Added 'platform abstraction layer' to abstract out the details of memory allocation...

diff --git a/SConstruct b/SConstruct
index 2303401125d9548dccf4555ece20e403a2263431..5399933c4100e565b6a9dc00f67f146a2c661617 100644 (file)
--- a/SConstruct
+++ b/SConstruct
@@ -4,6 +4,7 @@
 import platform
 import fnmatch
 import os
+import glob
 
 # Helper function for recursively finding files
 def find_files(path,pattern):
@@ -101,5 +102,7 @@ scheme.PrependENVPath('PATH', './build')
 #                    find_files('tests/slas/','*.scm') )
 
 # SCLPL Virtual Machine
-c_cpp.Program('build/slvm', find_files('source/slvm/','*.c'))
+c_cpp.Program('build/slvm',
+              glob.glob('source/slvm/*.c') +
+              glob.glob('source/slvm/platform/C99/*.c'))
 

diff --git a/source/slvm/main.c b/source/slvm/main.c
index df31dc8ff219e2d7bd1102f82d26e31890c02ba3..c859dd931437e6f49b7210227ffa095d80983275 100644 (file)
--- a/source/slvm/main.c
+++ b/source/slvm/main.c
@@ -6,6 +6,7 @@
 #include <limits.h>
 #include "slvm.h"
 #include "parser.h"
+#include "pal.h"
 
 /*
     Wish List:
@@ -29,17 +30,6 @@
     * Add support for multi-tasking with multiple cores/threads
 */
 
