2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_VERSION);
|
2021-02-07 10:32:23 +00:00
|
|
|
qbs_free(__STRING_DEVCHANNEL);
|
2016-11-09 13:23:49 +00:00
|
|
|
qbs_free(__STRING_AUTOBUILDMSG);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING1_SP);
|
|
|
|
qbs_free(__STRING1_SP2);
|
|
|
|
qbs_free(__STRING1_SP3);
|
|
|
|
qbs_free(__STRING_CHR_QUOTE);
|
|
|
|
qbs_free(__STRING_CHR_TAB);
|
|
|
|
qbs_free(__STRING_CRLF);
|
|
|
|
if (__ARRAY_UDT_GL_COMMANDS[2]&1){
|
|
|
|
if (__ARRAY_UDT_GL_COMMANDS[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_UDT_GL_COMMANDS[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_UDT_GL_COMMANDS[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_GL_COMMANDS)[8] );
|
|
|
|
qbs_free(__STRING_GL_HELPER_CODE);
|
|
|
|
if (__ARRAY_STRING_GL_DEFINES[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_GL_DEFINES[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_GL_DEFINES[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_GL_DEFINES[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_GL_DEFINES)[8] );
|
|
|
|
if (__ARRAY_INTEGER64_GL_DEFINES_VALUE[2]&1){
|
|
|
|
if (__ARRAY_INTEGER64_GL_DEFINES_VALUE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER64_GL_DEFINES_VALUE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER64_GL_DEFINES_VALUE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER64_GL_DEFINES_VALUE)[8] );
|
2021-02-08 14:42:20 +00:00
|
|
|
qbs_free(__STRING_CURRENTINIFILENAME);
|
|
|
|
qbs_free(__STRING_INIWHOLEFILE);
|
|
|
|
qbs_free(__STRING_INISECTIONDATA);
|
|
|
|
qbs_free(__STRING_ININEWFILE);
|
|
|
|
qbs_free(__STRING_INILASTSECTION);
|
|
|
|
qbs_free(__STRING_INILASTKEY);
|
|
|
|
qbs_free(__STRING_INILF);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_CACHE_FOLDER);
|
|
|
|
qbs_free(__STRING_HELP_TXT);
|
|
|
|
qbs_free(__STRING_HELP_LINE);
|
|
|
|
qbs_free(__STRING_HELP_LINK);
|
|
|
|
qbs_free(__STRING_HELP_LINK_SEP);
|
|
|
|
if (__ARRAY_LONG_HELP_LINELEN[2]&1){
|
|
|
|
if (__ARRAY_LONG_HELP_LINELEN[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_HELP_LINELEN[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_HELP_LINELEN[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_HELP_LINELEN)[8] );
|
|
|
|
if (__ARRAY_STRING_BACK[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_BACK[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_BACK[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_BACK[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_BACK)[8] );
|
|
|
|
if (__ARRAY_STRING_BACK_NAME[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_BACK_NAME[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_BACK_NAME[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_BACK_NAME[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_BACK_NAME)[8] );
|
|
|
|
if (__ARRAY_UDT_HELP_BACK[2]&1){
|
|
|
|
if (__ARRAY_UDT_HELP_BACK[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_UDT_HELP_BACK[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_UDT_HELP_BACK[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_HELP_BACK)[8] );
|
|
|
|
qbs_free(__STRING_HELP_SEARCH_STR);
|
|
|
|
qbs_free(__STRING_HELP_PAGELOADED);
|
|
|
|
qbs_free(__STRING_IDEINFO);
|
2021-07-19 21:21:56 +00:00
|
|
|
qbs_free(__STRING_HOSTPORT);
|
2021-07-29 21:43:08 +00:00
|
|
|
qbs_free(__STRING_VARIABLEWATCHLIST);
|
2021-10-02 07:24:31 +00:00
|
|
|
qbs_free(__STRING_BACKUPVARIABLEWATCHLIST);
|
2021-09-19 02:35:44 +00:00
|
|
|
qbs_free(__STRING_WATCHPOINTLIST);
|
2021-08-24 07:04:43 +00:00
|
|
|
if (__ARRAY_STRING_VWATCHRECEIVEDDATA[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_VWATCHRECEIVEDDATA[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_VWATCHRECEIVEDDATA[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_VWATCHRECEIVEDDATA[0]));
|
2021-08-17 13:00:16 +00:00
|
|
|
}
|
2021-08-24 07:04:43 +00:00
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_VWATCHRECEIVEDDATA)[8] );
|
2021-07-19 21:21:56 +00:00
|
|
|
qbs_free(__STRING_CALLSTACKLIST);
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_STRING_IDERECENTLINK[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_IDERECENTLINK[5]*__ARRAY_STRING_IDERECENTLINK[9];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_IDERECENTLINK[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_IDERECENTLINK[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_IDERECENTLINK)[12] );
|
|
|
|
qbs_free(__STRING_IDEOPENFILE);
|
2021-08-01 04:03:08 +00:00
|
|
|
qbs_free(__STRING_FILEDLGSEARCHTERM);
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_UDT_IDEBMK[2]&1){
|
|
|
|
if (__ARRAY_UDT_IDEBMK[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_UDT_IDEBMK[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_UDT_IDEBMK[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_IDEBMK)[8] );
|
2021-07-13 03:42:49 +00:00
|
|
|
if (__ARRAY_UDT_QUICKNAVHISTORY[2]&1){
|
|
|
|
if (__ARRAY_UDT_QUICKNAVHISTORY[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_UDT_QUICKNAVHISTORY[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_UDT_QUICKNAVHISTORY[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_QUICKNAVHISTORY)[8] );
|
2021-07-12 00:07:48 +00:00
|
|
|
if (__ARRAY_BYTE_IDEBREAKPOINTS[2]&1){
|
|
|
|
if (__ARRAY_BYTE_IDEBREAKPOINTS[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_BYTE_IDEBREAKPOINTS[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_BYTE_IDEBREAKPOINTS[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_BYTE_IDEBREAKPOINTS)[8] );
|
2021-07-21 21:30:49 +00:00
|
|
|
if (__ARRAY_BYTE_IDESKIPLINES[2]&1){
|
|
|
|
if (__ARRAY_BYTE_IDESKIPLINES[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_BYTE_IDESKIPLINES[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_BYTE_IDESKIPLINES[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_BYTE_IDESKIPLINES)[8] );
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_K);
|
|
|
|
if (__ARRAY_INTEGER_BLOCK_CHR[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_BLOCK_CHR[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_BLOCK_CHR[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_BLOCK_CHR[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_BLOCK_CHR)[8] );
|
|
|
|
if (__ARRAY_STRING_IDECPNAME[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_IDECPNAME[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_IDECPNAME[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_IDECPNAME[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_IDECPNAME)[8] );
|
|
|
|
if (__ARRAY_STRING_IDECP[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_IDECP[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_IDECP[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_IDECP[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_IDECP)[8] );
|
|
|
|
qbs_free(__STRING_IDECURRENTLINELAYOUT);
|
2017-10-02 12:11:10 +00:00
|
|
|
qbs_free(__STRING_LISTOFKEYWORDS);
|
2017-10-14 12:16:31 +00:00
|
|
|
qbs_free(__STRING_LISTOFCUSTOMKEYWORDS);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_IDET);
|
|
|
|
qbs_free(__STRING_IDECOMPILEDLINE);
|
2017-09-25 12:18:26 +00:00
|
|
|
qbs_free(__STRING_IDECURRENTSINGLELINESELECTION);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_IDEROOT);
|
|
|
|
if (__ARRAY_STRING_IDETXT[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_IDETXT[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_IDETXT[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_IDETXT[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_IDETXT)[8] );
|
|
|
|
qbs_free(__STRING_IDEPROGNAME);
|
|
|
|
qbs_free(__STRING_IDEPATH);
|
|
|
|
qbs_free(__STRING_IDEFINDTEXT);
|
|
|
|
qbs_free(__STRING_IDECHANGETO);
|
|
|
|
qbs_free(__STRING1_IDEPATHSEP);
|
2016-02-27 13:14:57 +00:00
|
|
|
if (__ARRAY_STRING_SUBFUNCLIST[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_SUBFUNCLIST[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_SUBFUNCLIST[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_SUBFUNCLIST[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_SUBFUNCLIST)[8] );
|
2016-04-15 12:14:31 +00:00
|
|
|
qbs_free(__STRING_MODIFYCOMMAND);
|
2017-05-15 12:17:16 +00:00
|
|
|
qbs_free(__STRING_ACTIVEINCLUDELINKFILE);
|
2021-01-18 21:32:35 +00:00
|
|
|
qbs_free(__STRING_VERSIONSTRINGSTATUS);
|
|
|
|
qbs_free(__STRING_LINENUMBERSTATUS);
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_STRING_MENU[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_MENU[5]*__ARRAY_STRING_MENU[9];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_MENU[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_MENU[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_MENU)[12] );
|
2021-02-06 08:28:35 +00:00
|
|
|
if (__ARRAY_STRING_MENUDESC[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_MENUDESC[5]*__ARRAY_STRING_MENUDESC[9];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_MENUDESC[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_MENUDESC[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_MENUDESC)[12] );
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_LONG_MENUSIZE[2]&1){
|
|
|
|
if (__ARRAY_LONG_MENUSIZE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_MENUSIZE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_MENUSIZE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_MENUSIZE)[8] );
|
2016-08-02 12:15:06 +00:00
|
|
|
if (__ARRAY_STRING_COLORSCHEMES[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_COLORSCHEMES[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_COLORSCHEMES[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_COLORSCHEMES[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_COLORSCHEMES)[8] );
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_MENUBAR);
|
2016-01-05 13:12:45 +00:00
|
|
|
qbs_free(__STRING_IDECONTEXTUALSEARCH);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_IDECUSTOMFONTFILE);
|
|
|
|
if (__ARRAY_STRING_ONAME[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_ONAME[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_ONAME[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_ONAME[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_ONAME)[8] );
|
|
|
|
if (__ARRAY_INTEGER_PL[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_PL[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_PL[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_PL[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_PL)[8] );
|
2020-01-15 03:17:45 +00:00
|
|
|
if (__ARRAY_STRING_PP_TYPEMOD[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_PP_TYPEMOD[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_PP_TYPEMOD[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_PP_TYPEMOD[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_PP_TYPEMOD)[8] );
|
|
|
|
if (__ARRAY_STRING_PP_CONVERTEDMOD[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_PP_CONVERTEDMOD[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_PP_CONVERTEDMOD[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_PP_CONVERTEDMOD[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_PP_CONVERTEDMOD)[8] );
|
2021-07-19 21:21:56 +00:00
|
|
|
qbs_free(__STRING_VWATCHERRORCALL);
|
2021-07-21 21:30:49 +00:00
|
|
|
qbs_free(__STRING_VWATCHNEWVARIABLE);
|
2021-07-22 06:14:26 +00:00
|
|
|
qbs_free(__STRING_VWATCHVARIABLEEXCLUSIONS);
|
2021-08-24 07:04:43 +00:00
|
|
|
qbs_free(__STRING_NATIVEDATATYPES);
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_LONG_EVERYCASESET[2]&1){
|
|
|
|
if (__ARRAY_LONG_EVERYCASESET[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_EVERYCASESET[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_EVERYCASESET[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_EVERYCASESET)[8] );
|
2020-12-18 04:39:45 +00:00
|
|
|
if (__ARRAY_LONG_SELECTCASEHASCASEBLOCK[2]&1){
|
|
|
|
if (__ARRAY_LONG_SELECTCASEHASCASEBLOCK[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_SELECTCASEHASCASEBLOCK[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_SELECTCASEHASCASEBLOCK[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_SELECTCASEHASCASEBLOCK)[8] );
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_LONG_EXECLEVEL[2]&1){
|
|
|
|
if (__ARRAY_LONG_EXECLEVEL[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_EXECLEVEL[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_EXECLEVEL[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_EXECLEVEL)[8] );
|
|
|
|
if (__ARRAY_STRING_USERDEFINE[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_USERDEFINE[5]*__ARRAY_STRING_USERDEFINE[9];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_USERDEFINE[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_USERDEFINE[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_USERDEFINE)[12] );
|
2020-01-19 14:29:08 +00:00
|
|
|
if (__ARRAY_BYTE_INVALIDLINE[2]&1){
|
|
|
|
if (__ARRAY_BYTE_INVALIDLINE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_BYTE_INVALIDLINE[0]));
|
2015-08-02 12:12:44 +00:00
|
|
|
}else{
|
2020-01-19 14:29:08 +00:00
|
|
|
free((void*)(__ARRAY_BYTE_INVALIDLINE[0]));
|
2015-08-02 12:12:44 +00:00
|
|
|
}
|
|
|
|
}
|
2020-01-19 14:29:08 +00:00
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_BYTE_INVALIDLINE)[8] );
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_BYTE_DEFINEELSE[2]&1){
|
|
|
|
if (__ARRAY_BYTE_DEFINEELSE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_BYTE_DEFINEELSE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_BYTE_DEFINEELSE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_BYTE_DEFINEELSE)[8] );
|
2021-02-18 18:10:07 +00:00
|
|
|
qbs_free(__STRING_USERDEFINELIST);
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_LONG_DEPENDENCY[2]&1){
|
|
|
|
if (__ARRAY_LONG_DEPENDENCY[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_DEPENDENCY[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_DEPENDENCY[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_DEPENDENCY)[8] );
|
2020-01-15 03:11:44 +00:00
|
|
|
qbs_free(__STRING_WINDOWTITLE);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_CMDLINEFILE);
|
2021-10-02 07:24:31 +00:00
|
|
|
if (__ARRAY_UDT_BACKUPUSEDVARIABLELIST[2]&1){
|
|
|
|
tmp_long=__ARRAY_UDT_BACKUPUSEDVARIABLELIST[5];
|
|
|
|
while(tmp_long--) {
|
|
|
|
|
2022-03-10 04:52:17 +00:00
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 32));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 40));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 48));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 56));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 64));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 72));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 80));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 88));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 96));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 104));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 112));}
|
2021-10-02 07:24:31 +00:00
|
|
|
free((void*)(__ARRAY_UDT_BACKUPUSEDVARIABLELIST[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_BACKUPUSEDVARIABLELIST)[8] );
|
|
|
|
qbs_free(__STRING_TYPEDEFINITIONS);
|
|
|
|
qbs_free(__STRING_BACKUPTYPEDEFINITIONS);
|
2019-03-31 23:29:05 +00:00
|
|
|
qbs_free(__STRING_LASTWARNINGHEADER);
|
2020-01-15 20:11:04 +00:00
|
|
|
qbs_free(__STRING_QB64PREFIX);
|
2017-04-29 12:15:43 +00:00
|
|
|
qbs_free(__STRING_VIFILEVERSIONNUM);
|
|
|
|
qbs_free(__STRING_VIPRODUCTVERSIONNUM);
|
|
|
|
qbs_free(__STRING_VICOMPANYNAME);
|
|
|
|
qbs_free(__STRING_VIFILEDESCRIPTION);
|
|
|
|
qbs_free(__STRING_VIFILEVERSION);
|
|
|
|
qbs_free(__STRING_VIINTERNALNAME);
|
|
|
|
qbs_free(__STRING_VILEGALCOPYRIGHT);
|
|
|
|
qbs_free(__STRING_VILEGALTRADEMARKS);
|
|
|
|
qbs_free(__STRING_VIORIGINALFILENAME);
|
|
|
|
qbs_free(__STRING_VIPRODUCTNAME);
|
|
|
|
qbs_free(__STRING_VIPRODUCTVERSION);
|
|
|
|
qbs_free(__STRING_VICOMMENTS);
|
2017-04-30 12:16:07 +00:00
|
|
|
qbs_free(__STRING_VIWEB);
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_STRING256_OPT[2]&1){
|
|
|
|
if (__ARRAY_STRING256_OPT[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_STRING256_OPT[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_STRING256_OPT[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING256_OPT)[12] );
|
|
|
|
if (__ARRAY_INTEGER_OPTWORDS[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_OPTWORDS[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_OPTWORDS[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_OPTWORDS[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_OPTWORDS)[12] );
|
|
|
|
if (__ARRAY_INTEGER_T[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_T[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_T[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_T[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_T)[8] );
|
|
|
|
if (__ARRAY_INTEGER_LEV[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_LEV[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_LEV[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_LEV[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_LEV)[8] );
|
|
|
|
if (__ARRAY_INTEGER_ENTRYLEV[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_ENTRYLEV[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_ENTRYLEV[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_ENTRYLEV[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_ENTRYLEV)[8] );
|
|
|
|
if (__ARRAY_INTEGER_DITCHLEV[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_DITCHLEV[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_DITCHLEV[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_DITCHLEV[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_DITCHLEV)[8] );
|
|
|
|
if (__ARRAY_INTEGER_DONTPASS[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_DONTPASS[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_DONTPASS[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_DONTPASS[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_DONTPASS)[8] );
|
|
|
|
if (__ARRAY_INTEGER_TEMPLIST[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_TEMPLIST[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_TEMPLIST[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_TEMPLIST[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_TEMPLIST)[8] );
|
|
|
|
if (__ARRAY_LONG_PASSRULE[2]&1){
|
|
|
|
if (__ARRAY_LONG_PASSRULE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_PASSRULE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_PASSRULE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_PASSRULE)[8] );
|
|
|
|
if (__ARRAY_LONG_LEVELENTERED[2]&1){
|
|
|
|
if (__ARRAY_LONG_LEVELENTERED[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_LEVELENTERED[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_LEVELENTERED[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_LEVELENTERED)[8] );
|
|
|
|
if (__ARRAY_STRING_SEPARGS[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_SEPARGS[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_SEPARGS[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_SEPARGS[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_SEPARGS)[8] );
|
|
|
|
if (__ARRAY_STRING_SEPARGSLAYOUT[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_SEPARGSLAYOUT[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_SEPARGSLAYOUT[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_SEPARGSLAYOUT[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_SEPARGSLAYOUT)[8] );
|
|
|
|
if (__ARRAY_STRING_SEPARGS2[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_SEPARGS2[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_SEPARGS2[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_SEPARGS2[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_SEPARGS2)[8] );
|
|
|
|
if (__ARRAY_STRING_SEPARGSLAYOUT2[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_SEPARGSLAYOUT2[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_SEPARGSLAYOUT2[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_SEPARGSLAYOUT2[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_SEPARGSLAYOUT2)[8] );
|
|
|
|
if (__ARRAY_STRING_RESOLVESTATICFUNCTION_FILE[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_RESOLVESTATICFUNCTION_FILE[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_RESOLVESTATICFUNCTION_FILE[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_RESOLVESTATICFUNCTION_FILE[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_RESOLVESTATICFUNCTION_FILE)[8] );
|
|
|
|
if (__ARRAY_STRING_RESOLVESTATICFUNCTION_NAME[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_RESOLVESTATICFUNCTION_NAME[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_RESOLVESTATICFUNCTION_NAME[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_RESOLVESTATICFUNCTION_NAME[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_RESOLVESTATICFUNCTION_NAME)[8] );
|
|
|
|
if (__ARRAY_LONG_RESOLVESTATICFUNCTION_METHOD[2]&1){
|
|
|
|
if (__ARRAY_LONG_RESOLVESTATICFUNCTION_METHOD[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_RESOLVESTATICFUNCTION_METHOD[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_RESOLVESTATICFUNCTION_METHOD[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_RESOLVESTATICFUNCTION_METHOD)[8] );
|
|
|
|
qbs_free(__STRING_ERROR_MESSAGE);
|
|
|
|
qbs_free(__STRING_OS);
|
|
|
|
qbs_free(__STRING_BATCHFILE_EXTENSION);
|
|
|
|
if (__ARRAY_STRING_INLINEDATASTR[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_INLINEDATASTR[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_INLINEDATASTR[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_INLINEDATASTR[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_INLINEDATASTR)[8] );
|
|
|
|
qbs_free(__STRING_EXTENSION);
|
2016-06-21 12:15:48 +00:00
|
|
|
qbs_free(__STRING_PATH__ASCII_CHR_046__EXE);
|
2016-06-30 12:14:27 +00:00
|
|
|
qbs_free(__STRING_PATH__ASCII_CHR_046__SOURCE);
|
2018-11-01 14:26:08 +00:00
|
|
|
qbs_free(__STRING_LASTBINARYGENERATED);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING1_PATHSEP);
|
|
|
|
qbs_free(__STRING_TMPDIR);
|
|
|
|
qbs_free(__STRING_TMPDIR2);
|
2017-05-18 12:17:33 +00:00
|
|
|
qbs_free(__STRING_CHECKPID);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_A);
|
|
|
|
qbs_free(__STRING_TEMPFOLDERINDEXSTR);
|
|
|
|
qbs_free(__STRING_TEMPFOLDERINDEXSTR2);
|
|
|
|
qbs_free(__STRING_SEPERATEARGS_ERROR_MESSAGE);
|
|
|
|
qbs_free(__STRING_IDECOMMAND);
|
|
|
|
qbs_free(__STRING_IDERETURN);
|
|
|
|
qbs_free(__STRING_IDEMESSAGE);
|
2016-07-02 12:15:04 +00:00
|
|
|
qbs_free(__STRING_OUTPUTFILE_CMD);
|
2017-10-25 12:15:44 +00:00
|
|
|
qbs_free(__STRING_COMPILELOG);
|
2021-02-08 14:42:20 +00:00
|
|
|
qbs_free(__STRING_WINDOWSETTINGSSECTION);
|
|
|
|
qbs_free(__STRING_COLORSETTINGSSECTION);
|
|
|
|
qbs_free(__STRING_CUSTOMDICTIONARYSECTION);
|
|
|
|
qbs_free(__STRING_MOUSESETTINGSSECTION);
|
|
|
|
qbs_free(__STRING_GENERALSETTINGSSECTION);
|
|
|
|
qbs_free(__STRING_DISPLAYSETTINGSSECTION);
|
|
|
|
qbs_free(__STRING_COLORSCHEMESSECTION);
|
2021-08-24 07:04:43 +00:00
|
|
|
qbs_free(__STRING_DEBUGSETTINGSSECTION);
|
2021-02-08 14:42:20 +00:00
|
|
|
qbs_free(__STRING_INIFOLDERINDEX);
|
|
|
|
qbs_free(__STRING_DEBUGINFOINIWARNING);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_CONFIGFILE);
|
2022-01-20 23:16:13 +00:00
|
|
|
qbs_free(__STRING_WIKIBASEADDRESS);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_VALUE);
|
2017-10-14 12:16:31 +00:00
|
|
|
qbs_free(__STRING_TEMPLIST);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_HASHFIND_NAME);
|
|
|
|
if (__ARRAY_INTEGER_HASH1CHAR[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_HASH1CHAR[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_HASH1CHAR[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_HASH1CHAR[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_HASH1CHAR)[8] );
|
|
|
|
if (__ARRAY_INTEGER_HASH2CHAR[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_HASH2CHAR[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_HASH2CHAR[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_HASH2CHAR[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_HASH2CHAR)[8] );
|
|
|
|
if (__ARRAY_UDT_HASHLIST[2]&1){
|
|
|
|
if (__ARRAY_UDT_HASHLIST[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_UDT_HASHLIST[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_UDT_HASHLIST[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_HASHLIST)[8] );
|
|
|
|
if (__ARRAY_STRING256_HASHLISTNAME[2]&1){
|
|
|
|
if (__ARRAY_STRING256_HASHLISTNAME[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_STRING256_HASHLISTNAME[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_STRING256_HASHLISTNAME[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING256_HASHLISTNAME)[8] );
|
|
|
|
if (__ARRAY_LONG_HASHLISTFREE[2]&1){
|
|
|
|
if (__ARRAY_LONG_HASHLISTFREE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_HASHLISTFREE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_HASHLISTFREE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_HASHLISTFREE)[8] );
|
|
|
|
if (__ARRAY_LONG_HASHTABLE[2]&1){
|
|
|
|
if (__ARRAY_LONG_HASHTABLE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_HASHTABLE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_HASHTABLE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_HASHTABLE)[8] );
|
|
|
|
if (__ARRAY_UDT_LABELS[2]&1){
|
|
|
|
if (__ARRAY_UDT_LABELS[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_UDT_LABELS[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_UDT_LABELS[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_LABELS)[8] );
|
|
|
|
qbs_free(__STRING_POSSIBLESUBNAMELABELS);
|
|
|
|
qbs_free(__STRING_SUBNAMELABELS);
|
|
|
|
if (__ARRAY_LONG_REVERTMAYMUSTHAVE[2]&1){
|
|
|
|
if (__ARRAY_LONG_REVERTMAYMUSTHAVE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_REVERTMAYMUSTHAVE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_REVERTMAYMUSTHAVE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_REVERTMAYMUSTHAVE)[8] );
|
|
|
|
qbs_free(__STRING_DIM2TYPEPASSBACK);
|
|
|
|
if (__ARRAY_STRING_INCNAME[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_INCNAME[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_INCNAME[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_INCNAME[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_INCNAME)[8] );
|
|
|
|
if (__ARRAY_LONG_INCLINENUMBER[2]&1){
|
|
|
|
if (__ARRAY_LONG_INCLINENUMBER[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_INCLINENUMBER[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_INCLINENUMBER[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_INCLINENUMBER)[8] );
|
|
|
|
qbs_free(__STRING_INCERROR);
|
|
|
|
qbs_free(__STRING_FIX046);
|
|
|
|
qbs_free(__STRING_LAYOUT);
|
|
|
|
qbs_free(__STRING_LAYOUTCOMMENT);
|
|
|
|
qbs_free(__STRING_TLAYOUT);
|
|
|
|
if (__ARRAY_LONG_ALPHANUMERIC[2]&1){
|
|
|
|
if (__ARRAY_LONG_ALPHANUMERIC[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_ALPHANUMERIC[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_ALPHANUMERIC[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_ALPHANUMERIC)[8] );
|
|
|
|
if (__ARRAY_LONG_ISALPHA[2]&1){
|
|
|
|
if (__ARRAY_LONG_ISALPHA[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_ISALPHA[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_ISALPHA[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_ISALPHA)[8] );
|
|
|
|
if (__ARRAY_LONG_ISNUMERIC[2]&1){
|
|
|
|
if (__ARRAY_LONG_ISNUMERIC[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_ISNUMERIC[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_ISNUMERIC[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_ISNUMERIC)[8] );
|
|
|
|
if (__ARRAY_LONG_LFSINGLECHAR[2]&1){
|
|
|
|
if (__ARRAY_LONG_LFSINGLECHAR[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_LFSINGLECHAR[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_LFSINGLECHAR[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_LFSINGLECHAR)[8] );
|
|
|
|
qbs_free(__STRING_LINEINPUT3BUFFER);
|
|
|
|
qbs_free(__STRING_STATICARRAYLIST);
|
|
|
|
qbs_free(__STRING_COMMONARRAYLIST);
|
|
|
|
if (__ARRAY_STRING_CONSTNAME[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_CONSTNAME[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_CONSTNAME[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_CONSTNAME[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_CONSTNAME)[8] );
|
|
|
|
if (__ARRAY_STRING_CONSTCNAME[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_CONSTCNAME[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_CONSTCNAME[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_CONSTCNAME[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_CONSTCNAME)[8] );
|
|
|
|
if (__ARRAY_STRING_CONSTNAMESYMBOL[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_CONSTNAMESYMBOL[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_CONSTNAMESYMBOL[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_CONSTNAMESYMBOL[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_CONSTNAMESYMBOL)[8] );
|
|
|
|
if (__ARRAY_LONG_CONSTTYPE[2]&1){
|
|
|
|
if (__ARRAY_LONG_CONSTTYPE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_CONSTTYPE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_CONSTTYPE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_CONSTTYPE)[8] );
|
|
|
|
if (__ARRAY_INTEGER64_CONSTINTEGER[2]&1){
|
|
|
|
if (__ARRAY_INTEGER64_CONSTINTEGER[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER64_CONSTINTEGER[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER64_CONSTINTEGER[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER64_CONSTINTEGER)[8] );
|
|
|
|
if (__ARRAY_UINTEGER64_CONSTUINTEGER[2]&1){
|
|
|
|
if (__ARRAY_UINTEGER64_CONSTUINTEGER[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_UINTEGER64_CONSTUINTEGER[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_UINTEGER64_CONSTUINTEGER[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UINTEGER64_CONSTUINTEGER)[8] );
|
|
|
|
if (__ARRAY_FLOAT_CONSTFLOAT[2]&1){
|
|
|
|
if (__ARRAY_FLOAT_CONSTFLOAT[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_FLOAT_CONSTFLOAT[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_FLOAT_CONSTFLOAT[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_FLOAT_CONSTFLOAT)[8] );
|
|
|
|
if (__ARRAY_STRING_CONSTSTRING[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_CONSTSTRING[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_CONSTSTRING[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_CONSTSTRING[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_CONSTSTRING)[8] );
|
|
|
|
if (__ARRAY_LONG_CONSTSUBFUNC[2]&1){
|
|
|
|
if (__ARRAY_LONG_CONSTSUBFUNC[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_CONSTSUBFUNC[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_CONSTSUBFUNC[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_CONSTSUBFUNC)[8] );
|
|
|
|
if (__ARRAY_LONG_CONSTDEFINED[2]&1){
|
|
|
|
if (__ARRAY_LONG_CONSTDEFINED[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_CONSTDEFINED[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_CONSTDEFINED[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_CONSTDEFINED)[8] );
|
2021-06-20 03:06:54 +00:00
|
|
|
qbs_free(*((qbs**)(((char*)__UDT_ID)+ 2861)));
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_UDT_IDS[2]&1){
|
2021-06-20 03:06:54 +00:00
|
|
|
tmp_long=__ARRAY_UDT_IDS[5];
|
|
|
|
while(tmp_long--) {
|
|
|
|
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_IDS[0]+(22952/8+1-1)*tmp_long+ 2861));}
|
2015-08-02 12:12:44 +00:00
|
|
|
free((void*)(__ARRAY_UDT_IDS[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_IDS)[8] );
|
|
|
|
if (__ARRAY_INTEGER_CMEMLIST[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_CMEMLIST[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_CMEMLIST[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_CMEMLIST[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_CMEMLIST)[8] );
|
|
|
|
if (__ARRAY_STRING100_SFCMEMARGS[2]&1){
|
|
|
|
if (__ARRAY_STRING100_SFCMEMARGS[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_STRING100_SFCMEMARGS[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_STRING100_SFCMEMARGS[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING100_SFCMEMARGS)[8] );
|
|
|
|
if (__ARRAY_INTEGER_ARRAYELEMENTSLIST[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_ARRAYELEMENTSLIST[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_ARRAYELEMENTSLIST[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_ARRAYELEMENTSLIST[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_ARRAYELEMENTSLIST)[8] );
|
2021-06-20 03:06:54 +00:00
|
|
|
qbs_free(*((qbs**)(((char*)__UDT_CLEARIDDATA)+ 2861)));
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_SOURCEFILE);
|
|
|
|
qbs_free(__STRING_FILE);
|
|
|
|
qbs_free(__STRING_FINDIDSECONDARG);
|
|
|
|
qbs_free(__STRING_WHOLELINE);
|
2021-07-21 21:30:49 +00:00
|
|
|
qbs_free(__STRING_VWATCHUSEDLABELS);
|
2021-08-30 04:47:27 +00:00
|
|
|
qbs_free(__STRING_VWATCHUSEDSKIPLABELS);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_LINEFRAGMENT);
|
|
|
|
qbs_free(__STRING_CLEANUPSTRINGPROCESSINGCALL);
|
|
|
|
qbs_free(__STRING_ADDMETAINCLUDE);
|
|
|
|
qbs_free(__STRING_MODULE);
|
|
|
|
qbs_free(__STRING_SUBFUNC);
|
|
|
|
if (__ARRAY_INTEGER64_BITMASK[2]&1){
|
|
|
|
if (__ARRAY_INTEGER64_BITMASK[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER64_BITMASK[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER64_BITMASK[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER64_BITMASK)[8] );
|
|
|
|
if (__ARRAY_INTEGER64_BITMASKINV[2]&1){
|
|
|
|
if (__ARRAY_INTEGER64_BITMASKINV[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER64_BITMASKINV[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER64_BITMASKINV[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER64_BITMASKINV)[8] );
|
|
|
|
if (__ARRAY_STRING_DEFINEEXTAZ[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_DEFINEEXTAZ[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_DEFINEEXTAZ[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_DEFINEEXTAZ[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_DEFINEEXTAZ)[8] );
|
|
|
|
if (__ARRAY_STRING_DEFINEAZ[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_DEFINEAZ[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_DEFINEAZ[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_DEFINEAZ[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_DEFINEAZ)[8] );
|
|
|
|
if (__ARRAY_INTEGER_CONTROLTYPE[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_CONTROLTYPE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_CONTROLTYPE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_CONTROLTYPE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_CONTROLTYPE)[8] );
|
|
|
|
if (__ARRAY_LONG_CONTROLID[2]&1){
|
|
|
|
if (__ARRAY_LONG_CONTROLID[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_CONTROLID[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_CONTROLID[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_CONTROLID)[8] );
|
|
|
|
if (__ARRAY_LONG_CONTROLVALUE[2]&1){
|
|
|
|
if (__ARRAY_LONG_CONTROLVALUE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_CONTROLVALUE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_CONTROLVALUE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_CONTROLVALUE)[8] );
|
|
|
|
if (__ARRAY_INTEGER_CONTROLSTATE[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_CONTROLSTATE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_CONTROLSTATE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_CONTROLSTATE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_CONTROLSTATE)[8] );
|
|
|
|
if (__ARRAY_LONG_CONTROLREF[2]&1){
|
|
|
|
if (__ARRAY_LONG_CONTROLREF[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_CONTROLREF[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_CONTROLREF[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_CONTROLREF)[8] );
|
2021-06-20 03:06:54 +00:00
|
|
|
qbs_free(*((qbs**)(((char*)__UDT_ID2)+ 2861)));
|
2015-08-02 12:12:44 +00:00
|
|
|
if (__ARRAY_LONG_SFIDLIST[2]&1){
|
|
|
|
if (__ARRAY_LONG_SFIDLIST[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_SFIDLIST[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_SFIDLIST[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_SFIDLIST)[8] );
|
|
|
|
if (__ARRAY_INTEGER_SFARGLIST[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_SFARGLIST[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_SFARGLIST[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_SFARGLIST[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_SFARGLIST)[8] );
|
|
|
|
if (__ARRAY_INTEGER_SFELELIST[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_SFELELIST[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_SFELELIST[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_SFELELIST[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_SFELELIST)[8] );
|
|
|
|
qbs_free(__STRING_SENDC);
|
|
|
|
qbs_free(__STRING_C);
|
|
|
|
qbs_free(__STRING_A3);
|
|
|
|
qbs_free(__STRING_F);
|
2021-02-14 03:56:09 +00:00
|
|
|
qbs_free(__STRING_TERRMSG);
|
2016-06-26 12:16:55 +00:00
|
|
|
qbs_free(__STRING_CURRENTDIR);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_MYLIB);
|
|
|
|
qbs_free(__STRING_MYLIBOPT);
|
2021-10-12 04:47:19 +00:00
|
|
|
if (__ARRAY_STRING256_UDTXNAME[2]&1){
|
|
|
|
if (__ARRAY_STRING256_UDTXNAME[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_STRING256_UDTXNAME[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_STRING256_UDTXNAME[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING256_UDTXNAME)[8] );
|
|
|
|
if (__ARRAY_STRING256_UDTXCNAME[2]&1){
|
|
|
|
if (__ARRAY_STRING256_UDTXCNAME[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_STRING256_UDTXCNAME[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_STRING256_UDTXCNAME[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING256_UDTXCNAME)[8] );
|
|
|
|
if (__ARRAY_LONG_UDTXSIZE[2]&1){
|
|
|
|
if (__ARRAY_LONG_UDTXSIZE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_UDTXSIZE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_UDTXSIZE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_UDTXSIZE)[8] );
|
|
|
|
if (__ARRAY_INTEGER_UDTXBYTEALIGN[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_UDTXBYTEALIGN[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_UDTXBYTEALIGN[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_UDTXBYTEALIGN[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_UDTXBYTEALIGN)[8] );
|
|
|
|
if (__ARRAY_LONG_UDTXNEXT[2]&1){
|
|
|
|
if (__ARRAY_LONG_UDTXNEXT[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_UDTXNEXT[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_UDTXNEXT[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_UDTXNEXT)[8] );
|
|
|
|
if (__ARRAY_INTEGER_UDTXVARIABLE[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_UDTXVARIABLE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_UDTXVARIABLE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_UDTXVARIABLE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_UDTXVARIABLE)[8] );
|
|
|
|
if (__ARRAY_STRING256_UDTENAME[2]&1){
|
|
|
|
if (__ARRAY_STRING256_UDTENAME[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_STRING256_UDTENAME[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_STRING256_UDTENAME[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING256_UDTENAME)[8] );
|
|
|
|
if (__ARRAY_STRING256_UDTECNAME[2]&1){
|
|
|
|
if (__ARRAY_STRING256_UDTECNAME[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_STRING256_UDTECNAME[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_STRING256_UDTECNAME[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING256_UDTECNAME)[8] );
|
|
|
|
if (__ARRAY_INTEGER_UDTEBYTEALIGN[2]&1){
|
|
|
|
if (__ARRAY_INTEGER_UDTEBYTEALIGN[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_INTEGER_UDTEBYTEALIGN[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_INTEGER_UDTEBYTEALIGN[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_INTEGER_UDTEBYTEALIGN)[8] );
|
|
|
|
if (__ARRAY_LONG_UDTESIZE[2]&1){
|
|
|
|
if (__ARRAY_LONG_UDTESIZE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_UDTESIZE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_UDTESIZE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_UDTESIZE)[8] );
|
|
|
|
if (__ARRAY_LONG_UDTETYPE[2]&1){
|
|
|
|
if (__ARRAY_LONG_UDTETYPE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_UDTETYPE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_UDTETYPE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_UDTETYPE)[8] );
|
|
|
|
if (__ARRAY_LONG_UDTETYPESIZE[2]&1){
|
|
|
|
if (__ARRAY_LONG_UDTETYPESIZE[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_UDTETYPESIZE[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_UDTETYPESIZE[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_UDTETYPESIZE)[8] );
|
|
|
|
if (__ARRAY_LONG_UDTEARRAYELEMENTS[2]&1){
|
|
|
|
if (__ARRAY_LONG_UDTEARRAYELEMENTS[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_UDTEARRAYELEMENTS[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_UDTEARRAYELEMENTS[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_UDTEARRAYELEMENTS)[8] );
|
|
|
|
if (__ARRAY_LONG_UDTENEXT[2]&1){
|
|
|
|
if (__ARRAY_LONG_UDTENEXT[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_UDTENEXT[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_UDTENEXT[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_UDTENEXT)[8] );
|
2021-07-22 21:44:11 +00:00
|
|
|
if (__ARRAY_UDT_USEDVARIABLELIST[2]&1){
|
|
|
|
tmp_long=__ARRAY_UDT_USEDVARIABLELIST[5];
|
|
|
|
while(tmp_long--) {
|
|
|
|
|
2022-03-10 04:52:17 +00:00
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 32));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 40));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 48));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 56));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 64));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 72));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 80));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 88));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 96));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 104));
|
|
|
|
qbs_free(*(qbs**)(__ARRAY_UDT_USEDVARIABLELIST[0]+(960/8+1-1)*tmp_long+ 112));}
|
2021-07-22 21:44:11 +00:00
|
|
|
free((void*)(__ARRAY_UDT_USEDVARIABLELIST[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_UDT_USEDVARIABLELIST)[8] );
|
2019-01-13 18:43:58 +00:00
|
|
|
if (__ARRAY_STRING_WARNING[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_WARNING[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_WARNING[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_WARNING[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_WARNING)[8] );
|
2021-02-14 03:56:09 +00:00
|
|
|
if (__ARRAY_LONG_WARNINGLINES[2]&1){
|
|
|
|
if (__ARRAY_LONG_WARNINGLINES[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_WARNINGLINES[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_WARNINGLINES[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_WARNINGLINES)[8] );
|
|
|
|
if (__ARRAY_LONG_WARNINGINCLINES[2]&1){
|
|
|
|
if (__ARRAY_LONG_WARNINGINCLINES[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(__ARRAY_LONG_WARNINGINCLINES[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(__ARRAY_LONG_WARNINGINCLINES[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_LONG_WARNINGINCLINES)[8] );
|
|
|
|
if (__ARRAY_STRING_WARNINGINCFILES[2]&1){
|
|
|
|
tmp_long=__ARRAY_STRING_WARNINGINCFILES[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(__ARRAY_STRING_WARNINGINCFILES[0]))[tmp_long]);
|
|
|
|
free((void*)(__ARRAY_STRING_WARNINGINCFILES[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)__ARRAY_STRING_WARNINGINCFILES)[8] );
|
2021-07-12 00:07:48 +00:00
|
|
|
qbs_free(__STRING_LINEBACKUP);
|
|
|
|
qbs_free(__STRING_FORCEINCLUDEFROMROOT);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_WHOLESTV);
|
2021-02-08 14:42:20 +00:00
|
|
|
qbs_free(__STRING_TEMP);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_L);
|
|
|
|
qbs_free(__STRING_R);
|
|
|
|
qbs_free(__STRING_R1);
|
|
|
|
qbs_free(__STRING_CWHOLELINE);
|
|
|
|
qbs_free(__STRING_E);
|
|
|
|
qbs_free(__STRING_CA);
|
|
|
|
qbs_free(__STRING_CE);
|
|
|
|
qbs_free(__STRING_FIRSTELEMENT);
|
|
|
|
qbs_free(__STRING_SECONDELEMENT);
|
|
|
|
qbs_free(__STRING_THIRDELEMENT);
|
|
|
|
qbs_free(__STRING_SIZ);
|
|
|
|
qbs_free(__STRING_N);
|
|
|
|
qbs_free(__STRING_T);
|
|
|
|
qbs_free(__STRING_HASHNAME);
|
2021-01-26 15:38:16 +00:00
|
|
|
qbs_free(__STRING_PREVIOUSELEMENT);
|
|
|
|
qbs_free(__STRING_LASTELEMENT);
|
|
|
|
qbs_free(__STRING_CN);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_S);
|
2020-01-15 20:11:04 +00:00
|
|
|
qbs_free(__STRING_READABLE_E);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_E2);
|
2020-01-15 20:11:04 +00:00
|
|
|
qbs_free(__STRING_E3);
|
|
|
|
qbs_free(__STRING_TEMP1);
|
2021-01-14 03:03:50 +00:00
|
|
|
qbs_free(__STRING_THISCONSTVAL);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_SYMBOL);
|
|
|
|
qbs_free(__STRING_ALIASNAME);
|
|
|
|
qbs_free(__STRING_PARAMS);
|
|
|
|
qbs_free(__STRING_PARAMSIZE);
|
|
|
|
qbs_free(__STRING_NELE);
|
|
|
|
qbs_free(__STRING_NELEREQ);
|
|
|
|
qbs_free(__STRING_A2);
|
|
|
|
qbs_free(__STRING_T2);
|
|
|
|
qbs_free(__STRING_N2);
|
|
|
|
qbs_free(__STRING_SYMBOL2);
|
|
|
|
qbs_free(__STRING_CTYPE);
|
|
|
|
qbs_free(__STRING_P);
|
|
|
|
qbs_free(__STRING_X);
|
|
|
|
qbs_free(__STRING_LAYOUTORIGINAL);
|
|
|
|
qbs_free(__STRING_A3U);
|
2021-02-18 18:10:07 +00:00
|
|
|
qbs_free(__STRING_TEMPOP);
|
2017-04-29 12:15:43 +00:00
|
|
|
qbs_free(__STRING_VERSIONINFOKEY);
|
|
|
|
qbs_free(__STRING_VERSIONINFOVALUE);
|
2016-08-18 12:23:07 +00:00
|
|
|
qbs_free(__STRING_EXEICONFILE);
|
|
|
|
qbs_free(__STRING_ICONPATH);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_ENTIRELINE);
|
|
|
|
qbs_free(__STRING_U);
|
|
|
|
qbs_free(__STRING_LABEL);
|
2016-03-23 12:18:29 +00:00
|
|
|
qbs_free(__STRING_INCLINENUMP);
|
2016-07-09 12:16:05 +00:00
|
|
|
qbs_free(__STRING_THISINCNAME);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_E1);
|
|
|
|
qbs_free(__STRING_AA);
|
2021-01-26 15:38:16 +00:00
|
|
|
qbs_free(__STRING_NEXTELEMENT);
|
|
|
|
qbs_free(__STRING_THISELEMENT);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_LIBNAME);
|
|
|
|
qbs_free(__STRING_HEADERNAME);
|
|
|
|
qbs_free(__STRING_AUTOFORMAT_X);
|
|
|
|
qbs_free(__STRING_V);
|
|
|
|
qbs_free(__STRING_LIBVER);
|
|
|
|
qbs_free(__STRING_LIBPATH);
|
|
|
|
qbs_free(__STRING_LIBPATH_INLINE);
|
|
|
|
qbs_free(__STRING_INLINELIBNAME);
|
|
|
|
qbs_free(__STRING_X2);
|
|
|
|
qbs_free(__STRING_DLLNAME);
|
|
|
|
qbs_free(__STRING_EE);
|
2021-07-19 21:21:56 +00:00
|
|
|
qbs_free(__STRING_SUBFUNCORIGINALNAME);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_SUBFUNCRET);
|
|
|
|
qbs_free(__STRING_T3);
|
|
|
|
qbs_free(__STRING_CALLNAME);
|
|
|
|
qbs_free(__STRING_TYP);
|
|
|
|
qbs_free(__STRING_TYP2);
|
|
|
|
qbs_free(__STRING_STARTVALUE);
|
|
|
|
qbs_free(__STRING_P3);
|
|
|
|
qbs_free(__STRING_P2);
|
|
|
|
qbs_free(__STRING_TC);
|
|
|
|
qbs_free(__STRING_F12);
|
|
|
|
qbs_free(__STRING_EL);
|
|
|
|
qbs_free(__STRING_ER);
|
|
|
|
qbs_free(__STRING_O);
|
|
|
|
qbs_free(__STRING_O2);
|
|
|
|
qbs_free(__STRING_SIZEE);
|
|
|
|
qbs_free(__STRING_OPTI);
|
|
|
|
qbs_free(__STRING_OPTCONTROLLER);
|
|
|
|
qbs_free(__STRING_OPTPASSED);
|
|
|
|
qbs_free(__STRING_CT);
|
|
|
|
qbs_free(__STRING_L2);
|
|
|
|
qbs_free(__STRING_TS);
|
|
|
|
qbs_free(__STRING_OLDSUBFUNC);
|
2021-01-26 15:38:16 +00:00
|
|
|
qbs_free(__STRING_L3);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_STRINGVARIABLE);
|
|
|
|
qbs_free(__STRING_POSITION);
|
|
|
|
qbs_free(__STRING_EXPRESSION);
|
|
|
|
qbs_free(__STRING_LENGTH);
|
|
|
|
qbs_free(__STRING_START);
|
|
|
|
qbs_free(__STRING_STRINGEXPRESSION);
|
|
|
|
qbs_free(__STRING_VAR);
|
|
|
|
qbs_free(__STRING_LS);
|
|
|
|
qbs_free(__STRING_BYTESPERELEMENT);
|
|
|
|
qbs_free(__STRING_VARNAME);
|
|
|
|
qbs_free(__STRING_ELEMENTS);
|
|
|
|
qbs_free(__STRING_D);
|
|
|
|
qbs_free(__STRING_APPENDNAME);
|
|
|
|
qbs_free(__STRING_APPENDTYPE);
|
|
|
|
qbs_free(__STRING_S2);
|
|
|
|
qbs_free(__STRING_VARNAME2);
|
|
|
|
qbs_free(__STRING_IGNORE);
|
|
|
|
qbs_free(__STRING_LBL);
|
|
|
|
qbs_free(__STRING_BLK);
|
|
|
|
qbs_free(__STRING_OFFS);
|
|
|
|
qbs_free(__STRING_TEST);
|
|
|
|
qbs_free(__STRING_BLKOFFS);
|
|
|
|
qbs_free(__STRING_VARSIZE);
|
|
|
|
qbs_free(__STRING_VAROFFS);
|
|
|
|
qbs_free(__STRING_ST);
|
|
|
|
qbs_free(__STRING_BYTES);
|
|
|
|
qbs_free(__STRING_NEXTCHAR);
|
|
|
|
qbs_free(__STRING_TEXTVALUE);
|
|
|
|
qbs_free(__STRING_DEST);
|
|
|
|
qbs_free(__STRING_SOURCE);
|
|
|
|
qbs_free(__STRING_E1L);
|
|
|
|
qbs_free(__STRING_E2L);
|
|
|
|
qbs_free(__STRING_LHSSCOPE);
|
|
|
|
qbs_free(__STRING_DST);
|
|
|
|
qbs_free(__STRING_SRC);
|
|
|
|
qbs_free(__STRING_SUBCALL);
|
|
|
|
qbs_free(__STRING_X3);
|
|
|
|
qbs_free(__STRING_TRY_STRING);
|
|
|
|
qbs_free(__STRING_LAYOUTCOMMENT_BACKUP);
|
|
|
|
qbs_free(__STRING_LAYOUT_BACKUP);
|
|
|
|
qbs_free(__STRING_PUREVARNAME);
|
|
|
|
qbs_free(__STRING_X1);
|
2021-01-14 03:03:50 +00:00
|
|
|
qbs_free(__STRING_HEADER);
|
2016-07-02 12:15:04 +00:00
|
|
|
qbs_free(__STRING_PATH__ASCII_CHR_046__OUT);
|
|
|
|
qbs_free(__STRING_T__ASCII_CHR_046__PATH__ASCII_CHR_046__EXE);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(__STRING_DEFINES);
|
|
|
|
qbs_free(__STRING_DEFINES_HEADER);
|
|
|
|
qbs_free(__STRING_VER);
|
|
|
|
qbs_free(__STRING_LIBS);
|
|
|
|
qbs_free(__STRING_LOCALPATH);
|
|
|
|
qbs_free(__STRING_LIBFILE);
|
|
|
|
qbs_free(__STRING_D1);
|
|
|
|
qbs_free(__STRING_D2);
|
|
|
|
qbs_free(__STRING_D3);
|
|
|
|
qbs_free(__STRING_DEPSTR);
|
|
|
|
qbs_free(__STRING_LIBQB);
|
|
|
|
qbs_free(__STRING_B);
|
2021-07-21 21:30:49 +00:00
|
|
|
qbs_free(_SUB_VWATCHVARIABLE_STRING_LOCALVARIABLESLIST);
|
|
|
|
qbs_free(_SUB_VWATCHVARIABLE_STRING_MAINMODULEVARIABLESLIST);
|
2016-01-05 13:12:45 +00:00
|
|
|
qbs_free(_FUNC_IDE2_STRING_MENULOCATIONS);
|
2021-01-15 23:34:30 +00:00
|
|
|
qbs_free(_FUNC_IDE2_STRING_MATHEVALEXPR);
|
2021-07-21 21:30:49 +00:00
|
|
|
qbs_free(_SUB_DEBUGMODE_STRING_BUFFER);
|
2021-07-29 21:43:08 +00:00
|
|
|
qbs_free(_SUB_DEBUGMODE_STRING_CURRENTSUB);
|
2021-08-15 06:00:33 +00:00
|
|
|
qbs_free(_SUB_SHOWVWATCHPANEL_STRING_PREVIOUSVARIABLEWATCHLIST);
|
2021-08-24 07:04:43 +00:00
|
|
|
qbs_free(_FUNC_IDEELEMENTWATCHBOX_STRING_RETURNLIST);
|
2021-09-10 04:26:50 +00:00
|
|
|
qbs_free(_FUNC_EXPANDARRAY_STRING_RETURNVALUE);
|
2017-10-14 12:16:31 +00:00
|
|
|
qbs_free(_SUB_IDESHOWTEXT_STRING_PREVLISTOFCUSTOMWORDS);
|
2021-10-18 03:13:30 +00:00
|
|
|
if (_FUNC_IDEACTIVITYBOX_ARRAY_UDT_O[2]&1){
|
|
|
|
if (_FUNC_IDEACTIVITYBOX_ARRAY_UDT_O[2]&4){
|
|
|
|
cmem_dynamic_free((uint8*)(_FUNC_IDEACTIVITYBOX_ARRAY_UDT_O[0]));
|
|
|
|
}else{
|
|
|
|
free((void*)(_FUNC_IDEACTIVITYBOX_ARRAY_UDT_O[0]));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)_FUNC_IDEACTIVITYBOX_ARRAY_UDT_O)[8] );
|
|
|
|
qbs_free(_FUNC_IDEACTIVITYBOX_STRING1_SEP);
|
|
|
|
if (_FUNC_IDEACTIVITYBOX_ARRAY_STRING_FULLMESSAGE[2]&1){
|
|
|
|
tmp_long=_FUNC_IDEACTIVITYBOX_ARRAY_STRING_FULLMESSAGE[5];
|
|
|
|
while(tmp_long--) qbs_free((qbs*)((uint64*)(_FUNC_IDEACTIVITYBOX_ARRAY_STRING_FULLMESSAGE[0]))[tmp_long]);
|
|
|
|
free((void*)(_FUNC_IDEACTIVITYBOX_ARRAY_STRING_FULLMESSAGE[0]));
|
|
|
|
}
|
|
|
|
free_mem_lock( (mem_lock*)((ptrszint*)_FUNC_IDEACTIVITYBOX_ARRAY_STRING_FULLMESSAGE)[8] );
|
|
|
|
qbs_free(_FUNC_IDEACTIVITYBOX_STRING_ALTLETTER);
|
2015-08-02 12:12:44 +00:00
|
|
|
qbs_free(_SUB_GETINPUT_STRING_ASCVALUE);
|
2022-01-24 01:29:53 +00:00
|
|
|
qbs_free(_FUNC_GETBYTES_STRING_PREVIOUSVALUE);
|