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

 #include <math.h>

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

 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 argument */
  "log10", Log10, /* checks argument */
  "exp", Exp, /* checks argument */
  "sqrt", Sqrt, /* checks argument */
  "int", integer,
  "abs", fabs,
  0, 0
 };

 init /* install constants and built-ins in table */
 {
  int i;
  Symbol *s;

  for (i = 0; consts[i].name; i++)
  install(consts[i].name, VAR, consts[i].eval);
  for (i = 0; builtins[i].name; i++) {
  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