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

licencing: third groups of files

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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: //
Note: See TracChangeset for help on using the changeset viewer.