Mercurial > botc / file comparison

comparison: src/parser.cpp

src/parser.cpp

changeset 138
a426c1039655
parent 137
73d057b030d0
child 139
cf11621ae422
equal deleted inserted replaced
137:73d057b030d0 138:a426c1039655
38 38
39 #define SCOPE(n) (m_scopeStack[m_scopeCursor - n]) 39 #define SCOPE(n) (m_scopeStack[m_scopeCursor - n])
40 40
41 static const StringList g_validZandronumVersions = {"1.2", "1.3", "2.0"}; 41 static const StringList g_validZandronumVersions = {"1.2", "1.3", "2.0"};
42 42
43 // ============================================================================ 43 // _________________________________________________________________________________________________
44 // 44 //
45 BotscriptParser::BotscriptParser() : 45 BotscriptParser::BotscriptParser() :
46 m_isReadOnly (false), 46 m_isReadOnly (false),
47 m_mainBuffer (new DataBuffer), 47 m_mainBuffer (new DataBuffer),
48 m_onenterBuffer (new DataBuffer), 48 m_onenterBuffer (new DataBuffer),
58 m_highestGlobalVarIndex (0), 58 m_highestGlobalVarIndex (0),
59 m_highestStateVarIndex (0), 59 m_highestStateVarIndex (0),
60 m_zandronumVersion (10200), // 1.2 60 m_zandronumVersion (10200), // 1.2
61 m_defaultZandronumVersion (true) {} 61 m_defaultZandronumVersion (true) {}
62 62
63 // ============================================================================ 63 // _________________________________________________________________________________________________
64 // 64 //
65 BotscriptParser::~BotscriptParser() 65 BotscriptParser::~BotscriptParser()
66 { 66 {
67 delete m_lexer; 67 delete m_lexer;
68 } 68 }
69 69
70 // ============================================================================ 70 // _________________________________________________________________________________________________
71 // 71 //
72 void BotscriptParser::checkToplevel() 72 void BotscriptParser::checkToplevel()
73 { 73 {
74 if (m_currentMode != ParserMode::TopLevel) 74 if (m_currentMode != ParserMode::TopLevel)
75 error ("%1-statements may only be defined at top level!", getTokenString()); 75 error ("%1-statements may only be defined at top level!", getTokenString());
76 } 76 }
77 77
78 // ============================================================================ 78 // _________________________________________________________________________________________________
79 // 79 //
80 void BotscriptParser::checkNotToplevel() 80 void BotscriptParser::checkNotToplevel()
81 { 81 {
82 if (m_currentMode == ParserMode::TopLevel) 82 if (m_currentMode == ParserMode::TopLevel)
83 error ("%1-statements must not be defined at top level!", getTokenString()); 83 error ("%1-statements must not be defined at top level!", getTokenString());
84 } 84 }
85 85
86 // ============================================================================ 86 // _________________________________________________________________________________________________
87 // 87 //
88 // Main compiler code. Begins read of the script file, checks the syntax of it 88 // Main compiler code. Begins read of the script file, checks the syntax of it
89 // and writes the data to the object file via Objwriter - which also takes care 89 // and writes the data to the object file via Objwriter - which also takes care
90 // of necessary buffering so stuff is written in the correct order. 90 // of necessary buffering so stuff is written in the correct order.
91 // 91 //
227 227
228 if (m_defaultZandronumVersion) 228 if (m_defaultZandronumVersion)
229 { 229 {
230 print ("\n"); 230 print ("\n");
231 print ("note: use the 'using' directive to define a target Zandronum version\n"); 231 print ("note: use the 'using' directive to define a target Zandronum version\n");
232 print ("usage: using zandronum <version>, possible versions: %1\n", g_validZandronumVersions); 232 print ("usage: using zandronum <version>, possible versions: %1\n",
233 g_validZandronumVersions);
233 print ("\n"); 234 print ("\n");
234 } 235 }
235 236
236 // Dump the last state's onenter and mainloop 237 // Dump the last state's onenter and mainloop
237 writeMemberBuffers(); 238 writeMemberBuffers();
239 // String table 240 // String table
240 writeStringTable(); 241 writeStringTable();
241 } 242 }
242 } 243 }
243 244
244 // ============================================================================ 245 // _________________________________________________________________________________________________
245 // 246 //
246 void BotscriptParser::parseStateBlock() 247 void BotscriptParser::parseStateBlock()
247 { 248 {
248 checkToplevel(); 249 checkToplevel();
249 m_lexer->mustGetNext (Token::String); 250 m_lexer->mustGetNext (Token::String);
274 m_numStates++; 275 m_numStates++;
275 m_currentState = statename; 276 m_currentState = statename;
276 m_gotMainLoop = false; 277 m_gotMainLoop = false;
277 } 278 }
278 279
279 // ============================================================================ 280 // _________________________________________________________________________________________________
280 // 281 //
281 void BotscriptParser::parseEventBlock() 282 void BotscriptParser::parseEventBlock()
282 { 283 {
283 checkToplevel(); 284 checkToplevel();
284 m_lexer->mustGetNext (Token::String); 285 m_lexer->mustGetNext (Token::String);
293 currentBuffer()->writeHeader (DataHeader::Event); 294 currentBuffer()->writeHeader (DataHeader::Event);
294 currentBuffer()->writeDWord (e->number); 295 currentBuffer()->writeDWord (e->number);
295 m_numEvents++; 296 m_numEvents++;
296 } 297 }
297 298
298 // ============================================================================ 299 // _________________________________________________________________________________________________
299 // 300 //
300 void BotscriptParser::parseMainloop() 301 void BotscriptParser::parseMainloop()
301 { 302 {
302 checkToplevel(); 303 checkToplevel();
303 m_lexer->mustGetNext (Token::BraceStart); 304 m_lexer->mustGetNext (Token::BraceStart);
304 305
305 m_currentMode = ParserMode::MainLoop; 306 m_currentMode = ParserMode::MainLoop;
306 m_mainLoopBuffer->writeHeader (DataHeader::MainLoop); 307 m_mainLoopBuffer->writeHeader (DataHeader::MainLoop);
307 } 308 }
308 309
309 // ============================================================================ 310 // _________________________________________________________________________________________________
310 // 311 //
311 void BotscriptParser::parseOnEnterExit() 312 void BotscriptParser::parseOnEnterExit()
312 { 313 {
313 checkToplevel(); 314 checkToplevel();
314 bool onenter = (tokenIs (Token::Onenter)); 315 bool onenter = (tokenIs (Token::Onenter));
315 m_lexer->mustGetNext (Token::BraceStart); 316 m_lexer->mustGetNext (Token::BraceStart);
316 m_currentMode = onenter ? ParserMode::Onenter : ParserMode::Onexit; 317 m_currentMode = onenter ? ParserMode::Onenter : ParserMode::Onexit;
317 currentBuffer()->writeHeader (onenter ? DataHeader::OnEnter : DataHeader::OnExit); 318 currentBuffer()->writeHeader (onenter ? DataHeader::OnEnter : DataHeader::OnExit);
318 } 319 }
319 320
320 // ============================================================================ 321 // _________________________________________________________________________________________________
321 // 322 //
322 void BotscriptParser::parseVar() 323 void BotscriptParser::parseVar()
323 { 324 {
324 Variable* var = new Variable; 325 Variable* var = new Variable;
325 var->origin = m_lexer->describeCurrentPosition(); 326 var->origin = m_lexer->describeCurrentPosition();
412 m_lexer->mustGetNext (Token::Semicolon); 413 m_lexer->mustGetNext (Token::Semicolon);
413 print ("Declared %3 variable #%1 $%2\n", var->index, var->name, isInGlobalState() ? "global" : 414 print ("Declared %3 variable #%1 $%2\n", var->index, var->name, isInGlobalState() ? "global" :
414 "state-local"); 415 "state-local");
415 } 416 }
416 417
417 // ============================================================================ 418 // _________________________________________________________________________________________________
418 // 419 //
419 void BotscriptParser::parseIf() 420 void BotscriptParser::parseIf()
420 { 421 {
421 checkNotToplevel(); 422 checkNotToplevel();
422 pushScope(); 423 pushScope();
443 // Store it 444 // Store it
444 SCOPE (0).mark1 = mark; 445 SCOPE (0).mark1 = mark;
445 SCOPE (0).type = SCOPE_If; 446 SCOPE (0).type = SCOPE_If;
446 } 447 }
447 448
448 // ============================================================================ 449 // _________________________________________________________________________________________________
449 // 450 //
450 void BotscriptParser::parseElse() 451 void BotscriptParser::parseElse()
451 { 452 {
452 checkNotToplevel(); 453 checkNotToplevel();
453 m_lexer->mustGetNext (Token::BraceStart); 454 m_lexer->mustGetNext (Token::BraceStart);
467 // Move the ifnot mark here and set type to else 468 // Move the ifnot mark here and set type to else
468 currentBuffer()->adjustMark (SCOPE (0).mark1); 469 currentBuffer()->adjustMark (SCOPE (0).mark1);
469 SCOPE (0).type = SCOPE_Else; 470 SCOPE (0).type = SCOPE_Else;
470 } 471 }
471 472
472 // ============================================================================ 473 // _________________________________________________________________________________________________
473 // 474 //
474 void BotscriptParser::parseWhileBlock() 475 void BotscriptParser::parseWhileBlock()
475 { 476 {
476 checkNotToplevel(); 477 checkNotToplevel();
477 pushScope(); 478 pushScope();
500 SCOPE (0).mark1 = mark1; 501 SCOPE (0).mark1 = mark1;
501 SCOPE (0).mark2 = mark2; 502 SCOPE (0).mark2 = mark2;
502 SCOPE (0).type = SCOPE_While; 503 SCOPE (0).type = SCOPE_While;
503 } 504 }
504 505
505 // ============================================================================ 506 // _________________________________________________________________________________________________
506 // 507 //
507 void BotscriptParser::parseForBlock() 508 void BotscriptParser::parseForBlock()
508 { 509 {
509 checkNotToplevel(); 510 checkNotToplevel();
510 pushScope(); 511 pushScope();
552 SCOPE (0).mark2 = mark2; 553 SCOPE (0).mark2 = mark2;
553 SCOPE (0).buffer1 = incr; 554 SCOPE (0).buffer1 = incr;
554 SCOPE (0).type = SCOPE_For; 555 SCOPE (0).type = SCOPE_For;
555 } 556 }
556 557
557 // ============================================================================ 558 // _________________________________________________________________________________________________
558 // 559 //
559 void BotscriptParser::parseDoBlock() 560 void BotscriptParser::parseDoBlock()
560 { 561 {
561 checkNotToplevel(); 562 checkNotToplevel();
562 pushScope(); 563 pushScope();
563 m_lexer->mustGetNext (Token::BraceStart); 564 m_lexer->mustGetNext (Token::BraceStart);
564 SCOPE (0).mark1 = currentBuffer()->addMark (""); 565 SCOPE (0).mark1 = currentBuffer()->addMark ("");
565 SCOPE (0).type = SCOPE_Do; 566 SCOPE (0).type = SCOPE_Do;
566 } 567 }
567 568
568 // ============================================================================ 569 // _________________________________________________________________________________________________
569 // 570 //
570 void BotscriptParser::parseSwitchBlock() 571 void BotscriptParser::parseSwitchBlock()
571 { 572 {
572 // This gets a bit tricky. switch is structured in the 573 // This gets a bit tricky. switch is structured in the
573 // bytecode followingly: 574 // bytecode followingly:
591 SCOPE (0).type = SCOPE_Switch; 592 SCOPE (0).type = SCOPE_Switch;
592 SCOPE (0).mark1 = currentBuffer()->addMark (""); // end mark 593 SCOPE (0).mark1 = currentBuffer()->addMark (""); // end mark
593 SCOPE (0).buffer1 = null; // default header 594 SCOPE (0).buffer1 = null; // default header
594 } 595 }
595 596
596 // ============================================================================ 597 // _________________________________________________________________________________________________
597 // 598 //
598 void BotscriptParser::parseSwitchCase() 599 void BotscriptParser::parseSwitchCase()
599 { 600 {
600 // case is only allowed inside switch 601 // case is only allowed inside switch
601 if (SCOPE (0).type != SCOPE_Switch) 602 if (SCOPE (0).type != SCOPE_Switch)
628 currentBuffer()->writeDWord (num); 629 currentBuffer()->writeDWord (num);
629 addSwitchCase (null); 630 addSwitchCase (null);
630 SCOPE (0).casecursor->number = num; 631 SCOPE (0).casecursor->number = num;
631 } 632 }
632 633
633 // ============================================================================ 634 // _________________________________________________________________________________________________
634 // 635 //
635 void BotscriptParser::parseSwitchDefault() 636 void BotscriptParser::parseSwitchDefault()
636 { 637 {
637 if (SCOPE (0).type != SCOPE_Switch) 638 if (SCOPE (0).type != SCOPE_Switch)
638 error ("default label outside switch"); 639 error ("default label outside switch");
654 buf->writeHeader (DataHeader::Drop); 655 buf->writeHeader (DataHeader::Drop);
655 buf->writeHeader (DataHeader::Goto); 656 buf->writeHeader (DataHeader::Goto);
656 addSwitchCase (buf); 657 addSwitchCase (buf);
657 } 658 }
658 659
659 // ============================================================================ 660 // _________________________________________________________________________________________________
660 // 661 //
661 void BotscriptParser::parseBreak() 662 void BotscriptParser::parseBreak()
662 { 663 {
663 if (m_scopeCursor == 0) 664 if (m_scopeCursor == 0)
664 error ("unexpected `break`"); 665 error ("unexpected `break`");
685 } 686 }
686 687
687 m_lexer->mustGetNext (Token::Semicolon); 688 m_lexer->mustGetNext (Token::Semicolon);
688 } 689 }
689 690
690 // ============================================================================ 691 // _________________________________________________________________________________________________
691 // 692 //
692 void BotscriptParser::parseContinue() 693 void BotscriptParser::parseContinue()
693 { 694 {
694 m_lexer->mustGetNext (Token::Semicolon); 695 m_lexer->mustGetNext (Token::Semicolon);
695 696
717 // No loop blocks 718 // No loop blocks
718 if (found == false) 719 if (found == false)
719 error ("`continue`-statement not inside a loop"); 720 error ("`continue`-statement not inside a loop");
720 } 721 }
721 722
722 // ============================================================================ 723 // _________________________________________________________________________________________________
723 // 724 //
724 void BotscriptParser::parseBlockEnd() 725 void BotscriptParser::parseBlockEnd()
725 { 726 {
726 // Closing brace 727 // Closing brace
727 // If we're in the block stack, we're descending down from it now 728 // If we're in the block stack, we're descending down from it now
835 currentBuffer()->writeHeader (dataheader); 836 currentBuffer()->writeHeader (dataheader);
836 m_currentMode = ParserMode::TopLevel; 837 m_currentMode = ParserMode::TopLevel;
837 m_lexer->next (Token::Semicolon); 838 m_lexer->next (Token::Semicolon);
838 } 839 }
839 840
840 // ============================================================================= 841 //
842 -------------------------------------------------------------------------------------------------=
841 // 843 //
842 void BotscriptParser::parseEventdef() 844 void BotscriptParser::parseEventdef()
843 { 845 {
844 EventDefinition* e = new EventDefinition; 846 EventDefinition* e = new EventDefinition;
845 847
852 m_lexer->mustGetNext (Token::ParenEnd); 854 m_lexer->mustGetNext (Token::ParenEnd);
853 m_lexer->mustGetNext (Token::Semicolon); 855 m_lexer->mustGetNext (Token::Semicolon);
854 addEvent (e); 856 addEvent (e);
855 } 857 }
856 858
857 // ============================================================================= 859 //
860 -------------------------------------------------------------------------------------------------=
858 // 861 //
859 void BotscriptParser::parseFuncdef() 862 void BotscriptParser::parseFuncdef()
860 { 863 {
861 CommandInfo* comm = new CommandInfo; 864 CommandInfo* comm = new CommandInfo;
862 comm->origin = m_lexer->describeCurrentPosition(); 865 comm->origin = m_lexer->describeCurrentPosition();
925 m_lexer->mustGetNext (Token::ParenEnd); 928 m_lexer->mustGetNext (Token::ParenEnd);
926 m_lexer->mustGetNext (Token::Semicolon); 929 m_lexer->mustGetNext (Token::Semicolon);
927 addCommandDefinition (comm); 930 addCommandDefinition (comm);
928 } 931 }
929 932
930 // ============================================================================ 933 // _________________________________________________________________________________________________
931 // 934 //
932 // Parses a using statement 935 // Parses a using statement
933 // 936 //
934 void BotscriptParser::parseUsing() 937 void BotscriptParser::parseUsing()
935 { 938 {
936 checkToplevel(); 939 checkToplevel();
937 m_lexer->mustGetSymbol ("zandronum"); 940 m_lexer->mustGetSymbol ("zandronum");
938 String versionText; 941 String versionText;
939 942
940 while (m_lexer->next() and (m_lexer->tokenType() == Token::Number or m_lexer->tokenType() == 943 while (m_lexer->next()
941 Token::Dot)) 944 and (m_lexer->tokenType() == Token::Number or m_lexer->tokenType() == Token::Dot))
945 {
942 versionText += getTokenString(); 946 versionText += getTokenString();
947 }
943 948
944 // Note: at this point the lexer's pointing at the token after the version. 949 // Note: at this point the lexer's pointing at the token after the version.
945 if (versionText.isEmpty()) 950 if (versionText.isEmpty())
946 error ("expected version string, got `%1`", getTokenString()); 951 error ("expected version string, got `%1`", getTokenString());
947 952
953 m_zandronumVersion = versionTokens[0].toLong() * 10000 + versionTokens[1].toLong() * 100; 958 m_zandronumVersion = versionTokens[0].toLong() * 10000 + versionTokens[1].toLong() * 100;
954 m_defaultZandronumVersion = false; 959 m_defaultZandronumVersion = false;
955 m_lexer->tokenMustBe (Token::Semicolon); 960 m_lexer->tokenMustBe (Token::Semicolon);
956 } 961 }
957 962
958 // ============================================================================/ 963 // _________________________________________________________________________________________________
959 // 964 //
960 // Parses a command call 965 // Parses a command call
961 // 966 //
962 DataBuffer* BotscriptParser::parseCommand (CommandInfo* comm) 967 DataBuffer* BotscriptParser::parseCommand (CommandInfo* comm)
963 { 968 {
983 988
984 break; 989 break;
985 } 990 }
986 991
987 if (curarg >= comm->args.size()) 992 if (curarg >= comm->args.size())
993 {
988 error ("too many arguments (%3) passed to %1\n\tusage is: %2", 994 error ("too many arguments (%3) passed to %1\n\tusage is: %2",
989 comm->name, comm->signature()); 995 comm->name, comm->signature());
996 }
990 997
991 r->mergeAndDestroy (parseExpression (comm->args[curarg].type, true)); 998 r->mergeAndDestroy (parseExpression (comm->args[curarg].type, true));
992 m_lexer->mustGetNext (Token::Any); 999 m_lexer->mustGetNext (Token::Any);
993 1000
994 if (curarg < comm->minargs - 1) 1001 if (curarg < comm->minargs - 1)
1027 r->writeDWord (comm->args.size()); 1034 r->writeDWord (comm->args.size());
1028 1035
1029 return r; 1036 return r;
1030 } 1037 }
1031 1038
1032 // ============================================================================ 1039 // _________________________________________________________________________________________________
1033 // 1040 //
1034 String BotscriptParser::parseFloat() 1041 String BotscriptParser::parseFloat()
1035 { 1042 {
1036 m_lexer->tokenMustBe (Token::Number); 1043 m_lexer->tokenMustBe (Token::Number);
1037 String floatstring = getTokenString(); 1044 String floatstring = getTokenString();
1047 } 1054 }
1048 1055
1049 return floatstring; 1056 return floatstring;
1050 } 1057 }
1051 1058
1052 // ============================================================================ 1059 // _________________________________________________________________________________________________
1053 // 1060 //
1054 // Parses an assignment operator. 1061 // Parses an assignment operator.
1055 // 1062 //
1056 AssignmentOperator BotscriptParser::parseAssignmentOperator() 1063 AssignmentOperator BotscriptParser::parseAssignmentOperator()
1057 { 1064 {
1084 1091
1085 error ("WTF bad operator token %1", m_lexer->DescribeToken (m_lexer->token())); 1092 error ("WTF bad operator token %1", m_lexer->DescribeToken (m_lexer->token()));
1086 return (AssignmentOperator) 0; 1093 return (AssignmentOperator) 0;
1087 } 1094 }
1088 1095
1089 // ============================================================================ 1096 // _________________________________________________________________________________________________
1090 // 1097 //
1091 struct AssignmentDataHeaderInfo 1098 const struct AssignmentDataHeaderInfo
1092 { 1099 {
1093 AssignmentOperator op; 1100 AssignmentOperator op;
1094 DataHeader local; 1101 DataHeader local;
1095 DataHeader global; 1102 DataHeader global;
1096 DataHeader array; 1103 DataHeader array;
1104 }
1105 AssignmentDataHeaders[] =
1106 {
1107 {
1108 ASSIGNOP_Assign,
1109 DataHeader::AssignLocalVar,
1110 DataHeader::AssignGlobalVar,
1111 DataHeader::AssignGlobalArray
1112 },
1113 {
1114 ASSIGNOP_Add,
1115 DataHeader::AddLocalVar,
1116 DataHeader::AddGlobalVar,
1117 DataHeader::AddGlobalArray
1118 },
1119 {
1120 ASSIGNOP_Subtract,
1121 DataHeader::SubtractLocalVar,
1122 DataHeader::SubtractGlobalVar,
1123 DataHeader::SubtractGlobalArray
1124 },
1125 {
1126 ASSIGNOP_Multiply,
1127 DataHeader::MultiplyLocalVar,
1128 DataHeader::MultiplyGlobalVar,
1129 DataHeader::MultiplyGlobalArray
1130 },
1131 {
1132 ASSIGNOP_Divide,
1133 DataHeader::DivideLocalVar,
1134 DataHeader::DivideGlobalVar,
1135 DataHeader::DivideGlobalArray
1136 },
1137 {
1138 ASSIGNOP_Modulus,
1139 DataHeader::ModLocalVar,
1140 DataHeader::ModGlobalVar,
1141 DataHeader::ModGlobalArray
1142 },
1143 {
1144 ASSIGNOP_Increase,
1145 DataHeader::IncreaseLocalVar,
1146 DataHeader::IncreaseGlobalVar,
1147 DataHeader::IncreaseGlobalArray
1148 },
1149 {
1150 ASSIGNOP_Decrease,
1151 DataHeader::DecreaseLocalVar,
1152 DataHeader::DecreaseGlobalVar,
1153 DataHeader::DecreaseGlobalArray
1154 },
1097 }; 1155 };
1098 1156
1099 const AssignmentDataHeaderInfo gAssignmentDataHeaders[] =
1100 {
1101 { ASSIGNOP_Assign, DataHeader::AssignLocalVar, DataHeader::AssignGlobalVar,
1102 DataHeader::AssignGlobalArray },
1103 { ASSIGNOP_Add, DataHeader::AddLocalVar, DataHeader::AddGlobalVar,
1104 DataHeader::AddGlobalArray },
1105 { ASSIGNOP_Subtract, DataHeader::SubtractLocalVar, DataHeader::SubtractGlobalVar,
1106 DataHeader::SubtractGlobalArray },
1107 { ASSIGNOP_Multiply, DataHeader::MultiplyLocalVar, DataHeader::MultiplyGlobalVar,
1108 DataHeader::MultiplyGlobalArray },
1109 { ASSIGNOP_Divide, DataHeader::DivideLocalVar, DataHeader::DivideGlobalVar,
1110 DataHeader::DivideGlobalArray },
1111 { ASSIGNOP_Modulus, DataHeader::ModLocalVar, DataHeader::ModGlobalVar,
1112 DataHeader::ModGlobalArray },
1113 { ASSIGNOP_Increase, DataHeader::IncreaseLocalVar, DataHeader::IncreaseGlobalVar,
1114 DataHeader::IncreaseGlobalArray },
1115 { ASSIGNOP_Decrease, DataHeader::DecreaseLocalVar, DataHeader::DecreaseGlobalVar,
1116 DataHeader::DecreaseGlobalArray },
1117 };
1118
1119 DataHeader BotscriptParser::getAssigmentDataHeader (AssignmentOperator op, Variable* var) 1157 DataHeader BotscriptParser::getAssigmentDataHeader (AssignmentOperator op, Variable* var)
1120 { 1158 {
1121 for (const auto& a : gAssignmentDataHeaders) 1159 for (const auto& a : AssignmentDataHeaders)
1122 { 1160 {
1123 if (a.op != op) 1161 if (a.op != op)
1124 continue; 1162 continue;
1125 1163
1126 if (var->isarray) 1164 if (var->isarray)
1134 1172
1135 error ("WTF: couldn't find data header for operator #%1", op); 1173 error ("WTF: couldn't find data header for operator #%1", op);
1136 return (DataHeader) 0; 1174 return (DataHeader) 0;
1137 } 1175 }
1138 1176
1139 // ============================================================================ 1177 // _________________________________________________________________________________________________
1140 // 1178 //
1141 // Parses an assignment. An assignment starts with a variable name, followed 1179 // Parses an assignment. An assignment starts with a variable name, followed
1142 // by an assignment operator, followed by an expression value. Expects current 1180 // by an assignment operator, followed by an expression value. Expects current
1143 // token to be the name of the variable, and expects the variable to be given. 1181 // token to be the name of the variable, and expects the variable to be given.
1144 // 1182 //
1191 retbuf->writeHeader (getAssigmentDataHeader (oper, var)); 1229 retbuf->writeHeader (getAssigmentDataHeader (oper, var));
1192 retbuf->writeDWord (var->index); 1230 retbuf->writeDWord (var->index);
1193 return retbuf; 1231 return retbuf;
1194 } 1232 }
1195 1233
1196 // ============================================================================ 1234 // _________________________________________________________________________________________________
1197 // 1235 //
1198 void BotscriptParser::pushScope (bool noreset) 1236 void BotscriptParser::pushScope (bool noreset)
1199 { 1237 {
1200 m_scopeCursor++; 1238 m_scopeCursor++;
1201 1239
1226 1264
1227 SCOPE(0).localVariables.clear(); 1265 SCOPE(0).localVariables.clear();
1228 SCOPE(0).globalVariables.clear(); 1266 SCOPE(0).globalVariables.clear();
1229 } 1267 }
1230 1268
1231 // ============================================================================ 1269 // _________________________________________________________________________________________________
1232 // 1270 //
1233 DataBuffer* BotscriptParser::parseExpression (DataType reqtype, bool fromhere) 1271 DataBuffer* BotscriptParser::parseExpression (DataType reqtype, bool fromhere)
1234 { 1272 {
1235 // hehe 1273 // hehe
1236 if (fromhere) 1274 if (fromhere)
1242 // The buffer will be destroyed once the function ends so we need to 1280 // The buffer will be destroyed once the function ends so we need to
1243 // clone it now. 1281 // clone it now.
1244 return expr.getResult()->buffer()->clone(); 1282 return expr.getResult()->buffer()->clone();
1245 } 1283 }
1246 1284
1247 // ============================================================================ 1285 // _________________________________________________________________________________________________
1248 // 1286 //
1249 DataBuffer* BotscriptParser::parseStatement() 1287 DataBuffer* BotscriptParser::parseStatement()
1250 { 1288 {
1251 // If it's a variable, expect assignment. 1289 // If it's a variable, expect assignment.
1252 if (m_lexer->next (Token::DollarSign)) 1290 if (m_lexer->next (Token::DollarSign))
1261 } 1299 }
1262 1300
1263 return null; 1301 return null;
1264 } 1302 }
1265 1303
1266 // ============================================================================ 1304 // _________________________________________________________________________________________________
1267 // 1305 //
1268 void BotscriptParser::addSwitchCase (DataBuffer* casebuffer) 1306 void BotscriptParser::addSwitchCase (DataBuffer* casebuffer)
1269 { 1307 {
1270 ScopeInfo* info = &SCOPE (0); 1308 ScopeInfo* info = &SCOPE (0);
1271 CaseInfo casedata; 1309 CaseInfo casedata;
1286 casedata.data = m_switchBuffer = new DataBuffer; 1324 casedata.data = m_switchBuffer = new DataBuffer;
1287 SCOPE(0).cases << casedata; 1325 SCOPE(0).cases << casedata;
1288 info->casecursor++; 1326 info->casecursor++;
1289 } 1327 }
1290 1328
1291 // ============================================================================ 1329 // _________________________________________________________________________________________________
1292 // 1330 //
1293 bool BotscriptParser::tokenIs (Token a) 1331 bool BotscriptParser::tokenIs (Token a)
1294 { 1332 {
1295 return (m_lexer->tokenType() == a); 1333 return (m_lexer->tokenType() == a);
1296 } 1334 }
1297 1335
1298 // ============================================================================ 1336 // _________________________________________________________________________________________________
1299 // 1337 //
1300 String BotscriptParser::getTokenString() 1338 String BotscriptParser::getTokenString()
1301 { 1339 {
1302 return m_lexer->token()->text; 1340 return m_lexer->token()->text;
1303 } 1341 }
1304 1342
1305 // ============================================================================ 1343 // _________________________________________________________________________________________________
1306 // 1344 //
1307 String BotscriptParser::describePosition() const 1345 String BotscriptParser::describePosition() const
1308 { 1346 {
1309 Lexer::TokenInfo* tok = m_lexer->token(); 1347 Lexer::TokenInfo* tok = m_lexer->token();
1310 return tok->file + ":" + String (tok->line) + ":" + String (tok->column); 1348 return tok->file + ":" + String (tok->line) + ":" + String (tok->column);
1311 } 1349 }
1312 1350
1313 // ============================================================================ 1351 // _________________________________________________________________________________________________
1352 //
1353 // Where are we writing to right now?
1314 // 1354 //
1315 DataBuffer* BotscriptParser::currentBuffer() 1355 DataBuffer* BotscriptParser::currentBuffer()
1316 { 1356 {
1317 if (m_switchBuffer != null) 1357 if (m_switchBuffer != null)
1318 return m_switchBuffer; 1358 return m_switchBuffer;
1324 return m_onenterBuffer; 1364 return m_onenterBuffer;
1325 1365
1326 return m_mainBuffer; 1366 return m_mainBuffer;
1327 } 1367 }
1328 1368
1329 // ============================================================================ 1369 // _________________________________________________________________________________________________
1330 // 1370 //
1331 void BotscriptParser::writeMemberBuffers() 1371 void BotscriptParser::writeMemberBuffers()
1332 { 1372 {
1333 // If there was no mainloop defined, write a dummy one now. 1373 // If there was no mainloop defined, write a dummy one now.
1334 if (m_gotMainLoop == false) 1374 if (m_gotMainLoop == false)
1348 1388
1349 // Next state definitely has no mainloop yet 1389 // Next state definitely has no mainloop yet
1350 m_gotMainLoop = false; 1390 m_gotMainLoop = false;
1351 } 1391 }
1352 1392
1353 // ============================================================================ 1393 // _________________________________________________________________________________________________
1354 // 1394 //
1355 // Write string table 1395 // Write string table
1356 // 1396 //
1357 void BotscriptParser::writeStringTable() 1397 void BotscriptParser::writeStringTable()
1358 { 1398 {
1368 // Write all strings 1408 // Write all strings
1369 for (int i = 0; i < stringcount; i++) 1409 for (int i = 0; i < stringcount; i++)
1370 m_mainBuffer->writeString (getStringTable()[i]); 1410 m_mainBuffer->writeString (getStringTable()[i]);
1371 } 1411 }
1372 1412
1373 // ============================================================================ 1413 // _________________________________________________________________________________________________
1374 // 1414 //
1375 // Write the compiled bytecode to a file 1415 // Write the compiled bytecode to a file
1376 // 1416 //
1377 void BotscriptParser::writeToFile (String outfile) 1417 void BotscriptParser::writeToFile (String outfile)
1378 { 1418 {
1392 fwrite (m_mainBuffer->buffer(), 1, m_mainBuffer->writtenSize(), fp); 1432 fwrite (m_mainBuffer->buffer(), 1, m_mainBuffer->writtenSize(), fp);
1393 print ("-- %1 byte%s1 written to %2\n", m_mainBuffer->writtenSize(), outfile); 1433 print ("-- %1 byte%s1 written to %2\n", m_mainBuffer->writtenSize(), outfile);
1394 fclose (fp); 1434 fclose (fp);
1395 } 1435 }
1396 1436
1397 // ============================================================================ 1437 // _________________________________________________________________________________________________
1398 // 1438 //
1399 // Attempt to find the variable by the given name. Looks from current scope 1439 // Attempt to find the variable by the given name. Looks from current scope
1400 // downwards. 1440 // downwards.
1401 // 1441 //
1402 Variable* BotscriptParser::findVariable (const String& name) 1442 Variable* BotscriptParser::findVariable (const String& name)
1411 } 1451 }
1412 1452
1413 return null; 1453 return null;
1414 } 1454 }
1415 1455
1416 // ============================================================================ 1456 // _________________________________________________________________________________________________
1417 // 1457 //
1418 // Is the parser currently in global state (i.e. not in any specific state)? 1458 // Is the parser currently in global state (i.e. not in any specific state)?
1419 // 1459 //
1420 bool BotscriptParser::isInGlobalState() const 1460 bool BotscriptParser::isInGlobalState() const
1421 { 1461 {
1422 return m_currentState.isEmpty(); 1462 return m_currentState.isEmpty();
1423 } 1463 }
1424 1464
1425 // ============================================================================ 1465 // _________________________________________________________________________________________________
1426 // 1466 //
1427 void BotscriptParser::suggestHighestVarIndex (bool global, int index) 1467 void BotscriptParser::suggestHighestVarIndex (bool global, int index)
1428 { 1468 {
1429 if (global) 1469 if (global)
1430 m_highestGlobalVarIndex = max (m_highestGlobalVarIndex, index); 1470 m_highestGlobalVarIndex = max (m_highestGlobalVarIndex, index);
1431 else 1471 else
1432 m_highestStateVarIndex = max (m_highestStateVarIndex, index); 1472 m_highestStateVarIndex = max (m_highestStateVarIndex, index);
1433 } 1473 }
1434 1474
1435 // ============================================================================ 1475 // _________________________________________________________________________________________________
1436 // 1476 //
1437 int BotscriptParser::getHighestVarIndex (bool global) 1477 int BotscriptParser::getHighestVarIndex (bool global)
1438 { 1478 {
1439 if (global) 1479 if (global)
1440 return m_highestGlobalVarIndex; 1480 return m_highestGlobalVarIndex;

Mercurial Repository: botc

mercurial