** of names and code was the same when saved and reloaded.\r
** 940228 PLB Added PF_NO_FILEIO version\r
** 961204 PLB Added PF_STATIC_DIC\r
-** 000623 PLB Cast chars as uint32 before shifting for 16 bit systems.\r
+** 000623 PLB Cast chars as ucell_t before shifting for 16 bit systems.\r
***************************************************************/\r
\r
+#include <assert.h>\r
+\r
#include "pf_all.h"\r
\r
/* If no File I/O, then force static dictionary. */\r
\r
/***************************************************************/\r
/* Endian-ness tools. */\r
-uint32 ReadLongBigEndian( const uint32 *addr )\r
+ucell_t ReadCellBigEndian( const uint8_t *addr )\r
{\r
- const unsigned char *bp = (const unsigned char *) addr;\r
-/* We must cast char to uint32 before shifting because\r
-** of systems with 16 bit ints. 000623 */\r
- uint32 temp = ((uint32)bp[0])<<24;\r
- temp |= ((uint32)bp[1])<<16;\r
- temp |= ((uint32)bp[2])<<8;\r
- temp |= ((uint32)bp[3]);\r
+ ucell_t temp = (ucell_t)addr[0];\r
+ temp = (temp << 8) | ((ucell_t)addr[1]);\r
+ temp = (temp << 8) | ((ucell_t)addr[2]);\r
+ temp = (temp << 8) | ((ucell_t)addr[3]);\r
+ if( sizeof(ucell_t) == 8 )\r
+ {\r
+ temp = (temp << 8) | ((ucell_t)addr[4]);\r
+ temp = (temp << 8) | ((ucell_t)addr[5]);\r
+ temp = (temp << 8) | ((ucell_t)addr[6]);\r
+ temp = (temp << 8) | ((ucell_t)addr[7]);\r
+ }\r
+ \r
return temp;\r
}\r
/***************************************************************/\r
-uint16 ReadShortBigEndian( const uint16 *addr )\r
+/* Endian-ness tools. */\r
+uint32_t Read32BigEndian( const uint8_t *addr )\r
{\r
- const unsigned char *bp = (const unsigned char *) addr;\r
- return (uint16) ((bp[0]<<8) | bp[1]);\r
+ uint32_t temp = (uint32_t)addr[0];\r
+ temp = (temp << 8) | ((uint32_t)addr[1]);\r
+ temp = (temp << 8) | ((uint32_t)addr[2]);\r
+ temp = (temp << 8) | ((uint32_t)addr[3]);\r
+ return temp;\r
}\r
\r
/***************************************************************/\r
-uint32 ReadLongLittleEndian( const uint32 *addr )\r
+uint16_t Read16BigEndian( const uint8_t *addr )\r
{\r
- const unsigned char *bp = (const unsigned char *) addr;\r
-/* We must cast char to uint32 before shifting because\r
-** of systems with 16 bit ints. 000623 */\r
- uint32 temp = ((uint32)bp[3])<<24;\r
- temp |= ((uint32)bp[2])<<16;\r
- temp |= ((uint32)bp[1])<<8;\r
- temp |= ((uint32)bp[0]);\r
+ return (uint16_t) ((addr[0]<<8) | addr[1]);\r
+}\r
+\r
+/***************************************************************/\r
+ucell_t ReadCellLittleEndian( const uint8_t *addr )\r
+{\r
+ ucell_t temp = 0;\r
+ if( sizeof(ucell_t) == 8 )\r
+ {\r
+ temp = (temp << 8) | ((uint32_t)addr[7]);\r
+ temp = (temp << 8) | ((uint32_t)addr[6]);\r
+ temp = (temp << 8) | ((uint32_t)addr[5]);\r
+ temp = (temp << 8) | ((uint32_t)addr[4]);\r
+ }\r
+ temp = (temp << 8) | ((uint32_t)addr[3]);\r
+ temp = (temp << 8) | ((uint32_t)addr[2]);\r
+ temp = (temp << 8) | ((uint32_t)addr[1]);\r
+ temp = (temp << 8) | ((uint32_t)addr[0]);\r
return temp;\r
}\r
+\r
/***************************************************************/\r
-uint16 ReadShortLittleEndian( const uint16 *addr )\r
+uint32_t Read32LittleEndian( const uint8_t *addr )\r
+{\r
+ uint32_t temp = (uint32_t)addr[3];\r
+ temp = (temp << 8) | ((uint32_t)addr[2]);\r
+ temp = (temp << 8) | ((uint32_t)addr[1]);\r
+ temp = (temp << 8) | ((uint32_t)addr[0]);\r
+ return temp;\r
+}\r
+\r
+/***************************************************************/\r
+uint16_t Read16LittleEndian( const uint8_t *addr )\r
{\r
const unsigned char *bp = (const unsigned char *) addr;\r
- return (uint16) ((bp[1]<<8) | bp[0]);\r
+ return (uint16_t) ((bp[1]<<8) | bp[0]);\r
}\r
\r
#ifdef PF_SUPPORT_FP\r
#endif /* PF_SUPPORT_FP */\r
\r
/***************************************************************/\r
-void WriteLongBigEndian( uint32 *addr, uint32 data )\r
+void WriteCellBigEndian( uint8_t *addr, ucell_t data )\r
{\r
- unsigned char *bp = (unsigned char *) addr;\r
-\r
- bp[0] = (unsigned char) (data>>24);\r
- bp[1] = (unsigned char) (data>>16);\r
- bp[2] = (unsigned char) (data>>8);\r
- bp[3] = (unsigned char) (data);\r
+ /* Write should be in order of increasing address \r
+ * to optimize for burst writes to DRAM. */\r
+ if( sizeof(ucell_t) == 8 )\r
+ {\r
+ *addr++ = (uint8_t) (data>>56);\r
+ *addr++ = (uint8_t) (data>>48);\r
+ *addr++ = (uint8_t) (data>>40);\r
+ *addr++ = (uint8_t) (data>>32);\r
+ }\r
+ *addr++ = (uint8_t) (data>>24);\r
+ *addr++ = (uint8_t) (data>>16);\r
+ *addr++ = (uint8_t) (data>>8);\r
+ *addr = (uint8_t) (data);\r
}\r
\r
/***************************************************************/\r
-void WriteShortBigEndian( uint16 *addr, uint16 data )\r
+void Write32BigEndian( uint8_t *addr, uint32_t data )\r
{\r
- unsigned char *bp = (unsigned char *) addr;\r
-\r
- bp[0] = (unsigned char) (data>>8);\r
- bp[1] = (unsigned char) (data);\r
+ *addr++ = (uint8_t) (data>>24);\r
+ *addr++ = (uint8_t) (data>>16);\r
+ *addr++ = (uint8_t) (data>>8);\r
+ *addr = (uint8_t) (data);\r
}\r
\r
/***************************************************************/\r
-void WriteLongLittleEndian( uint32 *addr, uint32 data )\r
+void Write16BigEndian( uint8_t *addr, uint16_t data )\r
{\r
- unsigned char *bp = (unsigned char *) addr;\r
+ *addr++ = (uint8_t) (data>>8);\r
+ *addr = (uint8_t) (data);\r
+}\r
\r
- bp[0] = (unsigned char) (data);\r
- bp[1] = (unsigned char) (data>>8);\r
- bp[2] = (unsigned char) (data>>16);\r
- bp[3] = (unsigned char) (data>>24);\r
+/***************************************************************/\r
+void WriteCellLittleEndian( uint8_t *addr, ucell_t data )\r
+{\r
+ /* Write should be in order of increasing address \r
+ * to optimize for burst writes to DRAM. */\r
+ if( sizeof(ucell_t) == 8 )\r
+ {\r
+ *addr++ = (uint8_t) data; /* LSB at near end */\r
+ data = data >> 8;\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ }\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr = (uint8_t) data;\r
}\r
/***************************************************************/\r
-void WriteShortLittleEndian( uint16 *addr, uint16 data )\r
+void Write32LittleEndian( uint8_t *addr, uint32_t data )\r
{\r
- unsigned char *bp = (unsigned char *) addr;\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr = (uint8_t) data;\r
+}\r
\r
- bp[0] = (unsigned char) (data);\r
- bp[1] = (unsigned char) (data>>8);\r
+/***************************************************************/\r
+void Write16LittleEndian( uint8_t *addr, uint16_t data )\r
+{\r
+ *addr++ = (uint8_t) data;\r
+ data = data >> 8;\r
+ *addr = (uint8_t) data;\r
}\r
\r
/***************************************************************/\r
\r
#if defined(PF_NO_FILEIO) || defined(PF_NO_SHELL)\r
\r
-int32 ffSaveForth( const char *FileName, ExecToken EntryPoint, int32 NameSize, int32 CodeSize)\r
+cell_t ffSaveForth( const char *FileName, ExecToken EntryPoint, cell_t NameSize, cell_t CodeSize)\r
{\r
TOUCH(FileName);\r
TOUCH(EntryPoint);\r
#else /* PF_NO_FILEIO or PF_NO_SHELL */\r
\r
/***************************************************************/\r
-static int32 WriteLong( FileStream *fid, int32 Val )\r
+static int Write32ToFile( FileStream *fid, uint32_t Val )\r
{\r
- int32 numw;\r
- uint32 pad;\r
+ int numw;\r
+ uint8_t pad[4];\r
\r
- WriteLongBigEndian(&pad,Val);\r
- numw = sdWriteFile( (char *) &pad, 1, sizeof(int32), fid );\r
- if( numw != sizeof(int32) ) return -1;\r
+ Write32BigEndian(pad,Val);\r
+ numw = sdWriteFile( pad, 1, sizeof(pad), fid );\r
+ if( numw != sizeof(pad) ) return -1;\r
return 0;\r
}\r
\r
/***************************************************************/\r
-static int32 WriteChunk( FileStream *fid, int32 ID, char *Data, int32 NumBytes )\r
+static cell_t WriteChunkToFile( FileStream *fid, cell_t ID, char *Data, int32_t NumBytes )\r
{\r
- int32 numw;\r
- int32 EvenNumW;\r
+ cell_t numw;\r
+ cell_t EvenNumW;\r
\r
EvenNumW = EVENUP(NumBytes);\r
\r
- if( WriteLong( fid, ID ) < 0 ) goto error;\r
- if( WriteLong( fid, EvenNumW ) < 0 ) goto error;\r
+ if( Write32ToFile( fid, ID ) < 0 ) goto error;\r
+ if( Write32ToFile( fid, EvenNumW ) < 0 ) goto error;\r
\r
numw = sdWriteFile( Data, 1, EvenNumW, fid );\r
if( numw != EvenNumW ) goto error;\r
return 0;\r
error:\r
- pfReportError("WriteChunk", PF_ERR_WRITE_FILE);\r
+ pfReportError("WriteChunkToFile", PF_ERR_WRITE_FILE);\r
return -1;\r
}\r
\r
+/* Convert dictionary info chunk between native and on-disk (big-endian). */\r
+static void\r
+convertDictionaryInfoWrite (DictionaryInfoChunk *sd)\r
+{\r
+/* Convert all fields in DictionaryInfoChunk from Native to BigEndian. \r
+ * This assumes they are all 32-bit integers.\r
+ */\r
+ int i;\r
+ uint32_t *p = (uint32_t *) sd;\r
+ for (i=0; i<((int)(sizeof(*sd)/sizeof(uint32_t))); i++)\r
+ {\r
+ Write32BigEndian( (uint8_t *)&p[i], p[i] );\r
+ }\r
+}\r
+\r
+static void\r
+convertDictionaryInfoRead (DictionaryInfoChunk *sd)\r
+{\r
+/* Convert all fields in structure from BigEndian to Native. */\r
+ int i;\r
+ uint32_t *p = (uint32_t *) sd;\r
+ for (i=0; i<((int)(sizeof(*sd)/sizeof(uint32_t))); i++)\r
+ {\r
+ p[i] = Read32BigEndian( (uint8_t *)&p[i] );\r
+ }\r
+}\r
+\r
/****************************************************************\r
** Save Dictionary in File.\r
** If EntryPoint is NULL, save as development environment.\r
** If EntryPoint is non-NULL, save as turnKey environment with no names.\r
*/\r
-int32 ffSaveForth( const char *FileName, ExecToken EntryPoint, int32 NameSize, int32 CodeSize)\r
+cell_t ffSaveForth( const char *FileName, ExecToken EntryPoint, cell_t NameSize, cell_t CodeSize)\r
{\r
FileStream *fid;\r
DictionaryInfoChunk SD;\r
- int32 FormSize;\r
- int32 NameChunkSize = 0;\r
- int32 CodeChunkSize;\r
- uint32 rhp, rcp;\r
- uint32 *p;\r
- int i;\r
+ uint32_t FormSize;\r
+ uint32_t NameChunkSize = 0;\r
+ uint32_t CodeChunkSize;\r
+ uint32_t relativeCodePtr;\r
\r
fid = sdOpenFile( FileName, "wb" );\r
if( fid == NULL )\r
pfExecIfDefined("AUTO.TERM");\r
\r
/* Write FORM Header ---------------------------- */\r
- if( WriteLong( fid, ID_FORM ) < 0 ) goto error;\r
- if( WriteLong( fid, 0 ) < 0 ) goto error;\r
- if( WriteLong( fid, ID_P4TH ) < 0 ) goto error;\r
+ if( Write32ToFile( fid, ID_FORM ) < 0 ) goto error;\r
+ if( Write32ToFile( fid, 0 ) < 0 ) goto error;\r
+ if( Write32ToFile( fid, ID_P4TH ) < 0 ) goto error;\r
\r
/* Write P4DI Dictionary Info ------------------ */\r
SD.sd_Version = PF_FILE_VERSION;\r
\r
- rcp = ABS_TO_CODEREL(gCurrentDictionary->dic_CodePtr.Byte); /* 940225 */\r
- SD.sd_RelCodePtr = rcp; \r
- SD.sd_UserStackSize = sizeof(cell) * (gCurrentTask->td_StackBase - gCurrentTask->td_StackLimit);\r
- SD.sd_ReturnStackSize = sizeof(cell) * (gCurrentTask->td_ReturnBase - gCurrentTask->td_ReturnLimit);\r
+ relativeCodePtr = ABS_TO_CODEREL(gCurrentDictionary->dic_CodePtr.Byte); /* 940225 */\r
+ SD.sd_RelCodePtr = relativeCodePtr; \r
+ SD.sd_UserStackSize = sizeof(cell_t) * (gCurrentTask->td_StackBase - gCurrentTask->td_StackLimit);\r
+ SD.sd_ReturnStackSize = sizeof(cell_t) * (gCurrentTask->td_ReturnBase - gCurrentTask->td_ReturnLimit);\r
SD.sd_NumPrimitives = gNumPrimitives; /* Must match compiled dictionary. */\r
\r
#ifdef PF_SUPPORT_FP\r
SD.sd_FloatSize = 0;\r
#endif\r
\r
- SD.sd_Reserved = 0;\r
+ SD.sd_CellSize = sizeof(cell_t);\r
\r
-/* Set bit that specifiec whether dictionary is BIG or LITTLE Endian. */\r
+/* Set bit that specifies whether dictionary is BIG or LITTLE Endian. */\r
{\r
#if defined(PF_BIG_ENDIAN_DIC)\r
int eflag = SD_F_BIG_ENDIAN_DIC;\r
}\r
else\r
{\r
+ uint32_t relativeHeaderPtr;\r
/* Development mode. */\r
SD.sd_RelContext = ABS_TO_NAMEREL(gVarContext);\r
- rhp = ABS_TO_NAMEREL(gCurrentDictionary->dic_HeaderPtr.Byte);\r
- SD.sd_RelHeaderPtr = rhp;\r
+ relativeHeaderPtr = ABS_TO_NAMEREL(gCurrentDictionary->dic_HeaderPtr);\r
+ SD.sd_RelHeaderPtr = relativeHeaderPtr;\r
\r
/* How much real name space is there? */\r
- NameChunkSize = QUADUP(rhp); /* Align */\r
+ NameChunkSize = QUADUP(relativeHeaderPtr); /* Align */\r
\r
/* NameSize must be 0 or greater than NameChunkSize + 1K */\r
NameSize = QUADUP(NameSize); /* Align */\r
}\r
\r
/* How much real code is there? */\r
- CodeChunkSize = QUADUP(rcp);\r
+ CodeChunkSize = QUADUP(relativeCodePtr);\r
CodeSize = QUADUP(CodeSize); /* Align */\r
CodeSize = MAX( CodeSize, (CodeChunkSize + 2048) );\r
SD.sd_CodeSize = CodeSize;\r
\r
\r
-/* Convert all fields in structure from Native to BigEndian. */\r
- p = (uint32 *) &SD;\r
- for( i=0; i<((int)(sizeof(SD)/sizeof(int32))); i++ )\r
- {\r
- WriteLongBigEndian( &p[i], p[i] );\r
- }\r
+ convertDictionaryInfoWrite (&SD);\r
\r
- if( WriteChunk( fid, ID_P4DI, (char *) &SD, sizeof(DictionaryInfoChunk) ) < 0 ) goto error;\r
+ if( WriteChunkToFile( fid, ID_P4DI, (char *) &SD, sizeof(DictionaryInfoChunk) ) < 0 ) goto error;\r
\r
/* Write Name Fields if NameSize non-zero ------- */\r
if( NameSize > 0 )\r
{\r
- if( WriteChunk( fid, ID_P4NM, (char *) NAME_BASE,\r
+ if( WriteChunkToFile( fid, ID_P4NM, (char *) NAME_BASE,\r
NameChunkSize ) < 0 ) goto error;\r
}\r
\r
/* Write Code Fields ---------------------------- */\r
- if( WriteChunk( fid, ID_P4CD, (char *) CODE_BASE,\r
+ if( WriteChunkToFile( fid, ID_P4CD, (char *) CODE_BASE,\r
CodeChunkSize ) < 0 ) goto error;\r
\r
FormSize = sdTellFile( fid ) - 8;\r
sdSeekFile( fid, 4, PF_SEEK_SET );\r
- if( WriteLong( fid, FormSize ) < 0 ) goto error;\r
+ if( Write32ToFile( fid, FormSize ) < 0 ) goto error;\r
\r
sdCloseFile( fid );\r
\r
-\r
-\r
/* Restore initialization. */\r
-\r
pfExecIfDefined("AUTO.INIT");\r
-\r
return 0;\r
\r
error:\r
sdSeekFile( fid, 0, PF_SEEK_SET );\r
- WriteLong( fid, ID_BADF ); /* Mark file as bad. */\r
+ Write32ToFile( fid, ID_BADF ); /* Mark file as bad. */\r
sdCloseFile( fid );\r
\r
/* Restore initialization. */\r
-\r
pfExecIfDefined("AUTO.INIT");\r
\r
return -1;\r
#ifndef PF_NO_FILEIO\r
\r
/***************************************************************/\r
-static int32 ReadLong( FileStream *fid, int32 *ValPtr )\r
+static uint32_t Read32FromFile( FileStream *fid, uint32_t *ValPtr )\r
{\r
- int32 numr;\r
- uint32 temp;\r
-\r
- numr = sdReadFile( &temp, 1, sizeof(int32), fid );\r
- if( numr != sizeof(int32) ) return -1;\r
- *ValPtr = ReadLongBigEndian( &temp );\r
+ int32_t numr;\r
+ uint8_t pad[4];\r
+ numr = sdReadFile( pad, 1, sizeof(pad), fid );\r
+ if( numr != sizeof(pad) ) return -1;\r
+ *ValPtr = Read32BigEndian( pad );\r
return 0;\r
}\r
\r
pfDictionary_t *dic = NULL;\r
FileStream *fid;\r
DictionaryInfoChunk *sd;\r
- int32 ChunkID;\r
- int32 ChunkSize;\r
- int32 FormSize;\r
- int32 BytesLeft;\r
- int32 numr;\r
- uint32 *p;\r
- int i;\r
+ uint32_t ChunkID;\r
+ uint32_t ChunkSize;\r
+ uint32_t FormSize;\r
+ uint32_t BytesLeft;\r
+ uint32_t numr;\r
int isDicBigEndian;\r
\r
DBUG(("pfLoadDictionary( %s )\n", FileName ));\r
}\r
\r
/* Read FORM, Size, ID */\r
- if (ReadLong( fid, &ChunkID ) < 0) goto read_error;\r
+ if (Read32FromFile( fid, &ChunkID ) < 0) goto read_error;\r
if( ChunkID != ID_FORM )\r
{\r
pfReportError("pfLoadDictionary", PF_ERR_WRONG_FILE);\r
goto error;\r
}\r
\r
- if (ReadLong( fid, &FormSize ) < 0) goto read_error;\r
+ if (Read32FromFile( fid, &FormSize ) < 0) goto read_error;\r
BytesLeft = FormSize;\r
\r
- if (ReadLong( fid, &ChunkID ) < 0) goto read_error;\r
+ if (Read32FromFile( fid, &ChunkID ) < 0) goto read_error;\r
BytesLeft -= 4;\r
if( ChunkID != ID_P4TH )\r
{\r
/* Scan and parse all chunks in file. */\r
while( BytesLeft > 0 )\r
{\r
- if (ReadLong( fid, &ChunkID ) < 0) goto read_error;\r
- if (ReadLong( fid, &ChunkSize ) < 0) goto read_error;\r
+ if (Read32FromFile( fid, &ChunkID ) < 0) goto read_error;\r
+ if (Read32FromFile( fid, &ChunkSize ) < 0) goto read_error;\r
BytesLeft -= 8;\r
\r
- DBUG(("ChunkID = %4s, Size = %d\n", &ChunkID, ChunkSize ));\r
+ DBUG(("ChunkID = %4s, Size = %d\n", (char *)&ChunkID, ChunkSize ));\r
\r
switch( ChunkID )\r
{\r
if( numr != ChunkSize ) goto read_error;\r
BytesLeft -= ChunkSize;\r
\r
-/* Convert all fields in structure from BigEndian to Native. */\r
- p = (uint32 *) sd;\r
- for( i=0; i<((int)(sizeof(*sd)/sizeof(int32))); i++ )\r
- {\r
- p[i] = ReadLongBigEndian( &p[i] );\r
- }\r
+ convertDictionaryInfoRead (sd);\r
\r
isDicBigEndian = sd->sd_Flags & SD_F_BIG_ENDIAN_DIC;\r
\r
MSG_NUM_D(" Name space size = ", sd->sd_NameSize );\r
MSG_NUM_D(" Code space size = ", sd->sd_CodeSize );\r
MSG_NUM_D(" Entry Point = ", sd->sd_EntryPoint );\r
+ MSG_NUM_D(" Cell Size = ", sd->sd_CellSize );\r
MSG( (isDicBigEndian ? " Big Endian Dictionary" :\r
" Little Endian Dictionary") );\r
if( isDicBigEndian == IsHostLittleEndian() ) MSG(" !!!!");\r
pfReportError("pfLoadDictionary", PF_ERR_VERSION_PAST );\r
goto error;\r
}\r
+ if( sd->sd_CellSize != sizeof(cell_t) )\r
+ {\r
+ pfReportError("pfLoadDictionary", PF_ERR_CELL_SIZE_CONFLICT );\r
+ goto error;\r
+ }\r
if( sd->sd_NumPrimitives > NUM_PRIMITIVES )\r
{\r
pfReportError("pfLoadDictionary", PF_ERR_NOT_SUPPORTED );\r
gCurrentDictionary = dic;\r
if( sd->sd_NameSize > 0 )\r
{\r
- gVarContext = (char *) NAMEREL_TO_ABS(sd->sd_RelContext); /* Restore context. */\r
- gCurrentDictionary->dic_HeaderPtr.Byte = (uint8 *)\r
+ gVarContext = NAMEREL_TO_ABS(sd->sd_RelContext); /* Restore context. */\r
+ gCurrentDictionary->dic_HeaderPtr = (ucell_t)(uint8_t *)\r
NAMEREL_TO_ABS(sd->sd_RelHeaderPtr);\r
}\r
else\r
{\r
gVarContext = 0;\r
- gCurrentDictionary->dic_HeaderPtr.Byte = NULL;\r
+ gCurrentDictionary->dic_HeaderPtr = (ucell_t)NULL;\r
}\r
- gCurrentDictionary->dic_CodePtr.Byte = (uint8 *) CODEREL_TO_ABS(sd->sd_RelCodePtr);\r
+ gCurrentDictionary->dic_CodePtr.Byte = (uint8_t *) CODEREL_TO_ABS(sd->sd_RelCodePtr);\r
gNumPrimitives = sd->sd_NumPrimitives; /* Must match compiled dictionary. */\r
/* Pass EntryPoint back to caller. */\r
if( EntryPointPtr != NULL ) *EntryPointPtr = sd->sd_EntryPoint;\r
pfReportError("pfLoadDictionary", PF_ERR_NO_SHELL );\r
goto error;\r
#else\r
- if( NAME_BASE == NULL )\r
+ if( NAME_BASE == 0 )\r
{\r
pfReportError("pfLoadDictionary", PF_ERR_NO_NAMES );\r
goto error;\r
pfReportError("pfLoadDictionary", PF_ERR_TOO_BIG);\r
goto error;\r
}\r
- numr = sdReadFile( NAME_BASE, 1, ChunkSize, fid );\r
+ numr = sdReadFile( (char *) NAME_BASE, 1, ChunkSize, fid );\r
if( numr != ChunkSize ) goto read_error;\r
BytesLeft -= ChunkSize;\r
#endif /* PF_NO_SHELL */\r
pfReportError("pfLoadDictionary", PF_ERR_TOO_BIG);\r
goto error;\r
}\r
- numr = sdReadFile( CODE_BASE, 1, ChunkSize, fid );\r
+ numr = sdReadFile( (uint8_t *) CODE_BASE, 1, ChunkSize, fid );\r
if( numr != ChunkSize ) goto read_error;\r
BytesLeft -= ChunkSize;\r
break;\r
\r
sdCloseFile( fid );\r
\r
- if( NAME_BASE != NULL)\r
+ if( NAME_BASE != 0)\r
{\r
- int32 Result;\r
+ cell_t Result;\r
/* Find special words in dictionary for global XTs. */\r
if( (Result = FindSpecialXTs()) < 0 )\r
{\r
}\r
}\r
\r
-DBUG(("pfLoadDictionary: return 0x%x\n", dic));\r
+DBUG(("pfLoadDictionary: return %p\n", dic));\r
return (PForthDictionary) dic;\r
\r
nomem_error:\r
PForthDictionary pfLoadStaticDictionary( void )\r
{\r
#ifdef PF_STATIC_DIC\r
- int32 Result;\r
+ cell_t Result;\r
pfDictionary_t *dic;\r
- int32 NewNameSize, NewCodeSize;\r
+ cell_t NewNameSize, NewCodeSize;\r
\r
if( IF_LITTLE_ENDIAN != IsHostLittleEndian() )\r
{\r
gCurrentDictionary = dic = pfCreateDictionary( NewNameSize, NewCodeSize );\r
if( !dic ) goto nomem_error;\r
\r
- pfCopyMemory( dic->dic_HeaderBase, MinDicNames, sizeof(MinDicNames) );\r
- pfCopyMemory( dic->dic_CodeBase, MinDicCode, sizeof(MinDicCode) );\r
- DBUG("Static data copied to newly allocated dictionaries.\n");\r
+ pfCopyMemory( (uint8_t *) dic->dic_HeaderBase, MinDicNames, sizeof(MinDicNames) );\r
+ pfCopyMemory( (uint8_t *) dic->dic_CodeBase, MinDicCode, sizeof(MinDicCode) );\r
+ DBUG(("Static data copied to newly allocated dictionaries.\n"));\r
\r
- dic->dic_CodePtr.Byte = (uint8 *) CODEREL_TO_ABS(CODEPTR);\r
+ dic->dic_CodePtr.Byte = (uint8_t *) CODEREL_TO_ABS(CODEPTR);\r
gNumPrimitives = NUM_PRIMITIVES;\r
\r
- if( NAME_BASE != NULL)\r
+ if( NAME_BASE != 0)\r
{\r
/* Setup name space. */\r
- dic->dic_HeaderPtr.Byte = (uint8 *) NAMEREL_TO_ABS(HEADERPTR);\r
- gVarContext = (char *) NAMEREL_TO_ABS(RELCONTEXT); /* Restore context. */\r
+ dic->dic_HeaderPtr = (ucell_t)(uint8_t *) NAMEREL_TO_ABS(HEADERPTR);\r
+ gVarContext = NAMEREL_TO_ABS(RELCONTEXT); /* Restore context. */\r
\r
/* Find special words in dictionary for global XTs. */\r
if( (Result = FindSpecialXTs()) < 0 )\r