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

  for (i = 0; builtins[i].name; i++) {
  s = install(builtins[i].name, BLTIN, 0.0);
  s->u.ptr = builtins[i].func;
  }
 }

3.4.4. lex.l

 %{
 #include "hoc.h"
 #include "y.tab.h"

 extern int lineno;
 %}
 %%
 [ \t] { ; } /* skip blanks and tabs */
 [0-9]+\.?|[0-9][0-9]+ {
  sscanf(yytext, "%lf", &yylval.val);
  return NUMBER;
 }
 [a-zA-Z][a-zA-Z0-9]* {
  Symbol *s;
  if ((s=lookup(yytext)) == 0)
  s = install(yytext, UNDEF, 0.0);
  yylval.sym = s;
  return s->type == UNDEF ? VAR : s->type;
 }
 \n {
  lineno++;
  return '\n';
 } /* everything else */
 . { return yytext[0]; }

3.4.5 makefile

 YFLAGS = -d
 OBJS = hoc.o lex.o init.o math.o symbol.o

 hoc3: $(OBJS)
  cc $(OBJS) -lm -ll -o hoc3

 hoc.o: hoc.h

 lex.o init.o symbol.o: hoc.h y.tab.h

3.4.6 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.4.7 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.5 hoc4

3.5.1 code.c

 #include "hoc.h"
 #include "y.tab.h"

 #define NSTACK 256
 static Datum stack[NSTACK]; /* the stack */
 static Datum *stackp; /* next free spot on stack */