1 /*******************************************************************
3 ** Forth Inspired Command Language - virtual machine methods
4 ** Author: John Sadler (john_sadler@alum.mit.edu)
5 ** Created: 19 July 1997
6 ** $Id: vm.c,v 1.13 2001/12/05 07:21:34 jsadler Exp $
7 *******************************************************************/
9 ** This file implements the virtual machine of FICL. Each virtual
10 ** machine retains the state of an interpreter. A virtual machine
11 ** owns a pair of stacks for parameters and return addresses, as
12 ** well as a pile of state variables and the two dedicated registers
16 ** Copyright (c) 1997-2001 John Sadler (john_sadler@alum.mit.edu)
17 ** All rights reserved.
19 ** Get the latest Ficl release at http://ficl.sourceforge.net
21 ** I am interested in hearing from anyone who uses ficl. If you have
22 ** a problem, a success story, a defect, an enhancement request, or
23 ** if you would like to contribute to the ficl release, please
24 ** contact me by email at the address above.
26 ** L I C E N S E and D I S C L A I M E R
28 ** Redistribution and use in source and binary forms, with or without
29 ** modification, are permitted provided that the following conditions
31 ** 1. Redistributions of source code must retain the above copyright
32 ** notice, this list of conditions and the following disclaimer.
33 ** 2. Redistributions in binary form must reproduce the above copyright
34 ** notice, this list of conditions and the following disclaimer in the
35 ** documentation and/or other materials provided with the distribution.
37 ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
38 ** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
39 ** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
40 ** ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
41 ** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
42 ** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
43 ** OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
44 ** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
45 ** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
46 ** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * $FreeBSD: src/sys/boot/ficl/vm.c,v 1.9 2002/04/09 17:45:11 dcs Exp $
52 * $DragonFly: src/sys/boot/ficl/vm.c,v 1.4 2003/11/10 06:08:33 dillon Exp $
66 static char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
69 /**************************************************************************
70 v m B r a n c h R e l a t i v e
72 **************************************************************************/
73 void vmBranchRelative(FICL_VM *pVM, int offset)
80 /**************************************************************************
82 ** Creates a virtual machine either from scratch (if pVM is NULL on entry)
83 ** or by resizing and reinitializing an existing VM to the specified stack
85 **************************************************************************/
86 FICL_VM *vmCreate(FICL_VM *pVM, unsigned nPStack, unsigned nRStack)
90 pVM = (FICL_VM *)ficlMalloc(sizeof (FICL_VM));
92 memset(pVM, 0, sizeof (FICL_VM));
96 stackDelete(pVM->pStack);
97 pVM->pStack = stackCreate(nPStack);
100 stackDelete(pVM->rStack);
101 pVM->rStack = stackCreate(nRStack);
105 stackDelete(pVM->fStack);
106 pVM->fStack = stackCreate(nPStack);
109 pVM->textOut = ficlTextOut;
116 /**************************************************************************
118 ** Free all memory allocated to the specified VM and its subordinate
120 **************************************************************************/
121 void vmDelete (FICL_VM *pVM)
125 ficlFree(pVM->pStack);
126 ficlFree(pVM->rStack);
128 ficlFree(pVM->fStack);
137 /**************************************************************************
139 ** Sets up the specified word to be run by the inner interpreter.
140 ** Executes the word's code part immediately, but in the case of
141 ** colon definition, the definition itself needs the inner interp
142 ** to complete. This does not happen until control reaches ficlExec
143 **************************************************************************/
144 void vmExecute(FICL_VM *pVM, FICL_WORD *pWord)
146 pVM->runningWord = pWord;
152 /**************************************************************************
153 v m I n n e r L o o p
154 ** the mysterious inner interpreter...
155 ** This loop is the address interpreter that makes colon definitions
156 ** work. Upon entry, it assumes that the IP points to an entry in
157 ** a definition (the body of a colon word). It runs one word at a time
158 ** until something does vmThrow. The catcher for this is expected to exist
159 ** in the calling code.
160 ** vmThrow gets you out of this loop with a longjmp()
161 ** Visual C++ 5 chokes on this loop in Release mode. Aargh.
162 **************************************************************************/
163 #if INLINE_INNER_LOOP == 0
164 void vmInnerLoop(FICL_VM *pVM)
171 ** Recast inner loop that inlines tokens for control structures, arithmetic and stack operations,
172 ** as well as create does> : ; and various literals
197 typedef CELL *IPTYPE;
199 void vmInnerLoop(FICL_VM *pVM)
202 FICL_STACK *pStack = pVM->pStack;
206 OPCODE o = (*ip++).i;
211 stackPushINT(pStack, 0);
214 stackPushINT(pStack, 1);
217 stackPushINT(pStack, 2);
220 stackPushINT(pStack, -1);
223 stackPushINT(pStack, -2);
226 stackDrop(pStack, 1);
229 stackRoll(pStack, 1);
232 stackPick(pStack, 0);
236 stackPick(pStack, c.i);
240 stackRoll(pStack, c.i);
253 /**************************************************************************
255 ** Returns the address dictionary for this VM's system
256 **************************************************************************/
257 FICL_DICT *vmGetDict(FICL_VM *pVM)
260 return pVM->pSys->dp;
264 /**************************************************************************
265 v m G e t S t r i n g
266 ** Parses a string out of the VM input buffer and copies up to the first
267 ** FICL_STRING_MAX characters to the supplied destination buffer, a
268 ** FICL_STRING. The destination string is NULL terminated.
270 ** Returns the address of the first unused character in the dest buffer.
271 **************************************************************************/
272 char *vmGetString(FICL_VM *pVM, FICL_STRING *spDest, char delimiter)
274 STRINGINFO si = vmParseStringEx(pVM, delimiter, 0);
276 if (SI_COUNT(si) > FICL_STRING_MAX)
278 SI_SETLEN(si, FICL_STRING_MAX);
281 strncpy(spDest->text, SI_PTR(si), SI_COUNT(si));
282 spDest->text[SI_COUNT(si)] = '\0';
283 spDest->count = (FICL_COUNT)SI_COUNT(si);
285 return spDest->text + SI_COUNT(si) + 1;
289 /**************************************************************************
291 ** vmGetWord calls vmGetWord0 repeatedly until it gets a string with
293 **************************************************************************/
294 STRINGINFO vmGetWord(FICL_VM *pVM)
296 STRINGINFO si = vmGetWord0(pVM);
298 if (SI_COUNT(si) == 0)
300 vmThrow(pVM, VM_RESTART);
307 /**************************************************************************
309 ** Skip leading whitespace and parse a space delimited word from the tib.
310 ** Returns the start address and length of the word. Updates the tib
311 ** to reflect characters consumed, including the trailing delimiter.
312 ** If there's nothing of interest in the tib, returns zero. This function
313 ** does not use vmParseString because it uses isspace() rather than a
314 ** single delimiter character.
315 **************************************************************************/
316 STRINGINFO vmGetWord0(FICL_VM *pVM)
318 char *pSrc = vmGetInBuf(pVM);
319 char *pEnd = vmGetInBufEnd(pVM);
324 pSrc = skipSpace(pSrc, pEnd);
327 for (ch = *pSrc; (pEnd != pSrc) && !isspace(ch); ch = *++pSrc)
332 SI_SETLEN(si, count);
334 if ((pEnd != pSrc) && isspace(ch)) /* skip one trailing delimiter */
337 vmUpdateTib(pVM, pSrc);
343 /**************************************************************************
344 v m G e t W o r d T o P a d
345 ** Does vmGetWord and copies the result to the pad as a NULL terminated
346 ** string. Returns the length of the string. If the string is too long
347 ** to fit in the pad, it is truncated.
348 **************************************************************************/
349 int vmGetWordToPad(FICL_VM *pVM)
352 char *cp = (char *)pVM->pad;
355 if (SI_COUNT(si) > nPAD)
358 strncpy(cp, SI_PTR(si), SI_COUNT(si));
359 cp[SI_COUNT(si)] = '\0';
360 return (int)(SI_COUNT(si));
364 /**************************************************************************
365 v m P a r s e S t r i n g
366 ** Parses a string out of the input buffer using the delimiter
367 ** specified. Skips leading delimiters, marks the start of the string,
368 ** and counts characters to the next delimiter it encounters. It then
369 ** updates the vm input buffer to consume all these chars, including the
370 ** trailing delimiter.
371 ** Returns the address and length of the parsed string, not including the
372 ** trailing delimiter.
373 **************************************************************************/
374 STRINGINFO vmParseString(FICL_VM *pVM, char delim)
376 return vmParseStringEx(pVM, delim, 1);
379 STRINGINFO vmParseStringEx(FICL_VM *pVM, char delim, char fSkipLeading)
382 char *pSrc = vmGetInBuf(pVM);
383 char *pEnd = vmGetInBufEnd(pVM);
387 { /* skip lead delimiters */
388 while ((pSrc != pEnd) && (*pSrc == delim))
392 SI_SETPTR(si, pSrc); /* mark start of text */
394 for (ch = *pSrc; (pSrc != pEnd)
397 && (ch != '\n'); ch = *++pSrc)
399 ; /* find next delimiter or end of line */
402 /* set length of result */
403 SI_SETLEN(si, pSrc - SI_PTR(si));
405 if ((pSrc != pEnd) && (*pSrc == delim)) /* gobble trailing delimiter */
408 vmUpdateTib(pVM, pSrc);
413 /**************************************************************************
416 **************************************************************************/
417 CELL vmPop(FICL_VM *pVM)
419 return stackPop(pVM->pStack);
423 /**************************************************************************
426 **************************************************************************/
427 void vmPush(FICL_VM *pVM, CELL c)
429 stackPush(pVM->pStack, c);
434 /**************************************************************************
437 **************************************************************************/
438 void vmPopIP(FICL_VM *pVM)
440 pVM->ip = (IPTYPE)(stackPopPtr(pVM->rStack));
445 /**************************************************************************
448 **************************************************************************/
449 void vmPushIP(FICL_VM *pVM, IPTYPE newIP)
451 stackPushPtr(pVM->rStack, (void *)pVM->ip);
457 /**************************************************************************
459 ** Binds the specified input string to the VM and clears >IN (the index)
460 **************************************************************************/
461 void vmPushTib(FICL_VM *pVM, char *text, FICL_INT nChars, TIB *pSaveTib)
465 *pSaveTib = pVM->tib;
469 pVM->tib.end = text + nChars;
474 void vmPopTib(FICL_VM *pVM, TIB *pTib)
484 /**************************************************************************
487 **************************************************************************/
488 void vmQuit(FICL_VM *pVM)
490 stackReset(pVM->rStack);
493 pVM->runningWord = NULL;
494 pVM->state = INTERPRET;
504 /**************************************************************************
507 **************************************************************************/
508 void vmReset(FICL_VM *pVM)
511 stackReset(pVM->pStack);
513 stackReset(pVM->fStack);
520 /**************************************************************************
521 v m S e t T e x t O u t
522 ** Binds the specified output callback to the vm. If you pass NULL,
523 ** binds the default output function (ficlTextOut)
524 **************************************************************************/
525 void vmSetTextOut(FICL_VM *pVM, OUTFUNC textOut)
528 pVM->textOut = textOut;
530 pVM->textOut = ficlTextOut;
536 /**************************************************************************
538 ** Feeds text to the vm's output callback
539 **************************************************************************/
540 void vmTextOut(FICL_VM *pVM, char *text, int fNewline)
543 assert(pVM->textOut);
544 (pVM->textOut)(pVM, text, fNewline);
550 /**************************************************************************
553 **************************************************************************/
554 void vmThrow(FICL_VM *pVM, int except)
557 longjmp(*(pVM->pState), except);
561 void vmThrowErr(FICL_VM *pVM, char *fmt, ...)
565 vsprintf(pVM->pad, fmt, va);
566 vmTextOut(pVM, pVM->pad, 1);
568 longjmp(*(pVM->pState), VM_ERREXIT);
572 /**************************************************************************
573 w o r d I s I m m e d i a t e
575 **************************************************************************/
576 int wordIsImmediate(FICL_WORD *pFW)
578 return ((pFW != NULL) && (pFW->flags & FW_IMMEDIATE));
582 /**************************************************************************
583 w o r d I s C o m p i l e O n l y
585 **************************************************************************/
586 int wordIsCompileOnly(FICL_WORD *pFW)
588 return ((pFW != NULL) && (pFW->flags & FW_COMPILE));
592 /**************************************************************************
595 **************************************************************************/
596 char *strrev( char *string )
597 { /* reverse a string in-place */
598 int i = strlen(string);
599 char *p1 = string; /* first char of string */
600 char *p2 = string + i - 1; /* last non-NULL char of string */
618 /**************************************************************************
619 d i g i t _ t o _ c h a r
621 **************************************************************************/
622 char digit_to_char(int value)
624 return digits[value];
628 /**************************************************************************
629 i s P o w e r O f T w o
630 ** Tests whether supplied argument is an integer power of 2 (2**n)
631 ** where 32 > n > 1, and returns n if so. Otherwise returns zero.
632 **************************************************************************/
633 int isPowerOfTwo(FICL_UNS u)
638 for (; ((t <= u) && (t != 0)); i++, t <<= 1)
648 /**************************************************************************
651 **************************************************************************/
652 char *ltoa( FICL_INT value, char *string, int radix )
653 { /* convert long to string, any base */
655 int sign = ((radix == 10) && (value < 0));
662 pwr = isPowerOfTwo((FICL_UNS)radix);
671 FICL_UNS v = (FICL_UNS) value;
672 FICL_UNS mask = (FICL_UNS) ~(-1 << pwr);
675 *cp++ = digits[v & mask];
684 v.lo = (FICL_UNS)value;
687 result = ficlLongDiv(v, (FICL_UNS)radix);
688 *cp++ = digits[result.rem];
698 return strrev(string);
702 /**************************************************************************
705 **************************************************************************/
706 char *ultoa(FICL_UNS value, char *string, int radix )
707 { /* convert long to string, any base */
726 result = ficlLongDiv(ud, (FICL_UNS)radix);
728 *cp++ = digits[result.rem];
734 return strrev(string);
738 /**************************************************************************
740 ** Case folds a NULL terminated string in place. All characters
741 ** get converted to lower case.
742 **************************************************************************/
743 char *caseFold(char *cp)
750 *cp = (char)tolower(*cp);
758 /**************************************************************************
760 ** (jws) simplified the code a bit in hopes of appeasing Purify
761 **************************************************************************/
762 int strincmp(char *cp1, char *cp2, FICL_UNS count)
766 for (; 0 < count; ++cp1, ++cp2, --count)
768 i = tolower(*cp1) - tolower(*cp2);
771 else if (*cp1 == '\0')
777 /**************************************************************************
779 ** Given a string pointer, returns a pointer to the first non-space
780 ** char of the string, or to the NULL terminator if no such char found.
781 ** If the pointer reaches "end" first, stop there. Pass NULL to
782 ** suppress this behavior.
783 **************************************************************************/
784 char *skipSpace(char *cp, char *end)
788 while ((cp != end) && isspace(*cp))