Changeset 0dd3a2f


Ignore:
Timestamp:
May 18, 2015, 11:20:23 AM (7 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, string, with_gc
Children:
51587aa
Parents:
a32b204
Message:

licencing: third groups of files

Location:
translator
Files:
60 edited

Legend:

Unmodified
Added
Removed
  • translator/SymTab/AddVisit.h

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: AddVisit.h,v 1.2 2005/08/29 20:14:17 rcbilson Exp $
    5  *
    6  */
    7 
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// AddVisit.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 16:14:32 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 16:16:38 2015
     13// Update Count     : 3
     14//
    815
    916namespace SymTab {
     17        void addDecls( std::list< Declaration* > &declsToAdd, std::list< Statement* > &statements, std::list< Statement* >::iterator i );
    1018
    11 void addDecls( std::list< Declaration* > &declsToAdd, std::list< Statement* > &statements, std::list< Statement* >::iterator i );
     19        template< typename Visitor >
     20        inline void addVisitStatementList( std::list< Statement* > &statements, Visitor &visitor ) {
     21                for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
     22                        addDecls( visitor.get_declsToAdd(), statements, i );
     23                        (*i)->accept( visitor );
     24                } // for
     25                addDecls( visitor.get_declsToAdd(), statements, statements.end() );
     26        }
    1227
    13 template< typename Visitor >
    14 inline void
    15 addVisitStatementList( std::list< Statement* > &statements, Visitor &visitor )
    16 {
    17   for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
    18     addDecls( visitor.get_declsToAdd(), statements, i );
    19     (*i)->accept( visitor );
    20   }
    21   addDecls( visitor.get_declsToAdd(), statements, statements.end() );
    22 }
    23 
    24 template< typename Visitor >
    25 inline void
    26 addVisitStatement( Statement *stmt, Visitor &visitor )
    27 {
    28   maybeAccept( stmt, visitor );
     28        template< typename Visitor >
     29        inline void addVisitStatement( Statement *stmt, Visitor &visitor ) {
     30                maybeAccept( stmt, visitor );
    2931///   if ( ! declsToAdd.empty() ) {
    3032///     CompoundStmt *compound = new CompoundStmt( noLabels );
     
    3234///     addDecls( declsToAdd, compound->get_kids(), compound->get_kids().end() );
    3335///   }
    34 }
     36        }
    3537
    36 template< typename Visitor >
    37 inline void
    38 addVisit(CompoundStmt *compoundStmt, Visitor &visitor)
    39 {
    40   addVisitStatementList( compoundStmt->get_kids(), visitor );
    41 }
     38        template< typename Visitor >
     39        inline void addVisit(CompoundStmt *compoundStmt, Visitor &visitor) {
     40                addVisitStatementList( compoundStmt->get_kids(), visitor );
     41        }
    4242
    43 template< typename Visitor >
    44 inline void
    45 addVisit(IfStmt *ifStmt, Visitor &visitor)
    46 {
    47   addVisitStatement( ifStmt->get_thenPart(), visitor );
    48   addVisitStatement( ifStmt->get_elsePart(), visitor );
    49   maybeAccept( ifStmt->get_condition(), visitor );
    50 }
     43        template< typename Visitor >
     44        inline void addVisit(IfStmt *ifStmt, Visitor &visitor) {
     45                addVisitStatement( ifStmt->get_thenPart(), visitor );
     46                addVisitStatement( ifStmt->get_elsePart(), visitor );
     47                maybeAccept( ifStmt->get_condition(), visitor );
     48        }
    5149
    52 template< typename Visitor >
    53 inline void
    54 addVisit(WhileStmt *whileStmt, Visitor &visitor)
    55 {
    56   addVisitStatement( whileStmt->get_body(), visitor );
    57   maybeAccept( whileStmt->get_condition(), visitor );
    58 }
     50        template< typename Visitor >
     51        inline void addVisit(WhileStmt *whileStmt, Visitor &visitor) {
     52                addVisitStatement( whileStmt->get_body(), visitor );
     53                maybeAccept( whileStmt->get_condition(), visitor );
     54        }
    5955
    60 template< typename Visitor >
    61 inline void
    62 addVisit(ForStmt *forStmt, Visitor &visitor)
    63 {
    64   addVisitStatement( forStmt->get_body(), visitor );
    65   maybeAccept( forStmt->get_initialization(), visitor );
    66   maybeAccept( forStmt->get_condition(), visitor );
    67   maybeAccept( forStmt->get_increment(), visitor );
    68 }
     56        template< typename Visitor >
     57        inline void addVisit(ForStmt *forStmt, Visitor &visitor) {
     58                addVisitStatement( forStmt->get_body(), visitor );
     59                maybeAccept( forStmt->get_initialization(), visitor );
     60                maybeAccept( forStmt->get_condition(), visitor );
     61                maybeAccept( forStmt->get_increment(), visitor );
     62        }
    6963
    70 template< typename Visitor >
    71 inline void
    72 addVisit(SwitchStmt *switchStmt, Visitor &visitor)
    73 {
    74   addVisitStatementList( switchStmt->get_branches(), visitor );
    75   maybeAccept( switchStmt->get_condition(), visitor );
    76 }
     64        template< typename Visitor >
     65        inline void addVisit(SwitchStmt *switchStmt, Visitor &visitor) {
     66                addVisitStatementList( switchStmt->get_branches(), visitor );
     67                maybeAccept( switchStmt->get_condition(), visitor );
     68        }
    7769
    78 template< typename Visitor >
    79 inline void
    80 addVisit(ChooseStmt *switchStmt, Visitor &visitor)
    81 {
    82   addVisitStatementList( switchStmt->get_branches(), visitor );
    83   maybeAccept( switchStmt->get_condition(), visitor );
    84 }
     70        template< typename Visitor >
     71        inline void addVisit(ChooseStmt *switchStmt, Visitor &visitor) {
     72                addVisitStatementList( switchStmt->get_branches(), visitor );
     73                maybeAccept( switchStmt->get_condition(), visitor );
     74        }
    8575
    86 template< typename Visitor >
    87 inline void
    88 addVisit(CaseStmt *caseStmt, Visitor &visitor)
    89 {
    90   addVisitStatementList( caseStmt->get_statements(), visitor );
    91   maybeAccept( caseStmt->get_condition(), visitor );
    92 }
     76        template< typename Visitor >
     77        inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) {
     78                addVisitStatementList( caseStmt->get_statements(), visitor );
     79                maybeAccept( caseStmt->get_condition(), visitor );
     80        }
    9381
    94 template< typename Visitor >
    95 inline void
    96 addVisit(CatchStmt *cathStmt, Visitor &visitor)
    97 {
    98   addVisitStatement( cathStmt->get_body(), visitor );
    99   maybeAccept( cathStmt->get_decl(), visitor );
    100 }
     82        template< typename Visitor >
     83        inline void addVisit(CatchStmt *cathStmt, Visitor &visitor) {
     84                addVisitStatement( cathStmt->get_body(), visitor );
     85                maybeAccept( cathStmt->get_decl(), visitor );
     86        }
     87} // namespace SymTab
    10188
    102 } // namespace SymTab
     89// Local Variables: //
     90// tab-width: 4 //
     91// mode: c++ //
     92// compile-command: "make install" //
     93// End: //
  • translator/SymTab/AggregateTable.h

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: AggregateTable.h,v 1.4 2005/08/29 20:14:17 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// AggregateTable.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 16:17:26 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 16:19:29 2015
     13// Update Count     : 4
     14//
    715
    8 #ifndef SYMTAB_AGGREGATETABLE_H
    9 #define SYMTAB_AGGREGATETABLE_H
     16#ifndef AGGREGATETABLE_H
     17#define AGGREGATETABLE_H
    1018
    1119#include <map>
     
    1826
    1927namespace SymTab {
     28        template< class AggregateDeclClass >
     29        class AggregateTableConflictFunction : public std::binary_function< AggregateDeclClass *, AggregateDeclClass *, AggregateDeclClass *> {
     30          public:
     31                AggregateDeclClass *operator()( AggregateDeclClass *existing, AggregateDeclClass *added ) {
     32                        if ( existing->get_members().empty() ) {
     33                                return added;
     34                        } else if ( ! added->get_members().empty() ) {
     35                                throw SemanticError( "redeclaration of ", added );
     36                        } // if
     37                        return existing;
     38                }
     39        };
    2040
    21 template< class AggregateDeclClass >
    22 class AggregateTableConflictFunction : public std::binary_function< AggregateDeclClass*, AggregateDeclClass*, AggregateDeclClass* >
    23 {
    24 public:
    25   AggregateDeclClass *operator()( AggregateDeclClass *existing, AggregateDeclClass *added )
    26   {
    27     if ( existing->get_members().empty() ) {
    28       return added;
    29     } else if ( ! added->get_members().empty() ) {
    30       throw SemanticError( "redeclaration of ", added );
    31     }
    32     return existing;
    33   }
    34  
    35 };
    36 
    37 typedef StackTable< StructDecl, AggregateTableConflictFunction< StructDecl > > StructTable;
    38 typedef StackTable< EnumDecl, AggregateTableConflictFunction< EnumDecl > > EnumTable;
    39 typedef StackTable< UnionDecl, AggregateTableConflictFunction< UnionDecl > > UnionTable;
    40 typedef StackTable< ContextDecl, AggregateTableConflictFunction< ContextDecl > > ContextTable;
    41 
     41        typedef StackTable< StructDecl, AggregateTableConflictFunction< StructDecl > > StructTable;
     42        typedef StackTable< EnumDecl, AggregateTableConflictFunction< EnumDecl > > EnumTable;
     43        typedef StackTable< UnionDecl, AggregateTableConflictFunction< UnionDecl > > UnionTable;
     44        typedef StackTable< ContextDecl, AggregateTableConflictFunction< ContextDecl > > ContextTable;
    4245} // namespace SymTab
    4346
    44 #endif /* #ifndef SYMTAB_AGGREGATETABLE_H */
     47#endif // AGGREGATETABLE_H
     48
     49// Local Variables: //
     50// tab-width: 4 //
     51// mode: c++ //
     52// compile-command: "make install" //
     53// End: //
  • translator/SymTab/FixFunction.cc

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// FixFunction.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 16:19:49 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 16:22:54 2015
     13// Update Count     : 2
     14//
     15
    116#include "FixFunction.h"
    217#include "SynTree/Declaration.h"
     
    621
    722namespace SymTab {
     23        FixFunction::FixFunction() : isVoid( false ) {
     24        }
    825
    9 FixFunction::FixFunction()
    10   : isVoid( false )
    11 {
    12 }
     26        DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
     27                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
     28                delete functionDecl;
     29                return pointer;
     30        }
    1331
    14 DeclarationWithType*
    15 FixFunction::mutate(FunctionDecl *functionDecl)
    16 {
    17   ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
    18   delete functionDecl;
    19   return pointer;
    20 }
     32        Type * FixFunction::mutate(VoidType *voidType) {
     33                isVoid = true;
     34                return voidType;
     35        }
    2136
    22 Type*
    23 FixFunction::mutate(VoidType *voidType)
    24 {
    25   isVoid = true;
    26   return voidType;
    27 }
     37        Type * FixFunction::mutate(BasicType *basicType) {
     38                return basicType;
     39        }
    2840
    29 Type*
    30 FixFunction::mutate(BasicType *basicType)
    31 {
    32   return basicType;
    33 }
     41        Type * FixFunction::mutate(PointerType *pointerType) {
     42                return pointerType;
     43        }
    3444
    35 Type*
    36 FixFunction::mutate(PointerType *pointerType)
    37 {
    38   return pointerType;
    39 }
     45        Type * FixFunction::mutate(ArrayType *arrayType) {
     46                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), maybeClone( arrayType->get_base()->clone() ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
     47                delete arrayType;
     48                return pointerType;
     49        }
    4050
    41 Type*
    42 FixFunction::mutate(ArrayType *arrayType)
    43 {
    44   PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), maybeClone( arrayType->get_base()->clone() ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
    45   delete arrayType;
    46   return pointerType;
    47 }
     51        Type * FixFunction::mutate(StructInstType *aggregateUseType) {
     52                return aggregateUseType;
     53        }
    4854
    49 Type*
    50 FixFunction::mutate(StructInstType *aggregateUseType)
    51 {
    52   return aggregateUseType;
    53 }
     55        Type * FixFunction::mutate(UnionInstType *aggregateUseType) {
     56                return aggregateUseType;
     57        }
    5458
    55 Type*
    56 FixFunction::mutate(UnionInstType *aggregateUseType)
    57 {
    58   return aggregateUseType;
    59 }
     59        Type * FixFunction::mutate(EnumInstType *aggregateUseType) {
     60                return aggregateUseType;
     61        }
    6062
    61 Type*
    62 FixFunction::mutate(EnumInstType *aggregateUseType)
    63 {
    64   return aggregateUseType;
    65 }
     63        Type * FixFunction::mutate(ContextInstType *aggregateUseType) {
     64                return aggregateUseType;
     65        }
    6666
    67 Type*
    68 FixFunction::mutate(ContextInstType *aggregateUseType)
    69 {
    70   return aggregateUseType;
    71 }
     67        Type * FixFunction::mutate(TypeInstType *aggregateUseType) {
     68                return aggregateUseType;
     69        }
    7270
    73 Type*
    74 FixFunction::mutate(TypeInstType *aggregateUseType)
    75 {
    76   return aggregateUseType;
    77 }
     71        Type * FixFunction::mutate(TupleType *tupleType) {
     72                return tupleType;
     73        }
     74} // namespace SymTab
    7875
    79 Type*
    80 FixFunction::mutate(TupleType *tupleType)
    81 {
    82   return tupleType;
    83 }
    84 
    85 
    86 } // namespace SymTab
     76// Local Variables: //
     77// tab-width: 4 //
     78// mode: c++ //
     79// compile-command: "make install" //
     80// End: //
  • translator/SymTab/FixFunction.h

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: FixFunction.h,v 1.3 2005/08/29 20:14:17 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// FixFunction.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 17:02:08 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 17:03:43 2015
     13// Update Count     : 2
     14//
    715
    8 #ifndef SYMTAB_FIXFUNCTION_H
    9 #define SYMTAB_FIXFUNCTION_H
     16#ifndef FIXFUNCTION_H
     17#define FIXFUNCTION_H
    1018
    1119#include "SynTree/Mutator.h"
    1220
    1321namespace SymTab {
     22        class FixFunction : public Mutator {
     23                typedef Mutator Parent;
     24          public:
     25                FixFunction();
    1426
    15 class FixFunction : public Mutator
    16 {
    17   typedef Mutator Parent;
     27                bool get_isVoid() const { return isVoid; }
     28                void set_isVoid( bool newValue ) { isVoid = newValue; }
     29          private:
     30                virtual DeclarationWithType* mutate(FunctionDecl *functionDecl);
    1831
    19 public:
    20   FixFunction();
    21 
    22   bool get_isVoid() const { return isVoid; }
    23   void set_isVoid( bool newValue ) { isVoid = newValue; }
    24 
    25 private:
    26   virtual DeclarationWithType* mutate(FunctionDecl *functionDecl);
    27 
    28   virtual Type* mutate(VoidType *voidType);
    29   virtual Type* mutate(BasicType *basicType);
    30   virtual Type* mutate(PointerType *pointerType);
    31   virtual Type* mutate(ArrayType *arrayType);
    32   virtual Type* mutate(StructInstType *aggregateUseType);
    33   virtual Type* mutate(UnionInstType *aggregateUseType);
    34   virtual Type* mutate(EnumInstType *aggregateUseType);
    35   virtual Type* mutate(ContextInstType *aggregateUseType);
    36   virtual Type* mutate(TypeInstType *aggregateUseType);
    37   virtual Type* mutate(TupleType *tupleType);
     32                virtual Type* mutate(VoidType *voidType);
     33                virtual Type* mutate(BasicType *basicType);
     34                virtual Type* mutate(PointerType *pointerType);
     35                virtual Type* mutate(ArrayType *arrayType);
     36                virtual Type* mutate(StructInstType *aggregateUseType);
     37                virtual Type* mutate(UnionInstType *aggregateUseType);
     38                virtual Type* mutate(EnumInstType *aggregateUseType);
     39                virtual Type* mutate(ContextInstType *aggregateUseType);
     40                virtual Type* mutate(TypeInstType *aggregateUseType);
     41                virtual Type* mutate(TupleType *tupleType);
    3842 
    39   bool isVoid;
    40 };
    41 
     43                bool isVoid;
     44        };
    4245} // namespace SymTab
    4346
    44 #endif /* #ifndef SYMTAB_FIXFUNCTION_H */
     47#endif // FIXFUNCTION_H
     48
     49// Local Variables: //
     50// tab-width: 4 //
     51// mode: c++ //
     52// compile-command: "make install" //
     53// End: //
  • translator/SymTab/IdTable.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: IdTable.cc,v 1.6 2005/08/29 20:14:17 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// IdTable.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 17:04:02 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 17:07:43 2015
     13// Update Count     : 3
     14//
    715
    816#include <cassert>
     
    1826
    1927namespace SymTab {
     28        IdTable::IdTable() : scopeLevel( 0 ) {
     29        }
    2030
    21 IdTable::IdTable()
    22   : scopeLevel( 0 )
    23 {
    24 }
     31        void IdTable::enterScope() {
     32                scopeLevel++;
     33        }
    2534
    26 void
    27 IdTable::enterScope()
    28 {
    29   scopeLevel++;
    30 }
     35        void IdTable::leaveScope() {
     36                for ( OuterTableType::iterator outer = table.begin(); outer != table.end(); ++outer ) {
     37                        for ( InnerTableType::iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
     38                                std::stack< DeclEntry >& entry = inner->second;
     39                                if ( ! entry.empty() && entry.top().second == scopeLevel ) {
     40                                        entry.pop();
     41                                } // if
     42                        } // for
     43                } // for
    3144
    32 void
    33 IdTable::leaveScope()
    34 {
    35   for ( OuterTableType::iterator outer = table.begin(); outer != table.end(); ++outer ) {
    36     for ( InnerTableType::iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
    37       std::stack< DeclEntry >& entry = inner->second;
    38       if ( ! entry.empty() && entry.top().second == scopeLevel ) {
    39         entry.pop();
    40       }
    41     }
    42   }
    43      
    44   scopeLevel--;
    45   assert( scopeLevel >= 0 );
    46 }
     45                scopeLevel--;
     46                assert( scopeLevel >= 0 );
     47        }
    4748
    48 void
    49 IdTable::addDecl( DeclarationWithType *decl )
    50 {
    51   const string &name = decl->get_name();
    52   string manglename;
    53   if ( decl->get_linkage() == LinkageSpec::C ) {
    54     manglename = name;
    55   } else {
    56     manglename = Mangler::mangle( decl );
    57   }
    58   InnerTableType &declTable = table[ name ];
    59   InnerTableType::iterator it = declTable.find( manglename );
    60   if ( it == declTable.end() ) {
    61     declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
    62   } else {
    63     std::stack< DeclEntry >& entry = it->second;
    64     if ( ! entry.empty() && entry.top().second == scopeLevel ) {
    65       if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->get_type(), Indexer() ) ) {
    66         FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( decl );
    67         FunctionDecl *old = dynamic_cast< FunctionDecl* >( entry.top().first );
    68         if ( newentry && old && newentry->get_statements() && old->get_statements() ) {
    69           throw SemanticError( "duplicate function definition for ", decl );
    70         } else {
    71           ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( decl );
    72           ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( entry.top().first );
    73           if ( newobj && oldobj && newobj->get_init() && oldobj->get_init() ) {
    74             throw SemanticError( "duplicate definition for ", decl );
    75           }
    76         }
    77       } else {
    78         throw SemanticError( "duplicate definition for ", decl );
    79       }
    80     } else {
    81       declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
    82     }
    83   }
    84   // ensure the set of routines with C linkage cannot be overloaded
    85   for ( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) {
    86     if ( ! i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) {
    87         InnerTableType::iterator j = i;
    88         for ( j++; j != declTable.end(); ++j ) {
    89           if ( ! j->second.empty() && j->second.top().first->get_linkage() == LinkageSpec::C ) {
    90             throw SemanticError( "invalid overload of C function " );
    91           }
     49        void IdTable::addDecl( DeclarationWithType *decl ) {
     50                const string &name = decl->get_name();
     51                string manglename;
     52                if ( decl->get_linkage() == LinkageSpec::C ) {
     53                        manglename = name;
     54                } else {
     55                        manglename = Mangler::mangle( decl );
     56                } // if
     57
     58                InnerTableType &declTable = table[ name ];
     59                InnerTableType::iterator it = declTable.find( manglename );
     60
     61                if ( it == declTable.end() ) {
     62                        declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
     63                } else {
     64                        std::stack< DeclEntry >& entry = it->second;
     65                        if ( ! entry.empty() && entry.top().second == scopeLevel ) {
     66                                if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->get_type(), Indexer() ) ) {
     67                                        FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( decl );
     68                                        FunctionDecl *old = dynamic_cast< FunctionDecl* >( entry.top().first );
     69                                        if ( newentry && old && newentry->get_statements() && old->get_statements() ) {
     70                                                throw SemanticError( "duplicate function definition for ", decl );
     71                                        } else {
     72                                                ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( decl );
     73                                                ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( entry.top().first );
     74                                                if ( newobj && oldobj && newobj->get_init() && oldobj->get_init() ) {
     75                                                        throw SemanticError( "duplicate definition for ", decl );
     76                                                } // if
     77                                        } // if
     78                                } else {
     79                                        throw SemanticError( "duplicate definition for ", decl );
     80                                } // if
     81                        } else {
     82                                declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
     83                        } // if
     84                } // if
     85                // ensure the set of routines with C linkage cannot be overloaded
     86                for ( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) {
     87                        if ( ! i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) {
     88                                InnerTableType::iterator j = i;
     89                                for ( j++; j != declTable.end(); ++j ) {
     90                                        if ( ! j->second.empty() && j->second.top().first->get_linkage() == LinkageSpec::C ) {
     91                                                throw SemanticError( "invalid overload of C function " );
     92                                        } // if
     93                                } // for
     94                        } // if
     95                } // for
    9296        }
    93     }
    94   }
    95 }
    9697
    97 void
    98 IdTable::lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const
    99 {
    100   OuterTableType::const_iterator outer = table.find( id );
    101   if ( outer == table.end() ) return;
    102   const InnerTableType &declTable = outer->second;
    103   for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
    104     const std::stack< DeclEntry >& entry = it->second;
    105     if ( ! entry.empty() ) {
    106       decls.push_back( entry.top().first );
    107     }
    108   }
    109 }
     98        void IdTable::lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const {
     99                OuterTableType::const_iterator outer = table.find( id );
     100                if ( outer == table.end() ) return;
     101                const InnerTableType &declTable = outer->second;
     102                for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
     103                        const std::stack< DeclEntry >& entry = it->second;
     104                        if ( ! entry.empty() ) {
     105                                decls.push_back( entry.top().first );
     106                        } // if
     107                } // for
     108        }
    110109
    111 DeclarationWithType* IdTable::lookupId( const std::string &id) const {
    112    DeclarationWithType* result = 0;
    113    int depth = -1;
     110        DeclarationWithType * IdTable::lookupId( const std::string &id) const {
     111                DeclarationWithType* result = 0;
     112                int depth = -1;
    114113
    115    OuterTableType::const_iterator outer = table.find( id );
    116    if ( outer == table.end() ) return 0;
    117    const InnerTableType &declTable = outer->second;
    118    for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
    119      const std::stack< DeclEntry >& entry = it->second;
    120      if ( ! entry.empty() && entry.top().second > depth ) {
    121        result = entry.top().first;
    122        depth = entry.top().second;
    123      }
    124    }
    125    return result;
    126 }
     114                OuterTableType::const_iterator outer = table.find( id );
     115                if ( outer == table.end() ) return 0;
     116                const InnerTableType &declTable = outer->second;
     117                for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
     118                        const std::stack< DeclEntry >& entry = it->second;
     119                        if ( ! entry.empty() && entry.top().second > depth ) {
     120                                result = entry.top().first;
     121                                depth = entry.top().second;
     122                        } // if
     123                } // for
     124                return result;
     125        }
    127126
    128 void
    129 IdTable::dump( std::ostream &os ) const
    130 {
    131   for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
    132     for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
     127        void IdTable::dump( std::ostream &os ) const {
     128                for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
     129                        for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
    133130#if 0
    134       const std::stack< DeclEntry >& entry = inner->second;
    135       if ( ! entry.empty() ) { // && entry.top().second == scopeLevel ) {
    136         os << outer->first << " (" << inner->first << ") (" << entry.top().second << ")" << std::endl;
    137       } else {
    138         os << outer->first << " (" << inner->first << ") ( entry-empty)" << std::endl;
    139       }
     131                                const std::stack< DeclEntry >& entry = inner->second;
     132                                if ( ! entry.empty() ) { // && entry.top().second == scopeLevel ) {
     133                                        os << outer->first << " (" << inner->first << ") (" << entry.top().second << ")" << std::endl;
     134                                } else {
     135                                        os << outer->first << " (" << inner->first << ") ( entry-empty)" << std::endl;
     136                                } // if
    140137#endif
    141138#if 0
    142       std::stack<DeclEntry> stack = inner->second;
    143       os << "dumping a stack" << std::endl;
    144       while (! stack.empty()) {
    145         DeclEntry d = stack.top();
    146         os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl;
    147         stack.pop();
    148       }
     139                                std::stack<DeclEntry> stack = inner->second;
     140                                os << "dumping a stack" << std::endl;
     141                                while (! stack.empty()) {
     142                                        DeclEntry d = stack.top();
     143                                        os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl;
     144                                        stack.pop();
     145                                } // while
    149146#endif
    150     }
    151   }
     147                        } // for
     148                } // for
    152149#if 0
    153   for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
    154     for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
    155       const std::stack< DeclEntry >& entry = inner->second;
    156       if ( ! entry.empty() && entry.top().second == scopeLevel ) {
    157         os << outer->first << " (" << inner->first << ") (" << scopeLevel << ")" << std::endl;
    158       }
    159     }
    160   }
     150                for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
     151                        for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
     152                                const std::stack< DeclEntry >& entry = inner->second;
     153                                if ( ! entry.empty() && entry.top().second == scopeLevel ) {
     154                                        os << outer->first << " (" << inner->first << ") (" << scopeLevel << ")" << std::endl;
     155                                } // if
     156                        } // for
     157                } // for
    161158#endif
    162 }
     159        }
     160} // namespace SymTab
    163161
    164 
    165 } // namespace SymTab
     162// Local Variables: //
     163// tab-width: 4 //
     164// mode: c++ //
     165// compile-command: "make install" //
     166// End: //
  • translator/SymTab/IdTable.h

    ra32b204 r0dd3a2f  
    1 #ifndef SYMTAB_IDTABLE_H
    2 #define SYMTAB_IDTABLE_H
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// IdTable.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:30:02 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:31:45 2015
     13// Update Count     : 3
     14//
     15
     16#ifndef IDTABLE_H
     17#define IDTABLE_H
    318
    419#include <iostream>
     
    1227    class IdTable {
    1328      public:
    14         IdTable();
     29                IdTable();
    1530 
    16         void enterScope();
    17         void leaveScope();
    18         void addDecl( DeclarationWithType *decl );
    19         void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const;
    20         DeclarationWithType* lookupId( const std::string &id) const;
     31                void enterScope();
     32                void leaveScope();
     33                void addDecl( DeclarationWithType *decl );
     34                void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const;
     35                DeclarationWithType* lookupId( const std::string &id) const;
    2136 
    22         void dump( std::ostream &os ) const; // debugging
     37                void dump( std::ostream &os ) const;                    // debugging
     38      private:
     39                typedef std::pair< DeclarationWithType*, int > DeclEntry;
     40                typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType;
     41                typedef std::map< std::string, InnerTableType > OuterTableType;
    2342
    24       private:
    25         typedef std::pair< DeclarationWithType*, int > DeclEntry;
    26         typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType;
    27         typedef std::map< std::string, InnerTableType > OuterTableType;
    28 
    29         OuterTableType table;
    30         int scopeLevel;
     43                OuterTableType table;
     44                int scopeLevel;
    3145    };
    3246} // namespace SymTab
    3347
    34 #endif // SYMTAB_IDTABLE_H
     48#endif // IDTABLE_H
     49
     50// Local Variables: //
     51// tab-width: 4 //
     52// mode: c++ //
     53// compile-command: "make install" //
     54// End: //
  • translator/SymTab/ImplementationType.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: ImplementationType.cc,v 1.4 2005/08/29 20:14:17 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// ImplementationType.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:32:01 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:34:40 2015
     13// Update Count     : 2
     14//
    715
    816#include "ImplementationType.h"
     
    1523
    1624namespace SymTab {
     25        class ImplementationType : public Visitor {
     26          public:
     27                ImplementationType( const SymTab::Indexer &indexer );
    1728
    18 class ImplementationType : public Visitor
    19 {
    20 public:
    21   ImplementationType( const SymTab::Indexer &indexer );
    22  
    23   Type *get_result() { return result; }
     29                Type *get_result() { return result; }
     30          private:
     31                virtual void visit(VoidType *voidType);
     32                virtual void visit(BasicType *basicType);
     33                virtual void visit(PointerType *pointerType);
     34                virtual void visit(ArrayType *arrayType);
     35                virtual void visit(FunctionType *functionType);
     36                virtual void visit(StructInstType *aggregateUseType);
     37                virtual void visit(UnionInstType *aggregateUseType);
     38                virtual void visit(EnumInstType *aggregateUseType);
     39                virtual void visit(ContextInstType *aggregateUseType);
     40                virtual void visit(TypeInstType *aggregateUseType);
     41                virtual void visit(TupleType *tupleType);
    2442
    25 private:
    26   virtual void visit(VoidType *voidType);
    27   virtual void visit(BasicType *basicType);
    28   virtual void visit(PointerType *pointerType);
    29   virtual void visit(ArrayType *arrayType);
    30   virtual void visit(FunctionType *functionType);
    31   virtual void visit(StructInstType *aggregateUseType);
    32   virtual void visit(UnionInstType *aggregateUseType);
    33   virtual void visit(EnumInstType *aggregateUseType);
    34   virtual void visit(ContextInstType *aggregateUseType);
    35   virtual void visit(TypeInstType *aggregateUseType);
    36   virtual void visit(TupleType *tupleType);
     43                Type *result;                   // synthesized
     44                const SymTab::Indexer &indexer;
     45        };
    3746
    38   Type *result;                 // synthesized
    39   const SymTab::Indexer &indexer;
    40 };
     47        Type * implementationType( Type *type, const SymTab::Indexer& indexer ) {
     48                ImplementationType implementor( indexer );
     49                type->accept( implementor );
     50                if ( implementor.get_result() == 0 ) {
     51                        return type->clone();
     52                } else {
     53                        return implementor.get_result();
     54                } // if
     55        }
    4156
    42 Type*
    43 implementationType( Type *type, const SymTab::Indexer& indexer )
    44 {
    45   ImplementationType implementor( indexer );
    46   type->accept( implementor );
    47   if ( implementor.get_result() == 0 ) {
    48     return type->clone();
    49   } else {
    50     return implementor.get_result();
    51   }
    52 }
     57        ImplementationType::ImplementationType( const SymTab::Indexer &indexer ) : result( 0 ), indexer( indexer ) {
     58        }
    5359
    54 ImplementationType::ImplementationType( const SymTab::Indexer &indexer )
    55   : result( 0 ), indexer( indexer )
    56 {
    57 }
     60        void ImplementationType::visit(VoidType *voidType) {
     61        }
    5862
    59 void
    60 ImplementationType::visit(VoidType *voidType)
    61 {
    62 }
     63        void ImplementationType::visit(BasicType *basicType) {
     64        }
    6365
    64 void
    65 ImplementationType::visit(BasicType *basicType)
    66 {
    67 }
     66        void ImplementationType::visit(PointerType *pointerType) {
     67                PointerType *newType = pointerType->clone();
     68                newType->set_base( implementationType( pointerType->get_base(), indexer ) );
     69                result = newType;
     70        }
    6871
    69 void
    70 ImplementationType::visit(PointerType *pointerType)
    71 {
    72   PointerType *newType = pointerType->clone();
    73   newType->set_base( implementationType( pointerType->get_base(), indexer ) );
    74   result = newType;
    75 }
     72        void ImplementationType::visit(ArrayType *arrayType) {
     73                ArrayType *newType = arrayType->clone();
     74                newType->set_base( implementationType( arrayType->get_base(), indexer ) );
     75                result = newType;
     76        }
    7677
    77 void
    78 ImplementationType::visit(ArrayType *arrayType)
    79 {
    80   ArrayType *newType = arrayType->clone();
    81   newType->set_base( implementationType( arrayType->get_base(), indexer ) );
    82   result = newType;
    83 }
    84 
    85 void
    86 ImplementationType::visit(FunctionType *functionType)
    87 {
     78        void ImplementationType::visit(FunctionType *functionType) {
    8879///   FunctionType *newType = functionType->clone();
    8980///   for ( std::list< DeclarationWithType* >::iterator i = newType->get_parameters().begin(); i != newType->get_parameters().end(); ++i ) {
     
    9384///     i->set_type( implementationType( i->get_type(), indexer ) );
    9485///   }
    95 }
     86        }
    9687
    97 void
    98 ImplementationType::visit(StructInstType *aggregateUseType)
    99 {
    100 }
     88        void ImplementationType::visit(StructInstType *aggregateUseType) {
     89        }
    10190
    102 void
    103 ImplementationType::visit(UnionInstType *aggregateUseType)
    104 {
    105 }
     91        void ImplementationType::visit(UnionInstType *aggregateUseType) {
     92        }
    10693
    107 void
    108 ImplementationType::visit(EnumInstType *aggregateUseType)
    109 {
    110 }
     94        void ImplementationType::visit(EnumInstType *aggregateUseType) {
     95        }
    11196
    112 void
    113 ImplementationType::visit(ContextInstType *aggregateUseType)
    114 {
    115 }
     97        void ImplementationType::visit(ContextInstType *aggregateUseType) {
     98        }
    11699
    117 void
    118 ImplementationType::visit(TypeInstType *inst)
    119 {
    120   NamedTypeDecl *typeDecl = indexer.lookupType( inst->get_name() );
    121   if ( typeDecl && typeDecl->get_base() ) {
    122     Type *base = implementationType( typeDecl->get_base(), indexer );
    123     base->get_qualifiers() += inst->get_qualifiers();
    124     result = base;
    125   }
    126 }
     100        void ImplementationType::visit(TypeInstType *inst) {
     101                NamedTypeDecl *typeDecl = indexer.lookupType( inst->get_name() );
     102                if ( typeDecl && typeDecl->get_base() ) {
     103                        Type *base = implementationType( typeDecl->get_base(), indexer );
     104                        base->get_qualifiers() += inst->get_qualifiers();
     105                        result = base;
     106                } // if
     107        }
    127108
    128 void
    129 ImplementationType::visit(TupleType *tupleType)
    130 {
    131   TupleType *newType = new TupleType( Type::Qualifiers() );
    132   for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
    133     Type *implType = implementationType( *i, indexer );
    134     implType->get_qualifiers() += tupleType->get_qualifiers();
    135     newType->get_types().push_back( implType );
    136   }
    137   result = newType;
    138 }
     109        void ImplementationType::visit(TupleType *tupleType) {
     110                TupleType *newType = new TupleType( Type::Qualifiers() );
     111                for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
     112                        Type *implType = implementationType( *i, indexer );
     113                        implType->get_qualifiers() += tupleType->get_qualifiers();
     114                        newType->get_types().push_back( implType );
     115                } // for
     116                result = newType;
     117        }
     118} // namespace SymTab
    139119
    140 } // namespace SymTab
     120// Local Variables: //
     121// tab-width: 4 //
     122// mode: c++ //
     123// compile-command: "make install" //
     124// End: //
  • translator/SymTab/ImplementationType.h

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: ImplementationType.h,v 1.3 2005/08/29 20:14:17 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// ImplementationType.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:35:41 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:37:15 2015
     13// Update Count     : 2
     14//
    715
    8 #ifndef SYMTAB_IMPLEMENTATIONTYPE_H
    9 #define SYMTAB_IMPLEMENTATIONTYPE_H
     16#ifndef IMPLEMENTATIONTYPE_H
     17#define IMPLEMENTATIONTYPE_H
    1018
    1119#include "SynTree/SynTree.h"
     
    1321
    1422namespace SymTab {
     23        Type *implementationType( Type *, const SymTab::Indexer &indexer );
    1524
    16 Type *implementationType( Type *, const SymTab::Indexer &indexer );
    17 
    18 template< typename InputIterator, typename OutputIterator >
    19 void
    20 implementationTypeList( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer )
    21 {
    22   while ( begin != end ) {
    23     *out++ = implementationType( *begin++, indexer );
    24   }
    25 }
    26 
     25        template< typename InputIterator, typename OutputIterator >
     26        void implementationTypeList( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
     27                while ( begin != end ) {
     28                        *out++ = implementationType( *begin++, indexer );
     29                } // while
     30        }
    2731} // namespace SymTab
    2832
    29 #endif /* #ifndef SYMTAB_IMPLEMENTATIONTYPE_H */
     33#endif // IMPLEMENTATIONTYPE_H
     34
     35// Local Variables: //
     36// tab-width: 4 //
     37// mode: c++ //
     38// compile-command: "make install" //
     39// End: //
  • translator/SymTab/Indexer.cc

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Indexer.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:37:33 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:38:44 2015
     13// Update Count     : 2
     14//
     15
    116#include "SynTree/Declaration.h"
    217#include "SynTree/Type.h"
     
    1631
    1732    void Indexer::visit( ObjectDecl *objectDecl ) {
    18         maybeAccept( objectDecl->get_type(), *this );
    19         maybeAccept( objectDecl->get_init(), *this );
    20         maybeAccept( objectDecl->get_bitfieldWidth(), *this );
    21         if ( objectDecl->get_name() != "" ) {
    22             debugPrint( "Adding object " << objectDecl->get_name() << std::endl );
    23             idTable.addDecl( objectDecl );
    24         }
     33                maybeAccept( objectDecl->get_type(), *this );
     34                maybeAccept( objectDecl->get_init(), *this );
     35                maybeAccept( objectDecl->get_bitfieldWidth(), *this );
     36                if ( objectDecl->get_name() != "" ) {
     37                        debugPrint( "Adding object " << objectDecl->get_name() << std::endl );
     38                        idTable.addDecl( objectDecl );
     39                } // if
    2540    }
    2641
    2742    void Indexer::visit( FunctionDecl *functionDecl ) {
    28         if ( functionDecl->get_name() == "" ) return;
    29         debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
    30         idTable.addDecl( functionDecl );
    31         enterScope();
    32         maybeAccept( functionDecl->get_functionType(), *this );
    33         acceptAll( functionDecl->get_oldDecls(), *this );
    34         maybeAccept( functionDecl->get_statements(), *this );
    35         leaveScope();
     43                if ( functionDecl->get_name() == "" ) return;
     44                debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
     45                idTable.addDecl( functionDecl );
     46                enterScope();
     47                maybeAccept( functionDecl->get_functionType(), *this );
     48                acceptAll( functionDecl->get_oldDecls(), *this );
     49                maybeAccept( functionDecl->get_statements(), *this );
     50                leaveScope();
    3651    }
    3752
     
    5671
    5772    void Indexer::visit( TypeDecl *typeDecl ) {
    58         // see A NOTE ON THE ORDER OF TRAVERSAL, above
    59         // note that assertions come after the type is added to the symtab, since they aren't part
    60         // of the type proper and may depend on the type itself
    61         enterScope();
    62         acceptAll( typeDecl->get_parameters(), *this );
    63         maybeAccept( typeDecl->get_base(), *this );
    64         leaveScope();
    65         debugPrint( "Adding type " << typeDecl->get_name() << std::endl );
    66         typeTable.add( typeDecl );
    67         acceptAll( typeDecl->get_assertions(), *this );
     73                // see A NOTE ON THE ORDER OF TRAVERSAL, above
     74                // note that assertions come after the type is added to the symtab, since they aren't part
     75                // of the type proper and may depend on the type itself
     76                enterScope();
     77                acceptAll( typeDecl->get_parameters(), *this );
     78                maybeAccept( typeDecl->get_base(), *this );
     79                leaveScope();
     80                debugPrint( "Adding type " << typeDecl->get_name() << std::endl );
     81                typeTable.add( typeDecl );
     82                acceptAll( typeDecl->get_assertions(), *this );
    6883    }
    6984
    7085    void Indexer::visit( TypedefDecl *typeDecl ) {
    71         enterScope();
    72         acceptAll( typeDecl->get_parameters(), *this );
    73         maybeAccept( typeDecl->get_base(), *this );
    74         leaveScope();
    75         debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
    76         typeTable.add( typeDecl );
     86                enterScope();
     87                acceptAll( typeDecl->get_parameters(), *this );
     88                maybeAccept( typeDecl->get_base(), *this );
     89                leaveScope();
     90                debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
     91                typeTable.add( typeDecl );
    7792    }
    7893
    7994    void Indexer::visit( StructDecl *aggregateDecl ) {
    80         // make up a forward declaration and add it before processing the members
    81         StructDecl fwdDecl( aggregateDecl->get_name() );
    82         cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
    83         debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
    84         structTable.add( &fwdDecl );
    85  
    86         enterScope();
    87         acceptAll( aggregateDecl->get_parameters(), *this );
    88         acceptAll( aggregateDecl->get_members(), *this );
    89         leaveScope();
    90  
    91         debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
    92         // this addition replaces the forward declaration
    93         structTable.add( aggregateDecl );
     95                // make up a forward declaration and add it before processing the members
     96                StructDecl fwdDecl( aggregateDecl->get_name() );
     97                cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
     98                debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
     99                structTable.add( &fwdDecl );
     100 
     101                enterScope();
     102                acceptAll( aggregateDecl->get_parameters(), *this );
     103                acceptAll( aggregateDecl->get_members(), *this );
     104                leaveScope();
     105 
     106                debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
     107                // this addition replaces the forward declaration
     108                structTable.add( aggregateDecl );
    94109    }
    95110
    96111    void Indexer::visit( UnionDecl *aggregateDecl ) {
    97         // make up a forward declaration and add it before processing the members
    98         UnionDecl fwdDecl( aggregateDecl->get_name() );
    99         cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
    100         debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
    101         unionTable.add( &fwdDecl );
    102  
    103         enterScope();
    104         acceptAll( aggregateDecl->get_parameters(), *this );
    105         acceptAll( aggregateDecl->get_members(), *this );
    106         leaveScope();
    107  
    108         debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
    109         unionTable.add( aggregateDecl );
     112                // make up a forward declaration and add it before processing the members
     113                UnionDecl fwdDecl( aggregateDecl->get_name() );
     114                cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
     115                debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
     116                unionTable.add( &fwdDecl );
     117 
     118                enterScope();
     119                acceptAll( aggregateDecl->get_parameters(), *this );
     120                acceptAll( aggregateDecl->get_members(), *this );
     121                leaveScope();
     122 
     123                debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
     124                unionTable.add( aggregateDecl );
    110125    }
    111126
    112127    void Indexer::visit( EnumDecl *aggregateDecl ) {
    113         debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
    114         enumTable.add( aggregateDecl );
    115         // unlike structs, contexts, and unions, enums inject their members into the global scope
    116         acceptAll( aggregateDecl->get_members(), *this );
     128                debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
     129                enumTable.add( aggregateDecl );
     130                // unlike structs, contexts, and unions, enums inject their members into the global scope
     131                acceptAll( aggregateDecl->get_members(), *this );
    117132    }
    118133
    119134    void Indexer::visit( ContextDecl *aggregateDecl ) {
    120         enterScope();
    121         acceptAll( aggregateDecl->get_parameters(), *this );
    122         acceptAll( aggregateDecl->get_members(), *this );
    123         leaveScope();
    124  
    125         debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
    126         contextTable.add( aggregateDecl );
     135                enterScope();
     136                acceptAll( aggregateDecl->get_parameters(), *this );
     137                acceptAll( aggregateDecl->get_members(), *this );
     138                leaveScope();
     139 
     140                debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
     141                contextTable.add( aggregateDecl );
    127142    }
    128143
    129144    void Indexer::visit( CompoundStmt *compoundStmt ) {
    130         enterScope();
    131         acceptAll( compoundStmt->get_kids(), *this );
    132         leaveScope();
     145                enterScope();
     146                acceptAll( compoundStmt->get_kids(), *this );
     147                leaveScope();
    133148    }
    134149
    135150    void Indexer::visit( ContextInstType *contextInst ) {
    136         acceptAll( contextInst->get_parameters(), *this );
    137         acceptAll( contextInst->get_members(), *this );
     151                acceptAll( contextInst->get_parameters(), *this );
     152                acceptAll( contextInst->get_members(), *this );
    138153    }
    139154
    140155    void Indexer::visit( StructInstType *structInst ) {
    141         if ( ! structTable.lookup( structInst->get_name() ) ) {
    142             debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
    143             structTable.add( structInst->get_name() );
    144         }
    145         enterScope();
    146         acceptAll( structInst->get_parameters(), *this );
    147         leaveScope();
     156                if ( ! structTable.lookup( structInst->get_name() ) ) {
     157                        debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
     158                        structTable.add( structInst->get_name() );
     159                }
     160                enterScope();
     161                acceptAll( structInst->get_parameters(), *this );
     162                leaveScope();
    148163    }
    149164
    150165    void Indexer::visit( UnionInstType *unionInst ) {
    151         if ( ! unionTable.lookup( unionInst->get_name() ) ) {
    152             debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
    153             unionTable.add( unionInst->get_name() );
    154         }
    155         enterScope();
    156         acceptAll( unionInst->get_parameters(), *this );
    157         leaveScope();
     166                if ( ! unionTable.lookup( unionInst->get_name() ) ) {
     167                        debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
     168                        unionTable.add( unionInst->get_name() );
     169                }
     170                enterScope();
     171                acceptAll( unionInst->get_parameters(), *this );
     172                leaveScope();
    158173    }
    159174
     
    167182
    168183    void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const {
    169         idTable.lookupId( id, list );
     184                idTable.lookupId( id, list );
    170185    }
    171186
    172187    DeclarationWithType* Indexer::lookupId( const std::string &id) const {
    173         return idTable.lookupId(id);
     188                return idTable.lookupId(id);
    174189    }
    175190
    176191    NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
    177         return typeTable.lookup( id );
     192                return typeTable.lookup( id );
    178193    }
    179194
    180195    StructDecl *Indexer::lookupStruct( const std::string &id ) const {
    181         return structTable.lookup( id );
     196                return structTable.lookup( id );
    182197    }
    183198
    184199    EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
    185         return enumTable.lookup( id );
     200                return enumTable.lookup( id );
    186201    }
    187202
    188203    UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
    189         return unionTable.lookup( id );
     204                return unionTable.lookup( id );
    190205    }
    191206
    192207    ContextDecl  * Indexer::lookupContext( const std::string &id ) const {
    193         return contextTable.lookup( id );
     208                return contextTable.lookup( id );
    194209    }
    195210
    196211    void Indexer::enterScope() {
    197         if ( doDebug ) {
    198             std::cout << "--- Entering scope" << std::endl;
    199         }
    200         idTable.enterScope();
    201         typeTable.enterScope();
    202         structTable.enterScope();
    203         enumTable.enterScope();
    204         unionTable.enterScope();
    205         contextTable.enterScope();
     212                if ( doDebug ) {
     213                        std::cout << "--- Entering scope" << std::endl;
     214                }
     215                idTable.enterScope();
     216                typeTable.enterScope();
     217                structTable.enterScope();
     218                enumTable.enterScope();
     219                unionTable.enterScope();
     220                contextTable.enterScope();
    206221    }
    207222
    208223    void Indexer::leaveScope() {
    209         using std::cout;
    210         using std::endl;
    211  
    212         if ( doDebug ) {
    213             cout << "--- Leaving scope containing" << endl;
    214             idTable.dump( cout );
    215             typeTable.dump( cout );
    216             structTable.dump( cout );
    217             enumTable.dump( cout );
    218             unionTable.dump( cout );
    219             contextTable.dump( cout );
    220         }
    221         idTable.leaveScope();
    222         typeTable.leaveScope();
    223         structTable.leaveScope();
    224         enumTable.leaveScope();
    225         unionTable.leaveScope();
    226         contextTable.leaveScope();
     224                using std::cout;
     225                using std::endl;
     226 
     227                if ( doDebug ) {
     228                        cout << "--- Leaving scope containing" << endl;
     229                        idTable.dump( cout );
     230                        typeTable.dump( cout );
     231                        structTable.dump( cout );
     232                        enumTable.dump( cout );
     233                        unionTable.dump( cout );
     234                        contextTable.dump( cout );
     235                }
     236                idTable.leaveScope();
     237                typeTable.leaveScope();
     238                structTable.leaveScope();
     239                enumTable.leaveScope();
     240                unionTable.leaveScope();
     241                contextTable.leaveScope();
    227242    }
    228243
     
    244259        contextTable.dump( os );
    245260#if 0
    246         idTable.dump( os );
    247         typeTable.dump( os );
    248         structTable.dump( os );
    249         enumTable.dump( os );
    250         unionTable.dump( os );
    251         contextTable.dump( os );
     261                idTable.dump( os );
     262                typeTable.dump( os );
     263                structTable.dump( os );
     264                enumTable.dump( os );
     265                unionTable.dump( os );
     266                contextTable.dump( os );
    252267#endif
    253268    }
    254269} // namespace SymTab
     270
     271// Local Variables: //
     272// tab-width: 4 //
     273// mode: c++ //
     274// compile-command: "make install" //
     275// End: //
  • translator/SymTab/Indexer.h

    ra32b204 r0dd3a2f  
    1 #ifndef SYMTAB_INDEXER_H
    2 #define SYMTAB_INDEXER_H
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Indexer.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:38:55 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:40:17 2015
     13// Update Count     : 2
     14//
     15
     16#ifndef INDEXER_H
     17#define INDEXER_H
    318
    419#include <list>
     
    6176} // namespace SymTab
    6277
    63 #endif // SYMTAB_INDEXER_H
     78#endif // INDEXER_H
     79
     80// Local Variables: //
     81// tab-width: 4 //
     82// mode: c++ //
     83// compile-command: "make install" //
     84// End: //
  • translator/SymTab/Mangler.cc

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Mangler.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:40:29 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:43:49 2015
     13// Update Count     : 2
     14//
     15
    116#include <cassert>
    217#include <string>
     
    1530
    1631namespace SymTab {
    17     Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true )
    18     {}
     32    Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) {
     33        }
    1934
    2035//Mangler::Mangler( const Mangler & )
     
    2338//}
    2439    Mangler::Mangler( const Mangler &rhs ) : mangleName() {
    25         varNums = rhs.varNums;
    26         nextVarNum = rhs.nextVarNum;
    27         isTopLevel = rhs.isTopLevel;
     40                varNums = rhs.varNums;
     41                nextVarNum = rhs.nextVarNum;
     42                isTopLevel = rhs.isTopLevel;
    2843    }
    2944
    3045    void Mangler::mangleDecl( DeclarationWithType *declaration ) {
    31         bool wasTopLevel = isTopLevel;
    32         if ( isTopLevel ) {
    33             varNums.clear();
    34             nextVarNum = 0;
    35             isTopLevel = false;
    36         }
    37         mangleName << "__";
    38         CodeGen::OperatorInfo opInfo;
    39         if ( operatorLookup( declaration->get_name(), opInfo ) ) {
    40             mangleName << opInfo.outputName;
    41         } else {
    42             mangleName << declaration->get_name();
    43         }
    44         mangleName << "__";
    45         maybeAccept( declaration->get_type(), *this );
    46         isTopLevel = wasTopLevel;
     46                bool wasTopLevel = isTopLevel;
     47                if ( isTopLevel ) {
     48                        varNums.clear();
     49                        nextVarNum = 0;
     50                        isTopLevel = false;
     51                } // if
     52                mangleName << "__";
     53                CodeGen::OperatorInfo opInfo;
     54                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
     55                        mangleName << opInfo.outputName;
     56                } else {
     57                        mangleName << declaration->get_name();
     58                } // if
     59                mangleName << "__";
     60                maybeAccept( declaration->get_type(), *this );
     61                isTopLevel = wasTopLevel;
    4762    }
    4863
    4964    void Mangler::visit( ObjectDecl *declaration ) {
    50         mangleDecl( declaration );
     65                mangleDecl( declaration );
    5166    }
    5267
    5368    void Mangler::visit( FunctionDecl *declaration ) {
    54         mangleDecl( declaration );
     69                mangleDecl( declaration );
    5570    }
    5671
    5772    void Mangler::visit( VoidType *voidType ) {
    58         printQualifiers( voidType );
    59         mangleName << "v";
     73                printQualifiers( voidType );
     74                mangleName << "v";
    6075    }
    6176
    6277    void Mangler::visit( BasicType *basicType ) {
    63         static const char *btLetter[] = {
    64             "b",        // Bool
    65             "c",        // Char
    66             "Sc",       // SignedChar
    67             "Uc",       // UnsignedChar
    68             "s",        // ShortSignedInt
    69             "Us",       // ShortUnsignedInt
    70             "i",        // SignedInt
    71             "Ui",       // UnsignedInt
    72             "l",        // LongSignedInt
    73             "Ul",       // LongUnsignedInt
    74             "q",        // LongLongSignedInt
    75             "Uq",       // LongLongUnsignedInt
    76             "f",        // Float
    77             "d",        // Double
    78             "r",        // LongDouble
    79             "Xf",       // FloatComplex
    80             "Xd",       // DoubleComplex
    81             "Xr",       // LongDoubleComplex
    82             "If",       // FloatImaginary
    83             "Id",       // DoubleImaginary
    84             "Ir",       // LongDoubleImaginary
    85         };
     78                static const char *btLetter[] = {
     79                        "b",    // Bool
     80                        "c",    // Char
     81                        "Sc",   // SignedChar
     82                        "Uc",   // UnsignedChar
     83                        "s",    // ShortSignedInt
     84                        "Us",   // ShortUnsignedInt
     85                        "i",    // SignedInt
     86                        "Ui",   // UnsignedInt
     87                        "l",    // LongSignedInt
     88                        "Ul",   // LongUnsignedInt
     89                        "q",    // LongLongSignedInt
     90                        "Uq",   // LongLongUnsignedInt
     91                        "f",    // Float
     92                        "d",    // Double
     93                        "r",    // LongDouble
     94                        "Xf",   // FloatComplex
     95                        "Xd",   // DoubleComplex
     96                        "Xr",   // LongDoubleComplex
     97                        "If",   // FloatImaginary
     98                        "Id",   // DoubleImaginary
     99                        "Ir",   // LongDoubleImaginary
     100                };
    86101 
    87         printQualifiers( basicType );
    88         mangleName << btLetter[ basicType->get_kind() ];
     102                printQualifiers( basicType );
     103                mangleName << btLetter[ basicType->get_kind() ];
    89104    }
    90105
    91106    void Mangler::visit( PointerType *pointerType ) {
    92         printQualifiers( pointerType );
    93         mangleName << "P";
    94         maybeAccept( pointerType->get_base(), *this );
     107                printQualifiers( pointerType );
     108                mangleName << "P";
     109                maybeAccept( pointerType->get_base(), *this );
    95110    }
    96111
    97112    void Mangler::visit( ArrayType *arrayType ) {
    98         // TODO: encode dimension
    99         printQualifiers( arrayType );
    100         mangleName << "A0";
    101         maybeAccept( arrayType->get_base(), *this );
     113                // TODO: encode dimension
     114                printQualifiers( arrayType );
     115                mangleName << "A0";
     116                maybeAccept( arrayType->get_base(), *this );
    102117    }
    103118
    104119    namespace {
    105         inline std::list< Type* >
    106         getTypes( const std::list< DeclarationWithType* > decls )
    107         {
    108             std::list< Type* > ret;
    109             std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
    110                             std::mem_fun( &DeclarationWithType::get_type ) );
    111             return ret;
    112         }
     120                inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
     121                        std::list< Type* > ret;
     122                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
     123                                                        std::mem_fun( &DeclarationWithType::get_type ) );
     124                        return ret;
     125                }
    113126    }
    114127
    115128    void Mangler::visit( FunctionType *functionType ) {
    116         printQualifiers( functionType );
    117         mangleName << "F";
    118         std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
    119         acceptAll( returnTypes, *this );
    120         mangleName << "_";
    121         std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
    122         acceptAll( paramTypes, *this );
    123         mangleName << "_";
     129                printQualifiers( functionType );
     130                mangleName << "F";
     131                std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
     132                acceptAll( returnTypes, *this );
     133                mangleName << "_";
     134                std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
     135                acceptAll( paramTypes, *this );
     136                mangleName << "_";
    124137    }
    125138
    126139    void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
    127         printQualifiers( refType );
    128         mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
     140                printQualifiers( refType );
     141                mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
    129142    }
    130143
    131144    void Mangler::visit( StructInstType *aggregateUseType ) {
    132         mangleRef( aggregateUseType, "s" );
     145                mangleRef( aggregateUseType, "s" );
    133146    }
    134147
    135148    void Mangler::visit( UnionInstType *aggregateUseType ) {
    136         mangleRef( aggregateUseType, "u" );
     149                mangleRef( aggregateUseType, "u" );
    137150    }
    138151
    139152    void Mangler::visit( EnumInstType *aggregateUseType ) {
    140         mangleRef( aggregateUseType, "e" );
     153                mangleRef( aggregateUseType, "e" );
    141154    }
    142155
    143156    void Mangler::visit( TypeInstType *typeInst ) {
    144         VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
    145         if ( varNum == varNums.end() ) {
    146             mangleRef( typeInst, "t" );
    147         } else {
    148             printQualifiers( typeInst );
    149             std::ostrstream numStream;
    150             numStream << varNum->second.first;
    151             mangleName << (numStream.pcount() + 1);
    152             switch ( (TypeDecl::Kind )varNum->second.second ) {
    153               case TypeDecl::Any:
    154                 mangleName << "t";
    155                 break;
    156               case TypeDecl::Dtype:
    157                 mangleName << "d";
    158                 break;
    159               case TypeDecl::Ftype:
    160                 mangleName << "f";
    161                 break;
    162             }
    163             mangleName << std::string( numStream.str(), numStream.pcount() );
    164         }
     157                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
     158                if ( varNum == varNums.end() ) {
     159                        mangleRef( typeInst, "t" );
     160                } else {
     161                        printQualifiers( typeInst );
     162                        std::ostrstream numStream;
     163                        numStream << varNum->second.first;
     164                        mangleName << (numStream.pcount() + 1);
     165                        switch ( (TypeDecl::Kind )varNum->second.second ) {
     166                          case TypeDecl::Any:
     167                                mangleName << "t";
     168                                break;
     169                          case TypeDecl::Dtype:
     170                                mangleName << "d";
     171                                break;
     172                          case TypeDecl::Ftype:
     173                                mangleName << "f";
     174                                break;
     175                        } // switch
     176                        mangleName << std::string( numStream.str(), numStream.pcount() );
     177                } // if
    165178    }
    166179
    167180    void Mangler::visit( TupleType *tupleType ) {
    168         printQualifiers( tupleType );
    169         mangleName << "T";
    170         acceptAll( tupleType->get_types(), *this );
    171         mangleName << "_";
     181                printQualifiers( tupleType );
     182                mangleName << "T";
     183                acceptAll( tupleType->get_types(), *this );
     184                mangleName << "_";
    172185    }
    173186
    174187    void Mangler::visit( TypeDecl *decl ) {
    175         static const char *typePrefix[] = { "BT", "BD", "BF" };
    176         mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
     188                static const char *typePrefix[] = { "BT", "BD", "BF" };
     189                mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
    177190    }
    178191
    179192    void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
    180         for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
    181             os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
    182         }
     193                for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
     194                        os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
     195                } // for
    183196    }
    184197
    185198    void Mangler::printQualifiers( Type *type ) {
    186         if ( ! type->get_forall().empty() ) {
    187             std::list< std::string > assertionNames;
    188             int tcount = 0, dcount = 0, fcount = 0;
    189             mangleName << "A";
    190             for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
    191                 switch ( (*i)->get_kind() ) {
    192                   case TypeDecl::Any:
    193                     tcount++;
    194                     break;
    195                   case TypeDecl::Dtype:
    196                     dcount++;
    197                     break;
    198                   case TypeDecl::Ftype:
    199                     fcount++;
    200                     break;
    201                 }
    202                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
    203                 for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
    204                     Mangler sub_mangler;
    205                     sub_mangler.nextVarNum = nextVarNum;
    206                     sub_mangler.isTopLevel = false;
    207                     sub_mangler.varNums = varNums;
    208                     (*assert)->accept( sub_mangler );
    209                     assertionNames.push_back( std::string( sub_mangler.mangleName.str(), sub_mangler.mangleName.pcount() ) );
    210                 }
    211             }
    212             mangleName << tcount << "_" << dcount << "_" << fcount << "_";
    213             std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
    214             mangleName << "_";
    215         }
    216         if ( type->get_isConst() ) {
    217             mangleName << "C";
    218         }
    219         if ( type->get_isVolatile() ) {
    220             mangleName << "V";
    221         }
    222         if ( type->get_isRestrict() ) {
    223             mangleName << "R";
    224         }
    225         if ( type->get_isLvalue() ) {
    226             mangleName << "L";
    227         }
    228         if ( type->get_isAtomic() ) {
    229             mangleName << "A";
    230         }
    231     }
    232 } // SymTab
     199                if ( ! type->get_forall().empty() ) {
     200                        std::list< std::string > assertionNames;
     201                        int tcount = 0, dcount = 0, fcount = 0;
     202                        mangleName << "A";
     203                        for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
     204                                switch ( (*i)->get_kind() ) {
     205                                  case TypeDecl::Any:
     206                                        tcount++;
     207                                        break;
     208                                  case TypeDecl::Dtype:
     209                                        dcount++;
     210                                        break;
     211                                  case TypeDecl::Ftype:
     212                                        fcount++;
     213                                        break;
     214                                } // switch
     215                                varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
     216                                for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
     217                                        Mangler sub_mangler;
     218                                        sub_mangler.nextVarNum = nextVarNum;
     219                                        sub_mangler.isTopLevel = false;
     220                                        sub_mangler.varNums = varNums;
     221                                        (*assert)->accept( sub_mangler );
     222                                        assertionNames.push_back( std::string( sub_mangler.mangleName.str(), sub_mangler.mangleName.pcount() ) );
     223                                } // for
     224                        } // for
     225                        mangleName << tcount << "_" << dcount << "_" << fcount << "_";
     226                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
     227                        mangleName << "_";
     228                } // if
     229                if ( type->get_isConst() ) {
     230                        mangleName << "C";
     231                } // if
     232                if ( type->get_isVolatile() ) {
     233                        mangleName << "V";
     234                } // if
     235                if ( type->get_isRestrict() ) {
     236                        mangleName << "R";
     237                } // if
     238                if ( type->get_isLvalue() ) {
     239                        mangleName << "L";
     240                } // if
     241                if ( type->get_isAtomic() ) {
     242                        mangleName << "A";
     243                } // if
     244    }
     245} // namespace SymTab
     246
     247// Local Variables: //
     248// tab-width: 4 //
     249// mode: c++ //
     250// compile-command: "make install" //
     251// End: //
  • translator/SymTab/Mangler.h

    ra32b204 r0dd3a2f  
    1 #ifndef SYMTAB_MANGLER_H
    2 #define SYMTAB_MANGLER_H
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Mangler.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:44:03 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:45:05 2015
     13// Update Count     : 2
     14//
     15
     16#ifndef MANGLER_H
     17#define MANGLER_H
    318
    419#include <strstream>
     
    924    class Mangler : public Visitor {
    1025      public:
    11         template< typename SynTreeClass >
     26                template< typename SynTreeClass >
    1227            static std::string mangle( SynTreeClass *decl ); // interface to clients
    1328
    1429///   using Visitor::visit;
    15         virtual void visit( ObjectDecl *declaration );
    16         virtual void visit( FunctionDecl *declaration );
    17         virtual void visit( TypeDecl *declaration );
     30                virtual void visit( ObjectDecl *declaration );
     31                virtual void visit( FunctionDecl *declaration );
     32                virtual void visit( TypeDecl *declaration );
    1833
    19         virtual void visit( VoidType *voidType );
    20         virtual void visit( BasicType *basicType );
    21         virtual void visit( PointerType *pointerType );
    22         virtual void visit( ArrayType *arrayType );
    23         virtual void visit( FunctionType *functionType );
    24         virtual void visit( StructInstType *aggregateUseType );
    25         virtual void visit( UnionInstType *aggregateUseType );
    26         virtual void visit( EnumInstType *aggregateUseType );
    27         virtual void visit( TypeInstType *aggregateUseType );
    28         virtual void visit( TupleType *tupleType );
     34                virtual void visit( VoidType *voidType );
     35                virtual void visit( BasicType *basicType );
     36                virtual void visit( PointerType *pointerType );
     37                virtual void visit( ArrayType *arrayType );
     38                virtual void visit( FunctionType *functionType );
     39                virtual void visit( StructInstType *aggregateUseType );
     40                virtual void visit( UnionInstType *aggregateUseType );
     41                virtual void visit( EnumInstType *aggregateUseType );
     42                virtual void visit( TypeInstType *aggregateUseType );
     43                virtual void visit( TupleType *tupleType );
    2944 
    30         std::string get_mangleName() { return std::string( mangleName.str(), mangleName.pcount() ); }
     45                std::string get_mangleName() { return std::string( mangleName.str(), mangleName.pcount() ); }
    3146      private:
    32         std::ostrstream mangleName;
    33         typedef std::map< std::string, std::pair< int, int > > VarMapType;
    34         VarMapType varNums;
    35         int nextVarNum;
    36         bool isTopLevel;
     47                std::ostrstream mangleName;
     48                typedef std::map< std::string, std::pair< int, int > > VarMapType;
     49                VarMapType varNums;
     50                int nextVarNum;
     51                bool isTopLevel;
    3752 
    38         Mangler();
    39         Mangler( const Mangler & );
     53                Mangler();
     54                Mangler( const Mangler & );
    4055 
    41         void mangleDecl( DeclarationWithType *declaration );
    42         void mangleRef( ReferenceToType *refType, std::string prefix );
     56                void mangleDecl( DeclarationWithType *declaration );
     57                void mangleRef( ReferenceToType *refType, std::string prefix );
    4358 
    44         void printQualifiers( Type *type );
     59                void printQualifiers( Type *type );
    4560    }; // Mangler
    4661
    4762    template< typename SynTreeClass >
    4863    std::string Mangler::mangle( SynTreeClass *decl ) {
    49         Mangler mangler;
    50         maybeAccept( decl, mangler );
    51         return mangler.get_mangleName();
     64                Mangler mangler;
     65                maybeAccept( decl, mangler );
     66                return mangler.get_mangleName();
    5267    }
    5368} // SymTab
    5469
    55 #endif // SYMTAB_MANGLER_H
     70#endif // MANGLER_H
     71
     72// Local Variables: //
     73// tab-width: 4 //
     74// mode: c++ //
     75// compile-command: "make install" //
     76// End: //
  • translator/SymTab/StackTable.cc

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// StackTable.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:45:15 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:46:59 2015
     13// Update Count     : 2
     14//
     15
    116#include <cassert>
    217
     
    520namespace SymTab {
    621    template< typename Element, typename ConflictFunction >
    7     StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 )
    8     {}
     22    StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 ) {
     23        }
    924
    1025    template< typename Element, typename ConflictFunction >
    1126    void StackTable< Element, ConflictFunction >::enterScope() {
    12         scopeLevel++;
     27                scopeLevel++;
    1328    }
    1429
    1530    template< typename Element, typename ConflictFunction >
    1631    void StackTable< Element, ConflictFunction >::leaveScope() {
    17         for ( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) {
    18             std::stack< Entry >& entry = it->second;
    19             if ( ! entry.empty() && entry.top().second == scopeLevel ) {
    20                 entry.pop();
    21             }
    22         }
    23         scopeLevel--;
    24         assert( scopeLevel >= 0 );
     32                for ( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) {
     33                        std::stack< Entry >& entry = it->second;
     34                        if ( ! entry.empty() && entry.top().second == scopeLevel ) {
     35                                entry.pop();
     36                        } // if
     37                } // for
     38                scopeLevel--;
     39                assert( scopeLevel >= 0 );
    2540    }
    2641
    2742    template< typename Element, typename ConflictFunction >
    2843    void StackTable< Element, ConflictFunction >::add( Element *type ) {
    29         std::stack< Entry >& entry = table[ type->get_name() ];
    30         if ( ! entry.empty() && entry.top().second == scopeLevel ) {
    31             entry.top().first = conflictFunction( entry.top().first, type );
    32         } else {
    33             entry.push( Entry( type, scopeLevel ) );
    34         }
     44                std::stack< Entry >& entry = table[ type->get_name() ];
     45                if ( ! entry.empty() && entry.top().second == scopeLevel ) {
     46                        entry.top().first = conflictFunction( entry.top().first, type );
     47                } else {
     48                        entry.push( Entry( type, scopeLevel ) );
     49                } // if
    3550    }
    3651
    3752    template< typename Element, typename ConflictFunction >
    3853    void StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) {
    39         add( new Element( fwdDeclName ) );
     54                add( new Element( fwdDeclName ) );
    4055    }
    4156
    4257    template< typename Element, typename ConflictFunction >
    4358    Element *StackTable< Element, ConflictFunction >::lookup( std::string id ) const {
    44         typename TableType::const_iterator it = table.find( id );
    45         if ( it == table.end() ) {
    46             return 0;
    47         } else if ( ! it->second.empty() ) {
    48             return it->second.top().first;
    49         } else {
    50             return 0;
    51         }
     59                typename TableType::const_iterator it = table.find( id );
     60                if ( it == table.end() ) {
     61                        return 0;
     62                } else if ( ! it->second.empty() ) {
     63                        return it->second.top().first;
     64                } else {
     65                        return 0;
     66                } // if
    5267    }
    5368
    5469    template< typename Element, typename ConflictFunction >
    5570    void StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const {
    56         for ( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) {
    57             const std::stack< Entry >& entry = it->second;
    58             if ( ! entry.empty() && entry.top().second == scopeLevel ) {
    59                 os << it->first << std::endl;
    60             }
    61         }
     71                for ( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) {
     72                        const std::stack< Entry >& entry = it->second;
     73                        if ( ! entry.empty() && entry.top().second == scopeLevel ) {
     74                                os << it->first << std::endl;
     75                        } // if
     76                } // for
    6277    }
    63 } // SymTab
     78} // namespace SymTab
     79
     80// Local Variables: //
     81// tab-width: 4 //
     82// mode: c++ //
     83// compile-command: "make install" //
     84// End: //
  • translator/SymTab/StackTable.h

    ra32b204 r0dd3a2f  
    1 #ifndef SYMTAB_STACKTABLE_H
    2 #define SYMTAB_STACKTABLE_H
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// StackTable.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:47:10 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:48:15 2015
     13// Update Count     : 3
     14//
     15
     16#ifndef STACKTABLE_H
     17#define STACKTABLE_H
    318
    419#include <map>
     
    1126        class StackTable {
    1227      public:
    13         StackTable();
     28                StackTable();
    1429
    15         void enterScope();
    16         void leaveScope();
    17         void add( Element *type );
    18         void add( std::string fwdDeclName );
    19         Element *lookup( std::string id ) const;
     30                void enterScope();
     31                void leaveScope();
     32                void add( Element *type );
     33                void add( std::string fwdDeclName );
     34                Element *lookup( std::string id ) const;
    2035
    21         void dump( std::ostream &os ) const; // debugging
     36                void dump( std::ostream &os ) const;                    // debugging
    2237      private:
    23         typedef std::pair< Element*, int > Entry;
    24         typedef std::map< std::string, std::stack< Entry > > TableType;
     38                typedef std::pair< Element*, int > Entry;
     39                typedef std::map< std::string, std::stack< Entry > > TableType;
    2540 
    26         ConflictFunction conflictFunction;
    27         TableType table;
    28         int scopeLevel;
     41                ConflictFunction conflictFunction;
     42                TableType table;
     43                int scopeLevel;
    2944    };
    3045} // SymTab
     
    3247#include "StackTable.cc"
    3348
    34 #endif // SYMTAB_STACKTABLE_H
     49#endif // STACKTABLE_H
     50
     51// Local Variables: //
     52// tab-width: 4 //
     53// mode: c++ //
     54// compile-command: "make install" //
     55// End: //
  • translator/SymTab/TypeTable.h

    ra32b204 r0dd3a2f  
    1 #ifndef SYMTAB_TYPETABLE_H
    2 #define SYMTAB_TYPETABLE_H
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// TypeTable.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:48:32 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:49:49 2015
     13// Update Count     : 2
     14//
     15
     16#ifndef TYPETABLE_H
     17#define TYPETABLE_H
    318
    419#include <cassert>
     
    1429    class TypeTableConflictFunction : public std::binary_function< NamedTypeDecl *, NamedTypeDecl *, NamedTypeDecl * > {
    1530      public:
    16         NamedTypeDecl *operator()( NamedTypeDecl *existing, NamedTypeDecl *added ) {
    17             if ( existing->get_base() == 0 ) {
    18                 return added;
    19             } else if ( added->get_base() == 0 ) {
    20                 return existing;
    21             } else {
    22                 throw SemanticError( "redeclaration of ", added );
    23             }
    24             assert( false );
    25             return 0;
    26         }
     31                NamedTypeDecl *operator()( NamedTypeDecl *existing, NamedTypeDecl *added ) {
     32                        if ( existing->get_base() == 0 ) {
     33                                return added;
     34                        } else if ( added->get_base() == 0 ) {
     35                                return existing;
     36                        } else {
     37                                throw SemanticError( "redeclaration of ", added );
     38                        } // if
     39                        assert( false );
     40                        return 0;
     41                }
    2742    };
    2843
    2944    typedef StackTable< NamedTypeDecl, TypeTableConflictFunction > TypeTable;
    30 } // SymTab
     45} // namespace SymTab
    3146
    32 #endif // SYMTAB_TYPETABLE_H
     47#endif // TYPETABLE_H
     48
     49// Local Variables: //
     50// tab-width: 4 //
     51// mode: c++ //
     52// compile-command: "make install" //
     53// End: //
  • translator/SymTab/Validate.cc

    ra32b204 r0dd3a2f  
    1 /*
    2   The "validate" phase of translation is used to take a syntax tree and convert it into a standard form that aims to be
    3   as regular in structure as possible.  Some assumptions can be made regarding the state of the tree after this pass is
    4   complete, including:
    5 
    6   - No nested structure or union definitions; any in the input are "hoisted" to the level of the containing struct or
    7     union.
    8 
    9   - All enumeration constants have type EnumInstType.
    10 
    11   - The type "void" never occurs in lists of function parameter or return types; neither do tuple types.  A function
    12     taking no arguments has no argument types, and tuples are flattened.
    13 
    14   - No context instances exist; they are all replaced by the set of declarations signified by the context, instantiated
    15     by the particular set of type arguments.
    16 
    17   - Every declaration is assigned a unique id.
    18 
    19   - No typedef declarations or instances exist; the actual type is substituted for each instance.
    20 
    21   - Each type, struct, and union definition is followed by an appropriate assignment operator.
    22 
    23   - Each use of a struct or union is connected to a complete definition of that struct or union, even if that definition
    24     occurs later in the input.
    25 */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Validate.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 21:50:04 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Sun May 17 21:53:16 2015
     13// Update Count     : 2
     14//
     15
     16// The "validate" phase of translation is used to take a syntax tree and convert it into a standard form that aims to be
     17// as regular in structure as possible.  Some assumptions can be made regarding the state of the tree after this pass is
     18// complete, including:
     19//
     20// - No nested structure or union definitions; any in the input are "hoisted" to the level of the containing struct or
     21//   union.
     22//
     23// - All enumeration constants have type EnumInstType.
     24//
     25// - The type "void" never occurs in lists of function parameter or return types; neither do tuple types.  A function
     26//   taking no arguments has no argument types, and tuples are flattened.
     27//
     28// - No context instances exist; they are all replaced by the set of declarations signified by the context, instantiated
     29//   by the particular set of type arguments.
     30//
     31// - Every declaration is assigned a unique id.
     32//
     33// - No typedef declarations or instances exist; the actual type is substituted for each instance.
     34//
     35// - Each type, struct, and union definition is followed by an appropriate assignment operator.
     36//
     37// - Each use of a struct or union is connected to a complete definition of that struct or union, even if that
     38//   definition occurs later in the input.
    2639
    2740#include <list>
     
    4659    class HoistStruct : public Visitor {
    4760      public:
    48         static void hoistStruct( std::list< Declaration * > &translationUnit );
    49  
    50         std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
    51  
    52         virtual void visit( StructDecl *aggregateDecl );
    53         virtual void visit( UnionDecl *aggregateDecl );
    54 
    55         virtual void visit( CompoundStmt *compoundStmt );
    56         virtual void visit( IfStmt *ifStmt );
    57         virtual void visit( WhileStmt *whileStmt );
    58         virtual void visit( ForStmt *forStmt );
    59         virtual void visit( SwitchStmt *switchStmt );
    60         virtual void visit( ChooseStmt *chooseStmt );
    61         virtual void visit( CaseStmt *caseStmt );
    62         virtual void visit( CatchStmt *catchStmt );
     61                static void hoistStruct( std::list< Declaration * > &translationUnit );
     62 
     63                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
     64 
     65                virtual void visit( StructDecl *aggregateDecl );
     66                virtual void visit( UnionDecl *aggregateDecl );
     67
     68                virtual void visit( CompoundStmt *compoundStmt );
     69                virtual void visit( IfStmt *ifStmt );
     70                virtual void visit( WhileStmt *whileStmt );
     71                virtual void visit( ForStmt *forStmt );
     72                virtual void visit( SwitchStmt *switchStmt );
     73                virtual void visit( ChooseStmt *chooseStmt );
     74                virtual void visit( CaseStmt *caseStmt );
     75                virtual void visit( CatchStmt *catchStmt );
    6376      private:
    64         HoistStruct();
    65 
    66         template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
    67 
    68         std::list< Declaration * > declsToAdd;
    69         bool inStruct;
     77                HoistStruct();
     78
     79                template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
     80
     81                std::list< Declaration * > declsToAdd;
     82                bool inStruct;
    7083    };
    7184
    7285    class Pass1 : public Visitor {
    73         typedef Visitor Parent;
    74         virtual void visit( EnumDecl *aggregateDecl );
    75         virtual void visit( FunctionType *func );
     86                typedef Visitor Parent;
     87                virtual void visit( EnumDecl *aggregateDecl );
     88                virtual void visit( FunctionType *func );
    7689    };
    7790 
    7891    class Pass2 : public Indexer {
    79         typedef Indexer Parent;
     92                typedef Indexer Parent;
    8093      public:
    81         Pass2( bool doDebug, const Indexer *indexer );
     94                Pass2( bool doDebug, const Indexer *indexer );
    8295      private:
    83         virtual void visit( StructInstType *structInst );
    84         virtual void visit( UnionInstType *unionInst );
    85         virtual void visit( ContextInstType *contextInst );
    86         virtual void visit( StructDecl *structDecl );
    87         virtual void visit( UnionDecl *unionDecl );
    88         virtual void visit( TypeInstType *typeInst );
    89 
    90         const Indexer *indexer;
    91  
    92         typedef std::map< std::string, std::list< StructInstType * > > ForwardStructsType;
    93         typedef std::map< std::string, std::list< UnionInstType * > > ForwardUnionsType;
    94         ForwardStructsType forwardStructs;
    95         ForwardUnionsType forwardUnions;
     96                virtual void visit( StructInstType *structInst );
     97                virtual void visit( UnionInstType *unionInst );
     98                virtual void visit( ContextInstType *contextInst );
     99                virtual void visit( StructDecl *structDecl );
     100                virtual void visit( UnionDecl *unionDecl );
     101                virtual void visit( TypeInstType *typeInst );
     102
     103                const Indexer *indexer;
     104 
     105                typedef std::map< std::string, std::list< StructInstType * > > ForwardStructsType;
     106                typedef std::map< std::string, std::list< UnionInstType * > > ForwardUnionsType;
     107                ForwardStructsType forwardStructs;
     108                ForwardUnionsType forwardUnions;
    96109    };
    97110
    98111    class Pass3 : public Indexer {
    99         typedef Indexer Parent;
     112                typedef Indexer Parent;
    100113      public:
    101         Pass3( const Indexer *indexer );
     114                Pass3( const Indexer *indexer );
    102115      private:
    103         virtual void visit( ObjectDecl *object );
    104         virtual void visit( FunctionDecl *func );
    105 
    106         const Indexer *indexer;
     116                virtual void visit( ObjectDecl *object );
     117                virtual void visit( FunctionDecl *func );
     118
     119                const Indexer *indexer;
    107120    };
    108121
    109122    class AddStructAssignment : public Visitor {
    110123      public:
    111         static void addStructAssignment( std::list< Declaration * > &translationUnit );
    112 
    113         std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
    114  
    115         virtual void visit( StructDecl *structDecl );
    116         virtual void visit( UnionDecl *structDecl );
    117         virtual void visit( TypeDecl *typeDecl );
    118         virtual void visit( ContextDecl *ctxDecl );
    119         virtual void visit( FunctionDecl *functionDecl );
    120 
    121         virtual void visit( FunctionType *ftype );
    122         virtual void visit( PointerType *ftype );
    123  
    124         virtual void visit( CompoundStmt *compoundStmt );
    125         virtual void visit( IfStmt *ifStmt );
    126         virtual void visit( WhileStmt *whileStmt );
    127         virtual void visit( ForStmt *forStmt );
    128         virtual void visit( SwitchStmt *switchStmt );
    129         virtual void visit( ChooseStmt *chooseStmt );
    130         virtual void visit( CaseStmt *caseStmt );
    131         virtual void visit( CatchStmt *catchStmt );
    132 
    133         AddStructAssignment() : functionNesting( 0 ) {}
     124                static void addStructAssignment( std::list< Declaration * > &translationUnit );
     125
     126                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
     127 
     128                virtual void visit( StructDecl *structDecl );
     129                virtual void visit( UnionDecl *structDecl );
     130                virtual void visit( TypeDecl *typeDecl );
     131                virtual void visit( ContextDecl *ctxDecl );
     132                virtual void visit( FunctionDecl *functionDecl );
     133
     134                virtual void visit( FunctionType *ftype );
     135                virtual void visit( PointerType *ftype );
     136 
     137                virtual void visit( CompoundStmt *compoundStmt );
     138                virtual void visit( IfStmt *ifStmt );
     139                virtual void visit( WhileStmt *whileStmt );
     140                virtual void visit( ForStmt *forStmt );
     141                virtual void visit( SwitchStmt *switchStmt );
     142                virtual void visit( ChooseStmt *chooseStmt );
     143                virtual void visit( CaseStmt *caseStmt );
     144                virtual void visit( CatchStmt *catchStmt );
     145
     146                AddStructAssignment() : functionNesting( 0 ) {}
    134147      private:
    135         template< typename StmtClass > void visitStatement( StmtClass *stmt );
    136  
    137         std::list< Declaration * > declsToAdd;
    138         std::set< std::string > structsDone;
    139         unsigned int functionNesting;                   // current level of nested functions
     148                template< typename StmtClass > void visitStatement( StmtClass *stmt );
     149 
     150                std::list< Declaration * > declsToAdd;
     151                std::set< std::string > structsDone;
     152                unsigned int functionNesting;                   // current level of nested functions
    140153    };
    141154
    142155    class EliminateTypedef : public Mutator {
    143156      public:
    144         static void eliminateTypedef( std::list< Declaration * > &translationUnit );
     157                static void eliminateTypedef( std::list< Declaration * > &translationUnit );
    145158      private:
    146         virtual Declaration *mutate( TypedefDecl *typeDecl );
    147         virtual TypeDecl *mutate( TypeDecl *typeDecl );
    148         virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );
    149         virtual ObjectDecl *mutate( ObjectDecl *objDecl );
    150         virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );
    151         virtual Type *mutate( TypeInstType *aggregateUseType );
    152         virtual Expression *mutate( CastExpr *castExpr );
    153  
    154         std::map< std::string, TypedefDecl * > typedefNames;
     159                virtual Declaration *mutate( TypedefDecl *typeDecl );
     160                virtual TypeDecl *mutate( TypeDecl *typeDecl );
     161                virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );
     162                virtual ObjectDecl *mutate( ObjectDecl *objDecl );
     163                virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );
     164                virtual Type *mutate( TypeInstType *aggregateUseType );
     165                virtual Expression *mutate( CastExpr *castExpr );
     166 
     167                std::map< std::string, TypedefDecl * > typedefNames;
    155168    };
    156169
    157170    void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
    158         Pass1 pass1;
    159         Pass2 pass2( doDebug, 0 );
    160         Pass3 pass3( 0 );
    161         EliminateTypedef::eliminateTypedef( translationUnit );
    162         HoistStruct::hoistStruct( translationUnit );
    163         acceptAll( translationUnit, pass1 );
    164         acceptAll( translationUnit, pass2 );
    165         AddStructAssignment::addStructAssignment( translationUnit );
    166         acceptAll( translationUnit, pass3 );
     171                Pass1 pass1;
     172                Pass2 pass2( doDebug, 0 );
     173                Pass3 pass3( 0 );
     174                EliminateTypedef::eliminateTypedef( translationUnit );
     175                HoistStruct::hoistStruct( translationUnit );
     176                acceptAll( translationUnit, pass1 );
     177                acceptAll( translationUnit, pass2 );
     178                AddStructAssignment::addStructAssignment( translationUnit );
     179                acceptAll( translationUnit, pass3 );
    167180    }
    168181   
    169182    void validateType( Type *type, const Indexer *indexer ) {
    170         Pass1 pass1;
    171         Pass2 pass2( false, indexer );
    172         Pass3 pass3( indexer );
    173         type->accept( pass1 );
    174         type->accept( pass2 );
    175         type->accept( pass3 );
     183                Pass1 pass1;
     184                Pass2 pass2( false, indexer );
     185                Pass3 pass3( indexer );
     186                type->accept( pass1 );
     187                type->accept( pass2 );
     188                type->accept( pass3 );
    176189    }
    177190
    178191    template< typename Visitor >
    179192    void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
    180         std::list< Declaration * >::iterator i = translationUnit.begin();
    181         while ( i != translationUnit.end() ) {
    182             (*i)->accept( visitor );
    183             std::list< Declaration * >::iterator next = i;
    184             next++;
    185             if ( ! visitor.get_declsToAdd().empty() ) {
    186                 translationUnit.splice( addBefore ? i : next, visitor.get_declsToAdd() );
    187             } // if
    188             i = next;
    189         } // while
     193                std::list< Declaration * >::iterator i = translationUnit.begin();
     194                while ( i != translationUnit.end() ) {
     195                        (*i)->accept( visitor );
     196                        std::list< Declaration * >::iterator next = i;
     197                        next++;
     198                        if ( ! visitor.get_declsToAdd().empty() ) {
     199                                translationUnit.splice( addBefore ? i : next, visitor.get_declsToAdd() );
     200                        } // if
     201                        i = next;
     202                } // while
    190203    }
    191204
    192205    void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
    193         HoistStruct hoister;
    194         acceptAndAdd( translationUnit, hoister, true );
     206                HoistStruct hoister;
     207                acceptAndAdd( translationUnit, hoister, true );
    195208    }
    196209
     
    199212
    200213    void filter( std::list< Declaration * > &declList, bool (*pred)( Declaration * ), bool doDelete ) {
    201         std::list< Declaration * >::iterator i = declList.begin();
    202         while ( i != declList.end() ) {
    203             std::list< Declaration * >::iterator next = i;
    204             ++next;
    205             if ( pred( *i ) ) {
    206                 if ( doDelete ) {
    207                     delete *i;
    208                 } // if
    209                 declList.erase( i );
    210             } // if
    211             i = next;
    212         } // while
     214                std::list< Declaration * >::iterator i = declList.begin();
     215                while ( i != declList.end() ) {
     216                        std::list< Declaration * >::iterator next = i;
     217                        ++next;
     218                        if ( pred( *i ) ) {
     219                                if ( doDelete ) {
     220                                        delete *i;
     221                                } // if
     222                                declList.erase( i );
     223                        } // if
     224                        i = next;
     225                } // while
    213226    }
    214227
    215228    bool isStructOrUnion( Declaration *decl ) {
    216         return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
     229                return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
    217230    }
    218231
    219232    template< typename AggDecl >
    220233    void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
    221         if ( inStruct ) {
    222             // Add elements in stack order corresponding to nesting structure.
    223             declsToAdd.push_front( aggregateDecl );
    224             Visitor::visit( aggregateDecl );
    225         } else {
    226             inStruct = true;
    227             Visitor::visit( aggregateDecl );
    228             inStruct = false;
    229         } // if
    230         // Always remove the hoisted aggregate from the inner structure.
    231         filter( aggregateDecl->get_members(), isStructOrUnion, false );
     234                if ( inStruct ) {
     235                        // Add elements in stack order corresponding to nesting structure.
     236                        declsToAdd.push_front( aggregateDecl );
     237                        Visitor::visit( aggregateDecl );
     238                } else {
     239                        inStruct = true;
     240                        Visitor::visit( aggregateDecl );
     241                        inStruct = false;
     242                } // if
     243                // Always remove the hoisted aggregate from the inner structure.
     244                filter( aggregateDecl->get_members(), isStructOrUnion, false );
    232245    }
    233246
    234247    void HoistStruct::visit( StructDecl *aggregateDecl ) {
    235         handleAggregate( aggregateDecl );
     248                handleAggregate( aggregateDecl );
    236249    }
    237250
    238251    void HoistStruct::visit( UnionDecl *aggregateDecl ) {
    239         handleAggregate( aggregateDecl );
     252                handleAggregate( aggregateDecl );
    240253    }
    241254
    242255    void HoistStruct::visit( CompoundStmt *compoundStmt ) {
    243         addVisit( compoundStmt, *this );
     256                addVisit( compoundStmt, *this );
    244257    }
    245258
    246259    void HoistStruct::visit( IfStmt *ifStmt ) {
    247         addVisit( ifStmt, *this );
     260                addVisit( ifStmt, *this );
    248261    }
    249262
    250263    void HoistStruct::visit( WhileStmt *whileStmt ) {
    251         addVisit( whileStmt, *this );
     264                addVisit( whileStmt, *this );
    252265    }
    253266
    254267    void HoistStruct::visit( ForStmt *forStmt ) {
    255         addVisit( forStmt, *this );
     268                addVisit( forStmt, *this );
    256269    }
    257270
    258271    void HoistStruct::visit( SwitchStmt *switchStmt ) {
    259         addVisit( switchStmt, *this );
     272                addVisit( switchStmt, *this );
    260273    }
    261274
    262275    void HoistStruct::visit( ChooseStmt *switchStmt ) {
    263         addVisit( switchStmt, *this );
     276                addVisit( switchStmt, *this );
    264277    }
    265278
    266279    void HoistStruct::visit( CaseStmt *caseStmt ) {
    267         addVisit( caseStmt, *this );
     280                addVisit( caseStmt, *this );
    268281    }
    269282
    270283    void HoistStruct::visit( CatchStmt *cathStmt ) {
    271         addVisit( cathStmt, *this );
     284                addVisit( cathStmt, *this );
    272285    }
    273286
    274287    void Pass1::visit( EnumDecl *enumDecl ) {
    275         // Set the type of each member of the enumeration to be EnumConstant
    276  
    277         for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
    278             ObjectDecl *obj = dynamic_cast< ObjectDecl * >( *i );
    279             assert( obj );
    280             obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
    281         } // for
    282         Parent::visit( enumDecl );
     288                // Set the type of each member of the enumeration to be EnumConstant
     289 
     290                for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
     291                        ObjectDecl *obj = dynamic_cast< ObjectDecl * >( *i );
     292                        assert( obj );
     293                        obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
     294                } // for
     295                Parent::visit( enumDecl );
    283296    }
    284297
    285298    namespace {
    286         template< typename DWTIterator >
    287         void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
    288             // the only case in which "void" is valid is where it is the only one in the list; then
    289             // it should be removed entirely
    290             // other fix ups are handled by the FixFunction class
    291             if ( begin == end ) return;
    292             FixFunction fixer;
    293             DWTIterator i = begin;
    294             *i = (*i )->acceptMutator( fixer );
    295             if ( fixer.get_isVoid() ) {
    296                 DWTIterator j = i;
    297                 ++i;
    298                 func->get_parameters().erase( j );
    299                 if ( i != end ) {
    300                     throw SemanticError( "invalid type void in function type ", func );
    301                 } // if
    302             } else {
    303                 ++i;
    304                 for ( ; i != end; ++i ) {
    305                     FixFunction fixer;
    306                     *i = (*i )->acceptMutator( fixer );
    307                     if ( fixer.get_isVoid() ) {
    308                         throw SemanticError( "invalid type void in function type ", func );
    309                     } // if
     299                template< typename DWTIterator >
     300                void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
     301                        // the only case in which "void" is valid is where it is the only one in the list; then it should be removed
     302                        // entirely other fix ups are handled by the FixFunction class
     303                        if ( begin == end ) return;
     304                        FixFunction fixer;
     305                        DWTIterator i = begin;
     306                        *i = (*i )->acceptMutator( fixer );
     307                        if ( fixer.get_isVoid() ) {
     308                                DWTIterator j = i;
     309                                ++i;
     310                                func->get_parameters().erase( j );
     311                                if ( i != end ) {
     312                                        throw SemanticError( "invalid type void in function type ", func );
     313                                } // if
     314                        } else {
     315                                ++i;
     316                                for ( ; i != end; ++i ) {
     317                                        FixFunction fixer;
     318                                        *i = (*i )->acceptMutator( fixer );
     319                                        if ( fixer.get_isVoid() ) {
     320                                                throw SemanticError( "invalid type void in function type ", func );
     321                                        } // if
     322                                } // for
     323                        } // if
     324                }
     325    }
     326
     327    void Pass1::visit( FunctionType *func ) {
     328                // Fix up parameters and return types
     329                fixFunctionList( func->get_parameters().begin(), func->get_parameters().end(), func );
     330                fixFunctionList( func->get_returnVals().begin(), func->get_returnVals().end(), func );
     331                Visitor::visit( func );
     332    }
     333
     334    Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
     335                if ( other_indexer ) {
     336                        indexer = other_indexer;
     337                } else {
     338                        indexer = this;
     339                } // if
     340    }
     341
     342    void Pass2::visit( StructInstType *structInst ) {
     343                Parent::visit( structInst );
     344                StructDecl *st = indexer->lookupStruct( structInst->get_name() );
     345                // it's not a semantic error if the struct is not found, just an implicit forward declaration
     346                if ( st ) {
     347                        assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
     348                        structInst->set_baseStruct( st );
     349                } // if
     350                if ( ! st || st->get_members().empty() ) {
     351                        // use of forward declaration
     352                        forwardStructs[ structInst->get_name() ].push_back( structInst );
     353                } // if
     354    }
     355
     356    void Pass2::visit( UnionInstType *unionInst ) {
     357                Parent::visit( unionInst );
     358                UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
     359                // it's not a semantic error if the union is not found, just an implicit forward declaration
     360                if ( un ) {
     361                        unionInst->set_baseUnion( un );
     362                } // if
     363                if ( ! un || un->get_members().empty() ) {
     364                        // use of forward declaration
     365                        forwardUnions[ unionInst->get_name() ].push_back( unionInst );
     366                } // if
     367    }
     368
     369    void Pass2::visit( ContextInstType *contextInst ) {
     370                Parent::visit( contextInst );
     371                ContextDecl *ctx = indexer->lookupContext( contextInst->get_name() );
     372                if ( ! ctx ) {
     373                        throw SemanticError( "use of undeclared context " + contextInst->get_name() );
     374                } // if
     375                for ( std::list< TypeDecl * >::const_iterator i = ctx->get_parameters().begin(); i != ctx->get_parameters().end(); ++i ) {
     376                        for ( std::list< DeclarationWithType * >::const_iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
     377                                if ( ContextInstType *otherCtx = dynamic_cast< ContextInstType * >(*assert ) ) {
     378                                        cloneAll( otherCtx->get_members(), contextInst->get_members() );
     379                                } else {
     380                                        contextInst->get_members().push_back( (*assert )->clone() );
     381                                } // if
     382                        } // for
    310383                } // for
    311             } // if
    312         }
    313     }
    314 
    315     void Pass1::visit( FunctionType *func ) {
    316         // Fix up parameters and return types
    317         fixFunctionList( func->get_parameters().begin(), func->get_parameters().end(), func );
    318         fixFunctionList( func->get_returnVals().begin(), func->get_returnVals().end(), func );
    319         Visitor::visit( func );
    320     }
    321 
    322     Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
    323         if ( other_indexer ) {
    324             indexer = other_indexer;
    325         } else {
    326             indexer = this;
    327         } // if
    328     }
    329 
    330     void Pass2::visit( StructInstType *structInst ) {
    331         Parent::visit( structInst );
    332         StructDecl *st = indexer->lookupStruct( structInst->get_name() );
    333         // it's not a semantic error if the struct is not found, just an implicit forward declaration
    334         if ( st ) {
    335             assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
    336             structInst->set_baseStruct( st );
    337         } // if
    338         if ( ! st || st->get_members().empty() ) {
    339             // use of forward declaration
    340             forwardStructs[ structInst->get_name() ].push_back( structInst );
    341         } // if
    342     }
    343 
    344     void Pass2::visit( UnionInstType *unionInst ) {
    345         Parent::visit( unionInst );
    346         UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
    347         // it's not a semantic error if the union is not found, just an implicit forward declaration
    348         if ( un ) {
    349             unionInst->set_baseUnion( un );
    350         } // if
    351         if ( ! un || un->get_members().empty() ) {
    352             // use of forward declaration
    353             forwardUnions[ unionInst->get_name() ].push_back( unionInst );
    354         } // if
    355     }
    356 
    357     void Pass2::visit( ContextInstType *contextInst ) {
    358         Parent::visit( contextInst );
    359         ContextDecl *ctx = indexer->lookupContext( contextInst->get_name() );
    360         if ( ! ctx ) {
    361             throw SemanticError( "use of undeclared context " + contextInst->get_name() );
    362         } // if
    363         for ( std::list< TypeDecl * >::const_iterator i = ctx->get_parameters().begin(); i != ctx->get_parameters().end(); ++i ) {
    364             for ( std::list< DeclarationWithType * >::const_iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
    365                 if ( ContextInstType *otherCtx = dynamic_cast< ContextInstType * >(*assert ) ) {
    366                     cloneAll( otherCtx->get_members(), contextInst->get_members() );
     384                applySubstitution( ctx->get_parameters().begin(), ctx->get_parameters().end(), contextInst->get_parameters().begin(), ctx->get_members().begin(), ctx->get_members().end(), back_inserter( contextInst->get_members() ) );
     385    }
     386
     387    void Pass2::visit( StructDecl *structDecl ) {
     388                if ( ! structDecl->get_members().empty() ) {
     389                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
     390                        if ( fwds != forwardStructs.end() ) {
     391                                for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
     392                                        (*inst )->set_baseStruct( structDecl );
     393                                } // for
     394                                forwardStructs.erase( fwds );
     395                        } // if
     396                } // if
     397                Indexer::visit( structDecl );
     398    }
     399
     400    void Pass2::visit( UnionDecl *unionDecl ) {
     401                if ( ! unionDecl->get_members().empty() ) {
     402                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
     403                        if ( fwds != forwardUnions.end() ) {
     404                                for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
     405                                        (*inst )->set_baseUnion( unionDecl );
     406                                } // for
     407                                forwardUnions.erase( fwds );
     408                        } // if
     409                } // if
     410                Indexer::visit( unionDecl );
     411    }
     412
     413    void Pass2::visit( TypeInstType *typeInst ) {
     414                if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
     415                        if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
     416                                typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
     417                        } // if
     418                } // if
     419    }
     420
     421    Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
     422                if ( other_indexer ) {
     423                        indexer = other_indexer;
    367424                } else {
    368                     contextInst->get_members().push_back( (*assert )->clone() );
    369                 } // if
    370             } // for
    371         } // for
    372         applySubstitution( ctx->get_parameters().begin(), ctx->get_parameters().end(), contextInst->get_parameters().begin(), ctx->get_members().begin(), ctx->get_members().end(), back_inserter( contextInst->get_members() ) );
    373     }
    374 
    375     void Pass2::visit( StructDecl *structDecl ) {
    376         if ( ! structDecl->get_members().empty() ) {
    377             ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
    378             if ( fwds != forwardStructs.end() ) {
    379                 for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    380                     (*inst )->set_baseStruct( structDecl );
     425                        indexer = this;
     426                } // if
     427    }
     428
     429    void forallFixer( Type *func ) {
     430                // Fix up assertions
     431                for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
     432                        std::list< DeclarationWithType * > toBeDone, nextRound;
     433                        toBeDone.splice( toBeDone.end(), (*type )->get_assertions() );
     434                        while ( ! toBeDone.empty() ) {
     435                                for ( std::list< DeclarationWithType * >::iterator assertion = toBeDone.begin(); assertion != toBeDone.end(); ++assertion ) {
     436                                        if ( ContextInstType *ctx = dynamic_cast< ContextInstType * >( (*assertion )->get_type() ) ) {
     437                                                for ( std::list< Declaration * >::const_iterator i = ctx->get_members().begin(); i != ctx->get_members().end(); ++i ) {
     438                                                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *i );
     439                                                        assert( dwt );
     440                                                        nextRound.push_back( dwt->clone() );
     441                                                }
     442                                                delete ctx;
     443                                        } else {
     444                                                FixFunction fixer;
     445                                                *assertion = (*assertion )->acceptMutator( fixer );
     446                                                if ( fixer.get_isVoid() ) {
     447                                                        throw SemanticError( "invalid type void in assertion of function ", func );
     448                                                }
     449                                                (*type )->get_assertions().push_back( *assertion );
     450                                        } // if
     451                                } // for
     452                                toBeDone.clear();
     453                                toBeDone.splice( toBeDone.end(), nextRound );
     454                        } // while
    381455                } // for
    382                 forwardStructs.erase( fwds );
    383             } // if
    384         } // if
    385         Indexer::visit( structDecl );
    386     }
    387 
    388     void Pass2::visit( UnionDecl *unionDecl ) {
    389         if ( ! unionDecl->get_members().empty() ) {
    390             ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
    391             if ( fwds != forwardUnions.end() ) {
    392                 for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
    393                     (*inst )->set_baseUnion( unionDecl );
    394                 } // for
    395                 forwardUnions.erase( fwds );
    396             } // if
    397         } // if
    398         Indexer::visit( unionDecl );
    399     }
    400 
    401     void Pass2::visit( TypeInstType *typeInst ) {
    402         if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
    403             if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
    404                 typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
    405             } // if
    406         } // if
    407     }
    408 
    409     Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
    410         if ( other_indexer ) {
    411             indexer = other_indexer;
    412         } else {
    413             indexer = this;
    414         } // if
    415     }
    416 
    417     void forallFixer( Type *func ) {
    418         // Fix up assertions
    419         for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
    420             std::list< DeclarationWithType * > toBeDone, nextRound;
    421             toBeDone.splice( toBeDone.end(), (*type )->get_assertions() );
    422             while ( ! toBeDone.empty() ) {
    423                 for ( std::list< DeclarationWithType * >::iterator assertion = toBeDone.begin(); assertion != toBeDone.end(); ++assertion ) {
    424                     if ( ContextInstType *ctx = dynamic_cast< ContextInstType * >( (*assertion )->get_type() ) ) {
    425                         for ( std::list< Declaration * >::const_iterator i = ctx->get_members().begin(); i != ctx->get_members().end(); ++i ) {
    426                             DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *i );
    427                             assert( dwt );
    428                             nextRound.push_back( dwt->clone() );
    429                         }
    430                         delete ctx;
    431                     } else {
    432                         FixFunction fixer;
    433                         *assertion = (*assertion )->acceptMutator( fixer );
    434                         if ( fixer.get_isVoid() ) {
    435                             throw SemanticError( "invalid type void in assertion of function ", func );
    436                         }
    437                         (*type )->get_assertions().push_back( *assertion );
    438                     }
    439                 }
    440                 toBeDone.clear();
    441                 toBeDone.splice( toBeDone.end(), nextRound );
    442             }
    443         }
    444456    }
    445457
    446458    void Pass3::visit( ObjectDecl *object ) {
    447         forallFixer( object->get_type() );
    448         if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
    449             forallFixer( pointer->get_base() );
    450         } // if
    451         Parent::visit( object );
    452         object->fixUniqueId();
     459                forallFixer( object->get_type() );
     460                if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
     461                        forallFixer( pointer->get_base() );
     462                } // if
     463                Parent::visit( object );
     464                object->fixUniqueId();
    453465    }
    454466
    455467    void Pass3::visit( FunctionDecl *func ) {
    456         forallFixer( func->get_type() );
    457         Parent::visit( func );
    458         func->fixUniqueId();
     468                forallFixer( func->get_type() );
     469                Parent::visit( func );
     470                func->fixUniqueId();
    459471    }
    460472
     
    462474
    463475    void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
    464         AddStructAssignment visitor;
    465         acceptAndAdd( translationUnit, visitor, false );
     476                AddStructAssignment visitor;
     477                acceptAndAdd( translationUnit, visitor, false );
    466478    }
    467479
    468480    template< typename OutputIterator >
    469481    void makeScalarAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, OutputIterator out ) {
    470         ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member );
    471         // unnamed bit fields are not copied as they cannot be accessed
    472         if ( obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL ) return;
    473 
    474         UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
    475  
    476         UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
    477         derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
    478  
    479         // do something special for unnamed members
    480         Expression *dstselect = new AddressExpr( new MemberExpr( member, derefExpr ) );
    481         assignExpr->get_args().push_back( dstselect );
    482  
    483         Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
    484         assignExpr->get_args().push_back( srcselect );
    485  
    486         *out++ = new ExprStmt( noLabels, assignExpr );
     482                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member );
     483                // unnamed bit fields are not copied as they cannot be accessed
     484                if ( obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL ) return;
     485
     486                UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
     487 
     488                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
     489                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
     490 
     491                // do something special for unnamed members
     492                Expression *dstselect = new AddressExpr( new MemberExpr( member, derefExpr ) );
     493                assignExpr->get_args().push_back( dstselect );
     494 
     495                Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
     496                assignExpr->get_args().push_back( srcselect );
     497 
     498                *out++ = new ExprStmt( noLabels, assignExpr );
    487499    }
    488500
    489501    template< typename OutputIterator >
    490502    void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
    491         static UniqueName indexName( "_index" );
    492  
    493         // for a flexible array member nothing is done -- user must define own assignment
    494         if ( ! array->get_dimension() ) return;
    495  
    496         ObjectDecl *index = new ObjectDecl( indexName.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 );
    497         *out++ = new DeclStmt( noLabels, index );
    498  
    499         UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
    500         init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
    501         init->get_args().push_back( new NameExpr( "0" ) );
    502         Statement *initStmt = new ExprStmt( noLabels, init );
    503  
    504         UntypedExpr *cond = new UntypedExpr( new NameExpr( "?<?" ) );
    505         cond->get_args().push_back( new VariableExpr( index ) );
    506         cond->get_args().push_back( array->get_dimension()->clone() );
    507  
    508         UntypedExpr *inc = new UntypedExpr( new NameExpr( "++?" ) );
    509         inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
    510  
    511         UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
    512  
    513         UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
    514         derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
    515  
    516         Expression *dstselect = new MemberExpr( member, derefExpr );
    517         UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?+?" ) );
    518         dstIndex->get_args().push_back( dstselect );
    519         dstIndex->get_args().push_back( new VariableExpr( index ) );
    520         assignExpr->get_args().push_back( dstIndex );
    521  
    522         Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
    523         UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
    524         srcIndex->get_args().push_back( srcselect );
    525         srcIndex->get_args().push_back( new VariableExpr( index ) );
    526         assignExpr->get_args().push_back( srcIndex );
    527  
    528         *out++ = new ForStmt( noLabels, initStmt, cond, inc, new ExprStmt( noLabels, assignExpr ) );
     503                static UniqueName indexName( "_index" );
     504 
     505                // for a flexible array member nothing is done -- user must define own assignment
     506                if ( ! array->get_dimension() ) return;
     507 
     508                ObjectDecl *index = new ObjectDecl( indexName.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 );
     509                *out++ = new DeclStmt( noLabels, index );
     510 
     511                UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
     512                init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
     513                init->get_args().push_back( new NameExpr( "0" ) );
     514                Statement *initStmt = new ExprStmt( noLabels, init );
     515 
     516                UntypedExpr *cond = new UntypedExpr( new NameExpr( "?<?" ) );
     517                cond->get_args().push_back( new VariableExpr( index ) );
     518                cond->get_args().push_back( array->get_dimension()->clone() );
     519 
     520                UntypedExpr *inc = new UntypedExpr( new NameExpr( "++?" ) );
     521                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
     522 
     523                UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
     524 
     525                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
     526                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
     527 
     528                Expression *dstselect = new MemberExpr( member, derefExpr );
     529                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?+?" ) );
     530                dstIndex->get_args().push_back( dstselect );
     531                dstIndex->get_args().push_back( new VariableExpr( index ) );
     532                assignExpr->get_args().push_back( dstIndex );
     533 
     534                Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
     535                UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
     536                srcIndex->get_args().push_back( srcselect );
     537                srcIndex->get_args().push_back( new VariableExpr( index ) );
     538                assignExpr->get_args().push_back( srcIndex );
     539 
     540                *out++ = new ForStmt( noLabels, initStmt, cond, inc, new ExprStmt( noLabels, assignExpr ) );
    529541    }
    530542
    531543    Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
    532         FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
    533  
    534         ObjectDecl *returnVal = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
    535         assignType->get_returnVals().push_back( returnVal );
    536  
    537         ObjectDecl *dstParam = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
    538         assignType->get_parameters().push_back( dstParam );
    539  
    540         ObjectDecl *srcParam = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
    541         assignType->get_parameters().push_back( srcParam );
    542 
    543         // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
    544         // because each unit generates copies of the default routines for each aggregate.
    545         FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? Declaration::NoStorageClass : Declaration::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true );
    546         assignDecl->fixUniqueId();
    547  
    548         for ( std::list< Declaration * >::const_iterator member = aggregateDecl->get_members().begin(); member != aggregateDecl->get_members().end(); ++member ) {
    549             if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ) ) {
    550                 if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
    551                     makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
    552                 } else {
    553                     makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
    554                 } // if
    555             } // if
    556         } // for
    557         assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
    558  
    559         return assignDecl;
     544                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
     545 
     546                ObjectDecl *returnVal = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
     547                assignType->get_returnVals().push_back( returnVal );
     548 
     549                ObjectDecl *dstParam = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
     550                assignType->get_parameters().push_back( dstParam );
     551 
     552                ObjectDecl *srcParam = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
     553                assignType->get_parameters().push_back( srcParam );
     554
     555                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
     556                // because each unit generates copies of the default routines for each aggregate.
     557                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? Declaration::NoStorageClass : Declaration::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true );
     558                assignDecl->fixUniqueId();
     559 
     560                for ( std::list< Declaration * >::const_iterator member = aggregateDecl->get_members().begin(); member != aggregateDecl->get_members().end(); ++member ) {
     561                        if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ) ) {
     562                                if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
     563                                        makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
     564                                } else {
     565                                        makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
     566                                } // if
     567                        } // if
     568                } // for
     569                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
     570 
     571                return assignDecl;
    560572    }
    561573
    562574    Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
    563         FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
    564  
    565         ObjectDecl *returnVal = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
    566         assignType->get_returnVals().push_back( returnVal );
    567  
    568         ObjectDecl *dstParam = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
    569         assignType->get_parameters().push_back( dstParam );
    570  
    571         ObjectDecl *srcParam = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
    572         assignType->get_parameters().push_back( srcParam );
    573  
    574         // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
    575         // because each unit generates copies of the default routines for each aggregate.
    576         FunctionDecl *assignDecl = new FunctionDecl( "?=?",  functionNesting > 0 ? Declaration::NoStorageClass : Declaration::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true );
    577         assignDecl->fixUniqueId();
    578  
    579         UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
    580         copy->get_args().push_back( new VariableExpr( dstParam ) );
    581         copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
    582         copy->get_args().push_back( new SizeofExpr( refType->clone() ) );
    583 
    584         assignDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, copy ) );
    585         assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
    586  
    587         return assignDecl;
     575                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
     576 
     577                ObjectDecl *returnVal = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
     578                assignType->get_returnVals().push_back( returnVal );
     579 
     580                ObjectDecl *dstParam = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
     581                assignType->get_parameters().push_back( dstParam );
     582 
     583                ObjectDecl *srcParam = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
     584                assignType->get_parameters().push_back( srcParam );
     585 
     586                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
     587                // because each unit generates copies of the default routines for each aggregate.
     588                FunctionDecl *assignDecl = new FunctionDecl( "?=?",  functionNesting > 0 ? Declaration::NoStorageClass : Declaration::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true );
     589                assignDecl->fixUniqueId();
     590 
     591                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
     592                copy->get_args().push_back( new VariableExpr( dstParam ) );
     593                copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
     594                copy->get_args().push_back( new SizeofExpr( refType->clone() ) );
     595
     596                assignDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, copy ) );
     597                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
     598 
     599                return assignDecl;
    588600    }
    589601
    590602    void AddStructAssignment::visit( StructDecl *structDecl ) {
    591         if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
    592             StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() );
    593             structInst->set_baseStruct( structDecl );
    594             declsToAdd.push_back( makeStructAssignment( structDecl, structInst, functionNesting ) );
    595             structsDone.insert( structDecl->get_name() );
    596         } // if
     603                if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
     604                        StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() );
     605                        structInst->set_baseStruct( structDecl );
     606                        declsToAdd.push_back( makeStructAssignment( structDecl, structInst, functionNesting ) );
     607                        structsDone.insert( structDecl->get_name() );
     608                } // if
    597609    }
    598610
    599611    void AddStructAssignment::visit( UnionDecl *unionDecl ) {
    600         if ( ! unionDecl->get_members().empty() ) {
    601             UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
    602             unionInst->set_baseUnion( unionDecl );
    603             declsToAdd.push_back( makeUnionAssignment( unionDecl, unionInst, functionNesting ) );
    604         } // if
     612                if ( ! unionDecl->get_members().empty() ) {
     613                        UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
     614                        unionInst->set_baseUnion( unionDecl );
     615                        declsToAdd.push_back( makeUnionAssignment( unionDecl, unionInst, functionNesting ) );
     616                } // if
    605617    }
    606618
    607619    void AddStructAssignment::visit( TypeDecl *typeDecl ) {
    608         CompoundStmt *stmts = 0;
    609         TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
    610         typeInst->set_baseType( typeDecl );
    611         ObjectDecl *src = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, typeInst->clone(), 0 );
    612         ObjectDecl *dst = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), typeInst->clone() ), 0 );
    613         if ( typeDecl->get_base() ) {
    614             stmts = new CompoundStmt( std::list< Label >() );
    615             UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
    616             assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) );
    617             assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) );
    618             stmts->get_kids().push_back( new ReturnStmt( std::list< Label >(), assign ) );
    619         } // if
    620         FunctionType *type = new FunctionType( Type::Qualifiers(), false );
    621         type->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, typeInst, 0 ) );
    622         type->get_parameters().push_back( dst );
    623         type->get_parameters().push_back( src );
    624         FunctionDecl *func = new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::AutoGen, type, stmts, false );
    625         declsToAdd.push_back( func );
     620                CompoundStmt *stmts = 0;
     621                TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
     622                typeInst->set_baseType( typeDecl );
     623                ObjectDecl *src = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, typeInst->clone(), 0 );
     624                ObjectDecl *dst = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), typeInst->clone() ), 0 );
     625                if ( typeDecl->get_base() ) {
     626                        stmts = new CompoundStmt( std::list< Label >() );
     627                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
     628                        assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) );
     629                        assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) );
     630                        stmts->get_kids().push_back( new ReturnStmt( std::list< Label >(), assign ) );
     631                } // if
     632                FunctionType *type = new FunctionType( Type::Qualifiers(), false );
     633                type->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, typeInst, 0 ) );
     634                type->get_parameters().push_back( dst );
     635                type->get_parameters().push_back( src );
     636                FunctionDecl *func = new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::AutoGen, type, stmts, false );
     637                declsToAdd.push_back( func );
    626638    }
    627639
    628640    void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
    629         if ( ! declsToAdd.empty() ) {
    630             for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
    631                 statements.insert( i, new DeclStmt( noLabels, *decl ) );
    632             } // for
    633             declsToAdd.clear();
    634         } // if
     641                if ( ! declsToAdd.empty() ) {
     642                        for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
     643                                statements.insert( i, new DeclStmt( noLabels, *decl ) );
     644                        } // for
     645                        declsToAdd.clear();
     646                } // if
    635647    }
    636648
    637649    void AddStructAssignment::visit( FunctionType *) {
    638         // ensure that we don't add assignment ops for types defined as part of the function
     650                // ensure that we don't add assignment ops for types defined as part of the function
    639651    }
    640652
    641653    void AddStructAssignment::visit( PointerType *) {
    642         // ensure that we don't add assignment ops for types defined as part of the pointer
     654                // ensure that we don't add assignment ops for types defined as part of the pointer
    643655    }
    644656
    645657    void AddStructAssignment::visit( ContextDecl *) {
    646         // ensure that we don't add assignment ops for types defined as part of the context
     658                // ensure that we don't add assignment ops for types defined as part of the context
    647659    }
    648660
    649661    template< typename StmtClass >
    650662    inline void AddStructAssignment::visitStatement( StmtClass *stmt ) {
    651         std::set< std::string > oldStructs = structsDone;
    652         addVisit( stmt, *this );
    653         structsDone = oldStructs;
     663                std::set< std::string > oldStructs = structsDone;
     664                addVisit( stmt, *this );
     665                structsDone = oldStructs;
    654666    }
    655667
    656668    void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
    657         maybeAccept( functionDecl->get_functionType(), *this );
    658         acceptAll( functionDecl->get_oldDecls(), *this );
    659         functionNesting += 1;
    660         maybeAccept( functionDecl->get_statements(), *this );
    661         functionNesting -= 1;
     669                maybeAccept( functionDecl->get_functionType(), *this );
     670                acceptAll( functionDecl->get_oldDecls(), *this );
     671                functionNesting += 1;
     672                maybeAccept( functionDecl->get_statements(), *this );
     673                functionNesting -= 1;
    662674    }
    663675
    664676    void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
    665         visitStatement( compoundStmt );
     677                visitStatement( compoundStmt );
    666678    }
    667679
    668680    void AddStructAssignment::visit( IfStmt *ifStmt ) {
    669         visitStatement( ifStmt );
     681                visitStatement( ifStmt );
    670682    }
    671683
    672684    void AddStructAssignment::visit( WhileStmt *whileStmt ) {
    673         visitStatement( whileStmt );
     685                visitStatement( whileStmt );
    674686    }
    675687
    676688    void AddStructAssignment::visit( ForStmt *forStmt ) {
    677         visitStatement( forStmt );
     689                visitStatement( forStmt );
    678690    }
    679691
    680692    void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
    681         visitStatement( switchStmt );
     693                visitStatement( switchStmt );
    682694    }
    683695
    684696    void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
    685         visitStatement( switchStmt );
     697                visitStatement( switchStmt );
    686698    }
    687699
    688700    void AddStructAssignment::visit( CaseStmt *caseStmt ) {
    689         visitStatement( caseStmt );
     701                visitStatement( caseStmt );
    690702    }
    691703
    692704    void AddStructAssignment::visit( CatchStmt *cathStmt ) {
    693         visitStatement( cathStmt );
     705                visitStatement( cathStmt );
    694706    }
    695707
    696708    bool isTypedef( Declaration *decl ) {
    697         return dynamic_cast< TypedefDecl * >( decl );
     709                return dynamic_cast< TypedefDecl * >( decl );
    698710    }
    699711
    700712    void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
    701         EliminateTypedef eliminator;
    702         mutateAll( translationUnit, eliminator );
    703         filter( translationUnit, isTypedef, true );
     713                EliminateTypedef eliminator;
     714                mutateAll( translationUnit, eliminator );
     715                filter( translationUnit, isTypedef, true );
    704716    }
    705717
    706718    Type *EliminateTypedef::mutate( TypeInstType *typeInst ) {
    707         std::map< std::string, TypedefDecl * >::const_iterator def = typedefNames.find( typeInst->get_name() );
    708         if ( def != typedefNames.end() ) {
    709             Type *ret = def->second->get_base()->clone();
    710             ret->get_qualifiers() += typeInst->get_qualifiers();
    711             delete typeInst;
    712             return ret;
    713         } // if
    714         return typeInst;
     719                std::map< std::string, TypedefDecl * >::const_iterator def = typedefNames.find( typeInst->get_name() );
     720                if ( def != typedefNames.end() ) {
     721                        Type *ret = def->second->get_base()->clone();
     722                        ret->get_qualifiers() += typeInst->get_qualifiers();
     723                        delete typeInst;
     724                        return ret;
     725                } // if
     726                return typeInst;
    715727    }
    716728
    717729    Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
    718         Declaration *ret = Mutator::mutate( tyDecl );
    719         typedefNames[ tyDecl->get_name() ] = tyDecl;
    720         // When a typedef is a forward declaration:
    721         //    typedef struct screen SCREEN;
    722         // the declaration portion must be retained:
    723         //    struct screen;
    724         // because the expansion of the typedef is:
    725         //    void rtn( SCREEN *p ) => void rtn( struct screen *p )
    726         // hence the type-name "screen" must be defined.
    727         // Note, qualifiers on the typedef are superfluous for the forward declaration.
    728         if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( tyDecl->get_base() ) ) {
    729             return new StructDecl( aggDecl->get_name() );
    730         } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) {
    731             return new UnionDecl( aggDecl->get_name() );
    732         } else {
    733             return ret;
    734         } // if
     730                Declaration *ret = Mutator::mutate( tyDecl );
     731                typedefNames[ tyDecl->get_name() ] = tyDecl;
     732                // When a typedef is a forward declaration:
     733                //    typedef struct screen SCREEN;
     734                // the declaration portion must be retained:
     735                //    struct screen;
     736                // because the expansion of the typedef is:
     737                //    void rtn( SCREEN *p ) => void rtn( struct screen *p )
     738                // hence the type-name "screen" must be defined.
     739                // Note, qualifiers on the typedef are superfluous for the forward declaration.
     740                if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( tyDecl->get_base() ) ) {
     741                        return new StructDecl( aggDecl->get_name() );
     742                } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) {
     743                        return new UnionDecl( aggDecl->get_name() );
     744                } else {
     745                        return ret;
     746                } // if
    735747    }
    736748
    737749    TypeDecl *EliminateTypedef::mutate( TypeDecl *typeDecl ) {
    738         std::map< std::string, TypedefDecl * >::iterator i = typedefNames.find( typeDecl->get_name() );
    739         if ( i != typedefNames.end() ) {
    740             typedefNames.erase( i ) ;
    741         } // if
    742         return typeDecl;
     750                std::map< std::string, TypedefDecl * >::iterator i = typedefNames.find( typeDecl->get_name() );
     751                if ( i != typedefNames.end() ) {
     752                        typedefNames.erase( i ) ;
     753                } // if
     754                return typeDecl;
    743755    }
    744756
    745757    DeclarationWithType *EliminateTypedef::mutate( FunctionDecl *funcDecl ) {
    746         std::map< std::string, TypedefDecl * > oldNames = typedefNames;
    747         DeclarationWithType *ret = Mutator::mutate( funcDecl );
    748         typedefNames = oldNames;
    749         return ret;
     758                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
     759                DeclarationWithType *ret = Mutator::mutate( funcDecl );
     760                typedefNames = oldNames;
     761                return ret;
    750762    }
    751763
    752764    ObjectDecl *EliminateTypedef::mutate( ObjectDecl *objDecl ) {
    753         std::map< std::string, TypedefDecl * > oldNames = typedefNames;
    754         ObjectDecl *ret = Mutator::mutate( objDecl );
    755         typedefNames = oldNames;
    756         return ret;
     765                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
     766                ObjectDecl *ret = Mutator::mutate( objDecl );
     767                typedefNames = oldNames;
     768                return ret;
    757769    }
    758770
    759771    Expression *EliminateTypedef::mutate( CastExpr *castExpr ) {
    760         std::map< std::string, TypedefDecl * > oldNames = typedefNames;
    761         Expression *ret = Mutator::mutate( castExpr );
    762         typedefNames = oldNames;
    763         return ret;
     772                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
     773                Expression *ret = Mutator::mutate( castExpr );
     774                typedefNames = oldNames;
     775                return ret;
    764776    }
    765777
    766778    CompoundStmt *EliminateTypedef::mutate( CompoundStmt *compoundStmt ) {
    767         std::map< std::string, TypedefDecl * > oldNames = typedefNames;
    768         CompoundStmt *ret = Mutator::mutate( compoundStmt );
    769         std::list< Statement * >::iterator i = compoundStmt->get_kids().begin();
    770         while ( i != compoundStmt->get_kids().end() ) {
    771             std::list< Statement * >::iterator next = i;
    772             ++next;
    773             if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( *i ) ) {
    774                 if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
    775                     delete *i;
    776                     compoundStmt->get_kids().erase( i );
    777                 } // if
    778             } // if
    779             i = next;
    780         } // while
    781         typedefNames = oldNames;
    782         return ret;
     779                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
     780                CompoundStmt *ret = Mutator::mutate( compoundStmt );
     781                std::list< Statement * >::iterator i = compoundStmt->get_kids().begin();
     782                while ( i != compoundStmt->get_kids().end() ) {
     783                        std::list< Statement * >::iterator next = i;
     784                        ++next;
     785                        if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( *i ) ) {
     786                                if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
     787                                        delete *i;
     788                                        compoundStmt->get_kids().erase( i );
     789                                } // if
     790                        } // if
     791                        i = next;
     792                } // while
     793                typedefNames = oldNames;
     794                return ret;
    783795    }
    784796} // namespace SymTab
     797
     798// Local Variables: //
     799// tab-width: 4 //
     800// mode: c++ //
     801// compile-command: "make install" //
     802// End: //
  • translator/SymTab/Validate.h

    ra32b204 r0dd3a2f  
    1 // This class is intended to perform pre-processing of declarations, validating their
    2 // correctness and computing some auxilliary data that is necessary for the indexer.
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Validate.h -- This class is intended to perform pre-processing of declarations, validating their correctness and
     8//               computing some auxilliary data that is necessary for the indexer.
     9//
     10// Author           : Richard C. Bilson
     11// Created On       : Sun May 17 21:53:34 2015
     12// Last Modified By : Peter A. Buhr
     13// Last Modified On : Sun May 17 21:55:09 2015
     14// Update Count     : 2
     15//
    316
    4 #ifndef SYMTAB_VALIDATE_H
    5 #define SYMTAB_VALIDATE_H
     17#ifndef VALIDATE_H
     18#define VALIDATE_H
    619
    720#include "SynTree/SynTree.h"
     
    1225    void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
    1326    void validateType( Type *type, const Indexer *indexer );
    14 } // SymTab
     27} // namespace SymTab
    1528
    16 #endif // SYMTAB_VALIDATE_H
     29#endif // VALIDATE_H
     30
     31// Local Variables: //
     32// tab-width: 4 //
     33// mode: c++ //
     34// compile-command: "make install" //
     35// End: //
  • translator/SynTree/AddressExpr.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: AddressExpr.cc,v 1.6 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// AddressExpr.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 23:54:44 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 07:48:14 2015
     13// Update Count     : 5
     14//
    715
    816#include "Expression.h"
     
    1018#include "utility.h"
    1119
    12 
    13 AddressExpr::AddressExpr( Expression *arg, Expression *_aname )
    14     : Expression( _aname ), arg( arg )
    15 {
     20AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
    1621    for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
    17         get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
    18     }
     22                get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
     23    } // for
    1924}
    2025
    21 AddressExpr::AddressExpr( const AddressExpr &other )
    22     : Expression( other ), arg( maybeClone( other.arg ) )
    23 {
     26AddressExpr::AddressExpr( const AddressExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
    2427}
    2528
    26 AddressExpr::~AddressExpr()
    27 {
     29AddressExpr::~AddressExpr() {
    2830    delete arg;
    2931}
    3032
    31 void
    32 AddressExpr::print( std::ostream &os, int indent ) const
    33 {
     33void AddressExpr::print( std::ostream &os, int indent ) const {
    3434    os << std::string( indent, ' ' ) << "Address of:" << std::endl;
    3535    if ( arg ) {
    36         arg->print( os, indent+2 );
    37     }
     36                arg->print( os, indent+2 );
     37    } // if
    3838}
    3939
    40 
     40// Local Variables: //
     41// tab-width: 4 //
     42// mode: c++ //
     43// compile-command: "make install" //
     44// End: //
  • translator/SynTree/AggregateDecl.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: AggregateDecl.cc,v 1.7 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// AggregateDecl.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Sun May 17 23:56:39 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 07:48:23 2015
     13// Update Count     : 4
     14//
    715
    816#include "Declaration.h"
     
    1119
    1220
    13 AggregateDecl::AggregateDecl( const std::string &name )
    14     : Parent( name, Declaration::NoStorageClass, LinkageSpec::Cforall )
    15 {
     21AggregateDecl::AggregateDecl( const std::string &name ) : Parent( name, Declaration::NoStorageClass, LinkageSpec::Cforall ) {
    1622}
    1723
    18 AggregateDecl::AggregateDecl( const AggregateDecl &other )
    19     : Parent( other )
    20 {
     24AggregateDecl::AggregateDecl( const AggregateDecl &other ) : Parent( other ) {
    2125    cloneAll( other.members, members );
    2226    cloneAll( other.parameters, parameters );
    2327}
    2428
    25 AggregateDecl::~AggregateDecl()
    26 {
     29AggregateDecl::~AggregateDecl() {
    2730    deleteAll( members );
    2831    deleteAll( parameters );
    2932}
    3033
    31 void
    32 AggregateDecl::print( std::ostream &os, int indent ) const
    33 {
     34void AggregateDecl::print( std::ostream &os, int indent ) const {
    3435    using std::string;
    3536    using std::endl;
     
    3738    os << typeString() << " " << get_name();
    3839    if ( ! parameters.empty() ) {
    39         os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
    40         printAll( parameters, os, indent+4 );
    41     }
     40                os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
     41                printAll( parameters, os, indent+4 );
     42    } // if
    4243    if ( ! members.empty() ) {
    43         os << endl << string( indent+2, ' ' ) << "with members" << endl;
    44         printAll( members, os, indent+4 );
    45     }
     44                os << endl << string( indent+2, ' ' ) << "with members" << endl;
     45                printAll( members, os, indent+4 );
     46    } // if
    4647}
    4748
    48 void
    49 AggregateDecl::printShort( std::ostream &os, int indent ) const
    50 {
     49void AggregateDecl::printShort( std::ostream &os, int indent ) const {
    5150    using std::string;
    5251    using std::endl;
     
    5453    os << typeString() << " " << get_name();
    5554    if ( ! parameters.empty() ) {
    56         os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
    57         printAll( parameters, os, indent+4 );
    58     }
     55                os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
     56                printAll( parameters, os, indent+4 );
     57    } // if
    5958}
    6059
     
    6766std::string ContextDecl::typeString() const { return "context"; }
    6867
     68// Local Variables: //
     69// tab-width: 4 //
     70// mode: c++ //
     71// compile-command: "make install" //
     72// End: //
  • translator/SynTree/ApplicationExpr.cc

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// ApplicationExpr.cc.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 07:54:17 2015
     13// Update Count     : 4
     14//
     15
    116#include <cassert>
    217
     
    823
    924
    10 ParamEntry::ParamEntry( const ParamEntry &other )
    11     : decl( other.decl ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) )
    12 {
     25ParamEntry::ParamEntry( const ParamEntry &other ) :
     26                decl( other.decl ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ) {
    1327}
    1428
    15 ParamEntry &
    16 ParamEntry::operator=( const ParamEntry &other )
    17 {
    18     if ( &other == this ) return *this;
    19     decl = other.decl;
    20     actualType = maybeClone( other.actualType );
    21     formalType = maybeClone( other.formalType );
    22     expr = maybeClone( other.expr );
    23     return *this;
     29ParamEntry &ParamEntry::operator=( const ParamEntry &other ) {
     30        if ( &other == this ) return *this;
     31        decl = other.decl;
     32        actualType = maybeClone( other.actualType );
     33        formalType = maybeClone( other.formalType );
     34        expr = maybeClone( other.expr );
     35        return *this;
    2436}
    2537
    26 ParamEntry::~ParamEntry()
    27 {
    28     delete actualType;
    29     delete formalType;
    30     delete expr;
     38ParamEntry::~ParamEntry() {
     39        delete actualType;
     40        delete formalType;
     41        delete expr;
    3142}
    3243
    33 ApplicationExpr::ApplicationExpr( Expression *funcExpr )
    34     : function( funcExpr )
    35 {
    36     PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
    37     assert( pointer );
    38     FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
    39     assert( function );
    40    
    41     for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
    42         get_results().push_back( (*i)->get_type()->clone() );
    43     }
     44ApplicationExpr::ApplicationExpr( Expression *funcExpr ) : function( funcExpr ) {
     45        PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
     46        assert( pointer );
     47        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
     48        assert( function );
     49       
     50        for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
     51                get_results().push_back( (*i)->get_type()->clone() );
     52        } // for
    4453}
    4554
    46 ApplicationExpr::ApplicationExpr( const ApplicationExpr &other )
    47     : Expression( other ), function( maybeClone( other.function ) ), inferParams( other.inferParams )
    48 {
    49     cloneAll( other.args, args );
     55ApplicationExpr::ApplicationExpr( const ApplicationExpr &other ) :
     56                Expression( other ), function( maybeClone( other.function ) ), inferParams( other.inferParams ) {
     57        cloneAll( other.args, args );
    5058}
    5159
    52 ApplicationExpr::~ApplicationExpr()
    53 {
    54     delete function;
    55     deleteAll( args );
     60ApplicationExpr::~ApplicationExpr() {
     61        delete function;
     62        deleteAll( args );
    5663}
    5764
    58 void
    59 ApplicationExpr::print( std::ostream &os, int indent ) const
    60 {
    61     os << std::string( indent, ' ' ) << "Application of" << std::endl;
    62     function->print( os, indent+2 );
    63     if ( ! args.empty() ) {
    64         os << std::string( indent, ' ' ) << "to arguments" << std::endl;
    65         printAll( args, os, indent+2 );
    66     }
    67     if ( ! inferParams.empty() ) {
    68         os << std::string(indent, ' ') << "with inferred parameters:" << std::endl;
    69         for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
    70             os << std::string(indent+2, ' ');
    71             Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
    72             os << std::endl;
    73         }
    74     }
    75     Expression::print( os, indent );
     65void ApplicationExpr::print( std::ostream &os, int indent ) const {
     66        os << std::string( indent, ' ' ) << "Application of" << std::endl;
     67        function->print( os, indent+2 );
     68        if ( ! args.empty() ) {
     69                os << std::string( indent, ' ' ) << "to arguments" << std::endl;
     70                printAll( args, os, indent+2 );
     71        } // if
     72        if ( ! inferParams.empty() ) {
     73                os << std::string(indent, ' ') << "with inferred parameters:" << std::endl;
     74                for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
     75                        os << std::string(indent+2, ' ');
     76                        Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
     77                        os << std::endl;
     78                } // for
     79        } // if
     80        Expression::print( os, indent );
    7681}
    7782
     83// Local Variables: //
     84// tab-width: 4 //
     85// mode: c++ //
     86// compile-command: "make install" //
     87// End: //
  • translator/SynTree/ArrayType.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: ArrayType.cc,v 1.6 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// ArrayType.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 07:52:08 2015
     13// Update Count     : 2
     14//
    715
    816#include "Type.h"
     
    1220
    1321ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic )
    14     : Type( tq ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic )
    15 {
    16     base->set_isLvalue( false );
     22                : Type( tq ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
     23        base->set_isLvalue( false );
    1724}
    1825
    1926ArrayType::ArrayType( const ArrayType &other )
    20     : Type( other ), base( maybeClone( other.base ) ), dimension( maybeClone( other.dimension ) ),
    21         isVarLen( other.isVarLen ), isStatic( other.isStatic )
    22 {
     27        : Type( other ), base( maybeClone( other.base ) ), dimension( maybeClone( other.dimension ) ),
     28          isVarLen( other.isVarLen ), isStatic( other.isStatic ) {
    2329}
    2430
    25 ArrayType::~ArrayType()
    26 {
    27     delete base;
    28     delete dimension;
     31ArrayType::~ArrayType() {
     32        delete base;
     33        delete dimension;
    2934}
    3035
    31 void
    32 ArrayType::print( std::ostream &os, int indent ) const
    33 {
    34     Type::print( os, indent );
    35     if ( isStatic ) {
    36         os << "static ";
    37     }
    38     if ( isVarLen ) {
    39         os << "variable length array of ";
    40     } else if ( dimension ) {
    41         os << "array of ";
    42         dimension->print( os, indent );
    43     } else {
    44         os << "open array of ";
    45     }
    46     if ( base ) {
    47         base->print( os, indent );
    48     }
     36void ArrayType::print( std::ostream &os, int indent ) const {
     37        Type::print( os, indent );
     38        if ( isStatic ) {
     39                os << "static ";
     40        } // if
     41        if ( isVarLen ) {
     42                os << "variable length array of ";
     43        } else if ( dimension ) {
     44                os << "array of ";
     45                dimension->print( os, indent );
     46        } else {
     47                os << "open array of ";
     48        } // if
     49        if ( base ) {
     50                base->print( os, indent );
     51        } // if
    4952}
    5053
     54// Local Variables: //
     55// tab-width: 4 //
     56// mode: c++ //
     57// compile-command: "make install" //
     58// End: //
  • translator/SynTree/AttrType.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: AttrType.cc,v 1.3 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// XXX.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 07:53:48 2015
     13// Update Count     : 1
     14//
    715
    816#include "Type.h"
     
    1220
    1321AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr )
    14     : Type( tq ), name( name ), expr( expr ), type( 0 ), isType( false )
    15 {
     22        : Type( tq ), name( name ), expr( expr ), type( 0 ), isType( false ) {
    1623}
    1724
    1825AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type )
    19     : Type( tq ), name( name ), expr( 0 ), type( type ), isType( true )
    20 {
     26        : Type( tq ), name( name ), expr( 0 ), type( type ), isType( true ) {
    2127}
    2228
    2329AttrType::AttrType( const AttrType &other )
    24     : Type( other ), name( other.name ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType )
    25 {
     30        : Type( other ), name( other.name ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
    2631}
    2732
    28 AttrType::~AttrType()
    29 {
    30     delete expr;
    31     delete type;
     33AttrType::~AttrType() {
     34        delete expr;
     35        delete type;
    3236}
    3337
    34 void
    35 AttrType::print( std::ostream &os, int indent ) const
    36 {
    37     Type::print( os, indent );
    38     os << "attribute " << name << " applied to ";
    39     if ( expr ) {
    40         os << "expression ";
    41         expr->print( os, indent );
    42     }
    43     if ( type ) {
    44         os << "type ";
    45         type->print( os, indent );
    46     }
     38void AttrType::print( std::ostream &os, int indent ) const {
     39        Type::print( os, indent );
     40        os << "attribute " << name << " applied to ";
     41        if ( expr ) {
     42                os << "expression ";
     43                expr->print( os, indent );
     44        } // if
     45        if ( type ) {
     46                os << "type ";
     47                type->print( os, indent );
     48        } // if
    4749}
    4850
     51// Local Variables: //
     52// tab-width: 4 //
     53// mode: c++ //
     54// compile-command: "make install" //
     55// End: //
  • translator/SynTree/BasicType.cc

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// BasicType.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 07:55:16 2015
     13// Update Count     : 1
     14//
     15
    116#include <cassert>
    2 
    317#include "Type.h"
    4 
    518
    619BasicType::BasicType( const Type::Qualifiers &tq, Kind bt ) : Type( tq ), kind( bt ) {}
    720
    821void BasicType::print( std::ostream &os, int indent ) const {
    9     static const char *kindNames[] = { 
    10         "_Bool", "char", "signed char", "unsigned char", "short signed int", "short unsigned int",
    11         "signed int", "unsigned int", "long signed int", "long unsigned int", "long long signed int",
    12         "long long unsigned int", "float", "double", "long double", "float _Complex", "double _Complex",
    13         "long double _Complex", "float _Imaginary", "double _Imaginary", "long double _Imaginary"
    14     };
     22        static const char *kindNames[] = {     
     23                "_Bool", "char", "signed char", "unsigned char", "short signed int", "short unsigned int",
     24                "signed int", "unsigned int", "long signed int", "long unsigned int", "long long signed int",
     25                "long long unsigned int", "float", "double", "long double", "float _Complex", "double _Complex",
     26                "long double _Complex", "float _Imaginary", "double _Imaginary", "long double _Imaginary"
     27        };
    1528
    16     Type::print( os, indent );
    17     os << kindNames[ kind ] << ' ';
     29        Type::print( os, indent );
     30        os << kindNames[ kind ] << ' ';
    1831}
    1932
    2033bool BasicType::isInteger() const {
    21     switch ( kind ) {
    22       case Bool:
    23       case Char:
    24       case SignedChar:
    25       case UnsignedChar:
    26       case ShortSignedInt:
    27       case ShortUnsignedInt:
    28       case SignedInt:
    29       case UnsignedInt:
    30       case LongSignedInt:
    31       case LongUnsignedInt:
    32       case LongLongSignedInt:
    33       case LongLongUnsignedInt:
    34         return true;
    35 
    36       case Float:
    37       case Double:
    38       case LongDouble:
    39       case FloatComplex:
    40       case DoubleComplex:
    41       case LongDoubleComplex:
    42       case FloatImaginary:
    43       case DoubleImaginary:
    44       case LongDoubleImaginary:
     34        switch ( kind ) {
     35          case Bool:
     36          case Char:
     37          case SignedChar:
     38          case UnsignedChar:
     39          case ShortSignedInt:
     40          case ShortUnsignedInt:
     41          case SignedInt:
     42          case UnsignedInt:
     43          case LongSignedInt:
     44          case LongUnsignedInt:
     45          case LongLongSignedInt:
     46          case LongLongUnsignedInt:
     47                return true;
     48          case Float:
     49          case Double:
     50          case LongDouble:
     51          case FloatComplex:
     52          case DoubleComplex:
     53          case LongDoubleComplex:
     54          case FloatImaginary:
     55          case DoubleImaginary:
     56          case LongDoubleImaginary:
     57                return false;
     58          case NUMBER_OF_BASIC_TYPES:
     59                assert( false );
     60        } // switch
     61        assert( false );
    4562        return false;
    46 
    47       case NUMBER_OF_BASIC_TYPES:
    48         assert( false );
    49     }
    50     assert( false );
    51     return false;
    5263}
    5364
    5465
     66// Local Variables: //
     67// tab-width: 4 //
     68// mode: c++ //
     69// compile-command: "make install" //
     70// End: //
  • translator/SynTree/CodeGenVisitor.cc

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// CodeGenVisitor.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 07:57:51 2015
     13// Update Count     : 3
     14//
     15
    116#include <iostream>
    217#include <list>
     
    722using namespace std;
    823
    9 //*** Types
    10 void CodeGenVisitor::visit(Type *type){ }
    11 void CodeGenVisitor::visit(BasicType *basicType) { }
     24void CodeGenVisitor::visit( Type *type ){ }
     25void CodeGenVisitor::visit( BasicType *basicType ) { }
    1226
    13 //*** Constant
    14 void CodeGenVisitor::visit(Constant *constant) {
    15     cout << constant->get_value() << endl;
     27void CodeGenVisitor::visit( Constant *constant ) {
     28        cout << constant->get_value() << endl;
    1629}
    1730
    18 //*** Expressions
    19 void CodeGenVisitor::visit(Expression *expr){ }
     31void CodeGenVisitor::visit( Expression *expr ){ }
    2032
    21 void CodeGenVisitor::visit(ConstantExpr *cnst){
    22     if (cnst != 0)
    23         visit(cnst->get_constant());
     33void CodeGenVisitor::visit( ConstantExpr *cnst ) {
     34        if ( cnst != 0 )
     35                visit(cnst->get_constant());
    2436}
    2537
    26 //*** Statements
    27 void CodeGenVisitor::visit(Statement *stmt){ }
     38void CodeGenVisitor::visit( Statement *stmt ) { }
    2839
    29 void CodeGenVisitor::visit(ExprStmt *exprStmt){
    30     if (exprStmt != 0)
    31         exprStmt->get_expr()->accept(*this);    // visit(exprStmt->get_expr()) doesn't work
     40void CodeGenVisitor::visit( ExprStmt *exprStmt ) {
     41        if ( exprStmt != 0 )
     42                exprStmt->get_expr()->accept( *this );                  // visit(exprStmt->get_expr()) doesn't work
    3243}
    3344
    34 void CodeGenVisitor::visit(SwitchStmt *switchStmt){
    35     cout << "switch (" << endl;     
    36     // visit(switchStmt->get_condition());   // why doesn't this work?
    37     switchStmt->get_condition()->accept(*this);
     45void CodeGenVisitor::visit( SwitchStmt *switchStmt ) {
     46        cout << "switch (" << endl;         
     47        // visit(switchStmt->get_condition());   // why doesn't this work?
     48        switchStmt->get_condition()->accept(*this);
    3849
    39     cout << ") {" << endl;     
    40     // visit(switchStmt->get_body());  // why doesn't this work?
    41     cout << "}" << endl;       
     50        cout << ") {" << endl; 
     51        // visit(switchStmt->get_body());  // why doesn't this work?
     52        cout << "}" << endl;   
    4253}
    4354
    44 
     55// Local Variables: //
     56// tab-width: 4 //
     57// mode: c++ //
     58// compile-command: "make install" //
     59// End: //
  • translator/SynTree/CodeGenVisitor.h

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// CodeGenVisitor.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 08:46:47 2015
     13// Update Count     : 4
     14//
     15
    116#ifndef CODEGENV_H
    217#define CODEGENV_H
     
    722#include "Visitor.h"
    823
     24class CodeGenVisitor : public Visitor {
     25  public:
     26        virtual void visit( Type * );
     27        virtual void visit( BasicType * );
    928
    10 class CodeGenVisitor : public Visitor {
    11 public:
    12     //*** Types
    13     virtual void visit(Type *);
    14     virtual void visit(BasicType *);
     29        virtual void visit( Constant * );
    1530
    16     //*** Constant
    17     virtual void visit(Constant *);
     31        virtual void visit( Expression * );
     32        virtual void visit( ConstantExpr * );
    1833
    19     //*** Expressions
    20     virtual void visit(Expression *);
    21     virtual void visit(ConstantExpr *);
    22 
    23     //*** Statements
    24     virtual void visit(Statement *);
    25     virtual void visit(ExprStmt *);
    26     virtual void visit(SwitchStmt *);
     34        virtual void visit( Statement * );
     35        virtual void visit( ExprStmt * );
     36        virtual void visit( SwitchStmt * );
    2737};
    2838
     39#endif // CODEGENV_H
    2940
    30 #endif /* #ifndef CODEGENV_H */
     41// Local Variables: //
     42// tab-width: 4 //
     43// mode: c++ //
     44// compile-command: "make install" //
     45// End: //
  • translator/SynTree/CommaExpr.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: CommaExpr.cc,v 1.7 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// CommaExpr.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 08:09:58 2015
     13// Update Count     : 1
     14//
    715
    816#include "Expression.h"
     
    1018#include "utility.h"
    1119
    12 
    1320CommaExpr::CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname )
    14     : Expression( _aname ), arg1( arg1 ), arg2( arg2 )
    15 {
    16     cloneAll( arg2->get_results(), get_results() );
     21                : Expression( _aname ), arg1( arg1 ), arg2( arg2 ) {
     22        cloneAll( arg2->get_results(), get_results() );
    1723}
    1824
    1925CommaExpr::CommaExpr( const CommaExpr &other )
    20     : Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) )
    21 {
     26                : Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ) {
    2227}
    2328
    24 CommaExpr::~CommaExpr()
    25 {
    26     delete arg1;
    27     delete arg2;
     29CommaExpr::~CommaExpr() {
     30        delete arg1;
     31        delete arg2;
    2832}
    2933
    30 void
    31 CommaExpr::print( std::ostream &os, int indent ) const
    32 {
    33     os << std::string( indent, ' ' ) << "Comma Expression:" << std::endl;
    34     arg1->print( os, indent+2 );
    35     os << std::endl;
    36     arg2->print( os, indent+2 );
    37     Expression::print( os, indent );
     34void CommaExpr::print( std::ostream &os, int indent ) const {
     35        os << std::string( indent, ' ' ) << "Comma Expression:" << std::endl;
     36        arg1->print( os, indent+2 );
     37        os << std::endl;
     38        arg2->print( os, indent+2 );
     39        Expression::print( os, indent );
    3840}
    3941
    40 
     42// Local Variables: //
     43// tab-width: 4 //
     44// mode: c++ //
     45// compile-command: "make install" //
     46// End: //
  • translator/SynTree/CompoundStmt.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: CompoundStmt.cc,v 1.4 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// XXX.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 08:11:02 2015
     13// Update Count     : 1
     14//
    715
    816#include "Statement.h"
     
    1826
    1927CompoundStmt::CompoundStmt( const CompoundStmt &other ) : Statement( other ) {
    20     cloneAll( other.kids, kids );
     28        cloneAll( other.kids, kids );
    2129}
    2230
    2331CompoundStmt::~CompoundStmt() {
    24     deleteAll( kids );
     32        deleteAll( kids );
    2533}
    2634
    2735void CompoundStmt::print( std::ostream &os, int indent ) {
    28     os << "\r" << string(indent, ' ') << "CompoundStmt" << endl ;
    29     printAll( kids, os, indent+2 );
     36        os << "\r" << string(indent, ' ') << "CompoundStmt" << endl ;
     37        printAll( kids, os, indent+2 );
    3038}
    3139
    32 
    33 
    34 
    35 
     40// Local Variables: //
     41// tab-width: 4 //
     42// mode: c++ //
     43// compile-command: "make install" //
     44// End: //
  • translator/SynTree/Constant.cc

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Constant.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 08:13:25 2015
     13// Update Count     : 1
     14//
     15
    116#include <iostream>
    217#include <list>
     
    520#include "Type.h"
    621
    7 
    8 Constant::Constant(Type *_type, std::string _value):
    9     type(_type), value(_value) {}
     22Constant::Constant( Type *_type, std::string _value ) : type(_type), value(_value) {}
    1023
    1124Constant::~Constant() {}
     
    1427
    1528void Constant::print( std::ostream &os ) const {
    16     os << value;
    17     if ( type ) {
    18         os << " (type: ";
    19         type->print( os );
    20         os << ")";
    21     }
     29        os << value;
     30        if ( type ) {
     31                os << " (type: ";
     32                type->print( os );
     33                os << ")";
     34        } // if
    2235}
    2336
    24 
    25 
    26 
     37// Local Variables: //
     38// tab-width: 4 //
     39// mode: c++ //
     40// compile-command: "make install" //
     41// End: //
  • translator/SynTree/Constant.h

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: Constant.h,v 1.6 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Constant.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 08:46:37 2015
     13// Update Count     : 2
     14//
    715
    816#ifndef CONSTANT_H
     
    1321#include "Mutator.h"
    1422
     23class Constant {
     24  public:
     25        Constant( Type *type, std::string value );
     26        virtual ~Constant();
    1527
    16 class Constant
    17 {
    18 public:
    19     Constant( Type *type, std::string value );
    20     virtual ~Constant();
     28        Type *get_type() { return type; }
     29        void set_type( Type *newValue ) { type = newValue; }
     30        std::string get_value() { return value; }
     31        void set_value( std::string newValue ) { value = newValue; }
    2132
    22     Type *get_type() { return type; }
    23     void set_type( Type *newValue ) { type = newValue; }
    24     std::string get_value() { return value; }
    25     void set_value( std::string newValue ) { value = newValue; }
    26 
    27     virtual Constant *clone() const;
    28     virtual void accept( Visitor &v ) { v.visit( this ); }
    29     virtual Constant *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    30     virtual void print( std::ostream &os ) const;
    31    
    32 private:
    33     Type *type;
    34     std::string value;
     33        virtual Constant *clone() const;
     34        virtual void accept( Visitor &v ) { v.visit( this ); }
     35        virtual Constant *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     36        virtual void print( std::ostream &os ) const;
     37  private:
     38        Type *type;
     39        std::string value;
    3540};
    3641
     42#endif // CONSTANT_H
    3743
    38 
    39 
    40 #endif /* #ifndef CONSTANT_H */
     44// Local Variables: //
     45// tab-width: 4 //
     46// mode: c++ //
     47// compile-command: "make install" //
     48// End: //
  • translator/SynTree/DeclStmt.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: DeclStmt.cc,v 1.4 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// DeclStmt.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 08:16:03 2015
     13// Update Count     : 2
     14//
    715
    816#include "Statement.h"
     
    1018#include "utility.h"
    1119
    12 
    13 DeclStmt::DeclStmt( std::list<Label> labels, Declaration *decl )
    14     : Statement( labels ), decl( decl )
    15 {
     20DeclStmt::DeclStmt( std::list<Label> labels, Declaration *decl ) : Statement( labels ), decl( decl ) {
    1621}
    1722
    18 DeclStmt::DeclStmt( const DeclStmt &other )
    19     : Statement( other ), decl( maybeClone( other.decl ) )
    20 {
     23DeclStmt::DeclStmt( const DeclStmt &other ) : Statement( other ), decl( maybeClone( other.decl ) ) {
    2124}
    2225
    23 DeclStmt::~DeclStmt()
    24 {
    25     delete decl;
     26DeclStmt::~DeclStmt() {
     27        delete decl;
    2628}
    2729
    28 void
    29 DeclStmt::print( std::ostream &os, int indent )
    30 {
    31     os << "Declaration of ";
    32     if ( decl ) {
    33         decl->print( os, indent );
    34     }
     30void DeclStmt::print( std::ostream &os, int indent ) {
     31        os << "Declaration of ";
     32        if ( decl ) {
     33                decl->print( os, indent );
     34        } // if
    3535}
    3636
    37 
     37// Local Variables: //
     38// tab-width: 4 //
     39// mode: c++ //
     40// compile-command: "make install" //
     41// End: //
  • translator/SynTree/Declaration.cc

    ra32b204 r0dd3a2f  
    1 /*
    2  * This file is part of the Cforall project
    3  *
    4  * $Id: Declaration.cc,v 1.8 2005/08/29 20:59:25 rcbilson Exp $
    5  *
    6  */
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Declaration.cc --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 08:18:35 2015
     13// Update Count     : 2
     14//
    715
    816#include <string>
     
    1422#include "utility.h"
    1523
    16 
    1724const char* Declaration::storageClassName[] = { "", "auto", "static", "extern", "register" }; 
    1825
     
    2229
    2330Declaration::Declaration( const std::string &name, StorageClass sc, LinkageSpec::Type linkage )
    24     : name( name ), storageClass( sc ), linkage( linkage ), uniqueId( 0 )
    25 {
     31        : name( name ), storageClass( sc ), linkage( linkage ), uniqueId( 0 ) {
    2632}
    2733
    2834Declaration::Declaration( const Declaration &other )
    29     : name( other.name ), storageClass( other.storageClass ), linkage( other.linkage ), uniqueId( other.uniqueId )
    30 {
     35        : name( other.name ), storageClass( other.storageClass ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
    3136}
    3237
    33 Declaration::~Declaration()
    34 {
     38Declaration::~Declaration() {
    3539}
    3640
    37 void
    38 Declaration::fixUniqueId()
    39 {
    40     uniqueId = ++lastUniqueId;
    41     idMap[ uniqueId ] = this;
     41void Declaration::fixUniqueId() {
     42        uniqueId = ++lastUniqueId;
     43        idMap[ uniqueId ] = this;
    4244}
    4345
    4446/* static class method */
    45 Declaration *
    46 Declaration::declFromId( UniqueId id )
    47 {
    48     IdMapType::const_iterator i = idMap.find( id );
    49     if ( i != idMap.end() ) {
    50         return i->second;
    51     } else {
    52         return 0;
    53     }
     47Declaration *Declaration::declFromId( UniqueId id ) {
     48        IdMapType::const_iterator i = idMap.find( id );
     49        if ( i != idMap.end() ) {
     50                return i->second;
     51        } else {
     52                return 0;
     53        } // if
    5454}
    5555
    5656/* static class method */
    57 void
    58 Declaration::dumpIds( std::ostream &os )
    59 {
    60     for ( IdMapType::const_iterator i = idMap.begin(); i != idMap.end(); ++i ) {
    61         os << i->first << " -> ";
    62         i->second->printShort( os );
    63         os << std::endl;
    64     }
     57void Declaration::dumpIds( std::ostream &os ) {
     58        for ( IdMapType::const_iterator i = idMap.begin(); i != idMap.end(); ++i ) {
     59                os << i->first << " -> ";
     60                i->second->printShort( os );
     61                os << std::endl;
     62        } // for
    6563}
    6664
     65// Local Variables: //
     66// tab-width: 4 //
     67// mode: c++ //
     68// compile-command: "make install" //
     69// End: //
  • translator/SynTree/Declaration.h

    ra32b204 r0dd3a2f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// Declaration.h --
     8//
     9// Author           : Richard C. Bilson
     10// Created On       : Mon May 18 07:44:20 2015
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon May 18 08:46:25 2015
     13// Update Count     : 2
     14//
     15
    116#ifndef DECLARATION_H
    217#define DECLARATION_H
     
    722#include "Parser/LinkageSpec.h"
    823
    9 
    1024class Declaration {
    1125  public:
    12     enum StorageClass { 
    13         NoStorageClass,
    14         Extern,
    15         Static,
    16         Auto,
    17         Register,
    18         Inline,
    19         Fortran,
    20     }; 
    21 
    22     Declaration( const std::string &name, StorageClass sc, LinkageSpec::Type linkage );
    23     Declaration( const Declaration &other );
    24     virtual ~Declaration();
    25 
    26     std::string get_name() const { return name; }
    27     void set_name( std::string newValue ) { name = newValue; }
    28     StorageClass get_storageClass() const { return storageClass; }
    29     void set_storageClass( StorageClass newValue ) { storageClass = newValue; }
    30     LinkageSpec::Type get_linkage() const { return linkage; }
    31     void set_linkage( LinkageSpec::Type newValue ) { linkage = newValue; }
    32     UniqueId get_uniqueId() const { return uniqueId; }
    33 
    34     void fixUniqueId( void );
    35     virtual Declaration *clone() const = 0;
    36     virtual void accept( Visitor &v ) = 0;
    37     virtual Declaration *acceptMutator( Mutator &m ) = 0;
    38     virtual void print( std::ostream &os, int indent = 0 ) const = 0;
    39     virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
    40 
    41     static const char* storageClassName[]; 
    42 
    43     static void dumpIds( std::ostream &os );
    44     static Declaration *declFromId( UniqueId id );
    45   private:
    46     std::string name;
    47     StorageClass storageClass;
    48     LinkageSpec::Type linkage;
    49     UniqueId uniqueId;
     26        enum StorageClass { 
     27                NoStorageClass,
     28                Extern,
     29                Static,
     30                Auto,
     31                Register,
     32                Inline,
     33                Fortran,
     34        };     
     35
     36        Declaration( const std::string &name, StorageClass sc, LinkageSpec::Type linkage );
     37        Declaration( const Declaration &other );
     38        virtual ~Declaration();
     39
     40        std::string get_name() const { return name; }
     41        void set_name( std::string newValue ) { name = newValue; }
     42        StorageClass get_storageClass() const { return storageClass; }
     43        void set_storageClass( StorageClass newValue ) { storageClass = newValue; }
     44        LinkageSpec::Type get_linkage() const { return linkage; }
     45        void set_linkage( LinkageSpec::Type newValue ) { linkage = newValue; }
     46        UniqueId get_uniqueId() const { return uniqueId; }
     47
     48        void fixUniqueId( void );
     49        virtual Declaration *clone() const = 0;
     50        virtual void accept( Visitor &v ) = 0;
     51        virtual Declaration *acceptMutator( Mutator &m ) = 0;
     52        virtual void print( std::ostream &os, int indent = 0 ) const = 0;
     53        virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
     54
     55        static const char* storageClassName[]; 
     56
     57        static void dumpIds( std::ostream &os );
     58        static Declaration *declFromId( UniqueId id );
     59  private:
     60        std::string name;
     61        StorageClass storageClass;
     62        LinkageSpec::Type linkage;
     63        UniqueId uniqueId;
    5064};
    5165
    5266class DeclarationWithType : public Declaration {
    5367  public:
    54     DeclarationWithType( const std::string &name, StorageClass sc, LinkageSpec::Type linkage );
    55     DeclarationWithType( const DeclarationWithType &other );
    56     virtual ~DeclarationWithType();
    57 
    58     std::string get_mangleName() const { return mangleName; }
    59     void set_mangleName( std::string newValue ) { mangleName = newValue; }
    60 
    61     virtual DeclarationWithType *clone() const = 0;
    62     virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
    63 
    64     virtual Type *get_type() const = 0;
    65     virtual void set_type(Type *) = 0;
    66   private:
    67     // this represents the type with all types and typedefs expanded it is generated by SymTab::Validate::Pass2
    68     std::string mangleName;
     68        DeclarationWithType( const std::string &name, StorageClass sc, LinkageSpec::Type linkage );
     69        DeclarationWithType( const DeclarationWithType &other );
     70        virtual ~DeclarationWithType();
     71
     72        std::string get_mangleName() const { return mangleName; }
     73        void set_mangleName( std::string newValue ) { mangleName = newValue; }
     74
     75        virtual DeclarationWithType *clone() const = 0;
     76        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
     77
     78        virtual Type *get_type() const = 0;
     79        virtual void set_type(Type *) = 0;
     80  private:
     81        // this represents the type with all types and typedefs expanded it is generated by SymTab::Validate::Pass2
     82        std::string mangleName;
    6983};
    7084
    7185class ObjectDecl : public DeclarationWithType {
    72     typedef DeclarationWithType Parent;
    73   public:
    74     ObjectDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init );
    75     ObjectDecl( const ObjectDecl &other );
    76     virtual ~ObjectDecl();
    77 
    78     virtual Type *get_type() const { return type; }
    79     virtual void set_type(Type *newType) { type = newType; }
    80 
    81     Initializer *get_init() const { return init; }
    82     void set_init( Initializer *newValue ) { init = newValue; }
    83     Expression *get_bitfieldWidth() const { return bitfieldWidth; }
    84     void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
    85 
    86     virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
    87     virtual void accept( Visitor &v ) { v.visit( this ); }
    88     virtual ObjectDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    89     virtual void print( std::ostream &os, int indent = 0 ) const;
    90     virtual void printShort( std::ostream &os, int indent = 0 ) const;
    91   private:
    92     Type *type;
    93     Initializer *init;
    94     Expression *bitfieldWidth;
     86        typedef DeclarationWithType Parent;
     87  public:
     88        ObjectDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init );
     89        ObjectDecl( const ObjectDecl &other );
     90        virtual ~ObjectDecl();
     91
     92        virtual Type *get_type() const { return type; }
     93        virtual void set_type(Type *newType) { type = newType; }
     94
     95        Initializer *get_init() const { return init; }
     96        void set_init( Initializer *newValue ) { init = newValue; }
     97        Expression *get_bitfieldWidth() const { return bitfieldWidth; }
     98        void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
     99
     100        virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
     101        virtual void accept( Visitor &v ) { v.visit( this ); }
     102        virtual ObjectDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     103        virtual void print( std::ostream &os, int indent = 0 ) const;
     104        virtual void printShort( std::ostream &os, int indent = 0 ) const;
     105  private:
     106        Type *type;
     107        Initializer *init;
     108        Expression *bitfieldWidth;
    95109};
    96110
    97111class FunctionDecl : public DeclarationWithType {
    98     typedef DeclarationWithType Parent;
    99   public:
    100     FunctionDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline );
    101     FunctionDecl( const FunctionDecl &other );
    102     virtual ~FunctionDecl();
    103 
    104     Type *get_type() const;
    105     virtual void set_type(Type *);
    106 
    107     FunctionType *get_functionType() const { return type; }
    108     void set_functionType( FunctionType *newValue ) { type = newValue; }
    109     CompoundStmt *get_statements() const { return statements; }
    110     void set_statements( CompoundStmt *newValue ) { statements = newValue; }
     112        typedef DeclarationWithType Parent;
     113  public:
     114        FunctionDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline );
     115        FunctionDecl( const FunctionDecl &other );
     116        virtual ~FunctionDecl();
     117
     118        Type *get_type() const;
     119        virtual void set_type(Type *);
     120
     121        FunctionType *get_functionType() const { return type; }
     122        void set_functionType( FunctionType *newValue ) { type = newValue; }
     123        CompoundStmt *get_statements() const { return statements; }
     124        void set_statements( CompoundStmt *newValue ) { statements = newValue; }
    111125//    bool get_isInline() const { return isInline; }
    112126//    void set_isInline( bool newValue ) { isInline = newValue; }
    113     std::list< std::string >& get_oldIdents() { return oldIdents; }
    114     std::list< Declaration* >& get_oldDecls() { return oldDecls; }
    115 
    116     virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
    117     virtual void accept( Visitor &v ) { v.visit( this ); }
    118     virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    119     virtual void print( std::ostream &os, int indent = 0 ) const;
    120     virtual void printShort( std::ostream &os, int indent = 0 ) const;
    121   private:
    122     FunctionType *type;
    123     CompoundStmt *statements;
    124     bool isInline;
    125     std::list< std::string > oldIdents;
    126     std::list< Declaration* > oldDecls;
     127        std::list< std::string >& get_oldIdents() { return oldIdents; }
     128        std::list< Declaration* >& get_oldDecls() { return oldDecls; }
     129
     130        virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
     131        virtual void accept( Visitor &v ) { v.visit( this ); }
     132        virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     133        virtual void print( std::ostream &os, int indent = 0 ) const;
     134        virtual void printShort( std::ostream &os, int indent = 0 ) const;
     135  private:
     136        FunctionType *type;
     137        CompoundStmt *statements;
     138        bool isInline;
     139        std::list< std::string > oldIdents;
     140        std::list< Declaration* > oldDecls;
    127141};
    128142
    129143class NamedTypeDecl : public Declaration {
    130     typedef Declaration Parent;
    131   public:
    132     NamedTypeDecl( const std::string &name, StorageClass sc, Type *type );
    133     NamedTypeDecl( const TypeDecl &other );
    134     virtual ~NamedTypeDecl();
    135 
    136     Type *get_base() const { return base; }
    137     void set_base( Type *newValue ) { base = newValue; }
    138     std::list< TypeDecl* >& get_parameters() { return parameters; }
    139     std::list< DeclarationWithType* >& get_assertions() { return assertions; }
    140 
    141     virtual NamedTypeDecl *clone() const = 0;
    142     virtual void print( std::ostream &os, int indent = 0 ) const;
    143     virtual void printShort( std::ostream &os, int indent = 0 ) const;
     144        typedef Declaration Parent;
     145  public:
     146        NamedTypeDecl( const std::string &name, StorageClass sc, Type *type );
     147        NamedTypeDecl( const TypeDecl &other );
     148        virtual ~NamedTypeDecl();
     149
     150        Type *get_base() const { return base; }
     151        void set_base( Type *newValue ) { base = newValue; }
     152        std::list< TypeDecl* >& get_parameters() { return parameters; }
     153        std::list< DeclarationWithType* >& get_assertions() { return assertions; }
     154
     155        virtual NamedTypeDecl *clone() const = 0;
     156        virtual void print( std::ostream &os, int indent = 0 ) const;
     157        virtual void printShort( std::ostream &os, int indent = 0 ) const;
    144158  protected:
    145     virtual std::string typeString() const = 0;
    146   private:
    147     Type *base;
    148     std::list< TypeDecl* > parameters;
    149     std::list< DeclarationWithType* > assertions;
     159        virtual std::string typeString() const = 0;
     160  private:
     161        Type *base;
     162        std::list< TypeDecl* > parameters;
     163        std::list< DeclarationWithType* > assertions;
    150164};
    151165
    152166class TypeDecl : public NamedTypeDecl {
    153     typedef NamedTypeDecl Parent;
    154   public:
    155     enum Kind { Any, Dtype, Ftype };
    156 
    157     TypeDecl( const std::string &name, StorageClass sc, Type *type, Kind kind );
    158     TypeDecl( const TypeDecl &other );
    159 
    160     Kind get_kind() const { return kind; }
    161 
    162     virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
    163     virtual void accept( Visitor &v ) { v.visit( this ); }
    164     virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    165   private:
    166     virtual std::string typeString() const;
    167     Kind kind;
     167        typedef NamedTypeDecl Parent;
     168  public:
     169        enum Kind { Any, Dtype, Ftype };
     170
     171        TypeDecl( const std::string &name, StorageClass sc, Type *type, Kind kind );
     172        TypeDecl( const TypeDecl &other );
     173
     174        Kind get_kind() const { return kind; }
     175
     176        virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
     177        virtual void accept( Visitor &v ) { v.visit( this ); }
     178        virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     179  private:
     180        virtual std::string typeString() const;
     181        Kind kind;
    168182};
    169183
    170184class TypedefDecl : public NamedTypeDecl {
    171     typedef NamedTypeDecl Parent;
    172   public:
    173     TypedefDecl( const std::string &name, StorageClass sc, Type *type ) : Parent( name, sc, type ) {}
    174     TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
    175 
    176     virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
    177     virtual void accept( Visitor &v ) { v.visit( this ); }
    178     virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    179   private:
    180     virtual std::string typeString() const;
     185        typedef NamedTypeDecl Parent;
     186  public:
     187        TypedefDecl( const std::string &name, StorageClass sc, Type *type ) : Parent( name, sc, type ) {}
     188        TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
     189
     190        virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
     191        virtual void accept( Visitor &v ) { v.visit( this ); }
     192        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     193  private:
     194        virtual std::string typeString() const;
    181195};
    182196
    183197class AggregateDecl : public Declaration {
    184     typedef Declaration Parent;
    185   public:
    186     AggregateDecl( const std::string &name );
    187     AggregateDecl( const AggregateDecl &other );
    188     virtual ~AggregateDecl();
    189 
    190     std::list<Declaration*>& get_members() { return members; }
    191     std::list<TypeDecl*>& get_parameters() { return parameters; }
    192 
    193     virtual void print( std::ostream &os, int indent = 0 ) const;
    194     virtual void printShort( std::ostream &os, int indent = 0 ) const;
     198        typedef Declaration Parent;
     199  public:
     200        AggregateDecl( const std::string &name );
     201        AggregateDecl( const AggregateDecl &other );
     202        virtual ~AggregateDecl();
     203
     204        std::list<Declaration*>& get_members() { return members; }
     205        std::list<TypeDecl*>& get_parameters() { return parameters; }
     206
     207        virtual void print( std::ostream &os, int indent = 0 ) const;
     208        virtual void printShort( std::ostream &os, int indent = 0 ) const;
    195209  protected:
    196     virtual std::string typeString() const = 0;
    197 
    198   private:
    199     std::list<Declaration*> members;
    200     std::list<TypeDecl*> parameters;
     210        virtual std::string typeString() const = 0;
     211
     212  private:
     213        std::list<Declaration*> members;
     214        std::list<TypeDecl*> parameters;
    201215};
    202216
    203217class StructDecl : public AggregateDecl {
    204     typedef AggregateDecl Parent;
    205   public:
    206     StructDecl( const std::string &name ) : Parent( name ) {}
    207     StructDecl( const StructDecl &other ) : Parent( other ) {}
    208 
    209     virtual StructDecl *clone() const { return new StructDecl( *this ); }
    210     virtual void accept( Visitor &v ) { v.visit( this ); }
    211     virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    212 
    213   private:
    214     virtual std::string typeString() const;
     218        typedef AggregateDecl Parent;
     219  public:
     220        StructDecl( const std::string &name ) : Parent( name ) {}
     221        StructDecl( const StructDecl &other ) : Parent( other ) {}
     222
     223        virtual StructDecl *clone() const { return new StructDecl( *this ); }
     224        virtual void accept( Visitor &v ) { v.visit( this ); }
     225        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     226
     227  private:
     228        virtual std::string typeString() const;
    215229};
    216230
    217231class UnionDecl : public AggregateDecl {
    218     typedef AggregateDecl Parent;
    219   public:
    220     UnionDecl( const std::string &name ) : Parent( name ) {}
    221     UnionDecl( const UnionDecl &other ) : Parent( other ) {}
    222 
    223     virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
    224     virtual void accept( Visitor &v ) { v.visit( this ); }
    225     virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this )