V25 with 64-bit support

[pforth] / csrc / pfcompil.c

diff --git a/csrc/pfcompil.c b/csrc/pfcompil.c
index 0d3e33e..3613b33 100644 (file)
--- a/csrc/pfcompil.c
+++ b/csrc/pfcompil.c
@@ -25,23 +25,23 @@
 #include "pfcompil.h"\r
 \r
 #define ABORT_RETURN_CODE   (10)\r
 #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
 \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 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
 \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
 {\r
        MSG("Function ");\r
        MSG(FunctionName);\r


@@ -54,7 +54,7 @@ int32 NotCompiled( const char *FunctionName )
 ** Create an entry in the Dictionary for the given ExecutionToken.\r
 ** FName is name in Forth format.\r
 */\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
 {\r
        cfNameLinks *cfnl;\r
 \r


@@ -63,7 +63,7 @@ void CreateDicEntry( ExecToken XT, const ForthStringPtr FName, uint32 Flags )
 /* Set link to previous header, if any. */\r
        if( gVarContext )\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
        else\r
        {\r


@@ -71,7 +71,7 @@ void CreateDicEntry( ExecToken XT, const ForthStringPtr FName, uint32 Flags )
        }\r
 \r
 /* Put Execution token in header. */\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
 \r
 /* Advance Header Dictionary Pointer */\r
        gCurrentDictionary->dic_HeaderPtr.Byte += sizeof(cfNameLinks);\r


@@ -85,7 +85,7 @@ void CreateDicEntry( ExecToken XT, const ForthStringPtr FName, uint32 Flags )
        *gVarContext |= (char) Flags;\r
        \r
 /* Align to quad byte boundaries with zeroes. */\r
        *gVarContext |= (char) Flags;\r
        \r
 /* Align to quad byte boundaries with zeroes. */\r

-       while( ((uint32) gCurrentDictionary->dic_HeaderPtr.Byte) & UINT32_MASK )\r
+       while( ((ucell_t) gCurrentDictionary->dic_HeaderPtr.Byte) & UINT32_MASK )\r

        {\r
                *gCurrentDictionary->dic_HeaderPtr.Byte++ = 0;\r
        }\r
        {\r
                *gCurrentDictionary->dic_HeaderPtr.Byte++ = 0;\r
        }\r


@@ -94,7 +94,7 @@ void CreateDicEntry( ExecToken XT, const ForthStringPtr FName, uint32 Flags )
 /***************************************************************\r
 ** Convert name then create dictionary entry.\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
        ForthString FName[40];\r
        CStringToForth( FName, CName );\r


@@ -107,14 +107,14 @@ void CreateDicEntryC( ExecToken XT, const char *CName, uint32 Flags )
 */\r
 const ForthString *NameToPrevious( const ForthString *NFA )\r
 {\r
 */\r
 const ForthString *NameToPrevious( const ForthString *NFA )\r
 {\r

-       cell RelNamePtr;\r
+       cell_t RelNamePtr;\r

        const cfNameLinks *cfnl;\r
 \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
        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
        if( RelNamePtr )\r
        {\r
                return ( NAMEREL_TO_ABS( RelNamePtr ) );\r


@@ -134,18 +134,18 @@ ExecToken NameToToken( const ForthString *NFA )
 /* Convert absolute namefield address to absolute link field address. */\r
        cfnl = (const cfNameLinks *) ( ((const char *) NFA) - sizeof(cfNameLinks) );\r
 \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
 }\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
 {\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
        return 0;\r
        \r
 nofind:\r


@@ -157,7 +157,7 @@ nofind:
 ** Build a dictionary from scratch.\r
 */\r
 #ifndef PF_NO_INIT\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
 {\r
        pfDictionary_t *dic;\r
 \r


@@ -197,6 +197,8 @@ PForthDictionary pfBuildDictionary( int32 HeaderSize, int32 CodeSize )
        CreateDicEntryC( ID_BODY_OFFSET, "BODY_OFFSET", 0 );\r
        CreateDicEntryC( ID_BYE, "BYE", 0 );\r
        CreateDicEntryC( ID_CATCH, "CATCH", 0 );\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
        CreateDicEntryC( ID_CFETCH, "C@", 0 );\r
        CreateDicEntryC( ID_CMOVE, "CMOVE", 0 );\r
        CreateDicEntryC( ID_CMOVE_UP, "CMOVE>", 0 );\r


@@ -398,11 +400,11 @@ nomem:
 ** ( xt -- nfa 1 , x 0 , find NFA in dictionary from XT )\r
 ** 1 for IMMEDIATE values\r
 */\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
 {\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
        ExecToken TempXT;\r
        \r
        NameField = gVarContext;\r


@@ -437,16 +439,16 @@ DBUGX(("ffCodeToName: NFA = 0x%x\n", NameField));
 ** ( $name -- $addr 0 | nfa -1 | nfa 1 , find NFA in dictionary )\r
 ** 1 for IMMEDIATE values\r
 */\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
 {\r
        const ForthString *WordChar;\r

-       uint8 WordLen;\r
+       uint8_t WordLen;\r

        const char *NameField, *NameChar;\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
        \r

-       WordLen = (uint8) ((uint32)*WordName & 0x1F);\r
+       WordLen = (uint8_t) ((ucell_t)*WordName & 0x1F);\r

        WordChar = WordName+1;\r
        \r
        NameField = gVarContext;\r
        WordChar = WordName+1;\r
        \r
        NameField = gVarContext;\r


@@ -454,7 +456,7 @@ DBUG(("\nffFindNFA: WordLen = %d, WordName = %*s\n", WordLen, WordLen, WordChar
 DBUG(("\nffFindNFA: gVarContext = 0x%x\n", gVarContext));\r
        do\r
        {\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
                NameChar = NameField+1;\r
 /* DBUG(("   %c\n", (*NameField & FLAG_SMUDGE) ? 'S' : 'V' )); */\r
                if(     ((*NameField & FLAG_SMUDGE) == 0) &&\r


@@ -485,10 +487,10 @@ DBUG(("ffFindNFA: returns 0x%x\n", Result));
 ** ( $name -- $name 0 | xt -1 | xt 1 )\r
 ** 1 for IMMEDIATE values\r
 */\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
 {\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
        Result = ffFindNFA( WordName, &NFA );\r
 DBUG(("ffFind: %8s at 0x%x\n", WordName+1, NFA)); /* WARNING, not NUL terminated. %Q */\r


@@ -507,7 +509,7 @@ DBUG(("ffFind: %8s at 0x%x\n", WordName+1, NFA)); /* WARNING, not NUL terminated
 /****************************************************************\r
 ** Find name when passed 'C' string.\r
 */\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
 DBUG(("ffFindC: %s\n", WordName ));\r
        CStringToForth( gScratch, WordName );\r


@@ -523,9 +525,9 @@ DBUG(("ffFindC: %s\n", WordName ));
 /*************************************************************\r
 **  Check for dictionary overflow. \r
 */\r
 /*************************************************************\r
 **  Check for dictionary overflow. \r
 */\r

-static int32 ffCheckDicRoom( void )\r
+static cell_t ffCheckDicRoom( void )\r

 {\r
 {\r

-       int32 RoomLeft;\r
+       cell_t RoomLeft;\r

        RoomLeft = gCurrentDictionary->dic_HeaderLimit -\r
                   gCurrentDictionary->dic_HeaderPtr.Byte;\r
        if( RoomLeft < DIC_SAFETY_MARGIN )\r
        RoomLeft = gCurrentDictionary->dic_HeaderLimit -\r
                   gCurrentDictionary->dic_HeaderPtr.Byte;\r
        if( RoomLeft < DIC_SAFETY_MARGIN )\r


@@ -556,9 +558,8 @@ void ffCreateSecondaryHeader( const ForthStringPtr FName)
        pfDebugMessage("ffCreateSecondaryHeader: CheckRedefinition()\n");\r
        CheckRedefinition( FName );\r
 /* Align CODE_HERE */\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
        CreateDicEntry( (ExecToken) ABS_TO_CODEREL(CODE_HERE), FName, FLAG_SMUDGE );\r

-DBUG(("ffCreateSecondaryHeader, XT = 0x%x, Name = %8s\n"));\r

 }\r
 \r
 /*************************************************************\r
 }\r
 \r
 /*************************************************************\r


@@ -589,15 +590,15 @@ void ffColon( void )
 /*************************************************************\r
 ** Check to see if name is already in dictionary.\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
 {\r

-       int32 flag;\r
+       cell_t flag;\r

        ExecToken XT;\r
        \r
        flag = ffFind( FName, &XT);\r
        if ( flag && !gVarQuiet)\r
        {\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
                MSG( " redefined.\n" ); // FIXME - allow user to run off this warning.\r
        }\r
        return flag;\r


@@ -692,18 +693,18 @@ void ffFinishSecondary( void )
 \r
 /**************************************************************/\r
 /* Used to pull a number from the dictionary to the stack */\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
 {\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
 {\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
 {\r
        CODE_COMMA( ID_LITERAL_P );\r
        CODE_COMMA( Num );\r


@@ -716,11 +717,11 @@ void ffFPLiteral( PF_FLOAT fnum )
         * original expression. \r
         */\r
        PF_FLOAT  *temp;\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
 \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
        {\r
                DBUG((" comma NOOP to align FPLiteral\n"));\r
                CODE_COMMA( ID_NOOP );\r


@@ -730,16 +731,16 @@ void ffFPLiteral( PF_FLOAT fnum )
        temp = (PF_FLOAT *)CODE_HERE;\r
        WRITE_FLOAT_DIC(temp,fnum);   /* Write to dictionary. */\r
        temp++;\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
 }\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
        ExecToken XT;\r

-       cell Num;\r
+       cell_t Num;\r

        ThrowCode exception = 0;\r
        \r
        Flag = ffFind( theWord, &XT);\r
        ThrowCode exception = 0;\r
        \r
        Flag = ffFind( theWord, &XT);\r


@@ -765,7 +766,7 @@ DBUG(("FindAndCompile: IMMEDIATE, theWord = 0x%x\n", theWord ));
        else /* try to interpret it as a number. */\r
        {\r
 /* Call deferred NUMBER? */\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
 DBUG(("FindAndCompile: not found, try number?\n" ));\r
                PUSH_DATA_STACK( theWord );   /* Push text of number */\r


@@ -820,7 +821,7 @@ error:
 */\r
 ThrowCode ffInterpret( void )\r
 {\r
 */\r
 ThrowCode ffInterpret( void )\r
 {\r

-       int32 flag;\r
+       cell_t flag;\r

        char *theWord;\r
        ThrowCode exception = 0;\r
        \r
        char *theWord;\r
        ThrowCode exception = 0;\r
        \r


@@ -852,7 +853,6 @@ ThrowCode ffInterpret( void )
                DBUG(("ffInterpret: IN=%d, SourceNum=%d\n", gCurrentTask->td_IN,\r
                        gCurrentTask->td_SourceNum ) );\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
 error:\r
        return exception;\r
 }\r


@@ -860,7 +860,7 @@ error:
 /**************************************************************/\r
 ThrowCode ffOK( void )\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
 /* Check for stack underflow.   %Q what about overflows? */\r
        if( (gCurrentTask->td_StackBase - gCurrentTask->td_StackPtr) < 0 )\r
        {\r


@@ -909,7 +909,7 @@ void pfHandleIncludeError( void )
 ***************************************************************/\r
 ThrowCode ffOuterInterpreterLoop( void )\r
 {\r
 ***************************************************************/\r
 ThrowCode ffOuterInterpreterLoop( void )\r
 {\r

-       int32 exception = 0;\r
+       cell_t exception = 0;\r

        do\r
        {\r
                exception = ffRefill();\r
        do\r
        {\r
                exception = ffRefill();\r


@@ -972,7 +972,7 @@ ThrowCode ffIncludeFile( FileStream *InputFile )
 ***************************************************************/\r
 Err ffPushInputStream( FileStream *InputFile )\r
 {\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
        IncludeFrame *inf;\r
        \r
 /* Push current input state onto special include stack. */\r


@@ -1040,9 +1040,9 @@ DBUG(("ffPopInputStream: return = 0x%x\n", Result ));
 /***************************************************************\r
 ** Convert file pointer to value consistent with SOURCE-ID.\r
 ***************************************************************/\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
 {\r

-       cell Result;\r
+       cell_t Result;\r

        if(Stream == PF_STDIN)\r
        {\r
                Result = 0;\r
        if(Stream == PF_STDIN)\r
        {\r
                Result = 0;\r


@@ -1053,7 +1053,7 @@ cell ffConvertStreamToSourceID( FileStream *Stream )
        }\r
        else\r
        {\r
        }\r
        else\r
        {\r

-               Result = (cell) Stream;\r
+               Result = (cell_t) Stream;\r

        }\r
        return Result;\r
 }\r
        }\r
        return Result;\r
 }\r


@@ -1061,7 +1061,7 @@ cell ffConvertStreamToSourceID( FileStream *Stream )
 /***************************************************************\r
 ** Convert file pointer to value consistent with SOURCE-ID.\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
 {\r
        FileStream *stream;\r
        \r


@@ -1085,7 +1085,7 @@ FileStream * ffConvertSourceIDToStream( cell id )
 ** Return length, or -1 for EOF.\r
 */\r
 #define BACKSPACE  (8)\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
 {\r
        int   c;\r
        int   len;\r


@@ -1135,10 +1135,10 @@ DBUGX(("readLineFromStream(0x%x, 0x%x, 0x%x)\n", buffer, len, stream ));
 ** ( -- , fill Source from current stream )\r
 ** Return 1 if successful, 0 for EOF, or a negative error.\r
 */\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
 {\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
 \r
 /* reset >IN for parser */\r
        gCurrentTask->td_IN = 0;\r