void simon(void) { int returnValue = 0; char buffer[256]; ficlVm *vm; int led_id; if (simon_system == NULL) simon_boot(NULL); vm = ficlSystemCreateVm(simon_system); led_id = ledOpen(fileno(stdin),fileno(stdout),100); while (returnValue != FICL_VM_STATUS_USER_EXIT) { fputs(FICL_PROMPT, stdout); fflush(stdout); ledRead(led_id,buffer,sizeof(buffer)); returnValue = ficlVmEvaluate(vm, buffer); } ledClose(led_id); ficlSystemDestroyVm(vm); }
static int spawn_helper ( int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6, int arg7, int arg8, int arg9 ) { unsigned command = arg0; char *taskName = (char *)arg1; ficlVm *vm; char eval[20]; sprintf(eval,"0x%x execute\n",command); vm = ficlSystemCreateVm(simon_system); ficlVmEvaluate(vm,eval); ficlSystemDestroyVm(vm); free(taskName); return 0; }
int main(int argc, char **argv) { int returnValue = 0; char buffer[256]; char *gotline; ficlVm *vm; ficlSystem *system; system = ficlSystemCreate(NULL); ficlSystemCompileExtras(system); vm = ficlSystemCreateVm(system); returnValue = ficlVmEvaluate(vm, ".ver .( " __DATE__ " ) cr quit"); /* ** load files specified on command-line */ if (argc > 1) { sprintf(buffer, ".( loading %s ) cr load %s\n cr", argv[1], argv[1]); returnValue = ficlVmEvaluate(vm, buffer); } while (returnValue != FICL_VM_STATUS_USER_EXIT) { fputs(FICL_PROMPT, stdout); gotline = fgets(buffer, sizeof(buffer), stdin); returnValue = ficlVmEvaluate(vm, gotline); } ficlSystemDestroy(system); return 0; }
/* * Initialise the Forth interpreter, create all our commands as words. */ void bf_init(char *rc) { struct bootblk_command **cmdp; char create_buf[41]; /* 31 characters-long builtins */ int fd, rv; ficlDictionary *dict; ficlDictionary *env; fsi = malloc(sizeof (ficlSystemInformation)); ficlSystemInformationInitialize(fsi); fsi->dictionarySize = BF_DICTSIZE; bf_sys = ficlSystemCreate(fsi); bf_vm = ficlSystemCreateVm(bf_sys); /* Put all private definitions in a "builtins" vocabulary */ rv = ficlVmEvaluate(bf_vm, "vocabulary builtins also builtins definitions"); if (rv != FICL_VM_STATUS_OUT_OF_TEXT) { panic("error interpreting forth: %d", rv); } /* Builtin constructor word */ rv = ficlVmEvaluate(bf_vm, BUILTIN_CONSTRUCTOR); if (rv != FICL_VM_STATUS_OUT_OF_TEXT) { panic("error interpreting forth: %d", rv); } /* make all commands appear as Forth words */ dict = ficlSystemGetDictionary(bf_sys); SET_FOREACH(cmdp, Xcommand_set) { ficlDictionaryAppendPrimitive(dict, (char *)(*cmdp)->c_name, bf_command, FICL_WORD_DEFAULT); rv = ficlVmEvaluate(bf_vm, "forth definitions builtins"); if (rv != FICL_VM_STATUS_OUT_OF_TEXT) { panic("error interpreting forth: %d", rv); } sprintf(create_buf, "builtin: %s", (*cmdp)->c_name); rv = ficlVmEvaluate(bf_vm, create_buf); if (rv != FICL_VM_STATUS_OUT_OF_TEXT) { panic("error interpreting forth: %d", rv); } rv = ficlVmEvaluate(bf_vm, "builtins definitions"); if (rv != FICL_VM_STATUS_OUT_OF_TEXT) { panic("error interpreting forth: %d", rv); } }
void full_simon(void) { int returnValue = 0; char buffer[256]; ficlVm *vm; ficlSystem *system; ficlSystemInformation fsi; ficlDictionary *dict; FILE *fd; int led_id; ficlSystemInformationInitialize(&fsi); fsi.dictionarySize = 256*1024; printf("creating ficl system\n"); system = ficlSystemCreate(&fsi); printf("compiling ficl extras\n"); ficlSystemCompileExtras(system); printf("creating ficl vm\n"); vm = ficlSystemCreateVm(system); printf("initializing silkworm customizations\n"); rf_spi_init(vm); printf("getting ficl version\n"); returnValue = ficlVmEvaluate(vm, ".ver .( " __DATE__ " ) cr quit"); simon_init(vm); rf_spi_init(vm); printf("ficl initialization complete\n"); led_id = ledOpen(fileno(stdin),fileno(stdout),100); while (returnValue != FICL_VM_STATUS_USER_EXIT) { fputs(FICL_PROMPT, stdout); fflush(stdout); ledRead(led_id,buffer,sizeof(buffer)); returnValue = ficlVmEvaluate(vm, buffer); } ledClose(led_id); ficlSystemDestroy(system); }
int simon_boot(char *eval) { ficlVm *vm; ficlSystemInformation fsi; ficlSystemInformationInitialize(&fsi); fsi.dictionarySize = 256*1024; simon_system = ficlSystemCreate(&fsi); ficlSystemCompileExtras(simon_system); vm = ficlSystemCreateVm(simon_system); simon_init(vm); rf_spi_init(vm); if (eval != NULL) ficlVmEvaluate(vm,eval); ficlSystemDestroyVm(vm); return 0; }
FICL_PLATFORM_EXTERN ficlVm *ficlNewVM(ficlSystem *system) { ficlVm *returnValue = ficlSystemCreateVm(system); if (returnValue != NULL) { if ((returnValue->callback.textOut != NULL) && (returnValue->callback.textOut != thunkTextOut)) { returnValue->thunkedTextout = (ficlCompatibilityOutputFunction)returnValue->callback.textOut; returnValue->callback.textOut = thunkTextOut; } if ((returnValue->callback.errorOut != NULL) && (returnValue->callback.errorOut != thunkTextOut)) { if (returnValue->thunkedTextout == NULL) returnValue->thunkedTextout = (ficlCompatibilityOutputFunction)returnValue->callback.errorOut; returnValue->callback.errorOut = thunkTextOut; } } return returnValue; }
int main(int argc, char **argv) { int returnValue = 0; char buffer[256]; ficlVm *vm; ficlSystem *system; int i=0; int ch; char *fileName=(char *)NULL; char *loadPath=(char *)NULL; strcpy(prompt, FICL_PROMPT); verbose=-1; // Default is to be talkative. i = tcgetattr( 0, &orig_termios); loadPath = getenv("FICL_PATH"); system = ficlSystemCreate(NULL); ficlSystemCompileExtras(system); vm = ficlSystemCreateVm(system); if(verbose !=0) { returnValue = ficlVmEvaluate(vm, ".ver .( " __DATE__ " ) cr quit"); // returnValue = ficlVmEvaluate(vm, ".ver cr quit"); } while (returnValue != FICL_VM_STATUS_USER_EXIT) { // fputs(FICL_PROMPT, stdout); fputs(prompt, stdout); if (fgets(buffer, sizeof(buffer), stdin) == NULL) break; returnValue = ficlVmEvaluate(vm, buffer); } ficlSystemDestroy(system); return 0; }
/************************************************************************** f i c l I n i t S y s t e m ** Binds a global dictionary to the interpreter system. ** You specify the address and size of the allocated area. ** After that, Ficl manages it. ** First step is to set up the static pointers to the area. ** Then write the "precompiled" portion of the dictionary in. ** The dictionary needs to be at least large enough to hold the ** precompiled part. Try 1K cells minimum. Use "words" to find ** out how much of the dictionary is used at any time. **************************************************************************/ ficlSystem *ficlSystemCreate(ficlSystemInformation *fsi) { ficlInteger dictionarySize; ficlInteger environmentSize; ficlInteger stackSize; ficlSystem *system; ficlCallback callback; ficlSystemInformation fauxInfo; ficlDictionary *environment; if (fsi == NULL) { fsi = &fauxInfo; ficlSystemInformationInitialize(fsi); } callback.context = fsi->context; callback.textOut = fsi->textOut; callback.errorOut = fsi->errorOut; callback.system = NULL; callback.vm = NULL; FICL_ASSERT(&callback, sizeof(ficlInteger) == sizeof(void *)); FICL_ASSERT(&callback, sizeof(ficlUnsigned) == sizeof(void *)); #if (FICL_WANT_FLOAT) FICL_ASSERT(&callback, sizeof(ficlFloat) == sizeof(void *)); #endif system = ficlMalloc(sizeof(ficlSystem)); FICL_ASSERT(&callback, system); memset(system, 0, sizeof(ficlSystem)); dictionarySize = fsi->dictionarySize; if (dictionarySize <= 0) dictionarySize = FICL_DEFAULT_DICTIONARY_SIZE; environmentSize = fsi->environmentSize; if (environmentSize <= 0) environmentSize = FICL_DEFAULT_DICTIONARY_SIZE; stackSize = fsi->stackSize; if (stackSize < FICL_DEFAULT_STACK_SIZE) stackSize = FICL_DEFAULT_STACK_SIZE; system->dictionary = ficlDictionaryCreateHashed(system, (unsigned)dictionarySize, FICL_HASH_SIZE); system->dictionary->forthWordlist->name = "forth-wordlist"; environment = ficlDictionaryCreate(system, (unsigned)environmentSize); system->environment = environment; system->environment->forthWordlist->name = "environment"; system->callback.textOut = fsi->textOut; system->callback.errorOut = fsi->errorOut; system->callback.context = fsi->context; system->callback.system = system; system->callback.vm = NULL; system->stackSize = stackSize; #if FICL_WANT_LOCALS /* ** The locals dictionary is only searched while compiling, ** but this is where speed is most important. On the other ** hand, the dictionary gets emptied after each use of locals ** The need to balance search speed with the cost of the 'empty' ** operation led me to select a single-threaded list... */ system->locals = ficlDictionaryCreate(system, (unsigned)FICL_MAX_LOCALS * FICL_CELLS_PER_WORD); #endif /* FICL_WANT_LOCALS */ /* ** Build the precompiled dictionary and load softwords. We need a temporary ** VM to do this - ficlNewVM links one to the head of the system VM list. ** ficlCompilePlatform (defined in win32.c, for example) adds platform specific words. */ ficlSystemCompileCore(system); ficlSystemCompilePrefix(system); #if FICL_WANT_FLOAT ficlSystemCompileFloat(system); #endif /* FICL_WANT_FLOAT */ #if FICL_WANT_PLATFORM ficlSystemCompilePlatform(system); #endif /* FICL_WANT_PLATFORM */ ficlSystemSetVersion(system); /* ** Establish the parse order. Note that prefixes precede numbers - ** this allows constructs like "0b101010" which might parse as a ** hex value otherwise. */ ficlSystemAddPrimitiveParseStep(system, "?word", ficlVmParseWord); ficlSystemAddPrimitiveParseStep(system, "?prefix", ficlVmParsePrefix); ficlSystemAddPrimitiveParseStep(system, "?number", ficlVmParseNumber); #if FICL_WANT_FLOAT ficlSystemAddPrimitiveParseStep(system, "?float", ficlVmParseFloatNumber); #endif /* ** Now create a temporary VM to compile the softwords. Since all VMs are ** linked into the vmList of ficlSystem, we don't have to pass the VM ** to ficlCompileSoftCore -- it just hijacks whatever it finds in the VM list. ** Ficl 2.05: vmCreate no longer depends on the presence of INTERPRET in the ** dictionary, so a VM can be created before the dictionary is built. It just ** can't do much... */ ficlSystemCreateVm(system); #define ADD_COMPILE_FLAG(name) ficlDictionarySetConstant(environment, #name, name) ADD_COMPILE_FLAG(FICL_WANT_LZ_SOFTCORE); ADD_COMPILE_FLAG(FICL_WANT_FILE); ADD_COMPILE_FLAG(FICL_WANT_FLOAT); ADD_COMPILE_FLAG(FICL_WANT_DEBUGGER); ADD_COMPILE_FLAG(FICL_WANT_EXTENDED_PREFIX); ADD_COMPILE_FLAG(FICL_WANT_USER); ADD_COMPILE_FLAG(FICL_WANT_LOCALS); ADD_COMPILE_FLAG(FICL_WANT_OOP); ADD_COMPILE_FLAG(FICL_WANT_SOFTWORDS); ADD_COMPILE_FLAG(FICL_WANT_MULTITHREADED); ADD_COMPILE_FLAG(FICL_WANT_OPTIMIZE); ADD_COMPILE_FLAG(FICL_WANT_VCALL); ADD_COMPILE_FLAG(FICL_PLATFORM_ALIGNMENT); ADD_COMPILE_FLAG(FICL_ROBUST); #define ADD_COMPILE_STRING(name) ficlDictionarySetConstantString(environment, #name, name) ADD_COMPILE_STRING(FICL_PLATFORM_ARCHITECTURE); ADD_COMPILE_STRING(FICL_PLATFORM_OS); ficlSystemCompileSoftCore(system); ficlSystemDestroyVm(system->vmList); if (ficlSystemGlobal == NULL) ficlSystemGlobal = system; return system; }