diff --git a/COPYING b/COPYING index 5ab7695ab..c00103def 100644 --- a/COPYING +++ b/COPYING @@ -1,5 +1,5 @@ - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA @@ -10,7 +10,7 @@ as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] - Preamble + Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public @@ -112,7 +112,7 @@ modification follow. Pay close attention to the difference between a former contains code derived from the library, whereas the latter must be combined with the library in order to run. - GNU LESSER GENERAL PUBLIC LICENSE + GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other @@ -432,7 +432,7 @@ decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. - NO WARRANTY + NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. @@ -455,7 +455,7 @@ FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. - END OF TERMS AND CONDITIONS + END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries diff --git a/generator/LICENSE.LGPL b/generator/LICENSE.LGPL index 9a30e8ce8..22bc77aac 100644 --- a/generator/LICENSE.LGPL +++ b/generator/LICENSE.LGPL @@ -1,4 +1,4 @@ - GNU LESSER GENERAL PUBLIC LICENSE + GNU LESSER GENERAL PUBLIC LICENSE The Qt GUI Toolkit is Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). Contact: Nokia Corporation (qt-info@nokia.com) @@ -8,8 +8,8 @@ ------------------------------------------------------------------------- - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA @@ -20,7 +20,7 @@ as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] - Preamble + Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public @@ -122,7 +122,7 @@ modification follow. Pay close attention to the difference between a former contains code derived from the library, whereas the latter must be combined with the library in order to run. - GNU LESSER GENERAL PUBLIC LICENSE + GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other @@ -442,7 +442,7 @@ decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. - NO WARRANTY + NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. @@ -465,7 +465,7 @@ FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. - END OF TERMS AND CONDITIONS + END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries diff --git a/generator/abstractmetalang.cpp b/generator/abstractmetalang.cpp index d7128b7dd..4e2aa8cab 100644 --- a/generator/abstractmetalang.cpp +++ b/generator/abstractmetalang.cpp @@ -1203,7 +1203,7 @@ bool AbstractMetaClass::hasVirtualDestructor() const static bool functions_contains(const AbstractMetaFunctionList &l, const AbstractMetaFunction *func) { foreach (const AbstractMetaFunction *f, l) { - if ((f->compareTo(func) & AbstractMetaFunction::PrettySimilar) == AbstractMetaFunction::PrettySimilar) + if ((f->compareTo(func) & AbstractMetaFunction::PrettySimilar) == AbstractMetaFunction::PrettySimilar) return true; } return false; diff --git a/generator/generator.pri b/generator/generator.pri index c941f879b..490e265c8 100644 --- a/generator/generator.pri +++ b/generator/generator.pri @@ -23,7 +23,7 @@ win32-msvc*{ QMAKE_CXXFLAGS += -wd4996 QMAKE_CFLAGS += -wd4996 #Disable warnings for external headers - greaterThan(QMAKE_MSC_VER, 1599):QMAKE_CXXFLAGS += -external:anglebrackets -external:W0 -external:templates- + greaterThan(QMAKE_MSC_VER, 1599):QMAKE_CXXFLAGS += -external:anglebrackets -external:W0 -external:templates- } #Do not issue warning to Qt's system includes gcc:!isEmpty(QT_INSTALL_HEADERS): QMAKE_CXXFLAGS += -isystem $$[QT_INSTALL_HEADERS] diff --git a/generator/parser/control.cpp b/generator/parser/control.cpp index a8e6a35e8..ee8963947 100644 --- a/generator/parser/control.cpp +++ b/generator/parser/control.cpp @@ -52,7 +52,7 @@ Control::Control() pushContext(); declareTypedef(findOrInsertName("__builtin_va_list", - strlen("__builtin_va_list")), 0); + strlen("__builtin_va_list")), 0); } Control::~Control() diff --git a/generator/parser/lexer.cpp b/generator/parser/lexer.cpp index c5e61441d..681df09b3 100644 --- a/generator/parser/lexer.cpp +++ b/generator/parser/lexer.cpp @@ -184,13 +184,13 @@ void Lexer::initialize_scan_table() for (int i=0; i<256; ++i) { if (isspace(i)) - s_scan_table[i] = &Lexer::scan_white_spaces; + s_scan_table[i] = &Lexer::scan_white_spaces; else if (isalpha(i) || i == '_') - s_scan_table[i] = &Lexer::scan_identifier_or_keyword; + s_scan_table[i] = &Lexer::scan_identifier_or_keyword; else if (isdigit(i)) - s_scan_table[i] = &Lexer::scan_int_constant; + s_scan_table[i] = &Lexer::scan_int_constant; else - s_scan_table[i] = &Lexer::scan_invalid_input; + s_scan_table[i] = &Lexer::scan_invalid_input; } s_scan_table[int('L')] = &Lexer::scan_identifier_or_literal; @@ -254,7 +254,7 @@ void Lexer::scan_char_constant() reportError("did not expect newline"); if (*cursor == '\\') - ++cursor; + ++cursor; ++cursor; } @@ -280,7 +280,7 @@ void Lexer::scan_string_constant() reportError("did not expect newline"); if (*cursor == '\\') - ++cursor; + ++cursor; ++cursor; } @@ -309,9 +309,9 @@ void Lexer::scan_white_spaces() while (isspace(*cursor)) { if (*cursor == '\n') - scan_newline(); + scan_newline(); else - ++cursor; + ++cursor; } } @@ -348,7 +348,7 @@ void Lexer::scan_identifier_or_keyword() if (current_token->kind == Token_identifier) { current_token->extra.symbol = - control->findOrInsertName((const char*) cursor, n); + control->findOrInsertName((const char*) cursor, n); } cursor = skip; @@ -376,8 +376,8 @@ void Lexer::scan_int_constant() void Lexer::scan_not() { /* - '!' ::= not - '!=' ::= not_equal + '!' ::= not + '!=' ::= not_equal */ ++cursor; @@ -396,8 +396,8 @@ void Lexer::scan_not() void Lexer::scan_remainder() { /* - '%' ::= remainder - '%=' ::= remainder_equal + '%' ::= remainder + '%=' ::= remainder_equal */ ++cursor; @@ -416,9 +416,9 @@ void Lexer::scan_remainder() void Lexer::scan_and() { /* - '&&' ::= and_and - '&' ::= and - '&=' ::= and_equal + '&&' ::= and_and + '&' ::= and + '&=' ::= and_equal */ ++cursor; @@ -453,8 +453,8 @@ void Lexer::scan_right_paren() void Lexer::scan_star() { /* - '*' ::= star - '*=' ::= star_equal + '*' ::= star + '*=' ::= star_equal */ ++cursor; @@ -473,9 +473,9 @@ void Lexer::scan_star() void Lexer::scan_plus() { /* - '+' ::= plus - '++' ::= incr - '+=' ::= plus_equal + '+' ::= plus + '++' ::= incr + '+=' ::= plus_equal */ ++cursor; @@ -504,10 +504,10 @@ void Lexer::scan_comma() void Lexer::scan_minus() { /* - '-' ::= minus - '--' ::= decr - '-=' ::= minus_equal - '->' ::= left_arrow + '-' ::= minus + '--' ::= decr + '-=' ::= minus_equal + '->' ::= left_arrow */ ++cursor; @@ -526,10 +526,10 @@ void Lexer::scan_minus() ++cursor; token_stream[(int) index++].kind = Token_arrow; if (*cursor == '*') - { - ++cursor; - token_stream[(int) index++].kind = Token_ptrmem; - } + { + ++cursor; + token_stream[(int) index++].kind = Token_ptrmem; + } } else { @@ -540,8 +540,8 @@ void Lexer::scan_minus() void Lexer::scan_dot() { /* - '.' ::= dot - '...' ::= ellipsis + '.' ::= dot + '...' ::= ellipsis */ ++cursor; @@ -562,8 +562,8 @@ void Lexer::scan_dot() void Lexer::scan_divide() { /* - '/' ::= divide - '/=' ::= divide_equal + '/' ::= divide + '/=' ::= divide_equal */ ++cursor; @@ -602,10 +602,10 @@ void Lexer::scan_semicolon() void Lexer::scan_less() { /* - '<' ::= less - '<<' ::= left_shift - '<<=' ::= left_shift_equal - '<=' ::= less_equal + '<' ::= less + '<<' ::= left_shift + '<<=' ::= left_shift_equal + '<=' ::= less_equal */ ++cursor; @@ -618,14 +618,14 @@ void Lexer::scan_less() { ++cursor; if (*cursor == '=') - { - ++cursor; - token_stream[(int) index++].kind = Token_assign; - } + { + ++cursor; + token_stream[(int) index++].kind = Token_assign; + } else - { - token_stream[(int) index++].kind = Token_shift; - } + { + token_stream[(int) index++].kind = Token_shift; + } } else { @@ -636,8 +636,8 @@ void Lexer::scan_less() void Lexer::scan_equal() { /* - '=' ::= equal - '==' ::= equal_equal + '=' ::= equal + '==' ::= equal_equal */ ++cursor; @@ -655,10 +655,10 @@ void Lexer::scan_equal() void Lexer::scan_greater() { /* - '>' ::= greater - '>=' ::= greater_equal - '>>' ::= right_shift - '>>=' ::= right_shift_equal + '>' ::= greater + '>=' ::= greater_equal + '>>' ::= right_shift + '>>=' ::= right_shift_equal */ ++cursor; @@ -671,14 +671,14 @@ void Lexer::scan_greater() { ++cursor; if (*cursor == '=') - { - ++cursor; - token_stream[(int) index++].kind = Token_assign; - } + { + ++cursor; + token_stream[(int) index++].kind = Token_assign; + } else - { - token_stream[(int) index++].kind = Token_shift; - } + { + token_stream[(int) index++].kind = Token_shift; + } } else { @@ -707,8 +707,8 @@ void Lexer::scan_right_bracket() void Lexer::scan_xor() { /* - '^' ::= xor - '^=' ::= xor_equal + '^' ::= xor + '^=' ::= xor_equal */ ++cursor; @@ -732,9 +732,9 @@ void Lexer::scan_left_brace() void Lexer::scan_or() { /* - '|' ::= or - '|=' ::= or_equal - '||' ::= or_or + '|' ::= or + '|=' ::= or_equal + '||' ::= or_or */ ++cursor; if (*cursor == '=') @@ -779,7 +779,7 @@ void Lexer::scan_invalid_input() } void LocationTable::positionAt(std::size_t offset, int max_line, - int *line, int *column) const + int *line, int *column) const { if (!(line && column && max_line != 0)) return; @@ -797,13 +797,13 @@ void LocationTable::positionAt(std::size_t offset, int max_line, middle += half; if (lines[middle] < offset) - { - first = middle; - ++first; - len = len - half - 1; - } + { + first = middle; + ++first; + len = len - half - 1; + } else - len = half; + len = half; } *line = std::max(first, 1); @@ -826,26 +826,26 @@ void Lexer::scanKeyword2() { case 'i': if (*(cursor + 1) == 'f') - { - token_stream[(int) index++].kind = Token_if; - return; - } + { + token_stream[(int) index++].kind = Token_if; + return; + } break; case 'd': if (*(cursor + 1) == 'o') - { - token_stream[(int) index++].kind = Token_do; - return; - } + { + token_stream[(int) index++].kind = Token_do; + return; + } break; case 'o': if (*(cursor + 1) == 'r') - { - token_stream[(int) index++].kind = Token_or; - return; - } + { + token_stream[(int) index++].kind = Token_or; + return; + } break; } @@ -858,68 +858,68 @@ void Lexer::scanKeyword3() { case 'a': if (*(cursor + 1) == 'n' && - *(cursor + 2) == 'd') - { - token_stream[(int) index++].kind = Token_and; - return; - } + *(cursor + 2) == 'd') + { + token_stream[(int) index++].kind = Token_and; + return; + } if (*(cursor + 1) == 's' && - *(cursor + 2) == 'm') - { - token_stream[(int) index++].kind = Token_asm; - return; - } + *(cursor + 2) == 'm') + { + token_stream[(int) index++].kind = Token_asm; + return; + } break; case 'f': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'r') - { - token_stream[(int) index++].kind = Token_for; - return; - } + *(cursor + 2) == 'r') + { + token_stream[(int) index++].kind = Token_for; + return; + } break; case 'i': if (*(cursor + 1) == 'n' && - *(cursor + 2) == 't') - { - token_stream[(int) index++].kind = Token_int; - return; - } + *(cursor + 2) == 't') + { + token_stream[(int) index++].kind = Token_int; + return; + } break; case 'n': if (*(cursor + 1) == 'e' && - *(cursor + 2) == 'w') - { - token_stream[(int) index++].kind = Token_new; - return; - } + *(cursor + 2) == 'w') + { + token_stream[(int) index++].kind = Token_new; + return; + } if (*(cursor + 1) == 'o' && - *(cursor + 2) == 't') - { - token_stream[(int) index++].kind = Token_not; - return; - } + *(cursor + 2) == 't') + { + token_stream[(int) index++].kind = Token_not; + return; + } break; case 't': if (*(cursor + 1) == 'r' && - *(cursor + 2) == 'y') - { - token_stream[(int) index++].kind = Token_try; - return; - } + *(cursor + 2) == 'y') + { + token_stream[(int) index++].kind = Token_try; + return; + } break; case 'x': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'r') - { - token_stream[(int) index++].kind = Token_xor; - return; - } + *(cursor + 2) == 'r') + { + token_stream[(int) index++].kind = Token_xor; + return; + } break; } @@ -932,103 +932,103 @@ void Lexer::scanKeyword4() { case 'a': if (*(cursor + 1) == 'u' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'o') - { - token_stream[(int) index++].kind = Token_auto; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'o') + { + token_stream[(int) index++].kind = Token_auto; + return; + } break; case 'c': if (*(cursor + 1) == 'a' && - *(cursor + 2) == 's' && - *(cursor + 3) == 'e') - { - token_stream[(int) index++].kind = Token_case; - return; - } + *(cursor + 2) == 's' && + *(cursor + 3) == 'e') + { + token_stream[(int) index++].kind = Token_case; + return; + } if (*(cursor + 1) == 'h' && - *(cursor + 2) == 'a' && - *(cursor + 3) == 'r') - { - token_stream[(int) index++].kind = Token_char; - return; - } + *(cursor + 2) == 'a' && + *(cursor + 3) == 'r') + { + token_stream[(int) index++].kind = Token_char; + return; + } break; case 'b': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'o' && - *(cursor + 3) == 'l') - { - token_stream[(int) index++].kind = Token_bool; - return; - } + *(cursor + 2) == 'o' && + *(cursor + 3) == 'l') + { + token_stream[(int) index++].kind = Token_bool; + return; + } break; case 'e': if (*(cursor + 1) == 'l' && - *(cursor + 2) == 's' && - *(cursor + 3) == 'e') - { - token_stream[(int) index++].kind = Token_else; - return; - } + *(cursor + 2) == 's' && + *(cursor + 3) == 'e') + { + token_stream[(int) index++].kind = Token_else; + return; + } if (*(cursor + 1) == 'm' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 't') - { - token_stream[(int) index++].kind = Token_emit; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 't') + { + token_stream[(int) index++].kind = Token_emit; + return; + } if (*(cursor + 1) == 'n' && - *(cursor + 2) == 'u' && - *(cursor + 3) == 'm') - { - token_stream[(int) index++].kind = Token_enum; - return; - } + *(cursor + 2) == 'u' && + *(cursor + 3) == 'm') + { + token_stream[(int) index++].kind = Token_enum; + return; + } break; case 'g': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'o') - { - token_stream[(int) index++].kind = Token_goto; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'o') + { + token_stream[(int) index++].kind = Token_goto; + return; + } break; case 'l': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'n' && - *(cursor + 3) == 'g') - { - token_stream[(int) index++].kind = Token_long; - return; - } + *(cursor + 2) == 'n' && + *(cursor + 3) == 'g') + { + token_stream[(int) index++].kind = Token_long; + return; + } break; case 't': if (*(cursor + 1) == 'h' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 's') - { - token_stream[(int) index++].kind = Token_this; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 's') + { + token_stream[(int) index++].kind = Token_this; + return; + } break; case 'v': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 'd') - { - token_stream[(int) index++].kind = Token_void; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 'd') + { + token_stream[(int) index++].kind = Token_void; + return; + } break; } @@ -1041,138 +1041,138 @@ void Lexer::scanKeyword5() { case 'c': if (*(cursor + 1) == 'a' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'c' && - *(cursor + 4) == 'h') - { - token_stream[(int) index++].kind = Token_catch; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'c' && + *(cursor + 4) == 'h') + { + token_stream[(int) index++].kind = Token_catch; + return; + } if (*(cursor + 1) == 'l' && - *(cursor + 2) == 'a' && - *(cursor + 3) == 's' && - *(cursor + 4) == 's') - { - token_stream[(int) index++].kind = Token_class; - return; - } + *(cursor + 2) == 'a' && + *(cursor + 3) == 's' && + *(cursor + 4) == 's') + { + token_stream[(int) index++].kind = Token_class; + return; + } if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'm' && - *(cursor + 3) == 'p' && - *(cursor + 4) == 'l') - { - token_stream[(int) index++].kind = Token_compl; - return; - } + *(cursor + 2) == 'm' && + *(cursor + 3) == 'p' && + *(cursor + 4) == 'l') + { + token_stream[(int) index++].kind = Token_compl; + return; + } if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'n' && - *(cursor + 3) == 's' && - *(cursor + 4) == 't') - { - token_stream[(int) index++].kind = Token_const; - return; - } + *(cursor + 2) == 'n' && + *(cursor + 3) == 's' && + *(cursor + 4) == 't') + { + token_stream[(int) index++].kind = Token_const; + return; + } break; case 'b': if (*(cursor + 1) == 'i' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'o' && - *(cursor + 4) == 'r') - { - token_stream[(int) index++].kind = Token_bitor; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'o' && + *(cursor + 4) == 'r') + { + token_stream[(int) index++].kind = Token_bitor; + return; + } if (*(cursor + 1) == 'r' && - *(cursor + 2) == 'e' && - *(cursor + 3) == 'a' && - *(cursor + 4) == 'k') - { - token_stream[(int) index++].kind = Token_break; - return; - } + *(cursor + 2) == 'e' && + *(cursor + 3) == 'a' && + *(cursor + 4) == 'k') + { + token_stream[(int) index++].kind = Token_break; + return; + } break; case 'f': if (*(cursor + 1) == 'l' && - *(cursor + 2) == 'o' && - *(cursor + 3) == 'a' && - *(cursor + 4) == 't') - { - token_stream[(int) index++].kind = Token_float; - return; - } + *(cursor + 2) == 'o' && + *(cursor + 3) == 'a' && + *(cursor + 4) == 't') + { + token_stream[(int) index++].kind = Token_float; + return; + } break; case 'o': if (*(cursor + 1) == 'r' && - *(cursor + 2) == '_' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 'q') - { - token_stream[(int) index++].kind = Token_or_eq; - return; - } + *(cursor + 2) == '_' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 'q') + { + token_stream[(int) index++].kind = Token_or_eq; + return; + } break; case 's': if (*(cursor + 1) == 'h' && - *(cursor + 2) == 'o' && - *(cursor + 3) == 'r' && - *(cursor + 4) == 't') - { - token_stream[(int) index++].kind = Token_short; - return; - } + *(cursor + 2) == 'o' && + *(cursor + 3) == 'r' && + *(cursor + 4) == 't') + { + token_stream[(int) index++].kind = Token_short; + return; + } if (*(cursor + 1) == 'l' && - *(cursor + 2) == 'o' && - *(cursor + 3) == 't' && - *(cursor + 4) == 's') - { - token_stream[(int) index++].kind = Token_slots; - return; - } + *(cursor + 2) == 'o' && + *(cursor + 3) == 't' && + *(cursor + 4) == 's') + { + token_stream[(int) index++].kind = Token_slots; + return; + } break; case 'u': if (*(cursor + 1) == 'n' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 'o' && - *(cursor + 4) == 'n') - { - token_stream[(int) index++].kind = Token_union; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 'o' && + *(cursor + 4) == 'n') + { + token_stream[(int) index++].kind = Token_union; + return; + } if (*(cursor + 1) == 's' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 'n' && - *(cursor + 4) == 'g') - { - token_stream[(int) index++].kind = Token_using; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 'n' && + *(cursor + 4) == 'g') + { + token_stream[(int) index++].kind = Token_using; + return; + } break; case 't': if (*(cursor + 1) == 'h' && - *(cursor + 2) == 'r' && - *(cursor + 3) == 'o' && - *(cursor + 4) == 'w') - { - token_stream[(int) index++].kind = Token_throw; - return; - } + *(cursor + 2) == 'r' && + *(cursor + 3) == 'o' && + *(cursor + 4) == 'w') + { + token_stream[(int) index++].kind = Token_throw; + return; + } break; case 'w': if (*(cursor + 1) == 'h' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 'l' && - *(cursor + 4) == 'e') - { - token_stream[(int) index++].kind = Token_while; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 'l' && + *(cursor + 4) == 'e') + { + token_stream[(int) index++].kind = Token_while; + return; + } break; } @@ -1185,224 +1185,224 @@ void Lexer::scanKeyword6() { case 'a': if (*(cursor + 1) == 'n' && - *(cursor + 2) == 'd' && - *(cursor + 3) == '_' && - *(cursor + 4) == 'e' && - *(cursor + 5) == 'q') - { - token_stream[(int) index++].kind = Token_and_eq; - return; - } + *(cursor + 2) == 'd' && + *(cursor + 3) == '_' && + *(cursor + 4) == 'e' && + *(cursor + 5) == 'q') + { + token_stream[(int) index++].kind = Token_and_eq; + return; + } break; case 'b': if (*(cursor + 1) == 'i' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'a' && - *(cursor + 4) == 'n' && - *(cursor + 5) == 'd') - { - token_stream[(int) index++].kind = Token_bitand; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'a' && + *(cursor + 4) == 'n' && + *(cursor + 5) == 'd') + { + token_stream[(int) index++].kind = Token_bitand; + return; + } break; case 'e': if (*(cursor + 1) == 'x' && - *(cursor + 2) == 'p' && - *(cursor + 3) == 'o' && - *(cursor + 4) == 'r' && - *(cursor + 5) == 't') - { - token_stream[(int) index++].kind = Token_export; - return; - } + *(cursor + 2) == 'p' && + *(cursor + 3) == 'o' && + *(cursor + 4) == 'r' && + *(cursor + 5) == 't') + { + token_stream[(int) index++].kind = Token_export; + return; + } if (*(cursor + 1) == 'x' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 'r' && - *(cursor + 5) == 'n') - { - token_stream[(int) index++].kind = Token_extern; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 'r' && + *(cursor + 5) == 'n') + { + token_stream[(int) index++].kind = Token_extern; + return; + } break; case 'd': if (*(cursor + 1) == 'e' && - *(cursor + 2) == 'l' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 't' && - *(cursor + 5) == 'e') - { - token_stream[(int) index++].kind = Token_delete; - return; - } + *(cursor + 2) == 'l' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 't' && + *(cursor + 5) == 'e') + { + token_stream[(int) index++].kind = Token_delete; + return; + } if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'u' && - *(cursor + 3) == 'b' && - *(cursor + 4) == 'l' && - *(cursor + 5) == 'e') - { - token_stream[(int) index++].kind = Token_double; - return; - } + *(cursor + 2) == 'u' && + *(cursor + 3) == 'b' && + *(cursor + 4) == 'l' && + *(cursor + 5) == 'e') + { + token_stream[(int) index++].kind = Token_double; + return; + } break; case 'f': if (*(cursor + 1) == 'r' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 'n' && - *(cursor + 5) == 'd') - { - token_stream[(int) index++].kind = Token_friend; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 'n' && + *(cursor + 5) == 'd') + { + token_stream[(int) index++].kind = Token_friend; + return; + } break; case 'i': if (*(cursor + 1) == 'n' && - *(cursor + 2) == 'l' && - *(cursor + 3) == 'i' && - *(cursor + 4) == 'n' && - *(cursor + 5) == 'e') - { - token_stream[(int) index++].kind = Token_inline; - return; - } + *(cursor + 2) == 'l' && + *(cursor + 3) == 'i' && + *(cursor + 4) == 'n' && + *(cursor + 5) == 'e') + { + token_stream[(int) index++].kind = Token_inline; + return; + } break; case 'K': if (*(cursor + 1) == '_' && - *(cursor + 2) == 'D' && - *(cursor + 3) == 'C' && - *(cursor + 4) == 'O' && - *(cursor + 5) == 'P') - { - token_stream[(int) index++].kind = Token_K_DCOP; - return; - } + *(cursor + 2) == 'D' && + *(cursor + 3) == 'C' && + *(cursor + 4) == 'O' && + *(cursor + 5) == 'P') + { + token_stream[(int) index++].kind = Token_K_DCOP; + return; + } break; case 'n': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 't' && - *(cursor + 3) == '_' && - *(cursor + 4) == 'e' && - *(cursor + 5) == 'q') - { - token_stream[(int) index++].kind = Token_not_eq; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == '_' && + *(cursor + 4) == 'e' && + *(cursor + 5) == 'q') + { + token_stream[(int) index++].kind = Token_not_eq; + return; + } break; case 'p': if (*(cursor + 1) == 'u' && - *(cursor + 2) == 'b' && - *(cursor + 3) == 'l' && - *(cursor + 4) == 'i' && - *(cursor + 5) == 'c') - { - token_stream[(int) index++].kind = Token_public; - return; - } + *(cursor + 2) == 'b' && + *(cursor + 3) == 'l' && + *(cursor + 4) == 'i' && + *(cursor + 5) == 'c') + { + token_stream[(int) index++].kind = Token_public; + return; + } break; case 's': if (*(cursor + 1) == 'i' && - *(cursor + 2) == 'g' && - *(cursor + 3) == 'n' && - *(cursor + 4) == 'e' && - *(cursor + 5) == 'd') - { - token_stream[(int) index++].kind = Token_signed; - return; - } + *(cursor + 2) == 'g' && + *(cursor + 3) == 'n' && + *(cursor + 4) == 'e' && + *(cursor + 5) == 'd') + { + token_stream[(int) index++].kind = Token_signed; + return; + } if (*(cursor + 1) == 'i' && - *(cursor + 2) == 'z' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 'o' && - *(cursor + 5) == 'f') - { - token_stream[(int) index++].kind = Token_sizeof; - return; - } + *(cursor + 2) == 'z' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 'o' && + *(cursor + 5) == 'f') + { + token_stream[(int) index++].kind = Token_sizeof; + return; + } if (*(cursor + 1) == 't' && - *(cursor + 2) == 'a' && - *(cursor + 3) == 't' && - *(cursor + 4) == 'i' && - *(cursor + 5) == 'c') - { - token_stream[(int) index++].kind = Token_static; - return; - } + *(cursor + 2) == 'a' && + *(cursor + 3) == 't' && + *(cursor + 4) == 'i' && + *(cursor + 5) == 'c') + { + token_stream[(int) index++].kind = Token_static; + return; + } if (*(cursor + 1) == 't' && - *(cursor + 2) == 'r' && - *(cursor + 3) == 'u' && - *(cursor + 4) == 'c' && - *(cursor + 5) == 't') - { - token_stream[(int) index++].kind = Token_struct; - return; - } + *(cursor + 2) == 'r' && + *(cursor + 3) == 'u' && + *(cursor + 4) == 'c' && + *(cursor + 5) == 't') + { + token_stream[(int) index++].kind = Token_struct; + return; + } if (*(cursor + 1) == 'w' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 't' && - *(cursor + 4) == 'c' && - *(cursor + 5) == 'h') - { - token_stream[(int) index++].kind = Token_switch; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 't' && + *(cursor + 4) == 'c' && + *(cursor + 5) == 'h') + { + token_stream[(int) index++].kind = Token_switch; + return; + } break; case 'r': if (*(cursor + 1) == 'e' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'u' && - *(cursor + 4) == 'r' && - *(cursor + 5) == 'n') - { - token_stream[(int) index++].kind = Token_return; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'u' && + *(cursor + 4) == 'r' && + *(cursor + 5) == 'n') + { + token_stream[(int) index++].kind = Token_return; + return; + } break; case 't': if (*(cursor + 1) == 'y' && - *(cursor + 2) == 'p' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 'i' && - *(cursor + 5) == 'd') - { - token_stream[(int) index++].kind = Token_typeid; - return; - } + *(cursor + 2) == 'p' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 'i' && + *(cursor + 5) == 'd') + { + token_stream[(int) index++].kind = Token_typeid; + return; + } break; case 'x': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'r' && - *(cursor + 3) == '_' && - *(cursor + 4) == 'e' && - *(cursor + 5) == 'q') - { - token_stream[(int) index++].kind = Token_xor_eq; - return; - } + *(cursor + 2) == 'r' && + *(cursor + 3) == '_' && + *(cursor + 4) == 'e' && + *(cursor + 5) == 'q') + { + token_stream[(int) index++].kind = Token_xor_eq; + return; + } break; case 'k': if (*(cursor + 1) == '_' && - *(cursor + 2) == 'd' && - *(cursor + 3) == 'c' && - *(cursor + 4) == 'o' && - *(cursor + 5) == 'p') - { - token_stream[(int) index++].kind = Token_k_dcop; - return; - } + *(cursor + 2) == 'd' && + *(cursor + 3) == 'c' && + *(cursor + 4) == 'o' && + *(cursor + 5) == 'p') + { + token_stream[(int) index++].kind = Token_k_dcop; + return; + } break; case 'Q': if (*(cursor + 1) == '_' && @@ -1426,78 +1426,78 @@ void Lexer::scanKeyword7() { case 'd': if (*(cursor + 1) == 'e' && - *(cursor + 2) == 'f' && - *(cursor + 3) == 'a' && - *(cursor + 4) == 'u' && - *(cursor + 5) == 'l' && - *(cursor + 6) == 't') - { - token_stream[(int) index++].kind = Token_default; - return; - } + *(cursor + 2) == 'f' && + *(cursor + 3) == 'a' && + *(cursor + 4) == 'u' && + *(cursor + 5) == 'l' && + *(cursor + 6) == 't') + { + token_stream[(int) index++].kind = Token_default; + return; + } break; case 'm': if (*(cursor + 1) == 'u' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'a' && - *(cursor + 4) == 'b' && - *(cursor + 5) == 'l' && - *(cursor + 6) == 'e') - { - token_stream[(int) index++].kind = Token_mutable; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'a' && + *(cursor + 4) == 'b' && + *(cursor + 5) == 'l' && + *(cursor + 6) == 'e') + { + token_stream[(int) index++].kind = Token_mutable; + return; + } break; case 'p': if (*(cursor + 1) == 'r' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 'v' && - *(cursor + 4) == 'a' && - *(cursor + 5) == 't' && - *(cursor + 6) == 'e') - { - token_stream[(int) index++].kind = Token_private; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 'v' && + *(cursor + 4) == 'a' && + *(cursor + 5) == 't' && + *(cursor + 6) == 'e') + { + token_stream[(int) index++].kind = Token_private; + return; + } break; case 's': if (*(cursor + 1) == 'i' && - *(cursor + 2) == 'g' && - *(cursor + 3) == 'n' && - *(cursor + 4) == 'a' && - *(cursor + 5) == 'l' && - *(cursor + 6) == 's') - { - token_stream[(int) index++].kind = Token_signals; - return; - } + *(cursor + 2) == 'g' && + *(cursor + 3) == 'n' && + *(cursor + 4) == 'a' && + *(cursor + 5) == 'l' && + *(cursor + 6) == 's') + { + token_stream[(int) index++].kind = Token_signals; + return; + } break; case 't': if (*(cursor + 1) == 'y' && - *(cursor + 2) == 'p' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 'd' && - *(cursor + 5) == 'e' && - *(cursor + 6) == 'f') - { - token_stream[(int) index++].kind = Token_typedef; - return; - } + *(cursor + 2) == 'p' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 'd' && + *(cursor + 5) == 'e' && + *(cursor + 6) == 'f') + { + token_stream[(int) index++].kind = Token_typedef; + return; + } break; case 'v': if (*(cursor + 1) == 'i' && - *(cursor + 2) == 'r' && - *(cursor + 3) == 't' && - *(cursor + 4) == 'u' && - *(cursor + 5) == 'a' && - *(cursor + 6) == 'l') - { - token_stream[(int) index++].kind = Token_virtual; - return; - } + *(cursor + 2) == 'r' && + *(cursor + 3) == 't' && + *(cursor + 4) == 'u' && + *(cursor + 5) == 'a' && + *(cursor + 6) == 'l') + { + token_stream[(int) index++].kind = Token_virtual; + return; + } break; case 'Q': @@ -1523,153 +1523,153 @@ void Lexer::scanKeyword8() { case '_': if (*(cursor + 1) == '_' && - *(cursor + 2) == 't' && - *(cursor + 3) == 'y' && - *(cursor + 4) == 'p' && - *(cursor + 5) == 'e' && - *(cursor + 6) == 'o' && - *(cursor + 7) == 'f') - { - token_stream[(int) index++].kind = Token___typeof; - return; - } + *(cursor + 2) == 't' && + *(cursor + 3) == 'y' && + *(cursor + 4) == 'p' && + *(cursor + 5) == 'e' && + *(cursor + 6) == 'o' && + *(cursor + 7) == 'f') + { + token_stream[(int) index++].kind = Token___typeof; + return; + } break; case 'c': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'n' && - *(cursor + 3) == 't' && - *(cursor + 4) == 'i' && - *(cursor + 5) == 'n' && - *(cursor + 6) == 'u' && - *(cursor + 7) == 'e') - { - token_stream[(int) index++].kind = Token_continue; - return; - } + *(cursor + 2) == 'n' && + *(cursor + 3) == 't' && + *(cursor + 4) == 'i' && + *(cursor + 5) == 'n' && + *(cursor + 6) == 'u' && + *(cursor + 7) == 'e') + { + token_stream[(int) index++].kind = Token_continue; + return; + } break; case 'd': if (*(cursor + 1) == 'e' && - *(cursor + 2) == 'c' && - *(cursor + 3) == 'l' && - *(cursor + 4) == 't' && - *(cursor + 5) == 'y' && - *(cursor + 6) == 'p' && - *(cursor + 7) == 'e') - { - token_stream[(int) index++].kind = Token_decltype; - return; - } + *(cursor + 2) == 'c' && + *(cursor + 3) == 'l' && + *(cursor + 4) == 't' && + *(cursor + 5) == 'y' && + *(cursor + 6) == 'p' && + *(cursor + 7) == 'e') + { + token_stream[(int) index++].kind = Token_decltype; + return; + } break; case 'e': if (*(cursor + 1) == 'x' && - *(cursor + 2) == 'p' && - *(cursor + 3) == 'l' && - *(cursor + 4) == 'i' && - *(cursor + 5) == 'c' && - *(cursor + 6) == 'i' && - *(cursor + 7) == 't') - { - token_stream[(int) index++].kind = Token_explicit; - return; - } + *(cursor + 2) == 'p' && + *(cursor + 3) == 'l' && + *(cursor + 4) == 'i' && + *(cursor + 5) == 'c' && + *(cursor + 6) == 'i' && + *(cursor + 7) == 't') + { + token_stream[(int) index++].kind = Token_explicit; + return; + } break; case 'o': if (*(cursor + 1) == 'p' && - *(cursor + 2) == 'e' && - *(cursor + 3) == 'r' && - *(cursor + 4) == 'a' && - *(cursor + 5) == 't' && - *(cursor + 6) == 'o' && - *(cursor + 7) == 'r') - { - token_stream[(int) index++].kind = Token_operator; - return; - } + *(cursor + 2) == 'e' && + *(cursor + 3) == 'r' && + *(cursor + 4) == 'a' && + *(cursor + 5) == 't' && + *(cursor + 6) == 'o' && + *(cursor + 7) == 'r') + { + token_stream[(int) index++].kind = Token_operator; + return; + } break; case 'Q': if (*(cursor + 1) == '_' && - *(cursor + 2) == 'O' && - *(cursor + 3) == 'B' && - *(cursor + 4) == 'J' && - *(cursor + 5) == 'E' && - *(cursor + 6) == 'C' && - *(cursor + 7) == 'T') - { - token_stream[(int) index++].kind = Token_Q_OBJECT; - return; - } + *(cursor + 2) == 'O' && + *(cursor + 3) == 'B' && + *(cursor + 4) == 'J' && + *(cursor + 5) == 'E' && + *(cursor + 6) == 'C' && + *(cursor + 7) == 'T') + { + token_stream[(int) index++].kind = Token_Q_OBJECT; + return; + } break; case 'r': if (*(cursor + 1) == 'e' && - *(cursor + 2) == 'g' && - *(cursor + 3) == 'i' && - *(cursor + 4) == 's' && - *(cursor + 5) == 't' && - *(cursor + 6) == 'e' && - *(cursor + 7) == 'r') - { - token_stream[(int) index++].kind = Token_register; - return; - } + *(cursor + 2) == 'g' && + *(cursor + 3) == 'i' && + *(cursor + 4) == 's' && + *(cursor + 5) == 't' && + *(cursor + 6) == 'e' && + *(cursor + 7) == 'r') + { + token_stream[(int) index++].kind = Token_register; + return; + } break; case 'u': if (*(cursor + 1) == 'n' && - *(cursor + 2) == 's' && - *(cursor + 3) == 'i' && - *(cursor + 4) == 'g' && - *(cursor + 5) == 'n' && - *(cursor + 6) == 'e' && - *(cursor + 7) == 'd') - { - token_stream[(int) index++].kind = Token_unsigned; - return; - } + *(cursor + 2) == 's' && + *(cursor + 3) == 'i' && + *(cursor + 4) == 'g' && + *(cursor + 5) == 'n' && + *(cursor + 6) == 'e' && + *(cursor + 7) == 'd') + { + token_stream[(int) index++].kind = Token_unsigned; + return; + } break; case 't': if (*(cursor + 1) == 'e' && - *(cursor + 2) == 'm' && - *(cursor + 3) == 'p' && - *(cursor + 4) == 'l' && - *(cursor + 5) == 'a' && - *(cursor + 6) == 't' && - *(cursor + 7) == 'e') - { - token_stream[(int) index++].kind = Token_template; - return; - } + *(cursor + 2) == 'm' && + *(cursor + 3) == 'p' && + *(cursor + 4) == 'l' && + *(cursor + 5) == 'a' && + *(cursor + 6) == 't' && + *(cursor + 7) == 'e') + { + token_stream[(int) index++].kind = Token_template; + return; + } if (*(cursor + 1) == 'y' && - *(cursor + 2) == 'p' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 'n' && - *(cursor + 5) == 'a' && - *(cursor + 6) == 'm' && - *(cursor + 7) == 'e') - { - token_stream[(int) index++].kind = Token_typename; - return; - } + *(cursor + 2) == 'p' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 'n' && + *(cursor + 5) == 'a' && + *(cursor + 6) == 'm' && + *(cursor + 7) == 'e') + { + token_stream[(int) index++].kind = Token_typename; + return; + } break; case 'v': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'l' && - *(cursor + 3) == 'a' && - *(cursor + 4) == 't' && - *(cursor + 5) == 'i' && - *(cursor + 6) == 'l' && - *(cursor + 7) == 'e') - { - token_stream[(int) index++].kind = Token_volatile; - return; - } + *(cursor + 2) == 'l' && + *(cursor + 3) == 'a' && + *(cursor + 4) == 't' && + *(cursor + 5) == 'i' && + *(cursor + 6) == 'l' && + *(cursor + 7) == 'e') + { + token_stream[(int) index++].kind = Token_volatile; + return; + } break; } @@ -1682,47 +1682,47 @@ void Lexer::scanKeyword9() { case 'c': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'n' && - *(cursor + 3) == 's' && - *(cursor + 4) == 't' && - *(cursor + 5) == 'e' && - *(cursor + 6) == 'x' && - *(cursor + 7) == 'p' && - *(cursor + 8) == 'r') - { - token_stream[(int) index++].kind = Token_constexpr; - return; - } + *(cursor + 2) == 'n' && + *(cursor + 3) == 's' && + *(cursor + 4) == 't' && + *(cursor + 5) == 'e' && + *(cursor + 6) == 'x' && + *(cursor + 7) == 'p' && + *(cursor + 8) == 'r') + { + token_stream[(int) index++].kind = Token_constexpr; + return; + } break; case 'p': if (*(cursor + 1) == 'r' && - *(cursor + 2) == 'o' && - *(cursor + 3) == 't' && - *(cursor + 4) == 'e' && - *(cursor + 5) == 'c' && - *(cursor + 6) == 't' && - *(cursor + 7) == 'e' && - *(cursor + 8) == 'd') - { - token_stream[(int) index++].kind = Token_protected; - return; - } + *(cursor + 2) == 'o' && + *(cursor + 3) == 't' && + *(cursor + 4) == 'e' && + *(cursor + 5) == 'c' && + *(cursor + 6) == 't' && + *(cursor + 7) == 'e' && + *(cursor + 8) == 'd') + { + token_stream[(int) index++].kind = Token_protected; + return; + } break; case 'n': if (*(cursor + 1) == 'a' && - *(cursor + 2) == 'm' && - *(cursor + 3) == 'e' && - *(cursor + 4) == 's' && - *(cursor + 5) == 'p' && - *(cursor + 6) == 'a' && - *(cursor + 7) == 'c' && - *(cursor + 8) == 'e') - { - token_stream[(int) index++].kind = Token_namespace; - return; - } + *(cursor + 2) == 'm' && + *(cursor + 3) == 'e' && + *(cursor + 4) == 's' && + *(cursor + 5) == 'p' && + *(cursor + 6) == 'a' && + *(cursor + 7) == 'c' && + *(cursor + 8) == 'e') + { + token_stream[(int) index++].kind = Token_namespace; + return; + } break; } @@ -1735,18 +1735,18 @@ void Lexer::scanKeyword10() { case 'c': if (*(cursor + 1) == 'o' && - *(cursor + 2) == 'n' && - *(cursor + 3) == 's' && - *(cursor + 4) == 't' && - *(cursor + 5) == '_' && - *(cursor + 6) == 'c' && - *(cursor + 7) == 'a' && - *(cursor + 8) == 's' && - *(cursor + 9) == 't') - { - token_stream[(int) index++].kind = Token_const_cast; - return; - } + *(cursor + 2) == 'n' && + *(cursor + 3) == 's' && + *(cursor + 4) == 't' && + *(cursor + 5) == '_' && + *(cursor + 6) == 'c' && + *(cursor + 7) == 'a' && + *(cursor + 8) == 's' && + *(cursor + 9) == 't') + { + token_stream[(int) index++].kind = Token_const_cast; + return; + } break; case 'Q': @@ -1776,36 +1776,36 @@ void Lexer::scanKeyword11() { case 'Q': if (*(cursor + 1) == '_' && - *(cursor + 2) == 'I' && - *(cursor + 3) == 'N' && - *(cursor + 4) == 'V' && - *(cursor + 5) == 'O' && - *(cursor + 6) == 'K' && - *(cursor + 7) == 'A' && - *(cursor + 8) == 'B' && - *(cursor + 9) == 'L' && - *(cursor + 10) == 'E') - { - token_stream[(int) index++].kind = Token_Q_INVOKABLE; - return; - } + *(cursor + 2) == 'I' && + *(cursor + 3) == 'N' && + *(cursor + 4) == 'V' && + *(cursor + 5) == 'O' && + *(cursor + 6) == 'K' && + *(cursor + 7) == 'A' && + *(cursor + 8) == 'B' && + *(cursor + 9) == 'L' && + *(cursor + 10) == 'E') + { + token_stream[(int) index++].kind = Token_Q_INVOKABLE; + return; + } break; case 's': if (*(cursor + 1) == 't' && - *(cursor + 2) == 'a' && - *(cursor + 3) == 't' && - *(cursor + 4) == 'i' && - *(cursor + 5) == 'c' && - *(cursor + 6) == '_' && - *(cursor + 7) == 'c' && - *(cursor + 8) == 'a' && - *(cursor + 9) == 's' && - *(cursor + 10) == 't') - { - token_stream[(int) index++].kind = Token_static_cast; - return; - } + *(cursor + 2) == 'a' && + *(cursor + 3) == 't' && + *(cursor + 4) == 'i' && + *(cursor + 5) == 'c' && + *(cursor + 6) == '_' && + *(cursor + 7) == 'c' && + *(cursor + 8) == 'a' && + *(cursor + 9) == 's' && + *(cursor + 10) == 't') + { + token_stream[(int) index++].kind = Token_static_cast; + return; + } break; } @@ -1818,20 +1818,20 @@ void Lexer::scanKeyword12() { case 'd': if (*(cursor + 1) == 'y' && - *(cursor + 2) == 'n' && - *(cursor + 3) == 'a' && - *(cursor + 4) == 'm' && - *(cursor + 5) == 'i' && - *(cursor + 6) == 'c' && - *(cursor + 7) == '_' && - *(cursor + 8) == 'c' && - *(cursor + 9) == 'a' && - *(cursor + 10) == 's' && - *(cursor + 11) == 't') - { - token_stream[(int) index++].kind = Token_dynamic_cast; - return; - } + *(cursor + 2) == 'n' && + *(cursor + 3) == 'a' && + *(cursor + 4) == 'm' && + *(cursor + 5) == 'i' && + *(cursor + 6) == 'c' && + *(cursor + 7) == '_' && + *(cursor + 8) == 'c' && + *(cursor + 9) == 'a' && + *(cursor + 10) == 's' && + *(cursor + 11) == 't') + { + token_stream[(int) index++].kind = Token_dynamic_cast; + return; + } break; } @@ -1844,21 +1844,21 @@ void Lexer::scanKeyword13() { case '_': if (*(cursor + 1) == '_' && - *(cursor + 2) == 'a' && - *(cursor + 3) == 't' && - *(cursor + 4) == 't' && - *(cursor + 5) == 'r' && - *(cursor + 6) == 'i' && - *(cursor + 7) == 'b' && - *(cursor + 8) == 'u' && - *(cursor + 9) == 't' && - *(cursor + 10) == 'e' && - *(cursor + 11) == '_' && - *(cursor + 12) == '_') - { - token_stream[(int) index++].kind = Token___attribute__; - return; - } + *(cursor + 2) == 'a' && + *(cursor + 3) == 't' && + *(cursor + 4) == 't' && + *(cursor + 5) == 'r' && + *(cursor + 6) == 'i' && + *(cursor + 7) == 'b' && + *(cursor + 8) == 'u' && + *(cursor + 9) == 't' && + *(cursor + 10) == 'e' && + *(cursor + 11) == '_' && + *(cursor + 12) == '_') + { + token_stream[(int) index++].kind = Token___attribute__; + return; + } break; } token_stream[(int) index++].kind = Token_identifier; @@ -1870,22 +1870,22 @@ void Lexer::scanKeyword14() { case 'k': if (*(cursor + 1) == '_' && - *(cursor + 2) == 'd' && - *(cursor + 3) == 'c' && - *(cursor + 4) == 'o' && - *(cursor + 5) == 'p' && - *(cursor + 6) == '_' && - *(cursor + 7) == 's' && - *(cursor + 8) == 'i' && - *(cursor + 9) == 'g' && - *(cursor + 10) == 'n' && - *(cursor + 11) == 'a' && - *(cursor + 12) == 'l' && - *(cursor + 13) == 's') - { - token_stream[(int) index++].kind = Token_k_dcop_signals; - return; - } + *(cursor + 2) == 'd' && + *(cursor + 3) == 'c' && + *(cursor + 4) == 'o' && + *(cursor + 5) == 'p' && + *(cursor + 6) == '_' && + *(cursor + 7) == 's' && + *(cursor + 8) == 'i' && + *(cursor + 9) == 'g' && + *(cursor + 10) == 'n' && + *(cursor + 11) == 'a' && + *(cursor + 12) == 'l' && + *(cursor + 13) == 's') + { + token_stream[(int) index++].kind = Token_k_dcop_signals; + return; + } break; } token_stream[(int) index++].kind = Token_identifier; @@ -1897,24 +1897,24 @@ void Lexer::scanKeyword16() { case 'r': if (*(cursor + 1) == 'e' && - *(cursor + 2) == 'i' && - *(cursor + 3) == 'n' && - *(cursor + 4) == 't' && - *(cursor + 5) == 'e' && - *(cursor + 6) == 'r' && - *(cursor + 7) == 'p' && - *(cursor + 8) == 'r' && - *(cursor + 9) == 'e' && - *(cursor + 10) == 't' && - *(cursor + 11) == '_' && - *(cursor + 12) == 'c' && - *(cursor + 13) == 'a' && - *(cursor + 14) == 's' && - *(cursor + 15) == 't') - { - token_stream[(int) index++].kind = Token_reinterpret_cast; - return; - } + *(cursor + 2) == 'i' && + *(cursor + 3) == 'n' && + *(cursor + 4) == 't' && + *(cursor + 5) == 'e' && + *(cursor + 6) == 'r' && + *(cursor + 7) == 'p' && + *(cursor + 8) == 'r' && + *(cursor + 9) == 'e' && + *(cursor + 10) == 't' && + *(cursor + 11) == '_' && + *(cursor + 12) == 'c' && + *(cursor + 13) == 'a' && + *(cursor + 14) == 's' && + *(cursor + 15) == 't') + { + token_stream[(int) index++].kind = Token_reinterpret_cast; + return; + } break; } diff --git a/generator/parser/parser.cpp b/generator/parser/parser.cpp index c01c8d753..4986b7078 100644 --- a/generator/parser/parser.cpp +++ b/generator/parser/parser.cpp @@ -1267,7 +1267,7 @@ bool Parser::parseDeclarator(DeclaratorAST *&node) } if (token_stream.lookAhead() == Token___attribute__) { - parse_Attribute__(); + parse_Attribute__(); } } @@ -1796,14 +1796,14 @@ bool Parser::parse_Attribute__() { parseExpression(expr); if (token_stream.lookAhead() != ')') - { - reportError(("')' expected")); - return false; - } + { + reportError(("')' expected")); + return false; + } else - { - token_stream.nextToken(); - } + { + token_stream.nextToken(); + } return true; } diff --git a/generator/parser/rpp/pp-main.cpp b/generator/parser/rpp/pp-main.cpp index 0676a2fee..aaf09e141 100644 --- a/generator/parser/rpp/pp-main.cpp +++ b/generator/parser/rpp/pp-main.cpp @@ -142,19 +142,19 @@ int main (int, char *argv []) opt_pch = true; else if (! strcmp (arg, "-msse")) - { - pp_macro __macro; - __macro.name = pp_symbol::get ("__SSE__", 7); - env.bind (__macro.name, __macro); + { + pp_macro __macro; + __macro.name = pp_symbol::get ("__SSE__", 7); + env.bind (__macro.name, __macro); - __macro.name = pp_symbol::get ("__MMX__", 7); - env.bind (__macro.name, __macro); - } + __macro.name = pp_symbol::get ("__MMX__", 7); + env.bind (__macro.name, __macro); + } else if (! strcmp (arg, "-include")) { if (argv [1]) - include_pch_file = *++argv; + include_pch_file = *++argv; } else if (! strncmp (arg, "-o", 2)) diff --git a/generator/parser/rpp/rpp.pri b/generator/parser/rpp/rpp.pri index 8468bcf97..46f6a98af 100644 --- a/generator/parser/rpp/rpp.pri +++ b/generator/parser/rpp/rpp.pri @@ -1,20 +1,20 @@ SOURCES += \ - $$RXXPATH/rpp/preprocessor.cpp + $$RXXPATH/rpp/preprocessor.cpp HEADERS += \ - $$RXXPATH/rpp/pp-cctype.h \ - $$RXXPATH/rpp/pp-engine-bits.h \ - $$RXXPATH/rpp/pp-engine.h \ - $$RXXPATH/rpp/pp-environment.h \ - $$RXXPATH/rpp/pp-fwd.h \ - $$RXXPATH/rpp/pp-internal.h \ - $$RXXPATH/rpp/pp-iterator.h \ - $$RXXPATH/rpp/pp-macro-expander.h \ - $$RXXPATH/rpp/pp-macro.h \ - $$RXXPATH/rpp/pp-scanner.h \ - $$RXXPATH/rpp/pp-string.h \ - $$RXXPATH/rpp/pp-symbol.h \ - $$RXXPATH/rpp/pp.h \ - $$RXXPATH/rpp/preprocessor.h + $$RXXPATH/rpp/pp-cctype.h \ + $$RXXPATH/rpp/pp-engine-bits.h \ + $$RXXPATH/rpp/pp-engine.h \ + $$RXXPATH/rpp/pp-environment.h \ + $$RXXPATH/rpp/pp-fwd.h \ + $$RXXPATH/rpp/pp-internal.h \ + $$RXXPATH/rpp/pp-iterator.h \ + $$RXXPATH/rpp/pp-macro-expander.h \ + $$RXXPATH/rpp/pp-macro.h \ + $$RXXPATH/rpp/pp-scanner.h \ + $$RXXPATH/rpp/pp-string.h \ + $$RXXPATH/rpp/pp-symbol.h \ + $$RXXPATH/rpp/pp.h \ + $$RXXPATH/rpp/preprocessor.h INCLUDEPATH += $$PWD $$RXXPATH/rpp diff --git a/src/PythonQtClassWrapper.cpp b/src/PythonQtClassWrapper.cpp index dda2bc1fd..ad8f50644 100644 --- a/src/PythonQtClassWrapper.cpp +++ b/src/PythonQtClassWrapper.cpp @@ -112,8 +112,8 @@ static int PythonQtInstanceWrapper_setitem(PyObject* self, PyObject* index, PyOb PythonQtInstanceWrapper* wrapper = (PythonQtInstanceWrapper*)self; bool isSetItem = value; PythonQtMemberInfo opSlot = isSetItem ? - wrapper->classInfo()->member("__setitem__") - : wrapper->classInfo()->member("__delitem__"); + wrapper->classInfo()->member("__setitem__") + : wrapper->classInfo()->member("__delitem__"); if (opSlot._type == PythonQtMemberInfo::Slot) { PyObject* args = PyTuple_New(isSetItem?2:1);