[d76c588] | 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 | // SymbolTable.cpp -- |
---|
| 8 | // |
---|
| 9 | // Author : Aaron B. Moss |
---|
| 10 | // Created On : Wed May 29 11:00:00 2019 |
---|
| 11 | // Last Modified By : Aaron B. Moss |
---|
| 12 | // Last Modified On : Wed May 29 11:00:00 2019 |
---|
| 13 | // Update Count : 1 |
---|
| 14 | // |
---|
| 15 | |
---|
| 16 | #include "SymbolTable.hpp" |
---|
| 17 | |
---|
| 18 | #include <cassert> |
---|
| 19 | |
---|
| 20 | #include "Decl.hpp" |
---|
| 21 | #include "Expr.hpp" |
---|
[e01eb4a] | 22 | #include "Inspect.hpp" |
---|
[d76c588] | 23 | #include "Type.hpp" |
---|
[fed6a0f] | 24 | #include "CodeGen/OperatorTable.h" // for isCtorDtorAssign |
---|
[d76c588] | 25 | #include "Common/SemanticError.h" |
---|
| 26 | #include "Common/Stats/Counter.h" |
---|
| 27 | #include "GenPoly/GenPoly.h" |
---|
| 28 | #include "InitTweak/InitTweak.h" |
---|
| 29 | #include "ResolvExpr/Cost.h" |
---|
[fed6a0f] | 30 | #include "ResolvExpr/CandidateFinder.hpp" // for referenceToRvalueConversion |
---|
[e563edf] | 31 | #include "ResolvExpr/Unify.h" |
---|
[d76c588] | 32 | #include "SymTab/Mangler.h" |
---|
| 33 | |
---|
| 34 | namespace ast { |
---|
| 35 | |
---|
| 36 | // Statistics block |
---|
| 37 | namespace { |
---|
| 38 | static inline auto stats() { |
---|
| 39 | using namespace Stats::Counters; |
---|
| 40 | static auto group = build<CounterGroup>("Indexers"); |
---|
| 41 | static struct { |
---|
| 42 | SimpleCounter * count; |
---|
| 43 | AverageCounter<double> * size; |
---|
| 44 | SimpleCounter * new_scopes; |
---|
| 45 | SimpleCounter * lazy_scopes; |
---|
| 46 | AverageCounter<double> * avg_scope_depth; |
---|
| 47 | MaxCounter<size_t> * max_scope_depth; |
---|
| 48 | SimpleCounter * add_calls; |
---|
| 49 | SimpleCounter * lookup_calls; |
---|
| 50 | SimpleCounter * map_lookups; |
---|
| 51 | SimpleCounter * map_mutations; |
---|
| 52 | } ret = { |
---|
| 53 | .count = build<SimpleCounter>("Count", group), |
---|
| 54 | .size = build<AverageCounter<double>>("Average Size", group), |
---|
| 55 | .new_scopes = build<SimpleCounter>("Scopes", group), |
---|
| 56 | .lazy_scopes = build<SimpleCounter>("Lazy Scopes", group), |
---|
| 57 | .avg_scope_depth = build<AverageCounter<double>>("Average Scope", group), |
---|
| 58 | .max_scope_depth = build<MaxCounter<size_t>>("Max Scope", group), |
---|
| 59 | .add_calls = build<SimpleCounter>("Add Calls", group), |
---|
| 60 | .lookup_calls = build<SimpleCounter>("Lookup Calls", group), |
---|
| 61 | .map_lookups = build<SimpleCounter>("Map Lookups", group), |
---|
| 62 | .map_mutations = build<SimpleCounter>("Map Mutations", group) |
---|
| 63 | }; |
---|
| 64 | return ret; |
---|
| 65 | } |
---|
| 66 | } |
---|
| 67 | |
---|
| 68 | Expr * SymbolTable::IdData::combine( const CodeLocation & loc, ResolvExpr::Cost & cost ) const { |
---|
[9e23b446] | 69 | Expr * ret; |
---|
| 70 | if ( baseExpr ) { |
---|
| 71 | if (baseExpr->env) { |
---|
| 72 | Expr * base = shallowCopy(baseExpr); |
---|
| 73 | const TypeSubstitution * subs = baseExpr->env; |
---|
| 74 | base->env = nullptr; |
---|
| 75 | ret = new MemberExpr{loc, id, referenceToRvalueConversion( base, cost )}; |
---|
| 76 | ret->env = subs; |
---|
| 77 | } |
---|
| 78 | else { |
---|
| 79 | ret = new MemberExpr{ loc, id, referenceToRvalueConversion( baseExpr, cost ) }; |
---|
| 80 | } |
---|
| 81 | } |
---|
| 82 | else { |
---|
| 83 | ret = new VariableExpr{ loc, id }; |
---|
| 84 | } |
---|
[d76c588] | 85 | if ( deleter ) { ret = new DeletedExpr{ loc, ret, deleter }; } |
---|
| 86 | return ret; |
---|
| 87 | } |
---|
| 88 | |
---|
| 89 | SymbolTable::SymbolTable() |
---|
[e67991f] | 90 | : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(), |
---|
[d76c588] | 91 | prevScope(), scope( 0 ), repScope( 0 ) { ++*stats().count; } |
---|
| 92 | |
---|
| 93 | SymbolTable::~SymbolTable() { stats().size->push( idTable ? idTable->size() : 0 ); } |
---|
| 94 | |
---|
| 95 | void SymbolTable::enterScope() { |
---|
| 96 | ++scope; |
---|
| 97 | |
---|
| 98 | ++*stats().new_scopes; |
---|
| 99 | stats().avg_scope_depth->push( scope ); |
---|
| 100 | stats().max_scope_depth->push( scope ); |
---|
| 101 | } |
---|
| 102 | |
---|
| 103 | void SymbolTable::leaveScope() { |
---|
| 104 | if ( repScope == scope ) { |
---|
| 105 | Ptr prev = prevScope; // make sure prevScope stays live |
---|
| 106 | *this = std::move(*prevScope); // replace with previous scope |
---|
| 107 | } |
---|
| 108 | |
---|
| 109 | --scope; |
---|
| 110 | } |
---|
| 111 | |
---|
[e5c3811] | 112 | SymbolTable::SpecialFunctionKind SymbolTable::getSpecialFunctionKind(const std::string & name) { |
---|
| 113 | if (name == "?{}") return CTOR; |
---|
| 114 | if (name == "^?{}") return DTOR; |
---|
| 115 | if (name == "?=?") return ASSIGN; |
---|
| 116 | return NUMBER_OF_KINDS; |
---|
| 117 | } |
---|
| 118 | |
---|
[d76c588] | 119 | std::vector<SymbolTable::IdData> SymbolTable::lookupId( const std::string &id ) const { |
---|
[e5c3811] | 120 | static Stats::Counters::CounterGroup * name_lookup_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Name Lookup Stats"); |
---|
| 121 | static std::map<std::string, Stats::Counters::SimpleCounter *> lookups_by_name; |
---|
| 122 | static std::map<std::string, Stats::Counters::SimpleCounter *> candidates_by_name; |
---|
| 123 | |
---|
| 124 | SpecialFunctionKind kind = getSpecialFunctionKind(id); |
---|
| 125 | if (kind != NUMBER_OF_KINDS) return specialLookupId(kind); |
---|
| 126 | |
---|
[d76c588] | 127 | ++*stats().lookup_calls; |
---|
| 128 | if ( ! idTable ) return {}; |
---|
| 129 | |
---|
| 130 | ++*stats().map_lookups; |
---|
| 131 | auto decls = idTable->find( id ); |
---|
| 132 | if ( decls == idTable->end() ) return {}; |
---|
| 133 | |
---|
| 134 | std::vector<IdData> out; |
---|
| 135 | for ( auto decl : *(decls->second) ) { |
---|
| 136 | out.push_back( decl.second ); |
---|
| 137 | } |
---|
[e5c3811] | 138 | |
---|
| 139 | if (Stats::Counters::enabled) { |
---|
| 140 | if (! lookups_by_name.count(id)) { |
---|
| 141 | // leaks some strings, but it is because Counters do not hold them |
---|
| 142 | auto lookupCounterName = new std::string(id + "%count"); |
---|
| 143 | auto candidatesCounterName = new std::string(id + "%candidate"); |
---|
| 144 | lookups_by_name.emplace(id, new Stats::Counters::SimpleCounter(lookupCounterName->c_str(), name_lookup_stats)); |
---|
| 145 | candidates_by_name.emplace(id, new Stats::Counters::SimpleCounter(candidatesCounterName->c_str(), name_lookup_stats)); |
---|
| 146 | } |
---|
| 147 | (*lookups_by_name[id]) ++; |
---|
| 148 | *candidates_by_name[id] += out.size(); |
---|
| 149 | } |
---|
| 150 | |
---|
| 151 | return out; |
---|
| 152 | } |
---|
| 153 | |
---|
| 154 | std::vector<SymbolTable::IdData> SymbolTable::specialLookupId( SymbolTable::SpecialFunctionKind kind, const std::string & otypeKey ) const { |
---|
| 155 | static Stats::Counters::CounterGroup * special_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Special Lookups"); |
---|
| 156 | static Stats::Counters::SimpleCounter * stat_counts[3] = { |
---|
| 157 | Stats::Counters::build<Stats::Counters::SimpleCounter>("constructor - count", special_stats), |
---|
| 158 | Stats::Counters::build<Stats::Counters::SimpleCounter>("destructor - count", special_stats), |
---|
| 159 | Stats::Counters::build<Stats::Counters::SimpleCounter>("assignment - count", special_stats) |
---|
| 160 | }; |
---|
| 161 | |
---|
| 162 | static Stats::Counters::SimpleCounter * stat_candidates[3] = { |
---|
| 163 | Stats::Counters::build<Stats::Counters::SimpleCounter>("constructor - candidates", special_stats), |
---|
| 164 | Stats::Counters::build<Stats::Counters::SimpleCounter>("destructor - candidates", special_stats), |
---|
| 165 | Stats::Counters::build<Stats::Counters::SimpleCounter>("assignment - candidates", special_stats) |
---|
| 166 | }; |
---|
| 167 | |
---|
| 168 | static Stats::Counters::SimpleCounter * num_lookup_with_key |
---|
| 169 | = Stats::Counters::build<Stats::Counters::SimpleCounter>("keyed lookups", special_stats); |
---|
| 170 | static Stats::Counters::SimpleCounter * num_lookup_without_key |
---|
| 171 | = Stats::Counters::build<Stats::Counters::SimpleCounter>("unkeyed lookups", special_stats); |
---|
| 172 | |
---|
| 173 | assert (kind != NUMBER_OF_KINDS); |
---|
| 174 | ++*stats().lookup_calls; |
---|
| 175 | if ( ! specialFunctionTable[kind] ) return {}; |
---|
| 176 | |
---|
| 177 | std::vector<IdData> out; |
---|
| 178 | |
---|
| 179 | if (otypeKey.empty()) { // returns everything |
---|
| 180 | ++*num_lookup_without_key; |
---|
| 181 | for (auto & table : *specialFunctionTable[kind]) { |
---|
| 182 | for (auto & decl : *table.second) { |
---|
| 183 | out.push_back(decl.second); |
---|
| 184 | } |
---|
| 185 | } |
---|
| 186 | } |
---|
| 187 | else { |
---|
| 188 | ++*num_lookup_with_key; |
---|
| 189 | ++*stats().map_lookups; |
---|
| 190 | auto decls = specialFunctionTable[kind]->find(otypeKey); |
---|
| 191 | if (decls == specialFunctionTable[kind]->end()) return {}; |
---|
| 192 | |
---|
| 193 | for (auto decl : *(decls->second)) { |
---|
| 194 | out.push_back(decl.second); |
---|
| 195 | } |
---|
| 196 | } |
---|
| 197 | |
---|
| 198 | ++*stat_counts[kind]; |
---|
| 199 | *stat_candidates[kind] += out.size(); |
---|
| 200 | |
---|
[d76c588] | 201 | return out; |
---|
| 202 | } |
---|
| 203 | |
---|
| 204 | const NamedTypeDecl * SymbolTable::lookupType( const std::string &id ) const { |
---|
| 205 | ++*stats().lookup_calls; |
---|
| 206 | if ( ! typeTable ) return nullptr; |
---|
| 207 | ++*stats().map_lookups; |
---|
| 208 | auto it = typeTable->find( id ); |
---|
| 209 | return it == typeTable->end() ? nullptr : it->second.decl; |
---|
| 210 | } |
---|
| 211 | |
---|
| 212 | const StructDecl * SymbolTable::lookupStruct( const std::string &id ) const { |
---|
| 213 | ++*stats().lookup_calls; |
---|
| 214 | if ( ! structTable ) return nullptr; |
---|
| 215 | ++*stats().map_lookups; |
---|
| 216 | auto it = structTable->find( id ); |
---|
| 217 | return it == structTable->end() ? nullptr : it->second.decl; |
---|
| 218 | } |
---|
| 219 | |
---|
| 220 | const EnumDecl * SymbolTable::lookupEnum( const std::string &id ) const { |
---|
| 221 | ++*stats().lookup_calls; |
---|
| 222 | if ( ! enumTable ) return nullptr; |
---|
| 223 | ++*stats().map_lookups; |
---|
| 224 | auto it = enumTable->find( id ); |
---|
| 225 | return it == enumTable->end() ? nullptr : it->second.decl; |
---|
| 226 | } |
---|
| 227 | |
---|
| 228 | const UnionDecl * SymbolTable::lookupUnion( const std::string &id ) const { |
---|
| 229 | ++*stats().lookup_calls; |
---|
| 230 | if ( ! unionTable ) return nullptr; |
---|
| 231 | ++*stats().map_lookups; |
---|
| 232 | auto it = unionTable->find( id ); |
---|
| 233 | return it == unionTable->end() ? nullptr : it->second.decl; |
---|
| 234 | } |
---|
| 235 | |
---|
| 236 | const TraitDecl * SymbolTable::lookupTrait( const std::string &id ) const { |
---|
| 237 | ++*stats().lookup_calls; |
---|
| 238 | if ( ! traitTable ) return nullptr; |
---|
| 239 | ++*stats().map_lookups; |
---|
| 240 | auto it = traitTable->find( id ); |
---|
| 241 | return it == traitTable->end() ? nullptr : it->second.decl; |
---|
| 242 | } |
---|
| 243 | |
---|
| 244 | const NamedTypeDecl * SymbolTable::globalLookupType( const std::string &id ) const { |
---|
| 245 | return atScope( 0 )->lookupType( id ); |
---|
| 246 | } |
---|
| 247 | |
---|
| 248 | const StructDecl * SymbolTable::globalLookupStruct( const std::string &id ) const { |
---|
| 249 | return atScope( 0 )->lookupStruct( id ); |
---|
| 250 | } |
---|
| 251 | |
---|
| 252 | const UnionDecl * SymbolTable::globalLookupUnion( const std::string &id ) const { |
---|
| 253 | return atScope( 0 )->lookupUnion( id ); |
---|
| 254 | } |
---|
| 255 | |
---|
| 256 | const EnumDecl * SymbolTable::globalLookupEnum( const std::string &id ) const { |
---|
| 257 | return atScope( 0 )->lookupEnum( id ); |
---|
| 258 | } |
---|
| 259 | |
---|
| 260 | void SymbolTable::addId( const DeclWithType * decl, const Expr * baseExpr ) { |
---|
| 261 | // default handling of conflicts is to raise an error |
---|
| 262 | addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr ); |
---|
| 263 | } |
---|
| 264 | |
---|
[e67991f] | 265 | void SymbolTable::addDeletedId( const DeclWithType * decl, const Decl * deleter ) { |
---|
[d76c588] | 266 | // default handling of conflicts is to raise an error |
---|
| 267 | addId( decl, OnConflict::error(), nullptr, deleter ); |
---|
| 268 | } |
---|
| 269 | |
---|
| 270 | namespace { |
---|
| 271 | /// true if redeclaration conflict between two types |
---|
| 272 | bool addedTypeConflicts( const NamedTypeDecl * existing, const NamedTypeDecl * added ) { |
---|
| 273 | if ( existing->base == nullptr ) { |
---|
| 274 | return false; |
---|
| 275 | } else if ( added->base == nullptr ) { |
---|
| 276 | return true; |
---|
| 277 | } else { |
---|
| 278 | // typedef redeclarations are errors only if types are different |
---|
| 279 | if ( ! ResolvExpr::typesCompatible( existing->base, added->base, SymbolTable{} ) ) { |
---|
| 280 | SemanticError( added->location, "redeclaration of " + added->name ); |
---|
| 281 | } |
---|
| 282 | } |
---|
[e67991f] | 283 | // does not need to be added to the table if both existing and added have a base that are |
---|
[d76c588] | 284 | // the same |
---|
| 285 | return true; |
---|
| 286 | } |
---|
| 287 | |
---|
| 288 | /// true if redeclaration conflict between two aggregate declarations |
---|
| 289 | bool addedDeclConflicts( const AggregateDecl * existing, const AggregateDecl * added ) { |
---|
| 290 | if ( ! existing->body ) { |
---|
| 291 | return false; |
---|
| 292 | } else if ( added->body ) { |
---|
| 293 | SemanticError( added, "redeclaration of " ); |
---|
| 294 | } |
---|
| 295 | return true; |
---|
| 296 | } |
---|
| 297 | } |
---|
| 298 | |
---|
| 299 | void SymbolTable::addType( const NamedTypeDecl * decl ) { |
---|
| 300 | ++*stats().add_calls; |
---|
| 301 | const std::string &id = decl->name; |
---|
| 302 | |
---|
[e67991f] | 303 | if ( ! typeTable ) { |
---|
[d76c588] | 304 | typeTable = TypeTable::new_ptr(); |
---|
| 305 | } else { |
---|
| 306 | ++*stats().map_lookups; |
---|
| 307 | auto existing = typeTable->find( id ); |
---|
[e67991f] | 308 | if ( existing != typeTable->end() |
---|
| 309 | && existing->second.scope == scope |
---|
[d76c588] | 310 | && addedTypeConflicts( existing->second.decl, decl ) ) return; |
---|
| 311 | } |
---|
[e67991f] | 312 | |
---|
[d76c588] | 313 | lazyInitScope(); |
---|
| 314 | ++*stats().map_mutations; |
---|
| 315 | typeTable = typeTable->set( id, scoped<NamedTypeDecl>{ decl, scope } ); |
---|
| 316 | } |
---|
| 317 | |
---|
| 318 | void SymbolTable::addStruct( const std::string &id ) { |
---|
[4b8b2a4] | 319 | addStruct( new StructDecl( CodeLocation(), id ) ); |
---|
[d76c588] | 320 | } |
---|
| 321 | |
---|
| 322 | void SymbolTable::addStruct( const StructDecl * decl ) { |
---|
| 323 | ++*stats().add_calls; |
---|
| 324 | const std::string &id = decl->name; |
---|
| 325 | |
---|
| 326 | if ( ! structTable ) { |
---|
| 327 | structTable = StructTable::new_ptr(); |
---|
| 328 | } else { |
---|
| 329 | ++*stats().map_lookups; |
---|
| 330 | auto existing = structTable->find( id ); |
---|
[e67991f] | 331 | if ( existing != structTable->end() |
---|
| 332 | && existing->second.scope == scope |
---|
[d76c588] | 333 | && addedDeclConflicts( existing->second.decl, decl ) ) return; |
---|
| 334 | } |
---|
| 335 | |
---|
| 336 | lazyInitScope(); |
---|
| 337 | ++*stats().map_mutations; |
---|
| 338 | structTable = structTable->set( id, scoped<StructDecl>{ decl, scope } ); |
---|
| 339 | } |
---|
| 340 | |
---|
| 341 | void SymbolTable::addEnum( const EnumDecl *decl ) { |
---|
| 342 | ++*stats().add_calls; |
---|
| 343 | const std::string &id = decl->name; |
---|
| 344 | |
---|
| 345 | if ( ! enumTable ) { |
---|
| 346 | enumTable = EnumTable::new_ptr(); |
---|
| 347 | } else { |
---|
| 348 | ++*stats().map_lookups; |
---|
| 349 | auto existing = enumTable->find( id ); |
---|
[e67991f] | 350 | if ( existing != enumTable->end() |
---|
| 351 | && existing->second.scope == scope |
---|
[d76c588] | 352 | && addedDeclConflicts( existing->second.decl, decl ) ) return; |
---|
| 353 | } |
---|
[e67991f] | 354 | |
---|
[d76c588] | 355 | lazyInitScope(); |
---|
| 356 | ++*stats().map_mutations; |
---|
| 357 | enumTable = enumTable->set( id, scoped<EnumDecl>{ decl, scope } ); |
---|
| 358 | } |
---|
| 359 | |
---|
| 360 | void SymbolTable::addUnion( const std::string &id ) { |
---|
[4b8b2a4] | 361 | addUnion( new UnionDecl( CodeLocation(), id ) ); |
---|
[d76c588] | 362 | } |
---|
| 363 | |
---|
| 364 | void SymbolTable::addUnion( const UnionDecl * decl ) { |
---|
| 365 | ++*stats().add_calls; |
---|
| 366 | const std::string &id = decl->name; |
---|
| 367 | |
---|
| 368 | if ( ! unionTable ) { |
---|
| 369 | unionTable = UnionTable::new_ptr(); |
---|
| 370 | } else { |
---|
| 371 | ++*stats().map_lookups; |
---|
| 372 | auto existing = unionTable->find( id ); |
---|
[e67991f] | 373 | if ( existing != unionTable->end() |
---|
| 374 | && existing->second.scope == scope |
---|
[d76c588] | 375 | && addedDeclConflicts( existing->second.decl, decl ) ) return; |
---|
| 376 | } |
---|
| 377 | |
---|
| 378 | lazyInitScope(); |
---|
| 379 | ++*stats().map_mutations; |
---|
| 380 | unionTable = unionTable->set( id, scoped<UnionDecl>{ decl, scope } ); |
---|
| 381 | } |
---|
| 382 | |
---|
| 383 | void SymbolTable::addTrait( const TraitDecl * decl ) { |
---|
| 384 | ++*stats().add_calls; |
---|
| 385 | const std::string &id = decl->name; |
---|
| 386 | |
---|
| 387 | if ( ! traitTable ) { |
---|
| 388 | traitTable = TraitTable::new_ptr(); |
---|
| 389 | } else { |
---|
| 390 | ++*stats().map_lookups; |
---|
| 391 | auto existing = traitTable->find( id ); |
---|
[e67991f] | 392 | if ( existing != traitTable->end() |
---|
| 393 | && existing->second.scope == scope |
---|
[d76c588] | 394 | && addedDeclConflicts( existing->second.decl, decl ) ) return; |
---|
| 395 | } |
---|
| 396 | |
---|
| 397 | lazyInitScope(); |
---|
| 398 | ++*stats().map_mutations; |
---|
| 399 | traitTable = traitTable->set( id, scoped<TraitDecl>{ decl, scope } ); |
---|
| 400 | } |
---|
| 401 | |
---|
| 402 | |
---|
[e67991f] | 403 | void SymbolTable::addWith( const std::vector< ptr<Expr> > & withExprs, const Decl * withStmt ) { |
---|
[d76c588] | 404 | for ( const Expr * expr : withExprs ) { |
---|
| 405 | if ( ! expr->result ) continue; |
---|
| 406 | const Type * resTy = expr->result->stripReferences(); |
---|
[98e8b3b] | 407 | auto aggrType = dynamic_cast< const BaseInstType * >( resTy ); |
---|
[e67991f] | 408 | assertf( aggrType, "WithStmt expr has non-aggregate type: %s", |
---|
[d76c588] | 409 | toString( expr->result ).c_str() ); |
---|
| 410 | const AggregateDecl * aggr = aggrType->aggr(); |
---|
[e67991f] | 411 | assertf( aggr, "WithStmt has null aggregate from type: %s", |
---|
[d76c588] | 412 | toString( expr->result ).c_str() ); |
---|
[e67991f] | 413 | |
---|
[d76c588] | 414 | addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) ); |
---|
| 415 | } |
---|
| 416 | } |
---|
| 417 | |
---|
| 418 | void SymbolTable::addIds( const std::vector< ptr<DeclWithType> > & decls ) { |
---|
| 419 | for ( const DeclWithType * decl : decls ) { addId( decl ); } |
---|
| 420 | } |
---|
| 421 | |
---|
| 422 | void SymbolTable::addTypes( const std::vector< ptr<TypeDecl> > & tds ) { |
---|
| 423 | for ( const TypeDecl * td : tds ) { |
---|
| 424 | addType( td ); |
---|
| 425 | addIds( td->assertions ); |
---|
| 426 | } |
---|
| 427 | } |
---|
| 428 | |
---|
[490fb92e] | 429 | |
---|
| 430 | void SymbolTable::addFunction( const FunctionDecl * func ) { |
---|
[3e5dd913] | 431 | for (auto & td : func->type_params) { |
---|
| 432 | addType(td); |
---|
| 433 | } |
---|
| 434 | for (auto & asst : func->assertions) { |
---|
| 435 | addId(asst); |
---|
| 436 | } |
---|
| 437 | // addTypes( func->type->forall ); |
---|
[490fb92e] | 438 | addIds( func->returns ); |
---|
| 439 | addIds( func->params ); |
---|
[d76c588] | 440 | } |
---|
[490fb92e] | 441 | |
---|
[d76c588] | 442 | |
---|
| 443 | void SymbolTable::lazyInitScope() { |
---|
| 444 | // do nothing if already in represented scope |
---|
| 445 | if ( repScope == scope ) return; |
---|
| 446 | |
---|
| 447 | ++*stats().lazy_scopes; |
---|
| 448 | // create rollback |
---|
| 449 | prevScope = std::make_shared<SymbolTable>( *this ); |
---|
| 450 | // update repScope |
---|
| 451 | repScope = scope; |
---|
| 452 | } |
---|
| 453 | |
---|
| 454 | const ast::SymbolTable * SymbolTable::atScope( unsigned long target ) const { |
---|
| 455 | // by lazy construction, final symtab in list has repScope 0, cannot be > target |
---|
| 456 | // otherwise, will find first scope representing the target |
---|
| 457 | const SymbolTable * symtab = this; |
---|
| 458 | while ( symtab->repScope > target ) { |
---|
| 459 | symtab = symtab->prevScope.get(); |
---|
| 460 | } |
---|
| 461 | return symtab; |
---|
| 462 | } |
---|
| 463 | |
---|
| 464 | namespace { |
---|
| 465 | /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function |
---|
[e5c3811] | 466 | std::string getOtypeKey( const FunctionType * ftype, bool stripParams = true ) { |
---|
| 467 | const auto & params = ftype->params; |
---|
[d76c588] | 468 | assert( ! params.empty() ); |
---|
| 469 | // use base type of pointer, so that qualifiers on the pointer type aren't considered. |
---|
[e01eb4a] | 470 | const Type * base = ast::getPointerBase( params.front() ); |
---|
[d76c588] | 471 | assert( base ); |
---|
[e5c3811] | 472 | if (stripParams) { |
---|
| 473 | if (dynamic_cast<const PointerType *>(base)) return Mangle::Encoding::pointer; |
---|
| 474 | return Mangle::mangle( base, Mangle::Type | Mangle::NoGenericParams ); |
---|
| 475 | } |
---|
| 476 | else |
---|
| 477 | return Mangle::mangle( base ); |
---|
[d76c588] | 478 | } |
---|
| 479 | |
---|
[e67991f] | 480 | /// gets the declaration for the function acting on a type specified by otype key, |
---|
[d76c588] | 481 | /// nullptr if none such |
---|
[e67991f] | 482 | const FunctionDecl * getFunctionForOtype( |
---|
[d76c588] | 483 | const DeclWithType * decl, const std::string & otypeKey ) { |
---|
| 484 | auto func = dynamic_cast< const FunctionDecl * >( decl ); |
---|
[e5c3811] | 485 | if ( ! func || otypeKey != getOtypeKey( func->type, false ) ) return nullptr; |
---|
[d76c588] | 486 | return func; |
---|
| 487 | } |
---|
| 488 | } |
---|
| 489 | |
---|
[e67991f] | 490 | bool SymbolTable::removeSpecialOverrides( |
---|
[d76c588] | 491 | SymbolTable::IdData & data, SymbolTable::MangleTable::Ptr & mangleTable ) { |
---|
[e67991f] | 492 | // if a type contains user defined ctor/dtor/assign, then special rules trigger, which |
---|
| 493 | // determine the set of ctor/dtor/assign that can be used by the requester. In particular, |
---|
| 494 | // if the user defines a default ctor, then the generated default ctor is unavailable, |
---|
| 495 | // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated |
---|
| 496 | // field ctors are available. If the user defines any ctor then the generated default ctor |
---|
| 497 | // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines |
---|
| 498 | // anything that looks like a copy constructor, then the generated copy constructor is |
---|
[d76c588] | 499 | // unavailable, and likewise for the assignment operator. |
---|
| 500 | |
---|
| 501 | // only relevant on function declarations |
---|
| 502 | const FunctionDecl * function = data.id.as< FunctionDecl >(); |
---|
| 503 | if ( ! function ) return true; |
---|
| 504 | // only need to perform this check for constructors, destructors, and assignment functions |
---|
| 505 | if ( ! CodeGen::isCtorDtorAssign( data.id->name ) ) return true; |
---|
| 506 | |
---|
| 507 | // set up information for this type |
---|
| 508 | bool dataIsUserDefinedFunc = ! function->linkage.is_overrideable; |
---|
| 509 | bool dataIsCopyFunc = InitTweak::isCopyFunction( function ); |
---|
[e5c3811] | 510 | std::string dataOtypeKey = getOtypeKey( function->type, false ); // requires exact match to override autogen |
---|
[d76c588] | 511 | |
---|
| 512 | if ( dataIsUserDefinedFunc && dataIsCopyFunc ) { |
---|
| 513 | // this is a user-defined copy function |
---|
| 514 | // if this is the first such, delete/remove non-user-defined overloads as needed |
---|
| 515 | std::vector< std::string > removed; |
---|
| 516 | std::vector< MangleTable::value_type > deleted; |
---|
| 517 | bool alreadyUserDefinedFunc = false; |
---|
| 518 | |
---|
| 519 | for ( const auto& entry : *mangleTable ) { |
---|
| 520 | // skip decls that aren't functions or are for the wrong type |
---|
| 521 | const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey ); |
---|
| 522 | if ( ! decl ) continue; |
---|
| 523 | |
---|
| 524 | bool isCopyFunc = InitTweak::isCopyFunction( decl ); |
---|
| 525 | if ( ! decl->linkage.is_overrideable ) { |
---|
| 526 | // matching user-defined function |
---|
| 527 | if ( isCopyFunc ) { |
---|
| 528 | // mutation already performed, return early |
---|
| 529 | return true; |
---|
| 530 | } else { |
---|
| 531 | // note that non-copy deletions already performed |
---|
| 532 | alreadyUserDefinedFunc = true; |
---|
| 533 | } |
---|
| 534 | } else { |
---|
| 535 | // non-user-defined function; mark for deletion/removal as appropriate |
---|
| 536 | if ( isCopyFunc ) { |
---|
| 537 | removed.push_back( entry.first ); |
---|
| 538 | } else if ( ! alreadyUserDefinedFunc ) { |
---|
| 539 | deleted.push_back( entry ); |
---|
| 540 | } |
---|
| 541 | } |
---|
| 542 | } |
---|
| 543 | |
---|
| 544 | // perform removals from mangle table, and deletions if necessary |
---|
| 545 | for ( const auto& key : removed ) { |
---|
| 546 | ++*stats().map_mutations; |
---|
| 547 | mangleTable = mangleTable->erase( key ); |
---|
| 548 | } |
---|
| 549 | if ( ! alreadyUserDefinedFunc ) for ( const auto& entry : deleted ) { |
---|
| 550 | ++*stats().map_mutations; |
---|
| 551 | mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } ); |
---|
| 552 | } |
---|
| 553 | } else if ( dataIsUserDefinedFunc ) { |
---|
| 554 | // this is a user-defined non-copy function |
---|
| 555 | // if this is the first user-defined function, delete non-user-defined overloads |
---|
| 556 | std::vector< MangleTable::value_type > deleted; |
---|
[e67991f] | 557 | |
---|
[d76c588] | 558 | for ( const auto& entry : *mangleTable ) { |
---|
| 559 | // skip decls that aren't functions or are for the wrong type |
---|
| 560 | const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey ); |
---|
| 561 | if ( ! decl ) continue; |
---|
| 562 | |
---|
| 563 | // exit early if already a matching user-defined function; |
---|
| 564 | // earlier function will have mutated table |
---|
| 565 | if ( ! decl->linkage.is_overrideable ) return true; |
---|
| 566 | |
---|
| 567 | // skip mutating intrinsic functions |
---|
| 568 | if ( decl->linkage == Linkage::Intrinsic ) continue; |
---|
| 569 | |
---|
| 570 | // user-defined non-copy functions do not override copy functions |
---|
| 571 | if ( InitTweak::isCopyFunction( decl ) ) continue; |
---|
| 572 | |
---|
| 573 | // this function to be deleted after mangleTable iteration is complete |
---|
| 574 | deleted.push_back( entry ); |
---|
| 575 | } |
---|
| 576 | |
---|
| 577 | // mark deletions to update mangle table |
---|
| 578 | // this needs to be a separate loop because of iterator invalidation |
---|
| 579 | for ( const auto& entry : deleted ) { |
---|
| 580 | ++*stats().map_mutations; |
---|
| 581 | mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } ); |
---|
| 582 | } |
---|
| 583 | } else if ( function->linkage != Linkage::Intrinsic ) { |
---|
| 584 | // this is an overridable generated function |
---|
| 585 | // if there already exists a matching user-defined function, delete this appropriately |
---|
| 586 | for ( const auto& entry : *mangleTable ) { |
---|
| 587 | // skip decls that aren't functions or are for the wrong type |
---|
| 588 | const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey ); |
---|
| 589 | if ( ! decl ) continue; |
---|
| 590 | |
---|
| 591 | // skip non-user-defined functions |
---|
| 592 | if ( decl->linkage.is_overrideable ) continue; |
---|
| 593 | |
---|
| 594 | if ( dataIsCopyFunc ) { |
---|
| 595 | // remove current function if exists a user-defined copy function |
---|
[e67991f] | 596 | // since the signatures for copy functions don't need to match exactly, using |
---|
[d76c588] | 597 | // a delete statement is the wrong approach |
---|
| 598 | if ( InitTweak::isCopyFunction( decl ) ) return false; |
---|
| 599 | } else { |
---|
| 600 | // mark current function deleted by first user-defined function found |
---|
| 601 | data.deleter = decl; |
---|
| 602 | return true; |
---|
| 603 | } |
---|
| 604 | } |
---|
| 605 | } |
---|
[e67991f] | 606 | |
---|
[d76c588] | 607 | // nothing (more) to fix, return true |
---|
| 608 | return true; |
---|
| 609 | } |
---|
| 610 | |
---|
| 611 | namespace { |
---|
| 612 | /// true iff the declaration represents a function |
---|
| 613 | bool isFunction( const DeclWithType * decl ) { |
---|
| 614 | return GenPoly::getFunctionType( decl->get_type() ); |
---|
| 615 | } |
---|
| 616 | |
---|
| 617 | bool isObject( const DeclWithType * decl ) { return ! isFunction( decl ); } |
---|
| 618 | |
---|
| 619 | /// true if the declaration represents a definition instead of a forward decl |
---|
| 620 | bool isDefinition( const DeclWithType * decl ) { |
---|
| 621 | if ( auto func = dynamic_cast< const FunctionDecl * >( decl ) ) { |
---|
| 622 | // a function is a definition if it has a body |
---|
| 623 | return func->stmts; |
---|
| 624 | } else { |
---|
| 625 | // an object is a definition if it is not marked extern |
---|
| 626 | return ! decl->storage.is_extern; |
---|
| 627 | } |
---|
| 628 | } |
---|
| 629 | } |
---|
| 630 | |
---|
| 631 | bool SymbolTable::addedIdConflicts( |
---|
[e67991f] | 632 | const SymbolTable::IdData & existing, const DeclWithType * added, |
---|
| 633 | SymbolTable::OnConflict handleConflicts, const Decl * deleter ) { |
---|
| 634 | // if we're giving the same name mangling to things of different types then there is something |
---|
[d76c588] | 635 | // wrong |
---|
| 636 | assert( (isObject( added ) && isObject( existing.id ) ) |
---|
| 637 | || ( isFunction( added ) && isFunction( existing.id ) ) ); |
---|
[e67991f] | 638 | |
---|
[d76c588] | 639 | if ( existing.id->linkage.is_overrideable ) { |
---|
| 640 | // new definition shadows the autogenerated one, even at the same scope |
---|
| 641 | return false; |
---|
[e67991f] | 642 | } else if ( existing.id->linkage.is_mangled |
---|
| 643 | || ResolvExpr::typesCompatible( |
---|
[d76c588] | 644 | added->get_type(), existing.id->get_type(), SymbolTable{} ) ) { |
---|
[e67991f] | 645 | |
---|
[d76c588] | 646 | // it is a conflict if one declaration is deleted and the other is not |
---|
| 647 | if ( deleter && ! existing.deleter ) { |
---|
| 648 | if ( handleConflicts.mode == OnConflict::Error ) { |
---|
| 649 | SemanticError( added, "deletion of defined identifier " ); |
---|
| 650 | } |
---|
| 651 | return true; |
---|
| 652 | } else if ( ! deleter && existing.deleter ) { |
---|
| 653 | if ( handleConflicts.mode == OnConflict::Error ) { |
---|
| 654 | SemanticError( added, "definition of deleted identifier " ); |
---|
| 655 | } |
---|
| 656 | return true; |
---|
| 657 | } |
---|
| 658 | |
---|
| 659 | // it is a conflict if both declarations are definitions |
---|
| 660 | if ( isDefinition( added ) && isDefinition( existing.id ) ) { |
---|
| 661 | if ( handleConflicts.mode == OnConflict::Error ) { |
---|
[e67991f] | 662 | SemanticError( added, |
---|
| 663 | isFunction( added ) ? |
---|
| 664 | "duplicate function definition for " : |
---|
[d76c588] | 665 | "duplicate object definition for " ); |
---|
| 666 | } |
---|
| 667 | return true; |
---|
| 668 | } |
---|
| 669 | } else { |
---|
| 670 | if ( handleConflicts.mode == OnConflict::Error ) { |
---|
| 671 | SemanticError( added, "duplicate definition for " ); |
---|
| 672 | } |
---|
| 673 | return true; |
---|
| 674 | } |
---|
| 675 | |
---|
| 676 | return true; |
---|
| 677 | } |
---|
| 678 | |
---|
[e67991f] | 679 | void SymbolTable::addId( |
---|
| 680 | const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr, |
---|
| 681 | const Decl * deleter ) { |
---|
[e5c3811] | 682 | SpecialFunctionKind kind = getSpecialFunctionKind(decl->name); |
---|
| 683 | if (kind == NUMBER_OF_KINDS) { // not a special decl |
---|
| 684 | addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter); |
---|
| 685 | } |
---|
| 686 | else { |
---|
| 687 | std::string key; |
---|
| 688 | if (auto func = dynamic_cast<const FunctionDecl *>(decl)) { |
---|
| 689 | key = getOtypeKey(func->type); |
---|
| 690 | } |
---|
| 691 | else if (auto obj = dynamic_cast<const ObjectDecl *>(decl)) { |
---|
| 692 | key = getOtypeKey(obj->type.strict_as<PointerType>()->base.strict_as<FunctionType>()); |
---|
| 693 | } |
---|
| 694 | else { |
---|
| 695 | assertf(false, "special decl with non-function type"); |
---|
| 696 | } |
---|
| 697 | addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter); |
---|
| 698 | } |
---|
| 699 | } |
---|
| 700 | |
---|
| 701 | void SymbolTable::addId( |
---|
| 702 | const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr, |
---|
| 703 | const Decl * deleter ) { |
---|
[d76c588] | 704 | ++*stats().add_calls; |
---|
| 705 | const std::string &name = decl->name; |
---|
| 706 | if ( name == "" ) return; |
---|
| 707 | |
---|
| 708 | std::string mangleName; |
---|
| 709 | if ( decl->linkage.is_overrideable ) { |
---|
[e67991f] | 710 | // mangle the name without including the appropriate suffix, so overridable routines |
---|
[d76c588] | 711 | // are placed into the same "bucket" as their user defined versions. |
---|
| 712 | mangleName = Mangle::mangle( decl, Mangle::Mode{ Mangle::NoOverrideable } ); |
---|
| 713 | } else { |
---|
| 714 | mangleName = Mangle::mangle( decl ); |
---|
| 715 | } |
---|
| 716 | |
---|
[e67991f] | 717 | // this ensures that no two declarations with the same unmangled name at the same scope |
---|
[d76c588] | 718 | // both have C linkage |
---|
| 719 | if ( decl->linkage.is_mangled ) { |
---|
| 720 | // Check that a Cforall declaration doesn't override any C declaration |
---|
| 721 | if ( hasCompatibleCDecl( name, mangleName ) ) { |
---|
| 722 | SemanticError( decl, "Cforall declaration hides C function " ); |
---|
| 723 | } |
---|
| 724 | } else { |
---|
[e67991f] | 725 | // NOTE: only correct if name mangling is completely isomorphic to C |
---|
[d76c588] | 726 | // type-compatibility, which it may not be. |
---|
| 727 | if ( hasIncompatibleCDecl( name, mangleName ) ) { |
---|
| 728 | SemanticError( decl, "conflicting overload of C function " ); |
---|
| 729 | } |
---|
| 730 | } |
---|
| 731 | |
---|
| 732 | // ensure tables exist and add identifier |
---|
| 733 | MangleTable::Ptr mangleTable; |
---|
[e5c3811] | 734 | if ( ! table ) { |
---|
| 735 | table = IdTable::new_ptr(); |
---|
[d76c588] | 736 | mangleTable = MangleTable::new_ptr(); |
---|
| 737 | } else { |
---|
| 738 | ++*stats().map_lookups; |
---|
[e5c3811] | 739 | auto decls = table->find( lookupKey ); |
---|
| 740 | if ( decls == table->end() ) { |
---|
[d76c588] | 741 | mangleTable = MangleTable::new_ptr(); |
---|
| 742 | } else { |
---|
| 743 | mangleTable = decls->second; |
---|
| 744 | // skip in-scope repeat declarations of same identifier |
---|
| 745 | ++*stats().map_lookups; |
---|
| 746 | auto existing = mangleTable->find( mangleName ); |
---|
| 747 | if ( existing != mangleTable->end() |
---|
| 748 | && existing->second.scope == scope |
---|
| 749 | && existing->second.id ) { |
---|
| 750 | if ( addedIdConflicts( existing->second, decl, handleConflicts, deleter ) ) { |
---|
| 751 | if ( handleConflicts.mode == OnConflict::Delete ) { |
---|
| 752 | // set delete expression for conflicting identifier |
---|
| 753 | lazyInitScope(); |
---|
| 754 | *stats().map_mutations += 2; |
---|
[e5c3811] | 755 | table = table->set( |
---|
| 756 | lookupKey, |
---|
[e67991f] | 757 | mangleTable->set( |
---|
| 758 | mangleName, |
---|
[d76c588] | 759 | IdData{ existing->second, handleConflicts.deleter } ) ); |
---|
| 760 | } |
---|
| 761 | return; |
---|
| 762 | } |
---|
| 763 | } |
---|
| 764 | } |
---|
| 765 | } |
---|
| 766 | |
---|
| 767 | // add/overwrite with new identifier |
---|
| 768 | lazyInitScope(); |
---|
| 769 | IdData data{ decl, baseExpr, deleter, scope }; |
---|
| 770 | // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary |
---|
[e5c3811] | 771 | if (table != idTable) { // adding to special table |
---|
| 772 | if ( ! removeSpecialOverrides( data, mangleTable ) ) return; |
---|
| 773 | } |
---|
[d76c588] | 774 | *stats().map_mutations += 2; |
---|
[e5c3811] | 775 | table = table->set( lookupKey, mangleTable->set( mangleName, std::move(data) ) ); |
---|
[d76c588] | 776 | } |
---|
| 777 | |
---|
[e67991f] | 778 | void SymbolTable::addMembers( |
---|
[d76c588] | 779 | const AggregateDecl * aggr, const Expr * expr, SymbolTable::OnConflict handleConflicts ) { |
---|
| 780 | for ( const Decl * decl : aggr->members ) { |
---|
| 781 | if ( auto dwt = dynamic_cast< const DeclWithType * >( decl ) ) { |
---|
| 782 | addId( dwt, handleConflicts, expr ); |
---|
| 783 | if ( dwt->name == "" ) { |
---|
| 784 | const Type * t = dwt->get_type()->stripReferences(); |
---|
[98e8b3b] | 785 | if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) { |
---|
[e67991f] | 786 | if ( ! dynamic_cast<const StructInstType *>(rty) |
---|
[d76c588] | 787 | && ! dynamic_cast<const UnionInstType *>(rty) ) continue; |
---|
| 788 | ResolvExpr::Cost cost = ResolvExpr::Cost::zero; |
---|
[9e23b446] | 789 | ast::ptr<ast::TypeSubstitution> tmp = expr->env; |
---|
| 790 | expr = mutate_field(expr, &Expr::env, nullptr); |
---|
[d76c588] | 791 | const Expr * base = ResolvExpr::referenceToRvalueConversion( expr, cost ); |
---|
[9e23b446] | 792 | base = mutate_field(base, &Expr::env, tmp); |
---|
| 793 | |
---|
[e67991f] | 794 | addMembers( |
---|
[d76c588] | 795 | rty->aggr(), new MemberExpr{ base->location, dwt, base }, handleConflicts ); |
---|
| 796 | } |
---|
| 797 | } |
---|
| 798 | } |
---|
| 799 | } |
---|
| 800 | } |
---|
| 801 | |
---|
| 802 | bool SymbolTable::hasCompatibleCDecl( const std::string &id, const std::string &mangleName ) const { |
---|
| 803 | if ( ! idTable ) return false; |
---|
| 804 | |
---|
| 805 | ++*stats().map_lookups; |
---|
| 806 | auto decls = idTable->find( id ); |
---|
| 807 | if ( decls == idTable->end() ) return false; |
---|
| 808 | |
---|
| 809 | for ( auto decl : *(decls->second) ) { |
---|
| 810 | // skip other scopes (hidden by this decl) |
---|
| 811 | if ( decl.second.scope != scope ) continue; |
---|
| 812 | // check for C decl with compatible type (by mangleName) |
---|
| 813 | if ( ! decl.second.id->linkage.is_mangled && decl.first == mangleName ) return true; |
---|
| 814 | } |
---|
[e67991f] | 815 | |
---|
[d76c588] | 816 | return false; |
---|
| 817 | } |
---|
| 818 | |
---|
| 819 | bool SymbolTable::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName ) const { |
---|
| 820 | if ( ! idTable ) return false; |
---|
| 821 | |
---|
| 822 | ++*stats().map_lookups; |
---|
| 823 | auto decls = idTable->find( id ); |
---|
| 824 | if ( decls == idTable->end() ) return false; |
---|
| 825 | |
---|
| 826 | for ( auto decl : *(decls->second) ) { |
---|
| 827 | // skip other scopes (hidden by this decl) |
---|
| 828 | if ( decl.second.scope != scope ) continue; |
---|
| 829 | // check for C decl with incompatible type (by manglename) |
---|
| 830 | if ( ! decl.second.id->linkage.is_mangled && decl.first != mangleName ) return true; |
---|
| 831 | } |
---|
| 832 | |
---|
| 833 | return false; |
---|
| 834 | } |
---|
| 835 | |
---|
| 836 | } |
---|
| 837 | |
---|
| 838 | // Local Variables: // |
---|
| 839 | // tab-width: 4 // |
---|
| 840 | // mode: c++ // |
---|
| 841 | // compile-command: "make install" // |
---|
[98e8b3b] | 842 | // End: // |
---|