from langkit.dsl import Field from language.parser import A, GPRNode class CompilationUnit(GPRNode): project = Field() A.add_rules(compilation_unit=CompilationUnit(A.project), )
A.add_rules( protected_type_decl=Row( "protected", "type", A.identifier, Opt(A.type_discriminant), A.aspect_specification, "is", Opt("new", List(A.static_name, sep="and"), "with")[1], A.protected_def ) ^ ProtectedTypeDecl, protected_op=Or(A.subprogram_decl, A.entry_decl, A.aspect_clause, A.pragma), protected_el=Or(A.protected_op, A.component_decl), protected_def=Row( List(Row(A.protected_op, ";")[0], empty_valid=True), Opt( "private", List(Row(A.protected_el, ";")[0], empty_valid=True) )[1], "end", Opt(A.identifier) ) ^ ProtectedDef, task_item=Or(A.entry_decl, A.aspect_clause, A.pragma), task_def=Row( List(Row(A.task_item, ";")[0], empty_valid=True), Opt( "private", List(Row(A.task_item, ";")[0], empty_valid=True) )[1], "end", Opt(A.identifier) ) ^ TaskDef, task_type_decl=Row( "task", "type", A.identifier, Opt(A.type_discriminant), A.aspect_specification, "is", Opt("new", List(A.static_name, sep="and"), "with")[1], A.task_def ) ^ TaskTypeDecl, subtype_decl=Row( "subtype", A.identifier, "is", A.type_expression, A.aspect_specification ) ^ SubtypeDecl, interface_type_def=Row( Opt(Or( Enum("limited", InterfaceKind("limited")), Enum("task", InterfaceKind("task")), Enum("protected", InterfaceKind("protected")), Enum("synchronized", InterfaceKind("synchronized")))), "interface", List(Row("and", A.static_name)[1], empty_valid=True) ) ^ InterfaceTypeDef, array_type_def=Row( "array", "(", Or( List(Row(A.static_name, "range", "<>")[0], sep=",") ^ UnconstrainedArrayIndices, List(A.discrete_subtype_definition, sep=",") ^ ConstrainedArrayIndices ), ")", "of", A.component_def ) ^ ArrayTypeDef, discrete_subtype_definition=A.discrete_range | A.type_expression, signed_int_type_def=Row(A.range_spec) ^ SignedIntTypeDef, mod_int_type_def=Row("mod", A.sexpr_or_diamond) ^ ModIntTypeDef, derived_type_def=Row( Opt("abstract").as_bool(), Opt("limited").as_bool(), Opt("synchronized").as_bool(), "new", Opt("not", "null").as_bool(), A.type_expression, Opt(A.constraint), List(Row("and", A.static_name)[1], empty_valid=True), Opt("with", A.record_def)[1], Opt("with", "private").as_bool() ) ^ DerivedTypeDef, discriminant_association=Row( List(A.identifier, sep="|"), "=>", A.expression ) ^ DiscriminantAssociation, discriminant_constraint=Row( "(", List(A.discriminant_association, sep=","), ")" ) ^ DiscriminantConstraint, index_constraint=Row( "(", List(A.discrete_subtype_definition, sep=","), ")" ) ^ IndexConstraint, digits_constraint=Row( "digits", A.simple_expr, Opt(A.range_spec) ) ^ DigitsConstraint, delta_constraint=Row( "delta", A.simple_expr, Opt(A.range_spec) ) ^ DeltaConstraint, range_constraint=Row(A.range_spec) ^ RangeConstraint, constraint=Or(A.digits_constraint, A.delta_constraint, A.range_constraint, A.index_constraint, A.discriminant_constraint), discriminant_spec=Row( List(A.identifier, sep=","), ":", A.type_expression, A.default_expr ) ^ DiscriminantSpec, discr_spec_list=List(A.discriminant_spec, sep=";"), type_discriminant=Row( "(", Or(A.discr_spec_list, Row("<>", Null(A.discr_spec_list))[1]), ")" ) ^ TypeDiscriminant, enum_type_def=Row( "(", List(Or(A.enum_identifier, A.char_literal), sep=","), ")" ) ^ EnumTypeDef, formal_discrete_type_def=Row( "(", "<>", ")" ) ^ FormalDiscreteTypeDef, record_def=Or( Row("record", A.component_list, "end", "record") ^ RecordDef, Row("null", Null(ComponentList), "record") ^ RecordDef ), range_spec=Row("range", A.discrete_range | A.name | A.diamond_expr)[1], real_type_def=Or(A.floating_point_def, A.decimal_fixed_point_def, A.ordinary_fixed_point_def), sexpr_or_diamond=A.simple_expr | A.diamond_expr, ordinary_fixed_point_def=Row( "delta", A.sexpr_or_diamond, Opt(A.range_spec), ) ^ OrdinaryFixedPointDef, decimal_fixed_point_def=Row( "delta", A.sexpr_or_diamond, "digits", A.sexpr_or_diamond, Opt(A.range_spec) ) ^ DecimalFixedPointDef, floating_point_def=Row( "digits", A.sexpr_or_diamond, Opt(A.range_spec) ) ^ FloatingPointDef, record_type_def=Row( Opt("abstract").as_bool(), Opt("tagged").as_bool(), Opt("limited").as_bool(), A.record_def ) ^ RecordTypeDef, access_def=Row( Opt("not", "null").as_bool(), A.access_expression ) ^ AccessDef, type_def=Or(A.enum_type_def, A.record_type_def, A.real_type_def, A.derived_type_def, A.signed_int_type_def, A.mod_int_type_def, A.array_type_def, A.interface_type_def, A.access_def, A.formal_discrete_type_def), variant=Row( "when", A.choice_list, "=>", A.component_list ) ^ Variant, full_type_decl=Row( "type", A.identifier, Opt(A.type_discriminant), Or( Row("is", A.type_def)[1], Row("is", Opt("abstract").as_bool(), Opt("tagged").as_bool(), Opt("limited").as_bool(), "private") ^ PrivateTypeDef, Row(Opt("is", "tagged").as_bool()) ^ IncompleteTypeDef, ), A.aspect_specification ) ^ FullTypeDecl, variant_part=Row( "case", A.identifier, "is", List(A.variant), "end", "case", ";" ) ^ VariantPart, component_def=Row( Opt("aliased").as_bool(), A.type_expression) ^ ComponentDef, component_item=Or( Row("null") ^ NullComponentDecl, A.component_decl, A.aspect_clause, A.pragma ), default_expr=Opt(":=", A.expression)[1], component_decl=Row( List(A.identifier, sep=","), ":", A.component_def, A.default_expr, A.aspect_specification ) ^ ComponentDecl, component_list=Row( List(Row(A.component_item, ";")[0], empty_valid=True), Opt(A.variant_part) ) ^ ComponentList, )
A.add_rules( project_qualifier=Or( ProjectQualifier.alt_abstract("abstract"), ProjectQualifier.alt_library(Lex.Identifier("library")), ProjectQualifier.alt_aggregate_library(Lex.Identifier("aggregate"), Lex.Identifier("library")), ProjectQualifier.alt_aggregate(Lex.Identifier("aggregate")), ProjectQualifier.alt_configuration(Lex.Identifier("configuration")), ProjectQualifier.alt_standard(Lex.Identifier("standard")), ), project_extension=ProjectExtension("extends", Opt("all").as_bool(AllQualifier), A.string_literal), project_declaration=ProjectDeclaration( Opt(A.project_qualifier), Lex.Identifier(match_text="project"), A.static_name, Opt(A.project_extension), "is", A.declarative_items, "end", A.static_name, ";", ), project=Project( A.context_clauses, A.project_declaration, ), # ----------------------------------------------- declarative items declarative_items=List(A.declarative_item, empty_valid=True), declarative_item=Or(A.simple_declarative_item, A.typed_string_decl, A.package_decl), simple_declarative_items=List(A.simple_declarative_item, empty_valid=True), simple_declarative_item=Or( A.variable_decl, A.attribute_decl, A.case_construction, A.empty_declaration, ), variable_decl=VariableDecl(A.identifier, Opt(Pick(":", A.type_reference)), ":=", A.expression, ";"), attribute_decl=AttributeDecl( "for", A.identifier, Opt(Pick("(", A.associative_array_index, ")")), "use", A.expression, ";", ), associative_array_index=Or(A.others_designator, A.string_literal_at), package_decl=PackageDecl("package", A.identifier, Or(A.package_renaming, A.package_spec), ";"), package_renaming=PackageRenaming("renames", A.identifier, ".", A.identifier), package_extension=PackageExtension( "extends", A.identifier, ".", A.identifier, ), package_spec=PackageSpec( Opt(A.package_extension), "is", A.simple_declarative_items, "end", A.identifier, ), empty_declaration=EmptyDecl("null", ";"), case_construction=CaseConstruction( "case", A.variable_reference, "is", List(A.case_item, empty_valid=True), "end", "case", ";", ), case_item=CaseItem( "when", A.discrete_choice_list, "=>", # ??? A.declarative_items A.simple_declarative_items, ), others_designator=OthersDesignator("others"), choice=Or(A.string_literal, A.others_designator), discrete_choice_list=List(A.choice, sep="|", list_cls=Choices), with_decl=WithDecl( Opt("limited").as_bool(Limited), "with", List(A.string_literal, sep=","), ";", ), context_clauses=List(A.with_decl, empty_valid=True), # Ada context clauses parsing ######################################### ada_with_clause=AdaWith( Limited("limited"), Private("private"), "with", List(A.static_name, sep=","), ";", ), ada_context=List(A.ada_context_item, empty_valid=True), ada_context_item=Or(A.ada_with_clause, A.ada_use_clause, A.ada_pragma), ada_context_skip=List(Or(Skip(AdaSkip), )), ada_use_clause=AdaUse("use", A.ada_context_skip.dont_skip(";"), ";"), ada_pragma=AdaPragma("pragma", A.ada_context_skip.dont_skip(";"), ";"), ada_subp_kind=Or(AdaSubpKind.alt_procedure(Lex.Identifier("procedure")), AdaSubpKind.alt_function(Lex.Identifier("function"))), ada_library_item=AdaLibraryItem( Opt( AdaGeneric( Lex.Identifier(match_text="generic"), List(Or( AdaWithFormal("with", A.ada_context_skip.dont_skip(";")), AdaAccessSubp(Lex.Identifier(match_text="access"), A.ada_subp_kind, A.ada_context_skip.dont_skip(";")), Skip(AdaSkip), ), empty_valid=True).dont_skip( Or(Lex.Identifier('procedure'), Lex.Identifier('function'), 'package')))), Opt(AdaSeparate(Lex.Identifier("separate"), "(", A.static_name, ")")), Or( AdaSubp(A.ada_subp_kind, A.static_name), AdaPkg(Private("private"), "package", A.static_name), AdaPkgBody("package", Lex.Identifier("body"), A.static_name), )), ada_prelude=AdaPrelude(A.ada_context, A.ada_library_item), # end Ada with clauses parsing ######################################### )
A.add_rules( identifier=Identifier(Token.Identifier), string_literal=StringLiteral(Token.String), num_literal=NumLiteral(Token.Number), static_name=Or(Prefix(A.static_name, '.', A.identifier), A.identifier), # ---------------------------------------------------------------- attribute_reference=AttributeReference( A.identifier, Opt(Pick("(", Or(A.others_designator, A.string_literal), ")"))), variable_reference=VariableReference(A.identifier, Opt(Pick(".", A.identifier)), Opt(Pick(".", A.identifier)), Opt(Pick("'", A.attribute_reference))), type_reference=TypeReference( A.identifier, Opt(Pick(".", A.identifier)), ), builtin_function_call=BuiltinFunctionCall(A.identifier, A.expression_list), # ---------------------------------------------------------------- expression=List(A.term, sep="&", list_cls=TermList), expression_list=ExprList("(", List(A.expression, sep=",", empty_valid=True), ")"), string_literal_at=StringLiteralAt(A.string_literal, Opt(Pick("at", A.num_literal))), project_reference=ProjectReference("project", "'", A.attribute_reference), term=Or(A.expression_list, A.string_literal_at, A.builtin_function_call, A.variable_reference, A.project_reference), )
A.add_rules( context_clauses=List(A.with_decl, empty_valid=True), with_decl=WithDecl( Opt("limited").as_bool(Limited), "with", List(A.string_literal, sep=","), ";"), abstract_present=AbstractPresent("abstract"), qualifier_names=QualifierNames(A.identifier, Opt(A.identifier)), project_qualifier=ProjectQualifier( Or(A.abstract_present, A.qualifier_names)), project_extension=ProjectExtension("extends", Opt("all").as_bool(AllQualifier), A.string_literal), project_declaration=ProjectDeclaration(Opt(A.project_qualifier), "project", A.static_name, Opt(A.project_extension), "is", A.declarative_items, "end", A.static_name, ";"), project=Project( A.context_clauses, A.project_declaration, ), # ----------------------------------------------- declarative items declarative_items=List(A.declarative_item, empty_valid=True), declarative_item=Or(A.simple_declarative_item, A.typed_string_decl, A.package_decl), simple_declarative_items=List(A.simple_declarative_item, empty_valid=True), simple_declarative_item=Or(A.variable_decl, A.attribute_decl, A.case_construction, A.empty_declaration), variable_decl=VariableDecl(A.identifier, Opt(Pick(":", A.type_reference)), ":=", A.expression, ";"), attribute_decl=AttributeDecl( "for", A.identifier, Opt(Pick("(", A.associative_array_index, ")")), "use", A.expression, ";"), associative_array_index=Or(A.others_designator, A.string_literal_at), package_decl=PackageDecl("package", A.identifier, Or(A.package_renaming, A.package_spec), ";"), package_renaming=PackageRenaming("renames", A.identifier, ".", A.identifier), package_extension=PackageExtension( "extends", A.identifier, ".", A.identifier, ), package_spec=PackageSpec(Opt(A.package_extension), "is", A.simple_declarative_items, "end", A.identifier), empty_declaration=EmptyDecl("null", ";"), case_construction=CaseConstruction("case", A.variable_reference, "is", List(A.case_item, empty_valid=True), "end", "case", ";"), case_item=CaseItem( "when", A.discrete_choice_list, "=>", # ??? A.declarative_items A.simple_declarative_items), others_designator=OthersDesignator("others"), choice=Or(A.string_literal, A.others_designator), discrete_choice_list=List(A.choice, sep="|", list_cls=Choices), )
A.add_rules( identifier=Tok(Token.Identifier, keep=True) ^ Identifier, enum_identifier=Tok(Token.Identifier, keep=True) ^ EnumIdentifier, char_literal=Tok(Token.Char, keep=True) ^ CharLiteral, string_literal=Tok(Token.String, keep=True) ^ StringLiteral, num_literal=Tok(Token.Number, keep=True) ^ NumLiteral, null_literal=Tok(Token.Null, keep=True) ^ NullLiteral, allocator=Row( "new", Opt("(", A.name, ")")[1], A.type_expression | A.name ) ^ Allocator, for_loop_parameter_spec=Row( A.identifier, Or(Enum("in", IterType("in")), Enum("of", IterType("of"))), Opt("reverse").as_bool(), A.constrained_type_ref | A.discrete_range | A.expression ) ^ ForLoopSpec, quantified_expression=Row( "for", Or(Enum("all", Quantifier("all")), Enum("some", Quantifier("some"))), A.for_loop_parameter_spec, "=>", A.expression | A.discrete_range ) ^ QuantifiedExpr, attribute=Or( Or("access", "delta", "digits", "mod", "range") ^ Attribute, A.identifier ), case_expression=Row( "case", A.expression, "is", List(A.case_expr_alt, sep=",") ) ^ CaseExpr, case_expr_alt=Row( "when", A.choice_list, "=>", A.expression ) ^ CaseExprAlternative, raise_expression=Or( Row("raise", A.name, Opt("with", A.expression)[1]) ^ RaiseExpression, Row("raise", Null(Expr), Null(Expr)) ^ RaiseExpression, ), if_expression=Row( "if", A.expression, "then", A.expression, List(Row("elsif", A.expression, "then", A.expression) ^ ElsifExprPart, empty_valid=True), Opt("else", A.expression)[1], ) ^ IfExpr, conditional_expression=Or(A.if_expression, A.case_expression, A.quantified_expression), diamond_expr=Tok("<>") ^ DiamondExpr, others_designator=Tok("others") ^ OthersDesignator, aggregate_field=Or( A.choice_list ^ AggregateMember, A.expression, A.others_designator, ), aggregate_assoc=Row( Opt(A.aggregate_field, "=>")[0], Or(A.diamond_expr, A.expression) ) ^ AggregateAssoc, aggregate_content=List(A.aggregate_assoc, sep=",") ^ AggregateContent, aggregate_content_null=Row( "null", "record", Null(AggregateContent) )[2], aggregate=Row( "(", Row( Opt(A.expression, "with")[0], Or(A.aggregate_content_null, A.aggregate_content) ) ^ Aggregate, ")")[1], direct_name=Or(A.identifier, A.string_literal, A.char_literal, A.access_deref, A.attribute), param_assoc=Row( Opt(A.identifier | A.others_designator | A.string_literal, "=>")[0], A.expression | A.diamond_expr ) ^ ParamAssoc, call_suffix=Or( A.discrete_range, List(A.param_assoc, sep=",") ^ ParamList ), name=Or( Row(A.name, Tok("(", keep=True), A.call_suffix, ")") ^ CallExpr, Row(A.name, ".", A.direct_name) ^ Prefix, Row(A.name, "'", A.attribute, Opt("(", A.call_suffix, ")")[1]) ^ AttributeRef, Row(A.name, "'", Or(Row("(", A.expression, ")")[1], A.aggregate)) ^ QualExpr, A.direct_name, ), access_deref=Tok("all") ^ AccessDeref, static_name=List( # We want to accept string literals here for the corner case of library # child unit subprogram operators, such as: # procedure Ada.Containers.Vector."=" is ... A.identifier | A.string_literal, sep=".", revtree=NamePrefix ), primary=Or(A.num_literal, A.null_literal, A.name, A.allocator, A.conditional_expression, A.raise_expression, Row("(", A.conditional_expression | A.expression, ")")[1], A.aggregate), factor=Or( Row(Or(Enum("abs", Op("abs")), Enum("not", Op("not"))), A.primary) ^ UnOp, Row(A.primary, Enum("**", Op("pow")), A.primary) ^ BinOp, A.primary ), term=Or( Row(A.factor, Or(Enum("*", Op("mult")), Enum("/", Op("div")), Enum("mod", Op("mod")), Enum("rem", Op("rem"))), A.term) ^ BinOp, A.factor ), unop_term=Or( Row(Or(Enum("+", Op("plus")), Enum("-", Op("minus"))), A.term) ^ UnOp, A.term ), simple_expr=Or( Row(A.unop_term, Or(Enum("+", Op("plus")), Enum("-", Op("minus")), Enum("&", Op("bin_and"))), A.simple_expr_2) ^ BinOp, A.unop_term ), simple_expr_2=Or( Row(A.term, Or(Enum("+", Op("plus")), Enum("-", Op("minus")), Enum("&", Op("bin_and"))), A.simple_expr_2) ^ BinOp, A.term ), boolean_op=Or( Enum("xor", Op("xor")), Enum(Row("and", "then"), Op("and_then")), Enum("and", Op("and")), Enum(Row("or", "else"), Op("or_else")), Enum("or", Op("or")), ), discrete_range=Row(A.expression, Enum("..", Op("ellipsis")), A.expression) ^ BinOp, range_expression=Or( A.discrete_range ), choice=Or(A.range_expression, A.expression, A.others_designator), choice_list=List(A.choice, sep="|"), rel_op=Or( Enum(Row("not", "in"), Op("not_in")), Enum("in", Op("in")), ), relation=Or( Row(A.simple_expr, Or(Enum("=", Op("eq")), Enum("/=", Op("neq")), Enum("<", Op("lt")), Enum("<=", Op("lte")), Enum(">", Op("gt")), Enum(">=", Op("gte"))), A.relation) ^ BinOp, Row(A.simple_expr, A.rel_op, A.choice_list) ^ MembershipExpr, A.simple_expr ), expression=Or( Row(A.relation, A.boolean_op, A.expression) ^ BinOp, A.relation ), )
from langkit.parsers import List from langkit.dsl import Field, T from language.parser import A, GPRNode class TypedStringDecl(GPRNode): type_id = Field(type=T.Identifier) string_literals = Field(type=T.StringLiteral.list) A.add_rules(typed_string_decl=TypedStringDecl( "type", A.identifier, "is", "(", List(A.string_literal, sep=","), ")", ";", ), )
A.add_rules( generic_decl=Or( Row(A.generic_formal_part, A.subprogram_spec) ^ GenericSubprogramDecl, Row(A.generic_formal_part, A.base_package_decl) ^ GenericPackageDecl ), generic_formal_part=Row( "generic", List(Row(A.generic_formal_decl | A.use_decl, ";")[0], empty_valid=True) )[1], generic_formal_decl=Or( A.pragma, A.object_decl, A.full_type_decl, A.formal_subp_decl, Row("with", A.generic_instantiation)[1] ), formal_subp_decl=Row( "with", A.subprogram_spec, _(Opt("is")), Opt("abstract").as_bool(), Opt(Or(A.diamond_expr, A.static_name, A.null_literal)) ) ^ FormalSubpDecl, renaming_clause=Row("renames", A.name) ^ RenamingClause, generic_renaming_decl=Row( "generic", _(Or("package", "function", "procedure")), A.static_name, "renames", A.static_name, A.aspect_specification ) ^ GenericRenamingDecl, generic_instantiation=Row( _(Or("package", "function", "procedure")), A.static_name, "is", "new", A.static_name, Opt("(", A.call_suffix, ")")[1], A.aspect_specification ) ^ GenericInstantiation, exception_decl=Row( A.id_list, ":", "exception", Opt(A.renaming_clause), A.aspect_specification ) ^ ExceptionDecl, basic_decls=List(Row(A.basic_decl, ";")[0], empty_valid=True), package_renaming_decl=Row( "package", A.static_name, A.renaming_clause, A.aspect_specification ) ^ PackageRenamingDecl, package_decl=package_decl_factory() ^ PackageDecl, base_package_decl=package_decl_factory() ^ BasePackageDecl, basic_decl=Or( A.body, A.body_stub, A.full_type_decl, A.task_type_decl, A.protected_type_decl, A.subprogram_decl, A.subtype_decl, A.object_decl, A.package_decl, A.generic_instantiation, A.aspect_clause, A.use_decl, A.exception_decl, A.package_renaming_decl, A.generic_renaming_decl, A.generic_decl, A.pragma ), object_decl=Or( A.sub_object_decl, A.task_decl, A.protected_decl, A.number_decl ), sub_object_decl=Row( A.id_list, ":", Opt("aliased").as_bool(), Opt("constant").as_bool(), Opt(A.in_out), A.type_expression | A.array_type_def, A.default_expr, Opt(A.renaming_clause), A.aspect_specification ) ^ ObjectDecl, id_list=List(A.identifier, sep=","), number_decl=Row( A.id_list, ":", "constant", ":=", A.simple_expr ) ^ NumberDecl, aspect_assoc=Row( A.name, Opt("=>", A.expression)[1] ) ^ AspectAssoc, aspect_specification=Opt( Row( "with", List(A.aspect_assoc, sep=",") ) ^ AspectSpecification ), protected_decl=Row( "protected", A.identifier, A.aspect_specification, "is", A.protected_def ) ^ ProtectedDecl, task_decl=Row("task", A.identifier, A.aspect_specification, Opt("is", A.task_def)[1]) ^ TaskDecl, overriding_indicator=Or( Enum("overriding", Overriding("overriding")), Enum(Row("not", "overriding"), Overriding("not_overriding")), Enum(None, Overriding("unspecified")) ), entry_decl=Row( A.overriding_indicator, "entry", A.identifier, Opt("(", A.type_ref, ")")[1], Opt(A.parameter_profiles), A.aspect_specification ) ^ EntryDecl, rep_component_clause=Row( A.identifier, "at", A.simple_expr, A.range_spec ) ^ RecordRepComponent, aspect_clause=Or( Row("for", A.name, "use", A.expression) ^ AttributeDefClause, Row("for", A.static_name, "use", A.aggregate) ^ EnumRepClause, Row("for", A.static_name, "use", "record", Opt("at", "mod", A.simple_expr)[2], List(Row(A.rep_component_clause, ";")[0], empty_valid=True), "end", "record") ^ RecordRepClause, Row("for", A.direct_name, "use", "at", A.expression) ^ AtClause ), parameter_profile=Row( List(A.identifier, sep=","), ":", Opt("aliased").as_bool(), Opt(A.in_out), A.type_expression, Opt(":=", A.expression)[1], ) ^ ParameterProfile, parameter_profiles=Row("(", List(A.parameter_profile, sep=";"), ")")[1], subprogram_spec=Row( _(Or("procedure", "function")), Opt(A.static_name), Opt( Row( "(", List(A.parameter_profile, sep=";"), Opt(")").error() )[1] ), Opt("return", A.type_expression)[1] ) ^ SubprogramSpec, subprogram_decl=Row( A.overriding_indicator, A.subprogram_spec, Opt("is", "null").as_bool(), Opt("is", "abstract").as_bool(), Opt("is", A.expression)[1], Opt(A.renaming_clause), A.aspect_specification, ) ^ SubprogramDecl, type_access_expression=Row( "access", Opt("all").as_bool(), Opt("constant").as_bool(), A.name ) ^ TypeAccessExpression, with_decl=Row( Opt("limited").as_bool(), Opt("private").as_bool(), "with", List(A.static_name, sep=",") ) ^ WithDecl, context_item=Or(A.with_decl, A.use_decl, A.pragma), use_decl=Or(A.use_package_decl, A.use_type_decl), use_package_decl=Row("use", List(A.static_name, sep=",")) ^ UsePkgDecl, use_type_decl=Row("use", Opt("all").as_bool(), "type", List(A.name, sep=",")) ^ UseTypDecl, subprogram_access_expression=Row( "access", Opt("protected").as_bool(), A.subprogram_spec ) ^ SubprogramAccessExpression, access_expression=Or(A.subprogram_access_expression, A.type_access_expression), type_ref=Row( A.name, Opt(A.constraint) ) ^ TypeRef, constrained_type_ref=Row( A.name, A.constraint ) ^ TypeRef, type_expression=Row( Opt("not", "null").as_bool(), Or(A.access_expression, A.type_ref), ) ^ TypeExpression, in_out=Or( Enum(Row("in", "out"), InOut("inout")), Enum("in", InOut("in")), Enum("out", InOut("out")), Enum(None, InOut("in")) ), ########### # Pragmas # ########### pragma_arg=Row( Opt(A.identifier, "=>")[0], A.expression ) ^ PragmaArgument, pragma=Row("pragma", A.identifier, Opt("(", List(A.pragma_arg, ","), ")")[1]) ^ Pragma, )
A.add_rules( project_qualifier=Or( ProjectQualifier.alt_abstract("abstract"), ProjectQualifier.alt_library(l_id("library")), ProjectQualifier.alt_aggregate_library(l_id("aggregate"), l_id("library")), ProjectQualifier.alt_aggregate(l_id("aggregate")), ProjectQualifier.alt_configuration(l_id("configuration")), ProjectQualifier.alt_standard(l_id("standard")), ), project_extension=ProjectExtension("extends", Opt("all").as_bool(AllQualifier), A.string_literal), project_declaration=ProjectDeclaration( Opt(A.project_qualifier), l_id("project"), A.static_name, Opt(A.project_extension), "is", A.declarative_items, "end", A.static_name, ";", ), project=Project( A.context_clauses, A.project_declaration, ), # ----------------------------------------------- declarative items declarative_items=List(A.declarative_item, empty_valid=True), declarative_item=Or(A.simple_declarative_item, A.typed_string_decl, A.package_decl), simple_declarative_items=List(A.simple_declarative_item, empty_valid=True), simple_declarative_item=Or( A.variable_decl, A.attribute_decl, A.case_construction, A.empty_declaration, ), variable_decl=VariableDecl(A.identifier, Opt(Pick(":", A.type_reference)), ":=", A.expression, ";"), attribute_decl=AttributeDecl( "for", A.identifier, Opt(Pick("(", A.associative_array_index, ")")), "use", A.expression, ";", ), associative_array_index=Or(A.others_designator, A.string_literal_at), package_decl=PackageDecl("package", A.identifier, Or(A.package_renaming, A.package_spec), ";"), package_renaming=PackageRenaming("renames", List(A.identifier, sep=".")), package_extension=PackageExtension("extends", List(A.identifier, sep=".")), package_spec=PackageSpec( Opt(A.package_extension), "is", A.simple_declarative_items, "end", A.identifier, ), empty_declaration=EmptyDecl("null", ";"), case_construction=CaseConstruction( "case", A.variable_reference, "is", List(A.case_item, empty_valid=True), "end", "case", ";", ), case_item=CaseItem( "when", A.discrete_choice_list, "=>", # ??? A.declarative_items A.simple_declarative_items, ), others_designator=OthersDesignator("others"), choice=Or(A.string_literal, A.others_designator), discrete_choice_list=List(A.choice, sep="|", list_cls=Choices), with_decl=WithDecl( Opt("limited").as_bool(Limited), "with", List(A.string_literal, sep=","), ";", ), context_clauses=List(A.with_decl, empty_valid=True), # Ada context clauses parsing ######################################### ada_with_clause=AdaWith( Limited("limited"), Private("private"), "with", List(A.static_name, sep=","), ";", ), ada_context=List(A.ada_context_item, empty_valid=True), ada_context_item=Or(A.ada_with_clause, A.ada_use_clause, A.ada_pragma), ada_context_skip=List(Or(Skip(AdaSkip), )), ada_use_clause=AdaUse("use", A.ada_context_skip.dont_skip(";"), ";"), ada_pragma=AdaPragma("pragma", A.ada_context_skip.dont_skip(";"), ";"), ada_subp_kind=Or(AdaEntityKind.alt_procedure(l_id("procedure")), AdaEntityKind.alt_function(l_id("function"))), ada_pkg_kind=AdaEntityKind.alt_package("package"), ada_library_item=AdaLibraryItem( Opt( AdaGeneric( l_id("generic"), List( Or( # Parse formals that start with "with". AdaWithFormal( "with", # We want to parse the subprogram or package's starting # keyword explicitly, because it cannot be skipped. Or(A.ada_subp_kind, A.ada_pkg_kind), A.ada_context_skip.dont_skip(";")), # Parse accesses to subprograms (we need to handle those # explicitly for the same reason as above, because they cannot # be skipped since they contain "function"/"procedure" AdaAccessSubp(l_id("access"), A.ada_subp_kind, A.ada_context_skip.dont_skip(";")), Skip(AdaSkip), ), empty_valid=True) # Don't skip procedure/function/package in the general case since # that's the start of the library item we're looking for. .dont_skip(Or(l_id('procedure'), l_id('function'), 'package')))), Opt(AdaSeparate(l_id("separate"), "(", A.static_name, ")")), Or( AdaSubp(A.ada_subp_kind, A.static_name), AdaPkgBody("package", l_id("body"), A.static_name), AdaPkg(Private("private"), "package", A.static_name), )), ada_prelude=AdaPrelude(A.ada_context, A.ada_library_item), # end Ada with clauses parsing ######################################### )
A.add_rules( subunit=Row( "separate", "(", A.static_name, ")", Or(A.subprogram_body, A.package_body, A.task_body, A.protected_body) ) ^ Subunit, library_unit_body=Or( A.subprogram_body, A.package_body ), library_unit_decl=Or( A.subprogram_decl, A.generic_decl, A.package_decl, A.generic_instantiation ), library_unit_renaming_decl=Or( A.package_renaming_decl, A.generic_renaming_decl, ), library_item=Row( Opt("private").as_bool(), Or(A.library_unit_body, A.library_unit_decl, A.library_unit_renaming_decl) ) ^ LibraryItem, compilation_unit=Row( List(Row(A.context_item, ";")[0], empty_valid=True), List(Row(A.library_item | A.subunit | A.generic_instantiation | A.pragma, ";")[0], empty_valid=True), ) ^ CompilationUnit, entry_body=Row( "entry", A.identifier, Opt(Row("(", "for", A.identifier, "in", A.discrete_subtype_definition, ")") ^ EntryIndexSpec), Opt(A.parameter_profiles), "when", A.expression, "is", A.basic_decls, Opt("begin", A.handled_statements)[1], "end", _(Opt(A.static_name)) ) ^ EntryBody, protected_body=Row( "protected", "body", A.static_name, A.aspect_specification, "is", Opt(A.basic_decls, "end", Opt(A.static_name))[0], Opt((Row("separate", A.aspect_specification)[1]) ^ BodyStub) ) ^ ProtectedBody, task_body=Row( "task", "body", A.static_name, A.aspect_specification, "is", A.basic_decls, Opt("begin", A.handled_statements)[1], "end", _(Opt(A.static_name)) ) ^ TaskBody, package_body_stub=Row( "package", "body", A.static_name, "is", "separate", A.aspect_specification ) ^ PackageBodyStub, package_body=Row( "package", "body", A.static_name, A.aspect_specification, "is", A.basic_decls, Opt("begin", A.handled_statements)[1], "end", _(Opt(A.static_name)) ) ^ PackageBody, terminate_statement=Row("terminate") ^ TerminateStatement, select_statement=Row( "select", List( Row(Opt("when", A.expression, "=>")[1], A.statements) ^ SelectWhenPart, sep="or"), Opt("else", A.statements)[1], Opt("then", "abort", A.statements)[2], "end", "select" ) ^ SelectStatement, accept_statement=Row( "accept", A.identifier, Opt("(", A.expression, ")")[1], Opt(A.parameter_profiles), Opt("do", A.handled_statements, "end", Opt(A.identifier))[1] ) ^ AcceptStatement, case_alt=Row( "when", A.choice_list, "=>", A.statements ) ^ CaseStatementAlternative, case_statement=Row( "case", A.expression, "is", List(A.case_alt), "end", "case" ) ^ CaseStatement, ext_return_statement=Row( "return", A.sub_object_decl, Opt("do", A.handled_statements, "end", "return")[1] ) ^ ExtReturnStatement, block_statement=Row( Opt(A.identifier, ":")[0], Opt("declare", A.basic_decls)[1], "begin", A.handled_statements, "end", _(Opt(A.identifier)) ) ^ BlockStatement, loop_statement=Row( Opt(A.identifier, ":")[0], Opt(A.iteration_scheme), "loop", A.statements, "end", "loop", _(Opt(A.identifier)) ) ^ LoopStatement, iteration_scheme=Or( Row("for", A.for_loop_parameter_spec)[1], Row("while", A.expression) ^ WhileLoopSpec ), compound_statement=Or(A.if_statement, A.block_statement, A.loop_statement, A.ext_return_statement, A.case_statement, A.accept_statement, A.select_statement), if_statement=Row( "if", A.expression, "then", A.statements, List(Row("elsif", A.expression, "then", A.statements) ^ ElsifStatementPart, empty_valid=True), Opt("else", A.statements)[1], "end", "if" ) ^ IfStatement, raise_statement=Or( Row("raise", A.name, Opt("with", A.expression)[1]) ^ RaiseStatement, Row("raise", Null(Expr), Null(Expr)) ^ RaiseStatement, ), delay_statement=Row( "delay", Opt("until").as_bool(), A.expression ) ^ DelayStatement, abort_statement=Row( "abort", List(A.static_name, sep=",") ) ^ AbortStatement, body=Or(A.subprogram_body, A.package_body, A.task_body, A.protected_body, A.entry_body), body_stub=Or(A.subprogram_body_stub, A.package_body_stub), subprogram_body_stub=Row( A.overriding_indicator, A.subprogram_spec, "is", "separate", A.aspect_specification ) ^ SubprogramBodyStub, subprogram_body=Row( A.overriding_indicator, A.subprogram_spec, A.aspect_specification, "is", A.basic_decls, "begin", A.handled_statements, "end", Opt(A.name) ) ^ SubprogramBody, handled_statements=Row( A.statements, Opt("exception", List(A.exception_handler))[1] ) ^ HandledStatements, exception_handler=Row( "when", Opt(A.identifier, ":")[0], List(A.name | A.others_designator, sep="|"), "=>", A.statements ) ^ ExceptionHandler, statements=List(Or(Row(A.statement, Opt(";").error())[0], A.label), empty_valid=True), label=Tok(Token.Label) ^ Label, statement=Or(A.compound_statement, A.simple_statement), simple_statement=Or(A.null_statement, A.assignment_statement, A.goto_statement, A.exit_statement, A.return_statement, A.requeue_statement, A.name, A.abort_statement, A.delay_statement, A.raise_statement, A.terminate_statement, A.pragma), null_statement=A.null_literal ^ NullStatement, assignment_statement=Row(A.name, ":=", A.expression) ^ AssignStatement, goto_statement=Row("goto", A.identifier) ^ GotoStatement, exit_statement=Row("exit", Opt(A.identifier), Opt("when", A.expression)[1]) ^ ExitStatement, return_statement=( Row("return", Opt(A.expression | A.raise_statement)) ^ ReturnStatement ), requeue_statement=Row( "requeue", A.expression, Opt("with", "abort").as_bool() ) ^ RequeueStatement, )