| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #if (defined(_WIN32) || defined(_MSDOS) || defined(__IBMC__)) | |
| #include <io.h> | |
| #else | |
| #include <unistd.h> | |
| #endif | |
| #include "cpp.h" | |
| /* | |
| * lexical FSM encoding | |
| * when in state state, and one of the characters | |
| * in ch arrives, enter nextstate. | |
| * States >= S_SELF are either final, or at least require special action. | |
| * In 'fsm' there is a line for each state X charset X nextstate. | |
| * List chars that overwrite previous entries later (e.g. C_ALPH | |
| * can be overridden by '_' by a later entry; and C_XX is the | |
| * the universal set, and should always be first. | |
| * States above S_SELF are represented in the big table as negative values. | |
| * S_SELF and S_SELFB encode the resulting token type in the upper bits. | |
| * These actions differ in that S_SELF doesn't have a lookahead char, | |
| * S_SELFB does. | |
| * | |
| * The encoding is blown out into a big table for time-efficiency. | |
| * Entries have | |
| * nextstate: 6 bits; ?\ marker: 1 bit; tokentype: 9 bits. | |
| */ | |
| #define MAXSTATE 32 | |
| #define ACT(tok,act) ((tok<<7)+act) | |
| #define QBSBIT 0100 | |
| #define GETACT(st) ((st>>7)&0x1ff) | |
| /* character classes */ | |
| #define C_WS 1 | |
| #define C_ALPH 2 | |
| #define C_NUM 3 | |
| #define C_EOF 4 | |
| #define C_XX 5 | |
| enum state | |
| { | |
| START = 0, NUM1, NUM2, NUM3, ID1, ST1, ST2, ST3, COM1, COM2, COM3, COM4, | |
| CC1, CC2, WS1, PLUS1, MINUS1, STAR1, SLASH1, PCT1, SHARP1, | |
| CIRC1, GT1, GT2, LT1, LT2, OR1, AND1, ASG1, NOT1, DOTS1, | |
| S_SELF = MAXSTATE, S_SELFB, S_EOF, S_NL, S_EOFSTR, | |
| S_STNL, S_COMNL, S_EOFCOM, S_COMMENT, S_EOB, S_WS, S_NAME | |
| }; | |
| int tottok; | |
| int tokkind[256]; | |
| struct fsm | |
| { | |
| int state; /* if in this state */ | |
| uchar ch[4]; /* and see one of these characters */ | |
| int nextstate; /* enter this state if +ve */ | |
| }; | |
| /*const*/ struct fsm fsm[] = { | |
| /* start state */ | |
| {START, {C_XX}, ACT(UNCLASS, S_SELF)}, | |
| {START, {' ', '\t', '\v'}, WS1}, | |
| {START, {C_NUM}, NUM1}, | |
| {START, {'.'}, NUM3}, | |
| {START, {C_ALPH}, ID1}, | |
| {START, {'L'}, ST1}, | |
| {START, {'"'}, ST2}, | |
| {START, {'\''}, CC1}, | |
| {START, {'/'}, COM1}, | |
| {START, {EOFC}, S_EOF}, | |
| {START, {'\n'}, S_NL}, | |
| {START, {'-'}, MINUS1}, | |
| {START, {'+'}, PLUS1}, | |
| {START, {'<'}, LT1}, | |
| {START, {'>'}, GT1}, | |
| {START, {'='}, ASG1}, | |
| {START, {'!'}, NOT1}, | |
| {START, {'&'}, AND1}, | |
| {START, {'|'}, OR1}, | |
| {START, {'#'}, SHARP1}, | |
| {START, {'%'}, PCT1}, | |
| {START, {'['}, ACT(SBRA, S_SELF)}, | |
| {START, {']'}, ACT(SKET, S_SELF)}, | |
| {START, {'('}, ACT(LP, S_SELF)}, | |
| {START, {')'}, ACT(RP, S_SELF)}, | |
| {START, {'*'}, STAR1}, | |
| {START, {','}, ACT(COMMA, S_SELF)}, | |
| {START, {'?'}, ACT(QUEST, S_SELF)}, | |
| {START, {':'}, ACT(COLON, S_SELF)}, | |
| {START, {';'}, ACT(SEMIC, S_SELF)}, | |
| {START, {'{'}, ACT(CBRA, S_SELF)}, | |
| {START, {'}'}, ACT(CKET, S_SELF)}, | |
| {START, {'~'}, ACT(TILDE, S_SELF)}, | |
| {START, {'^'}, CIRC1}, | |
| /* saw a digit */ | |
| {NUM1, {C_XX}, ACT(NUMBER, S_SELFB)}, | |
| {NUM1, {C_NUM, C_ALPH, '.'}, NUM1}, | |
| {NUM1, {'E', 'e'}, NUM2}, | |
| {NUM1, {'_'}, ACT(NUMBER, S_SELFB)}, | |
| /* saw possible start of exponent, digits-e */ | |
| {NUM2, {C_XX}, ACT(NUMBER, S_SELFB)}, | |
| {NUM2, {'+', '-'}, NUM1}, | |
| {NUM2, {C_NUM, C_ALPH}, NUM1}, | |
| {NUM2, {'_'}, ACT(NUMBER, S_SELFB)}, | |
| /* saw a '.', which could be a number or an operator */ | |
| {NUM3, {C_XX}, ACT(DOT, S_SELFB)}, | |
| {NUM3, {'.'}, DOTS1}, | |
| {NUM3, {C_NUM}, NUM1}, | |
| {DOTS1, {C_XX}, ACT(UNCLASS, S_SELFB)}, | |
| {DOTS1, {C_NUM}, NUM1}, | |
| {DOTS1, {'.'}, ACT(ELLIPS, S_SELF)}, | |
| /* saw a letter or _ */ | |
| {ID1, {C_XX}, ACT(NAME, S_NAME)}, | |
| {ID1, {C_ALPH, C_NUM}, ID1}, | |
| /* saw L (start of wide string?) */ | |
| {ST1, {C_XX}, ACT(NAME, S_NAME)}, | |
| {ST1, {C_ALPH, C_NUM}, ID1}, | |
| {ST1, {'"'}, ST2}, | |
| {ST1, {'\''}, CC1}, | |
| /* saw " beginning string */ | |
| {ST2, {C_XX}, ST2}, | |
| {ST2, {'"'}, ACT(STRING, S_SELF)}, | |
| {ST2, {'\\'}, ST3}, | |
| {ST2, {'\n'}, S_STNL}, | |
| {ST2, {EOFC}, S_EOFSTR}, | |
| /* saw \ in string */ | |
| {ST3, {C_XX}, ST2}, | |
| {ST3, {'\n'}, S_STNL}, | |
| {ST3, {EOFC}, S_EOFSTR}, | |
| /* saw ' beginning character const */ | |
| {CC1, {C_XX}, CC1}, | |
| {CC1, {'\''}, ACT(CCON, S_SELF)}, | |
| {CC1, {'\\'}, CC2}, | |
| {CC1, {'\n'}, S_STNL}, | |
| {CC1, {EOFC}, S_EOFSTR}, | |
| /* saw \ in ccon */ | |
| {CC2, {C_XX}, CC1}, | |
| {CC2, {'\n'}, S_STNL}, | |
| {CC2, {EOFC}, S_EOFSTR}, | |
| /* saw /, perhaps start of comment */ | |
| {COM1, {C_XX}, ACT(SLASH, S_SELFB)}, | |
| {COM1, {'='}, ACT(ASSLASH, S_SELF)}, | |
| {COM1, {'*'}, COM2}, | |
| {COM1, {'/'}, COM4}, | |
| /* saw / followed by *, start of comment */ | |
| {COM2, {C_XX}, COM2}, | |
| {COM2, {'\n'}, S_COMNL}, | |
| {COM2, {'*'}, COM3}, | |
| {COM2, {EOFC}, S_EOFCOM}, | |
| /* saw the * possibly ending a comment */ | |
| {COM3, {C_XX}, COM2}, | |
| {COM3, {'\n'}, S_COMNL}, | |
| {COM3, {'*'}, COM3}, | |
| {COM3, {'/'}, S_COMMENT}, | |
| /* // comment */ | |
| {COM4, {C_XX}, COM4}, | |
| {COM4, {'\n'}, S_NL}, | |
| {COM4, {EOFC}, S_EOFCOM}, | |
| /* saw white space, eat it up */ | |
| {WS1, {C_XX}, S_WS}, | |
| {WS1, {'\t', '\v', ' '}, WS1}, | |
| /* saw -, check --, -=, -> */ | |
| {MINUS1, {C_XX}, ACT(MINUS, S_SELFB)}, | |
| {MINUS1, {'-'}, ACT(MMINUS, S_SELF)}, | |
| {MINUS1, {'='}, ACT(ASMINUS, S_SELF)}, | |
| {MINUS1, {'>'}, ACT(ARROW, S_SELF)}, | |
| /* saw +, check ++, += */ | |
| {PLUS1, {C_XX}, ACT(PLUS, S_SELFB)}, | |
| {PLUS1, {'+'}, ACT(PPLUS, S_SELF)}, | |
| {PLUS1, {'='}, ACT(ASPLUS, S_SELF)}, | |
| /* saw <, check <<, <<=, <= */ | |
| {LT1, {C_XX}, ACT(LT, S_SELFB)}, | |
| {LT1, {'<'}, LT2}, | |
| {LT1, {'='}, ACT(LEQ, S_SELF)}, | |
| {LT2, {C_XX}, ACT(LSH, S_SELFB)}, | |
| {LT2, {'='}, ACT(ASLSH, S_SELF)}, | |
| /* saw >, check >>, >>=, >= */ | |
| {GT1, {C_XX}, ACT(GT, S_SELFB)}, | |
| {GT1, {'>'}, GT2}, | |
| {GT1, {'='}, ACT(GEQ, S_SELF)}, | |
| {GT2, {C_XX}, ACT(RSH, S_SELFB)}, | |
| {GT2, {'='}, ACT(ASRSH, S_SELF)}, | |
| /* = */ | |
| {ASG1, {C_XX}, ACT(ASGN, S_SELFB)}, | |
| {ASG1, {'='}, ACT(EQ, S_SELF)}, | |
| /* ! */ | |
| {NOT1, {C_XX}, ACT(NOT, S_SELFB)}, | |
| {NOT1, {'='}, ACT(NEQ, S_SELF)}, | |
| /* & */ | |
| {AND1, {C_XX}, ACT(AND, S_SELFB)}, | |
| {AND1, {'&'}, ACT(LAND, S_SELF)}, | |
| {AND1, {'='}, ACT(ASAND, S_SELF)}, | |
| /* | */ | |
| {OR1, {C_XX}, ACT(OR, S_SELFB)}, | |
| {OR1, {'|'}, ACT(LOR, S_SELF)}, | |
| {OR1, {'='}, ACT(ASOR, S_SELF)}, | |
| /* # */ | |
| {SHARP1, {C_XX}, ACT(SHARP, S_SELFB)}, | |
| {SHARP1, {'#'}, ACT(DSHARP, S_SELF)}, | |
| /* % */ | |
| {PCT1, {C_XX}, ACT(PCT, S_SELFB)}, | |
| {PCT1, {'='}, ACT(ASPCT, S_SELF)}, | |
| /* * */ | |
| {STAR1, {C_XX}, ACT(STAR, S_SELFB)}, | |
| {STAR1, {'='}, ACT(ASSTAR, S_SELF)}, | |
| /* ^ */ | |
| {CIRC1, {C_XX}, ACT(CIRC, S_SELFB)}, | |
| {CIRC1, {'='}, ACT(ASCIRC, S_SELF)}, | |
| {-1, "", 0} | |
| }; | |
| /* first index is char, second is state */ | |
| /* increase #states to power of 2 to encourage use of shift */ | |
| short bigfsm[256][MAXSTATE]; | |
| void | |
| expandlex(void) | |
| { | |
| /* const */ struct fsm *fp; | |
| int i, j, nstate; | |
| for (fp = fsm; fp->state >= 0; fp++) | |
| { | |
| for (i = 0; fp->ch[i]; i++) | |
| { | |
| nstate = fp->nextstate; | |
| if (nstate >= S_SELF) | |
| nstate = ~nstate; | |
| switch (fp->ch[i]) | |
| { | |
| case C_XX: /* random characters */ | |
| for (j = 0; j < 256; j++) | |
| bigfsm[j][fp->state] = (short) nstate; | |
| continue; | |
| case C_ALPH: | |
| for (j = 0; j < 256; j++) | |
| #ifdef S390 | |
| if( isalpha( j ) || (j == '_') ) | |
| #else | |
| if (('a' <= j && j <= 'z') || ('A' <= j && j <= 'Z') | |
| || j == '_') | |
| #endif | |
| bigfsm[j][fp->state] = (short) nstate; | |
| continue; | |
| case C_NUM: | |
| for (j = '0'; j <= '9'; j++) | |
| bigfsm[j][fp->state] = (short) nstate; | |
| continue; | |
| default: | |
| bigfsm[fp->ch[i]][fp->state] = (short) nstate; | |
| } | |
| } | |
| } | |
| /* | |
| * install special cases for ? (trigraphs), \ (splicing), runes, and | |
| * EOB | |
| */ | |
| for (i = 0; i < MAXSTATE; i++) | |
| { | |
| for (j = 0; j < 0xFF; j++) | |
| if (j == '?' || j == '\\' || j == '\n' || j == '\r') | |
| { | |
| if (bigfsm[j][i] > 0) | |
| bigfsm[j][i] = ~bigfsm[j][i]; | |
| bigfsm[j][i] &= ~QBSBIT; | |
| } | |
| bigfsm[EOB][i] = ~S_EOB; | |
| if (bigfsm[EOFC][i] >= 0) | |
| bigfsm[EOFC][i] = ~S_EOF; | |
| } | |
| } | |
| void | |
| fixlex(void) | |
| { | |
| /* do C++ comments? */ | |
| if ((Cplusplus == 0) || (Cflag != 0)) | |
| bigfsm['/'][COM1] = bigfsm['x'][COM1]; | |
| } | |
| /* | |
| * fill in a row of tokens from input, terminated by NL or END | |
| * First token is put at trp->lp. | |
| * Reset is non-zero when the input buffer can be "rewound." | |
| * The value is a flag indicating that possible macros have | |
| * been seen in the row. | |
| */ | |
| int | |
| gettokens(Tokenrow * trp, int reset) | |
| { | |
| register int c, state, oldstate; | |
| register uchar *ip; | |
| register Token *tp, *maxp; | |
| int runelen; | |
| Source *s = cursource; | |
| int nmac = 0; | |
| tp = trp->lp; | |
| ip = s->inp; | |
| if (reset) | |
| { | |
| s->lineinc = 0; | |
| if (ip >= s->inl) | |
| { /* nothing in buffer */ | |
| s->inl = s->inb; | |
| fillbuf(s); | |
| ip = s->inp = s->inb; | |
| } | |
| else | |
| if (ip >= s->inb + (3 * INS / 4)) | |
| { | |
| memmove(s->inb, ip, 4 + s->inl - ip); | |
| s->inl = s->inb + (s->inl - ip); | |
| ip = s->inp = s->inb; | |
| } | |
| } | |
| maxp = &trp->bp[trp->max]; | |
| runelen = 1; | |
| for (;;) | |
| { | |
| continue2: | |
| if (tp >= maxp) | |
| { | |
| trp->lp = tp; | |
| tp = growtokenrow(trp); | |
| maxp = &trp->bp[trp->max]; | |
| } | |
| tp->type = UNCLASS; | |
| tp->t = ip; | |
| tp->wslen = 0; | |
| tp->flag = 0; | |
| state = START; | |
| for (;;) | |
| { | |
| oldstate = state; | |
| c = *ip; | |
| if ((state = bigfsm[c][state]) >= 0) | |
| { | |
| ip += runelen; | |
| runelen = 1; | |
| continue; | |
| } | |
| state = ~state; | |
| reswitch: | |
| switch (state & 0177) | |
| { | |
| case S_SELF: | |
| ip += runelen; | |
| runelen = 1; | |
| case S_SELFB: | |
| tp->type = (unsigned char) GETACT(state); | |
| tp->len = ip - tp->t; | |
| tp++; | |
| goto continue2; | |
| case S_NAME: /* like S_SELFB but with nmac check */ | |
| tp->type = NAME; | |
| tp->len = ip - tp->t; | |
| nmac |= quicklook(tp->t[0], tp->len > 1 ? tp->t[1] : 0); | |
| tp++; | |
| goto continue2; | |
| case S_WS: | |
| tp->wslen = ip - tp->t; | |
| tp->t = ip; | |
| state = START; | |
| continue; | |
| default: | |
| if ((state & QBSBIT) == 0) | |
| { | |
| ip += runelen; | |
| runelen = 1; | |
| continue; | |
| } | |
| state &= ~QBSBIT; | |
| s->inp = ip; | |
| if (c == '\n') | |
| { | |
| while (s->inp + 1 >= s->inl && fillbuf(s) != EOF); | |
| if (s->inp[1] == '\r') | |
| { | |
| memmove(s->inp + 1, s->inp + 2, s->inl - s->inp + 2); | |
| s->inl -= 1; | |
| } | |
| goto reswitch; | |
| } | |
| if (c == '\r') | |
| { | |
| while (s->inp + 1 >= s->inl && fillbuf(s) != EOF); | |
| if (s->inp[1] == '\n') | |
| { | |
| memmove(s->inp, s->inp + 1, s->inl - s->inp + 1); | |
| s->inl -= 1; | |
| } | |
| else | |
| *s->inp = '\n'; | |
| state = oldstate; | |
| continue; | |
| } | |
| if (c == '?') | |
| { /* check trigraph */ | |
| if (trigraph(s)) | |
| { | |
| state = oldstate; | |
| continue; | |
| } | |
| goto reswitch; | |
| } | |
| if (c == '\\') | |
| { /* line-folding */ | |
| if (foldline(s)) | |
| { | |
| s->lineinc++; | |
| state = oldstate; | |
| continue; | |
| } | |
| goto reswitch; | |
| } | |
| error(WARNING, "Lexical botch in cpp"); | |
| ip += runelen; | |
| runelen = 1; | |
| continue; | |
| case S_EOB: | |
| s->inp = ip; | |
| fillbuf(cursource); | |
| state = oldstate; | |
| continue; | |
| case S_EOF: | |
| tp->type = END; | |
| tp->len = 0; | |
| s->inp = ip; | |
| if (tp != trp->bp && (tp - 1)->type != NL && cursource->fd != -1) | |
| error(WARNING, "No newline at end of file"); | |
| trp->lp = tp + 1; | |
| return nmac; | |
| case S_STNL: | |
| error(ERROR, "Unterminated string or char const"); | |
| case S_NL: | |
| tp->t = ip; | |
| tp->type = NL; | |
| tp->len = 1; | |
| tp->wslen = 0; | |
| s->lineinc++; | |
| s->inp = ip + 1; | |
| trp->lp = tp + 1; | |
| return nmac; | |
| case S_EOFSTR: | |
| error(FATAL, "EOF in string or char constant"); | |
| break; | |
| case S_COMNL: | |
| s->lineinc++; | |
| state = COM2; | |
| ip += runelen; | |
| runelen = 1; | |
| continue; | |
| case S_EOFCOM: | |
| error(WARNING, "EOF inside comment"); | |
| --ip; | |
| case S_COMMENT: | |
| if (!Cflag) | |
| { | |
| tp->t = ++ip; | |
| tp->t[-1] = ' '; | |
| tp->wslen = 1; | |
| state = START; | |
| continue; | |
| } | |
| else | |
| { | |
| runelen = 1; | |
| s->lineinc = 0; | |
| tp->type = COMMENT; | |
| tp->flag |= XTWS; | |
| } | |
| } | |
| break; | |
| } | |
| ip += runelen; | |
| runelen = 1; | |
| tp->len = ip - tp->t; | |
| tp++; | |
| } | |
| } | |
| /* have seen ?; handle the trigraph it starts (if any) else 0 */ | |
| int | |
| trigraph(Source * s) | |
| { | |
| uchar c; | |
| while (s->inp + 2 >= s->inl && fillbuf(s) != EOF); | |
| ; | |
| if (s->inp[1] != '?') | |
| return 0; | |
| c = 0; | |
| switch (s->inp[2]) | |
| { | |
| case '=': | |
| c = '#'; | |
| break; | |
| case '(': | |
| c = '['; | |
| break; | |
| case '/': | |
| c = '\\'; | |
| break; | |
| case ')': | |
| c = ']'; | |
| break; | |
| case '\'': | |
| c = '^'; | |
| break; | |
| case '<': | |
| c = '{'; | |
| break; | |
| case '!': | |
| c = '|'; | |
| break; | |
| case '>': | |
| c = '}'; | |
| break; | |
| case '-': | |
| c = '~'; | |
| break; | |
| } | |
| if (c) | |
| { | |
| *s->inp = c; | |
| memmove(s->inp + 1, s->inp + 3, s->inl - s->inp + 2); | |
| s->inl -= 2; | |
| } | |
| return c; | |
| } | |
| int | |
| foldline(Source * s) | |
| { | |
| int n = 1; | |
| /* skip pending white spaces */ | |
| while ((s->inp[n] == ' ') || (s->inp[n] == '\t')) | |
| { | |
| n++; | |
| if ((s->inp + n >= s->inl) && (fillbuf(s) == EOF)) | |
| break; | |
| } | |
| /* refill buffer */ | |
| while (s->inp + (n + 1) >= s->inl && fillbuf(s) != EOF); | |
| /* skip DOS line ends */ | |
| if (((s->inp[n] == '\r') && (s->inp[n+1] == '\n')) || | |
| ((s->inp[n] == '\n') && (s->inp[n+1] == '\r'))) | |
| n++; | |
| if ((s->inp[n] == '\n') || (s->inp[n] == '\r')) | |
| { | |
| memmove(s->inp, s->inp + n + 1, s->inl - s->inp + n + 2); | |
| s->inl -= n + 1; | |
| return 1; | |
| } | |
| return 0; | |
| } | |
| int | |
| fillbuf(Source * s) | |
| { | |
| int n; | |
| if (s->fd < 0 || (n = read(s->fd, (char *) s->inl, INS / 8)) <= 0) | |
| n = 0; | |
| s->inl += n; | |
| s->inl[0] = s->inl[1] = s->inl[2] = s->inl[3] = EOB; | |
| if (n == 0) | |
| { | |
| s->inl[0] = s->inl[1] = s->inl[2] = s->inl[3] = EOFC; | |
| return EOF; | |
| } | |
| return 0; | |
| } | |
| /* | |
| * Push down to new source of characters. | |
| * If fd>0 and str==NULL, then from a file `name'; | |
| * if fd==-1 and str, then from the string. | |
| */ | |
| Source * | |
| setsource(char *name, int path, int fd, char *str, int wrap) | |
| { | |
| Source *s = new(Source); | |
| int len; | |
| s->line = 1; | |
| s->lineinc = 0; | |
| s->fd = fd; | |
| s->filename = name; | |
| s->next = cursource; | |
| s->ifdepth = 0; | |
| s->pathdepth = path; | |
| s->wrap = wrap; | |
| cursource = s; | |
| if (s->wrap) | |
| genwrap(0); | |
| /* slop at right for EOB */ | |
| if (str) | |
| { | |
| len = strlen(str); | |
| s->inb = domalloc(len + 4); | |
| s->inp = s->inb; | |
| strncpy((char *) s->inp, str, len); | |
| } | |
| else | |
| { | |
| s->inb = domalloc(INS + 4); | |
| s->inp = s->inb; | |
| len = 0; | |
| } | |
| s->inl = s->inp + len; | |
| s->inl[0] = s->inl[1] = EOB; | |
| return s; | |
| } | |
| void | |
| unsetsource(void) | |
| { | |
| Source *s = cursource; | |
| if (s->wrap) | |
| genwrap(1); | |
| if (s->fd >= 0) | |
| { | |
| close(s->fd); | |
| dofree(s->inb); | |
| } | |
| cursource = s->next; | |
| dofree(s); | |
| } |