-/* System State
- *****************************************************************************/
-/** The argument stack */
-val_t ArgStack[ARG_STACK_SIZE];
-
-/** Pointer to current position on the stack */
-val_t* ArgStackPtr = ArgStack-1;
-
-/** Pointer to current instruction being executed */
-val_t* CodePtr = 0;
-
 /* Inner Interpreter
  *****************************************************************************/
 void docolon(val_t* code) {
@@ -76,32 +66,33 @@ defvar("latest", latest, 0, &state,  0);
 /* Word Words
  *****************************************************************************/
 defcode("wlink", wlink, 0, &latest){
-    *(ArgStackPtr) = (val_t)(((word_t*)*(ArgStackPtr))->link);
+    *(ArgStack) = (val_t)(((word_t*)*(ArgStack))->link);
 }
 
 defcode("wsize", wflags, 0, &wlink){
-    *(ArgStackPtr) = (val_t)(((word_t*)*(ArgStackPtr))->flags.attr.codesize);
+    *(ArgStack) = (val_t)(((word_t*)*(ArgStack))->flags.attr.codesize);
 }
 
 defcode("wname", wname, 0, &wflags){
-    *(ArgStackPtr) = (val_t)(((word_t*)*(ArgStackPtr))->name);
+    *(ArgStack) = (val_t)(((word_t*)*(ArgStack))->name);
 }
 
 defcode("wfunc", wfunc, 0, &wname){
-    *(ArgStackPtr) = (val_t)(((word_t*)*(ArgStackPtr))->codeword);
+    *(ArgStack) = (val_t)(((word_t*)*(ArgStack))->codeword);
 }
 
 defcode("wcode", wcode, 0, &wfunc){
-    *(ArgStackPtr) = (val_t)(((word_t*)*(ArgStackPtr))->code);
+    *(ArgStack) = (val_t)(((word_t*)*(ArgStack))->code);
 }
 
 defcode("here", here, 0, &wcode){
-    ArgStackPtr++;
-    *(ArgStackPtr) = (val_t)((((word_t*)latest_val)->flags.attr.codesize) - 1);
+    ArgStack++;
+    *(ArgStack) = (val_t)((((word_t*)latest_val)->flags.attr.codesize) - 1);
 }
 
 /* Input/Output Words
  *****************************************************************************/
+#if 0
 defvar("stdin",  _stdin,  0, &here,    0);
 defvar("stdout", _stdout, 0, &_stdin,  0);
 defvar("stderr", _stderr, 0, &_stdout, 0);
@@ -114,51 +105,52 @@ defconst("F_W+", f_wu, 0, &f_ru,    (val_t)"w+");
 defconst("F_A+", f_au, 0, &f_wu,    (val_t)"a+");
 
 defcode("fopen",  _fopen,  0, &f_au){
-    *(ArgStackPtr-1) = (val_t)fopen( (const char*)*(ArgStackPtr-1), (const char*)*(ArgStackPtr) );
-    ArgStackPtr--;
+    *(ArgStack-1) = (val_t)fopen( (const char*)*(ArgStack-1), (const char*)*(ArgStack) );
+    ArgStack--;
 }
 
 defcode("fclose", _fclose, 0, &_fopen){
-    fclose((FILE*)*(ArgStackPtr));
-    ArgStackPtr--;
+    fclose((FILE*)*(ArgStack));
+    ArgStack--;
 }
 
 defcode("fflush", _fflush, 0, &_fclose){
-    fflush((FILE*)*(ArgStackPtr));
-    ArgStackPtr--;
+    fflush((FILE*)*(ArgStack));
+    ArgStack--;
 }
 
 defcode("fgetc",  _fgetc,  0, &_fflush){
-    *(ArgStackPtr) = fgetc((FILE*)*(ArgStackPtr));
+    *(ArgStack) = fgetc((FILE*)*(ArgStack));
 }
 
 defcode("fputc",  _fputc,  0, &_fgetc){
-    fputc((char)*(ArgStackPtr-1), (FILE*)*(ArgStackPtr));
-    ArgStackPtr -= 2;
+    fputc((char)*(ArgStack-1), (FILE*)*(ArgStack));
+    ArgStack -= 2;
 }
 
 defcode("fputs",  _fputs,  0, &_fputc){
-    fputs((char*)*(ArgStackPtr-1), (FILE*)*(ArgStackPtr));
-    ArgStackPtr -= 2;
+    fputs((char*)*(ArgStack-1), (FILE*)*(ArgStack));
+    ArgStack -= 2;
 }
 
 defcode("fpeekc", _fpeekc, 0, &_fputs){
-    FILE* p_file = (FILE*)*(ArgStackPtr);
-    *(ArgStackPtr) = fgetc(p_file);
-    ungetc((char)*(ArgStackPtr), p_file);
+    FILE* p_file = (FILE*)*(ArgStack);
+    *(ArgStack) = fgetc(p_file);
+    ungetc((char)*(ArgStack), p_file);
 }
+#endif
 
 /* Interpreter Words
  *****************************************************************************/
-defcode("exec", exec, 0, &_fpeekc){
-    word_t* word = (word_t*)(*ArgStackPtr);
-    ArgStackPtr--;
+defcode("exec", exec, 0, &here){
+    word_t* word = (word_t*)(*ArgStack);
+    ArgStack--;
     EXEC( *(word) );
 }
 
 defcode("find", find, 0, &exec){
     word_t const* curr = (word_t const*)latest_val;
-    char* name = (char*)*(ArgStackPtr);
+    char* name = (char*)*(ArgStack);
     while(curr)
     {
         if (!(curr->flags.attr.hidden) && (0 == strcmp(curr->name,name)))
@@ -167,20 +159,20 @@ defcode("find", find, 0, &exec){
         }
         curr = curr->link;
     }
-    *(ArgStackPtr) = (val_t)curr;
+    *(ArgStack) = (val_t)curr;
 }
 
 defcode("fetch", _fetch, 0, &find){
-    ArgStackPtr++;
-    *(ArgStackPtr) = (val_t)fetch_token((FILE*)_stdin_val);
+    ArgStack++;
+    *(ArgStack) = (val_t)fetch_token();
 }
 
 defcode("parse", _parse, 0, &_fetch){
-    char* p_str = (char*)*(ArgStackPtr);
-    ArgStackPtr++;
-    *(ArgStackPtr) = (val_t)parse( p_str, ArgStackPtr-1 );
+    char* p_str = (char*)*(ArgStack);
+    ArgStack++;
+    *(ArgStack) = (val_t)parse( p_str, ArgStack-1 );
     /* If the parsed token no longer needs the original string */
-    if (*(ArgStackPtr) > STRING)
+    if (*(ArgStack) > STRING)
     {
         /* Free the mem */
         free(p_str);
@@ -190,8 +182,8 @@ defcode("parse", _parse, 0, &_fetch){
 /* Branching and Literal Words
  *****************************************************************************/
 defcode("lit", literal, 0, &_parse){
-    ArgStackPtr++;
-    *(ArgStackPtr) = *CodePtr;
+    ArgStack++;
+    *(ArgStack) = *CodePtr;
     CodePtr++;
 }
 
@@ -200,7 +192,7 @@ defcode("br", branch, 0, &literal){
 }
 
 defcode("0br", zbranch, 0, &branch){
-    if (*ArgStackPtr == 0)
+    if (*ArgStack == 0)
     {
         CodePtr = (val_t*)(((val_t)CodePtr) + (*(CodePtr) * sizeof(val_t)));
     }
@@ -208,7 +200,7 @@ defcode("0br", zbranch, 0, &branch){
     {
         CodePtr++;
     }
-    ArgStackPtr--;
+    ArgStack--;
 }
 
 /* Compiler Words
@@ -228,11 +220,11 @@ defcode("]", rbrack, 1, &lbrack){
 defcode("create", create, 0, &rbrack){
     /* Copy the name string */
     char* name = 0u;
-    if (*(ArgStackPtr))
+    if (*(ArgStack))
     {
-        size_t namesz = strlen((char*)*(ArgStackPtr));
+        size_t namesz = strlen((char*)*(ArgStack));
         name = (char*)malloc( namesz );
-        strcpy(name, (char*)*(ArgStackPtr));
+        strcpy(name, (char*)*(ArgStack));
     }
     /* Create the word entry */
     word_t* word   = (word_t*)malloc(sizeof(word_t));
@@ -248,7 +240,7 @@ defcode("create", create, 0, &rbrack){
     word->code[0]  = (val_t)&ret;
     /* Update Latest and Return the new word */
     latest_val     = (val_t)word;
-    *(ArgStackPtr) = (val_t)word;
+    *(ArgStack) = (val_t)word;
 }
 
 defcode(",", comma, 0, &create){
@@ -256,8 +248,8 @@ defcode(",", comma, 0, &create){
     word_t* word  = (word_t*)latest_val;
     /* Put the next instruction in place of the terminating 'ret' that "here"
      * points too */
-    word->code[word->flags.attr.codesize-1] = *(ArgStackPtr);
-    ArgStackPtr--;
+    word->code[word->flags.attr.codesize-1] = *(ArgStack);
+    ArgStack--;
     /* Resize the code section and relocate if necessary */
     word->flags.attr.codesize++;
     word->code = (val_t*)realloc(word->code, word->flags.attr.codesize * sizeof(val_t));
@@ -266,17 +258,17 @@ defcode(",", comma, 0, &create){
 }
 
 defcode("hidden", hidden, 1, &comma){
-    ((word_t*)*(ArgStackPtr))->flags.attr.hidden ^= 1;
+    ((word_t*)*(ArgStack))->flags.attr.hidden ^= 1;
 }
 
 defcode("immediate", immediate, 1, &hidden){
-    ((word_t*)*(ArgStackPtr))->flags.attr.immed ^= 1;
+    ((word_t*)*(ArgStack))->flags.attr.immed ^= 1;
 }
 
 defcode(":", colon, 0, &immediate){
     EXEC(_fetch);
     EXEC(_parse);
-    ArgStackPtr--;
+    ArgStack--;
     EXEC(create);
     EXEC(rbrack);
 }
@@ -284,13 +276,13 @@ defcode(":", colon, 0, &immediate){
 defcode(";", semicolon, 1, &colon){
     EXEC(lbrack);
     EXEC(hidden);
-    ArgStackPtr--;
+    ArgStack--;
 }
 
 defcode("'", tick, 1, &semicolon){
     EXEC(_fetch);
     EXEC(_parse);
-    ArgStackPtr--;
+    ArgStack--;
     EXEC(find);
 }
 
@@ -299,18 +291,18 @@ defcode("interp", interp, 0, &_parse){
     EXEC(_fetch);
     EXEC(_parse);
     /* If what we parsed was a word */
-    if(*ArgStackPtr == WORD)
+    if(*ArgStack == WORD)
     {
         /* Consume the type token and save off the string pointer */
-        ArgStackPtr--;
-        p_str = (char*)*ArgStackPtr;
+        ArgStack--;
+        p_str = (char*)*ArgStack;
         /* Search for the word in the dictionary */
         EXEC(find);
         /* If we found a definition */
-        if(*ArgStackPtr)
+        if(*ArgStack)
         {
             /* And the definition is marked immediate or we're in immediate mode */
-            if((state_val == 0) || (((word_t*)*ArgStackPtr)->flags.attr.immed))
+            if((state_val == 0) || (((word_t*)*ArgStack)->flags.attr.immed))
             {
                 /* Execute it */
                 EXEC(exec);
@@ -327,19 +319,19 @@ defcode("interp", interp, 0, &_parse){
             /* Ask the user what gives */
             printf("%s ?\n", p_str);
             /* Consume the token */
-            ArgStackPtr--;
+            ArgStack--;
         }
     }
     /* What we parsed is a literal and we're in compile mode */
     else if (state_val == 1)
     {
-        *(ArgStackPtr) = (val_t)&literal;
+        *(ArgStack) = (val_t)&literal;
         EXEC(comma);
         EXEC(comma);
     }
     else
     {
-        ArgStackPtr--;
+        ArgStack--;
     }
 
     /* If we saved off a pointer, we're done with it so free the memory */
@@ -347,187 +339,171 @@ defcode("interp", interp, 0, &_parse){
 }
 
 defcode("quit", quit, 0, &interp){
-    int i;
-    printf("=> ");
     while(1)
     {
+        pal_prompt();
         EXEC(interp);
-        if(line_read())
-        {
-            val_t stacksz = ArgStackPtr - ArgStack + 1;
-            if (stacksz > 5)
-                printf("( ... ");
-            else
-                printf("( ");
-
-            for(i = (stacksz > 5) ? 4 : stacksz-1; i >= 0; i--)
-            {
-                printf("%ld ", *(ArgStackPtr-i));
-            }
-            printf(")\n%s ", (state_val == 0) ? "=>" : "..");
-        }
-
     }
 }
 
 /* Stack Manipulation Words
  *****************************************************************************/
 defcode("drop", drop, 0, &tick){
-    ArgStackPtr--;
+    ArgStack--;
 }
 
 defcode("swap", swap, 0, &drop){
-    val_t temp = *(ArgStackPtr);
-    *(ArgStackPtr) = *(ArgStackPtr-1);
-    *(ArgStackPtr-1) = temp;
+    val_t temp = *(ArgStack);
+    *(ArgStack) = *(ArgStack-1);
+    *(ArgStack-1) = temp;
 }
 
 defcode("dup", dup, 0, &swap){
-    ArgStackPtr++;
-    *(ArgStackPtr) = *(ArgStackPtr-1);
+    ArgStack++;
+    *(ArgStack) = *(ArgStack-1);
 }
 
 defcode("over", over, 0, &dup){
-    ArgStackPtr++;
-    *(ArgStackPtr) = *(ArgStackPtr-2);
+    ArgStack++;
+    *(ArgStack) = *(ArgStack-2);
 }
 
 defcode("rot", rot, 0, &over){
-    val_t temp = *(ArgStackPtr);
-    *(ArgStackPtr) = *(ArgStackPtr-1);
-    *(ArgStackPtr-1) = *(ArgStackPtr-2);
-    *(ArgStackPtr-2) = temp;
+    val_t temp = *(ArgStack);
+    *(ArgStack) = *(ArgStack-1);
+    *(ArgStack-1) = *(ArgStack-2);
+    *(ArgStack-2) = temp;
 }
 
 defcode("-rot", nrot, 0, &rot){
-    val_t temp = *(ArgStackPtr-2);
-    *(ArgStackPtr-2) = *(ArgStackPtr-1);
-    *(ArgStackPtr-1) = *(ArgStackPtr);
-    *(ArgStackPtr) = temp;
+    val_t temp = *(ArgStack-2);
+    *(ArgStack-2) = *(ArgStack-1);
+    *(ArgStack-1) = *(ArgStack);
+    *(ArgStack) = temp;
 }
 
 /* Arithmetic Words
  *****************************************************************************/
 defcode("+", add, 0, &nrot){
-    *(ArgStackPtr-1) += *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) += *(ArgStack);
+    ArgStack--;
 }
 
 defcode("-", sub, 0, &add){
-    *(ArgStackPtr-1) -= *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) -= *(ArgStack);
+    ArgStack--;
 }
 
 defcode("*", mul, 0, &sub){
-    *(ArgStackPtr-1) *= *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) *= *(ArgStack);
+    ArgStack--;
 }
 
 defcode("/", divide, 0, &mul){
-    *(ArgStackPtr-1) /= *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) /= *(ArgStack);
+    ArgStack--;
 }
 
 defcode("%", mod, 0, &divide){
-    *(ArgStackPtr-1) %= *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) %= *(ArgStack);
+    ArgStack--;
 }
 
 /* Boolean Conditional Words
  *****************************************************************************/
 defcode("=", equal, 0, &mod){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) == *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) == *(ArgStack);
+    ArgStack--;
 }
 
 defcode("!=", notequal, 0, &equal){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) != *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) != *(ArgStack);
+    ArgStack--;
 }
 
 defcode("<", lessthan, 0, &notequal){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) < *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) < *(ArgStack);
+    ArgStack--;
 }
 
 defcode(">", greaterthan, 0, &lessthan){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) > *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) > *(ArgStack);
