Index: src/Validate/Autogen.cpp =================================================================== --- src/Validate/Autogen.cpp (revision 822332e90fec6c4a9a05fd800863fb5009a81bcd) +++ src/Validate/Autogen.cpp (revision 3b693980acdd9998e43ab2d670428143c51a1c7f) @@ -410,5 +410,5 @@ } -/// Use the current type T to create `T ?{}(T & _dst, T _src)`. +/// Use the current type T to create `T ?=?(T & _dst, T _src)`. ast::FunctionDecl * FuncGenerator::genAssignProto() const { // Only the name is different, so just reuse the generation function. Index: src/Validate/EnumAndPointerDecay.cpp =================================================================== --- src/Validate/EnumAndPointerDecay.cpp (revision 822332e90fec6c4a9a05fd800863fb5009a81bcd) +++ src/Validate/EnumAndPointerDecay.cpp (revision 3b693980acdd9998e43ab2d670428143c51a1c7f) @@ -47,21 +47,26 @@ new ast::EnumInstType( decl, ast::CV::Const ) ) ); } else if ( auto value = member.as() ) { - if ( auto targetEnum = symtab.lookupEnum( value->name ) ) { - for ( auto enumMember : targetEnum->members ) { - auto enumObject = enumMember.strict_as(); - buffer.push_back( new ast::ObjectDecl( - // Get the location from the "inline" declaration. - value->location, - enumObject->name, - // Construct a new EnumInstType as the type. - new ast::EnumInstType( decl, ast::CV::Const ), - enumObject->init, - enumObject->storage, - enumObject->linkage, - enumObject->bitfieldWidth, - {}, - enumObject->funcSpec - ) ); - } + auto targetEnum = symtab.lookupEnum( value->name ); + // assert( targetEnum ); + if (!targetEnum) { + SemanticError(value, "Only another enum is allowed for enum inline syntax "); + } + const ast::EnumInstType * instType = new ast::EnumInstType(targetEnum); + mut->inlinedDecl.push_back( std::move(instType) ); + for ( auto enumMember : targetEnum->members ) { + auto enumObject = enumMember.strict_as(); + buffer.push_back(new ast::ObjectDecl( + // Get the location from the "inline" declaration. + value->location, + enumObject->name, + // Construct a new EnumInstType as the type. + new ast::EnumInstType( decl, ast::CV::Const ), + enumObject->init, + enumObject->storage, + enumObject->linkage, + enumObject->bitfieldWidth, + {}, + enumObject->funcSpec + )); } } Index: src/Validate/ImplementEnumFunc.cpp =================================================================== --- src/Validate/ImplementEnumFunc.cpp (revision 822332e90fec6c4a9a05fd800863fb5009a81bcd) +++ src/Validate/ImplementEnumFunc.cpp (revision 3b693980acdd9998e43ab2d670428143c51a1c7f) @@ -10,4 +10,5 @@ const ast::EnumDecl* decl; unsigned int functionNesting; + const ast::StructDecl* quasi_void_decl; ast::Linkage::Spec proto_linkage; @@ -24,4 +25,7 @@ : decl(decl), functionNesting{functionNesting}, + quasi_void_decl(new ast::StructDecl(decl->location, + "quasi_void", ast::AggregateDecl::Struct, + {}, ast::Linkage::AutoGen)), proto_linkage{ast::Linkage::Cforall} {} @@ -52,4 +56,6 @@ void genSuccPredBody(ast::FunctionDecl *, const char *) const; + void genTypeNameFunc(); + // Implement TypedEnum trait void genTypedEnumFuncs(); @@ -58,17 +64,12 @@ ast::FunctionDecl* genLabelProto() const; ast::FunctionDecl* genValueProto() const; + ast::FunctionDecl* genQuasiValueProto() const; + ast::FunctionDecl* genTypeNameProto() const; + void genValueOrLabelBody( ast::FunctionDecl* func, ast::ObjectDecl* arrDecl) const; void genPosnBody(ast::FunctionDecl* func) const; - - //////////////// - - // --------------------------------------------------- - // ast::FunctionDecl* genAttrCtorProto() const; - /// Changes the node inside a pointer so that it has the unused attribute. - void addUnusedAttribute(ast::ptr& declPtr) { - ast::DeclWithType* decl = declPtr.get_and_mutate(); - decl->attributes.push_back(new ast::Attribute("unused")); - } + void genQuasiValueBody(ast::FunctionDecl* func) const; + void genTypeNameBody(ast::FunctionDecl* func) const; // ---------------------------------------------------- @@ -117,4 +118,5 @@ return inits; } + const ast::Init* EnumAttrFuncGenerator::getAutoInit( const ast::Init* prev) const { @@ -189,9 +191,20 @@ ast::FunctionDecl* EnumAttrFuncGenerator::genValueProto() const { + if (decl->base) + return genProto( + "valueE", + {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))}, + {new ast::ObjectDecl(getLocation(), "_ret", + ast::deepCopy(decl->base))}); + else + return genQuasiValueProto(); +} + +ast::FunctionDecl* EnumAttrFuncGenerator::genQuasiValueProto() const { return genProto( "valueE", {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))}, {new ast::ObjectDecl(getLocation(), "_ret", - ast::deepCopy(decl->base))}); + new ast::StructInstType(quasi_void_decl))}); } @@ -210,4 +223,13 @@ {new ast::ObjectDecl(getLocation(), "_ret", new ast::BasicType(ast::BasicKind::UnsignedInt))} ); +} + +ast::FunctionDecl* EnumAttrFuncGenerator::genTypeNameProto() const { + return genProto( + "type_name", + {new ast::ObjectDecl(getLocation(), "_i", new ast::EnumInstType(decl))}, + {new ast::ObjectDecl( + getLocation(), "_ret", + new ast::PointerType(new ast::BasicType{ast::BasicKind::Char}))}); } @@ -268,5 +290,4 @@ ); } - void EnumAttrFuncGenerator::genSerialTraitFuncs() { @@ -302,5 +323,6 @@ const CodeLocation & loc = func->location; auto mem = func->name=="lowerBound"? decl->members.front() : decl->members.back(); - auto expr = new ast::NameExpr( loc, mem->name ); + // auto expr = new ast::NameExpr( loc, mem->name ); + auto expr = new ast::QualifiedNameExpr( loc, decl->name, mem->name ); func->stmts = new ast::CompoundStmt( loc, {new ast::ReturnStmt(loc, expr)}); } @@ -349,4 +371,17 @@ } +void EnumAttrFuncGenerator::genQuasiValueBody(ast::FunctionDecl* func) const { + auto location = func->location; + const ast::ObjectDecl * objDecl = new ast::ObjectDecl( + location, "_out", new ast::StructInstType( quasi_void_decl )); + const ast::DeclStmt * declStmt = new ast::DeclStmt(location, objDecl); + const ast::VariableExpr * varExpr = new ast::VariableExpr(location, objDecl); + const ast::ReturnStmt * retStmt = new ast::ReturnStmt(location, varExpr); + + func->stmts = new ast::CompoundStmt( + location, {declStmt, retStmt} + ); +} + void EnumAttrFuncGenerator::genPosnBody(ast::FunctionDecl* func) const { auto castExpr = new ast::CastExpr( @@ -359,17 +394,36 @@ } +void EnumAttrFuncGenerator::genTypeNameBody(ast::FunctionDecl* func) const { + const ast::Expr * type_name = ast::ConstantExpr::from_string(func->location, decl->name); + func->stmts = new ast::CompoundStmt( + func->location, {new ast::ReturnStmt(func->location, type_name)} + ); +} + void EnumAttrFuncGenerator::genTypedEnumFunction(const ast::EnumAttribute attr) { - if (attr == ast::EnumAttribute::Value || - attr == ast::EnumAttribute::Label) { - // TypedEnum's backing arrays - std::vector> inits = - attr == ast::EnumAttribute::Value ? genValueInit() : genLabelInit(); + if (attr == ast::EnumAttribute::Value) { + if (decl->base) { + // TypedEnum's backing arrays + std::vector> inits = genValueInit(); + ast::ObjectDecl* arrayProto = + genAttrArrayProto(attr, getLocation(), inits); + forwards.push_back(arrayProto); + + ast::FunctionDecl* funcProto = genValueProto(); + produceForwardDecl(funcProto); + genValueOrLabelBody(funcProto, arrayProto); + produceDecl(funcProto); + } else { + ast::FunctionDecl* funcProto = genQuasiValueProto(); + produceForwardDecl(funcProto); + genQuasiValueBody(funcProto); + produceDecl(funcProto); + } + } else if (attr == ast::EnumAttribute::Label) { + std::vector> inits = genLabelInit(); ast::ObjectDecl* arrayProto = genAttrArrayProto(attr, getLocation(), inits); forwards.push_back(arrayProto); - - ast::FunctionDecl* funcProto = ( attr == ast::EnumAttribute::Value ) - ? genValueProto() - : genLabelProto(); + ast::FunctionDecl* funcProto = genLabelProto(); produceForwardDecl(funcProto); genValueOrLabelBody(funcProto, arrayProto); @@ -384,7 +438,14 @@ void EnumAttrFuncGenerator::genTypedEnumFuncs() { - if (decl->base) genTypedEnumFunction(ast::EnumAttribute::Value); + genTypedEnumFunction(ast::EnumAttribute::Value); genTypedEnumFunction(ast::EnumAttribute::Label); genTypedEnumFunction(ast::EnumAttribute::Posn); +} + +void EnumAttrFuncGenerator::genTypeNameFunc() { + ast::FunctionDecl* funcProto = genTypeNameProto(); + produceForwardDecl(funcProto); + genTypeNameBody(funcProto); + produceDecl(funcProto); } @@ -392,4 +453,5 @@ std::list>& decls) { // Generate the functions (they go into forwards and definitions). + genTypeNameFunc(); genTypedEnumFuncs(); genSerialTraitFuncs();