Add files via upload #32

duncanmac99 · 2018-11-08T17:10:07Z

Proposed fixes for Issue #5 (checking results of '*alloc' fcns) as well as a number of other fixes. Also included: a list of proposed changes affecting command line args [attached to 'usage()'].

logological · 2019-06-11T08:39:13Z

@duncanmac99, the diff is showing changes to every line of gpp.c. Could this be because you changed the line-ending characters in the file? Could you submit a patch such that I can see only the parts you've changed?

duncanmac99 · 2019-06-21T00:46:51Z

This Diff shows what I understood to have changed. I hope this clarifies the situation.

/media/duncan/PRODR_DAM_B/General/Music/Temp/gpp_c.diff

duncanmac99 · 2019-06-21T00:47:58Z

22d21
< /* To compile under MS VC++, one must define WIN_NT */
26a26

/* To compile under MS VC++, one must define WIN_NT /
34c34,38
< #else / UNIX settings */

#ifndef DFT_SYS_INCL_DIR
#define DFT_SYS_INCL_DIR "C:\usr\include" /* a pro-tem definition /
#endif
#else / UNIX & Linux settings */
36a41,44

#ifndef DFT_SYS_INCL_DIR
#define DFT_SYS_INCL_DIR "/usr/include"
#endif
42a51

48,50c57,66
< #define STACKDEPTH 50
< #define MAXARGS 100
< #define MAXINCL 128 /* max # of include dirs */

/* recursion depth for macros */
#define STACKDEPTH 50
#define MAXARGS 100
#define INIT_EXP_NUM_MACROS 31
#define INIT_LINESIZE 80

/* max # of include dirs */
#ifndef MAX_INCL_DIRS
#define MAX_INCL_DIRS 128
#endif
52,53c68,69
< #define MAX_GPP_NUM_SIZE 15
< #define MAX_GPP_DATE_SIZE 1024

