Брайан Керниган - UNIX — универсальная среда программирования

($1)[3] = (Inst)$7;

} /* end, if cond fails */

| '{' stmtlist '}' { $$ = $2; }

;

cond: '(' expr ')' { code(STOP); $$ = $2; }

;

while: WHILE { $$ = code3(whilecode,STOP,STOP); }

;

if: IF { $$ = code(ifcode); code3(STOP,STOP,STOP); }

;

begin: /* nothing */ { $$ = progp; }

;

end: /* nothing */ { code(STOP); $$ = progp; }

;

stmtlist: /* nothing */ { $$ = progp; }

| stmtlist '\n'

| stmtlist stmt

;

expr: NUMBER { $$ = code2(constpush, (Inst)$1); }

| VAR { $$ = code3(varpush, (Inst)$1, eval); }

| ARG { defnonly("$"); $$ = code2(arg, (Inst)$1); }

| asgn

| FUNCTION begin '(' arglist ');

{ $$ = $2; code3(call,(Inst)$1,(Inst)$4); }

| READ '(' VAR ')'{$$ = code2(varread, (Inst)$3); }

| BLTIN '(' expr ')' { $$=$3; code2(bltin, (Inst)$1->u.ptr); }

| '(' expr ')' { $$ = $2; }

| expr '+' expr { code(add); }

| expr '-' expr { code(sub); }

| expr '*' expr { code(mul); }

| expr '/' expr { code(div); }

| expr '^' expr { code(power); }

| '-' expr %prec UNARYMINUS { $$=$2; code(negate); }

| expr GT expr { code(gt); }

| expr GE expr { code(ge); }

| expr LT expr { code(lt); }

| expr LE expr { code(le); }

| expr EQ expr { code(eq); }

| expr NE expr { code(ne); }

| expr AND expr { code(and); }

| expr OR expr { code(or); }

| NOT expr { $$ = $2; code(not); }

;

prlist: expr { code(prexpr); }

| STRING { $$ = code2(prstr, (Inst)$1); }

| prlist expr { code(prexpr); }

| prlist STRING { code2(prstr, (Inst)$3); }

;

defn: FUNC procname { $2->type=FUNCTION; indef=1; }

'(' ')' stmt { code(procret); define($2); indef=0; }

| PROC procname { $2->type=PROCEDURE; indef=1; }

'(' ')' stmt { code(procret); define($2); indef=0; }

;

procname: VAR

| FUNCTION

| PROCEDURE

;

arglist: /* nothing */ { $$ = 0; }

| expr { $$ = 1; }

| arglist expr { $$ = $1 + 1; }

;

%%

/* end of grammar */

#include

#include

char *progname;

int lineno = 1;

#include

#include

jmp_buf begin;

int indef;

char *infile; /* input file name */

FILE *fin; /* input file pointer */

char **gargv; /* global argument list */

int gargc;

int c; /* global for use by warning() */

yylex() /* hoc6 */

{

while ((c=getc(fin)) == ' ' || c == '\t')

;

if (c == EOF)

return 0;

if (c == '.' || isdigit(c)) { /* number */

double d;

ungetc(c, fin);

fscanf(fin, "%lf", &d);

yylval.sym = install("", NUMBER, d);

return NUMBER;

}

if (isalpha(c)) {

Symbol *s;

char sbuf[100], *p = sbuf;

do {

if (p >= sbuf + sizeof(sbuf) - 1) {

*p = '\0';

execerror("name too long", sbuf);

}

*p++ = c;

} while ((c=getc(fin)) != EOF && isalnum(c));

ungetc(c, fin);

*p = '\0';

if ((s=lookup(sbuf)) == 0)

s = install(sbuf, UNDEF, 0.0);

yylval.sym = s;

return s->type == UNDEF ? VAR : s->type;

}

if (c == '$') { /* argument? */

int n = 0;

while (isdigit(c=getc(fin)))

n=10*n+c- '0';

ungetc(c, fin);

if (n == 0)

execerror("strange $...", (char*)0);

yylval.narg = n;

return ARG;

}

if (c == '"') { /* quoted string */

char sbuf[100], *p, *emalloc();

for (p = sbuf; (c=getc(fin)) != '"'; p++) {

if (с == '\n' || c == EOF)

execerror("missing quote", "");

if (p >= sbuf + sizeof(sbuf) - 1) {

*p = '\0';

execerror("string too long", sbuf);

}

*p = backslash(c);

}

*p = 0;

yylval.sym = (Symbol*)emalloc(strlen(sbuf)+1);

strcpy(yylval.sym, sbuf);

return STRING;

}

switch (c) {

case '>': return follow('=', GE, GT);

case '<': return follow('=', LE, LT);

case '=': return follow('=', EQ, '=');

case '!': return follow('=', NE, NOT);

case '|': return follow(' |', OR, '|');

case '&': return follow('&', AND, '&');

case '\n': lineno++; return '\n';

default: return c;

}

}