+    ArgStack--;
 }
 
 defcode("<=", lessthaneq, 0, &greaterthan){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) <= *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) <= *(ArgStack);
+    ArgStack--;
 }
 
 defcode(">=", greaterthaneq, 0, &lessthaneq){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) >= *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) >= *(ArgStack);
+    ArgStack--;
 }
 
 defcode("and", and, 0, &greaterthaneq){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) && *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) && *(ArgStack);
+    ArgStack--;
 }
 
 defcode("or", or, 0, &and){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) || *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) || *(ArgStack);
+    ArgStack--;
 }
 
 defcode("not", not, 0, &or){
-    *(ArgStackPtr) = !(*(ArgStackPtr));
+    *(ArgStack) = !(*(ArgStack));
 }
 
 /* Bitwise Words
  *****************************************************************************/
 defcode("band", band, 0, &not){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) & *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) & *(ArgStack);
+    ArgStack--;
 }
 
 defcode("bor", bor, 0, &band){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) | *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) | *(ArgStack);
+    ArgStack--;
 }
 
 defcode("bxor", bxor, 0, &bor){
-    *(ArgStackPtr-1) = *(ArgStackPtr-1) ^ *(ArgStackPtr);
-    ArgStackPtr--;
+    *(ArgStack-1) = *(ArgStack-1) ^ *(ArgStack);
+    ArgStack--;
 }
 
 defcode("bnot", bnot, 0, &bxor){
-    *(ArgStackPtr) = ~(*(ArgStackPtr));
+    *(ArgStack) = ~(*(ArgStack));
 }
 
 /* Memory Manipulation Words
  *****************************************************************************/
 defcode("!", store, 0, &bnot){
-    *((val_t*)*(ArgStackPtr)) = *(ArgStackPtr-1);
-    ArgStackPtr -= 2;
+    *((val_t*)*(ArgStack)) = *(ArgStack-1);
+    ArgStack -= 2;
 }
 
 defcode("@", fetch, 0, &store){
-    *(ArgStackPtr) = *((val_t*)*(ArgStackPtr));
+    *(ArgStack) = *((val_t*)*(ArgStack));
 }
 
 defcode("+!", addstore, 0, &fetch){
-    *((val_t*)*(ArgStackPtr)) += *(ArgStackPtr-1);
-    ArgStackPtr -= 2;
+    *((val_t*)*(ArgStack)) += *(ArgStack-1);
+    ArgStack -= 2;
 }
 
 defcode("-!", substore, 0, &addstore){
-    *((val_t*)*(ArgStackPtr)) -= *(ArgStackPtr-1);
-    ArgStackPtr -= 2;
+    *((val_t*)*(ArgStack)) -= *(ArgStack-1);
+    ArgStack -= 2;
 }
 
 defcode("b!", bytestore, 0, &substore){
-    *((char*)*(ArgStackPtr)) = (char)*(ArgStackPtr-1);
-    ArgStackPtr -= 2;
+    *((char*)*(ArgStack)) = (char)*(ArgStack-1);
+    ArgStack -= 2;
 }
 
 defcode("b@", bytefetch, 0, &bytestore){
-    *(ArgStackPtr) = *((char*)*(ArgStackPtr));
+    *(ArgStack) = *((char*)*(ArgStack));
 }
 
 defcode("b@b!", bytecopy, 0, &bytefetch){
@@ -538,18 +514,19 @@ defcode("bmove", bytemove, 0, &bytecopy){
 
 /* Control Flow Words
  *****************************************************************************/
+#if 0
 defcode("if", _if, 1, &bytemove){
     /* Compile branch instruction */
-    ArgStackPtr++;
-    *(ArgStackPtr) = (val_t)&zbranch;
+    ArgStack++;
+    *(ArgStack) = (val_t)&zbranch;
     EXEC(comma);
 
     /* Save off the current offset */
     EXEC(here);
 
     /* Compile a dummy offset */
-    ArgStackPtr++;
-    *(ArgStackPtr) = (val_t)0;
+    ArgStack++;
+    *(ArgStack) = (val_t)0;
     EXEC(comma);
 }
 
@@ -577,8 +554,8 @@ defcode("then", _then, 1, &_if){
 
 defcode("else", _else, 1, &_then){
     /* Compile the branch instruction */
-    ArgStackPtr++;
-    *(ArgStackPtr) = (val_t)&branch;
+    ArgStack++;
+    *(ArgStack) = (val_t)&branch;
     EXEC(comma);
 
     /* Save off the current offset */
@@ -586,37 +563,41 @@ defcode("else", _else, 1, &_then){
     EXEC(rot);
 
     /* Compile a dummy offset */
-    ArgStackPtr++;
-    *(ArgStackPtr) = 0;
+    ArgStack++;
+    *(ArgStack) = 0;
     EXEC(comma);
 
     /* Set the branch offset for the first branch */
     EXEC(_then);
     EXEC(swap);
 }
+#endif
 
 /* Memory Management Words
  *****************************************************************************/
+#if 0
 defcode("malloc", mem_alloc, 1, &_else){
-    *(ArgStackPtr) = (val_t)malloc((size_t)*(ArgStackPtr));
+    *(ArgStack) = (val_t)malloc((size_t)*(ArgStack));
 }
 
 defcode("mrealloc", mem_realloc, 1, &mem_alloc){
-    *(ArgStackPtr-1) = (val_t)realloc((void*)*(ArgStackPtr-1),*(ArgStackPtr));
-    ArgStackPtr--;
+    *(ArgStack-1) = (val_t)realloc((void*)*(ArgStack-1),*(ArgStack));
+    ArgStack--;
 }
 
 defcode("mfree", mem_free, 1, &mem_realloc){
-    free((void*)*(ArgStackPtr));
-    ArgStackPtr--;
+    free((void*)*(ArgStack));
+    ArgStack--;
 }
+#endif
 
 /* Debugging Words
  *****************************************************************************/
+#if 0
 defcode("printw", printw, 0, &mem_free){
-    word_t* word = (word_t*)*(ArgStackPtr);
+    word_t* word = (word_t*)*(ArgStack);
     val_t* bytecode = word->code;
-    ArgStackPtr--;
+    ArgStack--;
 
     printf("Name:     %s\n", word->name);
     //printf("Flags:    0x%lX\n", word->flags);
@@ -684,17 +665,25 @@ defcode("printdefw", printdefw, 0, &printallw){
         word = word->link;
     }
 }
+#endif
 
 /* Main
  *****************************************************************************/
 int main(int argc, char** argv)
 {
+    /* Default Kernel dictionary */
+    //static dict_t kernel_dict = { NULL, (word_t*)&bytemove };
+    /* Compile-time Assertions */
     CT_ASSERT(sizeof(val_t) == sizeof(val_t*));
     CT_ASSERT(sizeof(val_t) == sizeof(flags_t));
-    _stdin_val  = (val_t)stdin;
-    _stdout_val = (val_t)stdout;
-    _stderr_val = (val_t)stderr;
-    latest_val = (val_t)&printdefw;
+
+    /* Platform specific initialization */
+    //_stdin_val  = (val_t)stdin;
+    //_stdout_val = (val_t)stdout;
+    //_stderr_val = (val_t)stderr;
+    latest_val = (val_t)&bytemove;
+
+    /* Start the interpreter */
     EXEC(quit);
     return 0;
 }

diff --git a/source/slvm/pal.h b/source/slvm/pal.h
new file mode 100644 (file)
index 0000000..2b8f514
--- /dev/null
+++ b/source/slvm/pal.h
@@ -0,0 +1,26 @@
+/**
+  @file pal.h
+  @brief TODO: Describe this file
+  $Revision$
+  $HeadURL$
+*/
+#ifndef PAL_H
+#define PAL_H
+
+#include "slvm.h"
+#include <stdbool.h>
+#include <string.h>
+
+extern val_t* ArgStack;
+extern val_t* CodePtr;
+
+dict_t* pal_init(dict_t* p_prev_dict);
+void    pal_prompt(void);
+void*   pal_allocate(size_t size);
+void*   pal_reallocate(void* p_mem, size_t size);
+void    pal_free(void* p_mem);
+char    pal_read_char(void);
+char    pal_peek_char(void);
+bool    pal_is_eof(void);
+
+#endif /* PAL_H */

diff --git a/source/slvm/parser.c b/source/slvm/parser.c
index 5d4a5b131dac7422e54735b0727f9cb5d1fbf9a6..ab16e6cacd8e66c46ce20120eef1cd011eae2827 100644 (file)
--- a/source/slvm/parser.c
+++ b/source/slvm/parser.c
@@ -5,10 +5,10 @@
   $HeadURL$
   */
 #include "parser.h"
-#include <stdio.h>
+#include "pal.h"
 #include <stdbool.h>
-#include <stdlib.h>
 #include <string.h>
+#include <stdlib.h>
 
 /* Track Lines Read
  *****************************************************************************/
@@ -23,73 +23,72 @@ bool line_read(void)
 
 /* Fetching Tokens
  *****************************************************************************/
-static void skip_whitespace(FILE* input);
-static void skip_comment(FILE* input);
-static char* read_string(FILE* input);
-static char* read_token(FILE* input);
+static void skip_whitespace(void);
+static void skip_comment(void);
+static char* read_string(void);
+static char* read_token(void);
 static char* grow_token(size_t* p_size, size_t* p_index, char* p_str, char ch);
-static bool is_whitespace(FILE* input);
-static char fpeekc(FILE* input);
+static bool is_whitespace(void);
 
-char* fetch_token(FILE* input)
+char* fetch_token(void)
 {
     char* result = NULL;
-    skip_whitespace(input);
-    switch(fpeekc(input))
+    skip_whitespace();
+    switch(pal_peek_char())
     {
         case '#':
-            skip_comment(input);
-            result = fetch_token(input);
+            skip_comment();
+            result = fetch_token();
             break;
 
         case '"':
-            result = read_string(input);
+            result = read_string();
             break;
 
         case EOF:
             break;
 
         default:
-            result = read_token(input);
+            result = read_token();
             break;
 
     }
     return result;
 }
 
-static char* read_string(FILE* input)
+static char* read_string(void)
 {
     size_t strsize  = 8;
     size_t strindex = 0;
-    char*  string   = (char*)malloc(strsize);
+    char*  string   = (char*)pal_allocate(strsize);
 
-    string = grow_token(&strsize, &strindex, string, fgetc(input));
-    while('"' != fpeekc(input))
+    string = grow_token(&strsize, &strindex, string, pal_read_char());
+    while('"' != pal_peek_char())
     {
-        if(feof(input)) {
-            free(string);
+        if(pal_is_eof()) {
+            pal_free(string);
             return NULL;
         }
-        string = grow_token(&strsize, &strindex, string, fgetc(input));
+        string = grow_token(&strsize, &strindex, string, pal_read_char());
     }
-    string = grow_token(&strsize, &strindex, string, fgetc(input));
+    string = grow_token(&strsize, &strindex, string, pal_read_char());
 
     return string;
 }
 
-static char* read_token(FILE* input)
+static char* read_token(void)
 {
     size_t strsize  = 8;
     size_t strindex = 0;
-    char*  string   = (char*)malloc(strsize);
+    char*  string   = (char*)pal_allocate(strsize);
 
-    while(!is_whitespace(input))
+    while(!is_whitespace())
     {
-        if(feof(input)) {
-            free(string);
+        if(pal_is_eof()) {
+            pal_free(string);
             return NULL;
         }
-        string = grow_token(&strsize, &strindex, string, fgetc(input));
+        string = grow_token(&strsize, &strindex, string, pal_read_char());
     }
 
     return string;
@@ -102,7 +101,7 @@ static char* grow_token(size_t* p_size, size_t* p_index, char* p_str, char ch)
     {
         /* Double the string size */
         *(p_size) *= 2;
-        p_str = (char*)realloc( p_str, *(p_size) );
+        p_str = (char*)pal_reallocate( p_str, *(p_size) );
     }
     /* Set the current char to the provided value and null terminate the str */
     p_str[ *(p_index) ]  = ch;
@@ -112,37 +111,30 @@ static char* grow_token(size_t* p_size, size_t* p_index, char* p_str, char ch)
     return p_str;
 }
 
-static void skip_whitespace(FILE* input)
+static void skip_whitespace(void)
 {
-    while(!feof(input) && is_whitespace(input))
+    while(!pal_is_eof() && is_whitespace())
     {
-        (void)fgetc(input);
+        (void)pal_read_char();
     }
 }
 
-static void skip_comment(FILE* input)
+static void skip_comment(void)
 {
-    while(!feof(input) && ('\n' != fgetc(input)))
+    while(!pal_is_eof() && ('\n' != pal_read_char()))
     {
     }
 }
 
-static bool is_whitespace(FILE* input)
+static bool is_whitespace(void)
 {
-    char ch = fpeekc(input);
+    char ch = pal_peek_char();
     bool res = ((ch == ' ')  || (ch == '\t') || (ch == '\r') || (ch == '\n'));
     if (ch == '\n')
         Line_Read = true;
     return res;
 }
 
-static char fpeekc(FILE* input)
-{
-    char ch = fgetc(input);
-    ungetc(ch,input);
-    return ch;
-}
-
 /* Parsing Tokens
  *****************************************************************************/
 static bool is_integer(char* p_str, val_t* p_val);

diff --git a/source/slvm/parser.h b/source/slvm/parser.h
index f3eea3d05ba23ecb866d9f92e96e511a8abac560..b618be57a9ac0868aeda1f6b6ea3d616d259b471 100644 (file)
--- a/source/slvm/parser.h
+++ b/source/slvm/parser.h
@@ -20,7 +20,7 @@ typedef enum {
     FLOAT,
 } TokenType_T;
 
-char* fetch_token(FILE* input);
+char* fetch_token(void);
 
 TokenType_T parse(char* str, val_t* p_val);
 

diff --git a/source/slvm/platform/C99/pal.c b/source/slvm/platform/C99/pal.c
new file mode 100644 (file)
index 0000000..247a3a4
--- /dev/null
+++ b/source/slvm/platform/C99/pal.c
@@ -0,0 +1,77 @@
+/**
+  @file pal.c
+  @brief See header for details
+  $Revision$
+  $HeadURL$
+*/
+#include "../../pal.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+static val_t Stack[ARG_STACK_SIZE];
+static bool Line_Read = true;
+val_t* ArgStack = Stack - 1;
+val_t* CodePtr = 0;
+
+dict_t* pal_init(dict_t* p_prev_dict)
+{
+    return p_prev_dict;
+}
+
+void pal_prompt(void)
+{
+    int i;
+    if(Line_Read)
+    {
+        val_t stacksz = ArgStack - Stack + 1;
+        if (stacksz > 5)
+            printf("( ... ");
+        else
+            printf("( ");
+
+        for(i = (stacksz > 5) ? 4 : stacksz-1; i >= 0; i--)
+        {
+            printf("%ld ", *(ArgStack-i));
+        }
+        printf(")\n%s ", "=>"); //(state_val == 0) ? "=>" : "..");
+        Line_Read = false;
+    }
+}
+
+void* pal_allocate(size_t size)
+{
+    return malloc(size);
+}
+
+void* pal_reallocate(void* p_mem, size_t size)
+{
+    return realloc(p_mem, size);
+}
+
+void pal_free(void* p_mem)
+{
+    free(p_mem);
+}
+
+char pal_read_char(void)
+{
+    return fgetc(stdin);
+}
+
+char pal_peek_char(void)
+{
+    char ch = fgetc(stdin);
+    ungetc(ch,stdin);
+    if ((ch == '\n') || (ch == '\r'))
+    {
+        Line_Read = true;
+    }
+    return ch;
+}
+
+bool pal_is_eof(void)
+{
+    return feof(stdin);
+}
+
+

diff --git a/source/slvm/slvm.h b/source/slvm/slvm.h
index f56399c12a3f882c0a448565b9c3cc2a6a7c11e1..d25ba295a185bf5b15b5b8b01b9c6b7b57a7cf87 100644 (file)
--- a/source/slvm/slvm.h
+++ b/source/slvm/slvm.h
@@ -27,7 +27,7 @@
     The number of bits of the flags field dedicated to holding the size of the
     bytecode vector.
 */
-#define CODE_SZ_BITS ((sizeof(val_t) * 8) - 8u)
+#define CODE_SZ_BITS ((sizeof(val_t) * 8u) - 8u)
 
 /**
     This type represents a pointer to a function handler for executing a word.
@@ -109,19 +109,19 @@ typedef struct dict_t {
 /**
  * Define a built-in word representing a variable with the provided initial value */
 #define defvar(name_str,c_name,immed,prev,initial) \
-    static val_t c_name##_val = initial;            \
+    static val_t c_name##_val = initial;           \
     defcode(name_str,c_name,immed,prev) {          \
-        ArgStackPtr++;                             \
-        *(ArgStackPtr) = (val_t)&(c_name##_val);    \
+        ArgStack++;                                \
+        *(ArgStack) = (val_t)&(c_name##_val);      \
     }
 
 /**
  * Define a built-in word representing a constant with the provided value */
 #define defconst(name_str,c_name,immed,prev,value) \
-    static val_t const c_name##_val = value;        \
+    static val_t const c_name##_val = value;       \
     defcode(name_str,c_name,immed,prev) {          \
-        ArgStackPtr++;                             \
-        *(ArgStackPtr) = c_name##_val;             \
+        ArgStack++;                                \
+        *(ArgStack) = c_name##_val;                \
     }
 
 /**