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

  s = install(builtins[i].name, BLTIN, 0.0);

  s-u.ptr = builtins[i].func;

 }

}

3.3.5 math.c

#include math.h

#include errno.h

extern int errno;

double errcheck;

double Log(x)

 double x;

{

 return errcheck(log(x), "log");

}

double Log10(x)

 double x;

{

 return errcheck(log10(x), "log10");

}

double Sqrt(x)

 double x;

{

 return errcheck(sqrt(x), "sqrt");

}

double Exp(x)

 double x;

{

 return errcheck(exp(x), "exp");

}

double Pow(x, y)

 double x, y;

 return errcheck(pow(x,y), "exponentiation");

}

double integer(x)

 double x;

{

 return (double)(long)x;

}

double errcheck(d, s) /* check result of library call */

 double d;

 char *s;

{

 if (errno == EDOM) {

  errno = 0;

  execerror(s, "argument out of domain");

 }

 else if (errno == ERANGE) {

  errno = 0;

  execerror(s, "result out of range");

 }

 return d;

}

3.3.6 symbol.c

#include "hoc.h"

#include "y.tab.h"

static Symbol *symlist = 0; /* symbol table: linked list */

Symbol *lookup(s) /* find s in symbol table */

 char *s;

{

 Symbol *sp;

 for (sp = symlist; sp != (Symbol*)0; sp = sp-next)

  if (strcmp(sp-name, s) == 0)

   return sp;

 return 0; /* 0 == not found */

}

Symbol *install(s, t, d) /* install s in symbol table */

 char *s;

 int t;

 double d;

 Symbol *sp;

 char *emalloc;

 sp = (Symbol*)emalloc(sizeof(Symbol));

 sp-name = emalloc(strlen(s)+1); /* +1 for '\0' */

 strcpy(sp-name, s);

 sp-type = t;

 sp-u.val = d;

 sp-next = symlist; /* put at front of list */

 symlist = sp;

 return sp;

}

char *emalloc(n) /* check return from malloc */

 unsigned n;

{

 char *p, *malloc;

 p = malloc(n);

 if (p == 0)

  execerror("out of memory", (char*)0);

 return p;

}

3.4 hoc3 с lex

3.4.1. hoc.h

typedef struct Symbol { /* symbol table entry */

 char *name;

 short type; /* VAR, BLTIN, UNDEF */

 union {

  double val; /* if VAR */

  double (*ptr); /* if BLTIN */

 } u;

 struct Symbol *next; /* to link to another */

} Symbol;

Symbol *install, *lookup;

3.4.2 hoc.y

%{

#include "hoc.h"

extern double Pow;

%}

%union {

 double val; /* actual value */

 Symbol *sym; /* symbol table pointer */

}

%token val NUMBER

%token sym VAR BLTIN UNDEF

%type val expr asgn

%right '='

%left '+' '-'

%left '*' '/'

%left UNARYMINUS

%right '^' /* exponentiation */

%%

list: /* nothing */

 | list '\n'

 | list asgn '\n'

 | list expr '\n' { printf("\t%.8g\n", $2); }

 | list error '\n' { yyerrok; }

 ;

asgn: VAR '=' expr { $$=$1-u.val=$3; $1-type = VAR; }

 ;

expr: NUMBER

 | VAR {

  if ($1-type == UNDEF)

   execerror("undefined variable", $1-name);

  $$ = $1-u.val;

 }

 | asgn

 | BLTIN '(' expr ')' { $$ = (*($1-u.ptr))($3); }

 | expr '+' expr { $$ = $1 + $3; }

 | expr '+' expr { $$ = $1 - $3; }

 | expr '*' expr { $$ = $1 * $3; }

 | expr '/' expr {

  if ($3 == 0.0)

   execerror("division by zero", "");