Convert-Binary-C

 view release on metacpan or  search on metacpan

TODO  view on Meta::CPAN

* update / cleanup test suite using Test::More

* make sizeof/offsetof files plain text files and
  parse them on the fly. get rid of 'do'

* make offsetof test similar to sizeof test (sizeof.pl)

* add tests for ccconfig (using a "virtual" compiler?)

* add more floating point tests (NaN and stuff?)

* support #pragma pack( (push|pop) [, id] [, pack] ) ?

* what about

    #define foobar 2
    #pragma pack( push, foobar )

* support gcc's __attribute__, at least for struct packing
  (actually, this is worse than it seems, because it behaves

ppport.h  view on Meta::CPAN

    s++; if (s == send || (*s != 'F' && *s != 'f')) return 0;
    s++; if (s < send && (*s == 'I' || *s == 'i')) {
      s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
      s++; if (s == send || (*s != 'I' && *s != 'i')) return 0;
      s++; if (s == send || (*s != 'T' && *s != 't')) return 0;
      s++; if (s == send || (*s != 'Y' && *s != 'y')) return 0;
      s++;
    }
    sawinf = 1;
  } else if (*s == 'N' || *s == 'n') {
    /* XXX TODO: There are signaling NaNs and quiet NaNs. */
    s++; if (s == send || (*s != 'A' && *s != 'a')) return 0;
    s++; if (s == send || (*s != 'N' && *s != 'n')) return 0;
    s++;
    sawnan = 1;
  } else
    return 0;

  if (sawinf) {
    numtype &= IS_NUMBER_NEG; /* Keep track of sign  */
    numtype |= IS_NUMBER_INFINITY | IS_NUMBER_NOT_INT;

tests/include/pdclib/include/stdio.h  view on Meta::CPAN

       "abcdef" for 'x' and uppercase "ABCDEF" for 'X' conversion, other
       behaviour being as above.
   f,F The argument from the argument stack is assumed to be of type double,
       and converted to a decimal floating point in decimal-point notation,
       with the number of digits after the decimal point as specified by the
       precision (default 6) and the value being rounded appropriately. If
       precision is zero (and the '#' flag is not given), no decimal point is
       printed. At least one digit is always printed before the decimal point.
       For 'f' conversions, an infinity value is printed as either [-]inf or
       [-]infinity (, depending on the configuration of this implementation. A
       NaN value is printed as [-]nan. For 'F' conversions uppercase characters
       are used for these special values. The flags '-', '+' and ' ' apply as
       usual to these special values, '#' and '0' have no effect.
   e,E The argument from the argument stack is assumed to be of type double,
       and converted to a decimal floating point in normalized exponential
       notation ([?]d.ddd edd). "Normalized" means one nonzero digit before
       the decimal point, unless the value is zero. The number of digits after
       the decimal point is specified by the precision (default 6), the value
       being rounded appropriately. If precision is zero (and the '#' flag is
       not given), no decimal point is printed. The exponent has at least two
       digits, and not more than necessary to represent the exponent. If the
       value is zero, the exponent is zero. The 'e' written to indicate the
       exponend is uppercase for 'E' conversions.
       Infinity or NaN values are represented as for 'f' and 'F' conversions,
       respectively.
   g,G The argument from the argument stack is assumed to be of type double,
       and converted according to either 'f' or 'e' format for 'g' conversions,
       or 'F' or 'E' format for 'G' conversions, respectively, with the actual
       conversion chosen depending on the value. 'e' / 'E' conversion is chosen
       if the resulting exponent is < -4 or >= the precision (default 1).
       Trailing zeroes are removed (unless the '#' flag is given). A decimal
       point appears only if followed by a digit.
       Infinity or NaN values are represented as for 'f' and 'F' conversions,
       respectively.
   a,A The argument from the argument stack is assumed to be of type double,
       and converted to a floating point hexadecimal notation ([?]0xh.hhhh pd)
       with one hexadecimal digit (being nonzero if the value is normalized,
       and otherwise unspecified) before the decimal point, and the number of
       digits after the decimal point being specified by the precision. If no
       precision is given, the default is to print as many digits as nevessary
       to give an exact representation of the value (if FLT_RADIX is a power of
       2). If no precision is given and FLT_RADIX is not a power of 2, the
       default is to print as many digits to distinguish values of type double

tests/include/pdclib/include/stdio.h  view on Meta::CPAN

       implementation's scheme for determining the digit to the left of the
       decimal point.) The error has the correct sign for the current rounding
       direction.
       Unless the '#' flag is given, no decimal-point is given for zero
       precision.
       The 'a' conversion uses lowercase "abcdef", "0x" and 'p', the 'A'
       conversion uppercase "ABCDEF", "0X" and 'P'.
       The exponent always has at least one digit, and not more than necessary
       to represent the decimal exponent of 2. If the value is zero, the
       exponent is zero.
       Infinity or NaN values are represented as for 'f' and 'F' conversions,
       respectively.
       Binary implementations are at liberty to chose the hexadecimal digit to
       the left of the decimal point so that subsequent digits align to nibble
       boundaries.
   c   The argument from the argument stack is assumed to be of type int, and
       converted to a character after the value has been cast to unsigned char.
       If the 'l' length modifier is given, the argument is assumed to be of
       type wint_t, and converted as by a "%ls" conversion with no precision
       and a pointer to a two-element wchar_t array, with the first element
       being the wint_t argument and the second a '\0' wide character.