pcode.c

   1 \r
   2 //**************************************************************************\r
   3 //**\r
   4 //** pcode.c\r
   5 //**\r
   6 //**************************************************************************\r
   7 \r
   8 // HEADER FILES ------------------------------------------------------------\r
   9 \r
  10 #include <string.h>\r
  11 #include <stddef.h>\r
  12 #include "pcode.h"\r
  13 #include "common.h"\r
  14 #include "error.h"\r
  15 #include "misc.h"\r
  16 #include "strlist.h"\r
  17 #include "token.h"\r
  18 #include "symbol.h"\r
  19 #include "parse.h"\r
  20 \r
  21 // MACROS ------------------------------------------------------------------\r
  22 \r
  23 // TYPES -------------------------------------------------------------------\r
  24 \r
  25 typedef struct scriptInfo_s\r
  26 {\r
  27         U_WORD number;\r
  28         U_BYTE type;\r
  29         U_BYTE argCount;\r
  30         U_WORD varCount;\r
  31         U_WORD flags;\r
  32         int address;\r
  33         int srcLine;\r
  34         boolean imported;\r
  35 } scriptInfo_t;\r
  36 \r
  37 typedef struct functionInfo_s\r
  38 {\r
  39         U_BYTE hasReturnValue;\r
  40         U_BYTE argCount;\r
  41         U_BYTE localCount;\r
  42         int address;\r
  43         int name;\r
  44 } functionInfo_t;\r
  45 \r
  46 typedef struct mapVarInfo_s\r
  47 {\r
  48         int initializer;\r
  49         boolean isString;\r
  50         char *name;\r
  51         boolean imported;\r
  52 } mapVarInfo_t;\r
  53 \r
  54 // EXTERNAL FUNCTION PROTOTYPES --------------------------------------------\r
  55 \r
  56 // PUBLIC FUNCTION PROTOTYPES ----------------------------------------------\r
  57 \r
  58 // PRIVATE FUNCTION PROTOTYPES ---------------------------------------------\r
  59 \r
  60 static void GrowBuffer(void);\r
  61 static void Append(void *buffer, size_t size);\r
  62 static void Write(void *buffer, size_t size, int address);\r
  63 static void Skip(size_t size);\r
  64 static void CloseOld(void);\r
  65 static void CloseNew(void);\r
  66 static void CreateDummyScripts(void);\r
  67 static void RecordDummyScripts(void);\r
  68 \r
  69 // EXTERNAL DATA DECLARATIONS ----------------------------------------------\r
  70 \r
  71 // PUBLIC DATA DEFINITIONS -------------------------------------------------\r
  72 \r
  73 int pc_Address;\r
  74 byte *pc_Buffer;\r
  75 byte *pc_BufferPtr;\r
  76 int pc_ScriptCount;\r
  77 int pc_FunctionCount;\r
  78 boolean pc_NoShrink;\r
  79 boolean pc_HexenCase;\r
  80 boolean pc_WadAuthor = TRUE;\r
  81 boolean pc_EncryptStrings;\r
  82 int pc_LastAppendedCommand;\r
  83 int pc_DummyAddress;\r
  84 \r
  85 // PRIVATE DATA DEFINITIONS ------------------------------------------------\r
  86 \r
  87 static size_t BufferSize;\r
  88 static boolean ObjectOpened = NO;\r
  89 static scriptInfo_t ScriptInfo[MAX_SCRIPT_COUNT];\r
  90 static functionInfo_t FunctionInfo[MAX_FUNCTION_COUNT];\r
  91 static int ArraySizes[MAX_MAP_VARIABLES];\r
  92 static int *ArrayInits[MAX_MAP_VARIABLES];\r
  93 static boolean ArrayOfStrings[MAX_MAP_VARIABLES];\r
  94 static int NumArrays;\r
  95 static mapVarInfo_t MapVariables[MAX_MAP_VARIABLES];\r
  96 static boolean MapVariablesInit = NO;\r
  97 static char ObjectName[MAX_FILE_NAME_LENGTH];\r
  98 static int ObjectFlags;\r
  99 static int PushByteAddr;\r
 100 static char Imports[MAX_IMPORTS][9];\r
 101 static int NumImports;\r
 102 static boolean HaveScriptFlags;\r
 103 \r
 104 static char *PCDNames[PCODE_COMMAND_COUNT] =\r
 105 {\r
 106         "PCD_NOP",\r
 107         "PCD_TERMINATE",\r
 108         "PCD_SUSPEND",\r
 109         "PCD_PUSHNUMBER",\r
 110         "PCD_LSPEC1",\r
 111         "PCD_LSPEC2",\r
 112         "PCD_LSPEC3",\r
 113         "PCD_LSPEC4",\r
 114         "PCD_LSPEC5",\r
 115         "PCD_LSPEC1DIRECT",\r
 116         "PCD_LSPEC2DIRECT",\r
 117         "PCD_LSPEC3DIRECT",\r
 118         "PCD_LSPEC4DIRECT",\r
 119         "PCD_LSPEC5DIRECT",\r
 120         "PCD_ADD",\r
 121         "PCD_SUBTRACT",\r
 122         "PCD_MULTIPLY",\r
 123         "PCD_DIVIDE",\r
 124         "PCD_MODULUS",\r
 125         "PCD_EQ",\r
 126         "PCD_NE",\r
 127         "PCD_LT",\r
 128         "PCD_GT",\r
 129         "PCD_LE",\r
 130         "PCD_GE",\r
 131         "PCD_ASSIGNSCRIPTVAR",\r
 132         "PCD_ASSIGNMAPVAR",\r
 133         "PCD_ASSIGNWORLDVAR",\r
 134         "PCD_PUSHSCRIPTVAR",\r
 135         "PCD_PUSHMAPVAR",\r
 136         "PCD_PUSHWORLDVAR",\r
 137         "PCD_ADDSCRIPTVAR",\r
 138         "PCD_ADDMAPVAR",\r
 139         "PCD_ADDWORLDVAR",\r
 140         "PCD_SUBSCRIPTVAR",\r
 141         "PCD_SUBMAPVAR",\r
 142         "PCD_SUBWORLDVAR",\r
 143         "PCD_MULSCRIPTVAR",\r
 144         "PCD_MULMAPVAR",\r
 145         "PCD_MULWORLDVAR",\r
 146         "PCD_DIVSCRIPTVAR",\r
 147         "PCD_DIVMAPVAR",\r
 148         "PCD_DIVWORLDVAR",\r
 149         "PCD_MODSCRIPTVAR",\r
 150         "PCD_MODMAPVAR",\r
 151         "PCD_MODWORLDVAR",\r
 152         "PCD_INCSCRIPTVAR",\r
 153         "PCD_INCMAPVAR",\r
 154         "PCD_INCWORLDVAR",\r
 155         "PCD_DECSCRIPTVAR",\r
 156         "PCD_DECMAPVAR",\r
 157         "PCD_DECWORLDVAR",\r
 158         "PCD_GOTO",\r
 159         "PCD_IFGOTO",\r
 160         "PCD_DROP",\r
 161         "PCD_DELAY",\r
 162         "PCD_DELAYDIRECT",\r
 163         "PCD_RANDOM",\r
 164         "PCD_RANDOMDIRECT",\r
 165         "PCD_THINGCOUNT",\r
 166         "PCD_THINGCOUNTDIRECT",\r
 167         "PCD_TAGWAIT",\r
 168         "PCD_TAGWAITDIRECT",\r
 169         "PCD_POLYWAIT",\r
 170         "PCD_POLYWAITDIRECT",\r
 171         "PCD_CHANGEFLOOR",\r
 172         "PCD_CHANGEFLOORDIRECT",\r
 173         "PCD_CHANGECEILING",\r
 174         "PCD_CHANGECEILINGDIRECT",\r
 175         "PCD_RESTART",\r
 176         "PCD_ANDLOGICAL",\r
 177         "PCD_ORLOGICAL",\r
 178         "PCD_ANDBITWISE",\r
 179         "PCD_ORBITWISE",\r
 180         "PCD_EORBITWISE",\r
 181         "PCD_NEGATELOGICAL",\r
 182         "PCD_LSHIFT",\r
 183         "PCD_RSHIFT",\r
 184         "PCD_UNARYMINUS",\r
 185         "PCD_IFNOTGOTO",\r
 186         "PCD_LINESIDE",\r
 187         "PCD_SCRIPTWAIT",\r
 188         "PCD_SCRIPTWAITDIRECT",\r
 189         "PCD_CLEARLINESPECIAL",\r
 190         "PCD_CASEGOTO",\r
 191         "PCD_BEGINPRINT",\r
 192         "PCD_ENDPRINT",\r
 193         "PCD_PRINTSTRING",\r
 194         "PCD_PRINTNUMBER",\r
 195         "PCD_PRINTCHARACTER",\r
 196         "PCD_PLAYERCOUNT",\r
 197         "PCD_GAMETYPE",\r
 198         "PCD_GAMESKILL",\r
 199         "PCD_TIMER",\r
 200         "PCD_SECTORSOUND",\r
 201         "PCD_AMBIENTSOUND",\r
 202         "PCD_SOUNDSEQUENCE",\r
 203         "PCD_SETLINETEXTURE",\r
 204         "PCD_SETLINEBLOCKING",\r
 205         "PCD_SETLINESPECIAL",\r
 206         "PCD_THINGSOUND",\r
 207         "PCD_ENDPRINTBOLD",\r
 208 // [RH] End of Hexen p-codes\r
 209         "PCD_ACTIVATORSOUND",\r
 210         "PCD_LOCALAMBIENTSOUND",\r
 211         "PCD_SETLINEMONSTERBLOCKING",\r
 212 // [BC] Start of new pcodes\r
 213         "PCD_PLAYERBLUESKULL",\r
 214         "PCD_PLAYERREDSKULL",\r
 215         "PCD_PLAYERYELLOWSKULL",\r
 216         "PCD_PLAYERMASTERSKULL",\r
 217         "PCD_PLAYERBLUECARD",\r
 218         "PCD_PLAYERREDCARD",\r
 219         "PCD_PLAYERYELLOWCARD",\r
 220         "PCD_PLAYERMASTERCARD",\r
 221         "PCD_PLAYERBLACKSKULL",\r
 222         "PCD_PLAYERSILVERSKULL",\r
 223         "PCD_PLAYERGOLDSKULL",\r
 224         "PCD_PLAYERBLACKCARD",\r
 225         "PCD_PLAYERSILVERCARD",\r
 226         "PCD_PLAYERONTEAM",\r
 227         "PCD_PLAYERTEAM",\r
 228         "PCD_PLAYERHEALTH",\r
 229         "PCD_PLAYERARMORPOINTS",\r
 230         "PCD_PLAYERFRAGS",\r
 231         "PCD_PLAYEREXPERT",\r
 232         "PCD_BLUETEAMCOUNT",\r
 233         "PCD_REDTEAMCOUNT",\r
 234         "PCD_BLUETEAMSCORE",\r
 235         "PCD_REDTEAMSCORE",\r
 236         "PCD_ISONEFLAGCTF",\r
 237         "PCD_LSPEC6",\r
 238         "PCD_LSPEC6DIRECT",\r
 239         "PCD_PRINTNAME",\r
 240         "PCD_MUSICCHANGE",\r
 241         "PCD_CONSOLECOMMANDDIRECT",\r
 242         "PCD_CONSOLECOMMAND",\r
 243         "PCD_SINGLEPLAYER",\r
 244 // [RH] End of Skull Tag p-codes\r
 245         "PCD_FIXEDMUL",\r
 246         "PCD_FIXEDDIV",\r
 247         "PCD_SETGRAVITY",\r
 248         "PCD_SETGRAVITYDIRECT",\r
 249         "PCD_SETAIRCONTROL",\r
 250         "PCD_SETAIRCONTROLDIRECT",\r
 251         "PCD_CLEARINVENTORY",\r
 252         "PCD_GIVEINVENTORY",\r
 253         "PCD_GIVEINVENTORYDIRECT",\r
 254         "PCD_TAKEINVENTORY",\r
 255         "PCD_TAKEINVENTORYDIRECT",\r
 256         "PCD_CHECKINVENTORY",\r
 257         "PCD_CHECKINVENTORYDIRECT",\r
 258         "PCD_SPAWN",\r
 259         "PCD_SPAWNDIRECT",\r
 260         "PCD_SPAWNSPOT",\r
 261         "PCD_SPAWNSPOTDIRECT",\r
 262         "PCD_SETMUSIC",\r
 263         "PCD_SETMUSICDIRECT",\r
 264         "PCD_LOCALSETMUSIC",\r
 265         "PCD_LOCALSETMUSICDIRECT",\r
 266         "PCD_PRINTFIXED",\r
 267         "PCD_PRINTLOCALIZED",\r
 268         "PCD_MOREHUDMESSAGE",\r
 269         "PCD_OPTHUDMESSAGE",\r
 270         "PCD_ENDHUDMESSAGE",\r
 271         "PCD_ENDHUDMESSAGEBOLD",\r
 272         "PCD_SETSTYLE",\r
 273         "PCD_SETSTYLEDIRECT",\r
 274         "PCD_SETFONT",\r
 275         "PCD_SETFONTDIRECT",\r
 276         "PCD_PUSHBYTE",\r
 277         "PCD_LSPEC1DIRECTB",\r
 278         "PCD_LSPEC2DIRECTB",\r
 279         "PCD_LSPEC3DIRECTB",\r
 280         "PCD_LSPEC4DIRECTB",\r
 281         "PCD_LSPEC5DIRECTB",\r
 282         "PCD_DELAYDIRECTB",\r
 283         "PCD_RANDOMDIRECTB",\r
 284         "PCD_PUSHBYTES",\r
 285         "PCD_PUSH2BYTES",\r
 286         "PCD_PUSH3BYTES",\r
 287         "PCD_PUSH4BYTES",\r
 288         "PCD_PUSH5BYTES",\r
 289         "PCD_SETTHINGSPECIAL",\r
 290         "PCD_ASSIGNGLOBALVAR",\r
 291         "PCD_PUSHGLOBALVAR",\r
 292         "PCD_ADDGLOBALVAR",\r
 293         "PCD_SUBGLOBALVAR",\r
 294         "PCD_MULGLOBALVAR",\r
 295         "PCD_DIVGLOBALVAR",\r
 296         "PCD_MODGLOBALVAR",\r
 297         "PCD_INCGLOBALVAR",\r
 298         "PCD_DECGLOBALVAR",\r
 299         "PCD_FADETO",\r
 300         "PCD_FADERANGE",\r
 301         "PCD_CANCELFADE",\r
 302         "PCD_PLAYMOVIE",\r
 303         "PCD_SETFLOORTRIGGER",\r
 304         "PCD_SETCEILINGTRIGGER",\r
 305         "PCD_GETACTORX",\r
 306         "PCD_GETACTORY",\r
 307         "PCD_GETACTORZ",\r
 308         "PCD_STARTTRANSLATION",\r
 309         "PCD_TRANSLATIONRANGE1",\r
 310         "PCD_TRANSLATIONRANGE2",\r
 311         "PCD_ENDTRANSLATION",\r
 312         "PCD_CALL",\r
 313         "PCD_CALLDISCARD",\r
 314         "PCD_RETURNVOID",\r
 315         "PCD_RETURNVAL",\r
 316         "PCD_PUSHMAPARRAY",\r
 317         "PCD_ASSIGNMAPARRAY",\r
 318         "PCD_ADDMAPARRAY",\r
 319         "PCD_SUBMAPARRAY",\r
 320         "PCD_MULMAPARRAY",\r
 321         "PCD_DIVMAPARRAY",\r
 322         "PCD_MODMAPARRAY",\r
 323         "PCD_INCMAPARRAY",\r
 324         "PCD_DECMAPARRAY",\r
 325         "PCD_DUP",\r
 326         "PCD_SWAP",\r
 327         "PCD_WRITETOINI",\r
 328         "PCD_GETFROMINI",\r
 329         "PCD_SIN",\r
 330         "PCD_COS",\r
 331         "PCD_VECTORANGLE",\r
 332         "PCD_CHECKWEAPON",\r
 333         "PCD_SETWEAPON",\r
 334         "PCD_TAGSTRING",\r
 335         "PCD_PUSHWORLDARRAY",\r
 336         "PCD_ASSIGNWORLDARRAY",\r
 337         "PCD_ADDWORLDARRAY",\r
 338         "PCD_SUBWORLDARRAY",\r
 339         "PCD_MULWORLDARRAY",\r
 340         "PCD_DIVWORLDARRAY",\r
 341         "PCD_MODWORLDARRAY",\r
 342         "PCD_INCWORLDARRAY",\r
 343         "PCD_DECWORLDARRAY",\r
 344         "PCD_PUSHGLOBALARRAY",\r
 345         "PCD_ASSIGNGLOBALARRAY",\r
 346         "PCD_ADDGLOBALARRAY",\r
 347         "PCD_SUBGLOBALARRAY",\r
 348         "PCD_MULGLOBALARRAY",\r
 349         "PCD_DIVGLOBALARRAY",\r
 350         "PCD_MODGLOBALARRAY",\r
 351         "PCD_INCGLOBALARRAY",\r
 352         "PCD_DECGLOBALARRAY",\r
 353         "PCD_SETMARINEWEAPON",\r
 354         "PCD_SETACTORPROPERTY",\r
 355         "PCD_GETACTORPROPERTY",\r
 356         "PCD_PLAYERNUMBER",\r
 357         "PCD_ACTIVATORTID",\r
 358         "PCD_SETMARINESPRITE",\r
 359         "PCD_GETSCREENWIDTH",\r
 360         "PCD_GETSCREENHEIGHT",\r
 361         "PCD_THING_PROJECTILE2",\r
 362         "PCD_STRLEN",\r
 363         "PCD_SETHUDSIZE",\r
 364         "PCD_GETCVAR",\r
 365         "PCD_CASEGOTOSORTED",\r
 366         "PCD_SETRESULTVALUE",\r
 367         "PCD_GETLINEROWOFFSET",\r
 368         "PCD_GETACTORFLOORZ",\r
 369         "PCD_GETACTORANGLE",\r
 370         "PCD_GETSECTORFLOORZ",\r
 371         "PCD_GETSECTORCEILINGZ",\r
 372         "PCD_LSPEC5RESULT",\r
 373         "PCD_GETSIGILPIECES",\r
 374         "PCD_GELEVELINFO",\r
 375         "PCD_CHANGESKY",\r
 376         "PCD_PLAYERINGAME",\r
 377         "PCD_PLAYERISBOT",\r
 378         "PCD_SETCAMERATOTEXTURE",\r
 379         "PCD_ENDLOG",\r
 380         "PCD_GETAMMOCAPACITY",\r
 381         "PCD_SETAMMOCAPACITY",\r
 382 // [JB] start of new pcodes\r
 383         "PCD_PRINTMAPCHARARRAY",\r
 384         "PCD_PRINTWORLDCHARARRAY",\r
 385         "PCD_PRINTGLOBALCHARARRAY",\r
 386 // [JB] end of new pcodes\r
 387         "PCD_SETACTORANGLE",\r
 388         "PCD_GRABINPUT",\r
 389         "PCD_SETMOUSEPOINTER",\r
 390         "PCD_MOVEMOUSEPOINTER"\r
 391         "PCD_SPAWNPROJECTILE",\r
 392         "PCD_GETSECTORLIGHTLEVEL",\r
 393         "PCD_GETACTORCEILINGZ",\r
 394         "PCD_SETACTORPOSITION",\r
 395         "PCD_CLEARACTORINVENTORY",\r
 396         "PCD_GIVEACTORINVENTORY",\r
 397         "PCD_TAKEACTORINVENTORY",\r
 398         "PCD_CHECKACTORINVENTORY",\r
 399         "PCD_THINGCOUNTNAME",\r
 400         "PCD_SPAWNSPOTFACING",\r
 401         \r
 402 };\r
 403 \r
 404 // CODE --------------------------------------------------------------------\r
 405 \r
 406 //==========================================================================\r
 407 //\r
 408 // PC_OpenObject\r
 409 //\r
 410 //==========================================================================\r
 411 \r
 412 void PC_OpenObject(char *name, size_t size, int flags)\r
 413 {\r
 414         if(ObjectOpened == YES)\r
 415         {\r
 416                 PC_CloseObject();\r
 417         }\r
 418         if(strlen(name) >= MAX_FILE_NAME_LENGTH)\r
 419         {\r
 420                 ERR_Exit(ERR_FILE_NAME_TOO_LONG, NO, name);\r
 421         }\r
 422         strcpy(ObjectName, name);\r
 423         pc_Buffer = MS_Alloc(size, ERR_ALLOC_PCODE_BUFFER);\r
 424         pc_BufferPtr = pc_Buffer;\r
 425         pc_Address = 0;\r
 426         ObjectFlags = flags;\r
 427         BufferSize = size;\r
 428         pc_ScriptCount = 0;\r
 429         ObjectOpened = YES;\r
 430         PC_AppendString("ACS");\r
 431         PC_SkipLong(); // Script table offset\r
 432 }\r
 433 \r
 434 //==========================================================================\r
 435 //\r
 436 // PC_CloseObject\r
 437 //\r
 438 //==========================================================================\r
 439 \r
 440 void PC_CloseObject(void)\r
 441 {\r
 442         MS_Message(MSG_DEBUG, "---- PC_CloseObject ----\n");\r
 443         while (pc_Address & 3)\r
 444         {\r
 445                 PC_AppendByte (0);\r
 446         }\r
 447         if(!pc_NoShrink || (NumLanguages > 1) || (NumStringLists > 0) ||\r
 448                 (pc_FunctionCount > 0) || MapVariablesInit || NumArrays != 0 ||\r
 449                 pc_EncryptStrings || NumImports != 0 || HaveScriptFlags)\r
 450         {\r
 451                 CloseNew();\r
 452         }\r
 453         else\r
 454         {\r
 455                 CloseOld();\r
 456         }\r
 457         if(MS_SaveFile(ObjectName, pc_Buffer, pc_Address) == FALSE)\r
 458         {\r
 459                 ERR_Exit(ERR_SAVE_OBJECT_FAILED, NO);\r
 460         }\r
 461 }\r
 462 \r
 463 //==========================================================================\r
 464 //\r
 465 // CloseOld\r
 466 //\r
 467 //==========================================================================\r
 468 \r
 469 static void CloseOld(void)\r
 470 {\r
 471         int i;\r
 472 \r
 473         STR_WriteStrings();\r
 474         PC_WriteLong((U_LONG)pc_Address, 4);\r
 475         PC_AppendLong((U_LONG)pc_ScriptCount);\r
 476         for(i = 0; i < pc_ScriptCount; ++i)\r
 477         {\r
 478                 scriptInfo_t *info = &ScriptInfo[i];\r
 479                 MS_Message(MSG_DEBUG, "Script %d, address = %d, arg count = %d\n",\r
 480                         info->number, info->address, info->argCount);\r
 481                 PC_AppendLong((U_LONG)(info->number + info->type * 1000));\r
 482                 PC_AppendLong((U_LONG)info->address);\r
 483                 PC_AppendLong((U_LONG)info->argCount);\r
 484         }\r
 485         STR_WriteList();\r
 486 }\r
 487 \r
 488 //==========================================================================\r
 489 //\r
 490 // CloseNew\r
 491 //\r
 492 // Creates a new-format ACS file. For programs that don't know any better,\r
 493 // this will look just like an old ACS file with no scripts or strings but\r
 494 // with some extra junk in the middle. Both WadAuthor and DeePsea will not\r
 495 // accept ACS files that do not have the ACS\0 header. Worse, WadAuthor\r
 496 // will hang if the file begins with ACS\0 but does not look like something\r
 497 // that might have been created with Raven's ACC. Thus, the chunks live in\r
 498 // the string block, and there are two 0 dwords at the end of the file.\r
 499 //\r
 500 //==========================================================================\r
 501 \r
 502 static void CloseNew(void)\r
 503 {\r
 504         int i, j, count;\r
 505         int chunkStart;\r
 506 \r
 507         if(pc_WadAuthor)\r
 508         {\r
 509                 CreateDummyScripts();\r
 510         }\r
 511 \r
 512         chunkStart = pc_Address;\r
 513 \r
 514         // Only write out those scripts that this acs file actually provides.\r
 515         for(i = j = 0; i < pc_ScriptCount; ++i)\r
 516         {\r
 517                 if(!ScriptInfo[i].imported)\r
 518                 {\r
 519                         ++j;\r
 520                 }\r
 521         }\r
 522         if(j > 0)\r
 523         {\r
 524                 PC_Append("SPTR", 4);\r
 525                 PC_AppendLong(j * 8);\r
 526                 for(i = 0; i < pc_ScriptCount; i++)\r
 527                 {\r
 528                         scriptInfo_t *info = &ScriptInfo[i];\r
 529                         if(!info->imported)\r
 530                         {\r
 531                                 MS_Message(MSG_DEBUG, "Script %d, address = %d, arg count = %d\n",\r
 532                                         info->number, info->address, info->argCount);\r
 533                                 PC_AppendWord(info->number);\r
 534                                 PC_AppendByte(info->type);\r
 535                                 PC_AppendByte(info->argCount);\r
 536                                 PC_AppendLong((U_LONG)info->address);\r
 537                         }\r
 538                 }\r
 539         }\r
 540 \r
 541         // If any scripts have more than the maximum number of arguments, output them.\r
 542         for(i = j = 0; i < pc_ScriptCount; ++i)\r
 543         {\r
 544                 if(!ScriptInfo[i].imported && ScriptInfo[i].varCount > MAX_SCRIPT_VARIABLES)\r
 545                 {\r
 546                         ++j;\r
 547                 }\r
 548         }\r
 549         if(j > 0)\r
 550         {\r
 551                 PC_Append("SVCT", 4);\r
 552                 PC_AppendLong(j * 4);\r
 553                 for(i = 0; i < pc_ScriptCount; ++i)\r
 554                 {\r
 555                         scriptInfo_t *info = &ScriptInfo[i];\r
 556                         if(!info->imported && info->varCount > MAX_SCRIPT_VARIABLES)\r
 557                         {\r
 558                                 MS_Message(MSG_DEBUG, "Script %d, var count = %d\n",\r
 559                                         info->number, info->varCount);\r
 560                                 PC_AppendWord(info->number);\r
 561                                 PC_AppendWord(info->varCount);\r
 562                         }\r
 563                 }\r
 564         }\r
 565 \r
 566         // Write script flags in a separate chunk, so older ZDooms don't get confused\r
 567         for(i = j = 0; i < pc_ScriptCount; ++i)\r
 568         {\r
 569                 if(!ScriptInfo[i].imported && ScriptInfo[i].flags != 0)\r
 570                 {\r
 571                         ++j;\r
 572                 }\r
 573         }\r
 574         if (j > 0)\r
 575         {\r
 576                 PC_Append("SFLG", 4);\r
 577                 PC_AppendLong(j * 4);\r
 578                 for(i = 0; i < pc_ScriptCount; ++i)\r
 579                 {\r
 580                         scriptInfo_t *info = &ScriptInfo[i];\r
 581                         if(!info->imported && info->flags != 0)\r
 582                         {\r
 583                                 PC_AppendWord(info->number);\r
 584                                 PC_AppendWord(info->flags);\r
 585                         }\r
 586                 }\r
 587         }\r
 588 \r
 589         if(pc_FunctionCount > 0)\r
 590         {\r
 591                 PC_Append("FUNC", 4);\r
 592                 PC_AppendLong(pc_FunctionCount * 8);\r
 593                 for(i = 0; i < pc_FunctionCount; ++i)\r
 594                 {\r
 595                         functionInfo_t *info = &FunctionInfo[i];\r
 596                         MS_Message(MSG_DEBUG, "Function %d:%s, address = %d, arg count = %d, var count = %d\n",\r
 597                                 i, STR_GetString(STRLIST_FUNCTIONS, info->name),\r
 598                                 info->address, info->argCount, info->localCount);\r
 599                         PC_AppendByte(info->argCount);\r
 600                         PC_AppendByte(info->localCount);\r
 601                         PC_AppendByte((U_BYTE)(info->hasReturnValue?1:0));\r
 602                         PC_AppendByte(0);\r
 603                         PC_AppendLong((U_LONG)info->address);\r
 604                 }\r
 605                 STR_WriteListChunk(STRLIST_FUNCTIONS, MAKE4CC('F','N','A','M'), NO);\r
 606         }\r
 607 \r
 608         if(NumLanguages > 1)\r
 609         {\r
 610                 for(i = 0; i < NumLanguages; i++)\r
 611                 {\r
 612                         STR_WriteChunk(i, pc_EncryptStrings);\r
 613                 }\r
 614         }\r
 615         else if(STR_ListSize(0) > 0)\r
 616         {\r
 617                 STR_WriteChunk(0, pc_EncryptStrings);\r
 618         }\r
 619 \r
 620         STR_WriteListChunk(STRLIST_PICS, MAKE4CC('P','I','C','S'), NO);\r
 621         if(MapVariablesInit)\r
 622         {\r
 623                 int j;\r
 624 \r
 625                 for(i = 0; i < pa_MapVarCount; ++i)\r
 626                 {\r
 627                         if(MapVariables[i].initializer != 0)\r
 628                                 break;\r
 629                 }\r
 630                 for(j = pa_MapVarCount-1; j > i; --j)\r
 631                 {\r
 632                         if(MapVariables[j].initializer != 0)\r
 633                                 break;\r
 634                 }\r
 635                 ++j;\r
 636 \r
 637                 if (i < j)\r
 638                 {\r
 639                         PC_Append("MINI", 4);\r
 640                         PC_AppendLong((j-i)*4+4);\r
 641                         PC_AppendLong(i);                                               // First map var defined\r
 642                         for(; i < j; ++i)\r
 643                         {\r
 644                                 PC_AppendLong(MapVariables[i].initializer);\r
 645                         }\r
 646                 }\r
 647         }\r
 648 \r
 649         // If this is a library, record which map variables are\r
 650         // initialized with strings.\r
 651         if(ImportMode == IMPORT_Exporting)\r
 652         {\r
 653                 count = 0;\r
 654 \r
 655                 for(i = 0; i < pa_MapVarCount; ++i)\r
 656                 {\r
 657                         if(MapVariables[i].isString)\r
 658                         {\r
 659                                 ++count;\r
 660                         }\r
 661                 }\r
 662                 if(count > 0)\r
 663                 {\r
 664                         PC_Append("MSTR", 4);\r
 665                         PC_AppendLong(count*4);\r
 666                         for(i = 0; i < pa_MapVarCount; ++i)\r
 667                         {\r
 668                                 if(MapVariables[i].isString)\r
 669                                 {\r
 670                                         PC_AppendLong(i);\r
 671                                 }\r
 672                         }\r
 673                 }\r
 674 \r
 675                 // Now do the same thing for arrays.\r
 676                 for(count = 0, i = 0; i < pa_MapVarCount; ++i)\r
 677                 {\r
 678                         if(ArrayOfStrings[i])\r
 679                         {\r
 680                                 ++count;\r
 681                         }\r
 682                 }\r
 683                 if(count > 0)\r
 684                 {\r
 685                         PC_Append("ASTR", 4);\r
 686                         PC_AppendLong(count*4);\r
 687                         for(i = 0; i < pa_MapVarCount; ++i)\r
 688                         {\r
 689                                 if(ArrayOfStrings[i])\r
 690                                 {\r
 691                                         PC_AppendLong(i);\r
 692                                 }\r
 693                         }\r
 694                 }\r
 695         }\r
 696 \r
 697         // Publicize the names of map variables in a library.\r
 698         if(ImportMode == IMPORT_Exporting)\r
 699         {\r
 700                 for(i = 0; i < pa_MapVarCount; ++i)\r
 701                 {\r
 702                         if(!MapVariables[i].imported)\r
 703                         {\r
 704                                 STR_AppendToList(STRLIST_MAPVARS, MapVariables[i].name);\r
 705                         }\r
 706                         else\r
 707                         {\r
 708                                 STR_AppendToList(STRLIST_MAPVARS, NULL);\r
 709                         }\r
 710                 }\r
 711                 STR_WriteListChunk(STRLIST_MAPVARS, MAKE4CC('M','E','X','P'), NO);\r
 712         }\r
 713 \r
 714         // Record the names of imported map variables\r
 715         count = 0;\r
 716         for(i = 0; i < pa_MapVarCount; ++i)\r
 717         {\r
 718                 if(MapVariables[i].imported && !ArraySizes[i])\r
 719                 {\r
 720                         count += 5 + strlen(MapVariables[i].name);\r
 721                 }\r
 722         }\r
 723         if(count > 0)\r
 724         {\r
 725                 PC_Append("MIMP", 4);\r
 726                 PC_AppendLong(count);\r
 727                 for(i = 0; i < pa_MapVarCount; ++i)\r
 728                 {\r
 729                         if(MapVariables[i].imported && !ArraySizes[i])\r
 730                         {\r
 731                                 PC_AppendLong(i);\r
 732                                 PC_AppendString(MapVariables[i].name);\r
 733                         }\r
 734                 }\r
 735         }\r
 736 \r
 737         if(NumArrays)\r
 738         {\r
 739                 int count;\r
 740 \r
 741                 // Arrays defined here\r
 742                 for(count = 0, i = 0; i < pa_MapVarCount; ++i)\r
 743                 {\r
 744                         if(ArraySizes[i] && !MapVariables[i].imported)\r
 745                         {\r
 746                                 ++count;\r
 747                         }\r
 748                 }\r
 749                 if(count)\r
 750                 {\r
 751                         PC_Append("ARAY", 4);\r
 752                         PC_AppendLong(count*8);\r
 753                         for(i = 0; i < pa_MapVarCount; ++i)\r
 754                         {\r
 755                                 if(ArraySizes[i] && !MapVariables[i].imported)\r
 756                                 {\r
 757                                         PC_AppendLong(i);\r
 758                                         PC_AppendLong(ArraySizes[i]);\r
 759                                 }\r
 760                         }\r
 761                         for(i = 0; i < pa_MapVarCount; ++i)\r
 762                         {\r
 763                                 if(ArrayInits[i])\r
 764                                 {\r
 765                                         int j;\r
 766 \r
 767                                         PC_Append("AINI", 4);\r
 768                                         PC_AppendLong(ArraySizes[i]*4+4);\r
 769                                         PC_AppendLong((U_LONG)i);\r
 770                                         for(j = 0; j < ArraySizes[i]; ++j)\r
 771                                         {\r
 772                                                 PC_AppendLong((U_LONG)ArrayInits[i][j]);\r
 773                                         }\r
 774                                 }\r
 775                         }\r
 776                 }\r
 777 \r
 778                 // Arrays imported from elsewhere\r
 779                 for(count = 0, j = i = 0; i < pa_MapVarCount; ++i)\r
 780                 {\r
 781                         if(ArraySizes[i] && MapVariables[i].imported)\r
 782                         {\r
 783                                 count += 9 + strlen(MapVariables[i].name);\r
 784                                 ++j;\r
 785                         }\r
 786                 }\r
 787                 if(count)\r
 788                 {\r
 789                         PC_Append("AIMP", 4);\r
 790                         PC_AppendLong(count+4);\r
 791                         PC_AppendLong(j);\r
 792                         for(i = 0; i < pa_MapVarCount; ++i)\r
 793                         {\r
 794                                 if(ArraySizes[i] && MapVariables[i].imported)\r
 795                                 {\r
 796                                         PC_AppendLong(i);\r
 797                                         PC_AppendLong(ArraySizes[i]);\r
 798                                         PC_AppendString(MapVariables[i].name);\r
 799                                 }\r
 800                         }\r
 801                 }\r
 802         }\r
 803 \r
 804         // Add a dummy chunk to indicate if this object is a library.\r
 805         if(ImportMode == IMPORT_Exporting)\r
 806         {\r
 807                 PC_Append("ALIB", 4);\r
 808                 PC_AppendLong(0);\r
 809         }\r
 810 \r
 811         // Record libraries imported by this object.\r
 812         if(NumImports > 0)\r
 813         {\r
 814                 count = 0;\r
 815                 for(i = 0; i < NumImports; ++i)\r
 816                 {\r
 817                         count += strlen(Imports[i]) + 1;\r
 818                 }\r
 819                 if(count > 0)\r
 820                 {\r
 821                         PC_Append("LOAD", 4);\r
 822                         PC_AppendLong(count);\r
 823                         for(i = 0; i < NumImports; ++i)\r
 824                         {\r
 825                                 PC_AppendString(Imports[i]);\r
 826                         }\r
 827                 }\r
 828         }\r
 829 \r
 830         PC_AppendLong((U_LONG)chunkStart);\r
 831         if(pc_NoShrink)\r
 832         {\r
 833                 PC_Append("ACSE", 4);\r
 834         }\r
 835         else\r
 836         {\r
 837                 PC_Append("ACSe", 4);\r
 838         }\r
 839         PC_WriteLong((U_LONG)pc_Address, 4);\r
 840 \r
 841         // WadAuthor compatibility when creating a library is pointless, because\r
 842         // that editor does not know anything about libraries and will never\r
 843         // find their scripts ever.\r
 844         if(pc_WadAuthor && ImportMode != IMPORT_Exporting)\r
 845         {\r
 846                 RecordDummyScripts();\r
 847         }\r
 848         else\r
 849         {\r
 850                 PC_AppendLong(0);\r
 851         }\r
 852         PC_AppendLong(0);\r
 853 }\r
 854 \r
 855 //==========================================================================\r
 856 //\r
 857 // CreateDummyScripts\r
 858 //\r
 859 //==========================================================================\r
 860 \r
 861 static void CreateDummyScripts(void)\r
 862 {\r
 863         int i;\r
 864 \r
 865         MS_Message(MSG_DEBUG, "Creating dummy scripts to make WadAuthor happy.\n");\r
 866         if(pc_Address%4 != 0)\r
 867         { // Need to align\r
 868                 U_LONG pad = 0;\r
 869                 PC_Append((void *)&pad, 4-(pc_Address%4));\r
 870         }\r
 871         pc_DummyAddress = pc_Address;\r
 872         for(i = 0; i < pc_ScriptCount; ++i)\r
 873         {\r
 874                 if(!ScriptInfo[i].imported)\r
 875                 {\r
 876                         PC_AppendCmd(PCD_TERMINATE);\r
 877                         if(!pc_NoShrink)\r
 878                         {\r
 879                                 PC_AppendCmd(PCD_NOP);\r
 880                                 PC_AppendCmd(PCD_NOP);\r
 881                                 PC_AppendCmd(PCD_NOP);\r
 882                         }\r
 883                 }\r
 884         }\r
 885 }\r
 886 \r
 887 //==========================================================================\r
 888 //\r
 889 // RecordDummyScripts\r
 890 //\r
 891 //==========================================================================\r
 892 \r
 893 static void RecordDummyScripts(void)\r
 894 {\r
 895         int i, count;\r
 896 \r
 897         for(i = count = 0; i < pc_ScriptCount; ++i)\r
 898         {\r
 899                 if(!ScriptInfo[i].imported)\r
 900                 {\r
 901                         ++count;\r
 902                 }\r
 903         }\r
 904         PC_AppendLong((U_LONG)count);\r
 905         for(i = 0; i < pc_ScriptCount; ++i)\r
 906         {\r
 907                 scriptInfo_t *info = &ScriptInfo[i];\r
 908                 if(!info->imported)\r
 909                 {\r
 910                         MS_Message(MSG_DEBUG, "Dummy script %d, address = %d, arg count = %d\n",\r
 911                                 info->number, info->address, info->argCount);\r
 912                         PC_AppendLong((U_LONG)info->number);\r
 913                         PC_AppendLong((U_LONG)pc_DummyAddress + i*4);\r
 914                         PC_AppendLong((U_LONG)info->argCount);\r
 915                 }\r
 916         }\r
 917 }\r
 918 \r
 919 //==========================================================================\r
 920 //\r
 921 // GrowBuffer\r
 922 //\r
 923 //==========================================================================\r
 924 \r
 925 void GrowBuffer(void)\r
 926 {\r
 927         ptrdiff_t buffpos = pc_BufferPtr - pc_Buffer;\r
 928 \r
 929         BufferSize *= 2;\r
 930         pc_Buffer = MS_Realloc(pc_Buffer, BufferSize, ERR_PCODE_BUFFER_OVERFLOW);\r
 931         pc_BufferPtr = pc_Buffer + buffpos;\r
 932 }\r
 933 \r
 934 //==========================================================================\r
 935 //\r
 936 // PC_Append functions\r
 937 //\r
 938 //==========================================================================\r
 939 \r
 940 static void Append(void *buffer, size_t size)\r
 941 {\r
 942         if (ImportMode != IMPORT_Importing)\r
 943         {\r
 944                 if(pc_Address+size > BufferSize)\r
 945                 {\r
 946                         GrowBuffer ();\r
 947                 }\r
 948                 memcpy(pc_BufferPtr, buffer, size);\r
 949                 pc_BufferPtr += size;\r
 950                 pc_Address += size;\r
 951         }\r
 952 }\r
 953 \r
 954 void PC_Append(void *buffer, size_t size)\r
 955 {\r
 956         if (ImportMode != IMPORT_Importing)\r
 957         {\r
 958                 MS_Message(MSG_DEBUG, "AD> %06d = (%d bytes)\n", pc_Address, size);\r
 959                 Append(buffer, size);\r
 960         }\r
 961 }\r
 962 \r
 963 void PC_AppendByte(U_BYTE val)\r
 964 {\r
 965         if (ImportMode != IMPORT_Importing)\r
 966         {\r
 967                 MS_Message(MSG_DEBUG, "AB> %06d = %d\n", pc_Address, val);\r
 968                 Append(&val, sizeof(U_BYTE));\r
 969         }\r
 970 }\r
 971 \r
 972 void PC_AppendWord(U_WORD val)\r
 973 {\r
 974         if (ImportMode != IMPORT_Importing)\r
 975         {\r
 976                 MS_Message(MSG_DEBUG, "AW> %06d = %d\n", pc_Address, val);\r
 977                 val = MS_LittleUWORD(val);\r
 978                 Append(&val, sizeof(U_WORD));\r
 979         }\r
 980 }\r
 981 \r
 982 void PC_AppendLong(U_LONG val)\r
 983 {\r
 984         if (ImportMode != IMPORT_Importing)\r
 985         {\r
 986                 MS_Message(MSG_DEBUG, "AL> %06d = %d\n", pc_Address, val);\r
 987                 val = MS_LittleULONG(val);\r
 988                 Append(&val, sizeof(U_LONG));\r
 989         }\r
 990 }\r
 991 \r
 992 void PC_AppendString(char *string)\r
 993 {\r
 994         if (ImportMode != IMPORT_Importing)\r
 995         {\r
 996                 int length;\r
 997 \r
 998                 length = strlen(string)+1;\r
 999                 MS_Message(MSG_DEBUG, "AS> %06d = \"%s\" (%d bytes)\n",\r
1000                         pc_Address, string, length);\r
1001                 Append(string, length);\r
1002         }\r
1003 }\r
1004 \r
1005 void PC_AppendCmd(pcd_t command)\r
1006 {\r
1007         if (ImportMode != IMPORT_Importing)\r
1008         {\r
1009                 pc_LastAppendedCommand = command;\r
1010                 if (pc_NoShrink)\r
1011                 {\r
1012                         MS_Message(MSG_DEBUG, "AC> %06d = #%d:%s\n", pc_Address,\r
1013                                 command, PCDNames[command]);\r
1014                         command = MS_LittleULONG(command);\r
1015                         Append(&command, sizeof(U_LONG));\r
1016                 }\r
1017                 else\r
1018                 {\r
1019                         U_BYTE cmd;\r
1020                         if (command != PCD_PUSHBYTE && PushByteAddr)\r
1021                         { // Maybe shrink a PCD_PUSHBYTE sequence into PCD_PUSHBYTES\r
1022                                 int runlen = (pc_Address - PushByteAddr) / 2;\r
1023                                 int i;\r
1024 \r
1025                                 if (runlen > 5)\r
1026                                 {\r
1027                                         pc_Buffer[PushByteAddr] = PCD_PUSHBYTES;\r
1028                                         for (i = 0; i < runlen; i++)\r
1029                                         {\r
1030                                                 pc_Buffer[PushByteAddr+i+2] = pc_Buffer[PushByteAddr+i*2+1];\r
1031                                         }\r
1032                                         pc_Buffer[PushByteAddr+1] = runlen;\r
1033                                         pc_Address = PushByteAddr + runlen + 2;\r
1034                                         pc_BufferPtr = pc_Buffer + pc_Address;\r
1035                                         MS_Message (MSG_DEBUG, "AC> Last %d PCD_PUSHBYTEs changed to #%d:PCD_PUSHBYTES\n",\r
1036                                                 runlen, PCD_PUSHBYTES);\r
1037                                 }\r
1038                                 else if (runlen > 1)\r
1039                                 {\r
1040                                         pc_Buffer[PushByteAddr] = PCD_PUSH2BYTES + runlen - 2;\r
1041                                         for (i = 1; i < runlen; i++)\r
1042                                         {\r
1043                                                 pc_Buffer[PushByteAddr+1+i] = pc_Buffer[PushByteAddr+1+i*2];\r
1044                                         }\r
1045                                         pc_Address = PushByteAddr + runlen + 1;\r
1046                                         pc_BufferPtr = pc_Buffer + pc_Address;\r
1047                                         MS_Message (MSG_DEBUG, "AC> Last %d PCD_PUSHBYTEs changed to #%d:PCD_PUSH%dBYTES\n",\r
1048                                                 runlen, PCD_PUSH2BYTES+runlen-2, runlen);\r
1049                                 }\r
1050                                 PushByteAddr = 0;\r
1051                         }\r
1052                         else if (command == PCD_PUSHBYTE && PushByteAddr == 0)\r
1053                         { // Remember the first PCD_PUSHBYTE, in case there are more\r
1054                                 PushByteAddr = pc_Address;\r
1055                         }\r
1056                         MS_Message(MSG_DEBUG, "AC> %06d = #%d:%s\n", pc_Address,\r
1057                                 command, PCDNames[command]);\r
1058 \r
1059                         if (command < 256-16)\r
1060                         {\r
1061                                 cmd = command;\r
1062                                 Append(&cmd, sizeof(U_BYTE));\r
1063                         }\r
1064                         else\r
1065                         {\r
1066                                 // Room for expansion: The top 16 pcodes in the [0,255]\r
1067                                 // range select a set of pcodes, and the next byte is\r
1068                                 // the pcode in that set.\r
1069                                 cmd = ((command - (256-16)) >> 8) + (256-16);\r
1070                                 Append(&cmd, sizeof(U_BYTE));\r
1071                                 cmd = (command - (256-16)) & 255;\r
1072                                 Append(&cmd, sizeof(U_BYTE));\r
1073                         }\r
1074                 }\r
1075         }\r
1076 }\r
1077 \r
1078 //==========================================================================\r
1079 //\r
1080 // PC_AppendShrink\r
1081 //\r
1082 //==========================================================================\r
1083 \r
1084 void PC_AppendShrink(U_BYTE val)\r
1085 {\r
1086         if(pc_NoShrink)\r
1087         {\r
1088                 PC_AppendLong(val);\r
1089         }\r
1090         else\r
1091         {\r
1092                 PC_AppendByte(val);\r
1093         }\r
1094 }\r
1095 \r
1096 //==========================================================================\r
1097 //\r
1098 // PC_AppendPushVal\r
1099 //\r
1100 //==========================================================================\r
1101 \r
1102 void PC_AppendPushVal(U_LONG val)\r
1103 {\r
1104         if(pc_NoShrink || val > 255)\r
1105         {\r
1106                 PC_AppendCmd(PCD_PUSHNUMBER);\r
1107                 PC_AppendLong(val);\r
1108         }\r
1109         else\r
1110         {\r
1111                 PC_AppendCmd(PCD_PUSHBYTE);\r
1112                 PC_AppendByte((U_BYTE)val);\r
1113         }\r
1114 }\r
1115 \r
1116 //==========================================================================\r
1117 //\r
1118 // PC_Write functions\r
1119 //\r
1120 //==========================================================================\r
1121 \r
1122 static void Write(void *buffer, size_t size, int address)\r
1123 {\r
1124         if (ImportMode != IMPORT_Importing)\r
1125         {\r
1126                 if(address+size > BufferSize)\r
1127                 {\r
1128                         GrowBuffer();\r
1129                 }\r
1130                 memcpy(pc_Buffer+address, buffer, size);\r
1131         }\r
1132 }\r
1133 \r
1134 void PC_Write(void *buffer, size_t size, int address)\r
1135 {\r
1136         if (ImportMode != IMPORT_Importing)\r
1137         {\r
1138                 MS_Message(MSG_DEBUG, "WD> %06d = (%d bytes)\n", address, size);\r
1139                 Write(buffer, size, address);\r
1140         }\r
1141 }\r
1142 \r
1143 void PC_WriteByte(U_BYTE val, int address)\r
1144 {\r
1145         if (ImportMode != IMPORT_Importing)\r
1146         {\r
1147                 MS_Message(MSG_DEBUG, "WB> %06d = %d\n", address, val);\r
1148                 Write(&val, sizeof(U_BYTE), address);\r
1149         }\r
1150 }\r
1151 \r
1152 /*\r
1153 void PC_WriteWord(U_WORD val, int address)\r
1154 {\r
1155         MS_Message(MSG_DEBUG, "WW> %06d = %d\n", address, val);\r
1156         val = MS_LittleUWORD(val);\r
1157         Write(&val, sizeof(U_WORD), address);\r
1158 }\r
1159 */\r
1160 \r
1161 void PC_WriteLong(U_LONG val, int address)\r
1162 {\r
1163         if (ImportMode != IMPORT_Importing)\r
1164         {\r
1165                 MS_Message(MSG_DEBUG, "WL> %06d = %d\n", address, val);\r
1166                 val = MS_LittleULONG(val);\r
1167                 Write(&val, sizeof(U_LONG), address);\r
1168         }\r
1169         pc_LastAppendedCommand = PCD_NOP;\r
1170 }\r
1171 \r
1172 void PC_WriteString(char *string, int address)\r
1173 {\r
1174         if (ImportMode != IMPORT_Importing)\r
1175         {\r
1176                 int length;\r
1177 \r
1178                 length = strlen(string)+1;\r
1179                 MS_Message(MSG_DEBUG, "WS> %06d = \"%s\" (%d bytes)\n",\r
1180                         address, string, length);\r
1181                 Write(string, length, address);\r
1182         }\r
1183 }\r
1184 \r
1185 void PC_WriteCmd(pcd_t command, int address)\r
1186 {\r
1187         if (ImportMode != IMPORT_Importing)\r
1188         {\r
1189                 MS_Message(MSG_DEBUG, "WC> %06d = #%d:%s\n", address,\r
1190                         command, PCDNames[command]);\r
1191                 command = MS_LittleULONG(command);\r
1192                 Write(&command, sizeof(U_LONG), address);\r
1193         }\r
1194 }\r
1195 \r
1196 //==========================================================================\r
1197 //\r
1198 // PC_Skip functions\r
1199 //\r
1200 //==========================================================================\r
1201 \r
1202 static void Skip(size_t size)\r
1203 {\r
1204         if (ImportMode != IMPORT_Importing)\r
1205         {\r
1206                 if(pc_Address+size > BufferSize)\r
1207                 {\r
1208                         GrowBuffer();\r
1209                 }\r
1210                 pc_BufferPtr += size;\r
1211                 pc_Address += size;\r
1212         }\r
1213 }\r
1214 \r
1215 void PC_Skip(size_t size)\r
1216 {\r
1217         if (ImportMode != IMPORT_Importing)\r
1218         {\r
1219                 MS_Message(MSG_DEBUG, "SD> %06d (skip %d bytes)\n", pc_Address, size);\r
1220                 Skip(size);\r
1221         }\r
1222 }\r
1223 \r
1224 /*\r
1225 void PC_SkipByte(void)\r
1226 {\r
1227         MS_Message(MSG_DEBUG, "SB> %06d (skip byte)\n", pc_Address);\r
1228         Skip(sizeof(U_BYTE));\r
1229 }\r
1230 */\r
1231 \r
1232 /*\r
1233 void PC_SkipWord(void)\r
1234 {\r
1235         MS_Message(MSG_DEBUG, "SW> %06d (skip word)\n", pc_Address);\r
1236         Skip(sizeof(U_WORD));\r
1237 }\r
1238 */\r
1239 \r
1240 void PC_SkipLong(void)\r
1241 {\r
1242         if (ImportMode != IMPORT_Importing)\r
1243         {\r
1244                 MS_Message(MSG_DEBUG, "SL> %06d (skip long)\n", pc_Address);\r
1245                 Skip(sizeof(U_LONG));\r
1246         }\r
1247 }\r
1248 \r
1249 //==========================================================================\r
1250 //\r
1251 // PC_PutMapVariable\r
1252 //\r
1253 //==========================================================================\r
1254 \r
1255 void PC_PutMapVariable(int index, int value)\r
1256 {\r
1257         if(index < MAX_MAP_VARIABLES)\r
1258         {\r
1259                 MapVariables[index].isString = pa_ConstExprIsString;\r
1260                 MapVariables[index].initializer = value;\r
1261                 MapVariablesInit = YES;\r
1262         }\r
1263 }\r
1264 \r
1265 //==========================================================================\r
1266 //\r
1267 // PC_NameMapVariable\r
1268 //\r
1269 //==========================================================================\r
1270 \r
1271 void PC_NameMapVariable(int index, symbolNode_t *sym)\r
1272 {\r
1273         if(index < MAX_MAP_VARIABLES)\r
1274         {\r
1275                 MapVariables[index].name = sym->name;\r
1276                 MapVariables[index].imported = sym->imported;\r
1277         }\r
1278 }\r
1279 \r
1280 //==========================================================================\r
1281 //\r
1282 // PC_AddScript\r
1283 //\r
1284 //==========================================================================\r
1285 \r
1286 void PC_AddScript(int inNumber, int argCount)\r
1287 {\r
1288         scriptInfo_t *script;\r
1289         int i;\r
1290         U_BYTE type;\r
1291         U_WORD flags;\r
1292         U_WORD number;\r
1293 \r
1294         type = (inNumber & 65535) / 1000;\r
1295         number = (inNumber & 65535) % 1000;\r
1296         flags = (inNumber >> 16) & 65535;\r
1297 \r
1298         if (flags != 0)\r
1299         {\r
1300                 HaveScriptFlags = YES;\r
1301         }\r
1302 \r
1303         for (i = 0; i < pc_ScriptCount; i++)\r
1304         {\r
1305                 if (ScriptInfo[i].number == number)\r
1306                 {\r
1307                         ERR_Error(ERR_SCRIPT_ALREADY_DEFINED, YES);\r
1308                 }\r
1309         }\r
1310         if(pc_ScriptCount == MAX_SCRIPT_COUNT)\r
1311         {\r
1312                 ERR_Error(ERR_TOO_MANY_SCRIPTS, YES);\r
1313         }\r
1314         else\r
1315         {\r
1316                 script = &ScriptInfo[pc_ScriptCount];\r
1317                 script->number = number;\r
1318                 script->type = type;\r
1319                 script->address = (ImportMode == IMPORT_Importing) ? 0 : pc_Address;\r
1320                 script->argCount = argCount;\r
1321                 script->flags = flags;\r
1322                 script->srcLine = tk_Line;\r
1323                 script->imported = (ImportMode == IMPORT_Importing) ? YES : NO;\r
1324                 pc_ScriptCount++;\r
1325         }\r
1326 }\r
1327 \r
1328 //==========================================================================\r
1329 //\r
1330 // PC_SetScriptVarCount\r
1331 //\r
1332 // Sets the number of local variables used by a script, including\r
1333 // arguments.\r
1334 //\r
1335 //==========================================================================\r
1336 \r
1337 void PC_SetScriptVarCount(int inNumber, int varCount)\r
1338 {\r
1339         int i;\r
1340         U_BYTE type;\r
1341         U_WORD number;\r
1342 \r
1343         type = (inNumber & 65535) / 1000;\r
1344         number = (inNumber & 65535) % 1000;\r
1345 \r
1346         for(i = 0; i < pc_ScriptCount; i++)\r
1347         {\r
1348                 if(ScriptInfo[i].number == number)\r
1349                 {\r
1350                         ScriptInfo[i].varCount = varCount;\r
1351                         break;\r
1352                 }\r
1353         }\r
1354 }\r
1355 \r
1356 //==========================================================================\r
1357 //\r
1358 // PC_AddFunction\r
1359 //\r
1360 //==========================================================================\r
1361 \r
1362 void PC_AddFunction(symbolNode_t *sym)\r
1363 {\r
1364         functionInfo_t *function;\r
1365 \r
1366         if(pc_FunctionCount == MAX_FUNCTION_COUNT)\r
1367         {\r
1368                 ERR_Error(ERR_TOO_MANY_FUNCTIONS, YES, NULL);\r
1369         }\r
1370         function = &FunctionInfo[pc_FunctionCount];\r
1371         function->hasReturnValue = (U_BYTE)sym->info.scriptFunc.hasReturnValue;\r
1372         function->argCount = (U_BYTE)sym->info.scriptFunc.argCount;\r
1373         function->localCount = (U_BYTE)sym->info.scriptFunc.varCount;\r
1374         function->name = STR_AppendToList (STRLIST_FUNCTIONS, sym->name);\r
1375         function->address = sym->info.scriptFunc.address;\r
1376         sym->info.scriptFunc.funcNumber = pc_FunctionCount;\r
1377         pc_FunctionCount++;\r
1378 }\r
1379 \r
1380 //==========================================================================\r
1381 //\r
1382 // PC_AddArray\r
1383 //\r
1384 //==========================================================================\r
1385 \r
1386 void PC_AddArray(int index, int size)\r
1387 {\r
1388         NumArrays++;\r
1389         ArraySizes[index] = size;\r
1390 }\r
1391 \r
1392 //==========================================================================\r
1393 //\r
1394 // PC_InitArray\r
1395 //\r
1396 //==========================================================================\r
1397 \r
1398 void PC_InitArray(int index, int *entries, boolean hasStrings)\r
1399 {\r
1400         int i;\r
1401 \r
1402         // If the array is just initialized to zeros, then we don't need to\r
1403         // remember the initializer.\r
1404         for(i = 0; i < ArraySizes[index]; ++i)\r
1405         {\r
1406                 if(entries[i] != 0)\r
1407                 {\r
1408                         break;\r
1409                 }\r
1410         }\r
1411         if(i < ArraySizes[index])\r
1412         {\r
1413                 ArrayInits[index] = MS_Alloc(ArraySizes[index]*sizeof(int), ERR_OUT_OF_MEMORY);\r
1414                 memcpy(ArrayInits[index], entries, ArraySizes[index]*sizeof(int));\r
1415         }\r
1416         ArrayOfStrings[index] = hasStrings;\r
1417 }\r
1418 \r
1419 //==========================================================================\r
1420 //\r
1421 // PC_AddImport\r
1422 //\r
1423 //==========================================================================\r
1424 \r
1425 int PC_AddImport(char *name)\r
1426 {\r
1427         if (NumImports >= MAX_IMPORTS)\r
1428         {\r
1429                 ERR_Exit(ERR_TOO_MANY_IMPORTS, YES);\r
1430         }\r
1431         strncpy(Imports[NumImports], name, 8);\r
1432         return NumImports++;\r
1433 }\r