#define MAX_GPP_NUM_SIZE 15
#define MAX_GPP_DATE_SIZE 1024
55c71
< typedef struct MODE {

typedef struct MODE_ {
80,87c96,103
< /* st end args sep arge ref quot stk unstk*/
< struct MODE CUser = {"", "", "(", ",", ")", "#", '\', "(", ")" };
< struct MODE CMeta = {"#", "\n", "\001","\001","\n","#", '\', "(", ")" };
< struct MODE KUser = {"", "", "(", ",", ")", "#", 0, "(", ")" };
< struct MODE KMeta = {"\n#\002","\n", "\001","\001","\n","#", 0, "", "" };
< struct MODE Tex = {"\", "", "{", "}{", "}", "#", '@', "{", "}" };
< struct MODE Html = {"<#", ">", "\003","|", ">", "#", '\', "<", ">" };
< struct MODE XHtml = {"<#", "/>", "\003","|", "/>","#", '\', "<", ">" };

/* st end args sep arge ref quot stk unstk*/
MODE CUser = {"", "", "(", ",", ")", "#", '\', "(", ")" };
MODE CMeta = {"#", "\n", "\001","\001","\n","#", '\', "(", ")" };
MODE KUser = {"", "", "(", ",", ")", "#", 0, "(", ")" };
MODE KMeta = {"\n#\002","\n", "\001","\001","\n","#", 0, "", "" };
MODE Tex = {"\", "", "{", "}{", "}", "#", '@', "{", "}" };
MODE Html = {"<#", ">", "\003","|", ">", "#", '\', "<", ">" };
MODE XHtml = {"<#", "/>", "\003","|", "/>","#", '\', "<", ">" };
101c117
< typedef struct COMMENT {

typedef struct COMMENT_ {
107c123
< struct COMMENT *next;

struct COMMENT_ *next;

149,152c165,168
< typedef struct SPECS {
< struct MODE User, Meta;
< struct COMMENT comments;
< struct SPECS stack_next;

typedef struct SPECS_ {
MODE User, Meta;
COMMENT *comments;
struct SPECS_ *stack_next;
157c173
< struct SPECS *S;

SPECS *S;
159c175
< typedef struct MACRO {

typedef struct MACRO_DESC_ {
162c178
< struct SPECS *define_specs;

SPECS *define_specs;

166c182
< struct MACRO *macros;

MACRO *macros;
168c184
< char *includedir[MAXINCL];

char *includedir[MAX_INCL_DIRS];
172a189

182a200

/* if the file is delimited with "<>", the current directory ^should^ be last */
189c207
< typedef struct OUTPUTCONTEXT {

typedef struct OUTPUTCONTEXT_ {
195c213
< typedef struct INPUTCONTEXT {

typedef struct INPUTCONTEXT_ {
205c223
< struct OUTPUTCONTEXT *out;

OUTPUTCONTEXT *out;

212c230
< struct INPUTCONTEXT *C;

INPUTCONTEXT *C;
244c262,264
< ** versions in case the compiler does not support them

** versions in case the compiler does not support them.
** No checking is done on the malloc call here, as this code won't be used
** if the local library has a copy.
247a268

251c272
< return newstr ? (char *) memcpy(newstr, s, len) : NULL ;

return (newstr!=NULL) ? (char *) memcpy(newstr, s, len) : NULL ;

256a278

273a296,297

/* this only works if the global 'C' (an INPUTCONTEXT object) is defined /
/ it should be defined by the time text processing starts, fortunately */
283,285c307,309
< struct SPECS *CloneSpecs(const struct SPECS *Q) {
< struct SPECS *P;
< struct COMMENT *x, *y;

SPECS *CloneSpecs(const SPECS *Q) {
SPECS *P;
COMMENT *x, *y;
289,290c313,315
< bug("Out of memory.");
< memcpy(P, Q, sizeof(struct SPECS));

    bug("Out of memory for copying specs");

memcpy(P, Q, sizeof(SPECS));

292c317
< if (Q->comments != NULL )

if (Q->comments != NULL ) {

293a319,322

    if (P->comments == NULL)
        bug("Out of memory for copying first attached comment-strings block");
}

296c325,326
< memcpy(y, x, sizeof(struct COMMENT));

    memcpy(y, x, sizeof(COMMENT));

299c329,332
< if (x->next != NULL )

    if ((y->start==NULL) || (y->end==NULL))
        bug("Out of memory for copying attached individual comment-string");

    if (x->next != NULL ) {

300a334,336

        if (y->next == NULL)
            bug("Out of memory for copying next attached comment-strings block");
    }

305,306c341,342
< void FreeComments(struct SPECS Q) {
< struct COMMENT p;

void FreeComments(SPECS *Q) {
COMMENT *p;
317,318c353,354
< void PushSpecs(const struct SPECS *X) {
< struct SPECS *P;

void PushSpecs(const SPECS *X) {
SPECS *P;
326c362
< struct SPECS *P;

SPECS *P;

344a381,397

/* future proposed changes to command-line args: /
/ change '-x' to '+xx' (to enable "#exec") /
/ add '-xm' (to turn off "#mode", which would remain ON by default) /
/ [because "#mode" can enable major changes in syntax, it is desirable to add the ability to turn it off] /
/ add '-xxs' and '-xms' (to turn off "#exec" and "#mode" only in standard/system #include-d files) /
/ add '-aiCHARS (for input format; to hint at what text format the files in following directory/ies contain) /
/ [where CHARS is one of: 'U8' [UTF-8], 'U16' [UTF-16], 'U16L', 'U16B', or 'CPnnnn' (a Windows "code page")] /
/ (we can't use "iconv(1)" on #include-d files; what happens if an UTF-16 file #include-s a 'CP1252' one?) /
/ (use of "iconv(3)" also won't work, if we don't use 'glibc'; separately licenced one under incompatible licence) /
/ add '-aoCHARS' (for output format; list of allowable CHARS here should be Much Shorter) /
/ add '--allowlonesurr' (to allow cases where surrogate values appear alone, which breaks Unicode rules) /
/ add '--sysincdir' (to specify a "system" directory for finding standard includes) /
/ add '--rootprefix' (to supply a prefix-ed PATH to add to '-I=' arguments [for #28]) /
/ add '+Ksym' and '-Ksym' (see #29 for details; should also fix #27 first) /
/ add '--listheaders' (corr to "cpp" '-H' option, list all #include-d header files) /
/ add '--makegener' (generate list in Make format, see #24, corr to "cpp" '-M') /
/ add '--makeoutput' and '--maketarget' (corr to "cpp" '-MF' and '-MT') */
377c430
< if (c >= 128)

if (c >= 128) /* needs to be re-considered if UTF-8 (multi-byte) chars involved */

405c458
< bug("Out of memory");

        bug("Out of memory for new macro(s)");

407c460,461
< macros[nmacros].username = malloc(len + 1);

if ( (macros[nmacros].username = malloc(len + 1)) == NULL)
    bug("Out of memory for new macro(s)");

409c463
< macros[nmacros].username[len] = 0;

macros[nmacros].username[len] = '\0';

442c496,498
< t = malloc(strlen(s) + 1);

if ( (t = malloc(strlen(s) + 1)) == NULL)
    bug("Out of memory");

443a500

461,462c518
< t = malloc(strlen(s) + 1);
< u = t;

464a521,524

if ( (t = malloc(strlen(s) + 1)) == NULL)
    bug("Out of memory");
u = t;

483c543
< bug("\w and \W cannot be negated");

                bug("\\w and \\W cannot be negated"); /* should this be a "warning"? */

491c551
< bug("\w and \W cannot be negated");

                bug("\\w and \\W cannot be negated"); /* should this be a "warning"? */

555c615
< bug("\w and \W cannot be negated");

                bug("\\w and \\W cannot be negated"); /* should this be a "warning"? */

563c623
< bug("\w and \W cannot be negated");

                bug("\\w and \\W cannot be negated"); /* should this be a "warning"? */

601c661
< bug("unterminated string in #mode command");

        bug("non-terminated string in #mode command");

633a694,696

/* since the INPUTCONTEXT may be undefined when parsing the command line, avoid 'bug()' /
/ instead, use this */
#define OPT_BUG(s) { fprintf(stderr, "gpp: Error during Command-line parse: %s\n", (s)); exit(EXIT_FAILURE); }
636a700

651a716

653c718
< bug("invalid syntax in -D declaration");

            OPT_BUG("invalid syntax in -D declaration");

657a723,725

        if (macros[nmacros].argnames == NULL)
            OPT_BUG("out of memory for args of current macro");

659c727,728
< macros[nmacros].argnames[argc - 1] = malloc(i - l + 1);

            if ( (macros[nmacros].argnames[argc - 1] = malloc(i - l + 1)) == NULL)
                OPT_BUG("out of memory for arg(s) of current macro");

674c743,744
< bug("invalid syntax in -D declaration");

    OPT_BUG("invalid syntax in -D declaration");

676c746,749
< macros[nmacros++].macrotext = my_strdup(s + l);

macros[nmacros].macrotext = my_strdup(s + l);
if (macros[nmacros].macrotext == NULL)
    OPT_BUG("out of memory for text of current macro");
nmacros++;

679c752
< int readModeDescription(char **args, struct MODE *mode, int ismeta) {

int readModeDescription(char **args, MODE *mode, int ismeta) {
730,731c803
< bug("Invalid comment/string modifier");
< return 0;

    bug("invalid comment or string modifier"); /* should this be a warning? */

735c807
< void add_comment(struct SPECS S, const char specif, char start, char end,

void add_comment(SPECS *S, const char *specif, char *start, char *end,
737c809
< struct COMMENT *p;

COMMENT *p;

738a811,812

if ( (start==NULL) || (end==NULL) || (specif==NULL) )
    bug("No string passed for start, end or specifier string (perhaps a copy failed)");

740,741c814,817
< bug("Comment/string start delimiter must be non-empty");
< for (p = S->comments; p != NULL ; p = p->next)

    bug("Comment or string start delimiter must be non-empty");
if (strlen(specif) != 3)
    bug("Invalid comment or string modifier");
for (p = S->comments; p != NULL ; p = p->next) {

744c820,821
< bug("Conflicting comment/string delimiter specifications");

            bug("Conflicting (comment or string) delimiter specifications");
        /* found a match */

748a826

750,751c828,831
< if (p == NULL ) {
< p = malloc(sizeof *p);

/* No match for this comment or string?  Create a new one */
if (p == NULL) {
    if ( (p=malloc(sizeof *p)) == NULL)
        bug("Out of memory for new comment or string");

759,760d838
< if (strlen(specif) != 3)
< bug("Invalid comment/string modifier");
766,767c844,845
< void delete_comment(struct SPECS S, char start) {
< struct COMMENT p, q;

void delete_comment(SPECS *S, char *start) {
COMMENT *p, *q;
768a847,848
if (start == NULL)
bug("Out of memory for start string");
769a850

772c853
< if (q == NULL )

        if (q == NULL)

789,792c870,872
< if (C->out->len + 1 == C->out->bufsize) {
< C->out->bufsize = C->out->bufsize * 2;
< C->out->buf = realloc(C->out->buf, C->out->bufsize);
< if (C->out->buf == NULL )

    if (C->out->len + 1 >= C->out->bufsize) {
        C->out->bufsize = (C->out->bufsize * 2) + 1;
        if ( (C->out->buf = realloc(C->out->buf, C->out->bufsize)) == NULL)

829a910

832a914,916

    if (p == NULL)
        bug("Out of memory extending main buffer");

836,837d919
< if (C->buf == NULL )
< bug("Out of memory");
1073c1155,1156
< x = malloc(CHARSET_SUBSET_LEN * sizeof(unsigned long));

if ( (x = malloc(CHARSET_SUBSET_LEN * sizeof(unsigned long))) == NULL)
    bug("Out of memory for char-set check");

1079,1080c1162,1163
< bug(
< "negated special sequences not allowed in charset specifications");

            bug("negated special sequences not allowed in charset specifications");

1193c1276
< nalloced = 31;

nalloced = INIT_EXP_NUM_MACROS;

1194a1278,1279

if (macros == NULL)
    OPT_BUG("Out of memory for first macros");

1196a1282,1284

if (S == NULL)
    OPT_BUG("Out of memory for first macro-specs");

1206a1295,1297

if (C == NULL)
    OPT_BUG("Out of memory for input context");

1210,1211c1301,1305
< C->filename = my_strdup("stdin");
< C->out = malloc(sizeof *(C->out));

if ( (C->filename = my_strdup("stdin")) == NULL)
    OPT_BUG("Out of memory for input filename ref");

if ( (C->out = malloc(sizeof *(C->out))) == NULL)
    OPT_BUG("Out of memory for output context");

1214c1308
< C->lineno = 1;

C->lineno = 1; /* should really be zero, at the beginning */

1217c1311
< C->bufsize = 80;

C->bufsize = INIT_LINESIZE;

1218a1313

1219a1315,1317

if (C->buf == NULL)
    OPT_BUG("Out of memory for main input text buffer");

1230a1329,1330

#define OPT_SYNTAX_ERR { fprintf(stderr, "gpp: Command-line syntax error\n\n"); usage(); exit(EXIT_FAILURE); }
#define DEPRECATED_WARNING fprintf(stderr, "gpp: warning: deprecated option %s'; use -%s' instead\n", *arg, *arg)
1240d1339
< #define DEPRECATED_WARNING fprintf(stderr, "gpp: warning: deprecated option %s'; use -%s' instead\n", *arg, arg)
1259,1262c1358,1360
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

        if (!(*(++arg)))
            OPT_SYNTAX_ERR;

1267,1270c1365,1366
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

        if (!(*(++arg)))
            OPT_SYNTAX_ERR;

1276,1279c1372,1373
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

        if (!(*(++arg)))
            OPT_SYNTAX_ERR;

1297,1300c1391,1392
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

        if (!(*(++arg)))
            OPT_SYNTAX_ERR;

1305,1308c1397,1398
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

        if (!(*(++arg)))
            OPT_SYNTAX_ERR;

1319,1326c1409,1412
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

            if (!(*(++arg)))
                OPT_SYNTAX_ERR;
            if (!(*(++arg)))
                OPT_SYNTAX_ERR;

1333,1344c1419,1424
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

            if (!(*(++arg)))
                OPT_SYNTAX_ERR;
            if (!(*(++arg)))
                OPT_SYNTAX_ERR;
            if (!(*(++arg)))
                OPT_SYNTAX_ERR;

1359a1440

1360a1442,1445

        if (C->in == NULL) {
            fprintf(stderr, "Command line error: cannot open input file %s\n", *arg);
            exit(EXIT_FAILURE);
        }

1362,1365c1447,1449
< C->filename = my_strdup(*arg);
< if (C->in == NULL )
< bug("Cannot open input file");
< } else

        if ( (C->filename = my_strdup(*arg)) == NULL)
            OPT_BUG("Out of memory to copy input file name");
    } else /* arg does start with '-' => process option(s) */

1368,1369c1452,1453
< if (nincludedirs == MAXINCL)
< bug("too many include directories");

            if (nincludedirs >= MAX_INCL_DIRS)
                OPT_BUG("Too many directories to search");

1371,1375c1455,1457
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }
< includedir[nincludedirs++] = my_strdup(arg);

                if (!(*(++arg)))
                    OPT_SYNTAX_ERR;
                includedir[nincludedirs] = my_strdup(*arg);

1377c1459,1463
< includedir[nincludedirs++] = my_strdup((*arg) + 2);

                includedir[nincludedirs] = my_strdup((*arg) + 2);

            if (includedir[nincludedirs] == NULL)
                OPT_BUG("Out of memory to copy directory to search");
            nincludedirs++;

1427,1430c1513,1514
< if (!readModeDescription(arg, &(S->User), 0)) {
< usage();
< exit(EXIT_FAILURE);
< }

            if (!readModeDescription(arg, &(S->User), 0))
                OPT_SYNTAX_ERR;

1438,1441c1522,1523
< if (!readModeDescription(arg, &(S->Meta), 1)) {
< usage();
< exit(EXIT_FAILURE);
< }

            if (!readModeDescription(arg, &(S->Meta), 1))
                OPT_SYNTAX_ERR;

1447,1450c1529,1530
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

            if (!(*(++arg)))
                OPT_SYNTAX_ERR;

1455c1535
< bug("Cannot create output file");

                OPT_BUG("Cannot create output file");

1459,1462c1539,1540
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

                if (!(*(++arg)))
                    OPT_SYNTAX_ERR;

1480,1483c1558,1559
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

            if (!(*(++arg)))
                OPT_SYNTAX_ERR;

1492,1495c1568,1569
< if (hasmeta && !usrmode) {
< usage();
< exit(EXIT_FAILURE);
< }

    if (hasmeta && !usrmode)
        OPT_SYNTAX_ERR;

1502a1577

/* to be fixed later, see #27; the directory should be present no matter what */
1504c1579,1581
< includedir[0] = my_strdup("/usr/include");

    includedir[0] = my_strdup(DFT_SYS_INCL_DIR);
    if (includedir[0] == NULL)
        OPT_BUG("Out of memory for standard search dir ref");

1544c1621
< struct COMMENT *c;

COMMENT *c;

1724c1801
< struct INPUTCONTEXT *T;

INPUTCONTEXT *T;

1727c1804,1805
< s = malloc(1);

    if ( (s = malloc(1)) == NULL)
        bug("Out of memory");

1731c1809,1810
< s = malloc(l + 2);

if ( (s = malloc(l + 2)) == NULL)
    bug("Out of memory");

1734c1813,1814
< s[l + 1] = 0;

s[l + 1] = '\0';

1736,1737c1816,1819
< C = malloc(sizeof C);
< C->out = malloc(sizeof (C->out));

if ( (C = malloc(sizeof *C)) == NULL)
    bug("Out of memory for input context copy");
if ( (C->out = malloc(sizeof *(C->out))) == NULL)
    bug("Out of memory for output context copy");

1742c1824,1825
< C->out->buf = malloc(80);

if ( (C->out->buf = malloc(INIT_LINESIZE)) == NULL)
    bug("Out of memory for output context buffer copy");

1744c1827
< C->out->bufsize = 80;

C->out->bufsize = INIT_LINESIZE;

1877c1960
< bug("globbing support has not been compiled in");

    bug("support for 'glob' match has not been compiled in");

1888c1971,1974
< str1 = strdup(buf + pos1);

        str1 = my_strdup(buf + pos1);
        str2 = my_strdup(buf + spl2);
        if ((str1==NULL) || (str2==NULL))
            bug("Out of memory to copy 'fnmatch' operands");

1890d1975
< str2 = strdup(buf + spl2);
2076c2161
< memcpy(macros + i, macros + nmacros, sizeof(struct MACRO));

memcpy(macros + i, macros + nmacros, sizeof(MACRO));

2090c2175,2176
< macros[nmacros].macrotext = malloc(1);

    if ( (macros[nmacros].macrotext = malloc(1)) == NULL)
        bug("Out of memory");

2096a2183

2108,2109c2195,2197
< t = malloc(MAX_GPP_NUM_SIZE);
< sprintf(t, "%d", i);

if ( (t = malloc(MAX_GPP_NUM_SIZE + 1)) == NULL)
    bug("Out of memory for number value");
sprintf(t, "%d", i); /* check to see if it can be restricted to MAX_GPP_NUM_SIZE */

2131c2219,2221
< t = s = malloc(end - start + 1);

if ( (t = s = malloc(end - start + 1)) == NULL)
    bug("Out of memory for comment or string");

2146c2236
< void SetStandardMode(struct SPECS P, const char opt) {

void SetStandardMode(SPECS *P, const char opt) {
2189a2280,2281
/ in these cases, consideration should be given to making some of these warnings, /
/ rather than (fatal) bugs */
2191c2283
< struct SPECS *P;

SPECS *P;

2202a2295,2296

if (s == NULL)
    bug("Out of memory for second arg");

2282,2291c2376,2392
< if ((opt != NULL )||(nargs!=9))bug("#mode user requires 9 arguments");
< S->stack_next->User.mStart=my_strdup(args[0]);
< S->stack_next->User.mEnd=my_strdup(args[1]);
< S->stack_next->User.mArgS=my_strdup(args[2]);
< S->stack_next->User.mArgSep=my_strdup(args[3]);
< S->stack_next->User.mArgE=my_strdup(args[4]);
< S->stack_next->User.stackchar=my_strdup(args[5]);
< S->stack_next->User.unstackchar=my_strdup(args[6]);
< S->stack_next->User.mArgRef=my_strdup(args[7]);
< S->stack_next->User.quotechar=args[8][0];

    MODE *mCurr = &(S->stack_next->User);

    if ((opt != NULL ) || (nargs!=9))
        bug("#mode user requires 9 arguments");
    mCurr->mStart=my_strdup(args[0]);
    mCurr->mEnd=my_strdup(args[1]);
    mCurr->mArgS=my_strdup(args[2]);
    mCurr->mArgSep=my_strdup(args[3]);
    mCurr->mArgE=my_strdup(args[4]);
    mCurr->stackchar=my_strdup(args[5]);
    mCurr->unstackchar=my_strdup(args[6]);
    mCurr->mArgRef=my_strdup(args[7]);
    mCurr->quotechar=args[8][0];
    if ((mCurr->mStart==NULL) || (mCurr->mEnd==NULL) || (mCurr->mArgS==NULL) || (mCurr->mArgSep==NULL)
      || (mCurr->mArgE==NULL) || (mCurr->mArgRef==NULL) || (mCurr->stackchar==NULL)
      || (mCurr->unstackchar==NULL))
        bug("Out of memory to copy #mode user args");

2295c2396
< S->stack_next->Meta=S->stack_next->User;

        S->stack_next->Meta = S->stack_next->User;

2297,2304c2398,2411
< if ((opt!=NULL)||(nargs!=7)) bug("#mode meta requires 7 arguments");
< S->stack_next->Meta.mStart=my_strdup(args[0]);
< S->stack_next->Meta.mEnd=my_strdup(args[1]);
< S->stack_next->Meta.mArgS=my_strdup(args[2]);
< S->stack_next->Meta.mArgSep=my_strdup(args[3]);
< S->stack_next->Meta.mArgE=my_strdup(args[4]);
< S->stack_next->Meta.stackchar=my_strdup(args[5]);
< S->stack_next->Meta.unstackchar=my_strdup(args[6]);

        MODE *mCurr = &(S->stack_next->Meta);

        if ((opt!=NULL) || (nargs!=7))
            bug("#mode meta requires 7 arguments");
        mCurr->mStart=my_strdup(args[0]);
        mCurr->mEnd=my_strdup(args[1]);
        mCurr->mArgS=my_strdup(args[2]);
        mCurr->mArgSep=my_strdup(args[3]);
        mCurr->mArgE=my_strdup(args[4]);
        mCurr->stackchar=my_strdup(args[5]);
        mCurr->unstackchar=my_strdup(args[6]);
        if ((mCurr->mStart==NULL) || (mCurr->mEnd==NULL) || (mCurr->mArgS==NULL) || (mCurr->mArgSep==NULL)
          || (mCurr->mArgE==NULL) || (mCurr->stackchar==NULL) || (mCurr->unstackchar==NULL))
            bug("Out of memory to copy #mode meta args");

2323c2430
< S->stack_next->op_set=MakeCharsetSubset((unsigned char *)args[0]);

        S->stack_next->op_set=MakeCharsetSubset((unsigned char *)args[0]);

2325c2432
< S->stack_next->ext_op_set=MakeCharsetSubset((unsigned char *)args[0]);

        S->stack_next->ext_op_set=MakeCharsetSubset((unsigned char *)args[0]);

2327c2434
< S->stack_next->id_set=MakeCharsetSubset((unsigned char *)args[0]);

        S->stack_next->id_set=MakeCharsetSubset((unsigned char *)args[0]);

2336c2443
< struct INPUTCONTEXT *N;

INPUTCONTEXT *N;

2340c2447
< int len = strlen(file_name);

int len1 = strlen(file_name);

2354,2362c2461,2474
< for (j = 0; (f == NULL )&&(j<nincludedirs);j++){
< incfile_name =
< realloc(incfile_name,len+strlen(includedir[j])+2);
< strcpy(incfile_name,includedir[j]);
< incfile_name[strlen(includedir[j])]=SLASH;
< /* extract the orig include filename */
< strcpy(incfile_name+strlen(includedir[j])+1, file_name);
< f=fopen(incfile_name,"r");
< }

for (j = 0; (f == NULL) && (j<nincludedirs);j++) {
    int len2 = strlen(includedir[j]);

    /* 'realloc()' used, as generated name's length changes each time thru */
    if ( (incfile_name = realloc(incfile_name,len1+len2+2)) == NULL)
        bug("Out of memory for new file's name");
    strncpy(incfile_name, includedir[j], len2);
    incfile_name[len2] = SLASH;

    /* extract the orig include filename, and append */
    strncpy(incfile_name+len2+1, file_name, len1);
    incfile_name[len2+1+len1] = '\0';
    f=fopen(incfile_name,"r");
}

2375c2487,2488
< C = malloc(sizeof *C);

if ( (C = malloc(sizeof *C)) == NULL)
    bug("Out of memory for input context copy");

2384c2497,2498
< C->buf = C->malloced_buf = malloc(C->bufsize);

if ( (C->buf = C->malloced_buf = malloc(C->bufsize)) == NULL)
    bug("Out of memory for input buffer");

2390a2505

2399a2515

2539a2656,2657

            if (macros[nmacros].argnames == NULL)
                bug("Out of memory");

2545,2546c2663
< bug(
< "#define with named args needs identifiers as arg names");

                bug("#define with named args needs identifiers as arg names");

2547a2665,2666

            if (macros[nmacros].argnames[j] == NULL)
                bug("Out of memory");

2633c2752
< /* user may put "" or <> */

        /* user may put "" or <> (or other framing chars) */

2641c2760,2762
< incfile_name = malloc(p1end - p1start + 1);

        if ( (incfile_name = malloc(p1end - p1start + 1)) == NULL)
            bug("Out of memory for file name to #include");

2655,2656c2776
< warning(
< "Not allowed to #exec. Command output will be left blank");

            warning("Not allowed to #exec. Command output will be left blank");

2660a2781

2665,2666c2786,2788
< i = strlen(s);
< s = realloc(s, i + strlen(t) + 2);

                i = strlen(s);    j = strlen(t);
                if ( (s = realloc(s, i + j + 2)) == NULL)
                    bug("Out of memory");

2668c2790,2791
< strcpy(s + i + 1, t);

                strncpy(s + i + 1, t, j);
                s[i+1+j] = '\0';

2709c2832,2833
< macros[nmacros].argnames = malloc((argc + 1) * sizeof(char *));

            if ( (macros[nmacros].argnames = malloc((argc + 1) * sizeof(char *))) == NULL)
                bug("Out of memory for macro arg");

2717c2841,2842
< macros[nmacros].argnames[j] = malloc(arge[j] - argb[j] + 1);

            if ( (macros[nmacros].argnames[j] = malloc(arge[j] - argb[j] + 1)) == NULL)
                bug("Out of memory for macro arg");

2875c3000
< int argc, id, i, l;

int argc, id, i, j, l;

2878c3003
< struct INPUTCONTEXT *T;

INPUTCONTEXT *T;

2933c3058,3059
< C = malloc(sizeof *C);

if ( (C = malloc(sizeof *C)) == NULL)
    bug("Out of memory for input context");

2950c3076,3077
< C->buf = C->malloced_buf = malloc(l);

    if ( (C->buf = C->malloced_buf = malloc(l)) == NULL)
        bug("Out of memory");

2953,2954c3080,3081
< strcpy(C->buf + 1, macros[id].macrotext);
< while ((l > 1) && isWhite(C->buf[l - 1]))

    strncpy(C->buf + 1, macros[id].macrotext, l);
    while ((l > 1) && isWhite(C->buf[l - 1])) /* strip trailing whitespace */

2956c3083,3085
< strcpy(C->buf + l, macros[id].define_specs->User.mArgS);

    j = strlen(macros[id].define_specs->User.mArgS);
    strncpy(C->buf + 1 + l, macros[id].define_specs->User.mArgS, j);
    C->buf[1 + l + j] = '\0';

2965c3094,3095
< C->buf = C->malloced_buf = malloc(strlen(macros[id].macrotext) + 2);

    if ( (C->buf = C->malloced_buf = malloc(strlen(macros[id].macrotext) + 2)) == NULL)
        bug("Out of memory for input buffer");

2990c3120
< struct COMMENT *p;

COMMENT *p;

3080a3211

char *absfile = calloc(strlen(C->filename) + strlen(incfile) + 1, 1);

3082d3212
< char *absfile;
3084,3088c3214,3215
< if (IncludeFile) {
< return fopen(incfile, "r");
< }
<
< absfile = calloc(strlen(C->filename) + strlen(incfile) + 1, 1);

if (absfile == NULL)
    bug("Out of memory for local file name");

3100,3102c3227,3231
< while (start <= end) {
< if (*start == '\n') {
< if (skip) skip--; else fprintf(C->out->f,"\n");

    while (start <= end) {
        if (*start == '\n') {
            if (skip) skip--; else fprintf(C->out->f,"\n");
        }
        start++;

3104d3232
< start++;
3107d3234
< }
3115,3116c3242,3243
< fprintf(f,"\n");
< }

    fprintf(f,"\n");
}

3144c3271,3272
< outstr = malloc(2 strlen(instr));

if ( (*outstr = malloc(2 * strlen(instr))) == NULL)
    bug("Out of memory for file-rebuilding");

3170c3298,3299
< *include_directive_marker = malloc(len + 18);

if ( (*include_directive_marker = malloc(len + 18)) == NULL)
    bug("Out of memory for directive marker");

3194c3323
< bug("only 3 substitutions allowed in -includemarker");

                bug("only 3 substitutions allowed in --includemarker");

3216d3344
< IncludeFile = NULL;

Add files via upload

08403ce

Merge branch 'logological:master' into master

276faa5

duncanmac99 closed this Oct 12, 2021

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add files via upload #32

Add files via upload #32

duncanmac99 commented Nov 8, 2018

logological commented Jun 11, 2019

duncanmac99 commented Jun 21, 2019

duncanmac99 commented Jun 21, 2019

Add files via upload #32

Add files via upload #32

Conversation

duncanmac99 commented Nov 8, 2018

logological commented Jun 11, 2019

duncanmac99 commented Jun 21, 2019

duncanmac99 commented Jun 21, 2019

48,50c57,66 < #define STACKDEPTH 50 < #define MAXARGS 100 < #define MAXINCL 128 /* max # of include dirs */

149,152c165,168 < typedef struct SPECS { < struct MODE User, Meta; < struct COMMENT *comments; < struct SPECS *stack_next;

166c182 < struct MACRO *macros;

212c230 < struct INPUTCONTEXT *C;

251c272 < return newstr ? (char *) memcpy(newstr, s, len) : NULL ;

292c317 < if (Q->comments != NULL )

296c325,326 < memcpy(y, x, sizeof(struct COMMENT));

299c329,332 < if (x->next != NULL )

305,306c341,342 < void FreeComments(struct SPECS *Q) { < struct COMMENT *p;

405c458 < bug("Out of memory");

407c460,461 < macros[nmacros].username = malloc(len + 1);

409c463 < macros[nmacros].username[len] = 0;

442c496,498 < t = malloc(strlen(s) + 1);

461,462c518 < t = malloc(strlen(s) + 1); < u = t;

483c543 < bug("\w and \W cannot be negated");

491c551 < bug("\w and \W cannot be negated");

555c615 < bug("\w and \W cannot be negated");

563c623 < bug("\w and \W cannot be negated");

601c661 < bug("unterminated string in #mode command");

653c718 < bug("invalid syntax in -D declaration");

659c727,728 < macros[nmacros].argnames[argc - 1] = malloc(i - l + 1);

674c743,744 < bug("invalid syntax in -D declaration");

676c746,749 < macros[nmacros++].macrotext = my_strdup(s + l);

679c752 < int readModeDescription(char **args, struct MODE *mode, int ismeta) {

735c807 < void add_comment(struct SPECS *S, const char *specif, char *start, char *end,

740,741c814,817 < bug("Comment/string start delimiter must be non-empty"); < for (p = S->comments; p != NULL ; p = p->next)

744c820,821 < bug("Conflicting comment/string delimiter specifications");

750,751c828,831 < if (p == NULL ) { < p = malloc(sizeof *p);

759,760d838 < if (strlen(specif) != 3) < bug("Invalid comment/string modifier"); 766,767c844,845 < void delete_comment(struct SPECS *S, char *start) { < struct COMMENT *p, *q;

772c853 < if (q == NULL )

789,792c870,872 < if (C->out->len + 1 == C->out->bufsize) { < C->out->bufsize = C->out->bufsize * 2; < C->out->buf = realloc(C->out->buf, C->out->bufsize); < if (C->out->buf == NULL )

836,837d919 < if (C->buf == NULL ) < bug("Out of memory"); 1073c1155,1156 < x = malloc(CHARSET_SUBSET_LEN * sizeof(unsigned long));

1079,1080c1162,1163 < bug( < "negated special sequences not allowed in charset specifications");

1193c1276 < nalloced = 31;

1210,1211c1301,1305 < C->filename = my_strdup("stdin"); < C->out = malloc(sizeof *(C->out));

1214c1308 < C->lineno = 1;

1217c1311 < C->bufsize = 80;

1267,1270c1365,1366 < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1276,1279c1372,1373 < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1297,1300c1391,1392 < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1305,1308c1397,1398 < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1319,1326c1409,1412 < if (!((++arg))) { < usage(); < exit(EXIT_FAILURE); < } < if (!((++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1333,1344c1419,1424 < if (!((++arg))) { < usage(); < exit(EXIT_FAILURE); < } < if (!((++arg))) { < usage(); < exit(EXIT_FAILURE); < } < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1362,1365c1447,1449 < C->filename = my_strdup(*arg); < if (C->in == NULL ) < bug("Cannot open input file"); < } else

1368,1369c1452,1453 < if (nincludedirs == MAXINCL) < bug("too many include directories");

1371,1375c1455,1457 < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < } < includedir[nincludedirs++] = my_strdup(*arg);

1377c1459,1463 < includedir[nincludedirs++] = my_strdup((*arg) + 2);

1427,1430c1513,1514 < if (!readModeDescription(arg, &(S->User), 0)) { < usage(); < exit(EXIT_FAILURE); < }

1438,1441c1522,1523 < if (!readModeDescription(arg, &(S->Meta), 1)) { < usage(); < exit(EXIT_FAILURE); < }

1447,1450c1529,1530 < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1455c1535 < bug("Cannot create output file");

1459,1462c1539,1540 < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1480,1483c1558,1559 < if (!(*(++arg))) { < usage(); < exit(EXIT_FAILURE); < }

1492,1495c1568,1569 < if (hasmeta && !usrmode) { < usage(); < exit(EXIT_FAILURE); < }

1544c1621 < struct COMMENT *c;

1724c1801 < struct INPUTCONTEXT *T;

1727c1804,1805 < s = malloc(1);

1731c1809,1810 < s = malloc(l + 2);

1734c1813,1814 < s[l + 1] = 0;

1736,1737c1816,1819 < C = malloc(sizeof *C); < C->out = malloc(sizeof *(C->out));

1742c1824,1825 < C->out->buf = malloc(80);

1744c1827 < C->out->bufsize = 80;

1877c1960 < bug("globbing support has not been compiled in");

1888c1971,1974 < str1 = strdup(buf + pos1);

1890d1975 < str2 = strdup(buf + spl2); 2076c2161 < memcpy(macros + i, macros + nmacros, sizeof(struct MACRO));

2090c2175,2176 < macros[nmacros].macrotext = malloc(1);

2108,2109c2195,2197 < t = malloc(MAX_GPP_NUM_SIZE); < sprintf(t, "%d", i);

2131c2219,2221 < t = s = malloc(end - start + 1);

2146c2236 < void SetStandardMode(struct SPECS *P, const char *opt) {

2295c2396 < S->stack_next->Meta=S->stack_next->User;

2323c2430 < S->stack_next->op_set=MakeCharsetSubset((unsigned char *)args[0]);

2325c2432 < S->stack_next->ext_op_set=MakeCharsetSubset((unsigned char *)args[0]);

2327c2434 < S->stack_next->id_set=MakeCharsetSubset((unsigned char *)args[0]);

48,50c57,66
< #define STACKDEPTH 50
< #define MAXARGS 100
< #define MAXINCL 128 /* max # of include dirs */

149,152c165,168
< typedef struct SPECS {
< struct MODE User, Meta;
< struct COMMENT comments;
< struct SPECS stack_next;

166c182
< struct MACRO *macros;

212c230
< struct INPUTCONTEXT *C;

251c272
< return newstr ? (char *) memcpy(newstr, s, len) : NULL ;

292c317
< if (Q->comments != NULL )

296c325,326
< memcpy(y, x, sizeof(struct COMMENT));

299c329,332
< if (x->next != NULL )

305,306c341,342
< void FreeComments(struct SPECS Q) {
< struct COMMENT p;

405c458
< bug("Out of memory");

407c460,461
< macros[nmacros].username = malloc(len + 1);

409c463
< macros[nmacros].username[len] = 0;

442c496,498
< t = malloc(strlen(s) + 1);

461,462c518
< t = malloc(strlen(s) + 1);
< u = t;

483c543
< bug("\w and \W cannot be negated");

491c551
< bug("\w and \W cannot be negated");

555c615
< bug("\w and \W cannot be negated");

563c623
< bug("\w and \W cannot be negated");

601c661
< bug("unterminated string in #mode command");

653c718
< bug("invalid syntax in -D declaration");

659c727,728
< macros[nmacros].argnames[argc - 1] = malloc(i - l + 1);

674c743,744
< bug("invalid syntax in -D declaration");

676c746,749
< macros[nmacros++].macrotext = my_strdup(s + l);

679c752
< int readModeDescription(char **args, struct MODE *mode, int ismeta) {

735c807
< void add_comment(struct SPECS S, const char specif, char start, char end,

740,741c814,817
< bug("Comment/string start delimiter must be non-empty");
< for (p = S->comments; p != NULL ; p = p->next)

744c820,821
< bug("Conflicting comment/string delimiter specifications");

750,751c828,831
< if (p == NULL ) {
< p = malloc(sizeof *p);

759,760d838
< if (strlen(specif) != 3)
< bug("Invalid comment/string modifier");
766,767c844,845
< void delete_comment(struct SPECS S, char start) {
< struct COMMENT p, q;

772c853
< if (q == NULL )

789,792c870,872
< if (C->out->len + 1 == C->out->bufsize) {
< C->out->bufsize = C->out->bufsize * 2;
< C->out->buf = realloc(C->out->buf, C->out->bufsize);
< if (C->out->buf == NULL )

836,837d919
< if (C->buf == NULL )
< bug("Out of memory");
1073c1155,1156
< x = malloc(CHARSET_SUBSET_LEN * sizeof(unsigned long));

1079,1080c1162,1163
< bug(
< "negated special sequences not allowed in charset specifications");

1193c1276
< nalloced = 31;

1210,1211c1301,1305
< C->filename = my_strdup("stdin");
< C->out = malloc(sizeof *(C->out));

1214c1308
< C->lineno = 1;

1217c1311
< C->bufsize = 80;

1267,1270c1365,1366
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1276,1279c1372,1373
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1297,1300c1391,1392
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1305,1308c1397,1398
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1319,1326c1409,1412
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1333,1344c1419,1424
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1362,1365c1447,1449
< C->filename = my_strdup(*arg);
< if (C->in == NULL )
< bug("Cannot open input file");
< } else

1368,1369c1452,1453
< if (nincludedirs == MAXINCL)
< bug("too many include directories");

1371,1375c1455,1457
< if (!((++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }
< includedir[nincludedirs++] = my_strdup(arg);

1377c1459,1463
< includedir[nincludedirs++] = my_strdup((*arg) + 2);

1427,1430c1513,1514
< if (!readModeDescription(arg, &(S->User), 0)) {
< usage();
< exit(EXIT_FAILURE);
< }

1438,1441c1522,1523
< if (!readModeDescription(arg, &(S->Meta), 1)) {
< usage();
< exit(EXIT_FAILURE);
< }

1447,1450c1529,1530
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1455c1535
< bug("Cannot create output file");

1459,1462c1539,1540
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1480,1483c1558,1559
< if (!(*(++arg))) {
< usage();
< exit(EXIT_FAILURE);
< }

1492,1495c1568,1569
< if (hasmeta && !usrmode) {
< usage();
< exit(EXIT_FAILURE);
< }

1544c1621
< struct COMMENT *c;

1724c1801
< struct INPUTCONTEXT *T;

1727c1804,1805
< s = malloc(1);

1731c1809,1810
< s = malloc(l + 2);

1734c1813,1814
< s[l + 1] = 0;

1736,1737c1816,1819
< C = malloc(sizeof C);
< C->out = malloc(sizeof (C->out));

1742c1824,1825
< C->out->buf = malloc(80);

1744c1827
< C->out->bufsize = 80;

1877c1960
< bug("globbing support has not been compiled in");

1888c1971,1974
< str1 = strdup(buf + pos1);

1890d1975
< str2 = strdup(buf + spl2);
2076c2161
< memcpy(macros + i, macros + nmacros, sizeof(struct MACRO));

2090c2175,2176
< macros[nmacros].macrotext = malloc(1);

2108,2109c2195,2197
< t = malloc(MAX_GPP_NUM_SIZE);
< sprintf(t, "%d", i);

2131c2219,2221
< t = s = malloc(end - start + 1);

2146c2236
< void SetStandardMode(struct SPECS P, const char opt) {

2295c2396
< S->stack_next->Meta=S->stack_next->User;

2323c2430
< S->stack_next->op_set=MakeCharsetSubset((unsigned char *)args[0]);

2325c2432
< S->stack_next->ext_op_set=MakeCharsetSubset((unsigned char *)args[0]);

2327c2434
< S->stack_next->id_set=MakeCharsetSubset((unsigned char *)args[0]);

2336c2443
< struct INPUTCONTEXT *N;

2340c2447
< int len = strlen(file_name);

2375c2487,2488
< C = malloc(sizeof *C);

2384c2497,2498
< C->buf = C->malloced_buf = malloc(C->bufsize);

2545,2546c2663
< bug(
< "#define with named args needs identifiers as arg names");

2633c2752
< /* user may put "" or <> */

2641c2760,2762
< incfile_name = malloc(p1end - p1start + 1);