static int
gobble(struct filepointer *filep, struct inclist *file,
struct inclist *file_red)
{
char *line;
int type;
while ((line = getnextline(filep))) {
switch(type = deftype(line, filep, file_red, file, FALSE)) {
case IF:
case IFFALSE:
case IFGUESSFALSE:
case IFDEF:
case IFNDEF:
type = gobble(filep, file, file_red);
while ((type == ELIF) || (type == ELIFFALSE) ||
(type == ELIFGUESSFALSE))
type = gobble(filep, file, file_red);
if (type == ELSE)
(void)gobble(filep, file, file_red);
break;
case ELSE:
case ENDIF:
debug(0,("%s, line %d: #%s\n",
file->i_file, filep->f_line,
directives[type]));
return(type);
case DEFINE:
case UNDEF:
case INCLUDE:
case INCLUDEDOT:
case PRAGMA:
case ERROR:
case IDENT:
case SCCS:
case EJECT:
case WARNING:
case INCLUDENEXT:
case INCLUDENEXTDOT:
break;
case ELIF:
case ELIFFALSE:
case ELIFGUESSFALSE:
return(type);
case -1:
warning("%s", file_red->i_file);
if (file_red != file)
warning1(" (reading %s)", file->i_file);
warning1(", line %d: unknown directive == \"%s\"\n",
filep->f_line, line);
break;
}
}
return(-1);
}
int
hay_dialer(char *num, char *acu)
{
char *cp;
int connected = 0;
char dummy;
struct termios cntrl;
#ifdef ACULOG
char line[80];
#endif
if (hay_sync() == 0) /* make sure we can talk to the modem */
return(0);
if (boolean(value(VERBOSE)))
printf("\ndialing...");
fflush(stdout);
tcgetattr(FD, &cntrl);
cntrl.c_cflag |= HUPCL;
tcsetattr(FD, TCSANOW, &cntrl);
tcflush(FD, TCIOFLUSH);
write(FD, "ATv0\r", 5); /* tell modem to use short status codes */
gobble("\r");
gobble("\r");
write(FD, "ATTD", 4); /* send dial command */
for (cp = num; *cp; cp++)
if (*cp == '=')
*cp = ',';
write(FD, num, strlen(num));
state = DIALING;
write(FD, "\r", 1);
connected = 0;
if (gobble("\r")) {
if ((dummy = gobble("01234")) != '1')
error_rep(dummy);
else
connected = 1;
}
if (connected)
state = CONNECTED;
else {
state = FAILED;
return (connected); /* lets get out of here.. */
}
tcflush(FD, TCIOFLUSH);
#ifdef ACULOG
if (dialtimeout) {
(void)snprintf(line, sizeof line, "%ld second dial timeout",
number(value(DIALTIMEOUT)));
logent(value(HOST), num, "hayes", line);
}
#endif
if (dialtimeout)
hay_disconnect(); /* insurance */
return (connected);
}
int gobble(struct filepointer *filep,
struct inclist *file,
struct inclist *file_red,
struct symhash *symbols)
{
char *line;
int type;
while ((line = get_line(filep))) {
switch(type = deftype(line, filep, file_red, file, FALSE, symbols)) {
case IF:
case IFFALSE:
case IFGUESSFALSE:
case IFDEF:
case IFNDEF:
type = gobble(filep, file, file_red, symbols);
while ((type == ELIF) || (type == ELIFFALSE) ||
(type == ELIFGUESSFALSE))
type = gobble(filep, file, file_red, symbols);
if (type == ELSE)
(void)gobble(filep, file, file_red, symbols);
break;
case ELSE:
case ENDIF:
debug(0,("%s, line %d: #%s\n",
file->i_file, filep->f_line,
directives[type]));
return type;
case DEFINE:
case UNDEF:
case INCLUDE:
case INCLUDEDOT:
case PRAGMA:
case ERROR:
case IDENT:
case SCCS:
case EJECT:
break;
case ELIF:
case ELIFFALSE:
case ELIFGUESSFALSE:
return type;
case -1:
warning("%s, line %d: unknown directive == \"%s\"\n",
file_red->i_file, filep->f_line, line);
break;
}
}
return -1;
}
static int
grpmatch(Match_t* mp, int g, char* s, register char* p, char* e, int flags)
{
register char* a;
do
{
for (a = p; onematch(mp, g, s, a, e, NiL, flags); a++)
if (*(a = mp->next_p) != '&')
return 1;
} while (p = gobble(mp, p, '|', &g, 1));
return 0;
}
static int
cmygetc(void)
{
int c;
for (;;)
{
c = mygetc();
if (c == '/')
{
if (gobble('*'))
skip_comment();
else
return c;
} else
return c;
}
}
/*
* set modem back to normal verbose status codes.
*/
static void
goodbye(void)
{
int len;
char c;
tcflush(FD, TCIOFLUSH);
if (hay_sync()) {
sleep(1);
#ifndef DEBUG
tcflush(FD, TCIOFLUSH);
#endif
write(FD, "ATH0\r", 5); /* insurance */
#ifndef DEBUG
c = gobble("03");
if (c != '0' && c != '3') {
printf("cannot hang up modem\n\r");
printf("please use 'tip dialer' to make sure the line is hung up\n\r");
}
#endif
sleep(1);
ioctl(FD, FIONREAD, &len);
#ifdef DEBUG
printf("goodbye1: len=%d -- ", len);
rlen = read(FD, dumbuf, min(len, DUMBUFLEN));
dumbuf[rlen] = '\0';
printf("read (%d): %s\r\n", rlen, dumbuf);
#endif
write(FD, "ATv1\r", 5);
sleep(1);
#ifdef DEBUG
ioctl(FD, FIONREAD, &len);
printf("goodbye2: len=%d -- ", len);
rlen = read(FD, dumbuf, min(len, DUMBUFLEN));
dumbuf[rlen] = '\0';
printf("read (%d): %s\r\n", rlen, dumbuf);
#endif
}
tcflush(FD, TCIOFLUSH);
ioctl(FD, TIOCCDTR, 0); /* clear DTR (insurance) */
close(FD);
}
void misuseHeapClass(int len) {
Heap invalid; // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in an automatic variable}}
Heap alsoInvalid[2]; // expected-error {{variable of type 'Heap [2]' only valid on the heap}} expected-note {{value incorrectly allocated in an automatic variable}} expected-note {{'Heap [2]' is a heap type because it is an array of heap type 'Heap'}}
static Heap invalidStatic; // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a global variable}}
static Heap alsoInvalidStatic[2]; // expected-error {{variable of type 'Heap [2]' only valid on the heap}} expected-note {{value incorrectly allocated in a global variable}} expected-note {{'Heap [2]' is a heap type because it is an array of heap type 'Heap'}}
gobble(&invalid);
gobble(&invalidStatic);
gobble(&alsoInvalid[0]);
gobbleref(Heap()); // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a temporary}}
gobbleref(Heap(10, 20)); // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a temporary}}
gobbleref(Heap(10)); // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a temporary}}
gobbleref(10); // expected-error {{variable of type 'Heap' only valid on the heap}} expected-note {{value incorrectly allocated in a temporary}}
gobble(new Heap);
gobble(new Heap[10]);
gobble(new TemplateClass<int>);
gobble(len <= 5 ? &invalid : new Heap);
char buffer[sizeof(Heap)];
gobble(new (buffer) Heap);
}
void misuseNonTemporaryClass(int len) {
NonTemporary invalid;
NonTemporary alsoInvalid[2];
static NonTemporary invalidStatic;
static NonTemporary alsoInvalidStatic[2];
gobble(&invalid);
gobble(&invalidStatic);
gobble(&alsoInvalid[0]);
gobbleref(NonTemporary()); // expected-error {{variable of type 'NonTemporary' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
gobbleref(NonTemporary(10, 20)); // expected-error {{variable of type 'NonTemporary' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
gobbleref(NonTemporary(10)); // expected-error {{variable of type 'NonTemporary' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
gobbleref(10); // expected-error {{variable of type 'NonTemporary' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
gobbleanyref(TemplateClass<int>()); // expected-error {{variable of type 'TemplateClass<int>' is not valid in a temporary}} expected-note {{value incorrectly allocated in a temporary}}
gobble(new NonTemporary);
gobble(new NonTemporary[10]);
gobble(new TemplateClass<int>);
gobble(len <= 5 ? &invalid : new NonTemporary);
char buffer[sizeof(NonTemporary)];
gobble(new (buffer) NonTemporary);
}
static int
onematch(Match_t* mp, int g, char* s, char* p, char* e, char* r, int flags)
{
register int pc;
register int sc;
register int n;
register int icase;
char* olds;
char* oldp;
icase = flags & STR_ICASE;
do
{
olds = s;
sc = getsource(s, e);
if (icase && isupper(sc))
sc = tolower(sc);
oldp = p;
switch (pc = mbgetchar(p))
{
case '(':
case '*':
case '?':
case '+':
case '@':
case '!':
if (pc == '(' || *p == '(')
{
char* subp;
int oldg;
s = olds;
subp = p + (pc != '(');
oldg = g;
n = ++g;
if (g < MAXGROUP && (!r || g > mp->current.groups))
mp->current.beg[g] = mp->current.end[g] = 0;
if (!(p = gobble(mp, subp, 0, &g, !r)))
return 0;
if (pc == '*' || pc == '?' || pc == '+' && oldp == r)
{
if (onematch(mp, g, s, p, e, NiL, flags))
return 1;
if (!sc || !getsource(s, e))
{
mp->current.groups = oldg;
return 0;
}
}
if (pc == '*' || pc == '+')
{
p = oldp;
sc = n - 1;
}
else
sc = g;
pc = (pc != '!');
do
{
if (grpmatch(mp, n, olds, subp, s, flags) == pc)
{
if (n < MAXGROUP)
{
if (!mp->current.beg[n] || mp->current.beg[n] > olds)
mp->current.beg[n] = olds;
if (s > mp->current.end[n])
mp->current.end[n] = s;
}
if (onematch(mp, sc, s, p, e, oldp, flags))
{
if (p == oldp && n < MAXGROUP)
{
if (!mp->current.beg[n] || mp->current.beg[n] > olds)
mp->current.beg[n] = olds;
if (s > mp->current.end[n])
mp->current.end[n] = s;
}
return 1;
}
}
} while (s < e && mbgetchar(s));
mp->current.groups = oldg;
return 0;
}
else if (pc == '*')
{
/*
* several stars are the same as one
*/
while (*p == '*' && *(p + 1) != '(')
p++;
oldp = p;
switch (pc = mbgetchar(p))
{
case '@':
case '!':
case '+':
n = *p == '(';
break;
case '(':
case '[':
case '?':
case '*':
n = 1;
break;
case 0:
case '|':
case '&':
case ')':
mp->current.next_s = (flags & STR_MAXIMAL) ? e : olds;
mp->next_p = oldp;
mp->current.groups = g;
if (!pc && (!mp->best.next_s || (flags & STR_MAXIMAL) && mp->current.next_s > mp->best.next_s || !(flags & STR_MAXIMAL) && mp->current.next_s < mp->best.next_s))
mp->best = mp->current;
return 1;
case '\\':
if (!(pc = mbgetchar(p)))
return 0;
if (pc >= '0' && pc <= '9')
{
n = pc - '0';
if (n <= g && mp->current.beg[n])
pc = *mp->current.beg[n];
}
/*FALLTHROUGH*/
default:
if (icase && isupper(pc))
pc = tolower(pc);
n = 0;
break;
}
p = oldp;
for (;;)
{
if ((n || pc == sc) && onematch(mp, g, olds, p, e, NiL, flags))
return 1;
if (!sc)
return 0;
olds = s;
sc = getsource(s, e);
if ((flags & STR_ICASE) && isupper(sc))
sc = tolower(sc);
}
}
else if (pc != '?' && pc != sc)
return 0;
break;
case 0:
if (!(flags & STR_MAXIMAL))
sc = 0;
/*FALLTHROUGH*/
case '|':
case '&':
case ')':
if (!sc)
{
mp->current.next_s = olds;
mp->next_p = oldp;
mp->current.groups = g;
}
if (!pc && (!mp->best.next_s || (flags & STR_MAXIMAL) && olds > mp->best.next_s || !(flags & STR_MAXIMAL) && olds < mp->best.next_s))
{
mp->best = mp->current;
mp->best.next_s = olds;
mp->best.groups = g;
}
return !sc;
case '[':
{
/*UNDENT...*/
int invert;
int x;
int ok = 0;
char* range;
if (!sc)
return 0;
range = 0;
n = 0;
if (invert = *p == '!')
p++;
for (;;)
{
oldp = p;
if (!(pc = mbgetchar(p)))
return 0;
else if (pc == '[' && (*p == ':' || *p == '=' || *p == '.'))
{
x = 0;
n = mbgetchar(p);
oldp = p;
for (;;)
{
if (!(pc = mbgetchar(p)))
return 0;
if (pc == n && *p == ']')
break;
x++;
}
mbgetchar(p);
if (ok)
/*NOP*/;
else if (n == ':')
{
switch (HASHNKEY5(x, oldp[0], oldp[1], oldp[2], oldp[3], oldp[4]))
{
case HASHNKEY5(5,'a','l','n','u','m'):
if (isalnum(sc))
ok = 1;
break;
case HASHNKEY5(5,'a','l','p','h','a'):
if (isalpha(sc))
ok = 1;
break;
case HASHNKEY5(5,'b','l','a','n','k'):
if (isblank(sc))
ok = 1;
break;
case HASHNKEY5(5,'c','n','t','r','l'):
if (iscntrl(sc))
ok = 1;
break;
case HASHNKEY5(5,'d','i','g','i','t'):
if (isdigit(sc))
ok = 1;
break;
case HASHNKEY5(5,'g','r','a','p','h'):
if (isgraph(sc))
ok = 1;
break;
case HASHNKEY5(5,'l','o','w','e','r'):
if (islower(sc))
ok = 1;
break;
case HASHNKEY5(5,'p','r','i','n','t'):
if (isprint(sc))
ok = 1;
break;
case HASHNKEY5(5,'p','u','n','c','t'):
if (ispunct(sc))
ok = 1;
break;
case HASHNKEY5(5,'s','p','a','c','e'):
if (isspace(sc))
ok = 1;
break;
case HASHNKEY5(5,'u','p','p','e','r'):
if (icase ? islower(sc) : isupper(sc))
ok = 1;
break;
case HASHNKEY5(6,'x','d','i','g','i'):
if (oldp[5] == 't' && isxdigit(sc))
ok = 1;
break;
}
}
else if (range)
goto getrange;
else if (*p == '-' && *(p + 1) != ']')
{
mbgetchar(p);
range = oldp;
}
else if (isalpha(*oldp) && isalpha(*olds) && tolower(*oldp) == tolower(*olds) || sc == mbgetchar(oldp))
ok = 1;
n = 1;
}
else if (pc == ']' && n)
{
if (ok != invert)
break;
return 0;
}
else if (pc == '\\' && (oldp = p, !(pc = mbgetchar(p))))
return 0;
else if (ok)
/*NOP*/;
else if (range)
{
getrange:
if (icase && isupper(pc))
pc = tolower(pc);
x = mbgetchar(range);
if (icase && isupper(x))
x = tolower(x);
if (sc == x || sc == pc || sc > x && sc < pc)
ok = 1;
if (*p == '-' && *(p + 1) != ']')
{
mbgetchar(p);
range = oldp;
}
else
range = 0;
n = 1;
}
else if (*p == '-' && *(p + 1) != ']')
{
mbgetchar(p);
range = oldp;
n = 1;
}
else
{
if (icase && isupper(pc))
pc = tolower(pc);
if (sc == pc)
ok = 1;
n = pc;
}
}
/*...INDENT*/
}
break;
case '\\':
if (!(pc = mbgetchar(p)))
return 0;
if (pc >= '0' && pc <= '9')
{
n = pc - '0';
if (n <= g && (oldp = mp->current.beg[n]))
{
while (oldp < mp->current.end[n])
if (!*olds || *olds++ != *oldp++)
return 0;
s = olds;
break;
}
}
/*FALLTHROUGH*/
default:
if (icase && isupper(pc))
pc = tolower(pc);
if (pc != sc)
return 0;
break;
}
} while (sc);
return 0;
}
int find_includes(struct filepointer *filep, struct inclist *file, struct inclist *file_red, int recursion, boolean failOK, struct IncludesCollection* incCollection, struct symhash *symbols)
{
char *line;
int type;
boolean recfailOK;
while ((line = get_line(filep))) {
switch(type = deftype(line, filep, file_red, file, TRUE, symbols)) {
case IF:
doif:
type = find_includes(filep, file,
file_red, recursion+1, failOK, incCollection, symbols);
while ((type == ELIF) || (type == ELIFFALSE) ||
(type == ELIFGUESSFALSE))
type = gobble(filep, file, file_red, symbols);
if (type == ELSE)
gobble(filep, file, file_red, symbols);
break;
case IFFALSE:
case IFGUESSFALSE:
doiffalse:
if (type == IFGUESSFALSE || type == ELIFGUESSFALSE)
recfailOK = TRUE;
else
recfailOK = failOK;
type = gobble(filep, file, file_red, symbols);
if (type == ELSE)
find_includes(filep, file,
file_red, recursion+1, recfailOK, incCollection, symbols);
else if (type == ELIF)
goto doif;
else if ((type == ELIFFALSE) || (type == ELIFGUESSFALSE))
goto doiffalse;
break;
case IFDEF:
case IFNDEF:
if ((type == IFDEF && hash_lookup(line, symbols))
|| (type == IFNDEF && !hash_lookup(line, symbols))) {
debug(1,(type == IFNDEF ?
"line %d: %s !def'd in %s via %s%s\n" : "",
filep->f_line, line,
file->i_file, file_red->i_file, ": doit"));
type = find_includes(filep, file,
file_red, recursion+1, failOK, incCollection, symbols);
while (type == ELIF || type == ELIFFALSE || type == ELIFGUESSFALSE)
type = gobble(filep, file, file_red, symbols);
if (type == ELSE)
gobble(filep, file, file_red, symbols);
}
else {
debug(1,(type == IFDEF ?
"line %d: %s !def'd in %s via %s%s\n" : "",
filep->f_line, line,
file->i_file, file_red->i_file, ": gobble"));
type = gobble(filep, file, file_red, symbols);
if (type == ELSE)
find_includes(filep, file,
file_red, recursion + 1, failOK, incCollection, symbols);
else if (type == ELIF)
goto doif;
else if (type == ELIFFALSE || type == ELIFGUESSFALSE)
goto doiffalse;
}
break;
case ELSE:
case ELIFFALSE:
case ELIFGUESSFALSE:
case ELIF:
if (!recursion)
gobble(filep, file, file_red, symbols);
/*fall-through*/
case ENDIF:
if (recursion)
return type;
/*fall-through*/
case DEFINE:
define(line, &symbols);
break;
case UNDEF:
if (!*line) {
warning("%s, line %d: incomplete undef == \"%s\"\n",
file_red->i_file, filep->f_line, line);
break;
}
hash_undefine(line, symbols);
break;
case INCLUDE:
add_include(filep, file, file_red, line, FALSE, failOK, incCollection, symbols);
break;
case INCLUDEDOT:
add_include(filep, file, file_red, line, TRUE, failOK, incCollection, symbols);
break;
case ERROR:
warning("%s: %d: %s\n", file_red->i_file,
filep->f_line, line);
break;
case PRAGMA:
case IDENT:
case SCCS:
case EJECT:
break;
case -1:
warning("%s", file_red->i_file);
if (file_red != file)
warning1(" (reading %s)", file->i_file);
warning1(", line %d: unknown directive == \"%s\"\n",
filep->f_line, line);
break;
case -2:
warning("%s", file_red->i_file);
if (file_red != file)
warning1(" (reading %s)", file->i_file);
warning1(", line %d: incomplete include == \"%s\"\n",
filep->f_line, line);
break;
}
}
return -1;
}
//Skip comments, convert characters into their int codes, or if and int is found, return the code for integer etc
int
getlex()
{
int c;
char *p;
while( 0 <= (c = next()) && c <= ' ') /* consider all control chars as whitespace */
;
if (c == -1 || instr("()[]{},;", c)) {
return c;
}
if (c == '/') {
if (thechar == '*') {
/* next(); dropping this is wrong */
while(next() != '*' || thechar != '/')
;
next();
return getlex();
} else
return T_DIV;
}
if (c == '*') return T_MUL;
if (c == '%') return T_MOD;
if (c == '-')
return gobble(c,T_POSTDEC,T_SUB);
if (c == '>')
return gobble('=',T_GE,T_GT);
if (c == '<')
return gobble('=',T_LE,T_LT);
if (c == '=')
return gobble(c,T_EQ,T_ASSIGN);
if (c == '+')
return gobble(c,T_POSTINC,T_ADD);
if (c == '!')
return gobble('=',T_NE,T_NOT);
if (c == '&')
return gobble(c,T_ANDAND,T_AND);
if (c == '|')
return gobble(c,T_OROR,T_OR);
if (c == '\'') {
getstring(c);
lexval = symbol[0];
return T_CONST;
}
if (c == '"') {
getstring(c);
return T_STRING;
}
if (digit(c)) {
lexval = c - '0';
while(digit(thechar)) {
lexval = lexval * 10 + next() - '0';
}
return T_CONST;
}
if (letter(c)) {
p = symbol;
*p++ = c;
while(letter(thechar))
*p++ = next();
*p = 0;
if ( (lexval = lookup(symbol)) < RES) {
if (lexval == I_CHAR)
return T_INT;
return lexval + RESBASE;
}
return T_NAME;
}
error("Bad input");
}
int find_includes (struct filepointer *filep, struct inclist *file,
struct inclist *file_red, int recursion, bool failOK)
{
register char *line;
register int type;
bool recfailOK;
while ((line = getline (filep)))
{
switch (type = deftype (line, filep, file_red, file, true))
{
case IF:
doif:
type = find_includes (filep, file,
file_red, recursion + 1, failOK);
while ((type == ELIF) || (type == ELIFFALSE) ||
(type == ELIFGUESSFALSE))
type = gobble (filep, file, file_red);
if (type == ELSE)
gobble (filep, file, file_red);
break;
case IFFALSE:
case IFGUESSFALSE:
doiffalse:
if (type == IFGUESSFALSE || type == ELIFGUESSFALSE)
recfailOK = true;
else
recfailOK = failOK;
type = gobble (filep, file, file_red);
if (type == ELSE)
find_includes (filep, file,
file_red, recursion + 1, recfailOK);
else if (type == ELIF)
goto doif;
else if ((type == ELIFFALSE) || (type == ELIFGUESSFALSE))
goto doiffalse;
break;
case IFDEF:
case IFNDEF:
if ((type == IFDEF && isdefined (line, file_red, NULL))
|| (type == IFNDEF && !isdefined (line, file_red, NULL)))
{
debug (1, (type == IFNDEF ?
"line %d: %s !def'd in %s via %s%s\n" : "",
filep->f_line, line,
file->i_file, file_red->i_file, ": doit"));
type = find_includes (filep, file,
file_red, recursion + 1, failOK);
while (type == ELIF || type == ELIFFALSE || type == ELIFGUESSFALSE)
type = gobble (filep, file, file_red);
if (type == ELSE)
gobble (filep, file, file_red);
}
else
{
debug (1, (type == IFDEF ?
"line %d: %s !def'd in %s via %s%s\n" : "",
filep->f_line, line,
file->i_file, file_red->i_file, ": gobble"));
type = gobble (filep, file, file_red);
if (type == ELSE)
find_includes (filep, file,
file_red, recursion + 1, failOK);
else if (type == ELIF)
goto doif;
else if (type == ELIFFALSE || type == ELIFGUESSFALSE)
goto doiffalse;
}
break;
case ELSE:
case ELIFFALSE:
case ELIFGUESSFALSE:
case ELIF:
if (!recursion)
gobble (filep, file, file_red);
case ENDIF:
if (recursion)
return (type);
case DEFINE:
define (line, file);
break;
case UNDEF:
if (!*line)
{
warning ("%s, line %d: incomplete undef == \"%s\"\n",
file->i_file, filep->f_line, line);
display_included (file_red, file);
break;
}
undefine (line, file_red);
break;
case INCLUDE:
add_include (filep, file, file_red, line, false, failOK);
break;
case INCLUDEDOT:
add_include (filep, file, file_red, line, true, failOK);
break;
case ERROR:
case WARNING:
warning ("%s: %d: %s\n", file->i_file, filep->f_line, line);
display_included (file_red, file);
break;
case PRAGMA:
case IDENT:
case SCCS:
case EJECT:
break;
case -1:
warning ("%s", file_red->i_file);
if (file_red != file)
warning1 (" (reading %s)", file->i_file);
warning1 (", line %d: unknown directive == \"%s\"\n",
filep->f_line, line);
break;
case -2:
warning ("%s", file_red->i_file);
if (file_red != file)
warning1 (" (reading %s)", file->i_file);
warning1 (", line %d: incomplete include == \"%s\"\n",
filep->f_line, line);
break;
}
}
file->i_flags |= FINISHED;
return (-1);
}
int
ven_dialer(char *num, char *acu)
{
char *cp;
int connected = 0;
char *msg, line[80];
struct termios cntrl;
/*
* Get in synch with a couple of carriage returns
*/
if (!vensync(FD)) {
printf("can't synchronize with ventel\n");
#ifdef ACULOG
logent(value(HOST), num, "ventel", "can't synch up");
#endif
return (0);
}
if (boolean(value(VERBOSE)))
printf("\ndialing...");
fflush(stdout);
tcgetattr(FD, &cntrl);
cntrl.c_cflag |= HUPCL;
tcsetattr(FD, TCSANOW, &cntrl);
echo("#k$\r$\n$D$I$A$L$:$ ");
for (cp = num; *cp; cp++) {
delay(1, 10);
write(FD, cp, 1);
}
delay(1, 10);
write(FD, "\r", 1);
gobble('\n', line);
if (gobble('\n', line))
connected = gobble('!', line);
tcflush(FD, TCIOFLUSH);
#ifdef ACULOG
if (dialtimeout) {
(void)snprintf(line, sizeof line, "%ld second dial timeout",
number(value(DIALTIMEOUT)));
logent(value(HOST), num, "ventel", line);
}
#endif
if (dialtimeout)
ven_disconnect(); /* insurance */
if (connected || dialtimeout || !boolean(value(VERBOSE)))
return (connected);
/* call failed, parse response for user */
cp = strchr(line, '\r');
if (cp)
*cp = '\0';
for (cp = line; (cp = strchr(cp, ' ')) != NULL; cp++)
if (cp[1] == ' ')
break;
if (cp) {
while (*cp == ' ')
cp++;
msg = cp;
while (*cp) {
if (isupper(*cp))
*cp = tolower(*cp);
cp++;
}
printf("%s...", msg);
}
return (connected);
}
int
find_includes(struct filepointer *filep, struct inclist *file,
struct inclist *file_red, int recursion, boolean failOK)
{
struct inclist *inclistp;
char **includedirsp;
register char *line;
register int type;
boolean recfailOK;
while ((line = getnextline(filep))) {
switch(type = deftype(line, filep, file_red, file, TRUE)) {
case IF:
doif:
type = find_includes(filep, file,
file_red, recursion+1, failOK);
while ((type == ELIF) || (type == ELIFFALSE) ||
(type == ELIFGUESSFALSE))
type = gobble(filep, file, file_red);
if (type == ELSE)
gobble(filep, file, file_red);
break;
case IFFALSE:
case IFGUESSFALSE:
doiffalse:
if (type == IFGUESSFALSE || type == ELIFGUESSFALSE)
recfailOK = TRUE;
else
recfailOK = failOK;
type = gobble(filep, file, file_red);
if (type == ELSE)
find_includes(filep, file,
file_red, recursion+1, recfailOK);
else
if (type == ELIF)
goto doif;
else
if ((type == ELIFFALSE) || (type == ELIFGUESSFALSE))
goto doiffalse;
break;
case IFDEF:
case IFNDEF:
{
int isdef = (isdefined(line, file_red, NULL) != NULL);
if (type == IFNDEF) isdef = !isdef;
if (isdef) {
debug(1,(type == IFNDEF ?
"line %d: %s !def'd in %s via %s%s\n" : "",
filep->f_line, line,
file->i_file, file_red->i_file, ": doit"));
type = find_includes(filep, file,
file_red, recursion+1, failOK);
while (type == ELIF || type == ELIFFALSE || type == ELIFGUESSFALSE)
type = gobble(filep, file, file_red);
if (type == ELSE)
gobble(filep, file, file_red);
}
else {
debug(1,(type == IFDEF ?
"line %d: %s !def'd in %s via %s%s\n" : "",
filep->f_line, line,
file->i_file, file_red->i_file, ": gobble"));
type = gobble(filep, file, file_red);
if (type == ELSE)
find_includes(filep, file,
file_red, recursion+1, failOK);
else if (type == ELIF)
goto doif;
else if (type == ELIFFALSE || type == ELIFGUESSFALSE)
goto doiffalse;
}
}
break;
case ELSE:
case ELIFFALSE:
case ELIFGUESSFALSE:
case ELIF:
if (!recursion)
gobble(filep, file, file_red);
case ENDIF:
if (recursion)
return(type);
case DEFINE:
define(line, file);
break;
case UNDEF:
if (!*line) {
warning("%s", file_red->i_file);
if (file_red != file)
warning1(" (reading %s)", file->i_file);
warning1(", line %d: incomplete undef == \"%s\"\n",
filep->f_line, line);
break;
}
undefine(line, file_red);
break;
case INCLUDE:
case INCLUDEDOT:
case INCLUDENEXT:
case INCLUDENEXTDOT:
inclistp = inclistnext;
includedirsp = includedirsnext;
debug(2,("%s, reading %s, includes %s\n",
file_red->i_file, file->i_file, line));
add_include(filep, file, file_red, line, type, failOK);
inclistnext = inclistp;
includedirsnext = includedirsp;
break;
case ERROR:
case WARNING:
warning("%s", file_red->i_file);
if (file_red != file)
warning1(" (reading %s)", file->i_file);
warning1(", line %d: %s\n",
filep->f_line, line);
break;
case PRAGMA:
case IDENT:
case SCCS:
case EJECT:
break;
case -1:
warning("%s", file_red->i_file);
if (file_red != file)
warning1(" (reading %s)", file->i_file);
warning1(", line %d: unknown directive == \"%s\"\n",
filep->f_line, line);
break;
case -2:
warning("%s", file_red->i_file);
if (file_red != file)
warning1(" (reading %s)", file->i_file);
warning1(", line %d: incomplete include == \"%s\"\n",
filep->f_line, line);
break;
}
}
file->i_flags |= FINISHED;
debug(2,("finished with %s\n", file->i_file));
return(-1);
}
int
ven_dialer(char *num, char *acu)
{
char *cp;
int connected = 0;
char *msg, line[80];
/*
* Get in synch with a couple of carriage returns
*/
if (!vensync(FD)) {
printf("can't synchronize with ventel\n");
#if ACULOG
logent(value(HOST), num, "ventel", "can't synch up");
#endif
return (0);
}
if (boolean(value(VERBOSE)))
printf("\ndialing...");
fflush(stdout);
acu_hupcl ();
echo("#k$\r$\n$D$I$A$L$:$ ");
for (cp = num; *cp; cp++) {
delay(1, 10);
write(FD, cp, 1);
}
delay(1, 10);
write(FD, "\r", 1);
gobble('\n', line);
if (gobble('\n', line))
connected = gobble('!', line);
acu_flush ();
#if ACULOG
if (timeout) {
sprintf(line, "%d second dial timeout",
number(value(DIALTIMEOUT)));
logent(value(HOST), num, "ventel", line);
}
#endif
if (timeout)
ven_disconnect(); /* insurance */
if (connected || timeout || !boolean(value(VERBOSE)))
return (connected);
/* call failed, parse response for user */
cp = index(line, '\r');
if (cp)
*cp = '\0';
for (cp = line; (cp = index(cp, ' ')); cp++)
if (cp[1] == ' ')
break;
if (cp) {
while (*cp == ' ')
cp++;
msg = cp;
while (*cp) {
if (isupper(*cp))
*cp = tolower(*cp);
cp++;
}
printf("%s...", msg);
}
return (connected);
}
/* Conditional Move */
NOMIPS16 v2sf cond_move1 (v2sf a, v2sf b, int i)
{
if (i == 0)
a = b;
gobble (a);
}
short Scanner::getToken( YYSTYPE & lval )
//---------------------------------------
// get the next token from the input stream.
// at each call, the next character should be
// in _current.
{
const int MaxBufLen = 512;
char buffer[ MaxBufLen ];
int bufPos; // position in buffer
char special;
gobble();
if( isEOF() ) {
return 0;
}
if( isSpecial() ) {
special = (char) _current;
get(); // set up for next call
return special; // <-------- early return
}
if( isQuote() ) {
readQuotedString( lval );
return T_String; // <-------- early return
}
if( _current == '0' ) {
get();
if( toupper( _current ) == 'X' ) {
readHex( lval );
} else {
if( isDigit() ) {
readDecimal( lval );
} else {
lval = 0;
}
}
return T_Number; // <-------- early return
}
if( isDigit() ) {
readDecimal( lval );
return T_Number; // <-------- early return
}
for( bufPos = 0; bufPos < MaxBufLen; bufPos += 1 ) {
buffer[ bufPos ] = (char) _current;
get();
if( isEOF() || isSpace() || isSpecial() ) break;
}
bufPos += 1;
assert( bufPos < MaxBufLen );
buffer[ bufPos ] = '\0';
return tokenValue( buffer, lval );
}
static int
yylex1(void)
{
register char *yyp;
register int c;
register int c1, c2;
for (;;)
{
if (lex_fatal)
{
return -1;
}
switch(c = mygetc())
{
case EOF:
if (inctop)
{
struct incstate *p;
p = inctop;
(void)fclose(yyin);
/*(void)fprintf(stderr, "popping to %s\n", p->file);*/
free(current_file);
nexpands = 0;
current_file = p->file;
current_line = p->line + 1;
current_incfile = p->incfnum;
pragma_strict_types = p->pragma_strict_types;
yyin = p->yyin;
slast = p->slast;
lastchar = p->lastchar;
inctop = p->next;
if (p->nbuf)
{
nbuf = p->nbuf;
outp = defbuf + DEFMAX - nbuf;
memcpy(outp, p->outp, nbuf);
free((char *)p->outp);
}
else
{
nbuf = 0;
outp = defbuf + DEFMAX;
}
store_line_number_info(current_incfile, current_line);
incdepth--;
free((char *)p);
break;
}
if (iftop)
{
struct ifstate *p = iftop;
lexerror(p->state == EXPECT_ENDIF ? "Missing #endif" : "Missing #else");
while (iftop)
{
p = iftop;
iftop = p->next;
free((char *)p);
}
}
return -1;
case '\n':
{
nexpands=0;
store_line_number_info(current_incfile, current_line);
current_line++;
total_lines++;
}
/* FALLTHROUGH */
case ' ':
case '\t':
case '\f':
case '\v':
break;
case '+':
TRY('+', F_INC);
TRY('=', F_ADD_EQ);
return c;
case '-':
TRY('>', F_ARROW);
TRY('-', F_DEC);
TRY('=', F_SUB_EQ);
return c;
case '&':
TRY('&', F_LAND);
TRY('=', F_AND_EQ);
return c;
case '|':
TRY('|', F_LOR);
TRY('=', F_OR_EQ);
return c;
case '^':
TRY('=', F_XOR_EQ);
return c;
case '<':
if (gobble('<')) {
TRY('=', F_LSH_EQ);
return F_LSH;
}
TRY('=', F_LE);
return c;
case '>':
if (gobble('>'))
{
TRY('=', F_RSH_EQ);
return F_RSH;
}
TRY('=', F_GE);
return c;
case '*':
TRY('=', F_MULT_EQ);
return c;
case '%':
TRY('=', F_MOD_EQ);
return F_MOD;
case '/':
if (gobble('*'))
{
skip_comment();
break;
}
else if (gobble('/'))
{
skip_comment2();
break;
}
TRY('=', F_DIV_EQ);
return c;
case '=':
TRY('=', F_EQ);
return c;
case ';':
case '(':
case ')':
case ',':
case '{':
case '}':
case '~':
case '[':
case ']':
case '?':
case '@':
return c;
case '!':
TRY('=', F_NE);
return F_NOT;
case ':':
TRY(':', F_COLON_COLON);
return ':';
case '.':
if (gobble('.'))
{
if (gobble('.'))
return F_VARARG;
else
return F_RANGE;
}
return c;
case '#':
if (lastchar == '\n')
{
char *ssp = 0;
int quote;
yyp = yytext;
do
{
c = mygetc();
} while (isspace(c));
for (quote = 0;;)
{
if (c == '"')
quote ^= 1;
/*gc - handle comments cpp-like! 1.6.91 @@@*/
while (!quote && c == '/')
{
if (gobble('*'))
{
skip_comment();
c = mygetc();
}
else
break;
}
if (!ssp && isspace(c))
ssp = yyp;
if (c == '\n' || c == EOF)
break;
SAVEC;
c = mygetc();
}
if (ssp)
{
*ssp++ = 0;
while (isspace(*ssp))
ssp++;
}
else
{
ssp = yyp;
}
*yyp = 0;
if (strcmp("define", yytext) == 0)
{
handle_define(ssp);
}
else if (strcmp("if", yytext) == 0)
{
#if 0
short int nega=0; /*@@@ allow #if !VAR gc 1.6.91*/
if (*ssp=='!'){ ssp++; nega=1;}
if (isdigit(*ssp))
{
char *p;
long l;
l = strtol(ssp, &p, 10);
while (isspace(*p))
p++;
if (*p)
lexerror("Condition too complex in #if");
else
handle_cond(nega ? !(int)l : (int)l);
}
else if (isalunum(*ssp))
{
char *p = ssp;
while (isalunum(*p))
p++;
if (*p)
{
*p++ = 0;
while (isspace(*p))
p++;
}
if (*p)
lexerror("Condition too complex in #if");
else
{
struct defn *d;
d = lookup_define(ssp);
if (d)
{
handle_cond(nega ? !atoi(d->exps) : atoi(d->exps));/* a hack! */
}
else
{
handle_cond(nega?1:0); /* cpp-like gc*/
}
}
}
else
lexerror("Condition too complex in #if");
#else
int cond;
myungetc(0);
add_input(ssp);
cond = cond_get_exp(0);
if (mygetc())
{
lexerror("Condition too complex in #if");
while (mygetc())
;
}
else
handle_cond(cond);
#endif
}
else if (strcmp("ifdef", yytext) == 0)
{
deltrail(ssp);
handle_cond(lookup_define(ssp) != 0);
}
else if (strcmp("ifndef", yytext) == 0)
{
deltrail(ssp);
handle_cond(lookup_define(ssp) == 0);
}
else if (strcmp("else", yytext) == 0)
{
if (iftop && iftop->state == EXPECT_ELSE)
{
struct ifstate *p = iftop;
/*(void)fprintf(stderr, "found else\n");*/
iftop = p->next;
free((char *)p);
(void)skip_to("endif", (char *)0);
store_line_number_info(current_incfile, current_line);
current_line++;
total_lines++;
}
else
{
lexerror("Unexpected #else");
}
}
else if (strcmp("endif", yytext) == 0)
{
if (iftop && (iftop->state == EXPECT_ENDIF ||
iftop->state == EXPECT_ELSE))
{
struct ifstate *p = iftop;
/*(void)fprintf(stderr, "found endif\n");*/
iftop = p->next;
free((char *)p);
}
else
{
lexerror("Unexpected #endif");
}
}
else if (strcmp("undef", yytext) == 0)
{
struct defn *d;
deltrail(ssp);
if ((d = lookup_define(ssp)) != NULL )
d->undef++;
}
else if (strcmp("echo", yytext) == 0)
{
(void)fprintf(stderr, "%s\n", ssp);
}
else if (strcmp("include", yytext) == 0)
{
/*(void)fprintf(stderr, "including %s\n", ssp); */
handle_include(ssp, 0);
}
else if (strcmp("pragma", yytext) == 0)
{
deltrail(ssp);
handle_pragma(ssp);
}
else if (strcmp("error", yytext) == 0)
{
handle_exception(ERROR, ssp);
}
else if (strcmp("warning", yytext) == 0)
{
handle_exception(WARNING, ssp);
}
else
{
lexerror("Unrecognised # directive");
}
myungetc('\n');
break;
}
else
goto badlex;
case '\'':
yylval.number = mygetc();
if (yylval.number == '\\')
{
int tmp = mygetc();
switch (tmp)
{
case 'n': yylval.number = '\n'; break;
case 't': yylval.number = '\t'; break;
case 'b': yylval.number = '\b'; break;
case 'a': yylval.number = '\a'; break;
case 'v': yylval.number = '\v'; break;
case '\'':
case '\\':
case '"':
yylval.number = tmp; break;
default:
lexwarning("Bad character escape sequence");
yylval.number = tmp;
break;
}
}
if (!gobble('\''))
lexerror("Illegal character constant");
return F_NUMBER;
case '"':
yyp = yytext;
*yyp++ = c;
for (;;)
{
c = mygetc();
if (c == EOF)
{
lexerror("End of file in string");
return string("\"\"");
}
else if (c == '\n')
{
lexerror("Newline in string");
return string("\"\"");
}
SAVEC;
if (c == '"')
break;
if (c == '\\')
{
c = mygetc();
if ( c == '\n' )
{
yyp--;
store_line_number_info(current_incfile, current_line);
current_line++;
total_lines++;
}
else if ( c == EOF )
{
/* some operating systems give EOF only once */
myungetc(c);
}
else
*yyp++ = c;
}
}
*yyp = 0;
return string(yytext);
case '0':
c = mygetc();
if ( c == 'X' || c == 'x' || c == 'o')
{
char *endptr;
long long value;
int base = 16;
if (c == 'o')
base = 8;
yyp = yytext;
for (;;)
{
c = mygetc();
if (!isxdigit(c))
break;
SAVEC;
}
myungetc(c);
*yyp = '\0';
value = strtoll(yytext, &endptr, base);
if (*endptr != '\0')
{
fprintf(stderr, "%s\n", yytext);
lexwarning("Invalid digits in octal number number");
}
return number(value);
}
myungetc(c);
c = '0';
/* FALLTHROUGH */
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
yyp = yytext;
*yyp++ = c;
for (;;)
{
c = mygetc();
if (!isdigit(c))
break;
SAVEC;
}
if (c == '.')
{
if (isdigit(c1 = mygetc()))
{
SAVEC;
c = c1;
SAVEC;
for (c = mygetc(); isdigit(c); c = mygetc())
SAVEC;
if (c == 'e' || c == 'E')
{
c1 = mygetc();
if (c1 == '-' || c1 == '+')
{
c2 = mygetc();
if (isdigit(c2))
{
SAVEC;
c = c1;
SAVEC;
c = c2;
SAVEC;
for (c = mygetc(); isdigit(c); c = mygetc())
SAVEC;
}
else
{
myungetc(c2);
myungetc(c1);
}
}
else if (isdigit(c1))
{
SAVEC;
c = c1;
SAVEC;
for (c = mygetc(); isdigit(c); c = mygetc())
SAVEC;
}
else
myungetc(c1);
}
myungetc(c);
*yyp = 0;
return real(strtod(yytext, NULL));
}
myungetc(c1);
}
myungetc(c);
*yyp = 0;
if (*yytext == '0')
{
/* OCTALS */
char *endptr;
long long value;
value = strtoll(yytext, &endptr, 010);
if (*endptr != '\0')
lexwarning("Invalid digits in octal number");
if (value != 0)
lexwarning("Obsolete octal format used. Use 0o111 syntax");
return number(value);
}
return number(atoll(yytext));
default:
if (isalpha(c) || c == '_') {
int r;
yyp = yytext;
*yyp++ = c;
for (;;)
{
c = mygetc();
if (!isalunum(c))
break;
SAVEC;
}
*yyp = 0;
myungetc(c);
if (!expand_define())
{
r = lookup_resword(yytext);
if (r >= 0)
{
return r;
}
else
return ident(yytext);
}
break;
}
goto badlex;
}
}
badlex:
{
lexerror("Illegal character (hex %02x) '%c'", c, c);
return ' ';
}
}