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 53c73dd..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;
@@ -486,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;
@@ -677,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;
@@ -849,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;
@@ -1110,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;
@@ -1215,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 * );
@@ -1234,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__ ({
@@ -1250,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;
 }
 }
 
@@ -1466,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);
 }
 
@@ -1516,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);
 }
 
@@ -1575,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);
 }
@@ -1655,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;
@@ -1700,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;
@@ -1739,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;
@@ -1778,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;
@@ -1817,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;
@@ -1856,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;
@@ -1895,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;
@@ -1934,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;
@@ -1973,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;
@@ -2012,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;
@@ -2051,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;
@@ -2090,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;
@@ -2129,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;
@@ -2168,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);
@@ -2949,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);
@@ -2974,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++;
@@ -2989,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;
 
@@ -3004,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)
@@ -3074,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;
@@ -3167,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)
@@ -3632,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';
@@ -4196,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;
 }
 }
@@ -4730,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;
@@ -4791,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;
 }
@@ -4814,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;
@@ -4838,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;
 }
 }
@@ -4863,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)))
 {
@@ -5216,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);
@@ -5228,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)
@@ -5245,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;
@@ -5255,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"))
 {
@@ -5330,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;
@@ -5346,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)
 {
@@ -5406,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)
 {
@@ -5548,7 +5741,7 @@ sourceExp->expType = backupSourceExpType;
 }
 return 0x0;
 }
-if(!flag)
+if(!flag && !sourceExp->opDestType)
 {
 struct Expression * newExp = __ecereNameSpace__ecere__com__eInstance_New(__ecereClass_Expression);
 
@@ -5587,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)
 {
@@ -5628,6 +5826,7 @@ else
 sprintf(constant, "0x%X", (int)value->data);
 sourceExp->constant = __ecereNameSpace__ecere__sys__CopyString(constant);
 }
+FreeType(dest);
 return 0x1;
 }
 }
@@ -5635,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;
 }
 
