From 0e99bd1990ecfc87d58e6a0865c65a148e06e7a0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C4=99drzej=20Nowacki?= Date: Thu, 10 Apr 2014 17:52:50 +0000 Subject: Build fix with defined DEBUG_MOC Change-Id: I365feceda20625e95503eb5acfa58fc89bd3720a Reviewed-by: Olivier Goffart --- src/tools/moc/token.cpp | 171 +------------------- src/tools/moc/token.h | 410 ++++++++++++++++++++++++------------------------ 2 files changed, 211 insertions(+), 370 deletions(-) (limited to 'src/tools') diff --git a/src/tools/moc/token.cpp b/src/tools/moc/token.cpp index a936555980..36b413ca84 100644 --- a/src/tools/moc/token.cpp +++ b/src/tools/moc/token.cpp @@ -47,174 +47,9 @@ QT_BEGIN_NAMESPACE const char *tokenTypeName(Token t) { switch (t) { - case NOTOKEN: return "NOTOKEN"; - case IDENTIFIER: return "IDENTIFIER"; - case INTEGER_LITERAL: return "INTEGER_LITERAL"; - case CHARACTER_LITERAL: return "CHARACTER_LITERAL"; - case STRING_LITERAL: return "STRING_LITERAL"; - case BOOLEAN_LITERAL: return "BOOLEAN_LITERAL"; - case HEADER_NAME: return "HEADER_NAME"; - case LANGLE: return "LANGLE"; - case RANGLE: return "RANGLE"; - case LPAREN: return "LPAREN"; - case RPAREN: return "RPAREN"; - case ELIPSIS: return "ELIPSIS"; - case LBRACK: return "LBRACK"; - case RBRACK: return "RBRACK"; - case LBRACE: return "LBRACE"; - case RBRACE: return "RBRACE"; - case EQ: return "EQ"; - case SCOPE: return "SCOPE"; - case SEMIC: return "SEMIC"; - case COLON: return "COLON"; - case DOTSTAR: return "DOTSTAR"; - case QUESTION: return "QUESTION"; - case DOT: return "DOT"; - case DYNAMIC_CAST: return "DYNAMIC_CAST"; - case STATIC_CAST: return "STATIC_CAST"; - case REINTERPRET_CAST: return "REINTERPRET_CAST"; - case CONST_CAST: return "CONST_CAST"; - case TYPEID: return "TYPEID"; - case THIS: return "THIS"; - case TEMPLATE: return "TEMPLATE"; - case THROW: return "THROW"; - case TRY: return "TRY"; - case CATCH: return "CATCH"; - case TYPEDEF: return "TYPEDEF"; - case FRIEND: return "FRIEND"; - case CLASS: return "CLASS"; - case NAMESPACE: return "NAMESPACE"; - case ENUM: return "ENUM"; - case STRUCT: return "STRUCT"; - case UNION: return "UNION"; - case VIRTUAL: return "VIRTUAL"; - case PRIVATE: return "PRIVATE"; - case PROTECTED: return "PROTECTED"; - case PUBLIC: return "PUBLIC"; - case EXPORT: return "EXPORT"; - case AUTO: return "AUTO"; - case REGISTER: return "REGISTER"; - case EXTERN: return "EXTERN"; - case MUTABLE: return "MUTABLE"; - case ASM: return "ASM"; - case USING: return "USING"; - case INLINE: return "INLINE"; - case EXPLICIT: return "EXPLICIT"; - case STATIC: return "STATIC"; - case CONST: return "CONST"; - case VOLATILE: return "VOLATILE"; - case OPERATOR: return "OPERATOR"; - case SIZEOF: return "SIZEOF"; - case NEW: return "NEW"; - case DELETE: return "DELETE"; - case PLUS: return "PLUS"; - case MINUS: return "MINUS"; - case STAR: return "STAR"; - case SLASH: return "SLASH"; - case PERCENT: return "PERCENT"; - case HAT: return "HAT"; - case AND: return "AND"; - case OR: return "OR"; - case TILDE: return "TILDE"; - case NOT: return "NOT"; - case PLUS_EQ: return "PLUS_EQ"; - case MINUS_EQ: return "MINUS_EQ"; - case STAR_EQ: return "STAR_EQ"; - case SLASH_EQ: return "SLASH_EQ"; - case PERCENT_EQ: return "PERCENT_EQ"; - case HAT_EQ: return "HAT_EQ"; - case AND_EQ: return "AND_EQ"; - case OR_EQ: return "OR_EQ"; - case LTLT: return "LTLT"; - case GTGT: return "GTGT"; - case GTGT_EQ: return "GTGT_EQ"; - case LTLT_EQ: return "LTLT_EQ"; - case EQEQ: return "EQEQ"; - case NE: return "NE"; - case LE: return "LE"; - case GE: return "GE"; - case ANDAND: return "ANDAND"; - case OROR: return "OROR"; - case INCR: return "INCR"; - case DECR: return "DECR"; - case COMMA: return "COMMA"; - case ARROW_STAR: return "ARROW_STAR"; - case ARROW: return "ARROW"; - case CHAR: return "CHAR"; - case WCHAR: return "WCHAR"; - case BOOL: return "BOOL"; - case SHORT: return "SHORT"; - case INT: return "INT"; - case LONG: return "LONG"; - case SIGNED: return "SIGNED"; - case UNSIGNED: return "UNSIGNED"; - case FLOAT: return "FLOAT"; - case DOUBLE: return "DOUBLE"; - case VOID: return "VOID"; - case CASE: return "CASE"; - case DEFAULT: return "DEFAULT"; - case IF: return "IF"; - case ELSE: return "ELSE"; - case SWITCH: return "SWITCH"; - case WHILE: return "WHILE"; - case DO: return "DO"; - case FOR: return "FOR"; - case BREAK: return "BREAK"; - case CONTINUE: return "CONTINUE"; - case GOTO: return "GOTO"; - case SIGNALS: return "SIGNALS"; - case SLOTS: return "SLOTS"; - case RETURN: return "RETURN"; - case Q_OBJECT_TOKEN: return "Q_OBJECT_TOKEN"; - case Q_GADGET_TOKEN: return "Q_GADGET_TOKEN"; - case Q_PROPERTY_TOKEN: return "Q_PROPERTY_TOKEN"; - case Q_ENUMS_TOKEN: return "Q_ENUMS_TOKEN"; - case Q_FLAGS_TOKEN: return "Q_FLAGS_TOKEN"; - case Q_DECLARE_FLAGS_TOKEN: return "Q_DECLARE_FLAGS_TOKEN"; - case Q_DECLARE_INTERFACE_TOKEN: return "Q_DECLARE_INTERFACE_TOKEN"; - case Q_CLASSINFO_TOKEN: return "Q_CLASSINFO_TOKEN"; - case Q_INTERFACES_TOKEN: return "Q_INTERFACES_TOKEN"; - case Q_SIGNALS_TOKEN: return "Q_SIGNALS_TOKEN"; - case Q_SLOTS_TOKEN: return "Q_SLOTS_TOKEN"; - case Q_SIGNAL_TOKEN: return "Q_SIGNAL_TOKEN"; - case Q_SLOT_TOKEN: return "Q_SLOT_TOKEN"; - case Q_PRIVATE_SLOT_TOKEN: return "Q_PRIVATE_SLOT_TOKEN"; - case Q_PRIVATE_PROPERTY_TOKEN: return "Q_PRIVATE_PROPERTY_TOKEN"; - case Q_REVISION_TOKEN: return "Q_REVISION_TOKEN"; - case SPECIAL_TREATMENT_MARK: return "SPECIAL_TREATMENT_MARK"; - case MOC_INCLUDE_BEGIN: return "MOC_INCLUDE_BEGIN"; - case MOC_INCLUDE_END: return "MOC_INCLUDE_END"; - case CPP_COMMENT: return "CPP_COMMENT"; - case C_COMMENT: return "C_COMMENT"; - case FLOATING_LITERAL: return "FLOATING_LITERAL"; - case HASH: return "HASH"; - case QUOTE: return "QUOTE"; - case SINGLEQUOTE: return "SINGLEQUOTE"; - case DIGIT: return "DIGIT"; - case CHARACTER: return "CHARACTER"; - case NEWLINE: return "NEWLINE"; - case WHITESPACE: return "WHITESPACE"; - case BACKSLASH: return "BACKSLASH"; - case INCOMPLETE: return "INCOMPLETE"; - case PP_DEFINE: return "PP_DEFINE"; - case PP_UNDEF: return "PP_UNDEF"; - case PP_IF: return "PP_IF"; - case PP_IFDEF: return "PP_IFDEF"; - case PP_IFNDEF: return "PP_IFNDEF"; - case PP_ELIF: return "PP_ELIF"; - case PP_ELSE: return "PP_ELSE"; - case PP_ENDIF: return "PP_ENDIF"; - case PP_INCLUDE: return "PP_INCLUDE"; - case PP_HASHHASH: return "PP_HASHHASH"; - case PP_HASH: return "PP_HASH"; - case PP_DEFINED: return "PP_DEFINED"; - case PP_INCOMPLETE: return "PP_INCOMPLETE"; - case PP_MOC_TRUE: return "PP_MOC_TRUE"; - case PP_MOC_FALSE: return "PP_MOC_FALSE"; - case Q_DECLARE_METATYPE_TOKEN: return "Q_DECLARE_METATYPE_TOKEN"; - case Q_MOC_COMPAT_TOKEN: return "Q_MOC_COMPAT_TOKEN"; - case Q_INVOKABLE_TOKEN: return "Q_INVOKABLE_TOKEN"; - case Q_SCRIPTABLE_TOKEN: return "Q_SCRIPTABLE_TOKEN"; +#define CREATE_CASE(Name) case Name: return #Name; + FOR_ALL_TOKENS(CREATE_CASE) +#undef CREATE_CASE } return ""; } diff --git a/src/tools/moc/token.h b/src/tools/moc/token.h index 378d4c63f7..2920fadbb9 100644 --- a/src/tools/moc/token.h +++ b/src/tools/moc/token.h @@ -46,222 +46,228 @@ QT_BEGIN_NAMESPACE -enum Token { - NOTOKEN, - IDENTIFIER, - INTEGER_LITERAL, - CHARACTER_LITERAL, - STRING_LITERAL, - BOOLEAN_LITERAL, - HEADER_NAME, - LANGLE, - RANGLE, - LPAREN, - RPAREN, - ELIPSIS, - LBRACK, - RBRACK, - LBRACE, - RBRACE, - EQ, - SCOPE, - SEMIC, - COLON, - DOTSTAR, - QUESTION, - DOT, - DYNAMIC_CAST, - STATIC_CAST, - REINTERPRET_CAST, - CONST_CAST, - TYPEID, - THIS, - TEMPLATE, - THROW, - TRY, - CATCH, - TYPEDEF, - FRIEND, - CLASS, - NAMESPACE, - ENUM, - STRUCT, - UNION, - VIRTUAL, - PRIVATE, - PROTECTED, - PUBLIC, - EXPORT, - AUTO, - REGISTER, - EXTERN, - MUTABLE, - ASM, - USING, - INLINE, - EXPLICIT, - STATIC, - CONST, - VOLATILE, - OPERATOR, - SIZEOF, - NEW, - DELETE, - PLUS, - MINUS, - STAR, - SLASH, - PERCENT, - HAT, - AND, - OR, - TILDE, - NOT, - PLUS_EQ, - MINUS_EQ, - STAR_EQ, - SLASH_EQ, - PERCENT_EQ, - HAT_EQ, - AND_EQ, - OR_EQ, - LTLT, - GTGT, - GTGT_EQ, - LTLT_EQ, - EQEQ, - NE, - LE, - GE, - ANDAND, - OROR, - INCR, - DECR, - COMMA, - ARROW_STAR, - ARROW, - CHAR, - WCHAR, - BOOL, - SHORT, - INT, - LONG, - SIGNED, - UNSIGNED, - FLOAT, - DOUBLE, - VOID, - CASE, - DEFAULT, - IF, - ELSE, - SWITCH, - WHILE, - DO, - FOR, - BREAK, - CONTINUE, - GOTO, - SIGNALS, - SLOTS, - RETURN, - Q_META_TOKEN_BEGIN, - Q_OBJECT_TOKEN = Q_META_TOKEN_BEGIN, - Q_GADGET_TOKEN, - Q_PROPERTY_TOKEN, - Q_PLUGIN_METADATA_TOKEN, - Q_ENUMS_TOKEN, - Q_FLAGS_TOKEN, - Q_DECLARE_FLAGS_TOKEN, - Q_DECLARE_INTERFACE_TOKEN, - Q_DECLARE_METATYPE_TOKEN, - Q_CLASSINFO_TOKEN, - Q_INTERFACES_TOKEN, - Q_SIGNALS_TOKEN, - Q_SLOTS_TOKEN, - Q_SIGNAL_TOKEN, - Q_SLOT_TOKEN, - Q_PRIVATE_SLOT_TOKEN, - Q_MOC_COMPAT_TOKEN, - Q_INVOKABLE_TOKEN, - Q_SCRIPTABLE_TOKEN, - Q_PRIVATE_PROPERTY_TOKEN, - Q_REVISION_TOKEN, - Q_META_TOKEN_END, - SPECIAL_TREATMENT_MARK = Q_META_TOKEN_END, - MOC_INCLUDE_BEGIN, - MOC_INCLUDE_END, - CPP_COMMENT, - C_COMMENT, - FLOATING_LITERAL, - HASH, - QUOTE, - SINGLEQUOTE, - LANGLE_SCOPE, - DIGIT, - CHARACTER, - NEWLINE, - WHITESPACE, - BACKSLASH, - INCOMPLETE, +#define FOR_ALL_TOKENS(F) \ + F(NOTOKEN) \ + F(IDENTIFIER) \ + F(INTEGER_LITERAL) \ + F(CHARACTER_LITERAL) \ + F(STRING_LITERAL) \ + F(BOOLEAN_LITERAL) \ + F(HEADER_NAME) \ + F(LANGLE) \ + F(RANGLE) \ + F(LPAREN) \ + F(RPAREN) \ + F(ELIPSIS) \ + F(LBRACK) \ + F(RBRACK) \ + F(LBRACE) \ + F(RBRACE) \ + F(EQ) \ + F(SCOPE) \ + F(SEMIC) \ + F(COLON) \ + F(DOTSTAR) \ + F(QUESTION) \ + F(DOT) \ + F(DYNAMIC_CAST) \ + F(STATIC_CAST) \ + F(REINTERPRET_CAST) \ + F(CONST_CAST) \ + F(TYPEID) \ + F(THIS) \ + F(TEMPLATE) \ + F(THROW) \ + F(TRY) \ + F(CATCH) \ + F(TYPEDEF) \ + F(FRIEND) \ + F(CLASS) \ + F(NAMESPACE) \ + F(ENUM) \ + F(STRUCT) \ + F(UNION) \ + F(VIRTUAL) \ + F(PRIVATE) \ + F(PROTECTED) \ + F(PUBLIC) \ + F(EXPORT) \ + F(AUTO) \ + F(REGISTER) \ + F(EXTERN) \ + F(MUTABLE) \ + F(ASM) \ + F(USING) \ + F(INLINE) \ + F(EXPLICIT) \ + F(STATIC) \ + F(CONST) \ + F(VOLATILE) \ + F(OPERATOR) \ + F(SIZEOF) \ + F(NEW) \ + F(DELETE) \ + F(PLUS) \ + F(MINUS) \ + F(STAR) \ + F(SLASH) \ + F(PERCENT) \ + F(HAT) \ + F(AND) \ + F(OR) \ + F(TILDE) \ + F(NOT) \ + F(PLUS_EQ) \ + F(MINUS_EQ) \ + F(STAR_EQ) \ + F(SLASH_EQ) \ + F(PERCENT_EQ) \ + F(HAT_EQ) \ + F(AND_EQ) \ + F(OR_EQ) \ + F(LTLT) \ + F(GTGT) \ + F(GTGT_EQ) \ + F(LTLT_EQ) \ + F(EQEQ) \ + F(NE) \ + F(LE) \ + F(GE) \ + F(ANDAND) \ + F(OROR) \ + F(INCR) \ + F(DECR) \ + F(COMMA) \ + F(ARROW_STAR) \ + F(ARROW) \ + F(CHAR) \ + F(WCHAR) \ + F(BOOL) \ + F(SHORT) \ + F(INT) \ + F(LONG) \ + F(SIGNED) \ + F(UNSIGNED) \ + F(FLOAT) \ + F(DOUBLE) \ + F(VOID) \ + F(CASE) \ + F(DEFAULT) \ + F(IF) \ + F(ELSE) \ + F(SWITCH) \ + F(WHILE) \ + F(DO) \ + F(FOR) \ + F(BREAK) \ + F(CONTINUE) \ + F(GOTO) \ + F(SIGNALS) \ + F(SLOTS) \ + F(RETURN) \ + F(Q_OBJECT_TOKEN) \ + F(Q_GADGET_TOKEN) \ + F(Q_PROPERTY_TOKEN) \ + F(Q_PLUGIN_METADATA_TOKEN) \ + F(Q_ENUMS_TOKEN) \ + F(Q_FLAGS_TOKEN) \ + F(Q_DECLARE_FLAGS_TOKEN) \ + F(Q_DECLARE_INTERFACE_TOKEN) \ + F(Q_DECLARE_METATYPE_TOKEN) \ + F(Q_CLASSINFO_TOKEN) \ + F(Q_INTERFACES_TOKEN) \ + F(Q_SIGNALS_TOKEN) \ + F(Q_SLOTS_TOKEN) \ + F(Q_SIGNAL_TOKEN) \ + F(Q_SLOT_TOKEN) \ + F(Q_PRIVATE_SLOT_TOKEN) \ + F(Q_MOC_COMPAT_TOKEN) \ + F(Q_INVOKABLE_TOKEN) \ + F(Q_SCRIPTABLE_TOKEN) \ + F(Q_PRIVATE_PROPERTY_TOKEN) \ + F(Q_REVISION_TOKEN) \ + F(SPECIAL_TREATMENT_MARK) \ + F(MOC_INCLUDE_BEGIN) \ + F(MOC_INCLUDE_END) \ + F(CPP_COMMENT) \ + F(C_COMMENT) \ + F(FLOATING_LITERAL) \ + F(HASH) \ + F(QUOTE) \ + F(SINGLEQUOTE) \ + F(LANGLE_SCOPE) \ + F(DIGIT) \ + F(CHARACTER) \ + F(NEWLINE) \ + F(WHITESPACE) \ + F(BACKSLASH) \ + F(INCOMPLETE) \ + F(PP_DEFINE) \ + F(PP_UNDEF) \ + F(PP_IF) \ + F(PP_IFDEF) \ + F(PP_IFNDEF) \ + F(PP_ELIF) \ + F(PP_ELSE) \ + F(PP_ENDIF) \ + F(PP_INCLUDE) \ + F(PP_HASHHASH) \ + F(PP_HASH) \ + F(PP_DEFINED) \ + F(PP_INCOMPLETE) \ + F(PP_MOC_TRUE) \ + F(PP_MOC_FALSE) + - PP_DEFINE, - PP_UNDEF, - PP_IF, - PP_IFDEF, - PP_IFNDEF, - PP_ELIF, - PP_ELSE, - PP_ENDIF, - PP_INCLUDE, - PP_HASHHASH, - PP_HASH, - PP_DEFINED, - PP_INCOMPLETE, +enum Token { - PP_MOC_TRUE, - PP_MOC_FALSE, +#define CREATE_ENUM_VALUE(Name) Name, + FOR_ALL_TOKENS(CREATE_ENUM_VALUE) +#undef CREATE_ENUM_VALUE - PP_NOTOKEN = NOTOKEN, + // aliases + PP_AND = AND, + PP_ANDAND = ANDAND, + PP_BACKSLASH = BACKSLASH, + PP_CHARACTER = CHARACTER, + PP_CHARACTER_LITERAL = CHARACTER_LITERAL, + PP_COLON = COLON, + PP_COMMA = COMMA, + PP_CPP_COMMENT = CPP_COMMENT, + PP_C_COMMENT = C_COMMENT, + PP_DIGIT = DIGIT, + PP_EQEQ = EQEQ, + PP_FLOATING_LITERAL = FLOATING_LITERAL, + PP_GE = GE, + PP_GTGT = GTGT, + PP_HAT = HAT, PP_IDENTIFIER = IDENTIFIER, PP_INTEGER_LITERAL = INTEGER_LITERAL, - PP_CHARACTER_LITERAL = CHARACTER_LITERAL, - PP_STRING_LITERAL = STRING_LITERAL, PP_LANGLE = LANGLE, - PP_RANGLE = RANGLE, + PP_LE = LE, PP_LPAREN = LPAREN, - PP_RPAREN = RPAREN, - PP_COMMA = COMMA, - PP_PLUS = PLUS, - PP_MINUS = MINUS, - PP_STAR = STAR, - PP_SLASH = SLASH, - PP_PERCENT = PERCENT, - PP_HAT = HAT, - PP_AND = AND, - PP_OR = OR, - PP_TILDE = TILDE, - PP_NOT = NOT, PP_LTLT = LTLT, - PP_GTGT = GTGT, - PP_EQEQ = EQEQ, + PP_MINUS = MINUS, PP_NE = NE, - PP_LE = LE, - PP_GE = GE, - PP_ANDAND = ANDAND, + PP_NEWLINE = NEWLINE, + PP_NOTOKEN = NOTOKEN, + PP_NOT = NOT, + PP_OR = OR, PP_OROR = OROR, + PP_PERCENT = PERCENT, + PP_PLUS = PLUS, PP_QUESTION = QUESTION, - PP_COLON = COLON, - PP_FLOATING_LITERAL = FLOATING_LITERAL, PP_QUOTE = QUOTE, + PP_RANGLE = RANGLE, + PP_RPAREN = RPAREN, PP_SINGLEQUOTE = SINGLEQUOTE, - PP_DIGIT = DIGIT, - PP_CHARACTER = CHARACTER, + PP_SLASH = SLASH, + PP_STAR = STAR, + PP_STRING_LITERAL = STRING_LITERAL, + PP_TILDE = TILDE, PP_WHITESPACE = WHITESPACE, - PP_NEWLINE = NEWLINE, - PP_CPP_COMMENT = CPP_COMMENT, - PP_C_COMMENT = C_COMMENT, - PP_BACKSLASH = BACKSLASH + Q_META_TOKEN_BEGIN = Q_OBJECT_TOKEN, + Q_META_TOKEN_END = SPECIAL_TREATMENT_MARK }; // for debugging only -- cgit v1.2.3 From beb7258a56b6ec76531b73cc07ee30132a3f548f Mon Sep 17 00:00:00 2001 From: Kurt Pattyn Date: Tue, 15 Apr 2014 09:57:15 +0200 Subject: Add default case to switch statements When compiling with the -Wswitch-default flag, the compiler spits warnings for the moc generated files. In certain development environments (e.g. where MISRA rules have to be followed) every switch statement needs to have a default case. Unfortunately the moc generated files contain switch statements without default case. This patch adds a default statement to all switch statements that are generated by the moc compiler. Change-Id: I8f3d81e3463fce4d3abf2ea5d0fa8727a7d9ba2e Reviewed-by: Olivier Goffart Reviewed-by: Thiago Macieira --- src/tools/moc/generator.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/tools') diff --git a/src/tools/moc/generator.cpp b/src/tools/moc/generator.cpp index d831edfef0..a67ea05956 100644 --- a/src/tools/moc/generator.cpp +++ b/src/tools/moc/generator.cpp @@ -983,6 +983,7 @@ void Generator::generateMetacall() fprintf(out, " case %d: *reinterpret_cast< %s*>(_v) = %s%s; break;\n", propindex, p.type.constData(), prefix.constData(), p.member.constData()); } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); } @@ -1031,6 +1032,7 @@ void Generator::generateMetacall() fprintf(out, " break;\n"); } } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); } @@ -1054,6 +1056,7 @@ void Generator::generateMetacall() fprintf(out, " case %d: %s%s; break;\n", propindex, prefix.constData(), p.reset.constData()); } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); } fprintf(out, @@ -1072,6 +1075,7 @@ void Generator::generateMetacall() fprintf(out, " case %d: *_b = %s; break;\n", propindex, p.designable.constData()); } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); } fprintf(out, @@ -1090,6 +1094,7 @@ void Generator::generateMetacall() fprintf(out, " case %d: *_b = %s; break;\n", propindex, p.scriptable.constData()); } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); } fprintf(out, @@ -1108,6 +1113,7 @@ void Generator::generateMetacall() fprintf(out, " case %d: *_b = %s; break;\n", propindex, p.stored.constData()); } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); } fprintf(out, @@ -1126,6 +1132,7 @@ void Generator::generateMetacall() fprintf(out, " case %d: *_b = %s; break;\n", propindex, p.editable.constData()); } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); } fprintf(out, @@ -1145,6 +1152,7 @@ void Generator::generateMetacall() fprintf(out, " case %d: *_b = %s; break;\n", propindex, p.user.constData()); } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); } fprintf(out, @@ -1226,6 +1234,7 @@ void Generator::generateStaticMetacall() fprintf(out, ");\n"); fprintf(out, " if (_a[0]) *reinterpret_cast(_a[0]) = _r; } break;\n"); } + fprintf(out, " default: break;\n"); fprintf(out, " }\n"); fprintf(out, " }"); needElse = true; -- cgit v1.2.3