Convert-Binary-C

 view release on metacpan or  search on metacpan

xsubs/arg.xs  view on Meta::CPAN

#              them later on.
#
################################################################################

void
CBC::arg(...)
  PREINIT:
    CBC_METHOD(arg);
    int i;

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_VOID_CONTEXT;

    for (i = 1; i < items; i++)
    {
      const char *argstr;
      STRLEN len;
      HookArgType type;
      SV *sv;

xsubs/cbc.xs  view on Meta::CPAN

#   WRITTEN BY: Marcus Holland-Moritz             ON: Jan 2002
#   CHANGED BY:                                   ON:
#
################################################################################

void
CBC::new(...)
  PREINIT:
    CBC_METHOD(new);

  PPCODE:
    CT_DEBUG_METHOD;

    if (items % 2 == 0)
      Perl_croak(aTHX_ "Number of configuration arguments "
                       "to %s must be even", method);
    else
    {
      int i;
      CBC *THIS = cbc_new(aTHX);

xsubs/clone.xs  view on Meta::CPAN

#
################################################################################

void
CBC::clone()
  PREINIT:
    CBC_METHOD(clone);
    CBC *clone;
    const char *class;

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_VOID_CONTEXT;

    class = HvNAME(SvSTASH(SvRV(ST(0))));
    clone = cbc_clone(aTHX_ THIS);

    ST(0) = sv_2mortal(cbc_bless(aTHX_ clone, class));

    XSRETURN(1);

xsubs/compound.xs  view on Meta::CPAN

    union_names  = 2

  PREINIT:
    CBC_METHOD_VAR;
    ListIterator li;
    Struct *pStruct;
    int count = 0;
    U32 context;
    u_32 mask;

  PPCODE:
    switch (ix)
    {
      case 1:  /* struct_names */
        CBC_METHOD_SET("struct_names");
        mask = T_STRUCT;
        break;
      case 2:  /* union_names */
        CBC_METHOD_SET("union_names");
        mask = T_UNION;
        break;

xsubs/compound.xs  view on Meta::CPAN

  ALIAS:
    struct = 1
    union  = 2

  PREINIT:
    CBC_METHOD_VAR;
    Struct *pStruct;
    U32 context;
    u_32 mask;

  PPCODE:
    switch(ix)
    {
      case 1:  /* struct */
        CBC_METHOD_SET("struct");
        mask = T_STRUCT;
        break;
      case 2:  /* union */
        CBC_METHOD_SET("union");
        mask = T_UNION;
        break;

xsubs/dependencies.xs  view on Meta::CPAN

################################################################################

void
CBC::dependencies()
  PREINIT:
    CBC_METHOD(dependencies);
    HashIterator hi;
    const char *pKey;
    FileInfo   *pFI;

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_PARSE_DATA;
    CHECK_VOID_CONTEXT;

    if (GIMME_V == G_SCALAR)
    {
      HV *hv = newHV();

      HT_foreach(pKey, pFI, hi, THIS->cpi.htFiles)

xsubs/enum.xs  view on Meta::CPAN

void
CBC::enum_names()
  PREINIT:
    CBC_METHOD(enum_names);
    ListIterator li;
    EnumSpecifier *pEnumSpec;
    int count = 0;
    U32 context;

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_PARSE_DATA;
    CHECK_VOID_CONTEXT;

    context = GIMME_V;

    LL_foreach(pEnumSpec, li, THIS->cpi.enums)
      if (pEnumSpec->identifier[0] && pEnumSpec->enumerators)
      {

xsubs/enum.xs  view on Meta::CPAN

#
################################################################################

void
CBC::enum(...)
  PREINIT:
    CBC_METHOD(enum);
    EnumSpecifier *pEnumSpec;
    U32 context;

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_PARSE_DATA;
    CHECK_VOID_CONTEXT;

    context = GIMME_V;

    if (context == G_SCALAR && items != 2)
      XSRETURN_IV(items > 1 ? items-1 : LL_count(THIS->cpi.enums));

xsubs/feature.xs  view on Meta::CPAN

#
################################################################################

void
feature(...)
  PREINIT:
    CBC_METHOD(feature);
    int method_call;
    const char *feat;

  PPCODE:
    method_call = items > 0 && sv_isobject(ST(0));

    if (items != (method_call ? 2 : 1))
      Perl_croak(aTHX_ "Usage: Convert::Binary::C::feature(feat)");

    CHECK_VOID_CONTEXT;

    feat = (const char *)SvPV_nolen(ST(items-1));

    switch (*feat)

xsubs/include.xs  view on Meta::CPAN

  ALIAS:
    Define = 1
    Assert = 2

  PREINIT:
    CBC_METHOD_VAR;
    LinkedList list;
    int hasRval;
    SV *rval, *inval;

  PPCODE:
    switch (ix)
    {
      case 1:  /* Define */
        CBC_METHOD_SET("Define");
        list = THIS->cfg.defines;
        break;
      case 2:  /* Assert */
        CBC_METHOD_SET("Assert");
        list = THIS->cfg.assertions;
        break;

xsubs/macro.xs  view on Meta::CPAN

#   WRITTEN BY: Marcus Holland-Moritz             ON: Feb 2006
#   CHANGED BY:                                   ON:
#
################################################################################

void
CBC::macro_names()
  PREINIT:
    CBC_METHOD(macro_names);

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_PARSE_DATA;
    CHECK_VOID_CONTEXT;

    if (GIMME_V == G_ARRAY)
    {
      LinkedList ll = macros_get_names(aTHX_ &THIS->cpi, NULL);
      int count = LL_count(ll);
      SV *sv;

xsubs/macro.xs  view on Meta::CPAN

#   WRITTEN BY: Marcus Holland-Moritz             ON: Feb 2006
#   CHANGED BY:                                   ON:
#
################################################################################

void
CBC::macro(...)
  PREINIT:
    CBC_METHOD(macro);

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_PARSE_DATA;
    CHECK_VOID_CONTEXT;

    if (GIMME_V == G_SCALAR && items != 2)
    {
      if (items > 1)
      {
        XSRETURN_IV(items-1);

xsubs/member.xs  view on Meta::CPAN

void
CBC::member(type, offset = NULL)
  const char *type
  SV *offset

  PREINIT:
    CBC_METHOD(member);
    MemberInfo mi;
    int have_offset, off;

  PPCODE:
    off = (have_offset = DEFINED(offset)) ? SvIV(offset) : 0;

    CT_DEBUG_METHOD2("'%s', %d", type, off);

    CHECK_PARSE_DATA;
    CHECK_VOID_CONTEXT;

    NEED_PARSE_DATA;

    if (!get_member_info(aTHX_ THIS, type, &mi, 0))

xsubs/pack.xs  view on Meta::CPAN

  const char *type
  SV *string

  PREINIT:
    CBC_METHOD(unpack);
    char *buf;
    STRLEN len;
    MemberInfo mi;
    unsigned long count;

  PPCODE:
    CT_DEBUG_METHOD1("'%s'", type);

    CHECK_VOID_CONTEXT;

    SvGETMAGIC(string);

    if ((SvFLAGS(string) & (SVf_POK|SVp_POK)) == 0)
      Perl_croak(aTHX_ "Type of arg 2 to unpack must be string");

    NEED_PARSE_DATA;

xsubs/typedef.xs  view on Meta::CPAN

void
CBC::typedef_names()
  PREINIT:
    CBC_METHOD(typedef_names);
    ListIterator tli, ti;
    TypedefList *pTDL;
    Typedef     *pTypedef;
    int          count = 0;
    U32          context;

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_PARSE_DATA;
    CHECK_VOID_CONTEXT;

    context = GIMME_V;

    LL_foreach(pTDL, tli, THIS->cpi.typedef_lists)
      LL_foreach(pTypedef, ti, pTDL->typedefs)
        if (is_typedef_defined(pTypedef))

xsubs/typedef.xs  view on Meta::CPAN

#
################################################################################

void
CBC::typedef(...)
  PREINIT:
    CBC_METHOD(typedef);
    Typedef *pTypedef;
    U32      context;

  PPCODE:
    CT_DEBUG_METHOD;

    CHECK_PARSE_DATA;
    CHECK_VOID_CONTEXT;

    context = GIMME_V;

    if (context == G_SCALAR && items != 2)
      XSRETURN_IV(items > 1 ? items-1 : HT_count(THIS->cpi.htTypedefs));