@@ -5646,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;
@@ -5661,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;
@@ -5673,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;
@@ -5688,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;
@@ -5706,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;
@@ -5721,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;
@@ -5736,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;
@@ -5751,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;
@@ -5766,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;
@@ -5781,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;
@@ -5796,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;
@@ -5811,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;
@@ -5823,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;
@@ -5838,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;
@@ -5856,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;
@@ -5871,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;
@@ -5886,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;
@@ -5901,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;
@@ -5916,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;
@@ -5931,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;
@@ -5946,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;
@@ -5961,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;
@@ -5973,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;
@@ -5988,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;
@@ -6006,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;
@@ -6021,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;
@@ -6036,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;
@@ -6051,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;
@@ -6066,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;
@@ -6081,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;
@@ -6123,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;
@@ -6138,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;
@@ -6216,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;
@@ -6231,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;
@@ -6273,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;
@@ -6288,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;
@@ -6390,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;
@@ -6403,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;
@@ -6520,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;
@@ -6533,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;
@@ -6650,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;
@@ -6663,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;
@@ -6756,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;
@@ -6771,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;
@@ -6783,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;
@@ -6798,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;
@@ -6816,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;
@@ -6831,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;
@@ -6846,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;
@@ -6861,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;
@@ -6876,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;
@@ -6891,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;
@@ -6906,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;
@@ -6921,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;
@@ -6933,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;
@@ -6948,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;
@@ -6966,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;
@@ -6981,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;
@@ -6996,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;
@@ -7011,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;
@@ -7026,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;
@@ -7041,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;
@@ -7056,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;
@@ -7071,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;
@@ -7083,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;
@@ -7098,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;
@@ -7116,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;
@@ -7131,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;
@@ -7146,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;
@@ -7161,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;
@@ -7176,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;
@@ -7191,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;
@@ -7206,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;
@@ -7221,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;
@@ -7233,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;
@@ -7248,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;
@@ -7266,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;
@@ -7281,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;
@@ -7296,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;
@@ -7311,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;
@@ -7326,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;
@@ -7341,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;
@@ -7383,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;
@@ -7398,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;
@@ -7476,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;
@@ -7491,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;
@@ -7533,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;
@@ -7548,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;
@@ -7626,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;
@@ -7641,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;
@@ -7653,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;
@@ -7668,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;
@@ -7686,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;
@@ -7701,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;
@@ -7716,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;
@@ -7731,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;
@@ -7746,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;
@@ -7761,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;
@@ -7773,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;
@@ -7788,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;
@@ -7806,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;
@@ -7821,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;
@@ -7836,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;
@@ -7851,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;
@@ -7866,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;
@@ -7881,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;
@@ -7893,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;
@@ -7908,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;
@@ -7926,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;
@@ -7941,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;
@@ -7956,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;
@@ -7971,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;
@@ -7986,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;
@@ -8001,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;
@@ -8013,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;
@@ -8028,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;
@@ -8046,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;
@@ -8061,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;
@@ -8076,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;
@@ -8091,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;
@@ -8106,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;
@@ -8121,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;
@@ -8133,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;
@@ -8148,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;
@@ -8166,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;
@@ -8181,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;
@@ -8196,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;
@@ -8211,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;
@@ -8250,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;
@@ -8263,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;
@@ -8330,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;
@@ -8345,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;
@@ -8357,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;
@@ -8372,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;
@@ -8390,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;
@@ -8405,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;
@@ -8420,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;
@@ -8435,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;
@@ -8450,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;
@@ -8465,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;
@@ -8477,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;
@@ -8492,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;
@@ -8510,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;
@@ -8525,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;
@@ -8540,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;
@@ -8555,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;
@@ -8570,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;
@@ -8585,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;
@@ -8597,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;
@@ -8612,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;
@@ -8630,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;
@@ -8645,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;
@@ -8660,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;
@@ -8675,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;
@@ -8690,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;
@@ -8705,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;
@@ -8717,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;
@@ -8732,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;
@@ -8750,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;
@@ -8765,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;
@@ -8780,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;
@@ -8795,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;
@@ -8810,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;
@@ -8825,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;
@@ -8837,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;
@@ -8852,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;
@@ -8870,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;
@@ -8885,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;
@@ -8900,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;
@@ -8915,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;
@@ -8954,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;
@@ -8967,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;
@@ -9034,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;
@@ -9049,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;
@@ -9061,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;
@@ -9076,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;
@@ -9094,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;
@@ -9109,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;
@@ -9124,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;
@@ -9139,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;
@@ -9154,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;
@@ -9169,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;
@@ -9184,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;
@@ -9199,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;
@@ -9211,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;
@@ -9226,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;
@@ -9244,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;
@@ -9259,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;
@@ -9274,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;
@@ -9289,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;
@@ -9304,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;
@@ -9319,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;
@@ -9334,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;
@@ -9349,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;
@@ -9361,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;
@@ -9376,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;
@@ -9394,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;
@@ -9409,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;
@@ -9424,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;
@@ -9439,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;
@@ -9454,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;
@@ -9469,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;
@@ -9484,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;
@@ -9499,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;
@@ -9511,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;
@@ -9526,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;
@@ -9544,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;
@@ -9559,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;
@@ -9574,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;
@@ -9589,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;
@@ -9604,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;
@@ -9619,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;
@@ -9634,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;
@@ -9649,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;
@@ -9661,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;
@@ -9676,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;
@@ -9694,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;
@@ -9709,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;
@@ -9724,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;
@@ -9739,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;
@@ -9754,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;
@@ -9769,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;
@@ -9784,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;
@@ -9799,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;
@@ -9811,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;
@@ -9826,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;
@@ -9844,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;
@@ -9859,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;
@@ -9874,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;
@@ -9889,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;
@@ -9904,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;
@@ -9919,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;
@@ -9934,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;
@@ -9949,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;
@@ -9961,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;
@@ -9976,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;
@@ -9994,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;
@@ -10009,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;
@@ -10024,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;
@@ -10039,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;
@@ -10054,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;
@@ -10069,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;
@@ -10084,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;
@@ -10099,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;
@@ -10111,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;
@@ -10126,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;
@@ -10144,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;
@@ -10159,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;
@@ -10174,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;
@@ -10189,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;
@@ -10204,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;
@@ -10219,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;
@@ -10258,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;
@@ -10271,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;
@@ -10333,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
@@ -10450,8 +10627,10 @@ break;
 case '\"':
 output[d] = '\"';
 break;
