compiler/libec: (#341, #351, #644, #771) Improved enum type matching and type handlin...

[sdk] / compiler / bootstrap / libec / bootstrap / pass15.c

diff --git a/compiler/bootstrap/libec/bootstrap/pass15.c b/compiler/bootstrap/libec/bootstrap/pass15.c
index 3fa1191..41ec3f3 100644 (file)
--- a/compiler/bootstrap/libec/bootstrap/pass15.c
+++ b/compiler/bootstrap/libec/bootstrap/pass15.c
@@ -50,6 +50,8 @@ extern void *  __ecereNameSpace__ecere__com__eSystem_Renew(void *  memory, unsig
 
 extern void *  __ecereNameSpace__ecere__com__eSystem_Renew0(void *  memory, unsigned int size);
 
+extern void __ecereNameSpace__ecere__com__eSystem_Delete(void *  memory);
+
 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__sys__BTNode;
 
 struct __ecereNameSpace__ecere__sys__BTNode;
@@ -389,7 +391,11 @@ struct Identifier * identifier;
 } __attribute__ ((gcc_struct));
 struct Statement * compound;
 struct Instantiation * instance;
+struct
+{
 char *  string;
+unsigned int intlString;
+} __attribute__ ((gcc_struct));
 struct __ecereNameSpace__ecere__sys__OldList *  list;
 struct
 {
@@ -482,6 +488,7 @@ unsigned int isConstant;
 unsigned int addedThis;
 unsigned int needCast;
 unsigned int thisPtr;
+unsigned int opDestType;
 } __attribute__ ((gcc_struct));
 
 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_TemplateDatatype;
@@ -673,7 +680,7 @@ char *  name;
 struct __ecereNameSpace__ecere__sys__OldList methods;
 struct __ecereNameSpace__ecere__sys__OldList properties;
 unsigned int itself;
-unsigned int isRemote;
+int isRemote;
 } __attribute__ ((gcc_struct));
 
 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Symbol;
@@ -845,7 +852,7 @@ unsigned int noExpansion;
 char *  defaultProperty;
 unsigned int comRedefinition;
 int count;
-unsigned int isRemote;
+int isRemote;
 unsigned int internalDecl;
 void *  data;
 unsigned int computeSize;
@@ -868,6 +875,8 @@ unsigned int byValueSystemClass;
 
 extern long long __ecereNameSpace__ecere__com__eClass_GetProperty(struct __ecereNameSpace__ecere__com__Class * _class, char *  name);
 
+extern void __ecereNameSpace__ecere__com__eInstance_FireSelfWatchers(struct __ecereNameSpace__ecere__com__Instance * instance, struct __ecereNameSpace__ecere__com__Property * _property);
+
 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpace__ecere__com__Instance;
 
 struct __ecereNameSpace__ecere__com__Instance
@@ -953,7 +962,7 @@ unsigned long long int strtoull(const char * nptr, char ** endptr, int base);
 
 enum yytokentype
 {
-IDENTIFIER = 258, CONSTANT = 259, STRING_LITERAL = 260, SIZEOF = 261, PTR_OP = 262, INC_OP = 263, DEC_OP = 264, LEFT_OP = 265, RIGHT_OP = 266, LE_OP = 267, GE_OP = 268, EQ_OP = 269, NE_OP = 270, AND_OP = 271, OR_OP = 272, MUL_ASSIGN = 273, DIV_ASSIGN = 274, MOD_ASSIGN = 275, ADD_ASSIGN = 276, SUB_ASSIGN = 277, LEFT_ASSIGN = 278, RIGHT_ASSIGN = 279, AND_ASSIGN = 280, XOR_ASSIGN = 281, OR_ASSIGN = 282, TYPE_NAME = 283, TYPEDEF = 284, EXTERN = 285, STATIC = 286, AUTO = 287, REGISTER = 288, CHAR = 289, SHORT = 290, INT = 291, UINT = 292, INT64 = 293, LONG = 294, SIGNED = 295, UNSIGNED = 296, FLOAT = 297, DOUBLE = 298, CONST = 299, VOLATILE = 300, VOID = 301, VALIST = 302, STRUCT = 303, UNION = 304, ENUM = 305, ELLIPSIS = 306, CASE = 307, DEFAULT = 308, IF = 309, SWITCH = 310, WHILE = 311, DO = 312, FOR = 313, GOTO = 314, CONTINUE = 315, BREAK = 316, RETURN = 317, IFX = 318, ELSE = 319, CLASS = 320, THISCLASS = 321, CLASS_NAME = 322, PROPERTY = 323, SETPROP = 324, GETPROP = 325, NEWOP = 326, RENEW = 327, DELETE = 328, EXT_DECL = 329, EXT_STORAGE = 330, IMPORT = 331, DEFINE = 332, VIRTUAL = 333, ATTRIB = 334, PUBLIC = 335, PRIVATE = 336, TYPED_OBJECT = 337, ANY_OBJECT = 338, _INCREF = 339, EXTENSION = 340, ASM = 341, TYPEOF = 342, WATCH = 343, STOPWATCHING = 344, FIREWATCHERS = 345, WATCHABLE = 346, CLASS_DESIGNER = 347, CLASS_NO_EXPANSION = 348, CLASS_FIXED = 349, ISPROPSET = 350, CLASS_DEFAULT_PROPERTY = 351, PROPERTY_CATEGORY = 352, CLASS_DATA = 353, CLASS_PROPERTY = 354, SUBCLASS = 355, NAMESPACE = 356, NEW0OP = 357, RENEW0 = 358, VAARG = 359, DBTABLE = 360, DBFIELD = 361, DBINDEX = 362, DATABASE_OPEN = 363, ALIGNOF = 364, ATTRIB_DEP = 365, __ATTRIB = 366, BOOL = 367, _BOOL = 368, _COMPLEX = 369, _IMAGINARY = 370, RESTRICT = 371
+IDENTIFIER = 258, CONSTANT = 259, STRING_LITERAL = 260, SIZEOF = 261, PTR_OP = 262, INC_OP = 263, DEC_OP = 264, LEFT_OP = 265, RIGHT_OP = 266, LE_OP = 267, GE_OP = 268, EQ_OP = 269, NE_OP = 270, AND_OP = 271, OR_OP = 272, MUL_ASSIGN = 273, DIV_ASSIGN = 274, MOD_ASSIGN = 275, ADD_ASSIGN = 276, SUB_ASSIGN = 277, LEFT_ASSIGN = 278, RIGHT_ASSIGN = 279, AND_ASSIGN = 280, XOR_ASSIGN = 281, OR_ASSIGN = 282, TYPE_NAME = 283, TYPEDEF = 284, EXTERN = 285, STATIC = 286, AUTO = 287, REGISTER = 288, CHAR = 289, SHORT = 290, INT = 291, UINT = 292, INT64 = 293, LONG = 294, SIGNED = 295, UNSIGNED = 296, FLOAT = 297, DOUBLE = 298, CONST = 299, VOLATILE = 300, VOID = 301, VALIST = 302, STRUCT = 303, UNION = 304, ENUM = 305, ELLIPSIS = 306, CASE = 307, DEFAULT = 308, IF = 309, SWITCH = 310, WHILE = 311, DO = 312, FOR = 313, GOTO = 314, CONTINUE = 315, BREAK = 316, RETURN = 317, IFX = 318, ELSE = 319, CLASS = 320, THISCLASS = 321, CLASS_NAME = 322, PROPERTY = 323, SETPROP = 324, GETPROP = 325, NEWOP = 326, RENEW = 327, DELETE = 328, EXT_DECL = 329, EXT_STORAGE = 330, IMPORT = 331, DEFINE = 332, VIRTUAL = 333, ATTRIB = 334, PUBLIC = 335, PRIVATE = 336, TYPED_OBJECT = 337, ANY_OBJECT = 338, _INCREF = 339, EXTENSION = 340, ASM = 341, TYPEOF = 342, WATCH = 343, STOPWATCHING = 344, FIREWATCHERS = 345, WATCHABLE = 346, CLASS_DESIGNER = 347, CLASS_NO_EXPANSION = 348, CLASS_FIXED = 349, ISPROPSET = 350, CLASS_DEFAULT_PROPERTY = 351, PROPERTY_CATEGORY = 352, CLASS_DATA = 353, CLASS_PROPERTY = 354, SUBCLASS = 355, NAMESPACE = 356, NEW0OP = 357, RENEW0 = 358, VAARG = 359, DBTABLE = 360, DBFIELD = 361, DBINDEX = 362, DATABASE_OPEN = 363, ALIGNOF = 364, ATTRIB_DEP = 365, __ATTRIB = 366, BOOL = 367, _BOOL = 368, _COMPLEX = 369, _IMAGINARY = 370, RESTRICT = 371, THREAD = 372
 };
 
 typedef union YYSTYPE
@@ -1029,6 +1038,7 @@ struct AsmField * next;
 struct Location loc;
 char *  command;
 struct Expression * expression;
+struct Identifier * symbolic;
 } __attribute__ ((gcc_struct));
 
 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_Attribute;
@@ -1103,9 +1113,13 @@ struct Statement * getStmt;
 struct Statement * setStmt;
 struct Statement * issetStmt;
 struct Symbol * symbol;
-unsigned int conversion;
-unsigned int isWatchable;
 struct Expression * category;
+struct
+{
+unsigned int conversion : 1;
+unsigned int isWatchable : 1;
+unsigned int isDBProp : 1;
+} __attribute__ ((gcc_struct));
 } __attribute__ ((gcc_struct));
 
 extern struct __ecereNameSpace__ecere__com__Class * __ecereClass_PropertyWatch;
@@ -1208,6 +1222,8 @@ unsigned int thisClassParams = 0x1;
 
 unsigned int internalValueCounter;
 
+extern unsigned int outputLineNumbers;
+
 extern void OutputExpression(struct Expression * exp, struct __ecereNameSpace__ecere__com__Instance * f);
 
 extern size_t strlen(const char * );
@@ -1227,7 +1243,9 @@ void PrintExpression(struct Expression * exp, char * string)
 {
 struct __ecereNameSpace__ecere__com__Instance * f = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__sys__TempFile);
 int count;
+unsigned int backOutputLineNumbers = outputLineNumbers;
 
+outputLineNumbers = 0x0;
 if(exp)
 OutputExpression(exp, f);
 ((unsigned int (*)(struct __ecereNameSpace__ecere__com__Instance *, int pos, int mode))__extension__ ({
@@ -1243,6 +1261,7 @@ __internal_ClassInst ? __internal_ClassInst->_vTbl : __ecereClass___ecereNameSpa
 })[__ecereVMethodID___ecereNameSpace__ecere__sys__File_Read])(f, string + count, 1, 1023);
 string[count] = '\0';
 (__ecereNameSpace__ecere__com__eInstance_DecRef(f), f = 0);
+outputLineNumbers = backOutputLineNumbers;
 }
 }
 
@@ -1459,16 +1478,20 @@ extern int sprintf(char * , char * , ...);
 
 extern int __ecereNameSpace__ecere__com__GetRuntimePlatform(void);
 
+extern char *  strcat(char * , const char * );
+
 extern char *  __ecereNameSpace__ecere__sys__CopyString(char *  string);
 
 char * PrintInt(long long result)
 {
 char temp[100];
 
-if(result > (((long long)0x7fffffffffffffffLL)))
-sprintf(temp, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64XLL" : "0x%llXLL"), result);
+if(result > (((int)0x7fffffff)))
+sprintf(temp, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64X" : "0x%llX"), result);
 else
-sprintf(temp, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "%I64dLL" : "%lldLL"), result);
+sprintf(temp, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "%I64d" : "%lld"), result);
+if(result > (((int)0x7fffffff)) || result < (((int)0x80000000)))
+strcat(temp, "LL");
 return __ecereNameSpace__ecere__sys__CopyString(temp);
 }
 
@@ -1509,9 +1532,11 @@ char * PrintHexUInt(uint64 result)
 char temp[100];
 
 if(result > (0xffffffff))
-sprintf(temp, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64XLL" : "0x%llXLL"), result);
+sprintf(temp, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64X" : "0x%llX"), result);
 else
 sprintf(temp, ((__ecereNameSpace__ecere__com__GetRuntimePlatform() == 1) ? "0x%I64X" : "0x%llX"), result);
+if(result > (0xffffffff))
+strcat(temp, "LL");
 return __ecereNameSpace__ecere__sys__CopyString(temp);
 }
 
@@ -1568,18 +1593,74 @@ sprintf(temp, "0x%X", result);
 return __ecereNameSpace__ecere__sys__CopyString(temp);
 }
 
+extern char *  strcpy(char * , const char * );
+
+extern unsigned int (* __ecereProp_float_Get_isInf)(float this);
+
+extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp_float_isInf;
+
+extern int (* __ecereProp_float_Get_signBit)(float this);
+
+extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp_float_signBit;
+
+extern unsigned int (* __ecereProp_float_Get_isNan)(float this);
+
+extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp_float_isNan;
+
 char * PrintFloat(float result)
 {
 char temp[350];
 
+if(__ecereProp_float_Get_isInf(result))
+{
+if(__ecereProp_float_Get_signBit(result))
+strcpy(temp, "-inf");
+else
+strcpy(temp, "inf");
+}
+else if(__ecereProp_float_Get_isNan(result))
+{
+if(__ecereProp_float_Get_signBit(result))
+strcpy(temp, "-nan");
+else
+strcpy(temp, "nan");
+}
+else
 sprintf(temp, "%.16ff", result);
 return __ecereNameSpace__ecere__sys__CopyString(temp);
 }
 
+extern unsigned int (* __ecereProp_double_Get_isInf)(double this);
+
+extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp_double_isInf;
+
+extern int (* __ecereProp_double_Get_signBit)(double this);
+
+extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp_double_signBit;
+
+extern unsigned int (* __ecereProp_double_Get_isNan)(double this);
+
+extern struct __ecereNameSpace__ecere__com__Property ** __ecereProp_double_isNan;
+
 char * PrintDouble(double result)
 {
 char temp[350];
 
+if(__ecereProp_double_Get_isInf(result))
+{
+if(__ecereProp_double_Get_signBit(result))
+strcpy(temp, "-inf");
+else
+strcpy(temp, "inf");
+}
+else if(__ecereProp_double_Get_isNan(result))
+{
+if(__ecereProp_double_Get_signBit(result))
+strcpy(temp, "-nan");
+else
+strcpy(temp, "nan");
+}
+else
 sprintf(temp, "%.16f", result);
 return __ecereNameSpace__ecere__sys__CopyString(temp);
 }
@@ -1648,42 +1729,84 @@ uint64 ui64;
 struct OpTable ops;
 } __attribute__ ((gcc_struct));
 
