initial commit
[freebsd-arm:freebsd-arm.git] / boot / ficl / stack.c
1 /*******************************************************************
2 ** s t a c k . c
3 ** Forth Inspired Command Language
4 ** Author: John Sadler (john_sadler@alum.mit.edu)
5 ** Created: 16 Oct 1997
6 ** $Id: stack.c,v 1.10 2001/12/05 07:21:34 jsadler Exp $
7 *******************************************************************/
8 /*
9 ** Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
10 ** All rights reserved.
11 **
12 ** Get the latest Ficl release at http://ficl.sourceforge.net
13 **
14 ** I am interested in hearing from anyone who uses ficl. If you have
15 ** a problem, a success story, a defect, an enhancement request, or
16 ** if you would like to contribute to the ficl release, please
17 ** contact me by email at the address above.
18 **
19 ** L I C E N S E  and  D I S C L A I M E R
20 ** 
21 ** Redistribution and use in source and binary forms, with or without
22 ** modification, are permitted provided that the following conditions
23 ** are met:
24 ** 1. Redistributions of source code must retain the above copyright
25 **    notice, this list of conditions and the following disclaimer.
26 ** 2. Redistributions in binary form must reproduce the above copyright
27 **    notice, this list of conditions and the following disclaimer in the
28 **    documentation and/or other materials provided with the distribution.
29 **
30 ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
31 ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
32 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 ** ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
34 ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
36 ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
37 ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
38 ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
39 ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
40 ** SUCH DAMAGE.
41 */
42
43 /* $FreeBSD$ */
44
45 #ifdef TESTMAIN
46 #include <stdlib.h>
47 #else
48 #include <stand.h>
49 #endif
50 #include "ficl.h"
51
52 #define STKDEPTH(s) ((s)->sp - (s)->base)
53
54 /*
55 ** N O T E: Stack convention:
56 **
57 ** sp points to the first available cell
58 ** push: store value at sp, increment sp
59 ** pop:  decrement sp, fetch value at sp
60 ** Stack grows from low to high memory
61 */
62
63 /*******************************************************************
64                     v m C h e c k S t a c k
65 ** Check the parameter stack for underflow or overflow.
66 ** nCells controls the type of check: if nCells is zero,
67 ** the function checks the stack state for underflow and overflow.
68 ** If nCells > 0, checks to see that the stack has room to push
69 ** that many cells. If less than zero, checks to see that the
70 ** stack has room to pop that many cells. If any test fails,
71 ** the function throws (via vmThrow) a VM_ERREXIT exception.
72 *******************************************************************/
73 void vmCheckStack(FICL_VM *pVM, int popCells, int pushCells)
74 {
75     FICL_STACK *pStack = pVM->pStack;
76     int nFree = pStack->base + pStack->nCells - pStack->sp;
77
78     if (popCells > STKDEPTH(pStack))
79     {
80         vmThrowErr(pVM, "Error: stack underflow");
81     }
82
83     if (nFree < pushCells - popCells)
84     {
85         vmThrowErr(pVM, "Error: stack overflow");
86     }
87
88     return;
89 }
90
91 #if FICL_WANT_FLOAT
92 void vmCheckFStack(FICL_VM *pVM, int popCells, int pushCells)
93 {
94     FICL_STACK *fStack = pVM->fStack;
95     int nFree = fStack->base + fStack->nCells - fStack->sp;
96
97     if (popCells > STKDEPTH(fStack))
98     {
99         vmThrowErr(pVM, "Error: float stack underflow");
100     }
101
102     if (nFree < pushCells - popCells)
103     {
104         vmThrowErr(pVM, "Error: float stack overflow");
105     }
106 }
107 #endif
108
109 /*******************************************************************
110                     s t a c k C r e a t e
111 ** 
112 *******************************************************************/
113
114 FICL_STACK *stackCreate(unsigned nCells)
115 {
116     size_t size = sizeof (FICL_STACK) + nCells * sizeof (CELL);
117     FICL_STACK *pStack = ficlMalloc(size);
118
119 #if FICL_ROBUST
120     assert (nCells != 0);
121     assert (pStack != NULL);
122 #endif
123
124     pStack->nCells = nCells;
125     pStack->sp     = pStack->base;
126     pStack->pFrame = NULL;
127     return pStack;
128 }
129
130
131 /*******************************************************************
132                     s t a c k D e l e t e
133 ** 
134 *******************************************************************/
135
136 void stackDelete(FICL_STACK *pStack)
137 {
138     if (pStack)
139         ficlFree(pStack);
140     return;
141 }
142
143
144 /*******************************************************************
145                     s t a c k D e p t h 
146 ** 
147 *******************************************************************/
148
149 int stackDepth(FICL_STACK *pStack)
150 {
151     return STKDEPTH(pStack);
152 }
153
154 /*******************************************************************
155                     s t a c k D r o p
156 ** 
157 *******************************************************************/
158
159 void stackDrop(FICL_STACK *pStack, int n)
160 {
161 #if FICL_ROBUST
162     assert(n > 0);
163 #endif
164     pStack->sp -= n;
165     return;
166 }
167
168
169 /*******************************************************************
170                     s t a c k F e t c h
171 ** 
172 *******************************************************************/
173
174 CELL stackFetch(FICL_STACK *pStack, int n)
175 {
176     return pStack->sp[-n-1];
177 }
178
179 void stackStore(FICL_STACK *pStack, int n, CELL c)
180 {
181     pStack->sp[-n-1] = c;
182     return;
183 }
184
185
186 /*******************************************************************
187                     s t a c k G e t T o p
188 ** 
189 *******************************************************************/
190
191 CELL stackGetTop(FICL_STACK *pStack)
192 {
193     return pStack->sp[-1];
194 }
195
196
197 /*******************************************************************
198                     s t a c k L i n k
199 ** Link a frame using the stack's frame pointer. Allot space for
200 ** nCells cells in the frame
201 ** 1) Push pFrame
202 ** 2) pFrame = sp
203 ** 3) sp += nCells
204 *******************************************************************/
205
206 void stackLink(FICL_STACK *pStack, int nCells)
207 {
208     stackPushPtr(pStack, pStack->pFrame);
209     pStack->pFrame = pStack->sp;
210     pStack->sp += nCells;
211     return;
212 }
213
214
215 /*******************************************************************
216                     s t a c k U n l i n k
217 ** Unink a stack frame previously created by stackLink
218 ** 1) sp = pFrame
219 ** 2) pFrame = pop()
220 *******************************************************************/
221
222 void stackUnlink(FICL_STACK *pStack)
223 {
224     pStack->sp = pStack->pFrame;
225     pStack->pFrame = stackPopPtr(pStack);
226     return;
227 }
228
229
230 /*******************************************************************
231                     s t a c k P i c k
232 ** 
233 *******************************************************************/
234
235 void stackPick(FICL_STACK *pStack, int n)
236 {
237     stackPush(pStack, stackFetch(pStack, n));
238     return;
239 }
240
241
242 /*******************************************************************
243                     s t a c k P o p
244 ** 
245 *******************************************************************/
246
247 CELL stackPop(FICL_STACK *pStack)
248 {
249     return *--pStack->sp;
250 }
251
252 void *stackPopPtr(FICL_STACK *pStack)
253 {
254     return (*--pStack->sp).p;
255 }
256
257 FICL_UNS stackPopUNS(FICL_STACK *pStack)
258 {
259     return (*--pStack->sp).u;
260 }
261
262 FICL_INT stackPopINT(FICL_STACK *pStack)
263 {
264     return (*--pStack->sp).i;
265 }
266
267 #if (FICL_WANT_FLOAT)
268 float stackPopFloat(FICL_STACK *pStack)
269 {
270     return (*(--pStack->sp)).f;
271 }
272 #endif
273
274 /*******************************************************************
275                     s t a c k P u s h
276 ** 
277 *******************************************************************/
278
279 void stackPush(FICL_STACK *pStack, CELL c)
280 {
281     *pStack->sp++ = c;
282 }
283
284 void stackPushPtr(FICL_STACK *pStack, void *ptr)
285 {
286     *pStack->sp++ = LVALUEtoCELL(ptr);
287 }
288
289 void stackPushUNS(FICL_STACK *pStack, FICL_UNS u)
290 {
291     *pStack->sp++ = LVALUEtoCELL(u);
292 }
293
294 void stackPushINT(FICL_STACK *pStack, FICL_INT i)
295 {
296     *pStack->sp++ = LVALUEtoCELL(i);
297 }
298
299 #if (FICL_WANT_FLOAT)
300 void stackPushFloat(FICL_STACK *pStack, FICL_FLOAT f)
301 {
302     *pStack->sp++ = LVALUEtoCELL(f);
303 }
304 #endif
305
306 /*******************************************************************
307                     s t a c k R e s e t
308 ** 
309 *******************************************************************/
310
311 void stackReset(FICL_STACK *pStack)
312 {
313     pStack->sp = pStack->base;
314     return;
315 }
316
317
318 /*******************************************************************
319                     s t a c k R o l l 
320 ** Roll nth stack entry to the top (counting from zero), if n is 
321 ** >= 0. Drop other entries as needed to fill the hole.
322 ** If n < 0, roll top-of-stack to nth entry, pushing others
323 ** upward as needed to fill the hole.
324 *******************************************************************/
325
326 void stackRoll(FICL_STACK *pStack, int n)
327 {
328     CELL c;
329     CELL *pCell;
330
331     if (n == 0)
332         return;
333     else if (n > 0)
334     {
335         pCell = pStack->sp - n - 1;
336         c = *pCell;
337
338         for (;n > 0; --n, pCell++)
339         {
340             *pCell = pCell[1];
341         }
342
343         *pCell = c;
344     }
345     else
346     {
347         pCell = pStack->sp - 1;
348         c = *pCell;
349
350         for (; n < 0; ++n, pCell--)
351         {
352             *pCell = pCell[-1];
353         }
354
355         *pCell = c;
356     }
357     return;
358 }
359
360
361 /*******************************************************************
362                     s t a c k S e t T o p
363 ** 
364 *******************************************************************/
365
366 void stackSetTop(FICL_STACK *pStack, CELL c)
367 {
368     pStack->sp[-1] = c;
369     return;
370 }
371
372