Minix1.5/commands/bawk/bawksym.c
/*
* Bawk C actions builtin functions, variable declaration, and
* stack management routines.
*/
#include <ctype.h>
#include <stdio.h>
#include "bawk.h"
#define MAXARGS 10 /* max # of arguments to a builtin func */
#define F_PRINT 1
#define F_PRINTF 2
#define F_GETLINE 3
#define F_STRLEN 4
#define F_STRCPY 5
#define F_STRCMP 6
#define F_TOUPPER 7
#define F_TOLOWER 8
#define F_MATCH 9
#define F_NEXTFILE 10
isfunction( s )
char *s;
{
/*
* Compare the string "s" to a list of builtin functions
* and return its (non-zero) token number.
* Return zero if "s" is not a function.
*/
if ( !strcmp(s, "print") )
return F_PRINT;
if ( !strcmp( s, "printf" ) )
return F_PRINTF;
if ( !strcmp( s, "getline" ) )
return F_GETLINE;
if ( !strcmp( s, "strlen" ) )
return F_STRLEN;
if ( !strcmp( s, "strcpy" ) )
return F_STRCPY;
if ( !strcmp( s, "strcmp" ) )
return F_STRCMP;
if ( !strcmp( s, "toupper" ) )
return F_TOUPPER;
if ( !strcmp( s, "tolower" ) )
return F_TOLOWER;
if ( !strcmp( s, "match" ) )
return F_MATCH;
if ( !strcmp( s, "nextfile" ) )
return F_NEXTFILE;
return 0;
}
iskeyword( s )
char *s;
{
/*
* Compare the string "s" to a list of keywords and return its
* (non-zero) token number. Return zero if "s" is not a keyword.
*/
if ( !strcmp( s, "char" ) )
return T_CHAR;
if ( !strcmp( s, "int" ) )
return T_INT;
if ( !strcmp( s, "if" ) )
return T_IF;
if ( !strcmp( s, "else" ) )
return T_ELSE;
if ( !strcmp( s, "while" ) )
return T_WHILE;
if ( !strcmp( s, "break" ) )
return T_BREAK;
if ( !strcmp( s, "NF" ) )
return T_NF;
if ( !strcmp( s, "NR" ) )
return T_NR;
if ( !strcmp( s, "FS" ) )
return T_FS;
if ( !strcmp( s, "RS" ) )
return T_RS;
if ( !strcmp( s, "FILENAME" ) )
return T_FILENAME;
if ( !strcmp( s, "BEGIN" ) )
return T_BEGIN;
if ( !strcmp( s, "END" ) )
return T_END;
return 0;
}
function( funcnum )
{
int argc, j;
char lpar;
DATUM args[ MAXARGS ];
argc = 0;
if ( Token==T_LPAREN )
{
lpar = 1;
getoken();
}
else
lpar = 0;
/*
* If there are any arguments, evaluate them and copy their values
* to a local array. Clear the array first.
*/
for (j = 0; j < MAXARGS; j++) args[j].ival = 0;
if ( Token!=T_RPAREN && Token!=T_EOF )
{
for ( ;; )
{
expression();
if ( argc<MAXARGS )
args[ argc++ ].ival = popint();
else
popint();
if ( Token==T_COMMA )
getoken();
else
break;
}
}
if ( lpar )
{
if ( Token!=T_RPAREN )
error( "missing ')'", ACT_ERROR );
else
getoken();
}
switch ( funcnum )
{
case F_PRINT: /* quick and simple string printing */
pushint( (INT)pprint( args ) );
break;
case F_PRINTF: /* just like the real printf() function */
pushint( (INT)pprntf( args[0].dptr, &args[1] ) );
break;
case F_GETLINE:
/*
* Get the next line of input from the current input file
* and parse according to the current field seperator.
* Don't forget to free up the previous line's words first...
*/
while ( Fieldcount )
free( Fields[ --Fieldcount ] );
pushint( (INT)getline() );
Fieldcount = parse( Linebuf, Fields, Fieldsep );
break;
case F_STRLEN: /* calculate length of string argument */
pushint( (INT)strlen( args[0].dptr ) );
break;
case F_STRCPY: /* copy second string argument to first string */
pushint( (INT)strcpy( args[0].dptr, args[1].dptr ) );
break;
case F_STRCMP: /* compare two strings */
pushint( (INT)strcmp( args[0].dptr, args[1].dptr ) );
break;
case F_TOUPPER: /* convert the character argument to upper case */
pushint( (INT)toupper( args[0].ival ) );
break;
case F_TOLOWER: /* convert the character argument to lower case */
pushint( (INT)tolower( args[0].ival ) );
break;
case F_MATCH: /* match a string argument to a regular expression */
pushint( (INT)match( args[0].dptr, args[1].dptr ) );
break;
case F_NEXTFILE:/* close current input file and process next file */
pushint( (INT)endfile() );
break;
default: /* oops! */
error( "bad function call", ACT_ERROR );
}
}
VARIABLE *
findvar( s )
char *s;
{
/*
* Search the symbol table for a variable whose name is "s".
*/
VARIABLE *pvar;
int i;
char name[ MAXVARLEN ];
i = 0;
while ( i < MAXVARLEN && alphanum( *s ) )
name[i++] = *s++;
if ( i<MAXVARLEN )
name[i] = 0;
for ( pvar = Vartab; pvar<Nextvar; ++pvar )
{
if ( !strncmp( pvar->vname, name, MAXVARLEN ) )
return pvar;
}
return NULL;
}
VARIABLE *
addvar( name )
char *name;
{
/*
* Add a new variable to symbol table and assign it default
* attributes (int name;)
*/
int i;
if ( Nextvar <= Vartab + MAXVARTABSZ )
{
i = 0;
while ( i<MAXVARLEN && alphanum( *name ) )
Nextvar->vname[i++] = *name++;
if ( i<MAXVARLEN )
Nextvar->vname[i] = 0;
Nextvar->vclass = 0;
Nextvar->vsize = WORD;
Nextvar->vlen = 0;
/*
* Allocate some new room
*/
Nextvar->vptr = getmem((unsigned int) WORD );
fillmem( Nextvar->vptr, WORD, 0 );
}
else
error( "symbol table overflow", MEM_ERROR );
return Nextvar++;
}
declist()
{
/*
* Parse a "char" or "int" statement.
*/
char type;
type = Token;
getoken();
decl( type );
while ( Token==T_COMMA )
{
getoken();
decl( type );
}
if ( Token==T_SEMICOLON )
getoken();
}
VARIABLE *
decl( type )
{
/*
* Parse an element of a "char" or "int" declaration list.
* The function stmt_compile() has already entered the variable
* into the symbol table as an integer, this routine simply changes
* the symbol's class, size or length according to the declaraction.
* WARNING: The interpreter depends on the fact that pointers are
* the same length as int's. If your machine uses long's for
* pointers either change the code or #define int long (or whatever).
*/
char class, size;
int len;
unsigned oldsize, newsize;
VARIABLE *pvar;
if ( Token==T_MUL )
{
/*
* it's a pointer
*/
getoken();
pvar = decl( type );
++pvar->vclass;
}
else if ( Token==T_VARIABLE )
{
/*
* Simple variable so far. The token value (in the global
* "Value" variable) is a pointer to the variable's symbol
* table entry.
*/
pvar = (VARIABLE *)Value.dptr;
getoken();
class = 0;
/*
* Compute its length
*/
if ( Token==T_LBRACKET )
{
/*
* It's an array.
*/
getoken();
++class;
/*
* Compute the dimension
*/
expression();
if ( Token!=T_RBRACKET )
error( "missing ']'", ACT_ERROR );
getoken();
len = popint();
}
else
/*
* It's a simple variable - array length is zero.
*/
len = 0;
size = (type==T_CHAR) ? BYTE : WORD;
newsize = (len ? len : 1) * size;
oldsize = (pvar->vlen ? pvar->vlen : 1) * pvar->vsize;
if ( newsize != oldsize )
{
/*
* The amount of storage needed for the variable
* has changed - free up memory allocated initially
* and reallocate for new size.
*/
free( pvar->vptr );
pvar->vptr = getmem( newsize );
}
/*
* Now change the variable's attributes.
*/
pvar->vclass = class;
pvar->vsize = size;
pvar->vlen = len;
}
else
syntaxerror();
return pvar;
}
assignment()
{
/*
* Perform an assignment
*/
INT ival;
ival = popint();
/*
* make sure we've got an lvalue
*/
if ( Stackptr->lvalue )
{
if ( Stackptr->class )
movemem((char *) &ival, Stackptr->value.dptr, WORD );
else
movemem((char *) &ival, Stackptr->value.dptr, Stackptr->size);
pop();
pushint( ival );
}
else
error( "'=' needs an lvalue", ACT_ERROR );
}
INT pop()
{
/*
* Pop the stack and return the integer value
*/
if ( Stackptr >= Stackbtm )
return (Stackptr--)->value.ival;
return error( "stack underflow", ACT_ERROR );
}
push( pclass, plvalue, psize, pdatum )
char pclass, plvalue, psize;
DATUM *pdatum;
{
/*
* Push item parts onto the stack
*/
if ( ++Stackptr <= Stacktop )
{
Stackptr->lvalue = plvalue;
Stackptr->size = psize;
if ( !(Stackptr->class = pclass) && !plvalue )
Stackptr->value.ival = pdatum->ival;
else
Stackptr->value.dptr = pdatum->dptr;
}
else
error( "stack overflow", MEM_ERROR );
}
pushint( intvalue )
INT intvalue;
{
/*
* push an integer onto the stack
*/
if ( ++Stackptr <= Stacktop )
{
Stackptr->lvalue =
Stackptr->class = 0;
Stackptr->size = WORD;
Stackptr->value.ival = intvalue;
}
else
error( "stack overflow", MEM_ERROR );
}
INT popint()
{
/*
* Resolve the item on the top of the stack and return it
*/
INT intvalue;
if ( Stackptr->lvalue )
{
/*
* if it's a byte indirect, sign extend it
*/
if ( Stackptr->size == BYTE && !Stackptr->class )
intvalue = *Stackptr->value.dptr;
else
{
/*
* otherwise, it's an unsigned int
*/
intvalue = *(int *)Stackptr->value.dptr;
}
pop();
return intvalue;
}
else
{
/*
* else it's an ACTUAL, just pop it
*/
return pop();
}
}
pprint( args )
DATUM args[];
{
/*
* execute the "print string, ..." command
*/
int i;
for ( i=0; i<MAXARGS; i++ )
if ( args[i].dptr != (char *)NULL )
printf(" %s", args[i].dptr);
printf("\n"); /* AWK's default behaviour */
return 0;
}
pprntf( fmt, args )
char *fmt;
DATUM args[];
{
/*
* execute the "printf fmt, data ..." command
*/
char lfmt[40], *t;
register char *s;
int i, type, lflg;
#define LINT 0
#define SINT 1
#define PNTR 2
s = fmt;
i = 0;
while ( *s != '\0' && i < MAXARGS-1 )
{
if ( *s != '%' )
{
putc( *s++, stdout );
continue;
}
t = lfmt;
*t++ = *s++; /* % */
if ( *s == '-' || *s == '+' )
*t++ = *s++; /* sign */
while ( *s >= '0' && *s <= '9' || *s == '*' )
*t++ = *s++; /* width */
if ( *s == '.' )
*t++ = *s++; /* . */
while ( *s >= '0' && *s <= '9' || *s == '*' )
*t++ = *s++; /* digits */
lflg = (*s == 'l' || *s == 'L');
if ( lflg )
*t++ = *s++ ;
if ( *s == 'd' || *s == 'D' || *s == 'u' || *s == 'U' ||
*s == 'x' || *s == 'X' || *s == 'o' || *s == 'O' )
{
type = lflg ? LINT : SINT;
*t++ = *s++;
}
else if ( *s == 'p' || *s == 'P' || *s == 's' || *s == 'S' )
{
type = PNTR;
*t++ = *s++;
}
else /* yuk. Better to forbid %e, %f and %g here ? */
{
type = SINT;
if (*s) *t++ = *s++;
}
*t++ = '\0';
switch ( type )
{
case LINT:
printf( lfmt, (long) args[i++].ival );
break;
case SINT:
printf( lfmt, (int) args[i++].ival );
break;
case PNTR:
printf( lfmt, args[i++].dptr );
break;
default:
/* impossible */
break;
}
}
return 0;
}