| /******************************************************************************* |
| * Copyright (c) 2006, 2015 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *********************************************************************************/ |
| |
| // This file was generated by LPG |
| |
| package org.eclipse.cdt.internal.core.dom.lrparser.gpp; |
| |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.cdt.core.dom.ast.IASTBinaryExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTCompletionNode; |
| import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit; |
| import org.eclipse.cdt.core.dom.ast.IASTTypeIdExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTBinaryExpression; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTCastExpression; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTLiteralExpression; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTypeIdExpression; |
| import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTUnaryExpression; |
| import org.eclipse.cdt.core.dom.ast.gnu.cpp.IGPPASTExplicitTemplateInstantiation; |
| import org.eclipse.cdt.core.dom.lrparser.CPreprocessorAdapter; |
| import org.eclipse.cdt.core.dom.lrparser.IDOMTokenMap; |
| import org.eclipse.cdt.core.dom.lrparser.IParser; |
| import org.eclipse.cdt.core.dom.lrparser.ITokenCollector; |
| import org.eclipse.cdt.core.dom.lrparser.action.ITokenStream; |
| import org.eclipse.cdt.core.dom.lrparser.action.ScopedStack; |
| import org.eclipse.cdt.core.dom.lrparser.action.gnu.GNUBuildASTParserAction; |
| import org.eclipse.cdt.core.dom.lrparser.action.gnu.GPPBuildASTParserAction; |
| import org.eclipse.cdt.core.dom.lrparser.action.gnu.GPPSecondaryParserFactory; |
| import org.eclipse.cdt.core.dom.lrparser.lpgextensions.FixedBacktrackingParser; |
| import org.eclipse.cdt.core.dom.parser.IBuiltinBindingsProvider; |
| import org.eclipse.cdt.core.index.IIndex; |
| import org.eclipse.cdt.core.parser.IScanner; |
| import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPNodeFactory; |
| |
| import lpg.lpgjavaruntime.BadParseException; |
| import lpg.lpgjavaruntime.BadParseSymFileException; |
| import lpg.lpgjavaruntime.DiagnoseParser; |
| import lpg.lpgjavaruntime.ErrorToken; |
| import lpg.lpgjavaruntime.IToken; |
| import lpg.lpgjavaruntime.LexStream; |
| import lpg.lpgjavaruntime.Monitor; |
| import lpg.lpgjavaruntime.NotBacktrackParseTableException; |
| import lpg.lpgjavaruntime.NullExportedSymbolsException; |
| import lpg.lpgjavaruntime.NullTerminalSymbolsException; |
| import lpg.lpgjavaruntime.ParseErrorCodes; |
| import lpg.lpgjavaruntime.ParseTable; |
| import lpg.lpgjavaruntime.PrsStream; |
| import lpg.lpgjavaruntime.RuleAction; |
| import lpg.lpgjavaruntime.UndefinedEofSymbolException; |
| import lpg.lpgjavaruntime.UnimplementedTerminalsException; |
| |
| public class GPPParser extends PrsStream |
| implements RuleAction, ITokenStream, ITokenCollector, IParser<IASTTranslationUnit> |
| |
| { |
| private static ParseTable prs = new GPPParserprs(); |
| private FixedBacktrackingParser btParser; |
| |
| public FixedBacktrackingParser getParser() { |
| return btParser; |
| } |
| |
| private void setResult(Object object) { |
| btParser.setSym1(object); |
| } |
| |
| public Object getRhsSym(int i) { |
| return btParser.getSym(i); |
| } |
| |
| public int getRhsTokenIndex(int i) { |
| return btParser.getToken(i); |
| } |
| |
| public IToken getRhsIToken(int i) { |
| return super.getIToken(getRhsTokenIndex(i)); |
| } |
| |
| public int getRhsFirstTokenIndex(int i) { |
| return btParser.getFirstToken(i); |
| } |
| |
| public IToken getRhsFirstIToken(int i) { |
| return super.getIToken(getRhsFirstTokenIndex(i)); |
| } |
| |
| public int getRhsLastTokenIndex(int i) { |
| return btParser.getLastToken(i); |
| } |
| |
| public IToken getRhsLastIToken(int i) { |
| return super.getIToken(getRhsLastTokenIndex(i)); |
| } |
| |
| public int getLeftSpan() { |
| return btParser.getFirstToken(); |
| } |
| |
| @Override |
| public IToken getLeftIToken() { |
| return super.getIToken(getLeftSpan()); |
| } |
| |
| public int getRightSpan() { |
| return btParser.getLastToken(); |
| } |
| |
| @Override |
| public IToken getRightIToken() { |
| return super.getIToken(getRightSpan()); |
| } |
| |
| public int getRhsErrorTokenIndex(int i) { |
| int index = btParser.getToken(i); |
| IToken err = super.getIToken(index); |
| return (err instanceof ErrorToken ? index : 0); |
| } |
| |
| public ErrorToken getRhsErrorIToken(int i) { |
| int index = btParser.getToken(i); |
| IToken err = super.getIToken(index); |
| return (ErrorToken) (err instanceof ErrorToken ? err : null); |
| } |
| |
| public GPPParser(LexStream lexStream) { |
| super(lexStream); |
| |
| try { |
| super.remapTerminalSymbols(orderedTerminalSymbols(), GPPParserprs.EOFT_SYMBOL); |
| } catch (NullExportedSymbolsException e) { |
| } catch (NullTerminalSymbolsException e) { |
| } catch (UnimplementedTerminalsException e) { |
| java.util.ArrayList unimplemented_symbols = e.getSymbols(); |
| System.out.println("The Lexer will not scan the following token(s):"); |
| for (int i = 0; i < unimplemented_symbols.size(); i++) { |
| Integer id = (Integer) unimplemented_symbols.get(i); |
| System.out.println(" " + GPPParsersym.orderedTerminalSymbols[id.intValue()]); |
| } |
| System.out.println(); |
| } catch (UndefinedEofSymbolException e) { |
| throw new Error(new UndefinedEofSymbolException("The Lexer does not implement the Eof symbol " |
| + GPPParsersym.orderedTerminalSymbols[GPPParserprs.EOFT_SYMBOL])); |
| } |
| } |
| |
| @Override |
| public String[] orderedTerminalSymbols() { |
| return GPPParsersym.orderedTerminalSymbols; |
| } |
| |
| public String getTokenKindName(int kind) { |
| return GPPParsersym.orderedTerminalSymbols[kind]; |
| } |
| |
| public int getEOFTokenKind() { |
| return GPPParserprs.EOFT_SYMBOL; |
| } |
| |
| public PrsStream getParseStream() { |
| return this; |
| } |
| |
| // |
| // Report error message for given error_token. |
| // |
| public final void reportErrorTokenMessage(int error_token, String msg) { |
| int firsttok = super.getFirstErrorToken(error_token), lasttok = super.getLastErrorToken(error_token); |
| String location = super.getFileName() + ':' |
| + (firsttok > lasttok ? (super.getEndLine(lasttok) + ":" + super.getEndColumn(lasttok)) |
| : (super.getLine(error_token) + ":" + super.getColumn(error_token) + ":" |
| + super.getEndLine(error_token) + ":" + super.getEndColumn(error_token))) |
| + ": "; |
| super.reportError((firsttok > lasttok ? ParseErrorCodes.INSERTION_CODE : ParseErrorCodes.SUBSTITUTION_CODE), |
| location, msg); |
| } |
| |
| public void parser() { |
| parser(null, 0); |
| } |
| |
| public void parser(Monitor monitor) { |
| parser(monitor, 0); |
| } |
| |
| public void parser(int error_repair_count) { |
| parser(null, error_repair_count); |
| } |
| |
| public void parser(Monitor monitor, int error_repair_count) { |
| try { |
| btParser = new FixedBacktrackingParser(monitor, this, prs, this); |
| } catch (NotBacktrackParseTableException e) { |
| throw new Error(new NotBacktrackParseTableException("Regenerate GPPParserprs.java with -BACKTRACK option")); |
| } catch (BadParseSymFileException e) { |
| throw new Error(new BadParseSymFileException("Bad Parser Symbol File -- GPPParsersym.java")); |
| } |
| |
| try { |
| btParser.parse(error_repair_count); |
| } catch (BadParseException e) { |
| reset(e.error_token); // point to error token |
| DiagnoseParser diagnoseParser = new DiagnoseParser(this, prs); |
| diagnoseParser.diagnose(e.error_token); |
| } |
| } |
| |
| private GPPBuildASTParserAction action; |
| private IASTCompletionNode compNode; |
| |
| public GPPParser(IScanner scanner, IDOMTokenMap tokenMap, IBuiltinBindingsProvider builtinBindingsProvider, |
| IIndex index, Map<String, String> properties) { |
| initActions(properties); |
| action.initializeTranslationUnit(scanner, builtinBindingsProvider, index); |
| CPreprocessorAdapter.runCPreprocessor(scanner, this, tokenMap); |
| } |
| |
| private void initActions(Map<String, String> properties) { |
| ScopedStack<Object> astStack = new ScopedStack<>(); |
| |
| action = new GPPBuildASTParserAction(this, astStack, CPPNodeFactory.getDefault(), |
| GPPSecondaryParserFactory.getDefault()); |
| action.setParserProperties(properties); |
| |
| gnuAction = new GNUBuildASTParserAction(this, astStack, CPPNodeFactory.getDefault()); |
| gnuAction.setParserProperties(properties); |
| |
| } |
| |
| @Override |
| public void addToken(IToken token) { |
| token.setKind(mapKind(token.getKind())); // TODO does mapKind need to be called? |
| super.addToken(token); |
| } |
| |
| @Override |
| public IASTTranslationUnit parse() { |
| // this has to be done, or... kaboom! |
| setStreamLength(getSize()); |
| |
| final int errorRepairCount = -1; // -1 means full error handling |
| parser(null, errorRepairCount); // do the actual parse |
| super.resetTokenStream(); // allow tokens to be garbage collected |
| |
| compNode = action.getASTCompletionNode(); // the completion node may be null |
| return (IASTTranslationUnit) action.getParseResult(); |
| } |
| |
| @Override |
| public IASTCompletionNode getCompletionNode() { |
| return compNode; |
| } |
| |
| // uncomment this method to use with backtracking parser |
| @Override |
| public List<IToken> getRuleTokens() { |
| return getTokens().subList(getLeftSpan(), getRightSpan() + 1); |
| } |
| |
| @Override |
| public String[] getOrderedTerminalSymbols() { |
| return GPPParsersym.orderedTerminalSymbols; |
| } |
| |
| @Override |
| @SuppressWarnings("nls") |
| public String getName() { |
| return "GPPParser"; |
| } |
| |
| private GNUBuildASTParserAction gnuAction; |
| |
| @Override |
| public void ruleAction(int ruleNumber) { |
| switch (ruleNumber) { |
| |
| // |
| // Rule 1: <openscope-ast> ::= $Empty |
| // |
| case 1: { |
| action.openASTScope(); |
| break; |
| } |
| |
| // |
| // Rule 2: <empty> ::= $Empty |
| // |
| case 2: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 13: translation_unit ::= declaration_seq_opt |
| // |
| case 13: { |
| action.consumeTranslationUnit(); |
| break; |
| } |
| |
| // |
| // Rule 16: literal ::= integer |
| // |
| case 16: { |
| action.consumeExpressionLiteral(ICPPASTLiteralExpression.lk_integer_constant); |
| break; |
| } |
| |
| // |
| // Rule 17: literal ::= floating |
| // |
| case 17: { |
| action.consumeExpressionLiteral(ICPPASTLiteralExpression.lk_float_constant); |
| break; |
| } |
| |
| // |
| // Rule 18: literal ::= charconst |
| // |
| case 18: { |
| action.consumeExpressionLiteral(ICPPASTLiteralExpression.lk_char_constant); |
| break; |
| } |
| |
| // |
| // Rule 19: literal ::= stringlit |
| // |
| case 19: { |
| action.consumeExpressionLiteral(ICPPASTLiteralExpression.lk_string_literal); |
| break; |
| } |
| |
| // |
| // Rule 20: literal ::= true |
| // |
| case 20: { |
| action.consumeExpressionLiteral(ICPPASTLiteralExpression.lk_true); |
| break; |
| } |
| |
| // |
| // Rule 21: literal ::= false |
| // |
| case 21: { |
| action.consumeExpressionLiteral(ICPPASTLiteralExpression.lk_false); |
| break; |
| } |
| |
| // |
| // Rule 22: literal ::= this |
| // |
| case 22: { |
| action.consumeExpressionLiteral(ICPPASTLiteralExpression.lk_this); |
| break; |
| } |
| |
| // |
| // Rule 24: primary_expression ::= ( expression ) |
| // |
| case 24: { |
| action.consumeExpressionBracketed(); |
| break; |
| } |
| |
| // |
| // Rule 26: id_expression ::= qualified_or_unqualified_name |
| // |
| case 26: { |
| action.consumeExpressionName(); |
| break; |
| } |
| |
| // |
| // Rule 33: unqualified_id_name ::= ~ identifier_token |
| // |
| case 33: { |
| action.consumeDestructorName(); |
| break; |
| } |
| |
| // |
| // Rule 34: unqualified_id_name ::= ~ template_id_name |
| // |
| case 34: { |
| action.consumeDestructorNameTemplateId(); |
| break; |
| } |
| |
| // |
| // Rule 35: identifier_name ::= identifier_token |
| // |
| case 35: { |
| action.consumeIdentifierName(); |
| break; |
| } |
| |
| // |
| // Rule 36: template_opt ::= template |
| // |
| case 36: { |
| action.consumePlaceHolder(); |
| break; |
| } |
| |
| // |
| // Rule 37: template_opt ::= $Empty |
| // |
| case 37: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 38: dcolon_opt ::= :: |
| // |
| case 38: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 39: dcolon_opt ::= $Empty |
| // |
| case 39: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 40: qualified_id_name ::= dcolon_opt nested_name_specifier template_opt unqualified_id_name |
| // |
| case 40: { |
| action.consumeQualifiedId(true); |
| break; |
| } |
| |
| // |
| // Rule 41: qualified_id_name ::= :: unqualified_id_name |
| // |
| case 41: { |
| action.consumeGlobalQualifiedId(); |
| break; |
| } |
| |
| // |
| // Rule 42: nested_name_specifier ::= class_or_namespace_name :: nested_name_specifier_with_template |
| // |
| case 42: { |
| action.consumeNestedNameSpecifier(true); |
| break; |
| } |
| |
| // |
| // Rule 43: nested_name_specifier ::= class_or_namespace_name :: |
| // |
| case 43: { |
| action.consumeNestedNameSpecifier(false); |
| break; |
| } |
| |
| // |
| // Rule 44: nested_name_specifier_with_template ::= class_or_namespace_name_with_template :: nested_name_specifier_with_template |
| // |
| case 44: { |
| action.consumeNestedNameSpecifier(true); |
| break; |
| } |
| |
| // |
| // Rule 45: nested_name_specifier_with_template ::= class_or_namespace_name_with_template :: |
| // |
| case 45: { |
| action.consumeNestedNameSpecifier(false); |
| break; |
| } |
| |
| // |
| // Rule 46: class_or_namespace_name_with_template ::= template_opt class_or_namespace_name |
| // |
| case 46: { |
| action.consumeNameWithTemplateKeyword(); |
| break; |
| } |
| |
| // |
| // Rule 48: nested_name_specifier_opt ::= $Empty |
| // |
| case 48: { |
| action.consumeNestedNameSpecifierEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 51: postfix_expression ::= postfix_expression [ expression ] |
| // |
| case 51: { |
| action.consumeExpressionArraySubscript(); |
| break; |
| } |
| |
| // |
| // Rule 52: postfix_expression ::= postfix_expression ( expression_list_opt ) |
| // |
| case 52: { |
| action.consumeExpressionFunctionCall(); |
| break; |
| } |
| |
| // |
| // Rule 53: postfix_expression ::= simple_type_specifier ( expression_list_opt ) |
| // |
| case 53: { |
| action.consumeExpressionSimpleTypeConstructor(); |
| break; |
| } |
| |
| // |
| // Rule 54: postfix_expression ::= typename dcolon_opt nested_name_specifier <empty> identifier_name ( expression_list_opt ) |
| // |
| case 54: { |
| action.consumeExpressionTypeName(); |
| break; |
| } |
| |
| // |
| // Rule 55: postfix_expression ::= typename dcolon_opt nested_name_specifier template_opt template_id_name ( expression_list_opt ) |
| // |
| case 55: { |
| action.consumeExpressionTypeName(); |
| break; |
| } |
| |
| // |
| // Rule 56: postfix_expression ::= postfix_expression . qualified_or_unqualified_name |
| // |
| case 56: { |
| action.consumeExpressionFieldReference(false, false); |
| break; |
| } |
| |
| // |
| // Rule 57: postfix_expression ::= postfix_expression -> qualified_or_unqualified_name |
| // |
| case 57: { |
| action.consumeExpressionFieldReference(true, false); |
| break; |
| } |
| |
| // |
| // Rule 58: postfix_expression ::= postfix_expression . template qualified_or_unqualified_name |
| // |
| case 58: { |
| action.consumeExpressionFieldReference(false, true); |
| break; |
| } |
| |
| // |
| // Rule 59: postfix_expression ::= postfix_expression -> template qualified_or_unqualified_name |
| // |
| case 59: { |
| action.consumeExpressionFieldReference(true, true); |
| break; |
| } |
| |
| // |
| // Rule 60: postfix_expression ::= postfix_expression . pseudo_destructor_name |
| // |
| case 60: { |
| action.consumeExpressionFieldReference(false, false); |
| break; |
| } |
| |
| // |
| // Rule 61: postfix_expression ::= postfix_expression -> pseudo_destructor_name |
| // |
| case 61: { |
| action.consumeExpressionFieldReference(true, false); |
| break; |
| } |
| |
| // |
| // Rule 62: postfix_expression ::= postfix_expression ++ |
| // |
| case 62: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_postFixIncr); |
| break; |
| } |
| |
| // |
| // Rule 63: postfix_expression ::= postfix_expression -- |
| // |
| case 63: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_postFixDecr); |
| break; |
| } |
| |
| // |
| // Rule 64: postfix_expression ::= dynamic_cast < type_id > ( expression ) |
| // |
| case 64: { |
| action.consumeExpressionCast(ICPPASTCastExpression.op_dynamic_cast); |
| break; |
| } |
| |
| // |
| // Rule 65: postfix_expression ::= static_cast < type_id > ( expression ) |
| // |
| case 65: { |
| action.consumeExpressionCast(ICPPASTCastExpression.op_static_cast); |
| break; |
| } |
| |
| // |
| // Rule 66: postfix_expression ::= reinterpret_cast < type_id > ( expression ) |
| // |
| case 66: { |
| action.consumeExpressionCast(ICPPASTCastExpression.op_reinterpret_cast); |
| break; |
| } |
| |
| // |
| // Rule 67: postfix_expression ::= const_cast < type_id > ( expression ) |
| // |
| case 67: { |
| action.consumeExpressionCast(ICPPASTCastExpression.op_const_cast); |
| break; |
| } |
| |
| // |
| // Rule 68: postfix_expression ::= typeid ( expression ) |
| // |
| case 68: { |
| action.consumeExpressionUnaryOperator(ICPPASTUnaryExpression.op_typeid); |
| break; |
| } |
| |
| // |
| // Rule 69: postfix_expression ::= typeid ( type_id ) |
| // |
| case 69: { |
| action.consumeExpressionTypeId(ICPPASTTypeIdExpression.op_typeid); |
| break; |
| } |
| |
| // |
| // Rule 70: pseudo_destructor_name ::= dcolon_opt nested_name_specifier_opt type_name :: destructor_type_name |
| // |
| case 70: { |
| action.consumePsudoDestructorName(true); |
| break; |
| } |
| |
| // |
| // Rule 71: pseudo_destructor_name ::= dcolon_opt nested_name_specifier template template_id_name :: destructor_type_name |
| // |
| case 71: { |
| action.consumePsudoDestructorName(true); |
| break; |
| } |
| |
| // |
| // Rule 72: pseudo_destructor_name ::= dcolon_opt nested_name_specifier_opt destructor_type_name |
| // |
| case 72: { |
| action.consumePsudoDestructorName(false); |
| break; |
| } |
| |
| // |
| // Rule 73: destructor_type_name ::= ~ identifier_token |
| // |
| case 73: { |
| action.consumeDestructorName(); |
| break; |
| } |
| |
| // |
| // Rule 74: destructor_type_name ::= ~ template_id_name |
| // |
| case 74: { |
| action.consumeDestructorNameTemplateId(); |
| break; |
| } |
| |
| // |
| // Rule 78: unary_expression ::= ++ cast_expression |
| // |
| case 78: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_prefixIncr); |
| break; |
| } |
| |
| // |
| // Rule 79: unary_expression ::= -- cast_expression |
| // |
| case 79: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_prefixDecr); |
| break; |
| } |
| |
| // |
| // Rule 80: unary_expression ::= & cast_expression |
| // |
| case 80: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_amper); |
| break; |
| } |
| |
| // |
| // Rule 81: unary_expression ::= * cast_expression |
| // |
| case 81: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_star); |
| break; |
| } |
| |
| // |
| // Rule 82: unary_expression ::= + cast_expression |
| // |
| case 82: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_plus); |
| break; |
| } |
| |
| // |
| // Rule 83: unary_expression ::= - cast_expression |
| // |
| case 83: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_minus); |
| break; |
| } |
| |
| // |
| // Rule 84: unary_expression ::= ~ cast_expression |
| // |
| case 84: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_tilde); |
| break; |
| } |
| |
| // |
| // Rule 85: unary_expression ::= ! cast_expression |
| // |
| case 85: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_not); |
| break; |
| } |
| |
| // |
| // Rule 86: unary_expression ::= sizeof unary_expression |
| // |
| case 86: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_sizeof); |
| break; |
| } |
| |
| // |
| // Rule 87: unary_expression ::= sizeof ( type_id ) |
| // |
| case 87: { |
| action.consumeExpressionTypeId(ICPPASTTypeIdExpression.op_sizeof); |
| break; |
| } |
| |
| // |
| // Rule 88: new_expression ::= dcolon_opt new new_placement_opt new_type_id <openscope-ast> new_array_expressions_opt new_initializer_opt |
| // |
| case 88: { |
| action.consumeExpressionNew(true); |
| break; |
| } |
| |
| // |
| // Rule 89: new_expression ::= dcolon_opt new new_placement_opt ( type_id ) <openscope-ast> new_array_expressions_opt new_initializer_opt |
| // |
| case 89: { |
| action.consumeExpressionNew(false); |
| break; |
| } |
| |
| // |
| // Rule 91: new_placement_opt ::= $Empty |
| // |
| case 91: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 92: new_type_id ::= type_specifier_seq |
| // |
| case 92: { |
| action.consumeTypeId(false); |
| break; |
| } |
| |
| // |
| // Rule 93: new_type_id ::= type_specifier_seq new_declarator |
| // |
| case 93: { |
| action.consumeTypeId(true); |
| break; |
| } |
| |
| // |
| // Rule 94: new_declarator ::= <openscope-ast> new_pointer_operators |
| // |
| case 94: { |
| action.consumeNewDeclarator(); |
| break; |
| } |
| |
| // |
| // Rule 101: new_initializer ::= ( expression_list_opt ) |
| // |
| case 101: { |
| action.consumeNewInitializer(); |
| break; |
| } |
| |
| // |
| // Rule 103: new_initializer_opt ::= $Empty |
| // |
| case 103: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 104: delete_expression ::= dcolon_opt delete cast_expression |
| // |
| case 104: { |
| action.consumeExpressionDelete(false); |
| break; |
| } |
| |
| // |
| // Rule 105: delete_expression ::= dcolon_opt delete [ ] cast_expression |
| // |
| case 105: { |
| action.consumeExpressionDelete(true); |
| break; |
| } |
| |
| // |
| // Rule 107: cast_expression ::= ( type_id ) cast_expression |
| // |
| case 107: { |
| action.consumeExpressionCast(ICPPASTCastExpression.op_cast); |
| break; |
| } |
| |
| // |
| // Rule 109: pm_expression ::= pm_expression .* cast_expression |
| // |
| case 109: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_pmdot); |
| break; |
| } |
| |
| // |
| // Rule 110: pm_expression ::= pm_expression ->* cast_expression |
| // |
| case 110: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_pmarrow); |
| break; |
| } |
| |
| // |
| // Rule 112: multiplicative_expression ::= multiplicative_expression * pm_expression |
| // |
| case 112: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_multiply); |
| break; |
| } |
| |
| // |
| // Rule 113: multiplicative_expression ::= multiplicative_expression / pm_expression |
| // |
| case 113: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_divide); |
| break; |
| } |
| |
| // |
| // Rule 114: multiplicative_expression ::= multiplicative_expression % pm_expression |
| // |
| case 114: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_modulo); |
| break; |
| } |
| |
| // |
| // Rule 116: additive_expression ::= additive_expression + multiplicative_expression |
| // |
| case 116: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_plus); |
| break; |
| } |
| |
| // |
| // Rule 117: additive_expression ::= additive_expression - multiplicative_expression |
| // |
| case 117: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_minus); |
| break; |
| } |
| |
| // |
| // Rule 119: shift_expression ::= shift_expression << additive_expression |
| // |
| case 119: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftLeft); |
| break; |
| } |
| |
| // |
| // Rule 120: shift_expression ::= shift_expression >> additive_expression |
| // |
| case 120: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftRight); |
| break; |
| } |
| |
| // |
| // Rule 122: relational_expression ::= relational_expression < shift_expression |
| // |
| case 122: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_lessThan); |
| break; |
| } |
| |
| // |
| // Rule 123: relational_expression ::= relational_expression > shift_expression |
| // |
| case 123: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_greaterThan); |
| break; |
| } |
| |
| // |
| // Rule 124: relational_expression ::= relational_expression <= shift_expression |
| // |
| case 124: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_lessEqual); |
| break; |
| } |
| |
| // |
| // Rule 125: relational_expression ::= relational_expression >= shift_expression |
| // |
| case 125: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_greaterEqual); |
| break; |
| } |
| |
| // |
| // Rule 127: equality_expression ::= equality_expression == relational_expression |
| // |
| case 127: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_equals); |
| break; |
| } |
| |
| // |
| // Rule 128: equality_expression ::= equality_expression != relational_expression |
| // |
| case 128: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_notequals); |
| break; |
| } |
| |
| // |
| // Rule 130: and_expression ::= and_expression & equality_expression |
| // |
| case 130: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryAnd); |
| break; |
| } |
| |
| // |
| // Rule 132: exclusive_or_expression ::= exclusive_or_expression ^ and_expression |
| // |
| case 132: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryXor); |
| break; |
| } |
| |
| // |
| // Rule 134: inclusive_or_expression ::= inclusive_or_expression | exclusive_or_expression |
| // |
| case 134: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryOr); |
| break; |
| } |
| |
| // |
| // Rule 136: logical_and_expression ::= logical_and_expression && inclusive_or_expression |
| // |
| case 136: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_logicalAnd); |
| break; |
| } |
| |
| // |
| // Rule 138: logical_or_expression ::= logical_or_expression || logical_and_expression |
| // |
| case 138: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_logicalOr); |
| break; |
| } |
| |
| // |
| // Rule 140: conditional_expression ::= logical_or_expression ? expression : assignment_expression |
| // |
| case 140: { |
| action.consumeExpressionConditional(); |
| break; |
| } |
| |
| // |
| // Rule 142: relational_expression_inTemplate ::= relational_expression_inTemplate < shift_expression |
| // |
| case 142: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_lessThan); |
| break; |
| } |
| |
| // |
| // Rule 143: relational_expression_inTemplate ::= ( relational_expression_inTemplate > shift_expression ) |
| // |
| case 143: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_greaterThan); |
| break; |
| } |
| |
| // |
| // Rule 144: relational_expression_inTemplate ::= relational_expression_inTemplate <= shift_expression |
| // |
| case 144: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_lessEqual); |
| break; |
| } |
| |
| // |
| // Rule 145: relational_expression_inTemplate ::= relational_expression_inTemplate >= shift_expression |
| // |
| case 145: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_greaterEqual); |
| break; |
| } |
| |
| // |
| // Rule 147: equality_expression_inTemplate ::= equality_expression_inTemplate == relational_expression_inTemplate |
| // |
| case 147: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_equals); |
| break; |
| } |
| |
| // |
| // Rule 148: equality_expression_inTemplate ::= equality_expression_inTemplate != relational_expression_inTemplate |
| // |
| case 148: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_notequals); |
| break; |
| } |
| |
| // |
| // Rule 150: and_expression_inTemplate ::= and_expression_inTemplate & equality_expression_inTemplate |
| // |
| case 150: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryAnd); |
| break; |
| } |
| |
| // |
| // Rule 152: exclusive_or_expression_inTemplate ::= exclusive_or_expression_inTemplate ^ and_expression_inTemplate |
| // |
| case 152: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryXor); |
| break; |
| } |
| |
| // |
| // Rule 154: inclusive_or_expression_inTemplate ::= inclusive_or_expression_inTemplate | exclusive_or_expression_inTemplate |
| // |
| case 154: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryOr); |
| break; |
| } |
| |
| // |
| // Rule 156: logical_and_expression_inTemplate ::= logical_and_expression_inTemplate && inclusive_or_expression_inTemplate |
| // |
| case 156: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_logicalAnd); |
| break; |
| } |
| |
| // |
| // Rule 158: logical_or_expression_inTemplate ::= logical_or_expression_inTemplate || logical_and_expression_inTemplate |
| // |
| case 158: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_logicalOr); |
| break; |
| } |
| |
| // |
| // Rule 160: conditional_expression_inTemplate ::= logical_or_expression_inTemplate ? expression : assignment_expression_inTemplate |
| // |
| case 160: { |
| action.consumeExpressionConditional(); |
| break; |
| } |
| |
| // |
| // Rule 163: assignment_expression_inTemplate ::= logical_or_expression_inTemplate = assignment_expression_inTemplate |
| // |
| case 163: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_assign); |
| break; |
| } |
| |
| // |
| // Rule 164: assignment_expression_inTemplate ::= logical_or_expression_inTemplate *= assignment_expression_inTemplate |
| // |
| case 164: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_multiplyAssign); |
| break; |
| } |
| |
| // |
| // Rule 165: assignment_expression_inTemplate ::= logical_or_expression_inTemplate /= assignment_expression_inTemplate |
| // |
| case 165: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_divideAssign); |
| break; |
| } |
| |
| // |
| // Rule 166: assignment_expression_inTemplate ::= logical_or_expression_inTemplate %= assignment_expression_inTemplate |
| // |
| case 166: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_moduloAssign); |
| break; |
| } |
| |
| // |
| // Rule 167: assignment_expression_inTemplate ::= logical_or_expression_inTemplate += assignment_expression_inTemplate |
| // |
| case 167: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_plusAssign); |
| break; |
| } |
| |
| // |
| // Rule 168: assignment_expression_inTemplate ::= logical_or_expression_inTemplate -= assignment_expression_inTemplate |
| // |
| case 168: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_minusAssign); |
| break; |
| } |
| |
| // |
| // Rule 169: assignment_expression_inTemplate ::= logical_or_expression_inTemplate >>= assignment_expression_inTemplate |
| // |
| case 169: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftRightAssign); |
| break; |
| } |
| |
| // |
| // Rule 170: assignment_expression_inTemplate ::= logical_or_expression_inTemplate <<= assignment_expression_inTemplate |
| // |
| case 170: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftLeftAssign); |
| break; |
| } |
| |
| // |
| // Rule 171: assignment_expression_inTemplate ::= logical_or_expression_inTemplate &= assignment_expression_inTemplate |
| // |
| case 171: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryAndAssign); |
| break; |
| } |
| |
| // |
| // Rule 172: assignment_expression_inTemplate ::= logical_or_expression_inTemplate ^= assignment_expression_inTemplate |
| // |
| case 172: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryXorAssign); |
| break; |
| } |
| |
| // |
| // Rule 173: assignment_expression_inTemplate ::= logical_or_expression_inTemplate |= assignment_expression_inTemplate |
| // |
| case 173: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryOrAssign); |
| break; |
| } |
| |
| // |
| // Rule 174: throw_expression ::= throw |
| // |
| case 174: { |
| action.consumeExpressionThrow(false); |
| break; |
| } |
| |
| // |
| // Rule 175: throw_expression ::= throw assignment_expression |
| // |
| case 175: { |
| action.consumeExpressionThrow(true); |
| break; |
| } |
| |
| // |
| // Rule 178: assignment_expression ::= logical_or_expression = assignment_expression |
| // |
| case 178: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_assign); |
| break; |
| } |
| |
| // |
| // Rule 179: assignment_expression ::= logical_or_expression *= assignment_expression |
| // |
| case 179: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_multiplyAssign); |
| break; |
| } |
| |
| // |
| // Rule 180: assignment_expression ::= logical_or_expression /= assignment_expression |
| // |
| case 180: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_divideAssign); |
| break; |
| } |
| |
| // |
| // Rule 181: assignment_expression ::= logical_or_expression %= assignment_expression |
| // |
| case 181: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_moduloAssign); |
| break; |
| } |
| |
| // |
| // Rule 182: assignment_expression ::= logical_or_expression += assignment_expression |
| // |
| case 182: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_plusAssign); |
| break; |
| } |
| |
| // |
| // Rule 183: assignment_expression ::= logical_or_expression -= assignment_expression |
| // |
| case 183: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_minusAssign); |
| break; |
| } |
| |
| // |
| // Rule 184: assignment_expression ::= logical_or_expression >>= assignment_expression |
| // |
| case 184: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftRightAssign); |
| break; |
| } |
| |
| // |
| // Rule 185: assignment_expression ::= logical_or_expression <<= assignment_expression |
| // |
| case 185: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_shiftLeftAssign); |
| break; |
| } |
| |
| // |
| // Rule 186: assignment_expression ::= logical_or_expression &= assignment_expression |
| // |
| case 186: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryAndAssign); |
| break; |
| } |
| |
| // |
| // Rule 187: assignment_expression ::= logical_or_expression ^= assignment_expression |
| // |
| case 187: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryXorAssign); |
| break; |
| } |
| |
| // |
| // Rule 188: assignment_expression ::= logical_or_expression |= assignment_expression |
| // |
| case 188: { |
| action.consumeExpressionBinaryOperator(ICPPASTBinaryExpression.op_binaryOrAssign); |
| break; |
| } |
| |
| // |
| // Rule 190: expression_list ::= <openscope-ast> expression_list_actual |
| // |
| case 190: { |
| action.consumeExpressionList(); |
| break; |
| } |
| |
| // |
| // Rule 194: expression_list_opt ::= $Empty |
| // |
| case 194: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 196: expression_opt ::= $Empty |
| // |
| case 196: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 199: constant_expression_opt ::= $Empty |
| // |
| case 199: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 208: statement ::= ERROR_TOKEN |
| // |
| case 208: { |
| action.consumeStatementProblem(); |
| break; |
| } |
| |
| // |
| // Rule 209: labeled_statement ::= identifier : statement |
| // |
| case 209: { |
| action.consumeStatementLabeled(); |
| break; |
| } |
| |
| // |
| // Rule 210: labeled_statement ::= case constant_expression : statement |
| // |
| case 210: { |
| action.consumeStatementCase(); |
| break; |
| } |
| |
| // |
| // Rule 211: labeled_statement ::= default : statement |
| // |
| case 211: { |
| action.consumeStatementDefault(); |
| break; |
| } |
| |
| // |
| // Rule 212: expression_statement ::= expression ; |
| // |
| case 212: { |
| action.consumeStatementExpression(); |
| break; |
| } |
| |
| // |
| // Rule 213: expression_statement ::= ; |
| // |
| case 213: { |
| action.consumeStatementNull(); |
| break; |
| } |
| |
| // |
| // Rule 214: compound_statement ::= { <openscope-ast> statement_seq } |
| // |
| case 214: { |
| action.consumeStatementCompoundStatement(true); |
| break; |
| } |
| |
| // |
| // Rule 215: compound_statement ::= { } |
| // |
| case 215: { |
| action.consumeStatementCompoundStatement(false); |
| break; |
| } |
| |
| // |
| // Rule 218: selection_statement ::= if ( condition ) statement |
| // |
| case 218: { |
| action.consumeStatementIf(false); |
| break; |
| } |
| |
| // |
| // Rule 219: selection_statement ::= if ( condition ) statement else statement |
| // |
| case 219: { |
| action.consumeStatementIf(true); |
| break; |
| } |
| |
| // |
| // Rule 220: selection_statement ::= switch ( condition ) statement |
| // |
| case 220: { |
| action.consumeStatementSwitch(); |
| break; |
| } |
| |
| // |
| // Rule 222: condition ::= type_specifier_seq declarator = assignment_expression |
| // |
| case 222: { |
| action.consumeConditionDeclaration(); |
| break; |
| } |
| |
| // |
| // Rule 224: condition_opt ::= $Empty |
| // |
| case 224: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 225: iteration_statement ::= while ( condition ) statement |
| // |
| case 225: { |
| action.consumeStatementWhileLoop(); |
| break; |
| } |
| |
| // |
| // Rule 226: iteration_statement ::= do statement while ( expression ) ; |
| // |
| case 226: { |
| action.consumeStatementDoLoop(true); |
| break; |
| } |
| |
| // |
| // Rule 227: iteration_statement ::= do statement |
| // |
| case 227: { |
| action.consumeStatementDoLoop(false); |
| break; |
| } |
| |
| // |
| // Rule 228: iteration_statement ::= for ( for_init_statement condition_opt ; expression_opt ) statement |
| // |
| case 228: { |
| action.consumeStatementForLoop(); |
| break; |
| } |
| |
| // |
| // Rule 230: for_init_statement ::= simple_declaration_with_declspec |
| // |
| case 230: { |
| action.consumeStatementDeclaration(); |
| break; |
| } |
| |
| // |
| // Rule 231: jump_statement ::= break ; |
| // |
| case 231: { |
| action.consumeStatementBreak(); |
| break; |
| } |
| |
| // |
| // Rule 232: jump_statement ::= continue ; |
| // |
| case 232: { |
| action.consumeStatementContinue(); |
| break; |
| } |
| |
| // |
| // Rule 233: jump_statement ::= return expression ; |
| // |
| case 233: { |
| action.consumeStatementReturn(true); |
| break; |
| } |
| |
| // |
| // Rule 234: jump_statement ::= return ; |
| // |
| case 234: { |
| action.consumeStatementReturn(false); |
| break; |
| } |
| |
| // |
| // Rule 235: jump_statement ::= goto identifier_token ; |
| // |
| case 235: { |
| action.consumeStatementGoto(); |
| break; |
| } |
| |
| // |
| // Rule 236: declaration_statement ::= block_declaration |
| // |
| case 236: { |
| action.consumeStatementDeclarationWithDisambiguation(); |
| break; |
| } |
| |
| // |
| // Rule 237: declaration_statement ::= function_definition |
| // |
| case 237: { |
| action.consumeStatementDeclaration(); |
| break; |
| } |
| |
| // |
| // Rule 245: declaration ::= ERROR_TOKEN |
| // |
| case 245: { |
| action.consumeDeclarationProblem(); |
| break; |
| } |
| |
| // |
| // Rule 255: simple_declaration ::= declaration_specifiers_opt <openscope-ast> init_declarator_list_opt ; |
| // |
| case 255: { |
| action.consumeDeclarationSimple(true); |
| break; |
| } |
| |
| // |
| // Rule 256: simple_declaration_with_declspec ::= declaration_specifiers <openscope-ast> init_declarator_list_opt ; |
| // |
| case 256: { |
| action.consumeDeclarationSimple(true); |
| break; |
| } |
| |
| // |
| // Rule 257: declaration_specifiers ::= <openscope-ast> simple_declaration_specifiers |
| // |
| case 257: { |
| action.consumeDeclarationSpecifiersSimple(); |
| break; |
| } |
| |
| // |
| // Rule 258: declaration_specifiers ::= <openscope-ast> class_declaration_specifiers |
| // |
| case 258: { |
| action.consumeDeclarationSpecifiersComposite(); |
| break; |
| } |
| |
| // |
| // Rule 259: declaration_specifiers ::= <openscope-ast> elaborated_declaration_specifiers |
| // |
| case 259: { |
| action.consumeDeclarationSpecifiersComposite(); |
| break; |
| } |
| |
| // |
| // Rule 260: declaration_specifiers ::= <openscope-ast> enum_declaration_specifiers |
| // |
| case 260: { |
| action.consumeDeclarationSpecifiersComposite(); |
| break; |
| } |
| |
| // |
| // Rule 261: declaration_specifiers ::= <openscope-ast> type_name_declaration_specifiers |
| // |
| case 261: { |
| action.consumeDeclarationSpecifiersTypeName(); |
| break; |
| } |
| |
| // |
| // Rule 263: declaration_specifiers_opt ::= $Empty |
| // |
| case 263: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 267: no_type_declaration_specifier ::= friend |
| // |
| case 267: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 268: no_type_declaration_specifier ::= typedef |
| // |
| case 268: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 288: storage_class_specifier ::= auto |
| // |
| case 288: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 289: storage_class_specifier ::= register |
| // |
| case 289: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 290: storage_class_specifier ::= static |
| // |
| case 290: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 291: storage_class_specifier ::= extern |
| // |
| case 291: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 292: storage_class_specifier ::= mutable |
| // |
| case 292: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 293: function_specifier ::= inline |
| // |
| case 293: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 294: function_specifier ::= virtual |
| // |
| case 294: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 295: function_specifier ::= explicit |
| // |
| case 295: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 296: simple_type_specifier ::= simple_type_specifier_token |
| // |
| case 296: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 310: type_name_specifier ::= dcolon_opt nested_name_specifier_opt type_name |
| // |
| case 310: { |
| action.consumeQualifiedId(false); |
| break; |
| } |
| |
| // |
| // Rule 311: type_name_specifier ::= dcolon_opt nested_name_specifier template template_id_name |
| // |
| case 311: { |
| action.consumeQualifiedId(false); |
| break; |
| } |
| |
| // |
| // Rule 312: type_name_specifier ::= typename dcolon_opt nested_name_specifier identifier_name |
| // |
| case 312: { |
| action.consumeQualifiedId(false); |
| break; |
| } |
| |
| // |
| // Rule 313: type_name_specifier ::= typename dcolon_opt nested_name_specifier template_opt template_id_name |
| // |
| case 313: { |
| action.consumeQualifiedId(true); |
| break; |
| } |
| |
| // |
| // Rule 315: elaborated_type_specifier ::= class_keyword elaborated_specifier_hook dcolon_opt nested_name_specifier_opt identifier_name |
| // |
| case 315: { |
| action.consumeTypeSpecifierElaborated(false); |
| break; |
| } |
| |
| // |
| // Rule 316: elaborated_type_specifier ::= class_keyword elaborated_specifier_hook dcolon_opt nested_name_specifier_opt template_opt template_id_name |
| // |
| case 316: { |
| action.consumeTypeSpecifierElaborated(true); |
| break; |
| } |
| |
| // |
| // Rule 317: elaborated_type_specifier ::= enum elaborated_specifier_hook dcolon_opt nested_name_specifier_opt identifier_name |
| // |
| case 317: { |
| action.consumeTypeSpecifierElaborated(false); |
| break; |
| } |
| |
| // |
| // Rule 321: enum_specifier ::= enum enum_specifier_hook { <openscope-ast> enumerator_list_opt comma_opt } |
| // |
| case 321: { |
| action.consumeTypeSpecifierEnumeration(false); |
| break; |
| } |
| |
| // |
| // Rule 322: enum_specifier ::= enum enum_specifier_hook identifier_token { <openscope-ast> enumerator_list_opt comma_opt } |
| // |
| case 322: { |
| action.consumeTypeSpecifierEnumeration(true); |
| break; |
| } |
| |
| // |
| // Rule 328: enumerator_definition ::= identifier_token |
| // |
| case 328: { |
| action.consumeEnumerator(false); |
| break; |
| } |
| |
| // |
| // Rule 329: enumerator_definition ::= identifier_token = constant_expression |
| // |
| case 329: { |
| action.consumeEnumerator(true); |
| break; |
| } |
| |
| // |
| // Rule 331: namespace_definition ::= namespace namespace_name namespace_definition_hook { <openscope-ast> declaration_seq_opt } |
| // |
| case 331: { |
| action.consumeNamespaceDefinition(true); |
| break; |
| } |
| |
| // |
| // Rule 332: namespace_definition ::= namespace namespace_definition_hook { <openscope-ast> declaration_seq_opt } |
| // |
| case 332: { |
| action.consumeNamespaceDefinition(false); |
| break; |
| } |
| |
| // |
| // Rule 334: namespace_alias_definition ::= namespace identifier_token = dcolon_opt nested_name_specifier_opt namespace_name ; |
| // |
| case 334: { |
| action.consumeNamespaceAliasDefinition(); |
| break; |
| } |
| |
| // |
| // Rule 335: using_declaration ::= using typename_opt dcolon_opt nested_name_specifier_opt unqualified_id_name ; |
| // |
| case 335: { |
| action.consumeUsingDeclaration(); |
| break; |
| } |
| |
| // |
| // Rule 336: typename_opt ::= typename |
| // |
| case 336: { |
| action.consumePlaceHolder(); |
| break; |
| } |
| |
| // |
| // Rule 337: typename_opt ::= $Empty |
| // |
| case 337: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 338: using_directive ::= using namespace dcolon_opt nested_name_specifier_opt namespace_name ; |
| // |
| case 338: { |
| action.consumeUsingDirective(); |
| break; |
| } |
| |
| // |
| // Rule 339: linkage_specification ::= extern stringlit { <openscope-ast> declaration_seq_opt } |
| // |
| case 339: { |
| action.consumeLinkageSpecification(); |
| break; |
| } |
| |
| // |
| // Rule 340: linkage_specification ::= extern stringlit <openscope-ast> declaration |
| // |
| case 340: { |
| action.consumeLinkageSpecification(); |
| break; |
| } |
| |
| // |
| // Rule 345: init_declarator_complete ::= init_declarator |
| // |
| case 345: { |
| action.consumeInitDeclaratorComplete(); |
| break; |
| } |
| |
| // |
| // Rule 347: init_declarator ::= complete_declarator initializer |
| // |
| case 347: { |
| action.consumeDeclaratorWithInitializer(true); |
| break; |
| } |
| |
| // |
| // Rule 350: declarator ::= <openscope-ast> ptr_operator_seq direct_declarator |
| // |
| case 350: { |
| action.consumeDeclaratorWithPointer(true); |
| break; |
| } |
| |
| // |
| // Rule 352: function_declarator ::= <openscope-ast> ptr_operator_seq direct_declarator |
| // |
| case 352: { |
| action.consumeDeclaratorWithPointer(true); |
| break; |
| } |
| |
| // |
| // Rule 356: basic_direct_declarator ::= declarator_id_name |
| // |
| case 356: { |
| action.consumeDirectDeclaratorIdentifier(); |
| break; |
| } |
| |
| // |
| // Rule 357: basic_direct_declarator ::= ( declarator ) |
| // |
| case 357: { |
| action.consumeDirectDeclaratorBracketed(); |
| break; |
| } |
| |
| // |
| // Rule 358: function_direct_declarator ::= basic_direct_declarator ( <openscope-ast> parameter_declaration_clause ) <openscope-ast> cv_qualifier_seq_opt <openscope-ast> exception_specification_opt |
| // |
| case 358: { |
| action.consumeDirectDeclaratorFunctionDeclarator(true); |
| break; |
| } |
| |
| // |
| // Rule 359: array_direct_declarator ::= array_direct_declarator array_modifier |
| // |
| case 359: { |
| action.consumeDirectDeclaratorArrayDeclarator(true); |
| break; |
| } |
| |
| // |
| // Rule 360: array_direct_declarator ::= basic_direct_declarator array_modifier |
| // |
| case 360: { |
| action.consumeDirectDeclaratorArrayDeclarator(true); |
| break; |
| } |
| |
| // |
| // Rule 361: array_modifier ::= [ constant_expression ] |
| // |
| case 361: { |
| action.consumeDirectDeclaratorArrayModifier(true); |
| break; |
| } |
| |
| // |
| // Rule 362: array_modifier ::= [ ] |
| // |
| case 362: { |
| action.consumeDirectDeclaratorArrayModifier(false); |
| break; |
| } |
| |
| // |
| // Rule 363: ptr_operator ::= pointer_hook * pointer_hook <openscope-ast> cv_qualifier_seq_opt |
| // |
| case 363: { |
| action.consumePointer(); |
| break; |
| } |
| |
| // |
| // Rule 364: ptr_operator ::= pointer_hook & pointer_hook |
| // |
| case 364: { |
| action.consumeReferenceOperator(); |
| break; |
| } |
| |
| // |
| // Rule 365: ptr_operator ::= dcolon_opt nested_name_specifier pointer_hook * pointer_hook <openscope-ast> cv_qualifier_seq_opt |
| // |
| case 365: { |
| action.consumePointerToMember(); |
| break; |
| } |
| |
| // |
| // Rule 372: cv_qualifier ::= const |
| // |
| case 372: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 373: cv_qualifier ::= volatile |
| // |
| case 373: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 375: declarator_id_name ::= dcolon_opt nested_name_specifier_opt type_name |
| // |
| case 375: { |
| action.consumeQualifiedId(false); |
| break; |
| } |
| |
| // |
| // Rule 376: type_id ::= type_specifier_seq |
| // |
| case 376: { |
| action.consumeTypeId(false); |
| break; |
| } |
| |
| // |
| // Rule 377: type_id ::= type_specifier_seq abstract_declarator |
| // |
| case 377: { |
| action.consumeTypeId(true); |
| break; |
| } |
| |
| // |
| // Rule 380: abstract_declarator ::= <openscope-ast> ptr_operator_seq |
| // |
| case 380: { |
| action.consumeDeclaratorWithPointer(false); |
| break; |
| } |
| |
| // |
| // Rule 381: abstract_declarator ::= <openscope-ast> ptr_operator_seq direct_abstract_declarator |
| // |
| case 381: { |
| action.consumeDeclaratorWithPointer(true); |
| break; |
| } |
| |
| // |
| // Rule 385: basic_direct_abstract_declarator ::= ( abstract_declarator ) |
| // |
| case 385: { |
| action.consumeDirectDeclaratorBracketed(); |
| break; |
| } |
| |
| // |
| // Rule 386: basic_direct_abstract_declarator ::= ( ) |
| // |
| case 386: { |
| action.consumeAbstractDeclaratorEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 387: array_direct_abstract_declarator ::= array_modifier |
| // |
| case 387: { |
| action.consumeDirectDeclaratorArrayDeclarator(false); |
| break; |
| } |
| |
| // |
| // Rule 388: array_direct_abstract_declarator ::= array_direct_abstract_declarator array_modifier |
| // |
| case 388: { |
| action.consumeDirectDeclaratorArrayDeclarator(true); |
| break; |
| } |
| |
| // |
| // Rule 389: array_direct_abstract_declarator ::= basic_direct_abstract_declarator array_modifier |
| // |
| case 389: { |
| action.consumeDirectDeclaratorArrayDeclarator(true); |
| break; |
| } |
| |
| // |
| // Rule 390: function_direct_abstract_declarator ::= basic_direct_abstract_declarator ( <openscope-ast> parameter_declaration_clause ) <openscope-ast> cv_qualifier_seq_opt <openscope-ast> exception_specification_opt |
| // |
| case 390: { |
| action.consumeDirectDeclaratorFunctionDeclarator(true); |
| break; |
| } |
| |
| // |
| // Rule 391: function_direct_abstract_declarator ::= ( <openscope-ast> parameter_declaration_clause ) <openscope-ast> cv_qualifier_seq_opt <openscope-ast> exception_specification_opt |
| // |
| case 391: { |
| action.consumeDirectDeclaratorFunctionDeclarator(false); |
| break; |
| } |
| |
| // |
| // Rule 392: parameter_declaration_clause ::= parameter_declaration_list_opt ... |
| // |
| case 392: { |
| action.consumePlaceHolder(); |
| break; |
| } |
| |
| // |
| // Rule 393: parameter_declaration_clause ::= parameter_declaration_list_opt |
| // |
| case 393: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 394: parameter_declaration_clause ::= parameter_declaration_list , ... |
| // |
| case 394: { |
| action.consumePlaceHolder(); |
| break; |
| } |
| |
| // |
| // Rule 400: abstract_declarator_opt ::= $Empty |
| // |
| case 400: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 401: parameter_declaration ::= declaration_specifiers parameter_init_declarator |
| // |
| case 401: { |
| action.consumeParameterDeclaration(); |
| break; |
| } |
| |
| // |
| // Rule 402: parameter_declaration ::= declaration_specifiers |
| // |
| case 402: { |
| action.consumeParameterDeclarationWithoutDeclarator(); |
| break; |
| } |
| |
| // |
| // Rule 404: parameter_init_declarator ::= declarator = parameter_initializer |
| // |
| case 404: { |
| action.consumeDeclaratorWithInitializer(true); |
| break; |
| } |
| |
| // |
| // Rule 406: parameter_init_declarator ::= abstract_declarator = parameter_initializer |
| // |
| case 406: { |
| action.consumeDeclaratorWithInitializer(true); |
| break; |
| } |
| |
| // |
| // Rule 407: parameter_init_declarator ::= = parameter_initializer |
| // |
| case 407: { |
| action.consumeDeclaratorWithInitializer(false); |
| break; |
| } |
| |
| // |
| // Rule 408: parameter_initializer ::= assignment_expression |
| // |
| case 408: { |
| action.consumeInitializer(); |
| break; |
| } |
| |
| // |
| // Rule 409: function_definition ::= declaration_specifiers_opt function_declarator <openscope-ast> ctor_initializer_list_opt function_body |
| // |
| case 409: { |
| action.consumeFunctionDefinition(false); |
| break; |
| } |
| |
| // |
| // Rule 410: function_definition ::= declaration_specifiers_opt function_declarator try <openscope-ast> ctor_initializer_list_opt function_body <openscope-ast> handler_seq |
| // |
| case 410: { |
| action.consumeFunctionDefinition(true); |
| break; |
| } |
| |
| // |
| // Rule 413: initializer ::= ( expression_list ) |
| // |
| case 413: { |
| action.consumeInitializerConstructor(); |
| break; |
| } |
| |
| // |
| // Rule 414: initializer_clause ::= assignment_expression |
| // |
| case 414: { |
| action.consumeInitializer(); |
| break; |
| } |
| |
| // |
| // Rule 415: initializer_clause ::= initializer_list |
| // |
| case 415: { |
| action.consumeInitializer(); |
| break; |
| } |
| |
| // |
| // Rule 416: initializer_list ::= start_initializer_list { <openscope-ast> initializer_seq , } end_initializer_list |
| // |
| case 416: { |
| action.consumeInitializerList(); |
| break; |
| } |
| |
| // |
| // Rule 417: initializer_list ::= start_initializer_list { <openscope-ast> initializer_seq } end_initializer_list |
| // |
| case 417: { |
| action.consumeInitializerList(); |
| break; |
| } |
| |
| // |
| // Rule 418: initializer_list ::= { <openscope-ast> } |
| // |
| case 418: { |
| action.consumeInitializerList(); |
| break; |
| } |
| |
| // |
| // Rule 419: start_initializer_list ::= $Empty |
| // |
| case 419: { |
| action.initializerListStart(); |
| break; |
| } |
| |
| // |
| // Rule 420: end_initializer_list ::= $Empty |
| // |
| case 420: { |
| action.initializerListEnd(); |
| break; |
| } |
| |
| // |
| // Rule 425: class_specifier ::= class_head { <openscope-ast> member_declaration_list_opt } |
| // |
| case 425: { |
| action.consumeClassSpecifier(); |
| break; |
| } |
| |
| // |
| // Rule 426: class_head ::= class_keyword composite_specifier_hook identifier_name_opt class_name_suffix_hook <openscope-ast> base_clause_opt |
| // |
| case 426: { |
| action.consumeClassHead(false); |
| break; |
| } |
| |
| // |
| // Rule 427: class_head ::= class_keyword composite_specifier_hook template_id_name class_name_suffix_hook <openscope-ast> base_clause_opt |
| // |
| case 427: { |
| action.consumeClassHead(false); |
| break; |
| } |
| |
| // |
| // Rule 428: class_head ::= class_keyword composite_specifier_hook nested_name_specifier identifier_name class_name_suffix_hook <openscope-ast> base_clause_opt |
| // |
| case 428: { |
| action.consumeClassHead(true); |
| break; |
| } |
| |
| // |
| // Rule 429: class_head ::= class_keyword composite_specifier_hook nested_name_specifier template_id_name class_name_suffix_hook <openscope-ast> base_clause_opt |
| // |
| case 429: { |
| action.consumeClassHead(true); |
| break; |
| } |
| |
| // |
| // Rule 433: identifier_name_opt ::= $Empty |
| // |
| case 433: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 437: visibility_label ::= access_specifier_keyword : |
| // |
| case 437: { |
| action.consumeVisibilityLabel(); |
| break; |
| } |
| |
| // |
| // Rule 438: member_declaration ::= declaration_specifiers_opt <openscope-ast> member_declarator_list ; |
| // |
| case 438: { |
| action.consumeDeclarationSimple(true); |
| break; |
| } |
| |
| // |
| // Rule 439: member_declaration ::= declaration_specifiers_opt ; |
| // |
| case 439: { |
| action.consumeDeclarationSimple(false); |
| break; |
| } |
| |
| // |
| // Rule 442: member_declaration ::= dcolon_opt nested_name_specifier template_opt unqualified_id_name ; |
| // |
| case 442: { |
| action.consumeMemberDeclarationQualifiedId(); |
| break; |
| } |
| |
| // |
| // Rule 448: member_declaration ::= ERROR_TOKEN |
| // |
| case 448: { |
| action.consumeDeclarationProblem(); |
| break; |
| } |
| |
| // |
| // Rule 457: member_declarator ::= declarator constant_initializer |
| // |
| case 457: { |
| action.consumeMemberDeclaratorWithInitializer(); |
| break; |
| } |
| |
| // |
| // Rule 458: member_declarator ::= bit_field_declarator : constant_expression |
| // |
| case 458: { |
| action.consumeBitField(true); |
| break; |
| } |
| |
| // |
| // Rule 459: member_declarator ::= : constant_expression |
| // |
| case 459: { |
| action.consumeBitField(false); |
| break; |
| } |
| |
| // |
| // Rule 460: bit_field_declarator ::= identifier_name |
| // |
| case 460: { |
| action.consumeDirectDeclaratorIdentifier(); |
| break; |
| } |
| |
| // |
| // Rule 461: constant_initializer ::= = constant_expression |
| // |
| case 461: { |
| action.consumeInitializer(); |
| break; |
| } |
| |
| // |
| // Rule 467: base_specifier ::= dcolon_opt nested_name_specifier_opt class_name |
| // |
| case 467: { |
| action.consumeBaseSpecifier(false, false); |
| break; |
| } |
| |
| // |
| // Rule 468: base_specifier ::= virtual access_specifier_keyword_opt dcolon_opt nested_name_specifier_opt class_name |
| // |
| case 468: { |
| action.consumeBaseSpecifier(true, true); |
| break; |
| } |
| |
| // |
| // Rule 469: base_specifier ::= access_specifier_keyword virtual dcolon_opt nested_name_specifier_opt class_name |
| // |
| case 469: { |
| action.consumeBaseSpecifier(true, true); |
| break; |
| } |
| |
| // |
| // Rule 470: base_specifier ::= access_specifier_keyword dcolon_opt nested_name_specifier_opt class_name |
| // |
| case 470: { |
| action.consumeBaseSpecifier(true, false); |
| break; |
| } |
| |
| // |
| // Rule 471: access_specifier_keyword ::= private |
| // |
| case 471: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 472: access_specifier_keyword ::= protected |
| // |
| case 472: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 473: access_specifier_keyword ::= public |
| // |
| case 473: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 475: access_specifier_keyword_opt ::= $Empty |
| // |
| case 475: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 477: conversion_function_id_name ::= conversion_function_id < <openscope-ast> template_argument_list_opt > |
| // |
| case 477: { |
| action.consumeTemplateId(); |
| break; |
| } |
| |
| // |
| // Rule 478: conversion_function_id ::= operator conversion_type_id |
| // |
| case 478: { |
| action.consumeConversionName(); |
| break; |
| } |
| |
| // |
| // Rule 479: conversion_type_id ::= type_specifier_seq conversion_declarator |
| // |
| case 479: { |
| action.consumeTypeId(true); |
| break; |
| } |
| |
| // |
| // Rule 480: conversion_type_id ::= type_specifier_seq |
| // |
| case 480: { |
| action.consumeTypeId(false); |
| break; |
| } |
| |
| // |
| // Rule 481: conversion_declarator ::= <openscope-ast> ptr_operator_seq |
| // |
| case 481: { |
| action.consumeDeclaratorWithPointer(false); |
| break; |
| } |
| |
| // |
| // Rule 487: mem_initializer ::= mem_initializer_name ( expression_list_opt ) |
| // |
| case 487: { |
| action.consumeConstructorChainInitializer(); |
| break; |
| } |
| |
| // |
| // Rule 488: mem_initializer_name ::= dcolon_opt nested_name_specifier_opt class_name |
| // |
| case 488: { |
| action.consumeQualifiedId(false); |
| break; |
| } |
| |
| // |
| // Rule 491: operator_function_id_name ::= operator_id_name < <openscope-ast> template_argument_list_opt > |
| // |
| case 491: { |
| action.consumeTemplateId(); |
| break; |
| } |
| |
| // |
| // Rule 492: operator_id_name ::= operator overloadable_operator |
| // |
| case 492: { |
| action.consumeOperatorName(); |
| break; |
| } |
| |
| // |
| // Rule 535: template_declaration ::= export_opt template < <openscope-ast> template_parameter_list > declaration |
| // |
| case 535: { |
| action.consumeTemplateDeclaration(); |
| break; |
| } |
| |
| // |
| // Rule 536: export_opt ::= export |
| // |
| case 536: { |
| action.consumePlaceHolder(); |
| break; |
| } |
| |
| // |
| // Rule 537: export_opt ::= $Empty |
| // |
| case 537: { |
| action.consumeEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 541: template_parameter ::= parameter_declaration |
| // |
| case 541: { |
| action.consumeTemplateParamterDeclaration(); |
| break; |
| } |
| |
| // |
| // Rule 542: type_parameter ::= class identifier_name_opt |
| // |
| case 542: { |
| action.consumeSimpleTypeTemplateParameter(false); |
| break; |
| } |
| |
| // |
| // Rule 543: type_parameter ::= class identifier_name_opt = type_id |
| // |
| case 543: { |
| action.consumeSimpleTypeTemplateParameter(true); |
| break; |
| } |
| |
| // |
| // Rule 544: type_parameter ::= typename identifier_name_opt |
| // |
| case 544: { |
| action.consumeSimpleTypeTemplateParameter(false); |
| break; |
| } |
| |
| // |
| // Rule 545: type_parameter ::= typename identifier_name_opt = type_id |
| // |
| case 545: { |
| action.consumeSimpleTypeTemplateParameter(true); |
| break; |
| } |
| |
| // |
| // Rule 546: type_parameter ::= template < <openscope-ast> template_parameter_list > class identifier_name_opt |
| // |
| case 546: { |
| action.consumeTemplatedTypeTemplateParameter(false); |
| break; |
| } |
| |
| // |
| // Rule 547: type_parameter ::= template < <openscope-ast> template_parameter_list > class identifier_name_opt = id_expression |
| // |
| case 547: { |
| action.consumeTemplatedTypeTemplateParameter(true); |
| break; |
| } |
| |
| // |
| // Rule 548: template_id_name ::= identifier_name < <openscope-ast> template_argument_list_opt > |
| // |
| case 548: { |
| action.consumeTemplateId(); |
| break; |
| } |
| |
| // |
| // Rule 555: nested_name_specifier_inTemplate ::= class_or_namespace_name_inTemplate :: nested_name_specifier_with_template_inTemplate |
| // |
| case 555: { |
| action.consumeNestedNameSpecifier(true); |
| break; |
| } |
| |
| // |
| // Rule 556: nested_name_specifier_inTemplate ::= class_or_namespace_name_inTemplate :: |
| // |
| case 556: { |
| action.consumeNestedNameSpecifier(false); |
| break; |
| } |
| |
| // |
| // Rule 557: nested_name_specifier_with_template_inTemplate ::= class_or_namespace_name_with_template_inTemplate :: nested_name_specifier_with_template_inTemplate |
| // |
| case 557: { |
| action.consumeNestedNameSpecifier(true); |
| break; |
| } |
| |
| // |
| // Rule 558: nested_name_specifier_with_template_inTemplate ::= class_or_namespace_name_with_template_inTemplate :: |
| // |
| case 558: { |
| action.consumeNestedNameSpecifier(false); |
| break; |
| } |
| |
| // |
| // Rule 559: class_or_namespace_name_with_template_inTemplate ::= template_opt class_or_namespace_name_inTemplate |
| // |
| case 559: { |
| action.consumeNameWithTemplateKeyword(); |
| break; |
| } |
| |
| // |
| // Rule 561: nested_name_specifier_opt_inTemplate ::= $Empty |
| // |
| case 561: { |
| action.consumeNestedNameSpecifierEmpty(); |
| break; |
| } |
| |
| // |
| // Rule 564: type_name_specifier_inTemplate ::= typename dcolon_opt nested_name_specifier identifier_name |
| // |
| case 564: { |
| action.consumeQualifiedId(false); |
| break; |
| } |
| |
| // |
| // Rule 565: type_name_specifier_inTemplate ::= typename dcolon_opt nested_name_specifier template_opt template_id_name |
| // |
| case 565: { |
| action.consumeQualifiedId(true); |
| break; |
| } |
| |
| // |
| // Rule 570: declaration_specifiers_inTemplate ::= <openscope-ast> simple_declaration_specifiers |
| // |
| case 570: { |
| action.consumeDeclarationSpecifiersSimple(); |
| break; |
| } |
| |
| // |
| // Rule 571: declaration_specifiers_inTemplate ::= <openscope-ast> class_declaration_specifiers |
| // |
| case 571: { |
| action.consumeDeclarationSpecifiersComposite(); |
| break; |
| } |
| |
| // |
| // Rule 572: declaration_specifiers_inTemplate ::= <openscope-ast> elaborated_declaration_specifiers |
| // |
| case 572: { |
| action.consumeDeclarationSpecifiersComposite(); |
| break; |
| } |
| |
| // |
| // Rule 573: declaration_specifiers_inTemplate ::= <openscope-ast> enum_declaration_specifiers |
| // |
| case 573: { |
| action.consumeDeclarationSpecifiersComposite(); |
| break; |
| } |
| |
| // |
| // Rule 574: declaration_specifiers_inTemplate ::= <openscope-ast> type_name_declaration_specifiers_inTemplate |
| // |
| case 574: { |
| action.consumeDeclarationSpecifiersTypeName(); |
| break; |
| } |
| |
| // |
| // Rule 576: type_id_inTemplate ::= type_specifier_seq_inTemplate |
| // |
| case 576: { |
| action.consumeTypeId(false); |
| break; |
| } |
| |
| // |
| // Rule 577: type_id_inTemplate ::= type_specifier_seq_inTemplate abstract_declarator |
| // |
| case 577: { |
| action.consumeTypeId(true); |
| break; |
| } |
| |
| // |
| // Rule 578: template_argument ::= assignment_expression_inTemplate |
| // |
| case 578: { |
| action.consumeTemplateArgumentExpression(); |
| break; |
| } |
| |
| // |
| // Rule 579: template_argument ::= type_id_inTemplate |
| // |
| case 579: { |
| action.consumeTemplateArgumentTypeId(); |
| break; |
| } |
| |
| // |
| // Rule 580: explicit_instantiation ::= template declaration |
| // |
| case 580: { |
| action.consumeTemplateExplicitInstantiation(); |
| break; |
| } |
| |
| // |
| // Rule 581: explicit_specialization ::= template < > declaration |
| // |
| case 581: { |
| action.consumeTemplateExplicitSpecialization(); |
| break; |
| } |
| |
| // |
| // Rule 582: try_block ::= try compound_statement <openscope-ast> handler_seq |
| // |
| case 582: { |
| action.consumeStatementTryBlock(true); |
| break; |
| } |
| |
| // |
| // Rule 583: try_block ::= try compound_statement |
| // |
| case 583: { |
| action.consumeStatementTryBlock(false); |
| break; |
| } |
| |
| // |
| // Rule 586: handler ::= catch ( exception_declaration ) compound_statement |
| // |
| case 586: { |
| action.consumeStatementCatchHandler(false); |
| break; |
| } |
| |
| // |
| // Rule 587: handler ::= catch ( ... ) compound_statement |
| // |
| case 587: { |
| action.consumeStatementCatchHandler(true); |
| break; |
| } |
| |
| // |
| // Rule 588: exception_declaration ::= type_specifier_seq <openscope-ast> declarator |
| // |
| case 588: { |
| action.consumeDeclarationSimple(true); |
| break; |
| } |
| |
| // |
| // Rule 589: exception_declaration ::= type_specifier_seq <openscope-ast> abstract_declarator |
| // |
| case 589: { |
| action.consumeDeclarationSimple(true); |
| break; |
| } |
| |
| // |
| // Rule 590: exception_declaration ::= type_specifier_seq |
| // |
| case 590: { |
| action.consumeDeclarationSimple(false); |
| break; |
| } |
| |
| // |
| // Rule 592: exception_specification ::= throw ( ) |
| // |
| case 592: { |
| action.consumePlaceHolder(); |
| break; |
| } |
| |
| // |
| // Rule 613: attribute_parameter ::= assignment_expression |
| // |
| case 613: { |
| action.consumeIgnore(); |
| break; |
| } |
| |
| // |
| // Rule 624: extended_asm_declaration ::= asm volatile_opt ( extended_asm_param_seq ) ; |
| // |
| case 624: { |
| gnuAction.consumeDeclarationASM(); |
| break; |
| } |
| |
| // |
| // Rule 635: unary_expression ::= __alignof__ unary_expression |
| // |
| case 635: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_alignOf); |
| break; |
| } |
| |
| // |
| // Rule 636: unary_expression ::= __alignof__ ( type_id ) |
| // |
| case 636: { |
| action.consumeExpressionTypeId(IASTTypeIdExpression.op_alignof); |
| break; |
| } |
| |
| // |
| // Rule 637: unary_expression ::= typeof unary_expression |
| // |
| case 637: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_typeof); |
| break; |
| } |
| |
| // |
| // Rule 638: unary_expression ::= typeof ( type_id ) |
| // |
| case 638: { |
| action.consumeExpressionTypeId(IASTTypeIdExpression.op_typeof); |
| break; |
| } |
| |
| // |
| // Rule 639: relational_expression ::= relational_expression >? shift_expression |
| // |
| case 639: { |
| action.consumeExpressionBinaryOperator(IASTBinaryExpression.op_max); |
| break; |
| } |
| |
| // |
| // Rule 640: relational_expression ::= relational_expression <? shift_expression |
| // |
| case 640: { |
| action.consumeExpressionBinaryOperator(IASTBinaryExpression.op_min); |
| break; |
| } |
| |
| // |
| // Rule 641: conditional_expression ::= logical_or_expression ? <empty> : assignment_expression |
| // |
| case 641: { |
| action.consumeExpressionConditional(); |
| break; |
| } |
| |
| // |
| // Rule 642: primary_expression ::= ( compound_statement ) |
| // |
| case 642: { |
| gnuAction.consumeCompoundStatementExpression(); |
| break; |
| } |
| |
| // |
| // Rule 643: labeled_statement ::= case case_range_expression : statement |
| // |
| case 643: { |
| action.consumeStatementCase(); |
| break; |
| } |
| |
| // |
| // Rule 644: case_range_expression ::= constant_expression ... constant_expression |
| // |
| case 644: { |
| action.consumeExpressionBinaryOperator(IASTBinaryExpression.op_assign); |
| break; |
| } |
| |
| // |
| // Rule 648: typeof_type_specifier ::= typeof unary_expression |
| // |
| case 648: { |
| action.consumeExpressionUnaryOperator(IASTUnaryExpression.op_typeof); |
| break; |
| } |
| |
| // |
| // Rule 649: typeof_type_specifier ::= typeof ( type_id ) |
| // |
| case 649: { |
| action.consumeExpressionTypeId(IASTTypeIdExpression.op_typeof); |
| break; |
| } |
| |
| // |
| // Rule 650: declaration_specifiers ::= <openscope-ast> typeof_declaration_specifiers |
| // |
| case 650: { |
| action.consumeDeclarationSpecifiersTypeof(); |
| break; |
| } |
| |
| // |
| // Rule 663: declarator ::= <openscope-ast> ptr_operator_seq attribute_or_decl_specifier_seq direct_declarator |
| // |
| case 663: { |
| action.consumeDeclaratorWithPointer(true); |
| break; |
| } |
| |
| // |
| // Rule 666: simple_type_specifier ::= _Complex |
| // |
| case 666: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 667: simple_type_specifier ::= _Imaginary |
| // |
| case 667: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 668: cv_qualifier ::= restrict |
| // |
| case 668: { |
| action.consumeToken(); |
| break; |
| } |
| |
| // |
| // Rule 669: explicit_instantiation ::= extern template declaration |
| // |
| case 669: { |
| action.consumeTemplateExplicitInstantiationGCC(IGPPASTExplicitTemplateInstantiation.ti_extern); |
| break; |
| } |
| |
| // |
| // Rule 670: explicit_instantiation ::= static template declaration |
| // |
| case 670: { |
| action.consumeTemplateExplicitInstantiationGCC(IGPPASTExplicitTemplateInstantiation.ti_static); |
| break; |
| } |
| |
| // |
| // Rule 671: explicit_instantiation ::= inline template declaration |
| // |
| case 671: { |
| action.consumeTemplateExplicitInstantiationGCC(IGPPASTExplicitTemplateInstantiation.ti_inline); |
| break; |
| } |
| |
| // |
| // Rule 672: postfix_expression ::= ( type_id ) initializer_list |
| // |
| case 672: { |
| action.consumeExpressionTypeIdInitializer(); |
| break; |
| } |
| |
| default: |
| break; |
| } |
| return; |
| } |
| } |