+case '\'':
+output[d] = '\'';
+break;
 default:
-output[d++] = '\\';
 output[d] = ch;
 }
 d++;
@@ -10473,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 = 
@@ -10498,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);
@@ -10551,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;
@@ -10587,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;
@@ -10599,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;
 }
 }
@@ -11205,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);
@@ -11222,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);
+{
+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
@@ -11298,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)
@@ -11349,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 '+':
@@ -11520,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);
@@ -11551,7 +11934,7 @@ FreeType(op2.type);
 break;
 }
 case 5:
-case 34:
+case 32:
 {
 struct Expression * e, * n;
 
@@ -11561,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);
 }
@@ -11591,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)
 {
@@ -11759,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;
@@ -11959,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;
 }
 }
@@ -12187,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)
 {
@@ -12311,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")))));
@@ -12360,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")))));
@@ -12928,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;
@@ -12936,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;
@@ -13176,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;
 }
@@ -13235,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();
@@ -13261,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;
 }
@@ -13407,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);
@@ -13440,7 +13878,7 @@ case 0:
 {
 struct Identifier * id = exp->identifier;
 
-if(!id)
+if(!id || !topContext)
 return ;
 if(id->_class && id->_class->name)
 {
@@ -13511,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"))
 {
@@ -13562,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);
@@ -13583,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)
 {
@@ -13752,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)
 {
@@ -13804,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);
@@ -13814,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__ ({
@@ -13831,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)
@@ -13867,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;
@@ -13903,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++;
 }
@@ -13923,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);
@@ -13946,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++;
 }
@@ -13987,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++;
 }
@@ -14010,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)
@@ -14066,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)
@@ -14123,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;
@@ -14131,6 +14643,7 @@ 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("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)
@@ -14148,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);
 }
 }
@@ -14313,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++;
 }
@@ -14330,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(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(type1->kind == 8 && type1->_class && type1->_class->registered && type1->_class->registered->type == 4 && exp->op.exp2->expType)
+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))
 {
@@ -14357,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;
@@ -14407,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)
@@ -14513,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;
 
@@ -14528,6 +15103,7 @@ unsigned int inced = 0x0;
 if(!e->next)
 {
 FreeType(e->destType);
+e->opDestType = exp->opDestType;
 e->destType = exp->destType;
 if(e->destType)
 {
@@ -15182,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';
@@ -15257,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;
@@ -15453,7 +16030,8 @@ 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;
@@ -15654,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';
@@ -15868,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);
 
@@ -15922,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)
 {
@@ -15941,7 +16520,7 @@ exp->expType->refCount++;
 }
 break;
 }
-case 26:
+case 24:
 {
 struct Specifier * spec = (*exp->_classExp.specifiers).first;
 
@@ -15958,7 +16537,7 @@ exp->byReference = 0x1;
 }
 break;
 }
-case 27:
+case 25:
 {
 struct __ecereNameSpace__ecere__com__Class * _class = thisClass ? thisClass : currentClass;
 
@@ -15982,7 +16561,7 @@ return ;
 }
 break;
 }
-case 37:
+case 35:
 {
 struct Type * type = (((void *)0));
 char * typeString = (((void *)0));
@@ -16912,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;
@@ -16976,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;
@@ -17343,7 +17922,7 @@ ListAdd(args, MkExpIdentifier(MkIdentifier(watcherName)));
 ListAdd(stmt->expressions, MkExpCall(MkExpIdentifier(MkIdentifier("ecere::com::eInstance_Watch")), args));
 }
 else
-Compiler_Error(__ecereNameSpace__ecere__GetTranslatedString("ec", "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);
 }
 }
 }
@@ -17489,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("ec", "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)
@@ -17971,6 +18550,7 @@ 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);
@@ -17992,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)
@@ -18016,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);
 }
@@ -18048,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);
@@ -18091,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);
@@ -18101,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);