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
  22 xassq (SCM x, SCM a) ///for speed in core only
  23 {
  24   while (a != cell_nil && x != CDAR (a)) a = CDR (a);
  25   return a != cell_nil ? CAR (a) : cell_f;
  26 }
  27
  28 //MINI_MES
  29 // SCM
  30 // length (SCM x)
  31 // {
  32 //   int n = 0;
  33 //   while (x != cell_nil)
  34 //     {
  35 //       n++;
  36 //       if (TYPE (x) != TPAIR) return MAKE_NUMBER (-1);
  37 //       x = cdr (x);
  38 //     }
  39 //   return MAKE_NUMBER (n);
  40 // }
  41
  42 SCM
  43 exit_ (SCM x) ///((name . "exit"))
  44 {
  45   assert (TYPE (x) == TNUMBER);
  46   exit (VALUE (x));
  47 }
  48
  49 SCM
  50 append (SCM x) ///((arity . n))
  51 {
  52   if (x == cell_nil) return cell_nil;
  53   if (cdr (x) == cell_nil) return car (x);
  54   return append2 (car (x), append (cdr (x)));
  55 }
  56
  57 //MINI_MES
  58 // char const*
  59 // string_to_cstring (SCM s)
  60 // {
  61 //   static char buf[1024];
  62 //   char *p = buf;
  63 //   s = STRING (s);
  64 //   while (s != cell_nil)
  65 //     {
  66 //       *p++ = VALUE (car (s));
  67 //       s = cdr (s);
  68 //     }
  69 //   *p = 0;
  70 //   return buf;
  71 // }
  72
  73 // SCM
  74 // error (SCM key, SCM x)
  75 // {
  76 //   SCM throw;
  77 //   if ((throw = assq_ref_env (cell_symbol_throw, r0)) != cell_undefined)
  78 //     return apply (throw, cons (key, cons (x, cell_nil)), r0);
  79 //   assert (!"error");
  80 // }
  81
  82 SCM
  83 assert_defined (SCM x, SCM e) ///(internal)
  84 {
  85   if (e == cell_undefined) return error (cell_symbol_unbound_variable, x);
  86   return e;
  87 }
  88
  89 SCM
  90 check_formals (SCM f, SCM formals, SCM args) ///((internal))
  91 {
  92   int flen = (TYPE (formals) == TNUMBER) ? VALUE (formals) : VALUE (length (formals));
  93   int alen = VALUE (length (args));
  94   if (alen != flen && alen != -1 && flen != -1)
  95     {
  96       char buf[1024];
  97       sprintf (buf, "apply: wrong number of arguments; expected: %d, got: %d: ", flen, alen);
  98       SCM e = MAKE_STRING (cstring_to_list (buf));
  99       return error (cell_symbol_wrong_number_of_args, cons (e, f));
 100     }
 101   return cell_unspecified;
 102 }
 103
 104 SCM
 105 check_apply (SCM f, SCM e)
 106 {
 107   char const* type = 0;
 108   if (f == cell_f || f == cell_t) type = "bool";
 109   if (f == cell_nil) type = "nil";
 110   if (f == cell_unspecified) type = "*unspecified*";
 111   if (f == cell_undefined) type = "*undefined*";
 112   if (TYPE (f) == TCHAR) type = "char";
 113   if (TYPE (f) == TNUMBER) type = "number";
 114   if (TYPE (f) == TSTRING) type = "string";
 115
 116   if (type)
 117     {
 118       char buf[1024];
 119       sprintf (buf, "cannot apply: %s:", type);
 120       fprintf (stderr, " [");
 121       stderr_ (e);
 122       fprintf (stderr, "]\n");
 123       SCM e = MAKE_STRING (cstring_to_list (buf));
 124       return error (cell_symbol_wrong_type_arg, cons (e, f));
 125     }
 126   return cell_unspecified;
 127 }
 128
 129 char const*
 130 itoa (int x)
 131 {
 132   static char buf[10];
 133   char *p = buf+9;
 134   *p-- = 0;
 135
 136   int sign = x < 0;
 137   if (sign)
 138     x = -x;
 139
 140   do
 141     {
 142       *p-- = '0' + (x % 10);
 143       x = x / 10;
 144     } while (x);
 145
 146   if (sign)
 147     *p-- = '-';
 148
 149   return p+1;
 150 }
 151
 152 //FILE *g_stdin;
 153 int
 154 dump ()
 155 {
 156   fputs ("program r2=", stderr);
 157   stderr_ (r2);
 158   fputs ("\n", stderr);
 159
 160   r1 = g_symbols;
 161   gc_push_frame ();
 162   gc ();
 163   gc_peek_frame ();
 164   char *p = (char*)g_cells;
 165   fputc ('M', stdout);
 166   fputc ('E', stdout);
 167   fputc ('S', stdout);
 168   fputc (g_stack >> 8, stdout);
 169   fputc (g_stack % 256, stdout);
 170   // See HACKING, simple crafted dump for tiny-mes.c
 171   if (getenv ("MES_TINY"))
 172     {
 173       TYPE (9) = 0x2d2d2d2d;
 174       CAR (9) = 0x2d2d2d2d;
 175       CDR (9) = 0x3e3e3e3e;
 176
 177       TYPE (10) = TPAIR;
 178       CAR (10) = 11;
 179       CDR (10) = 12;
 180
 181       TYPE (11) = TCHAR;
 182       CAR (11) = 0x58585858;
 183       CDR (11) = 65;
 184
 185       TYPE (12) = TPAIR;
 186       CAR (12) = 13;
 187       CDR (12) = 1;
 188
 189       TYPE (13) = TCHAR;
 190       CAR (11) = 0x58585858;
 191       CDR (13) = 66;
 192
 193       TYPE (14) = 0x3c3c3c3c;
 194       CAR (14) = 0x2d2d2d2d;
 195       CDR (14) = 0x2d2d2d2d;
 196
 197       g_free = 15;
 198     }
 199   for (int i=0; i<g_free * sizeof(struct scm); i++)
 200     fputc (*p++, stdout);
 201   return 0;
 202 }
 203
 204 SCM
 205 load_env (SCM a) ///((internal))
 206 {
 207   r0 = a;
 208   g_stdin = fopen ("module/mes/read-0.mes", "r");
 209   g_stdin = g_stdin ? g_stdin : fopen (PREFIX "module/mes/read-0.mes", "r");
 210   if (!g_function) r0 = mes_builtins (r0);
 211   r2 = read_input_file_env (r0);
 212   g_stdin = stdin;
 213   return r2;
 214 }
 215
 216 SCM
 217 bload_env (SCM a) ///((internal))
 218 {
 219 #if MES_MINI
 220   g_stdin = fopen ("module/mes/read-0-32.mo", "r");
 221 #else
 222   g_stdin = fopen ("module/mes/read-0.mo", "r");
 223   g_stdin = g_stdin ? g_stdin : fopen (PREFIX "module/mes/read-0.mo", "r");
 224 #endif
 225
 226   char *p = (char*)g_cells;
 227   assert (getchar () == 'M');
 228   assert (getchar () == 'E');
 229   assert (getchar () == 'S');
 230   g_stack = getchar () << 8;
 231   g_stack += getchar ();
 232   int c = getchar ();
 233   while (c != EOF)
 234     {
 235       *p++ = c;
 236       c = getchar ();
 237     }
 238   g_free = (p-(char*)g_cells) / sizeof (struct scm);
 239   gc_peek_frame ();
 240   g_symbols = r1;
 241   g_stdin = stdin;
 242   r0 = mes_builtins (r0);
 243   return r2;
 244 }