Ticket #308: tt308-more-pf_items.patch

File tt308-more-pf_items.patch, 19.9 KB (added by rurban, 5 years ago)
  • include/parrot/packfile.h

    old new  
    3434/* Unsupported NaN difference, but patches welcome */ 
    3535#define FLOATTYPE_16MIPS      3 
    3636#define FLOATTYPE_16MIPS_NAME "MIPS 16 byte long double" 
     37/* See http://www.ncsa.uiuc.edu/UserInfo/Resources/Hardware/IBMp690/IBM/usr/share/man/info/en_US/a_doc_lib/aixprggd/genprogc/128bit_long_double_floating-point_datatype.htm */ 
     38#define FLOATTYPE_16AIX       4 
     39#define FLOATTYPE_16AIX_NAME "AIX 16 byte long double" 
    3740/* Not yet set into silicon AFAIK */ 
    38 #define FLOATTYPE_32          4 
     41#define FLOATTYPE_32          5 
    3942#define FLOATTYPE_32_NAME     "256-bit extended double" 
    4043 
    4144#define TRACE_PACKFILE 0 
  • src/packfile/pf_items.c

    old new  
    4646        __attribute__nonnull__(2) 
    4747        FUNC_MODIFIES(*dest); 
    4848 
    49 static void cvt_num12_num16_be( 
     49static void cvt_num12_num16_le( 
    5050    ARGOUT(unsigned char *dest), 
    5151    ARGIN(const unsigned char *src)) 
    5252        __attribute__nonnull__(1) 
     
    6060        __attribute__nonnull__(2) 
    6161        FUNC_MODIFIES(*dest); 
    6262 
    63 static void cvt_num12_num8_be( 
    64     ARGOUT(unsigned char *dest), 
    65     ARGIN(const unsigned char *src)) 
    66         __attribute__nonnull__(1) 
    67         __attribute__nonnull__(2) 
    68         FUNC_MODIFIES(*dest); 
    69  
    7063static void cvt_num12_num8_le( 
    7164    ARGOUT(unsigned char *dest), 
    7265    ARGIN(unsigned char *src)) 
     
    137130        __attribute__nonnull__(2) 
    138131        FUNC_MODIFIES(*dest); 
    139132 
     133static void cvt_num8_num16_le( 
     134    ARGOUT(unsigned char *dest), 
     135    ARGIN(const unsigned char *src)) 
     136        __attribute__nonnull__(1) 
     137        __attribute__nonnull__(2) 
     138        FUNC_MODIFIES(*dest); 
     139 
    140140PARROT_WARN_UNUSED_RESULT 
    141141static opcode_t fetch_op_be_4(ARGIN(const unsigned char *b)) 
    142142        __attribute__nonnull__(1); 
     
    168168#define ASSERT_ARGS_cvt_num12_num16 __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    169169       PARROT_ASSERT_ARG(dest) \ 
    170170    || PARROT_ASSERT_ARG(src) 
    171 #define ASSERT_ARGS_cvt_num12_num16_be __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
     171#define ASSERT_ARGS_cvt_num12_num16_le __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    172172       PARROT_ASSERT_ARG(dest) \ 
    173173    || PARROT_ASSERT_ARG(src) 
    174174#define ASSERT_ARGS_cvt_num12_num8 __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    175175       PARROT_ASSERT_ARG(dest) \ 
    176176    || PARROT_ASSERT_ARG(src) 
    177 #define ASSERT_ARGS_cvt_num12_num8_be __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    178        PARROT_ASSERT_ARG(dest) \ 
    179     || PARROT_ASSERT_ARG(src) 
    180177#define ASSERT_ARGS_cvt_num12_num8_le __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    181178       PARROT_ASSERT_ARG(dest) \ 
    182179    || PARROT_ASSERT_ARG(src) 
     
    207204#define ASSERT_ARGS_cvt_num8_num16_be __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    208205       PARROT_ASSERT_ARG(dest) \ 
    209206    || PARROT_ASSERT_ARG(src) 
     207#define ASSERT_ARGS_cvt_num8_num16_le __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
     208       PARROT_ASSERT_ARG(dest) \ 
     209    || PARROT_ASSERT_ARG(src) 
    210210#define ASSERT_ARGS_fetch_op_be_4 __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
    211211       PARROT_ASSERT_ARG(b) 
    212212#define ASSERT_ARGS_fetch_op_be_8 __attribute__unused__ int _ASSERT_ARGS_CHECK = \ 
     
    247247 
    248248=item C<static void cvt_num12_num8> 
    249249 
    250 Converts i386 LE 12-byte long double to IEEE 754 8 byte double. 
     250Converts i386 LE 12-byte long double to IEEE 754 8-byte double. 
    251251 
    252252=cut 
    253253 
     
    262262    int expo2; 
    263263#endif 
    264264 
     265    /* 
     266       12-byte double (96 bits): 
     267       sign  1  bit 95 
     268       exp  15 bits 94-80 
     269       man  80 bits 79-0 
     270    to 8-byte double (64 bits): 
     271       sign  1  bit 63 
     272       exp  11 bits 62-52 
     273       man  52 bits 51-0 
     274 
     275         +------+------+------+------+------+------+-...--+------+ 
     276         |byte 0|byte 1|byte 2|byte 3|byte 4|byte 5| ...  |byte12| 
     277         S|    E       |                F                        | 
     278         +------+------+------+------+------+------+-...--+------+ 
     279         1|<----15---->|<-------------80 bits------------------->| 
     280         <-----------------------96 bits-------------------------> 
     281              12-byte LONG DOUBLE FLOATING-POINT (i386 special) 
     282 
     283         +------+------+------+------+------+------+------+------+ 
     284         |byte 0|byte 1|byte 2|byte 3|byte 4|byte 5|byte 6|byte 7| 
     285         S|    E   |                    F                        | 
     286         +------+------+------+------+------+------+------+------+ 
     287         1|<--11-->|<-----------------52 bits------------------->| 
     288         <-----------------------64 bits-------------------------> 
     289                 8-byte DOUBLE FLOATING-POINT 
     290    */ 
    265291    memset(dest, 0, 8); 
    266292    /* exponents 15 -> 11 bits */ 
    267293    s = src[9] & 0x80; /* sign */ 
     
    309335Converts IEEE 754 LE 16-byte long double to i386 LE 12-byte long double . 
    310336 
    311337Not yet implemented (throws internal_exception). 
     338See http://babbage.cs.qc.cuny.edu/IEEE-754/References.xhtml 
    312339 
    313340=cut 
    314341 
    315342*/ 
    316343 
     344#if (NUMVAL_SIZE == 12) && !PARROT_BIGENDIAN 
    317345static void 
    318346cvt_num16_num12(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    319347{ 
    320348    ASSERT_ARGS(cvt_num16_num12) 
    321     exit_fatal(1, "TODO cvt_num16_num12\n"); 
    322 } 
    323349 
     350    /* 
     351       16-byte double (128 bits): 
     352       sign  1  bit 127 
     353       exp  15 bits 126-112 
     354       man 112 bits 111-0 
     355    to 12-byte double (96 bits): 
     356       sign  1  bit 95 
     357       exp  15 bits 94-80 
     358       man  80 bits 79-0 
     359 
     360         +------+------+------+------+------+------+-...--+------+ 
     361         |byte 0|byte 1|byte 2|byte 3|byte 4|byte 5| ...  |byte15| 
     362         S|    E       |                  F                      | 
     363         +------+------+------+------+------+------+-...--+------+ 
     364         1|<----15---->|<-------------112 bits------------------>| 
     365         <-----------------------128 bits------------------------> 
     366            16-byte LONG DOUBLE FLOATING-POINT (IA64 or BE 64-bit) 
     367 
     368         +------+------+------+------+------+------+-...--+------+ 
     369         |byte 0|byte 1|byte 2|byte 3|byte 4|byte 5| ...  |byte11| 
     370         S|    E       |                F                        | 
     371         +------+------+------+------+------+------+-...--+------+ 
     372         1|<----15---->|<-------------80 bits------------------->| 
     373         <-----------------------96 bits-------------------------> 
     374              12-byte LONG DOUBLE FLOATING-POINT (i386 special) 
     375 
     376    */ 
     377 
     378    memset(dest, 0, 12); 
     379    /* simply copy over sign + exp */ 
     380    TRACE_PRINTF_VAL(("  cvt_num16_num12: sign+exp=0x%2x\n", src[15])); 
     381    dest[11] = src[15]; 
     382    dest[12] = src[14]; 
     383    /* and trunc the rest */ 
     384    memcpy(dest[10], src[13], 10); 
     385    TRACE_PRINTF_VAL(("  cvt_num16_num12: mantissa=0x%10x, double=%lf\n", 
     386                      src[13], (long double)dest)); 
     387} 
     388#endif 
    324389 
    325390/* 
    326391 
     
    328393 
    329394Converts i386 LE 12-byte long double to IEEE 754 LE 16-byte long double. 
    330395 
    331 Not yet implemented (throws internal_exception). 
     396TODO: Inaccurate implementation 12->8->16. Need to follow cvt_num12_num8 
     397See http://babbage.cs.qc.cuny.edu/IEEE-754/References.xhtml 
    332398 
    333399=cut 
    334400 
     
    338404cvt_num12_num16(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    339405{ 
    340406    ASSERT_ARGS(cvt_num12_num16) 
    341     exit_fatal(1, "TODO cvt_num12_num16\n"); 
     407    unsigned char b[8]; 
     408    cvt_num12_num8(b, src); 
     409    cvt_num8_num16(dest, b); 
    342410} 
    343411 
    344412/* 
     
    357425cvt_num16_num8(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    358426{ 
    359427    ASSERT_ARGS(cvt_num16_num8) 
    360     long double d; 
    361     memcpy(&d, src, sizeof (unsigned char)); 
    362     *dest = (double)d; /* TODO: test */ 
     428 
     429#if NUMVAL_SIZE == 16 
     430 
     431    /* The compiler can do this for us */ 
     432    long double ld; 
     433    double d; 
     434    memcpy(&d, src, 8); 
     435    ld = (long double)d; /* TODO: test compiler cast */ 
     436    TRACE_PRINTF_VAL(("  cvt_num16_num8: ld=%lf, d=%f\n", ld, d)); 
     437    memcpy(dest, &ld, 16); 
     438 
     439#else 
     440 
     441    int expo, i, s; 
     442#  ifdef __LCC__ 
     443    int expo2; 
     444#  endif 
     445 
     446    /* TODO: Have only 12-byte long double, need to disect it */ 
     447    exit_fatal(1, "TODO cvt_num16_num8\n"); 
     448 
     449    /* 
     450       16-byte double (128 bits): 
     451       sign  1  bit 127 
     452       exp  15 bits 126-112 
     453       man 112 bits 111-0 
     454    to 8-byte double (64 bits): 
     455       sign  1  bit 63 
     456       exp  11 bits 62-52 
     457       man  52 bits 51-0 
     458 
     459         +------+------+------+------+------+------+-...--+------+ 
     460         |byte 0|byte 1|byte 2|byte 3|byte 4|byte 5| ...  |byte15| 
     461         S|    E       |                  F                      | 
     462         +------+------+------+------+------+------+-...--+------+ 
     463         1|<----15---->|<-------------112 bits------------------>| 
     464         <-----------------------128 bits------------------------> 
     465            16-byte LONG DOUBLE FLOATING-POINT (IA64 or BE 64-bit) 
     466 
     467         +------+------+------+------+------+------+------+------+ 
     468         |byte 0|byte 1|byte 2|byte 3|byte 4|byte 5|byte 6|byte 7| 
     469         S|    E   |                    F                        | 
     470         +------+------+------+------+------+------+------+------+ 
     471         1|<--11-->|<-----------------52 bits------------------->| 
     472         <-----------------------64 bits-------------------------> 
     473                 8-byte DOUBLE FLOATING-POINT 
     474   */ 
     475 
     476    memset(dest, 0, 16); 
     477    s = src[15] & 0x80; /* 10000000 */ 
     478    /* 15->8 exponents bits */ 
     479    expo = ((src[15] & 0x7f)<< 8 | src[14]); 
     480    if (expo == 0) { 
     481nul: 
     482        if (s) 
     483            dest[7] |= 0x80; 
     484        return; 
     485    } 
     486#  ifdef __LCC__ 
     487    /* LCC blows up mysteriously until a temporary variable is 
     488     * added. */ 
     489    expo2 = expo - 16383; 
     490    expo  = expo2; 
     491#  else 
     492    expo -= 16383;       /* - same bias as with 12-byte */ 
     493#  endif 
     494    expo += 1023;       /* + bias 8byte */ 
     495    if (expo <= 0)       /* underflow */ 
     496        goto nul; 
     497    if (expo > 0x7ff) {  /* inf/nan */ 
     498        dest[7] = 0x7f; 
     499        dest[6] = src[7] == 0xc0 ? 0xf8 : 0xf0 ; 
     500        goto nul; 
     501    } 
     502    expo <<= 4; 
     503    dest[6] = (expo & 0xff); 
     504    dest[7] = (expo & 0x7f00) >> 8; 
     505    if (s) 
     506        dest[7] |= 0x80; 
     507    /* long double frac 63 bits => 52 bits 
     508       src[7] &= 0x7f; reset integer bit */ 
     509    for (i = 0; i < 6; i++) { 
     510        dest[i+1] |= (i==5 ? src[7]&0x7f : src[i+2]) >> 3; 
     511        dest[i] |= (src[i+2] & 0x1f) << 5; 
     512    } 
     513    dest[0] |= src[1] >> 3; 
     514 
     515#endif 
    363516} 
    364517 
    365518/* 
     
    374527 
    375528*/ 
    376529 
     530#if NUMVAL_SIZE == 16 
    377531static void 
    378532cvt_num8_num16(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    379533{ 
    380534    ASSERT_ARGS(cvt_num8_num16) 
     535    /* The compiler can do this for us */ 
     536    long double ld; 
    381537    double d; 
    382     memcpy(&d, src, sizeof (unsigned char)); 
    383     *dest = (long double)d; /* TODO: test */ 
     538    memcpy(&d, src, 8); 
     539    ld = (long double)d; /* TODO: test compiler cast */ 
     540    TRACE_PRINTF_VAL(("  cvt_num8_num16: d=%f, ld=%lf\n", d, ld)); 
     541    memcpy(dest, &ld, 16); 
    384542} 
     543#endif 
    385544 
    386545/* 
    387546 
     
    395554 
    396555*/ 
    397556 
     557#if (NUMVAL_SIZE == 12) && !PARROT_BIGENDIAN 
    398558static void 
    399559cvt_num8_num12(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    400560{ 
    401561    ASSERT_ARGS(cvt_num8_num12) 
     562    long double ld; 
    402563    double d; 
    403     memcpy(&d, src, sizeof (unsigned char)); 
    404     *dest = (long double)d; /* TODO: test */ 
     564    memcpy(&d, src, 8); 
     565    ld = (long double)d; /* TODO: test compiler cast */ 
     566    TRACE_PRINTF_VAL(("  cvt_num8_num12: ld=%lf, d=%f\n", ld, d)); 
     567    memcpy(dest, &ld, 12); 
    405568} 
     569#endif 
     570 
    406571 
    407572/* 
    408573 
    409 =item C<static void cvt_num12_num8_be> 
     574=item C<static void cvt_num8_num12_be> 
    410575 
    411 Converts a 12-byte i386 long double into a big-endian IEEE 754 8-byte double. 
     576Converts a big-endian IEEE 754 8-byte double to i386 LE 12-byte long double. 
    412577 
    413578Untested. 
    414579 
     
    416581 
    417582*/ 
    418583 
     584#if (NUMVAL_SIZE == 12) && !PARROT_BIGENDIAN 
    419585static void 
    420 cvt_num12_num8_be(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
     586cvt_num8_num12_be(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    421587{ 
    422     ASSERT_ARGS(cvt_num12_num8_be) 
     588    ASSERT_ARGS(cvt_num8_num12_be) 
    423589    unsigned char b[8]; 
    424     cvt_num12_num8(b, src); 
    425     /* TODO test endianize */ 
    426     fetch_buf_le_8(dest, b); 
     590    fetch_buf_be_8(b, src);  /* TODO test endianize */ 
     591    TRACE_PRINTF_VAL(("  cvt_num8_num12_be: 0x%8x\n", b)); 
     592    cvt_num8_num12(dest, b); 
    427593} 
     594#endif 
    428595 
     596/* 
     597 
     598=item C<static void cvt_num8_num16_le> 
     599 
     600Converts a little-endian IEEE 754 8-byte double to big-endian 16-byte long double. 
     601 
     602Untested. 
     603 
     604=cut 
     605 
     606*/ 
     607 
     608#if (NUMVAL_SIZE == 16) && PARROT_BIGENDIAN 
     609static void 
     610cvt_num8_num16_le(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
     611{ 
     612    ASSERT_ARGS(cvt_num8_num16_le) 
     613    unsigned char b[8]; 
     614    fetch_buf_be_8(b, src);  /* TODO test endianize */ 
     615    TRACE_PRINTF_VAL(("  cvt_num8_num16_le: 0x%8x\n", b)); 
     616    cvt_num8_num16(dest, b); 
     617} 
     618#endif 
    429619 
    430620/* 
    431621 
    432 =item C<static void cvt_num8_num12_be> 
     622=item C<static void cvt_num12_num16_le> 
    433623 
    434 Converts a big-endian IEEE 754 8-byte double to i386 LE 12-byte long double. 
     624Converts a little-endian 12-byte double to big-endian 16-byte long double. 
    435625 
    436626Untested. 
    437627 
     
    439629 
    440630*/ 
    441631 
     632#if (NUMVAL_SIZE == 16) && PARROT_BIGENDIAN 
    442633static void 
    443 cvt_num8_num12_be(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
     634cvt_num12_num16_le(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    444635{ 
    445     ASSERT_ARGS(cvt_num8_num12_be) 
     636    ASSERT_ARGS(cvt_num12_num16_le) 
    446637    unsigned char b[12]; 
    447     cvt_num8_num12(b, src); 
    448     /* TODO test endianize */ 
    449     fetch_buf_le_8(dest, b); 
     638    fetch_buf_be_12(b, src);  /* TODO test endianize */ 
     639    TRACE_PRINTF_VAL(("  cvt_num12_num16_le: 0x%8x\n", b)); 
     640    cvt_num12_num16(dest, b); 
    450641} 
     642#endif 
    451643 
    452644/* 
    453645 
    454646=item C<static void cvt_num12_num8_le> 
    455647 
    456 Converts a 12-byte i386 long double into a little-endian IEEE 754 
    457 8-byte double. 
     648Converts a little-endian 12-byte i386 long double into a IEEE 754 8-byte double. 
    458649 
    459650Untested. 
    460651 
     
    462653 
    463654*/ 
    464655 
     656#if !PARROT_BIGENDIAN 
    465657static void 
    466658cvt_num12_num8_le(ARGOUT(unsigned char *dest), ARGIN(unsigned char *src)) 
    467659{ 
    468660    ASSERT_ARGS(cvt_num12_num8_le) 
    469     unsigned char b[8]; 
    470     cvt_num12_num8(b, src); 
    471     fetch_buf_le_8(dest, b); 
     661    unsigned char b[12]; 
     662    fetch_buf_le_12(b, src);  /* TODO test endianize */ 
     663    TRACE_PRINTF_VAL(("  cvt_num12_num8_le: 0x%12x\n", b)); 
     664    cvt_num12_num8(dest, b); 
    472665} 
     666#endif 
    473667 
    474668/* 
    475669 
    476670=item C<static void cvt_num16_num8_le> 
    477671 
    478 Converts a IEEE 754 16-byte long double into a little-endian IEEE 754 
    479 8-byte double. 
     672Converts a little-endian IEEE 754 intel 16-byte long double into a 
     673big-endian IEEE 754 8-byte double. 
    480674 
    481675Untested. 
    482676 
     
    484678 
    485679*/ 
    486680 
     681#if PARROT_BIGENDIAN 
    487682static void 
    488683cvt_num16_num8_le(ARGOUT(unsigned char *dest), ARGIN(unsigned char *src)) 
    489684{ 
    490685    ASSERT_ARGS(cvt_num16_num8_le) 
    491     unsigned char b[8]; 
    492     cvt_num16_num8(b, src); 
    493     fetch_buf_le_8(dest, b); 
     686    unsigned char b[16]; 
     687    fetch_buf_le_16(b, src); 
     688    TRACE_PRINTF_VAL(("  cvt_num16_num8_le: 0x%16x\n", b)); 
     689    cvt_num16_num8(dest, b); 
    494690} 
     691#endif 
    495692 
    496693/* 
    497694 
    498695=item C<static void cvt_num16_num8_be> 
    499696 
    500 Converts a IEEE 754 16-byte IA64 long double into a big-endian IEEE 754 8-byte double. 
     697Converts a big-endian IEEE 754 16-byte long double into a IEEE 754 8-byte double. 
    501698 
    502699Untested. 
    503700 
     
    505702 
    506703*/ 
    507704 
     705#if !PARROT_BIGENDIAN 
    508706static void 
    509707cvt_num16_num8_be(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    510708{ 
    511709    ASSERT_ARGS(cvt_num16_num8_be) 
    512     unsigned char b[8]; 
    513     cvt_num16_num8(b, src); 
    514     fetch_buf_be_8(dest, b); 
     710    unsigned char b[16]; 
     711    fetch_buf_be_16(b, src); 
     712    TRACE_PRINTF_VAL(("  cvt_num16_num8_be: 0x%16x\n", b)); 
     713    cvt_num16_num8(dest, b); 
    515714} 
     715#endif 
    516716 
    517717/* 
    518718 
    519719=item C<static void cvt_num16_num12_be> 
    520720 
    521 Converts a IEEE 754 16-byte BE long double into a 12-byte i386 long double. 
     721Converts a big-endian IEEE 754 16-byte long double into a 12-byte i386 long double. 
    522722 
    523723Untested. 
    524724 
     
    526726 
    527727*/ 
    528728 
     729#if (NUMVAL_SIZE == 12) && !PARROT_BIGENDIAN 
    529730static void 
    530731cvt_num16_num12_be(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    531732{ 
    532733    ASSERT_ARGS(cvt_num16_num12_be) 
    533     unsigned char b[12]; 
    534     cvt_num16_num12(b, src); 
    535     fetch_buf_be_12(dest, b); 
     734    unsigned char b[16]; 
     735    fetch_buf_be_16(b, src); 
     736    TRACE_PRINTF_VAL(("  cvt_num16_num12_be: 0x%16x\n", b)); 
     737    cvt_num16_num12(dest, b); 
    536738} 
     739#endif 
    537740 
    538741/* 
    539742 
    540743=item C<static void cvt_num8_num16_be> 
    541744 
    542 Converts IEEE 754 8-byte double to IEEE 754 BE 16 byte long double. 
     745Converts a big-endian IEEE 754 8-byte double to little-endian IEEE 754 16 byte 
     746long double. 
    543747 
    544748Untested. 
    545749 
     
    551755cvt_num8_num16_be(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    552756{ 
    553757    ASSERT_ARGS(cvt_num8_num16_be) 
    554     unsigned char b[16]; 
    555     cvt_num8_num16(b, src); 
    556     fetch_buf_be_16(dest, b); 
    557 } 
    558  
    559 static void 
    560 cvt_num12_num16_be(ARGOUT(unsigned char *dest), ARGIN(const unsigned char *src)) 
    561 { 
    562     ASSERT_ARGS(cvt_num12_num16_be) 
    563     unsigned char b[16]; 
    564     cvt_num12_num16(b, src); 
    565     fetch_buf_be_16(dest, b); 
     758    unsigned char b[8]; 
     759    fetch_buf_be_8(b, src); 
     760    cvt_num8_num16(dest, b); 
    566761} 
    567762 
    568763/* 
     
    13091504 
    13101505        switch (pf->header->floattype) { 
    13111506#  if NUMVAL_SIZE == 8 
    1312         case FLOATTYPE_8: 
     1507        case FLOATTYPE_8: /* native */ 
    13131508            break; 
    13141509        case FLOATTYPE_12: 
    13151510            pf->fetch_nv = cvt_num12_num8; 
     
    13251520        case FLOATTYPE_12: 
    13261521            pf->fetch_nv = cvt_num12_num16; 
    13271522            break; 
    1328         case FLOATTYPE_16: 
     1523        case FLOATTYPE_16: /* native */ 
    13291524            break; 
    13301525#  endif 
    13311526        default: 
     
    13541549            pf->fetch_nv = fetch_buf_be_8; 
    13551550            break; 
    13561551        case FLOATTYPE_12: 
    1357             pf->fetch_nv = cvt_num12_num8_be; 
     1552            exit_fatal(1, "PackFile_unpack: invalid floattype 1 big-endian"); 
    13581553            break; 
    13591554        case FLOATTYPE_16: 
    13601555            pf->fetch_nv = cvt_num16_num8_be; 
     
    13651560            pf->fetch_nv = cvt_num8_num12_be; 
    13661561            break; 
    13671562        case FLOATTYPE_12: 
    1368             pf->fetch_nv = fetch_buf_be_12; 
     1563            exit_fatal(1, "PackFile_unpack: invalid floattype 1 big-endian"); 
    13691564            break; 
    13701565        case FLOATTYPE_16: 
    13711566            pf->fetch_nv = cvt_num16_num12_be; 
     
    13761571            pf->fetch_nv = cvt_num8_num16_be; 
    13771572            break; 
    13781573        case FLOATTYPE_12: 
    1379             pf->fetch_nv = cvt_num12_num16_be; 
     1574            exit_fatal(1, "PackFile_unpack: invalid floattype 1 big-endian"); 
    13801575            break; 
    13811576        case FLOATTYPE_16: 
    13821577            pf->fetch_nv = fetch_buf_be_16; 
     
    13991594 
    14001595        switch (pf->header->floattype) { 
    14011596#  if NUMVAL_SIZE == 8 
    1402         case FLOATTYPE_8: 
     1597        case FLOATTYPE_8: /* native */ 
    14031598            break; 
    14041599        case FLOATTYPE_12: 
    14051600            pf->fetch_nv = cvt_num12_num8; 
     
    14121607        case FLOATTYPE_8: 
    14131608            pf->fetch_nv = cvt_num8_num12; 
    14141609            break; 
    1415         case FLOATTYPE_12: 
     1610        case FLOATTYPE_12: /* native */ 
    14161611            break; 
    14171612        case FLOATTYPE_16: 
    14181613            pf->fetch_nv = cvt_num16_num12; 
     
    14251620        case FLOATTYPE_12: 
    14261621            pf->fetch_nv = cvt_num12_num16; 
    14271622            break; 
    1428         case FLOATTYPE_16: 
     1623        case FLOATTYPE_16: /* native */ 
    14291624            break; 
    14301625#  endif 
    14311626          default: