comparison: src/Parser.cc
src/Parser.cc
- changeset 98
- ea02b78a737a
- parent 97
- 49e38433b9fd
- child 99
- 44c0c7f31ae8
equal
deleted
inserted
replaced
| 97:49e38433b9fd | 98:ea02b78a737a |
|---|---|
| 1075 tkAssign, | 1075 tkAssign, |
| 1076 tkAddAssign, | 1076 tkAddAssign, |
| 1077 tkSubAssign, | 1077 tkSubAssign, |
| 1078 tkMultiplyAssign, | 1078 tkMultiplyAssign, |
| 1079 tkDivideAssign, | 1079 tkDivideAssign, |
| 1080 tkModulusAssign | 1080 tkModulusAssign, |
| 1081 tkDoublePlus, | |
| 1082 tkDoubleMinus, | |
| 1081 }; | 1083 }; |
| 1082 | 1084 |
| 1083 mLexer->MustGetAnyOf (tokens); | 1085 mLexer->MustGetAnyOf (tokens); |
| 1084 | 1086 |
| 1085 switch (mLexer->GetTokenType()) | 1087 switch (mLexer->GetTokenType()) |
| 1088 case tkAddAssign: return EAssignAdd; | 1090 case tkAddAssign: return EAssignAdd; |
| 1089 case tkSubAssign: return EAssignSub; | 1091 case tkSubAssign: return EAssignSub; |
| 1090 case tkMultiplyAssign: return EAssignMul; | 1092 case tkMultiplyAssign: return EAssignMul; |
| 1091 case tkDivideAssign: return EAssignDiv; | 1093 case tkDivideAssign: return EAssignDiv; |
| 1092 case tkModulusAssign: return EAssignMod; | 1094 case tkModulusAssign: return EAssignMod; |
| 1095 case tkDoublePlus: return EAssignIncrement; | |
| 1096 case tkDoubleMinus: return EAssignDecrement; | |
| 1093 default: break; | 1097 default: break; |
| 1094 } | 1098 } |
| 1095 | 1099 |
| 1096 assert (false); | 1100 assert (false); |
| 1097 return (EAssignmentOperator) 0; | 1101 return (EAssignmentOperator) 0; |
| 1103 { | 1107 { |
| 1104 if (var->IsGlobal()) | 1108 if (var->IsGlobal()) |
| 1105 { | 1109 { |
| 1106 switch (op) | 1110 switch (op) |
| 1107 { | 1111 { |
| 1108 case EAssign: return dhAssignGlobalVar; | 1112 case EAssign: return dhAssignGlobalVar; |
| 1109 case EAssignAdd: return dhAddGlobalVar; | 1113 case EAssignAdd: return dhAddGlobalVar; |
| 1110 case EAssignSub: return dhSubtractGlobalVar; | 1114 case EAssignSub: return dhSubtractGlobalVar; |
| 1111 case EAssignMul: return dhMultiplyGlobalVar; | 1115 case EAssignMul: return dhMultiplyGlobalVar; |
| 1112 case EAssignDiv: return dhDivideGlobalVar; | 1116 case EAssignDiv: return dhDivideGlobalVar; |
| 1113 case EAssignMod: return dhModGlobalVar; | 1117 case EAssignMod: return dhModGlobalVar; |
| 1118 case EAssignIncrement: return dhIncreaseGlobalVar; | |
| 1119 case EAssignDecrement: return dhDecreaseGlobalVar; | |
| 1114 } | 1120 } |
| 1115 } | 1121 } |
| 1116 | 1122 |
| 1117 switch (op) | 1123 switch (op) |
| 1118 { | 1124 { |
| 1119 case EAssign: return dhAssignLocalVar; | 1125 case EAssign: return dhAssignLocalVar; |
| 1120 case EAssignAdd: return dhAddLocalVar; | 1126 case EAssignAdd: return dhAddLocalVar; |
| 1121 case EAssignSub: return dhSubtractLocalVar; | 1127 case EAssignSub: return dhSubtractLocalVar; |
| 1122 case EAssignMul: return dhMultiplyLocalVar; | 1128 case EAssignMul: return dhMultiplyLocalVar; |
| 1123 case EAssignDiv: return dhDivideLocalVar; | 1129 case EAssignDiv: return dhDivideLocalVar; |
| 1124 case EAssignMod: return dhModLocalVar; | 1130 case EAssignMod: return dhModLocalVar; |
| 1131 case EAssignIncrement: return dhIncreaseLocalVar; | |
| 1132 case EAssignDecrement: return dhDecreaseLocalVar; | |
| 1125 } | 1133 } |
| 1126 | 1134 |
| 1127 assert (false); | 1135 assert (false); |
| 1128 return (EDataHeader) 0; | 1136 return (EDataHeader) 0; |
| 1129 } | 1137 } |
| 1136 // | 1144 // |
| 1137 DataBuffer* BotscriptParser::ParseAssignment (ScriptVariable* var) | 1145 DataBuffer* BotscriptParser::ParseAssignment (ScriptVariable* var) |
| 1138 { | 1146 { |
| 1139 // Get an operator | 1147 // Get an operator |
| 1140 EAssignmentOperator oper = ParseAssignmentOperator(); | 1148 EAssignmentOperator oper = ParseAssignmentOperator(); |
| 1149 DataBuffer* retbuf = new DataBuffer; | |
| 1141 | 1150 |
| 1142 if (mCurrentMode == ETopLevelMode) | 1151 if (mCurrentMode == ETopLevelMode) |
| 1143 Error ("can't alter variables at top level"); | 1152 Error ("can't alter variables at top level"); |
| 1144 | 1153 |
| 1145 // Parse the right operand | 1154 // Parse the right operand |
| 1146 DataBuffer* retbuf = new DataBuffer; | 1155 if (oper != EAssignIncrement && oper != EAssignDecrement) |
| 1147 DataBuffer* expr = ParseExpression (var->type); | 1156 { |
| 1157 DataBuffer* expr = ParseExpression (var->type); | |
| 1158 retbuf->MergeAndDestroy (expr); | |
| 1159 } | |
| 1148 | 1160 |
| 1149 #if 0 | 1161 #if 0 |
| 1150 // <<= and >>= do not have data headers. Solution: expand them. | 1162 // <<= and >>= do not have data headers. Solution: expand them. |
| 1151 // a <<= b -> a = a << b | 1163 // a <<= b -> a = a << b |
| 1152 // a >>= b -> a = a >> b | 1164 // a >>= b -> a = a >> b |
| 1153 if (oper == OPER_ASSIGNLEFTSHIFT || oper == OPER_ASSIGNRIGHTSHIFT) | 1165 retbuf->WriteDWord (var->IsGlobal() ? dhPushGlobalVar : dhPushLocalVar); |
| 1154 { | 1166 retbuf->WriteDWord (var->index); |
| 1155 retbuf->WriteDWord (var->IsGlobal() ? dhPushGlobalVar : dhPushLocalVar); | 1167 retbuf->MergeAndDestroy (expr); |
| 1156 retbuf->WriteDWord (var->index); | 1168 retbuf->WriteDWord ((oper == OPER_ASSIGNLEFTSHIFT) ? dhLeftShift : dhRightShift); |
| 1157 retbuf->MergeAndDestroy (expr); | 1169 retbuf->WriteDWord (var->IsGlobal() ? dhAssignGlobalVar : dhAssignLocalVar); |
| 1158 retbuf->WriteDWord ((oper == OPER_ASSIGNLEFTSHIFT) ? dhLeftShift : dhRightShift); | 1170 retbuf->WriteDWord (var->index); |
| 1159 retbuf->WriteDWord (var->IsGlobal() ? dhAssignGlobalVar : dhAssignLocalVar); | |
| 1160 retbuf->WriteDWord (var->index); | |
| 1161 } | |
| 1162 else | |
| 1163 { | |
| 1164 #endif | 1171 #endif |
| 1165 retbuf->MergeAndDestroy (expr); | 1172 |
| 1166 EDataHeader dh = GetAssigmentDataHeader (oper, var); | 1173 EDataHeader dh = GetAssigmentDataHeader (oper, var); |
| 1167 retbuf->WriteDWord (dh); | 1174 retbuf->WriteDWord (dh); |
| 1168 retbuf->WriteDWord (var->index); | 1175 retbuf->WriteDWord (var->index); |
| 1169 #if 0 | |
| 1170 } | |
| 1171 #endif | |
| 1172 | |
| 1173 return retbuf; | 1176 return retbuf; |
| 1174 } | 1177 } |
| 1175 | 1178 |
| 1176 // ============================================================================ | 1179 // ============================================================================ |
| 1177 // | 1180 // |
| 1365 { | 1368 { |
| 1366 // Substitute the placeholder with the mark position | 1369 // Substitute the placeholder with the mark position |
| 1367 for (int i = 0; i < 4; ++i) | 1370 for (int i = 0; i < 4; ++i) |
| 1368 mMainBuffer->GetBuffer()[ref->pos + i] = (ref->target->pos >> (8 * i)) & 0xFF; | 1371 mMainBuffer->GetBuffer()[ref->pos + i] = (ref->target->pos >> (8 * i)) & 0xFF; |
| 1369 | 1372 |
| 1370 Print ("reference at %1 resolved to mark at %2\n", ref->pos, ref->target->pos); | 1373 // Print ("reference at %1 resolved to mark at %2\n", ref->pos, ref->target->pos); |
| 1371 } | 1374 } |
| 1372 | 1375 |
| 1373 // Then, dump the main buffer to the file | 1376 // Then, dump the main buffer to the file |
| 1374 fwrite (mMainBuffer->GetBuffer(), 1, mMainBuffer->GetWrittenSize(), fp); | 1377 fwrite (mMainBuffer->GetBuffer(), 1, mMainBuffer->GetWrittenSize(), fp); |
| 1375 Print ("-- %1 byte%s1 written to %2\n", mMainBuffer->GetWrittenSize(), outfile); | 1378 Print ("-- %1 byte%s1 written to %2\n", mMainBuffer->GetWrittenSize(), outfile); |
