Index: src/AST/Attribute.cpp =================================================================== --- src/AST/Attribute.cpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) +++ src/AST/Attribute.cpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) @@ -0,0 +1,53 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Attribute.cpp -- +// +// Author : Aaron B. Moss +// Created On : Fri May 10 10:30:00 2019 +// Last Modified By : Aaron B. Moss +// Created On : Fri May 10 10:30:00 2019 +// Update Count : 1 +// + +#include "Attribute.hpp" + +#include // for transform +#include // for tolower +#include // for back_inserter +#include + +namespace ast { + +std::string Attribute::normalizedName() const { + // trim underscores + auto begin = name.find_first_not_of('_'); + auto end = name.find_last_not_of('_'); + if ( begin == std::string::npos || end == std::string::npos ) return ""; + + // convert to lowercase + std::string ret; + ret.reserve( end-begin+1 ); + int (*tolower)(int) = std::tolower; + std::transform( &name[begin], &name[end+1], back_inserter( ret ), tolower ); + return ret; +} + +bool Attribute::isValidOnFuncParam() const { + // attributes such as aligned, cleanup, etc. produce GCC errors when they appear + // on function parameters. Maintain here a whitelist of attribute names that are + // allowed to appear on parameters. + std::string norm = normalizedName(); + return norm == "unused" || norm == "noreturn"; +} + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Attribute.hpp =================================================================== --- src/AST/Attribute.hpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) +++ src/AST/Attribute.hpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) @@ -0,0 +1,55 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Attribute.hpp -- +// +// Author : Aaron B. Moss +// Created On : Fri May 10 10:30:00 2019 +// Last Modified By : Aaron B. Moss +// Created On : Fri May 10 10:30:00 2019 +// Update Count : 1 +// + +#pragma once + +#include +#include + +#include "Node.hpp" // for ptr +#include "Visitor.hpp" + +namespace ast { + +class Expr; + +class Attribute final : public Node { +public: + std::string name; + std::vector> parameters; + + Attribute( const std::string& name = "", std::vector>&& params = {}) + : name( name ), parameters( params ) {} + + bool empty() const { return name.empty(); } + + /// strip leading/trailing underscores and lowercase + std::string normalizedName() const; + + /// true iff this attribute is allowed to appear attached to a function parameter + bool isValidOnFuncParam() const; + + Attribute* accept( Visitor& v ) override { return v.visit( this ); } +private: + Attribute* clone() const override { return new Attribute{ *this }; } +}; + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Decl.cpp =================================================================== --- src/AST/Decl.cpp (revision cdcd53dca689985e90e65039a76777261b54c5ea) +++ src/AST/Decl.cpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) @@ -14,12 +14,14 @@ // -#include // for assert, strict_dynamic_cast +#include "Decl.hpp" + +#include // for assert, strict_dynamic_cast +#include #include -#include "Decl.hpp" - -#include "Fwd.hpp" // for UniqueId +#include "Fwd.hpp" // for UniqueId #include "Init.hpp" -#include "Node.hpp" // for readonly +#include "Node.hpp" // for readonly +#include "Parser/ParseNode.h" // for DeclarationNode namespace ast { @@ -41,4 +43,21 @@ if ( i != idMap.end() ) return i->second; return {}; +} + +// --- TypeDecl + +std::string TypeDecl::typeString() const { + static const std::string kindNames[] = { "object type", "function type", "tuple type" }; + assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, + "typeString: kindNames is out of sync." ); + assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." ); + return (sized ? "sized " : "") + kindNames[ kind ]; +} + +std::string TypeDecl::genTypeString() const { + static const std::string kindNames[] = { "dtype", "ftype", "ttype" }; + assertf( sizeof(kindNames)/sizeof(kindNames[0]) == DeclarationNode::NoTypeClass-1, "genTypeString: kindNames is out of sync." ); + assertf( kind < sizeof(kindNames)/sizeof(kindNames[0]), "TypeDecl's kind is out of bounds." ); + return kindNames[ kind ]; } Index: src/AST/Decl.hpp =================================================================== --- src/AST/Decl.hpp (revision cdcd53dca689985e90e65039a76777261b54c5ea) +++ src/AST/Decl.hpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) @@ -115,4 +115,74 @@ }; +/// Base class for named type aliases +class NamedTypeDecl : public Decl { +public: + ptr base; + std::vector> parameters; + std::vector> assertions; + + NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, + Type* b, Linkage::Spec spec = Linkage::Cforall ) + : Decl( loc, name, storage, spec ), base( b ), parameters(), assertions() {} + + /// Produces a name for the kind of alias + virtual std::string typeString() const = 0; + +private: + NamedTypeDecl* clone() const override = 0; +}; + +/// Cforall type variable: `dtype T` +class TypeDecl final : public NamedTypeDecl { +public: + /// type variable variants. otype is a specialized dtype + enum Kind { Dtype, Ftype, Ttype, NUMBER_OF_KINDS } kind; + bool sized; + ptr init; + + /// Data extracted from a type decl + struct Data { + Kind kind; + bool isComplete; + + Data() : kind( (Kind)-1 ), isComplete( false ) {} + Data( TypeDecl* d ) : kind( d->kind ), isComplete( d->sized ) {} + Data( Kind k, bool c ) : kind( k ), isComplete( c ) {} + Data( const Data& d1, const Data& d2 ) + : kind( d1.kind ), isComplete( d1.isComplete || d2.isComplete ) {} + + bool operator== ( const Data& o ) const { + return kind == o.kind && isComplete == o.isComplete; + } + bool operator!= ( const Data& o ) const { return !(*this == o); } + }; + + TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b, + Kind k, bool s, Type* i = nullptr ) + : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == Ttype || s ), init( i ) {} + + std::string typeString() const override; + /// Produces a name for generated code + std::string genTypeString() const; + + Decl* accept( Visitor& v ) override { return v.visit( this ); } +private: + TypeDecl* clone() const override { return new TypeDecl{ *this }; } +}; + +/// C-style typedef `typedef Foo Bar` +class TypedefDecl final : public NamedTypeDecl { +public: + TypedefDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, + Type* b, Linkage::Spec spec = Linkage::Cforall ) + : NamedTypeDecl( loc, name, storage, b, spec ) {} + + std::string typeString() const override { return "typedef"; } + + Decl* accept( Visitor& v ) override { return v.visit( this ); } +private: + TypedefDecl* clone() const override { return new TypedefDecl{ *this }; } +}; + /// Aggregate type declaration base class class AggregateDecl : public Decl { Index: src/AST/Init.cpp =================================================================== --- src/AST/Init.cpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) +++ src/AST/Init.cpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) @@ -0,0 +1,45 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Init.cpp -- +// +// Author : Aaron B. Moss +// Created On : Fri May 10 10:30:00 2019 +// Last Modified By : Aaron B. Moss +// Created On : Fri May 10 10:30:00 2019 +// Update Count : 1 +// + +#include "Init.hpp" + +#include +#include // for move +#include + +namespace ast { + +ListInit::ListInit( const CodeLocation& loc, std::vector>&& is, + std::vector>&& ds, bool mc) +: Init( loc, mc ), initializers( std::move(is) ), designations( std::move(ds) ) { + // handle common case where ListInit is created without designations by making an + // equivalent-length empty list + if ( designations.empty() ) { + for ( unsigned i = 0; i < initializers.size(); ++i ) { + designations.emplace_back( new Designation{ loc } ); + } + } + + assertf( initializers.size() == designations.size(), "Created ListInit with mismatching " + "initializers (%zd) and designations (%zd)", initializers.size(), designations.size() ); +} + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/Init.hpp =================================================================== --- src/AST/Init.hpp (revision cdcd53dca689985e90e65039a76777261b54c5ea) +++ src/AST/Init.hpp (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) @@ -0,0 +1,119 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// Init.hpp -- +// +// Author : Aaron B. Moss +// Created On : Fri May 10 10:30:00 2019 +// Last Modified By : Aaron B. Moss +// Created On : Fri May 10 10:30:00 2019 +// Update Count : 1 +// + +#pragma once + +#include // for move +#include + +#include "ParseNode.hpp" +#include "Node.hpp" // for ptr +#include "Visitor.hpp" + +namespace ast { + +class Expr; +class Stmt; + +/// List of designator (NameExpr, VariableExpr, and ConstantExpr) expressions that specify an +/// object being initialized +class Designation final : public ParseNode { +public: + std::vector> designators; + + Designation( const CodeLocation& loc, std::vector>&& ds = {} ) + : ParseNode( loc ), designators( std::move(ds) ) {} + + Designation* accept( Visitor& v ) override { return v.visit( this ); } +private: + Designation* clone() const override { return new Designation{ *this }; } +}; + +/// Object initializer base class +class Init : public ParseNode { +public: + bool maybeConstructed; + + Init( const CodeLocation& loc, bool mc ) : ParseNode( loc ), maybeConstructed( mc ) {} + + virtual Init* accept( Visitor& v ) override = 0; +private: + virtual Init* clone() const override = 0; +}; + +/// Initializer for a common object: `int x = 4` +class SingleInit final : public Init { +public: + /// value to initialize to. Must be compile-time constant. + ptr value; + + SingleInit( const CodeLocation& loc, Expr* val, bool mc = false ) + : Init( loc, mc ), value( val ) {} + + Init* accept( Visitor& v ) override { return v.visit( this ); } +private: + SingleInit* clone() const override { return new SingleInit{ *this }; } +}; + +/// Initializer recursively composed of a list of initializers. +/// Used to initialize an array or aggregate: `int a[] = { 1, 2, 3 }` +class ListInit final : public Init { +public: + /// list of initializers + std::vector> initializers; + /// list of designators; order/length is consistent with initializers + std::vector> designations; + + ListInit( const CodeLocation& loc, std::vector>&& is, + std::vector>&& ds = {}, bool mc = false ); + + using iterator = std::vector>::iterator; + using const_iterator = std::vector>::const_iterator; + iterator begin() { return initializers.begin(); } + iterator end() { return initializers.end(); } + const_iterator begin() const { return initializers.begin(); } + const_iterator end() const { return initializers.end(); } + + Init* accept( Visitor& v ) override { return v.visit( this ); } +private: + ListInit* clone() const override { return new ListInit{ *this }; } +}; + +/// Either a constructor expression or a C-style initializer. +/// Should not be necessary to create manually; instead set `maybeConstructed` true on `SingleInit` +/// or `ListInit` if the object should be constructed. +class ConstructorInit final : public Init { +public: + ptr ctor; + ptr dtor; + /// C-style initializer made up of SingleInit/ListInit nodes to use as a fallback if an + /// appropriate constructor definition is not found by the resolver. + ptr init; + + ConstructorInit( const CodeLocation& loc, Stmt* ctor, Stmt* dtor, Init* init ) + : Init( loc, true ), ctor( ctor ), dtor( dtor ), init( init ) {} + + Init* accept( Visitor& v ) override { return v.visit( this ); } +private: + ConstructorInit* clone() const override { return new ConstructorInit{ *this }; } +}; + +} + +// Local Variables: // +// tab-width: 4 // +// mode: c++ // +// compile-command: "make install" // +// End: // Index: src/AST/porting.md =================================================================== --- src/AST/porting.md (revision cdcd53dca689985e90e65039a76777261b54c5ea) +++ src/AST/porting.md (revision 1531ef58a63686bb8a0904784ac52d11f4b511d8) @@ -89,4 +89,7 @@ * allows `newObject` as just default settings +`TypeDecl` +* stripped `isComplete()` accessor in favour of direct access to `sized` + `EnumDecl` * **TODO** rebuild `eval` for new AST (re: `valueOf` implementation)