Index: src/CodeGen/OperatorTable.cc =================================================================== --- src/CodeGen/OperatorTable.cc (revision 74330e70ac91b5ec34b6f71f01730ecbbf4e3af7) +++ src/CodeGen/OperatorTable.cc (revision 9853828849ae6cfc8816c786dd035e3969334bcb) @@ -24,46 +24,46 @@ namespace { const OperatorInfo tableValues[] = { - { "?[?]", "", "_operator_index", OT_INDEX }, - { "?{}", "=", "_constructor", OT_CTOR }, - { "^?{}", "", "_destructor", OT_DTOR }, - { "?()", "", "_operator_call", OT_CALL }, - { "?++", "++", "_operator_postincr", OT_POSTFIXASSIGN }, - { "?--", "--", "_operator_postdecr", OT_POSTFIXASSIGN }, - { "*?", "*", "_operator_deref", OT_PREFIX }, - { "+?", "+", "_operator_unaryplus", OT_PREFIX }, - { "-?", "-", "_operator_unaryminus", OT_PREFIX }, - { "~?", "~", "_operator_bitnot", OT_PREFIX }, - { "!?", "!", "_operator_lognot", OT_PREFIX }, - { "++?", "++", "_operator_preincr", OT_PREFIXASSIGN }, - { "--?", "--", "_operator_predecr", OT_PREFIXASSIGN }, - { "?\\?", "\\", "_operator_exponential", OT_INFIX }, - { "?*?", "*", "_operator_multiply", OT_INFIX }, - { "?/?", "/", "_operator_divide", OT_INFIX }, - { "?%?", "%", "_operator_modulus", OT_INFIX }, - { "?+?", "+", "_operator_add", OT_INFIX }, - { "?-?", "-", "_operator_subtract", OT_INFIX }, - { "?<>?", ">>", "_operator_shiftright", OT_INFIX }, - { "??", ">", "_operator_greater", OT_INFIX }, - { "?<=?", "<=", "_operator_lessequal", OT_INFIX }, - { "?>=?", ">=", "_operator_greaterequal", OT_INFIX }, - { "?==?", "==", "_operator_equal", OT_INFIX }, - { "?!=?", "!=", "_operator_notequal", OT_INFIX }, - { "?&?", "&", "_operator_bitand", OT_INFIX }, - { "?^?", "^", "_operator_bitxor", OT_INFIX }, - { "?|?", "|", "_operator_bitor", OT_INFIX }, - { "?=?", "=", "_operator_assign", OT_INFIXASSIGN }, - { "?\\=?", "\\=", "_operator_expassign", OT_INFIXASSIGN }, - { "?*=?", "*=", "_operator_multassign", OT_INFIXASSIGN }, - { "?/=?", "/=", "_operator_divassign", OT_INFIXASSIGN }, - { "?%=?", "%=", "_operator_modassign", OT_INFIXASSIGN }, - { "?+=?", "+=", "_operator_addassign", OT_INFIXASSIGN }, - { "?-=?", "-=", "_operator_subassign", OT_INFIXASSIGN }, - { "?<<=?", "<<=", "_operator_shiftleftassign", OT_INFIXASSIGN }, - { "?>>=?", ">>=", "_operator_shiftrightassign", OT_INFIXASSIGN }, - { "?&=?", "&=", "_operator_bitandassign", OT_INFIXASSIGN }, - { "?^=?", "^=", "_operator_bitxorassign", OT_INFIXASSIGN }, - { "?|=?", "|=", "_operator_bitorassign", OT_INFIXASSIGN }, + { "?[?]", "", "_operator_index", "Index", OT_INDEX }, + { "?{}", "=", "_constructor", "Constructor", OT_CTOR }, + { "^?{}", "", "_destructor", "Destructor", OT_DTOR }, + { "?()", "", "_operator_call", "Call Operator", OT_CALL }, + { "?++", "++", "_operator_postincr", "Postfix Increment", OT_POSTFIXASSIGN }, + { "?--", "--", "_operator_postdecr", "Postfix Decrement", OT_POSTFIXASSIGN }, + { "*?", "*", "_operator_deref", "Dereference", OT_PREFIX }, + { "+?", "+", "_operator_unaryplus", "Plus", OT_PREFIX }, + { "-?", "-", "_operator_unaryminus", "Minus", OT_PREFIX }, + { "~?", "~", "_operator_bitnot", "Bitwise Not", OT_PREFIX }, + { "!?", "!", "_operator_lognot", "Logical Not", OT_PREFIX }, + { "++?", "++", "_operator_preincr", "Prefix Increment", OT_PREFIXASSIGN }, + { "--?", "--", "_operator_predecr", "Prefix Decrement", OT_PREFIXASSIGN }, + { "?\\?", "\\", "_operator_exponential", "Exponentiation", OT_INFIX }, + { "?*?", "*", "_operator_multiply", "Multiplication", OT_INFIX }, + { "?/?", "/", "_operator_divide", "Division", OT_INFIX }, + { "?%?", "%", "_operator_modulus", "Modulo", OT_INFIX }, + { "?+?", "+", "_operator_add", "Addition", OT_INFIX }, + { "?-?", "-", "_operator_subtract", "Substraction", OT_INFIX }, + { "?<>?", ">>", "_operator_shiftright", "Shift Right", OT_INFIX }, + { "??", ">", "_operator_greater", "Greater-than", OT_INFIX }, + { "?<=?", "<=", "_operator_lessequal", "Less-than-or-Equal", OT_INFIX }, + { "?>=?", ">=", "_operator_greaterequal", "Greater-than-or-Equal", OT_INFIX }, + { "?==?", "==", "_operator_equal", "Equality", OT_INFIX }, + { "?!=?", "!=", "_operator_notequal", "Not-Equal", OT_INFIX }, + { "?&?", "&", "_operator_bitand", "Bitwise And", OT_INFIX }, + { "?^?", "^", "_operator_bitxor", "Bitwise Xor", OT_INFIX }, + { "?|?", "|", "_operator_bitor", "Bitwise Or", OT_INFIX }, + { "?=?", "=", "_operator_assign", "Assignment", OT_INFIXASSIGN }, + { "?\\=?", "\\=", "_operator_expassign", "Exponentiation Assignment", OT_INFIXASSIGN }, + { "?*=?", "*=", "_operator_multassign", "Multiplication Assignment", OT_INFIXASSIGN }, + { "?/=?", "/=", "_operator_divassign", "Division Assignment", OT_INFIXASSIGN }, + { "?%=?", "%=", "_operator_modassign", "Modulo Assignment", OT_INFIXASSIGN }, + { "?+=?", "+=", "_operator_addassign", "Addition Assignment", OT_INFIXASSIGN }, + { "?-=?", "-=", "_operator_subassign", "Substrction Assignment", OT_INFIXASSIGN }, + { "?<<=?", "<<=", "_operator_shiftleftassign", "Shift Left Assignment", OT_INFIXASSIGN }, + { "?>>=?", ">>=", "_operator_shiftrightassign", "Shift Right Assignment", OT_INFIXASSIGN }, + { "?&=?", "&=", "_operator_bitandassign", "Bitwise And Assignment", OT_INFIXASSIGN }, + { "?^=?", "^=", "_operator_bitxorassign", "Bitwise Xor Assignment", OT_INFIXASSIGN }, + { "?|=?", "|=", "_operator_bitorassign", "Bitwise Or Assignment", OT_INFIXASSIGN }, }; @@ -105,4 +105,12 @@ OperatorInfo info; return operatorLookup( funcName, info ); + } + + std::string operatorFriendlyName( const std::string & funcName ) { + OperatorInfo info; + if( operatorLookup( funcName, info ) ) { + return info.friendlyName; + } + return ""; } Index: src/CodeGen/OperatorTable.h =================================================================== --- src/CodeGen/OperatorTable.h (revision 74330e70ac91b5ec34b6f71f01730ecbbf4e3af7) +++ src/CodeGen/OperatorTable.h (revision 9853828849ae6cfc8816c786dd035e3969334bcb) @@ -38,4 +38,5 @@ std::string symbol; std::string outputName; + std::string friendlyName; OperatorType type; }; @@ -43,4 +44,5 @@ bool isOperator( const std::string & funcName ); bool operatorLookup( const std::string & funcName, OperatorInfo & info ); + std::string operatorFriendlyName( const std::string & funcName ); bool isConstructor( const std::string & ); Index: src/Common/SemanticError.h =================================================================== --- src/Common/SemanticError.h (revision 74330e70ac91b5ec34b6f71f01730ecbbf4e3af7) +++ src/Common/SemanticError.h (revision 9853828849ae6cfc8816c786dd035e3969334bcb) @@ -49,15 +49,16 @@ struct WarningData { const char * const name; + const Severity default_severity; const char * const message; - const Severity default_severity; }; constexpr WarningData WarningFormats[] = { - {"self-assign" , "self assignment of expression: %s" , Severity::Warn}, - {"reference-conversion" , "rvalue to reference conversion of rvalue: %s" , Severity::Warn}, - {"qualifiers-zero_t-one_t", "questionable use of type qualifier %s with %s", Severity::Warn}, - {"aggregate-forward-decl" , "forward declaration of nested aggregate: %s" , Severity::Warn}, - {"superfluous-decl" , "declaration does not allocate storage: %s" , Severity::Warn}, - {"gcc-attributes" , "invalid attribute: %s" , Severity::Warn}, + {"self-assign" , Severity::Warn , "self assignment of expression: %s" }, + {"reference-conversion" , Severity::Warn , "rvalue to reference conversion of rvalue: %s" }, + {"qualifiers-zero_t-one_t", Severity::Warn , "questionable use of type qualifier %s with %s" }, + {"aggregate-forward-decl" , Severity::Warn , "forward declaration of nested aggregate: %s" }, + {"superfluous-decl" , Severity::Warn , "declaration does not allocate storage: %s" }, + {"gcc-attributes" , Severity::Warn , "invalid attribute: %s" }, + {"c++-like-copy" , Severity::Warn , "Constructor from reference is not a valid copy constructor" }, }; @@ -69,4 +70,5 @@ SuperfluousDecl, GccAttributes, + CppCopy, NUMBER_OF_WARNINGS, // This MUST be the last warning }; Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 74330e70ac91b5ec34b6f71f01730ecbbf4e3af7) +++ src/SymTab/Validate.cc (revision 9853828849ae6cfc8816c786dd035e3969334bcb) @@ -311,4 +311,5 @@ Stats::Heap::newPass("validate-A"); Stats::Time::BlockGuard guard("validate-A"); + VerifyCtorDtorAssign::verify( translationUnit ); // must happen before autogen, because autogen examines existing ctor/dtors acceptAll( translationUnit, hoistDecls ); ReplaceTypedef::replaceTypedef( translationUnit ); @@ -336,5 +337,4 @@ Stats::Time::BlockGuard guard("validate-C"); acceptAll( translationUnit, genericParams ); // check as early as possible - can't happen before LinkReferenceToTypes_old - VerifyCtorDtorAssign::verify( translationUnit ); // must happen before autogen, because autogen examines existing ctor/dtors ReturnChecker::checkFunctionReturns( translationUnit ); InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen @@ -1182,12 +1182,14 @@ if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc. if ( params.size() == 0 ) { - SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " ); + SemanticError( funcDecl->location, "Constructors, destructors, and assignment functions require at least one parameter." ); } ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() ); if ( ! refType ) { - SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " ); + SemanticError( funcDecl->location, "First parameter of a constructor, destructor, or assignment function must be a reference." ); } if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) { - SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " ); + if(!returnVals.front()->get_type()->isVoid()) { + SemanticError( funcDecl->location, "Constructors and destructors cannot have explicit return values." ); + } } }