2 Copyright (C) 1998 BJ Eirich (aka vecna)
\r
3 This program is free software; you can redistribute it and/or
\r
4 modify it under the terms of the GNU General Public License
\r
5 as published by the Free Software Foundation; either version 2
\r
6 of the License, or (at your option) any later version.
\r
7 This program is distributed in the hope that it will be useful,
\r
8 but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
\r
10 See the GNU General Public Lic
\r
11 See the GNU General Public License for more details.
\r
12 You should have received a copy of the GNU General Public License
\r
13 along with this program; if not, write to the Free Software
\r
14 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
\r
17 // ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿
\r
18 // ³ The VergeC Compiler version 2.01 ³
\r
19 // ³ Copyright (C)1998 BJ Eirich (aka vecna) ³
\r
20 // ³ Code Generation module ³
\r
21 // ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ
\r
27 #include "funclib.h"
\r
30 #include "lexical.h"
\r
31 #include "preproc.h"
\r
33 // ================================= Data ====================================
\r
38 // -- Function arguements type defs
\r
45 unsigned char *source, *src;
\r
46 unsigned char *outbuf, *code;
\r
47 unsigned char inevent=0;
\r
53 int numargs, numlocals;
\r
58 funcdecl funcs[700];
\r
84 int vctype; // 0 / 1 :: map / system
\r
86 // -- local function parameters --
\r
90 // -- MAP vc stuff --
\r
95 // ================================= Code ====================================
\r
97 void HandleString();
\r
98 void HandleFunction();
\r
99 void HandleUserFunction();
\r
100 void HandleFunctionType();
\r
101 void EmitOperand();
\r
103 void EmitC (char c)
\r
105 if (locate && locate == (int)(code - outbuf))
\r
111 void EmitW (short w)
\r
113 short *c=(short *)code;
\r
115 if (locate && locate == (int)(code - outbuf))
\r
123 long *c=(long *)code;
\r
125 if (locate && locate == (int)(code - outbuf))
\r
131 void EmitString(char *str)
\r
132 { while ((*code++ = *str++)) ; }
\r
134 void HandleStringOperand()
\r
138 EmitC(s_IMMEDIATE);
\r
144 if (token_type==IDENTIFIER && varcategory==op_STRING)
\r
147 EmitW(str[varidx].vsofs);
\r
150 if (token_type==IDENTIFIER && varcategory==op_SARRAY)
\r
153 EmitW(str[varidx].vsofs);
\r
159 if (token_type==IDENTIFIER && varcategory==op_SLOCAL)
\r
162 EmitC((char) varidx);
\r
165 if (TokenIs("str"))
\r
173 if (TokenIs("left"))
\r
183 if (TokenIs("right"))
\r
193 if (TokenIs("mid"))
\r
205 if (TokenIs("chr"))
\r
213 else vcerr("Unknown string operand. ");
\r
216 void HandleString()
\r
220 HandleStringOperand();
\r
235 void EmitOperand();
\r
236 void DoSomething();
\r
238 void HandleOperand()
\r
241 if (token_type==DIGIT)
\r
243 EmitC(op_IMMEDIATE);
\r
244 EmitD(token_nvalue);
\r
247 if (token_type==IDENTIFIER)
\r
249 if (varcategory==op_UVAR)
\r
252 EmitD(vars[varidx].varstartofs);
\r
255 if (varcategory==op_UVARRAY)
\r
258 EmitD(vars[varidx].varstartofs);
\r
264 if (varcategory==op_LVAR)
\r
267 EmitC((char) varidx);
\r
270 if (varcategory==op_HVAR0)
\r
273 EmitC((char) varidx);
\r
276 if (varcategory==op_HVAR1)
\r
279 EmitC((char) varidx);
\r
286 if (token_type==FUNCTION && token_subtype==op_BFUNC)
\r
288 if (!returntypes[funcidx])
\r
290 vcerr("%s() does not return a vlue.", token);
\r
296 if (token_type==FUNCTION && token_subtype==op_UFUNC)
\r
298 if (!funcs[funcidx].returntype)
\r
300 vcerr("%s() does not return a vlue.", token);
\r
303 HandleUserFunction();
\r
306 vcerr("Unknown token.");
\r
311 while (1) // Modifier-process loop.
\r
320 else HandleOperand();
\r
328 else if (NextIs("-"))
\r
334 else if (NextIs("/"))
\r
340 else if (NextIs("*"))
\r
346 else if (NextIs("%"))
\r
352 else if (NextIs(">>"))
\r
358 else if (NextIs("<<"))
\r
364 else if (NextIs("&"))
\r
370 else if (NextIs("|"))
\r
376 else if (NextIs("^"))
\r
390 void HandleFunction()
\r
394 case 0: vcfunc_Exit(); break;
\r
395 case 1: Message(); break;
\r
396 case 2: GenericFunc(3,1); break;
\r
397 case 3: GenericFunc(4,1); break;
\r
398 case 4: GenericFunc(5,1); break;
\r
399 case 5: vc_loadimage(); break;
\r
400 case 6: GenericFunc(7,5); break;
\r
401 case 7: GenericFunc(8,5); break;
\r
402 case 8: GenericFunc(9,0); break;
\r
403 case 9: GenericFunc(10,0); break;
\r
404 case 10: vc_AllocateEntity(); break;
\r
405 case 11: GenericFunc(12,1); break;
\r
406 case 12: vc_Map(); break;
\r
407 case 13: vc_LoadFont(); break;
\r
408 case 14: vc_PlayFLI(); break;
\r
409 case 15: GenericFunc(16,2); break;
\r
410 case 16: vc_PrintString(); break;
\r
411 case 17: vc_LoadRaw(); break;
\r
412 case 18: GenericFunc(19,4); break;
\r
413 case 19: GenericFunc(20,1); break;
\r
414 case 20: GenericFunc(21,7); break;
\r
415 case 21: GenericFunc(22,0); break;
\r
416 case 22: GenericFunc(23,0); break;
\r
417 case 23: GenericFunc(24,1); break;
\r
418 case 24: vc_EntityMove(); break;
\r
419 case 25: GenericFunc(26,4); break;
\r
420 case 26: GenericFunc(27,4); break;
\r
421 case 27: GenericFunc(28,5); break;
\r
422 case 28: GenericFunc(29,4); break;
\r
423 case 29: GenericFunc(30,4); break;
\r
424 case 30: GenericFunc(31,5); break;
\r
425 case 31: GenericFunc(32,5); break;
\r
426 case 32: vc_strlen(); break;
\r
427 case 33: vc_strcmp(); break;
\r
428 case 34: GenericFunc(35,0); break;
\r
429 case 35: GenericFunc(36,1); break;
\r
430 case 36: GenericFunc(37,1); break;
\r
431 case 37: GenericFunc(38,1); break;
\r
432 case 38: GenericFunc(39,3); break;
\r
433 case 39: GenericFunc(40,2); break;
\r
434 case 40: GenericFunc(41,1); break;
\r
435 case 41: GenericFunc(42,1); break;
\r
436 case 42: GenericFunc(43,3); break;
\r
437 case 43: vc_HookRetrace(); break;
\r
438 case 44: vc_HookTimer(); break;
\r
439 case 45: GenericFunc(46,2); break;
\r
440 case 46: vc_SetRString(); break;
\r
441 case 47: GenericFunc(48,4); break;
\r
442 case 48: GenericFunc(49,3); break;
\r
443 case 49: GenericFunc(50,0); break;
\r
444 case 50: vc_PartyMove(); break;
\r
445 case 51: GenericFunc(52,1); break;
\r
446 case 52: GenericFunc(53,1); break;
\r
447 case 53: GenericFunc(54,1); break;
\r
448 case 54: GenericFunc(55,0); break;
\r
449 case 55: GenericFunc(56,1); break;
\r
450 case 56: GenericFunc(57,1); break;
\r
451 case 57: GenericFunc(58,5); break;
\r
452 case 58: GenericFunc(59,5); break;
\r
453 case 59: GenericFunc(60,2); break;
\r
454 case 60: vc_HookKey(); break;
\r
455 case 61: vc_PlayMusic(); break;
\r
456 case 62: GenericFunc(63,0); break;
\r
457 case 63: GenericFunc(64,5); break;
\r
458 case 64: vc_OpenFile(); break;
\r
459 case 65: GenericFunc(66,1); break;
\r
460 case 66: vc_QuickRead(); break;
\r
461 case 67: GenericFunc(68,1); break;
\r
462 case 68: GenericFunc(69,1); break;
\r
463 case 69: GenericFunc(70,0); break;
\r
464 case 70: GenericFunc(71,0); break;
\r
465 case 71: GenericFunc(72,7); break;
\r
466 case 72: GenericFunc(73,15); break;
\r
467 case 73: vc_CacheSound(); break;
\r
468 case 74: GenericFunc(75,0); break;
\r
469 case 75: GenericFunc(76,3); break;
\r
470 case 76: GenericFunc(77,7); break;
\r
471 case 77: GenericFunc(78,4); break;
\r
472 case 78: GenericFunc(79,4); break;
\r
473 case 79: vc_val(); break;
\r
474 case 80: GenericFunc(81,7); break;
\r
475 case 81: GenericFunc(82,5); break;
\r
476 case 82: vc_Log(); break;
\r
477 case 83: GenericFunc(84,2); break;
\r
478 case 84: GenericFunc(85,2); break;
\r
479 case 85: GenericFunc(86,3); break;
\r
480 case 86: GenericFunc(87,1); break;
\r
481 case 87: GenericFunc(88,1); break;
\r
482 case 88: GenericFunc(89,1); break;
\r
483 case 89: vc_fgetline(); break;
\r
484 case 90: vc_fgettoken(); break;
\r
485 case 91: vc_fwritestring(); break;
\r
486 case 92: GenericFunc(93, 3); break;
\r
487 case 93: vc_frename(); break;
\r
488 case 94: vc_fdelete(); break;
\r
489 case 95: vc_fwopen(); break;
\r
490 case 96: GenericFunc(97, 1); break;
\r
491 case 97: GenericFunc(98, 3); break;
\r
492 case 98: GenericFunc(99, 3); break;
\r
493 case 99: GenericFunc(100, 6); break;
\r
494 case 100: GenericFunc(101, 0); break;
\r
495 case 101: GenericFunc(102, 7); break;
\r
496 case 102: GenericFunc(103, 1); break;
\r
497 case 103: GenericFunc(104, 1); break;
\r
498 case 104: GenericFunc(105, 1); break;
\r
499 case 105: vc_asc(); break;
\r
500 case 106: GenericFunc(107, 1); break;
\r
501 case 107: vc_NumForScript(); break;
\r
502 case 108: vc_FileSize(); break;
\r
503 case 109: GenericFunc(110, 1); break;
\r
504 case 110: GenericFunc(111, 0); break;
\r
505 default: vcerr("Internal error. Unknown standard function.");
\r
509 void HandleUserFunction()
\r
514 EmitW((short) idx);
\r
516 for (i=0; i<funcs[idx].numargs; i++)
\r
518 if (i) Expect(",");
\r
519 if (funcs[idx].argtype[i]==INT) EmitOperand();
\r
520 if (funcs[idx].argtype[i]==STRING) HandleString();
\r
525 void HandleFunctionType()
\r
527 if (token_subtype==op_BFUNC)
\r
529 EmitC(opEXEC_STDLIB);
\r
533 if (token_subtype==op_UFUNC)
\r
535 EmitC(opEXEC_EXTERNFUNC);
\r
536 HandleUserFunction();
\r
540 void HandleIfComponent()
\r
550 if (NextIs("=")) { ot=i_EQUALTO; GetToken(); }
\r
551 if (NextIs("!=")) { ot=i_NOTEQUAL; GetToken(); }
\r
552 if (NextIs(">")) { ot=i_GREATERTHAN; GetToken(); }
\r
553 if (NextIs(">=")) { ot=i_GREATERTHANOREQUAL; GetToken(); }
\r
554 if (NextIs("<")) { ot=i_LESSTHAN; GetToken(); }
\r
555 if (NextIs("<=")) { ot=i_LESSTHANOREQUAL; GetToken(); }
\r
557 if (!ot) EmitC(i_NONZERO);
\r
558 else if (ot==i_ZERO) EmitC(i_ZERO);
\r
566 void HandleIfGroup()
\r
570 HandleIfComponent();
\r
578 else if (NextIs("||"))
\r
587 if (!TokenIs(")") && !TokenIs(";"))
\r
588 vcerr("Syntax error.");
\r
597 char *falseofs = 0;
\r
606 EmitD(0); // We'll come back to this and fix it up.
\r
611 if (NextIs("else"))
\r
621 while (!NextIs("}")) DoSomething();
\r
623 if (NextIs("else"))
\r
631 b=code; // Put correct false-execution offset thingy.
\r
633 EmitD((int) b - (int) outbuf);
\r
636 if (NextIs("else"))
\r
646 while (!NextIs("}")) DoSomething();
\r
649 b=code; // Put correct else-execution offset thingy.
\r
651 EmitD((int) b - (int) outbuf);
\r
656 void ProcessWhile()
\r
657 { char *falseofs, *top, *b;
\r
665 EmitD(0); // We'll come back to this and fix it up.
\r
671 EmitD((int) top - (int) outbuf);
\r
676 while (!NextIs("}")) DoSomething();
\r
679 EmitD((int) top - (int) outbuf);
\r
682 b=code; // Put correct false-execution offset thingy.
\r
684 EmitD((int) b - (int) outbuf);
\r
689 { char *src1, *src2, *loopstartpos, *srctmp;
\r
692 while (!TokenIs(";"))
\r
693 DoSomething(); // Emit initialization code.
\r
695 src1=src; // Store position of loop conditional
\r
696 while (!NextIs(";")) GetToken(); GetToken();
\r
697 src2=src; // Store position of end-of-loop code
\r
699 while (!NextIs(")")) GetToken(); GetToken();
\r
700 loopstartpos=(char *) (int) code - (int) outbuf;
\r
709 while (!NextIs("}")) DoSomething();
\r
714 while (!TokenIs(")"))
\r
719 EmitD((int) code - (int) outbuf +9);
\r
721 EmitD((int) loopstartpos);
\r
726 void HandleAssign()
\r
735 EmitD(vars[varidx].varstartofs);
\r
737 else if (vc==op_UVARRAY)
\r
740 EmitD(vars[varidx].varstartofs);
\r
745 else if (vc==op_LVAR)
\r
748 EmitC((char) varidx);
\r
750 else if (vc==op_HVAR0)
\r
753 EmitC((char) varidx);
\r
755 else if (vc==op_HVAR1)
\r
758 EmitC((char) varidx);
\r
763 else if (vc==op_STRING)
\r
766 EmitW((short) str[varidx].vsofs);
\r
768 else if (vc==op_SARRAY)
\r
771 EmitW((short) str[varidx].vsofs);
\r
776 else if (vc==op_SLOCAL)
\r
779 EmitW((short) varidx);
\r
782 if (TokenIs("++")) { EmitC(a_INC); GetToken(); return; } else
\r
783 if (TokenIs("--")) { EmitC(a_DEC); GetToken(); return; } else
\r
784 if (TokenIs("+=")) { EmitC(a_INCSET); } else
\r
785 if (TokenIs("-=")) { EmitC(a_DECSET); } else
\r
786 if (TokenIs("=")) { EmitC(a_SET); } else
\r
787 vcerr("Invalid assignment operator.");
\r
788 if (vc==op_STRING) HandleString();
\r
789 else if (vc==op_SARRAY) HandleString();
\r
790 else if (vc==op_SLOCAL) HandleString();
\r
791 else EmitOperand();
\r
797 void HandleReturn()
\r
805 if (!funcs[c].returntype)
\r
811 if (funcs[c].returntype==1)
\r
813 EmitC(opSETRETVAL);
\r
821 void ProcessSwitch()
\r
822 { char *buf,*retrptr;
\r
830 // case .. option loop
\r
832 while (!NextIs("}"))
\r
840 while (!NextIs("case") && !NextIs("}")) DoSomething();
\r
844 EmitD((int) buf - (int) outbuf);
\r
851 void DoSomething(void)
\r
854 if (TokenIs("return")) { HandleReturn(); return; }
\r
855 if (token_type==FUNCTION) { HandleFunctionType(); Expect(";"); return; }
\r
856 if (token_type==IDENTIFIER) { HandleAssign(); return; }
\r
857 if (TokenIs("if")) { ProcessIf(); return; }
\r
858 if (TokenIs("while")) { ProcessWhile(); return; }
\r
859 if (TokenIs("for")) { ProcessFor(); return; }
\r
860 if (TokenIs("switch")) { ProcessSwitch(); return; }
\r
861 vcerr("Unknown token.");
\r
864 void DumpSystemIdx()
\r
867 vprint("Dumping system.idx index file.");
\r
868 f=fopen("system.idx","wb");
\r
870 fwrite(&numvars, 1, 4, f);
\r
871 fwrite(&vars, sizeof vars / 500, numvars, f);
\r
872 fwrite(&numfuncs, 1, 4, f);
\r
873 fwrite(&funcs, sizeof funcs / 700, numfuncs, f);
\r
874 fwrite(&numstr, 1, 4, f);
\r
875 fwrite(&str, sizeof str / 300, numstr, f);
\r
879 void ReadSystemIdx()
\r
882 if (!(f=fopen("system.idx","rb")))
\r
883 err("Could not access system.idx.");
\r
885 fread(&numvars, 1, 4, f);
\r
886 fread(&vars, sizeof vars / 500, numvars, f);
\r
887 fread(&numfuncs, 1, 4, f);
\r
888 fread(&funcs, sizeof funcs / 700, numfuncs, f);
\r
889 fread(&numstr, 1, 4, f);
\r
890 fread(&str, sizeof str / 300, numstr, f);
\r
894 void DoLocalVariables(int c)
\r
898 na=funcs[c].numargs;
\r
899 while (NextIs("int") || NextIs("string"))
\r
902 if (TokenIs("int"))
\r
904 funcs[c].argtype[na]=INT;
\r
906 memcpy(larg[na++], token, 40);
\r
907 while (!NextIs(";"))
\r
910 funcs[c].argtype[na]=INT;
\r
912 memcpy(larg[na++], token, 40);
\r
916 if (TokenIs("string"))
\r
918 funcs[c].argtype[na]=STRING;
\r
920 memcpy(larg[na++], token, 40);
\r
921 while (!NextIs(";"))
\r
924 funcs[c].argtype[na]=STRING;
\r
926 memcpy(larg[na++], token, 40);
\r
931 funcs[c].numlocals=na;
\r
934 void CompileMAP(char *fname)
\r
938 // Compiles a map-based VC.
\r
940 memcpy(strbuf, fname, i);
\r
946 PreProcess(strbuf);
\r
948 source=(char *) malloc(1000000);
\r
949 memset(source, 0, 1000000);
\r
950 outbuf=(char *) malloc(1000000);
\r
951 memset(outbuf, 0, 1000000);
\r
952 if (!(f=fopen("vcctemp.$$$","rb")))
\r
953 err("Could not open source file.");
\r
954 fread(source, 1, 1000000, f);
\r
965 functbl[mfuncs]=(char *) (int) code - (int) outbuf;
\r
969 while (!NextIs("}")) DoSomething();
\r
974 dprint("%s.vc (%i lines)", fname, lines);
\r
977 void SkipBrackets()
\r
979 while (!NextIs("}"))
\r
982 err("No matching bracket.");
\r
984 if (TokenIs("{")) SkipBrackets();
\r
993 while (i<numhardfuncs)
\r
995 if (!strcmp(hardfuncs[i], token)) break;
\r
998 if (i<numhardfuncs)
\r
1000 vcerr("%s: Duplicate identifier.", token);
\r
1003 while (i<numhardvar0)
\r
1005 if (!strcmp(hardvar0[i], token)) break;
\r
1008 if (i<numhardvar0)
\r
1010 vcerr("%s: Duplicate identifier.", token);
\r
1013 while (i<numhardvar1)
\r
1015 if (!strcmp(hardvar1[i], token)) break;
\r
1018 if (i<numhardvar1)
\r
1020 vcerr("%s: Duplicate identifier.", token);
\r
1023 while (i<numfuncs)
\r
1025 if (!strcmp(funcs[i].fname, token)) break;
\r
1030 vcerr("%s: Duplicate identifier.", token);
\r
1036 if (!strcmp(vars[i].vname, token)) break;
\r
1041 vcerr("%s: Duplicate identifier.", token);
\r
1046 if (!strcmp(str[i].vname, token)) break;
\r
1051 vcerr("%s: Duplicate identifier.", token);
\r
1055 void CompileSystem()
\r
1062 // Compiles a map-based VC.
\r
1064 PreProcess("system.vc");
\r
1066 source = (char *) malloc(1000000);
\r
1067 memset(source, 0, 1000000);
\r
1068 outbuf = (char *) malloc(1000000);
\r
1069 memset(outbuf, 0, 1000000);
\r
1071 if (!(f=fopen("vcctemp.$$$","rb")))
\r
1072 err("Could not open source file.");
\r
1074 fread(source, 1, 1000000, f);
\r
1081 vprint("First pass...");
\r
1082 vctype=1; tlines=0;
\r
1085 // system.vc is compiled in a two-pass system. The first pass simply
\r
1086 // goes through the system.vc file and sets up declarations for all
\r
1087 // global variables and function declarations. So system.vc won't
\r
1088 // have to worry about forward declarations or anything.
\r
1092 if (TokenIs("string"))
\r
1098 memcpy(str[numstr].vname, token, strlen(token));
\r
1099 str[numstr].vsofs=sstartofs;
\r
1104 str[numstr].arraylen=token_nvalue;
\r
1107 else str[numstr].arraylen=1;
\r
1108 sstartofs+=str[numstr].arraylen;
\r
1109 vprint("Decl %s of type string, size %i. [%i]",
\r
1110 str[numstr].vname, str[numstr].arraylen, str[numstr].vsofs);
\r
1112 if (!NextIs(",")) break;
\r
1117 if (TokenIs("int"))
\r
1120 if (NextIs("(")) type=0; else type=1;
\r
1124 if (TokenIs("void") || (TokenIs("int") && !type))
\r
1126 if (TokenIs("void")) funcs[numfuncs].returntype=0;
\r
1127 if (TokenIs("int")) funcs[numfuncs].returntype=1;
\r
1130 memcpy(funcs[numfuncs].fname,token,strlen(token));
\r
1131 funcs[numfuncs].numargs=0;
\r
1133 while (!NextIs(")"))
\r
1136 na=funcs[numfuncs].numargs;
\r
1137 if (TokenIs("int")) { funcs[numfuncs].argtype[na]=INT; } else
\r
1138 if (TokenIs("string")) { funcs[numfuncs].argtype[na]=STRING; }
\r
1139 else vcerr("Invalid arguement declaration.");
\r
1141 if (NextIs(",")) GetToken();
\r
1142 funcs[numfuncs].numargs++;
\r
1147 vprint("Found %s declaration for %s, %i parameters.",
\r
1148 funcs[numfuncs].returntype ? "int" : "void",
\r
1149 funcs[numfuncs].fname, funcs[numfuncs].numargs);
\r
1152 if (TokenIs("int") && type)
\r
1158 memcpy(vars[numvars].vname, token, strlen(token));
\r
1159 vars[numvars].varstartofs=curstartofs;
\r
1164 vars[numvars].arraylen=token_nvalue;
\r
1167 else vars[numvars].arraylen=1;
\r
1168 curstartofs+=vars[numvars].arraylen;
\r
1169 vprint("Decl %s of type int, size %i. [%i]", vars[numvars].vname,
\r
1170 vars[numvars].arraylen, vars[numvars].varstartofs);
\r
1172 if (!NextIs(",")) break;
\r
1178 dprint("system.vc: %i ints, %i strings, %i functions",
\r
1179 numvars, numstr, numfuncs);
\r
1181 vprint("Second pass...");
\r
1182 src=source; tlines=0;
\r
1185 // Everything in system.vc will either be a global var decl or
\r
1186 // a function definition.
\r
1190 if (TokenIs("string"))
\r
1201 if (!NextIs(",")) break;
\r
1206 if (TokenIs("int"))
\r
1209 if (NextIs("(")) type=0; else type=1;
\r
1213 if (TokenIs("void") || (TokenIs("int") && !type))
\r
1215 funcs[c].syscodeofs=(int) code - (int) outbuf;
\r
1219 memset(&larg, 0, 480);
\r
1220 while (!NextIs(")"))
\r
1224 memcpy(larg[i], token, 40);
\r
1225 if (NextIs(",")) GetToken();
\r
1230 DoLocalVariables(c);
\r
1231 while (!NextIs("}")) DoSomething();
\r
1236 if (TokenIs("int") && type)
\r
1247 if (!NextIs(",")) break;
\r
1253 dprint("system.vc (%i lines, %i total)", lines, tlines);
\r