static Token *cmt(int ch) { Token *t = &tok; clear_lexeme(); switch (ch) { case '/': while (true) { ch = nextch(); if (ch == '\n' || ch == '\r') break; outch(ch); } break; case '*': while (true) { ch = nextch(); if (ch == '/' && prevch() == '*') { delete_prev(); break;} /* erase '*' */ outch(ch); } break; default: break; } t->sym = CMT; outch(0); return t; }
void record_struct::parse(proto_info &info, cursor &c) { pimpl->name = get_to_sep(c, ' ', struct_base_classes_separator, struct_body_open_char); skipws(c); // process list of base structs if ( curch(c) == struct_base_classes_separator ) { nextch(c); skipws(c); cursor tc = c; std::string base; bool flag = false; while ( ! flag ) { char ch = nextch(c); switch ( ch ) { case '/': { prevch(c); skipws(c); continue; } case ' ': case ',': { if ( ch == ',' && base.empty() ) YARMI_THROW( "bad char '%c', expected name of base struct in %s" ,ch ,c.format() ); if ( !struct_already_declared(info, base) ) YARMI_THROW( "base struct '%s'(%s) is not declared" ,base ,tc.format() ); pimpl->base.push_back(base); base.clear(); skipws(c); if ( curch(c) == ',' ) { nextch(c); skipws(c); } tc = c; continue; } case struct_body_open_char: { flag = true; prevch(c); break; } default: { base.push_back(ch); } } } } check_next(c, struct_body_open_char); skipws(c); for ( ;; ) { const iterator it = c.it; const std::string kword = get_to_sep(c, ' '); const bool is_type = is_type_name(kword); c.it = (is_type ? it : c.it); record_ptr o = record_factory((is_type ? "var" : kword)); if ( !o ) YARMI_THROW( "bad keyword \"%s\" in %s" ,kword ,c.format() ); o->parse(info, c); pimpl->members.push_back(std::move(o)); skipws(c); const char ch = curch(c); if ( ch == struct_body_close_char ) break; } check_next(c, struct_body_close_char); check_next(c, struct_body_close_dotcomma_char); }
int main(int argc, char *argv[]) { /* Command-line interface for CRC RevEng. * Process options and switches in the argument list and * run the required function. */ /* default values */ model_t model = { PZERO, /* no CRC polynomial, user must specify */ PZERO, /* Init = 0 */ P_BE, /* RefIn = false, RefOut = false, plus P_RTJUST setting in reveng.h */ PZERO, /* XorOut = 0 */ PZERO, /* check value unused */ NULL /* no model name */ }; int ibperhx = 8, obperhx = 8; int rflags = 0, uflags = 0; /* search and UI flags */ unsigned long width = 0UL; int c, mode = 0, args, psets, pass; poly_t apoly, crc, qpoly = PZERO, *apolys, *pptr = NULL, *qptr = NULL; model_t pset = model, *candmods, *mptr; char *string; myname = argv[0]; /* stdin must be binary */ #ifdef _WIN32 _setmode(STDIN_FILENO, _O_BINARY); #endif /* _WIN32 */ SETBMP(); do { c=getopt(argc, argv, "?A:BDFLMP:SVXa:bcdefhi:k:lm:p:q:rstuvw:x:y"); switch(c) { case 'A': /* A: bits per output character */ case 'a': /* a: bits per character */ if((obperhx = atoi(optarg)) > BMP_BIT) { fprintf(stderr,"%s: argument to -%c must be between 1 and %d\n", myname, c, BMP_BIT); exit(EXIT_FAILURE); } if(c == 'a') ibperhx = obperhx; break; case 'b': /* b big-endian (RefIn = false, RefOut = false ) */ model.flags &= ~P_REFIN; rflags |= R_HAVERI; /* fall through: */ case 'B': /* B big-endian output (RefOut = false) */ model.flags &= ~P_REFOUT; rflags |= R_HAVERO; mnovel(&model); /* fall through: */ case 'r': /* r right-justified */ model.flags |= P_RTJUST; break; case 'c': /* c calculate CRC */ case 'D': /* D list primary model names */ case 'd': /* d dump CRC model */ case 'e': /* e echo arguments */ case 's': /* s search for algorithm */ case 'v': /* v calculate reversed CRC */ if(mode) { fprintf(stderr,"%s: more than one mode switch specified. Use %s -h for help.\n", myname, myname); exit(EXIT_FAILURE); } mode = c; break; case 'F': /* F force search */ #ifndef NOFORCE uflags |= C_FORCE; #endif break; case 'f': /* f arguments are filenames */ uflags |= C_INFILE; break; case 'h': /* h get help / usage */ case 'u': /* u get help / usage */ case '?': /* ? get help / usage */ default: usage(); exit(EXIT_FAILURE); break; case 'i': /* i: Init value */ pptr = &model.init; rflags |= R_HAVEI; goto ippx; case 'k': /* k: polynomial in Koopman notation */ pfree(&model.spoly); model.spoly = strtop(optarg, 0, 4); pkchop(&model.spoly); width = plen(model.spoly); rflags |= R_HAVEP; mnovel(&model); break; case 'l': /* l little-endian input and output */ model.flags |= P_REFIN; rflags |= R_HAVERI; /* fall through: */ case 'L': /* L little-endian output */ model.flags |= P_REFOUT; rflags |= R_HAVERO; mnovel(&model); /* fall through: */ case 't': /* t left-justified */ model.flags &= ~P_RTJUST; break; case 'm': /* m: select preset CRC model */ if(!(c = mbynam(&model, optarg))) { fprintf(stderr,"%s: preset model '%s' not found. Use %s -D to list presets.\n", myname, optarg, myname); exit(EXIT_FAILURE); } if(c < 0) uerror("no preset models available"); /* must set width so that parameter to -ipx is not zeroed */ width = plen(model.spoly); rflags |= R_HAVEP | R_HAVEI | R_HAVERI | R_HAVERO | R_HAVEX; break; case 'M': /* M non-augmenting algorithm */ model.flags &= ~P_MULXN; break; case 'P': /* P: reversed polynomial */ case 'p': /* p: polynomial */ pptr = &model.spoly; rflags &= ~R_HAVEQ; rflags |= R_HAVEP; ippx: pfree(pptr); *pptr = strtop(optarg, 0, 4); pright(pptr, width); if(c == 'P') prev(pptr); mnovel(&model); break; case 'q': /* q: range end polynomial */ pptr = &qpoly; rflags &= ~R_HAVEP; rflags |= R_HAVEQ; goto ippx; case 'S': /* s space between output characters */ model.flags |= P_SPACE; break; case 'V': /* v reverse algorithm */ /* Distinct from the -v switch as the * user will have to reverse his or her * own arguments. The user cannot dump * the model generated by -v either. */ mrev(&model); break; case 'w': /* w: CRC width = order - 1 */ width = (unsigned long) atol(optarg); break; case 'X': /* X print uppercase hex */ model.flags |= P_UPPER; break; case 'x': /* x: XorOut value */ pptr = &model.xorout; rflags |= R_HAVEX; goto ippx; case 'y': /* y little-endian byte order in files */ model.flags |= P_LTLBYT; break; case -1: /* no more options, continue */ ; } } while(c != -1); /* canonicalise the model, so the one we dump is the one we * calculate with (not with -s, spoly may be blank which will * normalise to zero and clear init and xorout.) */ if(mode != 's') mcanon(&model); switch(mode) { case 'v': /* v calculate reversed CRC */ /* Distinct from the -V switch as this causes * the arguments and output to be reversed as well. */ /* reciprocate Poly */ prcp(&model.spoly); /* mrev() does: * if(refout) prev(init); else prev(xorout); * but here the entire argument polynomial is * reflected, not just the characters, so RefIn * and RefOut are not inverted as with -V. * Consequently Init is the mirror image of the * one resulting from -V, and so we have: */ if(~model.flags & P_REFOUT) { prev(&model.init); prev(&model.xorout); } /* swap init and xorout */ apoly = model.init; model.init = model.xorout; model.xorout = apoly; /* fall through: */ case 'c': /* c calculate CRC */ /* validate inputs */ /* if(plen(model.spoly) == 0) { * fprintf(stderr,"%s: no polynomial specified for -%c (add -w WIDTH -p POLY)\n", myname, mode); * exit(EXIT_FAILURE); * } */ /* in the Williams model, xorout is applied after the refout stage. * as refout is part of ptostr(), we reverse xorout here. */ if(model.flags & P_REFOUT) prev(&model.xorout); for(; optind < argc; ++optind) { if(uflags & C_INFILE) apoly = rdpoly(argv[optind], model.flags, ibperhx); else apoly = strtop(argv[optind], model.flags, ibperhx); if(mode == 'v') prev(&apoly); crc = pcrc(apoly, model.spoly, model.init, model.xorout, model.flags); if(mode == 'v') prev(&crc); string = ptostr(crc, model.flags, obperhx); puts(string); free(string); pfree(&crc); pfree(&apoly); } break; case 'D': /* D dump all models */ args = mcount(); if(!args) uerror("no preset models available"); for(mode = 0; mode < args; ++mode) { mbynum(&model, mode); mcanon(&model); ufound(&model); } break; case 'd': /* d dump CRC model */ /* maybe we don't want to do this: * either attaching names to arbitrary models or forcing to a preset * mmatch(&model, M_OVERWR); */ if(~model.flags & P_MULXN) uerror("not a Williams model compliant algorithm"); string = mtostr(&model); puts(string); free(string); break; case 'e': /* e echo arguments */ for(; optind < argc; ++optind) { if(uflags & C_INFILE) apoly = rdpoly(argv[optind], model.flags, ibperhx); else apoly = strtop(argv[optind], model.flags, ibperhx); psum(&apoly, model.init, 0UL); string = ptostr(apoly, model.flags, obperhx); puts(string); free(string); pfree(&apoly); } break; case 's': /* s search for algorithm */ if(!width) uerror("must specify positive -k or -w before -s"); if(~model.flags & P_MULXN) uerror("cannot search for non-Williams compliant models"); praloc(&model.spoly, width); praloc(&model.init, width); praloc(&model.xorout, width); if(!plen(model.spoly)) palloc(&model.spoly, width); else width = plen(model.spoly); /* special case if qpoly is zero, search to end of range */ if(!ptst(qpoly)) rflags &= ~R_HAVEQ; /* allocate argument array */ args = argc - optind; if(!(apolys = malloc(args * sizeof(poly_t)))) uerror("cannot allocate memory for argument list"); for(pptr = apolys; optind < argc; ++optind) { if(uflags & C_INFILE) *pptr++ = rdpoly(argv[optind], model.flags, ibperhx); else *pptr++ = strtop(argv[optind], model.flags, ibperhx); } /* exit value of pptr is used hereafter! */ /* if endianness not specified, try * little-endian then big-endian. * NB: crossed-endian algorithms will not be * searched. */ /* scan against preset models */ if(~uflags & C_FORCE) { pass = 0; do { psets = mcount(); while(psets) { mbynum(&pset, --psets); /* skip if different width, or refin or refout don't match */ if(plen(pset.spoly) != width || (model.flags ^ pset.flags) & (P_REFIN | P_REFOUT)) continue; /* skip if the preset doesn't match specified parameters */ if(rflags & R_HAVEP && pcmp(&model.spoly, &pset.spoly)) continue; if(rflags & R_HAVEI && psncmp(&model.init, &pset.init)) continue; if(rflags & R_HAVEX && psncmp(&model.xorout, &pset.xorout)) continue; apoly = pclone(pset.xorout); if(pset.flags & P_REFOUT) prev(&apoly); for(qptr = apolys; qptr < pptr; ++qptr) { crc = pcrc(*qptr, pset.spoly, pset.init, apoly, 0); if(ptst(crc)) { pfree(&crc); break; } else pfree(&crc); } pfree(&apoly); if(qptr == pptr) { /* the selected model solved all arguments */ mcanon(&pset); ufound(&pset); uflags |= C_RESULT; } } mfree(&pset); /* toggle refIn/refOut and reflect arguments */ if(~rflags & R_HAVERI) { model.flags ^= P_REFIN | P_REFOUT; for(qptr = apolys; qptr < pptr; ++qptr) prevch(qptr, ibperhx); } } while(~rflags & R_HAVERI && ++pass < 2); } if(uflags & C_RESULT) { for(qptr = apolys; qptr < pptr; ++qptr) pfree(qptr); exit(EXIT_SUCCESS); } if(!(model.flags & P_REFIN) != !(model.flags & P_REFOUT)) uerror("cannot search for crossed-endian models"); pass = 0; do { mptr = candmods = reveng(&model, qpoly, rflags, args, apolys); if(mptr && plen(mptr->spoly)) uflags |= C_RESULT; while(mptr && plen(mptr->spoly)) { /* results were printed by the callback * string = mtostr(mptr); * puts(string); * free(string); */ mfree(mptr++); } free(candmods); if(~rflags & R_HAVERI) { model.flags ^= P_REFIN | P_REFOUT; for(qptr = apolys; qptr < pptr; ++qptr) prevch(qptr, ibperhx); } } while(~rflags & R_HAVERI && ++pass < 2); for(qptr = apolys; qptr < pptr; ++qptr) pfree(qptr); free(apolys); if(~uflags & C_RESULT) uerror("no models found"); break; default: /* no mode specified */ fprintf(stderr, "%s: no mode switch specified. Use %s -h for help.\n", myname, myname); exit(EXIT_FAILURE); } exit(EXIT_SUCCESS); }