Changeset 3e94a23

Timestamp:

Apr 5, 2023, 11:30:56 AM (20 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, ast-experimental, master

Children:

835d6e8

Parents:

9bb8ee42

Message:

More use of the new AST named boolean types.

Location:

src

Files:

• AST/Convert.cpp (modified) (2 diffs)
• AST/Decl.cpp (modified) (2 diffs)
• AST/Decl.hpp (modified) (4 diffs)
• AST/Stmt.hpp (modified) (3 diffs)
• AST/Type.hpp (modified) (1 diff)
• Parser/StatementNode.cc (modified) (2 diffs)
• Parser/TypeData.cc (modified) (1 diff)

src/AST/Convert.cpp

@@ -1683 +1683 @@
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->get_funcSpec().val },
-                        old->type->isVarArgs
+                        (old->type->isVarArgs) ? ast::VariableArgs : ast::FixedArgs
                 };
 
@@ -1989 +1989 @@
                         GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
-                        old->isDoWhile,
+                        (old->isDoWhile) ? ast::DoWhile : ast::While,
                         GET_LABELS_V(old->labels)
                 );

src/AST/Decl.cpp

@@ -57 +57 @@
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
-        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ),
         type_params(std::move(forall)), assertions(),
         params(std::move(params)), returns(std::move(returns)), stmts( stmts ) {
-        FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+        FunctionType * ftype = new FunctionType( isVarArgs );
         for (auto & param : this->params) {
                 ftype->params.emplace_back(param->get_type());
@@ -81 +81 @@
         std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
         CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
-        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, ArgumentFlag isVarArgs )
 : DeclWithType( location, name, storage, linkage, std::move(attrs), fs ),
                 type_params( std::move( forall) ), assertions( std::move( assertions ) ),
                 params( std::move(params) ), returns( std::move(returns) ),
                 type( nullptr ), stmts( stmts ) {
-        FunctionType * type = new FunctionType( (isVarArgs) ? VariableArgs : FixedArgs );
+        FunctionType * type = new FunctionType( isVarArgs );
         for ( auto & param : this->params ) {
                 type->params.emplace_back( param->get_type() );

src/AST/Decl.hpp

@@ -10 +10 @@
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Nov 24  9:44:00 2022
-// Update Count     : 34
+// Last Modified On : Wed Apr  5 10:42:00 2023
+// Update Count     : 35
 //
 
@@ -122 +122 @@
 };
 
+/// Function variable arguments flag
+enum ArgumentFlag { FixedArgs, VariableArgs };
+
 /// Object declaration `int foo()`
 class FunctionDecl : public DeclWithType {
@@ -144 +147 @@
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
 
         FunctionDecl( const CodeLocation & location, const std::string & name,
@@ -150 +153 @@
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, ArgumentFlag isVarArgs = FixedArgs );
 
         const Type * get_type() const override;

src/AST/Stmt.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 13:00:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Apr 20 14:34:00 2022
-// Update Count     : 36
+// Last Modified On : Wed Apr  5 10:34:00 2023
+// Update Count     : 37
 //
 
@@ -205 +205 @@
 };
 
+// A while loop or a do-while loop:
+enum WhileDoKind { While, DoWhile };
+
 // While loop: while (...) ... else ... or do ... while (...) else ...;
 class WhileDoStmt final : public Stmt {
@@ -212 +215 @@
         ptr<Stmt> else_;
         std::vector<ptr<Stmt>> inits;
-        bool isDoWhile;
+        WhileDoKind isDoWhile;
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 
         WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
-                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
+                                 const std::vector<ptr<Stmt>> && inits, WhileDoKind isDoWhile = While, const std::vector<Label> && labels = {} )
                 : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
 

src/AST/Type.hpp

@@ -265 +265 @@
 };
 
-/// Function variable arguments flag
-enum ArgumentFlag { FixedArgs, VariableArgs };
-
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
 class FunctionType final : public Type {

src/Parser/StatementNode.cc

@@ -218 +218 @@
                 astelse.empty() ? nullptr : astelse.front().release(),
                 std::move( astinit ),
-                false
+                ast::While
         );
 } // build_while
@@ -237 +237 @@
                 astelse.empty() ? nullptr : astelse.front().release(),
                 {},
-                true
+                ast::DoWhile
         );
 } // build_do_while

src/Parser/TypeData.cc

@@ -1397 +1397 @@
                 std::move( attributes ),
                 funcSpec,
-                isVarArgs
+                (isVarArgs) ? ast::VariableArgs : ast::FixedArgs
         );
         buildList( td->function.withExprs, decl->withExprs );