lib.c

   1 /* -*-comment-start: "//";comment-end:""-*-
   2  * Mes --- Maxwell Equations of Software
   3  * Copyright © 2016 Jan Nieuwenhuizen <janneke@gnu.org>
   4  *
   5  * This file is part of Mes.
   6  *
   7  * Mes is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or (at
  10  * your option) any later version.
  11  *
  12  * Mes is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Mes.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21 SCM caar (SCM x) {return car (car (x));}
  22 SCM cadr (SCM x) {return car (cdr (x));}
  23 SCM cdar (SCM x) {return cdr (car (x));}
  24 SCM cddr (SCM x) {return cdr (cdr (x));}
  25
  26 SCM
  27 xassq (SCM x, SCM a) ///for speed in core only
  28 {
  29   while (a != cell_nil && x != CDAR (a)) a = CDR (a);
  30   return a != cell_nil ? CAR (a) : cell_f;
  31 }
  32
  33 SCM
  34 length (SCM x)
  35 {
  36   int n = 0;
  37   while (x != cell_nil)
  38     {
  39       n++;
  40       if (TYPE (x) != PAIR) return MAKE_NUMBER (-1);
  41       x = cdr (x);
  42     }
  43   return MAKE_NUMBER (n);
  44 }
  45
  46 SCM
  47 list (SCM x) ///((arity . n))
  48 {
  49   return x;
  50 }
  51
  52 SCM
  53 exit_ (SCM x) ///((name . "exit"))
  54 {
  55   assert (TYPE (x) == NUMBER);
  56   exit (VALUE (x));
  57 }
  58
  59 char const*
  60 string_to_cstring (SCM s)
  61 {
  62   static char buf[1024];
  63   char *p = buf;
  64   s = STRING (s);
  65   while (s != cell_nil)
  66     {
  67       *p++ = VALUE (car (s));
  68       s = cdr (s);
  69     }
  70   *p = 0;
  71   return buf;
  72 }
  73
  74 SCM
  75 error (SCM key, SCM x)
  76 {
  77   SCM throw;
  78   if ((throw = assq_ref_cache (cell_symbol_throw, r0)) != cell_undefined)
  79     return apply (throw, cons (key, cons (x, cell_nil)), r0);
  80   assert (!"error");
  81 }
  82
  83 SCM
  84 assert_defined (SCM x, SCM e)
  85 {
  86   if (e == cell_undefined) return error (cell_symbol_unbound_variable, x);
  87   return e;
  88 }
  89
  90 SCM
  91 check_formals (SCM f, SCM formals, SCM args)
  92 {
  93   int flen = (TYPE (formals) == NUMBER) ? VALUE (formals) : VALUE (length (formals));
  94   int alen = VALUE (length (args));
  95   if (alen != flen && alen != -1 && flen != -1)
  96     {
  97       char buf[1024];
  98       sprintf (buf, "apply: wrong number of arguments; expected: %d, got: %d: ", flen, alen);
  99       SCM e = MAKE_STRING (cstring_to_list (buf));
 100       return error (cell_symbol_wrong_number_of_args, cons (e, f));
 101     }
 102   return cell_unspecified;
 103 }
 104
 105 SCM
 106 check_apply (SCM f, SCM e)
 107 {
 108   char const* type = 0;
 109   if (f == cell_f || f == cell_t) type = "bool";
 110   if (f == cell_nil) type = "nil";
 111   if (f == cell_unspecified) type = "*unspecified*";
 112   if (f == cell_undefined) type = "*undefined*";
 113   if (TYPE (f) == CHAR) type = "char";
 114   if (TYPE (f) == NUMBER) type = "number";
 115   if (TYPE (f) == STRING) type = "string";
 116
 117   if (type)
 118     {
 119       char buf[1024];
 120       sprintf (buf, "cannot apply: %s:", type);
 121       fprintf (stderr, " [");
 122       stderr_ (e);
 123       fprintf (stderr, "]\n");
 124       SCM e = MAKE_STRING (cstring_to_list (buf));
 125       return error (cell_symbol_wrong_type_arg, cons (e, f));
 126     }
 127   return cell_unspecified;
 128 }
 129
 130 FILE *g_stdin;
 131 int
 132 dump ()
 133 {
 134   r1 = g_symbols;
 135   gc (gc_push_frame ());
 136   char *p = (char*)g_cells;
 137   fputc ('M', stdout);
 138   fputc ('E', stdout);
 139   fputc ('S', stdout);
 140   fputc (g_stack >> 8, stdout);
 141   fputc (g_stack % 256, stdout);
 142   if (getenv ("MES_HACK"))
 143     {
 144       TYPE (9) = 0x2d2d2d2d;
 145       CAR (9) = 0x2d2d2d2d;
 146       CDR (9) = 0x3e3e3e3e;
 147
 148       TYPE (10) = PAIR;
 149       CAR (10) = 11;
 150       CDR (10) = 12;
 151
 152       TYPE (11) = CHAR;
 153       CAR (11) = 0x58585858;
 154       CDR (11) = 65;
 155
 156       TYPE (12) = PAIR;
 157       CAR (12) = 13;
 158       CDR (12) = 1;
 159
 160       TYPE (13) = CHAR;
 161       CAR (11) = 0x58585858;
 162       CDR (13) = 66;
 163
 164       TYPE (14) = 0x3c3c3c3c;
 165       CAR (14) = 0x2d2d2d2d;
 166       CDR (14) = 0x2d2d2d2d;
 167
 168       g_free = 15;
 169     }
 170   for (int i=0; i<g_free * sizeof(scm); i++)
 171     fputc (*p++, stdout);
 172   return 0;
 173 }
 174
 175 SCM
 176 load_env (SCM a) ///((internal))
 177 {
 178   r0 = a;
 179   g_stdin = fopen ("module/mes/read-0.mes", "r");
 180   g_stdin = g_stdin ? g_stdin : fopen (PREFIX "module/mes/read-0.mes", "r");
 181   if (!g_function) r0 = mes_builtins (r0);
 182   r2 = read_input_file_env (r0);
 183   g_stdin = stdin;
 184   return r2;
 185 }
 186
 187 SCM
 188 bload_env (SCM a) ///((internal))
 189 {
 190   g_stdin = fopen ("module/mes/read-0.mo", "r");
 191   g_stdin = g_stdin ? g_stdin : fopen (PREFIX "module/mes/read-0.mo", "r");
 192   char *p = (char*)g_cells;
 193   assert (getchar () == 'M');
 194   assert (getchar () == 'E');
 195   assert (getchar () == 'S');
 196   g_stack = getchar () << 8;
 197   g_stack += getchar ();
 198   int c = getchar ();
 199   while (c != EOF)
 200     {
 201       *p++ = c;
 202       c = getchar ();
 203     }
 204   g_free = (p-(char*)g_cells) / sizeof (scm);
 205   gc_peek_frame ();
 206   g_symbols = r1;
 207   g_stdin = stdin;
 208   r0 = mes_builtins (r0);
 209   return r2;
 210 }