+unsigned int GetOpInt(struct Operand * op2, int * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = op2->i;
+else if(op2->kind == 3)
+*value2 = (int)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (int)op2->i64;
+else if(op2->kind == 4)
+*value2 = (int)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (int)op2->i64;
+else if(op2->kind == 23)
+*value2 = (int)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (int)op2->i64;
+else if(op2->kind == 22)
+*value2 = (int)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (int)op2->s;
+else if(op2->kind == 2)
+*value2 = (int)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (int)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (int)op2->uc;
+else if(op2->kind == 6)
+*value2 = (int)op2->f;
+else if(op2->kind == 7)
+*value2 = (int)op2->d;
+else if(op2->kind == 13)
+*value2 = (int)op2->ui64;
+else
+return 0x0;
+return 0x1;
+}
+
 struct Operand GetOperand(struct Expression * exp);
 
 unsigned int GetInt(struct Expression * exp, int * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = op2.i;
-else if(op2.kind == 3)
-*value2 = (int)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (int)op2.i64;
-else if(op2.kind == 4)
-*value2 = (int)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (int)op2.i64;
-else if(op2.kind == 23)
-*value2 = (int)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (int)op2.i64;
-else if(op2.kind == 22)
-*value2 = (int)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (int)op2.s;
-else if(op2.kind == 2)
-*value2 = (int)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (int)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (int)op2.uc;
-else if(op2.kind == 6)
-*value2 = (int)op2.f;
-else if(op2.kind == 7)
-*value2 = (int)op2.d;
-else if(op2.kind == 13)
-*value2 = (int)op2.ui64;
+return GetOpInt(&op2, value2);
+}
+
+unsigned int GetOpUInt(struct Operand * op2, unsigned int * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (unsigned int)op2->i;
+else if(op2->kind == 3)
+*value2 = op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (unsigned int)op2->i64;
+else if(op2->kind == 4)
+*value2 = (unsigned int)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (unsigned int)op2->i64;
+else if(op2->kind == 23)
+*value2 = (unsigned int)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (unsigned int)op2->i64;
+else if(op2->kind == 22)
+*value2 = (unsigned int)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (unsigned int)op2->s;
+else if(op2->kind == 2)
+*value2 = (unsigned int)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (unsigned int)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (unsigned int)op2->uc;
+else if(op2->kind == 6)
+*value2 = (unsigned int)op2->f;
+else if(op2->kind == 7)
+*value2 = (unsigned int)op2->d;
+else if(op2->kind == 13)
+*value2 = (unsigned int)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -1693,36 +1816,41 @@ unsigned int GetUInt(struct Expression * exp, unsigned int * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (unsigned int)op2.i;
-else if(op2.kind == 3)
-*value2 = op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (unsigned int)op2.i64;
-else if(op2.kind == 4)
-*value2 = (unsigned int)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (unsigned int)op2.i64;
-else if(op2.kind == 23)
-*value2 = (unsigned int)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (unsigned int)op2.i64;
-else if(op2.kind == 22)
-*value2 = (unsigned int)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (unsigned int)op2.s;
-else if(op2.kind == 2)
-*value2 = (unsigned int)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (unsigned int)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (unsigned int)op2.uc;
-else if(op2.kind == 6)
-*value2 = (unsigned int)op2.f;
-else if(op2.kind == 7)
-*value2 = (unsigned int)op2.d;
-else if(op2.kind == 13)
-*value2 = (unsigned int)op2.ui64;
+return GetOpUInt(&op2, value2);
+}
+
+unsigned int GetOpInt64(struct Operand * op2, long long * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (long long)op2->i;
+else if(op2->kind == 3)
+*value2 = (long long)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = op2->i64;
+else if(op2->kind == 4)
+*value2 = (long long)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = op2->i64;
+else if(op2->kind == 23)
+*value2 = (long long)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = op2->i64;
+else if(op2->kind == 22)
+*value2 = (long long)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (long long)op2->s;
+else if(op2->kind == 2)
+*value2 = (long long)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (long long)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (long long)op2->uc;
+else if(op2->kind == 6)
+*value2 = (long long)op2->f;
+else if(op2->kind == 7)
+*value2 = (long long)op2->d;
+else if(op2->kind == 13)
+*value2 = (long long)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -1732,36 +1860,41 @@ unsigned int GetInt64(struct Expression * exp, long long * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (long long)op2.i;
-else if(op2.kind == 3)
-*value2 = (long long)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = op2.i64;
-else if(op2.kind == 4)
-*value2 = (long long)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = op2.i64;
-else if(op2.kind == 23)
-*value2 = (long long)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = op2.i64;
-else if(op2.kind == 22)
-*value2 = (long long)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (long long)op2.s;
-else if(op2.kind == 2)
-*value2 = (long long)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (long long)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (long long)op2.uc;
-else if(op2.kind == 6)
-*value2 = (long long)op2.f;
-else if(op2.kind == 7)
-*value2 = (long long)op2.d;
-else if(op2.kind == 13)
-*value2 = (long long)op2.ui64;
+return GetOpInt64(&op2, value2);
+}
+
+unsigned int GetOpUInt64(struct Operand * op2, uint64 * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (uint64)op2->i;
+else if(op2->kind == 3)
+*value2 = (uint64)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (uint64)op2->i64;
+else if(op2->kind == 4)
+*value2 = op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (uint64)op2->i64;
+else if(op2->kind == 23)
+*value2 = op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (uint64)op2->i64;
+else if(op2->kind == 22)
+*value2 = op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (uint64)op2->s;
+else if(op2->kind == 2)
+*value2 = (uint64)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (uint64)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (uint64)op2->uc;
+else if(op2->kind == 6)
+*value2 = (uint64)op2->f;
+else if(op2->kind == 7)
+*value2 = (uint64)op2->d;
+else if(op2->kind == 13)
+*value2 = op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -1771,36 +1904,41 @@ unsigned int GetUInt64(struct Expression * exp, uint64 * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (uint64)op2.i;
-else if(op2.kind == 3)
-*value2 = (uint64)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (uint64)op2.i64;
-else if(op2.kind == 4)
-*value2 = op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (uint64)op2.i64;
-else if(op2.kind == 23)
-*value2 = op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (uint64)op2.i64;
-else if(op2.kind == 22)
-*value2 = op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (uint64)op2.s;
-else if(op2.kind == 2)
-*value2 = (uint64)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (uint64)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (uint64)op2.uc;
-else if(op2.kind == 6)
-*value2 = (uint64)op2.f;
-else if(op2.kind == 7)
-*value2 = (uint64)op2.d;
-else if(op2.kind == 13)
-*value2 = op2.ui64;
+return GetOpUInt64(&op2, value2);
+}
+
+unsigned int GetOpIntPtr(struct Operand * op2, intptr_t * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (intptr_t)op2->i;
+else if(op2->kind == 3)
+*value2 = (intptr_t)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (intptr_t)op2->i64;
+else if(op2->kind == 4)
+*value2 = (intptr_t)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (intptr_t)op2->i64;
+else if(op2->kind == 23)
+*value2 = (intptr_t)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (intptr_t)op2->i64;
+else if(op2->kind == 22)
+*value2 = (intptr_t)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (intptr_t)op2->s;
+else if(op2->kind == 2)
+*value2 = (intptr_t)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (intptr_t)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (intptr_t)op2->uc;
+else if(op2->kind == 6)
+*value2 = (intptr_t)op2->f;
+else if(op2->kind == 7)
+*value2 = (intptr_t)op2->d;
+else if(op2->kind == 13)
+*value2 = (intptr_t)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -1810,36 +1948,41 @@ unsigned int GetIntPtr(struct Expression * exp, intptr_t * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (intptr_t)op2.i;
-else if(op2.kind == 3)
-*value2 = (intptr_t)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (intptr_t)op2.i64;
-else if(op2.kind == 4)
-*value2 = (intptr_t)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (intptr_t)op2.i64;
-else if(op2.kind == 23)
-*value2 = (intptr_t)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (intptr_t)op2.i64;
-else if(op2.kind == 22)
-*value2 = (intptr_t)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (intptr_t)op2.s;
-else if(op2.kind == 2)
-*value2 = (intptr_t)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (intptr_t)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (intptr_t)op2.uc;
-else if(op2.kind == 6)
-*value2 = (intptr_t)op2.f;
-else if(op2.kind == 7)
-*value2 = (intptr_t)op2.d;
-else if(op2.kind == 13)
-*value2 = (intptr_t)op2.ui64;
+return GetOpIntPtr(&op2, value2);
+}
+
+unsigned int GetOpUIntPtr(struct Operand * op2, uintptr_t * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (uintptr_t)op2->i;
+else if(op2->kind == 3)
+*value2 = (uintptr_t)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (uintptr_t)op2->i64;
+else if(op2->kind == 4)
+*value2 = (uintptr_t)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (uintptr_t)op2->i64;
+else if(op2->kind == 23)
+*value2 = (uintptr_t)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (uintptr_t)op2->i64;
+else if(op2->kind == 22)
+*value2 = (uintptr_t)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (uintptr_t)op2->s;
+else if(op2->kind == 2)
+*value2 = (uintptr_t)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (uintptr_t)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (uintptr_t)op2->uc;
+else if(op2->kind == 6)
+*value2 = (uintptr_t)op2->f;
+else if(op2->kind == 7)
+*value2 = (uintptr_t)op2->d;
+else if(op2->kind == 13)
+*value2 = (uintptr_t)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -1849,36 +1992,41 @@ unsigned int GetUIntPtr(struct Expression * exp, uintptr_t * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (uintptr_t)op2.i;
-else if(op2.kind == 3)
-*value2 = (uintptr_t)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (uintptr_t)op2.i64;
-else if(op2.kind == 4)
-*value2 = (uintptr_t)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (uintptr_t)op2.i64;
-else if(op2.kind == 23)
-*value2 = (uintptr_t)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (uintptr_t)op2.i64;
-else if(op2.kind == 22)
-*value2 = (uintptr_t)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (uintptr_t)op2.s;
-else if(op2.kind == 2)
-*value2 = (uintptr_t)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (uintptr_t)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (uintptr_t)op2.uc;
-else if(op2.kind == 6)
-*value2 = (uintptr_t)op2.f;
-else if(op2.kind == 7)
-*value2 = (uintptr_t)op2.d;
-else if(op2.kind == 13)
-*value2 = (uintptr_t)op2.ui64;
+return GetOpUIntPtr(&op2, value2);
+}
+
+unsigned int GetOpIntSize(struct Operand * op2, ssize_t * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (ssize_t)op2->i;
+else if(op2->kind == 3)
+*value2 = (ssize_t)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (ssize_t)op2->i64;
+else if(op2->kind == 4)
+*value2 = (ssize_t)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (ssize_t)op2->i64;
+else if(op2->kind == 23)
+*value2 = (ssize_t)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (ssize_t)op2->i64;
+else if(op2->kind == 22)
+*value2 = (ssize_t)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (ssize_t)op2->s;
+else if(op2->kind == 2)
+*value2 = (ssize_t)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (ssize_t)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (ssize_t)op2->uc;
+else if(op2->kind == 6)
+*value2 = (ssize_t)op2->f;
+else if(op2->kind == 7)
+*value2 = (ssize_t)op2->d;
+else if(op2->kind == 13)
+*value2 = (ssize_t)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -1888,36 +2036,41 @@ unsigned int GetIntSize(struct Expression * exp, ssize_t * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (ssize_t)op2.i;
-else if(op2.kind == 3)
-*value2 = (ssize_t)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (ssize_t)op2.i64;
-else if(op2.kind == 4)
-*value2 = (ssize_t)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (ssize_t)op2.i64;
-else if(op2.kind == 23)
-*value2 = (ssize_t)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (ssize_t)op2.i64;
-else if(op2.kind == 22)
-*value2 = (ssize_t)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (ssize_t)op2.s;
-else if(op2.kind == 2)
-*value2 = (ssize_t)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (ssize_t)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (ssize_t)op2.uc;
-else if(op2.kind == 6)
-*value2 = (ssize_t)op2.f;
-else if(op2.kind == 7)
-*value2 = (ssize_t)op2.d;
-else if(op2.kind == 13)
-*value2 = (ssize_t)op2.ui64;
+return GetOpIntSize(&op2, value2);
+}
+
+unsigned int GetOpUIntSize(struct Operand * op2, size_t * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (size_t)op2->i;
+else if(op2->kind == 3)
+*value2 = (size_t)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (size_t)op2->i64;
+else if(op2->kind == 4)
+*value2 = (size_t)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (size_t)op2->i64;
+else if(op2->kind == 23)
+*value2 = (size_t)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (size_t)op2->i64;
+else if(op2->kind == 22)
+*value2 = (size_t)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (size_t)op2->s;
+else if(op2->kind == 2)
+*value2 = (size_t)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (size_t)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (size_t)op2->uc;
+else if(op2->kind == 6)
+*value2 = (size_t)op2->f;
+else if(op2->kind == 7)
+*value2 = (size_t)op2->d;
+else if(op2->kind == 13)
+*value2 = (size_t)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -1927,36 +2080,41 @@ unsigned int GetUIntSize(struct Expression * exp, size_t * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (size_t)op2.i;
-else if(op2.kind == 3)
-*value2 = (size_t)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (size_t)op2.i64;
-else if(op2.kind == 4)
-*value2 = (size_t)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (size_t)op2.i64;
-else if(op2.kind == 23)
-*value2 = (size_t)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (size_t)op2.i64;
-else if(op2.kind == 22)
-*value2 = (size_t)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (size_t)op2.s;
-else if(op2.kind == 2)
-*value2 = (size_t)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (size_t)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (size_t)op2.uc;
-else if(op2.kind == 6)
-*value2 = (size_t)op2.f;
-else if(op2.kind == 7)
-*value2 = (size_t)op2.d;
-else if(op2.kind == 13)
-*value2 = (size_t)op2.ui64;
+return GetOpUIntSize(&op2, value2);
+}
+
+unsigned int GetOpShort(struct Operand * op2, short * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (short)op2->i;
+else if(op2->kind == 3)
+*value2 = (short)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (short)op2->i64;
+else if(op2->kind == 4)
+*value2 = (short)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (short)op2->i64;
+else if(op2->kind == 23)
+*value2 = (short)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (short)op2->i64;
+else if(op2->kind == 22)
+*value2 = (short)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = op2->s;
+else if(op2->kind == 2)
+*value2 = (short)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (short)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (short)op2->uc;
+else if(op2->kind == 6)
+*value2 = (short)op2->f;
+else if(op2->kind == 7)
+*value2 = (short)op2->d;
+else if(op2->kind == 13)
+*value2 = (short)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -1966,36 +2124,41 @@ unsigned int GetShort(struct Expression * exp, short * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (short)op2.i;
-else if(op2.kind == 3)
-*value2 = (short)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (short)op2.i64;
-else if(op2.kind == 4)
-*value2 = (short)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (short)op2.i64;
-else if(op2.kind == 23)
-*value2 = (short)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (short)op2.i64;
-else if(op2.kind == 22)
-*value2 = (short)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = op2.s;
-else if(op2.kind == 2)
-*value2 = (short)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (short)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (short)op2.uc;
-else if(op2.kind == 6)
-*value2 = (short)op2.f;
-else if(op2.kind == 7)
-*value2 = (short)op2.d;
-else if(op2.kind == 13)
-*value2 = (short)op2.ui64;
+return GetOpShort(&op2, value2);
+}
+
+unsigned int GetOpUShort(struct Operand * op2, unsigned short * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (unsigned short)op2->i;
+else if(op2->kind == 3)
+*value2 = (unsigned short)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (unsigned short)op2->i64;
+else if(op2->kind == 4)
+*value2 = (unsigned short)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (unsigned short)op2->i64;
+else if(op2->kind == 23)
+*value2 = (unsigned short)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (unsigned short)op2->i64;
+else if(op2->kind == 22)
+*value2 = (unsigned short)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (unsigned short)op2->s;
+else if(op2->kind == 2)
+*value2 = op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (unsigned short)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (unsigned short)op2->uc;
+else if(op2->kind == 6)
+*value2 = (unsigned short)op2->f;
+else if(op2->kind == 7)
+*value2 = (unsigned short)op2->d;
+else if(op2->kind == 13)
+*value2 = (unsigned short)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -2005,36 +2168,41 @@ unsigned int GetUShort(struct Expression * exp, unsigned short * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (unsigned short)op2.i;
-else if(op2.kind == 3)
-*value2 = (unsigned short)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (unsigned short)op2.i64;
-else if(op2.kind == 4)
-*value2 = (unsigned short)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (unsigned short)op2.i64;
-else if(op2.kind == 23)
-*value2 = (unsigned short)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (unsigned short)op2.i64;
-else if(op2.kind == 22)
-*value2 = (unsigned short)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (unsigned short)op2.s;
-else if(op2.kind == 2)
-*value2 = op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (unsigned short)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (unsigned short)op2.uc;
-else if(op2.kind == 6)
-*value2 = (unsigned short)op2.f;
-else if(op2.kind == 7)
-*value2 = (unsigned short)op2.d;
-else if(op2.kind == 13)
-*value2 = (unsigned short)op2.ui64;
+return GetOpUShort(&op2, value2);
+}
+
+unsigned int GetOpChar(struct Operand * op2, char * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (char)op2->i;
+else if(op2->kind == 3)
+*value2 = (char)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (char)op2->i64;
+else if(op2->kind == 4)
+*value2 = (char)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (char)op2->i64;
+else if(op2->kind == 23)
+*value2 = (char)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (char)op2->i64;
+else if(op2->kind == 22)
+*value2 = (char)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (char)op2->s;
+else if(op2->kind == 2)
+*value2 = (char)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (char)op2->uc;
+else if(op2->kind == 6)
+*value2 = (char)op2->f;
+else if(op2->kind == 7)
+*value2 = (char)op2->d;
+else if(op2->kind == 13)
+*value2 = (char)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -2044,36 +2212,41 @@ unsigned int GetChar(struct Expression * exp, char * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (char)op2.i;
-else if(op2.kind == 3)
-*value2 = (char)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (char)op2.i64;
-else if(op2.kind == 4)
-*value2 = (char)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (char)op2.i64;
-else if(op2.kind == 23)
-*value2 = (char)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (char)op2.i64;
-else if(op2.kind == 22)
-*value2 = (char)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (char)op2.s;
-else if(op2.kind == 2)
-*value2 = (char)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (char)op2.uc;
-else if(op2.kind == 6)
-*value2 = (char)op2.f;
-else if(op2.kind == 7)
-*value2 = (char)op2.d;
-else if(op2.kind == 13)
-*value2 = (char)op2.ui64;
+return GetOpChar(&op2, value2);
+}
+
+unsigned int GetOpUChar(struct Operand * op2, unsigned char * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (unsigned char)op2->i;
+else if(op2->kind == 3)
+*value2 = (unsigned char)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (unsigned char)op2->i64;
+else if(op2->kind == 4)
+*value2 = (unsigned char)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (unsigned char)op2->i64;
+else if(op2->kind == 23)
+*value2 = (unsigned char)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (unsigned char)op2->i64;
+else if(op2->kind == 22)
+*value2 = (unsigned char)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (unsigned char)op2->s;
+else if(op2->kind == 2)
+*value2 = (unsigned char)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (unsigned char)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = op2->uc;
+else if(op2->kind == 6)
+*value2 = (unsigned char)op2->f;
+else if(op2->kind == 7)
+*value2 = (unsigned char)op2->d;
+else if(op2->kind == 13)
+*value2 = (unsigned char)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -2083,36 +2256,41 @@ unsigned int GetUChar(struct Expression * exp, unsigned char * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (unsigned char)op2.i;
-else if(op2.kind == 3)
-*value2 = (unsigned char)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (unsigned char)op2.i64;
-else if(op2.kind == 4)
-*value2 = (unsigned char)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (unsigned char)op2.i64;
-else if(op2.kind == 23)
-*value2 = (unsigned char)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (unsigned char)op2.i64;
-else if(op2.kind == 22)
-*value2 = (unsigned char)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (unsigned char)op2.s;
-else if(op2.kind == 2)
-*value2 = (unsigned char)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (unsigned char)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = op2.uc;
-else if(op2.kind == 6)
-*value2 = (unsigned char)op2.f;
-else if(op2.kind == 7)
-*value2 = (unsigned char)op2.d;
-else if(op2.kind == 13)
-*value2 = (unsigned char)op2.ui64;
+return GetOpUChar(&op2, value2);
+}
+
+unsigned int GetOpFloat(struct Operand * op2, float * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (float)(float)op2->i;
+else if(op2->kind == 3)
+*value2 = (float)(float)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (float)(float)op2->i64;
+else if(op2->kind == 4)
+*value2 = (float)(float)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (float)(float)op2->i64;
+else if(op2->kind == 23)
+*value2 = (float)(float)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (float)(float)op2->i64;
+else if(op2->kind == 22)
+*value2 = (float)(float)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (float)(float)op2->s;
+else if(op2->kind == 2)
+*value2 = (float)(float)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (float)(float)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (float)(float)op2->uc;
+else if(op2->kind == 6)
+*value2 = (float)op2->f;
+else if(op2->kind == 7)
+*value2 = (float)op2->d;
+else if(op2->kind == 13)
+*value2 = (float)(float)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -2122,36 +2300,41 @@ unsigned int GetFloat(struct Expression * exp, float * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (float)(float)op2.i;
-else if(op2.kind == 3)
-*value2 = (float)(float)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (float)(float)op2.i64;
-else if(op2.kind == 4)
-*value2 = (float)(float)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (float)(float)op2.i64;
-else if(op2.kind == 23)
-*value2 = (float)(float)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (float)(float)op2.i64;
-else if(op2.kind == 22)
-*value2 = (float)(float)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (float)(float)op2.s;
-else if(op2.kind == 2)
-*value2 = (float)(float)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (float)(float)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (float)(float)op2.uc;
-else if(op2.kind == 6)
-*value2 = (float)op2.f;
-else if(op2.kind == 7)
-*value2 = (float)op2.d;
-else if(op2.kind == 13)
-*value2 = (float)(float)op2.ui64;
+return GetOpFloat(&op2, value2);
+}
+
+unsigned int GetOpDouble(struct Operand * op2, double * value2)
+{
+if(op2->kind == 3 && op2->type->isSigned)
+*value2 = (double)(double)op2->i;
+else if(op2->kind == 3)
+*value2 = (double)(double)op2->ui;
+else if(op2->kind == 4 && op2->type->isSigned)
+*value2 = (double)(double)op2->i64;
+else if(op2->kind == 4)
+*value2 = (double)(double)op2->ui64;
+else if(op2->kind == 23 && op2->type->isSigned)
+*value2 = (double)(double)op2->i64;
+else if(op2->kind == 23)
+*value2 = (double)(double)op2->ui64;
+else if(op2->kind == 22 && op2->type->isSigned)
+*value2 = (double)(double)op2->i64;
+else if(op2->kind == 22)
+*value2 = (double)(double)op2->ui64;
+else if(op2->kind == 2 && op2->type->isSigned)
+*value2 = (double)(double)op2->s;
+else if(op2->kind == 2)
+*value2 = (double)(double)op2->us;
+else if(op2->kind == 1 && op2->type->isSigned)
+*value2 = (double)(double)op2->c;
+else if(op2->kind == 24 || op2->kind == 1)
+*value2 = (double)(double)op2->uc;
+else if(op2->kind == 6)
+*value2 = (double)op2->f;
+else if(op2->kind == 7)
+*value2 = (double)op2->d;
+else if(op2->kind == 13)
+*value2 = (double)(double)op2->ui64;
 else
 return 0x0;
 return 0x1;
@@ -2161,39 +2344,7 @@ unsigned int GetDouble(struct Expression * exp, double * value2)
 {
 struct Operand op2 = GetOperand(exp);
 
-if(op2.kind == 3 && op2.type->isSigned)
-*value2 = (double)(double)op2.i;
-else if(op2.kind == 3)
-*value2 = (double)(double)op2.ui;
-else if(op2.kind == 4 && op2.type->isSigned)
-*value2 = (double)(double)op2.i64;
-else if(op2.kind == 4)
-*value2 = (double)(double)op2.ui64;
-else if(op2.kind == 23 && op2.type->isSigned)
-*value2 = (double)(double)op2.i64;
-else if(op2.kind == 23)
-*value2 = (double)(double)op2.ui64;
-else if(op2.kind == 22 && op2.type->isSigned)
-*value2 = (double)(double)op2.i64;
-else if(op2.kind == 22)
-*value2 = (double)(double)op2.ui64;
-else if(op2.kind == 2 && op2.type->isSigned)
-*value2 = (double)(double)op2.s;
-else if(op2.kind == 2)
-*value2 = (double)(double)op2.us;
-else if(op2.kind == 1 && op2.type->isSigned)
-*value2 = (double)(double)op2.c;
-else if(op2.kind == 24 || op2.kind == 1)
-*value2 = (double)(double)op2.uc;
-else if(op2.kind == 6)
-*value2 = (double)op2.f;
-else if(op2.kind == 7)
-*value2 = (double)op2.d;
-else if(op2.kind == 13)
-*value2 = (double)(double)op2.ui64;
-else
-return 0x0;
-return 0x1;
+return GetOpDouble(&op2, value2);
 }
 
 void ComputeExpression(struct Expression * exp);
@@ -2571,9 +2722,7 @@ extern unsigned int inCompiler;
 
 extern void Compiler_Error(char *  format, ...);
 
-extern char *  __ecereNameSpace__ecere__GetTranslatedString(struct __ecereNameSpace__ecere__com__Instance * module, char *  string, char *  stringAndContext);
-
-extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
+extern char *  __ecereNameSpace__ecere__GetTranslatedString(char * name, char *  string, char *  stringAndContext);
 
 int ComputeTypeSize(struct Type * type)
 {
@@ -2655,7 +2804,7 @@ type->arraySizeExp->expType = (((void *)0));
 yylloc = type->arraySizeExp->loc;
 if(inCompiler)
 PrintExpression(type->arraySizeExp, expression);
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Array size not constant int (%s)\n", (((void *)0))), expression);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Array size not constant int (%s)\n", (((void *)0))), expression);
 yylloc = oldLoc;
 }
 GetInt(type->arraySizeExp, &type->arraySize);
@@ -2944,8 +3093,6 @@ extern struct External * MkExternalDeclaration(struct Declaration * declaration)
 
 extern struct Declaration * MkDeclaration(struct __ecereNameSpace__ecere__sys__OldList * specifiers, struct __ecereNameSpace__ecere__sys__OldList * initDeclarators);
 
-extern char *  strcpy(char * , const char * );
-
 extern void MangleClassName(char *  className);
 
 extern void DeclareClass(struct Symbol * classSym, char *  className);
@@ -2969,6 +3116,7 @@ struct Declaration * decl;
 struct __ecereNameSpace__ecere__sys__OldList * specifiers, * declarators;
 struct __ecereNameSpace__ecere__sys__OldList * declarations = (((void *)0));
 char structName[1024];
+struct Specifier * spec = (((void *)0));
 
 external = (classSym->registered && classSym->registered->type == 1) ? classSym->pointerExternal : classSym->structExternal;
 classSym->declaring++;
@@ -2984,7 +3132,15 @@ return ;
 DeclareMembers(classSym->registered, 0x0);
 structName[0] = (char)0;
 FullClassNameCat(structName, name, 0x0);
-if(!skipNoHead)
+if(external && external->declaration && external->declaration->specifiers)
+{
+for(spec = (*external->declaration->specifiers).first; spec; spec = spec->next)
+{
+if(spec->type == 3 || spec->type == 4)
+break;
+}
+}
+if(!skipNoHead && (!spec || !spec->definitions))
 {
 unsigned int addedPadding = 0x0;
 
@@ -2999,9 +3155,10 @@ declarations = (((void *)0));
 }
 if(skipNoHead || declarations)
 {
-if(external && external->declaration)
+if(spec)
 {
-((struct Specifier *)(*external->declaration->specifiers).first)->definitions = declarations;
+if(declarations)
+spec->definitions = declarations;
 if(curExternal && curExternal->symbol && curExternal->symbol->idCode < classSym->id)
 {
 if(classSym->structExternal)
@@ -3069,8 +3226,6 @@ classSym->declaring--;
 }
 }
 
-extern char *  strcat(char * , const char * );
-
 extern struct ModuleImport * FindModule(struct __ecereNameSpace__ecere__com__Instance * moduleToFind);
 
 extern struct ModuleImport * mainModule;
@@ -3162,7 +3317,7 @@ if(classSym)
 __ecereMethod___ecereNameSpace__ecere__sys__OldList_Add(&classSym->_import->properties, symbol->_import);
 }
 imported = 0x1;
-if(prop->_class->module != privateModule && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)prop->_class->module + structSize_Instance)))->importType != 1)
+if((prop->_class->module != privateModule || !strcmp(prop->_class->name, "float") || !strcmp(prop->_class->name, "double")) && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)prop->_class->module + 24)))->importType != 1)
 dllImport = 0x1;
 }
 if(!symbol->type)
@@ -3374,7 +3529,7 @@ type = source;
 source->refCount++;
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "cannot dereference type\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "cannot dereference type\n", (((void *)0))));
 }
 return type;
 }
@@ -3627,6 +3782,7 @@ struct Expression * exp;
 char * string = PrintHexUInt64(arg.expression.ui64);
 
 exp = MkExpCast(MkTypeName(specs, decl), MkExpConstant(string));
+(__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
 ProcessExpressionType(exp);
 ComputeExpression(exp);
 expString[0] = '\0';
@@ -3699,12 +3855,12 @@ char expString[10240];
 expString[0] = '\0';
 PrintExpression(member->initializer->exp, expString);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "unresolved symbol used as an instance method %s\n", (((void *)0))), expString);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved symbol used as an instance method %s\n", (((void *)0))), expString);
 }
 }
 else if(!MatchTypes(member->initializer->exp->expType, type, (((void *)0)), (((void *)0)), _class, 0x1, 0x1, 0x0, 0x0))
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "incompatible instance method %s\n", (((void *)0))), ident->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible instance method %s\n", (((void *)0))), ident->string);
 }
 }
 else if(member->initializer)
@@ -3736,17 +3892,17 @@ if(ident)
 {
 if(method)
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't find virtual method %s in class %s\n", (((void *)0))), ident->string, _class->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't find virtual method %s in class %s\n", (((void *)0))), ident->string, _class->fullName);
 }
 else if(_class)
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't find member %s in class %s\n", (((void *)0))), ident->string, _class->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't find member %s in class %s\n", (((void *)0))), ident->string, _class->fullName);
 if(inCompiler)
 __ecereNameSpace__ecere__com__eClass_AddDataMember(_class, ident->string, "int", 0, 0, 1);
 }
 }
 else if(_class)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "too many initializers for instantiation of class %s\n", (((void *)0))), _class->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "too many initializers for instantiation of class %s\n", (((void *)0))), _class->fullName);
 }
 }
 }
