freebsd-ports - FreeBSD Ports (https://github.com/freebsd/freebsd-ports)

diff options

author	Greg Lewis <glewis@FreeBSD.org>	2005-11-02 06:01:12 +0800
committer	Greg Lewis <glewis@FreeBSD.org>	2005-11-02 06:01:12 +0800
commit	5c2fd494ba788d2a145c1d250f5bfef73eeda019 (patch)
tree	8c959ac7a1b6836228c020a9d9c6e413938927a2 /java
parent	b0f40404815ddde06a9ac4e06c988ce7bffdc74d (diff)
download	freebsd-ports-5c2fd494ba788d2a145c1d250f5bfef73eeda019.tar.gz freebsd-ports-5c2fd494ba788d2a145c1d250f5bfef73eeda019.tar.zst freebsd-ports-5c2fd494ba788d2a145c1d250f5bfef73eeda019.zip

. Update to 1.4.2_10.

Notes

Notes: svn path=/head/; revision=146957

Diffstat (limited to 'java')

-rw-r--r--

java/linux-sun-jdk14/Makefile

-rw-r--r--

java/linux-sun-jdk14/distinfo

-rw-r--r--

java/linux-sun-jdk14/pkg-plist

3 files changed, 6 insertions, 4 deletions

/* This file is part of cpp-ethereum. cpp-ethereum is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. cpp-ethereum is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>. */ /** * @author Christian <c@ethdev.com> * @date 2014 * Solidity abstract syntax tree. */ #pragma once #include <string> #include <vector> #include <memory> #include <boost/noncopyable.hpp> #include <libevmasm/SourceLocation.h> #include <libsolidity/interface/Utils.h> #include <libsolidity/ast/ASTForward.h> #include <libsolidity/parsing/Token.h> #include <libsolidity/ast/Types.h> #include <libsolidity/interface/Exceptions.h> #include <libsolidity/ast/ASTAnnotations.h> namespace dev { namespace solidity { class ASTVisitor; class ASTConstVisitor; /** * The root (abstract) class of the AST inheritance tree. * It is possible to traverse all direct and indirect children of an AST node by calling * accept, providing an ASTVisitor. */ class ASTNode: private boost::noncopyable { public: explicit ASTNode(SourceLocation const& _location); virtual ~ASTNode(); virtual void accept(ASTVisitor& _visitor) = 0; virtual void accept(ASTConstVisitor& _visitor) const = 0; template <class T> static void listAccept(std::vector<T> const& _list, ASTVisitor& _visitor) { for (T const& element: _list) element->accept(_visitor); } template <class T> static void listAccept(std::vector<T> const& _list, ASTConstVisitor& _visitor) { for (T const& element: _list) element->accept(_visitor); } /// @returns a copy of the vector containing only the nodes which derive from T. template <class _T> static std::vector<_T const*> filteredNodes(std::vector<ASTPointer<ASTNode>> const& _nodes); /// Returns the source code location of this node. SourceLocation const& location() const { return m_location; } /// Creates a @ref TypeError exception and decorates it with the location of the node and /// the given description Error createTypeError(std::string const& _description) const; ///@todo make this const-safe by providing a different way to access the annotation virtual ASTAnnotation& annotation() const; ///@{ ///@name equality operators /// Equality relies on the fact that nodes cannot be copied. bool operator==(ASTNode const& _other) const { return this == &_other; } bool operator!=(ASTNode const& _other) const { return !operator==(_other); } ///@} protected: /// Annotation - is specialised in derived classes, is created upon request (because of polymorphism). mutable ASTAnnotation* m_annotation = nullptr; private: SourceLocation m_location; }; template <class _T> std::vector<_T const*> ASTNode::filteredNodes(std::vector<ASTPointer<ASTNode>> const& _nodes) { std::vector<_T const*> ret; for (auto const& n: _nodes) if (auto const* nt = dynamic_cast<_T const*>(n.get())) ret.push_back(nt); return ret; } /** * Source unit containing import directives and contract definitions. */ class SourceUnit: public ASTNode { public: SourceUnit(SourceLocation const& _location, std::vector<ASTPointer<ASTNode>> const& _nodes): ASTNode(_location), m_nodes(_nodes) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; std::vector<ASTPointer<ASTNode>> nodes() const { return m_nodes; } private: std::vector<ASTPointer<ASTNode>> m_nodes; }; /** * Import directive for referencing other files / source objects. * Example: import "abc.sol" * Source objects are identified by a string which can be a file name but does not have to be. */ class ImportDirective: public ASTNode { public: ImportDirective(SourceLocation const& _location, ASTPointer<ASTString> const& _identifier): ASTNode(_location), m_identifier(_identifier) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; ASTString const& identifier() const { return *m_identifier; } private: ASTPointer<ASTString> m_identifier; }; /** * Abstract AST class for a declaration (contract, function, struct, variable). */ class Declaration: public ASTNode { public: /// Visibility ordered from restricted to unrestricted. enum class Visibility { Default, Private, Internal, Public, External }; Declaration( SourceLocation const& _location, ASTPointer<ASTString> const& _name, Visibility _visibility = Visibility::Default ): ASTNode(_location), m_name(_name), m_visibility(_visibility), m_scope(nullptr) {} /// @returns the declared name. ASTString const& name() const { return *m_name; } Visibility visibility() const { return m_visibility == Visibility::Default ? defaultVisibility() : m_visibility; } bool isPublic() const { return visibility() >= Visibility::Public; } virtual bool isVisibleInContract() const { return visibility() != Visibility::External; } bool isVisibleInDerivedContracts() const { return isVisibleInContract() && visibility() >= Visibility::Internal; } /// @returns the scope this declaration resides in. Can be nullptr if it is the global scope. /// Available only after name and type resolution step. Declaration const* scope() const { return m_scope; } void setScope(Declaration const* _scope) { m_scope = _scope; } virtual bool isLValue() const { return false; } virtual bool isPartOfExternalInterface() const { return false; } /// @returns the type of expressions referencing this declaration. /// The current contract has to be given since this context can change the type, especially of /// contract types. /// This can only be called once types of variable declarations have already been resolved. virtual TypePointer type() const = 0; protected: virtual Visibility defaultVisibility() const { return Visibility::Public; } private: ASTPointer<ASTString> m_name; Visibility m_visibility; Declaration const* m_scope; }; /** * Abstract class that is added to each AST node that can store local variables. */ class VariableScope { public: void addLocalVariable(VariableDeclaration const& _localVariable) { m_localVariables.push_back(&_localVariable); } std::vector<VariableDeclaration const*> const& localVariables() const { return m_localVariables; } private: std::vector<VariableDeclaration const*> m_localVariables; }; /** * Abstract class that is added to each AST node that can receive documentation. */ class Documented { public: explicit Documented(ASTPointer<ASTString> const& _documentation): m_documentation(_documentation) {} /// @return A shared pointer of an ASTString. /// Can contain a nullptr in which case indicates absence of documentation ASTPointer<ASTString> const& documentation() const { return m_documentation; } protected: ASTPointer<ASTString> m_documentation; }; /** * Abstract class that is added to AST nodes that can be marked as not being fully implemented */ class ImplementationOptional { public: explicit ImplementationOptional(bool _implemented): m_implemented(_implemented) {} /// @return whether this node is fully implemented or not bool isImplemented() const { return m_implemented; } protected: bool m_implemented; }; /// @} /** * Definition of a contract or library. This is the only AST nodes where child nodes are not visited in * document order. It first visits all struct declarations, then all variable declarations and * finally all function declarations. */ class ContractDefinition: public Declaration, public Documented { public: ContractDefinition( SourceLocation const& _location, ASTPointer<ASTString> const& _name, ASTPointer<ASTString> const& _documentation, std::vector<ASTPointer<InheritanceSpecifier>> const& _baseContracts, std::vector<ASTPointer<ASTNode>> const& _subNodes, bool _isLibrary ): Declaration(_location, _name), Documented(_documentation), m_baseContracts(_baseContracts), m_subNodes(_subNodes), m_isLibrary(_isLibrary) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; std::vector<ASTPointer<InheritanceSpecifier>> const& baseContracts() const { return m_baseContracts; } std::vector<ASTPointer<ASTNode>> const& subNodes() const { return m_subNodes; } std::vector<UsingForDirective const*> usingForDirectives() const { return filteredNodes<UsingForDirective>(m_subNodes); } std::vector<StructDefinition const*> definedStructs() const { return filteredNodes<StructDefinition>(m_subNodes); } std::vector<EnumDefinition const*> definedEnums() const { return filteredNodes<EnumDefinition>(m_subNodes); } std::vector<VariableDeclaration const*> stateVariables() const { return filteredNodes<VariableDeclaration>(m_subNodes); } std::vector<ModifierDefinition const*> functionModifiers() const { return filteredNodes<ModifierDefinition>(m_subNodes); } std::vector<FunctionDefinition const*> definedFunctions() const { return filteredNodes<FunctionDefinition>(m_subNodes); } std::vector<EventDefinition const*> events() const { return filteredNodes<EventDefinition>(m_subNodes); } std::vector<EventDefinition const*> const& interfaceEvents() const; bool isLibrary() const { return m_isLibrary; } /// @returns a map of canonical function signatures to FunctionDefinitions /// as intended for use by the ABI. std::map<FixedHash<4>, FunctionTypePointer> interfaceFunctions() const; std::vector<std::pair<FixedHash<4>, FunctionTypePointer>> const& interfaceFunctionList() const; /// @returns a list of the inheritable members of this contract std::vector<Declaration const*> const& inheritableMembers() const; /// Returns the constructor or nullptr if no constructor was specified. FunctionDefinition const* constructor() const; /// Returns the fallback function or nullptr if no fallback function was specified. FunctionDefinition const* fallbackFunction() const; std::string const& userDocumentation() const; void setUserDocumentation(std::string const& _userDocumentation); std::string const& devDocumentation() const; void setDevDocumentation(std::string const& _devDocumentation); virtual TypePointer type() const override; virtual ContractDefinitionAnnotation& annotation() const override; private: std::vector<ASTPointer<InheritanceSpecifier>> m_baseContracts; std::vector<ASTPointer<ASTNode>> m_subNodes; bool m_isLibrary; // parsed Natspec documentation of the contract. std::string m_userDocumentation; std::string m_devDocumentation; std::vector<ContractDefinition const*> m_linearizedBaseContracts; mutable std::unique_ptr<std::vector<std::pair<FixedHash<4>, FunctionTypePointer>>> m_interfaceFunctionList; mutable std::unique_ptr<std::vector<EventDefinition const*>> m_interfaceEvents; mutable std::unique_ptr<std::vector<Declaration const*>> m_inheritableMembers; }; class InheritanceSpecifier: public ASTNode { public: InheritanceSpecifier( SourceLocation const& _location, ASTPointer<Identifier> const& _baseName, std::vector<ASTPointer<Expression>> _arguments ): ASTNode(_location), m_baseName(_baseName), m_arguments(_arguments) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; Identifier const& name() const { return *m_baseName; } std::vector<ASTPointer<Expression>> const& arguments() const { return m_arguments; } private: ASTPointer<Identifier> m_baseName; std::vector<ASTPointer<Expression>> m_arguments; }; /** * `using LibraryName for uint` will attach all functions from the library LibraryName * to `uint` if the first parameter matches the type. `using LibraryName for *` attaches * the function to any matching type. */ class UsingForDirective: public ASTNode { public: UsingForDirective( SourceLocation const& _location, ASTPointer<Identifier> const& _libraryName, ASTPointer<TypeName> const& _typeName ): ASTNode(_location), m_libraryName(_libraryName), m_typeName(_typeName) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; Identifier const& libraryName() const { return *m_libraryName; } /// @returns the type name the library is attached to, null for `*`. TypeName const* typeName() const { return m_typeName.get(); } private: ASTPointer<Identifier> m_libraryName; ASTPointer<TypeName> m_typeName; }; class StructDefinition: public Declaration { public: StructDefinition( SourceLocation const& _location, ASTPointer<ASTString> const& _name, std::vector<ASTPointer<VariableDeclaration>> const& _members ): Declaration(_location, _name), m_members(_members) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; std::vector<ASTPointer<VariableDeclaration>> const& members() const { return m_members; } virtual TypePointer type() const override; virtual TypeDeclarationAnnotation& annotation() const override; private: std::vector<ASTPointer<VariableDeclaration>> m_members; }; class EnumDefinition: public Declaration { public: EnumDefinition( SourceLocation const& _location, ASTPointer<ASTString> const& _name, std::vector<ASTPointer<EnumValue>> const& _members ): Declaration(_location, _name), m_members(_members) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; std::vector<ASTPointer<EnumValue>> const& members() const { return m_members; } virtual TypePointer type() const override; virtual TypeDeclarationAnnotation& annotation() const override; private: std::vector<ASTPointer<EnumValue>> m_members; }; /** * Declaration of an Enum Value */ class EnumValue: public Declaration { public: EnumValue(SourceLocation const& _location, ASTPointer<ASTString> const& _name): Declaration(_location, _name) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; virtual TypePointer type() const override; }; /** * Parameter list, used as function parameter list and return list. * None of the parameters is allowed to contain mappings (not even recursively * inside structs). */ class ParameterList: public ASTNode { public: ParameterList( SourceLocation const& _location, std::vector<ASTPointer<VariableDeclaration>> const& _parameters ): ASTNode(_location), m_parameters(_parameters) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; std::vector<ASTPointer<VariableDeclaration>> const& parameters() const { return m_parameters; } private: std::vector<ASTPointer<VariableDeclaration>> m_parameters; }; /** * Base class for all nodes that define function-like objects, i.e. FunctionDefinition, * EventDefinition and ModifierDefinition. */ class CallableDeclaration: public Declaration, public VariableScope { public: CallableDeclaration( SourceLocation const& _location, ASTPointer<ASTString> const& _name, Declaration::Visibility _visibility, ASTPointer<ParameterList> const& _parameters, ASTPointer<ParameterList> const& _returnParameters = ASTPointer<ParameterList>() ): Declaration(_location, _name, _visibility), m_parameters(_parameters), m_returnParameters(_returnParameters) { } std::vector<ASTPointer<VariableDeclaration>> const& parameters() const { return m_parameters->parameters(); } ParameterList const& parameterList() const { return *m_parameters; } ASTPointer<ParameterList> const& returnParameterList() const { return m_returnParameters; } protected: ASTPointer<ParameterList> m_parameters; ASTPointer<ParameterList> m_returnParameters; }; class FunctionDefinition: public CallableDeclaration, public Documented, public ImplementationOptional { public: FunctionDefinition( SourceLocation const& _location, ASTPointer<ASTString> const& _name, Declaration::Visibility _visibility, bool _isConstructor, ASTPointer<ASTString> const& _documentation, ASTPointer<ParameterList> const& _parameters, bool _isDeclaredConst, std::vector<ASTPointer<ModifierInvocation>> const& _modifiers, ASTPointer<ParameterList> const& _returnParameters, ASTPointer<Block> const& _body ): CallableDeclaration(_location, _name, _visibility, _parameters, _returnParameters), Documented(_documentation), ImplementationOptional(_body != nullptr), m_isConstructor(_isConstructor), m_isDeclaredConst(_isDeclaredConst), m_functionModifiers(_modifiers), m_body(_body) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; bool isConstructor() const { return m_isConstructor; } bool isDeclaredConst() const { return m_isDeclaredConst; } std::vector<ASTPointer<ModifierInvocation>> const& modifiers() const { return m_functionModifiers; } std::vector<ASTPointer<VariableDeclaration>> const& returnParameters() const { return m_returnParameters->parameters(); } Block const& body() const { return *m_body; } virtual bool isVisibleInContract() const override { return Declaration::isVisibleInContract() && !isConstructor() && !name().empty(); } virtual bool isPartOfExternalInterface() const override { return isPublic() && !m_isConstructor && !name().empty(); } /// @returns the external signature of the function /// That consists of the name of the function followed by the types of the /// arguments separated by commas all enclosed in parentheses without any spaces. std::string externalSignature() const; virtual TypePointer type() const override; virtual FunctionDefinitionAnnotation& annotation() const override; private: bool m_isConstructor; bool m_isDeclaredConst; std::vector<ASTPointer<ModifierInvocation>> m_functionModifiers; ASTPointer<Block> m_body; }; /** * Declaration of a variable. This can be used in various places, e.g. in function parameter * lists, struct definitions and even function bodys. */ class VariableDeclaration: public Declaration { public: enum Location { Default, Storage, Memory }; VariableDeclaration( SourceLocation const& _sourceLocation, ASTPointer<TypeName> const& _type, ASTPointer<ASTString> const& _name, ASTPointer<Expression> _value, Visibility _visibility, bool _isStateVar = false, bool _isIndexed = false, bool _isConstant = false, Location _referenceLocation = Location::Default ): Declaration(_sourceLocation, _name, _visibility), m_typeName(_type), m_value(_value), m_isStateVariable(_isStateVar), m_isIndexed(_isIndexed), m_isConstant(_isConstant), m_location(_referenceLocation) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; TypeName* typeName() const { return m_typeName.get(); } ASTPointer<Expression> const& value() const { return m_value; } virtual bool isLValue() const override; virtual bool isPartOfExternalInterface() const override { return isPublic(); } bool isLocalVariable() const { return !!dynamic_cast<FunctionDefinition const*>(scope()); } /// @returns true if this variable is a parameter or return parameter of a function. bool isCallableParameter() const; /// @returns true if this variable is a parameter (not return parameter) of an external function. bool isExternalCallableParameter() const; /// @returns true if the type of the variable does not need to be specified, i.e. it is declared /// in the body of a function or modifier. bool canHaveAutoType() const; bool isStateVariable() const { return m_isStateVariable; } bool isIndexed() const { return m_isIndexed; } bool isConstant() const { return m_isConstant; } Location referenceLocation() const { return m_location; } virtual TypePointer type() const override; virtual VariableDeclarationAnnotation& annotation() const override; protected: Visibility defaultVisibility() const override { return Visibility::Internal; } private: ASTPointer<TypeName> m_typeName; ///< can be empty ("var") /// Initially assigned value, can be missing. For local variables, this is stored inside /// VariableDeclarationStatement and not here. ASTPointer<Expression> m_value; bool m_isStateVariable; ///< Whether or not this is a contract state variable bool m_isIndexed; ///< Whether this is an indexed variable (used by events). bool m_isConstant; ///< Whether the variable is a compile-time constant. Location m_location; ///< Location of the variable if it is of reference type. }; /** * Definition of a function modifier. */ class ModifierDefinition: public CallableDeclaration, public Documented { public: ModifierDefinition( SourceLocation const& _location, ASTPointer<ASTString> const& _name, ASTPointer<ASTString> const& _documentation, ASTPointer<ParameterList> const& _parameters, ASTPointer<Block> const& _body ): CallableDeclaration(_location, _name, Visibility::Default, _parameters), Documented(_documentation), m_body(_body) { } virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; Block const& body() const { return *m_body; } virtual TypePointer type() const override; virtual ModifierDefinitionAnnotation& annotation() const override; private: ASTPointer<Block> m_body; }; /** * Invocation/usage of a modifier in a function header or a base constructor call. */ class ModifierInvocation: public ASTNode { public: ModifierInvocation( SourceLocation const& _location, ASTPointer<Identifier> const& _name, std::vector<ASTPointer<Expression>> _arguments ): ASTNode(_location), m_modifierName(_name), m_arguments(_arguments) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; ASTPointer<Identifier> const& name() const { return m_modifierName; } std::vector<ASTPointer<Expression>> const& arguments() const { return m_arguments; } private: ASTPointer<Identifier> m_modifierName; std::vector<ASTPointer<Expression>> m_arguments; }; /** * Definition of a (loggable) event. */ class EventDefinition: public CallableDeclaration, public Documented { public: EventDefinition( SourceLocation const& _location, ASTPointer<ASTString> const& _name, ASTPointer<ASTString> const& _documentation, ASTPointer<ParameterList> const& _parameters, bool _anonymous = false ): CallableDeclaration(_location, _name, Visibility::Default, _parameters), Documented(_documentation), m_anonymous(_anonymous) { } virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; bool isAnonymous() const { return m_anonymous; } virtual TypePointer type() const override; virtual EventDefinitionAnnotation& annotation() const override; private: bool m_anonymous = false; }; /** * Pseudo AST node that is used as declaration for "this", "msg", "tx", "block" and the global * functions when such an identifier is encountered. Will never have a valid location in the source code. */ class MagicVariableDeclaration: public Declaration { public: MagicVariableDeclaration(ASTString const& _name, std::shared_ptr<Type const> const& _type): Declaration(SourceLocation(), std::make_shared<ASTString>(_name)), m_type(_type) {} virtual void accept(ASTVisitor&) override { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("MagicVariableDeclaration used inside real AST.")); } virtual void accept(ASTConstVisitor&) const override { BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("MagicVariableDeclaration used inside real AST.")); } virtual TypePointer type() const override { return m_type; } private: std::shared_ptr<Type const> m_type; }; /// Types /// @{ /** * Abstract base class of a type name, can be any built-in or user-defined type. */ class TypeName: public ASTNode { public: explicit TypeName(SourceLocation const& _location): ASTNode(_location) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; virtual TypeNameAnnotation& annotation() const override; }; /** * Any pre-defined type name represented by a single keyword, i.e. it excludes mappings, * contracts, functions, etc. */ class ElementaryTypeName: public TypeName { public: ElementaryTypeName(SourceLocation const& _location, Token::Value _type): TypeName(_location), m_type(_type) { solAssert(Token::isElementaryTypeName(_type), ""); } virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; Token::Value typeName() const { return m_type; } private: Token::Value m_type; }; /** * Name referring to a user-defined type (i.e. a struct, contract, etc.). */ class UserDefinedTypeName: public TypeName { public: UserDefinedTypeName(SourceLocation const& _location, std::vector<ASTString> const& _namePath): TypeName(_location), m_namePath(_namePath) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; std::vector<ASTString> const& namePath() const { return m_namePath; } virtual UserDefinedTypeNameAnnotation& annotation() const override; private: std::vector<ASTString> m_namePath; }; /** * A mapping type. Its source form is "mapping('keyType' => 'valueType')" */ class Mapping: public TypeName { public: Mapping( SourceLocation const& _location, ASTPointer<ElementaryTypeName> const& _keyType, ASTPointer<TypeName> const& _valueType ): TypeName(_location), m_keyType(_keyType), m_valueType(_valueType) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; ElementaryTypeName const& keyType() const { return *m_keyType; } TypeName const& valueType() const { return *m_valueType; } private: ASTPointer<ElementaryTypeName> m_keyType; ASTPointer<TypeName> m_valueType; }; /** * An array type, can be "typename[]" or "typename[<expression>]". */ class ArrayTypeName: public TypeName { public: ArrayTypeName( SourceLocation const& _location, ASTPointer<TypeName> const& _baseType, ASTPointer<Expression> const& _length ): TypeName(_location), m_baseType(_baseType), m_length(_length) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; TypeName const& baseType() const { return *m_baseType; } Expression const* length() const { return m_length.get(); } private: ASTPointer<TypeName> m_baseType; ASTPointer<Expression> m_length; ///< Length of the array, might be empty. }; /// @} /// Statements /// @{ /** * Abstract base class for statements. */ class Statement: public ASTNode, public Documented { public: explicit Statement( SourceLocation const& _location, ASTPointer<ASTString> const& _docString ): ASTNode(_location), Documented(_docString) {} virtual StatementAnnotation& annotation() const override; }; /** * Brace-enclosed block containing zero or more statements. */ class Block: public Statement { public: Block( SourceLocation const& _location, ASTPointer<ASTString> const& _docString, std::vector<ASTPointer<Statement>> const& _statements ): Statement(_location, _docString), m_statements(_statements) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; std::vector<ASTPointer<Statement>> const& statements() const { return m_statements; } private: std::vector<ASTPointer<Statement>> m_statements; }; /** * Special placeholder statement denoted by "_" used in function modifiers. This is replaced by * the original function when the modifier is applied. */ class PlaceholderStatement: public Statement { public: explicit PlaceholderStatement( SourceLocation const& _location, ASTPointer<ASTString> const& _docString ): Statement(_location, _docString) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; }; /** * If-statement with an optional "else" part. Note that "else if" is modeled by having a new * if-statement as the false (else) body. */ class IfStatement: public Statement { public: IfStatement( SourceLocation const& _location, ASTPointer<ASTString> const& _docString, ASTPointer<Expression> const& _condition, ASTPointer<Statement> const& _trueBody, ASTPointer<Statement> const& _falseBody ): Statement(_location, _docString), m_condition(_condition), m_trueBody(_trueBody), m_falseBody(_falseBody) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; Expression const& condition() const { return *m_condition; } Statement const& trueStatement() const { return *m_trueBody; } /// @returns the "else" part of the if statement or nullptr if there is no "else" part. Statement const* falseStatement() const { return m_falseBody.get(); } private: ASTPointer<Expression> m_condition; ASTPointer<Statement> m_trueBody; ASTPointer<Statement> m_falseBody; ///< "else" part, optional }; /** * Statement in which a break statement is legal (abstract class). */ class BreakableStatement: public Statement { public: explicit BreakableStatement( SourceLocation const& _location, ASTPointer<ASTString> const& _docString ): Statement(_location, _docString) {} }; class WhileStatement: public BreakableStatement { public: WhileStatement( SourceLocation const& _location, ASTPointer<ASTString> const& _docString, ASTPointer<Expression> const& _condition, ASTPointer<Statement> const& _body ): BreakableStatement(_location, _docString), m_condition(_condition), m_body(_body) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; Expression const& condition() const { return *m_condition; } Statement const& body() const { return *m_body; } private: ASTPointer<Expression> m_condition; ASTPointer<Statement> m_body; }; /** * For loop statement */ class ForStatement: public BreakableStatement { public: ForStatement( SourceLocation const& _location, ASTPointer<ASTString> const& _docString, ASTPointer<Statement> const& _initExpression, ASTPointer<Expression> const& _conditionExpression, ASTPointer<ExpressionStatement> const& _loopExpression, ASTPointer<Statement> const& _body ): BreakableStatement(_location, _docString), m_initExpression(_initExpression), m_condExpression(_conditionExpression), m_loopExpression(_loopExpression), m_body(_body) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; Statement const* initializationExpression() const { return m_initExpression.get(); } Expression const* condition() const { return m_condExpression.get(); } ExpressionStatement const* loopExpression() const { return m_loopExpression.get(); } Statement const& body() const { return *m_body; } private: /// For statement's initialization expresion. for(XXX; ; ). Can be empty ASTPointer<Statement> m_initExpression; /// For statement's condition expresion. for(; XXX ; ). Can be empty ASTPointer<Expression> m_condExpression; /// For statement's loop expresion. for(;;XXX). Can be empty ASTPointer<ExpressionStatement> m_loopExpression; /// The body of the loop ASTPointer<Statement> m_body; }; class Continue: public Statement { public: explicit Continue(SourceLocation const& _location, ASTPointer<ASTString> const& _docString): Statement(_location, _docString) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; }; class Break: public Statement { public: explicit Break(SourceLocation const& _location, ASTPointer<ASTString> const& _docString): Statement(_location, _docString) {} virtual void accept(ASTVisitor& _visitor) override; virtual void accept(ASTConstVisitor& _visitor) const override; }; class Return: public Statement { public: Return( SourceLocation const& _location,


context:
space:
mode: