Changeset 6e50a6b for src/SynTree

Timestamp:

Jun 18, 2021, 12:20:59 PM (4 years ago)

Author:

Michael Brooks <mlbrooks@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

c7d8696a

Parents:

dcbfcbc

Message:

Implementing language-provided syntax for (array) dimensions.

Former z(i) and Z(N) macros are eliminated.

Location:

src/SynTree

Files:

• Declaration.h (modified) (1 diff)
• Expression.h (modified) (1 diff)
• Mutator.h (modified) (1 diff)
• SynTree.h (modified) (1 diff)
• TypeDecl.cc (modified) (1 diff)
• TypeExpr.cc (modified) (1 diff)
• Visitor.h (modified) (1 diff)

src/SynTree/Declaration.h

@@ -201 +201 @@
         typedef NamedTypeDecl Parent;
   public:
-        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, ALtype, NUMBER_OF_KINDS };
+        enum Kind { Dtype, DStype, Otype, Ftype, Ttype, Dimension, NUMBER_OF_KINDS };
 
         Kind kind;

src/SynTree/Expression.h

@@ -587 +587 @@
 };
 
+/// DimensionExpr represents a type-system provided value used in an expression ( forrall([N]) ... N + 1 )
+class DimensionExpr : public Expression {
+  public:
+        std::string name;
+
+        DimensionExpr( std::string name );
+        DimensionExpr( const DimensionExpr & other );
+        virtual ~DimensionExpr();
+
+        const std::string & get_name() const { return name; }
+        void set_name( std::string newValue ) { name = newValue; }
+
+        virtual DimensionExpr * clone() const override { return new DimensionExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
+
 /// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
 class AsmExpr : public Expression {

src/SynTree/Mutator.h

@@ -80 +80 @@
         virtual Expression * mutate( CommaExpr * commaExpr ) = 0;
         virtual Expression * mutate( TypeExpr * typeExpr ) = 0;
+        virtual Expression * mutate( DimensionExpr * dimensionExpr ) = 0;
         virtual Expression * mutate( AsmExpr * asmExpr ) = 0;
         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) = 0;

src/SynTree/SynTree.h

@@ -85 +85 @@
 class CommaExpr;
 class TypeExpr;
+class DimensionExpr;
 class AsmExpr;
 class ImplicitCopyCtorExpr;

src/SynTree/TypeDecl.cc

@@ -33 +33 @@
 
 const char * TypeDecl::typeString() const {
-        static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized array length type" };
+        static const char * kindNames[] = { "sized data type", "sized data type", "sized object type", "sized function type", "sized tuple type", "sized length value" };
         static_assert( sizeof(kindNames) / sizeof(kindNames[0]) == TypeDecl::NUMBER_OF_KINDS, "typeString: kindNames is out of sync." );
         assertf( kind < TypeDecl::NUMBER_OF_KINDS, "TypeDecl kind is out of bounds." );

src/SynTree/TypeExpr.cc

@@ -35 +35 @@
 }
 
+DimensionExpr::DimensionExpr( std::string name ) : Expression(), name(name) {
+        assertf(name != "0", "Zero is not a valid name");
+        assertf(name != "1", "One is not a valid name");
+}
+
+DimensionExpr::DimensionExpr( const DimensionExpr & other ) : Expression( other ), name( other.name ) {
+}
+
+DimensionExpr::~DimensionExpr() {}
+
+void DimensionExpr::print( std::ostream & os, Indenter indent ) const {
+        os << "Type-Sys Value: " << get_name();
+        Expression::print( os, indent );
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Visitor.h

@@ -135 +135 @@
         virtual void visit( TypeExpr * node ) { visit( const_cast<const TypeExpr *>(node) ); }
         virtual void visit( const TypeExpr * typeExpr ) = 0;
+        virtual void visit( DimensionExpr * node ) { visit( const_cast<const DimensionExpr *>(node) ); }
+        virtual void visit( const DimensionExpr * typeExpr ) = 0;
         virtual void visit( AsmExpr * node ) { visit( const_cast<const AsmExpr *>(node) ); }
         virtual void visit( const AsmExpr * asmExpr ) = 0;