@@ -3852,7 +4008,7 @@ DeclareType(symbol->type, 0x1, 0x1);
 }
 else if(classSym)
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't find virtual method %s in class %s\n", (((void *)0))), unmangled, classSym->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't find virtual method %s in class %s\n", (((void *)0))), unmangled, classSym->string);
 }
 }
 createdExternal = ProcessClassFunction(classSym ? classSym->registered : (((void *)0)), members->function, ast, afterExternal, 0x1);
@@ -4191,7 +4347,7 @@ symbol->type->refCount++;
 if(!method->dataType->dllExport)
 {
 imported = 0x1;
-if(method->_class->module != privateModule && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)method->_class->module + structSize_Instance)))->importType != 1)
+if((method->_class->module != privateModule || !strcmp(method->_class->name, "float") || !strcmp(method->_class->name, "double")) && ((struct __ecereNameSpace__ecere__com__Module *)(((char *)method->_class->module + 24)))->importType != 1)
 dllImport = 0x1;
 }
 }
@@ -4725,7 +4881,7 @@ struct Conversion * after = (conversions != (((void *)0))) ? conversions->last :
 
 if(!convert->dataType)
 convert->dataType = ProcessTypeString(convert->dataTypeString, 0x0);
-if(MatchTypes(convert->dataType, dest, conversions, (((void *)0)), (((void *)0)), 0x0, 0x1, 0x0, 0x1))
+if((!isConversionExploration || convert->dataType->kind == 8 || !strcmp(_class->name, "String")) && MatchTypes(convert->dataType, dest, conversions, (((void *)0)), (((void *)0)), (convert->dataType->kind == 8 && !strcmp(convert->dataTypeString, "String")) ? 0x1 : 0x0, convert->dataType->kind == 8, 0x0, 0x1))
 {
 if(!conversions && !convert->Get)
 return 0x1;
@@ -4786,7 +4942,7 @@ if(!dest->_class->registered->dataType)
 dest->_class->registered->dataType = ProcessTypeString(dest->_class->registered->dataTypeString, 0x0);
 if(dest->_class->registered->dataType->kind == 8 || source->truth || dest->truth)
 {
-if(MatchTypes(source, dest->_class->registered->dataType, conversions, (((void *)0)), (((void *)0)), 0x1, 0x1, 0x0, 0x0))
+if(MatchTypes(source, dest->_class->registered->dataType, conversions, (((void *)0)), (((void *)0)), 0x1, dest->_class->registered->dataType->kind == 8, 0x0, 0x0))
 {
 return 0x1;
 }
@@ -4809,7 +4965,7 @@ struct Conversion * after = (conversions != (((void *)0))) ? conversions->last :
 
 if(!convert->dataType)
 convert->dataType = ProcessTypeString(convert->dataTypeString, 0x0);
-if(convert->dataType != source && MatchTypes(convert->dataType, dest, conversions, (((void *)0)), (((void *)0)), 0x1, 0x1, 0x0, 0x1))
+if(convert->dataType != source && (!isConversionExploration || convert->dataType->kind == 8 || !strcmp(_class->name, "String")) && MatchTypes(convert->dataType, dest, conversions, (((void *)0)), (((void *)0)), convert->dataType->kind == 8, convert->dataType->kind == 8, 0x0, 0x1))
 {
 if(!conversions && !convert->Get)
 return 0x1;
@@ -4833,8 +4989,11 @@ if(enumBaseType && source->_class && source->_class->registered && source->_clas
 {
 if(!source->_class->registered->dataType)
 source->_class->registered->dataType = ProcessTypeString(source->_class->registered->dataTypeString, 0x0);
-if(MatchTypes(source->_class->registered->dataType, dest, conversions, (((void *)0)), (((void *)0)), 0x1, 0x1, 0x0, 0x0))
+if(!isConversionExploration || source->_class->registered->dataType->kind == 8 || !strcmp(source->_class->registered->name, "String"))
 {
+if(MatchTypes(source->_class->registered->dataType, dest, conversions, (((void *)0)), (((void *)0)), source->_class->registered->dataType->kind == 8, source->_class->registered->dataType->kind == 8, 0x0, 0x0))
+return 0x1;
+else if(MatchTypes(dest, source->_class->registered->dataType, (((void *)0)), (((void *)0)), (((void *)0)), 0x0, 0x0, 0x0, 0x0))
 return 0x1;
 }
 }
@@ -4858,7 +5017,7 @@ else if(dest->kind == 23 && (source->kind == 2 || source->kind == 1 || source->k
 return 0x1;
 else if(source->kind == 15 && (dest->kind == 3 || dest->kind == 2 || dest->kind == 1 || source->kind == 24 || dest->kind == 5 || dest->kind == 4 || dest->kind == 22 || dest->kind == 23))
 return 0x1;
-else if(dest->kind == 15 && (source->kind == 3 || source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 5 || source->kind == 4 || source->kind == 22 || source->kind == 23))
+else if(dest->kind == 15 && !isConversionExploration && (source->kind == 3 || source->kind == 2 || source->kind == 1 || source->kind == 24 || source->kind == 5 || source->kind == 4 || source->kind == 22 || source->kind == 23))
 return 0x1;
 else if((dest->kind == 11 || (dest->kind == 13 && dest->type->kind == 11) || dest->kind == 16) && ((source->kind == 11 || (source->kind == 13 && source->type->kind == 11) || source->kind == 16)))
 {
@@ -4887,9 +5046,9 @@ if((dest->staticMethod || (!dest->thisClass && !owningClassDest)) && !(source->s
 if(!paramDest || (!(paramDest->kind == 13 && paramDest->type && paramDest->type->kind == 0) && (paramDest->kind != 8 || !__ecereNameSpace__ecere__com__eClass_IsDerived(source->thisClass ? source->thisClass->registered : owningClassSource, paramDest->_class->registered))))
 {
 if(paramDest && paramDest->kind == 8)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "method class must be derived from %s\n", (((void *)0))), paramDest->_class->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "method class must be derived from %s\n", (((void *)0))), paramDest->_class->string);
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "method class should not take an object\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "method class should not take an object\n", (((void *)0))));
 return 0x0;
 }
 paramDest = paramDest->next;
@@ -4902,7 +5061,7 @@ if(dest->thisClass)
 {
 if(!paramSource || paramSource->kind != 8 || !__ecereNameSpace__ecere__com__eClass_IsDerived(paramSource->_class->registered, dest->thisClass->registered))
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "method class must be derived from %s\n", (((void *)0))), dest->thisClass->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "method class must be derived from %s\n", (((void *)0))), dest->thisClass->string);
 return 0x0;
 }
 }
@@ -4911,9 +5070,9 @@ else
 if(!paramSource || paramSource->kind != 8 || (owningClassDest && !__ecereNameSpace__ecere__com__eClass_IsDerived(paramSource->_class->registered, owningClassDest)))
 {
 if(owningClassDest)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "%s expected to be derived from method class\n", (((void *)0))), owningClassDest->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "%s expected to be derived from method class\n", (((void *)0))), owningClassDest->fullName);
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "overriding class expected to be derived from method class\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "overriding class expected to be derived from method class\n", (((void *)0))));
 return 0x0;
 }
 }
@@ -4925,7 +5084,7 @@ if(dest->thisClass)
 {
 if(!__ecereNameSpace__ecere__com__eClass_IsDerived(source->thisClass ? source->thisClass->registered : owningClassSource, dest->thisClass->registered))
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "method class must be derived from %s\n", (((void *)0))), dest->thisClass->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "method class must be derived from %s\n", (((void *)0))), dest->thisClass->string);
 return 0x0;
 }
 }
@@ -4933,7 +5092,7 @@ else
 {
 if(source->thisClass && source->thisClass->registered && owningClassDest && !__ecereNameSpace__ecere__com__eClass_IsDerived(source->thisClass->registered, owningClassDest))
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "%s expected to be derived from method class\n", (((void *)0))), source->thisClass->registered->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "%s expected to be derived from method class\n", (((void *)0))), source->thisClass->registered->fullName);
 return 0x0;
 }
 }
@@ -4941,14 +5100,14 @@ return 0x0;
 }
 if(!MatchTypes(source->returnType, dest->returnType, (((void *)0)), (((void *)0)), (((void *)0)), 0x1, 0x1, 0x0, 0x0))
 {
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "incompatible return type for function\n", (((void *)0))));
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible return type for function\n", (((void *)0))));
 return 0x0;
 }
 for(; paramDest; paramDest = paramDest->next)
 {
 if(!paramSource)
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "not enough parameters\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "not enough parameters\n", (((void *)0))));
 return 0x0;
 }
 {
@@ -4997,7 +5156,7 @@ char type[1024];
 
 type[0] = (char)0;
 PrintType(paramDest, type, 0x0, 0x1);
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "incompatible parameter %s (expected %s)\n", (((void *)0))), paramSource->name, type);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible parameter %s (expected %s)\n", (((void *)0))), paramSource->name, type);
 if(paramDestType != paramDest)
 FreeType(paramDestType);
 return 0x0;
@@ -5009,7 +5168,7 @@ paramSource = paramSource->next;
 }
 if(paramSource)
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "too many parameters\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "too many parameters\n", (((void *)0))));
 return 0x0;
 }
 return 0x1;
@@ -5211,6 +5370,8 @@ return 0x1;
 return 0x0;
 }
 
+extern struct Expression * CopyExpression(struct Expression * exp);
+
 extern unsigned long strtoul(const char *  nptr, char * *  endptr, int base);
 
 void ReadString(char *  output, char *  string);
