Lines Matching refs:token
137 Token token = lexer_.PeekToken(false);
138 if (token.kind == TokenType::COMMENT_BLOCK) {
140 return token.value;
149 Token token = lexer_.PeekToken();
150 if (token.kind != TokenType::PACKAGE) {
151 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected 'package'"));
157 token = lexer_.PeekToken();
158 if (token.kind != TokenType::ID) {
159 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected name of package"));
163 std::string packageName = token.value;
167 token = lexer_.PeekToken();
168 if (token.kind != TokenType::SEMICOLON) {
169 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ';'"));
215 Token token = lexer_.PeekToken();
216 if (token.kind != TokenType::INTERFACE_TOKEN) {
217 LogError(__func__, __LINE__, token, StringHelper::Format("expected 'interface token'"));
222 token = lexer_.PeekToken();
223 if (token.kind != TokenType::ID) {
224 LogError(__func__, __LINE__, token, StringHelper::Format("expected name of interface_token before '%s' token",
225 token.value.c_str()));
229 std::string interfaceToken = token.value;
232 token = lexer_.PeekToken();
233 if (token.kind != TokenType::SEMICOLON) {
234 LogError(__func__, __LINE__, token, StringHelper::Format("expected ';' before '%s' token",
235 token.value.c_str()));
241 LogError(__func__, __LINE__, token, StringHelper::Format("interface_token name is not expected."));
251 Token token = lexer_.PeekToken();
252 if (token.kind != TokenType::SUPPORT_DELEGATOR) {
253 LogError(__func__, __LINE__, token, StringHelper::Format("expected 'support_delegator'"));
258 token = lexer_.PeekToken();
259 if (token.kind != TokenType::ID) {
260 LogError(__func__, __LINE__, token, StringHelper::Format("expected name of suport_delegator before '%s' token",
261 token.value.c_str()));
265 std::string supportDelegator = token.value;
268 token = lexer_.PeekToken();
269 if (token.kind != TokenType::SEMICOLON) {
270 LogError(__func__, __LINE__, token, StringHelper::Format("expected ';' before '%s' token",
271 token.value.c_str()));
277 LogError(__func__, __LINE__, token, StringHelper::Format("support_delegator name is not expected."));
287 Token token = lexer_.PeekToken();
288 TokenType kind = token.kind;
292 token = lexer_.PeekToken();
293 if (token.kind != TokenType::ID) {
294 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected identifier"));
296 token = lexer_.PeekToken();
308 token = lexer_.PeekToken();
309 if (token.kind != TokenType::SEMICOLON) {
310 LogError(__func__, __LINE__, token, StringHelper::Format("expected ';' before '%s'.", token.value.c_str()));
320 Token token = lexer_.PeekToken();
321 std::string importName = token.value;
323 LogError(__func__, __LINE__, token, std::string("import name is empty"));
328 LogError(__func__, __LINE__, token, std::string("import name is illegal"));
335 LogError(__func__, __LINE__, token,
341 LogError(__func__, __LINE__, token,
347 LogError(__func__, __LINE__, token, StringHelper::Format("multiple import of '%s'", importName.c_str()));
353 Token token = lexer_.PeekToken();
354 std::string seqName = token.value;
356 LogError(__func__, __LINE__, token, std::string("sequenceable name is empty"));
381 Token token = lexer_.PeekToken();
382 switch (token.kind) {
399 LogError(__func__, __LINE__, token, StringHelper::Format("'%s' is not expected", token.value.c_str()));
410 Token token = lexer_.PeekToken();
411 switch (token.kind) {
425 LogError(__func__, __LINE__, token, StringHelper::Format("'%s' is not expected", token.value.c_str()));
426 lexer_.SkipToken(token.kind);
435 Token token = lexer_.PeekToken();
436 if (token.kind != TokenType::BRACKETS_LEFT) {
437 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '['"));
438 lexer_.SkipToken(token.kind);
444 token = lexer_.PeekToken();
445 while (token.kind != TokenType::BRACKETS_RIGHT && token.kind != TokenType::END_OF_FILE) {
450 token = lexer_.PeekToken();
451 if (token.kind == TokenType::COMMA) {
453 token = lexer_.PeekToken();
457 if (token.kind == TokenType::BRACKETS_RIGHT) {
460 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ',' or ']'"));
471 Token token = lexer_.PeekToken();
472 switch (token.kind) {
478 if (attrs.find(token) != attrs.end()) {
479 LogError(__func__, __LINE__, token, StringHelper::Format("Duplicate declared attributes '%s'",
480 token.value.c_str()));
482 attrs.insert(token);
488 if (attrs.find(token) != attrs.end()) {
489 LogError(__func__, __LINE__, token, StringHelper::Format("Duplicate declared attributes cacheable"));
491 if (!lexer_.ReadCacheableTime(token)) {
492 LogError(__func__, __LINE__, token, StringHelper::Format("Cacheable time parse failed"));
494 attrs.insert(token);
500 ParseAttrUnitFreezecontrol(attrs, token);
504 LogError(__func__, __LINE__, token, StringHelper::Format("'%s' is a illegal attribute",
505 token.value.c_str()));
511 void Parser::ParseAttrUnitFreezecontrol(AttrSet &attrs, Token &token)
513 if (attrs.find(token) != attrs.end()) {
514 LogError(__func__, __LINE__, token, StringHelper::Format("Duplicate declared attr freezecontrol"));
516 attrs.insert(token);
518 token = lexer_.PeekToken();
519 if (token.value == "]") {
520 LogError(__func__, __LINE__, token, StringHelper::Format("freezecontrol attr cannot be empty"));
521 } else if (token.kind == TokenType::ID) {
522 freezecontrolAttr_ = token.value;
535 Token token = lexer_.PeekToken();
536 if (token.kind != TokenType::ID) {
537 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected interface name"));
539 size_t index = token.value.rfind('.');
541 interfaceType->SetName(StringHelper::SubStr(token.value, index + 1));
542 interfaceType->SetNamespace(ast_->ParseNamespace(token.value));
544 interfaceType->SetName(token.value);
551 CheckInterfaceAttr(interfaceType, token);
553 token = lexer_.PeekToken();
554 if (token.kind == TokenType::SEMICOLON) {
558 LogError(__func__, __LINE__, token, StringHelper::Format(
603 void Parser::CheckInterfaceAttr(const AutoPtr<ASTInterfaceType> &interface, Token token)
625 LogError(__func__, __LINE__, token, StringHelper::Format("the system option is '%s', but the '%s' interface "
632 Token token = lexer_.PeekToken();
637 LogError(__func__, __LINE__, token, std::string("interface forward declaration should not have attribute."));
643 Token token = lexer_.PeekToken();
645 if (token.kind != TokenType::BRACES_LEFT) {
646 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '{'"));
652 token = lexer_.PeekToken();
653 while (token.kind != TokenType::BRACES_RIGHT && token.kind != TokenType::END_OF_FILE) {
656 token = lexer_.PeekToken();
660 token = lexer_.PeekToken();
661 if (token.kind != TokenType::BRACES_RIGHT) {
662 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '}'"));
668 token = lexer_.PeekToken();
669 if (token.kind == TokenType::SEMICOLON) {
686 Token token = lexer_.PeekToken();
687 if (token.kind != TokenType::ID) {
688 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected method name"));
690 method->SetName(token.value);
699 token = lexer_.PeekToken();
700 if (token.kind != TokenType::SEMICOLON) {
701 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ';'"));
727 Token token = lexer_.PeekToken();
728 if (token.kind == TokenType::ID && ast_->FindType(token.value) == nullptr) {
732 if (CheckBasicType(token) || CheckUserDefType(token) || token.kind == TokenType::LIST ||
733 token.kind == TokenType::MAP || token.kind == TokenType::SMQ) {
824 Token token = lexer_.PeekToken();
825 if (token.kind != TokenType::PARENTHESES_LEFT) {
826 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '('"));
832 token = lexer_.PeekToken();
833 if (token.kind == TokenType::PARENTHESES_RIGHT) {
839 while (token.kind != TokenType::PARENTHESES_RIGHT && token.kind != TokenType::END_OF_FILE) {
842 LogError(__func__, __LINE__, token, StringHelper::Format("the '%s' parameter of '%s' method "
848 token = lexer_.PeekToken();
849 if (token.kind == TokenType::COMMA) {
851 token = lexer_.PeekToken();
852 if (token.kind == TokenType::PARENTHESES_RIGHT) {
853 LogError(__func__, __LINE__, token, std::string(""));
859 if (token.kind == TokenType::PARENTHESES_RIGHT) {
862 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ',' or ')'"));
876 Token token = lexer_.PeekToken();
877 if (token.kind != TokenType::ID) {
878 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected param name"));
880 paramName = token.value;
903 Token token = lexer_.PeekToken();
904 while (token.kind != TokenType::BRACKETS_RIGHT && token.kind != TokenType::END_OF_FILE) {
905 SetParamAttrVal(token, attr);
908 token = lexer_.PeekToken();
909 if (token.kind == TokenType::COMMA) {
911 token = lexer_.PeekToken();
916 if (token.kind != TokenType::BRACKETS_RIGHT) {
917 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ']'"));
918 while (token.kind != TokenType::COMMA && token.kind != TokenType::PARENTHESES_RIGHT &&
919 token.kind != TokenType::END_OF_FILE) {
921 token = lexer_.PeekToken();
936 Token token = lexer_.PeekToken();
937 if (token.kind != TokenType::BRACKETS_LEFT) {
938 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '['"));
939 while (token.kind != TokenType::COMMA && token.kind != TokenType::PARENTHESES_RIGHT &&
940 token.kind != TokenType::END_OF_FILE) {
942 token = lexer_.PeekToken();
950 void Parser::SetParamAttrVal(Token token, AutoPtr<ASTParamAttr> attr)
952 switch (token.kind) {
963 LogErrorBeforeToken(__func__, __LINE__, token,
973 Token token = lexer_.PeekToken();
974 if (CheckBasicType(token)) {
976 } else if (CheckUserDefType(token)) {
979 switch (token.kind) {
990 LogError(__func__, __LINE__, token, StringHelper::Format("'%s' of type is illegal",
991 token.value.c_str()));
997 LogError(__func__, __LINE__, token, std::string("this type was not declared in this scope"));
999 if (!CheckType(token, type)) {
1009 bool Parser::CheckBasicType(Token token)
1011 switch (token.kind) {
1037 Token token = lexer_.PeekToken();
1038 if (token.kind == TokenType::UNSIGNED) {
1041 type = ast_->FindType(token.value);
1053 Token token = lexer_.PeekToken();
1054 switch (token.kind) {
1059 type = ast_->FindType(namePrefix + " " + token.value);
1063 LogError(__func__, __LINE__, token,
1064 StringHelper::Format("'unsigned %s' was not declared in the idl file", token.value.c_str()));
1074 Token token = lexer_.PeekToken();
1075 if (token.kind != TokenType::BRACKETS_RIGHT) {
1076 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ']'"));
1099 Token token = lexer_.PeekToken();
1100 if (token.kind != TokenType::ANGLE_BRACKETS_LEFT) {
1101 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '<'"));
1112 token = lexer_.PeekToken();
1113 if (token.kind != TokenType::ANGLE_BRACKETS_RIGHT) {
1114 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '>'"));
1133 Token token = lexer_.PeekToken();
1134 if (token.kind != TokenType::ANGLE_BRACKETS_LEFT) {
1135 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '<'"));
1142 LogError(__func__, __LINE__, token, StringHelper::Format("key type '%s' is illegal", token.value.c_str()));
1147 token = lexer_.PeekToken();
1148 if (token.kind != TokenType::COMMA) {
1149 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ','"));
1156 LogError(__func__, __LINE__, token, StringHelper::Format("value type '%s' is illegal", token.value.c_str()));
1161 token = lexer_.PeekToken();
1162 if (token.kind != TokenType::ANGLE_BRACKETS_RIGHT) {
1163 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '>'"));
1183 Token token = lexer_.PeekToken();
1184 if (token.kind != TokenType::ANGLE_BRACKETS_LEFT) {
1185 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '<'"));
1196 token = lexer_.PeekToken();
1197 if (token.kind != TokenType::ANGLE_BRACKETS_RIGHT) {
1198 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '>'"));
1210 bool Parser::CheckUserDefType(Token token)
1212 switch (token.kind) {
1226 Token token = lexer_.GetToken();
1227 if (token.kind == TokenType::ID) {
1228 return ast_->FindType(token.value);
1231 token = lexer_.PeekToken();
1232 if (token.kind != TokenType::ID) {
1233 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected identifier"));
1237 AutoPtr<ASTType> type = ast_->FindType(token.value);
1249 Token token = lexer_.PeekToken();
1250 if (token.kind != TokenType::ID) {
1251 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected enum type name"));
1254 enumType->SetName(token.value);
1257 token = lexer_.PeekToken();
1258 if (token.kind == TokenType::COLON || token.kind == TokenType::BRACES_LEFT) {
1261 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ':' or '{'"));
1265 token = lexer_.PeekToken();
1266 if (token.kind != TokenType::BRACES_RIGHT) {
1267 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '}'"));
1273 token = lexer_.PeekToken();
1274 if (token.kind != TokenType::SEMICOLON) {
1275 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ';'"));
1287 Token token = lexer_.PeekToken();
1289 if (token.kind != TokenType::COLON) {
1293 token = lexer_.PeekToken();
1308 LogError(__func__, __LINE__, token, std::string("illegal base type of enum"));
1315 token = lexer_.PeekToken();
1316 if (token.kind != TokenType::BRACES_LEFT) {
1317 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '{'"));
1326 Token token = lexer_.GetToken();
1327 AutoPtr<ASTEnumValue> enumValue = new ASTEnumValue(token.value);
1329 token = lexer_.PeekToken();
1330 if (token.kind == TokenType::ASSIGN) {
1340 token = lexer_.PeekToken();
1341 if (token.kind == TokenType::COMMA) {
1346 if (token.kind != TokenType::BRACES_RIGHT) {
1347 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ',' or '}'"));
1358 Token token = lexer_.PeekToken();
1359 if (token.kind != TokenType::ID) {
1360 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected struct name"));
1362 structType->SetName(token.value);
1366 token = lexer_.PeekToken();
1367 if (token.kind == TokenType::COLON) {
1370 } else if (token.kind != TokenType::BRACES_LEFT) {
1371 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '{'"));
1378 token = lexer_.PeekToken();
1379 if (token.kind != TokenType::BRACES_RIGHT) {
1380 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '}'"));
1385 token = lexer_.PeekToken();
1386 if (token.kind != TokenType::SEMICOLON) {
1387 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ';'"));
1399 Token token = lexer_.PeekToken();
1402 LogError(__func__, __LINE__, token, std::string("expected base type name before '{' token"));
1407 LogError(__func__, __LINE__, token, StringHelper::Format("illegal base type of struct: '%s'",
1412 token = lexer_.PeekToken();
1413 if (token.kind != TokenType::BRACES_LEFT) {
1414 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '{'"));
1422 Token token = lexer_.PeekToken();
1423 while (token.kind != TokenType::BRACES_RIGHT && token.kind != TokenType::END_OF_FILE) {
1427 token = lexer_.PeekToken();
1431 token = lexer_.PeekToken();
1432 if (token.kind != TokenType::ID) {
1433 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected member name"));
1435 token = lexer_.PeekToken();
1440 std::string memberName = token.value;
1443 token = lexer_.PeekToken();
1444 if (token.kind == TokenType::SEMICOLON) {
1446 token = lexer_.PeekToken();
1450 if (token.kind != TokenType::BRACES_RIGHT) {
1451 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ',' or '}'"));
1462 Token token = lexer_.PeekToken();
1463 if (token.kind != TokenType::ID) {
1464 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected struct name"));
1466 unionType->SetName(token.value);
1470 token = lexer_.PeekToken();
1471 if (token.kind != TokenType::BRACES_LEFT) {
1472 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '{'"));
1479 token = lexer_.PeekToken();
1480 if (token.kind != TokenType::BRACES_RIGHT) {
1481 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected '}'"));
1486 token = lexer_.PeekToken();
1487 if (token.kind != TokenType::SEMICOLON) {
1488 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ';'"));
1499 Token token = lexer_.PeekToken();
1500 while (token.kind != TokenType::BRACES_RIGHT && token.kind != TokenType::END_OF_FILE) {
1504 token = lexer_.PeekToken();
1508 token = lexer_.PeekToken();
1509 if (token.kind != TokenType::ID) {
1510 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected member name"));
1512 token = lexer_.PeekToken();
1517 std::string memberName = token.value;
1519 LogError(__func__, __LINE__, token, StringHelper::Format(
1520 "union not support this type or name of member duplicate '%s'", token.value.c_str()));
1523 token = lexer_.PeekToken();
1524 if (token.kind == TokenType::SEMICOLON) {
1526 token = lexer_.PeekToken();
1530 if (token.kind != TokenType::BRACES_RIGHT) {
1531 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected ',' or '}'"));
1557 for (const auto &token : attrs) {
1558 switch (token.kind) {
1569 LogError(__func__, __LINE__, token, StringHelper::Format("invalid attribute '%s' for type decl",
1570 token.value.c_str()));
1593 Token token = lexer_.PeekToken();
1594 while (token.kind == TokenType::AND) {
1602 token = lexer_.PeekToken();
1610 Token token = lexer_.PeekToken();
1611 while (token.kind == TokenType::XOR) {
1619 token = lexer_.PeekToken();
1627 Token token = lexer_.PeekToken();
1628 while (token.kind == TokenType::OR) {
1636 token = lexer_.PeekToken();
1644 Token token = lexer_.PeekToken();
1645 while (token.kind == TokenType::LEFT_SHIFT || token.kind == TokenType::RIGHT_SHIFT) {
1647 BinaryOpKind op = (token.kind == TokenType::LEFT_SHIFT) ? BinaryOpKind::LSHIFT : BinaryOpKind::RSHIFT;
1654 token = lexer_.PeekToken();
1662 Token token = lexer_.PeekToken();
1663 while (token.kind == TokenType::ADD || token.kind == TokenType::SUB) {
1665 BinaryOpKind op = (token.kind == TokenType::ADD) ? BinaryOpKind::ADD : BinaryOpKind::SUB;
1672 token = lexer_.PeekToken();
1680 Token token = lexer_.PeekToken();
1682 token.kind == TokenType::STAR || token.kind == TokenType::SLASH || token.kind == TokenType::PERCENT_SIGN) {
1685 if (token.kind == TokenType::SLASH) {
1687 } else if (token.kind == TokenType::PERCENT_SIGN) {
1696 token = lexer_.PeekToken();
1703 Token token = lexer_.PeekToken();
1704 switch (token.kind) {
1711 if (token.kind == TokenType::SUB) {
1713 } else if (token.kind == TokenType::TILDE) {
1727 Token token = lexer_.PeekToken();
1728 switch (token.kind) {
1732 token = lexer_.PeekToken();
1733 if (token.kind != TokenType::PARENTHESES_RIGHT) {
1734 LogErrorBeforeToken(__func__, __LINE__, token, StringHelper::Format("expected ')'"));
1745 LogError(__func__, __LINE__, token, std::string("this expression is not supported"));
1751 LogError(__func__, __LINE__, token, std::string("this expression is not supported"));
1759 Token token = lexer_.GetToken();
1760 if (!CheckNumber(token.value)) {
1761 LogError(__func__, __LINE__, token, StringHelper::Format("unknown integer number: '%s'", token.value.c_str()));
1766 expr->value_ = token.value;
1772 Token token = lexer_.GetToken();
1773 if (!g_currentEnum->HasMember(token.value)) {
1774 LogError(__func__, __LINE__, token, StringHelper::Format("unknown enum member: '%s'", token.value.c_str()));
1779 expr->value_ = token.value;
1792 bool Parser::CheckType(const Token &token, const AutoPtr<ASTType> &type)
1794 if ((type == nullptr) || !CheckTypeByMode(token, type)) {
1800 LogError(__func__, __LINE__, token, StringHelper::Format("The %s type is not supported by c language.",
1815 LogError(__func__, __LINE__, token, StringHelper::Format("The '%s' type is not supported "
1826 bool Parser::CheckTypeByMode(const Token &token, const AutoPtr<ASTType> &type)
1829 LogError(__func__, __LINE__, token, StringHelper::Format("The %s type is only supported by passthrough mode.",
1844 LogError(__func__, __LINE__, token,
1925 Token token = lexer_.PeekToken();
1926 if (token.kind != TokenType::EXTENDS) {
1930 token = lexer_.PeekToken();
1931 if (token.kind != TokenType::ID) {
1932 LogErrorBeforeToken(__func__, __LINE__, token, std::string("expected extends interface name"));
1942 Token token = lexer_.PeekToken();
1943 std::string extendsInterfaceName = token.value;
1945 LogError(__func__, __LINE__, token, std::string("extends interface name is empty"));
1949 LogError(__func__, __LINE__, token, std::string("extends interface name is illegal"));
1955 LogError(__func__, __LINE__, token, StringHelper::Format("can not find idl file by extends interface "
1960 LogError(__func__, __LINE__, token, StringHelper::Format(
1965 LogError(__func__, __LINE__, token,
1970 LogError(__func__, __LINE__, token, StringHelper::Format("multiple extends of '%s'",