Index: libcfa/src/containers/array.hfa =================================================================== --- libcfa/src/containers/array.hfa (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ libcfa/src/containers/array.hfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -27,5 +27,5 @@ // - Given bug of Trac #247, CFA gives sizeof expressions type unsigned long int, when it // should give them type size_t. - // + // // gcc -m32 cfa -m32 given bug gcc -m64 // ptrdiff_t int int long int @@ -39,5 +39,15 @@ } + static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, int i ) { + assert( i < N ); + return (Timmed &) a.strides[i]; + } + static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, unsigned int i ) { + assert( i < N ); + return (Timmed &) a.strides[i]; + } + + static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, unsigned int i ) { assert( i < N ); return (Timmed &) a.strides[i]; @@ -49,5 +59,15 @@ } + static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, long int i ) { + assert( i < N ); + return (Timmed &) a.strides[i]; + } + static inline Timmed & ?[?]( arpk(N, S, Timmed, Tbase) & a, unsigned long int i ) { + assert( i < N ); + return (Timmed &) a.strides[i]; + } + + static inline const Timmed & ?[?]( const arpk(N, S, Timmed, Tbase) & a, unsigned long int i ) { assert( i < N ); return (Timmed &) a.strides[i]; @@ -83,5 +103,5 @@ // Make a FOREACH macro #define FE_0(WHAT) - #define FE_1(WHAT, X) WHAT(X) + #define FE_1(WHAT, X) WHAT(X) #define FE_2(WHAT, X, ...) WHAT(X)FE_1(WHAT, __VA_ARGS__) #define FE_3(WHAT, X, ...) WHAT(X)FE_2(WHAT, __VA_ARGS__) @@ -90,5 +110,5 @@ //... repeat as needed - #define GET_MACRO(_0,_1,_2,_3,_4,_5,NAME,...) NAME + #define GET_MACRO(_0,_1,_2,_3,_4,_5,NAME,...) NAME #define FOR_EACH(action,...) \ GET_MACRO(_0,__VA_ARGS__,FE_5,FE_4,FE_3,FE_2,FE_1,FE_0)(action,__VA_ARGS__) @@ -115,5 +135,5 @@ } -#else +#else // Workaround form. Listing all possibilities up to 4 dims. @@ -155,5 +175,5 @@ // Wrapper -struct all_t {} all; +extern struct all_t {} all; forall( [N], S & | sized(S), Te &, result &, Tbase & | { tag(result) enq_( tag(Tbase), tag(N), tag(S), tag(Te) ); } ) static inline result & ?[?]( arpk(N, S, Te, Tbase) & this, all_t ) { Index: libcfa/src/device/cpu.cfa =================================================================== --- libcfa/src/device/cpu.cfa (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ libcfa/src/device/cpu.cfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -359,17 +359,32 @@ int idxs = count_cache_indexes(); + // Do we actually have a cache? + if(idxs == 0) { + // if not just fake the data structure, it makes things easier. + cpu_info.hthrd_count = cpus_c; + cpu_info.llc_count = 0; + struct cpu_map_entry_t * entries = alloc(cpu_info.hthrd_count); + for(i; cpu_info.hthrd_count) { + entries[i].self = i; + entries[i].start = 0; + entries[i].count = cpu_info.hthrd_count; + entries[i].cache = 0; + } + cpu_info.llc_map = entries; + return; + } + // Count actual cache levels unsigned cache_levels = 0; unsigned llc = 0; - if (idxs != 0) { - unsigned char prev = -1u; - void first(unsigned idx, unsigned char level, const char * map, size_t len) { - /* paranoid */ verifyf(level < prev, "Index %u of cpu 0 has cache levels out of order: %u then %u", idx, (unsigned)prev, (unsigned)level); - llc = max(llc, level); - prev = level; - cache_levels++; - } - foreach_cacheidx(0, idxs, first); - } + + unsigned char prev = -1u; + void first(unsigned idx, unsigned char level, const char * map, size_t len) { + /* paranoid */ verifyf(level < prev, "Index %u of cpu 0 has cache levels out of order: %u then %u", idx, (unsigned)prev, (unsigned)level); + llc = max(llc, level); + prev = level; + cache_levels++; + } + foreach_cacheidx(0, idxs, first); // Read in raw data Index: libcfa/src/parseargs.cfa =================================================================== --- libcfa/src/parseargs.cfa (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ libcfa/src/parseargs.cfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -50,10 +50,12 @@ extern char ** cfa_args_envp __attribute__((weak)); -static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * usage, FILE * out) __attribute__ ((noreturn)); +forall([N]) +static void usage(char * cmd, const array( cfa_option, N ) & options, const char * usage, FILE * out) __attribute__ ((noreturn)); //----------------------------------------------------------------------------- // checking -static void check_args(cfa_option options[], size_t opt_count) { - for(i; opt_count) { - for(j; opt_count) { +forall([N]) +static void check_args( const array( cfa_option, N ) & options ) { + for(i; N) { + for(j; N) { if(i == j) continue; @@ -70,94 +72,101 @@ //----------------------------------------------------------------------------- // Parsing args -void parse_args( cfa_option options[], size_t opt_count, const char * usage, char ** & left ) { - if( 0p != &cfa_args_argc ) { - parse_args(cfa_args_argc, cfa_args_argv, options, opt_count, usage, left ); - } - else { - char * temp = ""; - parse_args(0, &temp, options, opt_count, usage, left ); - } -} - -void parse_args( - int argc, - char * argv[], - cfa_option options[], - size_t opt_count, - const char * usage, - char ** & left -) { - check_args(options, opt_count); - - int maxv = 'h'; - char optstring[(opt_count * 3) + 2] = { '\0' }; - { - int idx = 0; - for(i; opt_count) { - if (options[i].short_name) { - maxv = max(options[i].short_name, maxv); - optstring[idx] = options[i].short_name; - idx++; - if( ((intptr_t)options[i].parse) != ((intptr_t)parse_settrue) - && ((intptr_t)options[i].parse) != ((intptr_t)parse_setfalse) ) { - optstring[idx] = ':'; +forall([opt_count]) { + void parse_args( const array( cfa_option, opt_count ) & options, const char * usage, char ** & left ) { + if( 0p != &cfa_args_argc ) { + parse_args(cfa_args_argc, cfa_args_argv, options, usage, left ); + } + else { + char * temp = ""; + parse_args(0, &temp, options, usage, left ); + } + } + + void parse_args( + int argc, + char * argv[], + const array( cfa_option, opt_count ) & options, + const char * usage, + char ** & left + ) { + check_args(options); + + int maxv = 'h'; + char optstring[(opt_count * 3) + 2] = { '\0' }; + { + int idx = 0; + for(i; opt_count) { + if (options[i].short_name) { + maxv = max(options[i].short_name, maxv); + optstring[idx] = options[i].short_name; + idx++; + if( ((intptr_t)options[i].parse) != ((intptr_t)parse_settrue) + && ((intptr_t)options[i].parse) != ((intptr_t)parse_setfalse) ) { + optstring[idx] = ':'; + idx++; + } + } + } + optstring[idx+0] = 'h'; + optstring[idx+1] = '\0'; + } + + struct option optarr[opt_count + 2]; + { + int idx = 0; + for(i; opt_count) { + if(options[i].long_name) { + // we don't have the mutable keyword here, which is really what we would want + int & val_ref = (int &)(const int &)options[i].val; + val_ref = (options[i].short_name != '\0') ? ((int)options[i].short_name) : ++maxv; + + optarr[idx].name = options[i].long_name; + optarr[idx].flag = 0p; + optarr[idx].val = options[i].val; + if( ((intptr_t)options[i].parse) == ((intptr_t)parse_settrue) + || ((intptr_t)options[i].parse) == ((intptr_t)parse_setfalse) ) { + optarr[idx].has_arg = no_argument; + } else { + optarr[idx].has_arg = required_argument; + } idx++; } } - } - optstring[idx+0] = 'h'; - optstring[idx+1] = '\0'; - } - - struct option optarr[opt_count + 2]; - { - int idx = 0; - for(i; opt_count) { - if(options[i].long_name) { - options[i].val = (options[i].short_name != '\0') ? ((int)options[i].short_name) : ++maxv; - optarr[idx].name = options[i].long_name; - optarr[idx].flag = 0p; - optarr[idx].val = options[i].val; - if( ((intptr_t)options[i].parse) == ((intptr_t)parse_settrue) - || ((intptr_t)options[i].parse) == ((intptr_t)parse_setfalse) ) { - optarr[idx].has_arg = no_argument; - } else { - optarr[idx].has_arg = required_argument; - } - idx++; + optarr[idx+0].[name, has_arg, flag, val] = ["help", no_argument, 0, 'h']; + optarr[idx+1].[name, has_arg, flag, val] = [0, no_argument, 0, 0]; + } + + FILE * out = stderr; + NEXT_ARG: + for() { + int idx = 0; + int opt = getopt_long(argc, argv, optstring, optarr, &idx); + switch(opt) { + case -1: + if(&left != 0p) left = argv + optind; + return; + case 'h': + out = stdout; + case '?': + usage(argv[0], options, usage, out); + default: + for(i; opt_count) { + if(opt == options[i].val) { + const char * arg = optarg ? optarg : ""; + if( arg[0] == '=' ) { arg++; } + // work around for some weird bug + void * variable = options[i].variable; + bool (*parse_func)(const char *, void * ) = options[i].parse; + bool success = parse_func( arg, variable ); + if(success) continue NEXT_ARG; + + fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt); + usage(argv[0], options, usage, out); + } + } + abort("Internal parse arg error\n"); } - } - optarr[idx+0].[name, has_arg, flag, val] = ["help", no_argument, 0, 'h']; - optarr[idx+1].[name, has_arg, flag, val] = [0, no_argument, 0, 0]; - } - - FILE * out = stderr; - NEXT_ARG: - for() { - int idx = 0; - int opt = getopt_long(argc, argv, optstring, optarr, &idx); - switch(opt) { - case -1: - if(&left != 0p) left = argv + optind; - return; - case 'h': - out = stdout; - case '?': - usage(argv[0], options, opt_count, usage, out); - default: - for(i; opt_count) { - if(opt == options[i].val) { - const char * arg = optarg ? optarg : ""; - if( arg[0] == '=' ) { arg++; } - bool success = options[i].parse( arg, options[i].variable ); - if(success) continue NEXT_ARG; - - fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt); - usage(argv[0], options, opt_count, usage, out); - } - } - abort("Internal parse arg error\n"); - } - + + } } } @@ -222,15 +231,28 @@ void print_args_usage(cfa_option options[], size_t opt_count, const char * usage, bool error) __attribute__ ((noreturn)) { - usage(cfa_args_argv[0], options, opt_count, usage, error ? stderr : stdout); + const array( cfa_option, opt_count ) & arr = (const array( cfa_option, opt_count ) &) *options; + usage(cfa_args_argv[0], arr, usage, error ? stderr : stdout); } void print_args_usage(int , char * argv[], cfa_option options[], size_t opt_count, const char * usage, bool error) __attribute__ ((noreturn)) { - usage(argv[0], options, opt_count, usage, error ? stderr : stdout); -} - -static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * help, FILE * out) __attribute__((noreturn)) { + const array( cfa_option, opt_count ) & arr = (const array( cfa_option, opt_count ) &) *options; + usage(argv[0], arr, usage, error ? stderr : stdout); +} + +forall( [N] ) { + void print_args_usage( const array(cfa_option, N ) & options, const char * usage, bool error) { + usage(cfa_args_argv[0], options, usage, error ? stderr : stdout); + } + + void print_args_usage(int argc, char * argv[], const array( cfa_option, N ) & options, const char * usage, bool error) { + usage(argv[0], options, usage, error ? stderr : stdout); + } +} + +forall([N]) +static void usage(char * cmd, const array( cfa_option, N ) & options, const char * help, FILE * out) __attribute__((noreturn)) { int width = 0; { - for(i; opt_count) { + for(i; N) { if(options[i].long_name) { int w = strlen(options[i].long_name); @@ -251,5 +273,5 @@ fprintf(out, "Usage:\n %s %s\n", cmd, help); - for(i; opt_count) { + for(i; N) { printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help); } Index: libcfa/src/parseargs.hfa =================================================================== --- libcfa/src/parseargs.hfa (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ libcfa/src/parseargs.hfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -16,11 +16,13 @@ #pragma once +#include + struct cfa_option { - int val; // reserved - char short_name; - const char * long_name; - const char * help; - void * variable; - bool (*parse)(const char *, void * ); + int val; // reserved + char short_name; + const char * long_name; + const char * help; + void * variable; + bool (*parse)(const char *, void * ); }; @@ -31,20 +33,20 @@ forall(T & | { bool parse(const char *, T & ); }) static inline void ?{}( cfa_option & this, char short_name, const char * long_name, const char * help, T & variable ) { - this.val = 0; - this.short_name = short_name; - this.long_name = long_name; - this.help = help; - this.variable = (void*)&variable; - this.parse = (bool (*)(const char *, void * ))parse; + this.val = 0; + this.short_name = short_name; + this.long_name = long_name; + this.help = help; + this.variable = (void*)&variable; + this.parse = (bool (*)(const char *, void * ))parse; } forall(T &) static inline void ?{}( cfa_option & this, char short_name, const char * long_name, const char * help, T & variable, bool (*parse)(const char *, T & )) { - this.val = 0; - this.short_name = short_name; - this.long_name = long_name; - this.help = help; - this.variable = (void*)&variable; - this.parse = (bool (*)(const char *, void * ))parse; + this.val = 0; + this.short_name = short_name; + this.long_name = long_name; + this.help = help; + this.variable = (void*)&variable; + this.parse = (bool (*)(const char *, void * ))parse; } @@ -52,6 +54,16 @@ void parse_args( int argc, char * argv[], cfa_option options[], size_t opt_count, const char * usage, char ** & left ); +forall( [N] ) { + void parse_args( const array( cfa_option, N ) & options, const char * usage, char ** & left ); + void parse_args( int argc, char * argv[], const array( cfa_option, N ) & options, const char * usage, char ** & left ); +} + void print_args_usage(cfa_option options[], size_t opt_count, const char * usage, bool error) __attribute__ ((noreturn)); void print_args_usage(int argc, char * argv[], cfa_option options[], size_t opt_count, const char * usage, bool error) __attribute__ ((noreturn)); + +forall( [N] ) { + void print_args_usage( const array(cfa_option, N ) & options, const char * usage, bool error) __attribute__ ((noreturn)); + void print_args_usage(int argc, char * argv[], const array( cfa_option, N ) & options, const char * usage, bool error) __attribute__ ((noreturn)); +} bool parse_yesno (const char *, bool & ); Index: src/AST/Convert.cpp =================================================================== --- src/AST/Convert.cpp (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/AST/Convert.cpp (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -310,9 +310,9 @@ node->name, get().acceptL( node->attributes ), - false, // Temporary + node->isTyped, LinkageSpec::Spec( node->linkage.val ), get().accept1(node->base) ); - return aggregatePostamble( decl, node ); // Node info, including members, processed in aggregatePostamble + return aggregatePostamble( decl, node ); } @@ -737,5 +737,4 @@ node->name ); - temp->var = get().accept1(node->var); auto expr = visitBaseExpr( node, temp @@ -1615,4 +1614,5 @@ { old->get_funcSpec().val } ); + decl->enumInLine = old->enumInLine; cache.emplace(old, decl); assert(cache.find( old ) != cache.end()); @@ -2281,6 +2281,4 @@ } - /// xxx - type_decl should be DeclWithType in the final design - /// type_decl is set to EnumDecl as a temporary fix virtual void visit( const QualifiedNameExpr * old ) override final { this->node = visitBaseExpr( old, @@ -2288,5 +2286,4 @@ old->location, GET_ACCEPT_1(type_decl, Decl), - GET_ACCEPT_1(var, DeclWithType), old->name ) Index: src/AST/Decl.hpp =================================================================== --- src/AST/Decl.hpp (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/AST/Decl.hpp (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -105,4 +105,7 @@ ptr init; ptr bitfieldWidth; + bool enumInLine = false; // enum inline is not a real object declaration. + // It is a place holder for a set of enum value (ObjectDecl) + bool importValue = false; // if the value copied from somewhere else ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type, @@ -312,6 +315,7 @@ class EnumDecl final : public AggregateDecl { public: - bool isTyped; - ptr base; + bool isTyped; // isTyped indicated if the enum has a declaration like: + // enum (type_optional) Name {...} + ptr base; // if isTyped == true && base.get() == nullptr, it is a "void" type enum EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false, Index: src/AST/Expr.hpp =================================================================== --- src/AST/Expr.hpp (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/AST/Expr.hpp (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -257,9 +257,8 @@ public: ptr type_decl; - ptr var; std::string name; - QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const DeclWithType * r, const std::string & n ) - : Expr( loc ), type_decl( d ), var(r), name( n ) {} + QualifiedNameExpr( const CodeLocation & loc, const Decl * d, const std::string & n ) + : Expr( loc ), type_decl( d ), name( n ) {} const Expr * accept( Visitor & v ) const override { return v.visit( this ); } Index: src/AST/Pass.impl.hpp =================================================================== --- src/AST/Pass.impl.hpp (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/AST/Pass.impl.hpp (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -1205,5 +1205,4 @@ if ( __visit_children() ) { guard_symtab guard { *this }; - maybe_accept( node, &QualifiedNameExpr::var ); maybe_accept( node, &QualifiedNameExpr::type_decl ); } Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/CodeGen/CodeGenerator.cc (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -912,10 +912,4 @@ } output << ")"; - } - - // QualifiedNameExpr should not reach to CodeGen. - // FixQualifiedName Convert QualifiedNameExpr to VariableExpr - void CodeGenerator::postvisit( QualifiedNameExpr * expr ) { - output << "/* label */" << mangleName(expr->var); } Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/CodeGen/CodeGenerator.h (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -103,5 +103,4 @@ void postvisit( DefaultArgExpr * ); void postvisit( GenericExpr * ); - void postvisit( QualifiedNameExpr *); //*** Statements Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/Common/PassVisitor.impl.h (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -1934,5 +1934,4 @@ indexerScopedAccept( node->result, *this ); maybeAccept_impl( node->type_decl, *this ); - maybeAccept_impl( node->var, *this ); VISIT_END( node ); @@ -1945,5 +1944,4 @@ indexerScopedAccept( node->result, *this ); maybeAccept_impl( node->type_decl, *this ); - maybeAccept_impl( node->var, *this ); VISIT_END( node ); @@ -1957,5 +1955,4 @@ indexerScopedMutate( node->result, *this ); maybeMutate_impl( node->type_decl, *this ); - maybeAccept_impl( node->var, *this ); MUTATE_END( Expression, node ); Index: src/Parser/DeclarationNode.cc =================================================================== --- src/Parser/DeclarationNode.cc (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/Parser/DeclarationNode.cc (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -297,4 +297,10 @@ } // if } // DeclarationNode::newEnumValueGeneric + +DeclarationNode * DeclarationNode::newEnumInLine( const string name ) { + DeclarationNode * newnode = newName( new std::string(name) ); + newnode->enumInLine = true; + return newnode; +} DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) { Index: src/Parser/ExpressionNode.cc =================================================================== --- src/Parser/ExpressionNode.cc (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/Parser/ExpressionNode.cc (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -523,5 +523,4 @@ auto enumInst = new EnumInstType( Type::Qualifiers(), e ); auto obj = new ObjectDecl( name->name, Type::StorageClasses(), LinkageSpec::Cforall, nullptr, enumInst, nullptr ); - ret->set_var( obj ); } return ret; Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/Parser/ParseNode.h (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -240,4 +240,5 @@ static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant ); static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init ); + static DeclarationNode * newEnumInLine( const std::string name ); static DeclarationNode * newName( const std::string * ); static DeclarationNode * newFromTypeGen( const std::string *, ExpressionNode * params ); @@ -339,4 +340,5 @@ bool inLine = false; + bool enumInLine = false; Type::FuncSpecifiers funcSpecs; Type::StorageClasses storageClasses; Index: src/Parser/TypeData.cc =================================================================== --- src/Parser/TypeData.cc (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/Parser/TypeData.cc (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -924,4 +924,9 @@ list< Declaration * >::iterator members = ret->get_members().begin(); for ( const DeclarationNode * cur = td->enumeration.constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) { + if ( cur->enumInLine ) { + // Tell the compiler this is a inline value placeholder + ObjectDecl * member = dynamic_cast< ObjectDecl* >(* members); + member->enumInLine = true; + } if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) { SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." ); Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/Parser/parser.yy (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -2605,5 +2605,5 @@ { $$ = DeclarationNode::newEnumValueGeneric( $1, $2 ); } | INLINE type_name - { $$ = DeclarationNode::newEnumValueGeneric( new string("inline"), nullptr ); } + { $$ = DeclarationNode::newEnumInLine( *$2->type->symbolic.name ); } | enumerator_list ',' identifier_or_type_name enumerator_value_opt { $$ = $1->appendList( DeclarationNode::newEnumValueGeneric( $3, $4 ) ); } Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/ResolvExpr/CandidateFinder.cpp (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -862,9 +862,4 @@ } } - } - - void postvisit( const ast::QualifiedNameExpr * qualifiedNameExpr ) { - auto mangleName = Mangle::mangle(qualifiedNameExpr->var); - addCandidate( qualifiedNameExpr, tenv ); } Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/SymTab/Mangler.cc (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -65,6 +65,4 @@ void postvisit( const QualifiedType * qualType ); - void postvisit( const QualifiedNameExpr * qualNameExpr ); - std::string get_mangleName() { return mangleName; } private: @@ -307,8 +305,4 @@ mangleName += Encoding::qualifiedTypeEnd; } - } - - void Mangler_old::postvisit( const QualifiedNameExpr * qual ) { - maybeAccept( qual->var, *visitor ); } @@ -423,5 +417,4 @@ void postvisit( const ast::OneType * oneType ); void postvisit( const ast::QualifiedType * qualType ); - void postvisit( const ast::QualifiedNameExpr * qualNameExpr ); std::string get_mangleName() { return mangleName; } @@ -652,7 +645,4 @@ mangleName += Encoding::qualifiedTypeEnd; } - } - void Mangler_new::postvisit( const ast::QualifiedNameExpr * qual ) { - maybeAccept( qual->var.get(), *visitor ); } Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/SymTab/Validate.cc (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -858,5 +858,4 @@ declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) ); } else if ( EnumInstType * enumInst = dynamic_cast< EnumInstType * >( designatorType ) ) { - // declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage, enumDecl->baseEnum->base ) ); if ( enumInst->baseEnum ) { const EnumDecl * enumDecl = enumInst->baseEnum; Index: src/SymTab/ValidateType.cc =================================================================== --- src/SymTab/ValidateType.cc (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/SymTab/ValidateType.cc (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -81,7 +81,6 @@ void previsit( QualifiedType * qualType ); void postvisit( QualifiedType * qualType ); - void postvisit( QualifiedNameExpr * qualExpr ); - + void postvisit( EnumDecl * enumDecl ); void postvisit( StructDecl * structDecl ); Index: src/SynTree/AddressExpr.cc =================================================================== --- src/SynTree/AddressExpr.cc (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/SynTree/AddressExpr.cc (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -50,4 +50,5 @@ set_result( addrType( refType->base ) ); } else { + if(!arg->result->location.isSet()) arg->result->location = arg->location; SemanticError( arg->result, "Attempt to take address of non-lvalue expression: " ); } // if Index: src/SynTree/Declaration.h =================================================================== --- src/SynTree/Declaration.h (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/SynTree/Declaration.h (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -121,4 +121,5 @@ Initializer * init; Expression * bitfieldWidth; + bool enumInLine = false; ObjectDecl( const std::string & name, Type::StorageClasses scs, LinkageSpec::Spec linkage, Expression * bitfieldWidth, Type * type, Initializer * init, Index: src/SynTree/Expression.h =================================================================== --- src/SynTree/Expression.h (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/SynTree/Expression.h (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -168,13 +168,9 @@ Declaration * type_decl; std::string name; - DeclarationWithType * var; QualifiedNameExpr( Declaration * decl, std::string name): Expression(), type_decl(decl), name(name) {} - QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.name), var(other.var) {} - DeclarationWithType * get_var() const { return var; } - void set_var( DeclarationWithType * newValue ) { var = newValue; } + QualifiedNameExpr( const QualifiedNameExpr & other): Expression(other), type_decl(other.type_decl), name(other.name) {} virtual ~QualifiedNameExpr() { - delete var; delete type_decl; } Index: src/Validate/FixQualifiedTypes.cpp =================================================================== --- src/Validate/FixQualifiedTypes.cpp (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/Validate/FixQualifiedTypes.cpp (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -102,11 +102,8 @@ } - - auto var = new ast::ObjectDecl( t->var->location, t->name, - new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall ); - var->scopeLevel = 1; // 1 for now; should copy the scopeLevel of the enumValue + auto var = new ast::ObjectDecl( t->location, t->name, + new ast::EnumInstType(enumDecl, ast::CV::Const), nullptr, {}, ast::Linkage::Cforall ); var->mangleName = Mangle::mangle( var ); return new ast::VariableExpr( t->location, var ); - // return ret; } Index: src/Validate/LinkReferenceToTypes.cpp =================================================================== --- src/Validate/LinkReferenceToTypes.cpp (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ src/Validate/LinkReferenceToTypes.cpp (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -44,5 +44,4 @@ void postvisit( ast::UnionDecl const * decl ); ast::TraitDecl const * postvisit( ast::TraitDecl const * decl ); - ast::QualifiedNameExpr const * previsit( ast::QualifiedNameExpr const * decl); private: @@ -203,4 +202,45 @@ } + // The following section + auto mut = ast::mutate( decl ); + std::vector> buffer; + for ( auto it = decl->members.begin(); it != decl->members.end(); ++it) { + auto member = (*it).as(); + if ( member->enumInLine ) { + auto targetEnum = symtab.lookupEnum( member->name ); + if ( targetEnum ) { + for ( auto singleMamber : targetEnum->members ) { + auto tm = singleMamber.as(); + auto t = new ast::ObjectDecl( + member->location, // use the "inline" location + tm->name, + new ast::EnumInstType( decl, ast::CV::Const ), + // Construct a new EnumInstType as the type + tm->init, + tm->storage, + tm->linkage, + tm->bitfieldWidth, + {}, // enum member doesn't have attribute + tm->funcSpec + ); + t->importValue = true; + buffer.push_back(t); + } + } + } else { + auto search_it = std::find_if( buffer.begin(), buffer.end(), [member](ast::ptr cur) { + auto curAsObjDecl = cur.as(); + return (curAsObjDecl->importValue) && (curAsObjDecl->name == member->name); + }); + if ( search_it != buffer.end() ) { + buffer.erase( search_it ); // Found an import enum value that has the same name + // override the imported value + } + buffer.push_back( *it ); + } + } + mut->members = buffer; + decl = mut; + ForwardEnumsType::iterator fwds = forwardEnums.find( decl->name ); if ( fwds != forwardEnums.end() ) { @@ -284,37 +324,4 @@ } -ast::QualifiedNameExpr const * LinkTypesCore::previsit( ast::QualifiedNameExpr const * decl ) { - // Try to lookup type - if ( auto objDecl = decl->type_decl.as() ) { - if ( auto inst = objDecl->type.as()) { - if ( auto enumDecl = symtab.lookupEnum ( inst->name ) ) { - auto mut = ast::mutate( decl ); - mut->type_decl = enumDecl; - auto enumInst = new ast::EnumInstType( enumDecl ); - enumInst->name = decl->name; - // Adding result; addCandidate() use result - mut->result = enumInst; - decl = mut; - } - } - } else if ( auto enumDecl = decl->type_decl.as() ) { - auto mut = ast::mutate( decl ); - auto enumInst = new ast::EnumInstType( enumDecl ); - enumInst->name = decl->name; - // Adding result; addCandidate() use result - mut->result = enumInst; - decl = mut; - } - // ast::EnumDecl const * decl = symtab.lookupEnum( type->name ); - // // It's not a semantic error if the enum is not found, just an implicit forward declaration. - // if ( decl ) { - // // Just linking in the node. - // auto mut = ast::mutate( type ); - // mut->base = const_cast( decl ); - // type = mut; - // } - return decl; -} - } // namespace Index: tests/configs/parsebools.cfa =================================================================== --- tests/configs/parsebools.cfa (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ tests/configs/parsebools.cfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -15,6 +15,6 @@ // +#include #include -#include #include "../meta/fork+exec.hfa" @@ -30,16 +30,14 @@ bool sf = true; - cfa_option options[] = { - {'e', "yesno", "test yes/no", YN, parse_yesno}, - {'y', "YN", "test yes/no", Yn, parse_yesno}, - {'n', "yn", "test yes/no", yn, parse_yesno}, - {'t', "truefalse", "test true/false", tf, parse_truefalse}, - {'s', "settrue", "test set true", st, parse_settrue}, - {'u', "setfalse", "test set false", sf, parse_setfalse}, - }; - int options_cnt = sizeof(options) / sizeof(cfa_option); + array( cfa_option, 6 ) options; + options[0] = (cfa_option){'e', "yesno", "test yes/no", YN, parse_yesno}; + options[1] = (cfa_option){'y', "YN", "test yes/no", Yn, parse_yesno}; + options[2] = (cfa_option){'n', "yn", "test yes/no", yn, parse_yesno}; + options[3] = (cfa_option){'t', "truefalse", "test true/false", tf, parse_truefalse}; + options[4] = (cfa_option){'s', "settrue", "test set true", st, parse_settrue}; + options[5] = (cfa_option){'u', "setfalse", "test set false", sf, parse_setfalse}; char **left; - parse_args( options, options_cnt, "[OPTIONS]...\ntesting bool parameters", left); + parse_args( options, "[OPTIONS]...\ntesting bool parameters", left); sout | "yes/no :" | YN; Index: tests/configs/parsenums.cfa =================================================================== --- tests/configs/parsenums.cfa (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ tests/configs/parsenums.cfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -15,6 +15,6 @@ // +#include #include -#include #include "../meta/fork+exec.hfa" @@ -42,15 +42,13 @@ - cfa_option options[] = { - { 'i', "int", "test int", i }, - { 'u', "unsigned", "test unsigned", u }, - { 'l', "unsignedlong", "test unsigned long", ul }, - { 'L', "unsignedlonglong", "test unsigned long long", ull }, - { 'd', "double", "test double", d }, - }; - int options_cnt = sizeof(options) / sizeof(cfa_option); + array( cfa_option, 5 ) options; + options[0] = (cfa_option){ 'i', "int", "test int", i }; + options[1] = (cfa_option){ 'u', "unsigned", "test unsigned", u }; + options[2] = (cfa_option){ 'l', "unsignedlong", "test unsigned long", ul }; + options[3] = (cfa_option){ 'L', "unsignedlonglong", "test unsigned long long", ull }; + options[4] = (cfa_option){ 'd', "double", "test double", d }; char **left; - parse_args( options, options_cnt, "[OPTIONS]...\ntesting bool parameters", left); + parse_args( options, "[OPTIONS]...\ntesting bool parameters", left); sout | "int :" | i; Index: tests/configs/usage.cfa =================================================================== --- tests/configs/usage.cfa (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ tests/configs/usage.cfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -15,6 +15,6 @@ // +#include #include -#include #include "../meta/fork+exec.hfa" @@ -25,6 +25,6 @@ sout | "No args, no errors"; if(pid_t child = strict_fork(); child == 0) { - cfa_option opts[0]; - print_args_usage(1, fake_argv, opts, 0, "Test usage", false); + array( cfa_option, 0 ) opts; + print_args_usage(1, fake_argv, opts, "Test usage", false); } else { @@ -35,6 +35,6 @@ sout | "No args, with errors"; if(pid_t child = strict_fork(); child == 0) { - cfa_option opts[0]; - print_args_usage(1, fake_argv, opts, 0, "Test usage", true); + array( cfa_option, 0 ) opts; + print_args_usage(1, fake_argv, opts, "Test usage", true); } else { @@ -46,10 +46,9 @@ if(pid_t child = strict_fork(); child == 0) { int a, b, c; - cfa_option opts[] = { - {'a', "", "First arg", a }, - {'b', "", "Second arg", b }, - {'c', "", "Third arg", c }, - }; - print_args_usage(1, fake_argv, opts, 3, "Test usage", false); + array( cfa_option, 3 ) opts; + opts[0] = (cfa_option){'a', "", "First arg", a }; + opts[1] = (cfa_option){'b', "", "Second arg", b }; + opts[2] = (cfa_option){'c', "", "Third arg", c }; + print_args_usage(1, fake_argv, opts, "Test usage", false); } else { @@ -61,10 +60,9 @@ if(pid_t child = strict_fork(); child == 0) { int a, b, c; - cfa_option opts[] = { - {'\0', "AA", "First arg", a }, - {'\0', "BB", "Second arg", b }, - {'\0', "CC", "Third arg", c }, - }; - print_args_usage(1, fake_argv, opts, 3, "Test usage", false); + array( cfa_option, 3 ) opts; + opts[0] = (cfa_option){'\0', "AA", "First arg", a }; + opts[1] = (cfa_option){'\0', "BB", "Second arg", b }; + opts[2] = (cfa_option){'\0', "CC", "Third arg", c }; + print_args_usage(1, fake_argv, opts, "Test usage", false); } else { @@ -76,10 +74,9 @@ if(pid_t child = strict_fork(); child == 0) { int a, b, c; - cfa_option opts[] = { - {'a', "", "First arg", a }, - {'b', "BBBB", "Second arg", b }, - {'\0', "CC", "Third arg", c }, - }; - print_args_usage(1, fake_argv, opts, 3, "Test usage", false); + array( cfa_option, 3 ) opts; + opts[0] = (cfa_option){'a', "", "First arg", a }; + opts[1] = (cfa_option){'b', "BBBB", "Second arg", b }; + opts[2] = (cfa_option){'\0', "CC", "Third arg", c }; + print_args_usage(1, fake_argv, opts, "Test usage", false); } else { @@ -91,10 +88,9 @@ if(pid_t child = strict_fork(); child == 0) { int a, b, c; - cfa_option opts[] = { - {'a', "", "First arg", a }, - {'b', "BBBB", "", b }, - {'\0', "CC", "Third arg", c }, - }; - print_args_usage(1, fake_argv, opts, 3, "Test usage", false); + array( cfa_option, 3 ) opts; + opts[0] = (cfa_option){'a', "", "First arg", a }; + opts[1] = (cfa_option){'b', "BBBB", "", b }; + opts[2] = (cfa_option){'\0', "CC", "Third arg", c }; + print_args_usage(1, fake_argv, opts, "Test usage", false); } else { @@ -106,10 +102,9 @@ if(pid_t child = strict_fork(); child == 0) { int a, b, c; - cfa_option opts[] = { - {'a', "", "First arg\nThe description has multiple lines,\n...for some reason", a }, - {'b', "BBBB", "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", b }, - {'\0', "CC", "Third arg", c }, - }; - print_args_usage(1, fake_argv, opts, 3, "Test usage", false); + array( cfa_option, 3 ) opts; + opts[0] = (cfa_option){'a', "", "First arg\nThe description has multiple lines,\n...for some reason", a }; + opts[1] = (cfa_option){'b', "BBBB", "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890", b }; + opts[2] = (cfa_option){'\0', "CC", "Third arg", c }; + print_args_usage(1, fake_argv, opts, "Test usage", false); } else { Index: tests/device/cpu.cfa =================================================================== --- tests/device/cpu.cfa (revision 82ff4ed18ea03926ec7563a6b4b0dd85391eb692) +++ tests/device/cpu.cfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -117,4 +117,5 @@ unsigned find_idx() { int idxs = count_cache_indexes(); + if( 0 == idxs ) return 0; unsigned found_level = 0; @@ -179,5 +180,5 @@ unsigned idx = find_idx(); // For all procs check mapping is consistent - for(cpu_me; cpu_info.hthrd_count) { + if( idx > 0 ) for(cpu_me; cpu_info.hthrd_count) { char buf_me[32]; size_t len_me = read_cpuidxinfo_into(cpu_me, idx, "shared_cpu_list", buf_me, 32); Index: tests/enum_tests/.expect/enumInlineValue.txt =================================================================== --- tests/enum_tests/.expect/enumInlineValue.txt (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) +++ tests/enum_tests/.expect/enumInlineValue.txt (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -0,0 +1,4 @@ +enumB.A is 5 +enumB.B is 10 +enumB.D is 11 +enumB.E is 12 Index: tests/enum_tests/enumInlineValue.cfa =================================================================== --- tests/enum_tests/enumInlineValue.cfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) +++ tests/enum_tests/enumInlineValue.cfa (revision d191e246fd6d1f8e4ff7e7d8cafe22bbd3d09639) @@ -0,0 +1,18 @@ +#include +enum enumA { + A=5, B, C=10, D +}; + +enum enumB { + inline enumA, + E, B=10 +}; + +int main() { + enum enumB val = A; + sout | "enumB.A is" | val; + enum enumB val2= enumB.B; + sout | "enumB.B is" | val2; + sout | "enumB.D is" | enumB.D; + sout | "enumB.E is" | enumB.E; +}