mirror of
https://github.com/QB64-Phoenix-Edition/QB64pe.git
synced 2024-05-12 12:00:13 +00:00
Automatic update of ./internal/source
This commit is contained in:
parent
ab23b0f773
commit
11e40594ef
|
@ -1509,7 +1509,6 @@ __ARRAY_LONG_RESOLVESTATICFUNCTION_METHOD[0]=(ptrszint)nothingvalue;
|
|||
}
|
||||
__STRING_OS->len=0;
|
||||
*__LONG_MACOSX=0;
|
||||
*__LONG_INLINE_DATA=0;
|
||||
__STRING_BATCHFILE_EXTENSION->len=0;
|
||||
if (__ARRAY_STRING_INLINEDATASTR[2]&1){
|
||||
if (__ARRAY_STRING_INLINEDATASTR[2]&2){
|
||||
|
@ -2987,6 +2986,9 @@ __STRING_LAYOUT_BACKUP->len=0;
|
|||
*__LONG_OLDSFLISTN=0;
|
||||
*__LONG_R2=0;
|
||||
*__LONG_FF=0;
|
||||
*__LONG_IDSL=0;
|
||||
*__LONG_XL=0;
|
||||
*__LONG_X2OFS=0;
|
||||
*__LONG_NCOMMONTMP=0;
|
||||
__STRING_PUREVARNAME->len=0;
|
||||
*__LONG_ARRAYTYPE=0;
|
||||
|
|
|
@ -5,13 +5,13 @@ if(_FUNC_PARSECMDLINEARGS_LONG_I==NULL){
|
|||
_FUNC_PARSECMDLINEARGS_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_PARSECMDLINEARGS_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value2186;
|
||||
int64 fornext_finalvalue2186;
|
||||
int64 fornext_step2186;
|
||||
uint8 fornext_step_negative2186;
|
||||
int64 fornext_value2174;
|
||||
int64 fornext_finalvalue2174;
|
||||
int64 fornext_step2174;
|
||||
uint8 fornext_step_negative2174;
|
||||
qbs *_FUNC_PARSECMDLINEARGS_STRING_TOKEN=NULL;
|
||||
if (!_FUNC_PARSECMDLINEARGS_STRING_TOKEN)_FUNC_PARSECMDLINEARGS_STRING_TOKEN=qbs_new(0,0);
|
||||
static qbs *sc_2187=qbs_new(0,0);
|
||||
static qbs *sc_2175=qbs_new(0,0);
|
||||
int32 *_FUNC_PARSECMDLINEARGS_LONG_CMDLINESWITCH=NULL;
|
||||
if(_FUNC_PARSECMDLINEARGS_LONG_CMDLINESWITCH==NULL){
|
||||
_FUNC_PARSECMDLINEARGS_LONG_CMDLINESWITCH=(int32*)mem_static_malloc(4);
|
||||
|
@ -22,16 +22,16 @@ if(_FUNC_PARSECMDLINEARGS_LONG_SETTINGSMODE==NULL){
|
|||
_FUNC_PARSECMDLINEARGS_LONG_SETTINGSMODE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_PARSECMDLINEARGS_LONG_SETTINGSMODE=0;
|
||||
}
|
||||
static qbs *sc_2214=qbs_new(0,0);
|
||||
static qbs *sc_2202=qbs_new(0,0);
|
||||
qbs *_FUNC_PARSECMDLINEARGS_STRING_DEBUGINFOINIWARNING=NULL;
|
||||
if (!_FUNC_PARSECMDLINEARGS_STRING_DEBUGINFOINIWARNING)_FUNC_PARSECMDLINEARGS_STRING_DEBUGINFOINIWARNING=qbs_new(0,0);
|
||||
int32 pass2230;
|
||||
int32 pass2232;
|
||||
int32 pass2238;
|
||||
static qbs *sc_2239=qbs_new(0,0);
|
||||
int32 pass2218;
|
||||
int32 pass2220;
|
||||
int32 pass2226;
|
||||
static qbs *sc_2227=qbs_new(0,0);
|
||||
qbs *_FUNC_PARSECMDLINEARGS_STRING_PASSEDFILENAME=NULL;
|
||||
if (!_FUNC_PARSECMDLINEARGS_STRING_PASSEDFILENAME)_FUNC_PARSECMDLINEARGS_STRING_PASSEDFILENAME=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2240=NULL;
|
||||
if (!byte_element_2240){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2240=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2240=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2228=NULL;
|
||||
if (!byte_element_2228){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2228=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2228=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,22 +1,22 @@
|
|||
qbs*oldstr2359=NULL;
|
||||
qbs*oldstr2347=NULL;
|
||||
if(_SUB_ASSIGN_STRING_A->tmp||_SUB_ASSIGN_STRING_A->fixed||_SUB_ASSIGN_STRING_A->readonly){
|
||||
oldstr2359=_SUB_ASSIGN_STRING_A;
|
||||
if (oldstr2359->cmem_descriptor){
|
||||
_SUB_ASSIGN_STRING_A=qbs_new_cmem(oldstr2359->len,0);
|
||||
oldstr2347=_SUB_ASSIGN_STRING_A;
|
||||
if (oldstr2347->cmem_descriptor){
|
||||
_SUB_ASSIGN_STRING_A=qbs_new_cmem(oldstr2347->len,0);
|
||||
}else{
|
||||
_SUB_ASSIGN_STRING_A=qbs_new(oldstr2359->len,0);
|
||||
_SUB_ASSIGN_STRING_A=qbs_new(oldstr2347->len,0);
|
||||
}
|
||||
memcpy(_SUB_ASSIGN_STRING_A->chr,oldstr2359->chr,oldstr2359->len);
|
||||
memcpy(_SUB_ASSIGN_STRING_A->chr,oldstr2347->chr,oldstr2347->len);
|
||||
}
|
||||
int32 *_SUB_ASSIGN_LONG_I=NULL;
|
||||
if(_SUB_ASSIGN_LONG_I==NULL){
|
||||
_SUB_ASSIGN_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_SUB_ASSIGN_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value2361;
|
||||
int64 fornext_finalvalue2361;
|
||||
int64 fornext_step2361;
|
||||
uint8 fornext_step_negative2361;
|
||||
int64 fornext_value2349;
|
||||
int64 fornext_finalvalue2349;
|
||||
int64 fornext_step2349;
|
||||
uint8 fornext_step_negative2349;
|
||||
int32 *_SUB_ASSIGN_LONG_C=NULL;
|
||||
if(_SUB_ASSIGN_LONG_C==NULL){
|
||||
_SUB_ASSIGN_LONG_C=(int32*)mem_static_malloc(4);
|
||||
|
@ -29,8 +29,8 @@ _SUB_ASSIGN_LONG_B=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_SUB_ASSIGN_STRING_A2=NULL;
|
||||
if (!_SUB_ASSIGN_STRING_A2)_SUB_ASSIGN_STRING_A2=qbs_new(0,0);
|
||||
int32 pass2362;
|
||||
int32 pass2363;
|
||||
int32 pass2350;
|
||||
int32 pass2351;
|
||||
qbs *_SUB_ASSIGN_STRING_L=NULL;
|
||||
if (!_SUB_ASSIGN_STRING_L)_SUB_ASSIGN_STRING_L=qbs_new(0,0);
|
||||
int32 *_SUB_ASSIGN_LONG_TRY=NULL;
|
||||
|
@ -43,5 +43,5 @@ if(_SUB_ASSIGN_LONG_TYP==NULL){
|
|||
_SUB_ASSIGN_LONG_TYP=(int32*)mem_static_malloc(4);
|
||||
*_SUB_ASSIGN_LONG_TYP=0;
|
||||
}
|
||||
int32 pass2365;
|
||||
int32 pass2366;
|
||||
int32 pass2353;
|
||||
int32 pass2354;
|
||||
|
|
|
@ -1,13 +1,13 @@
|
|||
qbs *_FUNC_GETELEMENTSBEFORE_STRING_GETELEMENTSBEFORE=NULL;
|
||||
if (!_FUNC_GETELEMENTSBEFORE_STRING_GETELEMENTSBEFORE)_FUNC_GETELEMENTSBEFORE_STRING_GETELEMENTSBEFORE=qbs_new(0,0);
|
||||
qbs*oldstr3679=NULL;
|
||||
qbs*oldstr3667=NULL;
|
||||
if(_FUNC_GETELEMENTSBEFORE_STRING_A->tmp||_FUNC_GETELEMENTSBEFORE_STRING_A->fixed||_FUNC_GETELEMENTSBEFORE_STRING_A->readonly){
|
||||
oldstr3679=_FUNC_GETELEMENTSBEFORE_STRING_A;
|
||||
if (oldstr3679->cmem_descriptor){
|
||||
_FUNC_GETELEMENTSBEFORE_STRING_A=qbs_new_cmem(oldstr3679->len,0);
|
||||
oldstr3667=_FUNC_GETELEMENTSBEFORE_STRING_A;
|
||||
if (oldstr3667->cmem_descriptor){
|
||||
_FUNC_GETELEMENTSBEFORE_STRING_A=qbs_new_cmem(oldstr3667->len,0);
|
||||
}else{
|
||||
_FUNC_GETELEMENTSBEFORE_STRING_A=qbs_new(oldstr3679->len,0);
|
||||
_FUNC_GETELEMENTSBEFORE_STRING_A=qbs_new(oldstr3667->len,0);
|
||||
}
|
||||
memcpy(_FUNC_GETELEMENTSBEFORE_STRING_A->chr,oldstr3679->chr,oldstr3679->len);
|
||||
memcpy(_FUNC_GETELEMENTSBEFORE_STRING_A->chr,oldstr3667->chr,oldstr3667->len);
|
||||
}
|
||||
int32 pass3680;
|
||||
int32 pass3668;
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_GETELEMENTSAFTER_STRING_GETELEMENTSAFTER=NULL;
|
||||
if (!_FUNC_GETELEMENTSAFTER_STRING_GETELEMENTSAFTER)_FUNC_GETELEMENTSAFTER_STRING_GETELEMENTSAFTER=qbs_new(0,0);
|
||||
qbs*oldstr3681=NULL;
|
||||
qbs*oldstr3669=NULL;
|
||||
if(_FUNC_GETELEMENTSAFTER_STRING_A->tmp||_FUNC_GETELEMENTSAFTER_STRING_A->fixed||_FUNC_GETELEMENTSAFTER_STRING_A->readonly){
|
||||
oldstr3681=_FUNC_GETELEMENTSAFTER_STRING_A;
|
||||
if (oldstr3681->cmem_descriptor){
|
||||
_FUNC_GETELEMENTSAFTER_STRING_A=qbs_new_cmem(oldstr3681->len,0);
|
||||
oldstr3669=_FUNC_GETELEMENTSAFTER_STRING_A;
|
||||
if (oldstr3669->cmem_descriptor){
|
||||
_FUNC_GETELEMENTSAFTER_STRING_A=qbs_new_cmem(oldstr3669->len,0);
|
||||
}else{
|
||||
_FUNC_GETELEMENTSAFTER_STRING_A=qbs_new(oldstr3681->len,0);
|
||||
_FUNC_GETELEMENTSAFTER_STRING_A=qbs_new(oldstr3669->len,0);
|
||||
}
|
||||
memcpy(_FUNC_GETELEMENTSAFTER_STRING_A->chr,oldstr3681->chr,oldstr3681->len);
|
||||
memcpy(_FUNC_GETELEMENTSAFTER_STRING_A->chr,oldstr3669->chr,oldstr3669->len);
|
||||
}
|
||||
int32 *_FUNC_GETELEMENTSAFTER_LONG_P=NULL;
|
||||
if(_FUNC_GETELEMENTSAFTER_LONG_P==NULL){
|
||||
|
@ -25,7 +25,7 @@ if(_FUNC_GETELEMENTSAFTER_LONG_I==NULL){
|
|||
_FUNC_GETELEMENTSAFTER_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_GETELEMENTSAFTER_LONG_I=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3682=NULL;
|
||||
if (!byte_element_3682){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3682=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3682=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3670=NULL;
|
||||
if (!byte_element_3670){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3670=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3670=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,22 +1,22 @@
|
|||
qbs*oldstr3683=NULL;
|
||||
qbs*oldstr3671=NULL;
|
||||
if(_SUB_INSERTELEMENTS_STRING_A->tmp||_SUB_INSERTELEMENTS_STRING_A->fixed||_SUB_INSERTELEMENTS_STRING_A->readonly){
|
||||
oldstr3683=_SUB_INSERTELEMENTS_STRING_A;
|
||||
if (oldstr3683->cmem_descriptor){
|
||||
_SUB_INSERTELEMENTS_STRING_A=qbs_new_cmem(oldstr3683->len,0);
|
||||
oldstr3671=_SUB_INSERTELEMENTS_STRING_A;
|
||||
if (oldstr3671->cmem_descriptor){
|
||||
_SUB_INSERTELEMENTS_STRING_A=qbs_new_cmem(oldstr3671->len,0);
|
||||
}else{
|
||||
_SUB_INSERTELEMENTS_STRING_A=qbs_new(oldstr3683->len,0);
|
||||
_SUB_INSERTELEMENTS_STRING_A=qbs_new(oldstr3671->len,0);
|
||||
}
|
||||
memcpy(_SUB_INSERTELEMENTS_STRING_A->chr,oldstr3683->chr,oldstr3683->len);
|
||||
memcpy(_SUB_INSERTELEMENTS_STRING_A->chr,oldstr3671->chr,oldstr3671->len);
|
||||
}
|
||||
qbs*oldstr3684=NULL;
|
||||
qbs*oldstr3672=NULL;
|
||||
if(_SUB_INSERTELEMENTS_STRING_ELEMENTS->tmp||_SUB_INSERTELEMENTS_STRING_ELEMENTS->fixed||_SUB_INSERTELEMENTS_STRING_ELEMENTS->readonly){
|
||||
oldstr3684=_SUB_INSERTELEMENTS_STRING_ELEMENTS;
|
||||
if (oldstr3684->cmem_descriptor){
|
||||
_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new_cmem(oldstr3684->len,0);
|
||||
oldstr3672=_SUB_INSERTELEMENTS_STRING_ELEMENTS;
|
||||
if (oldstr3672->cmem_descriptor){
|
||||
_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new_cmem(oldstr3672->len,0);
|
||||
}else{
|
||||
_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new(oldstr3684->len,0);
|
||||
_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new(oldstr3672->len,0);
|
||||
}
|
||||
memcpy(_SUB_INSERTELEMENTS_STRING_ELEMENTS->chr,oldstr3684->chr,oldstr3684->len);
|
||||
memcpy(_SUB_INSERTELEMENTS_STRING_ELEMENTS->chr,oldstr3672->chr,oldstr3672->len);
|
||||
}
|
||||
qbs *_SUB_INSERTELEMENTS_STRING_A2=NULL;
|
||||
if (!_SUB_INSERTELEMENTS_STRING_A2)_SUB_INSERTELEMENTS_STRING_A2=qbs_new(0,0);
|
||||
|
@ -30,7 +30,7 @@ if(_SUB_INSERTELEMENTS_LONG_I2==NULL){
|
|||
_SUB_INSERTELEMENTS_LONG_I2=(int32*)mem_static_malloc(4);
|
||||
*_SUB_INSERTELEMENTS_LONG_I2=0;
|
||||
}
|
||||
int64 fornext_value3686;
|
||||
int64 fornext_finalvalue3686;
|
||||
int64 fornext_step3686;
|
||||
uint8 fornext_step_negative3686;
|
||||
int64 fornext_value3674;
|
||||
int64 fornext_finalvalue3674;
|
||||
int64 fornext_step3674;
|
||||
uint8 fornext_step_negative3674;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_NUMELEMENTS_LONG_NUMELEMENTS==NULL){
|
|||
_FUNC_NUMELEMENTS_LONG_NUMELEMENTS=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_NUMELEMENTS_LONG_NUMELEMENTS=0;
|
||||
}
|
||||
qbs*oldstr3687=NULL;
|
||||
qbs*oldstr3675=NULL;
|
||||
if(_FUNC_NUMELEMENTS_STRING_A->tmp||_FUNC_NUMELEMENTS_STRING_A->fixed||_FUNC_NUMELEMENTS_STRING_A->readonly){
|
||||
oldstr3687=_FUNC_NUMELEMENTS_STRING_A;
|
||||
if (oldstr3687->cmem_descriptor){
|
||||
_FUNC_NUMELEMENTS_STRING_A=qbs_new_cmem(oldstr3687->len,0);
|
||||
oldstr3675=_FUNC_NUMELEMENTS_STRING_A;
|
||||
if (oldstr3675->cmem_descriptor){
|
||||
_FUNC_NUMELEMENTS_STRING_A=qbs_new_cmem(oldstr3675->len,0);
|
||||
}else{
|
||||
_FUNC_NUMELEMENTS_STRING_A=qbs_new(oldstr3687->len,0);
|
||||
_FUNC_NUMELEMENTS_STRING_A=qbs_new(oldstr3675->len,0);
|
||||
}
|
||||
memcpy(_FUNC_NUMELEMENTS_STRING_A->chr,oldstr3687->chr,oldstr3687->len);
|
||||
memcpy(_FUNC_NUMELEMENTS_STRING_A->chr,oldstr3675->chr,oldstr3675->len);
|
||||
}
|
||||
int32 *_FUNC_NUMELEMENTS_LONG_P=NULL;
|
||||
if(_FUNC_NUMELEMENTS_LONG_P==NULL){
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr3688=NULL;
|
||||
qbs*oldstr3676=NULL;
|
||||
if(_SUB_REMOVEELEMENTS_STRING_A->tmp||_SUB_REMOVEELEMENTS_STRING_A->fixed||_SUB_REMOVEELEMENTS_STRING_A->readonly){
|
||||
oldstr3688=_SUB_REMOVEELEMENTS_STRING_A;
|
||||
if (oldstr3688->cmem_descriptor){
|
||||
_SUB_REMOVEELEMENTS_STRING_A=qbs_new_cmem(oldstr3688->len,0);
|
||||
oldstr3676=_SUB_REMOVEELEMENTS_STRING_A;
|
||||
if (oldstr3676->cmem_descriptor){
|
||||
_SUB_REMOVEELEMENTS_STRING_A=qbs_new_cmem(oldstr3676->len,0);
|
||||
}else{
|
||||
_SUB_REMOVEELEMENTS_STRING_A=qbs_new(oldstr3688->len,0);
|
||||
_SUB_REMOVEELEMENTS_STRING_A=qbs_new(oldstr3676->len,0);
|
||||
}
|
||||
memcpy(_SUB_REMOVEELEMENTS_STRING_A->chr,oldstr3688->chr,oldstr3688->len);
|
||||
memcpy(_SUB_REMOVEELEMENTS_STRING_A->chr,oldstr3676->chr,oldstr3676->len);
|
||||
}
|
||||
int32 *_SUB_REMOVEELEMENTS_LONG_N=NULL;
|
||||
if(_SUB_REMOVEELEMENTS_LONG_N==NULL){
|
||||
|
@ -20,11 +20,11 @@ _SUB_REMOVEELEMENTS_LONG_I=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_SUB_REMOVEELEMENTS_STRING_A2=NULL;
|
||||
if (!_SUB_REMOVEELEMENTS_STRING_A2)_SUB_REMOVEELEMENTS_STRING_A2=qbs_new(0,0);
|
||||
int64 fornext_value3690;
|
||||
int64 fornext_finalvalue3690;
|
||||
int64 fornext_step3690;
|
||||
uint8 fornext_step_negative3690;
|
||||
byte_element_struct *byte_element_3691=NULL;
|
||||
if (!byte_element_3691){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3691=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3691=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3678;
|
||||
int64 fornext_finalvalue3678;
|
||||
int64 fornext_step3678;
|
||||
uint8 fornext_step_negative3678;
|
||||
byte_element_struct *byte_element_3679=NULL;
|
||||
if (!byte_element_3679){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3679=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3679=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
qbs*oldstr3692=NULL;
|
||||
qbs*oldstr3680=NULL;
|
||||
if(_SUB_REMOVEELEMENT_STRING_A->tmp||_SUB_REMOVEELEMENT_STRING_A->fixed||_SUB_REMOVEELEMENT_STRING_A->readonly){
|
||||
oldstr3692=_SUB_REMOVEELEMENT_STRING_A;
|
||||
if (oldstr3692->cmem_descriptor){
|
||||
_SUB_REMOVEELEMENT_STRING_A=qbs_new_cmem(oldstr3692->len,0);
|
||||
oldstr3680=_SUB_REMOVEELEMENT_STRING_A;
|
||||
if (oldstr3680->cmem_descriptor){
|
||||
_SUB_REMOVEELEMENT_STRING_A=qbs_new_cmem(oldstr3680->len,0);
|
||||
}else{
|
||||
_SUB_REMOVEELEMENT_STRING_A=qbs_new(oldstr3692->len,0);
|
||||
_SUB_REMOVEELEMENT_STRING_A=qbs_new(oldstr3680->len,0);
|
||||
}
|
||||
memcpy(_SUB_REMOVEELEMENT_STRING_A->chr,oldstr3692->chr,oldstr3692->len);
|
||||
memcpy(_SUB_REMOVEELEMENT_STRING_A->chr,oldstr3680->chr,oldstr3680->len);
|
||||
}
|
||||
int32 pass3693;
|
||||
int32 pass3681;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNTFUNCTIONELEMENTS==NULL){
|
|||
_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNTFUNCTIONELEMENTS=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNTFUNCTIONELEMENTS=0;
|
||||
}
|
||||
qbs*oldstr3694=NULL;
|
||||
qbs*oldstr3682=NULL;
|
||||
if(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->tmp||_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->fixed||_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->readonly){
|
||||
oldstr3694=_FUNC_COUNTFUNCTIONELEMENTS_STRING_A;
|
||||
if (oldstr3694->cmem_descriptor){
|
||||
_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new_cmem(oldstr3694->len,0);
|
||||
oldstr3682=_FUNC_COUNTFUNCTIONELEMENTS_STRING_A;
|
||||
if (oldstr3682->cmem_descriptor){
|
||||
_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new_cmem(oldstr3682->len,0);
|
||||
}else{
|
||||
_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new(oldstr3694->len,0);
|
||||
_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new(oldstr3682->len,0);
|
||||
}
|
||||
memcpy(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->chr,oldstr3694->chr,oldstr3694->len);
|
||||
memcpy(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->chr,oldstr3682->chr,oldstr3682->len);
|
||||
}
|
||||
int32 *_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNT=NULL;
|
||||
if(_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNT==NULL){
|
||||
|
@ -33,8 +33,8 @@ if(_FUNC_COUNTFUNCTIONELEMENTS_LONG_I==NULL){
|
|||
_FUNC_COUNTFUNCTIONELEMENTS_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_COUNTFUNCTIONELEMENTS_LONG_I=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3695=NULL;
|
||||
if (!byte_element_3695){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3695=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3695=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3683=NULL;
|
||||
if (!byte_element_3683){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3683=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3683=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
static int32 sc_3697;
|
||||
static int32 sc_3685;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_HASFUNCTIONELEMENT_LONG_HASFUNCTIONELEMENT==NULL){
|
|||
_FUNC_HASFUNCTIONELEMENT_LONG_HASFUNCTIONELEMENT=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_HASFUNCTIONELEMENT_LONG_HASFUNCTIONELEMENT=0;
|
||||
}
|
||||
qbs*oldstr3698=NULL;
|
||||
qbs*oldstr3686=NULL;
|
||||
if(_FUNC_HASFUNCTIONELEMENT_STRING_A->tmp||_FUNC_HASFUNCTIONELEMENT_STRING_A->fixed||_FUNC_HASFUNCTIONELEMENT_STRING_A->readonly){
|
||||
oldstr3698=_FUNC_HASFUNCTIONELEMENT_STRING_A;
|
||||
if (oldstr3698->cmem_descriptor){
|
||||
_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new_cmem(oldstr3698->len,0);
|
||||
oldstr3686=_FUNC_HASFUNCTIONELEMENT_STRING_A;
|
||||
if (oldstr3686->cmem_descriptor){
|
||||
_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new_cmem(oldstr3686->len,0);
|
||||
}else{
|
||||
_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new(oldstr3698->len,0);
|
||||
_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new(oldstr3686->len,0);
|
||||
}
|
||||
memcpy(_FUNC_HASFUNCTIONELEMENT_STRING_A->chr,oldstr3698->chr,oldstr3698->len);
|
||||
memcpy(_FUNC_HASFUNCTIONELEMENT_STRING_A->chr,oldstr3686->chr,oldstr3686->len);
|
||||
}
|
||||
int32 *_FUNC_HASFUNCTIONELEMENT_LONG_COUNT=NULL;
|
||||
if(_FUNC_HASFUNCTIONELEMENT_LONG_COUNT==NULL){
|
||||
|
@ -38,16 +38,16 @@ if(_FUNC_HASFUNCTIONELEMENT_LONG_START==NULL){
|
|||
_FUNC_HASFUNCTIONELEMENT_LONG_START=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_HASFUNCTIONELEMENT_LONG_START=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3699=NULL;
|
||||
if (!byte_element_3699){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3699=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3699=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3687=NULL;
|
||||
if (!byte_element_3687){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3687=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3687=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3700=NULL;
|
||||
if (!byte_element_3700){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3700=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3700=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3688=NULL;
|
||||
if (!byte_element_3688){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3688=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3688=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3702=NULL;
|
||||
if (!byte_element_3702){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3702=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3702=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3690=NULL;
|
||||
if (!byte_element_3690){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3690=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3690=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
static int32 sc_3703;
|
||||
static int32 sc_3691;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_ISVALIDARGSET_LONG_ISVALIDARGSET==NULL){
|
|||
_FUNC_ISVALIDARGSET_LONG_ISVALIDARGSET=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ISVALIDARGSET_LONG_ISVALIDARGSET=0;
|
||||
}
|
||||
qbs*oldstr3704=NULL;
|
||||
qbs*oldstr3692=NULL;
|
||||
if(_FUNC_ISVALIDARGSET_STRING_FORMAT->tmp||_FUNC_ISVALIDARGSET_STRING_FORMAT->fixed||_FUNC_ISVALIDARGSET_STRING_FORMAT->readonly){
|
||||
oldstr3704=_FUNC_ISVALIDARGSET_STRING_FORMAT;
|
||||
if (oldstr3704->cmem_descriptor){
|
||||
_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new_cmem(oldstr3704->len,0);
|
||||
oldstr3692=_FUNC_ISVALIDARGSET_STRING_FORMAT;
|
||||
if (oldstr3692->cmem_descriptor){
|
||||
_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new_cmem(oldstr3692->len,0);
|
||||
}else{
|
||||
_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new(oldstr3704->len,0);
|
||||
_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new(oldstr3692->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ISVALIDARGSET_STRING_FORMAT->chr,oldstr3704->chr,oldstr3704->len);
|
||||
memcpy(_FUNC_ISVALIDARGSET_STRING_FORMAT->chr,oldstr3692->chr,oldstr3692->len);
|
||||
}
|
||||
int32 *_FUNC_ISVALIDARGSET_LONG_MAXARGUMENT=NULL;
|
||||
if(_FUNC_ISVALIDARGSET_LONG_MAXARGUMENT==NULL){
|
||||
|
@ -60,12 +60,12 @@ if(_FUNC_ISVALIDARGSET_LONG_ARGIGNORED==NULL){
|
|||
_FUNC_ISVALIDARGSET_LONG_ARGIGNORED=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ISVALIDARGSET_LONG_ARGIGNORED=0;
|
||||
}
|
||||
int64 fornext_value3706;
|
||||
int64 fornext_finalvalue3706;
|
||||
int64 fornext_step3706;
|
||||
uint8 fornext_step_negative3706;
|
||||
byte_element_struct *byte_element_3707=NULL;
|
||||
if (!byte_element_3707){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3707=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3707=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3694;
|
||||
int64 fornext_finalvalue3694;
|
||||
int64 fornext_step3694;
|
||||
uint8 fornext_step_negative3694;
|
||||
byte_element_struct *byte_element_3695=NULL;
|
||||
if (!byte_element_3695){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3695=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3695=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
static int32 sc_3708;
|
||||
static int32 sc_3696;
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_ELEUCASE_STRING_ELEUCASE=NULL;
|
||||
if (!_FUNC_ELEUCASE_STRING_ELEUCASE)_FUNC_ELEUCASE_STRING_ELEUCASE=qbs_new(0,0);
|
||||
qbs*oldstr3709=NULL;
|
||||
qbs*oldstr3697=NULL;
|
||||
if(_FUNC_ELEUCASE_STRING_A->tmp||_FUNC_ELEUCASE_STRING_A->fixed||_FUNC_ELEUCASE_STRING_A->readonly){
|
||||
oldstr3709=_FUNC_ELEUCASE_STRING_A;
|
||||
if (oldstr3709->cmem_descriptor){
|
||||
_FUNC_ELEUCASE_STRING_A=qbs_new_cmem(oldstr3709->len,0);
|
||||
oldstr3697=_FUNC_ELEUCASE_STRING_A;
|
||||
if (oldstr3697->cmem_descriptor){
|
||||
_FUNC_ELEUCASE_STRING_A=qbs_new_cmem(oldstr3697->len,0);
|
||||
}else{
|
||||
_FUNC_ELEUCASE_STRING_A=qbs_new(oldstr3709->len,0);
|
||||
_FUNC_ELEUCASE_STRING_A=qbs_new(oldstr3697->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ELEUCASE_STRING_A->chr,oldstr3709->chr,oldstr3709->len);
|
||||
memcpy(_FUNC_ELEUCASE_STRING_A->chr,oldstr3697->chr,oldstr3697->len);
|
||||
}
|
||||
int32 *_FUNC_ELEUCASE_LONG_I=NULL;
|
||||
if(_FUNC_ELEUCASE_LONG_I==NULL){
|
||||
|
@ -29,23 +29,23 @@ if(_FUNC_ELEUCASE_LONG_I3==NULL){
|
|||
_FUNC_ELEUCASE_LONG_I3=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ELEUCASE_LONG_I3=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3710=NULL;
|
||||
if (!byte_element_3710){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3710=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3710=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3698=NULL;
|
||||
if (!byte_element_3698){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3698=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3698=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3711=NULL;
|
||||
if (!byte_element_3711){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3711=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3711=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3699=NULL;
|
||||
if (!byte_element_3699){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3699=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3699=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3713=NULL;
|
||||
if (!byte_element_3713){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3713=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3713=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3701=NULL;
|
||||
if (!byte_element_3701){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3701=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3701=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3714=NULL;
|
||||
if (!byte_element_3714){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3714=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3714=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3702=NULL;
|
||||
if (!byte_element_3702){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3702=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3702=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3715=NULL;
|
||||
if (!byte_element_3715){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3715=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3715=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3703=NULL;
|
||||
if (!byte_element_3703){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3703=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3703=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_ELEMENTGETNUMERICVALUE_LONG_ELEMENTGETNUMERICVALUE==NULL){
|
|||
_FUNC_ELEMENTGETNUMERICVALUE_LONG_ELEMENTGETNUMERICVALUE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ELEMENTGETNUMERICVALUE_LONG_ELEMENTGETNUMERICVALUE=0;
|
||||
}
|
||||
qbs*oldstr3716=NULL;
|
||||
qbs*oldstr3704=NULL;
|
||||
if(_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->tmp||_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->fixed||_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->readonly){
|
||||
oldstr3716=_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE;
|
||||
if (oldstr3716->cmem_descriptor){
|
||||
_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE=qbs_new_cmem(oldstr3716->len,0);
|
||||
oldstr3704=_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE;
|
||||
if (oldstr3704->cmem_descriptor){
|
||||
_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE=qbs_new_cmem(oldstr3704->len,0);
|
||||
}else{
|
||||
_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE=qbs_new(oldstr3716->len,0);
|
||||
_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE=qbs_new(oldstr3704->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->chr,oldstr3716->chr,oldstr3716->len);
|
||||
memcpy(_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->chr,oldstr3704->chr,oldstr3704->len);
|
||||
}
|
||||
qbs *_FUNC_ELEMENTGETNUMERICVALUE_STRING_NUM=NULL;
|
||||
if (!_FUNC_ELEMENTGETNUMERICVALUE_STRING_NUM)_FUNC_ELEMENTGETNUMERICVALUE_STRING_NUM=qbs_new(0,0);
|
||||
|
@ -27,19 +27,19 @@ if(_FUNC_ELEMENTGETNUMERICVALUE_LONG_X==NULL){
|
|||
_FUNC_ELEMENTGETNUMERICVALUE_LONG_X=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ELEMENTGETNUMERICVALUE_LONG_X=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3717=NULL;
|
||||
if (!byte_element_3717){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3717=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3717=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3705=NULL;
|
||||
if (!byte_element_3705){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3705=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3705=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3718=NULL;
|
||||
if (!byte_element_3718){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3718=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3718=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3706=NULL;
|
||||
if (!byte_element_3706){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3706=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3706=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3719=NULL;
|
||||
if (!byte_element_3719){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3719=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3719=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3707=NULL;
|
||||
if (!byte_element_3707){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3707=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3707=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3720=NULL;
|
||||
if (!byte_element_3720){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3720=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3720=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3708=NULL;
|
||||
if (!byte_element_3708){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3708=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3708=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_ELEMENTISNUMBER_LONG_ELEMENTISNUMBER==NULL){
|
|||
_FUNC_ELEMENTISNUMBER_LONG_ELEMENTISNUMBER=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ELEMENTISNUMBER_LONG_ELEMENTISNUMBER=0;
|
||||
}
|
||||
qbs*oldstr3721=NULL;
|
||||
qbs*oldstr3709=NULL;
|
||||
if(_FUNC_ELEMENTISNUMBER_STRING_OELE->tmp||_FUNC_ELEMENTISNUMBER_STRING_OELE->fixed||_FUNC_ELEMENTISNUMBER_STRING_OELE->readonly){
|
||||
oldstr3721=_FUNC_ELEMENTISNUMBER_STRING_OELE;
|
||||
if (oldstr3721->cmem_descriptor){
|
||||
_FUNC_ELEMENTISNUMBER_STRING_OELE=qbs_new_cmem(oldstr3721->len,0);
|
||||
oldstr3709=_FUNC_ELEMENTISNUMBER_STRING_OELE;
|
||||
if (oldstr3709->cmem_descriptor){
|
||||
_FUNC_ELEMENTISNUMBER_STRING_OELE=qbs_new_cmem(oldstr3709->len,0);
|
||||
}else{
|
||||
_FUNC_ELEMENTISNUMBER_STRING_OELE=qbs_new(oldstr3721->len,0);
|
||||
_FUNC_ELEMENTISNUMBER_STRING_OELE=qbs_new(oldstr3709->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ELEMENTISNUMBER_STRING_OELE->chr,oldstr3721->chr,oldstr3721->len);
|
||||
memcpy(_FUNC_ELEMENTISNUMBER_STRING_OELE->chr,oldstr3709->chr,oldstr3709->len);
|
||||
}
|
||||
qbs *_FUNC_ELEMENTISNUMBER_STRING_ELE=NULL;
|
||||
if (!_FUNC_ELEMENTISNUMBER_STRING_ELE)_FUNC_ELEMENTISNUMBER_STRING_ELE=qbs_new(0,0);
|
||||
|
@ -20,7 +20,7 @@ if(_FUNC_ELEMENTISNUMBER_LONG_RES==NULL){
|
|||
_FUNC_ELEMENTISNUMBER_LONG_RES=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ELEMENTISNUMBER_LONG_RES=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3722=NULL;
|
||||
if (!byte_element_3722){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3722=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3722=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3710=NULL;
|
||||
if (!byte_element_3710){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3710=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3710=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -3,13 +3,13 @@ if(_FUNC_ELEMENTISSTRING_LONG_ELEMENTISSTRING==NULL){
|
|||
_FUNC_ELEMENTISSTRING_LONG_ELEMENTISSTRING=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ELEMENTISSTRING_LONG_ELEMENTISSTRING=0;
|
||||
}
|
||||
qbs*oldstr3723=NULL;
|
||||
qbs*oldstr3711=NULL;
|
||||
if(_FUNC_ELEMENTISSTRING_STRING_ELE->tmp||_FUNC_ELEMENTISSTRING_STRING_ELE->fixed||_FUNC_ELEMENTISSTRING_STRING_ELE->readonly){
|
||||
oldstr3723=_FUNC_ELEMENTISSTRING_STRING_ELE;
|
||||
if (oldstr3723->cmem_descriptor){
|
||||
_FUNC_ELEMENTISSTRING_STRING_ELE=qbs_new_cmem(oldstr3723->len,0);
|
||||
oldstr3711=_FUNC_ELEMENTISSTRING_STRING_ELE;
|
||||
if (oldstr3711->cmem_descriptor){
|
||||
_FUNC_ELEMENTISSTRING_STRING_ELE=qbs_new_cmem(oldstr3711->len,0);
|
||||
}else{
|
||||
_FUNC_ELEMENTISSTRING_STRING_ELE=qbs_new(oldstr3723->len,0);
|
||||
_FUNC_ELEMENTISSTRING_STRING_ELE=qbs_new(oldstr3711->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ELEMENTISSTRING_STRING_ELE->chr,oldstr3723->chr,oldstr3723->len);
|
||||
memcpy(_FUNC_ELEMENTISSTRING_STRING_ELE->chr,oldstr3711->chr,oldstr3711->len);
|
||||
}
|
||||
|
|
|
@ -3,25 +3,25 @@ if(_FUNC_ELEMENTGETSTRINGVALUE_LONG_ELEMENTGETSTRINGVALUE==NULL){
|
|||
_FUNC_ELEMENTGETSTRINGVALUE_LONG_ELEMENTGETSTRINGVALUE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ELEMENTGETSTRINGVALUE_LONG_ELEMENTGETSTRINGVALUE=0;
|
||||
}
|
||||
qbs*oldstr3724=NULL;
|
||||
qbs*oldstr3712=NULL;
|
||||
if(_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->tmp||_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->fixed||_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->readonly){
|
||||
oldstr3724=_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE;
|
||||
if (oldstr3724->cmem_descriptor){
|
||||
_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE=qbs_new_cmem(oldstr3724->len,0);
|
||||
oldstr3712=_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE;
|
||||
if (oldstr3712->cmem_descriptor){
|
||||
_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE=qbs_new_cmem(oldstr3712->len,0);
|
||||
}else{
|
||||
_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE=qbs_new(oldstr3724->len,0);
|
||||
_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE=qbs_new(oldstr3712->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->chr,oldstr3724->chr,oldstr3724->len);
|
||||
memcpy(_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->chr,oldstr3712->chr,oldstr3712->len);
|
||||
}
|
||||
qbs*oldstr3725=NULL;
|
||||
qbs*oldstr3713=NULL;
|
||||
if(_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->tmp||_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->fixed||_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->readonly){
|
||||
oldstr3725=_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE;
|
||||
if (oldstr3725->cmem_descriptor){
|
||||
_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE=qbs_new_cmem(oldstr3725->len,0);
|
||||
oldstr3713=_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE;
|
||||
if (oldstr3713->cmem_descriptor){
|
||||
_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE=qbs_new_cmem(oldstr3713->len,0);
|
||||
}else{
|
||||
_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE=qbs_new(oldstr3725->len,0);
|
||||
_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE=qbs_new(oldstr3713->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->chr,oldstr3725->chr,oldstr3725->len);
|
||||
memcpy(_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->chr,oldstr3713->chr,oldstr3713->len);
|
||||
}
|
||||
qbs *_FUNC_ELEMENTGETSTRINGVALUE_STRING_RAWSTRING=NULL;
|
||||
if (!_FUNC_ELEMENTGETSTRINGVALUE_STRING_RAWSTRING)_FUNC_ELEMENTGETSTRINGVALUE_STRING_RAWSTRING=qbs_new(0,0);
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_CREATEELEMENTSTRING_STRING_CREATEELEMENTSTRING=NULL;
|
||||
if (!_FUNC_CREATEELEMENTSTRING_STRING_CREATEELEMENTSTRING)_FUNC_CREATEELEMENTSTRING_STRING_CREATEELEMENTSTRING=qbs_new(0,0);
|
||||
qbs*oldstr3727=NULL;
|
||||
qbs*oldstr3715=NULL;
|
||||
if(_FUNC_CREATEELEMENTSTRING_STRING_S->tmp||_FUNC_CREATEELEMENTSTRING_STRING_S->fixed||_FUNC_CREATEELEMENTSTRING_STRING_S->readonly){
|
||||
oldstr3727=_FUNC_CREATEELEMENTSTRING_STRING_S;
|
||||
if (oldstr3727->cmem_descriptor){
|
||||
_FUNC_CREATEELEMENTSTRING_STRING_S=qbs_new_cmem(oldstr3727->len,0);
|
||||
oldstr3715=_FUNC_CREATEELEMENTSTRING_STRING_S;
|
||||
if (oldstr3715->cmem_descriptor){
|
||||
_FUNC_CREATEELEMENTSTRING_STRING_S=qbs_new_cmem(oldstr3715->len,0);
|
||||
}else{
|
||||
_FUNC_CREATEELEMENTSTRING_STRING_S=qbs_new(oldstr3727->len,0);
|
||||
_FUNC_CREATEELEMENTSTRING_STRING_S=qbs_new(oldstr3715->len,0);
|
||||
}
|
||||
memcpy(_FUNC_CREATEELEMENTSTRING_STRING_S->chr,oldstr3727->chr,oldstr3727->len);
|
||||
memcpy(_FUNC_CREATEELEMENTSTRING_STRING_S->chr,oldstr3715->chr,oldstr3715->len);
|
||||
}
|
||||
qbs *_FUNC_CREATEELEMENTSTRING_STRING_ELE=NULL;
|
||||
if (!_FUNC_CREATEELEMENTSTRING_STRING_ELE)_FUNC_CREATEELEMENTSTRING_STRING_ELE=qbs_new(0,0);
|
||||
|
@ -29,23 +29,23 @@ if(_FUNC_CREATEELEMENTSTRING_LONG_I==NULL){
|
|||
_FUNC_CREATEELEMENTSTRING_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_CREATEELEMENTSTRING_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value3729;
|
||||
int64 fornext_finalvalue3729;
|
||||
int64 fornext_step3729;
|
||||
uint8 fornext_step_negative3729;
|
||||
byte_element_struct *byte_element_3730=NULL;
|
||||
if (!byte_element_3730){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3730=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3730=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3717;
|
||||
int64 fornext_finalvalue3717;
|
||||
int64 fornext_step3717;
|
||||
uint8 fornext_step_negative3717;
|
||||
byte_element_struct *byte_element_3718=NULL;
|
||||
if (!byte_element_3718){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3718=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3718=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3731=NULL;
|
||||
if (!byte_element_3731){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3731=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3731=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3719=NULL;
|
||||
if (!byte_element_3719){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3719=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3719=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3732=NULL;
|
||||
if (!byte_element_3732){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3732=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3732=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3720=NULL;
|
||||
if (!byte_element_3720){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3720=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3720=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3733=NULL;
|
||||
if (!byte_element_3733){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3733=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3733=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3721=NULL;
|
||||
if (!byte_element_3721){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3721=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3721=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,24 +1,24 @@
|
|||
qbs *_FUNC_ELEMENTSTRINGCONCAT_STRING_ELEMENTSTRINGCONCAT=NULL;
|
||||
if (!_FUNC_ELEMENTSTRINGCONCAT_STRING_ELEMENTSTRINGCONCAT)_FUNC_ELEMENTSTRINGCONCAT_STRING_ELEMENTSTRINGCONCAT=qbs_new(0,0);
|
||||
qbs*oldstr3734=NULL;
|
||||
qbs*oldstr3722=NULL;
|
||||
if(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->tmp||_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->fixed||_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->readonly){
|
||||
oldstr3734=_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1;
|
||||
if (oldstr3734->cmem_descriptor){
|
||||
_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1=qbs_new_cmem(oldstr3734->len,0);
|
||||
oldstr3722=_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1;
|
||||
if (oldstr3722->cmem_descriptor){
|
||||
_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1=qbs_new_cmem(oldstr3722->len,0);
|
||||
}else{
|
||||
_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1=qbs_new(oldstr3734->len,0);
|
||||
_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1=qbs_new(oldstr3722->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->chr,oldstr3734->chr,oldstr3734->len);
|
||||
memcpy(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->chr,oldstr3722->chr,oldstr3722->len);
|
||||
}
|
||||
qbs*oldstr3735=NULL;
|
||||
qbs*oldstr3723=NULL;
|
||||
if(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->tmp||_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->fixed||_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->readonly){
|
||||
oldstr3735=_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2;
|
||||
if (oldstr3735->cmem_descriptor){
|
||||
_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2=qbs_new_cmem(oldstr3735->len,0);
|
||||
oldstr3723=_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2;
|
||||
if (oldstr3723->cmem_descriptor){
|
||||
_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2=qbs_new_cmem(oldstr3723->len,0);
|
||||
}else{
|
||||
_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2=qbs_new(oldstr3735->len,0);
|
||||
_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2=qbs_new(oldstr3723->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->chr,oldstr3735->chr,oldstr3735->len);
|
||||
memcpy(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->chr,oldstr3723->chr,oldstr3723->len);
|
||||
}
|
||||
qbs *_FUNC_ELEMENTSTRINGCONCAT_STRING_S1=NULL;
|
||||
if (!_FUNC_ELEMENTSTRINGCONCAT_STRING_S1)_FUNC_ELEMENTSTRINGCONCAT_STRING_S1=qbs_new(0,0);
|
||||
|
@ -34,19 +34,19 @@ if(_FUNC_ELEMENTSTRINGCONCAT_LONG_S2SIZE==NULL){
|
|||
_FUNC_ELEMENTSTRINGCONCAT_LONG_S2SIZE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ELEMENTSTRINGCONCAT_LONG_S2SIZE=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3736=NULL;
|
||||
if (!byte_element_3736){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3736=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3736=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3724=NULL;
|
||||
if (!byte_element_3724){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3724=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3724=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3737=NULL;
|
||||
if (!byte_element_3737){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3737=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3737=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3725=NULL;
|
||||
if (!byte_element_3725){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3725=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3725=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3738=NULL;
|
||||
if (!byte_element_3738){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3738=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3738=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3726=NULL;
|
||||
if (!byte_element_3726){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3726=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3726=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3739=NULL;
|
||||
if (!byte_element_3739){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3739=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3739=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3727=NULL;
|
||||
if (!byte_element_3727){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3727=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3727=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,34 +1,34 @@
|
|||
qbs *_FUNC_GL2QB_TYPE_CONVERT_STRING_GL2QB_TYPE_CONVERT=NULL;
|
||||
if (!_FUNC_GL2QB_TYPE_CONVERT_STRING_GL2QB_TYPE_CONVERT)_FUNC_GL2QB_TYPE_CONVERT_STRING_GL2QB_TYPE_CONVERT=qbs_new(0,0);
|
||||
qbs*oldstr3740=NULL;
|
||||
qbs*oldstr3728=NULL;
|
||||
if(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_A->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_A->readonly){
|
||||
oldstr3740=_FUNC_GL2QB_TYPE_CONVERT_STRING_A;
|
||||
if (oldstr3740->cmem_descriptor){
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new_cmem(oldstr3740->len,0);
|
||||
oldstr3728=_FUNC_GL2QB_TYPE_CONVERT_STRING_A;
|
||||
if (oldstr3728->cmem_descriptor){
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new_cmem(oldstr3728->len,0);
|
||||
}else{
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new(oldstr3740->len,0);
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new(oldstr3728->len,0);
|
||||
}
|
||||
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->chr,oldstr3740->chr,oldstr3740->len);
|
||||
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->chr,oldstr3728->chr,oldstr3728->len);
|
||||
}
|
||||
qbs*oldstr3741=NULL;
|
||||
qbs*oldstr3729=NULL;
|
||||
if(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->readonly){
|
||||
oldstr3741=_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL;
|
||||
if (oldstr3741->cmem_descriptor){
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new_cmem(oldstr3741->len,0);
|
||||
oldstr3729=_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL;
|
||||
if (oldstr3729->cmem_descriptor){
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new_cmem(oldstr3729->len,0);
|
||||
}else{
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new(oldstr3741->len,0);
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new(oldstr3729->len,0);
|
||||
}
|
||||
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->chr,oldstr3741->chr,oldstr3741->len);
|
||||
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->chr,oldstr3729->chr,oldstr3729->len);
|
||||
}
|
||||
qbs*oldstr3742=NULL;
|
||||
qbs*oldstr3730=NULL;
|
||||
if(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->readonly){
|
||||
oldstr3742=_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP;
|
||||
if (oldstr3742->cmem_descriptor){
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new_cmem(oldstr3742->len,0);
|
||||
oldstr3730=_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP;
|
||||
if (oldstr3730->cmem_descriptor){
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new_cmem(oldstr3730->len,0);
|
||||
}else{
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new(oldstr3742->len,0);
|
||||
_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new(oldstr3730->len,0);
|
||||
}
|
||||
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->chr,oldstr3742->chr,oldstr3742->len);
|
||||
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->chr,oldstr3730->chr,oldstr3730->len);
|
||||
}
|
||||
qbs *_FUNC_GL2QB_TYPE_CONVERT_STRING_B=NULL;
|
||||
if (!_FUNC_GL2QB_TYPE_CONVERT_STRING_B)_FUNC_GL2QB_TYPE_CONVERT_STRING_B=qbs_new(0,0);
|
||||
|
|
|
@ -1,44 +1,44 @@
|
|||
qbs *_FUNC_READCHUNK_STRING_READCHUNK=NULL;
|
||||
if (!_FUNC_READCHUNK_STRING_READCHUNK)_FUNC_READCHUNK_STRING_READCHUNK=qbs_new(0,0);
|
||||
qbs*oldstr3744=NULL;
|
||||
qbs*oldstr3732=NULL;
|
||||
if(_FUNC_READCHUNK_STRING_A->tmp||_FUNC_READCHUNK_STRING_A->fixed||_FUNC_READCHUNK_STRING_A->readonly){
|
||||
oldstr3744=_FUNC_READCHUNK_STRING_A;
|
||||
if (oldstr3744->cmem_descriptor){
|
||||
_FUNC_READCHUNK_STRING_A=qbs_new_cmem(oldstr3744->len,0);
|
||||
oldstr3732=_FUNC_READCHUNK_STRING_A;
|
||||
if (oldstr3732->cmem_descriptor){
|
||||
_FUNC_READCHUNK_STRING_A=qbs_new_cmem(oldstr3732->len,0);
|
||||
}else{
|
||||
_FUNC_READCHUNK_STRING_A=qbs_new(oldstr3744->len,0);
|
||||
_FUNC_READCHUNK_STRING_A=qbs_new(oldstr3732->len,0);
|
||||
}
|
||||
memcpy(_FUNC_READCHUNK_STRING_A->chr,oldstr3744->chr,oldstr3744->len);
|
||||
memcpy(_FUNC_READCHUNK_STRING_A->chr,oldstr3732->chr,oldstr3732->len);
|
||||
}
|
||||
qbs*oldstr3745=NULL;
|
||||
qbs*oldstr3733=NULL;
|
||||
if(_FUNC_READCHUNK_STRING_LAST_CHARACTER->tmp||_FUNC_READCHUNK_STRING_LAST_CHARACTER->fixed||_FUNC_READCHUNK_STRING_LAST_CHARACTER->readonly){
|
||||
oldstr3745=_FUNC_READCHUNK_STRING_LAST_CHARACTER;
|
||||
if (oldstr3745->cmem_descriptor){
|
||||
_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new_cmem(oldstr3745->len,0);
|
||||
oldstr3733=_FUNC_READCHUNK_STRING_LAST_CHARACTER;
|
||||
if (oldstr3733->cmem_descriptor){
|
||||
_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new_cmem(oldstr3733->len,0);
|
||||
}else{
|
||||
_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new(oldstr3745->len,0);
|
||||
_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new(oldstr3733->len,0);
|
||||
}
|
||||
memcpy(_FUNC_READCHUNK_STRING_LAST_CHARACTER->chr,oldstr3745->chr,oldstr3745->len);
|
||||
memcpy(_FUNC_READCHUNK_STRING_LAST_CHARACTER->chr,oldstr3733->chr,oldstr3733->len);
|
||||
}
|
||||
int32 *_FUNC_READCHUNK_LONG_X=NULL;
|
||||
if(_FUNC_READCHUNK_LONG_X==NULL){
|
||||
_FUNC_READCHUNK_LONG_X=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_READCHUNK_LONG_X=0;
|
||||
}
|
||||
int64 fornext_value3747;
|
||||
int64 fornext_finalvalue3747;
|
||||
int64 fornext_step3747;
|
||||
uint8 fornext_step_negative3747;
|
||||
byte_element_struct *byte_element_3748=NULL;
|
||||
if (!byte_element_3748){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3748=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3748=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3735;
|
||||
int64 fornext_finalvalue3735;
|
||||
int64 fornext_step3735;
|
||||
uint8 fornext_step_negative3735;
|
||||
byte_element_struct *byte_element_3736=NULL;
|
||||
if (!byte_element_3736){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3736=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3736=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_READCHUNK_LONG_C=NULL;
|
||||
if(_FUNC_READCHUNK_LONG_C==NULL){
|
||||
_FUNC_READCHUNK_LONG_C=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_READCHUNK_LONG_C=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3749=NULL;
|
||||
if (!byte_element_3749){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3749=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3749=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3737=NULL;
|
||||
if (!byte_element_3737){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3737=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3737=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -17,22 +17,22 @@ _SUB_GL_SCAN_HEADER_LONG_H=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_SUB_GL_SCAN_HEADER_STRING_A=NULL;
|
||||
if (!_SUB_GL_SCAN_HEADER_STRING_A)_SUB_GL_SCAN_HEADER_STRING_A=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_3753=NULL;
|
||||
if (!byte_element_3753){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3753=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3753=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3741=NULL;
|
||||
if (!byte_element_3741){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3741=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3741=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_SUB_GL_SCAN_HEADER_LONG_X=NULL;
|
||||
if(_SUB_GL_SCAN_HEADER_LONG_X==NULL){
|
||||
_SUB_GL_SCAN_HEADER_LONG_X=(int32*)mem_static_malloc(4);
|
||||
*_SUB_GL_SCAN_HEADER_LONG_X=0;
|
||||
}
|
||||
int64 fornext_value3755;
|
||||
int64 fornext_finalvalue3755;
|
||||
int64 fornext_step3755;
|
||||
uint8 fornext_step_negative3755;
|
||||
byte_element_struct *byte_element_3756=NULL;
|
||||
if (!byte_element_3756){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3756=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3756=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3743;
|
||||
int64 fornext_finalvalue3743;
|
||||
int64 fornext_step3743;
|
||||
uint8 fornext_step_negative3743;
|
||||
byte_element_struct *byte_element_3744=NULL;
|
||||
if (!byte_element_3744){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3744=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3744=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_SUB_GL_SCAN_HEADER_LONG_C=NULL;
|
||||
if(_SUB_GL_SCAN_HEADER_LONG_C==NULL){
|
||||
|
@ -44,13 +44,13 @@ if(_SUB_GL_SCAN_HEADER_LONG_X2==NULL){
|
|||
_SUB_GL_SCAN_HEADER_LONG_X2=(int32*)mem_static_malloc(4);
|
||||
*_SUB_GL_SCAN_HEADER_LONG_X2=0;
|
||||
}
|
||||
int64 fornext_value3758;
|
||||
int64 fornext_finalvalue3758;
|
||||
int64 fornext_step3758;
|
||||
uint8 fornext_step_negative3758;
|
||||
byte_element_struct *byte_element_3759=NULL;
|
||||
if (!byte_element_3759){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3759=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3759=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3746;
|
||||
int64 fornext_finalvalue3746;
|
||||
int64 fornext_step3746;
|
||||
uint8 fornext_step_negative3746;
|
||||
byte_element_struct *byte_element_3747=NULL;
|
||||
if (!byte_element_3747){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3747=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3747=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_SUB_GL_SCAN_HEADER_LONG_C2=NULL;
|
||||
if(_SUB_GL_SCAN_HEADER_LONG_C2==NULL){
|
||||
|
@ -59,32 +59,32 @@ _SUB_GL_SCAN_HEADER_LONG_C2=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_SUB_GL_SCAN_HEADER_STRING_VALUE=NULL;
|
||||
if (!_SUB_GL_SCAN_HEADER_STRING_VALUE)_SUB_GL_SCAN_HEADER_STRING_VALUE=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_3760=NULL;
|
||||
if (!byte_element_3760){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3760=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3760=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3748=NULL;
|
||||
if (!byte_element_3748){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3748=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3748=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3761=NULL;
|
||||
if (!byte_element_3761){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3761=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3761=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3749=NULL;
|
||||
if (!byte_element_3749){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3749=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3749=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int64 *_SUB_GL_SCAN_HEADER_INTEGER64_VALUE=NULL;
|
||||
if(_SUB_GL_SCAN_HEADER_INTEGER64_VALUE==NULL){
|
||||
_SUB_GL_SCAN_HEADER_INTEGER64_VALUE=(int64*)mem_static_malloc(8);
|
||||
*_SUB_GL_SCAN_HEADER_INTEGER64_VALUE=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3762=NULL;
|
||||
if (!byte_element_3762){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3762=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3762=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3750=NULL;
|
||||
if (!byte_element_3750){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3750=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3750=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_SUB_GL_SCAN_HEADER_LONG_I=NULL;
|
||||
if(_SUB_GL_SCAN_HEADER_LONG_I==NULL){
|
||||
_SUB_GL_SCAN_HEADER_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_SUB_GL_SCAN_HEADER_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value3764;
|
||||
int64 fornext_finalvalue3764;
|
||||
int64 fornext_step3764;
|
||||
uint8 fornext_step_negative3764;
|
||||
int64 fornext_value3752;
|
||||
int64 fornext_finalvalue3752;
|
||||
int64 fornext_step3752;
|
||||
uint8 fornext_step_negative3752;
|
||||
qbs *_SUB_GL_SCAN_HEADER_STRING_L=NULL;
|
||||
if (!_SUB_GL_SCAN_HEADER_STRING_L)_SUB_GL_SCAN_HEADER_STRING_L=qbs_new(0,0);
|
||||
qbs *_SUB_GL_SCAN_HEADER_STRING_RET_TYPE=NULL;
|
||||
|
@ -125,23 +125,23 @@ qbs *_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE=NULL;
|
|||
if (!_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE)_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE=qbs_new(0,0);
|
||||
qbs *_SUB_GL_SCAN_HEADER_STRING_VAR_NAME=NULL;
|
||||
if (!_SUB_GL_SCAN_HEADER_STRING_VAR_NAME)_SUB_GL_SCAN_HEADER_STRING_VAR_NAME=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_3771=NULL;
|
||||
if (!byte_element_3771){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3771=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3771=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3759=NULL;
|
||||
if (!byte_element_3759){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3759=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3759=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3772=NULL;
|
||||
if (!byte_element_3772){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3772=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3772=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3760=NULL;
|
||||
if (!byte_element_3760){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3760=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3760=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE_BACKUP=NULL;
|
||||
if (!_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE_BACKUP)_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE_BACKUP=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_3773=NULL;
|
||||
if (!byte_element_3773){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3773=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3773=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3761=NULL;
|
||||
if (!byte_element_3761){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3761=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3761=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3774=NULL;
|
||||
if (!byte_element_3774){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3774=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3774=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3762=NULL;
|
||||
if (!byte_element_3762){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3762=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3762=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_SUB_GL_SCAN_HEADER_STRING_QB_TYPE=NULL;
|
||||
if (!_SUB_GL_SCAN_HEADER_STRING_QB_TYPE)_SUB_GL_SCAN_HEADER_STRING_QB_TYPE=qbs_new(0,0);
|
||||
|
@ -151,10 +151,10 @@ qbs *_SUB_GL_SCAN_HEADER_STRING_LETTER=NULL;
|
|||
if (!_SUB_GL_SCAN_HEADER_STRING_LETTER)_SUB_GL_SCAN_HEADER_STRING_LETTER=qbs_new(0,0);
|
||||
qbs *_SUB_GL_SCAN_HEADER_STRING_H=NULL;
|
||||
if (!_SUB_GL_SCAN_HEADER_STRING_H)_SUB_GL_SCAN_HEADER_STRING_H=qbs_new(0,0);
|
||||
int64 fornext_value3781;
|
||||
int64 fornext_finalvalue3781;
|
||||
int64 fornext_step3781;
|
||||
uint8 fornext_step_negative3781;
|
||||
int64 fornext_value3769;
|
||||
int64 fornext_finalvalue3769;
|
||||
int64 fornext_step3769;
|
||||
uint8 fornext_step_negative3769;
|
||||
int32 *_SUB_GL_SCAN_HEADER_LONG_FH=NULL;
|
||||
if(_SUB_GL_SCAN_HEADER_LONG_FH==NULL){
|
||||
_SUB_GL_SCAN_HEADER_LONG_FH=(int32*)mem_static_malloc(4);
|
||||
|
|
|
@ -3,25 +3,25 @@ if(_SUB_GL_INCLUDE_CONTENT_LONG_D==NULL){
|
|||
_SUB_GL_INCLUDE_CONTENT_LONG_D=(int32*)mem_static_malloc(4);
|
||||
*_SUB_GL_INCLUDE_CONTENT_LONG_D=0;
|
||||
}
|
||||
int64 fornext_value3785;
|
||||
int64 fornext_finalvalue3785;
|
||||
int64 fornext_step3785;
|
||||
uint8 fornext_step_negative3785;
|
||||
int64 fornext_value3773;
|
||||
int64 fornext_finalvalue3773;
|
||||
int64 fornext_step3773;
|
||||
uint8 fornext_step_negative3773;
|
||||
int32 *_SUB_GL_INCLUDE_CONTENT_LONG_I=NULL;
|
||||
if(_SUB_GL_INCLUDE_CONTENT_LONG_I==NULL){
|
||||
_SUB_GL_INCLUDE_CONTENT_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_SUB_GL_INCLUDE_CONTENT_LONG_I=0;
|
||||
}
|
||||
int32 pass3786;
|
||||
int32 pass3774;
|
||||
int32 *_SUB_GL_INCLUDE_CONTENT_LONG_C=NULL;
|
||||
if(_SUB_GL_INCLUDE_CONTENT_LONG_C==NULL){
|
||||
_SUB_GL_INCLUDE_CONTENT_LONG_C=(int32*)mem_static_malloc(4);
|
||||
*_SUB_GL_INCLUDE_CONTENT_LONG_C=0;
|
||||
}
|
||||
int64 fornext_value3788;
|
||||
int64 fornext_finalvalue3788;
|
||||
int64 fornext_step3788;
|
||||
uint8 fornext_step_negative3788;
|
||||
int64 fornext_value3776;
|
||||
int64 fornext_finalvalue3776;
|
||||
int64 fornext_step3776;
|
||||
uint8 fornext_step_negative3776;
|
||||
void *_SUB_GL_INCLUDE_CONTENT_UDT_G=NULL;
|
||||
if(_SUB_GL_INCLUDE_CONTENT_UDT_G==NULL){
|
||||
_SUB_GL_INCLUDE_CONTENT_UDT_G=(void*)mem_static_malloc(216);
|
||||
|
|
|
@ -1,25 +1,25 @@
|
|||
qbs*oldstr2367=NULL;
|
||||
qbs*oldstr2355=NULL;
|
||||
if(_SUB_VWATCHVARIABLE_STRING_THIS->tmp||_SUB_VWATCHVARIABLE_STRING_THIS->fixed||_SUB_VWATCHVARIABLE_STRING_THIS->readonly){
|
||||
oldstr2367=_SUB_VWATCHVARIABLE_STRING_THIS;
|
||||
if (oldstr2367->cmem_descriptor){
|
||||
_SUB_VWATCHVARIABLE_STRING_THIS=qbs_new_cmem(oldstr2367->len,0);
|
||||
oldstr2355=_SUB_VWATCHVARIABLE_STRING_THIS;
|
||||
if (oldstr2355->cmem_descriptor){
|
||||
_SUB_VWATCHVARIABLE_STRING_THIS=qbs_new_cmem(oldstr2355->len,0);
|
||||
}else{
|
||||
_SUB_VWATCHVARIABLE_STRING_THIS=qbs_new(oldstr2367->len,0);
|
||||
_SUB_VWATCHVARIABLE_STRING_THIS=qbs_new(oldstr2355->len,0);
|
||||
}
|
||||
memcpy(_SUB_VWATCHVARIABLE_STRING_THIS->chr,oldstr2367->chr,oldstr2367->len);
|
||||
memcpy(_SUB_VWATCHVARIABLE_STRING_THIS->chr,oldstr2355->chr,oldstr2355->len);
|
||||
}
|
||||
int32 pass2369;
|
||||
int32 pass2370;
|
||||
int8 pass2371;
|
||||
int32 pass2372;
|
||||
int32 pass2373;
|
||||
int8 pass2374;
|
||||
int16 pass2375;
|
||||
int16 pass2376;
|
||||
int16 pass2377;
|
||||
int16 pass2378;
|
||||
int16 pass2379;
|
||||
int16 pass2380;
|
||||
int16 pass2381;
|
||||
int16 pass2382;
|
||||
int16 pass2383;
|
||||
int32 pass2357;
|
||||
int32 pass2358;
|
||||
int8 pass2359;
|
||||
int32 pass2360;
|
||||
int32 pass2361;
|
||||
int8 pass2362;
|
||||
int16 pass2363;
|
||||
int16 pass2364;
|
||||
int16 pass2365;
|
||||
int16 pass2366;
|
||||
int16 pass2367;
|
||||
int16 pass2368;
|
||||
int16 pass2369;
|
||||
int16 pass2370;
|
||||
int16 pass2371;
|
||||
|
|
|
@ -1,17 +1,17 @@
|
|||
byte_element_struct *byte_element_3789=NULL;
|
||||
if (!byte_element_3789){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3789=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3789=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3777=NULL;
|
||||
if (!byte_element_3777){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3777=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3777=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int16 *_SUB_INICOMMIT_INTEGER_FILENUM=NULL;
|
||||
if(_SUB_INICOMMIT_INTEGER_FILENUM==NULL){
|
||||
_SUB_INICOMMIT_INTEGER_FILENUM=(int16*)mem_static_malloc(2);
|
||||
*_SUB_INICOMMIT_INTEGER_FILENUM=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3790=NULL;
|
||||
if (!byte_element_3790){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3790=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3790=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3778=NULL;
|
||||
if (!byte_element_3778){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3778=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3778=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3791=NULL;
|
||||
if (!byte_element_3791){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3791=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3791=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3779=NULL;
|
||||
if (!byte_element_3779){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3779=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3779=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_INIGETSECTION_STRING_INIGETSECTION=NULL;
|
||||
if (!_FUNC_INIGETSECTION_STRING_INIGETSECTION)_FUNC_INIGETSECTION_STRING_INIGETSECTION=qbs_new(0,0);
|
||||
qbs*oldstr3792=NULL;
|
||||
qbs*oldstr3780=NULL;
|
||||
if(_FUNC_INIGETSECTION_STRING___SECTION->tmp||_FUNC_INIGETSECTION_STRING___SECTION->fixed||_FUNC_INIGETSECTION_STRING___SECTION->readonly){
|
||||
oldstr3792=_FUNC_INIGETSECTION_STRING___SECTION;
|
||||
if (oldstr3792->cmem_descriptor){
|
||||
_FUNC_INIGETSECTION_STRING___SECTION=qbs_new_cmem(oldstr3792->len,0);
|
||||
oldstr3780=_FUNC_INIGETSECTION_STRING___SECTION;
|
||||
if (oldstr3780->cmem_descriptor){
|
||||
_FUNC_INIGETSECTION_STRING___SECTION=qbs_new_cmem(oldstr3780->len,0);
|
||||
}else{
|
||||
_FUNC_INIGETSECTION_STRING___SECTION=qbs_new(oldstr3792->len,0);
|
||||
_FUNC_INIGETSECTION_STRING___SECTION=qbs_new(oldstr3780->len,0);
|
||||
}
|
||||
memcpy(_FUNC_INIGETSECTION_STRING___SECTION->chr,oldstr3792->chr,oldstr3792->len);
|
||||
memcpy(_FUNC_INIGETSECTION_STRING___SECTION->chr,oldstr3780->chr,oldstr3780->len);
|
||||
}
|
||||
qbs *_FUNC_INIGETSECTION_STRING_SECTION=NULL;
|
||||
if (!_FUNC_INIGETSECTION_STRING_SECTION)_FUNC_INIGETSECTION_STRING_SECTION=qbs_new(0,0);
|
||||
|
@ -42,23 +42,23 @@ if(_FUNC_INIGETSECTION_BYTE_INQUOTE==NULL){
|
|||
_FUNC_INIGETSECTION_BYTE_INQUOTE=(int8*)mem_static_malloc(1);
|
||||
*_FUNC_INIGETSECTION_BYTE_INQUOTE=0;
|
||||
}
|
||||
int64 fornext_value3794;
|
||||
int64 fornext_finalvalue3794;
|
||||
int64 fornext_step3794;
|
||||
uint8 fornext_step_negative3794;
|
||||
int64 fornext_value3797;
|
||||
int64 fornext_finalvalue3797;
|
||||
int64 fornext_step3797;
|
||||
uint8 fornext_step_negative3797;
|
||||
int64 fornext_value3799;
|
||||
int64 fornext_finalvalue3799;
|
||||
int64 fornext_step3799;
|
||||
uint8 fornext_step_negative3799;
|
||||
int64 fornext_value3801;
|
||||
int64 fornext_finalvalue3801;
|
||||
int64 fornext_step3801;
|
||||
uint8 fornext_step_negative3801;
|
||||
byte_element_struct *byte_element_3802=NULL;
|
||||
if (!byte_element_3802){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3802=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3802=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3782;
|
||||
int64 fornext_finalvalue3782;
|
||||
int64 fornext_step3782;
|
||||
uint8 fornext_step_negative3782;
|
||||
int64 fornext_value3785;
|
||||
int64 fornext_finalvalue3785;
|
||||
int64 fornext_step3785;
|
||||
uint8 fornext_step_negative3785;
|
||||
int64 fornext_value3787;
|
||||
int64 fornext_finalvalue3787;
|
||||
int64 fornext_step3787;
|
||||
uint8 fornext_step_negative3787;
|
||||
int64 fornext_value3789;
|
||||
int64 fornext_finalvalue3789;
|
||||
int64 fornext_step3789;
|
||||
uint8 fornext_step_negative3789;
|
||||
byte_element_struct *byte_element_3790=NULL;
|
||||
if (!byte_element_3790){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3790=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3790=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,22 +1,22 @@
|
|||
qbs *_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION=NULL;
|
||||
if (!_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION)_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION=qbs_new(0,0);
|
||||
qbs*oldstr3803=NULL;
|
||||
qbs*oldstr3791=NULL;
|
||||
if(_FUNC_INIFORMATSECTION_STRING___SECTION->tmp||_FUNC_INIFORMATSECTION_STRING___SECTION->fixed||_FUNC_INIFORMATSECTION_STRING___SECTION->readonly){
|
||||
oldstr3803=_FUNC_INIFORMATSECTION_STRING___SECTION;
|
||||
if (oldstr3803->cmem_descriptor){
|
||||
_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new_cmem(oldstr3803->len,0);
|
||||
oldstr3791=_FUNC_INIFORMATSECTION_STRING___SECTION;
|
||||
if (oldstr3791->cmem_descriptor){
|
||||
_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new_cmem(oldstr3791->len,0);
|
||||
}else{
|
||||
_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new(oldstr3803->len,0);
|
||||
_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new(oldstr3791->len,0);
|
||||
}
|
||||
memcpy(_FUNC_INIFORMATSECTION_STRING___SECTION->chr,oldstr3803->chr,oldstr3803->len);
|
||||
memcpy(_FUNC_INIFORMATSECTION_STRING___SECTION->chr,oldstr3791->chr,oldstr3791->len);
|
||||
}
|
||||
qbs *_FUNC_INIFORMATSECTION_STRING_SECTION=NULL;
|
||||
if (!_FUNC_INIFORMATSECTION_STRING_SECTION)_FUNC_INIFORMATSECTION_STRING_SECTION=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_3804=NULL;
|
||||
if (!byte_element_3804){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3804=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3804=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3792=NULL;
|
||||
if (!byte_element_3792){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3792=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3792=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3805=NULL;
|
||||
if (!byte_element_3805){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3805=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3805=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3793=NULL;
|
||||
if (!byte_element_3793){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3793=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3793=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,34 +1,34 @@
|
|||
qbs *_FUNC_READSETTING_STRING_READSETTING=NULL;
|
||||
if (!_FUNC_READSETTING_STRING_READSETTING)_FUNC_READSETTING_STRING_READSETTING=qbs_new(0,0);
|
||||
qbs*oldstr3806=NULL;
|
||||
qbs*oldstr3794=NULL;
|
||||
if(_FUNC_READSETTING_STRING_FILE->tmp||_FUNC_READSETTING_STRING_FILE->fixed||_FUNC_READSETTING_STRING_FILE->readonly){
|
||||
oldstr3806=_FUNC_READSETTING_STRING_FILE;
|
||||
if (oldstr3806->cmem_descriptor){
|
||||
_FUNC_READSETTING_STRING_FILE=qbs_new_cmem(oldstr3806->len,0);
|
||||
oldstr3794=_FUNC_READSETTING_STRING_FILE;
|
||||
if (oldstr3794->cmem_descriptor){
|
||||
_FUNC_READSETTING_STRING_FILE=qbs_new_cmem(oldstr3794->len,0);
|
||||
}else{
|
||||
_FUNC_READSETTING_STRING_FILE=qbs_new(oldstr3806->len,0);
|
||||
_FUNC_READSETTING_STRING_FILE=qbs_new(oldstr3794->len,0);
|
||||
}
|
||||
memcpy(_FUNC_READSETTING_STRING_FILE->chr,oldstr3806->chr,oldstr3806->len);
|
||||
memcpy(_FUNC_READSETTING_STRING_FILE->chr,oldstr3794->chr,oldstr3794->len);
|
||||
}
|
||||
qbs*oldstr3807=NULL;
|
||||
qbs*oldstr3795=NULL;
|
||||
if(_FUNC_READSETTING_STRING___SECTION->tmp||_FUNC_READSETTING_STRING___SECTION->fixed||_FUNC_READSETTING_STRING___SECTION->readonly){
|
||||
oldstr3807=_FUNC_READSETTING_STRING___SECTION;
|
||||
if (oldstr3807->cmem_descriptor){
|
||||
_FUNC_READSETTING_STRING___SECTION=qbs_new_cmem(oldstr3807->len,0);
|
||||
oldstr3795=_FUNC_READSETTING_STRING___SECTION;
|
||||
if (oldstr3795->cmem_descriptor){
|
||||
_FUNC_READSETTING_STRING___SECTION=qbs_new_cmem(oldstr3795->len,0);
|
||||
}else{
|
||||
_FUNC_READSETTING_STRING___SECTION=qbs_new(oldstr3807->len,0);
|
||||
_FUNC_READSETTING_STRING___SECTION=qbs_new(oldstr3795->len,0);
|
||||
}
|
||||
memcpy(_FUNC_READSETTING_STRING___SECTION->chr,oldstr3807->chr,oldstr3807->len);
|
||||
memcpy(_FUNC_READSETTING_STRING___SECTION->chr,oldstr3795->chr,oldstr3795->len);
|
||||
}
|
||||
qbs*oldstr3808=NULL;
|
||||
qbs*oldstr3796=NULL;
|
||||
if(_FUNC_READSETTING_STRING___KEY->tmp||_FUNC_READSETTING_STRING___KEY->fixed||_FUNC_READSETTING_STRING___KEY->readonly){
|
||||
oldstr3808=_FUNC_READSETTING_STRING___KEY;
|
||||
if (oldstr3808->cmem_descriptor){
|
||||
_FUNC_READSETTING_STRING___KEY=qbs_new_cmem(oldstr3808->len,0);
|
||||
oldstr3796=_FUNC_READSETTING_STRING___KEY;
|
||||
if (oldstr3796->cmem_descriptor){
|
||||
_FUNC_READSETTING_STRING___KEY=qbs_new_cmem(oldstr3796->len,0);
|
||||
}else{
|
||||
_FUNC_READSETTING_STRING___KEY=qbs_new(oldstr3808->len,0);
|
||||
_FUNC_READSETTING_STRING___KEY=qbs_new(oldstr3796->len,0);
|
||||
}
|
||||
memcpy(_FUNC_READSETTING_STRING___KEY->chr,oldstr3808->chr,oldstr3808->len);
|
||||
memcpy(_FUNC_READSETTING_STRING___KEY->chr,oldstr3796->chr,oldstr3796->len);
|
||||
}
|
||||
uint32 *_FUNC_READSETTING_ULONG_EQUAL=NULL;
|
||||
if(_FUNC_READSETTING_ULONG_EQUAL==NULL){
|
||||
|
@ -61,31 +61,31 @@ if(_FUNC_READSETTING_ULONG_FOUNDLF==NULL){
|
|||
_FUNC_READSETTING_ULONG_FOUNDLF=(uint32*)mem_static_malloc(4);
|
||||
*_FUNC_READSETTING_ULONG_FOUNDLF=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3809=NULL;
|
||||
if (!byte_element_3809){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3809=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3809=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3797=NULL;
|
||||
if (!byte_element_3797){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3797=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3797=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int64 fornext_value3811;
|
||||
int64 fornext_finalvalue3811;
|
||||
int64 fornext_step3811;
|
||||
uint8 fornext_step_negative3811;
|
||||
int64 fornext_value3813;
|
||||
int64 fornext_finalvalue3813;
|
||||
int64 fornext_step3813;
|
||||
uint8 fornext_step_negative3813;
|
||||
byte_element_struct *byte_element_3814=NULL;
|
||||
if (!byte_element_3814){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3814=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3814=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3799;
|
||||
int64 fornext_finalvalue3799;
|
||||
int64 fornext_step3799;
|
||||
uint8 fornext_step_negative3799;
|
||||
int64 fornext_value3801;
|
||||
int64 fornext_finalvalue3801;
|
||||
int64 fornext_step3801;
|
||||
uint8 fornext_step_negative3801;
|
||||
byte_element_struct *byte_element_3802=NULL;
|
||||
if (!byte_element_3802){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3802=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3802=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3815=NULL;
|
||||
if (!byte_element_3815){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3815=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3815=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3803=NULL;
|
||||
if (!byte_element_3803){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3803=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3803=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3816=NULL;
|
||||
if (!byte_element_3816){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3816=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3816=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3804=NULL;
|
||||
if (!byte_element_3804){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3804=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3804=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3817=NULL;
|
||||
if (!byte_element_3817){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3817=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3817=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3805=NULL;
|
||||
if (!byte_element_3805){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3805=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3805=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -15,11 +15,11 @@ if(_FUNC_INICURRENTSECTION_ULONG_CLOSINGBRACKET==NULL){
|
|||
_FUNC_INICURRENTSECTION_ULONG_CLOSINGBRACKET=(uint32*)mem_static_malloc(4);
|
||||
*_FUNC_INICURRENTSECTION_ULONG_CLOSINGBRACKET=0;
|
||||
}
|
||||
int64 fornext_value3819;
|
||||
int64 fornext_finalvalue3819;
|
||||
int64 fornext_step3819;
|
||||
uint8 fornext_step_negative3819;
|
||||
int64 fornext_value3821;
|
||||
int64 fornext_finalvalue3821;
|
||||
int64 fornext_step3821;
|
||||
uint8 fornext_step_negative3821;
|
||||
int64 fornext_value3807;
|
||||
int64 fornext_finalvalue3807;
|
||||
int64 fornext_step3807;
|
||||
uint8 fornext_step_negative3807;
|
||||
int64 fornext_value3809;
|
||||
int64 fornext_finalvalue3809;
|
||||
int64 fornext_step3809;
|
||||
uint8 fornext_step_negative3809;
|
||||
|
|
|
@ -1,42 +1,42 @@
|
|||
qbs*oldstr3822=NULL;
|
||||
qbs*oldstr3810=NULL;
|
||||
if(_SUB_WRITESETTING_STRING_FILE->tmp||_SUB_WRITESETTING_STRING_FILE->fixed||_SUB_WRITESETTING_STRING_FILE->readonly){
|
||||
oldstr3822=_SUB_WRITESETTING_STRING_FILE;
|
||||
if (oldstr3822->cmem_descriptor){
|
||||
_SUB_WRITESETTING_STRING_FILE=qbs_new_cmem(oldstr3822->len,0);
|
||||
oldstr3810=_SUB_WRITESETTING_STRING_FILE;
|
||||
if (oldstr3810->cmem_descriptor){
|
||||
_SUB_WRITESETTING_STRING_FILE=qbs_new_cmem(oldstr3810->len,0);
|
||||
}else{
|
||||
_SUB_WRITESETTING_STRING_FILE=qbs_new(oldstr3822->len,0);
|
||||
_SUB_WRITESETTING_STRING_FILE=qbs_new(oldstr3810->len,0);
|
||||
}
|
||||
memcpy(_SUB_WRITESETTING_STRING_FILE->chr,oldstr3822->chr,oldstr3822->len);
|
||||
memcpy(_SUB_WRITESETTING_STRING_FILE->chr,oldstr3810->chr,oldstr3810->len);
|
||||
}
|
||||
qbs*oldstr3823=NULL;
|
||||
qbs*oldstr3811=NULL;
|
||||
if(_SUB_WRITESETTING_STRING___SECTION->tmp||_SUB_WRITESETTING_STRING___SECTION->fixed||_SUB_WRITESETTING_STRING___SECTION->readonly){
|
||||
oldstr3823=_SUB_WRITESETTING_STRING___SECTION;
|
||||
if (oldstr3823->cmem_descriptor){
|
||||
_SUB_WRITESETTING_STRING___SECTION=qbs_new_cmem(oldstr3823->len,0);
|
||||
oldstr3811=_SUB_WRITESETTING_STRING___SECTION;
|
||||
if (oldstr3811->cmem_descriptor){
|
||||
_SUB_WRITESETTING_STRING___SECTION=qbs_new_cmem(oldstr3811->len,0);
|
||||
}else{
|
||||
_SUB_WRITESETTING_STRING___SECTION=qbs_new(oldstr3823->len,0);
|
||||
_SUB_WRITESETTING_STRING___SECTION=qbs_new(oldstr3811->len,0);
|
||||
}
|
||||
memcpy(_SUB_WRITESETTING_STRING___SECTION->chr,oldstr3823->chr,oldstr3823->len);
|
||||
memcpy(_SUB_WRITESETTING_STRING___SECTION->chr,oldstr3811->chr,oldstr3811->len);
|
||||
}
|
||||
qbs*oldstr3824=NULL;
|
||||
qbs*oldstr3812=NULL;
|
||||
if(_SUB_WRITESETTING_STRING___KEY->tmp||_SUB_WRITESETTING_STRING___KEY->fixed||_SUB_WRITESETTING_STRING___KEY->readonly){
|
||||
oldstr3824=_SUB_WRITESETTING_STRING___KEY;
|
||||
if (oldstr3824->cmem_descriptor){
|
||||
_SUB_WRITESETTING_STRING___KEY=qbs_new_cmem(oldstr3824->len,0);
|
||||
oldstr3812=_SUB_WRITESETTING_STRING___KEY;
|
||||
if (oldstr3812->cmem_descriptor){
|
||||
_SUB_WRITESETTING_STRING___KEY=qbs_new_cmem(oldstr3812->len,0);
|
||||
}else{
|
||||
_SUB_WRITESETTING_STRING___KEY=qbs_new(oldstr3824->len,0);
|
||||
_SUB_WRITESETTING_STRING___KEY=qbs_new(oldstr3812->len,0);
|
||||
}
|
||||
memcpy(_SUB_WRITESETTING_STRING___KEY->chr,oldstr3824->chr,oldstr3824->len);
|
||||
memcpy(_SUB_WRITESETTING_STRING___KEY->chr,oldstr3812->chr,oldstr3812->len);
|
||||
}
|
||||
qbs*oldstr3825=NULL;
|
||||
qbs*oldstr3813=NULL;
|
||||
if(_SUB_WRITESETTING_STRING___VALUE->tmp||_SUB_WRITESETTING_STRING___VALUE->fixed||_SUB_WRITESETTING_STRING___VALUE->readonly){
|
||||
oldstr3825=_SUB_WRITESETTING_STRING___VALUE;
|
||||
if (oldstr3825->cmem_descriptor){
|
||||
_SUB_WRITESETTING_STRING___VALUE=qbs_new_cmem(oldstr3825->len,0);
|
||||
oldstr3813=_SUB_WRITESETTING_STRING___VALUE;
|
||||
if (oldstr3813->cmem_descriptor){
|
||||
_SUB_WRITESETTING_STRING___VALUE=qbs_new_cmem(oldstr3813->len,0);
|
||||
}else{
|
||||
_SUB_WRITESETTING_STRING___VALUE=qbs_new(oldstr3825->len,0);
|
||||
_SUB_WRITESETTING_STRING___VALUE=qbs_new(oldstr3813->len,0);
|
||||
}
|
||||
memcpy(_SUB_WRITESETTING_STRING___VALUE->chr,oldstr3825->chr,oldstr3825->len);
|
||||
memcpy(_SUB_WRITESETTING_STRING___VALUE->chr,oldstr3813->chr,oldstr3813->len);
|
||||
}
|
||||
qbs *_SUB_WRITESETTING_STRING_TEMPVALUE=NULL;
|
||||
if (!_SUB_WRITESETTING_STRING_TEMPVALUE)_SUB_WRITESETTING_STRING_TEMPVALUE=qbs_new(0,0);
|
||||
|
@ -71,31 +71,31 @@ if(_SUB_WRITESETTING_ULONG_I==NULL){
|
|||
_SUB_WRITESETTING_ULONG_I=(uint32*)mem_static_malloc(4);
|
||||
*_SUB_WRITESETTING_ULONG_I=0;
|
||||
}
|
||||
int64 fornext_value3827;
|
||||
int64 fornext_finalvalue3827;
|
||||
int64 fornext_step3827;
|
||||
uint8 fornext_step_negative3827;
|
||||
int64 fornext_value3829;
|
||||
int64 fornext_finalvalue3829;
|
||||
int64 fornext_step3829;
|
||||
uint8 fornext_step_negative3829;
|
||||
byte_element_struct *byte_element_3830=NULL;
|
||||
if (!byte_element_3830){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3830=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3830=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value3815;
|
||||
int64 fornext_finalvalue3815;
|
||||
int64 fornext_step3815;
|
||||
uint8 fornext_step_negative3815;
|
||||
int64 fornext_value3817;
|
||||
int64 fornext_finalvalue3817;
|
||||
int64 fornext_step3817;
|
||||
uint8 fornext_step_negative3817;
|
||||
byte_element_struct *byte_element_3818=NULL;
|
||||
if (!byte_element_3818){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3818=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3818=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3831=NULL;
|
||||
if (!byte_element_3831){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3831=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3831=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3819=NULL;
|
||||
if (!byte_element_3819){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3819=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3819=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3832=NULL;
|
||||
if (!byte_element_3832){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3832=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3832=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3820=NULL;
|
||||
if (!byte_element_3820){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3820=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3820=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3833=NULL;
|
||||
if (!byte_element_3833){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3833=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3833=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3821=NULL;
|
||||
if (!byte_element_3821){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3821=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3821=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3834=NULL;
|
||||
if (!byte_element_3834){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3834=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3834=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3822=NULL;
|
||||
if (!byte_element_3822){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3822=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3822=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
byte_element_struct *byte_element_2385=NULL;
|
||||
if (!byte_element_2385){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2385=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2385=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2373=NULL;
|
||||
if (!byte_element_2373){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2373=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2373=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int16 pass2386;
|
||||
int16 pass2387;
|
||||
int16 pass2388;
|
||||
int16 pass2374;
|
||||
int16 pass2375;
|
||||
int16 pass2376;
|
||||
|
|
|
@ -1,19 +1,19 @@
|
|||
qbs*oldstr3835=NULL;
|
||||
qbs*oldstr3823=NULL;
|
||||
if(_SUB_INILOAD_STRING_FILE->tmp||_SUB_INILOAD_STRING_FILE->fixed||_SUB_INILOAD_STRING_FILE->readonly){
|
||||
oldstr3835=_SUB_INILOAD_STRING_FILE;
|
||||
if (oldstr3835->cmem_descriptor){
|
||||
_SUB_INILOAD_STRING_FILE=qbs_new_cmem(oldstr3835->len,0);
|
||||
oldstr3823=_SUB_INILOAD_STRING_FILE;
|
||||
if (oldstr3823->cmem_descriptor){
|
||||
_SUB_INILOAD_STRING_FILE=qbs_new_cmem(oldstr3823->len,0);
|
||||
}else{
|
||||
_SUB_INILOAD_STRING_FILE=qbs_new(oldstr3835->len,0);
|
||||
_SUB_INILOAD_STRING_FILE=qbs_new(oldstr3823->len,0);
|
||||
}
|
||||
memcpy(_SUB_INILOAD_STRING_FILE->chr,oldstr3835->chr,oldstr3835->len);
|
||||
memcpy(_SUB_INILOAD_STRING_FILE->chr,oldstr3823->chr,oldstr3823->len);
|
||||
}
|
||||
int16 *_SUB_INILOAD_INTEGER_FILENUM=NULL;
|
||||
if(_SUB_INILOAD_INTEGER_FILENUM==NULL){
|
||||
_SUB_INILOAD_INTEGER_FILENUM=(int16*)mem_static_malloc(2);
|
||||
*_SUB_INILOAD_INTEGER_FILENUM=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3836=NULL;
|
||||
if (!byte_element_3836){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3836=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3836=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3824=NULL;
|
||||
if (!byte_element_3824){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3824=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3824=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_FILETOBUF_INTEGER_FILETOBUF==NULL){
|
|||
_FUNC_FILETOBUF_INTEGER_FILETOBUF=(int16*)mem_static_malloc(2);
|
||||
*_FUNC_FILETOBUF_INTEGER_FILETOBUF=0;
|
||||
}
|
||||
qbs*oldstr3838=NULL;
|
||||
qbs*oldstr3826=NULL;
|
||||
if(_FUNC_FILETOBUF_STRING_FILESPEC->tmp||_FUNC_FILETOBUF_STRING_FILESPEC->fixed||_FUNC_FILETOBUF_STRING_FILESPEC->readonly){
|
||||
oldstr3838=_FUNC_FILETOBUF_STRING_FILESPEC;
|
||||
if (oldstr3838->cmem_descriptor){
|
||||
_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new_cmem(oldstr3838->len,0);
|
||||
oldstr3826=_FUNC_FILETOBUF_STRING_FILESPEC;
|
||||
if (oldstr3826->cmem_descriptor){
|
||||
_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new_cmem(oldstr3826->len,0);
|
||||
}else{
|
||||
_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new(oldstr3838->len,0);
|
||||
_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new(oldstr3826->len,0);
|
||||
}
|
||||
memcpy(_FUNC_FILETOBUF_STRING_FILESPEC->chr,oldstr3838->chr,oldstr3838->len);
|
||||
memcpy(_FUNC_FILETOBUF_STRING_FILESPEC->chr,oldstr3826->chr,oldstr3826->len);
|
||||
}
|
||||
int16 *_FUNC_FILETOBUF_INTEGER_HAN=NULL;
|
||||
if(_FUNC_FILETOBUF_INTEGER_HAN==NULL){
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr3839=NULL;
|
||||
qbs*oldstr3827=NULL;
|
||||
if(_SUB_BUFTOFILE_STRING_FILESPEC->tmp||_SUB_BUFTOFILE_STRING_FILESPEC->fixed||_SUB_BUFTOFILE_STRING_FILESPEC->readonly){
|
||||
oldstr3839=_SUB_BUFTOFILE_STRING_FILESPEC;
|
||||
if (oldstr3839->cmem_descriptor){
|
||||
_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new_cmem(oldstr3839->len,0);
|
||||
oldstr3827=_SUB_BUFTOFILE_STRING_FILESPEC;
|
||||
if (oldstr3827->cmem_descriptor){
|
||||
_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new_cmem(oldstr3827->len,0);
|
||||
}else{
|
||||
_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new(oldstr3839->len,0);
|
||||
_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new(oldstr3827->len,0);
|
||||
}
|
||||
memcpy(_SUB_BUFTOFILE_STRING_FILESPEC->chr,oldstr3839->chr,oldstr3839->len);
|
||||
memcpy(_SUB_BUFTOFILE_STRING_FILESPEC->chr,oldstr3827->chr,oldstr3827->len);
|
||||
}
|
||||
int32 *_SUB_BUFTOFILE_LONG_BUF=NULL;
|
||||
if(_SUB_BUFTOFILE_LONG_BUF==NULL){
|
||||
|
@ -20,7 +20,7 @@ _SUB_BUFTOFILE_INTEGER_FF=(int16*)mem_static_malloc(2);
|
|||
}
|
||||
qbs *_SUB_BUFTOFILE_STRING_DAT=NULL;
|
||||
if (!_SUB_BUFTOFILE_STRING_DAT)_SUB_BUFTOFILE_STRING_DAT=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_3840=NULL;
|
||||
if (!byte_element_3840){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3840=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3840=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3828=NULL;
|
||||
if (!byte_element_3828){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3828=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3828=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -27,7 +27,7 @@ if(_FUNC_READBUFLINE_LONG_EOL==NULL){
|
|||
_FUNC_READBUFLINE_LONG_EOL=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_READBUFLINE_LONG_EOL=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3841=NULL;
|
||||
if (!byte_element_3841){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3841=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3841=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3829=NULL;
|
||||
if (!byte_element_3829){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3829=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3829=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr3842=NULL;
|
||||
qbs*oldstr3830=NULL;
|
||||
if(_SUB_WRITEBUFLINE_STRING_TEXT->tmp||_SUB_WRITEBUFLINE_STRING_TEXT->fixed||_SUB_WRITEBUFLINE_STRING_TEXT->readonly){
|
||||
oldstr3842=_SUB_WRITEBUFLINE_STRING_TEXT;
|
||||
if (oldstr3842->cmem_descriptor){
|
||||
_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new_cmem(oldstr3842->len,0);
|
||||
oldstr3830=_SUB_WRITEBUFLINE_STRING_TEXT;
|
||||
if (oldstr3830->cmem_descriptor){
|
||||
_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new_cmem(oldstr3830->len,0);
|
||||
}else{
|
||||
_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new(oldstr3842->len,0);
|
||||
_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new(oldstr3830->len,0);
|
||||
}
|
||||
memcpy(_SUB_WRITEBUFLINE_STRING_TEXT->chr,oldstr3842->chr,oldstr3842->len);
|
||||
memcpy(_SUB_WRITEBUFLINE_STRING_TEXT->chr,oldstr3830->chr,oldstr3830->len);
|
||||
}
|
||||
int32 *_SUB_WRITEBUFLINE_LONG_BUF=NULL;
|
||||
if(_SUB_WRITEBUFLINE_LONG_BUF==NULL){
|
||||
|
@ -50,15 +50,15 @@ if(_SUB_WRITEBUFLINE_LONG_EXT==NULL){
|
|||
_SUB_WRITEBUFLINE_LONG_EXT=(int32*)mem_static_malloc(4);
|
||||
*_SUB_WRITEBUFLINE_LONG_EXT=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3843=NULL;
|
||||
if (!byte_element_3843){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3843=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3843=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3831=NULL;
|
||||
if (!byte_element_3831){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3831=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3831=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3844=NULL;
|
||||
if (!byte_element_3844){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3844=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3844=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3832=NULL;
|
||||
if (!byte_element_3832){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3832=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3832=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3845=NULL;
|
||||
if (!byte_element_3845){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3845=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3845=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3833=NULL;
|
||||
if (!byte_element_3833){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3833=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3833=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -30,7 +30,7 @@ if(_SUB_DELETEBUFLINE_LONG_CHG==NULL){
|
|||
_SUB_DELETEBUFLINE_LONG_CHG=(int32*)mem_static_malloc(4);
|
||||
*_SUB_DELETEBUFLINE_LONG_CHG=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3847=NULL;
|
||||
if (!byte_element_3847){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3847=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3847=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3835=NULL;
|
||||
if (!byte_element_3835){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3835=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3835=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr3848=NULL;
|
||||
qbs*oldstr3836=NULL;
|
||||
if(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->tmp||_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->fixed||_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->readonly){
|
||||
oldstr3848=_SUB_WRITEBUFRAWDATA_STRING_RAWDATA;
|
||||
if (oldstr3848->cmem_descriptor){
|
||||
_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new_cmem(oldstr3848->len,0);
|
||||
oldstr3836=_SUB_WRITEBUFRAWDATA_STRING_RAWDATA;
|
||||
if (oldstr3836->cmem_descriptor){
|
||||
_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new_cmem(oldstr3836->len,0);
|
||||
}else{
|
||||
_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new(oldstr3848->len,0);
|
||||
_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new(oldstr3836->len,0);
|
||||
}
|
||||
memcpy(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->chr,oldstr3848->chr,oldstr3848->len);
|
||||
memcpy(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->chr,oldstr3836->chr,oldstr3836->len);
|
||||
}
|
||||
int32 *_SUB_WRITEBUFRAWDATA_LONG_BUF=NULL;
|
||||
if(_SUB_WRITEBUFRAWDATA_LONG_BUF==NULL){
|
||||
|
@ -38,11 +38,11 @@ if(_SUB_WRITEBUFRAWDATA_LONG_EXT==NULL){
|
|||
_SUB_WRITEBUFRAWDATA_LONG_EXT=(int32*)mem_static_malloc(4);
|
||||
*_SUB_WRITEBUFRAWDATA_LONG_EXT=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3849=NULL;
|
||||
if (!byte_element_3849){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3849=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3849=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3837=NULL;
|
||||
if (!byte_element_3837){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3837=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3837=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_3850=NULL;
|
||||
if (!byte_element_3850){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3850=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3850=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3838=NULL;
|
||||
if (!byte_element_3838){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3838=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3838=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,15 +1,29 @@
|
|||
int16 pass2389;
|
||||
int16 pass2390;
|
||||
int16 pass2391;
|
||||
int16 pass2377;
|
||||
int16 pass2378;
|
||||
int16 pass2379;
|
||||
int32 *_SUB_CLOSEMAIN_LONG_I=NULL;
|
||||
if(_SUB_CLOSEMAIN_LONG_I==NULL){
|
||||
_SUB_CLOSEMAIN_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_SUB_CLOSEMAIN_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value2393;
|
||||
int64 fornext_finalvalue2393;
|
||||
int64 fornext_step2393;
|
||||
uint8 fornext_step_negative2393;
|
||||
int64 fornext_value2381;
|
||||
int64 fornext_finalvalue2381;
|
||||
int64 fornext_step2381;
|
||||
uint8 fornext_step_negative2381;
|
||||
int16 pass2382;
|
||||
int16 pass2383;
|
||||
int16 pass2384;
|
||||
int16 pass2385;
|
||||
int16 pass2386;
|
||||
int16 pass2387;
|
||||
int16 pass2388;
|
||||
int16 pass2389;
|
||||
int16 pass2390;
|
||||
int64 fornext_value2392;
|
||||
int64 fornext_finalvalue2392;
|
||||
int64 fornext_step2392;
|
||||
uint8 fornext_step_negative2392;
|
||||
int16 pass2393;
|
||||
int16 pass2394;
|
||||
int16 pass2395;
|
||||
int16 pass2396;
|
||||
|
@ -17,17 +31,3 @@ int16 pass2397;
|
|||
int16 pass2398;
|
||||
int16 pass2399;
|
||||
int16 pass2400;
|
||||
int16 pass2401;
|
||||
int16 pass2402;
|
||||
int64 fornext_value2404;
|
||||
int64 fornext_finalvalue2404;
|
||||
int64 fornext_step2404;
|
||||
uint8 fornext_step_negative2404;
|
||||
int16 pass2405;
|
||||
int16 pass2406;
|
||||
int16 pass2407;
|
||||
int16 pass2408;
|
||||
int16 pass2409;
|
||||
int16 pass2410;
|
||||
int16 pass2411;
|
||||
int16 pass2412;
|
||||
|
|
|
@ -35,7 +35,7 @@ if(_FUNC_SEEKBUF_LONG_NEWPOS==NULL){
|
|||
_FUNC_SEEKBUF_LONG_NEWPOS=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_SEEKBUF_LONG_NEWPOS=0;
|
||||
}
|
||||
byte_element_struct *byte_element_3852=NULL;
|
||||
if (!byte_element_3852){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3852=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3852=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_3840=NULL;
|
||||
if (!byte_element_3840){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3840=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3840=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -5,4 +5,4 @@ if(_FUNC_BUFEOLSEQ_LONG_BUF==NULL){
|
|||
_FUNC_BUFEOLSEQ_LONG_BUF=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_BUFEOLSEQ_LONG_BUF=0;
|
||||
}
|
||||
static qbs *sc_3854=qbs_new(0,0);
|
||||
static qbs *sc_3842=qbs_new(0,0);
|
||||
|
|
|
@ -3,25 +3,25 @@ if(_FUNC_OPENBUFFER_INTEGER_OPENBUFFER==NULL){
|
|||
_FUNC_OPENBUFFER_INTEGER_OPENBUFFER=(int16*)mem_static_malloc(2);
|
||||
*_FUNC_OPENBUFFER_INTEGER_OPENBUFFER=0;
|
||||
}
|
||||
qbs*oldstr3855=NULL;
|
||||
qbs*oldstr3843=NULL;
|
||||
if(_FUNC_OPENBUFFER_STRING_SBMODE->tmp||_FUNC_OPENBUFFER_STRING_SBMODE->fixed||_FUNC_OPENBUFFER_STRING_SBMODE->readonly){
|
||||
oldstr3855=_FUNC_OPENBUFFER_STRING_SBMODE;
|
||||
if (oldstr3855->cmem_descriptor){
|
||||
_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new_cmem(oldstr3855->len,0);
|
||||
oldstr3843=_FUNC_OPENBUFFER_STRING_SBMODE;
|
||||
if (oldstr3843->cmem_descriptor){
|
||||
_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new_cmem(oldstr3843->len,0);
|
||||
}else{
|
||||
_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new(oldstr3855->len,0);
|
||||
_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new(oldstr3843->len,0);
|
||||
}
|
||||
memcpy(_FUNC_OPENBUFFER_STRING_SBMODE->chr,oldstr3855->chr,oldstr3855->len);
|
||||
memcpy(_FUNC_OPENBUFFER_STRING_SBMODE->chr,oldstr3843->chr,oldstr3843->len);
|
||||
}
|
||||
qbs*oldstr3856=NULL;
|
||||
qbs*oldstr3844=NULL;
|
||||
if(_FUNC_OPENBUFFER_STRING_SBNAME->tmp||_FUNC_OPENBUFFER_STRING_SBNAME->fixed||_FUNC_OPENBUFFER_STRING_SBNAME->readonly){
|
||||
oldstr3856=_FUNC_OPENBUFFER_STRING_SBNAME;
|
||||
if (oldstr3856->cmem_descriptor){
|
||||
_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new_cmem(oldstr3856->len,0);
|
||||
oldstr3844=_FUNC_OPENBUFFER_STRING_SBNAME;
|
||||
if (oldstr3844->cmem_descriptor){
|
||||
_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new_cmem(oldstr3844->len,0);
|
||||
}else{
|
||||
_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new(oldstr3856->len,0);
|
||||
_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new(oldstr3844->len,0);
|
||||
}
|
||||
memcpy(_FUNC_OPENBUFFER_STRING_SBNAME->chr,oldstr3856->chr,oldstr3856->len);
|
||||
memcpy(_FUNC_OPENBUFFER_STRING_SBNAME->chr,oldstr3844->chr,oldstr3844->len);
|
||||
}
|
||||
int16 *_FUNC_OPENBUFFER_INTEGER_BUF=NULL;
|
||||
if(_FUNC_OPENBUFFER_INTEGER_BUF==NULL){
|
||||
|
@ -33,14 +33,14 @@ if(_FUNC_OPENBUFFER_LONG_NUL==NULL){
|
|||
_FUNC_OPENBUFFER_LONG_NUL=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_OPENBUFFER_LONG_NUL=0;
|
||||
}
|
||||
int32 fornext_value3858;
|
||||
int32 fornext_finalvalue3858;
|
||||
int32 fornext_step3858;
|
||||
uint8 fornext_step_negative3858;
|
||||
static qbs *sc_3859=qbs_new(0,0);
|
||||
int32 pass3860;
|
||||
int16 pass3861;
|
||||
int32 pass3862;
|
||||
int16 pass3863;
|
||||
int32 pass3864;
|
||||
int16 pass3865;
|
||||
int32 fornext_value3846;
|
||||
int32 fornext_finalvalue3846;
|
||||
int32 fornext_step3846;
|
||||
uint8 fornext_step_negative3846;
|
||||
static qbs *sc_3847=qbs_new(0,0);
|
||||
int32 pass3848;
|
||||
int16 pass3849;
|
||||
int32 pass3850;
|
||||
int16 pass3851;
|
||||
int32 pass3852;
|
||||
int16 pass3853;
|
||||
|
|
|
@ -1,23 +1,23 @@
|
|||
qbs*oldstr3866=NULL;
|
||||
qbs*oldstr3854=NULL;
|
||||
if(_SUB_CLEARBUFFERS_STRING_SBNAME->tmp||_SUB_CLEARBUFFERS_STRING_SBNAME->fixed||_SUB_CLEARBUFFERS_STRING_SBNAME->readonly){
|
||||
oldstr3866=_SUB_CLEARBUFFERS_STRING_SBNAME;
|
||||
if (oldstr3866->cmem_descriptor){
|
||||
_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr3866->len,0);
|
||||
oldstr3854=_SUB_CLEARBUFFERS_STRING_SBNAME;
|
||||
if (oldstr3854->cmem_descriptor){
|
||||
_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr3854->len,0);
|
||||
}else{
|
||||
_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new(oldstr3866->len,0);
|
||||
_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new(oldstr3854->len,0);
|
||||
}
|
||||
memcpy(_SUB_CLEARBUFFERS_STRING_SBNAME->chr,oldstr3866->chr,oldstr3866->len);
|
||||
memcpy(_SUB_CLEARBUFFERS_STRING_SBNAME->chr,oldstr3854->chr,oldstr3854->len);
|
||||
}
|
||||
int16 *_SUB_CLEARBUFFERS_INTEGER_BUF=NULL;
|
||||
if(_SUB_CLEARBUFFERS_INTEGER_BUF==NULL){
|
||||
_SUB_CLEARBUFFERS_INTEGER_BUF=(int16*)mem_static_malloc(2);
|
||||
*_SUB_CLEARBUFFERS_INTEGER_BUF=0;
|
||||
}
|
||||
int32 fornext_value3868;
|
||||
int32 fornext_finalvalue3868;
|
||||
int32 fornext_step3868;
|
||||
uint8 fornext_step_negative3868;
|
||||
int32 fornext_value3870;
|
||||
int32 fornext_finalvalue3870;
|
||||
int32 fornext_step3870;
|
||||
uint8 fornext_step_negative3870;
|
||||
int32 fornext_value3856;
|
||||
int32 fornext_finalvalue3856;
|
||||
int32 fornext_step3856;
|
||||
uint8 fornext_step_negative3856;
|
||||
int32 fornext_value3858;
|
||||
int32 fornext_finalvalue3858;
|
||||
int32 fornext_step3858;
|
||||
uint8 fornext_step_negative3858;
|
||||
|
|
|
@ -1,23 +1,23 @@
|
|||
qbs*oldstr3871=NULL;
|
||||
qbs*oldstr3859=NULL;
|
||||
if(_SUB_WRITEBUFFERS_STRING_SBNAME->tmp||_SUB_WRITEBUFFERS_STRING_SBNAME->fixed||_SUB_WRITEBUFFERS_STRING_SBNAME->readonly){
|
||||
oldstr3871=_SUB_WRITEBUFFERS_STRING_SBNAME;
|
||||
if (oldstr3871->cmem_descriptor){
|
||||
_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr3871->len,0);
|
||||
oldstr3859=_SUB_WRITEBUFFERS_STRING_SBNAME;
|
||||
if (oldstr3859->cmem_descriptor){
|
||||
_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr3859->len,0);
|
||||
}else{
|
||||
_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new(oldstr3871->len,0);
|
||||
_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new(oldstr3859->len,0);
|
||||
}
|
||||
memcpy(_SUB_WRITEBUFFERS_STRING_SBNAME->chr,oldstr3871->chr,oldstr3871->len);
|
||||
memcpy(_SUB_WRITEBUFFERS_STRING_SBNAME->chr,oldstr3859->chr,oldstr3859->len);
|
||||
}
|
||||
int16 *_SUB_WRITEBUFFERS_INTEGER_BUF=NULL;
|
||||
if(_SUB_WRITEBUFFERS_INTEGER_BUF==NULL){
|
||||
_SUB_WRITEBUFFERS_INTEGER_BUF=(int16*)mem_static_malloc(2);
|
||||
*_SUB_WRITEBUFFERS_INTEGER_BUF=0;
|
||||
}
|
||||
int32 fornext_value3873;
|
||||
int32 fornext_finalvalue3873;
|
||||
int32 fornext_step3873;
|
||||
uint8 fornext_step_negative3873;
|
||||
int32 fornext_value3875;
|
||||
int32 fornext_finalvalue3875;
|
||||
int32 fornext_step3875;
|
||||
uint8 fornext_step_negative3875;
|
||||
int32 fornext_value3861;
|
||||
int32 fornext_finalvalue3861;
|
||||
int32 fornext_step3861;
|
||||
uint8 fornext_step_negative3861;
|
||||
int32 fornext_value3863;
|
||||
int32 fornext_finalvalue3863;
|
||||
int32 fornext_step3863;
|
||||
uint8 fornext_step_negative3863;
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_EVALUATE_EXPRESSION_STRING_EVALUATE_EXPRESSION=NULL;
|
||||
if (!_FUNC_EVALUATE_EXPRESSION_STRING_EVALUATE_EXPRESSION)_FUNC_EVALUATE_EXPRESSION_STRING_EVALUATE_EXPRESSION=qbs_new(0,0);
|
||||
qbs*oldstr3876=NULL;
|
||||
qbs*oldstr3864=NULL;
|
||||
if(_FUNC_EVALUATE_EXPRESSION_STRING_E->tmp||_FUNC_EVALUATE_EXPRESSION_STRING_E->fixed||_FUNC_EVALUATE_EXPRESSION_STRING_E->readonly){
|
||||
oldstr3876=_FUNC_EVALUATE_EXPRESSION_STRING_E;
|
||||
if (oldstr3876->cmem_descriptor){
|
||||
_FUNC_EVALUATE_EXPRESSION_STRING_E=qbs_new_cmem(oldstr3876->len,0);
|
||||
oldstr3864=_FUNC_EVALUATE_EXPRESSION_STRING_E;
|
||||
if (oldstr3864->cmem_descriptor){
|
||||
_FUNC_EVALUATE_EXPRESSION_STRING_E=qbs_new_cmem(oldstr3864->len,0);
|
||||
}else{
|
||||
_FUNC_EVALUATE_EXPRESSION_STRING_E=qbs_new(oldstr3876->len,0);
|
||||
_FUNC_EVALUATE_EXPRESSION_STRING_E=qbs_new(oldstr3864->len,0);
|
||||
}
|
||||
memcpy(_FUNC_EVALUATE_EXPRESSION_STRING_E->chr,oldstr3876->chr,oldstr3876->len);
|
||||
memcpy(_FUNC_EVALUATE_EXPRESSION_STRING_E->chr,oldstr3864->chr,oldstr3864->len);
|
||||
}
|
||||
qbs *_FUNC_EVALUATE_EXPRESSION_STRING_T=NULL;
|
||||
if (!_FUNC_EVALUATE_EXPRESSION_STRING_T)_FUNC_EVALUATE_EXPRESSION_STRING_T=qbs_new(0,0);
|
||||
|
@ -26,19 +26,19 @@ _FUNC_EVALUATE_EXPRESSION_LONG_C=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_EVALUATE_EXPRESSION_STRING_EVAL=NULL;
|
||||
if (!_FUNC_EVALUATE_EXPRESSION_STRING_EVAL)_FUNC_EVALUATE_EXPRESSION_STRING_EVAL=qbs_new(0,0);
|
||||
int32 pass3878;
|
||||
int32 pass3879;
|
||||
int32 pass3866;
|
||||
int32 pass3867;
|
||||
int32 *_FUNC_EVALUATE_EXPRESSION_LONG_FUNCOP=NULL;
|
||||
if(_FUNC_EVALUATE_EXPRESSION_LONG_FUNCOP==NULL){
|
||||
_FUNC_EVALUATE_EXPRESSION_LONG_FUNCOP=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_EXPRESSION_LONG_FUNCOP=0;
|
||||
}
|
||||
int32 pass3880;
|
||||
int32 pass3868;
|
||||
qbs *_FUNC_EVALUATE_EXPRESSION_STRING_LEFTELE=NULL;
|
||||
if (!_FUNC_EVALUATE_EXPRESSION_STRING_LEFTELE)_FUNC_EVALUATE_EXPRESSION_STRING_LEFTELE=qbs_new(0,0);
|
||||
int32 pass3881;
|
||||
int32 pass3882;
|
||||
int32 pass3869;
|
||||
int32 pass3870;
|
||||
qbs *_FUNC_EVALUATE_EXPRESSION_STRING_RIGHTELE=NULL;
|
||||
if (!_FUNC_EVALUATE_EXPRESSION_STRING_RIGHTELE)_FUNC_EVALUATE_EXPRESSION_STRING_RIGHTELE=qbs_new(0,0);
|
||||
int32 pass3883;
|
||||
int32 pass3884;
|
||||
int32 pass3871;
|
||||
int32 pass3872;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_COUNTELEMENTS_LONG_COUNTELEMENTS==NULL){
|
|||
_FUNC_COUNTELEMENTS_LONG_COUNTELEMENTS=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_COUNTELEMENTS_LONG_COUNTELEMENTS=0;
|
||||
}
|
||||
qbs*oldstr2413=NULL;
|
||||
qbs*oldstr2401=NULL;
|
||||
if(_FUNC_COUNTELEMENTS_STRING_A->tmp||_FUNC_COUNTELEMENTS_STRING_A->fixed||_FUNC_COUNTELEMENTS_STRING_A->readonly){
|
||||
oldstr2413=_FUNC_COUNTELEMENTS_STRING_A;
|
||||
if (oldstr2413->cmem_descriptor){
|
||||
_FUNC_COUNTELEMENTS_STRING_A=qbs_new_cmem(oldstr2413->len,0);
|
||||
oldstr2401=_FUNC_COUNTELEMENTS_STRING_A;
|
||||
if (oldstr2401->cmem_descriptor){
|
||||
_FUNC_COUNTELEMENTS_STRING_A=qbs_new_cmem(oldstr2401->len,0);
|
||||
}else{
|
||||
_FUNC_COUNTELEMENTS_STRING_A=qbs_new(oldstr2413->len,0);
|
||||
_FUNC_COUNTELEMENTS_STRING_A=qbs_new(oldstr2401->len,0);
|
||||
}
|
||||
memcpy(_FUNC_COUNTELEMENTS_STRING_A->chr,oldstr2413->chr,oldstr2413->len);
|
||||
memcpy(_FUNC_COUNTELEMENTS_STRING_A->chr,oldstr2401->chr,oldstr2401->len);
|
||||
}
|
||||
int32 *_FUNC_COUNTELEMENTS_LONG_N=NULL;
|
||||
if(_FUNC_COUNTELEMENTS_LONG_N==NULL){
|
||||
|
@ -28,10 +28,10 @@ if(_FUNC_COUNTELEMENTS_LONG_I==NULL){
|
|||
_FUNC_COUNTELEMENTS_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_COUNTELEMENTS_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value2415;
|
||||
int64 fornext_finalvalue2415;
|
||||
int64 fornext_step2415;
|
||||
uint8 fornext_step_negative2415;
|
||||
int64 fornext_value2403;
|
||||
int64 fornext_finalvalue2403;
|
||||
int64 fornext_step2403;
|
||||
uint8 fornext_step_negative2403;
|
||||
qbs *_FUNC_COUNTELEMENTS_STRING_E=NULL;
|
||||
if (!_FUNC_COUNTELEMENTS_STRING_E)_FUNC_COUNTELEMENTS_STRING_E=qbs_new(0,0);
|
||||
int32 *_FUNC_COUNTELEMENTS_LONG_B=NULL;
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr3885=NULL;
|
||||
qbs*oldstr3873=NULL;
|
||||
if(_SUB_FINDINNERPARENS_STRING_EXP->tmp||_SUB_FINDINNERPARENS_STRING_EXP->fixed||_SUB_FINDINNERPARENS_STRING_EXP->readonly){
|
||||
oldstr3885=_SUB_FINDINNERPARENS_STRING_EXP;
|
||||
if (oldstr3885->cmem_descriptor){
|
||||
_SUB_FINDINNERPARENS_STRING_EXP=qbs_new_cmem(oldstr3885->len,0);
|
||||
oldstr3873=_SUB_FINDINNERPARENS_STRING_EXP;
|
||||
if (oldstr3873->cmem_descriptor){
|
||||
_SUB_FINDINNERPARENS_STRING_EXP=qbs_new_cmem(oldstr3873->len,0);
|
||||
}else{
|
||||
_SUB_FINDINNERPARENS_STRING_EXP=qbs_new(oldstr3885->len,0);
|
||||
_SUB_FINDINNERPARENS_STRING_EXP=qbs_new(oldstr3873->len,0);
|
||||
}
|
||||
memcpy(_SUB_FINDINNERPARENS_STRING_EXP->chr,oldstr3885->chr,oldstr3885->len);
|
||||
memcpy(_SUB_FINDINNERPARENS_STRING_EXP->chr,oldstr3873->chr,oldstr3873->len);
|
||||
}
|
||||
int32 *_SUB_FINDINNERPARENS_LONG_STRINDEX=NULL;
|
||||
if(_SUB_FINDINNERPARENS_LONG_STRINDEX==NULL){
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_COMMAEXPRESSION_LONG_COMMAEXPRESSION==NULL){
|
|||
_FUNC_COMMAEXPRESSION_LONG_COMMAEXPRESSION=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_COMMAEXPRESSION_LONG_COMMAEXPRESSION=0;
|
||||
}
|
||||
qbs*oldstr3888=NULL;
|
||||
qbs*oldstr3876=NULL;
|
||||
if(_FUNC_COMMAEXPRESSION_STRING_EXP->tmp||_FUNC_COMMAEXPRESSION_STRING_EXP->fixed||_FUNC_COMMAEXPRESSION_STRING_EXP->readonly){
|
||||
oldstr3888=_FUNC_COMMAEXPRESSION_STRING_EXP;
|
||||
if (oldstr3888->cmem_descriptor){
|
||||
_FUNC_COMMAEXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3888->len,0);
|
||||
oldstr3876=_FUNC_COMMAEXPRESSION_STRING_EXP;
|
||||
if (oldstr3876->cmem_descriptor){
|
||||
_FUNC_COMMAEXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3876->len,0);
|
||||
}else{
|
||||
_FUNC_COMMAEXPRESSION_STRING_EXP=qbs_new(oldstr3888->len,0);
|
||||
_FUNC_COMMAEXPRESSION_STRING_EXP=qbs_new(oldstr3876->len,0);
|
||||
}
|
||||
memcpy(_FUNC_COMMAEXPRESSION_STRING_EXP->chr,oldstr3888->chr,oldstr3888->len);
|
||||
memcpy(_FUNC_COMMAEXPRESSION_STRING_EXP->chr,oldstr3876->chr,oldstr3876->len);
|
||||
}
|
||||
qbs *_FUNC_COMMAEXPRESSION_STRING_ELE=NULL;
|
||||
if (!_FUNC_COMMAEXPRESSION_STRING_ELE)_FUNC_COMMAEXPRESSION_STRING_ELE=qbs_new(0,0);
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_STREXPRESSION_LONG_STREXPRESSION==NULL){
|
|||
_FUNC_STREXPRESSION_LONG_STREXPRESSION=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_STREXPRESSION_LONG_STREXPRESSION=0;
|
||||
}
|
||||
qbs*oldstr3890=NULL;
|
||||
qbs*oldstr3878=NULL;
|
||||
if(_FUNC_STREXPRESSION_STRING_EXP->tmp||_FUNC_STREXPRESSION_STRING_EXP->fixed||_FUNC_STREXPRESSION_STRING_EXP->readonly){
|
||||
oldstr3890=_FUNC_STREXPRESSION_STRING_EXP;
|
||||
if (oldstr3890->cmem_descriptor){
|
||||
_FUNC_STREXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3890->len,0);
|
||||
oldstr3878=_FUNC_STREXPRESSION_STRING_EXP;
|
||||
if (oldstr3878->cmem_descriptor){
|
||||
_FUNC_STREXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3878->len,0);
|
||||
}else{
|
||||
_FUNC_STREXPRESSION_STRING_EXP=qbs_new(oldstr3890->len,0);
|
||||
_FUNC_STREXPRESSION_STRING_EXP=qbs_new(oldstr3878->len,0);
|
||||
}
|
||||
memcpy(_FUNC_STREXPRESSION_STRING_EXP->chr,oldstr3890->chr,oldstr3890->len);
|
||||
memcpy(_FUNC_STREXPRESSION_STRING_EXP->chr,oldstr3878->chr,oldstr3878->len);
|
||||
}
|
||||
qbs *_FUNC_STREXPRESSION_STRING_S=NULL;
|
||||
if (!_FUNC_STREXPRESSION_STRING_S)_FUNC_STREXPRESSION_STRING_S=qbs_new(0,0);
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_PARSESTRING_LONG_PARSESTRING==NULL){
|
|||
_FUNC_PARSESTRING_LONG_PARSESTRING=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_PARSESTRING_LONG_PARSESTRING=0;
|
||||
}
|
||||
qbs*oldstr3892=NULL;
|
||||
qbs*oldstr3880=NULL;
|
||||
if(_FUNC_PARSESTRING_STRING_EXP->tmp||_FUNC_PARSESTRING_STRING_EXP->fixed||_FUNC_PARSESTRING_STRING_EXP->readonly){
|
||||
oldstr3892=_FUNC_PARSESTRING_STRING_EXP;
|
||||
if (oldstr3892->cmem_descriptor){
|
||||
_FUNC_PARSESTRING_STRING_EXP=qbs_new_cmem(oldstr3892->len,0);
|
||||
oldstr3880=_FUNC_PARSESTRING_STRING_EXP;
|
||||
if (oldstr3880->cmem_descriptor){
|
||||
_FUNC_PARSESTRING_STRING_EXP=qbs_new_cmem(oldstr3880->len,0);
|
||||
}else{
|
||||
_FUNC_PARSESTRING_STRING_EXP=qbs_new(oldstr3892->len,0);
|
||||
_FUNC_PARSESTRING_STRING_EXP=qbs_new(oldstr3880->len,0);
|
||||
}
|
||||
memcpy(_FUNC_PARSESTRING_STRING_EXP->chr,oldstr3892->chr,oldstr3892->len);
|
||||
memcpy(_FUNC_PARSESTRING_STRING_EXP->chr,oldstr3880->chr,oldstr3880->len);
|
||||
}
|
||||
qbs *_FUNC_PARSESTRING_STRING_ELE=NULL;
|
||||
if (!_FUNC_PARSESTRING_STRING_ELE)_FUNC_PARSESTRING_STRING_ELE=qbs_new(0,0);
|
||||
|
|
|
@ -3,13 +3,13 @@ if(_FUNC_NUMERICEXPRESSION_LONG_NUMERICEXPRESSION==NULL){
|
|||
_FUNC_NUMERICEXPRESSION_LONG_NUMERICEXPRESSION=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_NUMERICEXPRESSION_LONG_NUMERICEXPRESSION=0;
|
||||
}
|
||||
qbs*oldstr3893=NULL;
|
||||
qbs*oldstr3881=NULL;
|
||||
if(_FUNC_NUMERICEXPRESSION_STRING_EXP->tmp||_FUNC_NUMERICEXPRESSION_STRING_EXP->fixed||_FUNC_NUMERICEXPRESSION_STRING_EXP->readonly){
|
||||
oldstr3893=_FUNC_NUMERICEXPRESSION_STRING_EXP;
|
||||
if (oldstr3893->cmem_descriptor){
|
||||
_FUNC_NUMERICEXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3893->len,0);
|
||||
oldstr3881=_FUNC_NUMERICEXPRESSION_STRING_EXP;
|
||||
if (oldstr3881->cmem_descriptor){
|
||||
_FUNC_NUMERICEXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3881->len,0);
|
||||
}else{
|
||||
_FUNC_NUMERICEXPRESSION_STRING_EXP=qbs_new(oldstr3893->len,0);
|
||||
_FUNC_NUMERICEXPRESSION_STRING_EXP=qbs_new(oldstr3881->len,0);
|
||||
}
|
||||
memcpy(_FUNC_NUMERICEXPRESSION_STRING_EXP->chr,oldstr3893->chr,oldstr3893->len);
|
||||
memcpy(_FUNC_NUMERICEXPRESSION_STRING_EXP->chr,oldstr3881->chr,oldstr3881->len);
|
||||
}
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_LOGICALIMP_LONG_LOGICALIMP==NULL){
|
|||
_FUNC_LOGICALIMP_LONG_LOGICALIMP=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_LOGICALIMP_LONG_LOGICALIMP=0;
|
||||
}
|
||||
qbs*oldstr3894=NULL;
|
||||
qbs*oldstr3882=NULL;
|
||||
if(_FUNC_LOGICALIMP_STRING_EXP->tmp||_FUNC_LOGICALIMP_STRING_EXP->fixed||_FUNC_LOGICALIMP_STRING_EXP->readonly){
|
||||
oldstr3894=_FUNC_LOGICALIMP_STRING_EXP;
|
||||
if (oldstr3894->cmem_descriptor){
|
||||
_FUNC_LOGICALIMP_STRING_EXP=qbs_new_cmem(oldstr3894->len,0);
|
||||
oldstr3882=_FUNC_LOGICALIMP_STRING_EXP;
|
||||
if (oldstr3882->cmem_descriptor){
|
||||
_FUNC_LOGICALIMP_STRING_EXP=qbs_new_cmem(oldstr3882->len,0);
|
||||
}else{
|
||||
_FUNC_LOGICALIMP_STRING_EXP=qbs_new(oldstr3894->len,0);
|
||||
_FUNC_LOGICALIMP_STRING_EXP=qbs_new(oldstr3882->len,0);
|
||||
}
|
||||
memcpy(_FUNC_LOGICALIMP_STRING_EXP->chr,oldstr3894->chr,oldstr3894->len);
|
||||
memcpy(_FUNC_LOGICALIMP_STRING_EXP->chr,oldstr3882->chr,oldstr3882->len);
|
||||
}
|
||||
void *_FUNC_LOGICALIMP_UDT_NUM=NULL;
|
||||
if(_FUNC_LOGICALIMP_UDT_NUM==NULL){
|
||||
|
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALIMP_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_LOGICALIMP_STRING_ELE=NULL;
|
||||
if (!_FUNC_LOGICALIMP_STRING_ELE)_FUNC_LOGICALIMP_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3896;
|
||||
uint64 pass3897;
|
||||
int32 pass3898;
|
||||
int64 pass3899;
|
||||
int32 pass3884;
|
||||
uint64 pass3885;
|
||||
int32 pass3886;
|
||||
int64 pass3887;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_LOGICALEQV_LONG_LOGICALEQV==NULL){
|
|||
_FUNC_LOGICALEQV_LONG_LOGICALEQV=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_LOGICALEQV_LONG_LOGICALEQV=0;
|
||||
}
|
||||
qbs*oldstr3900=NULL;
|
||||
qbs*oldstr3888=NULL;
|
||||
if(_FUNC_LOGICALEQV_STRING_EXP->tmp||_FUNC_LOGICALEQV_STRING_EXP->fixed||_FUNC_LOGICALEQV_STRING_EXP->readonly){
|
||||
oldstr3900=_FUNC_LOGICALEQV_STRING_EXP;
|
||||
if (oldstr3900->cmem_descriptor){
|
||||
_FUNC_LOGICALEQV_STRING_EXP=qbs_new_cmem(oldstr3900->len,0);
|
||||
oldstr3888=_FUNC_LOGICALEQV_STRING_EXP;
|
||||
if (oldstr3888->cmem_descriptor){
|
||||
_FUNC_LOGICALEQV_STRING_EXP=qbs_new_cmem(oldstr3888->len,0);
|
||||
}else{
|
||||
_FUNC_LOGICALEQV_STRING_EXP=qbs_new(oldstr3900->len,0);
|
||||
_FUNC_LOGICALEQV_STRING_EXP=qbs_new(oldstr3888->len,0);
|
||||
}
|
||||
memcpy(_FUNC_LOGICALEQV_STRING_EXP->chr,oldstr3900->chr,oldstr3900->len);
|
||||
memcpy(_FUNC_LOGICALEQV_STRING_EXP->chr,oldstr3888->chr,oldstr3888->len);
|
||||
}
|
||||
void *_FUNC_LOGICALEQV_UDT_NUM=NULL;
|
||||
if(_FUNC_LOGICALEQV_UDT_NUM==NULL){
|
||||
|
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALEQV_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_LOGICALEQV_STRING_ELE=NULL;
|
||||
if (!_FUNC_LOGICALEQV_STRING_ELE)_FUNC_LOGICALEQV_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3902;
|
||||
uint64 pass3903;
|
||||
int32 pass3904;
|
||||
int64 pass3905;
|
||||
int32 pass3890;
|
||||
uint64 pass3891;
|
||||
int32 pass3892;
|
||||
int64 pass3893;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_LOGICALXOR_LONG_LOGICALXOR==NULL){
|
|||
_FUNC_LOGICALXOR_LONG_LOGICALXOR=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_LOGICALXOR_LONG_LOGICALXOR=0;
|
||||
}
|
||||
qbs*oldstr3906=NULL;
|
||||
qbs*oldstr3894=NULL;
|
||||
if(_FUNC_LOGICALXOR_STRING_EXP->tmp||_FUNC_LOGICALXOR_STRING_EXP->fixed||_FUNC_LOGICALXOR_STRING_EXP->readonly){
|
||||
oldstr3906=_FUNC_LOGICALXOR_STRING_EXP;
|
||||
if (oldstr3906->cmem_descriptor){
|
||||
_FUNC_LOGICALXOR_STRING_EXP=qbs_new_cmem(oldstr3906->len,0);
|
||||
oldstr3894=_FUNC_LOGICALXOR_STRING_EXP;
|
||||
if (oldstr3894->cmem_descriptor){
|
||||
_FUNC_LOGICALXOR_STRING_EXP=qbs_new_cmem(oldstr3894->len,0);
|
||||
}else{
|
||||
_FUNC_LOGICALXOR_STRING_EXP=qbs_new(oldstr3906->len,0);
|
||||
_FUNC_LOGICALXOR_STRING_EXP=qbs_new(oldstr3894->len,0);
|
||||
}
|
||||
memcpy(_FUNC_LOGICALXOR_STRING_EXP->chr,oldstr3906->chr,oldstr3906->len);
|
||||
memcpy(_FUNC_LOGICALXOR_STRING_EXP->chr,oldstr3894->chr,oldstr3894->len);
|
||||
}
|
||||
void *_FUNC_LOGICALXOR_UDT_NUM=NULL;
|
||||
if(_FUNC_LOGICALXOR_UDT_NUM==NULL){
|
||||
|
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALXOR_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_LOGICALXOR_STRING_ELE=NULL;
|
||||
if (!_FUNC_LOGICALXOR_STRING_ELE)_FUNC_LOGICALXOR_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3908;
|
||||
uint64 pass3909;
|
||||
int32 pass3910;
|
||||
int64 pass3911;
|
||||
int32 pass3896;
|
||||
uint64 pass3897;
|
||||
int32 pass3898;
|
||||
int64 pass3899;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_LOGICALOR_LONG_LOGICALOR==NULL){
|
|||
_FUNC_LOGICALOR_LONG_LOGICALOR=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_LOGICALOR_LONG_LOGICALOR=0;
|
||||
}
|
||||
qbs*oldstr3912=NULL;
|
||||
qbs*oldstr3900=NULL;
|
||||
if(_FUNC_LOGICALOR_STRING_EXP->tmp||_FUNC_LOGICALOR_STRING_EXP->fixed||_FUNC_LOGICALOR_STRING_EXP->readonly){
|
||||
oldstr3912=_FUNC_LOGICALOR_STRING_EXP;
|
||||
if (oldstr3912->cmem_descriptor){
|
||||
_FUNC_LOGICALOR_STRING_EXP=qbs_new_cmem(oldstr3912->len,0);
|
||||
oldstr3900=_FUNC_LOGICALOR_STRING_EXP;
|
||||
if (oldstr3900->cmem_descriptor){
|
||||
_FUNC_LOGICALOR_STRING_EXP=qbs_new_cmem(oldstr3900->len,0);
|
||||
}else{
|
||||
_FUNC_LOGICALOR_STRING_EXP=qbs_new(oldstr3912->len,0);
|
||||
_FUNC_LOGICALOR_STRING_EXP=qbs_new(oldstr3900->len,0);
|
||||
}
|
||||
memcpy(_FUNC_LOGICALOR_STRING_EXP->chr,oldstr3912->chr,oldstr3912->len);
|
||||
memcpy(_FUNC_LOGICALOR_STRING_EXP->chr,oldstr3900->chr,oldstr3900->len);
|
||||
}
|
||||
void *_FUNC_LOGICALOR_UDT_NUM=NULL;
|
||||
if(_FUNC_LOGICALOR_UDT_NUM==NULL){
|
||||
|
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALOR_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_LOGICALOR_STRING_ELE=NULL;
|
||||
if (!_FUNC_LOGICALOR_STRING_ELE)_FUNC_LOGICALOR_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3914;
|
||||
uint64 pass3915;
|
||||
int32 pass3916;
|
||||
int64 pass3917;
|
||||
int32 pass3902;
|
||||
uint64 pass3903;
|
||||
int32 pass3904;
|
||||
int64 pass3905;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_LOGICALAND_LONG_LOGICALAND==NULL){
|
|||
_FUNC_LOGICALAND_LONG_LOGICALAND=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_LOGICALAND_LONG_LOGICALAND=0;
|
||||
}
|
||||
qbs*oldstr3918=NULL;
|
||||
qbs*oldstr3906=NULL;
|
||||
if(_FUNC_LOGICALAND_STRING_EXP->tmp||_FUNC_LOGICALAND_STRING_EXP->fixed||_FUNC_LOGICALAND_STRING_EXP->readonly){
|
||||
oldstr3918=_FUNC_LOGICALAND_STRING_EXP;
|
||||
if (oldstr3918->cmem_descriptor){
|
||||
_FUNC_LOGICALAND_STRING_EXP=qbs_new_cmem(oldstr3918->len,0);
|
||||
oldstr3906=_FUNC_LOGICALAND_STRING_EXP;
|
||||
if (oldstr3906->cmem_descriptor){
|
||||
_FUNC_LOGICALAND_STRING_EXP=qbs_new_cmem(oldstr3906->len,0);
|
||||
}else{
|
||||
_FUNC_LOGICALAND_STRING_EXP=qbs_new(oldstr3918->len,0);
|
||||
_FUNC_LOGICALAND_STRING_EXP=qbs_new(oldstr3906->len,0);
|
||||
}
|
||||
memcpy(_FUNC_LOGICALAND_STRING_EXP->chr,oldstr3918->chr,oldstr3918->len);
|
||||
memcpy(_FUNC_LOGICALAND_STRING_EXP->chr,oldstr3906->chr,oldstr3906->len);
|
||||
}
|
||||
void *_FUNC_LOGICALAND_UDT_NUM=NULL;
|
||||
if(_FUNC_LOGICALAND_UDT_NUM==NULL){
|
||||
|
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALAND_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_LOGICALAND_STRING_ELE=NULL;
|
||||
if (!_FUNC_LOGICALAND_STRING_ELE)_FUNC_LOGICALAND_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3920;
|
||||
uint64 pass3921;
|
||||
int32 pass3922;
|
||||
int64 pass3923;
|
||||
int32 pass3908;
|
||||
uint64 pass3909;
|
||||
int32 pass3910;
|
||||
int64 pass3911;
|
||||
|
|
|
@ -3,35 +3,35 @@ if(_FUNC_DIM2_LONG_DIM2==NULL){
|
|||
_FUNC_DIM2_LONG_DIM2=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_DIM2_LONG_DIM2=0;
|
||||
}
|
||||
qbs*oldstr2416=NULL;
|
||||
qbs*oldstr2404=NULL;
|
||||
if(_FUNC_DIM2_STRING_VARNAME->tmp||_FUNC_DIM2_STRING_VARNAME->fixed||_FUNC_DIM2_STRING_VARNAME->readonly){
|
||||
oldstr2416=_FUNC_DIM2_STRING_VARNAME;
|
||||
if (oldstr2416->cmem_descriptor){
|
||||
_FUNC_DIM2_STRING_VARNAME=qbs_new_cmem(oldstr2416->len,0);
|
||||
oldstr2404=_FUNC_DIM2_STRING_VARNAME;
|
||||
if (oldstr2404->cmem_descriptor){
|
||||
_FUNC_DIM2_STRING_VARNAME=qbs_new_cmem(oldstr2404->len,0);
|
||||
}else{
|
||||
_FUNC_DIM2_STRING_VARNAME=qbs_new(oldstr2416->len,0);
|
||||
_FUNC_DIM2_STRING_VARNAME=qbs_new(oldstr2404->len,0);
|
||||
}
|
||||
memcpy(_FUNC_DIM2_STRING_VARNAME->chr,oldstr2416->chr,oldstr2416->len);
|
||||
memcpy(_FUNC_DIM2_STRING_VARNAME->chr,oldstr2404->chr,oldstr2404->len);
|
||||
}
|
||||
qbs*oldstr2417=NULL;
|
||||
qbs*oldstr2405=NULL;
|
||||
if(_FUNC_DIM2_STRING_TYP2->tmp||_FUNC_DIM2_STRING_TYP2->fixed||_FUNC_DIM2_STRING_TYP2->readonly){
|
||||
oldstr2417=_FUNC_DIM2_STRING_TYP2;
|
||||
if (oldstr2417->cmem_descriptor){
|
||||
_FUNC_DIM2_STRING_TYP2=qbs_new_cmem(oldstr2417->len,0);
|
||||
oldstr2405=_FUNC_DIM2_STRING_TYP2;
|
||||
if (oldstr2405->cmem_descriptor){
|
||||
_FUNC_DIM2_STRING_TYP2=qbs_new_cmem(oldstr2405->len,0);
|
||||
}else{
|
||||
_FUNC_DIM2_STRING_TYP2=qbs_new(oldstr2417->len,0);
|
||||
_FUNC_DIM2_STRING_TYP2=qbs_new(oldstr2405->len,0);
|
||||
}
|
||||
memcpy(_FUNC_DIM2_STRING_TYP2->chr,oldstr2417->chr,oldstr2417->len);
|
||||
memcpy(_FUNC_DIM2_STRING_TYP2->chr,oldstr2405->chr,oldstr2405->len);
|
||||
}
|
||||
qbs*oldstr2418=NULL;
|
||||
qbs*oldstr2406=NULL;
|
||||
if(_FUNC_DIM2_STRING_ELEMENTS->tmp||_FUNC_DIM2_STRING_ELEMENTS->fixed||_FUNC_DIM2_STRING_ELEMENTS->readonly){
|
||||
oldstr2418=_FUNC_DIM2_STRING_ELEMENTS;
|
||||
if (oldstr2418->cmem_descriptor){
|
||||
_FUNC_DIM2_STRING_ELEMENTS=qbs_new_cmem(oldstr2418->len,0);
|
||||
oldstr2406=_FUNC_DIM2_STRING_ELEMENTS;
|
||||
if (oldstr2406->cmem_descriptor){
|
||||
_FUNC_DIM2_STRING_ELEMENTS=qbs_new_cmem(oldstr2406->len,0);
|
||||
}else{
|
||||
_FUNC_DIM2_STRING_ELEMENTS=qbs_new(oldstr2418->len,0);
|
||||
_FUNC_DIM2_STRING_ELEMENTS=qbs_new(oldstr2406->len,0);
|
||||
}
|
||||
memcpy(_FUNC_DIM2_STRING_ELEMENTS->chr,oldstr2418->chr,oldstr2418->len);
|
||||
memcpy(_FUNC_DIM2_STRING_ELEMENTS->chr,oldstr2406->chr,oldstr2406->len);
|
||||
}
|
||||
qbs *_FUNC_DIM2_STRING_TYP=NULL;
|
||||
if (!_FUNC_DIM2_STRING_TYP)_FUNC_DIM2_STRING_TYP=qbs_new(0,0);
|
||||
|
@ -46,19 +46,19 @@ _FUNC_DIM2_LONG_F=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_DIM2_STRING_SCOPE2=NULL;
|
||||
if (!_FUNC_DIM2_STRING_SCOPE2)_FUNC_DIM2_STRING_SCOPE2=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2420=NULL;
|
||||
if (!byte_element_2420){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2420=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2420=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2408=NULL;
|
||||
if (!byte_element_2408){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2408=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2408=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_DIM2_LONG_I=NULL;
|
||||
if(_FUNC_DIM2_LONG_I==NULL){
|
||||
_FUNC_DIM2_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_DIM2_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value2422;
|
||||
int64 fornext_finalvalue2422;
|
||||
int64 fornext_step2422;
|
||||
uint8 fornext_step_negative2422;
|
||||
int64 fornext_value2410;
|
||||
int64 fornext_finalvalue2410;
|
||||
int64 fornext_step2410;
|
||||
uint8 fornext_step_negative2410;
|
||||
qbs *_FUNC_DIM2_STRING_N=NULL;
|
||||
if (!_FUNC_DIM2_STRING_N)_FUNC_DIM2_STRING_N=qbs_new(0,0);
|
||||
int32 *_FUNC_DIM2_LONG_TRY=NULL;
|
||||
|
@ -71,53 +71,53 @@ if(_FUNC_DIM2_LONG_BITS==NULL){
|
|||
_FUNC_DIM2_LONG_BITS=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_DIM2_LONG_BITS=0;
|
||||
}
|
||||
byte_element_struct *byte_element_2424=NULL;
|
||||
if (!byte_element_2424){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2424=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2424=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2412=NULL;
|
||||
if (!byte_element_2412){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2412=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2412=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_DIM2_LONG_NUME=NULL;
|
||||
if(_FUNC_DIM2_LONG_NUME==NULL){
|
||||
_FUNC_DIM2_LONG_NUME=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_DIM2_LONG_NUME=0;
|
||||
}
|
||||
int32 pass2425;
|
||||
int8 pass2426;
|
||||
int32 pass2413;
|
||||
int8 pass2414;
|
||||
int32 *_FUNC_DIM2_LONG_BYTES=NULL;
|
||||
if(_FUNC_DIM2_LONG_BYTES==NULL){
|
||||
_FUNC_DIM2_LONG_BYTES=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_DIM2_LONG_BYTES=0;
|
||||
}
|
||||
int16 pass2427;
|
||||
int16 pass2428;
|
||||
int16 pass2429;
|
||||
int16 pass2430;
|
||||
int16 pass2431;
|
||||
int16 pass2432;
|
||||
int16 pass2433;
|
||||
int16 pass2434;
|
||||
int16 pass2435;
|
||||
int32 pass2436;
|
||||
int32 pass2437;
|
||||
int16 pass2438;
|
||||
int8 pass2439;
|
||||
int16 pass2415;
|
||||
int16 pass2416;
|
||||
int16 pass2417;
|
||||
int16 pass2418;
|
||||
int16 pass2419;
|
||||
int16 pass2420;
|
||||
int16 pass2421;
|
||||
int16 pass2422;
|
||||
int16 pass2423;
|
||||
int32 pass2424;
|
||||
int32 pass2425;
|
||||
int16 pass2426;
|
||||
int8 pass2427;
|
||||
int32 *_FUNC_DIM2_LONG_UNSGN=NULL;
|
||||
if(_FUNC_DIM2_LONG_UNSGN==NULL){
|
||||
_FUNC_DIM2_LONG_UNSGN=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_DIM2_LONG_UNSGN=0;
|
||||
}
|
||||
byte_element_struct *byte_element_2440=NULL;
|
||||
if (!byte_element_2440){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2440=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2440=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2428=NULL;
|
||||
if (!byte_element_2428){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2428=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2428=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2441=NULL;
|
||||
if (!byte_element_2441){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2441=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2441=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2429=NULL;
|
||||
if (!byte_element_2429){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2429=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2429=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_DIM2_STRING_C=NULL;
|
||||
if (!_FUNC_DIM2_STRING_C)_FUNC_DIM2_STRING_C=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2442=NULL;
|
||||
if (!byte_element_2442){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2442=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2442=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2430=NULL;
|
||||
if (!byte_element_2430){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2430=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2430=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_DIM2_LONG_HASHFOUND=NULL;
|
||||
if(_FUNC_DIM2_LONG_HASHFOUND==NULL){
|
||||
|
@ -171,30 +171,57 @@ if(_FUNC_DIM2_UINTEGER64_V==NULL){
|
|||
_FUNC_DIM2_UINTEGER64_V=(uint64*)mem_static_malloc(8);
|
||||
*_FUNC_DIM2_UINTEGER64_V=0;
|
||||
}
|
||||
byte_element_struct *byte_element_2444=NULL;
|
||||
if (!byte_element_2444){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2444=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2444=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2432=NULL;
|
||||
if (!byte_element_2432){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2432=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2432=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2446=NULL;
|
||||
if (!byte_element_2446){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2446=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2446=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2434=NULL;
|
||||
if (!byte_element_2434){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2434=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2434=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2447;
|
||||
int32 pass2435;
|
||||
int8 pass2436;
|
||||
int16 pass2437;
|
||||
int16 pass2438;
|
||||
int16 pass2439;
|
||||
int16 pass2440;
|
||||
int16 pass2441;
|
||||
int16 pass2442;
|
||||
int16 pass2443;
|
||||
int16 pass2444;
|
||||
qbs *_FUNC_DIM2_STRING_O=NULL;
|
||||
if (!_FUNC_DIM2_STRING_O)_FUNC_DIM2_STRING_O=qbs_new(0,0);
|
||||
int16 pass2445;
|
||||
int16 pass2446;
|
||||
int16 pass2447;
|
||||
int8 pass2448;
|
||||
int16 pass2449;
|
||||
int16 pass2450;
|
||||
int16 pass2451;
|
||||
int16 pass2452;
|
||||
int16 pass2453;
|
||||
byte_element_struct *byte_element_2450=NULL;
|
||||
if (!byte_element_2450){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2450=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2450=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2451;
|
||||
int32 pass2452;
|
||||
int8 pass2453;
|
||||
int16 pass2454;
|
||||
int16 pass2455;
|
||||
int16 pass2456;
|
||||
qbs *_FUNC_DIM2_STRING_O=NULL;
|
||||
if (!_FUNC_DIM2_STRING_O)_FUNC_DIM2_STRING_O=qbs_new(0,0);
|
||||
int16 pass2457;
|
||||
int16 pass2458;
|
||||
int16 pass2459;
|
||||
int8 pass2460;
|
||||
int8 pass2457;
|
||||
byte_element_struct *byte_element_2458=NULL;
|
||||
if (!byte_element_2458){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2458=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2458=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2459=NULL;
|
||||
if (!byte_element_2459){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2459=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2459=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2460=NULL;
|
||||
if (!byte_element_2460){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2460=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2460=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_DIM2_STRING_CT=NULL;
|
||||
if (!_FUNC_DIM2_STRING_CT)_FUNC_DIM2_STRING_CT=qbs_new(0,0);
|
||||
qbs *_FUNC_DIM2_STRING_CMPS=NULL;
|
||||
if (!_FUNC_DIM2_STRING_CMPS)_FUNC_DIM2_STRING_CMPS=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2462=NULL;
|
||||
if (!byte_element_2462){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2462=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2462=(byte_element_struct*)mem_static_malloc(12);
|
||||
|
@ -205,30 +232,17 @@ int8 pass2465;
|
|||
int16 pass2466;
|
||||
int16 pass2467;
|
||||
int16 pass2468;
|
||||
int8 pass2469;
|
||||
byte_element_struct *byte_element_2470=NULL;
|
||||
if (!byte_element_2470){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2470=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2470=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2471=NULL;
|
||||
if (!byte_element_2471){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2471=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2471=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2472=NULL;
|
||||
if (!byte_element_2472){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2472=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2472=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_DIM2_STRING_CT=NULL;
|
||||
if (!_FUNC_DIM2_STRING_CT)_FUNC_DIM2_STRING_CT=qbs_new(0,0);
|
||||
qbs *_FUNC_DIM2_STRING_CMPS=NULL;
|
||||
if (!_FUNC_DIM2_STRING_CMPS)_FUNC_DIM2_STRING_CMPS=qbs_new(0,0);
|
||||
int16 pass2469;
|
||||
int16 pass2470;
|
||||
int16 pass2471;
|
||||
int8 pass2472;
|
||||
byte_element_struct *byte_element_2474=NULL;
|
||||
if (!byte_element_2474){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2474=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2474=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2475;
|
||||
int32 pass2476;
|
||||
int8 pass2477;
|
||||
int16 pass2477;
|
||||
int16 pass2478;
|
||||
int16 pass2479;
|
||||
int16 pass2480;
|
||||
|
@ -258,25 +272,25 @@ int32 pass2499;
|
|||
int32 pass2500;
|
||||
int16 pass2501;
|
||||
int16 pass2502;
|
||||
int16 pass2503;
|
||||
int32 pass2503;
|
||||
int16 pass2504;
|
||||
int16 pass2505;
|
||||
int16 pass2506;
|
||||
int16 pass2507;
|
||||
int8 pass2508;
|
||||
byte_element_struct *byte_element_2510=NULL;
|
||||
if (!byte_element_2510){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2510=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2510=(byte_element_struct*)mem_static_malloc(12);
|
||||
int32 pass2507;
|
||||
int16 pass2508;
|
||||
int16 pass2509;
|
||||
int8 pass2510;
|
||||
byte_element_struct *byte_element_2512=NULL;
|
||||
if (!byte_element_2512){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2512=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2512=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2511;
|
||||
int32 pass2512;
|
||||
int16 pass2513;
|
||||
int16 pass2514;
|
||||
int32 pass2515;
|
||||
int32 pass2513;
|
||||
int32 pass2514;
|
||||
int16 pass2515;
|
||||
int16 pass2516;
|
||||
int16 pass2517;
|
||||
int16 pass2518;
|
||||
int32 pass2519;
|
||||
int16 pass2519;
|
||||
int16 pass2520;
|
||||
int16 pass2521;
|
||||
int8 pass2522;
|
||||
|
@ -336,17 +350,3 @@ int16 pass2567;
|
|||
int16 pass2568;
|
||||
int16 pass2569;
|
||||
int8 pass2570;
|
||||
byte_element_struct *byte_element_2572=NULL;
|
||||
if (!byte_element_2572){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2572=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2572=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2573;
|
||||
int32 pass2574;
|
||||
int16 pass2575;
|
||||
int16 pass2576;
|
||||
int16 pass2577;
|
||||
int16 pass2578;
|
||||
int16 pass2579;
|
||||
int16 pass2580;
|
||||
int16 pass2581;
|
||||
int8 pass2582;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_LOGICALNOT_LONG_LOGICALNOT==NULL){
|
|||
_FUNC_LOGICALNOT_LONG_LOGICALNOT=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_LOGICALNOT_LONG_LOGICALNOT=0;
|
||||
}
|
||||
qbs*oldstr3924=NULL;
|
||||
qbs*oldstr3912=NULL;
|
||||
if(_FUNC_LOGICALNOT_STRING_EXP->tmp||_FUNC_LOGICALNOT_STRING_EXP->fixed||_FUNC_LOGICALNOT_STRING_EXP->readonly){
|
||||
oldstr3924=_FUNC_LOGICALNOT_STRING_EXP;
|
||||
if (oldstr3924->cmem_descriptor){
|
||||
_FUNC_LOGICALNOT_STRING_EXP=qbs_new_cmem(oldstr3924->len,0);
|
||||
oldstr3912=_FUNC_LOGICALNOT_STRING_EXP;
|
||||
if (oldstr3912->cmem_descriptor){
|
||||
_FUNC_LOGICALNOT_STRING_EXP=qbs_new_cmem(oldstr3912->len,0);
|
||||
}else{
|
||||
_FUNC_LOGICALNOT_STRING_EXP=qbs_new(oldstr3924->len,0);
|
||||
_FUNC_LOGICALNOT_STRING_EXP=qbs_new(oldstr3912->len,0);
|
||||
}
|
||||
memcpy(_FUNC_LOGICALNOT_STRING_EXP->chr,oldstr3924->chr,oldstr3924->len);
|
||||
memcpy(_FUNC_LOGICALNOT_STRING_EXP->chr,oldstr3912->chr,oldstr3912->len);
|
||||
}
|
||||
qbs *_FUNC_LOGICALNOT_STRING_ELE=NULL;
|
||||
if (!_FUNC_LOGICALNOT_STRING_ELE)_FUNC_LOGICALNOT_STRING_ELE=qbs_new(0,0);
|
||||
|
@ -20,7 +20,7 @@ if(_FUNC_LOGICALNOT_LONG_NUM__ASCII_CHR_046__TYP==NULL){
|
|||
_FUNC_LOGICALNOT_LONG_NUM__ASCII_CHR_046__TYP=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_LOGICALNOT_LONG_NUM__ASCII_CHR_046__TYP=0;
|
||||
}
|
||||
int32 pass3925;
|
||||
uint64 pass3926;
|
||||
int32 pass3927;
|
||||
int64 pass3928;
|
||||
int32 pass3913;
|
||||
uint64 pass3914;
|
||||
int32 pass3915;
|
||||
int64 pass3916;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_RELATION_LONG_RELATION==NULL){
|
|||
_FUNC_RELATION_LONG_RELATION=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_RELATION_LONG_RELATION=0;
|
||||
}
|
||||
qbs*oldstr3929=NULL;
|
||||
qbs*oldstr3917=NULL;
|
||||
if(_FUNC_RELATION_STRING_EXP->tmp||_FUNC_RELATION_STRING_EXP->fixed||_FUNC_RELATION_STRING_EXP->readonly){
|
||||
oldstr3929=_FUNC_RELATION_STRING_EXP;
|
||||
if (oldstr3929->cmem_descriptor){
|
||||
_FUNC_RELATION_STRING_EXP=qbs_new_cmem(oldstr3929->len,0);
|
||||
oldstr3917=_FUNC_RELATION_STRING_EXP;
|
||||
if (oldstr3917->cmem_descriptor){
|
||||
_FUNC_RELATION_STRING_EXP=qbs_new_cmem(oldstr3917->len,0);
|
||||
}else{
|
||||
_FUNC_RELATION_STRING_EXP=qbs_new(oldstr3929->len,0);
|
||||
_FUNC_RELATION_STRING_EXP=qbs_new(oldstr3917->len,0);
|
||||
}
|
||||
memcpy(_FUNC_RELATION_STRING_EXP->chr,oldstr3929->chr,oldstr3929->len);
|
||||
memcpy(_FUNC_RELATION_STRING_EXP->chr,oldstr3917->chr,oldstr3917->len);
|
||||
}
|
||||
void *_FUNC_RELATION_UDT_NUM=NULL;
|
||||
if(_FUNC_RELATION_UDT_NUM==NULL){
|
||||
|
@ -21,6 +21,18 @@ memset(_FUNC_RELATION_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_RELATION_STRING_ELE=NULL;
|
||||
if (!_FUNC_RELATION_STRING_ELE)_FUNC_RELATION_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3919;
|
||||
long double pass3920;
|
||||
int32 pass3921;
|
||||
uint64 pass3922;
|
||||
int32 pass3923;
|
||||
int64 pass3924;
|
||||
int32 pass3925;
|
||||
long double pass3926;
|
||||
int32 pass3927;
|
||||
uint64 pass3928;
|
||||
int32 pass3929;
|
||||
int64 pass3930;
|
||||
int32 pass3931;
|
||||
long double pass3932;
|
||||
int32 pass3933;
|
||||
|
@ -45,15 +57,3 @@ int32 pass3951;
|
|||
uint64 pass3952;
|
||||
int32 pass3953;
|
||||
int64 pass3954;
|
||||
int32 pass3955;
|
||||
long double pass3956;
|
||||
int32 pass3957;
|
||||
uint64 pass3958;
|
||||
int32 pass3959;
|
||||
int64 pass3960;
|
||||
int32 pass3961;
|
||||
long double pass3962;
|
||||
int32 pass3963;
|
||||
uint64 pass3964;
|
||||
int32 pass3965;
|
||||
int64 pass3966;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_TERM_LONG_TERM==NULL){
|
|||
_FUNC_TERM_LONG_TERM=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_TERM_LONG_TERM=0;
|
||||
}
|
||||
qbs*oldstr3967=NULL;
|
||||
qbs*oldstr3955=NULL;
|
||||
if(_FUNC_TERM_STRING_EXP->tmp||_FUNC_TERM_STRING_EXP->fixed||_FUNC_TERM_STRING_EXP->readonly){
|
||||
oldstr3967=_FUNC_TERM_STRING_EXP;
|
||||
if (oldstr3967->cmem_descriptor){
|
||||
_FUNC_TERM_STRING_EXP=qbs_new_cmem(oldstr3967->len,0);
|
||||
oldstr3955=_FUNC_TERM_STRING_EXP;
|
||||
if (oldstr3955->cmem_descriptor){
|
||||
_FUNC_TERM_STRING_EXP=qbs_new_cmem(oldstr3955->len,0);
|
||||
}else{
|
||||
_FUNC_TERM_STRING_EXP=qbs_new(oldstr3967->len,0);
|
||||
_FUNC_TERM_STRING_EXP=qbs_new(oldstr3955->len,0);
|
||||
}
|
||||
memcpy(_FUNC_TERM_STRING_EXP->chr,oldstr3967->chr,oldstr3967->len);
|
||||
memcpy(_FUNC_TERM_STRING_EXP->chr,oldstr3955->chr,oldstr3955->len);
|
||||
}
|
||||
void *_FUNC_TERM_UDT_NUM=NULL;
|
||||
if(_FUNC_TERM_UDT_NUM==NULL){
|
||||
|
@ -21,15 +21,15 @@ memset(_FUNC_TERM_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_TERM_STRING_ELE=NULL;
|
||||
if (!_FUNC_TERM_STRING_ELE)_FUNC_TERM_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3969;
|
||||
long double pass3970;
|
||||
int32 pass3971;
|
||||
uint64 pass3972;
|
||||
int32 pass3973;
|
||||
int64 pass3974;
|
||||
int32 pass3975;
|
||||
long double pass3976;
|
||||
int32 pass3977;
|
||||
uint64 pass3978;
|
||||
int32 pass3979;
|
||||
int64 pass3980;
|
||||
int32 pass3957;
|
||||
long double pass3958;
|
||||
int32 pass3959;
|
||||
uint64 pass3960;
|
||||
int32 pass3961;
|
||||
int64 pass3962;
|
||||
int32 pass3963;
|
||||
long double pass3964;
|
||||
int32 pass3965;
|
||||
uint64 pass3966;
|
||||
int32 pass3967;
|
||||
int64 pass3968;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_PARSEMOD_LONG_PARSEMOD==NULL){
|
|||
_FUNC_PARSEMOD_LONG_PARSEMOD=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_PARSEMOD_LONG_PARSEMOD=0;
|
||||
}
|
||||
qbs*oldstr3981=NULL;
|
||||
qbs*oldstr3969=NULL;
|
||||
if(_FUNC_PARSEMOD_STRING_EXP->tmp||_FUNC_PARSEMOD_STRING_EXP->fixed||_FUNC_PARSEMOD_STRING_EXP->readonly){
|
||||
oldstr3981=_FUNC_PARSEMOD_STRING_EXP;
|
||||
if (oldstr3981->cmem_descriptor){
|
||||
_FUNC_PARSEMOD_STRING_EXP=qbs_new_cmem(oldstr3981->len,0);
|
||||
oldstr3969=_FUNC_PARSEMOD_STRING_EXP;
|
||||
if (oldstr3969->cmem_descriptor){
|
||||
_FUNC_PARSEMOD_STRING_EXP=qbs_new_cmem(oldstr3969->len,0);
|
||||
}else{
|
||||
_FUNC_PARSEMOD_STRING_EXP=qbs_new(oldstr3981->len,0);
|
||||
_FUNC_PARSEMOD_STRING_EXP=qbs_new(oldstr3969->len,0);
|
||||
}
|
||||
memcpy(_FUNC_PARSEMOD_STRING_EXP->chr,oldstr3981->chr,oldstr3981->len);
|
||||
memcpy(_FUNC_PARSEMOD_STRING_EXP->chr,oldstr3969->chr,oldstr3969->len);
|
||||
}
|
||||
void *_FUNC_PARSEMOD_UDT_NUM=NULL;
|
||||
if(_FUNC_PARSEMOD_UDT_NUM==NULL){
|
||||
|
@ -21,7 +21,7 @@ memset(_FUNC_PARSEMOD_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_PARSEMOD_STRING_ELE=NULL;
|
||||
if (!_FUNC_PARSEMOD_STRING_ELE)_FUNC_PARSEMOD_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3983;
|
||||
uint64 pass3984;
|
||||
int32 pass3985;
|
||||
int64 pass3986;
|
||||
int32 pass3971;
|
||||
uint64 pass3972;
|
||||
int32 pass3973;
|
||||
int64 pass3974;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_INTDIV_LONG_INTDIV==NULL){
|
|||
_FUNC_INTDIV_LONG_INTDIV=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_INTDIV_LONG_INTDIV=0;
|
||||
}
|
||||
qbs*oldstr3987=NULL;
|
||||
qbs*oldstr3975=NULL;
|
||||
if(_FUNC_INTDIV_STRING_EXP->tmp||_FUNC_INTDIV_STRING_EXP->fixed||_FUNC_INTDIV_STRING_EXP->readonly){
|
||||
oldstr3987=_FUNC_INTDIV_STRING_EXP;
|
||||
if (oldstr3987->cmem_descriptor){
|
||||
_FUNC_INTDIV_STRING_EXP=qbs_new_cmem(oldstr3987->len,0);
|
||||
oldstr3975=_FUNC_INTDIV_STRING_EXP;
|
||||
if (oldstr3975->cmem_descriptor){
|
||||
_FUNC_INTDIV_STRING_EXP=qbs_new_cmem(oldstr3975->len,0);
|
||||
}else{
|
||||
_FUNC_INTDIV_STRING_EXP=qbs_new(oldstr3987->len,0);
|
||||
_FUNC_INTDIV_STRING_EXP=qbs_new(oldstr3975->len,0);
|
||||
}
|
||||
memcpy(_FUNC_INTDIV_STRING_EXP->chr,oldstr3987->chr,oldstr3987->len);
|
||||
memcpy(_FUNC_INTDIV_STRING_EXP->chr,oldstr3975->chr,oldstr3975->len);
|
||||
}
|
||||
void *_FUNC_INTDIV_UDT_NUM=NULL;
|
||||
if(_FUNC_INTDIV_UDT_NUM==NULL){
|
||||
|
@ -21,7 +21,7 @@ memset(_FUNC_INTDIV_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_INTDIV_STRING_ELE=NULL;
|
||||
if (!_FUNC_INTDIV_STRING_ELE)_FUNC_INTDIV_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3989;
|
||||
uint64 pass3990;
|
||||
int32 pass3991;
|
||||
int64 pass3992;
|
||||
int32 pass3977;
|
||||
uint64 pass3978;
|
||||
int32 pass3979;
|
||||
int64 pass3980;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_FACTOR_LONG_FACTOR==NULL){
|
|||
_FUNC_FACTOR_LONG_FACTOR=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_FACTOR_LONG_FACTOR=0;
|
||||
}
|
||||
qbs*oldstr3993=NULL;
|
||||
qbs*oldstr3981=NULL;
|
||||
if(_FUNC_FACTOR_STRING_EXP->tmp||_FUNC_FACTOR_STRING_EXP->fixed||_FUNC_FACTOR_STRING_EXP->readonly){
|
||||
oldstr3993=_FUNC_FACTOR_STRING_EXP;
|
||||
if (oldstr3993->cmem_descriptor){
|
||||
_FUNC_FACTOR_STRING_EXP=qbs_new_cmem(oldstr3993->len,0);
|
||||
oldstr3981=_FUNC_FACTOR_STRING_EXP;
|
||||
if (oldstr3981->cmem_descriptor){
|
||||
_FUNC_FACTOR_STRING_EXP=qbs_new_cmem(oldstr3981->len,0);
|
||||
}else{
|
||||
_FUNC_FACTOR_STRING_EXP=qbs_new(oldstr3993->len,0);
|
||||
_FUNC_FACTOR_STRING_EXP=qbs_new(oldstr3981->len,0);
|
||||
}
|
||||
memcpy(_FUNC_FACTOR_STRING_EXP->chr,oldstr3993->chr,oldstr3993->len);
|
||||
memcpy(_FUNC_FACTOR_STRING_EXP->chr,oldstr3981->chr,oldstr3981->len);
|
||||
}
|
||||
void *_FUNC_FACTOR_UDT_NUM=NULL;
|
||||
if(_FUNC_FACTOR_UDT_NUM==NULL){
|
||||
|
@ -21,11 +21,11 @@ memset(_FUNC_FACTOR_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_FACTOR_STRING_ELE=NULL;
|
||||
if (!_FUNC_FACTOR_STRING_ELE)_FUNC_FACTOR_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass3995;
|
||||
long double pass3996;
|
||||
int32 pass3997;
|
||||
uint64 pass3998;
|
||||
int32 pass3999;
|
||||
int64 pass4000;
|
||||
int32 pass4001;
|
||||
long double pass4002;
|
||||
int32 pass3983;
|
||||
long double pass3984;
|
||||
int32 pass3985;
|
||||
uint64 pass3986;
|
||||
int32 pass3987;
|
||||
int64 pass3988;
|
||||
int32 pass3989;
|
||||
long double pass3990;
|
||||
|
|
|
@ -3,17 +3,17 @@ if(_FUNC_UNARY_LONG_UNARY==NULL){
|
|||
_FUNC_UNARY_LONG_UNARY=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_UNARY_LONG_UNARY=0;
|
||||
}
|
||||
qbs*oldstr4003=NULL;
|
||||
qbs*oldstr3991=NULL;
|
||||
if(_FUNC_UNARY_STRING_EXP->tmp||_FUNC_UNARY_STRING_EXP->fixed||_FUNC_UNARY_STRING_EXP->readonly){
|
||||
oldstr4003=_FUNC_UNARY_STRING_EXP;
|
||||
if (oldstr4003->cmem_descriptor){
|
||||
_FUNC_UNARY_STRING_EXP=qbs_new_cmem(oldstr4003->len,0);
|
||||
oldstr3991=_FUNC_UNARY_STRING_EXP;
|
||||
if (oldstr3991->cmem_descriptor){
|
||||
_FUNC_UNARY_STRING_EXP=qbs_new_cmem(oldstr3991->len,0);
|
||||
}else{
|
||||
_FUNC_UNARY_STRING_EXP=qbs_new(oldstr4003->len,0);
|
||||
_FUNC_UNARY_STRING_EXP=qbs_new(oldstr3991->len,0);
|
||||
}
|
||||
memcpy(_FUNC_UNARY_STRING_EXP->chr,oldstr4003->chr,oldstr4003->len);
|
||||
memcpy(_FUNC_UNARY_STRING_EXP->chr,oldstr3991->chr,oldstr3991->len);
|
||||
}
|
||||
qbs *_FUNC_UNARY_STRING_ELE=NULL;
|
||||
if (!_FUNC_UNARY_STRING_ELE)_FUNC_UNARY_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass4004;
|
||||
int64 pass4005;
|
||||
int32 pass3992;
|
||||
int64 pass3993;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_EXPONENT_LONG_EXPONENT==NULL){
|
|||
_FUNC_EXPONENT_LONG_EXPONENT=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EXPONENT_LONG_EXPONENT=0;
|
||||
}
|
||||
qbs*oldstr4006=NULL;
|
||||
qbs*oldstr3994=NULL;
|
||||
if(_FUNC_EXPONENT_STRING_EXP->tmp||_FUNC_EXPONENT_STRING_EXP->fixed||_FUNC_EXPONENT_STRING_EXP->readonly){
|
||||
oldstr4006=_FUNC_EXPONENT_STRING_EXP;
|
||||
if (oldstr4006->cmem_descriptor){
|
||||
_FUNC_EXPONENT_STRING_EXP=qbs_new_cmem(oldstr4006->len,0);
|
||||
oldstr3994=_FUNC_EXPONENT_STRING_EXP;
|
||||
if (oldstr3994->cmem_descriptor){
|
||||
_FUNC_EXPONENT_STRING_EXP=qbs_new_cmem(oldstr3994->len,0);
|
||||
}else{
|
||||
_FUNC_EXPONENT_STRING_EXP=qbs_new(oldstr4006->len,0);
|
||||
_FUNC_EXPONENT_STRING_EXP=qbs_new(oldstr3994->len,0);
|
||||
}
|
||||
memcpy(_FUNC_EXPONENT_STRING_EXP->chr,oldstr4006->chr,oldstr4006->len);
|
||||
memcpy(_FUNC_EXPONENT_STRING_EXP->chr,oldstr3994->chr,oldstr3994->len);
|
||||
}
|
||||
void *_FUNC_EXPONENT_UDT_NUM=NULL;
|
||||
if(_FUNC_EXPONENT_UDT_NUM==NULL){
|
||||
|
@ -21,12 +21,12 @@ memset(_FUNC_EXPONENT_UDT_NUM,0,60);
|
|||
}
|
||||
qbs *_FUNC_EXPONENT_STRING_ELE=NULL;
|
||||
if (!_FUNC_EXPONENT_STRING_ELE)_FUNC_EXPONENT_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass4008;
|
||||
long double pass4009;
|
||||
int32 pass4010;
|
||||
uint64 pass4011;
|
||||
int32 pass4012;
|
||||
int64 pass4013;
|
||||
int32 pass3996;
|
||||
long double pass3997;
|
||||
int32 pass3998;
|
||||
uint64 pass3999;
|
||||
int32 pass4000;
|
||||
int64 pass4001;
|
||||
int32 *_FUNC_EXPONENT_LONG_SIG=NULL;
|
||||
if(_FUNC_EXPONENT_LONG_SIG==NULL){
|
||||
_FUNC_EXPONENT_LONG_SIG=(int32*)mem_static_malloc(4);
|
||||
|
@ -37,5 +37,5 @@ if(_FUNC_EXPONENT_FLOAT_EXPON==NULL){
|
|||
_FUNC_EXPONENT_FLOAT_EXPON=(long double*)mem_static_malloc(32);
|
||||
*_FUNC_EXPONENT_FLOAT_EXPON=0;
|
||||
}
|
||||
int32 pass4014;
|
||||
long double pass4015;
|
||||
int32 pass4002;
|
||||
long double pass4003;
|
||||
|
|
|
@ -3,17 +3,17 @@ if(_FUNC_NUMERIC_LONG_NUMERIC==NULL){
|
|||
_FUNC_NUMERIC_LONG_NUMERIC=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_NUMERIC_LONG_NUMERIC=0;
|
||||
}
|
||||
qbs*oldstr4016=NULL;
|
||||
qbs*oldstr4004=NULL;
|
||||
if(_FUNC_NUMERIC_STRING_EXP->tmp||_FUNC_NUMERIC_STRING_EXP->fixed||_FUNC_NUMERIC_STRING_EXP->readonly){
|
||||
oldstr4016=_FUNC_NUMERIC_STRING_EXP;
|
||||
if (oldstr4016->cmem_descriptor){
|
||||
_FUNC_NUMERIC_STRING_EXP=qbs_new_cmem(oldstr4016->len,0);
|
||||
oldstr4004=_FUNC_NUMERIC_STRING_EXP;
|
||||
if (oldstr4004->cmem_descriptor){
|
||||
_FUNC_NUMERIC_STRING_EXP=qbs_new_cmem(oldstr4004->len,0);
|
||||
}else{
|
||||
_FUNC_NUMERIC_STRING_EXP=qbs_new(oldstr4016->len,0);
|
||||
_FUNC_NUMERIC_STRING_EXP=qbs_new(oldstr4004->len,0);
|
||||
}
|
||||
memcpy(_FUNC_NUMERIC_STRING_EXP->chr,oldstr4016->chr,oldstr4016->len);
|
||||
memcpy(_FUNC_NUMERIC_STRING_EXP->chr,oldstr4004->chr,oldstr4004->len);
|
||||
}
|
||||
qbs *_FUNC_NUMERIC_STRING_ELE=NULL;
|
||||
if (!_FUNC_NUMERIC_STRING_ELE)_FUNC_NUMERIC_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass4017;
|
||||
long double pass4018;
|
||||
int32 pass4005;
|
||||
long double pass4006;
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_PARSENUMHASHLOOKUP_LONG_PARSENUMHASHLOOKUP==NULL){
|
|||
_FUNC_PARSENUMHASHLOOKUP_LONG_PARSENUMHASHLOOKUP=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_PARSENUMHASHLOOKUP_LONG_PARSENUMHASHLOOKUP=0;
|
||||
}
|
||||
qbs*oldstr4019=NULL;
|
||||
qbs*oldstr4007=NULL;
|
||||
if(_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->tmp||_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->fixed||_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->readonly){
|
||||
oldstr4019=_FUNC_PARSENUMHASHLOOKUP_STRING_ELE;
|
||||
if (oldstr4019->cmem_descriptor){
|
||||
_FUNC_PARSENUMHASHLOOKUP_STRING_ELE=qbs_new_cmem(oldstr4019->len,0);
|
||||
oldstr4007=_FUNC_PARSENUMHASHLOOKUP_STRING_ELE;
|
||||
if (oldstr4007->cmem_descriptor){
|
||||
_FUNC_PARSENUMHASHLOOKUP_STRING_ELE=qbs_new_cmem(oldstr4007->len,0);
|
||||
}else{
|
||||
_FUNC_PARSENUMHASHLOOKUP_STRING_ELE=qbs_new(oldstr4019->len,0);
|
||||
_FUNC_PARSENUMHASHLOOKUP_STRING_ELE=qbs_new(oldstr4007->len,0);
|
||||
}
|
||||
memcpy(_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->chr,oldstr4019->chr,oldstr4019->len);
|
||||
memcpy(_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->chr,oldstr4007->chr,oldstr4007->len);
|
||||
}
|
||||
int32 *_FUNC_PARSENUMHASHLOOKUP_LONG_HASHFOUND=NULL;
|
||||
if(_FUNC_PARSENUMHASHLOOKUP_LONG_HASHFOUND==NULL){
|
||||
|
|
|
@ -1,24 +1,24 @@
|
|||
qbs *_FUNC_UDTREFERENCE_STRING_UDTREFERENCE=NULL;
|
||||
if (!_FUNC_UDTREFERENCE_STRING_UDTREFERENCE)_FUNC_UDTREFERENCE_STRING_UDTREFERENCE=qbs_new(0,0);
|
||||
qbs*oldstr2583=NULL;
|
||||
qbs*oldstr2571=NULL;
|
||||
if(_FUNC_UDTREFERENCE_STRING_O->tmp||_FUNC_UDTREFERENCE_STRING_O->fixed||_FUNC_UDTREFERENCE_STRING_O->readonly){
|
||||
oldstr2583=_FUNC_UDTREFERENCE_STRING_O;
|
||||
if (oldstr2583->cmem_descriptor){
|
||||
_FUNC_UDTREFERENCE_STRING_O=qbs_new_cmem(oldstr2583->len,0);
|
||||
oldstr2571=_FUNC_UDTREFERENCE_STRING_O;
|
||||
if (oldstr2571->cmem_descriptor){
|
||||
_FUNC_UDTREFERENCE_STRING_O=qbs_new_cmem(oldstr2571->len,0);
|
||||
}else{
|
||||
_FUNC_UDTREFERENCE_STRING_O=qbs_new(oldstr2583->len,0);
|
||||
_FUNC_UDTREFERENCE_STRING_O=qbs_new(oldstr2571->len,0);
|
||||
}
|
||||
memcpy(_FUNC_UDTREFERENCE_STRING_O->chr,oldstr2583->chr,oldstr2583->len);
|
||||
memcpy(_FUNC_UDTREFERENCE_STRING_O->chr,oldstr2571->chr,oldstr2571->len);
|
||||
}
|
||||
qbs*oldstr2584=NULL;
|
||||
qbs*oldstr2572=NULL;
|
||||
if(_FUNC_UDTREFERENCE_STRING_A->tmp||_FUNC_UDTREFERENCE_STRING_A->fixed||_FUNC_UDTREFERENCE_STRING_A->readonly){
|
||||
oldstr2584=_FUNC_UDTREFERENCE_STRING_A;
|
||||
if (oldstr2584->cmem_descriptor){
|
||||
_FUNC_UDTREFERENCE_STRING_A=qbs_new_cmem(oldstr2584->len,0);
|
||||
oldstr2572=_FUNC_UDTREFERENCE_STRING_A;
|
||||
if (oldstr2572->cmem_descriptor){
|
||||
_FUNC_UDTREFERENCE_STRING_A=qbs_new_cmem(oldstr2572->len,0);
|
||||
}else{
|
||||
_FUNC_UDTREFERENCE_STRING_A=qbs_new(oldstr2584->len,0);
|
||||
_FUNC_UDTREFERENCE_STRING_A=qbs_new(oldstr2572->len,0);
|
||||
}
|
||||
memcpy(_FUNC_UDTREFERENCE_STRING_A->chr,oldstr2584->chr,oldstr2584->len);
|
||||
memcpy(_FUNC_UDTREFERENCE_STRING_A->chr,oldstr2572->chr,oldstr2572->len);
|
||||
}
|
||||
qbs *_FUNC_UDTREFERENCE_STRING_OBAK=NULL;
|
||||
if (!_FUNC_UDTREFERENCE_STRING_OBAK)_FUNC_UDTREFERENCE_STRING_OBAK=qbs_new(0,0);
|
||||
|
@ -53,9 +53,9 @@ qbs *_FUNC_UDTREFERENCE_STRING_N=NULL;
|
|||
if (!_FUNC_UDTREFERENCE_STRING_N)_FUNC_UDTREFERENCE_STRING_N=qbs_new(0,0);
|
||||
qbs *_FUNC_UDTREFERENCE_STRING_NSYM=NULL;
|
||||
if (!_FUNC_UDTREFERENCE_STRING_NSYM)_FUNC_UDTREFERENCE_STRING_NSYM=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2585=NULL;
|
||||
if (!byte_element_2585){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2585=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2585=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2573=NULL;
|
||||
if (!byte_element_2573){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2573=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2573=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_UDTREFERENCE_LONG_NTYP=NULL;
|
||||
if(_FUNC_UDTREFERENCE_LONG_NTYP==NULL){
|
||||
|
@ -69,7 +69,7 @@ _FUNC_UDTREFERENCE_LONG_NTYPSIZE=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_UDTREFERENCE_STRING_N2=NULL;
|
||||
if (!_FUNC_UDTREFERENCE_STRING_N2)_FUNC_UDTREFERENCE_STRING_N2=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2586=NULL;
|
||||
if (!byte_element_2586){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2586=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2586=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2574=NULL;
|
||||
if (!byte_element_2574){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2574=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2574=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,10 +1,10 @@
|
|||
qbs*oldstr4021=NULL;
|
||||
qbs*oldstr4009=NULL;
|
||||
if(_SUB_PARSENUMSETS_STRING_S->tmp||_SUB_PARSENUMSETS_STRING_S->fixed||_SUB_PARSENUMSETS_STRING_S->readonly){
|
||||
oldstr4021=_SUB_PARSENUMSETS_STRING_S;
|
||||
if (oldstr4021->cmem_descriptor){
|
||||
_SUB_PARSENUMSETS_STRING_S=qbs_new_cmem(oldstr4021->len,0);
|
||||
oldstr4009=_SUB_PARSENUMSETS_STRING_S;
|
||||
if (oldstr4009->cmem_descriptor){
|
||||
_SUB_PARSENUMSETS_STRING_S=qbs_new_cmem(oldstr4009->len,0);
|
||||
}else{
|
||||
_SUB_PARSENUMSETS_STRING_S=qbs_new(oldstr4021->len,0);
|
||||
_SUB_PARSENUMSETS_STRING_S=qbs_new(oldstr4009->len,0);
|
||||
}
|
||||
memcpy(_SUB_PARSENUMSETS_STRING_S->chr,oldstr4021->chr,oldstr4021->len);
|
||||
memcpy(_SUB_PARSENUMSETS_STRING_S->chr,oldstr4009->chr,oldstr4009->len);
|
||||
}
|
||||
|
|
|
@ -1,10 +1,10 @@
|
|||
qbs*oldstr4022=NULL;
|
||||
qbs*oldstr4010=NULL;
|
||||
if(_SUB_FIXUPERRORMESSAGE_STRING_OP->tmp||_SUB_FIXUPERRORMESSAGE_STRING_OP->fixed||_SUB_FIXUPERRORMESSAGE_STRING_OP->readonly){
|
||||
oldstr4022=_SUB_FIXUPERRORMESSAGE_STRING_OP;
|
||||
if (oldstr4022->cmem_descriptor){
|
||||
_SUB_FIXUPERRORMESSAGE_STRING_OP=qbs_new_cmem(oldstr4022->len,0);
|
||||
oldstr4010=_SUB_FIXUPERRORMESSAGE_STRING_OP;
|
||||
if (oldstr4010->cmem_descriptor){
|
||||
_SUB_FIXUPERRORMESSAGE_STRING_OP=qbs_new_cmem(oldstr4010->len,0);
|
||||
}else{
|
||||
_SUB_FIXUPERRORMESSAGE_STRING_OP=qbs_new(oldstr4022->len,0);
|
||||
_SUB_FIXUPERRORMESSAGE_STRING_OP=qbs_new(oldstr4010->len,0);
|
||||
}
|
||||
memcpy(_SUB_FIXUPERRORMESSAGE_STRING_OP->chr,oldstr4022->chr,oldstr4022->len);
|
||||
memcpy(_SUB_FIXUPERRORMESSAGE_STRING_OP->chr,oldstr4010->chr,oldstr4010->len);
|
||||
}
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr4023=NULL;
|
||||
qbs*oldstr4011=NULL;
|
||||
if(_SUB_PARSEEXPRESSION2_STRING_EXP->tmp||_SUB_PARSEEXPRESSION2_STRING_EXP->fixed||_SUB_PARSEEXPRESSION2_STRING_EXP->readonly){
|
||||
oldstr4023=_SUB_PARSEEXPRESSION2_STRING_EXP;
|
||||
if (oldstr4023->cmem_descriptor){
|
||||
_SUB_PARSEEXPRESSION2_STRING_EXP=qbs_new_cmem(oldstr4023->len,0);
|
||||
oldstr4011=_SUB_PARSEEXPRESSION2_STRING_EXP;
|
||||
if (oldstr4011->cmem_descriptor){
|
||||
_SUB_PARSEEXPRESSION2_STRING_EXP=qbs_new_cmem(oldstr4011->len,0);
|
||||
}else{
|
||||
_SUB_PARSEEXPRESSION2_STRING_EXP=qbs_new(oldstr4023->len,0);
|
||||
_SUB_PARSEEXPRESSION2_STRING_EXP=qbs_new(oldstr4011->len,0);
|
||||
}
|
||||
memcpy(_SUB_PARSEEXPRESSION2_STRING_EXP->chr,oldstr4023->chr,oldstr4023->len);
|
||||
memcpy(_SUB_PARSEEXPRESSION2_STRING_EXP->chr,oldstr4011->chr,oldstr4011->len);
|
||||
}
|
||||
void *_SUB_PARSEEXPRESSION2_UDT_STATE=NULL;
|
||||
if(_SUB_PARSEEXPRESSION2_UDT_STATE==NULL){
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_EVALUATEFUNCTION_STRING_EVALUATEFUNCTION=NULL;
|
||||
if (!_FUNC_EVALUATEFUNCTION_STRING_EVALUATEFUNCTION)_FUNC_EVALUATEFUNCTION_STRING_EVALUATEFUNCTION=qbs_new(0,0);
|
||||
qbs*oldstr4024=NULL;
|
||||
qbs*oldstr4012=NULL;
|
||||
if(_FUNC_EVALUATEFUNCTION_STRING_ARGS->tmp||_FUNC_EVALUATEFUNCTION_STRING_ARGS->fixed||_FUNC_EVALUATEFUNCTION_STRING_ARGS->readonly){
|
||||
oldstr4024=_FUNC_EVALUATEFUNCTION_STRING_ARGS;
|
||||
if (oldstr4024->cmem_descriptor){
|
||||
_FUNC_EVALUATEFUNCTION_STRING_ARGS=qbs_new_cmem(oldstr4024->len,0);
|
||||
oldstr4012=_FUNC_EVALUATEFUNCTION_STRING_ARGS;
|
||||
if (oldstr4012->cmem_descriptor){
|
||||
_FUNC_EVALUATEFUNCTION_STRING_ARGS=qbs_new_cmem(oldstr4012->len,0);
|
||||
}else{
|
||||
_FUNC_EVALUATEFUNCTION_STRING_ARGS=qbs_new(oldstr4024->len,0);
|
||||
_FUNC_EVALUATEFUNCTION_STRING_ARGS=qbs_new(oldstr4012->len,0);
|
||||
}
|
||||
memcpy(_FUNC_EVALUATEFUNCTION_STRING_ARGS->chr,oldstr4024->chr,oldstr4024->len);
|
||||
memcpy(_FUNC_EVALUATEFUNCTION_STRING_ARGS->chr,oldstr4012->chr,oldstr4012->len);
|
||||
}
|
||||
long double *_FUNC_EVALUATEFUNCTION_FLOAT_N1=NULL;
|
||||
if(_FUNC_EVALUATEFUNCTION_FLOAT_N1==NULL){
|
||||
|
@ -51,32 +51,32 @@ if(_FUNC_EVALUATEFUNCTION_LONG_I==NULL){
|
|||
_FUNC_EVALUATEFUNCTION_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNCTION_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value4026;
|
||||
int64 fornext_finalvalue4026;
|
||||
int64 fornext_step4026;
|
||||
uint8 fornext_step_negative4026;
|
||||
int64 fornext_value4014;
|
||||
int64 fornext_finalvalue4014;
|
||||
int64 fornext_step4014;
|
||||
uint8 fornext_step_negative4014;
|
||||
qbs *_FUNC_EVALUATEFUNCTION_STRING_ELE=NULL;
|
||||
if (!_FUNC_EVALUATEFUNCTION_STRING_ELE)_FUNC_EVALUATEFUNCTION_STRING_ELE=qbs_new(0,0);
|
||||
int32 pass4027;
|
||||
int32 pass4028;
|
||||
int32 pass4015;
|
||||
int32 pass4016;
|
||||
int32 *_FUNC_EVALUATEFUNCTION_LONG_TYP=NULL;
|
||||
if(_FUNC_EVALUATEFUNCTION_LONG_TYP==NULL){
|
||||
_FUNC_EVALUATEFUNCTION_LONG_TYP=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNCTION_LONG_TYP=0;
|
||||
}
|
||||
static qbs *sc_4029=qbs_new(0,0);
|
||||
static uint64 sc_4031;
|
||||
static qbs *sc_4017=qbs_new(0,0);
|
||||
static uint64 sc_4019;
|
||||
int32 *_FUNC_EVALUATEFUNCTION_LONG_T=NULL;
|
||||
if(_FUNC_EVALUATEFUNCTION_LONG_T==NULL){
|
||||
_FUNC_EVALUATEFUNCTION_LONG_T=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNCTION_LONG_T=0;
|
||||
}
|
||||
static uint64 sc_4032;
|
||||
static int64 sc_4033;
|
||||
static uint64 sc_4020;
|
||||
static int64 sc_4021;
|
||||
qbs *_FUNC_EVALUATEFUNCTION_STRING_EVALUATENUMBERS=NULL;
|
||||
if (!_FUNC_EVALUATEFUNCTION_STRING_EVALUATENUMBERS)_FUNC_EVALUATEFUNCTION_STRING_EVALUATENUMBERS=qbs_new(0,0);
|
||||
static qbs *sc_4034=qbs_new(0,0);
|
||||
static qbs *sc_4035=qbs_new(0,0);
|
||||
static qbs *sc_4022=qbs_new(0,0);
|
||||
static qbs *sc_4023=qbs_new(0,0);
|
||||
int64 *_FUNC_EVALUATEFUNCTION_INTEGER64_N=NULL;
|
||||
if(_FUNC_EVALUATEFUNCTION_INTEGER64_N==NULL){
|
||||
_FUNC_EVALUATEFUNCTION_INTEGER64_N=(int64*)mem_static_malloc(8);
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_DWD_STRING_DWD=NULL;
|
||||
if (!_FUNC_DWD_STRING_DWD)_FUNC_DWD_STRING_DWD=qbs_new(0,0);
|
||||
qbs*oldstr4036=NULL;
|
||||
qbs*oldstr4024=NULL;
|
||||
if(_FUNC_DWD_STRING_EXP->tmp||_FUNC_DWD_STRING_EXP->fixed||_FUNC_DWD_STRING_EXP->readonly){
|
||||
oldstr4036=_FUNC_DWD_STRING_EXP;
|
||||
if (oldstr4036->cmem_descriptor){
|
||||
_FUNC_DWD_STRING_EXP=qbs_new_cmem(oldstr4036->len,0);
|
||||
oldstr4024=_FUNC_DWD_STRING_EXP;
|
||||
if (oldstr4024->cmem_descriptor){
|
||||
_FUNC_DWD_STRING_EXP=qbs_new_cmem(oldstr4024->len,0);
|
||||
}else{
|
||||
_FUNC_DWD_STRING_EXP=qbs_new(oldstr4036->len,0);
|
||||
_FUNC_DWD_STRING_EXP=qbs_new(oldstr4024->len,0);
|
||||
}
|
||||
memcpy(_FUNC_DWD_STRING_EXP->chr,oldstr4036->chr,oldstr4036->len);
|
||||
memcpy(_FUNC_DWD_STRING_EXP->chr,oldstr4024->chr,oldstr4024->len);
|
||||
}
|
||||
qbs *_FUNC_DWD_STRING_T=NULL;
|
||||
if (!_FUNC_DWD_STRING_T)_FUNC_DWD_STRING_T=qbs_new(0,0);
|
||||
|
@ -17,16 +17,16 @@ if(_FUNC_DWD_LONG_L==NULL){
|
|||
_FUNC_DWD_LONG_L=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_DWD_LONG_L=0;
|
||||
}
|
||||
int64 fornext_value4038;
|
||||
int64 fornext_finalvalue4038;
|
||||
int64 fornext_step4038;
|
||||
uint8 fornext_step_negative4038;
|
||||
int64 fornext_value4026;
|
||||
int64 fornext_finalvalue4026;
|
||||
int64 fornext_step4026;
|
||||
uint8 fornext_step_negative4026;
|
||||
qbs *_FUNC_DWD_STRING_ELE=NULL;
|
||||
if (!_FUNC_DWD_STRING_ELE)_FUNC_DWD_STRING_ELE=qbs_new(0,0);
|
||||
qbs *_FUNC_DWD_STRING_NEXTELE=NULL;
|
||||
if (!_FUNC_DWD_STRING_NEXTELE)_FUNC_DWD_STRING_NEXTELE=qbs_new(0,0);
|
||||
int32 pass4039;
|
||||
int32 pass4040;
|
||||
int32 pass4041;
|
||||
int32 pass4042;
|
||||
int32 pass4043;
|
||||
int32 pass4027;
|
||||
int32 pass4028;
|
||||
int32 pass4029;
|
||||
int32 pass4030;
|
||||
int32 pass4031;
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr4044=NULL;
|
||||
qbs*oldstr4032=NULL;
|
||||
if(_SUB_PREPARSE_STRING_E->tmp||_SUB_PREPARSE_STRING_E->fixed||_SUB_PREPARSE_STRING_E->readonly){
|
||||
oldstr4044=_SUB_PREPARSE_STRING_E;
|
||||
if (oldstr4044->cmem_descriptor){
|
||||
_SUB_PREPARSE_STRING_E=qbs_new_cmem(oldstr4044->len,0);
|
||||
oldstr4032=_SUB_PREPARSE_STRING_E;
|
||||
if (oldstr4032->cmem_descriptor){
|
||||
_SUB_PREPARSE_STRING_E=qbs_new_cmem(oldstr4032->len,0);
|
||||
}else{
|
||||
_SUB_PREPARSE_STRING_E=qbs_new(oldstr4044->len,0);
|
||||
_SUB_PREPARSE_STRING_E=qbs_new(oldstr4032->len,0);
|
||||
}
|
||||
memcpy(_SUB_PREPARSE_STRING_E->chr,oldstr4044->chr,oldstr4044->len);
|
||||
memcpy(_SUB_PREPARSE_STRING_E->chr,oldstr4032->chr,oldstr4032->len);
|
||||
}
|
||||
qbs *_SUB_PREPARSE_STRING_T=NULL;
|
||||
if (!_SUB_PREPARSE_STRING_T)_SUB_PREPARSE_STRING_T=qbs_new(0,0);
|
||||
|
@ -20,10 +20,10 @@ if(_SUB_PREPARSE_LONG_L==NULL){
|
|||
_SUB_PREPARSE_LONG_L=(int32*)mem_static_malloc(4);
|
||||
*_SUB_PREPARSE_LONG_L=0;
|
||||
}
|
||||
int64 fornext_value4046;
|
||||
int64 fornext_finalvalue4046;
|
||||
int64 fornext_step4046;
|
||||
uint8 fornext_step_negative4046;
|
||||
int64 fornext_value4034;
|
||||
int64 fornext_finalvalue4034;
|
||||
int64 fornext_step4034;
|
||||
uint8 fornext_step_negative4034;
|
||||
qbs *_SUB_PREPARSE_STRING_ELE=NULL;
|
||||
if (!_SUB_PREPARSE_STRING_ELE)_SUB_PREPARSE_STRING_ELE=qbs_new(0,0);
|
||||
int32 *_SUB_PREPARSE_LONG_C=NULL;
|
||||
|
@ -31,18 +31,18 @@ if(_SUB_PREPARSE_LONG_C==NULL){
|
|||
_SUB_PREPARSE_LONG_C=(int32*)mem_static_malloc(4);
|
||||
*_SUB_PREPARSE_LONG_C=0;
|
||||
}
|
||||
int64 fornext_value4048;
|
||||
int64 fornext_finalvalue4048;
|
||||
int64 fornext_step4048;
|
||||
uint8 fornext_step_negative4048;
|
||||
int64 fornext_value4036;
|
||||
int64 fornext_finalvalue4036;
|
||||
int64 fornext_step4036;
|
||||
uint8 fornext_step_negative4036;
|
||||
int32 *_SUB_PREPARSE_LONG_L2=NULL;
|
||||
if(_SUB_PREPARSE_LONG_L2==NULL){
|
||||
_SUB_PREPARSE_LONG_L2=(int32*)mem_static_malloc(4);
|
||||
*_SUB_PREPARSE_LONG_L2=0;
|
||||
}
|
||||
int64 fornext_value4050;
|
||||
int64 fornext_finalvalue4050;
|
||||
int64 fornext_step4050;
|
||||
uint8 fornext_step_negative4050;
|
||||
int32 pass4051;
|
||||
int32 pass4052;
|
||||
int64 fornext_value4038;
|
||||
int64 fornext_finalvalue4038;
|
||||
int64 fornext_step4038;
|
||||
uint8 fornext_step_negative4038;
|
||||
int32 pass4039;
|
||||
int32 pass4040;
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_EVALUATE_STRING_EVALUATE=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_EVALUATE)_FUNC_EVALUATE_STRING_EVALUATE=qbs_new(0,0);
|
||||
qbs*oldstr2587=NULL;
|
||||
qbs*oldstr2575=NULL;
|
||||
if(_FUNC_EVALUATE_STRING_A2->tmp||_FUNC_EVALUATE_STRING_A2->fixed||_FUNC_EVALUATE_STRING_A2->readonly){
|
||||
oldstr2587=_FUNC_EVALUATE_STRING_A2;
|
||||
if (oldstr2587->cmem_descriptor){
|
||||
_FUNC_EVALUATE_STRING_A2=qbs_new_cmem(oldstr2587->len,0);
|
||||
oldstr2575=_FUNC_EVALUATE_STRING_A2;
|
||||
if (oldstr2575->cmem_descriptor){
|
||||
_FUNC_EVALUATE_STRING_A2=qbs_new_cmem(oldstr2575->len,0);
|
||||
}else{
|
||||
_FUNC_EVALUATE_STRING_A2=qbs_new(oldstr2587->len,0);
|
||||
_FUNC_EVALUATE_STRING_A2=qbs_new(oldstr2575->len,0);
|
||||
}
|
||||
memcpy(_FUNC_EVALUATE_STRING_A2->chr,oldstr2587->chr,oldstr2587->len);
|
||||
memcpy(_FUNC_EVALUATE_STRING_A2->chr,oldstr2575->chr,oldstr2575->len);
|
||||
}
|
||||
ptrszint *_FUNC_EVALUATE_ARRAY_STRING_BLOCK=NULL;
|
||||
if (!_FUNC_EVALUATE_ARRAY_STRING_BLOCK){
|
||||
|
@ -68,15 +68,15 @@ if(_FUNC_EVALUATE_LONG_I==NULL){
|
|||
_FUNC_EVALUATE_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value2590;
|
||||
int64 fornext_finalvalue2590;
|
||||
int64 fornext_step2590;
|
||||
uint8 fornext_step_negative2590;
|
||||
int64 fornext_value2578;
|
||||
int64 fornext_finalvalue2578;
|
||||
int64 fornext_step2578;
|
||||
uint8 fornext_step_negative2578;
|
||||
qbs *_FUNC_EVALUATE_STRING_L=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_L)_FUNC_EVALUATE_STRING_L=qbs_new(0,0);
|
||||
qbs *_FUNC_EVALUATE_STRING_NEXTL=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_NEXTL)_FUNC_EVALUATE_STRING_NEXTL=qbs_new(0,0);
|
||||
int32 pass2592;
|
||||
int32 pass2580;
|
||||
qbs *_FUNC_EVALUATE_STRING_L2=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_L2)_FUNC_EVALUATE_STRING_L2=qbs_new(0,0);
|
||||
int32 *_FUNC_EVALUATE_LONG_TRY_METHOD=NULL;
|
||||
|
@ -84,15 +84,15 @@ if(_FUNC_EVALUATE_LONG_TRY_METHOD==NULL){
|
|||
_FUNC_EVALUATE_LONG_TRY_METHOD=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_TRY_METHOD=0;
|
||||
}
|
||||
int64 fornext_value2595;
|
||||
int64 fornext_finalvalue2595;
|
||||
int64 fornext_step2595;
|
||||
uint8 fornext_step_negative2595;
|
||||
int64 fornext_value2583;
|
||||
int64 fornext_finalvalue2583;
|
||||
int64 fornext_step2583;
|
||||
uint8 fornext_step_negative2583;
|
||||
qbs *_FUNC_EVALUATE_STRING_DTYP=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_DTYP)_FUNC_EVALUATE_STRING_DTYP=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2596=NULL;
|
||||
if (!byte_element_2596){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2596=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2596=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2584=NULL;
|
||||
if (!byte_element_2584){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2584=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2584=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_EVALUATE_LONG_V=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_V==NULL){
|
||||
|
@ -121,8 +121,8 @@ _FUNC_EVALUATE_LONG_B2=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_EVALUATE_STRING_C=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_C)_FUNC_EVALUATE_STRING_C=qbs_new(0,0);
|
||||
int32 pass2599;
|
||||
int32 pass2600;
|
||||
int32 pass2587;
|
||||
int32 pass2588;
|
||||
int32 *_FUNC_EVALUATE_LONG_TYP2=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_TYP2==NULL){
|
||||
_FUNC_EVALUATE_LONG_TYP2=(int32*)mem_static_malloc(4);
|
||||
|
@ -130,9 +130,9 @@ _FUNC_EVALUATE_LONG_TYP2=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_EVALUATE_STRING_O=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_O)_FUNC_EVALUATE_STRING_O=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2601=NULL;
|
||||
if (!byte_element_2601){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2601=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2601=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2589=NULL;
|
||||
if (!byte_element_2589){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2589=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2589=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_EVALUATE_LONG_U=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_U==NULL){
|
||||
|
@ -149,10 +149,10 @@ if(_FUNC_EVALUATE_LONG_I3==NULL){
|
|||
_FUNC_EVALUATE_LONG_I3=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_I3=0;
|
||||
}
|
||||
int64 fornext_value2603;
|
||||
int64 fornext_finalvalue2603;
|
||||
int64 fornext_step2603;
|
||||
uint8 fornext_step_negative2603;
|
||||
int64 fornext_value2591;
|
||||
int64 fornext_finalvalue2591;
|
||||
int64 fornext_step2591;
|
||||
uint8 fornext_step_negative2591;
|
||||
qbs *_FUNC_EVALUATE_STRING_E2=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_E2)_FUNC_EVALUATE_STRING_E2=qbs_new(0,0);
|
||||
int32 *_FUNC_EVALUATE_LONG_I4=NULL;
|
||||
|
@ -162,31 +162,31 @@ _FUNC_EVALUATE_LONG_I4=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_EVALUATE_STRING_E=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_E)_FUNC_EVALUATE_STRING_E=qbs_new(0,0);
|
||||
int32 pass2604;
|
||||
int32 pass2592;
|
||||
int32 *_FUNC_EVALUATE_LONG_ARGS=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_ARGS==NULL){
|
||||
_FUNC_EVALUATE_LONG_ARGS=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_ARGS=0;
|
||||
}
|
||||
int32 pass2605;
|
||||
int32 pass2606;
|
||||
int32 pass2607;
|
||||
int32 pass2608;
|
||||
int32 pass2593;
|
||||
int32 pass2594;
|
||||
int32 pass2595;
|
||||
int32 pass2596;
|
||||
int32 *_FUNC_EVALUATE_LONG_NUME=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_NUME==NULL){
|
||||
_FUNC_EVALUATE_LONG_NUME=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_NUME=0;
|
||||
}
|
||||
int64 fornext_value2613;
|
||||
int64 fornext_finalvalue2613;
|
||||
int64 fornext_step2613;
|
||||
uint8 fornext_step_negative2613;
|
||||
int64 fornext_value2601;
|
||||
int64 fornext_finalvalue2601;
|
||||
int64 fornext_step2601;
|
||||
uint8 fornext_step_negative2601;
|
||||
qbs *_FUNC_EVALUATE_STRING_FAKEE=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_FAKEE)_FUNC_EVALUATE_STRING_FAKEE=qbs_new(0,0);
|
||||
int64 fornext_value2615;
|
||||
int64 fornext_finalvalue2615;
|
||||
int64 fornext_step2615;
|
||||
uint8 fornext_step_negative2615;
|
||||
int64 fornext_value2603;
|
||||
int64 fornext_finalvalue2603;
|
||||
int64 fornext_step2603;
|
||||
uint8 fornext_step_negative2603;
|
||||
int32 *_FUNC_EVALUATE_LONG_OLDDIMSTATIC=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_OLDDIMSTATIC==NULL){
|
||||
_FUNC_EVALUATE_LONG_OLDDIMSTATIC=(int32*)mem_static_malloc(4);
|
||||
|
@ -207,10 +207,10 @@ if(_FUNC_EVALUATE_LONG_X==NULL){
|
|||
_FUNC_EVALUATE_LONG_X=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_X=0;
|
||||
}
|
||||
int64 fornext_value2618;
|
||||
int64 fornext_finalvalue2618;
|
||||
int64 fornext_step2618;
|
||||
uint8 fornext_step_negative2618;
|
||||
int64 fornext_value2606;
|
||||
int64 fornext_finalvalue2606;
|
||||
int64 fornext_step2606;
|
||||
uint8 fornext_step_negative2606;
|
||||
qbs *_FUNC_EVALUATE_STRING_VARNAME2=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_VARNAME2)_FUNC_EVALUATE_STRING_VARNAME2=qbs_new(0,0);
|
||||
qbs *_FUNC_EVALUATE_STRING_TYP2=NULL;
|
||||
|
@ -234,17 +234,17 @@ if(_FUNC_EVALUATE_LONG_I1==NULL){
|
|||
_FUNC_EVALUATE_LONG_I1=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_I1=0;
|
||||
}
|
||||
int32 pass2620;
|
||||
int32 pass2608;
|
||||
qbs *_FUNC_EVALUATE_STRING_R=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_R)_FUNC_EVALUATE_STRING_R=qbs_new(0,0);
|
||||
int64 fornext_value2623;
|
||||
int64 fornext_finalvalue2623;
|
||||
int64 fornext_step2623;
|
||||
uint8 fornext_step_negative2623;
|
||||
int64 fornext_value2627;
|
||||
int64 fornext_finalvalue2627;
|
||||
int64 fornext_step2627;
|
||||
uint8 fornext_step_negative2627;
|
||||
int64 fornext_value2611;
|
||||
int64 fornext_finalvalue2611;
|
||||
int64 fornext_step2611;
|
||||
uint8 fornext_step_negative2611;
|
||||
int64 fornext_value2615;
|
||||
int64 fornext_finalvalue2615;
|
||||
int64 fornext_step2615;
|
||||
uint8 fornext_step_negative2615;
|
||||
int32 *_FUNC_EVALUATE_LONG_C=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_C==NULL){
|
||||
_FUNC_EVALUATE_LONG_C=(int32*)mem_static_malloc(4);
|
||||
|
@ -261,29 +261,29 @@ qbs *_FUNC_EVALUATE_STRING_X=NULL;
|
|||
if (!_FUNC_EVALUATE_STRING_X)_FUNC_EVALUATE_STRING_X=qbs_new(0,0);
|
||||
qbs *_FUNC_EVALUATE_STRING_TYP=NULL;
|
||||
if (!_FUNC_EVALUATE_STRING_TYP)_FUNC_EVALUATE_STRING_TYP=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2628=NULL;
|
||||
if (!byte_element_2628){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2628=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2628=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2616=NULL;
|
||||
if (!byte_element_2616){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2616=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2616=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_EVALUATE_LONG_RETVAL=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_RETVAL==NULL){
|
||||
_FUNC_EVALUATE_LONG_RETVAL=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_RETVAL=0;
|
||||
}
|
||||
int32 pass2632;
|
||||
int32 pass2633;
|
||||
int8 pass2634;
|
||||
int32 pass2635;
|
||||
int32 pass2636;
|
||||
int32 pass2620;
|
||||
int32 pass2621;
|
||||
int8 pass2622;
|
||||
int32 pass2623;
|
||||
int32 pass2624;
|
||||
int32 *_FUNC_EVALUATE_LONG_NONOP=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_NONOP==NULL){
|
||||
_FUNC_EVALUATE_LONG_NONOP=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_NONOP=0;
|
||||
}
|
||||
int64 fornext_value2640;
|
||||
int64 fornext_finalvalue2640;
|
||||
int64 fornext_step2640;
|
||||
uint8 fornext_step_negative2640;
|
||||
int64 fornext_value2628;
|
||||
int64 fornext_finalvalue2628;
|
||||
int64 fornext_step2628;
|
||||
uint8 fornext_step_negative2628;
|
||||
int32 *_FUNC_EVALUATE_LONG_ISOP=NULL;
|
||||
if(_FUNC_EVALUATE_LONG_ISOP==NULL){
|
||||
_FUNC_EVALUATE_LONG_ISOP=(int32*)mem_static_malloc(4);
|
||||
|
@ -341,8 +341,8 @@ if(_FUNC_EVALUATE_LONG_B3==NULL){
|
|||
_FUNC_EVALUATE_LONG_B3=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATE_LONG_B3=0;
|
||||
}
|
||||
int64 fornext_value2643;
|
||||
int64 fornext_finalvalue2643;
|
||||
int64 fornext_step2643;
|
||||
uint8 fornext_step_negative2643;
|
||||
int32 pass2652;
|
||||
int64 fornext_value2631;
|
||||
int64 fornext_finalvalue2631;
|
||||
int64 fornext_step2631;
|
||||
uint8 fornext_step_negative2631;
|
||||
int32 pass2640;
|
||||
|
|
|
@ -3,22 +3,22 @@ if(_FUNC_ISFUNCTIONIDENTIFIER_LONG_ISFUNCTIONIDENTIFIER==NULL){
|
|||
_FUNC_ISFUNCTIONIDENTIFIER_LONG_ISFUNCTIONIDENTIFIER=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ISFUNCTIONIDENTIFIER_LONG_ISFUNCTIONIDENTIFIER=0;
|
||||
}
|
||||
qbs*oldstr4053=NULL;
|
||||
qbs*oldstr4041=NULL;
|
||||
if(_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->tmp||_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->fixed||_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->readonly){
|
||||
oldstr4053=_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE;
|
||||
if (oldstr4053->cmem_descriptor){
|
||||
_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE=qbs_new_cmem(oldstr4053->len,0);
|
||||
oldstr4041=_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE;
|
||||
if (oldstr4041->cmem_descriptor){
|
||||
_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE=qbs_new_cmem(oldstr4041->len,0);
|
||||
}else{
|
||||
_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE=qbs_new(oldstr4053->len,0);
|
||||
_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE=qbs_new(oldstr4041->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->chr,oldstr4053->chr,oldstr4053->len);
|
||||
memcpy(_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->chr,oldstr4041->chr,oldstr4041->len);
|
||||
}
|
||||
int32 *_FUNC_ISFUNCTIONIDENTIFIER_LONG_I=NULL;
|
||||
if(_FUNC_ISFUNCTIONIDENTIFIER_LONG_I==NULL){
|
||||
_FUNC_ISFUNCTIONIDENTIFIER_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ISFUNCTIONIDENTIFIER_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value4055;
|
||||
int64 fornext_finalvalue4055;
|
||||
int64 fornext_step4055;
|
||||
uint8 fornext_step_negative4055;
|
||||
int64 fornext_value4043;
|
||||
int64 fornext_finalvalue4043;
|
||||
int64 fornext_step4043;
|
||||
uint8 fornext_step_negative4043;
|
||||
|
|
|
@ -3,24 +3,24 @@ if(_FUNC_HASHVALUE_LONG_HASHVALUE==NULL){
|
|||
_FUNC_HASHVALUE_LONG_HASHVALUE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_HASHVALUE_LONG_HASHVALUE=0;
|
||||
}
|
||||
qbs*oldstr4056=NULL;
|
||||
qbs*oldstr4044=NULL;
|
||||
if(_FUNC_HASHVALUE_STRING_A->tmp||_FUNC_HASHVALUE_STRING_A->fixed||_FUNC_HASHVALUE_STRING_A->readonly){
|
||||
oldstr4056=_FUNC_HASHVALUE_STRING_A;
|
||||
if (oldstr4056->cmem_descriptor){
|
||||
_FUNC_HASHVALUE_STRING_A=qbs_new_cmem(oldstr4056->len,0);
|
||||
oldstr4044=_FUNC_HASHVALUE_STRING_A;
|
||||
if (oldstr4044->cmem_descriptor){
|
||||
_FUNC_HASHVALUE_STRING_A=qbs_new_cmem(oldstr4044->len,0);
|
||||
}else{
|
||||
_FUNC_HASHVALUE_STRING_A=qbs_new(oldstr4056->len,0);
|
||||
_FUNC_HASHVALUE_STRING_A=qbs_new(oldstr4044->len,0);
|
||||
}
|
||||
memcpy(_FUNC_HASHVALUE_STRING_A->chr,oldstr4056->chr,oldstr4056->len);
|
||||
memcpy(_FUNC_HASHVALUE_STRING_A->chr,oldstr4044->chr,oldstr4044->len);
|
||||
}
|
||||
int32 *_FUNC_HASHVALUE_LONG_L=NULL;
|
||||
if(_FUNC_HASHVALUE_LONG_L==NULL){
|
||||
_FUNC_HASHVALUE_LONG_L=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_HASHVALUE_LONG_L=0;
|
||||
}
|
||||
byte_element_struct *byte_element_4057=NULL;
|
||||
if (!byte_element_4057){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4057=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4057=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4045=NULL;
|
||||
if (!byte_element_4045){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4045=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4045=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_HASHVALUE_LONG_A=NULL;
|
||||
if(_FUNC_HASHVALUE_LONG_A==NULL){
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr4060=NULL;
|
||||
qbs*oldstr4048=NULL;
|
||||
if(_SUB_HASHADD_STRING_A->tmp||_SUB_HASHADD_STRING_A->fixed||_SUB_HASHADD_STRING_A->readonly){
|
||||
oldstr4060=_SUB_HASHADD_STRING_A;
|
||||
if (oldstr4060->cmem_descriptor){
|
||||
_SUB_HASHADD_STRING_A=qbs_new_cmem(oldstr4060->len,0);
|
||||
oldstr4048=_SUB_HASHADD_STRING_A;
|
||||
if (oldstr4048->cmem_descriptor){
|
||||
_SUB_HASHADD_STRING_A=qbs_new_cmem(oldstr4048->len,0);
|
||||
}else{
|
||||
_SUB_HASHADD_STRING_A=qbs_new(oldstr4060->len,0);
|
||||
_SUB_HASHADD_STRING_A=qbs_new(oldstr4048->len,0);
|
||||
}
|
||||
memcpy(_SUB_HASHADD_STRING_A->chr,oldstr4060->chr,oldstr4060->len);
|
||||
memcpy(_SUB_HASHADD_STRING_A->chr,oldstr4048->chr,oldstr4048->len);
|
||||
}
|
||||
int32 *_SUB_HASHADD_LONG_I=NULL;
|
||||
if(_SUB_HASHADD_LONG_I==NULL){
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_HASHFIND_LONG_HASHFIND==NULL){
|
|||
_FUNC_HASHFIND_LONG_HASHFIND=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_HASHFIND_LONG_HASHFIND=0;
|
||||
}
|
||||
qbs*oldstr4061=NULL;
|
||||
qbs*oldstr4049=NULL;
|
||||
if(_FUNC_HASHFIND_STRING_A->tmp||_FUNC_HASHFIND_STRING_A->fixed||_FUNC_HASHFIND_STRING_A->readonly){
|
||||
oldstr4061=_FUNC_HASHFIND_STRING_A;
|
||||
if (oldstr4061->cmem_descriptor){
|
||||
_FUNC_HASHFIND_STRING_A=qbs_new_cmem(oldstr4061->len,0);
|
||||
oldstr4049=_FUNC_HASHFIND_STRING_A;
|
||||
if (oldstr4049->cmem_descriptor){
|
||||
_FUNC_HASHFIND_STRING_A=qbs_new_cmem(oldstr4049->len,0);
|
||||
}else{
|
||||
_FUNC_HASHFIND_STRING_A=qbs_new(oldstr4061->len,0);
|
||||
_FUNC_HASHFIND_STRING_A=qbs_new(oldstr4049->len,0);
|
||||
}
|
||||
memcpy(_FUNC_HASHFIND_STRING_A->chr,oldstr4061->chr,oldstr4061->len);
|
||||
memcpy(_FUNC_HASHFIND_STRING_A->chr,oldstr4049->chr,oldstr4049->len);
|
||||
}
|
||||
int32 *_FUNC_HASHFIND_LONG_I=NULL;
|
||||
if(_FUNC_HASHFIND_LONG_I==NULL){
|
||||
|
@ -20,9 +20,9 @@ _FUNC_HASHFIND_LONG_I=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_HASHFIND_STRING_UA=NULL;
|
||||
if (!_FUNC_HASHFIND_STRING_UA)_FUNC_HASHFIND_STRING_UA=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4062=NULL;
|
||||
if (!byte_element_4062){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4062=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4062=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4050=NULL;
|
||||
if (!byte_element_4050){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4050=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4050=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_HASHFIND_LONG_F=NULL;
|
||||
if(_FUNC_HASHFIND_LONG_F==NULL){
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_HASHFINDREV_LONG_HASHFINDREV==NULL){
|
|||
_FUNC_HASHFINDREV_LONG_HASHFINDREV=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_HASHFINDREV_LONG_HASHFINDREV=0;
|
||||
}
|
||||
qbs*oldstr4063=NULL;
|
||||
qbs*oldstr4051=NULL;
|
||||
if(_FUNC_HASHFINDREV_STRING_A->tmp||_FUNC_HASHFINDREV_STRING_A->fixed||_FUNC_HASHFINDREV_STRING_A->readonly){
|
||||
oldstr4063=_FUNC_HASHFINDREV_STRING_A;
|
||||
if (oldstr4063->cmem_descriptor){
|
||||
_FUNC_HASHFINDREV_STRING_A=qbs_new_cmem(oldstr4063->len,0);
|
||||
oldstr4051=_FUNC_HASHFINDREV_STRING_A;
|
||||
if (oldstr4051->cmem_descriptor){
|
||||
_FUNC_HASHFINDREV_STRING_A=qbs_new_cmem(oldstr4051->len,0);
|
||||
}else{
|
||||
_FUNC_HASHFINDREV_STRING_A=qbs_new(oldstr4063->len,0);
|
||||
_FUNC_HASHFINDREV_STRING_A=qbs_new(oldstr4051->len,0);
|
||||
}
|
||||
memcpy(_FUNC_HASHFINDREV_STRING_A->chr,oldstr4063->chr,oldstr4063->len);
|
||||
memcpy(_FUNC_HASHFINDREV_STRING_A->chr,oldstr4051->chr,oldstr4051->len);
|
||||
}
|
||||
int32 *_FUNC_HASHFINDREV_LONG_I=NULL;
|
||||
if(_FUNC_HASHFINDREV_LONG_I==NULL){
|
||||
|
@ -20,9 +20,9 @@ _FUNC_HASHFINDREV_LONG_I=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_HASHFINDREV_STRING_UA=NULL;
|
||||
if (!_FUNC_HASHFINDREV_STRING_UA)_FUNC_HASHFINDREV_STRING_UA=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4064=NULL;
|
||||
if (!byte_element_4064){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4064=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4064=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4052=NULL;
|
||||
if (!byte_element_4052){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4052=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4052=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_HASHFINDREV_LONG_F=NULL;
|
||||
if(_FUNC_HASHFINDREV_LONG_F==NULL){
|
||||
|
|
|
@ -10,10 +10,10 @@ if(_SUB_HASHDUMP_LONG_X==NULL){
|
|||
_SUB_HASHDUMP_LONG_X=(int32*)mem_static_malloc(4);
|
||||
*_SUB_HASHDUMP_LONG_X=0;
|
||||
}
|
||||
int64 fornext_value4066;
|
||||
int64 fornext_finalvalue4066;
|
||||
int64 fornext_step4066;
|
||||
uint8 fornext_step_negative4066;
|
||||
int64 fornext_value4054;
|
||||
int64 fornext_finalvalue4054;
|
||||
int64 fornext_step4054;
|
||||
uint8 fornext_step_negative4054;
|
||||
int32 *_SUB_HASHDUMP_LONG_I=NULL;
|
||||
if(_SUB_HASHDUMP_LONG_I==NULL){
|
||||
_SUB_HASHDUMP_LONG_I=(int32*)mem_static_malloc(4);
|
||||
|
@ -36,10 +36,10 @@ if(_SUB_HASHDUMP_LONG_Z==NULL){
|
|||
_SUB_HASHDUMP_LONG_Z=(int32*)mem_static_malloc(4);
|
||||
*_SUB_HASHDUMP_LONG_Z=0;
|
||||
}
|
||||
int64 fornext_value4070;
|
||||
int64 fornext_finalvalue4070;
|
||||
int64 fornext_step4070;
|
||||
uint8 fornext_step_negative4070;
|
||||
int64 fornext_value4058;
|
||||
int64 fornext_finalvalue4058;
|
||||
int64 fornext_step4058;
|
||||
uint8 fornext_step_negative4058;
|
||||
int32 *_SUB_HASHDUMP_LONG_I1=NULL;
|
||||
if(_SUB_HASHDUMP_LONG_I1==NULL){
|
||||
_SUB_HASHDUMP_LONG_I1=(int32*)mem_static_malloc(4);
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_EVALUATEFUNC_STRING_EVALUATEFUNC=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_EVALUATEFUNC)_FUNC_EVALUATEFUNC_STRING_EVALUATEFUNC=qbs_new(0,0);
|
||||
qbs*oldstr2653=NULL;
|
||||
qbs*oldstr2641=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_STRING_A2->tmp||_FUNC_EVALUATEFUNC_STRING_A2->fixed||_FUNC_EVALUATEFUNC_STRING_A2->readonly){
|
||||
oldstr2653=_FUNC_EVALUATEFUNC_STRING_A2;
|
||||
if (oldstr2653->cmem_descriptor){
|
||||
_FUNC_EVALUATEFUNC_STRING_A2=qbs_new_cmem(oldstr2653->len,0);
|
||||
oldstr2641=_FUNC_EVALUATEFUNC_STRING_A2;
|
||||
if (oldstr2641->cmem_descriptor){
|
||||
_FUNC_EVALUATEFUNC_STRING_A2=qbs_new_cmem(oldstr2641->len,0);
|
||||
}else{
|
||||
_FUNC_EVALUATEFUNC_STRING_A2=qbs_new(oldstr2653->len,0);
|
||||
_FUNC_EVALUATEFUNC_STRING_A2=qbs_new(oldstr2641->len,0);
|
||||
}
|
||||
memcpy(_FUNC_EVALUATEFUNC_STRING_A2->chr,oldstr2653->chr,oldstr2653->len);
|
||||
memcpy(_FUNC_EVALUATEFUNC_STRING_A2->chr,oldstr2641->chr,oldstr2641->len);
|
||||
}
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_A=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_A)_FUNC_EVALUATEFUNC_STRING_A=qbs_new(0,0);
|
||||
|
@ -25,8 +25,8 @@ if(_FUNC_EVALUATEFUNC_LONG_TARGETID==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_TARGETID=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_TARGETID=0;
|
||||
}
|
||||
int16 pass2655;
|
||||
int32 pass2656;
|
||||
int16 pass2643;
|
||||
int32 pass2644;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_ARGCOUNT=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_ARGCOUNT==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_ARGCOUNT=(int32*)mem_static_malloc(4);
|
||||
|
@ -61,28 +61,28 @@ _FUNC_EVALUATEFUNC_LONG_FIRSTOPTIONALARGUMENT=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_F=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_F)_FUNC_EVALUATEFUNC_STRING_F=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2657=NULL;
|
||||
if (!byte_element_2657){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2657=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2657=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2645=NULL;
|
||||
if (!byte_element_2645){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2645=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2645=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_FI=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_FI==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_FI=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_FI=0;
|
||||
}
|
||||
int64 fornext_value2659;
|
||||
int64 fornext_finalvalue2659;
|
||||
int64 fornext_step2659;
|
||||
uint8 fornext_step_negative2659;
|
||||
int64 fornext_value2647;
|
||||
int64 fornext_finalvalue2647;
|
||||
int64 fornext_step2647;
|
||||
uint8 fornext_step_negative2647;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_SKIPFIRSTARG=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_SKIPFIRSTARG==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_SKIPFIRSTARG=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_SKIPFIRSTARG=0;
|
||||
}
|
||||
int64 fornext_value2661;
|
||||
int64 fornext_finalvalue2661;
|
||||
int64 fornext_step2661;
|
||||
uint8 fornext_step_negative2661;
|
||||
int64 fornext_value2649;
|
||||
int64 fornext_finalvalue2649;
|
||||
int64 fornext_step2649;
|
||||
uint8 fornext_step_negative2649;
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_R=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_R)_FUNC_EVALUATEFUNC_STRING_R=qbs_new(0,0);
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_CURARG=NULL;
|
||||
|
@ -105,10 +105,10 @@ if(_FUNC_EVALUATEFUNC_LONG_I==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value2663;
|
||||
int64 fornext_finalvalue2663;
|
||||
int64 fornext_step2663;
|
||||
uint8 fornext_step_negative2663;
|
||||
int64 fornext_value2651;
|
||||
int64 fornext_finalvalue2651;
|
||||
int64 fornext_step2651;
|
||||
uint8 fornext_step_negative2651;
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_L=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_L)_FUNC_EVALUATEFUNC_STRING_L=qbs_new(0,0);
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_B=NULL;
|
||||
|
@ -133,7 +133,7 @@ _FUNC_EVALUATEFUNC_LONG_NELEREQ=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_E=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_E)_FUNC_EVALUATEFUNC_STRING_E=qbs_new(0,0);
|
||||
int32 pass2664;
|
||||
int32 pass2652;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_DEREFERENCE=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_DEREFERENCE==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_DEREFERENCE=(int32*)mem_static_malloc(4);
|
||||
|
@ -157,34 +157,34 @@ if(_FUNC_EVALUATEFUNC_LONG_KET==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_KET=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_KET=0;
|
||||
}
|
||||
byte_element_struct *byte_element_2666=NULL;
|
||||
if (!byte_element_2666){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2666=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2666=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2654=NULL;
|
||||
if (!byte_element_2654){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2654=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2654=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
static int32 sc_2667;
|
||||
static int32 sc_2655;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_RSI=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_RSI==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_RSI=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_RSI=0;
|
||||
}
|
||||
int64 fornext_value2669;
|
||||
int64 fornext_finalvalue2669;
|
||||
int64 fornext_step2669;
|
||||
uint8 fornext_step_negative2669;
|
||||
byte_element_struct *byte_element_2670=NULL;
|
||||
if (!byte_element_2670){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2670=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2670=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value2657;
|
||||
int64 fornext_finalvalue2657;
|
||||
int64 fornext_step2657;
|
||||
uint8 fornext_step_negative2657;
|
||||
byte_element_struct *byte_element_2658=NULL;
|
||||
if (!byte_element_2658){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2658=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2658=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
static int32 sc_2671;
|
||||
static int32 sc_2659;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_EFLUB=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_EFLUB==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_EFLUB=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_EFLUB=0;
|
||||
}
|
||||
int64 fornext_value2673;
|
||||
int64 fornext_finalvalue2673;
|
||||
int64 fornext_step2673;
|
||||
uint8 fornext_step_negative2673;
|
||||
int64 fornext_value2661;
|
||||
int64 fornext_finalvalue2661;
|
||||
int64 fornext_step2661;
|
||||
uint8 fornext_step_negative2661;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_SOURCETYP=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_SOURCETYP==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_SOURCETYP=(int32*)mem_static_malloc(4);
|
||||
|
@ -197,22 +197,22 @@ if(_FUNC_EVALUATEFUNC_LONG_ULBOUNDARRAYTYP==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_ULBOUNDARRAYTYP=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_ULBOUNDARRAYTYP=0;
|
||||
}
|
||||
byte_element_struct *byte_element_2674=NULL;
|
||||
if (!byte_element_2674){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2674=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2674=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2662=NULL;
|
||||
if (!byte_element_2662){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2662=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2662=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2675;
|
||||
int32 pass2663;
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_MEMGET_BLK=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_MEMGET_BLK)_FUNC_EVALUATEFUNC_STRING_MEMGET_BLK=qbs_new(0,0);
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_MEMGET_OFFS=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_MEMGET_OFFS)_FUNC_EVALUATEFUNC_STRING_MEMGET_OFFS=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2676=NULL;
|
||||
if (!byte_element_2676){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2676=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2676=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2664=NULL;
|
||||
if (!byte_element_2664){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2664=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2664=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2677=NULL;
|
||||
if (!byte_element_2677){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2677=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2677=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2665=NULL;
|
||||
if (!byte_element_2665){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2665=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2665=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_T=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_T==NULL){
|
||||
|
@ -228,24 +228,24 @@ qbs *_FUNC_EVALUATEFUNC_STRING_MEMGET_CTYP=NULL;
|
|||
if (!_FUNC_EVALUATEFUNC_STRING_MEMGET_CTYP)_FUNC_EVALUATEFUNC_STRING_MEMGET_CTYP=qbs_new(0,0);
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_OFFS=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_OFFS)_FUNC_EVALUATEFUNC_STRING_OFFS=qbs_new(0,0);
|
||||
int32 pass2678;
|
||||
int32 pass2666;
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_BLKOFFS=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_BLKOFFS)_FUNC_EVALUATEFUNC_STRING_BLKOFFS=qbs_new(0,0);
|
||||
int32 pass2679;
|
||||
int32 pass2667;
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_E2=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_E2)_FUNC_EVALUATEFUNC_STRING_E2=qbs_new(0,0);
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_ROTLR_N=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_ROTLR_N)_FUNC_EVALUATEFUNC_STRING_ROTLR_N=qbs_new(0,0);
|
||||
int32 pass2680;
|
||||
int32 pass2681;
|
||||
int32 pass2682;
|
||||
byte_element_struct *byte_element_2683=NULL;
|
||||
if (!byte_element_2683){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2683=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2683=(byte_element_struct*)mem_static_malloc(12);
|
||||
int32 pass2668;
|
||||
int32 pass2669;
|
||||
int32 pass2670;
|
||||
byte_element_struct *byte_element_2671=NULL;
|
||||
if (!byte_element_2671){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2671=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2671=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2684;
|
||||
int32 pass2685;
|
||||
int32 pass2686;
|
||||
int32 pass2672;
|
||||
int32 pass2673;
|
||||
int32 pass2674;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_BITS=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_BITS==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_BITS=(int32*)mem_static_malloc(4);
|
||||
|
@ -256,22 +256,22 @@ if(_FUNC_EVALUATEFUNC_LONG_WASREF==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_WASREF=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_WASREF=0;
|
||||
}
|
||||
int32 pass2687;
|
||||
int32 pass2688;
|
||||
int32 pass2689;
|
||||
int32 pass2675;
|
||||
int32 pass2676;
|
||||
int32 pass2677;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_CHARS=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_CHARS==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_CHARS=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_CHARS=0;
|
||||
}
|
||||
int32 pass2690;
|
||||
int32 pass2691;
|
||||
int32 pass2692;
|
||||
int32 pass2693;
|
||||
int32 pass2694;
|
||||
int32 pass2695;
|
||||
int32 pass2696;
|
||||
int32 pass2697;
|
||||
int32 pass2678;
|
||||
int32 pass2679;
|
||||
int32 pass2680;
|
||||
int32 pass2681;
|
||||
int32 pass2682;
|
||||
int32 pass2683;
|
||||
int32 pass2684;
|
||||
int32 pass2685;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_MKTYPE=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_MKTYPE==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_MKTYPE=(int32*)mem_static_malloc(4);
|
||||
|
@ -289,13 +289,13 @@ _FUNC_EVALUATEFUNC_LONG_QTYP=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_CTYPE=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_CTYPE)_FUNC_EVALUATEFUNC_STRING_CTYPE=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2698=NULL;
|
||||
if (!byte_element_2698){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2698=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2698=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2686=NULL;
|
||||
if (!byte_element_2686){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2686=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2686=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2699=NULL;
|
||||
if (!byte_element_2699){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2699=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2699=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2687=NULL;
|
||||
if (!byte_element_2687){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2687=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2687=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_NOCOMMA=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_NOCOMMA==NULL){
|
||||
|
@ -307,20 +307,20 @@ if(_FUNC_EVALUATEFUNC_LONG_CVTYPE==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_CVTYPE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_CVTYPE=0;
|
||||
}
|
||||
int32 pass2700;
|
||||
byte_element_struct *byte_element_2701=NULL;
|
||||
if (!byte_element_2701){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2701=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2701=(byte_element_struct*)mem_static_malloc(12);
|
||||
int32 pass2688;
|
||||
byte_element_struct *byte_element_2689=NULL;
|
||||
if (!byte_element_2689){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2689=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2689=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2702=NULL;
|
||||
if (!byte_element_2702){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2702=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2702=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2690=NULL;
|
||||
if (!byte_element_2690){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2690=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2690=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2703;
|
||||
int32 pass2704;
|
||||
int32 pass2705;
|
||||
int32 pass2706;
|
||||
int32 pass2707;
|
||||
int32 pass2691;
|
||||
int32 pass2692;
|
||||
int32 pass2693;
|
||||
int32 pass2694;
|
||||
int32 pass2695;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_M=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_M==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_M=(int32*)mem_static_malloc(4);
|
||||
|
@ -328,65 +328,65 @@ _FUNC_EVALUATEFUNC_LONG_M=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_INDEX=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_INDEX)_FUNC_EVALUATEFUNC_STRING_INDEX=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2708=NULL;
|
||||
if (!byte_element_2708){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2708=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2708=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2696=NULL;
|
||||
if (!byte_element_2696){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2696=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2696=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2709;
|
||||
byte_element_struct *byte_element_2710=NULL;
|
||||
if (!byte_element_2710){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2710=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2710=(byte_element_struct*)mem_static_malloc(12);
|
||||
int32 pass2697;
|
||||
byte_element_struct *byte_element_2698=NULL;
|
||||
if (!byte_element_2698){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2698=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2698=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2711=NULL;
|
||||
if (!byte_element_2711){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2711=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2711=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2699=NULL;
|
||||
if (!byte_element_2699){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2699=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2699=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_O=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_O)_FUNC_EVALUATEFUNC_STRING_O=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_2712=NULL;
|
||||
if (!byte_element_2712){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2712=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2712=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2700=NULL;
|
||||
if (!byte_element_2700){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2700=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2700=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2701=NULL;
|
||||
if (!byte_element_2701){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2701=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2701=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2702;
|
||||
byte_element_struct *byte_element_2703=NULL;
|
||||
if (!byte_element_2703){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2703=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2703=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2704=NULL;
|
||||
if (!byte_element_2704){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2704=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2704=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2705=NULL;
|
||||
if (!byte_element_2705){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2705=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2705=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2706;
|
||||
int32 pass2707;
|
||||
int32 pass2708;
|
||||
int32 pass2709;
|
||||
int32 pass2710;
|
||||
int32 pass2711;
|
||||
int32 pass2712;
|
||||
byte_element_struct *byte_element_2713=NULL;
|
||||
if (!byte_element_2713){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2713=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2713=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2714;
|
||||
byte_element_struct *byte_element_2714=NULL;
|
||||
if (!byte_element_2714){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2714=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2714=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2715=NULL;
|
||||
if (!byte_element_2715){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2715=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2715=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2716=NULL;
|
||||
if (!byte_element_2716){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2716=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2716=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2717=NULL;
|
||||
if (!byte_element_2717){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2717=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2717=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2716;
|
||||
int32 pass2717;
|
||||
int32 pass2718;
|
||||
int32 pass2719;
|
||||
int32 pass2720;
|
||||
int32 pass2721;
|
||||
int32 pass2722;
|
||||
int32 pass2723;
|
||||
int32 pass2724;
|
||||
byte_element_struct *byte_element_2725=NULL;
|
||||
if (!byte_element_2725){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2725=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2725=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2726=NULL;
|
||||
if (!byte_element_2726){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2726=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2726=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_2727=NULL;
|
||||
if (!byte_element_2727){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2727=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2727=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass2728;
|
||||
int32 pass2729;
|
||||
int32 pass2730;
|
||||
int32 pass2731;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_EXPLICITREFERENCE=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_EXPLICITREFERENCE==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_EXPLICITREFERENCE=(int32*)mem_static_malloc(4);
|
||||
|
@ -432,9 +432,9 @@ if(_FUNC_EVALUATEFUNC_LONG_UDTREFE==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_UDTREFE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_UDTREFE=0;
|
||||
}
|
||||
byte_element_struct *byte_element_2734=NULL;
|
||||
if (!byte_element_2734){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2734=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2734=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2722=NULL;
|
||||
if (!byte_element_2722){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2722=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2722=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_IDNUM=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_IDNUM==NULL){
|
||||
|
@ -446,7 +446,7 @@ if(_FUNC_EVALUATEFUNC_LONG_TARGETTYPSIZE==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_TARGETTYPSIZE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_TARGETTYPSIZE=0;
|
||||
}
|
||||
int32 pass2735;
|
||||
int32 pass2723;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_ARR=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_ARR==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_ARR=(int32*)mem_static_malloc(4);
|
||||
|
@ -457,55 +457,55 @@ if(_FUNC_EVALUATEFUNC_LONG_PASSUDTELEMENT==NULL){
|
|||
_FUNC_EVALUATEFUNC_LONG_PASSUDTELEMENT=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_PASSUDTELEMENT=0;
|
||||
}
|
||||
byte_element_struct *byte_element_2736=NULL;
|
||||
if (!byte_element_2736){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2736=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2736=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_2724=NULL;
|
||||
if (!byte_element_2724){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2724=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2724=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_N2=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_N2)_FUNC_EVALUATEFUNC_STRING_N2=qbs_new(0,0);
|
||||
int32 pass2737;
|
||||
int32 pass2738;
|
||||
int32 pass2739;
|
||||
int32 pass2740;
|
||||
int32 pass2725;
|
||||
int32 pass2726;
|
||||
int32 pass2727;
|
||||
int32 pass2728;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_NTH=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_NTH==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_NTH=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_NTH=0;
|
||||
}
|
||||
int32 pass2741;
|
||||
int32 pass2729;
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_X=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_X)_FUNC_EVALUATEFUNC_STRING_X=qbs_new(0,0);
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_T=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_T)_FUNC_EVALUATEFUNC_STRING_T=qbs_new(0,0);
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_V=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_V)_FUNC_EVALUATEFUNC_STRING_V=qbs_new(0,0);
|
||||
int32 pass2742;
|
||||
int32 pass2730;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_BYTESREQ=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_BYTESREQ==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_BYTESREQ=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_BYTESREQ=0;
|
||||
}
|
||||
int16 pass2743;
|
||||
int16 pass2744;
|
||||
int16 pass2745;
|
||||
int16 pass2746;
|
||||
int16 pass2747;
|
||||
int16 pass2748;
|
||||
int64 fornext_value2750;
|
||||
int64 fornext_finalvalue2750;
|
||||
int64 fornext_step2750;
|
||||
uint8 fornext_step_negative2750;
|
||||
int16 pass2731;
|
||||
int16 pass2732;
|
||||
int16 pass2733;
|
||||
int16 pass2734;
|
||||
int16 pass2735;
|
||||
int16 pass2736;
|
||||
int64 fornext_value2738;
|
||||
int64 fornext_finalvalue2738;
|
||||
int64 fornext_step2738;
|
||||
uint8 fornext_step_negative2738;
|
||||
qbs *_FUNC_EVALUATEFUNC_STRING_R2=NULL;
|
||||
if (!_FUNC_EVALUATEFUNC_STRING_R2)_FUNC_EVALUATEFUNC_STRING_R2=qbs_new(0,0);
|
||||
int32 pass2751;
|
||||
int32 pass2739;
|
||||
int32 *_FUNC_EVALUATEFUNC_LONG_ARRAYELEMENTS=NULL;
|
||||
if(_FUNC_EVALUATEFUNC_LONG_ARRAYELEMENTS==NULL){
|
||||
_FUNC_EVALUATEFUNC_LONG_ARRAYELEMENTS=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_EVALUATEFUNC_LONG_ARRAYELEMENTS=0;
|
||||
}
|
||||
int64 fornext_value2753;
|
||||
int64 fornext_finalvalue2753;
|
||||
int64 fornext_step2753;
|
||||
uint8 fornext_step_negative2753;
|
||||
int32 pass2754;
|
||||
int32 pass2755;
|
||||
int64 fornext_value2741;
|
||||
int64 fornext_finalvalue2741;
|
||||
int64 fornext_step2741;
|
||||
uint8 fornext_step_negative2741;
|
||||
int32 pass2742;
|
||||
int32 pass2743;
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_SYMBOL2FULLTYPENAME=NULL;
|
||||
if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_SYMBOL2FULLTYPENAME)_FUNC_SYMBOL2FULLTYPENAME_STRING_SYMBOL2FULLTYPENAME=qbs_new(0,0);
|
||||
qbs*oldstr4074=NULL;
|
||||
qbs*oldstr4062=NULL;
|
||||
if(_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->tmp||_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->fixed||_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->readonly){
|
||||
oldstr4074=_FUNC_SYMBOL2FULLTYPENAME_STRING_S2;
|
||||
if (oldstr4074->cmem_descriptor){
|
||||
_FUNC_SYMBOL2FULLTYPENAME_STRING_S2=qbs_new_cmem(oldstr4074->len,0);
|
||||
oldstr4062=_FUNC_SYMBOL2FULLTYPENAME_STRING_S2;
|
||||
if (oldstr4062->cmem_descriptor){
|
||||
_FUNC_SYMBOL2FULLTYPENAME_STRING_S2=qbs_new_cmem(oldstr4062->len,0);
|
||||
}else{
|
||||
_FUNC_SYMBOL2FULLTYPENAME_STRING_S2=qbs_new(oldstr4074->len,0);
|
||||
_FUNC_SYMBOL2FULLTYPENAME_STRING_S2=qbs_new(oldstr4062->len,0);
|
||||
}
|
||||
memcpy(_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->chr,oldstr4074->chr,oldstr4074->len);
|
||||
memcpy(_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->chr,oldstr4062->chr,oldstr4062->len);
|
||||
}
|
||||
qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_S=NULL;
|
||||
if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_S)_FUNC_SYMBOL2FULLTYPENAME_STRING_S=qbs_new(0,0);
|
||||
|
@ -19,42 +19,42 @@ _FUNC_SYMBOL2FULLTYPENAME_LONG_U=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_TYP=NULL;
|
||||
if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_TYP)_FUNC_SYMBOL2FULLTYPENAME_STRING_TYP=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4075=NULL;
|
||||
if (!byte_element_4075){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4075=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4075=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4063=NULL;
|
||||
if (!byte_element_4063){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4063=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4063=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4076=NULL;
|
||||
if (!byte_element_4076){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4076=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4076=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4064=NULL;
|
||||
if (!byte_element_4064){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4064=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4064=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_U=NULL;
|
||||
if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_U)_FUNC_SYMBOL2FULLTYPENAME_STRING_U=qbs_new(0,0);
|
||||
qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_T=NULL;
|
||||
if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_T)_FUNC_SYMBOL2FULLTYPENAME_STRING_T=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4077=NULL;
|
||||
if (!byte_element_4077){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4077=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4077=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4065=NULL;
|
||||
if (!byte_element_4065){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4065=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4065=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_N=NULL;
|
||||
if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_N)_FUNC_SYMBOL2FULLTYPENAME_STRING_N=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4078=NULL;
|
||||
if (!byte_element_4078){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4078=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4078=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4066=NULL;
|
||||
if (!byte_element_4066){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4066=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4066=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4079=NULL;
|
||||
if (!byte_element_4079){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4079=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4079=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4067=NULL;
|
||||
if (!byte_element_4067){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4067=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4067=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_SYMBOL2FULLTYPENAME_LONG_I=NULL;
|
||||
if(_FUNC_SYMBOL2FULLTYPENAME_LONG_I==NULL){
|
||||
_FUNC_SYMBOL2FULLTYPENAME_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_SYMBOL2FULLTYPENAME_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value4081;
|
||||
int64 fornext_finalvalue4081;
|
||||
int64 fornext_step4081;
|
||||
uint8 fornext_step_negative4081;
|
||||
byte_element_struct *byte_element_4082=NULL;
|
||||
if (!byte_element_4082){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4082=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4082=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value4069;
|
||||
int64 fornext_finalvalue4069;
|
||||
int64 fornext_step4069;
|
||||
uint8 fornext_step_negative4069;
|
||||
byte_element_struct *byte_element_4070=NULL;
|
||||
if (!byte_element_4070){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4070=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4070=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -3,19 +3,19 @@ if(_FUNC_SYMBOLTYPE_LONG_SYMBOLTYPE==NULL){
|
|||
_FUNC_SYMBOLTYPE_LONG_SYMBOLTYPE=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_SYMBOLTYPE_LONG_SYMBOLTYPE=0;
|
||||
}
|
||||
qbs*oldstr4083=NULL;
|
||||
qbs*oldstr4071=NULL;
|
||||
if(_FUNC_SYMBOLTYPE_STRING_S->tmp||_FUNC_SYMBOLTYPE_STRING_S->fixed||_FUNC_SYMBOLTYPE_STRING_S->readonly){
|
||||
oldstr4083=_FUNC_SYMBOLTYPE_STRING_S;
|
||||
if (oldstr4083->cmem_descriptor){
|
||||
_FUNC_SYMBOLTYPE_STRING_S=qbs_new_cmem(oldstr4083->len,0);
|
||||
oldstr4071=_FUNC_SYMBOLTYPE_STRING_S;
|
||||
if (oldstr4071->cmem_descriptor){
|
||||
_FUNC_SYMBOLTYPE_STRING_S=qbs_new_cmem(oldstr4071->len,0);
|
||||
}else{
|
||||
_FUNC_SYMBOLTYPE_STRING_S=qbs_new(oldstr4083->len,0);
|
||||
_FUNC_SYMBOLTYPE_STRING_S=qbs_new(oldstr4071->len,0);
|
||||
}
|
||||
memcpy(_FUNC_SYMBOLTYPE_STRING_S->chr,oldstr4083->chr,oldstr4083->len);
|
||||
memcpy(_FUNC_SYMBOLTYPE_STRING_S->chr,oldstr4071->chr,oldstr4071->len);
|
||||
}
|
||||
byte_element_struct *byte_element_4084=NULL;
|
||||
if (!byte_element_4084){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4084=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4084=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4072=NULL;
|
||||
if (!byte_element_4072){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4072=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4072=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_SYMBOLTYPE_LONG_A=NULL;
|
||||
if(_FUNC_SYMBOLTYPE_LONG_A==NULL){
|
||||
|
@ -27,9 +27,9 @@ if(_FUNC_SYMBOLTYPE_LONG_L==NULL){
|
|||
_FUNC_SYMBOLTYPE_LONG_L=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_SYMBOLTYPE_LONG_L=0;
|
||||
}
|
||||
byte_element_struct *byte_element_4085=NULL;
|
||||
if (!byte_element_4085){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4085=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4085=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4073=NULL;
|
||||
if (!byte_element_4073){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4073=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4073=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_SYMBOLTYPE_LONG_N=NULL;
|
||||
if(_FUNC_SYMBOLTYPE_LONG_N==NULL){
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_TYP2CTYP_STRING_TYP2CTYP=NULL;
|
||||
if (!_FUNC_TYP2CTYP_STRING_TYP2CTYP)_FUNC_TYP2CTYP_STRING_TYP2CTYP=qbs_new(0,0);
|
||||
qbs*oldstr4086=NULL;
|
||||
qbs*oldstr4074=NULL;
|
||||
if(_FUNC_TYP2CTYP_STRING_TSTR->tmp||_FUNC_TYP2CTYP_STRING_TSTR->fixed||_FUNC_TYP2CTYP_STRING_TSTR->readonly){
|
||||
oldstr4086=_FUNC_TYP2CTYP_STRING_TSTR;
|
||||
if (oldstr4086->cmem_descriptor){
|
||||
_FUNC_TYP2CTYP_STRING_TSTR=qbs_new_cmem(oldstr4086->len,0);
|
||||
oldstr4074=_FUNC_TYP2CTYP_STRING_TSTR;
|
||||
if (oldstr4074->cmem_descriptor){
|
||||
_FUNC_TYP2CTYP_STRING_TSTR=qbs_new_cmem(oldstr4074->len,0);
|
||||
}else{
|
||||
_FUNC_TYP2CTYP_STRING_TSTR=qbs_new(oldstr4086->len,0);
|
||||
_FUNC_TYP2CTYP_STRING_TSTR=qbs_new(oldstr4074->len,0);
|
||||
}
|
||||
memcpy(_FUNC_TYP2CTYP_STRING_TSTR->chr,oldstr4086->chr,oldstr4086->len);
|
||||
memcpy(_FUNC_TYP2CTYP_STRING_TSTR->chr,oldstr4074->chr,oldstr4074->len);
|
||||
}
|
||||
qbs *_FUNC_TYP2CTYP_STRING_CTYP=NULL;
|
||||
if (!_FUNC_TYP2CTYP_STRING_CTYP)_FUNC_TYP2CTYP_STRING_CTYP=qbs_new(0,0);
|
||||
|
@ -24,20 +24,20 @@ if(_FUNC_TYP2CTYP_LONG_UNSGN==NULL){
|
|||
_FUNC_TYP2CTYP_LONG_UNSGN=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_TYP2CTYP_LONG_UNSGN=0;
|
||||
}
|
||||
byte_element_struct *byte_element_4087=NULL;
|
||||
if (!byte_element_4087){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4087=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4087=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4075=NULL;
|
||||
if (!byte_element_4075){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4075=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4075=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_TYP2CTYP_STRING_N=NULL;
|
||||
if (!_FUNC_TYP2CTYP_STRING_N)_FUNC_TYP2CTYP_STRING_N=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4088=NULL;
|
||||
if (!byte_element_4088){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4088=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4088=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4076=NULL;
|
||||
if (!byte_element_4076){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4076=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4076=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_TYP2CTYP_STRING_S=NULL;
|
||||
if (!_FUNC_TYP2CTYP_STRING_S)_FUNC_TYP2CTYP_STRING_S=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4089=NULL;
|
||||
if (!byte_element_4089){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4089=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4089=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4077=NULL;
|
||||
if (!byte_element_4077){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4077=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4077=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 pass4090;
|
||||
int32 pass4078;
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_TYPE2SYMBOL_STRING_TYPE2SYMBOL=NULL;
|
||||
if (!_FUNC_TYPE2SYMBOL_STRING_TYPE2SYMBOL)_FUNC_TYPE2SYMBOL_STRING_TYPE2SYMBOL=qbs_new(0,0);
|
||||
qbs*oldstr4091=NULL;
|
||||
qbs*oldstr4079=NULL;
|
||||
if(_FUNC_TYPE2SYMBOL_STRING_TYP->tmp||_FUNC_TYPE2SYMBOL_STRING_TYP->fixed||_FUNC_TYPE2SYMBOL_STRING_TYP->readonly){
|
||||
oldstr4091=_FUNC_TYPE2SYMBOL_STRING_TYP;
|
||||
if (oldstr4091->cmem_descriptor){
|
||||
_FUNC_TYPE2SYMBOL_STRING_TYP=qbs_new_cmem(oldstr4091->len,0);
|
||||
oldstr4079=_FUNC_TYPE2SYMBOL_STRING_TYP;
|
||||
if (oldstr4079->cmem_descriptor){
|
||||
_FUNC_TYPE2SYMBOL_STRING_TYP=qbs_new_cmem(oldstr4079->len,0);
|
||||
}else{
|
||||
_FUNC_TYPE2SYMBOL_STRING_TYP=qbs_new(oldstr4091->len,0);
|
||||
_FUNC_TYPE2SYMBOL_STRING_TYP=qbs_new(oldstr4079->len,0);
|
||||
}
|
||||
memcpy(_FUNC_TYPE2SYMBOL_STRING_TYP->chr,oldstr4091->chr,oldstr4091->len);
|
||||
memcpy(_FUNC_TYPE2SYMBOL_STRING_TYP->chr,oldstr4079->chr,oldstr4079->len);
|
||||
}
|
||||
qbs *_FUNC_TYPE2SYMBOL_STRING_T=NULL;
|
||||
if (!_FUNC_TYPE2SYMBOL_STRING_T)_FUNC_TYPE2SYMBOL_STRING_T=qbs_new(0,0);
|
||||
|
@ -17,13 +17,13 @@ if(_FUNC_TYPE2SYMBOL_LONG_I==NULL){
|
|||
_FUNC_TYPE2SYMBOL_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_TYPE2SYMBOL_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value4093;
|
||||
int64 fornext_finalvalue4093;
|
||||
int64 fornext_step4093;
|
||||
uint8 fornext_step_negative4093;
|
||||
byte_element_struct *byte_element_4094=NULL;
|
||||
if (!byte_element_4094){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4094=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4094=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value4081;
|
||||
int64 fornext_finalvalue4081;
|
||||
int64 fornext_step4081;
|
||||
uint8 fornext_step_negative4081;
|
||||
byte_element_struct *byte_element_4082=NULL;
|
||||
if (!byte_element_4082){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4082=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4082=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
qbs *_FUNC_TYPE2SYMBOL_STRING_E=NULL;
|
||||
if (!_FUNC_TYPE2SYMBOL_STRING_E)_FUNC_TYPE2SYMBOL_STRING_E=qbs_new(0,0);
|
||||
|
@ -31,60 +31,60 @@ qbs *_FUNC_TYPE2SYMBOL_STRING_T2=NULL;
|
|||
if (!_FUNC_TYPE2SYMBOL_STRING_T2)_FUNC_TYPE2SYMBOL_STRING_T2=qbs_new(0,0);
|
||||
qbs *_FUNC_TYPE2SYMBOL_STRING_S=NULL;
|
||||
if (!_FUNC_TYPE2SYMBOL_STRING_S)_FUNC_TYPE2SYMBOL_STRING_S=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4095=NULL;
|
||||
if (!byte_element_4095){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4095=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4095=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4083=NULL;
|
||||
if (!byte_element_4083){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4083=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4083=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4096=NULL;
|
||||
if (!byte_element_4096){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4096=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4096=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4084=NULL;
|
||||
if (!byte_element_4084){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4084=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4084=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4097=NULL;
|
||||
if (!byte_element_4097){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4097=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4097=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4085=NULL;
|
||||
if (!byte_element_4085){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4085=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4085=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4098=NULL;
|
||||
if (!byte_element_4098){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4098=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4098=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4086=NULL;
|
||||
if (!byte_element_4086){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4086=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4086=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4099=NULL;
|
||||
if (!byte_element_4099){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4099=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4099=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4087=NULL;
|
||||
if (!byte_element_4087){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4087=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4087=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4100=NULL;
|
||||
if (!byte_element_4100){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4100=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4100=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4088=NULL;
|
||||
if (!byte_element_4088){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4088=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4088=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4101=NULL;
|
||||
if (!byte_element_4101){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4101=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4101=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4089=NULL;
|
||||
if (!byte_element_4089){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4089=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4089=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4102=NULL;
|
||||
if (!byte_element_4102){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4102=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4102=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4090=NULL;
|
||||
if (!byte_element_4090){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4090=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4090=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4103=NULL;
|
||||
if (!byte_element_4103){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4103=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4103=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4091=NULL;
|
||||
if (!byte_element_4091){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4091=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4091=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4104=NULL;
|
||||
if (!byte_element_4104){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4104=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4104=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4092=NULL;
|
||||
if (!byte_element_4092){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4092=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4092=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4105=NULL;
|
||||
if (!byte_element_4105){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4105=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4105=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4093=NULL;
|
||||
if (!byte_element_4093){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4093=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4093=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4106=NULL;
|
||||
if (!byte_element_4106){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4106=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4106=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4094=NULL;
|
||||
if (!byte_element_4094){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4094=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4094=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_TYPE2SYMBOL_LONG_V=NULL;
|
||||
if(_FUNC_TYPE2SYMBOL_LONG_V==NULL){
|
||||
_FUNC_TYPE2SYMBOL_LONG_V=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_TYPE2SYMBOL_LONG_V=0;
|
||||
}
|
||||
byte_element_struct *byte_element_4107=NULL;
|
||||
if (!byte_element_4107){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4107=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4107=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4095=NULL;
|
||||
if (!byte_element_4095){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4095=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4095=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -3,15 +3,15 @@ if(_FUNC_TYPNAME2TYP_LONG_TYPNAME2TYP==NULL){
|
|||
_FUNC_TYPNAME2TYP_LONG_TYPNAME2TYP=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_TYPNAME2TYP_LONG_TYPNAME2TYP=0;
|
||||
}
|
||||
qbs*oldstr4108=NULL;
|
||||
qbs*oldstr4096=NULL;
|
||||
if(_FUNC_TYPNAME2TYP_STRING_T2->tmp||_FUNC_TYPNAME2TYP_STRING_T2->fixed||_FUNC_TYPNAME2TYP_STRING_T2->readonly){
|
||||
oldstr4108=_FUNC_TYPNAME2TYP_STRING_T2;
|
||||
if (oldstr4108->cmem_descriptor){
|
||||
_FUNC_TYPNAME2TYP_STRING_T2=qbs_new_cmem(oldstr4108->len,0);
|
||||
oldstr4096=_FUNC_TYPNAME2TYP_STRING_T2;
|
||||
if (oldstr4096->cmem_descriptor){
|
||||
_FUNC_TYPNAME2TYP_STRING_T2=qbs_new_cmem(oldstr4096->len,0);
|
||||
}else{
|
||||
_FUNC_TYPNAME2TYP_STRING_T2=qbs_new(oldstr4108->len,0);
|
||||
_FUNC_TYPNAME2TYP_STRING_T2=qbs_new(oldstr4096->len,0);
|
||||
}
|
||||
memcpy(_FUNC_TYPNAME2TYP_STRING_T2->chr,oldstr4108->chr,oldstr4108->len);
|
||||
memcpy(_FUNC_TYPNAME2TYP_STRING_T2->chr,oldstr4096->chr,oldstr4096->len);
|
||||
}
|
||||
qbs *_FUNC_TYPNAME2TYP_STRING_T=NULL;
|
||||
if (!_FUNC_TYPNAME2TYP_STRING_T)_FUNC_TYPNAME2TYP_STRING_T=qbs_new(0,0);
|
||||
|
@ -19,9 +19,9 @@ qbs *_FUNC_TYPNAME2TYP_STRING_TS=NULL;
|
|||
if (!_FUNC_TYPNAME2TYP_STRING_TS)_FUNC_TYPNAME2TYP_STRING_TS=qbs_new(0,0);
|
||||
qbs *_FUNC_TYPNAME2TYP_STRING_N=NULL;
|
||||
if (!_FUNC_TYPNAME2TYP_STRING_N)_FUNC_TYPNAME2TYP_STRING_N=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4109=NULL;
|
||||
if (!byte_element_4109){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4109=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4109=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4097=NULL;
|
||||
if (!byte_element_4097){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4097=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4097=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_TYPNAME2TYP_LONG_B=NULL;
|
||||
if(_FUNC_TYPNAME2TYP_LONG_B==NULL){
|
||||
|
@ -33,13 +33,13 @@ if(_FUNC_TYPNAME2TYP_LONG_UNSGN==NULL){
|
|||
_FUNC_TYPNAME2TYP_LONG_UNSGN=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_TYPNAME2TYP_LONG_UNSGN=0;
|
||||
}
|
||||
byte_element_struct *byte_element_4110=NULL;
|
||||
if (!byte_element_4110){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4110=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4110=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4098=NULL;
|
||||
if (!byte_element_4098){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4098=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4098=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4111=NULL;
|
||||
if (!byte_element_4111){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4111=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4111=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4099=NULL;
|
||||
if (!byte_element_4099){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4099=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4099=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_TYPNAME2TYP_LONG_T=NULL;
|
||||
if(_FUNC_TYPNAME2TYP_LONG_T==NULL){
|
||||
|
@ -51,17 +51,17 @@ if(_FUNC_TYPNAME2TYP_LONG_I==NULL){
|
|||
_FUNC_TYPNAME2TYP_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_TYPNAME2TYP_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value4113;
|
||||
int64 fornext_finalvalue4113;
|
||||
int64 fornext_step4113;
|
||||
uint8 fornext_step_negative4113;
|
||||
byte_element_struct *byte_element_4114=NULL;
|
||||
if (!byte_element_4114){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4114=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4114=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value4101;
|
||||
int64 fornext_finalvalue4101;
|
||||
int64 fornext_step4101;
|
||||
uint8 fornext_step_negative4101;
|
||||
byte_element_struct *byte_element_4102=NULL;
|
||||
if (!byte_element_4102){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4102=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4102=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4115=NULL;
|
||||
if (!byte_element_4115){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4115=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4115=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4103=NULL;
|
||||
if (!byte_element_4103){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4103=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4103=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_TYPNAME2TYP_LONG_HASHFOUND=NULL;
|
||||
if(_FUNC_TYPNAME2TYP_LONG_HASHFOUND==NULL){
|
||||
|
@ -110,28 +110,28 @@ if(_FUNC_TYPNAME2TYP_UINTEGER64_V==NULL){
|
|||
_FUNC_TYPNAME2TYP_UINTEGER64_V=(uint64*)mem_static_malloc(8);
|
||||
*_FUNC_TYPNAME2TYP_UINTEGER64_V=0;
|
||||
}
|
||||
byte_element_struct *byte_element_4117=NULL;
|
||||
if (!byte_element_4117){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4117=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4117=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4105=NULL;
|
||||
if (!byte_element_4105){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4105=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4105=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4118=NULL;
|
||||
if (!byte_element_4118){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4118=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4118=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4106=NULL;
|
||||
if (!byte_element_4106){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4106=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4106=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_TYPNAME2TYP_LONG_U=NULL;
|
||||
if(_FUNC_TYPNAME2TYP_LONG_U==NULL){
|
||||
_FUNC_TYPNAME2TYP_LONG_U=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_TYPNAME2TYP_LONG_U=0;
|
||||
}
|
||||
byte_element_struct *byte_element_4119=NULL;
|
||||
if (!byte_element_4119){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4119=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4119=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4107=NULL;
|
||||
if (!byte_element_4107){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4107=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4107=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4120=NULL;
|
||||
if (!byte_element_4120){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4120=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4120=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4108=NULL;
|
||||
if (!byte_element_4108){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4108=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4108=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int64 fornext_value4122;
|
||||
int64 fornext_finalvalue4122;
|
||||
int64 fornext_step4122;
|
||||
uint8 fornext_step_negative4122;
|
||||
int64 fornext_value4110;
|
||||
int64 fornext_finalvalue4110;
|
||||
int64 fornext_step4110;
|
||||
uint8 fornext_step_negative4110;
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_REMOVESYMBOL_STRING_REMOVESYMBOL=NULL;
|
||||
if (!_FUNC_REMOVESYMBOL_STRING_REMOVESYMBOL)_FUNC_REMOVESYMBOL_STRING_REMOVESYMBOL=qbs_new(0,0);
|
||||
qbs*oldstr4123=NULL;
|
||||
qbs*oldstr4111=NULL;
|
||||
if(_FUNC_REMOVESYMBOL_STRING_VARNAME->tmp||_FUNC_REMOVESYMBOL_STRING_VARNAME->fixed||_FUNC_REMOVESYMBOL_STRING_VARNAME->readonly){
|
||||
oldstr4123=_FUNC_REMOVESYMBOL_STRING_VARNAME;
|
||||
if (oldstr4123->cmem_descriptor){
|
||||
_FUNC_REMOVESYMBOL_STRING_VARNAME=qbs_new_cmem(oldstr4123->len,0);
|
||||
oldstr4111=_FUNC_REMOVESYMBOL_STRING_VARNAME;
|
||||
if (oldstr4111->cmem_descriptor){
|
||||
_FUNC_REMOVESYMBOL_STRING_VARNAME=qbs_new_cmem(oldstr4111->len,0);
|
||||
}else{
|
||||
_FUNC_REMOVESYMBOL_STRING_VARNAME=qbs_new(oldstr4123->len,0);
|
||||
_FUNC_REMOVESYMBOL_STRING_VARNAME=qbs_new(oldstr4111->len,0);
|
||||
}
|
||||
memcpy(_FUNC_REMOVESYMBOL_STRING_VARNAME->chr,oldstr4123->chr,oldstr4123->len);
|
||||
memcpy(_FUNC_REMOVESYMBOL_STRING_VARNAME->chr,oldstr4111->chr,oldstr4111->len);
|
||||
}
|
||||
int32 *_FUNC_REMOVESYMBOL_LONG_I=NULL;
|
||||
if(_FUNC_REMOVESYMBOL_LONG_I==NULL){
|
||||
|
@ -17,7 +17,7 @@ _FUNC_REMOVESYMBOL_LONG_I=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_REMOVESYMBOL_STRING_SYMBOL=NULL;
|
||||
if (!_FUNC_REMOVESYMBOL_STRING_SYMBOL)_FUNC_REMOVESYMBOL_STRING_SYMBOL=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4124=NULL;
|
||||
if (!byte_element_4124){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4124=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4124=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4112=NULL;
|
||||
if (!byte_element_4112){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4112=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4112=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,14 +1,14 @@
|
|||
qbs *_FUNC_TRYREMOVESYMBOL_STRING_TRYREMOVESYMBOL=NULL;
|
||||
if (!_FUNC_TRYREMOVESYMBOL_STRING_TRYREMOVESYMBOL)_FUNC_TRYREMOVESYMBOL_STRING_TRYREMOVESYMBOL=qbs_new(0,0);
|
||||
qbs*oldstr4125=NULL;
|
||||
qbs*oldstr4113=NULL;
|
||||
if(_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->tmp||_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->fixed||_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->readonly){
|
||||
oldstr4125=_FUNC_TRYREMOVESYMBOL_STRING_VARNAME;
|
||||
if (oldstr4125->cmem_descriptor){
|
||||
_FUNC_TRYREMOVESYMBOL_STRING_VARNAME=qbs_new_cmem(oldstr4125->len,0);
|
||||
oldstr4113=_FUNC_TRYREMOVESYMBOL_STRING_VARNAME;
|
||||
if (oldstr4113->cmem_descriptor){
|
||||
_FUNC_TRYREMOVESYMBOL_STRING_VARNAME=qbs_new_cmem(oldstr4113->len,0);
|
||||
}else{
|
||||
_FUNC_TRYREMOVESYMBOL_STRING_VARNAME=qbs_new(oldstr4125->len,0);
|
||||
_FUNC_TRYREMOVESYMBOL_STRING_VARNAME=qbs_new(oldstr4113->len,0);
|
||||
}
|
||||
memcpy(_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->chr,oldstr4125->chr,oldstr4125->len);
|
||||
memcpy(_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->chr,oldstr4113->chr,oldstr4113->len);
|
||||
}
|
||||
int32 *_FUNC_TRYREMOVESYMBOL_LONG_I=NULL;
|
||||
if(_FUNC_TRYREMOVESYMBOL_LONG_I==NULL){
|
||||
|
@ -17,7 +17,7 @@ _FUNC_TRYREMOVESYMBOL_LONG_I=(int32*)mem_static_malloc(4);
|
|||
}
|
||||
qbs *_FUNC_TRYREMOVESYMBOL_STRING_SYMBOL=NULL;
|
||||
if (!_FUNC_TRYREMOVESYMBOL_STRING_SYMBOL)_FUNC_TRYREMOVESYMBOL_STRING_SYMBOL=qbs_new(0,0);
|
||||
byte_element_struct *byte_element_4126=NULL;
|
||||
if (!byte_element_4126){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4126=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4126=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4114=NULL;
|
||||
if (!byte_element_4114){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4114=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4114=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs *_FUNC_INVALIDSETTINGERROR_STRING_INVALIDSETTINGERROR=NULL;
|
||||
if (!_FUNC_INVALIDSETTINGERROR_STRING_INVALIDSETTINGERROR)_FUNC_INVALIDSETTINGERROR_STRING_INVALIDSETTINGERROR=qbs_new(0,0);
|
||||
qbs*oldstr2241=NULL;
|
||||
qbs*oldstr2229=NULL;
|
||||
if(_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->tmp||_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->fixed||_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->readonly){
|
||||
oldstr2241=_FUNC_INVALIDSETTINGERROR_STRING_TOKEN;
|
||||
if (oldstr2241->cmem_descriptor){
|
||||
_FUNC_INVALIDSETTINGERROR_STRING_TOKEN=qbs_new_cmem(oldstr2241->len,0);
|
||||
oldstr2229=_FUNC_INVALIDSETTINGERROR_STRING_TOKEN;
|
||||
if (oldstr2229->cmem_descriptor){
|
||||
_FUNC_INVALIDSETTINGERROR_STRING_TOKEN=qbs_new_cmem(oldstr2229->len,0);
|
||||
}else{
|
||||
_FUNC_INVALIDSETTINGERROR_STRING_TOKEN=qbs_new(oldstr2241->len,0);
|
||||
_FUNC_INVALIDSETTINGERROR_STRING_TOKEN=qbs_new(oldstr2229->len,0);
|
||||
}
|
||||
memcpy(_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->chr,oldstr2241->chr,oldstr2241->len);
|
||||
memcpy(_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->chr,oldstr2229->chr,oldstr2229->len);
|
||||
}
|
||||
|
|
|
@ -29,8 +29,8 @@ if(_FUNC_VARIABLESIZE_LONG_I2==NULL){
|
|||
_FUNC_VARIABLESIZE_LONG_I2=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_VARIABLESIZE_LONG_I2=0;
|
||||
}
|
||||
int64 fornext_value2758;
|
||||
int64 fornext_finalvalue2758;
|
||||
int64 fornext_step2758;
|
||||
uint8 fornext_step_negative2758;
|
||||
int32 pass2759;
|
||||
int64 fornext_value2746;
|
||||
int64 fornext_finalvalue2746;
|
||||
int64 fornext_step2746;
|
||||
uint8 fornext_step_negative2746;
|
||||
int32 pass2747;
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr4127=NULL;
|
||||
qbs*oldstr4115=NULL;
|
||||
if(_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->tmp||_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->fixed||_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->readonly){
|
||||
oldstr4127=_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N;
|
||||
if (oldstr4127->cmem_descriptor){
|
||||
_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4127->len,0);
|
||||
oldstr4115=_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N;
|
||||
if (oldstr4115->cmem_descriptor){
|
||||
_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4115->len,0);
|
||||
}else{
|
||||
_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4127->len,0);
|
||||
_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4115->len,0);
|
||||
}
|
||||
memcpy(_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->chr,oldstr4127->chr,oldstr4127->len);
|
||||
memcpy(_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->chr,oldstr4115->chr,oldstr4115->len);
|
||||
}
|
||||
int32 *_SUB_INITIALISE_UDT_VARSTRINGS_LONG_ELEMENT=NULL;
|
||||
if(_SUB_INITIALISE_UDT_VARSTRINGS_LONG_ELEMENT==NULL){
|
||||
|
@ -18,5 +18,5 @@ if(_SUB_INITIALISE_UDT_VARSTRINGS_LONG_OFFSET==NULL){
|
|||
_SUB_INITIALISE_UDT_VARSTRINGS_LONG_OFFSET=(int32*)mem_static_malloc(4);
|
||||
*_SUB_INITIALISE_UDT_VARSTRINGS_LONG_OFFSET=0;
|
||||
}
|
||||
int16 pass4129;
|
||||
int32 pass4130;
|
||||
int16 pass4117;
|
||||
int32 pass4118;
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr4131=NULL;
|
||||
qbs*oldstr4119=NULL;
|
||||
if(_SUB_FREE_UDT_VARSTRINGS_STRING_N->tmp||_SUB_FREE_UDT_VARSTRINGS_STRING_N->fixed||_SUB_FREE_UDT_VARSTRINGS_STRING_N->readonly){
|
||||
oldstr4131=_SUB_FREE_UDT_VARSTRINGS_STRING_N;
|
||||
if (oldstr4131->cmem_descriptor){
|
||||
_SUB_FREE_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4131->len,0);
|
||||
oldstr4119=_SUB_FREE_UDT_VARSTRINGS_STRING_N;
|
||||
if (oldstr4119->cmem_descriptor){
|
||||
_SUB_FREE_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4119->len,0);
|
||||
}else{
|
||||
_SUB_FREE_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4131->len,0);
|
||||
_SUB_FREE_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4119->len,0);
|
||||
}
|
||||
memcpy(_SUB_FREE_UDT_VARSTRINGS_STRING_N->chr,oldstr4131->chr,oldstr4131->len);
|
||||
memcpy(_SUB_FREE_UDT_VARSTRINGS_STRING_N->chr,oldstr4119->chr,oldstr4119->len);
|
||||
}
|
||||
int32 *_SUB_FREE_UDT_VARSTRINGS_LONG_ELEMENT=NULL;
|
||||
if(_SUB_FREE_UDT_VARSTRINGS_LONG_ELEMENT==NULL){
|
||||
|
@ -18,5 +18,5 @@ if(_SUB_FREE_UDT_VARSTRINGS_LONG_OFFSET==NULL){
|
|||
_SUB_FREE_UDT_VARSTRINGS_LONG_OFFSET=(int32*)mem_static_malloc(4);
|
||||
*_SUB_FREE_UDT_VARSTRINGS_LONG_OFFSET=0;
|
||||
}
|
||||
int16 pass4133;
|
||||
int32 pass4134;
|
||||
int16 pass4121;
|
||||
int32 pass4122;
|
||||
|
|
|
@ -1,12 +1,12 @@
|
|||
qbs*oldstr4135=NULL;
|
||||
qbs*oldstr4123=NULL;
|
||||
if(_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->tmp||_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->fixed||_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->readonly){
|
||||
oldstr4135=_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N;
|
||||
if (oldstr4135->cmem_descriptor){
|
||||
_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4135->len,0);
|
||||
oldstr4123=_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N;
|
||||
if (oldstr4123->cmem_descriptor){
|
||||
_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4123->len,0);
|
||||
}else{
|
||||
_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N=qbs_new(oldstr4135->len,0);
|
||||
_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N=qbs_new(oldstr4123->len,0);
|
||||
}
|
||||
memcpy(_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->chr,oldstr4135->chr,oldstr4135->len);
|
||||
memcpy(_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->chr,oldstr4123->chr,oldstr4123->len);
|
||||
}
|
||||
int32 *_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_ELEMENT=NULL;
|
||||
if(_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_ELEMENT==NULL){
|
||||
|
@ -18,8 +18,8 @@ if(_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_OFFSET==NULL){
|
|||
_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_OFFSET=(int32*)mem_static_malloc(4);
|
||||
*_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_OFFSET=0;
|
||||
}
|
||||
int16 pass4137;
|
||||
int16 pass4138;
|
||||
int32 pass4139;
|
||||
int32 pass4140;
|
||||
int16 pass4141;
|
||||
int16 pass4125;
|
||||
int16 pass4126;
|
||||
int32 pass4127;
|
||||
int32 pass4128;
|
||||
int16 pass4129;
|
||||
|
|
|
@ -1,32 +1,32 @@
|
|||
qbs*oldstr4142=NULL;
|
||||
qbs*oldstr4130=NULL;
|
||||
if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->tmp||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->fixed||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->readonly){
|
||||
oldstr4142=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N;
|
||||
if (oldstr4142->cmem_descriptor){
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4142->len,0);
|
||||
oldstr4130=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N;
|
||||
if (oldstr4130->cmem_descriptor){
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4130->len,0);
|
||||
}else{
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4142->len,0);
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4130->len,0);
|
||||
}
|
||||
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr4142->chr,oldstr4142->len);
|
||||
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr4130->chr,oldstr4130->len);
|
||||
}
|
||||
qbs*oldstr4143=NULL;
|
||||
qbs*oldstr4131=NULL;
|
||||
if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->tmp||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->fixed||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->readonly){
|
||||
oldstr4143=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
|
||||
if (oldstr4143->cmem_descriptor){
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr4143->len,0);
|
||||
oldstr4131=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
|
||||
if (oldstr4131->cmem_descriptor){
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr4131->len,0);
|
||||
}else{
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr4143->len,0);
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr4131->len,0);
|
||||
}
|
||||
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr4143->chr,oldstr4143->len);
|
||||
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr4131->chr,oldstr4131->len);
|
||||
}
|
||||
qbs*oldstr4144=NULL;
|
||||
qbs*oldstr4132=NULL;
|
||||
if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->tmp||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->fixed||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->readonly){
|
||||
oldstr4144=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
|
||||
if (oldstr4144->cmem_descriptor){
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr4144->len,0);
|
||||
oldstr4132=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
|
||||
if (oldstr4132->cmem_descriptor){
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr4132->len,0);
|
||||
}else{
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr4144->len,0);
|
||||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr4132->len,0);
|
||||
}
|
||||
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr4144->chr,oldstr4144->len);
|
||||
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr4132->chr,oldstr4132->len);
|
||||
}
|
||||
int32 *_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_OFFSET=NULL;
|
||||
if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_OFFSET==NULL){
|
||||
|
@ -38,4 +38,4 @@ if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT==NULL){
|
|||
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT=(int32*)mem_static_malloc(4);
|
||||
*_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT=0;
|
||||
}
|
||||
int32 pass4146;
|
||||
int32 pass4134;
|
||||
|
|
|
@ -1,32 +1,32 @@
|
|||
qbs*oldstr4147=NULL;
|
||||
qbs*oldstr4135=NULL;
|
||||
if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->tmp||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->fixed||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->readonly){
|
||||
oldstr4147=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N;
|
||||
if (oldstr4147->cmem_descriptor){
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4147->len,0);
|
||||
oldstr4135=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N;
|
||||
if (oldstr4135->cmem_descriptor){
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4135->len,0);
|
||||
}else{
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4147->len,0);
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4135->len,0);
|
||||
}
|
||||
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr4147->chr,oldstr4147->len);
|
||||
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr4135->chr,oldstr4135->len);
|
||||
}
|
||||
qbs*oldstr4148=NULL;
|
||||
qbs*oldstr4136=NULL;
|
||||
if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->tmp||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->fixed||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->readonly){
|
||||
oldstr4148=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
|
||||
if (oldstr4148->cmem_descriptor){
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr4148->len,0);
|
||||
oldstr4136=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
|
||||
if (oldstr4136->cmem_descriptor){
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr4136->len,0);
|
||||
}else{
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr4148->len,0);
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr4136->len,0);
|
||||
}
|
||||
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr4148->chr,oldstr4148->len);
|
||||
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr4136->chr,oldstr4136->len);
|
||||
}
|
||||
qbs*oldstr4149=NULL;
|
||||
qbs*oldstr4137=NULL;
|
||||
if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->tmp||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->fixed||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->readonly){
|
||||
oldstr4149=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
|
||||
if (oldstr4149->cmem_descriptor){
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr4149->len,0);
|
||||
oldstr4137=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
|
||||
if (oldstr4137->cmem_descriptor){
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr4137->len,0);
|
||||
}else{
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr4149->len,0);
|
||||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr4137->len,0);
|
||||
}
|
||||
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr4149->chr,oldstr4149->len);
|
||||
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr4137->chr,oldstr4137->len);
|
||||
}
|
||||
int32 *_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_OFFSET=NULL;
|
||||
if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_OFFSET==NULL){
|
||||
|
@ -38,4 +38,4 @@ if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT==NULL){
|
|||
_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT=(int32*)mem_static_malloc(4);
|
||||
*_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT=0;
|
||||
}
|
||||
int32 pass4151;
|
||||
int32 pass4139;
|
||||
|
|
|
@ -1,24 +1,24 @@
|
|||
qbs*oldstr4152=NULL;
|
||||
qbs*oldstr4140=NULL;
|
||||
if(_SUB_COPY_FULL_UDT_STRING_DST->tmp||_SUB_COPY_FULL_UDT_STRING_DST->fixed||_SUB_COPY_FULL_UDT_STRING_DST->readonly){
|
||||
oldstr4152=_SUB_COPY_FULL_UDT_STRING_DST;
|
||||
if (oldstr4152->cmem_descriptor){
|
||||
_SUB_COPY_FULL_UDT_STRING_DST=qbs_new_cmem(oldstr4152->len,0);
|
||||
oldstr4140=_SUB_COPY_FULL_UDT_STRING_DST;
|
||||
if (oldstr4140->cmem_descriptor){
|
||||
_SUB_COPY_FULL_UDT_STRING_DST=qbs_new_cmem(oldstr4140->len,0);
|
||||
}else{
|
||||
_SUB_COPY_FULL_UDT_STRING_DST=qbs_new(oldstr4152->len,0);
|
||||
_SUB_COPY_FULL_UDT_STRING_DST=qbs_new(oldstr4140->len,0);
|
||||
}
|
||||
memcpy(_SUB_COPY_FULL_UDT_STRING_DST->chr,oldstr4152->chr,oldstr4152->len);
|
||||
memcpy(_SUB_COPY_FULL_UDT_STRING_DST->chr,oldstr4140->chr,oldstr4140->len);
|
||||
}
|
||||
qbs*oldstr4153=NULL;
|
||||
qbs*oldstr4141=NULL;
|
||||
if(_SUB_COPY_FULL_UDT_STRING_SRC->tmp||_SUB_COPY_FULL_UDT_STRING_SRC->fixed||_SUB_COPY_FULL_UDT_STRING_SRC->readonly){
|
||||
oldstr4153=_SUB_COPY_FULL_UDT_STRING_SRC;
|
||||
if (oldstr4153->cmem_descriptor){
|
||||
_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new_cmem(oldstr4153->len,0);
|
||||
oldstr4141=_SUB_COPY_FULL_UDT_STRING_SRC;
|
||||
if (oldstr4141->cmem_descriptor){
|
||||
_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new_cmem(oldstr4141->len,0);
|
||||
}else{
|
||||
_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new(oldstr4153->len,0);
|
||||
_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new(oldstr4141->len,0);
|
||||
}
|
||||
memcpy(_SUB_COPY_FULL_UDT_STRING_SRC->chr,oldstr4153->chr,oldstr4153->len);
|
||||
memcpy(_SUB_COPY_FULL_UDT_STRING_SRC->chr,oldstr4141->chr,oldstr4141->len);
|
||||
}
|
||||
int16 pass4154;
|
||||
int16 pass4142;
|
||||
int32 *_SUB_COPY_FULL_UDT_LONG_OFFSET=NULL;
|
||||
if(_SUB_COPY_FULL_UDT_LONG_OFFSET==NULL){
|
||||
_SUB_COPY_FULL_UDT_LONG_OFFSET=(int32*)mem_static_malloc(4);
|
||||
|
@ -29,6 +29,6 @@ if(_SUB_COPY_FULL_UDT_LONG_ELEMENT==NULL){
|
|||
_SUB_COPY_FULL_UDT_LONG_ELEMENT=(int32*)mem_static_malloc(4);
|
||||
*_SUB_COPY_FULL_UDT_LONG_ELEMENT=0;
|
||||
}
|
||||
int16 pass4156;
|
||||
int32 pass4157;
|
||||
int16 pass4158;
|
||||
int16 pass4144;
|
||||
int32 pass4145;
|
||||
int16 pass4146;
|
||||
|
|
|
@ -8,11 +8,11 @@ if(_SUB_DUMP_UDTS_LONG_I==NULL){
|
|||
_SUB_DUMP_UDTS_LONG_I=(int32*)mem_static_malloc(4);
|
||||
*_SUB_DUMP_UDTS_LONG_I=0;
|
||||
}
|
||||
int64 fornext_value4161;
|
||||
int64 fornext_finalvalue4161;
|
||||
int64 fornext_step4161;
|
||||
uint8 fornext_step_negative4161;
|
||||
int64 fornext_value4165;
|
||||
int64 fornext_finalvalue4165;
|
||||
int64 fornext_step4165;
|
||||
uint8 fornext_step_negative4165;
|
||||
int64 fornext_value4149;
|
||||
int64 fornext_finalvalue4149;
|
||||
int64 fornext_step4149;
|
||||
uint8 fornext_step_negative4149;
|
||||
int64 fornext_value4153;
|
||||
int64 fornext_finalvalue4153;
|
||||
int64 fornext_step4153;
|
||||
uint8 fornext_step_negative4153;
|
||||
|
|
|
@ -3,36 +3,36 @@ if(_FUNC_ISUINTEGER_LONG_ISUINTEGER==NULL){
|
|||
_FUNC_ISUINTEGER_LONG_ISUINTEGER=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ISUINTEGER_LONG_ISUINTEGER=0;
|
||||
}
|
||||
qbs*oldstr4167=NULL;
|
||||
qbs*oldstr4155=NULL;
|
||||
if(_FUNC_ISUINTEGER_STRING_I->tmp||_FUNC_ISUINTEGER_STRING_I->fixed||_FUNC_ISUINTEGER_STRING_I->readonly){
|
||||
oldstr4167=_FUNC_ISUINTEGER_STRING_I;
|
||||
if (oldstr4167->cmem_descriptor){
|
||||
_FUNC_ISUINTEGER_STRING_I=qbs_new_cmem(oldstr4167->len,0);
|
||||
oldstr4155=_FUNC_ISUINTEGER_STRING_I;
|
||||
if (oldstr4155->cmem_descriptor){
|
||||
_FUNC_ISUINTEGER_STRING_I=qbs_new_cmem(oldstr4155->len,0);
|
||||
}else{
|
||||
_FUNC_ISUINTEGER_STRING_I=qbs_new(oldstr4167->len,0);
|
||||
_FUNC_ISUINTEGER_STRING_I=qbs_new(oldstr4155->len,0);
|
||||
}
|
||||
memcpy(_FUNC_ISUINTEGER_STRING_I->chr,oldstr4167->chr,oldstr4167->len);
|
||||
memcpy(_FUNC_ISUINTEGER_STRING_I->chr,oldstr4155->chr,oldstr4155->len);
|
||||
}
|
||||
byte_element_struct *byte_element_4168=NULL;
|
||||
if (!byte_element_4168){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4168=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4168=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4156=NULL;
|
||||
if (!byte_element_4156){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4156=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4156=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
byte_element_struct *byte_element_4169=NULL;
|
||||
if (!byte_element_4169){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4169=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4169=(byte_element_struct*)mem_static_malloc(12);
|
||||
byte_element_struct *byte_element_4157=NULL;
|
||||
if (!byte_element_4157){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4157=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4157=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_ISUINTEGER_LONG_C=NULL;
|
||||
if(_FUNC_ISUINTEGER_LONG_C==NULL){
|
||||
_FUNC_ISUINTEGER_LONG_C=(int32*)mem_static_malloc(4);
|
||||
*_FUNC_ISUINTEGER_LONG_C=0;
|
||||
}
|
||||
int64 fornext_value4171;
|
||||
int64 fornext_finalvalue4171;
|
||||
int64 fornext_step4171;
|
||||
uint8 fornext_step_negative4171;
|
||||
byte_element_struct *byte_element_4172=NULL;
|
||||
if (!byte_element_4172){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4172=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4172=(byte_element_struct*)mem_static_malloc(12);
|
||||
int64 fornext_value4159;
|
||||
int64 fornext_finalvalue4159;
|
||||
int64 fornext_step4159;
|
||||
uint8 fornext_step_negative4159;
|
||||
byte_element_struct *byte_element_4160=NULL;
|
||||
if (!byte_element_4160){
|
||||
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4160=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4160=(byte_element_struct*)mem_static_malloc(12);
|
||||
}
|
||||
int32 *_FUNC_ISUINTEGER_LONG_V=NULL;
|
||||
if(_FUNC_ISUINTEGER_LONG_V==NULL){
|
||||
|
|
|
@ -1,10 +1,10 @@
|
|||
qbs*oldstr4173=NULL;
|
||||
qbs*oldstr4161=NULL;
|
||||
if(_SUB_GIVE_ERROR_STRING_A->tmp||_SUB_GIVE_ERROR_STRING_A->fixed||_SUB_GIVE_ERROR_STRING_A->readonly){
|
||||
oldstr4173=_SUB_GIVE_ERROR_STRING_A;
|
||||
if (oldstr4173->cmem_descriptor){
|
||||
_SUB_GIVE_ERROR_STRING_A=qbs_new_cmem(oldstr4173->len,0);
|
||||
oldstr4161=_SUB_GIVE_ERROR_STRING_A;
|
||||
if (oldstr4161->cmem_descriptor){
|
||||
_SUB_GIVE_ERROR_STRING_A=qbs_new_cmem(oldstr4161->len,0);
|
||||
}else{
|
||||
_SUB_GIVE_ERROR_STRING_A=qbs_new(oldstr4173->len,0);
|
||||
_SUB_GIVE_ERROR_STRING_A=qbs_new(oldstr4161->len,0);
|
||||
}
|
||||
memcpy(_SUB_GIVE_ERROR_STRING_A->chr,oldstr4173->chr,oldstr4173->len);
|
||||
memcpy(_SUB_GIVE_ERROR_STRING_A->chr,oldstr4161->chr,oldstr4161->len);
|
||||
}
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue