#include "pfcompil.h"\r
\r
#define ABORT_RETURN_CODE (10)\r
-#define UINT32_MASK ((sizeof(uint32)-1))\r
+#define UINT32_MASK ((sizeof(ucell_t)-1))\r
\r
/***************************************************************/\r
/************** Static Prototypes ******************************/\r
/***************************************************************/\r
\r
static void ffStringColon( const ForthStringPtr FName );\r
-static int32 CheckRedefinition( const ForthStringPtr FName );\r
+static cell_t CheckRedefinition( const ForthStringPtr FName );\r
static void ffUnSmudge( void );\r
-static int32 FindAndCompile( const char *theWord );\r
-static int32 ffCheckDicRoom( void );\r
+static cell_t FindAndCompile( const char *theWord );\r
+static cell_t ffCheckDicRoom( void );\r
\r
#ifndef PF_NO_INIT\r
static void CreateDeferredC( ExecToken DefaultXT, const char *CName );\r
#endif\r
\r
-int32 NotCompiled( const char *FunctionName )\r
+cell_t NotCompiled( const char *FunctionName )\r
{\r
MSG("Function ");\r
MSG(FunctionName);\r
** Create an entry in the Dictionary for the given ExecutionToken.\r
** FName is name in Forth format.\r
*/\r
-void CreateDicEntry( ExecToken XT, const ForthStringPtr FName, uint32 Flags )\r
+void CreateDicEntry( ExecToken XT, const ForthStringPtr FName, ucell_t Flags )\r
{\r
cfNameLinks *cfnl;\r
\r
- cfnl = (cfNameLinks *) gCurrentDictionary->dic_HeaderPtr.Byte;\r
+ cfnl = (cfNameLinks *) gCurrentDictionary->dic_HeaderPtr;\r
\r
/* Set link to previous header, if any. */\r
if( gVarContext )\r
{\r
- WRITE_LONG_DIC( &cfnl->cfnl_PreviousName, ABS_TO_NAMEREL( gVarContext ) );\r
+ WRITE_CELL_DIC( &cfnl->cfnl_PreviousName, ABS_TO_NAMEREL( gVarContext ) );\r
}\r
else\r
{\r
}\r
\r
/* Put Execution token in header. */\r
- WRITE_LONG_DIC( &cfnl->cfnl_ExecToken, XT );\r
+ WRITE_CELL_DIC( &cfnl->cfnl_ExecToken, XT );\r
\r
/* Advance Header Dictionary Pointer */\r
- gCurrentDictionary->dic_HeaderPtr.Byte += sizeof(cfNameLinks);\r
+ gCurrentDictionary->dic_HeaderPtr += sizeof(cfNameLinks);\r
\r
/* Laydown name. */\r
- gVarContext = (char *) gCurrentDictionary->dic_HeaderPtr.Byte;\r
- pfCopyMemory( gCurrentDictionary->dic_HeaderPtr.Byte, FName, (*FName)+1 );\r
- gCurrentDictionary->dic_HeaderPtr.Byte += (*FName)+1;\r
+ gVarContext = (char *) gCurrentDictionary->dic_HeaderPtr;\r
+ pfCopyMemory( (char *)gCurrentDictionary->dic_HeaderPtr, FName, (*FName)+1 );\r
+ gCurrentDictionary->dic_HeaderPtr += (*FName)+1;\r
\r
/* Set flags. */\r
- *gVarContext |= (char) Flags;\r
+ *(char*)gVarContext |= (char) Flags;\r
\r
/* Align to quad byte boundaries with zeroes. */\r
- while( ((uint32) gCurrentDictionary->dic_HeaderPtr.Byte) & UINT32_MASK )\r
+ while( gCurrentDictionary->dic_HeaderPtr & UINT32_MASK )\r
{\r
- *gCurrentDictionary->dic_HeaderPtr.Byte++ = 0;\r
+ *(char*)(gCurrentDictionary->dic_HeaderPtr++) = 0;\r
}\r
}\r
\r
/***************************************************************\r
** Convert name then create dictionary entry.\r
*/\r
-void CreateDicEntryC( ExecToken XT, const char *CName, uint32 Flags )\r
+void CreateDicEntryC( ExecToken XT, const char *CName, ucell_t Flags )\r
{\r
ForthString FName[40];\r
CStringToForth( FName, CName );\r
*/\r
const ForthString *NameToPrevious( const ForthString *NFA )\r
{\r
- cell RelNamePtr;\r
+ cell_t RelNamePtr;\r
const cfNameLinks *cfnl;\r
\r
-/* DBUG(("\nNameToPrevious: NFA = 0x%x\n", (int32) NFA)); */\r
+/* DBUG(("\nNameToPrevious: NFA = 0x%x\n", (cell_t) NFA)); */\r
cfnl = (const cfNameLinks *) ( ((const char *) NFA) - sizeof(cfNameLinks) );\r
\r
- RelNamePtr = READ_LONG_DIC((const cell *) (&cfnl->cfnl_PreviousName));\r
-/* DBUG(("\nNameToPrevious: RelNamePtr = 0x%x\n", (int32) RelNamePtr )); */\r
+ RelNamePtr = READ_CELL_DIC((const cell_t *) (&cfnl->cfnl_PreviousName));\r
+/* DBUG(("\nNameToPrevious: RelNamePtr = 0x%x\n", (cell_t) RelNamePtr )); */\r
if( RelNamePtr )\r
{\r
return ( NAMEREL_TO_ABS( RelNamePtr ) );\r
/* Convert absolute namefield address to absolute link field address. */\r
cfnl = (const cfNameLinks *) ( ((const char *) NFA) - sizeof(cfNameLinks) );\r
\r
- return READ_LONG_DIC((const cell *) (&cfnl->cfnl_ExecToken));\r
+ return READ_CELL_DIC((const cell_t *) (&cfnl->cfnl_ExecToken));\r
}\r
\r
/***************************************************************\r
** Find XTs needed by compiler.\r
*/\r
-int32 FindSpecialXTs( void )\r
+cell_t FindSpecialXTs( void )\r
{\r
if( ffFindC( "(QUIT)", &gQuitP_XT ) == 0) goto nofind;\r
if( ffFindC( "NUMBER?", &gNumberQ_XT ) == 0) goto nofind;\r
if( ffFindC( "ACCEPT", &gAcceptP_XT ) == 0) goto nofind;\r
-DBUG(("gNumberQ_XT = 0x%x\n", gNumberQ_XT ));\r
+DBUG(("gNumberQ_XT = 0x%x\n", (unsigned int)gNumberQ_XT ));\r
return 0;\r
\r
nofind:\r
** Build a dictionary from scratch.\r
*/\r
#ifndef PF_NO_INIT\r
-PForthDictionary pfBuildDictionary( int32 HeaderSize, int32 CodeSize )\r
+PForthDictionary pfBuildDictionary( cell_t HeaderSize, cell_t CodeSize )\r
{\r
pfDictionary_t *dic;\r
\r
CreateDicEntryC( ID_BODY_OFFSET, "BODY_OFFSET", 0 );\r
CreateDicEntryC( ID_BYE, "BYE", 0 );\r
CreateDicEntryC( ID_CATCH, "CATCH", 0 );\r
+ CreateDicEntryC( ID_CELL, "CELL", 0 );\r
+ CreateDicEntryC( ID_CELLS, "CELLS", 0 );\r
CreateDicEntryC( ID_CFETCH, "C@", 0 );\r
CreateDicEntryC( ID_CMOVE, "CMOVE", 0 );\r
CreateDicEntryC( ID_CMOVE_UP, "CMOVE>", 0 );\r
** ( xt -- nfa 1 , x 0 , find NFA in dictionary from XT )\r
** 1 for IMMEDIATE values\r
*/\r
-cell ffTokenToName( ExecToken XT, const ForthString **NFAPtr )\r
+cell_t ffTokenToName( ExecToken XT, const ForthString **NFAPtr )\r
{\r
const ForthString *NameField;\r
- int32 Searching = TRUE;\r
- cell Result = 0;\r
+ cell_t Searching = TRUE;\r
+ cell_t Result = 0;\r
ExecToken TempXT;\r
\r
NameField = gVarContext;\r
** ( $name -- $addr 0 | nfa -1 | nfa 1 , find NFA in dictionary )\r
** 1 for IMMEDIATE values\r
*/\r
-cell ffFindNFA( const ForthString *WordName, const ForthString **NFAPtr )\r
+cell_t ffFindNFA( const ForthString *WordName, const ForthString **NFAPtr )\r
{\r
const ForthString *WordChar;\r
- uint8 WordLen;\r
+ uint8_t WordLen;\r
const char *NameField, *NameChar;\r
- int8 NameLen;\r
- int32 Searching = TRUE;\r
- cell Result = 0;\r
+ int8_t NameLen;\r
+ cell_t Searching = TRUE;\r
+ cell_t Result = 0;\r
\r
- WordLen = (uint8) ((uint32)*WordName & 0x1F);\r
+ WordLen = (uint8_t) ((ucell_t)*WordName & 0x1F);\r
WordChar = WordName+1;\r
\r
NameField = gVarContext;\r
DBUG(("\nffFindNFA: gVarContext = 0x%x\n", gVarContext));\r
do\r
{\r
- NameLen = (uint8) ((uint32)(*NameField) & MASK_NAME_SIZE);\r
+ NameLen = (uint8_t) ((ucell_t)(*NameField) & MASK_NAME_SIZE);\r
NameChar = NameField+1;\r
/* DBUG((" %c\n", (*NameField & FLAG_SMUDGE) ? 'S' : 'V' )); */\r
if( ((*NameField & FLAG_SMUDGE) == 0) &&\r
** ( $name -- $name 0 | xt -1 | xt 1 )\r
** 1 for IMMEDIATE values\r
*/\r
-cell ffFind( const ForthString *WordName, ExecToken *pXT )\r
+cell_t ffFind( const ForthString *WordName, ExecToken *pXT )\r
{\r
const ForthString *NFA;\r
- int32 Result;\r
+ cell_t Result;\r
\r
Result = ffFindNFA( WordName, &NFA );\r
DBUG(("ffFind: %8s at 0x%x\n", WordName+1, NFA)); /* WARNING, not NUL terminated. %Q */\r
/****************************************************************\r
** Find name when passed 'C' string.\r
*/\r
-cell ffFindC( const char *WordName, ExecToken *pXT )\r
+cell_t ffFindC( const char *WordName, ExecToken *pXT )\r
{\r
DBUG(("ffFindC: %s\n", WordName ));\r
CStringToForth( gScratch, WordName );\r
/*************************************************************\r
** Check for dictionary overflow. \r
*/\r
-static int32 ffCheckDicRoom( void )\r
+static cell_t ffCheckDicRoom( void )\r
{\r
- int32 RoomLeft;\r
- RoomLeft = gCurrentDictionary->dic_HeaderLimit -\r
- gCurrentDictionary->dic_HeaderPtr.Byte;\r
+ cell_t RoomLeft;\r
+ RoomLeft = (char *)gCurrentDictionary->dic_HeaderLimit -\r
+ (char *)gCurrentDictionary->dic_HeaderPtr;\r
if( RoomLeft < DIC_SAFETY_MARGIN )\r
{\r
pfReportError("ffCheckDicRoom", PF_ERR_HEADER_ROOM);\r
return PF_ERR_HEADER_ROOM;\r
}\r
\r
- RoomLeft = gCurrentDictionary->dic_CodeLimit -\r
- gCurrentDictionary->dic_CodePtr.Byte;\r
+ RoomLeft = (char *)gCurrentDictionary->dic_CodeLimit -\r
+ (char *)gCurrentDictionary->dic_CodePtr.Byte;\r
if( RoomLeft < DIC_SAFETY_MARGIN )\r
{\r
pfReportError("ffCheckDicRoom", PF_ERR_CODE_ROOM);\r
pfDebugMessage("ffCreateSecondaryHeader: CheckRedefinition()\n");\r
CheckRedefinition( FName );\r
/* Align CODE_HERE */\r
- CODE_HERE = (cell *)( (((uint32)CODE_HERE) + UINT32_MASK) & ~UINT32_MASK);\r
+ CODE_HERE = (cell_t *)( (((ucell_t)CODE_HERE) + UINT32_MASK) & ~UINT32_MASK);\r
CreateDicEntry( (ExecToken) ABS_TO_CODEREL(CODE_HERE), FName, FLAG_SMUDGE );\r
-DBUG(("ffCreateSecondaryHeader, XT = 0x%x, Name = %8s\n"));\r
}\r
\r
/*************************************************************\r
/*************************************************************\r
** Check to see if name is already in dictionary.\r
*/\r
-static int32 CheckRedefinition( const ForthStringPtr FName )\r
+static cell_t CheckRedefinition( const ForthStringPtr FName )\r
{\r
- int32 flag;\r
+ cell_t flag;\r
ExecToken XT;\r
\r
flag = ffFind( FName, &XT);\r
if ( flag && !gVarQuiet)\r
{\r
- ioType( FName+1, (int32) *FName );\r
+ ioType( FName+1, (cell_t) *FName );\r
MSG( " redefined.\n" ); // FIXME - allow user to run off this warning.\r
}\r
return flag;\r
/* Unsmudge the word to make it visible. */\r
void ffUnSmudge( void )\r
{\r
- *gVarContext &= ~FLAG_SMUDGE;\r
+ *(char*)gVarContext &= ~FLAG_SMUDGE;\r
}\r
\r
/* Implement ; */\r
\r
/**************************************************************/\r
/* Used to pull a number from the dictionary to the stack */\r
-void ff2Literal( cell dHi, cell dLo )\r
+void ff2Literal( cell_t dHi, cell_t dLo )\r
{\r
CODE_COMMA( ID_2LITERAL_P );\r
CODE_COMMA( dHi );\r
CODE_COMMA( dLo );\r
}\r
-void ffALiteral( cell Num )\r
+void ffALiteral( cell_t Num )\r
{\r
CODE_COMMA( ID_ALITERAL_P );\r
CODE_COMMA( Num );\r
}\r
-void ffLiteral( cell Num )\r
+void ffLiteral( cell_t Num )\r
{\r
CODE_COMMA( ID_LITERAL_P );\r
CODE_COMMA( Num );\r
* original expression. \r
*/\r
PF_FLOAT *temp;\r
- cell *dicPtr;\r
+ cell_t *dicPtr;\r
\r
/* Make sure that literal float data is float aligned. */\r
dicPtr = CODE_HERE + 1;\r
- while( (((uint32) dicPtr++) & (sizeof(PF_FLOAT) - 1)) != 0)\r
+ while( (((ucell_t) dicPtr++) & (sizeof(PF_FLOAT) - 1)) != 0)\r
{\r
DBUG((" comma NOOP to align FPLiteral\n"));\r
CODE_COMMA( ID_NOOP );\r
temp = (PF_FLOAT *)CODE_HERE;\r
WRITE_FLOAT_DIC(temp,fnum); /* Write to dictionary. */\r
temp++;\r
- CODE_HERE = (cell *) temp;\r
+ CODE_HERE = (cell_t *) temp;\r
}\r
#endif /* PF_SUPPORT_FP */\r
\r
/**************************************************************/\r
ThrowCode FindAndCompile( const char *theWord )\r
{\r
- int32 Flag;\r
+ cell_t Flag;\r
ExecToken XT;\r
- cell Num;\r
+ cell_t Num;\r
ThrowCode exception = 0;\r
\r
Flag = ffFind( theWord, &XT);\r
else /* try to interpret it as a number. */\r
{\r
/* Call deferred NUMBER? */\r
- int32 NumResult;\r
+ cell_t NumResult;\r
\r
DBUG(("FindAndCompile: not found, try number?\n" ));\r
PUSH_DATA_STACK( theWord ); /* Push text of number */\r
*/\r
ThrowCode ffInterpret( void )\r
{\r
- int32 flag;\r
+ cell_t flag;\r
char *theWord;\r
ThrowCode exception = 0;\r
\r
DBUG(("ffInterpret: IN=%d, SourceNum=%d\n", gCurrentTask->td_IN,\r
gCurrentTask->td_SourceNum ) );\r
}\r
- DBUG(("ffInterpret: CHECK_ABORT = %d\n", CHECK_ABORT));\r
error:\r
return exception;\r
}\r
/**************************************************************/\r
ThrowCode ffOK( void )\r
{\r
- int32 exception = 0;\r
+ cell_t exception = 0;\r
/* Check for stack underflow. %Q what about overflows? */\r
if( (gCurrentTask->td_StackBase - gCurrentTask->td_StackPtr) < 0 )\r
{\r
***************************************************************/\r
ThrowCode ffOuterInterpreterLoop( void )\r
{\r
- int32 exception = 0;\r
+ cell_t exception = 0;\r
do\r
{\r
exception = ffRefill();\r
***************************************************************/\r
Err ffPushInputStream( FileStream *InputFile )\r
{\r
- cell Result = 0;\r
+ cell_t Result = 0;\r
IncludeFrame *inf;\r
\r
/* Push current input state onto special include stack. */\r
/***************************************************************\r
** Convert file pointer to value consistent with SOURCE-ID.\r
***************************************************************/\r
-cell ffConvertStreamToSourceID( FileStream *Stream )\r
+cell_t ffConvertStreamToSourceID( FileStream *Stream )\r
{\r
- cell Result;\r
+ cell_t Result;\r
if(Stream == PF_STDIN)\r
{\r
Result = 0;\r
}\r
else\r
{\r
- Result = (cell) Stream;\r
+ Result = (cell_t) Stream;\r
}\r
return Result;\r
}\r
/***************************************************************\r
** Convert file pointer to value consistent with SOURCE-ID.\r
***************************************************************/\r
-FileStream * ffConvertSourceIDToStream( cell id )\r
+FileStream * ffConvertSourceIDToStream( cell_t id )\r
{\r
FileStream *stream;\r
\r
** Return length, or -1 for EOF.\r
*/\r
#define BACKSPACE (8)\r
-static cell readLineFromStream( char *buffer, cell maxChars, FileStream *stream )\r
+static cell_t readLineFromStream( char *buffer, cell_t maxChars, FileStream *stream )\r
{\r
int c;\r
int len;\r
** ( -- , fill Source from current stream )\r
** Return 1 if successful, 0 for EOF, or a negative error.\r
*/\r
-cell ffRefill( void )\r
+cell_t ffRefill( void )\r
{\r
- cell Num;\r
- cell Result = 1;\r
+ cell_t Num;\r
+ cell_t Result = 1;\r
\r
/* reset >IN for parser */\r
gCurrentTask->td_IN = 0;\r