FreeBSD/Linux Kernel Cross Reference
sys/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: src/sys/boot/ficl/stack.c,v 1.5 2002/04/09 17:45:11 dcs Exp $ */
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
373 Cache object: 16d4763e2ef24985e241f76e14ed3f9b
|