backslash(c) /* get next char with \'s interpreted */

int c;

{

char *index(); /* 'strchr()' in some systems */

static char transtab[] = "b\bf\fn\nr\rt\t";

if (c != '\\')

return c;

с = getc(fin);

if (islower(c) && index(transtab, c))

return index(transtab, с)[1];

return c;

}

follow(expect, ifyes, ifno) /* look ahead for >=, etc. */

{

int с = getc(fin);

if (c == expect)

return ifyes;

ungetc(c, fin);

return ifno;

}

defnonly(s) /* warn if illegal definition */

char *s;

{

if (!indef)

execerror(s, "used outside definition");

}

yyerror(s) /* report compile-time error */

char *s;

{

warning(s, (char *)0);

}

execerror(s, t) /* recover from run-time error */

char *s, *t;

{

warning(s, t);

fseek(fin, 0L, 2); /* flush rest of file */

longjmp(begin, 0);

}

fpecatch() /* catch floating point exceptions */

{

execerror("floating point exception", (char*)0);

}

main(argc, argv) /* hoc6 */

char *argv[];

{

int i, fpecatch();

progname = argv[0];

if (argc == 1) { /* fake an argument list */

static char *stdinonly[] = { "-" };

gargv = stdinonly;

gargc = 1;

} else {

gargv = argv+1;

gargc = argc-1;

}

init();

while (moreinput())

run();

return 0;

}

moreinput() {

if (gargc-- <= 0)

return 0;

if (fin && fin != stdin)

fclose(fin);

infile = *gargv++;

lineno = 1;

if (strcmp(infile, "-") == 0) {

fin = stdin;

infile = 0;

} else if ((fin=fopen(infile, "r")) == NULL) {

fprintf (stderr, "%s: can't open %s\n", progname, infile);

return moreinput();

}

return 1;

}

run() /* execute until EOF */

{

setjmp(begin);

signal(SIGFPE, fpecatch);

for (initcode(); yyparse(); initcode())

execute(progbase);

}

warning(s, t) /* print warning message */

char *s, *t;

{

fprintf(stderr, "%s: %s", progname, s);

if (t)

fprintf(stderr, " %s", t);

if (infile)

fprintf(stderr, " in %s", infile);

fprintf(stderr, " near line %d\n", lineno);

while (c != '\n' && c != EOF)

с = getc(fin); /* flush rest of input line */

if (c == '\n')

lineno++;

}

#include "hoc.h"

#include "y.tab.h"

#include

extern double Log(), Log10(), Sqrt(), Exp(), integer();

static struct { /* Keywords */

char *name;

int kval;

} keywords[] = {

"proc", PROC,

"func", FUNC,

"return", RETURN,

"if", IF,

"else", ELSE,

"while", WHILE,

"print", PRINT,

"read", READ,

0, 0,

};

static struct { /* Constants */

char *name;

double eval;

} consts[] = {

"PI", 3.14159265358979323846,

"E", 2.71828182845904523536,

"GAMMA", 0.57721566490153286060, /* Euler */

"DEG", 57.29577951308232087680, /* deg/radian */

"PHI", 1.61803398874989484820, /* golden ratio */

0, 0

};

static struct { /* Built-ins */

char *name;

double (*func)();

} builtins[] = {

"sin", sin,

"cos", cos,

"atan", atan,

"log", Log, /* checks range */

"log10", Log10, /* checks range */

"exp", Exp, /* checks range */

"sqrt", Sqrt, /* checks range */

"int", integer,

"abs", fabs,

0, 0

};

init() /* install constants and built-ins in table */

{

int i;

Symbol *s;

for (i = 0; keywords[i].name; i++)

install(keywords[i].name, keywords[i].kval, 0.0);

for (i = 0; consts[i].name; i++)