cc09ea3a0a2b13856ad4ec5199e291fada120e1f
[mes.git] / 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 char const*
131 itoa (int x)
132 {
133   static char buf[10];
134   char *p = buf+9;
135   *p-- = 0;
136
137   int sign = x < 0;
138   if (sign)
139     x = -x;
140   
141   do
142     {
143       *p-- = '0' + (x % 10);
144       x = x / 10;
145     } while (x);
146
147   if (sign)
148     *p-- = '-';
149
150   return p+1;
151 }
152
153 FILE *g_stdin;
154 int
155 dump ()
156 {
157   fputs ("program r2=", stderr);
158   stderr_ (r2);
159   fputs ("\n", stderr);
160
161   r1 = g_symbols;
162   gc_push_frame ();
163   gc ();
164   gc_peek_frame ();
165   char *p = (char*)g_cells;
166   fputc ('M', stdout);
167   fputc ('E', stdout);
168   fputc ('S', stdout);
169   fputc (g_stack >> 8, stdout);
170   fputc (g_stack % 256, stdout);
171   if (getenv ("MES_HACK"))
172     {
173       TYPE (9) = 0x2d2d2d2d;
174       CAR (9) = 0x2d2d2d2d;
175       CDR (9) = 0x3e3e3e3e;
176
177       TYPE (10) = PAIR;
178       CAR (10) = 11;
179       CDR (10) = 12;
180
181       TYPE (11) = CHAR;
182       CAR (11) = 0x58585858;
183       CDR (11) = 65;
184
185       TYPE (12) = PAIR;
186       CAR (12) = 13;
187       CDR (12) = 1;
188
189       TYPE (13) = CHAR;
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(scm); i++)
200     fputc (*p++, stdout);
201   return 0;
202 }
203
204 SCM
205 load_env (SCM a) ///((internal))
206 {
207   r0 = a;
208   if (getenv ("MES_MINI"))
209     g_stdin = fopen ("mini-0.mes", "r");
210   else
211     {
212       g_stdin = fopen ("module/mes/read-0.mes", "r");
213       g_stdin = g_stdin ? g_stdin : fopen (PREFIX "module/mes/read-0.mes", "r");
214     }
215   if (!g_function) r0 = mes_builtins (r0);
216   r2 = read_input_file_env (r0);
217   g_stdin = stdin;
218   return r2;
219 }
220
221 SCM
222 bload_env (SCM a) ///((internal))
223 {
224 #if MES_MINI
225   g_stdin = fopen ("mini-0.mo", "r");
226 #else
227   g_stdin = fopen ("module/mes/read-0.mo", "r");
228   g_stdin = g_stdin ? g_stdin : fopen (PREFIX "module/mes/read-0.mo", "r");
229 #endif
230
231   char *p = (char*)g_cells;
232   assert (getchar () == 'M');
233   assert (getchar () == 'E');
234   assert (getchar () == 'S');
235   g_stack = getchar () << 8;
236   g_stack += getchar ();
237   int c = getchar ();
238   while (c != EOF)
239     {
240       *p++ = c;
241       c = getchar ();
242     }
243   g_free = (p-(char*)g_cells) / sizeof (scm);
244   gc_peek_frame ();
245   g_symbols = r1;
246   g_stdin = stdin;
247   r0 = mes_builtins (r0);
248   return r2;
249 }