@@ -5223,12 +5384,28 @@ extern struct Expression * MkExpBrackets(struct __ecereNameSpace__ecere__sys__Ol
 
 unsigned int MatchTypeExpression(struct Expression * sourceExp, struct Type * dest, struct __ecereNameSpace__ecere__sys__OldList * conversions, unsigned int skipUnitBla)
 {
-struct Type * source = sourceExp->expType;
+struct Type * source;
 struct Type * realDest = dest;
 struct Type * backupSourceExpType = (((void *)0));
+struct Expression * computedExp = sourceExp;
 
+dest->refCount++;
+if(sourceExp->isConstant && sourceExp->type != 2 && sourceExp->type != 0 && sourceExp->type != 11 && dest->kind == 8 && dest->_class && dest->_class->registered && dest->_class->registered->type == 4)
+{
+computedExp = CopyExpression(sourceExp);
+ComputeExpression(computedExp);
+}
+source = sourceExp->expType;
 if(dest->kind == 13 && sourceExp->type == 2 && !strtoul(sourceExp->constant, (((void *)0)), 0))
+{
+if(computedExp != sourceExp)
+{
+FreeExpression(computedExp);
+computedExp = sourceExp;
+}
+FreeType(dest);
 return 0x1;
+}
 if(!skipUnitBla && source && dest && source->kind == 8 && dest->kind == 8)
 {
 if(source->_class && source->_class->registered && source->_class->registered->type == 3)
@@ -5240,9 +5417,17 @@ for(sourceBase = source->_class->registered; sourceBase && sourceBase->base && s
 for(destBase = dest->_class->registered; destBase && destBase->base && destBase->base->type != 1000; destBase = destBase->base)
 ;
 if(sourceBase == destBase)
+{
+if(computedExp != sourceExp)
+{
+FreeExpression(computedExp);
+computedExp = sourceExp;
+}
+FreeType(dest);
 return 0x1;
 }
 }
+}
 if(source)
 {
 struct __ecereNameSpace__ecere__sys__OldList * specs;
@@ -5250,20 +5435,24 @@ unsigned int flag = 0x0;
 long long value = (((int)0x7fffffff));
 
 source->refCount++;
-dest->refCount++;
-if(sourceExp->type == 2)
+if(computedExp->type == 2)
 {
 if(source->isSigned)
-value = strtoll(sourceExp->constant, (((void *)0)), 0);
+value = strtoll(computedExp->constant, (((void *)0)), 0);
 else
-value = strtoull(sourceExp->constant, (((void *)0)), 0);
+value = strtoull(computedExp->constant, (((void *)0)), 0);
 }
-else if(sourceExp->type == 4 && sourceExp->op.op == '-' && !sourceExp->op.exp1 && sourceExp->op.exp2 && sourceExp->op.exp2->type == 2)
+else if(computedExp->type == 4 && sourceExp->op.op == '-' && !computedExp->op.exp1 && computedExp->op.exp2 && computedExp->op.exp2->type == 2)
 {
 if(source->isSigned)
-value = -strtoll(sourceExp->op.exp2->constant, (((void *)0)), 0);
+value = -strtoll(computedExp->op.exp2->constant, (((void *)0)), 0);
 else
-value = -strtoull(sourceExp->op.exp2->constant, (((void *)0)), 0);
+value = -strtoull(computedExp->op.exp2->constant, (((void *)0)), 0);
+}
+if(computedExp != sourceExp)
+{
+FreeExpression(computedExp);
+computedExp = sourceExp;
 }
 if(dest->kind != 8 && source->kind == 8 && source->_class && source->_class->registered && !strcmp(source->_class->registered->fullName, "ecere::com::unichar"))
 {
@@ -5325,7 +5514,7 @@ ReadString(string, sourceExp->string);
 decl = SpecDeclFromString(string, specs, (((void *)0)));
 FreeExpContents(sourceExp);
 FreeType(sourceExp->expType);
-sourceExp->type = 26;
+sourceExp->type = 24;
 sourceExp->_classExp.specifiers = specs;
 sourceExp->_classExp.decl = decl;
 sourceExp->expType = dest;
@@ -5341,7 +5530,7 @@ else if(source->kind == 8)
 {
 struct __ecereNameSpace__ecere__com__Class * _class = source->_class ? source->_class->registered : (((void *)0));
 
-if(_class && (_class->type == 3 || !strcmp(_class->fullName, "bool") || _class->type == 2))
+if(_class && (_class->type == 3 || _class->type == 2))
 {
 if(dest->kind != 8)
 {
@@ -5401,8 +5590,17 @@ return 0x1;
 if(dest->kind == 8)
 {
 struct __ecereNameSpace__ecere__com__Class * _class = dest->_class ? dest->_class->registered : (((void *)0));
+unsigned int fittingValue = 0x0;
+
+if(_class && _class->type == 4)
+{
+struct __ecereNameSpace__ecere__com__Class * enumClass = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "enum");
+struct __ecereNameSpace__ecere__com__EnumClassData * c = (_class ? ((void *)(((char *)_class->data) + enumClass->offsetClass)) : (((void *)0)));
 
-if(_class && !dest->truth && (_class->type == 3 || !strcmp(_class->fullName, "bool") || (_class->type != 1 && !value && source->kind == 3) || _class->type == 2))
+if(c && value >= 0 && value <= c->largest)
+fittingValue = 0x1;
+}
+if(_class && !dest->truth && (_class->type == 3 || fittingValue || (_class->type != 1 && !value && source->kind == 3) || _class->type == 2))
 {
 if(_class->type == 0 || _class->type == 5)
 {
@@ -5543,7 +5741,7 @@ sourceExp->expType = backupSourceExpType;
 }
 return 0x0;
 }
-if(!flag)
+if(!flag && !sourceExp->opDestType)
 {
 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
 
@@ -5582,7 +5780,12 @@ return 0x1;
 }
 else
 {
-while((sourceExp->type == 5 || sourceExp->type == 34) && sourceExp->list)
+if(computedExp != sourceExp)
+{
+FreeExpression(computedExp);
+computedExp = sourceExp;
+}
+while((sourceExp->type == 5 || sourceExp->type == 32) && sourceExp->list)
 sourceExp = (*sourceExp->list).last;
 if(sourceExp->type == 0)
 {
@@ -5623,6 +5826,7 @@ else
 sprintf(constant, "0x%X", (int)value->data);
 sourceExp->constant = __ecereNameSpace__ecere__sys__CopyString(constant);
 }
+FreeType(dest);
 return 0x1;
 }
 }
@@ -5630,9 +5834,13 @@ return 0x1;
 }
 }
 if(dest->classObjectType != 2 && dest->kind == 8 && MatchWithEnums_Module(privateModule, sourceExp, dest, id->string, conversions))
+{
+FreeType(dest);
 return 0x1;
 }
 }
+FreeType(dest);
+}
 return 0x0;
 }
 
@@ -5641,7 +5849,7 @@ static unsigned int IntAdd(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i + value2);
+exp->string = PrintInt((op1->i + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5656,7 +5864,7 @@ static unsigned int UIntAdd(struct Expression * exp, struct Operand * op1, struc
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui + value2);
+exp->string = PrintUInt((op1->ui + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5668,10 +5876,10 @@ return 0x1;
 
 static unsigned int Int64Add(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i + value2);
+exp->string = PrintInt64((op1->i64 + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5683,10 +5891,10 @@ return 0x1;
 
 static unsigned int UInt64Add(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui + value2);
+exp->string = PrintUInt64((op1->ui64 + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5701,7 +5909,7 @@ static unsigned int ShortAdd(struct Expression * exp, struct Operand * op1, stru
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s + value2);
+exp->string = PrintShort((op1->s + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5716,7 +5924,7 @@ static unsigned int UShortAdd(struct Expression * exp, struct Operand * op1, str
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us + value2);
+exp->string = PrintUShort((op1->us + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5731,7 +5939,7 @@ static unsigned int CharAdd(struct Expression * exp, struct Operand * op1, struc
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c + value2);
+exp->string = PrintChar((op1->c + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5746,7 +5954,7 @@ static unsigned int UCharAdd(struct Expression * exp, struct Operand * op1, stru
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc + value2);
+exp->string = PrintUChar((op1->uc + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5761,7 +5969,7 @@ static unsigned int FloatAdd(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f + value2);
+exp->string = PrintFloat((float)(op1->f + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5776,7 +5984,7 @@ static unsigned int DoubleAdd(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d + value2);
+exp->string = PrintDouble((double)(op1->d + value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5791,7 +5999,7 @@ static unsigned int IntSub(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i - value2);
+exp->string = PrintInt((op1->i - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5806,7 +6014,7 @@ static unsigned int UIntSub(struct Expression * exp, struct Operand * op1, struc
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui - value2);
+exp->string = PrintUInt((op1->ui - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5818,10 +6026,10 @@ return 0x1;
 
 static unsigned int Int64Sub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i - value2);
+exp->string = PrintInt64((op1->i64 - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5833,10 +6041,10 @@ return 0x1;
 
 static unsigned int UInt64Sub(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui - value2);
+exp->string = PrintUInt64((op1->ui64 - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5851,7 +6059,7 @@ static unsigned int ShortSub(struct Expression * exp, struct Operand * op1, stru
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s - value2);
+exp->string = PrintShort((op1->s - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5866,7 +6074,7 @@ static unsigned int UShortSub(struct Expression * exp, struct Operand * op1, str
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us - value2);
+exp->string = PrintUShort((op1->us - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5881,7 +6089,7 @@ static unsigned int CharSub(struct Expression * exp, struct Operand * op1, struc
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c - value2);
+exp->string = PrintChar((op1->c - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5896,7 +6104,7 @@ static unsigned int UCharSub(struct Expression * exp, struct Operand * op1, stru
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc - value2);
+exp->string = PrintUChar((op1->uc - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5911,7 +6119,7 @@ static unsigned int FloatSub(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f - value2);
+exp->string = PrintFloat((float)(op1->f - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5926,7 +6134,7 @@ static unsigned int DoubleSub(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d - value2);
+exp->string = PrintDouble((double)(op1->d - value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5941,7 +6149,7 @@ static unsigned int IntMul(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i * value2);
+exp->string = PrintInt((op1->i * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5956,7 +6164,7 @@ static unsigned int UIntMul(struct Expression * exp, struct Operand * op1, struc
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui * value2);
+exp->string = PrintUInt((op1->ui * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5968,10 +6176,10 @@ return 0x1;
 
 static unsigned int Int64Mul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i * value2);
+exp->string = PrintInt64((op1->i64 * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -5983,10 +6191,10 @@ return 0x1;
 
 static unsigned int UInt64Mul(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui * value2);
+exp->string = PrintUInt64((op1->ui64 * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6001,7 +6209,7 @@ static unsigned int ShortMul(struct Expression * exp, struct Operand * op1, stru
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s * value2);
+exp->string = PrintShort((op1->s * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6016,7 +6224,7 @@ static unsigned int UShortMul(struct Expression * exp, struct Operand * op1, str
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us * value2);
+exp->string = PrintUShort((op1->us * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6031,7 +6239,7 @@ static unsigned int CharMul(struct Expression * exp, struct Operand * op1, struc
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c * value2);
+exp->string = PrintChar((op1->c * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6046,7 +6254,7 @@ static unsigned int UCharMul(struct Expression * exp, struct Operand * op1, stru
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc * value2);
+exp->string = PrintUChar((op1->uc * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6061,7 +6269,7 @@ static unsigned int FloatMul(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f * value2);
+exp->string = PrintFloat((float)(op1->f * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6076,7 +6284,7 @@ static unsigned int DoubleMul(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d * value2);
+exp->string = PrintDouble((double)(op1->d * value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6118,10 +6326,10 @@ return 0x1;
 
 static unsigned int Int64Div(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(value2 ? (op1->i / value2) : 0);
+exp->string = PrintInt64(value2 ? (op1->i64 / value2) : 0);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6133,10 +6341,10 @@ return 0x1;
 
 static unsigned int UInt64Div(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(value2 ? (op1->ui / value2) : 0);
+exp->string = PrintUInt64(value2 ? (op1->ui64 / value2) : 0);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6211,7 +6419,7 @@ static unsigned int FloatDiv(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(value2 ? (op1->f / value2) : 0);
+exp->string = PrintFloat(op1->f / value2);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6226,7 +6434,7 @@ static unsigned int DoubleDiv(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(value2 ? (op1->d / value2) : 0);
+exp->string = PrintDouble(op1->d / value2);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6268,10 +6476,10 @@ return 0x1;
 
 static unsigned int Int64Mod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(value2 ? (op1->i % value2) : 0);
+exp->string = PrintInt64(value2 ? (op1->i64 % value2) : 0);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6283,10 +6491,10 @@ return 0x1;
 
 static unsigned int UInt64Mod(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(value2 ? (op1->ui % value2) : 0);
+exp->string = PrintUInt64(value2 ? (op1->ui64 % value2) : 0);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6385,7 +6593,7 @@ return 0x1;
 static unsigned int Int64Neg(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintInt64((-op1->i));
+exp->string = PrintInt64((-op1->i64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6398,7 +6606,7 @@ return 0x1;
 static unsigned int UInt64Neg(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintUInt64((unsigned int)(-op1->ui));
+exp->string = PrintUInt64((uint64)(-op1->ui64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6515,7 +6723,7 @@ return 0x1;
 static unsigned int Int64Inc(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintInt64((++op1->i));
+exp->string = PrintInt64((++op1->i64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6528,7 +6736,7 @@ return 0x1;
 static unsigned int UInt64Inc(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintUInt64((++op1->ui));
+exp->string = PrintUInt64((++op1->ui64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6645,7 +6853,7 @@ return 0x1;
 static unsigned int Int64Dec(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintInt64((--op1->i));
+exp->string = PrintInt64((--op1->i64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6658,7 +6866,7 @@ return 0x1;
 static unsigned int UInt64Dec(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintUInt64((--op1->ui));
+exp->string = PrintUInt64((--op1->ui64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6751,7 +6959,7 @@ static unsigned int IntAsign(struct Expression * exp, struct Operand * op1, stru
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i = value2);
+exp->string = PrintInt((op1->i = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6766,7 +6974,7 @@ static unsigned int UIntAsign(struct Expression * exp, struct Operand * op1, str
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui = value2);
+exp->string = PrintUInt((op1->ui = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6778,10 +6986,10 @@ return 0x1;
 
 static unsigned int Int64Asign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i = value2);
+exp->string = PrintInt64((op1->i64 = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6793,10 +7001,10 @@ return 0x1;
 
 static unsigned int UInt64Asign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui = value2);
+exp->string = PrintUInt64((op1->ui64 = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6811,7 +7019,7 @@ static unsigned int ShortAsign(struct Expression * exp, struct Operand * op1, st
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s = value2);
+exp->string = PrintShort((op1->s = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6826,7 +7034,7 @@ static unsigned int UShortAsign(struct Expression * exp, struct Operand * op1, s
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us = value2);
+exp->string = PrintUShort((op1->us = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6841,7 +7049,7 @@ static unsigned int CharAsign(struct Expression * exp, struct Operand * op1, str
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c = value2);
+exp->string = PrintChar((op1->c = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6856,7 +7064,7 @@ static unsigned int UCharAsign(struct Expression * exp, struct Operand * op1, st
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc = value2);
+exp->string = PrintUChar((op1->uc = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6871,7 +7079,7 @@ static unsigned int FloatAsign(struct Expression * exp, struct Operand * op1, st
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f = value2);
+exp->string = PrintFloat((float)(op1->f = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6886,7 +7094,7 @@ static unsigned int DoubleAsign(struct Expression * exp, struct Operand * op1, s
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d = value2);
+exp->string = PrintDouble((double)(op1->d = value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6901,7 +7109,7 @@ static unsigned int IntAddAsign(struct Expression * exp, struct Operand * op1, s
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i += value2);
+exp->string = PrintInt((op1->i += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6916,7 +7124,7 @@ static unsigned int UIntAddAsign(struct Expression * exp, struct Operand * op1,
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui += value2);
+exp->string = PrintUInt((op1->ui += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6928,10 +7136,10 @@ return 0x1;
 
 static unsigned int Int64AddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i += value2);
+exp->string = PrintInt64((op1->i64 += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6943,10 +7151,10 @@ return 0x1;
 
 static unsigned int UInt64AddAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui += value2);
+exp->string = PrintUInt64((op1->ui64 += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6961,7 +7169,7 @@ static unsigned int ShortAddAsign(struct Expression * exp, struct Operand * op1,
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s += value2);
+exp->string = PrintShort((op1->s += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6976,7 +7184,7 @@ static unsigned int UShortAddAsign(struct Expression * exp, struct Operand * op1
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us += value2);
+exp->string = PrintUShort((op1->us += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -6991,7 +7199,7 @@ static unsigned int CharAddAsign(struct Expression * exp, struct Operand * op1,
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c += value2);
+exp->string = PrintChar((op1->c += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7006,7 +7214,7 @@ static unsigned int UCharAddAsign(struct Expression * exp, struct Operand * op1,
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc += value2);
+exp->string = PrintUChar((op1->uc += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7021,7 +7229,7 @@ static unsigned int FloatAddAsign(struct Expression * exp, struct Operand * op1,
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f += value2);
+exp->string = PrintFloat((float)(op1->f += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7036,7 +7244,7 @@ static unsigned int DoubleAddAsign(struct Expression * exp, struct Operand * op1
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d += value2);
+exp->string = PrintDouble((double)(op1->d += value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7051,7 +7259,7 @@ static unsigned int IntSubAsign(struct Expression * exp, struct Operand * op1, s
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i -= value2);
+exp->string = PrintInt((op1->i -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7066,7 +7274,7 @@ static unsigned int UIntSubAsign(struct Expression * exp, struct Operand * op1,
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui -= value2);
+exp->string = PrintUInt((op1->ui -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7078,10 +7286,10 @@ return 0x1;
 
 static unsigned int Int64SubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i -= value2);
+exp->string = PrintInt64((op1->i64 -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7093,10 +7301,10 @@ return 0x1;
 
 static unsigned int UInt64SubAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui -= value2);
+exp->string = PrintUInt64((op1->ui64 -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7111,7 +7319,7 @@ static unsigned int ShortSubAsign(struct Expression * exp, struct Operand * op1,
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s -= value2);
+exp->string = PrintShort((op1->s -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7126,7 +7334,7 @@ static unsigned int UShortSubAsign(struct Expression * exp, struct Operand * op1
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us -= value2);
+exp->string = PrintUShort((op1->us -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7141,7 +7349,7 @@ static unsigned int CharSubAsign(struct Expression * exp, struct Operand * op1,
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c -= value2);
+exp->string = PrintChar((op1->c -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7156,7 +7364,7 @@ static unsigned int UCharSubAsign(struct Expression * exp, struct Operand * op1,
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc -= value2);
+exp->string = PrintUChar((op1->uc -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7171,7 +7379,7 @@ static unsigned int FloatSubAsign(struct Expression * exp, struct Operand * op1,
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f -= value2);
+exp->string = PrintFloat((float)(op1->f -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7186,7 +7394,7 @@ static unsigned int DoubleSubAsign(struct Expression * exp, struct Operand * op1
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d -= value2);
+exp->string = PrintDouble((double)(op1->d -= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7201,7 +7409,7 @@ static unsigned int IntMulAsign(struct Expression * exp, struct Operand * op1, s
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i *= value2);
+exp->string = PrintInt((op1->i *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7216,7 +7424,7 @@ static unsigned int UIntMulAsign(struct Expression * exp, struct Operand * op1,
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui *= value2);
+exp->string = PrintUInt((op1->ui *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7228,10 +7436,10 @@ return 0x1;
 
 static unsigned int Int64MulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i *= value2);
+exp->string = PrintInt64((op1->i64 *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7243,10 +7451,10 @@ return 0x1;
 
 static unsigned int UInt64MulAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui *= value2);
+exp->string = PrintUInt64((op1->ui64 *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7261,7 +7469,7 @@ static unsigned int ShortMulAsign(struct Expression * exp, struct Operand * op1,
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s *= value2);
+exp->string = PrintShort((op1->s *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7276,7 +7484,7 @@ static unsigned int UShortMulAsign(struct Expression * exp, struct Operand * op1
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us *= value2);
+exp->string = PrintUShort((op1->us *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7291,7 +7499,7 @@ static unsigned int CharMulAsign(struct Expression * exp, struct Operand * op1,
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c *= value2);
+exp->string = PrintChar((op1->c *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7306,7 +7514,7 @@ static unsigned int UCharMulAsign(struct Expression * exp, struct Operand * op1,
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc *= value2);
+exp->string = PrintUChar((op1->uc *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7321,7 +7529,7 @@ static unsigned int FloatMulAsign(struct Expression * exp, struct Operand * op1,
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f *= value2);
+exp->string = PrintFloat((float)(op1->f *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7336,7 +7544,7 @@ static unsigned int DoubleMulAsign(struct Expression * exp, struct Operand * op1
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d *= value2);
+exp->string = PrintDouble((double)(op1->d *= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7378,10 +7586,10 @@ return 0x1;
 
 static unsigned int Int64DivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(value2 ? (op1->i /= value2) : 0);
+exp->string = PrintInt64(value2 ? (op1->i64 /= value2) : 0);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7393,10 +7601,10 @@ return 0x1;
 
 static unsigned int UInt64DivAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(value2 ? (op1->ui /= value2) : 0);
+exp->string = PrintUInt64(value2 ? (op1->ui64 /= value2) : 0);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7471,7 +7679,7 @@ static unsigned int FloatDivAsign(struct Expression * exp, struct Operand * op1,
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(value2 ? (op1->f /= value2) : 0);
+exp->string = PrintFloat(op1->f /= value2);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7486,7 +7694,7 @@ static unsigned int DoubleDivAsign(struct Expression * exp, struct Operand * op1
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(value2 ? (op1->d /= value2) : 0);
+exp->string = PrintDouble(op1->d /= value2);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7528,10 +7736,10 @@ return 0x1;
 
 static unsigned int Int64ModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(value2 ? (op1->i %= value2) : 0);
+exp->string = PrintInt64(value2 ? (op1->i64 %= value2) : 0);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7543,10 +7751,10 @@ return 0x1;
 
 static unsigned int UInt64ModAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(value2 ? (op1->ui %= value2) : 0);
+exp->string = PrintUInt64(value2 ? (op1->ui64 %= value2) : 0);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7621,7 +7829,7 @@ static unsigned int IntBitAnd(struct Expression * exp, struct Operand * op1, str
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i & value2);
+exp->string = PrintInt((op1->i & value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7636,7 +7844,7 @@ static unsigned int UIntBitAnd(struct Expression * exp, struct Operand * op1, st
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui & value2);
+exp->string = PrintUInt((op1->ui & value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7648,10 +7856,10 @@ return 0x1;
 
 static unsigned int Int64BitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i & value2);
+exp->string = PrintInt64((op1->i64 & value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7663,10 +7871,10 @@ return 0x1;
 
 static unsigned int UInt64BitAnd(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui & value2);
+exp->string = PrintUInt64((op1->ui64 & value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7681,7 +7889,7 @@ static unsigned int ShortBitAnd(struct Expression * exp, struct Operand * op1, s
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s & value2);
+exp->string = PrintShort((op1->s & value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7696,7 +7904,7 @@ static unsigned int UShortBitAnd(struct Expression * exp, struct Operand * op1,
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us & value2);
+exp->string = PrintUShort((op1->us & value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7711,7 +7919,7 @@ static unsigned int CharBitAnd(struct Expression * exp, struct Operand * op1, st
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c & value2);
+exp->string = PrintChar((op1->c & value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7726,7 +7934,7 @@ static unsigned int UCharBitAnd(struct Expression * exp, struct Operand * op1, s
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc & value2);
+exp->string = PrintUChar((op1->uc & value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7741,7 +7949,7 @@ static unsigned int IntBitOr(struct Expression * exp, struct Operand * op1, stru
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i | value2);
+exp->string = PrintInt((op1->i | value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7756,7 +7964,7 @@ static unsigned int UIntBitOr(struct Expression * exp, struct Operand * op1, str
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui | value2);
+exp->string = PrintUInt((op1->ui | value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7768,10 +7976,10 @@ return 0x1;
 
 static unsigned int Int64BitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i | value2);
+exp->string = PrintInt64((op1->i64 | value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7783,10 +7991,10 @@ return 0x1;
 
 static unsigned int UInt64BitOr(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui | value2);
+exp->string = PrintUInt64((op1->ui64 | value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7801,7 +8009,7 @@ static unsigned int ShortBitOr(struct Expression * exp, struct Operand * op1, st
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s | value2);
+exp->string = PrintShort((op1->s | value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7816,7 +8024,7 @@ static unsigned int UShortBitOr(struct Expression * exp, struct Operand * op1, s
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us | value2);
+exp->string = PrintUShort((op1->us | value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7831,7 +8039,7 @@ static unsigned int CharBitOr(struct Expression * exp, struct Operand * op1, str
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c | value2);
+exp->string = PrintChar((op1->c | value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7846,7 +8054,7 @@ static unsigned int UCharBitOr(struct Expression * exp, struct Operand * op1, st
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc | value2);
+exp->string = PrintUChar((op1->uc | value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7861,7 +8069,7 @@ static unsigned int IntBitXor(struct Expression * exp, struct Operand * op1, str
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i ^ value2);
+exp->string = PrintInt((op1->i ^ value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7876,7 +8084,7 @@ static unsigned int UIntBitXor(struct Expression * exp, struct Operand * op1, st
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui ^ value2);
+exp->string = PrintUInt((op1->ui ^ value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7888,10 +8096,10 @@ return 0x1;
 
 static unsigned int Int64BitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i ^ value2);
+exp->string = PrintInt64((op1->i64 ^ value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7903,10 +8111,10 @@ return 0x1;
 
 static unsigned int UInt64BitXor(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui ^ value2);
+exp->string = PrintUInt64((op1->ui64 ^ value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7921,7 +8129,7 @@ static unsigned int ShortBitXor(struct Expression * exp, struct Operand * op1, s
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s ^ value2);
+exp->string = PrintShort((op1->s ^ value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7936,7 +8144,7 @@ static unsigned int UShortBitXor(struct Expression * exp, struct Operand * op1,
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us ^ value2);
+exp->string = PrintUShort((op1->us ^ value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7951,7 +8159,7 @@ static unsigned int CharBitXor(struct Expression * exp, struct Operand * op1, st
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c ^ value2);
+exp->string = PrintChar((op1->c ^ value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7966,7 +8174,7 @@ static unsigned int UCharBitXor(struct Expression * exp, struct Operand * op1, s
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc ^ value2);
+exp->string = PrintUChar((op1->uc ^ value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7981,7 +8189,7 @@ static unsigned int IntLShift(struct Expression * exp, struct Operand * op1, str
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i << value2);
+exp->string = PrintInt((op1->i << value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -7996,7 +8204,7 @@ static unsigned int UIntLShift(struct Expression * exp, struct Operand * op1, st
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui << value2);
+exp->string = PrintUInt((op1->ui << value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8008,10 +8216,10 @@ return 0x1;
 
 static unsigned int Int64LShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i << value2);
+exp->string = PrintInt64((op1->i64 << value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8023,10 +8231,10 @@ return 0x1;
 
 static unsigned int UInt64LShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui << value2);
+exp->string = PrintUInt64((op1->ui64 << value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8041,7 +8249,7 @@ static unsigned int ShortLShift(struct Expression * exp, struct Operand * op1, s
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s << value2);
+exp->string = PrintShort((op1->s << value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8056,7 +8264,7 @@ static unsigned int UShortLShift(struct Expression * exp, struct Operand * op1,
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us << value2);
+exp->string = PrintUShort((op1->us << value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8071,7 +8279,7 @@ static unsigned int CharLShift(struct Expression * exp, struct Operand * op1, st
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c << value2);
+exp->string = PrintChar((op1->c << value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8086,7 +8294,7 @@ static unsigned int UCharLShift(struct Expression * exp, struct Operand * op1, s
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc << value2);
+exp->string = PrintUChar((op1->uc << value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8101,7 +8309,7 @@ static unsigned int IntRShift(struct Expression * exp, struct Operand * op1, str
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i >> value2);
+exp->string = PrintInt((op1->i >> value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8116,7 +8324,7 @@ static unsigned int UIntRShift(struct Expression * exp, struct Operand * op1, st
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui >> value2);
+exp->string = PrintUInt((op1->ui >> value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8128,10 +8336,10 @@ return 0x1;
 
 static unsigned int Int64RShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i >> value2);
+exp->string = PrintInt64((op1->i64 >> value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8143,10 +8351,10 @@ return 0x1;
 
 static unsigned int UInt64RShift(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui >> value2);
+exp->string = PrintUInt64((op1->ui64 >> value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8161,7 +8369,7 @@ static unsigned int ShortRShift(struct Expression * exp, struct Operand * op1, s
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s >> value2);
+exp->string = PrintShort((op1->s >> value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8176,7 +8384,7 @@ static unsigned int UShortRShift(struct Expression * exp, struct Operand * op1,
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us >> value2);
+exp->string = PrintUShort((op1->us >> value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8191,7 +8399,7 @@ static unsigned int CharRShift(struct Expression * exp, struct Operand * op1, st
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c >> value2);
+exp->string = PrintChar((op1->c >> value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8206,7 +8414,7 @@ static unsigned int UCharRShift(struct Expression * exp, struct Operand * op1, s
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc >> value2);
+exp->string = PrintUChar((op1->uc >> value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8245,7 +8453,7 @@ return 0x1;
 static unsigned int Int64BitNot(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintInt64((~op1->i));
+exp->string = PrintInt64((long long)(~op1->i64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8258,7 +8466,7 @@ return 0x1;
 static unsigned int UInt64BitNot(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintUInt64((unsigned int)(~op1->ui));
+exp->string = PrintUInt64((uint64)(~op1->ui64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8325,7 +8533,7 @@ static unsigned int IntAndAsign(struct Expression * exp, struct Operand * op1, s
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i &= value2);
+exp->string = PrintInt((op1->i &= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8340,7 +8548,7 @@ static unsigned int UIntAndAsign(struct Expression * exp, struct Operand * op1,
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui &= value2);
+exp->string = PrintUInt((op1->ui &= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8352,10 +8560,10 @@ return 0x1;
 
 static unsigned int Int64AndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i &= value2);
+exp->string = PrintInt64((op1->i64 &= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8367,10 +8575,10 @@ return 0x1;
 
 static unsigned int UInt64AndAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui &= value2);
+exp->string = PrintUInt64((op1->ui64 &= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8385,7 +8593,7 @@ static unsigned int ShortAndAsign(struct Expression * exp, struct Operand * op1,
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s &= value2);
+exp->string = PrintShort((op1->s &= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8400,7 +8608,7 @@ static unsigned int UShortAndAsign(struct Expression * exp, struct Operand * op1
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us &= value2);
+exp->string = PrintUShort((op1->us &= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8415,7 +8623,7 @@ static unsigned int CharAndAsign(struct Expression * exp, struct Operand * op1,
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c &= value2);
+exp->string = PrintChar((op1->c &= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8430,7 +8638,7 @@ static unsigned int UCharAndAsign(struct Expression * exp, struct Operand * op1,
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc &= value2);
+exp->string = PrintUChar((op1->uc &= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8445,7 +8653,7 @@ static unsigned int IntOrAsign(struct Expression * exp, struct Operand * op1, st
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i |= value2);
+exp->string = PrintInt((op1->i |= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8460,7 +8668,7 @@ static unsigned int UIntOrAsign(struct Expression * exp, struct Operand * op1, s
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui |= value2);
+exp->string = PrintUInt((op1->ui |= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8472,10 +8680,10 @@ return 0x1;
 
 static unsigned int Int64OrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i |= value2);
+exp->string = PrintInt64((op1->i64 |= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8487,10 +8695,10 @@ return 0x1;
 
 static unsigned int UInt64OrAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui |= value2);
+exp->string = PrintUInt64((op1->ui64 |= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8505,7 +8713,7 @@ static unsigned int ShortOrAsign(struct Expression * exp, struct Operand * op1,
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s |= value2);
+exp->string = PrintShort((op1->s |= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8520,7 +8728,7 @@ static unsigned int UShortOrAsign(struct Expression * exp, struct Operand * op1,
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us |= value2);
+exp->string = PrintUShort((op1->us |= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8535,7 +8743,7 @@ static unsigned int CharOrAsign(struct Expression * exp, struct Operand * op1, s
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c |= value2);
+exp->string = PrintChar((op1->c |= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8550,7 +8758,7 @@ static unsigned int UCharOrAsign(struct Expression * exp, struct Operand * op1,
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc |= value2);
+exp->string = PrintUChar((op1->uc |= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8565,7 +8773,7 @@ static unsigned int IntXorAsign(struct Expression * exp, struct Operand * op1, s
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i ^= value2);
+exp->string = PrintInt((op1->i ^= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8580,7 +8788,7 @@ static unsigned int UIntXorAsign(struct Expression * exp, struct Operand * op1,
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui ^= value2);
+exp->string = PrintUInt((op1->ui ^= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8592,10 +8800,10 @@ return 0x1;
 
 static unsigned int Int64XorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i ^= value2);
+exp->string = PrintInt64((op1->i64 ^= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8607,10 +8815,10 @@ return 0x1;
 
 static unsigned int UInt64XorAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui ^= value2);
+exp->string = PrintUInt64((op1->ui64 ^= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8625,7 +8833,7 @@ static unsigned int ShortXorAsign(struct Expression * exp, struct Operand * op1,
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s ^= value2);
+exp->string = PrintShort((op1->s ^= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8640,7 +8848,7 @@ static unsigned int UShortXorAsign(struct Expression * exp, struct Operand * op1
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us ^= value2);
+exp->string = PrintUShort((op1->us ^= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8655,7 +8863,7 @@ static unsigned int CharXorAsign(struct Expression * exp, struct Operand * op1,
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c ^= value2);
+exp->string = PrintChar((op1->c ^= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8670,7 +8878,7 @@ static unsigned int UCharXorAsign(struct Expression * exp, struct Operand * op1,
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc ^= value2);
+exp->string = PrintUChar((op1->uc ^= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8685,7 +8893,7 @@ static unsigned int IntLShiftAsign(struct Expression * exp, struct Operand * op1
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i <<= value2);
+exp->string = PrintInt((op1->i <<= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8700,7 +8908,7 @@ static unsigned int UIntLShiftAsign(struct Expression * exp, struct Operand * op
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui <<= value2);
+exp->string = PrintUInt((op1->ui <<= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8712,10 +8920,10 @@ return 0x1;
 
 static unsigned int Int64LShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i <<= value2);
+exp->string = PrintInt64((op1->i64 <<= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8727,10 +8935,10 @@ return 0x1;
 
 static unsigned int UInt64LShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui <<= value2);
+exp->string = PrintUInt64((op1->ui64 <<= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8745,7 +8953,7 @@ static unsigned int ShortLShiftAsign(struct Expression * exp, struct Operand * o
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s <<= value2);
+exp->string = PrintShort((op1->s <<= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8760,7 +8968,7 @@ static unsigned int UShortLShiftAsign(struct Expression * exp, struct Operand *
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us <<= value2);
+exp->string = PrintUShort((op1->us <<= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8775,7 +8983,7 @@ static unsigned int CharLShiftAsign(struct Expression * exp, struct Operand * op
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c <<= value2);
+exp->string = PrintChar((op1->c <<= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8790,7 +8998,7 @@ static unsigned int UCharLShiftAsign(struct Expression * exp, struct Operand * o
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc <<= value2);
+exp->string = PrintUChar((op1->uc <<= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8805,7 +9013,7 @@ static unsigned int IntRShiftAsign(struct Expression * exp, struct Operand * op1
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i >>= value2);
+exp->string = PrintInt((op1->i >>= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8820,7 +9028,7 @@ static unsigned int UIntRShiftAsign(struct Expression * exp, struct Operand * op
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui >>= value2);
+exp->string = PrintUInt((op1->ui >>= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8832,10 +9040,10 @@ return 0x1;
 
 static unsigned int Int64RShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i >>= value2);
+exp->string = PrintInt64((op1->i64 >>= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8847,10 +9055,10 @@ return 0x1;
 
 static unsigned int UInt64RShiftAsign(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui >>= value2);
+exp->string = PrintUInt64((op1->ui64 >>= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8865,7 +9073,7 @@ static unsigned int ShortRShiftAsign(struct Expression * exp, struct Operand * o
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s >>= value2);
+exp->string = PrintShort((op1->s >>= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8880,7 +9088,7 @@ static unsigned int UShortRShiftAsign(struct Expression * exp, struct Operand *
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us >>= value2);
+exp->string = PrintUShort((op1->us >>= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8895,7 +9103,7 @@ static unsigned int CharRShiftAsign(struct Expression * exp, struct Operand * op
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c >>= value2);
+exp->string = PrintChar((op1->c >>= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8910,7 +9118,7 @@ static unsigned int UCharRShiftAsign(struct Expression * exp, struct Operand * o
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc >>= value2);
+exp->string = PrintUChar((op1->uc >>= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8949,7 +9157,7 @@ return 0x1;
 static unsigned int Int64Not(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintInt64((int)(!op1->i));
+exp->string = PrintInt64((long long)(!op1->i64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -8962,7 +9170,7 @@ return 0x1;
 static unsigned int UInt64Not(struct Expression * exp, struct Operand * op1)
 {
 exp->type = 2;
-exp->string = PrintUInt64((unsigned int)(!op1->ui));
+exp->string = PrintUInt64((uint64)(!op1->ui64));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9029,7 +9237,7 @@ static unsigned int IntEqu(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i == value2);
+exp->string = PrintInt((int)(op1->i == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9044,7 +9252,7 @@ static unsigned int UIntEqu(struct Expression * exp, struct Operand * op1, struc
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui == value2);
+exp->string = PrintUInt((unsigned int)(op1->ui == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9056,10 +9264,10 @@ return 0x1;
 
 static unsigned int Int64Equ(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i == value2);
+exp->string = PrintInt64((long long)(op1->i64 == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9071,10 +9279,10 @@ return 0x1;
 
 static unsigned int UInt64Equ(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui == value2);
+exp->string = PrintUInt64((uint64)(op1->ui64 == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9089,7 +9297,7 @@ static unsigned int ShortEqu(struct Expression * exp, struct Operand * op1, stru
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s == value2);
+exp->string = PrintShort((short)(op1->s == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9104,7 +9312,7 @@ static unsigned int UShortEqu(struct Expression * exp, struct Operand * op1, str
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us == value2);
+exp->string = PrintUShort((unsigned short)(op1->us == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9119,7 +9327,7 @@ static unsigned int CharEqu(struct Expression * exp, struct Operand * op1, struc
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c == value2);
+exp->string = PrintChar((char)(op1->c == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9134,7 +9342,7 @@ static unsigned int UCharEqu(struct Expression * exp, struct Operand * op1, stru
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc == value2);
+exp->string = PrintUChar((unsigned char)(op1->uc == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9149,7 +9357,7 @@ static unsigned int FloatEqu(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f == value2);
+exp->string = PrintFloat((float)(op1->f == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9164,7 +9372,7 @@ static unsigned int DoubleEqu(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d == value2);
+exp->string = PrintDouble((double)(op1->d == value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9179,7 +9387,7 @@ static unsigned int IntNqu(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i != value2);
+exp->string = PrintInt((int)(op1->i != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9194,7 +9402,7 @@ static unsigned int UIntNqu(struct Expression * exp, struct Operand * op1, struc
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui != value2);
+exp->string = PrintUInt((unsigned int)(op1->ui != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9206,10 +9414,10 @@ return 0x1;
 
 static unsigned int Int64Nqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i != value2);
+exp->string = PrintInt64((long long)(op1->i64 != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9221,10 +9429,10 @@ return 0x1;
 
 static unsigned int UInt64Nqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui != value2);
+exp->string = PrintUInt64((uint64)(op1->ui64 != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9239,7 +9447,7 @@ static unsigned int ShortNqu(struct Expression * exp, struct Operand * op1, stru
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s != value2);
+exp->string = PrintShort((short)(op1->s != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9254,7 +9462,7 @@ static unsigned int UShortNqu(struct Expression * exp, struct Operand * op1, str
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us != value2);
+exp->string = PrintUShort((unsigned short)(op1->us != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9269,7 +9477,7 @@ static unsigned int CharNqu(struct Expression * exp, struct Operand * op1, struc
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c != value2);
+exp->string = PrintChar((char)(op1->c != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9284,7 +9492,7 @@ static unsigned int UCharNqu(struct Expression * exp, struct Operand * op1, stru
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc != value2);
+exp->string = PrintUChar((unsigned char)(op1->uc != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9299,7 +9507,7 @@ static unsigned int FloatNqu(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f != value2);
+exp->string = PrintFloat((float)(op1->f != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9314,7 +9522,7 @@ static unsigned int DoubleNqu(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d != value2);
+exp->string = PrintDouble((double)(op1->d != value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9329,7 +9537,7 @@ static unsigned int IntAnd(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i && value2);
+exp->string = PrintInt((int)(op1->i && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9344,7 +9552,7 @@ static unsigned int UIntAnd(struct Expression * exp, struct Operand * op1, struc
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui && value2);
+exp->string = PrintUInt((unsigned int)(op1->ui && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9356,10 +9564,10 @@ return 0x1;
 
 static unsigned int Int64And(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i && value2);
+exp->string = PrintInt64((long long)(op1->i64 && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9371,10 +9579,10 @@ return 0x1;
 
 static unsigned int UInt64And(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui && value2);
+exp->string = PrintUInt64((uint64)(op1->ui64 && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9389,7 +9597,7 @@ static unsigned int ShortAnd(struct Expression * exp, struct Operand * op1, stru
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s && value2);
+exp->string = PrintShort((short)(op1->s && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9404,7 +9612,7 @@ static unsigned int UShortAnd(struct Expression * exp, struct Operand * op1, str
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us && value2);
+exp->string = PrintUShort((unsigned short)(op1->us && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9419,7 +9627,7 @@ static unsigned int CharAnd(struct Expression * exp, struct Operand * op1, struc
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c && value2);
+exp->string = PrintChar((char)(op1->c && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9434,7 +9642,7 @@ static unsigned int UCharAnd(struct Expression * exp, struct Operand * op1, stru
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc && value2);
+exp->string = PrintUChar((unsigned char)(op1->uc && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9449,7 +9657,7 @@ static unsigned int FloatAnd(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f && value2);
+exp->string = PrintFloat((float)(op1->f && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9464,7 +9672,7 @@ static unsigned int DoubleAnd(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d && value2);
+exp->string = PrintDouble((double)(op1->d && value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9479,7 +9687,7 @@ static unsigned int IntOr(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i || value2);
+exp->string = PrintInt((int)(op1->i || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9494,7 +9702,7 @@ static unsigned int UIntOr(struct Expression * exp, struct Operand * op1, struct
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui || value2);
+exp->string = PrintUInt((unsigned int)(op1->ui || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9506,10 +9714,10 @@ return 0x1;
 
 static unsigned int Int64Or(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i || value2);
+exp->string = PrintInt64((long long)(op1->i64 || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9521,10 +9729,10 @@ return 0x1;
 
 static unsigned int UInt64Or(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui || value2);
+exp->string = PrintUInt64((uint64)(op1->ui64 || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9539,7 +9747,7 @@ static unsigned int ShortOr(struct Expression * exp, struct Operand * op1, struc
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s || value2);
+exp->string = PrintShort((short)(op1->s || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9554,7 +9762,7 @@ static unsigned int UShortOr(struct Expression * exp, struct Operand * op1, stru
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us || value2);
+exp->string = PrintUShort((unsigned short)(op1->us || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9569,7 +9777,7 @@ static unsigned int CharOr(struct Expression * exp, struct Operand * op1, struct
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c || value2);
+exp->string = PrintChar((char)(op1->c || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9584,7 +9792,7 @@ static unsigned int UCharOr(struct Expression * exp, struct Operand * op1, struc
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc || value2);
+exp->string = PrintUChar((unsigned char)(op1->uc || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9599,7 +9807,7 @@ static unsigned int FloatOr(struct Expression * exp, struct Operand * op1, struc
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f || value2);
+exp->string = PrintFloat((float)(op1->f || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9614,7 +9822,7 @@ static unsigned int DoubleOr(struct Expression * exp, struct Operand * op1, stru
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d || value2);
+exp->string = PrintDouble((double)(op1->d || value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9629,7 +9837,7 @@ static unsigned int IntGrt(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i > value2);
+exp->string = PrintInt((int)(op1->i > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9644,7 +9852,7 @@ static unsigned int UIntGrt(struct Expression * exp, struct Operand * op1, struc
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui > value2);
+exp->string = PrintUInt((unsigned int)(op1->ui > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9656,10 +9864,10 @@ return 0x1;
 
 static unsigned int Int64Grt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i > value2);
+exp->string = PrintInt64((long long)(op1->i64 > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9671,10 +9879,10 @@ return 0x1;
 
 static unsigned int UInt64Grt(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui > value2);
+exp->string = PrintUInt64((uint64)(op1->ui64 > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9689,7 +9897,7 @@ static unsigned int ShortGrt(struct Expression * exp, struct Operand * op1, stru
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s > value2);
+exp->string = PrintShort((short)(op1->s > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9704,7 +9912,7 @@ static unsigned int UShortGrt(struct Expression * exp, struct Operand * op1, str
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us > value2);
+exp->string = PrintUShort((unsigned short)(op1->us > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9719,7 +9927,7 @@ static unsigned int CharGrt(struct Expression * exp, struct Operand * op1, struc
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c > value2);
+exp->string = PrintChar((char)(op1->c > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9734,7 +9942,7 @@ static unsigned int UCharGrt(struct Expression * exp, struct Operand * op1, stru
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc > value2);
+exp->string = PrintUChar((unsigned char)(op1->uc > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9749,7 +9957,7 @@ static unsigned int FloatGrt(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f > value2);
+exp->string = PrintFloat((float)(op1->f > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9764,7 +9972,7 @@ static unsigned int DoubleGrt(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d > value2);
+exp->string = PrintDouble((double)(op1->d > value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9779,7 +9987,7 @@ static unsigned int IntSma(struct Expression * exp, struct Operand * op1, struct
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i < value2);
+exp->string = PrintInt((int)(op1->i < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9794,7 +10002,7 @@ static unsigned int UIntSma(struct Expression * exp, struct Operand * op1, struc
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui < value2);
+exp->string = PrintUInt((unsigned int)(op1->ui < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9806,10 +10014,10 @@ return 0x1;
 
 static unsigned int Int64Sma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i < value2);
+exp->string = PrintInt64((long long)(op1->i64 < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9821,10 +10029,10 @@ return 0x1;
 
 static unsigned int UInt64Sma(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui < value2);
+exp->string = PrintUInt64((uint64)(op1->ui64 < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9839,7 +10047,7 @@ static unsigned int ShortSma(struct Expression * exp, struct Operand * op1, stru
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s < value2);
+exp->string = PrintShort((short)(op1->s < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9854,7 +10062,7 @@ static unsigned int UShortSma(struct Expression * exp, struct Operand * op1, str
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us < value2);
+exp->string = PrintUShort((unsigned short)(op1->us < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9869,7 +10077,7 @@ static unsigned int CharSma(struct Expression * exp, struct Operand * op1, struc
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c < value2);
+exp->string = PrintChar((char)(op1->c < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9884,7 +10092,7 @@ static unsigned int UCharSma(struct Expression * exp, struct Operand * op1, stru
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc < value2);
+exp->string = PrintUChar((unsigned char)(op1->uc < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9899,7 +10107,7 @@ static unsigned int FloatSma(struct Expression * exp, struct Operand * op1, stru
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f < value2);
+exp->string = PrintFloat((float)(op1->f < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9914,7 +10122,7 @@ static unsigned int DoubleSma(struct Expression * exp, struct Operand * op1, str
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d < value2);
+exp->string = PrintDouble((double)(op1->d < value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9929,7 +10137,7 @@ static unsigned int IntGrtEqu(struct Expression * exp, struct Operand * op1, str
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i >= value2);
+exp->string = PrintInt((int)(op1->i >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9944,7 +10152,7 @@ static unsigned int UIntGrtEqu(struct Expression * exp, struct Operand * op1, st
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui >= value2);
+exp->string = PrintUInt((unsigned int)(op1->ui >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9956,10 +10164,10 @@ return 0x1;
 
 static unsigned int Int64GrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i >= value2);
+exp->string = PrintInt64((long long)(op1->i64 >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9971,10 +10179,10 @@ return 0x1;
 
 static unsigned int UInt64GrtEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui >= value2);
+exp->string = PrintUInt64((uint64)(op1->ui64 >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -9989,7 +10197,7 @@ static unsigned int ShortGrtEqu(struct Expression * exp, struct Operand * op1, s
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s >= value2);
+exp->string = PrintShort((short)(op1->s >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10004,7 +10212,7 @@ static unsigned int UShortGrtEqu(struct Expression * exp, struct Operand * op1,
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us >= value2);
+exp->string = PrintUShort((unsigned short)(op1->us >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10019,7 +10227,7 @@ static unsigned int CharGrtEqu(struct Expression * exp, struct Operand * op1, st
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c >= value2);
+exp->string = PrintChar((char)(op1->c >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10034,7 +10242,7 @@ static unsigned int UCharGrtEqu(struct Expression * exp, struct Operand * op1, s
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc >= value2);
+exp->string = PrintUChar((unsigned char)(op1->uc >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10049,7 +10257,7 @@ static unsigned int FloatGrtEqu(struct Expression * exp, struct Operand * op1, s
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f >= value2);
+exp->string = PrintFloat((float)(op1->f >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10064,7 +10272,7 @@ static unsigned int DoubleGrtEqu(struct Expression * exp, struct Operand * op1,
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d >= value2);
+exp->string = PrintDouble((double)(op1->d >= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10079,7 +10287,7 @@ static unsigned int IntSmaEqu(struct Expression * exp, struct Operand * op1, str
 int value2 = op2->i;
 
 exp->type = 2;
-exp->string = PrintInt(op1->i <= value2);
+exp->string = PrintInt((int)(op1->i <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10094,7 +10302,7 @@ static unsigned int UIntSmaEqu(struct Expression * exp, struct Operand * op1, st
 unsigned int value2 = op2->ui;
 
 exp->type = 2;
-exp->string = PrintUInt(op1->ui <= value2);
+exp->string = PrintUInt((unsigned int)(op1->ui <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10106,10 +10314,10 @@ return 0x1;
 
 static unsigned int Int64SmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-int value2 = op2->i;
+long long value2 = op2->i64;
 
 exp->type = 2;
-exp->string = PrintInt64(op1->i <= value2);
+exp->string = PrintInt64((long long)(op1->i64 <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10121,10 +10329,10 @@ return 0x1;
 
 static unsigned int UInt64SmaEqu(struct Expression * exp, struct Operand * op1, struct Operand * op2)
 {
-unsigned int value2 = op2->ui;
+uint64 value2 = op2->ui64;
 
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui <= value2);
+exp->string = PrintUInt64((uint64)(op1->ui64 <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10139,7 +10347,7 @@ static unsigned int ShortSmaEqu(struct Expression * exp, struct Operand * op1, s
 short value2 = op2->s;
 
 exp->type = 2;
-exp->string = PrintShort(op1->s <= value2);
+exp->string = PrintShort((short)(op1->s <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10154,7 +10362,7 @@ static unsigned int UShortSmaEqu(struct Expression * exp, struct Operand * op1,
 unsigned short value2 = op2->us;
 
 exp->type = 2;
-exp->string = PrintUShort(op1->us <= value2);
+exp->string = PrintUShort((unsigned short)(op1->us <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10169,7 +10377,7 @@ static unsigned int CharSmaEqu(struct Expression * exp, struct Operand * op1, st
 char value2 = op2->c;
 
 exp->type = 2;
-exp->string = PrintChar(op1->c <= value2);
+exp->string = PrintChar((char)(op1->c <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10184,7 +10392,7 @@ static unsigned int UCharSmaEqu(struct Expression * exp, struct Operand * op1, s
 unsigned char value2 = op2->uc;
 
 exp->type = 2;
-exp->string = PrintUChar(op1->uc <= value2);
+exp->string = PrintUChar((unsigned char)(op1->uc <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10199,7 +10407,7 @@ static unsigned int FloatSmaEqu(struct Expression * exp, struct Operand * op1, s
 float value2 = op2->f;
 
 exp->type = 2;
-exp->string = PrintFloat(op1->f <= value2);
+exp->string = PrintFloat((float)(op1->f <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10214,7 +10422,7 @@ static unsigned int DoubleSmaEqu(struct Expression * exp, struct Operand * op1,
 double value2 = op2->d;
 
 exp->type = 2;
-exp->string = PrintDouble(op1->d <= value2);
+exp->string = PrintDouble((double)(op1->d <= value2));
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10253,7 +10461,7 @@ return 0x1;
 static unsigned int Int64Cond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
 {
 exp->type = 2;
-exp->string = PrintInt64(op1->i ? op2->i : op3->i);
+exp->string = PrintInt64(op1->i64 ? op2->i64 : op3->i64);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10266,7 +10474,7 @@ return 0x1;
 static unsigned int UInt64Cond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
 {
 exp->type = 2;
-exp->string = PrintUInt64(op1->ui ? op2->ui : op3->ui);
+exp->string = PrintUInt64(op1->ui64 ? op2->ui64 : op3->ui64);
 if(!exp->expType)
 {
 exp->expType = op1->type;
@@ -10328,32 +10536,6 @@ op1->type->refCount++;
 return 0x1;
 }
 
-static unsigned int FloatCond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
-{
-exp->type = 2;
-exp->string = PrintFloat(op1->f ? op2->f : op3->f);
-if(!exp->expType)
-{
-exp->expType = op1->type;
-if(op1->type)
-op1->type->refCount++;
-}
-return 0x1;
-}
-
-static unsigned int DoubleCond(struct Expression * exp, struct Operand * op1, struct Operand * op2, struct Operand * op3)
-{
-exp->type = 2;
-exp->string = PrintDouble(op1->d ? op2->d : op3->d);
-if(!exp->expType)
-{
-exp->expType = op1->type;
-if(op1->type)
-op1->type->refCount++;
-}
-return 0x1;
-}
-
 struct OpTable intOps = 
 {
 IntAdd, IntSub, IntMul, IntDiv, IntMod, IntNeg, IntInc, IntDec, IntAsign, IntAddAsign, IntSubAsign, IntMulAsign, IntDivAsign, IntModAsign, IntBitAnd, IntBitOr, IntBitXor, IntLShift, IntRShift, IntBitNot, IntAndAsign, IntOrAsign, IntXorAsign, IntLShiftAsign, IntRShiftAsign, IntNot, IntEqu, IntNqu, IntAnd, IntOr, IntGrt, IntSma, IntGrtEqu, IntSmaEqu, IntCond
@@ -10445,8 +10627,10 @@ break;
 case '\"':
 output[d] = '\"';
 break;
+case '\'':
+output[d] = '\'';
+break;
 default:
-output[d++] = '\\';
 output[d] = ch;
 }
 d++;
@@ -10468,12 +10652,90 @@ output[d++] = ch;
 output[d] = '\0';
 }
 
+int UnescapeString(char * d, char * s, int len)
+{
+int j = 0, k = 0;
+char ch;
+
+while(j < len && (ch = s[j]))
+{
+switch(ch)
+{
+case '\\':
+switch((ch = s[++j]))
+{
+case 'n':
+d[k] = '\n';
+break;
+case 't':
+d[k] = '\t';
+break;
+case 'a':
+d[k] = '\a';
+break;
+case 'b':
+d[k] = '\b';
+break;
+case 'f':
+d[k] = '\f';
+break;
+case 'r':
+d[k] = '\r';
+break;
+case 'v':
+d[k] = '\v';
+break;
+case '\\':
+d[k] = '\\';
+break;
+case '\"':
+d[k] = '\"';
+break;
+case '\'':
+d[k] = '\'';
+break;
+default:
+d[k] = '\\';
+d[k] = ch;
+}
+break;
+default:
+d[k] = ch;
+}
+j++, k++;
+}
+d[k] = '\0';
+return k;
+}
+
+char * OffsetEscapedString(char * s, int len, int offset)
+{
+char ch;
+int j = 0, k = 0;
+
+while(j < len && k < offset && (ch = s[j]))
+{
+if(ch == '\\')
+++j;
+j++, k++;
+}
+return (k == offset) ? s + j : (((void *)0));
+}
+
 extern long long __ecereNameSpace__ecere__com___strtoi64(char *  string, char * *  endString, int base);
 
 extern uint64 __ecereNameSpace__ecere__com___strtoui64(char *  string, char * *  endString, int base);
 
 extern double strtod(char * , char * * );
 
+extern float (* __ecereMethod_float_inf)(void);
+
+extern float (* __ecereMethod_float_nan)(void);
+
+extern double (* __ecereMethod_double_inf)(void);
+
+extern double (* __ecereMethod_double_nan)(void);
+
 struct Operand GetOperand(struct Expression * exp)
 {
 struct Operand op = 
@@ -10493,17 +10755,26 @@ if(!type->_class->registered->dataType)
 type->_class->registered->dataType = ProcessTypeString(type->_class->registered->dataTypeString, 0x0);
 type = type->_class->registered->dataType;
 }
+if(exp->type == 3 && op.kind == 13)
+{
+op.ui64 = (uint64)exp->string;
+op.kind = 13;
+op.ops = uint64Ops;
+}
+else if(exp->isConstant && exp->type == 2)
+{
 op.kind = type->kind;
 op.type = exp->expType;
-if(exp->isConstant && exp->type == 2)
-{
 switch(op.kind)
 {
 case 24:
 case 1:
 {
 if(exp->constant[0] == '\'')
+{
 op.c = exp->constant[1];
+op.ops = charOps;
+}
 else if(type->isSigned)
 {
 op.c = (char)strtol(exp->constant, (((void *)0)), 0);
@@ -10546,12 +10817,12 @@ case 4:
 if(type->isSigned)
 {
 op.i64 = __ecereNameSpace__ecere__com___strtoi64(exp->constant, (((void *)0)), 0);
-op.ops = intOps;
+op.ops = int64Ops;
 }
 else
 {
 op.ui64 = __ecereNameSpace__ecere__com___strtoui64(exp->constant, (((void *)0)), 0);
-op.ops = uintOps;
+op.ops = uint64Ops;
 }
 op.kind = 4;
 break;
@@ -10582,10 +10853,28 @@ op.ops = uint64Ops;
 op.kind = 4;
 break;
 case 6:
+if(!strcmp(exp->constant, "inf"))
+op.f = __ecereMethod_float_inf();
+else if(!strcmp(exp->constant, "-inf"))
+op.f = -__ecereMethod_float_inf();
+else if(!strcmp(exp->constant, "nan"))
+op.f = __ecereMethod_float_nan();
+else if(!strcmp(exp->constant, "-nan"))
+op.f = -__ecereMethod_float_nan();
+else
 op.f = (float)strtod(exp->constant, (((void *)0)));
 op.ops = floatOps;
 break;
 case 7:
+if(!strcmp(exp->constant, "inf"))
+op.d = __ecereMethod_double_inf();
+else if(!strcmp(exp->constant, "-inf"))
+op.d = -__ecereMethod_double_inf();
+else if(!strcmp(exp->constant, "nan"))
+op.d = __ecereMethod_double_nan();
+else if(!strcmp(exp->constant, "-nan"))
+op.d = -__ecereMethod_double_nan();
+else
 op.d = (double)strtod(exp->constant, (((void *)0)));
 op.ops = doubleOps;
 break;
@@ -10594,7 +10883,7 @@ case 13:
 case 8:
 op.ui64 = __ecereNameSpace__ecere__com___strtoui64(exp->constant, (((void *)0)), 0);
 op.kind = 13;
-op.ops = uintOps;
+op.ops = uint64Ops;
 break;
 }
 }
@@ -10720,7 +11009,7 @@ exp->type = 2;
 break;
 }
 default:
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Unhandled type populating instance\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Unhandled type populating instance\n", (((void *)0))));
 }
 }
 ListAdd(memberList, member);
@@ -10834,7 +11123,7 @@ exp->type = 2;
 break;
 }
 default:
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Unhandled type populating instance\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Unhandled type populating instance\n", (((void *)0))));
 }
 }
 ListAdd(memberList, member);
@@ -11200,9 +11489,8 @@ else if(dataMember)
 {
 struct __ecereNameSpace__ecere__com__BitMember * bitMember = (struct __ecereNameSpace__ecere__com__BitMember *)dataMember;
 struct Type * type;
-int part = 0;
+uint64 part;
 
-GetInt(value, &part);
 bits = (bits & ~bitMember->mask);
 if(!bitMember->dataType)
 bitMember->dataType = ProcessTypeString(bitMember->dataTypeString, 0x0);
@@ -11217,52 +11505,57 @@ switch(type->kind)
 {
 case 24:
 case 1:
-if(type->isSigned)
-bits |= ((char)part << bitMember->pos);
-else
-bits |= ((unsigned char)part << bitMember->pos);
+{
+unsigned char v;
+
+type->isSigned ? GetChar(value, &v) : GetUChar(value, &v);
+part = (uint64)v;
 break;
+}
 case 2:
-if(type->isSigned)
-bits |= ((short)part << bitMember->pos);
-else
-bits |= ((unsigned short)part << bitMember->pos);
-break;
+{
+unsigned short v;
+
+type->isSigned ? GetShort(value, &v) : GetUShort(value, &v);
+part = (uint64)v;
+break;
+}
 case 3:
 case 5:
-if(type->isSigned)
-bits |= (part << bitMember->pos);
-else
-bits |= ((unsigned int)part << bitMember->pos);
+{
+unsigned int v;
+
+type->isSigned ? GetInt(value, &v) : GetUInt(value, &v);
+part = (uint64)v;
 break;
+}
 case 4:
-if(type->isSigned)
-bits |= ((long long)part << bitMember->pos);
-else
-bits |= ((uint64)part << bitMember->pos);
-break;
-case 22:
-if(type->isSigned)
 {
-bits |= ((intptr_t)part << bitMember->pos);
+uint64 v;
+
+type->isSigned ? GetInt64(value, &v) : GetUInt64(value, &v);
+part = v;
+break;
 }
-else
+case 22:
 {
-bits |= ((uintptr_t)part << bitMember->pos);
-}
+intptr_t v;
+
+type->isSigned ? GetIntPtr(value, &v) : GetUIntPtr(value, &v);
+part = (uint64)v;
 break;
-case 23:
-if(type->isSigned)
-{
-bits |= ((ssize_t)part << bitMember->pos);
 }
-else
+case 23:
 {
-bits |= ((size_t)part << bitMember->pos);
-}
+ssize_t v;
+
+type->isSigned ? GetIntSize(value, &v) : GetUIntSize(value, &v);
+part = (uint64)v;
 break;
 }
 }
+bits += part << bitMember->pos;
+}
 }
 }
 else
@@ -11293,6 +11586,53 @@ FreeInstance(inst);
 }
 }
 
+static unsigned int Promote(struct Operand * op, int kind, unsigned int isSigned)
+{
+unsigned int result = 0x0;
+
+switch(kind)
+{
+case 2:
+if(op->kind == 1 || op->kind == 15 || op->kind == 24)
+result = isSigned ? GetOpShort(op, &op->s) : GetOpUShort(op, &op->us);
+break;
+case 3:
+case 5:
+if(op->kind == 1 || op->kind == 2 || op->kind == 15 || op->kind == 24)
+result = isSigned ? GetOpInt(op, &op->i) : GetOpUInt(op, &op->ui);
+break;
+case 4:
+if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 6 || op->kind == 7 || op->kind == 13 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
+result = isSigned ? GetOpInt64(op, &op->i64) : GetOpUInt64(op, &op->ui64);
+break;
+case 6:
+if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
+result = GetOpFloat(op, &op->f);
+break;
+case 7:
+if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 6 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
+result = GetOpDouble(op, &op->d);
+break;
+case 13:
+if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 6 || op->kind == 7 || op->kind == 13 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
+result = GetOpUIntPtr(op, &op->ui64);
+break;
+case 15:
+if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 4 || op->kind == 5 || op->kind == 6 || op->kind == 7 || op->kind == 13 || op->kind == 15 || op->kind == 22 || op->kind == 23 || op->kind == 24)
+result = isSigned ? GetOpInt(op, &op->i) : GetOpUInt(op, &op->ui);
+break;
+case 22:
+if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 5 || op->kind == 15 || op->kind == 24)
+result = isSigned ? GetOpIntPtr(op, &op->i64) : GetOpUIntPtr(op, &op->i64);
+break;
+case 23:
+if(op->kind == 1 || op->kind == 2 || op->kind == 3 || op->kind == 5 || op->kind == 15 || op->kind == 24)
+result = isSigned ? GetOpIntSize(op, &op->ui64) : GetOpUIntSize(op, &op->ui64);
+break;
+}
+return result;
+}
+
 void CallOperator(struct Expression * exp, struct Expression * exp1, struct Expression * exp2, struct Operand * op1, struct Operand * op2)
 {
 if(exp->op.op == SIZEOF)
@@ -11344,6 +11684,13 @@ break;
 }
 else
 {
+if(op1 && op2 && op1->type && op2->type && op1->kind != op2->kind)
+{
+if(Promote(op2, op1->kind, op1->type->isSigned))
+op2->kind = op1->kind, op2->ops = op1->ops;
+else if(Promote(op1, op2->kind, op2->type->isSigned))
+op1->kind = op2->kind, op1->ops = op2->ops;
+}
 switch(exp->op.op)
 {
 case '+':
@@ -11515,7 +11862,48 @@ struct Operand op2 =
 };
 
 if(exp->op.exp2)
+{
+struct Expression * e = exp->op.exp2;
+
+while((e->type == 5 || e->type == 32 || e->type == 23) && e->list)
+{
+if(e->type == 5 || e->type == 32 || e->type == 23)
+{
+if(e->type == 23)
+e = (*((struct Statement *)(*e->compound->compound.statements).last)->expressions).last;
+else
+e = (*e->list).last;
+}
+}
+if(exp->op.op == 261 && e && e->expType)
+{
+if(e->type == 3 && e->string)
+{
+char * string = e->string;
+int len = strlen(string);
+char * tmp = __ecereNameSpace__ecere__com__eSystem_New(sizeof(char) * (len - 2 + 1));
+
+len = UnescapeString(tmp, string + 1, len - 2);
+(__ecereNameSpace__ecere__com__eSystem_Delete(tmp), tmp = 0);
+FreeExpContents(exp);
+exp->type = 2;
+exp->constant = PrintUInt(len + 1);
+}
+else
+{
+struct Type * type = e->expType;
+
+type->refCount++;
+FreeExpContents(exp);
+exp->type = 2;
+exp->constant = PrintUInt(ComputeTypeSize(type));
+FreeType(type);
+}
+break;
+}
+else
 ComputeExpression(exp->op.exp2);
+}
 if(exp->op.exp1)
 {
 ComputeExpression(exp->op.exp1);
@@ -11546,7 +11934,7 @@ FreeType(op2.type);
 break;
 }
 case 5:
-case 34:
+case 32:
 {
 struct Expression * e, * n;
 
@@ -11556,11 +11944,15 @@ n = e->next;
 if(!n)
 {
 struct __ecereNameSpace__ecere__sys__OldList * list = exp->list;
+struct Expression * prev = exp->prev;
+struct Expression * next = exp->next;
 
 ComputeExpression(e);
 FreeType(exp->expType);
 FreeType(exp->destType);
 *exp = *e;
+exp->prev = prev;
+exp->next = next;
 ((e ? (__ecereClass_Expression->Destructor ? __ecereClass_Expression->Destructor(e) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(e)) : 0), e = 0);
 (__ecereNameSpace__ecere__com__eSystem_Delete(list), list = 0);
 }
@@ -11586,7 +11978,7 @@ struct __ecereNameSpace__ecere__com__Property * prop = (((void *)0));
 struct __ecereNameSpace__ecere__com__DataMember * member = (((void *)0));
 struct __ecereNameSpace__ecere__com__Class * convertTo = (((void *)0));
 
-if(type->kind == 19 && exp->member.exp->type == 26)
+if(type->kind == 19 && exp->member.exp->type == 24)
 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "ecere::com::Class");
 if(!_class)
 {
@@ -11754,6 +12146,21 @@ Set(exp->instance->data, intValue);
 PopulateInstance(exp->instance);
 break;
 }
+case 6:
+{
+float floatValue;
+void (* Set)(void *, float) = (void *)prop->Set;
+
+exp->instance = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Instantiation);
+exp->instance->data = __ecereNameSpace__ecere__com__eSystem_New0(sizeof(unsigned char) * (_class->structSize));
+exp->instance->_class = MkSpecifierName(_class->fullName);
+exp->instance->loc = exp->loc;
+exp->type = 1;
+GetFloat(value, &floatValue);
+Set(exp->instance->data, floatValue);
+PopulateInstance(exp->instance);
+break;
+}
 case 7:
 {
 double doubleValue;
@@ -11954,141 +12361,169 @@ case 24:
 case 1:
 if(type->isSigned)
 {
-char value;
+char value = (char)0;
 
-GetChar(e, &value);
+if(GetChar(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintChar(value);
 exp->type = 2;
 }
+}
 else
 {
-unsigned char value;
+unsigned char value = (unsigned char)0;
 
-GetUChar(e, &value);
+if(GetUChar(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintUChar(value);
 exp->type = 2;
 }
+}
 break;
 case 2:
 if(type->isSigned)
 {
-short value;
+short value = (short)0;
 
-GetShort(e, &value);
+if(GetShort(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintShort(value);
 exp->type = 2;
 }
+}
 else
 {
-unsigned short value;
+unsigned short value = (unsigned short)0;
 
-GetUShort(e, &value);
+if(GetUShort(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintUShort(value);
 exp->type = 2;
 }
+}
 break;
 case 3:
 if(type->isSigned)
 {
-int value;
+int value = 0;
 
-GetInt(e, &value);
+if(GetInt(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintInt(value);
 exp->type = 2;
 }
+}
 else
 {
-unsigned int value;
+unsigned int value = 0;
 
-GetUInt(e, &value);
+if(GetUInt(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintUInt(value);
 exp->type = 2;
 }
+}
 break;
 case 4:
 if(type->isSigned)
 {
-long long value;
+long long value = 0;
 
-GetInt64(e, &value);
+if(GetInt64(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintInt64(value);
 exp->type = 2;
 }
+}
 else
 {
-uint64 value;
+uint64 value = 0;
 
-GetUInt64(e, &value);
+if(GetUInt64(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintUInt64(value);
 exp->type = 2;
 }
+}
 break;
 case 22:
 if(type->isSigned)
 {
-intptr_t value;
+intptr_t value = 0;
 
-GetIntPtr(e, &value);
+if(GetIntPtr(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintInt64((long long)value);
 exp->type = 2;
 }
+}
 else
 {
-uintptr_t value;
+uintptr_t value = 0;
 
-GetUIntPtr(e, &value);
+if(GetUIntPtr(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintUInt64((uint64)value);
 exp->type = 2;
 }
+}
 break;
 case 23:
 if(type->isSigned)
 {
-ssize_t value;
+ssize_t value = 0;
 
-GetIntSize(e, &value);
+if(GetIntSize(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintInt64((long long)value);
 exp->type = 2;
 }
+}
 else
 {
-size_t value;
+size_t value = 0;
 
-GetUIntSize(e, &value);
+if(GetUIntSize(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintUInt64((uint64)value);
 exp->type = 2;
 }
+}
 break;
 case 6:
 {
-float value;
+float value = 0;
 
-GetFloat(e, &value);
+if(GetFloat(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintFloat(value);
 exp->type = 2;
+}
 break;
 }
 case 7:
 {
-double value;
+double value = 0;
 
-GetDouble(e, &value);
+if(GetDouble(e, &value))
+{
 FreeExpContents(exp);
 exp->constant = PrintDouble(value);
 exp->type = 2;
+}
 break;
 }
 }
@@ -12182,6 +12617,8 @@ struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecere
 int objectType = exp->expType ? exp->expType->classObjectType : 0;
 
 *newExp = *exp;
+newExp->prev = (((void *)0));
+newExp->next = (((void *)0));
 newExp->destType = (((void *)0));
 if(convert->isGet)
 {
@@ -12306,7 +12743,7 @@ context = PushContext();
 ListAdd(unionDefs, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifier(DOUBLE)), MkListOne(MkDeclaratorIdentifier(MkIdentifier("d"))), (((void *)0)))));
 ListAdd(unionDefs, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifierName("uint64")), MkListOne(MkDeclaratorIdentifier(MkIdentifier("i"))), (((void *)0)))));
 specs = MkListOne(MkStructOrUnion(4, (((void *)0)), unionDefs));
-exp->type = 25;
+exp->type = 23;
 exp->compound = MkCompoundStmt(MkListOne(MkDeclaration(specs, MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("__internal_union")), (((void *)0)))))), statements);
 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("__internal_union")), MkIdentifier("d")), '=', newExp))));
 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpMember(MkExpIdentifier(MkIdentifier("__internal_union")), MkIdentifier("i")))));
@@ -12355,7 +12792,7 @@ context = PushContext();
 ListAdd(unionDefs, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifier(DOUBLE)), MkListOne(MkDeclaratorIdentifier(MkIdentifier("d"))), (((void *)0)))));
 ListAdd(unionDefs, MkClassDefDeclaration(MkStructDeclaration(MkListOne(MkSpecifierName("uint64")), MkListOne(MkDeclaratorIdentifier(MkIdentifier("i"))), (((void *)0)))));
 specs = MkListOne(MkStructOrUnion(4, (((void *)0)), unionDefs));
-exp->type = 25;
+exp->type = 23;
 exp->compound = MkCompoundStmt(MkListOne(MkDeclaration(specs, MkListOne(MkInitDeclarator(MkDeclaratorIdentifier(MkIdentifier("__internal_union")), (((void *)0)))))), statements);
 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpOp(MkExpMember(MkExpIdentifier(MkIdentifier("__internal_union")), MkIdentifier("i")), '=', newExp))));
 ListAdd(statements, MkExpressionStmt(MkListOne(MkExpMember(MkExpIdentifier(MkIdentifier("__internal_union")), MkIdentifier("d")))));
@@ -12923,6 +13360,13 @@ return memberType;
 return (((void *)0));
 }
 
+extern unsigned int parseError;
+
+unsigned int GetParseError()
+{
+return parseError;
+}
+
 extern struct __ecereNameSpace__ecere__com__Instance * fileInput;
 
 int __ecereVMethodID___ecereNameSpace__ecere__sys__File_Write;
@@ -12931,6 +13375,7 @@ extern struct __ecereNameSpace__ecere__com__Class * __ecereClass___ecereNameSpac
 
 struct Expression * ParseExpressionString(char * expression)
 {
+parseError = 0x0;
 fileInput = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__sys__TempFile);
 ((int (*)(struct __ecereNameSpace__ecere__com__Instance *, void *  buffer, unsigned int size, unsigned int count))__extension__ ({
 struct __ecereNameSpace__ecere__com__Instance * __internal_ClassInst = fileInput;
@@ -13171,11 +13616,11 @@ if(!_class || strcmp(_class->fullName, "char *"))
 {
 struct Expression * checkedExp = e, * newExp;
 
-while(((checkedExp->type == 5 || checkedExp->type == 34 || checkedExp->type == 25) && checkedExp->list) || checkedExp->type == 11)
+while(((checkedExp->type == 5 || checkedExp->type == 32 || checkedExp->type == 23) && checkedExp->list) || checkedExp->type == 11)
 {
-if(checkedExp->type == 5 || checkedExp->type == 34 || checkedExp->type == 25)
+if(checkedExp->type == 5 || checkedExp->type == 32 || checkedExp->type == 23)
 {
-if(checkedExp->type == 25)
+if(checkedExp->type == 23)
 {
 checkedExp = (*((struct Statement *)(*checkedExp->compound->compound.statements).last)->expressions).last;
 }
@@ -13230,7 +13675,7 @@ if(curCompound)
 char name[100];
 struct __ecereNameSpace__ecere__sys__OldList * stmts = MkList();
 
-e->type = 25;
+e->type = 23;
 sprintf(name, "__internalValue%03X", internalValueCounter++);
 if(!curCompound->compound.declarations)
 curCompound->compound.declarations = MkList();
@@ -13256,11 +13701,11 @@ curContext = context->parent;
 }
 }
 checkedExp = e;
-while(((checkedExp->type == 5 || checkedExp->type == 34 || checkedExp->type == 25) && checkedExp->list) || checkedExp->type == 11)
+while(((checkedExp->type == 5 || checkedExp->type == 32 || checkedExp->type == 23) && checkedExp->list) || checkedExp->type == 11)
 {
-if(checkedExp->type == 5 || checkedExp->type == 34 || checkedExp->type == 25)
+if(checkedExp->type == 5 || checkedExp->type == 32 || checkedExp->type == 23)
 {
-if(checkedExp->type == 25)
+if(checkedExp->type == 23)
 {
 checkedExp = (*((struct Statement *)(*checkedExp->compound->compound.statements).last)->expressions).last;
 }
@@ -13323,7 +13768,7 @@ else if(destType && e->expType && (e->expType->classObjectType == 3 || e->expTyp
 {
 if(destType->kind == 14)
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Unspecified type\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Unspecified type\n", (((void *)0))));
 }
 else if(!(destType->truth && e->expType->kind == 8 && e->expType->_class && e->expType->_class->registered && e->expType->_class->registered->type == 1))
 {
@@ -13402,8 +13847,6 @@ extern struct Expression * GetTemplateArgExp(struct TemplateParameter * param, s
 
 extern struct Expression * MkExpCondition(struct Expression * cond, struct __ecereNameSpace__ecere__sys__OldList * expressions, struct Expression * elseExp);
 
-extern struct Expression * CopyExpression(struct Expression * exp);
-
 extern struct Expression * MkExpTypeSize(struct TypeName * typeName);
 
 extern struct Expression * MkExpClass(struct __ecereNameSpace__ecere__sys__OldList *  specifiers, struct Declarator * decl);
@@ -13435,7 +13878,7 @@ case 0:
 {
 struct Identifier * id = exp->identifier;
 
-if(!id)
+if(!id || !topContext)
 return ;
 if(id->_class && id->_class->name)
 {
@@ -13506,7 +13949,7 @@ id->classSym = (((void *)0));
 exp->expType = type;
 if(type)
 type->refCount++;
-if(type && (type->kind == 15 || (_class && _class->type == 4)))
+if(type && (type->kind == 15))
 exp->isConstant = 0x1;
 if(symbol->isParam || !strcmp(id->string, "this"))
 {
@@ -13557,9 +14000,10 @@ int c;
 for(c = 0; c < definedExpStackPos; c++)
 if(definedExpStack[c] == definedExp)
 break;
-if(c == definedExpStackPos && c < sizeof definedExpStack / sizeof(void *))
+if(c == definedExpStackPos && c < sizeof (definedExpStack) / sizeof(void *))
 {
 struct Location backupYylloc = yylloc;
+struct __ecereNameSpace__ecere__com__Instance * backInput = fileInput;
 
 definedExpStack[definedExpStackPos++] = definedExp;
 fileInput = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass___ecereNameSpace__ecere__sys__TempFile);
@@ -13578,6 +14022,8 @@ parsedExpression = (((void *)0));
 resetScanner();
 expression_yyparse();
 (__ecereNameSpace__ecere__com__eInstance_DecRef(fileInput), fileInput = 0);
+if(backInput)
+fileInput = backInput;
 yylloc = backupYylloc;
 if(parsedExpression)
 {
@@ -13595,7 +14041,7 @@ else
 {
 if(inCompiler)
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Recursion in defined expression %s\n", (((void *)0))), id->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Recursion in defined expression %s\n", (((void *)0))), id->string);
 }
 }
 }
@@ -13747,9 +14193,10 @@ type->isSigned = 0x1;
 else
 {
 unsigned int isSigned = constant[0] == '-';
-long long i64 = strtoll(constant, (((void *)0)), 0);
-uint64 ui64 = strtoull(constant, (((void *)0)), 0);
-unsigned int is64Bit = 0x0;
+char * endP = (((void *)0));
+long long i64 = strtoll(constant, &endP, 0);
+uint64 ui64 = strtoull(constant, &endP, 0);
+unsigned int is64Bit = endP && (!strcmp(endP, "LL") || !strcmp(endP, "ll"));
 
 if(isSigned)
 {
@@ -13799,7 +14246,7 @@ __ecereInstance1->refCount = 1, __ecereInstance1->kind = 1, __ecereInstance1->co
 break;
 }
 case 13:
-case 28:
+case 26:
 ProcessExpressionType(exp->_new.size);
 exp->expType = __extension__ ({
 struct Type * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type);
@@ -13809,7 +14256,7 @@ __ecereInstance1->refCount = 1, __ecereInstance1->kind = 13, __ecereInstance1->t
 DeclareType(exp->expType->type, 0x0, 0x0);
 break;
 case 14:
-case 29:
+case 27:
 ProcessExpressionType(exp->_renew.size);
 ProcessExpressionType(exp->_renew.exp);
 exp->expType = __extension__ ({
@@ -13826,6 +14273,7 @@ struct Type * type1 = (((void *)0)), * type2 = (((void *)0));
 unsigned int useDestType = 0x0, useSideType = 0x0;
 struct Location oldyylloc = yylloc;
 unsigned int useSideUnit = 0x0;
+struct __ecereNameSpace__ecere__com__Class * destClass = (exp->destType && exp->destType->kind == 8 && exp->destType->_class) ? exp->destType->_class->registered : (((void *)0));
 struct Type * dummy = (dummy = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Type), dummy->count = 1, dummy->refCount = 1, dummy);
 
 switch(exp->op.op)
@@ -13862,13 +14310,27 @@ break;
 case '+':
 case '-':
 useSideUnit = 0x1;
+useSideType = 0x1;
+useDestType = 0x1;
+break;
+case LEFT_OP:
+case RIGHT_OP:
+useSideType = 0x1;
+useDestType = 0x1;
+break;
 case '|':
-case '&':
 case '^':
+useSideType = 0x1;
+useDestType = 0x1;
+break;
 case '/':
 case '%':
+useSideType = 0x1;
+useDestType = 0x1;
+break;
+case '&':
 case '*':
-if(exp->op.op != '*' || exp->op.exp1)
+if(exp->op.exp1)
 {
 useSideType = 0x1;
 useDestType = 0x1;
@@ -13898,11 +14360,14 @@ break;
 }
 if(exp->op.exp1)
 {
-if(exp->destType && exp->destType->kind == 8 && exp->destType->_class && exp->destType->_class->registered && useDestType && ((exp->destType->_class->registered->type == 3 && useSideUnit) || exp->destType->_class->registered->type == 4 || exp->destType->_class->registered->type == 2))
+if(exp->op.exp2 && useSideUnit && useDestType && destClass && destClass->type == 3 && destClass->base->type != 3)
+useDestType = 0x0;
+if(destClass && useDestType && ((destClass->type == 3 && useSideUnit) || destClass->type == 4 || destClass->type == 2))
 {
 if(exp->op.exp1->destType)
 FreeType(exp->op.exp1->destType);
 exp->op.exp1->destType = exp->destType;
+exp->op.exp1->opDestType = 0x1;
 if(exp->destType)
 exp->destType->refCount++;
 }
@@ -13918,6 +14383,13 @@ exp->op.exp1->destType->count++;
 ProcessExpressionType(exp->op.exp1);
 if(exp->op.exp1->destType && exp->op.op != '=')
 exp->op.exp1->destType->count--;
+exp->op.exp1->opDestType = 0x0;
+if(!exp->op.exp2 && (exp->op.op == INC_OP || exp->op.op == DEC_OP) && exp->op.exp1->expType && exp->op.exp1->expType->kind == 8 && exp->op.exp1->expType->_class && exp->op.exp1->expType->_class->registered && exp->op.exp1->expType->_class->registered->type == 3)
+{
+exp->op.exp2 = MkExpConstant("1");
+exp->op.op = exp->op.op == INC_OP ? ADD_ASSIGN : SUB_ASSIGN;
+assign = 0x1;
+}
 if(exp->op.exp1->destType == dummy)
 {
 FreeType(dummy);
@@ -13941,6 +14413,8 @@ exp->op.exp1->expType->refCount++;
 else
 {
 exp->op.exp2->destType = exp->destType;
+if(!exp->op.exp1 || exp->op.op != '&')
+exp->op.exp2->opDestType = 0x1;
 if(exp->destType)
 exp->destType->refCount++;
 }
@@ -13955,7 +14429,7 @@ PrintExpression(exp->op.exp2, expString);
 if(type1 && type1->kind == 13)
 {
 if(exp->op.op == MUL_ASSIGN || exp->op.op == DIV_ASSIGN || exp->op.op == MOD_ASSIGN || exp->op.op == LEFT_ASSIGN || exp->op.op == RIGHT_ASSIGN || exp->op.op == AND_ASSIGN || exp->op.op == OR_ASSIGN)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "operator %s illegal on pointer\n", (((void *)0))), exp->op.op);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "operator %s illegal on pointer\n", (((void *)0))), exp->op.op);
 else if(exp->op.op == '=')
 {
 if(exp->op.exp2->destType)
@@ -13982,11 +14456,13 @@ if(type1)
 type1->refCount++;
 exp->expType = type1;
 }
-else if(exp->destType && exp->destType->kind == 8 && exp->destType->_class && exp->destType->_class->registered && ((exp->destType->_class->registered->type == 3 && useDestType && useSideUnit) || (exp->destType->_class->registered->type == 4 && useDestType)))
+else if(destClass && ((destClass->type == 3 && useDestType && useSideUnit) || (destClass->type == 4 && useDestType)))
 {
 if(exp->op.exp2->destType)
 FreeType(exp->op.exp2->destType);
 exp->op.exp2->destType = exp->destType;
+if(exp->op.op != '&')
+exp->op.exp2->opDestType = 0x1;
 if(exp->destType)
 exp->destType->refCount++;
 }
@@ -14005,7 +14481,25 @@ type1->refCount++;
 }
 if(exp->op.exp2->destType && exp->op.op != '=')
 exp->op.exp2->destType->count++;
+if(exp->op.op == SIZEOF)
+{
+struct Expression * e = exp->op.exp2;
+
+while((e->type == 5 || e->type == 32 || e->type == 23) && e->list)
+{
+if(e->type == 5 || e->type == 32 || e->type == 23)
+{
+if(e->type == 23)
+e = (*((struct Statement *)(*e->compound->compound.statements).last)->expressions).last;
+else
+e = (*e->list).last;
+}
+}
+if(e->type == 11 && e->cast.exp)
+e->cast.exp->needCast = 0x1;
+}
 ProcessExpressionType(exp->op.exp2);
+exp->op.exp2->opDestType = 0x0;
 if(exp->op.exp2->destType && exp->op.op != '=')
 exp->op.exp2->destType->count--;
 if(assign && type1 && type1->kind == 13 && exp->op.exp2->expType)
@@ -14013,17 +14507,17 @@ if(assign && type1 && type1->kind == 13 && exp->op.exp2->expType)
 if(exp->op.exp2->expType->kind == 23 || exp->op.exp2->expType->kind == 22 || exp->op.exp2->expType->kind == 4 || exp->op.exp2->expType->kind == 3 || exp->op.exp2->expType->kind == 2 || exp->op.exp2->expType->kind == 1)
 {
 if(exp->op.op != '=' && type1->type->kind == 0)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "void *: unknown size\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "void *: unknown size\n", (((void *)0))));
 }
 else if(exp->op.exp2->expType->kind == 13 || exp->op.exp2->expType->kind == 12 || exp->op.exp2->expType->kind == 11 || exp->op.exp2->expType->kind == 16 || (type1->type->kind == 0 && exp->op.exp2->expType->kind == 8 && exp->op.exp2->expType->_class->registered && (exp->op.exp2->expType->_class->registered->type == 0 || exp->op.exp2->expType->_class->registered->type == 1 || exp->op.exp2->expType->_class->registered->type == 5)))
 {
 if(exp->op.op == ADD_ASSIGN)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "cannot add two pointers\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "cannot add two pointers\n", (((void *)0))));
 }
 else if((exp->op.exp2->expType->kind == 8 && type1->kind == 13 && type1->type->kind == 8 && type1->type->_class == exp->op.exp2->expType->_class && exp->op.exp2->expType->_class->registered && exp->op.exp2->expType->_class->registered->type == 1))
 {
 if(exp->op.op == ADD_ASSIGN)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "cannot add two pointers\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "cannot add two pointers\n", (((void *)0))));
 }
 else if(inCompiler)
 {
@@ -14035,7 +14529,7 @@ type2String[0] = '\0';
 PrintType(exp->op.exp2->expType, type1String, 0x0, 0x1);
 PrintType(type1, type2String, 0x0, 0x1);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "incompatible expression %s (%s); expected %s\n", (((void *)0))), expString, type1String, type2String);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible expression %s (%s); expected %s\n", (((void *)0))), expString, type1String, type2String);
 }
 }
 if(exp->op.exp2->destType == dummy)
@@ -14061,7 +14555,11 @@ type2->refCount = 1;
 type2->isSigned = 0x1;
 }
 else
+{
 type2 = exp->op.exp2->expType;
+if(type2)
+type2->refCount++;
+}
 }
 dummy->kind = 0;
 if(exp->op.op == SIZEOF)
@@ -14118,6 +14616,25 @@ else if(exp->op.exp1 && exp->op.exp2 && ((useSideType) || ((!type1 || type1->kin
 {
 if(type1 && type2 && ((type1->kind == 8 && type1->_class && strcmp(type1->_class->string, "String")) == (type2->kind == 8 && type2->_class && strcmp(type2->_class->string, "String"))))
 {
+if(exp->op.op == '-' && ((type1->kind == 8 && type1->_class->registered && type1->_class->registered->type == 4) || (type2->kind == 8 && type2->_class->registered && type2->_class->registered->type == 4)))
+{
+struct Type * intType;
+
+if(!type1->_class->registered->dataType)
+type1->_class->registered->dataType = ProcessTypeString(type1->_class->registered->dataTypeString, 0x0);
+if(!type2->_class->registered->dataType)
+type2->_class->registered->dataType = ProcessTypeString(type2->_class->registered->dataTypeString, 0x0);
+intType = ProcessTypeString((type1->_class->registered->dataType->kind == 4 || type2->_class->registered->dataType->kind == 4) ? "int64" : "int", 0x0);
+if(exp->op.exp1->destType)
+FreeType(exp->op.exp1->destType);
+if(exp->op.exp2->destType)
+FreeType(exp->op.exp2->destType);
+exp->op.exp1->destType = intType;
+exp->op.exp2->destType = intType;
+intType->refCount++;
+}
+else
+{
 if(exp->op.exp2->destType)
 FreeType(exp->op.exp2->destType);
 exp->op.exp2->destType = type1;
@@ -14126,8 +14643,9 @@ if(exp->op.exp1->destType)
 FreeType(exp->op.exp1->destType);
 exp->op.exp1->destType = type2;
 type2->refCount++;
+}
 if(!boolResult && type1->kind == 8 && (!exp->destType || exp->destType->kind != 8) && type1->_class->registered && type1->_class->registered->type == 3 && type2->_class->registered && type2->_class->registered->type == 3 && type1->_class->registered != type2->_class->registered)
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "operating on %s and %s with an untyped result, assuming %s\n", (((void *)0))), type1->_class->string, type2->_class->string, type1->_class->string);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "operating on %s and %s with an untyped result, assuming %s\n", (((void *)0))), type1->_class->string, type2->_class->string, type1->_class->string);
 if(type1->kind == 13 && type1->type->kind == 20 && type2->kind != 13)
 {
 struct Expression * argExp = GetTemplateArgExp(type1->type->templateParameter, thisClass, 0x1);
@@ -14143,7 +14661,12 @@ if(type2->kind != 13)
 ProcessExpressionType(classExp);
 exp->op.exp2 = MkExpBrackets(MkListOne(MkExpOp(exp->op.exp2, '*', MkExpBrackets(MkListOne(MkExpCondition(MkExpBrackets(MkListOne(MkExpOp(MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpConstant("5")), OR_OP, MkExpOp(MkExpMember(CopyExpression(classExp), MkIdentifier("type")), EQ_OP, MkExpConstant("0"))))), MkListOne(MkExpTypeSize(MkTypeName(MkListOne(MkSpecifier(VOID)), MkDeclaratorPointer(MkPointer((((void *)0)), (((void *)0))), (((void *)0)))))), MkExpMember(classExp, MkIdentifier("typeSize"))))))));
 if(!exp->op.exp2->expType)
+{
+if(type2)
+FreeType(type2);
 type2 = exp->op.exp2->expType = ProcessTypeString("int", 0x0);
+type2->refCount++;
+}
 ProcessExpressionType(exp->op.exp2);
 }
 }
@@ -14151,7 +14674,7 @@ ProcessExpressionType(exp->op.exp2);
 if(!boolResult && ((type1->kind == 13 || type1->kind == 12 || (type1->kind == 8 && !strcmp(type1->_class->string, "String"))) && (type2->kind == 23 || type2->kind == 22 || type2->kind == 4 || type2->kind == 3 || type2->kind == 2 || type2->kind == 1)))
 {
 if(type1->kind != 8 && type1->type->kind == 0)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "void *: unknown size\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "void *: unknown size\n", (((void *)0))));
 exp->expType = type1;
 if(type1)
 type1->refCount++;
@@ -14159,14 +14682,14 @@ type1->refCount++;
 else if(!boolResult && ((type2->kind == 13 || type2->kind == 12 || (type2->kind == 8 && !strcmp(type2->_class->string, "String"))) && (type1->kind == 23 || type1->kind == 22 || type1->kind == 4 || type1->kind == 3 || type1->kind == 2 || type1->kind == 1)))
 {
 if(type2->kind != 8 && type2->type->kind == 0)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "void *: unknown size\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "void *: unknown size\n", (((void *)0))));
 exp->expType = type2;
 if(type2)
 type2->refCount++;
 }
 else if((type1->kind == 13 && type2->kind != 13 && type2->kind != 12 && type2->kind != 11 && type2->kind != 16 && type2->kind != 8 && type2->kind != 19) || (type2->kind == 13 && type1->kind != 13 && type1->kind != 12 && type1->kind != 11 && type1->kind != 16 && type1->kind != 8 && type1->kind != 19))
 {
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "different levels of indirection\n", (((void *)0))));
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "different levels of indirection\n", (((void *)0))));
 }
 else
 {
@@ -14175,7 +14698,7 @@ unsigned int success = 0x0;
 if(type1->kind == 13 && type2->kind == 13)
 {
 if(exp->op.op == '+')
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "cannot add two pointers\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "cannot add two pointers\n", (((void *)0))));
 else if(exp->op.op == '-')
 {
 if(MatchTypes(type1->type, type2->type, (((void *)0)), (((void *)0)), (((void *)0)), 0x0, 0x0, 0x0, 0x0))
@@ -14267,7 +14790,7 @@ __ecereNameSpace__ecere__sys__ChangeCh(expString2, '\n', ' ');
 PrintType(exp->op.exp1->expType, type1, 0x0, 0x1);
 PrintType(exp->op.exp2->expType, type2, 0x0, 0x1);
 }
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "incompatible expressions %s (%s) and %s (%s)\n", (((void *)0))), expString1, type1, expString2, type2);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible expressions %s (%s) and %s (%s)\n", (((void *)0))), expString1, type1, expString2, type2);
 }
 }
 }
@@ -14308,7 +14831,11 @@ type1->_class->registered->dataType = ProcessTypeString(type1->_class->registere
 exp->op.exp2->destType = type1->_class->registered->dataType;
 exp->op.exp2->destType->refCount++;
 CheckExpressionType(exp->op.exp2, exp->op.exp2->destType, 0x0);
+if(type2)
+FreeType(type2);
 type2 = exp->op.exp2->destType;
+if(type2)
+type2->refCount++;
 exp->expType = type2;
 type2->refCount++;
 }
@@ -14325,21 +14852,53 @@ type1 = exp->op.exp1->destType;
 exp->expType = type1;
 type1->refCount++;
 }
-if(!boolResult || exp->op.op == '>' || exp->op.op == '<')
+if(!boolResult || exp->op.op == '>' || exp->op.op == '<' || exp->op.op == GE_OP || exp->op.op == LE_OP)
+{
+unsigned int op1IsEnum = type1 && type1->kind == 8 && type1->_class && type1->_class->registered && type1->_class->registered->type == 4;
+unsigned int op2IsEnum = type2 && type2->kind == 8 && type2->_class && type2->_class->registered && type2->_class->registered->type == 4;
+
+if(exp->op.op == '*' || exp->op.op == '/' || exp->op.op == '-' || exp->op.op == '|' || exp->op.op == '^')
+{
+if(op1IsEnum && exp->op.exp2->expType)
+{
+if(CheckExpressionType(exp->op.exp1, exp->op.exp2->expType, 0x0))
+{
+if(exp->expType)
+FreeType(exp->expType);
+exp->expType = exp->op.exp2->expType;
+if(exp->op.exp2->expType)
+exp->op.exp2->expType->refCount++;
+valid = 0x1;
+}
+}
+else if(op2IsEnum && exp->op.exp1->expType)
 {
-if(type1->kind == 8 && type1->_class && type1->_class->registered && type1->_class->registered->type == 4 && exp->op.exp2->expType)
+if(CheckExpressionType(exp->op.exp2, exp->op.exp1->expType, 0x0))
+{
+if(exp->expType)
+FreeType(exp->expType);
+exp->expType = exp->op.exp1->expType;
+if(exp->op.exp1->expType)
+exp->op.exp1->expType->refCount++;
+valid = 0x1;
+}
+}
+}
+else
+{
+if(op1IsEnum && exp->op.exp2->expType)
 {
 if(CheckExpressionType(exp->op.exp1, exp->op.exp2->expType, 0x0))
 {
 if(exp->expType)
 FreeType(exp->expType);
 exp->expType = exp->op.exp1->expType;
-if(exp->op.exp2->expType)
+if(exp->op.exp1->expType)
 exp->op.exp1->expType->refCount++;
 valid = 0x1;
 }
 }
-else if(type2 && (type2->kind == 8 && type2->_class && type2->_class->registered && type2->_class->registered->type == 4 && exp->op.exp1->expType))
+else if(op2IsEnum && exp->op.exp1->expType)
 {
 if(CheckExpressionType(exp->op.exp2, exp->op.exp1->expType, 0x0))
 {
@@ -14352,8 +14911,26 @@ valid = 0x1;
 }
 }
 }
+}
 if(!valid)
 {
+if(type2 && type2->kind == 8 && type2->_class && type2->_class->registered && type2->_class->registered->type == 3 && (type1->kind != 8 || !type1->_class || !type1->_class->registered || type1->_class->registered->type != 3))
+{
+if(exp->op.exp1->destType)
+FreeType(exp->op.exp1->destType);
+exp->op.exp1->destType = type2;
+type2->refCount++;
+if(CheckExpressionType(exp->op.exp1, exp->op.exp1->destType, 0x0))
+{
+if(exp->expType)
+FreeType(exp->expType);
+exp->expType = exp->op.exp1->destType;
+if(exp->op.exp1->destType)
+exp->op.exp1->destType->refCount++;
+}
+}
+else
+{
 if(exp->op.exp2->destType)
 FreeType(exp->op.exp2->destType);
 exp->op.exp2->destType = type1;
@@ -14386,7 +14963,7 @@ __ecereNameSpace__ecere__sys__ChangeCh(expString2, '\n', ' ');
 PrintType(exp->op.exp1->expType, type1String, 0x0, 0x1);
 PrintType(exp->op.exp2->expType, type2String, 0x0, 0x1);
 }
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "incompatible expressions %s (%s) and %s (%s)\n", (((void *)0))), expString1, type1String, expString2, type2String);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible expressions %s (%s) and %s (%s)\n", (((void *)0))), expString1, type1String, expString2, type2String);
 if(type1->kind == 8 && type1->_class && type1->_class->registered && type1->_class->registered->type == 4)
 {
 exp->expType = exp->op.exp1->expType;
@@ -14402,6 +14979,7 @@ exp->op.exp2->expType->refCount++;
 }
 }
 }
+}
 else if(type2)
 {
 if(type2->kind == 8 && type2->_class && type2->_class->registered && type2->_class->registered->type == 4)
@@ -14479,7 +15057,7 @@ PrintExpression(exp->op.exp1, expString);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
 }
 if(expString[0])
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't determine type of %s\n", (((void *)0))), expString);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s\n", (((void *)0))), expString);
 }
 if(exp->op.exp2 && !exp->op.exp2->expType)
 {
@@ -14492,7 +15070,7 @@ PrintExpression(exp->op.exp2, expString);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
 }
 if(expString[0])
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't determine type of %s\n", (((void *)0))), expString);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s\n", (((void *)0))), expString);
 }
 if(boolResult)
 {
@@ -14508,10 +15086,12 @@ DeclareType(exp->op.exp2->expType, 0x0, 0x0);
 }
 yylloc = oldyylloc;
 FreeType(dummy);
+if(type2)
+FreeType(type2);
 break;
 }
 case 5:
-case 34:
+case 32:
 {
 struct Expression * e;
 
@@ -14523,6 +15103,7 @@ unsigned int inced = 0x0;
 if(!e->next)
 {
 FreeType(e->destType);
+e->opDestType = exp->opDestType;
 e->destType = exp->destType;
 if(e->destType)
 {
@@ -14813,7 +15394,7 @@ functionType = type;
 }
 if(functionType && functionType->kind != 11)
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "called object %s is not a function\n", (((void *)0))), name);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "called object %s is not a function\n", (((void *)0))), name);
 }
 else if(functionType)
 {
@@ -14875,9 +15456,9 @@ if(!type && !emptyParams)
 {
 yylloc = e->loc;
 if(methodType && methodType->methodClass)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "too many arguments for method %s::%s (%d given, expected %d)\n", (((void *)0))), methodType->methodClass->fullName, methodType->method->name, (*exp->call.arguments).count, noParams ? 0 : functionType->params.count);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "too many arguments for method %s::%s (%d given, expected %d)\n", (((void *)0))), methodType->methodClass->fullName, methodType->method->name, (*exp->call.arguments).count, noParams ? 0 : functionType->params.count);
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "too many arguments for function %s (%d given, expected %d)\n", (((void *)0))), name, (*exp->call.arguments).count, noParams ? 0 : functionType->params.count);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "too many arguments for function %s (%d given, expected %d)\n", (((void *)0))), name, (*exp->call.arguments).count, noParams ? 0 : functionType->params.count);
 break;
 }
 if(methodType && type && type->kind == 20 && type->templateParameter->type == 0)
@@ -14965,9 +15546,9 @@ type = next;
 if(type && type->kind != 14)
 {
 if(methodType && methodType->methodClass)
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "not enough arguments for method %s::%s (%d given, expected %d)\n", (((void *)0))), methodType->methodClass->fullName, methodType->method->name, exp->call.arguments ? (*exp->call.arguments).count : 0, functionType->params.count + extra);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "not enough arguments for method %s::%s (%d given, expected %d)\n", (((void *)0))), methodType->methodClass->fullName, methodType->method->name, exp->call.arguments ? (*exp->call.arguments).count : 0, functionType->params.count + extra);
 else
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "not enough arguments for function %s (%d given, expected %d)\n", (((void *)0))), name, exp->call.arguments ? (*exp->call.arguments).count : 0, functionType->params.count + extra);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "not enough arguments for function %s (%d given, expected %d)\n", (((void *)0))), name, exp->call.arguments ? (*exp->call.arguments).count : 0, functionType->params.count + extra);
 }
 yylloc = oldyylloc;
 if(type && !type->refCount)
@@ -14999,7 +15580,7 @@ exp->destType->refCount++;
 }
 }
 else
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "%s undefined; assuming extern returning int\n", (((void *)0))), string);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "%s undefined; assuming extern returning int\n", (((void *)0))), string);
 symbol = __extension__ ({
 struct Symbol * __ecereInstance1 = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Symbol);
 
@@ -15015,7 +15596,7 @@ else if(exp->call.exp->type == 8)
 {
 }
 else
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "callable object undefined; extern assuming returning int\n", (((void *)0))));
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "callable object undefined; extern assuming returning int\n", (((void *)0))));
 if(!functionType->returnType)
 {
 functionType->returnType = __extension__ ({
@@ -15177,6 +15758,7 @@ struct Expression * exp;
 char * string = PrintHexUInt64(arg.expression.ui64);
 
 exp = MkExpCast(MkTypeName(specs, decl), MkExpConstant(string));
+(__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
 ProcessExpressionType(exp);
 ComputeExpression(exp);
 expString[0] = '\0';
@@ -15252,7 +15834,7 @@ struct Identifier * id = exp->member.member;
 int typeKind = type->kind;
 struct __ecereNameSpace__ecere__com__Class * _class = (id && (!id->_class || id->_class->name)) ? (id->classSym ? id->classSym->registered : (type->_class ? type->_class->registered : (((void *)0)))) : (((void *)0));
 
-if(typeKind == 19 && exp->member.exp->type == 26)
+if(typeKind == 19 && exp->member.exp->type == 24)
 {
 _class = __ecereNameSpace__ecere__com__eSystem_FindClass(privateModule, "ecere::com::Class");
 typeKind = 8;
@@ -15301,7 +15883,7 @@ struct __ecereNameSpace__ecere__com__ClassProperty * classProp = (((void *)0));
 if(id && id->_class && id->_class->name && !strcmp(id->_class->name, "property"))
 exp->member.memberType = 1;
 if(id && id->_class && type->_class && !__ecereNameSpace__ecere__com__eClass_IsDerived(type->_class->registered, _class))
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "invalid class specifier %s for object of class %s\n", (((void *)0))), _class->fullName, type->_class->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "invalid class specifier %s for object of class %s\n", (((void *)0))), _class->fullName, type->_class->string);
 if(typeKind != 19)
 {
 if((exp->member.memberType == 0 && thisPtr) || exp->member.memberType == 3)
@@ -15448,11 +16030,12 @@ if(exp->member.exp->expType->classObjectType == 2 && !strcmp(exp->member.member-
 FreeExpContents(exp);
 exp->type = 0;
 exp->identifier = MkIdentifier("class");
-ProcessExpressionType(exp);
+FreeType(exp->expType);
+exp->expType = MkClassType("ecere::com::Class");
 return ;
 }
 yylloc = exp->member.member->loc;
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't find member %s in class %s\n", (((void *)0))), id->string, _class->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't find member %s in class %s\n", (((void *)0))), id->string, _class->fullName);
 if(inCompiler)
 __ecereNameSpace__ecere__com__eClass_AddDataMember(_class, id->string, "int", 0, 0, 1);
 }
@@ -15649,6 +16232,7 @@ struct Expression * exp;
 char * string = PrintHexUInt64(arg.expression.ui64);
 
 exp = MkExpCast(MkTypeName(specs, decl), MkExpConstant(string));
+(__ecereNameSpace__ecere__com__eSystem_Delete(string), string = 0);
 ProcessExpressionType(exp);
 ComputeExpression(exp);
 expString[0] = '\0';
@@ -15706,7 +16290,7 @@ FinishTemplatesContext(context);
 }
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "undefined class %s\n", (((void *)0))), (id && (!id->_class || id->_class->name)) ? (id->classSym ? id->classSym->string : (type->_class ? type->_class->string : (((void *)0)))) : "(null)");
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "undefined class %s\n", (((void *)0))), (id && (!id->_class || id->_class->name)) ? (id->classSym ? id->classSym->string : (type->_class ? type->_class->string : (((void *)0)))) : "(null)");
 }
 else if(type && (type->kind == 9 || type->kind == 10))
 {
@@ -15729,7 +16313,7 @@ if(inCompiler)
 PrintExpression(exp, expString);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
 }
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "member operator on non-structure type expression %s\n", (((void *)0))), expString);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "member operator on non-structure type expression %s\n", (((void *)0))), expString);
 }
 if(exp->expType && exp->expType->kind == 21 && (!exp->destType || exp->destType->kind != 21))
 {
@@ -15863,14 +16447,14 @@ exp->isConstant = exp->cast.exp->isConstant;
 }
 break;
 }
-case 35:
+case 33:
 {
 struct Type * type = ProcessType(exp->initializer.typeName->qualifiers, exp->initializer.typeName->declarator);
 
 exp->expType = type;
 break;
 }
-case 36:
+case 34:
 {
 struct Type * type = ProcessType(exp->vaArg.typeName->qualifiers, exp->vaArg.typeName->declarator);
 
@@ -15917,7 +16501,7 @@ if(!exp->cond.elseExp->isConstant)
 exp->isConstant = 0x0;
 break;
 }
-case 25:
+case 23:
 {
 if(exp->compound && exp->compound->compound.statements && (*exp->compound->compound.statements).last)
 {
@@ -15936,7 +16520,7 @@ exp->expType->refCount++;
 }
 break;
 }
-case 26:
+case 24:
 {
 struct Specifier * spec = (*exp->_classExp.specifiers).first;
 
@@ -15953,7 +16537,7 @@ exp->byReference = 0x1;
 }
 break;
 }
-case 27:
+case 25:
 {
 struct __ecereNameSpace__ecere__com__Class * _class = thisClass ? thisClass : currentClass;
 
@@ -15977,7 +16561,7 @@ return ;
 }
 break;
 }
-case 37:
+case 35:
 {
 struct Type * type = (((void *)0));
 char * typeString = (((void *)0));
@@ -16092,7 +16676,7 @@ ProcessExpressionType(expExt);
 else
 {
 exp->expType = ProcessTypeString("Container", 0x0);
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Couldn't determine type of array elements\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Couldn't determine type of array elements\n", (((void *)0))));
 }
 break;
 }
@@ -16164,9 +16748,9 @@ PrintExpression(exp, expString);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
 }
 if(unresolved)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "unresolved identifier %s; expected %s\n", (((void *)0))), expString, type2);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved identifier %s; expected %s\n", (((void *)0))), expString, type2);
 else if(exp->type != 16)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't determine type of %s; expected %s\n", (((void *)0))), expString, type2);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s; expected %s\n", (((void *)0))), expString, type2);
 }
 }
 else
@@ -16180,9 +16764,9 @@ PrintExpression(exp, expString);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
 }
 if(unresolved)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "unresolved identifier %s\n", (((void *)0))), expString);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved identifier %s\n", (((void *)0))), expString);
 else if(exp->type != 16)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't determine type of %s\n", (((void *)0))), expString);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s\n", (((void *)0))), expString);
 }
 }
 else
@@ -16210,7 +16794,7 @@ PrintExpression(exp, expString);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
 }
 if(!sourceFile || (strcmp(sourceFile, "src\\lexer.ec") && strcmp(sourceFile, "src/lexer.ec") && strcmp(sourceFile, "src\\grammar.ec") && strcmp(sourceFile, "src/grammar.ec")))
-Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "incompatible expression %s (%s); expected %s\n", (((void *)0))), expString, type1, type2);
+Compiler_Warning(__ecereNameSpace__ecere__GetTranslatedString("ec", "incompatible expression %s (%s); expected %s\n", (((void *)0))), expString, type1, type2);
 FreeType(exp->expType);
 exp->destType->refCount++;
 exp->expType = exp->destType;
@@ -16242,9 +16826,9 @@ exp->cast.exp = newExp;
 else if(unresolved)
 {
 if(exp->identifier->_class && exp->identifier->_class->name)
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "unresolved identifier %s::%s\n", (((void *)0))), exp->identifier->_class->name, exp->identifier->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved identifier %s::%s\n", (((void *)0))), exp->identifier->_class->name, exp->identifier->string);
 else if(exp->identifier->string && exp->identifier->string[0])
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "unresolved identifier %s\n", (((void *)0))), exp->identifier->string);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "unresolved identifier %s\n", (((void *)0))), exp->identifier->string);
 }
 else if(!exp->expType && exp->type != 16)
 {
@@ -16256,11 +16840,11 @@ if(inCompiler)
 PrintExpression(exp, expString);
 __ecereNameSpace__ecere__sys__ChangeCh(expString, '\n', ' ');
 }
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "couldn't determine type of %s\n", (((void *)0))), expString);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "couldn't determine type of %s\n", (((void *)0))), expString);
 }
 if(inCompiler)
 ApplyAnyObjectLogic(exp);
-if(!notByReference && exp->expType && exp->expType->kind == 8 && exp->expType->_class && exp->expType->_class->registered && exp->expType->_class->registered->type == 5 && (!exp->destType || (exp->destType->kind != 3 && exp->destType->kind != 4 && exp->destType->kind != 22 && exp->destType->kind != 23 && exp->destType->kind != 5 && exp->destType->kind != 2 && exp->destType->kind != 1)))
+if(!notByReference && exp->expType && exp->expType->kind == 8 && exp->expType->_class && exp->expType->_class->registered && exp->expType->_class->registered->type == 5 && (!exp->destType || (exp->destType->kind != 3 && exp->destType->kind != 4 && exp->destType->kind != 22 && exp->destType->kind != 23 && exp->destType->kind != 5 && exp->destType->kind != 2 && exp->destType->kind != 1 && exp->destType->kind != 24)))
 {
 exp->byReference = 0x1;
 }
@@ -16407,7 +16991,7 @@ if(type && type->kind == 12)
 FreeType(initializerType);
 if(type && type->kind != 12 && type->kind != 9 && type->kind != 10 && (type->kind != 8 || !type->_class->registered || type->_class->registered->type != 1))
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Assigning list initializer to non list\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Assigning list initializer to non list\n", (((void *)0))));
 }
 break;
 }
@@ -16769,10 +17353,8 @@ struct Statement * prevCompound = curCompound;
 struct Context * prevContext = curContext;
 
 if(!stmt->compound.isSwitch)
-{
 curCompound = stmt;
 curContext = stmt->compound.context;
-}
 if(stmt->compound.declarations)
 {
 for(decl = (*stmt->compound.declarations).first; decl; decl = decl->next)
@@ -16909,7 +17491,7 @@ struct Statement * block = stmt->forEachStmt.stmt;
 char iteratorType[1024];
 struct Type * source;
 struct Expression * e;
-unsigned int isBuiltin = exp && (*exp).last && (((struct Expression *)(*exp).last)->type == 37 || (((struct Expression *)(*exp).last)->type == 11 && ((struct Expression *)(*exp).last)->cast.exp->type == 37));
+unsigned int isBuiltin = exp && (*exp).last && (((struct Expression *)(*exp).last)->type == 35 || (((struct Expression *)(*exp).last)->type == 11 && ((struct Expression *)(*exp).last)->cast.exp->type == 35));
 struct Expression * arrayExp;
 char * typeString = (((void *)0));
 int builtinCount = 0;
@@ -16973,7 +17555,7 @@ else if(isBuiltin)
 struct Type * type = (((void *)0));
 char typeStringBuf[1024];
 
-arrayExp = (((struct Expression *)(*exp).last)->type == 37) ? (struct Expression *)(*exp).last : ((struct Expression *)(*exp).last)->cast.exp;
+arrayExp = (((struct Expression *)(*exp).last)->type == 35) ? (struct Expression *)(*exp).last : ((struct Expression *)(*exp).last)->cast.exp;
 if(((struct Expression *)(*exp).last)->type == 11)
 {
 struct TypeName * typeName = ((struct Expression *)(*exp).last)->cast.typeName;
@@ -17069,7 +17651,7 @@ FreeList(exp, FreeExpression);
 else
 {
 arrayExp->expType = ProcessTypeString("Container", 0x0);
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Couldn't determine type of array elements\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Couldn't determine type of array elements\n", (((void *)0))));
 }
 }
 else if(isLinkList && !isList)
@@ -17182,7 +17764,7 @@ break;
 }
 else
 {
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Expression is not a container\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Expression is not a container\n", (((void *)0))));
 }
 break;
 }
@@ -17340,12 +17922,12 @@ ListAdd(args, MkExpIdentifier(MkIdentifier(watcherName)));
 ListAdd(stmt->expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_Watch")), args));
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Property %s not found in class %s\n", (((void *)0))), prop->name, _class->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Property %s not found in class %s\n", (((void *)0))), propID->string, _class->fullName);
 }
 }
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Invalid watched object\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Invalid watched object\n", (((void *)0))));
 }
 curExternal = external;
 curContext = context;
@@ -17356,7 +17938,7 @@ FreeExpression(object);
 FreeList(watches, FreePropertyWatch);
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "No observer specified and not inside a _class\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No observer specified and not inside a _class\n", (((void *)0))));
 }
 else
 {
@@ -17402,7 +17984,7 @@ if(prop)
 CreateFireWatcher(prop, object, stmt);
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Property %s not found in class %s\n", (((void *)0))), propID->string, _class->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Property %s not found in class %s\n", (((void *)0))), propID->string, _class->fullName);
 }
 }
 else
@@ -17426,7 +18008,7 @@ FreeExpression(object);
 FreeList(watches, FreeIdentifier);
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Invalid object specified and not inside a class\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Invalid object specified and not inside a class\n", (((void *)0))));
 }
 break;
 }
@@ -17486,7 +18068,7 @@ ListAdd(args, watcher ? CopyExpression(watcher) : MkExpIdentifier(MkIdentifier("
 ListAdd(stmt->expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_StopWatching")), args));
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Property %s not found in class %s\n", (((void *)0))), prop->name, _class->fullName);
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Property %s not found in class %s\n", (((void *)0))), propID->string, _class->fullName);
 }
 }
 if(object)
@@ -17496,10 +18078,10 @@ FreeExpression(watcher);
 FreeList(watches, FreeIdentifier);
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "Invalid object specified and not inside a class\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "Invalid object specified and not inside a class\n", (((void *)0))));
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString(__thisModule, "No observer specified and not inside a class\n", (((void *)0))));
+Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "No observer specified and not inside a class\n", (((void *)0))));
 }
 break;
 }
@@ -17968,7 +18550,9 @@ DeclareFunctionUtil("eSystem_New");
 DeclareFunctionUtil("eSystem_New0");
 DeclareFunctionUtil("eSystem_Renew");
 DeclareFunctionUtil("eSystem_Renew0");
+DeclareFunctionUtil("eSystem_Delete");
 DeclareFunctionUtil("eClass_GetProperty");
+DeclareFunctionUtil("eInstance_FireSelfWatchers");
 DeclareStruct("ecere::com::Class", 0x0);
 DeclareStruct("ecere::com::Instance", 0x0);
 DeclareStruct("ecere::com::Property", 0x0);
@@ -17988,6 +18572,7 @@ ProcessFunction(external->function);
 else if(external->type == 1)
 {
 currentClass = (((void *)0));
+if(external->declaration)
 ProcessDeclaration(external->declaration);
 }
 else if(external->type == 2)
@@ -18012,6 +18597,7 @@ thisNameSpace = external->id->string;
 }
 currentClass = (((void *)0));
 thisNameSpace = (((void *)0));
+curExternal = (((void *)0));
 ((temp->symbol ? (__ecereClass_Symbol->Destructor ? __ecereClass_Symbol->Destructor(temp->symbol) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(temp->symbol)) : 0), temp->symbol = 0);
 ((temp ? (__ecereClass_External->Destructor ? __ecereClass_External->Destructor(temp) : 0, __ecereNameSpace__ecere__com__eSystem_Delete(temp)) : 0), temp = 0);
 }
@@ -18020,6 +18606,8 @@ extern struct __ecereNameSpace__ecere__com__GlobalFunction * __ecereNameSpace__e
 
 extern struct __ecereNameSpace__ecere__com__Class * __ecereNameSpace__ecere__com__eSystem_RegisterClass(int type, char *  name, char *  baseName, int size, int sizeClass, unsigned int (*  Constructor)(void * ), void (*  Destructor)(void * ), struct __ecereNameSpace__ecere__com__Instance * module, int declMode, int inheritanceAccess);
 
+extern struct __ecereNameSpace__ecere__com__Instance * __thisModule;
+
 void __ecereRegisterModule_pass15(struct __ecereNameSpace__ecere__com__Instance * module)
 {
 struct __ecereNameSpace__ecere__com__Class * class;
@@ -18042,19 +18630,33 @@ __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintChar", "char * Prin
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintUChar", "char * PrintUChar(byte result)", PrintUChar, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintFloat", "char * PrintFloat(float result)", PrintFloat, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintDouble", "char * PrintDouble(double result)", PrintDouble, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpInt", "bool GetOpInt(Operand op2, int * value2)", GetOpInt, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetInt", "bool GetInt(Expression exp, int * value2)", GetInt, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUInt", "bool GetOpUInt(Operand op2, uint * value2)", GetOpUInt, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUInt", "bool GetUInt(Expression exp, uint * value2)", GetUInt, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpInt64", "bool GetOpInt64(Operand op2, int64 * value2)", GetOpInt64, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetInt64", "bool GetInt64(Expression exp, int64 * value2)", GetInt64, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUInt64", "bool GetOpUInt64(Operand op2, uint64 * value2)", GetOpUInt64, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUInt64", "bool GetUInt64(Expression exp, uint64 * value2)", GetUInt64, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpIntPtr", "bool GetOpIntPtr(Operand op2, intptr * value2)", GetOpIntPtr, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetIntPtr", "bool GetIntPtr(Expression exp, intptr * value2)", GetIntPtr, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUIntPtr", "bool GetOpUIntPtr(Operand op2, uintptr * value2)", GetOpUIntPtr, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUIntPtr", "bool GetUIntPtr(Expression exp, uintptr * value2)", GetUIntPtr, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpIntSize", "bool GetOpIntSize(Operand op2, intsize * value2)", GetOpIntSize, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetIntSize", "bool GetIntSize(Expression exp, intsize * value2)", GetIntSize, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUIntSize", "bool GetOpUIntSize(Operand op2, uintsize * value2)", GetOpUIntSize, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUIntSize", "bool GetUIntSize(Expression exp, uintsize * value2)", GetUIntSize, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpShort", "bool GetOpShort(Operand op2, short * value2)", GetOpShort, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetShort", "bool GetShort(Expression exp, short * value2)", GetShort, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUShort", "bool GetOpUShort(Operand op2, uint16 * value2)", GetOpUShort, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUShort", "bool GetUShort(Expression exp, uint16 * value2)", GetUShort, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpChar", "bool GetOpChar(Operand op2, char * value2)", GetOpChar, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetChar", "bool GetChar(Expression exp, char * value2)", GetChar, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpUChar", "bool GetOpUChar(Operand op2, byte * value2)", GetOpUChar, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetUChar", "bool GetUChar(Expression exp, byte * value2)", GetUChar, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpFloat", "bool GetOpFloat(Operand op2, float * value2)", GetOpFloat, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetFloat", "bool GetFloat(Expression exp, float * value2)", GetFloat, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOpDouble", "bool GetOpDouble(Operand op2, double * value2)", GetOpDouble, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetDouble", "bool GetDouble(Expression exp, double * value2)", GetDouble, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeClassMembers", "void ComputeClassMembers(ecere::com::Class _class, bool isMember)", ComputeClassMembers, module, 2);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeModuleClasses", "void ComputeModuleClasses(ecere::com::Module module)", ComputeModuleClasses, module, 1);
@@ -18085,6 +18687,8 @@ __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ModuleVisibility", "bool
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("MatchWithEnums_Module", "bool MatchWithEnums_Module(ecere::com::Module mainModule, Expression sourceExp, Type dest, char * string, ecere::sys::OldList conversions)", MatchWithEnums_Module, module, 2);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("MatchTypeExpression", "bool MatchTypeExpression(Expression sourceExp, Type dest, ecere::sys::OldList conversions, bool skipUnitBla)", MatchTypeExpression, module, 2);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ReadString", "void ReadString(char * output, char * string)", ReadString, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("UnescapeString", "int UnescapeString(char * d, char * s, int len)", UnescapeString, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("OffsetEscapedString", "char * OffsetEscapedString(char * s, int len, int offset)", OffsetEscapedString, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetOperand", "Operand GetOperand(Expression exp)", GetOperand, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PopulateInstance", "void PopulateInstance(Instantiation inst)", PopulateInstance, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ComputeInstantiation", "void ComputeInstantiation(Expression exp)", ComputeInstantiation, module, 1);
@@ -18095,6 +18699,7 @@ __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FindSymbol", "Symbol Fin
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintType", "void PrintType(Type type, char * string, bool printName, bool fullName)", PrintType, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("PrintTypeNoConst", "void PrintTypeNoConst(Type type, char * string, bool printName, bool fullName)", PrintTypeNoConst, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("FindMemberAndOffset", "Type FindMemberAndOffset(Type type, char * string, uint * offset)", FindMemberAndOffset, module, 1);
+__ecereNameSpace__ecere__com__eSystem_RegisterFunction("GetParseError", "bool GetParseError(void)", GetParseError, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ParseExpressionString", "Expression ParseExpressionString(char * expression)", ParseExpressionString, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ReplaceExpContents", "void ReplaceExpContents(Expression checkedExp, Expression newExp)", ReplaceExpContents, module, 1);
 __ecereNameSpace__ecere__com__eSystem_RegisterFunction("ApplyAnyObjectLogic", "void ApplyAnyObjectLogic(Expression e)", ApplyAnyObjectLogic, module, 1);