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 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;
}
/**************************************************************************
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;
}