zdoom/acc
0
0
Fork 0
mirror of https://github.com/ZDoom/acc.git synced 2024-11-23 04:12:32 +00:00
Code Issues Projects Releases Packages Wiki Activity

- added ACC 64bit patch from Agent ME.

Browse source 
SVN r1073 (trunk)
This commit is contained in:
Christoph Oelckers 2008-07-19 08:01:33 +00:00
parent 08c9083086
commit 78184b3f56
7 changed files with 146 additions and 143 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
common.h
View file

@ -87,14 +87,16 @@ enum
// TYPES ------------------------------------------------------------------- // TYPES -------------------------------------------------------------------
typedef unsigned long boolean; typedef unsigned int boolean;
typedef unsigned char byte; typedef unsigned char byte;
typedef signed char S_BYTE; typedef signed char S_BYTE;
typedef unsigned char U_BYTE; typedef unsigned char U_BYTE;
typedef signed short S_WORD; typedef signed short S_WORD;
typedef unsigned short U_WORD; typedef unsigned short U_WORD;
typedef signed long S_LONG; typedef int S_INT;
typedef unsigned long U_LONG; typedef unsigned int U_INT;
// typedef signed long S_LONG;
// typedef unsigned long U_LONG;
enum ImportModes enum ImportModes
{ {

6
misc.c
View file

@ -113,13 +113,13 @@ U_WORD MS_LittleUWORD(U_WORD val)
//========================================================================== //==========================================================================
// //
// MS_LittleULONG // MS_LittleUINT
// //
// Converts a host U_LONG (4 bytes) to little endian byte order. // Converts a host U_INT (4 bytes) to little endian byte order.
// //
//========================================================================== //==========================================================================
U_LONG MS_LittleULONG(U_LONG val) U_INT MS_LittleUINT(U_INT val)
{ {
if(acs_BigEndianHost == NO) if(acs_BigEndianHost == NO)
{ {

3
misc.h
View file

@ -32,7 +32,8 @@ typedef enum
void *MS_Alloc(size_t size, error_t error); void *MS_Alloc(size_t size, error_t error);
void *MS_Realloc(void *base, size_t size, error_t error); void *MS_Realloc(void *base, size_t size, error_t error);
U_WORD MS_LittleUWORD(U_WORD val); U_WORD MS_LittleUWORD(U_WORD val);
U_LONG MS_LittleULONG(U_LONG val); // U_LONG MS_LittleULONG(U_LONG val);
U_INT MS_LittleUINT(U_INT val);
int MS_LoadFile(char *name, char **buffer); int MS_LoadFile(char *name, char **buffer);
boolean MS_SaveFile(char *name, void *buffer, int length); boolean MS_SaveFile(char *name, void *buffer, int length);
int MS_StrCmp(char *s1, char *s2); int MS_StrCmp(char *s1, char *s2);

118
parse.c
View file

@ -1548,7 +1548,7 @@ static void LeadingLineSpecial(boolean executewait)
PC_AppendCmd(PCD_LSPEC1+(argCount-1)); PC_AppendCmd(PCD_LSPEC1+(argCount-1));
if(pc_NoShrink) if(pc_NoShrink)
{ {
PC_AppendLong(specialValue); PC_AppendInt(specialValue);
} }
else else
{ {
@ -1561,33 +1561,33 @@ static void LeadingLineSpecial(boolean executewait)
} }
else else
{ {
boolean uselongform; boolean useintform;
if(pc_NoShrink) if(pc_NoShrink)
{ {
PC_AppendCmd(PCD_LSPEC1DIRECT+(argCount-1)); PC_AppendCmd(PCD_LSPEC1DIRECT+(argCount-1));
PC_AppendLong(specialValue); PC_AppendInt(specialValue);
uselongform = YES; useintform = YES;
} }
else else
{ {
uselongform = NO; useintform = NO;
for (i = 0; i < argCount; i++) for (i = 0; i < argCount; i++)
{ {
if ((unsigned int)argSave[i] > 255) if ((U_INT)argSave[i] > 255)
{ {
uselongform = YES; useintform = YES;
break; break;
} }
} }
PC_AppendCmd((argCount-1)+(uselongform?PCD_LSPEC1DIRECT:PCD_LSPEC1DIRECTB)); PC_AppendCmd((argCount-1)+(useintform?PCD_LSPEC1DIRECT:PCD_LSPEC1DIRECTB));
PC_AppendByte(specialValue); PC_AppendByte(specialValue);
} }
if (uselongform) if (useintform)
{ {
for (i = 0; i < argCount; i++) for (i = 0; i < argCount; i++)
{ {
PC_AppendLong(argSave[i]); PC_AppendInt(argSave[i]);
} }
} }
else else
@ -1600,7 +1600,7 @@ static void LeadingLineSpecial(boolean executewait)
if(executewait) if(executewait)
{ {
PC_AppendCmd(PCD_SCRIPTWAITDIRECT); PC_AppendCmd(PCD_SCRIPTWAITDIRECT);
PC_AppendLong(argSave[0]); PC_AppendInt(argSave[0]);
} }
} }
TK_NextToken(); TK_NextToken();
@ -1743,7 +1743,7 @@ static void ProcessInternFunc(symbolNode_t *sym)
} }
else else
{ {
PC_AppendLong(EvalConstExpression()); PC_AppendInt(EvalConstExpression());
} }
} }
else else
@ -1756,7 +1756,7 @@ static void ProcessInternFunc(symbolNode_t *sym)
} }
else else
{ {
PC_AppendLong(0); PC_AppendInt(0);
} }
} }
else else
@ -1788,16 +1788,16 @@ static void ProcessInternFunc(symbolNode_t *sym)
switch (sym->type) switch (sym->type)
{ {
case SY_SCRIPTVAR: case SY_SCRIPTVAR:
PC_AppendLong(sym->info.var.index | OUTVAR_SCRIPT_SPEC); PC_AppendInt(sym->info.var.index | OUTVAR_SCRIPT_SPEC);
break; break;
case SY_MAPVAR: case SY_MAPVAR:
PC_AppendLong(sym->info.var.index | OUTVAR_MAP_SPEC); PC_AppendInt(sym->info.var.index | OUTVAR_MAP_SPEC);
break; break;
case SY_WORLDVAR: case SY_WORLDVAR:
PC_AppendLong(sym->info.var.index | OUTVAR_WORLD_SPEC); PC_AppendInt(sym->info.var.index | OUTVAR_WORLD_SPEC);
break; break;
case SY_GLOBALVAR: case SY_GLOBALVAR:
PC_AppendLong(sym->info.var.index | OUTVAR_GLOBAL_SPEC); PC_AppendInt(sym->info.var.index | OUTVAR_GLOBAL_SPEC);
break; break;
default: default:
ERR_Error (ERR_PARM_MUST_BE_VAR, YES); ERR_Error (ERR_PARM_MUST_BE_VAR, YES);
@ -1838,7 +1838,7 @@ static void ProcessInternFunc(symbolNode_t *sym)
} }
else else
{ {
PC_AppendLong(0); PC_AppendInt(0);
} }
} }
else else
@ -1859,7 +1859,7 @@ static void ProcessInternFunc(symbolNode_t *sym)
} }
else if (specialDirect) else if (specialDirect)
{ {
boolean uselongform = NO; boolean useintform = NO;
pcd_t shortpcd; pcd_t shortpcd;
switch (sym->info.internFunc.directCommand) switch (sym->info.internFunc.directCommand)
@ -1871,29 +1871,29 @@ static void ProcessInternFunc(symbolNode_t *sym)
shortpcd = PCD_RANDOMDIRECTB; shortpcd = PCD_RANDOMDIRECTB;
break; break;
default: default:
uselongform = YES; useintform = YES;
shortpcd = PCD_NOP; shortpcd = PCD_NOP;
break; break;
} }
if (!uselongform) if (!useintform)
{ {
for (i = 0; i < argCount; i++) for (i = 0; i < argCount; i++)
{ {
if ((unsigned int)argSave[i] > 255) if ((U_INT)argSave[i] > 255)
{ {
uselongform = YES; useintform = YES;
break; break;
} }
} }
} }
if (uselongform) if (useintform)
{ {
PC_AppendCmd(sym->info.internFunc.directCommand); PC_AppendCmd(sym->info.internFunc.directCommand);
for (i = 0; i < argCount; i++) for (i = 0; i < argCount; i++)
{ {
PC_AppendLong (argSave[i]); PC_AppendInt (argSave[i]);
} }
} }
else else
@ -2006,7 +2006,7 @@ static void ProcessScriptFunc(symbolNode_t *sym, boolean discardReturn)
} }
if (pc_NoShrink) if (pc_NoShrink)
{ {
PC_AppendLong(sym->info.scriptFunc.funcNumber); PC_AppendInt(sym->info.scriptFunc.funcNumber);
} }
else else
{ {
@ -2279,7 +2279,7 @@ static void LeadingIf(void)
TK_TokenMustBe(TK_RPAREN, ERR_MISSING_RPAREN); TK_TokenMustBe(TK_RPAREN, ERR_MISSING_RPAREN);
PC_AppendCmd(PCD_IFNOTGOTO); PC_AppendCmd(PCD_IFNOTGOTO);
jumpAddrPtr1 = pc_Address; jumpAddrPtr1 = pc_Address;
PC_SkipLong(); PC_SkipInt();
TK_NextToken(); TK_NextToken();
if(ProcessStatement(STMT_IF) == NO) if(ProcessStatement(STMT_IF) == NO)
{ {
@ -2289,18 +2289,18 @@ static void LeadingIf(void)
{ {
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
jumpAddrPtr2 = pc_Address; jumpAddrPtr2 = pc_Address;
PC_SkipLong(); PC_SkipInt();
PC_WriteLong(pc_Address, jumpAddrPtr1); PC_WriteInt(pc_Address, jumpAddrPtr1);
TK_NextToken(); TK_NextToken();
if(ProcessStatement(STMT_ELSE) == NO) if(ProcessStatement(STMT_ELSE) == NO)
{ {
ERR_Error(ERR_INVALID_STATEMENT, YES); ERR_Error(ERR_INVALID_STATEMENT, YES);
} }
PC_WriteLong(pc_Address, jumpAddrPtr2); PC_WriteInt(pc_Address, jumpAddrPtr2);
} }
else else
{ {
PC_WriteLong(pc_Address, jumpAddrPtr1); PC_WriteInt(pc_Address, jumpAddrPtr1);
} }
} }
@ -2330,10 +2330,10 @@ static void LeadingFor(void)
TK_NextToken(); TK_NextToken();
PC_AppendCmd(PCD_IFGOTO); PC_AppendCmd(PCD_IFGOTO);
ifgotoAddr = pc_Address; ifgotoAddr = pc_Address;
PC_SkipLong(); PC_SkipInt();
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
gotoAddr = pc_Address; gotoAddr = pc_Address;
PC_SkipLong(); PC_SkipInt();
incAddr = pc_Address; incAddr = pc_Address;
forSemicolonHack = TRUE; forSemicolonHack = TRUE;
if(ProcessStatement(STMT_FOR) == NO) if(ProcessStatement(STMT_FOR) == NO)
@ -2342,17 +2342,17 @@ static void LeadingFor(void)
} }
forSemicolonHack = FALSE; forSemicolonHack = FALSE;
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
PC_AppendLong(exprAddr); PC_AppendInt(exprAddr);
PC_WriteLong(pc_Address,ifgotoAddr); PC_WriteInt(pc_Address,ifgotoAddr);
if(ProcessStatement(STMT_FOR) == NO) if(ProcessStatement(STMT_FOR) == NO)
{ {
ERR_Error(ERR_INVALID_STATEMENT, YES); ERR_Error(ERR_INVALID_STATEMENT, YES);
} }
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
PC_AppendLong(incAddr); PC_AppendInt(incAddr);
WriteContinues(incAddr); WriteContinues(incAddr);
WriteBreaks(); WriteBreaks();
PC_WriteLong(pc_Address,gotoAddr); PC_WriteInt(pc_Address,gotoAddr);
} }
//========================================================================== //==========================================================================
@ -2376,16 +2376,16 @@ static void LeadingWhileUntil(void)
TK_TokenMustBe(TK_RPAREN, ERR_MISSING_RPAREN); TK_TokenMustBe(TK_RPAREN, ERR_MISSING_RPAREN);
PC_AppendCmd(stmtToken == TK_WHILE ? PCD_IFNOTGOTO : PCD_IFGOTO); PC_AppendCmd(stmtToken == TK_WHILE ? PCD_IFNOTGOTO : PCD_IFGOTO);
outAddrPtr = pc_Address; outAddrPtr = pc_Address;
PC_SkipLong(); PC_SkipInt();
TK_NextToken(); TK_NextToken();
if(ProcessStatement(STMT_WHILEUNTIL) == NO) if(ProcessStatement(STMT_WHILEUNTIL) == NO)
{ {
ERR_Error(ERR_INVALID_STATEMENT, YES); ERR_Error(ERR_INVALID_STATEMENT, YES);
} }
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
PC_AppendLong(topAddr); PC_AppendInt(topAddr);
PC_WriteLong(pc_Address, outAddrPtr); PC_WriteInt(pc_Address, outAddrPtr);
WriteContinues(topAddr); WriteContinues(topAddr);
WriteBreaks(); WriteBreaks();
@ -2424,7 +2424,7 @@ static void LeadingDo(void)
TK_TokenMustBe(TK_RPAREN, ERR_MISSING_RPAREN); TK_TokenMustBe(TK_RPAREN, ERR_MISSING_RPAREN);
TK_NextTokenMustBe(TK_SEMICOLON, ERR_MISSING_SEMICOLON); TK_NextTokenMustBe(TK_SEMICOLON, ERR_MISSING_SEMICOLON);
PC_AppendCmd(stmtToken == TK_WHILE ? PCD_IFGOTO : PCD_IFNOTGOTO); PC_AppendCmd(stmtToken == TK_WHILE ? PCD_IFGOTO : PCD_IFNOTGOTO);
PC_AppendLong(topAddr); PC_AppendInt(topAddr);
WriteContinues(exprAddr); WriteContinues(exprAddr);
WriteBreaks(); WriteBreaks();
TK_NextToken(); TK_NextToken();
@ -2452,7 +2452,7 @@ static void LeadingSwitch(void)
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
switcherAddrPtr = pc_Address; switcherAddrPtr = pc_Address;
PC_SkipLong(); PC_SkipInt();
TK_NextToken(); TK_NextToken();
if(ProcessStatement(STMT_SWITCH) == NO) if(ProcessStatement(STMT_SWITCH) == NO)
@ -2462,9 +2462,9 @@ static void LeadingSwitch(void)
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
outAddrPtr = pc_Address; outAddrPtr = pc_Address;
PC_SkipLong(); PC_SkipInt();
PC_WriteLong(pc_Address, switcherAddrPtr); PC_WriteInt(pc_Address, switcherAddrPtr);
defaultAddress = 0; defaultAddress = 0;
if(pc_HexenCase) if(pc_HexenCase)
@ -2477,8 +2477,8 @@ static void LeadingSwitch(void)
continue; continue;
} }
PC_AppendCmd(PCD_CASEGOTO); PC_AppendCmd(PCD_CASEGOTO);
PC_AppendLong(cInfo->value); PC_AppendInt(cInfo->value);
PC_AppendLong(cInfo->address); PC_AppendInt(cInfo->address);
} }
} }
else if(CaseIndex != 0) else if(CaseIndex != 0)
@ -2503,14 +2503,14 @@ static void LeadingSwitch(void)
PC_AppendCmd(PCD_CASEGOTOSORTED); PC_AppendCmd(PCD_CASEGOTOSORTED);
if(pc_Address%4 != 0) if(pc_Address%4 != 0)
{ // Align to a 4-byte boundary { // Align to a 4-byte boundary
U_LONG pad = 0; U_INT pad = 0;
PC_Append((void *)&pad, 4-(pc_Address%4)); PC_Append((void *)&pad, 4-(pc_Address%4));
} }
PC_AppendLong(maxCase - minCase); PC_AppendInt(maxCase - minCase);
for(; minCase < maxCase; ++minCase) for(; minCase < maxCase; ++minCase)
{ {
PC_AppendLong(minCase->value); PC_AppendInt(minCase->value);
PC_AppendLong(minCase->address); PC_AppendInt(minCase->address);
} }
} }
} }
@ -2519,10 +2519,10 @@ static void LeadingSwitch(void)
if(defaultAddress != 0) if(defaultAddress != 0)
{ {
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
PC_AppendLong(defaultAddress); PC_AppendInt(defaultAddress);
} }
PC_WriteLong(pc_Address, outAddrPtr); PC_WriteInt(pc_Address, outAddrPtr);
WriteBreaks(); WriteBreaks();
} }
@ -2650,7 +2650,7 @@ static void LeadingBreak(void)
TK_NextTokenMustBe(TK_SEMICOLON, ERR_MISSING_SEMICOLON); TK_NextTokenMustBe(TK_SEMICOLON, ERR_MISSING_SEMICOLON);
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
PushBreak(); PushBreak();
PC_SkipLong(); PC_SkipInt();
TK_NextToken(); TK_NextToken();
} }
@ -2681,7 +2681,7 @@ static void WriteBreaks(void)
{ {
while(BreakIndex && BreakInfo[BreakIndex-1].level > StatementLevel) while(BreakIndex && BreakInfo[BreakIndex-1].level > StatementLevel)
{ {
PC_WriteLong(pc_Address, BreakInfo[--BreakIndex].addressPtr); PC_WriteInt(pc_Address, BreakInfo[--BreakIndex].addressPtr);
} }
} }
@ -2720,7 +2720,7 @@ static void LeadingContinue(void)
TK_NextTokenMustBe(TK_SEMICOLON, ERR_MISSING_SEMICOLON); TK_NextTokenMustBe(TK_SEMICOLON, ERR_MISSING_SEMICOLON);
PC_AppendCmd(PCD_GOTO); PC_AppendCmd(PCD_GOTO);
PushContinue(); PushContinue();
PC_SkipLong(); PC_SkipInt();
TK_NextToken(); TK_NextToken();
} }
@ -2755,7 +2755,7 @@ static void WriteContinues(int address)
} }
while(ContinueInfo[ContinueIndex-1].level > StatementLevel) while(ContinueInfo[ContinueIndex-1].level > StatementLevel)
{ {
PC_WriteLong(address, ContinueInfo[--ContinueIndex].addressPtr); PC_WriteInt(address, ContinueInfo[--ContinueIndex].addressPtr);
} }
} }
@ -2862,7 +2862,7 @@ static void LeadingVarAssign(symbolNode_t *sym)
PC_AppendCmd(GetIncDecPCD(tk_Token, sym->type)); PC_AppendCmd(GetIncDecPCD(tk_Token, sym->type));
if (pc_NoShrink) if (pc_NoShrink)
{ {
PC_AppendLong(sym->info.var.index); PC_AppendInt(sym->info.var.index);
} }
else else
{ {
@ -3191,7 +3191,7 @@ static void ExprLineSpecial(void)
PC_AppendCmd(PCD_LSPEC5RESULT); PC_AppendCmd(PCD_LSPEC5RESULT);
if(pc_NoShrink) if(pc_NoShrink)
{ {
PC_AppendLong(specialValue); PC_AppendInt(specialValue);
} }
else else
{ {
@ -3962,7 +3962,7 @@ static void UnspeculateFunction(symbolNode_t *sym)
if(pc_NoShrink) if(pc_NoShrink)
{ {
PC_WriteLong(sym->info.scriptFunc.funcNumber, fillin->address); PC_WriteInt(sym->info.scriptFunc.funcNumber, fillin->address);
} }
else else
{ {

116
pcode.c
View file

@ -486,7 +486,7 @@ void PC_OpenObject(char *name, size_t size, int flags)
pc_ScriptCount = 0; pc_ScriptCount = 0;
ObjectOpened = YES; ObjectOpened = YES;
PC_AppendString("ACS"); PC_AppendString("ACS");
PC_SkipLong(); // Script table offset PC_SkipInt(); // Script table offset
} }
//========================================================================== //==========================================================================
@ -529,16 +529,16 @@ static void CloseOld(void)
int i; int i;
STR_WriteStrings(); STR_WriteStrings();
PC_WriteLong((U_LONG)pc_Address, 4); PC_WriteInt((U_INT)pc_Address, 4);
PC_AppendLong((U_LONG)pc_ScriptCount); PC_AppendInt((U_INT)pc_ScriptCount);
for(i = 0; i < pc_ScriptCount; ++i) for(i = 0; i < pc_ScriptCount; ++i)
{ {
scriptInfo_t *info = &ScriptInfo[i]; scriptInfo_t *info = &ScriptInfo[i];
MS_Message(MSG_DEBUG, "Script %d, address = %d, arg count = %d\n", MS_Message(MSG_DEBUG, "Script %d, address = %d, arg count = %d\n",
info->number, info->address, info->argCount); info->number, info->address, info->argCount);
PC_AppendLong((U_LONG)(info->number + info->type * 1000)); PC_AppendInt((U_INT)(info->number + info->type * 1000));
PC_AppendLong((U_LONG)info->address); PC_AppendInt((U_INT)info->address);
PC_AppendLong((U_LONG)info->argCount); PC_AppendInt((U_INT)info->argCount);
} }
STR_WriteList(); STR_WriteList();
} }
@ -580,7 +580,7 @@ static void CloseNew(void)
if(j > 0) if(j > 0)
{ {
PC_Append("SPTR", 4); PC_Append("SPTR", 4);
PC_AppendLong(j * 8); PC_AppendInt(j * 8);
for(i = 0; i < pc_ScriptCount; i++) for(i = 0; i < pc_ScriptCount; i++)
{ {
scriptInfo_t *info = &ScriptInfo[i]; scriptInfo_t *info = &ScriptInfo[i];
@ -591,7 +591,7 @@ static void CloseNew(void)
PC_AppendWord(info->number); PC_AppendWord(info->number);
PC_AppendByte(info->type); PC_AppendByte(info->type);
PC_AppendByte(info->argCount); PC_AppendByte(info->argCount);
PC_AppendLong((U_LONG)info->address); PC_AppendInt((U_INT)info->address);
} }
} }
} }
@ -607,7 +607,7 @@ static void CloseNew(void)
if(j > 0) if(j > 0)
{ {
PC_Append("SVCT", 4); PC_Append("SVCT", 4);
PC_AppendLong(j * 4); PC_AppendInt(j * 4);
for(i = 0; i < pc_ScriptCount; ++i) for(i = 0; i < pc_ScriptCount; ++i)
{ {
scriptInfo_t *info = &ScriptInfo[i]; scriptInfo_t *info = &ScriptInfo[i];
@ -632,7 +632,7 @@ static void CloseNew(void)
if (j > 0) if (j > 0)
{ {
PC_Append("SFLG", 4); PC_Append("SFLG", 4);
PC_AppendLong(j * 4); PC_AppendInt(j * 4);
for(i = 0; i < pc_ScriptCount; ++i) for(i = 0; i < pc_ScriptCount; ++i)
{ {
scriptInfo_t *info = &ScriptInfo[i]; scriptInfo_t *info = &ScriptInfo[i];
@ -647,7 +647,7 @@ static void CloseNew(void)
if(pc_FunctionCount > 0) if(pc_FunctionCount > 0)
{ {
PC_Append("FUNC", 4); PC_Append("FUNC", 4);
PC_AppendLong(pc_FunctionCount * 8); PC_AppendInt(pc_FunctionCount * 8);
for(i = 0; i < pc_FunctionCount; ++i) for(i = 0; i < pc_FunctionCount; ++i)
{ {
functionInfo_t *info = &FunctionInfo[i]; functionInfo_t *info = &FunctionInfo[i];
@ -658,7 +658,7 @@ static void CloseNew(void)
PC_AppendByte(info->localCount); PC_AppendByte(info->localCount);
PC_AppendByte((U_BYTE)(info->hasReturnValue?1:0)); PC_AppendByte((U_BYTE)(info->hasReturnValue?1:0));
PC_AppendByte(0); PC_AppendByte(0);
PC_AppendLong((U_LONG)info->address); PC_AppendInt((U_INT)info->address);
} }
STR_WriteListChunk(STRLIST_FUNCTIONS, MAKE4CC('F','N','A','M'), NO); STR_WriteListChunk(STRLIST_FUNCTIONS, MAKE4CC('F','N','A','M'), NO);
} }
@ -695,11 +695,11 @@ static void CloseNew(void)
if (i < j) if (i < j)
{ {
PC_Append("MINI", 4); PC_Append("MINI", 4);
PC_AppendLong((j-i)*4+4); PC_AppendInt((j-i)*4+4);
PC_AppendLong(i); // First map var defined PC_AppendInt(i); // First map var defined
for(; i < j; ++i) for(; i < j; ++i)
{ {
PC_AppendLong(MapVariables[i].initializer); PC_AppendInt(MapVariables[i].initializer);
} }
} }
} }
@ -720,12 +720,12 @@ static void CloseNew(void)
if(count > 0) if(count > 0)
{ {
PC_Append("MSTR", 4); PC_Append("MSTR", 4);
PC_AppendLong(count*4); PC_AppendInt(count*4);
for(i = 0; i < pa_MapVarCount; ++i) for(i = 0; i < pa_MapVarCount; ++i)
{ {
if(MapVariables[i].isString) if(MapVariables[i].isString)
{ {
PC_AppendLong(i); PC_AppendInt(i);
} }
} }
} }
@ -741,12 +741,12 @@ static void CloseNew(void)
if(count > 0) if(count > 0)
{ {
PC_Append("ASTR", 4); PC_Append("ASTR", 4);
PC_AppendLong(count*4); PC_AppendInt(count*4);
for(i = 0; i < pa_MapVarCount; ++i) for(i = 0; i < pa_MapVarCount; ++i)
{ {
if(ArrayOfStrings[i]) if(ArrayOfStrings[i])
{ {
PC_AppendLong(i); PC_AppendInt(i);
} }
} }
} }
@ -781,12 +781,12 @@ static void CloseNew(void)
if(count > 0) if(count > 0)
{ {
PC_Append("MIMP", 4); PC_Append("MIMP", 4);
PC_AppendLong(count); PC_AppendInt(count);
for(i = 0; i < pa_MapVarCount; ++i) for(i = 0; i < pa_MapVarCount; ++i)
{ {
if(MapVariables[i].imported && !ArraySizes[i]) if(MapVariables[i].imported && !ArraySizes[i])
{ {
PC_AppendLong(i); PC_AppendInt(i);
PC_AppendString(MapVariables[i].name); PC_AppendString(MapVariables[i].name);
} }
} }
@ -807,13 +807,13 @@ static void CloseNew(void)
if(count) if(count)
{ {
PC_Append("ARAY", 4); PC_Append("ARAY", 4);
PC_AppendLong(count*8); PC_AppendInt(count*8);
for(i = 0; i < pa_MapVarCount; ++i) for(i = 0; i < pa_MapVarCount; ++i)
{ {
if(ArraySizes[i] && !MapVariables[i].imported) if(ArraySizes[i] && !MapVariables[i].imported)
{ {
PC_AppendLong(i); PC_AppendInt(i);
PC_AppendLong(ArraySizes[i]); PC_AppendInt(ArraySizes[i]);
} }
} }
for(i = 0; i < pa_MapVarCount; ++i) for(i = 0; i < pa_MapVarCount; ++i)
@ -823,11 +823,11 @@ static void CloseNew(void)
int j; int j;
PC_Append("AINI", 4); PC_Append("AINI", 4);
PC_AppendLong(ArraySizes[i]*4+4); PC_AppendInt(ArraySizes[i]*4+4);
PC_AppendLong((U_LONG)i); PC_AppendInt((U_INT)i);
for(j = 0; j < ArraySizes[i]; ++j) for(j = 0; j < ArraySizes[i]; ++j)
{ {
PC_AppendLong((U_LONG)ArrayInits[i][j]); PC_AppendInt((U_INT)ArrayInits[i][j]);
} }
} }
} }
@ -845,14 +845,14 @@ static void CloseNew(void)
if(count) if(count)
{ {
PC_Append("AIMP", 4); PC_Append("AIMP", 4);
PC_AppendLong(count+4); PC_AppendInt(count+4);
PC_AppendLong(j); PC_AppendInt(j);
for(i = 0; i < pa_MapVarCount; ++i) for(i = 0; i < pa_MapVarCount; ++i)
{ {
if(ArraySizes[i] && MapVariables[i].imported) if(ArraySizes[i] && MapVariables[i].imported)
{ {
PC_AppendLong(i); PC_AppendInt(i);
PC_AppendLong(ArraySizes[i]); PC_AppendInt(ArraySizes[i]);
PC_AppendString(MapVariables[i].name); PC_AppendString(MapVariables[i].name);
} }
} }
@ -863,7 +863,7 @@ static void CloseNew(void)
if(ImportMode == IMPORT_Exporting) if(ImportMode == IMPORT_Exporting)
{ {
PC_Append("ALIB", 4); PC_Append("ALIB", 4);
PC_AppendLong(0); PC_AppendInt(0);
} }
// Record libraries imported by this object. // Record libraries imported by this object.
@ -877,7 +877,7 @@ static void CloseNew(void)
if(count > 0) if(count > 0)
{ {
PC_Append("LOAD", 4); PC_Append("LOAD", 4);
PC_AppendLong(count); PC_AppendInt(count);
for(i = 0; i < NumImports; ++i) for(i = 0; i < NumImports; ++i)
{ {
PC_AppendString(Imports[i]); PC_AppendString(Imports[i]);
@ -885,7 +885,7 @@ static void CloseNew(void)
} }
} }
PC_AppendLong((U_LONG)chunkStart); PC_AppendInt((U_INT)chunkStart);
if(pc_NoShrink) if(pc_NoShrink)
{ {
PC_Append("ACSE", 4); PC_Append("ACSE", 4);
@ -894,7 +894,7 @@ static void CloseNew(void)
{ {
PC_Append("ACSe", 4); PC_Append("ACSe", 4);
} }
PC_WriteLong((U_LONG)pc_Address, 4); PC_WriteInt((U_INT)pc_Address, 4);
// WadAuthor compatibility when creating a library is pointless, because // WadAuthor compatibility when creating a library is pointless, because
// that editor does not know anything about libraries and will never // that editor does not know anything about libraries and will never
@ -905,9 +905,9 @@ static void CloseNew(void)
} }
else else
{ {
PC_AppendLong(0); PC_AppendInt(0);
} }
PC_AppendLong(0); PC_AppendInt(0);
} }
//========================================================================== //==========================================================================
@ -923,7 +923,7 @@ static void CreateDummyScripts(void)
MS_Message(MSG_DEBUG, "Creating dummy scripts to make WadAuthor happy.\n"); MS_Message(MSG_DEBUG, "Creating dummy scripts to make WadAuthor happy.\n");
if(pc_Address%4 != 0) if(pc_Address%4 != 0)
{ // Need to align { // Need to align
U_LONG pad = 0; U_INT pad = 0;
PC_Append((void *)&pad, 4-(pc_Address%4)); PC_Append((void *)&pad, 4-(pc_Address%4));
} }
pc_DummyAddress = pc_Address; pc_DummyAddress = pc_Address;
@ -959,7 +959,7 @@ static void RecordDummyScripts(void)
++count; ++count;
} }
} }
PC_AppendLong((U_LONG)count); PC_AppendInt((U_INT)count);
for(i = 0; i < pc_ScriptCount; ++i) for(i = 0; i < pc_ScriptCount; ++i)
{ {
scriptInfo_t *info = &ScriptInfo[i]; scriptInfo_t *info = &ScriptInfo[i];
@ -967,9 +967,9 @@ static void RecordDummyScripts(void)
{ {
MS_Message(MSG_DEBUG, "Dummy script %d, address = %d, arg count = %d\n", MS_Message(MSG_DEBUG, "Dummy script %d, address = %d, arg count = %d\n",
info->number, info->address, info->argCount); info->number, info->address, info->argCount);
PC_AppendLong((U_LONG)info->number); PC_AppendInt((U_INT)info->number);
PC_AppendLong((U_LONG)pc_DummyAddress + i*4); PC_AppendInt((U_INT)pc_DummyAddress + i*4);
PC_AppendLong((U_LONG)info->argCount); PC_AppendInt((U_INT)info->argCount);
} }
} }
} }
@ -1037,13 +1037,13 @@ void PC_AppendWord(U_WORD val)
} }
} }
void PC_AppendLong(U_LONG val) void PC_AppendInt(U_INT val)
{ {
if (ImportMode != IMPORT_Importing) if (ImportMode != IMPORT_Importing)
{ {
MS_Message(MSG_DEBUG, "AL> %06d = %d\n", pc_Address, val); MS_Message(MSG_DEBUG, "AL> %06d = %d\n", pc_Address, val);
val = MS_LittleULONG(val); val = MS_LittleUINT(val);
Append(&val, sizeof(U_LONG)); Append(&val, sizeof(U_INT));
} }
} }
@ -1069,8 +1069,8 @@ void PC_AppendCmd(pcd_t command)
{ {
MS_Message(MSG_DEBUG, "AC> %06d = #%d:%s\n", pc_Address, MS_Message(MSG_DEBUG, "AC> %06d = #%d:%s\n", pc_Address,
command, PCDNames[command]); command, PCDNames[command]);
command = MS_LittleULONG(command); command = MS_LittleUINT(command);
Append(&command, sizeof(U_LONG)); Append(&command, sizeof(U_INT));
} }
else else
{ {
@ -1143,7 +1143,7 @@ void PC_AppendShrink(U_BYTE val)
{ {
if(pc_NoShrink) if(pc_NoShrink)
{ {
PC_AppendLong(val); PC_AppendInt(val);
} }
else else
{ {
@ -1157,12 +1157,12 @@ void PC_AppendShrink(U_BYTE val)
// //
//========================================================================== //==========================================================================
void PC_AppendPushVal(U_LONG val) void PC_AppendPushVal(U_INT val)
{ {
if(pc_NoShrink || val > 255) if(pc_NoShrink || val > 255)
{ {
PC_AppendCmd(PCD_PUSHNUMBER); PC_AppendCmd(PCD_PUSHNUMBER);
PC_AppendLong(val); PC_AppendInt(val);
} }
else else
{ {
@ -1216,13 +1216,13 @@ void PC_WriteWord(U_WORD val, int address)
} }
*/ */
void PC_WriteLong(U_LONG val, int address) void PC_WriteInt(U_INT val, int address)
{ {
if (ImportMode != IMPORT_Importing) if (ImportMode != IMPORT_Importing)
{ {
MS_Message(MSG_DEBUG, "WL> %06d = %d\n", address, val); MS_Message(MSG_DEBUG, "WL> %06d = %d\n", address, val);
val = MS_LittleULONG(val); val = MS_LittleUINT(val);
Write(&val, sizeof(U_LONG), address); Write(&val, sizeof(U_INT), address);
} }
pc_LastAppendedCommand = PCD_NOP; pc_LastAppendedCommand = PCD_NOP;
} }
@ -1246,8 +1246,8 @@ void PC_WriteCmd(pcd_t command, int address)
{ {
MS_Message(MSG_DEBUG, "WC> %06d = #%d:%s\n", address, MS_Message(MSG_DEBUG, "WC> %06d = #%d:%s\n", address,
command, PCDNames[command]); command, PCDNames[command]);
command = MS_LittleULONG(command); command = MS_LittleUINT(command);
Write(&command, sizeof(U_LONG), address); Write(&command, sizeof(U_INT), address);
} }
} }
@ -1295,12 +1295,12 @@ void PC_SkipWord(void)
} }
*/ */
void PC_SkipLong(void) void PC_SkipInt(void)
{ {
if (ImportMode != IMPORT_Importing) if (ImportMode != IMPORT_Importing)
{ {
MS_Message(MSG_DEBUG, "SL> %06d (skip long)\n", pc_Address); MS_Message(MSG_DEBUG, "SL> %06d (skip int)\n", pc_Address);
Skip(sizeof(U_LONG)); Skip(sizeof(U_INT));
} }
} }

8
pcode.h
View file

@ -419,21 +419,21 @@ void PC_CloseObject(void);
void PC_Append(void *buffer, size_t size); void PC_Append(void *buffer, size_t size);
void PC_AppendByte(U_BYTE val); void PC_AppendByte(U_BYTE val);
void PC_AppendWord(U_WORD val); void PC_AppendWord(U_WORD val);
void PC_AppendLong(U_LONG val); void PC_AppendInt(U_INT val);
void PC_AppendString(char *string); void PC_AppendString(char *string);
void PC_AppendCmd(pcd_t command); void PC_AppendCmd(pcd_t command);
void PC_AppendPushVal(U_LONG val); void PC_AppendPushVal(U_INT val);
void PC_AppendShrink(U_BYTE val); void PC_AppendShrink(U_BYTE val);
void PC_Write(void *buffer, size_t size, int address); void PC_Write(void *buffer, size_t size, int address);
void PC_WriteByte(U_BYTE val, int address); void PC_WriteByte(U_BYTE val, int address);
//void PC_WriteWord(U_WORD val, int address); //void PC_WriteWord(U_WORD val, int address);
void PC_WriteLong(U_LONG val, int address); void PC_WriteInt(U_INT val, int address);
void PC_WriteString(char *string, int address); void PC_WriteString(char *string, int address);
void PC_WriteCmd(pcd_t command, int address); void PC_WriteCmd(pcd_t command, int address);
void PC_Skip(size_t size); void PC_Skip(size_t size);
//void PC_SkipByte(void); //void PC_SkipByte(void);
//void PC_SkipWord(void); //void PC_SkipWord(void);
void PC_SkipLong(void); void PC_SkipInt(void);
void PC_AddScript(int number, int argCount); void PC_AddScript(int number, int argCount);
void PC_SetScriptVarCount(int number, int varCount); void PC_SetScriptVarCount(int number, int varCount);
void PC_AddFunction(struct symbolNode_s *sym); void PC_AddFunction(struct symbolNode_s *sym);

30
strlist.c
View file

@ -274,7 +274,7 @@ int STR_ListSize(int list)
void STR_WriteStrings(void) void STR_WriteStrings(void)
{ {
int i; int i;
U_LONG pad; U_INT pad;
MS_Message(MSG_DEBUG, "---- STR_WriteStrings ----\n"); MS_Message(MSG_DEBUG, "---- STR_WriteStrings ----\n");
for(i = 0; i < LanguageInfo[0]->list.stringCount; i++) for(i = 0; i < LanguageInfo[0]->list.stringCount; i++)
@ -300,10 +300,10 @@ void STR_WriteList(void)
int i; int i;
MS_Message(MSG_DEBUG, "---- STR_WriteList ----\n"); MS_Message(MSG_DEBUG, "---- STR_WriteList ----\n");
PC_AppendLong((U_LONG)LanguageInfo[0]->list.stringCount); PC_AppendInt((U_INT)LanguageInfo[0]->list.stringCount);
for(i = 0; i < LanguageInfo[0]->list.stringCount; i++) for(i = 0; i < LanguageInfo[0]->list.stringCount; i++)
{ {
PC_AppendLong((U_LONG)LanguageInfo[0]->list.strings[i].address); PC_AppendInt((U_INT)LanguageInfo[0]->list.strings[i].address);
} }
} }
@ -321,10 +321,10 @@ void STR_WriteChunk(int language, boolean encrypt)
MS_Message(MSG_DEBUG, "---- STR_WriteChunk %d ----\n", language); MS_Message(MSG_DEBUG, "---- STR_WriteChunk %d ----\n", language);
PC_Append(encrypt ? "STRE" : "STRL", 4); PC_Append(encrypt ? "STRE" : "STRL", 4);
lenadr = pc_Address; lenadr = pc_Address;
PC_SkipLong(); PC_SkipInt();
PC_Append(&lang->name, 4); PC_Append(&lang->name, 4);
PC_AppendLong(lang->list.stringCount); PC_AppendInt(lang->list.stringCount);
PC_AppendLong(0); // Used in-game for stringing lists together PC_AppendInt(0); // Used in-game for stringing lists together
DumpStrings (&lang->list, lenadr, NO, encrypt); DumpStrings (&lang->list, lenadr, NO, encrypt);
} }
@ -343,14 +343,14 @@ void STR_WriteListChunk(int list, int id, boolean quad)
{ {
MS_Message(MSG_DEBUG, "---- STR_WriteListChunk %d %c%c%c%c----\n", list, MS_Message(MSG_DEBUG, "---- STR_WriteListChunk %d %c%c%c%c----\n", list,
id&255, (id>>8)&255, (id>>16)&255, (id>>24)&255); id&255, (id>>8)&255, (id>>16)&255, (id>>24)&255);
PC_AppendLong((U_LONG)id); PC_AppendInt((U_INT)id);
lenadr = pc_Address; lenadr = pc_Address;
PC_SkipLong(); PC_SkipInt();
PC_AppendLong(StringLists[list]->stringCount); PC_AppendInt(StringLists[list]->stringCount);
if (quad && pc_Address%8 != 0) if (quad && pc_Address%8 != 0)
{ // If writing quadword indices, align the indices to an { // If writing quadword indices, align the indices to an
// 8-byte boundary. // 8-byte boundary.
U_LONG pad = 0; U_INT pad = 0;
PC_Append (&pad, 4); PC_Append (&pad, 4);
} }
DumpStrings(StringLists[list], lenadr, quad, NO); DumpStrings(StringLists[list], lenadr, quad, NO);
@ -373,16 +373,16 @@ static void DumpStrings(stringList_t *list, int lenadr, boolean quad, boolean cr
{ {
if (list->strings[i].name != NULL) if (list->strings[i].name != NULL)
{ {
PC_AppendLong((U_LONG)ofs); PC_AppendInt((U_INT)ofs);
ofs += strlen(list->strings[i].name) + 1; ofs += strlen(list->strings[i].name) + 1;
} }
else else
{ {
PC_AppendLong(0); PC_AppendInt(0);
} }
if (quad) if (quad)
{ {
PC_AppendLong(0); PC_AppendInt(0);
} }
} }
@ -410,11 +410,11 @@ static void DumpStrings(stringList_t *list, int lenadr, boolean quad, boolean cr
} }
if(pc_Address%4 != 0) if(pc_Address%4 != 0)
{ // Need to align { // Need to align
U_LONG pad = 0; U_INT pad = 0;
PC_Append((void *)&pad, 4-(pc_Address%4)); PC_Append((void *)&pad, 4-(pc_Address%4));
} }
PC_WriteLong(pc_Address - lenadr - 4, lenadr); PC_WriteInt(pc_Address - lenadr - 4, lenadr);
} }
static void Encrypt(void *data, int key, int len) static void Encrypt(void *data, int key, int len)