1
1
Fork 0
mirror of https://github.com/QB64-Phoenix-Edition/QB64pe.git synced 2024-07-04 04:50:22 +00:00

Merge branch 'QB64-Phoenix-Edition:main' into miniaudio-upgrade

This commit is contained in:
Samuel Gomes 2024-01-03 15:28:21 +05:30 committed by GitHub
commit ba29d47f17
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
343 changed files with 83798 additions and 83382 deletions

View file

@ -52,14 +52,14 @@
# endif
// common includes
# include <stdio.h>
# include <cmath>
# include <stdint.h>
# include <errno.h>
# include <fcntl.h>
# include <fstream>
# include <iostream>
# include <limits.h>
# include <stdint.h>
# include <stdio.h>
# include <string.h>
# include <time.h>
@ -77,13 +77,13 @@
# else
# include <dlfcn.h>
# include <pthread.h>
# include <stdlib.h>
# include <sys/stat.h>
# include <sys/types.h>
# include <sys/wait.h>
# include <unistd.h>
# include <dlfcn.h>
# endif
@ -93,6 +93,105 @@
# endif
# endif
# define QB_FALSE 0
# define QB_TRUE -1
# define QB_ERROR_NEXT_WITHOUT_FOR 1
# define QB_ERROR_SYNTAX_ERROR 2
# define QB_ERROR_RETURN_WITHOUT_GOSUB 3
# define QB_ERROR_OUT_OF_DATA 4
# define QB_ERROR_ILLEGAL_FUNCTION_CALL 5
# define QB_ERROR_OVERFLOW 6
# define QB_ERROR_OUT_OF_MEMORY 7
# define QB_ERROR_LABEL_NOT_DEFINED 8
# define QB_ERROR_SUBSCRIPT_OUT_OF_RANGE 9
# define QB_ERROR_DUPLICATE_DEFINITION 10
# define QB_ERROR_DIVISION_BY_ZERO 11
# define QB_ERROR_ILLEGAL_IN_DIRECT_MODE 12
# define QB_ERROR_TYPE_MISMATCH 13
# define QB_ERROR_OUT_OF_STRING_SPACE 14
# define QB_ERROR_STRING_FORMULA_TOO_COMPLEX 16
# define QB_ERROR_CANNOT_CONTINUE 17
# define QB_ERROR_FUNCTION_NOT_DEFINED 18
# define QB_ERROR_NO_RESUME 19
# define QB_ERROR_RESUME_WITHOUT_ERROR 20
# define QB_ERROR_DEVICE_TIMEOUT 24
# define QB_ERROR_DEVICE_FAULT 25
# define QB_ERROR_FOR_WITHOUT_NEXT 26
# define QB_ERROR_OUT_OF_PAPER 27
# define QB_ERROR_WHILE_WITHOUT_WEND 29
# define QB_ERROR_WEND_WITHOUT_WHILE 30
# define QB_ERROR_DUPLICATE_LABEL 33
# define QB_ERROR_SUBPROGRAM_NOT_DEFINED 35
# define QB_ERROR_ARGUMENT_COUNT_MISMATCH 37
# define QB_ERROR_ARRAY_NOT_DEFINED 38
# define QB_ERROR_VARIABLE_REQUIRED 40
# define QB_ERROR_FIELD_OVERFLOW 50
# define QB_ERROR_INTERNAL_ERROR 51
# define QB_ERROR_BAD_FILE_NAME_OR_NUMBER 52
# define QB_ERROR_FILE_NOT_FOUND 53
# define QB_ERROR_BAD_FILE_MODE 54
# define QB_ERROR_FILE_ALREADY_OPEN 55
# define QB_ERROR_FIELD_STATEMENT_ACTIVE 56
# define QB_ERROR_DEVICE_IO_ERROR 57
# define QB_ERROR_FILE_ALREADY_EXISTS 58
# define QB_ERROR_BAD_RECORD_LENGTH 59
# define QB_ERROR_DISK_FULL 61
# define QB_ERROR_INPUT_PAST_END_OF_FILE 62
# define QB_ERROR_BAD_RECORD_NUMBER 63
# define QB_ERROR_BAD_FILE_NAME 64
# define QB_ERROR_TOO_MANY_FILES 67
# define QB_ERROR_DEVICE_UNAVAILABLE 68
# define QB_ERROR_COMMUNICATION_BUFFER_OVERFLOW 69
# define QB_ERROR_PERMISSION_DENIED 70
# define QB_ERROR_DISK_NOT_READY 71
# define QB_ERROR_DISK_MEDIA_ERROR 72
# define QB_ERROR_FEATURE_UNAVAILABLE 73
# define QB_ERROR_RENAME_ACROSS_DISKS 74
# define QB_ERROR_PATH_FILE_ACCESS_ERROR 75
# define QB_ERROR_PATH_NOT_FOUND 76
# define QB_ERROR_OUT_OF_STACK_SPACE 256
# define QB_ERROR_OUT_OF_MEMORY_FATAL 257
# define QB_ERROR_INVALID_HANDLE 258
# define QB_ERROR_CANNOT_FIND_DYNAMIC_LIBRARY_FILE 259
# define QB_ERROR_FUNCTION_NOT_FOUND_IN_DYNAMIC_LIBRARY 260
# define QB_ERROR_FUNCTION_NOT_FOUND_IN_DYNAMIC_LIBRARY_261 261
# define QB_ERROR_GL_COMMAND_OUTSIDE_SUB_GL_SCOPE 270
# define QB_ERROR_END_SYSTEM_IN_SUB_GL_SCOPE 271
# define QB_ERROR_MEMORY_REGION_OUT_OF_RANGE 300
# define QB_ERROR_INVALID_SIZE 301
# define QB_ERROR_SOURCE_MEMORY_REGION_OUT_OF_RANGE 302
# define QB_ERROR_DESTINATION_MEMORY_REGION_OUT_OF_RANGE 303
# define QB_ERROR_BOTH_MEMORY_REGIONS_OUT_OF_RANGE 304
# define QB_ERROR_SOURCE_MEMORY_FREED 305
# define QB_ERROR_DESTINATION_MEMORY_FREED 306
# define QB_ERROR_MEMORY_ALREADY_FREED 307
# define QB_ERROR_MEMORY_HAS_BEEN_FREED 308
# define QB_ERROR_MEMORY_NOT_INITIALIZED 309
# define QB_ERROR_SOURCE_MEMORY_NOT_INITIALIZED 310
# define QB_ERROR_DESTINATION_MEMORY_NOT_INITIALIZED 311
# define QB_ERROR_BOTH_MEMORY_NOT_INITIALIZED 312
# define QB_ERROR_BOTH_MEMORY_FREED 313
# define QB_ERROR_ASSERT_FAILED 314
# define QB_ERROR_ASSERT_FAILED_WITH_DESCRIPTION 315
# define QB_ERROR_OUT_OF_MEMORY_FATAL_502 502
# define QB_ERROR_OUT_OF_MEMORY_FATAL_503 503
# define QB_ERROR_OUT_OF_MEMORY_FATAL_504 504
# define QB_ERROR_OUT_OF_MEMORY_FATAL_505 505
# define QB_ERROR_OUT_OF_MEMORY_FATAL_506 506
# define QB_ERROR_OUT_OF_MEMORY_FATAL_507 507
# define QB_ERROR_OUT_OF_MEMORY_FATAL_508 508
# define QB_ERROR_OUT_OF_MEMORY_FATAL_509 509
# define QB_ERROR_OUT_OF_MEMORY_FATAL_510 510
# define QB_ERROR_OUT_OF_MEMORY_FATAL_511 511
# define QB_ERROR_OUT_OF_MEMORY_FATAL_512 512
# define QB_ERROR_OUT_OF_MEMORY_FATAL_513 513
# define QB_ERROR_OUT_OF_MEMORY_FATAL_514 514
# define QB_ERROR_OUT_OF_MEMORY_FATAL_515 515
# define QB_ERROR_OUT_OF_MEMORY_FATAL_516 516
# define QB_ERROR_OUT_OF_MEMORY_FATAL_517 517
# define QB_ERROR_OUT_OF_MEMORY_FATAL_518 518
// QB64 string descriptor structure
struct qbs_field {
int32 fileno;

View file

@ -21,6 +21,8 @@
#include "compression.h"
#include "datetime.h"
#include "event.h"
#include "filepath.h"
#include "filesystem.h"
#include "font.h"
#include "game_controller.h"
#include "glut-thread.h"
@ -3946,23 +3948,6 @@ int32 exit_value = 0;
void error(int32 error_number); // for forward references
char *fixdir(qbs *filename) {
// note: changes the slashes in a filename to make it compatible with the OS
// applied to QB commands: open, bload/bsave, loadfont, loadimage, sndopen/sndplayfile
static int32 i;
for (i = 0; i < filename->len; i++) {
#ifdef QB64_WINDOWS
if (filename->chr[i] == 47)
filename->chr[i] = 92;
#else
if (filename->chr[i] == 92)
filename->chr[i] = 47;
#endif
}
return (char *)filename->chr;
}
int32 width8050switch = 1; // if set, can automatically switch to WIDTH 80,50 if LOCATE'ing beyond row 26
uint32 pal[256];
@ -20913,7 +20898,7 @@ void sub_bsave(qbs *filename, int32 offset, int32 size) {
if (size != 65536)
size &= 0xFFFF;
qbs_set(tqbs, qbs_add(filename, nullt)); // prepare null-terminated filename
fh.open(fixdir(tqbs), std::ios::binary | std::ios::out);
fh.open(filepath_fix_directory(tqbs), std::ios::binary | std::ios::out);
if (fh.is_open() == NULL) {
error(64);
return;
@ -20954,7 +20939,7 @@ void sub_bload(qbs *filename, int32 offset, int32 passed) {
offset &= 0xFFFF;
}
qbs_set(tqbs, qbs_add(filename, nullt)); // prepare null-terminated filename
fh.open(fixdir(tqbs), std::ios::binary | std::ios::in);
fh.open(filepath_fix_directory(tqbs), std::ios::binary | std::ios::in);
if (fh.is_open() == NULL) {
error(53);
return;
@ -23022,166 +23007,6 @@ shell_complete:;
} //_DONTWAIT & _HIDE
void sub_kill(qbs *str) {
// note: file not found returned for non-existant paths too
// file already open returned if access unavailable
if (new_error)
return;
static int32 i;
static qbs *strz = NULL;
if (!strz)
strz = qbs_new(0, 0);
qbs_set(strz, qbs_add(str, qbs_new_txt_len("\0", 1)));
#ifdef QB64_WINDOWS
static WIN32_FIND_DATA fd;
static HANDLE hFind;
static qbs *strpath = NULL;
if (!strpath)
strpath = qbs_new(0, 0);
static qbs *strfullz = NULL;
if (!strfullz)
strfullz = qbs_new(0, 0);
// find path
qbs_set(strpath, strz);
for (i = strpath->len; i > 0; i--) {
if ((strpath->chr[i - 1] == 47) || (strpath->chr[i - 1] == 92)) {
strpath->len = i;
break;
}
} // i
if (i == 0)
strpath->len = 0; // no path specified
static int32 count;
count = 0;
hFind = FindFirstFile(fixdir(strz), &fd);
if (hFind == INVALID_HANDLE_VALUE) {
error(53);
return;
} // file not found
do {
if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
qbs_set(strfullz, qbs_add(strpath, qbs_new_txt_len(fd.cFileName, strlen(fd.cFileName) + 1)));
if (!DeleteFile((char *)strfullz->chr)) {
i = GetLastError();
if ((i == 5) || (i == 19) || (i == 33) || (i == 32)) {
FindClose(hFind);
error(55);
return;
} // file already open
FindClose(hFind);
error(53);
return; // file not found
}
count++;
} // not a directory
} while (FindNextFile(hFind, &fd));
FindClose(hFind);
if (!count) {
error(53);
return;
} // file not found
return;
#else
if (remove(fixdir(strz))) {
i = errno;
if (i == ENOENT) {
error(53);
return;
} // file not found
if (i == EACCES) {
error(75);
return;
} // path/file access error
error(64); // bad file name (assumed)
}
#endif
}
void sub_name(qbs *oldname, qbs *newname) {
if (new_error)
return;
static qbs *strz = NULL;
if (!strz)
strz = qbs_new(0, 0);
static qbs *strz2 = NULL;
if (!strz2)
strz2 = qbs_new(0, 0);
static int32 i;
qbs_set(strz, qbs_add(oldname, qbs_new_txt_len("\0", 1)));
qbs_set(strz2, qbs_add(newname, qbs_new_txt_len("\0", 1)));
if (rename(fixdir(strz), fixdir(strz2))) {
i = errno;
if (i == ENOENT) {
error(53);
return;
} // file not found
if (i == EINVAL) {
error(64);
return;
} // bad file name
if (i == EACCES) {
error(75);
return;
} // path/file access error
error(5); // Illegal function call (assumed)
}
}
void sub_chdir(qbs *str) {
if (new_error)
return;
static qbs *strz = NULL;
if (!strz)
strz = qbs_new(0, 0);
qbs_set(strz, qbs_add(str, qbs_new_txt_len("\0", 1)));
if (chdir(fixdir(strz)) == -1) {
// assume errno==ENOENT
error(76); // path not found
}
static int32 tmp_long;
static int32 got_ports = 0;
}
void sub_mkdir(qbs *str) {
if (new_error)
return;
static qbs *strz = NULL;
if (!strz)
strz = qbs_new(0, 0);
qbs_set(strz, qbs_add(str, qbs_new_txt_len("\0", 1)));
#ifdef QB64_UNIX
if (mkdir(fixdir(strz), 0770) == -1) {
#else
if (mkdir(fixdir(strz)) == -1) {
#endif
if (errno == EEXIST) {
error(75);
return;
} // path/file access error
// assume errno==ENOENT
error(76); // path not found
}
}
void sub_rmdir(qbs *str) {
if (new_error)
return;
static qbs *strz = NULL;
if (!strz)
strz = qbs_new(0, 0);
qbs_set(strz, qbs_add(str, qbs_new_txt_len("\0", 1)));
if (rmdir(fixdir(strz)) == -1) {
if (errno == ENOTEMPTY) {
error(75);
return;
} // path/file access error
// assume errno==ENOENT
error(76); // path not found
}
}
long double pow2(long double x, long double y) {
if (x < 0) {
if (y != std::floor(y)) {
@ -24962,7 +24787,7 @@ int32_t func__loadfont(qbs *file_name, int32_t size, qbs *requirements, int32_t
FONT_DEBUG_PRINT("Loading font from memory. Size = %i", bytes);
} else {
qbs_set(fileNameZ, qbs_add(file_name, qbs_new_txt_len("\0", 1))); // s1 = filename + CHR$(0)
content = FontLoadFileToMemory((char *)fileNameZ->chr, &bytes); // this we must free!!!
content = FontLoadFileToMemory(filepath_fix_directory(fileNameZ), &bytes); // this we must free!!!
FONT_DEBUG_PRINT("Loading font from file %s", fileNameZ->chr);
}
@ -26588,7 +26413,7 @@ void sub_run(qbs *f) {
strz = qbs_new(0, 0);
qbs_set(str, f);
fixdir(str);
filepath_fix_directory(str);
#ifdef QB64_WINDOWS
@ -29733,24 +29558,24 @@ int32 gfs_open(qbs *filename, int32 access, int32 restrictions, int32 how) {
if (how == 2) {
// with truncate
if (access == 1)
f->file_handle->open(fixdir(filenamez), std::ios::in | std::ios::binary | std::ios::trunc);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::in | std::ios::binary | std::ios::trunc);
if (access == 2)
f->file_handle->open(fixdir(filenamez), std::ios::out | std::ios::binary | std::ios::trunc);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::out | std::ios::binary | std::ios::trunc);
if (access == 3)
f->file_handle->open(fixdir(filenamez), std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc);
} else {
// without truncate
if (access == 1)
f->file_handle->open(fixdir(filenamez), std::ios::in | std::ios::binary);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::in | std::ios::binary);
if (access == 2)
f->file_handle->open(fixdir(filenamez), std::ios::out | std::ios::binary | std::ios::app);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::out | std::ios::binary | std::ios::app);
if (access == 3)
f->file_handle->open(fixdir(filenamez), std::ios::in | std::ios::out | std::ios::binary);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::in | std::ios::out | std::ios::binary);
}
if (how) {
if (!f->file_handle->is_open()) { // couldn't open file, so attempt creation
f->file_handle_o = new std::ofstream();
f->file_handle_o->open(fixdir(filenamez), std::ios::out);
f->file_handle_o->open(filepath_fix_directory(filenamez), std::ios::out);
if (f->file_handle_o->is_open()) { // created new file
f->file_handle_o->close();
// retry open
@ -29758,19 +29583,19 @@ int32 gfs_open(qbs *filename, int32 access, int32 restrictions, int32 how) {
if (how == 2) {
// with truncate
if (access == 1)
f->file_handle->open(fixdir(filenamez), std::ios::in | std::ios::binary | std::ios::trunc);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::in | std::ios::binary | std::ios::trunc);
if (access == 2)
f->file_handle->open(fixdir(filenamez), std::ios::out | std::ios::binary | std::ios::trunc);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::out | std::ios::binary | std::ios::trunc);
if (access == 3)
f->file_handle->open(fixdir(filenamez), std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::in | std::ios::out | std::ios::binary | std::ios::trunc);
} else {
// without truncate
if (access == 1)
f->file_handle->open(fixdir(filenamez), std::ios::in | std::ios::binary);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::in | std::ios::binary);
if (access == 2)
f->file_handle->open(fixdir(filenamez), std::ios::out | std::ios::binary | std::ios::app);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::out | std::ios::binary | std::ios::app);
if (access == 3)
f->file_handle->open(fixdir(filenamez), std::ios::in | std::ios::out | std::ios::binary);
f->file_handle->open(filepath_fix_directory(filenamez), std::ios::in | std::ios::out | std::ios::binary);
}
}
delete f->file_handle_o;
@ -29906,7 +29731,7 @@ int32 gfs_open(qbs *filename, int32 access, int32 restrictions, int32 how) {
if (how)
x3 = OPEN_ALWAYS;
undefined_retry:
f_w->file_handle = CreateFile(fixdir(filenamez), x, x2, NULL, x3, FILE_ATTRIBUTE_NORMAL, NULL);
f_w->file_handle = CreateFile(filepath_fix_directory(filenamez), x, x2, NULL, x3, FILE_ATTRIBUTE_NORMAL, NULL);
if (f_w->file_handle == INVALID_HANDLE_VALUE) {
if (how == 3) {
@ -29950,7 +29775,7 @@ undefined_retry:
if (GetFileSize_low || GetFileSize_high) {
CloseHandle(f_w->file_handle);
x3 = TRUNCATE_EXISTING;
f_w->file_handle = CreateFile(fixdir(filenamez), x, x2, NULL, x3, FILE_ATTRIBUTE_NORMAL, NULL);
f_w->file_handle = CreateFile(filepath_fix_directory(filenamez), x, x2, NULL, x3, FILE_ATTRIBUTE_NORMAL, NULL);
if (f_w->file_handle == INVALID_HANDLE_VALUE) {
gfs_free(i);
@ -31669,134 +31494,6 @@ failed:;
#endif
void sub_files(qbs *str, int32 passed) {
if (new_error)
return;
static int32 i, i2, i3;
static qbs *strz = NULL;
if (!strz)
strz = qbs_new(0, 0);
if (passed) {
qbs_set(strz, qbs_add(str, qbs_new_txt_len("\0", 1)));
} else {
qbs_set(strz, qbs_new_txt_len("\0", 1));
}
#ifdef QB64_WINDOWS
static WIN32_FIND_DATA fd;
static HANDLE hFind;
static qbs *strpath = NULL;
if (!strpath)
strpath = qbs_new(0, 0);
static qbs *strz2 = NULL;
if (!strz2)
strz2 = qbs_new(0, 0);
i = 0;
if (strz->len >= 2) {
if (strz->chr[strz->len - 2] == 92)
i = 1;
} else
i = 1;
if (i) { // add * (and new NULL term.)
strz->chr[strz->len - 1] = 42; //"*"
qbs_set(strz, qbs_add(strz, qbs_new_txt_len("\0", 1)));
}
qbs_set(strpath, strz);
for (i = strpath->len; i > 0; i--) {
if ((strpath->chr[i - 1] == 47) || (strpath->chr[i - 1] == 92)) {
strpath->len = i;
break;
}
} // i
if (i == 0)
strpath->len = 0; // no path specified
// print the current path
// note: for QBASIC compatibility reasons it does not print the directory name of the files being displayed
static uint8 curdir[4096];
static uint8 curdir2[4096];
i2 = GetCurrentDirectory(4096, (char *)curdir);
if (i2) {
i2 = GetShortPathName((char *)curdir, (char *)curdir2, 4096);
if (i2) {
qbs_set(strz2, qbs_ucase(qbs_new_txt_len((char *)curdir2, i2)));
qbs_print(strz2, 1);
} else {
error(5);
return;
}
} else {
error(5);
return;
}
hFind = FindFirstFile(fixdir(strz), &fd);
if (hFind == INVALID_HANDLE_VALUE) {
error(53);
return;
} // file not found
do {
if (!fd.cAlternateFileName[0]) { // no alternate filename exists
qbs_set(strz2, qbs_ucase(qbs_new_txt_len(fd.cFileName, strlen(fd.cFileName))));
} else {
qbs_set(strz2, qbs_ucase(qbs_new_txt_len(fd.cAlternateFileName, strlen(fd.cAlternateFileName))));
}
if (strz2->len < 12) { // padding required
qbs_set(strz2, qbs_add(strz2, func_space(12 - strz2->len)));
i2 = 0;
for (i = 0; i < 12; i++) {
if (strz2->chr[i] == 46) {
memmove(&strz2->chr[8], &strz2->chr[i], 4);
memset(&strz2->chr[i], 32, 8 - i);
break;
}
} // i
} // padding
// add " " or "<DIR> "
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
qbs_set(strz2, qbs_add(strz2, qbs_new_txt_len("<DIR> ", 6)));
} else {
qbs_set(strz2, qbs_add(strz2, func_space(6)));
}
makefit(strz2);
qbs_print(strz2, 0);
} while (FindNextFile(hFind, &fd));
FindClose(hFind);
static ULARGE_INTEGER FreeBytesAvailableToCaller;
static ULARGE_INTEGER TotalNumberOfBytes;
static ULARGE_INTEGER TotalNumberOfFreeBytes;
static int64 bytes;
static char *cp;
qbs_set(strpath, qbs_add(strpath, qbs_new_txt_len("\0", 1)));
cp = (char *)strpath->chr;
if (strpath->len == 1)
cp = NULL;
if (GetDiskFreeSpaceEx(cp, &FreeBytesAvailableToCaller, &TotalNumberOfBytes, &TotalNumberOfFreeBytes)) {
bytes = *(int64 *)(void *)&FreeBytesAvailableToCaller;
} else {
bytes = 0;
}
if (func_pos(NULL) > 1) {
strz2->len = 0;
qbs_print(strz2, 1);
} // new line if necessary
qbs_set(strz2, qbs_add(qbs_str(bytes), qbs_new_txt_len(" Bytes free", 11)));
qbs_print(strz2, 1);
#endif
}
int32 func__keyhit() {
/*
//keyhit cyclic buffer
@ -33463,65 +33160,6 @@ int32 func_strig(int32 i, int32 controller, int32 passed) {
return 0;
}
int32 func__fileexists(qbs *file) {
if (new_error)
return 0;
static qbs *strz = NULL;
if (!strz)
strz = qbs_new(0, 0);
qbs_set(strz, qbs_add(file, qbs_new_txt_len("\0", 1)));
#ifdef QB64_WINDOWS
static int32 x;
x = GetFileAttributes(fixdir(strz));
if (x == INVALID_FILE_ATTRIBUTES)
return 0;
if (x & FILE_ATTRIBUTE_DIRECTORY)
return 0;
return -1;
#elif defined(QB64_UNIX)
struct stat sb;
if (stat(fixdir(strz), &sb) == 0 && S_ISREG(sb.st_mode))
return -1;
return 0;
#else
// generic method (not currently used)
static std::ifstream fh;
fh.open(fixdir(strz), std::ios::binary | std::ios::in);
if (fh.is_open() == NULL) {
fh.clear(std::ios::goodbit);
return 0;
}
fh.clear(std::ios::goodbit);
fh.close();
return -1;
#endif
}
int32 func__direxists(qbs *file) {
if (new_error)
return 0;
static qbs *strz = NULL;
if (!strz)
strz = qbs_new(0, 0);
qbs_set(strz, qbs_add(file, qbs_new_txt_len("\0", 1)));
#ifdef QB64_WINDOWS
static int32 x;
x = GetFileAttributes(fixdir(strz));
if (x == INVALID_FILE_ATTRIBUTES)
return 0;
if (x & FILE_ATTRIBUTE_DIRECTORY)
return -1;
return 0;
#elif defined(QB64_UNIX)
struct stat sb;
if (stat(fixdir(strz), &sb) == 0 && S_ISDIR(sb.st_mode))
return -1;
return 0;
#else
return 0; // default response
#endif
}
int32 func__console() {
if (new_error)
return -1;
@ -36318,219 +35956,8 @@ int32 func__resizeheight() { return resize_event_y; }
int32 func__scaledwidth() { return environment_2d__screen_scaled_width; }
int32 func__scaledheight() { return environment_2d__screen_scaled_height; }
// Get Current Working Directory
qbs *func__cwd() {
qbs *final, *tqbs;
int length;
char *buf, *ret;
#if defined QB64_WINDOWS
length = GetCurrentDirectoryA(0, NULL);
buf = (char *)malloc(length);
if (!buf) {
error(7); //"Out of memory"
return tqbs;
}
if (GetCurrentDirectoryA(length, buf) != --length) { // Sanity check
free(buf); // It's good practice
tqbs = qbs_new(0, 1);
error(51); //"Internal error"
return tqbs;
}
#elif defined QB64_UNIX
length = 512;
while (1) {
buf = (char *)malloc(length);
if (!buf) {
tqbs = qbs_new(0, 1);
error(7);
return tqbs;
}
ret = getcwd(buf, length);
if (ret)
break;
if (errno != ERANGE) {
tqbs = qbs_new(0, 1);
error(51);
return tqbs;
}
free(buf);
length += 512;
}
length = strlen(ret);
ret = (char *)realloc(ret, length); // Chops off the null byte
if (!ret) {
tqbs = qbs_new(0, 1);
error(7);
return tqbs;
}
buf = ret;
#endif
final = qbs_new(length, 1);
memcpy(final->chr, buf, length);
free(buf);
return final;
}
qbs *startDir = NULL; // set on startup
qbs *func__startdir() {
qbs *temp = qbs_new(0, 1);
qbs_set(temp, startDir);
return temp;
}
qbs *rootDir = NULL; // the dir moved to when program begins
qbs *func__dir(qbs *context_in) {
static qbs *context = NULL;
if (!context) {
context = qbs_new(0, 0);
}
qbs_set(context, qbs_ucase(context_in));
if (qbs_equal(qbs_ucase(context), qbs_new_txt("TEXT")) || qbs_equal(qbs_ucase(context), qbs_new_txt("DOCUMENT")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("DOCUMENTS")) || qbs_equal(qbs_ucase(context), qbs_new_txt("MY DOCUMENTS"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 5, NULL, 0, osPath))) { // Documents
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("MUSIC")) || qbs_equal(qbs_ucase(context), qbs_new_txt("AUDIO")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("SOUND")) || qbs_equal(qbs_ucase(context), qbs_new_txt("SOUNDS")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("MY MUSIC"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 13, NULL, 0, osPath))) { // Music
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("PICTURE")) || qbs_equal(qbs_ucase(context), qbs_new_txt("PICTURES")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("IMAGE")) || qbs_equal(qbs_ucase(context), qbs_new_txt("IMAGES")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("MY PICTURES"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 39, NULL, 0, osPath))) { // Pictures
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("DCIM")) || qbs_equal(qbs_ucase(context), qbs_new_txt("CAMERA")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("CAMERA ROLL")) || qbs_equal(qbs_ucase(context), qbs_new_txt("PHOTO")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("PHOTOS"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 39, NULL, 0, osPath))) { // Pictures
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("MOVIE")) || qbs_equal(qbs_ucase(context), qbs_new_txt("MOVIES")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("VIDEO")) || qbs_equal(qbs_ucase(context), qbs_new_txt("VIDEOS")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("MY VIDEOS"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 14, NULL, 0, osPath))) { // Videos
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("DOWNLOAD")) || qbs_equal(qbs_ucase(context), qbs_new_txt("DOWNLOADS"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 0x0028, NULL, 0, osPath))) { // user folder
// XP & SHGetFolderPathA do not support the concept of a Downloads folder, however it can be constructed
mkdir((char *)((qbs_add(qbs_new_txt(osPath), qbs_new_txt_len("\\Downloads\0", 11)))->chr));
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\Downloads\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("DESKTOP"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 0, NULL, 0, osPath))) { // Desktop
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("APPDATA")) || qbs_equal(qbs_ucase(context), qbs_new_txt("APPLICATION DATA")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAM DATA")) || qbs_equal(qbs_ucase(context), qbs_new_txt("DATA"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 0x001a, NULL, 0, osPath))) { // CSIDL_APPDATA (%APPDATA%)
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("LOCALAPPDATA")) || qbs_equal(qbs_ucase(context), qbs_new_txt("LOCAL APPLICATION DATA")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("LOCAL PROGRAM DATA")) || qbs_equal(qbs_ucase(context), qbs_new_txt("LOCAL DATA"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 0x001c, NULL, 0, osPath))) { // CSIDL_LOCAL_APPDATA (%LOCALAPPDATA%)
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAMFILES")) || qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAM FILES"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 0x0026, NULL, 0, osPath))) { // CSIDL_PROGRAM_FILES (%PROGRAMFILES%)
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAMFILESX86")) || qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAMFILES X86")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAM FILES X86")) || qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAM FILES 86")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAM FILES (X86)")) || qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAMFILES (X86)")) ||
qbs_equal(qbs_ucase(context), qbs_new_txt("PROGRAM FILES(X86)"))) {
#ifdef QB64_WINDOWS &&_WIN64
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 0x002a, NULL, 0, osPath))) { // CSIDL_PROGRAM_FILES (%PROGRAMFILES(X86)%)
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
#endif
}
if (qbs_equal(qbs_ucase(context), qbs_new_txt("TEMP")) || qbs_equal(qbs_ucase(context), qbs_new_txt("TEMP FILES"))) {
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH + 1];
DWORD pathlen;
pathlen = GetTempPathA(261, osPath); //%TEMP%
char path[pathlen];
memcpy(path, &osPath, pathlen);
if (pathlen > 0) {
return qbs_new_txt(path);
}
#endif
}
// general fallback location
#ifdef QB64_WINDOWS
CHAR osPath[MAX_PATH];
if (SUCCEEDED(SHGetFolderPathA(NULL, 0, NULL, 0, osPath))) { // desktop
return qbs_add(qbs_new_txt(osPath), qbs_new_txt("\\"));
}
return qbs_new_txt(".\\"); // current location
#else
return qbs_new_txt("./"); // current location
#endif
}
extern void set_dynamic_info();
int main(int argc, char *argv[]) {
#if defined(QB64_LINUX) && defined(X11)
@ -36716,9 +36143,9 @@ int main(int argc, char *argv[]) {
singlespace = qbs_new_cmem(1, 0);
singlespace->chr[0] = 32;
// store _CWD$ for recall using _STARTDIR$ in startDir
startDir = qbs_new(0, 0);
qbs_set(startDir, func__cwd());
// store _CWD$ for recall using _STARTDIR$ in g_startDir
g_startDir = qbs_new(0, 0);
qbs_set(g_startDir, func__cwd());
// switch to directory of this EXE file
// http://stackoverflow.com/questions/1023306/finding-current-executables-path-without-proc-self-exe
@ -36753,9 +36180,6 @@ int main(int argc, char *argv[]) {
}
#endif
rootDir = qbs_new(0, 0);
qbs_set(rootDir, func__cwd());
unknown_opcode_mess = qbs_new(0, 0);
qbs_set(unknown_opcode_mess, qbs_new_txt_len("Unknown Opcode ( )\0", 20));

View file

@ -34,6 +34,20 @@ qbs *qbs_new_txt(const char *);
qbs *qbs_new_txt_len(const char *, int32_t);
qbs *qbs_add(qbs *, qbs *);
qbs *qbs_set(qbs *, qbs *);
int32 qbs_equal(qbs *str1, qbs *str2);
qbs *func_space(int32 spaces);
void makefit(qbs *text);
qbs *qbs_str(int64 value);
qbs *qbs_str(int32 value);
qbs *qbs_str(int16 value);
qbs *qbs_str(int8 value);
qbs *qbs_str(uint64 value);
qbs *qbs_str(uint32 value);
qbs *qbs_str(uint16 value);
qbs *qbs_str(uint8 value);
qbs *qbs_str(float value);
qbs *qbs_str(double value);
qbs *qbs_str(long double value);
void qbg_sub_window(float, float, float, float, int32);
extern int32 autodisplay;
// GFS forward references

View file

@ -2,6 +2,7 @@
libqb-objs-y += $(PATH_LIBQB)/src/threading.o
libqb-objs-y += $(PATH_LIBQB)/src/buffer.o
libqb-objs-y += $(PATH_LIBQB)/src/filepath.o
libqb-objs-y += $(PATH_LIBQB)/src/filesystem.o
libqb-objs-y += $(PATH_LIBQB)/src/datetime.o
libqb-objs-y += $(PATH_LIBQB)/src/rounding.o
@ -20,4 +21,12 @@ ifeq ($(OS),osx)
libqb-objs-y$(DEP_CONSOLE_ONLY) += $(PATH_LIBQB)/src/mac-key-monitor.o
endif
$(PATH_LIBQB)/src/%.o: $(PATH_LIBQB)/src/%.cpp
$(CXX) -O2 $(CXXFLAGS) -Wall $< -c -o $@
ifeq ($(OS),osx)
$(PATH_LIBQB)/src/%.o: $(PATH_LIBQB)/src/%.mm
$(CXX) -O2 $(CXXFLAGS) -Wall $< -c -o $@
endif
CLEAN_LIST += $(libqb-objs-y) $(libqb-objs-yy) $(libqb-objs-)

View file

@ -1,6 +1,10 @@
#ifndef INCLUDE_LIBQB_FILEPATH_H
#define INCLUDE_LIBQB_FILEPATH_H
#include <string>
struct qbs;
// Takes a path + filename, and returns just the filename portion
// Returns either NULL or empty string if it has none.
const char *filepath_get_filename(const char *path);
@ -12,4 +16,15 @@ const char *filepath_get_extension(const char *fliename);
// Returns true if the path is to a file that matches the provided extension
bool filepath_has_extension(const char *path, const char *extension);
// The following overloaded functions changes the path separators in path based on the OS (path is modified)
const char *filepath_fix_directory(char *path);
const char *filepath_fix_directory(qbs *path);
const char *filepath_fix_directory(std::string &path);
// Splits a file path into directory and file name
void filepath_split(const std::string &filePath, std::string &directory, std::string &fileName);
// Joins a directory and file name into a file path
void filepath_join(std::string &filePath, const std::string &directory, const std::string &fileName);
#endif

View file

@ -0,0 +1,26 @@
//-----------------------------------------------------------------------------------------------------
// QB64-PE filesystem related functions
//-----------------------------------------------------------------------------------------------------
#pragma once
#include <stdint.h>
struct qbs;
/// @brief This is a global variable that is set on startup and holds the directory that was current when the program was loaded
extern qbs *g_startDir;
qbs *func__cwd();
qbs *func__dir(qbs *qbsContext);
int32_t func__direxists(qbs *path);
int32_t func__fileexists(qbs *path);
qbs *func__startdir();
void sub_chdir(qbs *str);
qbs *func__files(qbs *qbsFileSpec, int32_t passed);
qbs *func__fullpath(qbs *qbsPathName);
void sub_files(qbs *str, int32_t passed);
void sub_kill(qbs *str);
void sub_mkdir(qbs *str);
void sub_name(qbs *oldname, qbs *newname);
void sub_rmdir(qbs *str);

View file

@ -3,10 +3,12 @@
#include "libqb-common.h"
#include <string.h>
#include <algorithm>
const char *filepath_get_filename(const char *path)
{
#include "../../libqb.h"
#include "filepath.h"
const char *filepath_get_filename(const char *path) {
const char *fileName;
if (path == NULL) {
@ -32,8 +34,7 @@ const char *filepath_get_filename(const char *path)
return fileName;
}
const char *filepath_get_extension(const char *path)
{
const char *filepath_get_extension(const char *path) {
const char *extension;
const char *lastOccurance;
@ -57,8 +58,7 @@ const char *filepath_get_extension(const char *path)
return (lastOccurance != NULL) ? lastOccurance : extension;
}
bool filepath_has_extension(const char *path, const char *extension)
{
bool filepath_has_extension(const char *path, const char *extension) {
const char *ext1;
const char *ext2;
@ -75,3 +75,86 @@ bool filepath_has_extension(const char *path, const char *extension)
return strcasecmp(ext1, ext2) == 0;
#endif
}
/// @brief Changes the slashes in a file name / path to make it compatible with the OS
/// @param path The path to fix (contents may be changed)
/// @return Returns the C-string for convenience
const char *filepath_fix_directory(char *path) {
auto len = strlen(path);
for (size_t i = 0; i < len; i++) {
#ifdef QB64_WINDOWS
if (path[i] == '/')
path[i] = '\\';
#else
if (path[i] == '\\')
path[i] = '/';
#endif
}
return path;
}
/// @brief Changes the slashes in a file name / path to make it compatible with the OS
/// @param path The path to fix (contents may be changed)
/// @return Returns the C-string for convenience
const char *filepath_fix_directory(qbs *path) {
for (size_t i = 0; i < path->len; i++) {
#ifdef QB64_WINDOWS
if (path->chr[i] == '/')
path->chr[i] = '\\';
#else
if (path->chr[i] == '\\')
path->chr[i] = '/';
#endif
}
return reinterpret_cast<char *>(path->chr);
}
/// @brief Changes the slashes in a file name / path to make it compatible with the OS
/// @param path The path to fix (contents may be changed)
/// @return Returns the C-string for convenience
const char *filepath_fix_directory(std::string &path) {
std::transform(path.begin(), path.end(), path.begin(), [](unsigned char c) {
#ifdef QB64_WINDOWS
return c == '/' ? '\\' : c;
#else
return c == '\\' ? '/' : c;
#endif
});
return path.c_str();
}
// Splits a file path into directory and file name
void filepath_split(const std::string &filePath, std::string &directory, std::string &fileName) {
// Find the last occurrence of either '/' or '\\'
size_t lastSlash = filePath.find_last_of("/\\");
if (lastSlash != std::string::npos) {
directory = filePath.substr(0, lastSlash + 1); // include the trailing separator
fileName = filePath.substr(lastSlash + 1);
} else {
// No directory separator found
directory.clear();
fileName = filePath;
}
}
// Joins a directory and file name into a file path
void filepath_join(std::string &filePath, const std::string &directory, const std::string &fileName) {
// Check if the directory has a trailing separator, and add one if not
filePath = directory;
if (!filePath.empty() && filePath.back() != '/' && filePath.back() != '\\') {
#ifdef QB64_WINDOWS
filePath += '\\';
#else
filePath += '/';
#endif
}
// Append the file name to the directory
filePath += fileName;
}

View file

@ -0,0 +1,974 @@
//-----------------------------------------------------------------------------------------------------
// QB64-PE filesystem related functions
//-----------------------------------------------------------------------------------------------------
#include "libqb-common.h"
#include "filepath.h"
#include "filesystem.h"
#include "../../libqb.h"
#include <algorithm>
#include <dirent.h>
#include <sys/stat.h>
#include <unistd.h>
#ifdef QB64_WINDOWS
# include <shlobj.h>
#else
# include <sys/statvfs.h>
#endif
#ifdef QB64_BACKSLASH_FILESYSTEM
# define FS_PATH_SEPARATOR '\\'
#else
# define FS_PATH_SEPARATOR '/'
#endif
#if (FILENAME_MAX > 4096)
# define FS_PATHNAME_LENGTH_MAX FILENAME_MAX
#else
# define FS_PATHNAME_LENGTH_MAX 4096
#endif
/// @brief This is a global variable that is set on startup and holds the directory that was current when the program was loaded
qbs *g_startDir = nullptr;
/// @brief Gets the current working directory
/// @return A qbs containing the current working directory or an empty string on error
qbs *func__cwd() {
std::string path;
qbs *qbsFinal;
path.resize(FILENAME_MAX, '\0');
for (;;) {
if (getcwd(&path[0], path.size())) {
auto size = strlen(path.c_str());
qbsFinal = qbs_new(size, 1);
memcpy(qbsFinal->chr, &path[0], size);
return qbsFinal;
} else {
if (errno == ERANGE)
path.resize(path.size() << 1, '\0'); // buffer size was not sufficient; try again with a larger buffer
else
break; // some other error occurred
}
}
qbsFinal = qbs_new(0, 1);
error(QB_ERROR_INTERNAL_ERROR);
return qbsFinal;
}
/// @brief Returns true if the specified directory exists
/// @param path The directory to check for
/// @return True if the directory exists
static inline bool FS_DirectoryExists(const char *path) {
#ifdef QB64_WINDOWS
auto x = GetFileAttributesA(path);
return x != INVALID_FILE_ATTRIBUTES && (x & FILE_ATTRIBUTE_DIRECTORY);
#else
struct stat info;
return stat(path, &info) == 0 && S_ISDIR(info.st_mode);
#endif
}
/// @brief Known directories (primarily Windows based, but we'll do our best to emulate on other platforms)
enum class FS_KnownDirectory {
HOME = 0,
DESKTOP,
DOCUMENTS,
PICTURES,
MUSIC,
VIDEOS,
DOWNLOAD,
APP_DATA,
LOCAL_APP_DATA,
PROGRAM_DATA,
SYSTEM_FONTS,
USER_FONTS,
TEMP,
PROGRAM_FILES,
PROGRAM_FILES_32,
};
#ifdef QB64_WINDOWS
/// @brief Returns the full path for a known directory
/// @param kD Is a value from FS_KnownDirectory (above)
/// @return The full path that ends with the system path separator
static std::string FS_GetKnownDirectory(FS_KnownDirectory kD) {
std::string path(FS_PATHNAME_LENGTH_MAX, '\0'); // allocate something that is sufficiently large
switch (kD) {
case FS_KnownDirectory::DESKTOP: // %USERPROFILE%\OneDrive\Desktop
SHGetFolderPathA(NULL, CSIDL_DESKTOPDIRECTORY | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::DOCUMENTS: // %USERPROFILE%\OneDrive\Documents
SHGetFolderPathA(NULL, CSIDL_MYDOCUMENTS | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::PICTURES: // %USERPROFILE%\OneDrive\Pictures
SHGetFolderPathA(NULL, CSIDL_MYPICTURES | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::MUSIC: // %USERPROFILE%\Music
SHGetFolderPathA(NULL, CSIDL_MYMUSIC | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::VIDEOS: // %USERPROFILE%\Videos
SHGetFolderPathA(NULL, CSIDL_MYVIDEO | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::DOWNLOAD: // %USERPROFILE%\Downloads
if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_PROFILE | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]))) {
// XP & SHGetFolderPathA do not support the concept of a Downloads folder, however it can be constructed
path.resize(strlen(path.c_str()));
path.append("\\Downloads");
mkdir(path.c_str());
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::APP_DATA: // %USERPROFILE%\AppData\Roaming
SHGetFolderPathA(NULL, CSIDL_APPDATA | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::LOCAL_APP_DATA: // %USERPROFILE%\AppData\Local
SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::PROGRAM_DATA: // %SystemDrive%\ProgramData
SHGetFolderPathA(NULL, CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::SYSTEM_FONTS: // %SystemRoot%\Fonts
SHGetFolderPathA(NULL, CSIDL_FONTS | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::USER_FONTS: // %USERPROFILE%\AppData\Local\Microsoft\Windows\Fonts
if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]))) {
path.resize(strlen(path.c_str()));
path.append("\\Microsoft\\Windows\\Fonts");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::TEMP: // %USERPROFILE%\AppData\Local\Temp
GetTempPathA(path.size(), &path[0]);
break;
case FS_KnownDirectory::PROGRAM_FILES: // %SystemDrive%\Program Files
SHGetFolderPathA(NULL, CSIDL_PROGRAM_FILES | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
break;
case FS_KnownDirectory::PROGRAM_FILES_32: // %SystemDrive%\Program Files (x86)
# ifdef _WIN64
SHGetFolderPathA(NULL, CSIDL_PROGRAM_FILESX86 | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
# else
SHGetFolderPathA(NULL, CSIDL_PROGRAM_FILES | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
# endif
break;
case FS_KnownDirectory::HOME: // %USERPROFILE%
default:
SHGetFolderPathA(NULL, CSIDL_PROFILE | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0]);
}
// Check if we got anything at all
if (!strlen(path.c_str())) {
path.resize(FS_PATHNAME_LENGTH_MAX, '\0'); // just in case this was shrunk above
if (FAILED(SHGetFolderPathA(NULL, CSIDL_PROFILE | CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, &path[0])))
path.assign(".\\"); // fallback to the current directory
}
// Add the trailing slash
path.resize(strlen(path.c_str()));
if (path.back() != FS_PATH_SEPARATOR)
path.append(1, FS_PATH_SEPARATOR);
return path;
}
#else
/// @brief Returns the full path for a known directory
/// @param kD Is a value from FS_KnownDirectory (above)
/// @return The full path that ends with the system path separator
static std::string FS_GetKnownDirectory(FS_KnownDirectory kD) {
std::string path;
auto envVar = getenv("HOME");
switch (kD) {
case FS_KnownDirectory::DESKTOP: // %USERPROFILE%\OneDrive\Desktop
if (envVar) {
path.assign(envVar);
path.append("/Desktop");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::DOCUMENTS: // %USERPROFILE%\OneDrive\Documents
if (envVar) {
path.assign(envVar);
path.append("/Documents");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::PICTURES: // %USERPROFILE%\OneDrive\Pictures
if (envVar) {
path.assign(envVar);
path.append("/Pictures");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::MUSIC: // %USERPROFILE%\Music
if (envVar) {
path.assign(envVar);
path.append("/Music");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::VIDEOS: // %USERPROFILE%\Videos
if (envVar) {
path.assign(envVar);
# ifdef QB64_MACOSX
path.append("/Movies");
# else
path.append("/Videos");
# endif
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::DOWNLOAD: // %USERPROFILE%\Downloads
if (envVar) {
path.assign(envVar);
path.append("/Downloads");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::APP_DATA: // %USERPROFILE%\AppData\Roaming
if (envVar) {
path.assign(envVar);
path.append("/.config");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::LOCAL_APP_DATA: // %USERPROFILE%\AppData\Local
case FS_KnownDirectory::PROGRAM_DATA: // %SystemDrive%\ProgramData
if (envVar) {
path.assign(envVar);
path.append("/.local/share");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::SYSTEM_FONTS: // %SystemRoot%\Fonts
# ifdef QB64_MACOSX
path.assign("/System/Library/Fonts");
if (!FS_DirectoryExists(path.c_str())) {
path.assign("/Library/Fonts");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
# else
path.assign("/usr/share/fonts");
if (!FS_DirectoryExists(path.c_str())) {
path.assign("/usr/local/share/fonts");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
# endif
break;
case FS_KnownDirectory::USER_FONTS: // %USERPROFILE%\AppData\Local\Microsoft\Windows\Fonts
if (envVar) {
path.assign(envVar);
# ifdef QB64_MACOSX
path.append("/Library/Fonts");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
# else
path.append("/.local/share/fonts");
if (!FS_DirectoryExists(path.c_str())) {
path.assign(envVar);
path.append("/.fonts");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
# endif
}
break;
case FS_KnownDirectory::TEMP: // %USERPROFILE%\AppData\Local\Temp
path.assign("/var/tmp");
if (!FS_DirectoryExists(path.c_str())) {
path.assign("/tmp");
if (!FS_DirectoryExists(path.c_str()))
path.clear();
}
break;
case FS_KnownDirectory::PROGRAM_FILES: // %SystemDrive%\Program Files
case FS_KnownDirectory::PROGRAM_FILES_32: // %SystemDrive%\Program Files (x86)
# ifdef QB64_MACOSX
path.assign("/Applications");
# else
path.assign("/opt");
# endif
if (!FS_DirectoryExists(path.c_str()))
path.clear();
break;
case FS_KnownDirectory::HOME: // %USERPROFILE%
default:
if (envVar)
path.assign(envVar);
}
// Check if we got anything at all
if (!strlen(path.c_str()))
path.assign(envVar ? envVar : "./");
// Add the trailing slash
path.resize(strlen(path.c_str()));
if (path.back() != FS_PATH_SEPARATOR)
path.append(1, FS_PATH_SEPARATOR);
return path;
}
#endif
/// @brief Returns common paths such as My Documents, My Pictures, My Music, Desktop
/// @param qbsContext Is the directory type
/// @return A qbs containing the directory or an empty string on error
qbs *func__dir(qbs *qbsContext) {
std::string path, context(reinterpret_cast<char *>(qbsContext->chr), qbsContext->len);
std::transform(context.begin(), context.end(), context.begin(), [](unsigned char c) { return std::toupper(c); });
// The following is largely unchanged from what we previously had
if (context.compare("TEXT") == 0 || context.compare("DOCUMENT") == 0 || context.compare("DOCUMENTS") == 0 || context.compare("MY DOCUMENTS") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::DOCUMENTS);
} else if (context.compare("MUSIC") == 0 || context.compare("AUDIO") == 0 || context.compare("SOUND") == 0 || context.compare("SOUNDS") == 0 ||
context.compare("MY MUSIC") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::MUSIC);
} else if (context.compare("PICTURE") == 0 || context.compare("PICTURES") == 0 || context.compare("IMAGE") == 0 || context.compare("IMAGES") == 0 ||
context.compare("MY PICTURES") == 0 || context.compare("DCIM") == 0 || context.compare("CAMERA") == 0 || context.compare("CAMERA ROLL") == 0 ||
context.compare("PHOTO") == 0 || context.compare("PHOTOS") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::PICTURES);
} else if (context.compare("MOVIE") == 0 || context.compare("MOVIES") == 0 || context.compare("VIDEO") == 0 || context.compare("VIDEOS") == 0 ||
context.compare("MY VIDEOS") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::VIDEOS);
} else if (context.compare("DOWNLOAD") == 0 || context.compare("DOWNLOADS") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::DOWNLOAD);
} else if (context.compare("DESKTOP") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::DESKTOP);
} else if (context.compare("APPDATA") == 0 || context.compare("APPLICATION DATA") == 0 || context.compare("PROGRAM DATA") == 0 ||
context.compare("DATA") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::APP_DATA);
} else if (context.compare("LOCALAPPDATA") == 0 || context.compare("LOCAL APPLICATION DATA") == 0 || context.compare("LOCAL PROGRAM DATA") == 0 ||
context.compare("LOCAL DATA") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::LOCAL_APP_DATA);
} else if (context.compare("PROGRAMFILES") == 0 || context.compare("PROGRAM FILES") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::PROGRAM_FILES);
} else if (context.compare("PROGRAMFILESX86") == 0 || context.compare("PROGRAMFILES X86") == 0 || context.compare("PROGRAM FILES X86") == 0 ||
context.compare("PROGRAM FILES 86") == 0 || context.compare("PROGRAM FILES (X86)") == 0 || context.compare("PROGRAMFILES (X86)") == 0 ||
context.compare("PROGRAM FILES(X86)") == 0 || context.compare("PROGRAMFILES(X86)") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::PROGRAM_FILES_32);
} else if (context.compare("TMP") == 0 || context.compare("TEMP") == 0 || context.compare("TEMP FILES") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::TEMP);
} else if (context.compare("HOME") == 0 || context.compare("USER") == 0 || context.compare("PROFILE") == 0 || context.compare("USERPROFILE") == 0 ||
context.compare("USER PROFILE") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::HOME);
} else if (context.compare("FONT") == 0 || context.compare("FONTS") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::SYSTEM_FONTS);
} else if (context.compare("USERFONT") == 0 || context.compare("USER FONT") == 0 || context.compare("USERFONTS") == 0 ||
context.compare("USER FONTS") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::USER_FONTS);
} else if (context.compare("PROGRAMDATA") == 0 || context.compare("COMMON PROGRAM DATA") == 0) {
path = FS_GetKnownDirectory(FS_KnownDirectory::PROGRAM_DATA);
} else {
path = FS_GetKnownDirectory(FS_KnownDirectory::DESKTOP); // anything else defaults to the desktop where the user can easily see stuff
}
auto size = path.size();
auto qbsFinal = qbs_new(size, 1);
memcpy(qbsFinal->chr, &path[0], size);
return qbsFinal;
}
/// @brief Returns true if a directory specified exists
/// @param path The directory path
/// @return True if the directory exists
int32_t func__direxists(qbs *path) {
if (new_error)
return QB_FALSE;
std::string pathName(reinterpret_cast<char *>(path->chr), path->len);
return FS_DirectoryExists(filepath_fix_directory(pathName)) ? QB_TRUE : QB_FALSE;
}
/// @brief Returns true if a file specified exists
/// @param path The file path to check for
/// @return True if the file exists
static inline bool FS_FileExists(const char *path) {
#ifdef QB64_WINDOWS
auto x = GetFileAttributesA(path);
return x != INVALID_FILE_ATTRIBUTES && !(x & FILE_ATTRIBUTE_DIRECTORY);
#else
struct stat info;
return stat(path, &info) == 0 && S_ISREG(info.st_mode);
#endif
}
/// @brief Returns true if a file specified exists
/// @param path The file path to check for
/// @return True if the file exists
int32_t func__fileexists(qbs *path) {
if (new_error)
return QB_FALSE;
std::string pathName(reinterpret_cast<char *>(path->chr), path->len);
return FS_FileExists(filepath_fix_directory(pathName)) ? QB_TRUE : QB_FALSE;
}
/// @brief Return the startup directory
/// @return A qbs containing the directory path
qbs *func__startdir() {
auto temp = qbs_new(0, 1);
qbs_set(temp, g_startDir);
return temp;
}
/// @brief Changes the current directory
/// @param str The directory path to change to
void sub_chdir(qbs *str) {
if (new_error)
return;
std::string pathName(reinterpret_cast<char *>(str->chr), str->len);
if (chdir(filepath_fix_directory(pathName)) == -1)
error(QB_ERROR_PATH_NOT_FOUND); // assume errno == ENOENT; path not found
}
/// @brief Checks if s is an empty string (either NULL or zero length)
/// @param s A null-terminated string or NULL
/// @return False is we have a valid string > length 0
static inline bool FS_IsStringEmpty(const char *s) { return s == nullptr || s[0] == '\0'; }
/// @brief This is a basic pattern matching function used by FS_GetDirectoryEntryName()
/// @param fileSpec The pattern to match
/// @param fileName The filename to match
/// @return True if it is a match, false otherwise
static inline bool FS_IsPatternMatching(const char *fileSpec, const char *fileName) {
auto spec = fileSpec;
auto name = fileName;
const char *any = nullptr;
while (*spec || *name) {
switch (*spec) {
case '*': // handle wildcard '*' character
any = spec;
spec++;
while (*name && *name != *spec)
name++;
break;
case '?': // handle wildcard '?' character
spec++;
if (*name)
name++;
break;
default: // compare non-wildcard characters
if (*spec != *name) {
if (any && *name)
spec = any;
else
return false;
} else {
spec++;
name++;
}
break;
}
}
return true;
}
/// @brief Returns true if fileSpec has any wildcards
/// @param fileSpec The string to check
/// @return True if * or ? are found
static inline bool FS_HasPattern(const char *fileSpec) { return fileSpec != nullptr && (strchr(fileSpec, '*') || strchr(fileSpec, '?')); }
/// @brief An MS BASIC PDS DIR$ style function
/// @param fileSpec This can be a path with wildcard for the final level (i.e. C:/Windows/*.* or /usr/lib/* etc.)
/// @return Returns a file or directory name matching fileSpec or an empty string when there is nothing left
static const char *FS_GetDirectoryEntryName(const char *fileSpec) {
static DIR *pDir = nullptr;
static char pattern[FS_PATHNAME_LENGTH_MAX];
static char entry[FS_PATHNAME_LENGTH_MAX];
entry[0] = '\0'; // set to an empty string
if (!FS_IsStringEmpty(fileSpec)) {
// We got a filespec. Check if we have one already going and if so, close it
if (pDir) {
closedir(pDir);
pDir = nullptr;
}
char dirName[FS_PATHNAME_LENGTH_MAX]; // we only need this for opendir()
if (FS_HasPattern(fileSpec)) {
// We have a pattern. Check if we have a path in it
auto p = strrchr(fileSpec, '/'); // try *nix style separator
#ifdef QB64_WINDOWS
if (!p)
p = strrchr(fileSpec, '\\'); // try windows style separator
#endif
if (p) {
// Split the path and the filespec
strncpy(pattern, p + 1, FS_PATHNAME_LENGTH_MAX);
pattern[FS_PATHNAME_LENGTH_MAX - 1] = '\0';
auto len = std::min<size_t>((p - fileSpec) + 1, FS_PATHNAME_LENGTH_MAX - 1);
memcpy(dirName, fileSpec, len);
dirName[len] = '\0';
} else {
// No path. Use the current path
strncpy(pattern, fileSpec, FS_PATHNAME_LENGTH_MAX);
pattern[FS_PATHNAME_LENGTH_MAX - 1] = '\0';
strcpy(dirName, "./");
}
} else {
// No pattern. Check if this is a file and simply return the name if it exists
if (FS_FileExists(fileSpec)) {
strncpy(entry, filepath_get_filename(fileSpec), FS_PATHNAME_LENGTH_MAX);
entry[FS_PATHNAME_LENGTH_MAX - 1] = '\0';
return entry;
}
// Else, We'll just assume it's a directory
strncpy(dirName, fileSpec, FS_PATHNAME_LENGTH_MAX);
dirName[FS_PATHNAME_LENGTH_MAX - 1] = '\0';
strcpy(pattern, "*");
}
pDir = opendir(dirName);
}
if (pDir) {
for (;;) {
auto pDirent = readdir(pDir);
if (!pDirent) {
closedir(pDir);
pDir = nullptr;
break;
}
if (FS_IsPatternMatching(pattern, pDirent->d_name)) {
strncpy(entry, pDirent->d_name, FS_PATHNAME_LENGTH_MAX);
entry[FS_PATHNAME_LENGTH_MAX - 1] = '\0';
break;
}
}
}
return entry;
}
/// @brief This mimics MS BASIC PDS 7.1 & VBDOS 1.0 DIR$() function
/// @param qbsFileSpec This can be a path with wildcard for the final level (i.e. C:/Windows/*.* or /usr/lib/* etc.)
/// @param passed Flags for optional parameters
/// @return Retuns a qbs with the directory entry name or an empty string if there are no more entries
qbs *func__files(qbs *qbsFileSpec, int32_t passed) {
static std::string directory;
std::string pathName;
const char *entry;
qbs *qbsFinal;
// Check if fresh arguments were passed and we need to begin a new session
if (passed) {
std::string fileSpec(reinterpret_cast<char *>(qbsFileSpec->chr), qbsFileSpec->len);
if (FS_DirectoryExists(filepath_fix_directory(fileSpec)))
directory = fileSpec;
else
filepath_split(fileSpec, directory, pathName); // split the file path
entry = FS_GetDirectoryEntryName(fileSpec.c_str());
if (FS_IsStringEmpty(entry)) {
// This is per MS BASIC PDS 7.1 and VBDOS 1.0 behavior
qbsFinal = qbs_new(0, 1);
error(QB_ERROR_FILE_NOT_FOUND);
return qbsFinal;
}
} else {
entry = FS_GetDirectoryEntryName(nullptr);
}
filepath_join(pathName, directory, entry);
auto size = strlen(entry);
if (size && FS_DirectoryExists(pathName.c_str())) {
// Add a trailing slash if it is a directory
qbsFinal = qbs_new(size + 1, 1);
memcpy(qbsFinal->chr, entry, size);
qbsFinal->chr[size] = FS_PATH_SEPARATOR;
} else {
qbsFinal = qbs_new(size, 1);
memcpy(qbsFinal->chr, entry, size);
}
return qbsFinal;
}
/// @brief Returns the free volume space for a given directory
/// @param path A directory that resides on the volume we want the free space for
/// @return The free space in bytes
static uint64_t FS_GetFreeDiskSpace(const char *path) {
#ifdef QB64_WINDOWS
ULARGE_INTEGER freeBytesAvailable;
ULARGE_INTEGER totalNumberOfBytes;
ULARGE_INTEGER totalNumberOfFreeBytes;
if (GetDiskFreeSpaceExA(path, &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes))
return totalNumberOfFreeBytes.QuadPart;
#else
struct statvfs stat;
if (statvfs(path, &stat) == 0)
return static_cast<uint64_t>(stat.f_bsize) * stat.f_bfree;
#endif
return 0; // zero if something failed
}
/// @brief Gets the fully qualified name (FQN)
/// @param path The path name to get the FQN for
/// @return The FQN
static std::string FS_GetFQN(const char *path) {
std::string FQN = path; // fallback
#ifdef QB64_WINDOWS
DWORD size = GetFullPathNameA(path, 0, nullptr, nullptr); // get the required buffer size
if (size) {
FQN.resize(size);
if (GetFullPathNameA(path, size, &FQN[0], nullptr))
FQN.resize(size - 1); // resize to exclude the null terminator
}
#else
char *result = realpath(path, nullptr);
if (result) {
FQN = result;
free(result); // cleanup memory allocated by realpath
}
#endif
if (FS_DirectoryExists(FQN.c_str()) && FQN.back() != FS_PATH_SEPARATOR)
FQN.append(1, FS_PATH_SEPARATOR);
return FQN;
}
/// @brief Gets the fully qualified name (FQN)
/// @param qbsPathName The path name to get the FQN for
/// @return The FQN
qbs *func__fullpath(qbs *qbsPathName) {
qbs *temp;
if (!qbsPathName->len) {
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
temp = qbs_new(0, 1);
return temp;
}
std::string pathName(reinterpret_cast<char *>(qbsPathName->chr), qbsPathName->len);
filepath_fix_directory(pathName);
if (!FS_DirectoryExists(pathName.c_str()) && !FS_FileExists(pathName.c_str())) {
// Path not found
error(QB_ERROR_PATH_NOT_FOUND);
temp = qbs_new(0, 1);
return temp;
}
pathName = FS_GetFQN(pathName.c_str());
temp = qbs_new(pathName.size(), 1);
memcpy(temp->chr, &pathName[0], pathName.size());
return temp;
}
/// @brief Gets the short name for a file / directory (if possible)
/// @param path The file / directory to get the short name for
/// @return The short name
static std::string FS_GetShortName(const char *path) {
#ifdef QB64_WINDOWS
DWORD size = GetShortPathNameA(path, nullptr, 0); // get the required buffer size
if (size) {
std::string shortPath;
shortPath.resize(size);
if (GetShortPathNameA(path, &shortPath[0], size)) {
shortPath.resize(size - 1); // resize to exclude the null terminator
return shortPath;
}
}
#endif
return path; // return the path as-is for *nix or if GetShortPathNameA failed
}
/// @brief Prints a list of files in the current directory using a file specification
/// @param str Is a string containing a path (it can include wildcards)
/// @param passed Optional parameters
void sub_files(qbs *str, int32_t passed) {
static qbs *strz = nullptr;
if (new_error)
return;
if (!strz)
strz = qbs_new(0, 0);
std::string fileSpec, directory, pathName;
if (passed && str->len) {
fileSpec.assign(reinterpret_cast<char *>(str->chr), str->len);
if (FS_DirectoryExists(filepath_fix_directory(fileSpec))) {
directory = FS_GetFQN(fileSpec.c_str());
} else {
std::string d;
filepath_split(fileSpec, d, pathName);
directory = FS_GetFQN(d.c_str());
}
} else {
fileSpec = "./";
directory = FS_GetFQN(fileSpec.c_str());
}
if (!directory.size()) {
// Invalid filespec
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
std::string shortName = FS_GetShortName(directory.c_str());
// Print the path
qbs_set(strz, qbs_new_txt_len(shortName.c_str(), shortName.size()));
qbs_print(strz, 1);
auto entry = FS_GetDirectoryEntryName(fileSpec.c_str()); // get the first entry
filepath_join(pathName, directory, entry);
if (FS_IsStringEmpty(entry)) {
// File not found
error(QB_ERROR_FILE_NOT_FOUND);
return;
}
// Print directory entries
do {
fileSpec = FS_GetShortName(pathName.c_str()); // we do not need fileSpec anymore
filepath_split(fileSpec, directory, shortName);
qbs_set(strz, qbs_new_txt_len(shortName.c_str(), shortName.size()));
if (strz->len < 12) {
// Padding required
qbs_set(strz, qbs_add(strz, func_space(12 - strz->len)));
for (auto i = 0; i < 12; i++) {
if (strz->chr[i] == 46) {
memmove(&strz->chr[8], &strz->chr[i], 4);
memset(&strz->chr[i], 32, 8 - i);
break;
}
}
}
if (FS_DirectoryExists(pathName.c_str()))
qbs_set(strz, qbs_add(strz, qbs_new_txt_len("<DIR> ", 6)));
else
qbs_set(strz, qbs_add(strz, func_space(6)));
makefit(strz);
qbs_print(strz, 0);
entry = FS_GetDirectoryEntryName(nullptr); // get the next entry
filepath_join(pathName, directory, entry);
} while (!FS_IsStringEmpty(entry));
if (func_pos(0) > 1) {
// Move to a new line if necessary
strz->len = 0;
qbs_print(strz, 1);
}
// Print the free volume space
qbs_set(strz, qbs_add(qbs_str(FS_GetFreeDiskSpace(directory.c_str())), qbs_new_txt_len(" Bytes free", 11)));
qbs_print(strz, 1);
}
/// @brief Deletes files from disk
/// @param str The file(s) to delete (may contain wildcard at the final level)
void sub_kill(qbs *str) {
if (new_error)
return;
std::string directory, pathName, fileSpec(reinterpret_cast<char *>(str->chr), str->len);
filepath_split(filepath_fix_directory(fileSpec), directory, pathName); // split the file path
auto entry = FS_GetDirectoryEntryName(fileSpec.c_str()); // get the first entry
// Keep looking through the entries until we file a file
while (!FS_IsStringEmpty(entry)) {
filepath_join(pathName, directory, entry);
if (FS_FileExists(pathName.c_str()))
break;
entry = FS_GetDirectoryEntryName(nullptr); // get the next entry
}
// Check if we have exhausted the entries without ever finding a file
if (FS_IsStringEmpty(entry)) {
// This behavior is per QBasic 1.1
error(QB_ERROR_FILE_NOT_FOUND);
return;
}
// Process all matches
do {
// We'll delete only if it is a file
if (FS_FileExists(pathName.c_str())) {
if (remove(pathName.c_str())) {
auto i = errno;
if (i == ENOENT) {
error(QB_ERROR_FILE_NOT_FOUND);
return;
} // file not found
if (i == EACCES) {
error(QB_ERROR_PATH_FILE_ACCESS_ERROR);
return;
} // path / file access error
error(QB_ERROR_BAD_FILE_NAME); // bad file name (assumed)
}
}
entry = FS_GetDirectoryEntryName(nullptr); // get the next entry
filepath_join(pathName, directory, entry);
} while (!FS_IsStringEmpty(entry));
}
/// @brief Creates a new directory
/// @param str The directory path name to create
void sub_mkdir(qbs *str) {
if (new_error)
return;
std::string pathName(reinterpret_cast<char *>(str->chr), str->len);
#ifdef QB64_WINDOWS
if (mkdir(filepath_fix_directory(pathName)) == -1)
#else
if (mkdir(filepath_fix_directory(pathName), S_IRWXU | S_IRWXG) == -1)
#endif
{
if (errno == EEXIST) {
error(QB_ERROR_PATH_FILE_ACCESS_ERROR);
return;
} // path / file access error
error(QB_ERROR_PATH_NOT_FOUND); // assume errno == ENOENT; path not found
}
}
/// @brief Renames a file or directory
/// @param oldname The old file / directory name
/// @param newname The new file / directory name
void sub_name(qbs *oldname, qbs *newname) {
if (new_error)
return;
std::string pathNameOld(reinterpret_cast<char *>(oldname->chr), oldname->len), pathNameNew(reinterpret_cast<char *>(newname->chr), newname->len);
if (rename(filepath_fix_directory(pathNameOld), filepath_fix_directory(pathNameNew))) {
auto i = errno;
if (i == ENOENT) {
error(QB_ERROR_FILE_NOT_FOUND);
return;
} // file not found
if (i == EINVAL) {
error(QB_ERROR_BAD_FILE_NAME);
return;
} // bad file name
if (i == EACCES) {
error(QB_ERROR_PATH_FILE_ACCESS_ERROR);
return;
} // path / file access error
error(QB_ERROR_ILLEGAL_FUNCTION_CALL); // illegal function call (assumed)
}
}
/// @brief Deletes an empty directory
/// @param str The path name of the directory to delete
void sub_rmdir(qbs *str) {
if (new_error)
return;
std::string pathName(reinterpret_cast<char *>(str->chr), str->len);
if (rmdir(filepath_fix_directory(pathName)) == -1) {
if (errno == ENOTEMPTY) {
error(QB_ERROR_PATH_FILE_ACCESS_ERROR);
return;
} // path/file access error; not an empty directory
error(QB_ERROR_PATH_NOT_FOUND); // assume errno == ENOENT; path not found
}
}

View file

@ -17,6 +17,7 @@
#define STB_VORBIS_HEADER_ONLY
#include "datetime.h"
#include "extras/stb_vorbis.c"
#include "filepath.h"
#include "miniaudio.h"
#include "mutex.h"
#include <algorithm>
@ -28,9 +29,6 @@
#define INVALID_MEM_LOCK 1073741821
// This should be defined elsewhere (in libqb?). Since it is not, we are doing it here
#define MEM_TYPE_SOUND 5
// In QuickBASIC false means 0 and true means -1 (sad, but true XD)
#define QB_FALSE MA_FALSE
#define QB_TRUE -MA_TRUE
// This is returned to the caller if handle allocation fails with a -1
// CreateHandle() does not return 0 because it is a valid internal handle
// Handle 0 is 'handled' as a special case
@ -87,7 +85,7 @@ struct RawStream {
libqb_mutex *m; // we'll use a mutex to give exclusive access to resources used by both threads
bool stop; // set this to true to stop supply of samples completely (including silent samples)
static const size_t DEFAULT_SIZE = 1024; // this is almost twice the amout what miniaudio actually asks for in frameCount
static const size_t DEFAULT_SIZE = 1024; // this is almost twice the amount what miniaudio actually asks for in frameCount
// Delete default, copy and move constructors and assignments
RawStream() = delete;
@ -118,7 +116,7 @@ struct RawStream {
libqb_mutex_guard lock(m); // lock the mutex before accessing the vectors
consumer->cursor = 0; // reset the cursor
consumer->data.clear(); // clear the consumer vector
std::swap(consumer, producer); // quicky swap the Buffer pointers
std::swap(consumer, producer); // quickly swap the Buffer pointers
}
/// @brief This pushes a sample frame at the end of the queue. This is mutex protected and called by the main thread
@ -255,7 +253,7 @@ static ma_data_source_vtable rawStreamDataSourceVtable = {
/// @brief This creates, initializes and sets up a raw stream for playback
/// @param pmaEngine This should come from the QBPE sound engine
/// @param pmaSound This should come from a QBPE sound handle
/// @return Returns a pointer to a data souce if successful, NULL otherwise
/// @return Returns a pointer to a data source if successful, NULL otherwise
static RawStream *RawStreamCreate(ma_engine *pmaEngine, ma_sound *pmaSound) {
if (!pmaEngine || !pmaSound) { // these should not be NULL
AUDIO_DEBUG_PRINT("Invalid arguments");
@ -287,7 +285,7 @@ static RawStream *RawStreamCreate(ma_engine *pmaEngine, ma_sound *pmaSound) {
result = ma_sound_init_from_data_source(pmaEngine, &pRawStream->maDataSource, MA_SOUND_FLAG_NO_PITCH | MA_SOUND_FLAG_NO_SPATIALIZATION, NULL,
pmaSound); // attach data source to the ma_sound
if (result != MA_SUCCESS) {
AUDIO_DEBUG_PRINT("Error %i: failed to initalize sound from data source", result);
AUDIO_DEBUG_PRINT("Error %i: failed to initialize sound from data source", result);
delete pRawStream;
@ -423,7 +421,7 @@ class BufferMap {
}
};
/// @brief This is a PSG class that handles all kinds of sound generatation for BEEP, SOUND and PLAY
/// @brief This is a PSG class that handles all kinds of sound generation for BEEP, SOUND and PLAY
class PSG {
public:
/// @brief Various types of waveform that can be generated
@ -496,7 +494,7 @@ class PSG {
auto neededFrames = (ma_uint64)(waveDuration * rawStream->sampleRate);
if (!neededFrames || maWaveform.config.frequency >= 20000 || mixCursor + neededFrames > waveBuffer.size()) {
AUDIO_DEBUG_PRINT("Not generating any wavefrom. Frames = %llu, frequency = %lf, cursor = %llu", neededFrames, maWaveform.config.frequency,
AUDIO_DEBUG_PRINT("Not generating any waveform. Frames = %llu, frequency = %lf, cursor = %llu", neededFrames, maWaveform.config.frequency,
mixCursor);
return; // nothing to do
}
@ -769,7 +767,7 @@ class PSG {
if (processedChar == 'X') { // "X" + VARPTR$()
// A minimum of 3 bytes is need to read the address
if (currentState.length < 3) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -791,12 +789,12 @@ class PSG {
continue;
} else if (currentChar == '=') { // "=" + VARPTR$()
if (dots) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
if (numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -816,7 +814,7 @@ class PSG {
*/
if (currentState.length < 3) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -868,14 +866,14 @@ class PSG {
default:
// bit type?
if ((currentChar & 64) == 0) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
auto x2 = currentChar & 63;
if (x2 > 56) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
} // valid number of bits?
@ -897,7 +895,7 @@ class PSG {
}
if (d > 2147483647.0 || d < -2147483648.0) {
error(5); // out of range value!
error(QB_ERROR_ILLEGAL_FUNCTION_CALL); // out of range value!
return;
}
@ -906,7 +904,7 @@ class PSG {
continue;
} else if (currentChar >= '0' && currentChar <= '9') {
if (dots || numberEntered == 2) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -920,7 +918,7 @@ class PSG {
continue;
} else if (currentChar == '.') {
if (followUp != 7 && followUp != 1 && followUp != 4) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -932,14 +930,14 @@ class PSG {
follow_up:
if (followUp == 10) { // Q...
if (!numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
numberEntered = 0;
if (number > 100) { // 0 - 100 ms
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -950,14 +948,14 @@ class PSG {
break;
} else if (followUp == 9) { // @...
if (!numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
numberEntered = 0;
if ((WaveformType)number <= WaveformType::NONE || (WaveformType)number >= WaveformType::COUNT) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -969,14 +967,14 @@ class PSG {
break;
} else if (followUp == 8) { // V...
if (!numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
numberEntered = 0;
if (number > MAX_MML_VOLUME) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -990,7 +988,7 @@ class PSG {
if (numberEntered) {
numberEntered = 0;
if (number < 1 || number > 64) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
duration = 1.0 / (tempo / 60.0) * (4.0 / ((double)number));
@ -1027,7 +1025,7 @@ class PSG {
break;
} else if (followUp == 6) { // T...
if (!numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1045,7 +1043,7 @@ class PSG {
break;
} else if (followUp == 5) { // M...
if (numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1073,7 +1071,7 @@ class PSG {
background = false;
break;
default:
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1082,14 +1080,14 @@ class PSG {
continue;
} else if (followUp == 4) { // N...
if (!numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
numberEntered = 0;
if (number > 84) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1098,14 +1096,14 @@ class PSG {
goto follow_up_1;
} else if (followUp == 3) { // O...
if (!numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
numberEntered = 0;
if (number > MAX_OCTAVE) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1117,14 +1115,14 @@ class PSG {
break;
} else if (followUp == 2) { // L...
if (!numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
numberEntered = 0;
if (number < MIN_LENGTH || number > MAX_LENGTH) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1137,7 +1135,7 @@ class PSG {
} else if (followUp == 1) { // A-G...
if (currentChar == '-') {
if (noteShifted || numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1148,7 +1146,7 @@ class PSG {
}
if (currentChar == '+' || currentChar == '#') {
if (noteShifted || numberEntered) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1163,7 +1161,7 @@ class PSG {
numberEntered = 0;
if (number < 0 || number > 64) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1276,12 +1274,12 @@ class PSG {
continue;
}
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
if (numberEntered || followUp) {
error(5); // unhandled data
error(QB_ERROR_ILLEGAL_FUNCTION_CALL); // unhandled data
return;
}
@ -1536,7 +1534,7 @@ struct AudioEngine {
soundHandles[handle]->isUsed = false;
soundHandles[handle]->type = SoundHandle::Type::NONE;
// Save the free hanndle to lowestFreeHandle if it is lower than lowestFreeHandle
// Save the free handle to lowestFreeHandle if it is lower than lowestFreeHandle
if (handle < lowestFreeHandle)
lowestFreeHandle = handle;
@ -1588,13 +1586,13 @@ void sub_sound(double frequency, double lengthInClockTicks, double volume, doubl
return;
if ((frequency < 37.0 && frequency != 0) || frequency > 32767.0 || lengthInClockTicks < 0.0 || lengthInClockTicks > 65535.0) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
if (passed & 1) {
if (volume < PSG::MIN_VOLUME || volume > PSG::MAX_VOLUME) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
audioEngine.psg->SetAmplitude(volume);
@ -1602,7 +1600,7 @@ void sub_sound(double frequency, double lengthInClockTicks, double volume, doubl
if (passed & 2) {
if (panning < PSG::PAN_LEFT || panning > PSG::PAN_RIGHT) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
audioEngine.psg->SetPanning((float)panning);
@ -1610,7 +1608,7 @@ void sub_sound(double frequency, double lengthInClockTicks, double volume, doubl
if (passed & 4) {
if ((PSG::WaveformType)waveform <= PSG::WaveformType::NONE || (PSG::WaveformType)waveform >= PSG::WaveformType::COUNT) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
audioEngine.psg->SetWaveformType((PSG::WaveformType)waveform);
@ -1654,7 +1652,7 @@ void sub_play(const qbs *str) {
/// <summary>
/// This returns the sample rate from ma engine if ma is initialized.
/// </summary>
/// <returns>miniaudio sample rtate</returns>
/// <returns>miniaudio sample rate</returns>
int32_t func__sndrate() { return audioEngine.sampleRate; }
/// @brief Creates a ma_decoder and ma_sound from a memory buffer for a valid sound handle
@ -1722,7 +1720,7 @@ int32_t func__sndopen(qbs *fileName, qbs *requirements, int32_t passed) {
if (!reqs)
reqs = qbs_new(0, 0);
// Alocate a sound handle
// Allocate a sound handle
int32_t handle = audioEngine.CreateHandle();
if (handle < 1) // We are not expected to open files with handle 0
return INVALID_SOUND_HANDLE;
@ -1734,7 +1732,7 @@ int32_t func__sndopen(qbs *fileName, qbs *requirements, int32_t passed) {
if (passed && requirements->len)
qbs_set(reqs, qbs_ucase(requirements)); // Convert tmp str to perm str
// Set the flags to specifiy how we want the audio file to be opened
// Set the flags to specify how we want the audio file to be opened
if (passed && requirements->len && func_instr(1, reqs, qbs_new_txt(REQUIREMENT_STRING_STREAM), 1)) {
audioEngine.soundHandles[handle]->maFlags |= MA_SOUND_FLAG_STREAM; // Check if the user wants to stream the file
AUDIO_DEBUG_PRINT("Sound will stream");
@ -1757,8 +1755,8 @@ int32_t func__sndopen(qbs *fileName, qbs *requirements, int32_t passed) {
qbs_set(fileNameZ, qbs_add(fileName, qbs_new_txt_len("\0", 1))); // s1 = filename + CHR$(0)
// Forward the request to miniaudio to open the sound file
audioEngine.maResult = ma_sound_init_from_file(&audioEngine.maEngine, (const char *)fileNameZ->chr, audioEngine.soundHandles[handle]->maFlags, NULL,
NULL, &audioEngine.soundHandles[handle]->maSound);
audioEngine.maResult = ma_sound_init_from_file(&audioEngine.maEngine, filepath_fix_directory(fileNameZ), audioEngine.soundHandles[handle]->maFlags,
NULL, NULL, &audioEngine.soundHandles[handle]->maSound);
}
// If the sound failed to initialize, then free the handle and return INVALID_SOUND_HANDLE
@ -1782,7 +1780,7 @@ void sub__sndclose(int32_t handle) {
if (audioEngine.isInitialized && IS_SOUND_HANDLE_VALID(handle)) {
// If we have a raw stream then force it to push all it's data to miniaudio
// Note that this will take care of checking if the handle is a raw steam and other stuff
// So it is completly safe to call it this way
// So it is completely safe to call it this way
sub__sndrawdone(handle, true);
if (audioEngine.soundHandles[handle]->type == SoundHandle::Type::RAW)
@ -1826,7 +1824,7 @@ int32_t func__sndcopy(int32_t src_handle) {
} else if (audioEngine.soundHandles[src_handle]->maDecoder) {
AUDIO_DEBUG_PRINT("Doing custom sound copy for ma_decoder");
dst_handle = audioEngine.CreateHandle(); // alocate a sound handle
dst_handle = audioEngine.CreateHandle(); // allocate a sound handle
if (dst_handle < 1)
return INVALID_SOUND_HANDLE;
@ -1847,7 +1845,7 @@ int32_t func__sndcopy(int32_t src_handle) {
} else {
AUDIO_DEBUG_PRINT("Doing regular miniaudio sound copy");
dst_handle = audioEngine.CreateHandle(); // alocate a sound handle
dst_handle = audioEngine.CreateHandle(); // allocate a sound handle
if (dst_handle < 1)
return INVALID_SOUND_HANDLE;
@ -2182,7 +2180,7 @@ int32_t func__sndopenraw() {
if (!audioEngine.isInitialized)
return INVALID_SOUND_HANDLE;
// Alocate a sound handle
// Allocate a sound handle
int32_t handle = audioEngine.CreateHandle();
if (handle < 1)
return INVALID_SOUND_HANDLE;
@ -2415,7 +2413,7 @@ mem_block func__memsound(int32_t handle, int32_t targetChannel, int32_t passed)
AUDIO_DEBUG_PRINT("Format = %u, channels = %u, frames = %llu", maFormat, channels, sampleFrames);
// Setup type: This was not done in the old code
// But we are doing it here. By examing the type the user can now figure out if they have to use FP32 or integers
// But we are doing it here. By examining the type the user can now figure out if they have to use FP32 or integers
switch (maFormat) {
case ma_format::ma_format_f32:
mb.type = 4 + 256; // FP32
@ -2497,7 +2495,7 @@ void snd_init() {
// Get and save the engine sample rate. We will let miniaudio choose the device sample rate for us
// This ensures we get the lowest latency
// Set the resource manager decorder sample rate to the device sample rate (miniaudio engine bug?)
// Set the resource manager decoder sample rate to the device sample rate (miniaudio engine bug?)
audioEngine.maResourceManager.config.decodedSampleRate = audioEngine.sampleRate = ma_engine_get_sample_rate(&audioEngine.maEngine);
// Set the initialized flag as true

View file

@ -189,13 +189,13 @@ struct FontManager {
FT_Face face; // FreeType face object
FT_Pos monospaceWidth; // the monospace width (if font was loaded as monospace, else zero)
FT_Pos defaultHeight; // default (max) pixel height the user wants
FT_Pos baseline; // font baeline in pixels
FT_Pos baseline; // font baseline in pixels
int32_t options; // fonts options that were passed by QB64 while loading the font
/// @brief Manages a single glyph in a font
struct Glyph {
// Usually the bitmap size & metrics returned by FT for mono and gray can be the same
// But it's a bad idea to assume that is the case everytime
// But it's a bad idea to assume that is the case every time
struct Bitmap {
uint8_t *data; // pointer to the raw pixels
FT_Vector size; // bitmap width & height in pixels
@ -205,7 +205,7 @@ struct FontManager {
FT_UInt index; // glyph index
Bitmap bmpMono; // monochrome bitmap in 8-bit format
Bitmap bmpGray; // anti-aliased bitamp in 8-bit format
Bitmap bmpGray; // anti-aliased bitmap in 8-bit format
Bitmap *bitmap; // pointer to the currently selected bitmap (mono / gray)
// Delete copy and move constructors and assignments
@ -435,7 +435,7 @@ struct FontManager {
auto newGlyph = new Glyph;
if (!newGlyph) {
FONT_DEBUG_PRINT("Failed to allocate mmemory");
FONT_DEBUG_PRINT("Failed to allocate memory");
return nullptr; // failed to allocate memory
}
@ -573,7 +573,7 @@ struct FontManager {
if (h >= vectorSize) {
// Scan through the entire vector and return a slot that is not being used
// Ideally this should execute in extremely few (if at all) senarios
// Ideally this should execute in extremely few (if at all) scenarios
// Also, this loop should not execute if size is 0
for (h = 0; h < vectorSize; h++) {
if (!fonts[h]->isUsed) {
@ -1018,14 +1018,14 @@ int32_t func__UFontHeight(int32_t qb64_fh, int32_t passed) {
if (passed) {
// Check if a valid font handle was passed
if (!IS_VALID_QB64_FONT_HANDLE(qb64_fh)) {
error(258);
error(QB_ERROR_INVALID_HANDLE);
return 0;
}
} else {
qb64_fh = write_page->font; // else get the current write page font handle
}
// For buint-in fonts return the handle value (which is = font height)
// For built-in fonts return the handle value (which is = font height)
if (qb64_fh < 32)
return qb64_fh;
@ -1041,7 +1041,7 @@ int32_t func__UFontHeight(int32_t qb64_fh, int32_t passed) {
return fnt->defaultHeight;
}
/// @brief Returns the text widht in pixels
/// @brief Returns the text width in pixels
/// @param text The text to calculate the width for
/// @param utf_encoding The UTF encoding of the text (0 = ASCII, 8 = UTF-8, 16 - UTF-16, 32 = UTF-32)
/// @param qb64_fh A QB64 font handle (this can be a builtin font as well)
@ -1056,7 +1056,7 @@ int32_t func__UPrintWidth(const qbs *text, int32_t utf_encoding, int32_t qb64_fh
// Check UTF argument
if (passed & 1) {
if (!IS_VALID_UTF_ENCODING(utf_encoding)) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return 0;
}
} else {
@ -1066,7 +1066,7 @@ int32_t func__UPrintWidth(const qbs *text, int32_t utf_encoding, int32_t qb64_fh
// Check if a valid font handle was passed
if (passed & 2) {
if (!IS_VALID_QB64_FONT_HANDLE(qb64_fh)) {
error(258);
error(QB_ERROR_INVALID_HANDLE);
return 0;
}
} else {
@ -1122,14 +1122,14 @@ int32_t func__ULineSpacing(int32_t qb64_fh, int32_t passed) {
if (passed) {
// Check if a valid font handle was passed
if (!IS_VALID_QB64_FONT_HANDLE(qb64_fh)) {
error(258);
error(QB_ERROR_INVALID_HANDLE);
return 0;
}
} else {
qb64_fh = write_page->font; // else get the current write page font handle
}
// For buint-in fonts return the handle value (which is = font height)
// For built-in fonts return the handle value (which is = font height)
if (qb64_fh < 32)
return qb64_fh;
@ -1160,7 +1160,7 @@ void sub__UPrintString(int32_t start_x, int32_t start_y, const qbs *text, int32_
// Check if we are in text mode and generate an error if we are
if (write_page->text) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
@ -1177,7 +1177,7 @@ void sub__UPrintString(int32_t start_x, int32_t start_y, const qbs *text, int32_
// Check UTF argument
if (passed & 2) {
if (!IS_VALID_UTF_ENCODING(utf_encoding)) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return;
}
} else {
@ -1187,7 +1187,7 @@ void sub__UPrintString(int32_t start_x, int32_t start_y, const qbs *text, int32_
// Check if a valid font handle was passed
if (passed & 4) {
if (!IS_VALID_QB64_FONT_HANDLE(qb64_fh)) {
error(258);
error(QB_ERROR_INVALID_HANDLE);
return;
}
} else {
@ -1464,7 +1464,7 @@ void sub__UPrintString(int32_t start_x, int32_t start_y, const qbs *text, int32_
free(drawBuf);
}
/// @brief Calculate the starting pixel positions of each chancter to an array. First one being zero.
/// @brief Calculate the starting pixel positions of each codepoint to an array. First one being zero.
/// This also calculates the pixel position of the last + 1 character.
/// @param text Text for which the data needs to be calculated. This can be unicode encoded
/// @param arr A QB64 LONG array. This should be codepoints + 1 long. If the array is shorter additional calculated data is ignored
@ -1488,7 +1488,7 @@ int32_t func__UCharPos(const qbs *text, void *arr, int32_t utf_encoding, int32_t
// Check UTF argument
if (passed & 2) {
if (!IS_VALID_UTF_ENCODING(utf_encoding)) {
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return 0;
}
} else {
@ -1498,7 +1498,7 @@ int32_t func__UCharPos(const qbs *text, void *arr, int32_t utf_encoding, int32_t
// Check if a valid font handle was passed
if (passed & 4) {
if (!IS_VALID_QB64_FONT_HANDLE(qb64_fh)) {
error(258);
error(QB_ERROR_INVALID_HANDLE);
return 0;
}
} else {

View file

@ -49,13 +49,6 @@
// This is returned to the caller if something goes wrong while loading the image
#define INVALID_IMAGE_HANDLE -1
// TODO: We should have QB64 error code enums in some common place
// Maybe consolidate error() & friends, and these enums
#define ERROR_ILLEGAL_FUNCTION_CALL 5
#define ERROR_INTERNAL_ERROR 51
#define ERROR_BAD_FILE_NAME 64
#define ERROR_INVALID_HANDLE 258
#ifdef QB64_WINDOWS
# define ZERO_VARIABLE(_v_) ZeroMemory(&(_v_), sizeof(_v_))
#else
@ -294,7 +287,7 @@ static uint32_t *image_qoi_load_from_memory(const uint8_t *buffer, size_t size,
return pixels;
}
/// @brief Decodes an image file freom a file using the dr_pcx & stb_image libraries.
/// @brief Decodes an image file from a file using the dr_pcx & stb_image libraries.
/// @param fileName A valid filename
/// @param xOut Out: width in pixels. This cannot be NULL
/// @param yOut Out: height in pixels. This cannot be NULL
@ -386,7 +379,7 @@ static inline uint8_t image_clamp_component(int32_t n) { return n < 0 ? 0 : n >
/// @brief This takes in a 32bpp (BGRA) image raw data and spits out an 8bpp raw image along with it's 256 color (BGRA) palette.
/// @param src32 The source raw image data. This must be in BGRA format and not NULL
/// @param w The widht of the image in pixels
/// @param w The width of the image in pixels
/// @param h The height of the image in pixels
/// @param paletteOut A 256 color palette if the operation was successful. This cannot be NULL
/// @return A pointer to a 8bpp raw image or NULL if operation failed
@ -448,7 +441,7 @@ static uint8_t *image_convert_8bpp(const uint32_t *src32, int32_t w, int32_t h,
/// If the number of unique colors in the 32bpp image > 256, then the functions returns a NULL.
/// Unlike image_convert_8bpp(), no 'real' conversion takes place.
/// @param src The source raw image data. This must be in BGRA format and not NULL
/// @param w The widht of the image in pixels
/// @param w The width of the image in pixels
/// @param h The height of the image in pixels
/// @param paletteOut A 256 color palette if the operation was successful. This cannot be NULL
/// @return A pointer to a 8bpp raw image or NULL if operation failed
@ -545,7 +538,7 @@ static inline uint32_t image_swap_red_blue(uint32_t clr) { return ((clr & 0xFF00
/// @brief This function loads an image into memory and returns valid LONG image handle values that are less than -1
/// @param qbsFileName The filename or memory buffer (see requirements below) of the image
/// @param bpp 32 = 32bpp, 33 = 32bpp (hardware acclerated), 256=8bpp or 257=8bpp (without palette remap)
/// @param bpp 32 = 32bpp, 33 = 32bpp (hardware accelerated), 256=8bpp or 257=8bpp (without palette remap)
/// @param qbsRequirements A qbs that can contain one or more of: hardware, memory, adaptive
/// @param passed How many parameters were passed?
/// @return Valid LONG image handle values that are less than -1 or -1 on failure
@ -573,7 +566,7 @@ int32_t func__loadimage(qbs *qbsFileName, int32_t bpp, qbs *qbsRequirements, int
if ((bpp != 32) && (bpp != 256)) { // invalid BPP?
IMAGE_DEBUG_PRINT("Invalid bpp (0x%X)", bpp);
error(5);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
return INVALID_IMAGE_HANDLE;
}
} else {
@ -594,8 +587,6 @@ int32_t func__loadimage(qbs *qbsFileName, int32_t bpp, qbs *qbsRequirements, int
IMAGE_DEBUG_PRINT("Parsing requirements string: %s", requirements.c_str());
// requirements.find(REQUIREMENT_STRING_MEMORY) != std::string::npos
if (requirements.find("HARDWARE") != std::string::npos && bpp == 32) {
isHardwareImage = true;
IMAGE_DEBUG_PRINT("Hardware image selected");
@ -627,7 +618,7 @@ int32_t func__loadimage(qbs *qbsFileName, int32_t bpp, qbs *qbsRequirements, int
pixels = image_decode_from_memory(qbsFileName->chr, qbsFileName->len, &x, &y, scaler);
} else {
std::string fileName(reinterpret_cast<char *>(qbsFileName->chr), qbsFileName->len);
pixels = image_decode_from_file(fileName.c_str(), &x, &y, scaler);
pixels = image_decode_from_file(filepath_fix_directory(fileName), &x, &y, scaler);
}
if (!pixels)
@ -718,7 +709,7 @@ int32_t func__loadimage(qbs *qbsFileName, int32_t bpp, qbs *qbsRequirements, int
/// @param qbsFileName The file path name to save to
/// @param imageHandle Optional: The image handle. If omitted, then this is _DISPLAY()
/// @param qbsRequirements Optional: Extra format and setting arguments
/// @param passed Argument bitmask
/// @param passed Optional parameters
void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements, int32_t passed) {
enum struct SaveFormat { PNG = 0, QOI, BMP, TGA, JPG, HDR };
static const char *formatName[] = {"png", "qoi", "bmp", "tga", "jpg", "hdr"};
@ -728,7 +719,7 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
if (!qbsFileName->len) { // empty file names not allowed
IMAGE_DEBUG_PRINT("Empty file name");
error(ERROR_BAD_FILE_NAME);
error(QB_ERROR_BAD_FILE_NAME);
return;
}
@ -743,11 +734,11 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
imageHandle = -imageHandle;
if (imageHandle >= nextimg) {
error(ERROR_INVALID_HANDLE);
error(QB_ERROR_INVALID_HANDLE);
return;
}
if (!img[imageHandle].valid) {
error(ERROR_INVALID_HANDLE);
error(QB_ERROR_INVALID_HANDLE);
return;
}
}
@ -759,11 +750,11 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
// Safety
if (imageHandle >= nextimg) {
error(ERROR_INVALID_HANDLE);
error(QB_ERROR_INVALID_HANDLE);
return;
}
if (!img[imageHandle].valid) {
error(ERROR_INVALID_HANDLE);
error(QB_ERROR_INVALID_HANDLE);
return;
}
}
@ -792,6 +783,7 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
IMAGE_DEBUG_PRINT("Format selected: %s", formatName[(int)format]);
std::string fileName(reinterpret_cast<char *>(qbsFileName->chr), qbsFileName->len);
filepath_fix_directory(fileName);
// Check if fileName has a valid extension and add one if it does not have one
if (fileName.length() > 4) { // must be at least n.ext
@ -889,7 +881,7 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
pixels.resize(width * height);
if (img[imageHandle].bits_per_pixel == 32) { // BGRA pixels
IMAGE_DEBUG_PRINT("Coverting BGRA surface to RGBA");
IMAGE_DEBUG_PRINT("Converting BGRA surface to RGBA");
auto p = img[imageHandle].offset32;
@ -898,7 +890,7 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
++p;
}
} else { // indexed pixels
IMAGE_DEBUG_PRINT("Coverting BGRA indexed surface to RGBA");
IMAGE_DEBUG_PRINT("Converting BGRA indexed surface to RGBA");
auto p = img[imageHandle].offset;
for (size_t i = 0; i < pixels.size(); i++) {
@ -915,7 +907,7 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
stbi_write_png_compression_level = 100;
if (!stbi_write_png(fileName.c_str(), width, height, sizeof(uint32_t), pixels.data(), 0)) {
IMAGE_DEBUG_PRINT("stbi_write_png() failed");
error(ERROR_ILLEGAL_FUNCTION_CALL);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
}
} break;
@ -928,28 +920,28 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
if (!qoi_write(fileName.c_str(), pixels.data(), &desc)) {
IMAGE_DEBUG_PRINT("qoi_write() failed");
error(ERROR_ILLEGAL_FUNCTION_CALL);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
}
} break;
case SaveFormat::BMP: {
if (!stbi_write_bmp(fileName.c_str(), width, height, sizeof(uint32_t), pixels.data())) {
IMAGE_DEBUG_PRINT("stbi_write_bmp() failed");
error(ERROR_ILLEGAL_FUNCTION_CALL);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
}
} break;
case SaveFormat::TGA: {
if (!stbi_write_tga(fileName.c_str(), width, height, sizeof(uint32_t), pixels.data())) {
IMAGE_DEBUG_PRINT("stbi_write_tga() failed");
error(ERROR_ILLEGAL_FUNCTION_CALL);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
}
} break;
case SaveFormat::JPG: {
if (!stbi_write_jpg(fileName.c_str(), width, height, sizeof(uint32_t), pixels.data(), 100)) {
IMAGE_DEBUG_PRINT("stbi_write_jpg() failed");
error(ERROR_ILLEGAL_FUNCTION_CALL);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
}
} break;
@ -974,12 +966,12 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
if (!stbi_write_hdr(fileName.c_str(), width, height, HDRComponents, HDRPixels.data())) {
IMAGE_DEBUG_PRINT("stbi_write_hdr() failed");
error(ERROR_ILLEGAL_FUNCTION_CALL);
error(QB_ERROR_ILLEGAL_FUNCTION_CALL);
}
} break;
default:
IMAGE_DEBUG_PRINT("Save handler not implemented");
error(ERROR_INTERNAL_ERROR);
error(QB_ERROR_INTERNAL_ERROR);
}
}

View file

@ -3,11 +3,13 @@
#include "compression.h"
#include "datetime.h"
#include "event.h"
#include "extended_math.h"
#include "filepath.h"
#include "filesystem.h"
#include "font.h"
#include "gui.h"
#include "image.h"
#include "rounding.h"
#include "extended_math.h"
extern int32 func__cinp(int32 toggle,
int32 passed); // Console INP scan code reader
@ -88,14 +90,9 @@ void requestKeyboardOverlayImage(int32 handle) {
// extern functions
extern qbs *func__dir(qbs *context);
extern int32 func__scaledwidth();
extern int32 func__scaledheight();
extern qbs *func__cwd();
extern qbs *func__startdir();
extern void sub__fps(double fps, int32 passed);
extern void sub__resize(int32 on_off, int32 stretch_smooth);
@ -178,8 +175,6 @@ extern int32 func_windowexists();
extern int32 func_screenicon();
extern int32 func_screenwidth();
extern int32 func_screenheight();
extern int32 func__borderwidth();
extern int32 func__titlebarheight();
extern void sub_screenicon();
extern void sub__console(int32);
extern int32 func__console();
@ -191,8 +186,6 @@ extern int32 func__hasfocus();
extern void set_foreground_window(ptrszint i);
extern qbs *func__title();
extern int32 func__handle();
extern int32 func__fileexists(qbs *);
extern int32 func__direxists(qbs *);
extern int32 func_stick(int32 i, int32 axis_group, int32 passed);
extern int32 func_strig(int32 i, int32 controller, int32 passed);
extern void sub__maptriangle(int32 cull_options, float sx1, float sy1,
@ -224,7 +217,6 @@ extern void field_get(int32 fileno, int64 seekpos, int32 passed);
extern void field_put(int32 fileno, int64 seekpos, int32 passed);
extern int32 func__keydown(int32 x);
extern int32 func__keyhit();
extern void sub_files(qbs *str, int32 passed);
extern int32 func_lpos(int32);
extern void sub__printimage(int32 i);
extern float func__mousemovementx(int32 context, int32 passed);
@ -246,7 +238,6 @@ extern qbs *func__clipboard();
extern int32 func__clipboardimage();
extern void sub__clipboardimage(int32 src);
extern int32 func__exit();
extern char *fixdir(qbs *);
extern void revert_input_check();
extern int32 func__openhost(qbs *);
extern int32 func__openconnection(int32);
@ -276,7 +267,6 @@ extern void sub__putimage(double f_dx1, double f_dy1, double f_dx2,
double f_sy1, double f_sx2, double f_sy2,
int32 passed);
extern int32 selectfont(int32 f, img_struct *im);
extern void sndsetup();
extern uint32 sib();
extern uint32 sib_mod0();
extern uint8 *rm8();
@ -299,10 +289,6 @@ extern void sub_defseg(int32 segment, int32 passed);
extern int32 func_peek(int32 offset);
extern void sub_poke(int32 offset, int32 value);
extern void more_return_points();
extern void qb64_generatesound(double f, double l, uint8 wait);
extern uint8 *soundwave(double frequency, double length, double volume,
double fadein, double fadeout);
extern int32 wavesize(double length);
extern qbs *qbs_new_descriptor();
extern void qbs_free_descriptor(qbs *str);
extern void qbs_free(qbs *str);
@ -524,14 +510,8 @@ extern qbs *func_input(int32 n, int32 i, int32 passed);
extern int32 func__statusCode(int32 handle);
extern double func_sqr(double value);
extern void snd_check();
extern qbs *func_command(int32 index, int32 passed);
extern int32 func__commandcount();
extern void sub_kill(qbs *str);
extern void sub_name(qbs *oldname, qbs *newname);
extern void sub_chdir(qbs *str);
extern void sub_mkdir(qbs *str);
extern void sub_rmdir(qbs *str);
extern long double pow2(long double x, long double y);
extern int32 func_freefile();
extern void sub__mousehide();
@ -1333,8 +1313,8 @@ void sub_chain(qbs *f) {
extensions_ready:
// normalize dir slashes
fixdir(f_exe);
fixdir(f_bas);
filepath_fix_directory(f_exe);
filepath_fix_directory(f_bas);
// get path (strip paths from f_exe & f_bas)
f_path->len = 0;

View file

@ -1,4 +1,4 @@
g++ -no-pie -w -std=gnu++14 -DFREEGLUT_STATIC -I./internal/c/libqb/include -I./internal/c/parts/core/src/ -I./internal/c/parts/core/glew/include/ -DDEPENDENCY_SOCKETS -DDEPENDENCY_NO_PRINTER -DDEPENDENCY_ICON -DDEPENDENCY_NO_SCREENIMAGE internal/c/qbx.cpp -c -o internal/c/qbx.o
g++ -no-pie -w -std=gnu++14 -DFREEGLUT_STATIC -I./internal/c/libqb/include -I./internal/c/parts/core/src/ -I./internal/c/parts/core/glew/include/ -DDEPENDENCY_SOCKETS -DDEPENDENCY_NO_PRINTER -DDEPENDENCY_ICON -DDEPENDENCY_NO_SCREENIMAGE ./internal/c/libqb_make_000101000.o ./internal/c/qbx.o -o "/home/runner/work/QB64pe/QB64pe/qb64pe" ./internal/c/libqb/src/threading.o ./internal/c/libqb/src/buffer.o ./internal/c/libqb/src/filepath.o ./internal/c/libqb/src/datetime.o ./internal/c/libqb/src/rounding.o ./internal/c/libqb/src/http.o ./internal/c/libqb/src/threading-posix.o ./internal/c/libqb/src/glut-main-thread.o ./internal/c/libqb/src/glut-message.o ./internal/c/libqb/src/glut-msg-queue.o ./internal/c/parts/gui/tinyfiledialogs.o ./internal/c/parts/gui/gui.o ./internal/c/parts/video/font/freetypeamalgam.o ./internal/c/parts/video/font/font.o ./internal/c/parts/audio/stub_audio.o ./internal/c/parts/compression/miniz.o ./internal/c/parts/compression/compression.o ./internal/c/parts/core/src.a -lGL -lGLU -lX11 -lpthread -ldl -lrt -lcurl
g++ -no-pie -w -std=gnu++14 -DFREEGLUT_STATIC -I./internal/c/libqb/include -I./internal/c/parts/core/src/ -I./internal/c/parts/core/glew/include/ -DDEPENDENCY_SOCKETS -DDEPENDENCY_NO_PRINTER -DDEPENDENCY_ICON -DDEPENDENCY_NO_SCREENIMAGE ./internal/c/libqb_make_000101000.o ./internal/c/qbx.o -o "/home/runner/work/QB64pe/QB64pe/qb64pe" ./internal/c/libqb/src/threading.o ./internal/c/libqb/src/buffer.o ./internal/c/libqb/src/filepath.o ./internal/c/libqb/src/filesystem.o ./internal/c/libqb/src/datetime.o ./internal/c/libqb/src/rounding.o ./internal/c/libqb/src/http.o ./internal/c/libqb/src/threading-posix.o ./internal/c/libqb/src/glut-main-thread.o ./internal/c/libqb/src/glut-message.o ./internal/c/libqb/src/glut-msg-queue.o ./internal/c/parts/gui/tinyfiledialogs.o ./internal/c/parts/gui/gui.o ./internal/c/parts/video/font/freetypeamalgam.o ./internal/c/parts/video/font/font.o ./internal/c/parts/audio/stub_audio.o ./internal/c/parts/compression/miniz.o ./internal/c/parts/compression/compression.o ./internal/c/parts/core/src.a -lGL -lGLU -lX11 -lpthread -ldl -lrt -lcurl
objcopy --only-keep-debug "/home/runner/work/QB64pe/QB64pe/qb64pe" "./internal/temp/qb64pe.sym"
objcopy --strip-unneeded "/home/runner/work/QB64pe/QB64pe/qb64pe"

View file

@ -1,32 +1,32 @@
qbs*oldstr3743=NULL;
qbs*oldstr3726=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){
oldstr3743=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N;
if (oldstr3743->cmem_descriptor){
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr3743->len,0);
oldstr3726=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N;
if (oldstr3726->cmem_descriptor){
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr3726->len,0);
}else{
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr3743->len,0);
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr3726->len,0);
}
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr3743->chr,oldstr3743->len);
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr3726->chr,oldstr3726->len);
}
qbs*oldstr3744=NULL;
qbs*oldstr3727=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){
oldstr3744=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
if (oldstr3744->cmem_descriptor){
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr3744->len,0);
oldstr3727=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
if (oldstr3727->cmem_descriptor){
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr3727->len,0);
}else{
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr3744->len,0);
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr3727->len,0);
}
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr3744->chr,oldstr3744->len);
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr3727->chr,oldstr3727->len);
}
qbs*oldstr3745=NULL;
qbs*oldstr3728=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){
oldstr3745=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
if (oldstr3745->cmem_descriptor){
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr3745->len,0);
oldstr3728=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
if (oldstr3728->cmem_descriptor){
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr3728->len,0);
}else{
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr3745->len,0);
_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr3728->len,0);
}
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr3745->chr,oldstr3745->len);
memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr3728->chr,oldstr3728->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 pass3747;
int32 pass3730;

View file

@ -1,32 +1,32 @@
qbs*oldstr3748=NULL;
qbs*oldstr3731=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){
oldstr3748=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N;
if (oldstr3748->cmem_descriptor){
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr3748->len,0);
oldstr3731=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N;
if (oldstr3731->cmem_descriptor){
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr3731->len,0);
}else{
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr3748->len,0);
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr3731->len,0);
}
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr3748->chr,oldstr3748->len);
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr3731->chr,oldstr3731->len);
}
qbs*oldstr3749=NULL;
qbs*oldstr3732=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){
oldstr3749=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
if (oldstr3749->cmem_descriptor){
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr3749->len,0);
oldstr3732=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
if (oldstr3732->cmem_descriptor){
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr3732->len,0);
}else{
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr3749->len,0);
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr3732->len,0);
}
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr3749->chr,oldstr3749->len);
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr3732->chr,oldstr3732->len);
}
qbs*oldstr3750=NULL;
qbs*oldstr3733=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){
oldstr3750=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
if (oldstr3750->cmem_descriptor){
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr3750->len,0);
oldstr3733=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
if (oldstr3733->cmem_descriptor){
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr3733->len,0);
}else{
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr3750->len,0);
_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr3733->len,0);
}
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr3750->chr,oldstr3750->len);
memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr3733->chr,oldstr3733->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 pass3752;
int32 pass3735;

View file

@ -1,24 +1,24 @@
qbs*oldstr3753=NULL;
qbs*oldstr3736=NULL;
if(_SUB_COPY_FULL_UDT_STRING_DST->tmp||_SUB_COPY_FULL_UDT_STRING_DST->fixed||_SUB_COPY_FULL_UDT_STRING_DST->readonly){
oldstr3753=_SUB_COPY_FULL_UDT_STRING_DST;
if (oldstr3753->cmem_descriptor){
_SUB_COPY_FULL_UDT_STRING_DST=qbs_new_cmem(oldstr3753->len,0);
oldstr3736=_SUB_COPY_FULL_UDT_STRING_DST;
if (oldstr3736->cmem_descriptor){
_SUB_COPY_FULL_UDT_STRING_DST=qbs_new_cmem(oldstr3736->len,0);
}else{
_SUB_COPY_FULL_UDT_STRING_DST=qbs_new(oldstr3753->len,0);
_SUB_COPY_FULL_UDT_STRING_DST=qbs_new(oldstr3736->len,0);
}
memcpy(_SUB_COPY_FULL_UDT_STRING_DST->chr,oldstr3753->chr,oldstr3753->len);
memcpy(_SUB_COPY_FULL_UDT_STRING_DST->chr,oldstr3736->chr,oldstr3736->len);
}
qbs*oldstr3754=NULL;
qbs*oldstr3737=NULL;
if(_SUB_COPY_FULL_UDT_STRING_SRC->tmp||_SUB_COPY_FULL_UDT_STRING_SRC->fixed||_SUB_COPY_FULL_UDT_STRING_SRC->readonly){
oldstr3754=_SUB_COPY_FULL_UDT_STRING_SRC;
if (oldstr3754->cmem_descriptor){
_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new_cmem(oldstr3754->len,0);
oldstr3737=_SUB_COPY_FULL_UDT_STRING_SRC;
if (oldstr3737->cmem_descriptor){
_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new_cmem(oldstr3737->len,0);
}else{
_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new(oldstr3754->len,0);
_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new(oldstr3737->len,0);
}
memcpy(_SUB_COPY_FULL_UDT_STRING_SRC->chr,oldstr3754->chr,oldstr3754->len);
memcpy(_SUB_COPY_FULL_UDT_STRING_SRC->chr,oldstr3737->chr,oldstr3737->len);
}
int16 pass3755;
int16 pass3738;
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 pass3757;
int32 pass3758;
int16 pass3759;
int16 pass3740;
int32 pass3741;
int16 pass3742;

View file

@ -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_value3762;
int64 fornext_finalvalue3762;
int64 fornext_step3762;
uint8 fornext_step_negative3762;
int64 fornext_value3766;
int64 fornext_finalvalue3766;
int64 fornext_step3766;
uint8 fornext_step_negative3766;
int64 fornext_value3745;
int64 fornext_finalvalue3745;
int64 fornext_step3745;
uint8 fornext_step_negative3745;
int64 fornext_value3749;
int64 fornext_finalvalue3749;
int64 fornext_step3749;
uint8 fornext_step_negative3749;

View file

@ -1,22 +1,22 @@
qbs*oldstr3768=NULL;
qbs*oldstr3751=NULL;
if(_SUB_MANAGEVARIABLELIST_STRING___NAME->tmp||_SUB_MANAGEVARIABLELIST_STRING___NAME->fixed||_SUB_MANAGEVARIABLELIST_STRING___NAME->readonly){
oldstr3768=_SUB_MANAGEVARIABLELIST_STRING___NAME;
if (oldstr3768->cmem_descriptor){
_SUB_MANAGEVARIABLELIST_STRING___NAME=qbs_new_cmem(oldstr3768->len,0);
oldstr3751=_SUB_MANAGEVARIABLELIST_STRING___NAME;
if (oldstr3751->cmem_descriptor){
_SUB_MANAGEVARIABLELIST_STRING___NAME=qbs_new_cmem(oldstr3751->len,0);
}else{
_SUB_MANAGEVARIABLELIST_STRING___NAME=qbs_new(oldstr3768->len,0);
_SUB_MANAGEVARIABLELIST_STRING___NAME=qbs_new(oldstr3751->len,0);
}
memcpy(_SUB_MANAGEVARIABLELIST_STRING___NAME->chr,oldstr3768->chr,oldstr3768->len);
memcpy(_SUB_MANAGEVARIABLELIST_STRING___NAME->chr,oldstr3751->chr,oldstr3751->len);
}
qbs*oldstr3769=NULL;
qbs*oldstr3752=NULL;
if(_SUB_MANAGEVARIABLELIST_STRING___CNAME->tmp||_SUB_MANAGEVARIABLELIST_STRING___CNAME->fixed||_SUB_MANAGEVARIABLELIST_STRING___CNAME->readonly){
oldstr3769=_SUB_MANAGEVARIABLELIST_STRING___CNAME;
if (oldstr3769->cmem_descriptor){
_SUB_MANAGEVARIABLELIST_STRING___CNAME=qbs_new_cmem(oldstr3769->len,0);
oldstr3752=_SUB_MANAGEVARIABLELIST_STRING___CNAME;
if (oldstr3752->cmem_descriptor){
_SUB_MANAGEVARIABLELIST_STRING___CNAME=qbs_new_cmem(oldstr3752->len,0);
}else{
_SUB_MANAGEVARIABLELIST_STRING___CNAME=qbs_new(oldstr3769->len,0);
_SUB_MANAGEVARIABLELIST_STRING___CNAME=qbs_new(oldstr3752->len,0);
}
memcpy(_SUB_MANAGEVARIABLELIST_STRING___CNAME->chr,oldstr3769->chr,oldstr3769->len);
memcpy(_SUB_MANAGEVARIABLELIST_STRING___CNAME->chr,oldstr3752->chr,oldstr3752->len);
}
int32 *_SUB_MANAGEVARIABLELIST_LONG_FINDITEM=NULL;
if(_SUB_MANAGEVARIABLELIST_LONG_FINDITEM==NULL){
@ -39,43 +39,43 @@ qbs *_SUB_MANAGEVARIABLELIST_STRING_NAME=NULL;
if (!_SUB_MANAGEVARIABLELIST_STRING_NAME)_SUB_MANAGEVARIABLELIST_STRING_NAME=qbs_new(0,0);
qbs *_SUB_MANAGEVARIABLELIST_STRING_TEMP=NULL;
if (!_SUB_MANAGEVARIABLELIST_STRING_TEMP)_SUB_MANAGEVARIABLELIST_STRING_TEMP=qbs_new(0,0);
byte_element_struct *byte_element_3770=NULL;
if (!byte_element_3770){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3770=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3770=(byte_element_struct*)mem_static_malloc(12);
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);
}
int32 *_SUB_MANAGEVARIABLELIST_LONG_FOUND=NULL;
if(_SUB_MANAGEVARIABLELIST_LONG_FOUND==NULL){
_SUB_MANAGEVARIABLELIST_LONG_FOUND=(int32*)mem_static_malloc(4);
*_SUB_MANAGEVARIABLELIST_LONG_FOUND=0;
}
int64 fornext_value3772;
int64 fornext_finalvalue3772;
int64 fornext_step3772;
uint8 fornext_step_negative3772;
int64 fornext_value3755;
int64 fornext_finalvalue3755;
int64 fornext_step3755;
uint8 fornext_step_negative3755;
qbs *_SUB_MANAGEVARIABLELIST_STRING_THISINCNAME=NULL;
if (!_SUB_MANAGEVARIABLELIST_STRING_THISINCNAME)_SUB_MANAGEVARIABLELIST_STRING_THISINCNAME=qbs_new(0,0);
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_3757=NULL;
if (!byte_element_3757){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3757=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3757=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_MANAGEVARIABLELIST_LONG_X=NULL;
if(_SUB_MANAGEVARIABLELIST_LONG_X==NULL){
_SUB_MANAGEVARIABLELIST_LONG_X=(int32*)mem_static_malloc(4);
*_SUB_MANAGEVARIABLELIST_LONG_X=0;
}
byte_element_struct *byte_element_3776=NULL;
if (!byte_element_3776){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3776=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3776=(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_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);
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_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_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_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);
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);
}

View file

@ -1,50 +1,50 @@
qbs*oldstr3780=NULL;
qbs*oldstr3763=NULL;
if(_SUB_ADDWARNING_STRING_INCFILENAME->tmp||_SUB_ADDWARNING_STRING_INCFILENAME->fixed||_SUB_ADDWARNING_STRING_INCFILENAME->readonly){
oldstr3780=_SUB_ADDWARNING_STRING_INCFILENAME;
if (oldstr3780->cmem_descriptor){
_SUB_ADDWARNING_STRING_INCFILENAME=qbs_new_cmem(oldstr3780->len,0);
oldstr3763=_SUB_ADDWARNING_STRING_INCFILENAME;
if (oldstr3763->cmem_descriptor){
_SUB_ADDWARNING_STRING_INCFILENAME=qbs_new_cmem(oldstr3763->len,0);
}else{
_SUB_ADDWARNING_STRING_INCFILENAME=qbs_new(oldstr3780->len,0);
_SUB_ADDWARNING_STRING_INCFILENAME=qbs_new(oldstr3763->len,0);
}
memcpy(_SUB_ADDWARNING_STRING_INCFILENAME->chr,oldstr3780->chr,oldstr3780->len);
memcpy(_SUB_ADDWARNING_STRING_INCFILENAME->chr,oldstr3763->chr,oldstr3763->len);
}
qbs*oldstr3781=NULL;
qbs*oldstr3764=NULL;
if(_SUB_ADDWARNING_STRING_HEADER->tmp||_SUB_ADDWARNING_STRING_HEADER->fixed||_SUB_ADDWARNING_STRING_HEADER->readonly){
oldstr3781=_SUB_ADDWARNING_STRING_HEADER;
if (oldstr3781->cmem_descriptor){
_SUB_ADDWARNING_STRING_HEADER=qbs_new_cmem(oldstr3781->len,0);
oldstr3764=_SUB_ADDWARNING_STRING_HEADER;
if (oldstr3764->cmem_descriptor){
_SUB_ADDWARNING_STRING_HEADER=qbs_new_cmem(oldstr3764->len,0);
}else{
_SUB_ADDWARNING_STRING_HEADER=qbs_new(oldstr3781->len,0);
_SUB_ADDWARNING_STRING_HEADER=qbs_new(oldstr3764->len,0);
}
memcpy(_SUB_ADDWARNING_STRING_HEADER->chr,oldstr3781->chr,oldstr3781->len);
memcpy(_SUB_ADDWARNING_STRING_HEADER->chr,oldstr3764->chr,oldstr3764->len);
}
qbs*oldstr3782=NULL;
qbs*oldstr3765=NULL;
if(_SUB_ADDWARNING_STRING_TEXT->tmp||_SUB_ADDWARNING_STRING_TEXT->fixed||_SUB_ADDWARNING_STRING_TEXT->readonly){
oldstr3782=_SUB_ADDWARNING_STRING_TEXT;
if (oldstr3782->cmem_descriptor){
_SUB_ADDWARNING_STRING_TEXT=qbs_new_cmem(oldstr3782->len,0);
oldstr3765=_SUB_ADDWARNING_STRING_TEXT;
if (oldstr3765->cmem_descriptor){
_SUB_ADDWARNING_STRING_TEXT=qbs_new_cmem(oldstr3765->len,0);
}else{
_SUB_ADDWARNING_STRING_TEXT=qbs_new(oldstr3782->len,0);
_SUB_ADDWARNING_STRING_TEXT=qbs_new(oldstr3765->len,0);
}
memcpy(_SUB_ADDWARNING_STRING_TEXT->chr,oldstr3782->chr,oldstr3782->len);
memcpy(_SUB_ADDWARNING_STRING_TEXT->chr,oldstr3765->chr,oldstr3765->len);
}
qbs *_SUB_ADDWARNING_STRING_THISSOURCE=NULL;
if (!_SUB_ADDWARNING_STRING_THISSOURCE)_SUB_ADDWARNING_STRING_THISSOURCE=qbs_new(0,0);
byte_element_struct *byte_element_3783=NULL;
if (!byte_element_3783){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3783=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3783=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3766=NULL;
if (!byte_element_3766){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3766=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3766=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_SUB_ADDWARNING_STRING_THISINCNAME=NULL;
if (!_SUB_ADDWARNING_STRING_THISINCNAME)_SUB_ADDWARNING_STRING_THISINCNAME=qbs_new(0,0);
byte_element_struct *byte_element_3784=NULL;
if (!byte_element_3784){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3784=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3784=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3767=NULL;
if (!byte_element_3767){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3767=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3767=(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_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_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);
byte_element_struct *byte_element_3776=NULL;
if (!byte_element_3776){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3776=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3776=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,12 +1,12 @@
qbs *_FUNC_SCASE_STRING_SCASE=NULL;
if (!_FUNC_SCASE_STRING_SCASE)_FUNC_SCASE_STRING_SCASE=qbs_new(0,0);
qbs*oldstr3794=NULL;
qbs*oldstr3777=NULL;
if(_FUNC_SCASE_STRING_T->tmp||_FUNC_SCASE_STRING_T->fixed||_FUNC_SCASE_STRING_T->readonly){
oldstr3794=_FUNC_SCASE_STRING_T;
if (oldstr3794->cmem_descriptor){
_FUNC_SCASE_STRING_T=qbs_new_cmem(oldstr3794->len,0);
oldstr3777=_FUNC_SCASE_STRING_T;
if (oldstr3777->cmem_descriptor){
_FUNC_SCASE_STRING_T=qbs_new_cmem(oldstr3777->len,0);
}else{
_FUNC_SCASE_STRING_T=qbs_new(oldstr3794->len,0);
_FUNC_SCASE_STRING_T=qbs_new(oldstr3777->len,0);
}
memcpy(_FUNC_SCASE_STRING_T->chr,oldstr3794->chr,oldstr3794->len);
memcpy(_FUNC_SCASE_STRING_T->chr,oldstr3777->chr,oldstr3777->len);
}

View file

@ -1,14 +1,14 @@
qbs *_FUNC_SCASE2_STRING_SCASE2=NULL;
if (!_FUNC_SCASE2_STRING_SCASE2)_FUNC_SCASE2_STRING_SCASE2=qbs_new(0,0);
qbs*oldstr3795=NULL;
qbs*oldstr3778=NULL;
if(_FUNC_SCASE2_STRING_T->tmp||_FUNC_SCASE2_STRING_T->fixed||_FUNC_SCASE2_STRING_T->readonly){
oldstr3795=_FUNC_SCASE2_STRING_T;
if (oldstr3795->cmem_descriptor){
_FUNC_SCASE2_STRING_T=qbs_new_cmem(oldstr3795->len,0);
oldstr3778=_FUNC_SCASE2_STRING_T;
if (oldstr3778->cmem_descriptor){
_FUNC_SCASE2_STRING_T=qbs_new_cmem(oldstr3778->len,0);
}else{
_FUNC_SCASE2_STRING_T=qbs_new(oldstr3795->len,0);
_FUNC_SCASE2_STRING_T=qbs_new(oldstr3778->len,0);
}
memcpy(_FUNC_SCASE2_STRING_T->chr,oldstr3795->chr,oldstr3795->len);
memcpy(_FUNC_SCASE2_STRING_T->chr,oldstr3778->chr,oldstr3778->len);
}
qbs *_FUNC_SCASE2_STRING_SEPARATOR=NULL;
if (!_FUNC_SCASE2_STRING_SEPARATOR)_FUNC_SCASE2_STRING_SEPARATOR=qbs_new(0,0);
@ -24,13 +24,13 @@ if(_FUNC_SCASE2_LONG_I==NULL){
_FUNC_SCASE2_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_SCASE2_LONG_I=0;
}
int64 fornext_value3797;
int64 fornext_finalvalue3797;
int64 fornext_step3797;
uint8 fornext_step_negative3797;
byte_element_struct *byte_element_3798=NULL;
if (!byte_element_3798){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3798=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3798=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3780;
int64 fornext_finalvalue3780;
int64 fornext_step3780;
uint8 fornext_step_negative3780;
byte_element_struct *byte_element_3781=NULL;
if (!byte_element_3781){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3781=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3781=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_SCASE2_STRING_S=NULL;
if (!_FUNC_SCASE2_STRING_S)_FUNC_SCASE2_STRING_S=qbs_new(0,0);

View file

@ -3,37 +3,37 @@ if(_FUNC_COMPAREVERSIONS_LONG_COMPAREVERSIONS==NULL){
_FUNC_COMPAREVERSIONS_LONG_COMPAREVERSIONS=(int32*)mem_static_malloc(4);
*_FUNC_COMPAREVERSIONS_LONG_COMPAREVERSIONS=0;
}
qbs*oldstr3799=NULL;
qbs*oldstr3782=NULL;
if(_FUNC_COMPAREVERSIONS_STRING_V->tmp||_FUNC_COMPAREVERSIONS_STRING_V->fixed||_FUNC_COMPAREVERSIONS_STRING_V->readonly){
oldstr3799=_FUNC_COMPAREVERSIONS_STRING_V;
if (oldstr3799->cmem_descriptor){
_FUNC_COMPAREVERSIONS_STRING_V=qbs_new_cmem(oldstr3799->len,0);
oldstr3782=_FUNC_COMPAREVERSIONS_STRING_V;
if (oldstr3782->cmem_descriptor){
_FUNC_COMPAREVERSIONS_STRING_V=qbs_new_cmem(oldstr3782->len,0);
}else{
_FUNC_COMPAREVERSIONS_STRING_V=qbs_new(oldstr3799->len,0);
_FUNC_COMPAREVERSIONS_STRING_V=qbs_new(oldstr3782->len,0);
}
memcpy(_FUNC_COMPAREVERSIONS_STRING_V->chr,oldstr3799->chr,oldstr3799->len);
memcpy(_FUNC_COMPAREVERSIONS_STRING_V->chr,oldstr3782->chr,oldstr3782->len);
}
qbs*oldstr3800=NULL;
qbs*oldstr3783=NULL;
if(_FUNC_COMPAREVERSIONS_STRING_V1->tmp||_FUNC_COMPAREVERSIONS_STRING_V1->fixed||_FUNC_COMPAREVERSIONS_STRING_V1->readonly){
oldstr3800=_FUNC_COMPAREVERSIONS_STRING_V1;
if (oldstr3800->cmem_descriptor){
_FUNC_COMPAREVERSIONS_STRING_V1=qbs_new_cmem(oldstr3800->len,0);
oldstr3783=_FUNC_COMPAREVERSIONS_STRING_V1;
if (oldstr3783->cmem_descriptor){
_FUNC_COMPAREVERSIONS_STRING_V1=qbs_new_cmem(oldstr3783->len,0);
}else{
_FUNC_COMPAREVERSIONS_STRING_V1=qbs_new(oldstr3800->len,0);
_FUNC_COMPAREVERSIONS_STRING_V1=qbs_new(oldstr3783->len,0);
}
memcpy(_FUNC_COMPAREVERSIONS_STRING_V1->chr,oldstr3800->chr,oldstr3800->len);
memcpy(_FUNC_COMPAREVERSIONS_STRING_V1->chr,oldstr3783->chr,oldstr3783->len);
}
qbs *_FUNC_COMPAREVERSIONS_STRING_T=NULL;
if (!_FUNC_COMPAREVERSIONS_STRING_T)_FUNC_COMPAREVERSIONS_STRING_T=qbs_new(0,0);
qbs *_FUNC_COMPAREVERSIONS_STRING_T1=NULL;
if (!_FUNC_COMPAREVERSIONS_STRING_T1)_FUNC_COMPAREVERSIONS_STRING_T1=qbs_new(0,0);
byte_element_struct *byte_element_3801=NULL;
if (!byte_element_3801){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3801=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3801=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3784=NULL;
if (!byte_element_3784){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3784=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3784=(byte_element_struct*)mem_static_malloc(12);
}
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_3785=NULL;
if (!byte_element_3785){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3785=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3785=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_COMPAREVERSIONS_LONG_L=NULL;
if(_FUNC_COMPAREVERSIONS_LONG_L==NULL){

View file

@ -1,24 +1,24 @@
qbs *_FUNC_STRREMOVE_STRING_STRREMOVE=NULL;
if (!_FUNC_STRREMOVE_STRING_STRREMOVE)_FUNC_STRREMOVE_STRING_STRREMOVE=qbs_new(0,0);
qbs*oldstr3804=NULL;
qbs*oldstr3787=NULL;
if(_FUNC_STRREMOVE_STRING_MYSTRING->tmp||_FUNC_STRREMOVE_STRING_MYSTRING->fixed||_FUNC_STRREMOVE_STRING_MYSTRING->readonly){
oldstr3804=_FUNC_STRREMOVE_STRING_MYSTRING;
if (oldstr3804->cmem_descriptor){
_FUNC_STRREMOVE_STRING_MYSTRING=qbs_new_cmem(oldstr3804->len,0);
oldstr3787=_FUNC_STRREMOVE_STRING_MYSTRING;
if (oldstr3787->cmem_descriptor){
_FUNC_STRREMOVE_STRING_MYSTRING=qbs_new_cmem(oldstr3787->len,0);
}else{
_FUNC_STRREMOVE_STRING_MYSTRING=qbs_new(oldstr3804->len,0);
_FUNC_STRREMOVE_STRING_MYSTRING=qbs_new(oldstr3787->len,0);
}
memcpy(_FUNC_STRREMOVE_STRING_MYSTRING->chr,oldstr3804->chr,oldstr3804->len);
memcpy(_FUNC_STRREMOVE_STRING_MYSTRING->chr,oldstr3787->chr,oldstr3787->len);
}
qbs*oldstr3805=NULL;
qbs*oldstr3788=NULL;
if(_FUNC_STRREMOVE_STRING_WHATTOREMOVE->tmp||_FUNC_STRREMOVE_STRING_WHATTOREMOVE->fixed||_FUNC_STRREMOVE_STRING_WHATTOREMOVE->readonly){
oldstr3805=_FUNC_STRREMOVE_STRING_WHATTOREMOVE;
if (oldstr3805->cmem_descriptor){
_FUNC_STRREMOVE_STRING_WHATTOREMOVE=qbs_new_cmem(oldstr3805->len,0);
oldstr3788=_FUNC_STRREMOVE_STRING_WHATTOREMOVE;
if (oldstr3788->cmem_descriptor){
_FUNC_STRREMOVE_STRING_WHATTOREMOVE=qbs_new_cmem(oldstr3788->len,0);
}else{
_FUNC_STRREMOVE_STRING_WHATTOREMOVE=qbs_new(oldstr3805->len,0);
_FUNC_STRREMOVE_STRING_WHATTOREMOVE=qbs_new(oldstr3788->len,0);
}
memcpy(_FUNC_STRREMOVE_STRING_WHATTOREMOVE->chr,oldstr3805->chr,oldstr3805->len);
memcpy(_FUNC_STRREMOVE_STRING_WHATTOREMOVE->chr,oldstr3788->chr,oldstr3788->len);
}
qbs *_FUNC_STRREMOVE_STRING_A=NULL;
if (!_FUNC_STRREMOVE_STRING_A)_FUNC_STRREMOVE_STRING_A=qbs_new(0,0);
@ -29,11 +29,11 @@ if(_FUNC_STRREMOVE_LONG_I==NULL){
_FUNC_STRREMOVE_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_STRREMOVE_LONG_I=0;
}
byte_element_struct *byte_element_3807=NULL;
if (!byte_element_3807){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3807=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3807=(byte_element_struct*)mem_static_malloc(12);
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_3808=NULL;
if (!byte_element_3808){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3808=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3808=(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);
}

View file

@ -1,34 +1,34 @@
qbs *_FUNC_STRREPLACE_STRING_STRREPLACE=NULL;
if (!_FUNC_STRREPLACE_STRING_STRREPLACE)_FUNC_STRREPLACE_STRING_STRREPLACE=qbs_new(0,0);
qbs*oldstr3809=NULL;
qbs*oldstr3792=NULL;
if(_FUNC_STRREPLACE_STRING_MYSTRING->tmp||_FUNC_STRREPLACE_STRING_MYSTRING->fixed||_FUNC_STRREPLACE_STRING_MYSTRING->readonly){
oldstr3809=_FUNC_STRREPLACE_STRING_MYSTRING;
if (oldstr3809->cmem_descriptor){
_FUNC_STRREPLACE_STRING_MYSTRING=qbs_new_cmem(oldstr3809->len,0);
oldstr3792=_FUNC_STRREPLACE_STRING_MYSTRING;
if (oldstr3792->cmem_descriptor){
_FUNC_STRREPLACE_STRING_MYSTRING=qbs_new_cmem(oldstr3792->len,0);
}else{
_FUNC_STRREPLACE_STRING_MYSTRING=qbs_new(oldstr3809->len,0);
_FUNC_STRREPLACE_STRING_MYSTRING=qbs_new(oldstr3792->len,0);
}
memcpy(_FUNC_STRREPLACE_STRING_MYSTRING->chr,oldstr3809->chr,oldstr3809->len);
memcpy(_FUNC_STRREPLACE_STRING_MYSTRING->chr,oldstr3792->chr,oldstr3792->len);
}
qbs*oldstr3810=NULL;
qbs*oldstr3793=NULL;
if(_FUNC_STRREPLACE_STRING_FIND->tmp||_FUNC_STRREPLACE_STRING_FIND->fixed||_FUNC_STRREPLACE_STRING_FIND->readonly){
oldstr3810=_FUNC_STRREPLACE_STRING_FIND;
if (oldstr3810->cmem_descriptor){
_FUNC_STRREPLACE_STRING_FIND=qbs_new_cmem(oldstr3810->len,0);
oldstr3793=_FUNC_STRREPLACE_STRING_FIND;
if (oldstr3793->cmem_descriptor){
_FUNC_STRREPLACE_STRING_FIND=qbs_new_cmem(oldstr3793->len,0);
}else{
_FUNC_STRREPLACE_STRING_FIND=qbs_new(oldstr3810->len,0);
_FUNC_STRREPLACE_STRING_FIND=qbs_new(oldstr3793->len,0);
}
memcpy(_FUNC_STRREPLACE_STRING_FIND->chr,oldstr3810->chr,oldstr3810->len);
memcpy(_FUNC_STRREPLACE_STRING_FIND->chr,oldstr3793->chr,oldstr3793->len);
}
qbs*oldstr3811=NULL;
qbs*oldstr3794=NULL;
if(_FUNC_STRREPLACE_STRING_REPLACEWITH->tmp||_FUNC_STRREPLACE_STRING_REPLACEWITH->fixed||_FUNC_STRREPLACE_STRING_REPLACEWITH->readonly){
oldstr3811=_FUNC_STRREPLACE_STRING_REPLACEWITH;
if (oldstr3811->cmem_descriptor){
_FUNC_STRREPLACE_STRING_REPLACEWITH=qbs_new_cmem(oldstr3811->len,0);
oldstr3794=_FUNC_STRREPLACE_STRING_REPLACEWITH;
if (oldstr3794->cmem_descriptor){
_FUNC_STRREPLACE_STRING_REPLACEWITH=qbs_new_cmem(oldstr3794->len,0);
}else{
_FUNC_STRREPLACE_STRING_REPLACEWITH=qbs_new(oldstr3811->len,0);
_FUNC_STRREPLACE_STRING_REPLACEWITH=qbs_new(oldstr3794->len,0);
}
memcpy(_FUNC_STRREPLACE_STRING_REPLACEWITH->chr,oldstr3811->chr,oldstr3811->len);
memcpy(_FUNC_STRREPLACE_STRING_REPLACEWITH->chr,oldstr3794->chr,oldstr3794->len);
}
qbs *_FUNC_STRREPLACE_STRING_A=NULL;
if (!_FUNC_STRREPLACE_STRING_A)_FUNC_STRREPLACE_STRING_A=qbs_new(0,0);
@ -44,19 +44,19 @@ if(_FUNC_STRREPLACE_LONG_I==NULL){
_FUNC_STRREPLACE_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_STRREPLACE_LONG_I=0;
}
byte_element_struct *byte_element_3812=NULL;
if (!byte_element_3812){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3812=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3812=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3795=NULL;
if (!byte_element_3795){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3795=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3795=(byte_element_struct*)mem_static_malloc(12);
}
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);
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);
}
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_3798=NULL;
if (!byte_element_3798){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3798=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3798=(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_3799=NULL;
if (!byte_element_3799){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3799=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3799=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -3,35 +3,35 @@ if(_FUNC_HASSTRINGENCLOSINGPAIR_BYTE_HASSTRINGENCLOSINGPAIR==NULL){
_FUNC_HASSTRINGENCLOSINGPAIR_BYTE_HASSTRINGENCLOSINGPAIR=(int8*)mem_static_malloc(1);
*_FUNC_HASSTRINGENCLOSINGPAIR_BYTE_HASSTRINGENCLOSINGPAIR=0;
}
qbs*oldstr3817=NULL;
qbs*oldstr3800=NULL;
if(_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT->tmp||_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT->fixed||_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT->readonly){
oldstr3817=_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT;
if (oldstr3817->cmem_descriptor){
_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT=qbs_new_cmem(oldstr3817->len,0);
oldstr3800=_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT;
if (oldstr3800->cmem_descriptor){
_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT=qbs_new_cmem(oldstr3800->len,0);
}else{
_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT=qbs_new(oldstr3817->len,0);
_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT=qbs_new(oldstr3800->len,0);
}
memcpy(_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT->chr,oldstr3817->chr,oldstr3817->len);
memcpy(_FUNC_HASSTRINGENCLOSINGPAIR_STRING_TEXT->chr,oldstr3800->chr,oldstr3800->len);
}
qbs*oldstr3818=NULL;
qbs*oldstr3801=NULL;
if(_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR->tmp||_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR->fixed||_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR->readonly){
oldstr3818=_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR;
if (oldstr3818->cmem_descriptor){
_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR=qbs_new_cmem(oldstr3818->len,0);
oldstr3801=_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR;
if (oldstr3801->cmem_descriptor){
_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR=qbs_new_cmem(oldstr3801->len,0);
}else{
_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR=qbs_new(oldstr3818->len,0);
_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR=qbs_new(oldstr3801->len,0);
}
memcpy(_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR->chr,oldstr3818->chr,oldstr3818->len);
memcpy(_FUNC_HASSTRINGENCLOSINGPAIR_STRING_PAIR->chr,oldstr3801->chr,oldstr3801->len);
}
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_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_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_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_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_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);
}

View file

@ -1,26 +1,26 @@
qbs *_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_REMOVESTRINGENCLOSINGPAIR=NULL;
if (!_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_REMOVESTRINGENCLOSINGPAIR)_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_REMOVESTRINGENCLOSINGPAIR=qbs_new(0,0);
qbs*oldstr3822=NULL;
qbs*oldstr3805=NULL;
if(_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT->tmp||_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT->fixed||_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT->readonly){
oldstr3822=_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT;
if (oldstr3822->cmem_descriptor){
_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT=qbs_new_cmem(oldstr3822->len,0);
oldstr3805=_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT;
if (oldstr3805->cmem_descriptor){
_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT=qbs_new_cmem(oldstr3805->len,0);
}else{
_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT=qbs_new(oldstr3822->len,0);
_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT=qbs_new(oldstr3805->len,0);
}
memcpy(_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT->chr,oldstr3822->chr,oldstr3822->len);
memcpy(_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_TEXT->chr,oldstr3805->chr,oldstr3805->len);
}
qbs*oldstr3823=NULL;
qbs*oldstr3806=NULL;
if(_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR->tmp||_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR->fixed||_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR->readonly){
oldstr3823=_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR;
if (oldstr3823->cmem_descriptor){
_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR=qbs_new_cmem(oldstr3823->len,0);
oldstr3806=_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR;
if (oldstr3806->cmem_descriptor){
_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR=qbs_new_cmem(oldstr3806->len,0);
}else{
_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR=qbs_new(oldstr3823->len,0);
_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR=qbs_new(oldstr3806->len,0);
}
memcpy(_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR->chr,oldstr3823->chr,oldstr3823->len);
memcpy(_FUNC_REMOVESTRINGENCLOSINGPAIR_STRING_PAIR->chr,oldstr3806->chr,oldstr3806->len);
}
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);
byte_element_struct *byte_element_3807=NULL;
if (!byte_element_3807){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3807=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3807=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,12 +1,12 @@
qbs *_FUNC_ADDQUOTES_STRING_ADDQUOTES=NULL;
if (!_FUNC_ADDQUOTES_STRING_ADDQUOTES)_FUNC_ADDQUOTES_STRING_ADDQUOTES=qbs_new(0,0);
qbs*oldstr3825=NULL;
qbs*oldstr3808=NULL;
if(_FUNC_ADDQUOTES_STRING_S->tmp||_FUNC_ADDQUOTES_STRING_S->fixed||_FUNC_ADDQUOTES_STRING_S->readonly){
oldstr3825=_FUNC_ADDQUOTES_STRING_S;
if (oldstr3825->cmem_descriptor){
_FUNC_ADDQUOTES_STRING_S=qbs_new_cmem(oldstr3825->len,0);
oldstr3808=_FUNC_ADDQUOTES_STRING_S;
if (oldstr3808->cmem_descriptor){
_FUNC_ADDQUOTES_STRING_S=qbs_new_cmem(oldstr3808->len,0);
}else{
_FUNC_ADDQUOTES_STRING_S=qbs_new(oldstr3825->len,0);
_FUNC_ADDQUOTES_STRING_S=qbs_new(oldstr3808->len,0);
}
memcpy(_FUNC_ADDQUOTES_STRING_S->chr,oldstr3825->chr,oldstr3825->len);
memcpy(_FUNC_ADDQUOTES_STRING_S->chr,oldstr3808->chr,oldstr3808->len);
}

View file

@ -3,15 +3,15 @@ if(_FUNC_TFSTRINGTOBOOL_INTEGER_TFSTRINGTOBOOL==NULL){
_FUNC_TFSTRINGTOBOOL_INTEGER_TFSTRINGTOBOOL=(int16*)mem_static_malloc(2);
*_FUNC_TFSTRINGTOBOOL_INTEGER_TFSTRINGTOBOOL=0;
}
qbs*oldstr3826=NULL;
qbs*oldstr3809=NULL;
if(_FUNC_TFSTRINGTOBOOL_STRING_S->tmp||_FUNC_TFSTRINGTOBOOL_STRING_S->fixed||_FUNC_TFSTRINGTOBOOL_STRING_S->readonly){
oldstr3826=_FUNC_TFSTRINGTOBOOL_STRING_S;
if (oldstr3826->cmem_descriptor){
_FUNC_TFSTRINGTOBOOL_STRING_S=qbs_new_cmem(oldstr3826->len,0);
oldstr3809=_FUNC_TFSTRINGTOBOOL_STRING_S;
if (oldstr3809->cmem_descriptor){
_FUNC_TFSTRINGTOBOOL_STRING_S=qbs_new_cmem(oldstr3809->len,0);
}else{
_FUNC_TFSTRINGTOBOOL_STRING_S=qbs_new(oldstr3826->len,0);
_FUNC_TFSTRINGTOBOOL_STRING_S=qbs_new(oldstr3809->len,0);
}
memcpy(_FUNC_TFSTRINGTOBOOL_STRING_S->chr,oldstr3826->chr,oldstr3826->len);
memcpy(_FUNC_TFSTRINGTOBOOL_STRING_S->chr,oldstr3809->chr,oldstr3809->len);
}
qbs *_FUNC_TFSTRINGTOBOOL_STRING_S2=NULL;
if (!_FUNC_TFSTRINGTOBOOL_STRING_S2)_FUNC_TFSTRINGTOBOOL_STRING_S2=qbs_new(0,0);

View file

@ -3,25 +3,25 @@ if(_FUNC_READWRITEBOOLEANSETTINGVALUE_INTEGER_READWRITEBOOLEANSETTINGVALUE==NULL
_FUNC_READWRITEBOOLEANSETTINGVALUE_INTEGER_READWRITEBOOLEANSETTINGVALUE=(int16*)mem_static_malloc(2);
*_FUNC_READWRITEBOOLEANSETTINGVALUE_INTEGER_READWRITEBOOLEANSETTINGVALUE=0;
}
qbs*oldstr3827=NULL;
qbs*oldstr3810=NULL;
if(_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION->tmp||_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION->fixed||_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION->readonly){
oldstr3827=_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION;
if (oldstr3827->cmem_descriptor){
_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION=qbs_new_cmem(oldstr3827->len,0);
oldstr3810=_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION;
if (oldstr3810->cmem_descriptor){
_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION=qbs_new_cmem(oldstr3810->len,0);
}else{
_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION=qbs_new(oldstr3827->len,0);
_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION=qbs_new(oldstr3810->len,0);
}
memcpy(_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION->chr,oldstr3827->chr,oldstr3827->len);
memcpy(_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SECTION->chr,oldstr3810->chr,oldstr3810->len);
}
qbs*oldstr3828=NULL;
qbs*oldstr3811=NULL;
if(_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING->tmp||_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING->fixed||_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING->readonly){
oldstr3828=_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING;
if (oldstr3828->cmem_descriptor){
_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING=qbs_new_cmem(oldstr3828->len,0);
oldstr3811=_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING;
if (oldstr3811->cmem_descriptor){
_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING=qbs_new_cmem(oldstr3811->len,0);
}else{
_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING=qbs_new(oldstr3828->len,0);
_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING=qbs_new(oldstr3811->len,0);
}
memcpy(_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING->chr,oldstr3828->chr,oldstr3828->len);
memcpy(_FUNC_READWRITEBOOLEANSETTINGVALUE_STRING_SETTING->chr,oldstr3811->chr,oldstr3811->len);
}
int16 *_FUNC_READWRITEBOOLEANSETTINGVALUE_INTEGER_CHECKRESULT=NULL;
if(_FUNC_READWRITEBOOLEANSETTINGVALUE_INTEGER_CHECKRESULT==NULL){
@ -35,4 +35,4 @@ if(_FUNC_READWRITEBOOLEANSETTINGVALUE_INTEGER_RESULT==NULL){
_FUNC_READWRITEBOOLEANSETTINGVALUE_INTEGER_RESULT=(int16*)mem_static_malloc(2);
*_FUNC_READWRITEBOOLEANSETTINGVALUE_INTEGER_RESULT=0;
}
int32 pass3829;
int32 pass3812;

View file

@ -1,34 +1,34 @@
qbs *_FUNC_READWRITESTRINGSETTINGVALUE_STRING_READWRITESTRINGSETTINGVALUE=NULL;
if (!_FUNC_READWRITESTRINGSETTINGVALUE_STRING_READWRITESTRINGSETTINGVALUE)_FUNC_READWRITESTRINGSETTINGVALUE_STRING_READWRITESTRINGSETTINGVALUE=qbs_new(0,0);
qbs*oldstr3830=NULL;
qbs*oldstr3813=NULL;
if(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION->tmp||_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION->fixed||_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION->readonly){
oldstr3830=_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION;
if (oldstr3830->cmem_descriptor){
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION=qbs_new_cmem(oldstr3830->len,0);
oldstr3813=_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION;
if (oldstr3813->cmem_descriptor){
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION=qbs_new_cmem(oldstr3813->len,0);
}else{
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION=qbs_new(oldstr3830->len,0);
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION=qbs_new(oldstr3813->len,0);
}
memcpy(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION->chr,oldstr3830->chr,oldstr3830->len);
memcpy(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SECTION->chr,oldstr3813->chr,oldstr3813->len);
}
qbs*oldstr3831=NULL;
qbs*oldstr3814=NULL;
if(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING->tmp||_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING->fixed||_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING->readonly){
oldstr3831=_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING;
if (oldstr3831->cmem_descriptor){
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING=qbs_new_cmem(oldstr3831->len,0);
oldstr3814=_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING;
if (oldstr3814->cmem_descriptor){
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING=qbs_new_cmem(oldstr3814->len,0);
}else{
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING=qbs_new(oldstr3831->len,0);
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING=qbs_new(oldstr3814->len,0);
}
memcpy(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING->chr,oldstr3831->chr,oldstr3831->len);
memcpy(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_SETTING->chr,oldstr3814->chr,oldstr3814->len);
}
qbs*oldstr3832=NULL;
qbs*oldstr3815=NULL;
if(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT->tmp||_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT->fixed||_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT->readonly){
oldstr3832=_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT;
if (oldstr3832->cmem_descriptor){
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT=qbs_new_cmem(oldstr3832->len,0);
oldstr3815=_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT;
if (oldstr3815->cmem_descriptor){
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT=qbs_new_cmem(oldstr3815->len,0);
}else{
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT=qbs_new(oldstr3832->len,0);
_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT=qbs_new(oldstr3815->len,0);
}
memcpy(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT->chr,oldstr3832->chr,oldstr3832->len);
memcpy(_FUNC_READWRITESTRINGSETTINGVALUE_STRING_DEFAULT->chr,oldstr3815->chr,oldstr3815->len);
}
qbs *_FUNC_READWRITESTRINGSETTINGVALUE_STRING_VALUE=NULL;
if (!_FUNC_READWRITESTRINGSETTINGVALUE_STRING_VALUE)_FUNC_READWRITESTRINGSETTINGVALUE_STRING_VALUE=qbs_new(0,0);

View file

@ -3,25 +3,25 @@ if(_FUNC_READWRITELONGSETTINGVALUE_LONG_READWRITELONGSETTINGVALUE==NULL){
_FUNC_READWRITELONGSETTINGVALUE_LONG_READWRITELONGSETTINGVALUE=(int32*)mem_static_malloc(4);
*_FUNC_READWRITELONGSETTINGVALUE_LONG_READWRITELONGSETTINGVALUE=0;
}
qbs*oldstr3833=NULL;
qbs*oldstr3816=NULL;
if(_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION->tmp||_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION->fixed||_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION->readonly){
oldstr3833=_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION;
if (oldstr3833->cmem_descriptor){
_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION=qbs_new_cmem(oldstr3833->len,0);
oldstr3816=_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION;
if (oldstr3816->cmem_descriptor){
_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION=qbs_new_cmem(oldstr3816->len,0);
}else{
_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION=qbs_new(oldstr3833->len,0);
_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION=qbs_new(oldstr3816->len,0);
}
memcpy(_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION->chr,oldstr3833->chr,oldstr3833->len);
memcpy(_FUNC_READWRITELONGSETTINGVALUE_STRING_SECTION->chr,oldstr3816->chr,oldstr3816->len);
}
qbs*oldstr3834=NULL;
qbs*oldstr3817=NULL;
if(_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING->tmp||_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING->fixed||_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING->readonly){
oldstr3834=_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING;
if (oldstr3834->cmem_descriptor){
_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING=qbs_new_cmem(oldstr3834->len,0);
oldstr3817=_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING;
if (oldstr3817->cmem_descriptor){
_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING=qbs_new_cmem(oldstr3817->len,0);
}else{
_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING=qbs_new(oldstr3834->len,0);
_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING=qbs_new(oldstr3817->len,0);
}
memcpy(_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING->chr,oldstr3834->chr,oldstr3834->len);
memcpy(_FUNC_READWRITELONGSETTINGVALUE_STRING_SETTING->chr,oldstr3817->chr,oldstr3817->len);
}
qbs *_FUNC_READWRITELONGSETTINGVALUE_STRING_VALUE=NULL;
if (!_FUNC_READWRITELONGSETTINGVALUE_STRING_VALUE)_FUNC_READWRITELONGSETTINGVALUE_STRING_VALUE=qbs_new(0,0);

View file

@ -3,25 +3,25 @@ if(_FUNC_COPYFILE_LONG_COPYFILE==NULL){
_FUNC_COPYFILE_LONG_COPYFILE=(int32*)mem_static_malloc(4);
*_FUNC_COPYFILE_LONG_COPYFILE=0;
}
qbs*oldstr3835=NULL;
qbs*oldstr3818=NULL;
if(_FUNC_COPYFILE_STRING_SOURCEFILE->tmp||_FUNC_COPYFILE_STRING_SOURCEFILE->fixed||_FUNC_COPYFILE_STRING_SOURCEFILE->readonly){
oldstr3835=_FUNC_COPYFILE_STRING_SOURCEFILE;
if (oldstr3835->cmem_descriptor){
_FUNC_COPYFILE_STRING_SOURCEFILE=qbs_new_cmem(oldstr3835->len,0);
oldstr3818=_FUNC_COPYFILE_STRING_SOURCEFILE;
if (oldstr3818->cmem_descriptor){
_FUNC_COPYFILE_STRING_SOURCEFILE=qbs_new_cmem(oldstr3818->len,0);
}else{
_FUNC_COPYFILE_STRING_SOURCEFILE=qbs_new(oldstr3835->len,0);
_FUNC_COPYFILE_STRING_SOURCEFILE=qbs_new(oldstr3818->len,0);
}
memcpy(_FUNC_COPYFILE_STRING_SOURCEFILE->chr,oldstr3835->chr,oldstr3835->len);
memcpy(_FUNC_COPYFILE_STRING_SOURCEFILE->chr,oldstr3818->chr,oldstr3818->len);
}
qbs*oldstr3836=NULL;
qbs*oldstr3819=NULL;
if(_FUNC_COPYFILE_STRING_DESTFILE->tmp||_FUNC_COPYFILE_STRING_DESTFILE->fixed||_FUNC_COPYFILE_STRING_DESTFILE->readonly){
oldstr3836=_FUNC_COPYFILE_STRING_DESTFILE;
if (oldstr3836->cmem_descriptor){
_FUNC_COPYFILE_STRING_DESTFILE=qbs_new_cmem(oldstr3836->len,0);
oldstr3819=_FUNC_COPYFILE_STRING_DESTFILE;
if (oldstr3819->cmem_descriptor){
_FUNC_COPYFILE_STRING_DESTFILE=qbs_new_cmem(oldstr3819->len,0);
}else{
_FUNC_COPYFILE_STRING_DESTFILE=qbs_new(oldstr3836->len,0);
_FUNC_COPYFILE_STRING_DESTFILE=qbs_new(oldstr3819->len,0);
}
memcpy(_FUNC_COPYFILE_STRING_DESTFILE->chr,oldstr3836->chr,oldstr3836->len);
memcpy(_FUNC_COPYFILE_STRING_DESTFILE->chr,oldstr3819->chr,oldstr3819->len);
}
int32 *_FUNC_COPYFILE_LONG_SOURCEFILENO=NULL;
if(_FUNC_COPYFILE_LONG_SOURCEFILENO==NULL){
@ -40,7 +40,7 @@ _FUNC_COPYFILE_INTEGER64_FILELENGTH=(int64*)mem_static_malloc(8);
}
qbs *_FUNC_COPYFILE_STRING_BUFFER=NULL;
if (!_FUNC_COPYFILE_STRING_BUFFER)_FUNC_COPYFILE_STRING_BUFFER=qbs_new(0,0);
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_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);
}

View file

@ -3,25 +3,25 @@ if(_FUNC_CONVERTFILETOCARRAY_INTEGER_CONVERTFILETOCARRAY==NULL){
_FUNC_CONVERTFILETOCARRAY_INTEGER_CONVERTFILETOCARRAY=(int16*)mem_static_malloc(2);
*_FUNC_CONVERTFILETOCARRAY_INTEGER_CONVERTFILETOCARRAY=0;
}
qbs*oldstr3838=NULL;
qbs*oldstr3821=NULL;
if(_FUNC_CONVERTFILETOCARRAY_STRING_FILE->tmp||_FUNC_CONVERTFILETOCARRAY_STRING_FILE->fixed||_FUNC_CONVERTFILETOCARRAY_STRING_FILE->readonly){
oldstr3838=_FUNC_CONVERTFILETOCARRAY_STRING_FILE;
if (oldstr3838->cmem_descriptor){
_FUNC_CONVERTFILETOCARRAY_STRING_FILE=qbs_new_cmem(oldstr3838->len,0);
oldstr3821=_FUNC_CONVERTFILETOCARRAY_STRING_FILE;
if (oldstr3821->cmem_descriptor){
_FUNC_CONVERTFILETOCARRAY_STRING_FILE=qbs_new_cmem(oldstr3821->len,0);
}else{
_FUNC_CONVERTFILETOCARRAY_STRING_FILE=qbs_new(oldstr3838->len,0);
_FUNC_CONVERTFILETOCARRAY_STRING_FILE=qbs_new(oldstr3821->len,0);
}
memcpy(_FUNC_CONVERTFILETOCARRAY_STRING_FILE->chr,oldstr3838->chr,oldstr3838->len);
memcpy(_FUNC_CONVERTFILETOCARRAY_STRING_FILE->chr,oldstr3821->chr,oldstr3821->len);
}
qbs*oldstr3839=NULL;
qbs*oldstr3822=NULL;
if(_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE->tmp||_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE->fixed||_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE->readonly){
oldstr3839=_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE;
if (oldstr3839->cmem_descriptor){
_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE=qbs_new_cmem(oldstr3839->len,0);
oldstr3822=_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE;
if (oldstr3822->cmem_descriptor){
_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE=qbs_new_cmem(oldstr3822->len,0);
}else{
_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE=qbs_new(oldstr3839->len,0);
_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE=qbs_new(oldstr3822->len,0);
}
memcpy(_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE->chr,oldstr3839->chr,oldstr3839->len);
memcpy(_FUNC_CONVERTFILETOCARRAY_STRING_HANDLE->chr,oldstr3822->chr,oldstr3822->len);
}
int16 *_FUNC_CONVERTFILETOCARRAY_INTEGER_SFF=NULL;
if(_FUNC_CONVERTFILETOCARRAY_INTEGER_SFF==NULL){
@ -32,19 +32,19 @@ qbs *_FUNC_CONVERTFILETOCARRAY_STRING_FILEDATA=NULL;
if (!_FUNC_CONVERTFILETOCARRAY_STRING_FILEDATA)_FUNC_CONVERTFILETOCARRAY_STRING_FILEDATA=qbs_new(0,0);
qbs *_FUNC_CONVERTFILETOCARRAY_STRING_COMPDATA=NULL;
if (!_FUNC_CONVERTFILETOCARRAY_STRING_COMPDATA)_FUNC_CONVERTFILETOCARRAY_STRING_COMPDATA=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_3823=NULL;
if (!byte_element_3823){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3823=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3823=(byte_element_struct*)mem_static_malloc(12);
}
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_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);
}
qbs *_FUNC_CONVERTFILETOCARRAY_STRING_TMPFILE=NULL;
if (!_FUNC_CONVERTFILETOCARRAY_STRING_TMPFILE)_FUNC_CONVERTFILETOCARRAY_STRING_TMPFILE=qbs_new(0,0);
byte_element_struct *byte_element_3842=NULL;
if (!byte_element_3842){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3842=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3842=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3825=NULL;
if (!byte_element_3825){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3825=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3825=(byte_element_struct*)mem_static_malloc(12);
}
int16 *_FUNC_CONVERTFILETOCARRAY_INTEGER_PACKED=NULL;
if(_FUNC_CONVERTFILETOCARRAY_INTEGER_PACKED==NULL){
@ -83,10 +83,10 @@ if(_FUNC_CONVERTFILETOCARRAY_LONG_VC==NULL){
_FUNC_CONVERTFILETOCARRAY_LONG_VC=(int32*)mem_static_malloc(4);
*_FUNC_CONVERTFILETOCARRAY_LONG_VC=0;
}
int64 fornext_value3844;
int64 fornext_finalvalue3844;
int64 fornext_step3844;
uint8 fornext_step_negative3844;
int64 fornext_value3827;
int64 fornext_finalvalue3827;
int64 fornext_step3827;
uint8 fornext_step_negative3827;
int32 *_FUNC_CONVERTFILETOCARRAY_LONG_NUML=NULL;
if(_FUNC_CONVERTFILETOCARRAY_LONG_NUML==NULL){
_FUNC_CONVERTFILETOCARRAY_LONG_NUML=(int32*)mem_static_malloc(4);
@ -97,10 +97,10 @@ if(_FUNC_CONVERTFILETOCARRAY_LONG_Z==NULL){
_FUNC_CONVERTFILETOCARRAY_LONG_Z=(int32*)mem_static_malloc(4);
*_FUNC_CONVERTFILETOCARRAY_LONG_Z=0;
}
int64 fornext_value3848;
int64 fornext_finalvalue3848;
int64 fornext_step3848;
uint8 fornext_step_negative3848;
int64 fornext_value3831;
int64 fornext_finalvalue3831;
int64 fornext_step3831;
uint8 fornext_step_negative3831;
int16 *_FUNC_CONVERTFILETOCARRAY_INTEGER_OFFI=NULL;
if(_FUNC_CONVERTFILETOCARRAY_INTEGER_OFFI==NULL){
_FUNC_CONVERTFILETOCARRAY_INTEGER_OFFI=(int16*)mem_static_malloc(2);
@ -123,24 +123,24 @@ if(_FUNC_CONVERTFILETOCARRAY_INTEGER_X==NULL){
_FUNC_CONVERTFILETOCARRAY_INTEGER_X=(int16*)mem_static_malloc(2);
*_FUNC_CONVERTFILETOCARRAY_INTEGER_X=0;
}
int32 fornext_value3858;
int32 fornext_finalvalue3858;
int32 fornext_step3858;
uint8 fornext_step_negative3858;
int32 fornext_value3841;
int32 fornext_finalvalue3841;
int32 fornext_step3841;
uint8 fornext_step_negative3841;
int8 *_FUNC_CONVERTFILETOCARRAY_BYTE_TMPB=NULL;
if(_FUNC_CONVERTFILETOCARRAY_BYTE_TMPB==NULL){
_FUNC_CONVERTFILETOCARRAY_BYTE_TMPB=(int8*)mem_static_malloc(1);
*_FUNC_CONVERTFILETOCARRAY_BYTE_TMPB=0;
}
byte_element_struct *byte_element_3859=NULL;
if (!byte_element_3859){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3859=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3859=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3842=NULL;
if (!byte_element_3842){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3842=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3842=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value3873;
int64 fornext_finalvalue3873;
int64 fornext_step3873;
uint8 fornext_step_negative3873;
byte_element_struct *byte_element_3879=NULL;
if (!byte_element_3879){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3879=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3879=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3856;
int64 fornext_finalvalue3856;
int64 fornext_step3856;
uint8 fornext_step_negative3856;
byte_element_struct *byte_element_3862=NULL;
if (!byte_element_3862){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3862=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3862=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,27 +1,27 @@
qbs *_FUNC_GETFILEPATH_STRING_GETFILEPATH=NULL;
if (!_FUNC_GETFILEPATH_STRING_GETFILEPATH)_FUNC_GETFILEPATH_STRING_GETFILEPATH=qbs_new(0,0);
qbs*oldstr3883=NULL;
qbs*oldstr3866=NULL;
if(_FUNC_GETFILEPATH_STRING_F->tmp||_FUNC_GETFILEPATH_STRING_F->fixed||_FUNC_GETFILEPATH_STRING_F->readonly){
oldstr3883=_FUNC_GETFILEPATH_STRING_F;
if (oldstr3883->cmem_descriptor){
_FUNC_GETFILEPATH_STRING_F=qbs_new_cmem(oldstr3883->len,0);
oldstr3866=_FUNC_GETFILEPATH_STRING_F;
if (oldstr3866->cmem_descriptor){
_FUNC_GETFILEPATH_STRING_F=qbs_new_cmem(oldstr3866->len,0);
}else{
_FUNC_GETFILEPATH_STRING_F=qbs_new(oldstr3883->len,0);
_FUNC_GETFILEPATH_STRING_F=qbs_new(oldstr3866->len,0);
}
memcpy(_FUNC_GETFILEPATH_STRING_F->chr,oldstr3883->chr,oldstr3883->len);
memcpy(_FUNC_GETFILEPATH_STRING_F->chr,oldstr3866->chr,oldstr3866->len);
}
int32 *_FUNC_GETFILEPATH_LONG_I=NULL;
if(_FUNC_GETFILEPATH_LONG_I==NULL){
_FUNC_GETFILEPATH_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_GETFILEPATH_LONG_I=0;
}
int64 fornext_value3885;
int64 fornext_finalvalue3885;
int64 fornext_step3885;
uint8 fornext_step_negative3885;
byte_element_struct *byte_element_3886=NULL;
if (!byte_element_3886){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3886=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3886=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3868;
int64 fornext_finalvalue3868;
int64 fornext_step3868;
uint8 fornext_step_negative3868;
byte_element_struct *byte_element_3869=NULL;
if (!byte_element_3869){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3869=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3869=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_GETFILEPATH_STRING_A=NULL;
if (!_FUNC_GETFILEPATH_STRING_A)_FUNC_GETFILEPATH_STRING_A=qbs_new(0,0);

View file

@ -3,28 +3,28 @@ if(_FUNC_FILEHASEXTENSION_LONG_FILEHASEXTENSION==NULL){
_FUNC_FILEHASEXTENSION_LONG_FILEHASEXTENSION=(int32*)mem_static_malloc(4);
*_FUNC_FILEHASEXTENSION_LONG_FILEHASEXTENSION=0;
}
qbs*oldstr3887=NULL;
qbs*oldstr3870=NULL;
if(_FUNC_FILEHASEXTENSION_STRING_F->tmp||_FUNC_FILEHASEXTENSION_STRING_F->fixed||_FUNC_FILEHASEXTENSION_STRING_F->readonly){
oldstr3887=_FUNC_FILEHASEXTENSION_STRING_F;
if (oldstr3887->cmem_descriptor){
_FUNC_FILEHASEXTENSION_STRING_F=qbs_new_cmem(oldstr3887->len,0);
oldstr3870=_FUNC_FILEHASEXTENSION_STRING_F;
if (oldstr3870->cmem_descriptor){
_FUNC_FILEHASEXTENSION_STRING_F=qbs_new_cmem(oldstr3870->len,0);
}else{
_FUNC_FILEHASEXTENSION_STRING_F=qbs_new(oldstr3887->len,0);
_FUNC_FILEHASEXTENSION_STRING_F=qbs_new(oldstr3870->len,0);
}
memcpy(_FUNC_FILEHASEXTENSION_STRING_F->chr,oldstr3887->chr,oldstr3887->len);
memcpy(_FUNC_FILEHASEXTENSION_STRING_F->chr,oldstr3870->chr,oldstr3870->len);
}
int32 *_FUNC_FILEHASEXTENSION_LONG_I=NULL;
if(_FUNC_FILEHASEXTENSION_LONG_I==NULL){
_FUNC_FILEHASEXTENSION_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_FILEHASEXTENSION_LONG_I=0;
}
int64 fornext_value3889;
int64 fornext_finalvalue3889;
int64 fornext_step3889;
uint8 fornext_step_negative3889;
byte_element_struct *byte_element_3890=NULL;
if (!byte_element_3890){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3890=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3890=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3872;
int64 fornext_finalvalue3872;
int64 fornext_step3872;
uint8 fornext_step_negative3872;
byte_element_struct *byte_element_3873=NULL;
if (!byte_element_3873){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3873=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3873=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_FILEHASEXTENSION_LONG_A=NULL;
if(_FUNC_FILEHASEXTENSION_LONG_A==NULL){

View file

@ -1,27 +1,27 @@
qbs *_FUNC_REMOVEFILEEXTENSION_STRING_REMOVEFILEEXTENSION=NULL;
if (!_FUNC_REMOVEFILEEXTENSION_STRING_REMOVEFILEEXTENSION)_FUNC_REMOVEFILEEXTENSION_STRING_REMOVEFILEEXTENSION=qbs_new(0,0);
qbs*oldstr3891=NULL;
qbs*oldstr3874=NULL;
if(_FUNC_REMOVEFILEEXTENSION_STRING_F->tmp||_FUNC_REMOVEFILEEXTENSION_STRING_F->fixed||_FUNC_REMOVEFILEEXTENSION_STRING_F->readonly){
oldstr3891=_FUNC_REMOVEFILEEXTENSION_STRING_F;
if (oldstr3891->cmem_descriptor){
_FUNC_REMOVEFILEEXTENSION_STRING_F=qbs_new_cmem(oldstr3891->len,0);
oldstr3874=_FUNC_REMOVEFILEEXTENSION_STRING_F;
if (oldstr3874->cmem_descriptor){
_FUNC_REMOVEFILEEXTENSION_STRING_F=qbs_new_cmem(oldstr3874->len,0);
}else{
_FUNC_REMOVEFILEEXTENSION_STRING_F=qbs_new(oldstr3891->len,0);
_FUNC_REMOVEFILEEXTENSION_STRING_F=qbs_new(oldstr3874->len,0);
}
memcpy(_FUNC_REMOVEFILEEXTENSION_STRING_F->chr,oldstr3891->chr,oldstr3891->len);
memcpy(_FUNC_REMOVEFILEEXTENSION_STRING_F->chr,oldstr3874->chr,oldstr3874->len);
}
int32 *_FUNC_REMOVEFILEEXTENSION_LONG_I=NULL;
if(_FUNC_REMOVEFILEEXTENSION_LONG_I==NULL){
_FUNC_REMOVEFILEEXTENSION_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_REMOVEFILEEXTENSION_LONG_I=0;
}
int64 fornext_value3893;
int64 fornext_finalvalue3893;
int64 fornext_step3893;
uint8 fornext_step_negative3893;
byte_element_struct *byte_element_3894=NULL;
if (!byte_element_3894){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3894=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3894=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3876;
int64 fornext_finalvalue3876;
int64 fornext_step3876;
uint8 fornext_step_negative3876;
byte_element_struct *byte_element_3877=NULL;
if (!byte_element_3877){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3877=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3877=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_REMOVEFILEEXTENSION_LONG_A=NULL;
if(_FUNC_REMOVEFILEEXTENSION_LONG_A==NULL){

View file

@ -1,27 +1,27 @@
qbs *_FUNC_GETFILEEXTENSION_STRING_GETFILEEXTENSION=NULL;
if (!_FUNC_GETFILEEXTENSION_STRING_GETFILEEXTENSION)_FUNC_GETFILEEXTENSION_STRING_GETFILEEXTENSION=qbs_new(0,0);
qbs*oldstr3895=NULL;
qbs*oldstr3878=NULL;
if(_FUNC_GETFILEEXTENSION_STRING_F->tmp||_FUNC_GETFILEEXTENSION_STRING_F->fixed||_FUNC_GETFILEEXTENSION_STRING_F->readonly){
oldstr3895=_FUNC_GETFILEEXTENSION_STRING_F;
if (oldstr3895->cmem_descriptor){
_FUNC_GETFILEEXTENSION_STRING_F=qbs_new_cmem(oldstr3895->len,0);
oldstr3878=_FUNC_GETFILEEXTENSION_STRING_F;
if (oldstr3878->cmem_descriptor){
_FUNC_GETFILEEXTENSION_STRING_F=qbs_new_cmem(oldstr3878->len,0);
}else{
_FUNC_GETFILEEXTENSION_STRING_F=qbs_new(oldstr3895->len,0);
_FUNC_GETFILEEXTENSION_STRING_F=qbs_new(oldstr3878->len,0);
}
memcpy(_FUNC_GETFILEEXTENSION_STRING_F->chr,oldstr3895->chr,oldstr3895->len);
memcpy(_FUNC_GETFILEEXTENSION_STRING_F->chr,oldstr3878->chr,oldstr3878->len);
}
int32 *_FUNC_GETFILEEXTENSION_LONG_I=NULL;
if(_FUNC_GETFILEEXTENSION_LONG_I==NULL){
_FUNC_GETFILEEXTENSION_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_GETFILEEXTENSION_LONG_I=0;
}
int64 fornext_value3897;
int64 fornext_finalvalue3897;
int64 fornext_step3897;
uint8 fornext_step_negative3897;
byte_element_struct *byte_element_3898=NULL;
if (!byte_element_3898){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3898=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3898=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3880;
int64 fornext_finalvalue3880;
int64 fornext_step3880;
uint8 fornext_step_negative3880;
byte_element_struct *byte_element_3881=NULL;
if (!byte_element_3881){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3881=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3881=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_GETFILEEXTENSION_LONG_A=NULL;
if(_FUNC_GETFILEEXTENSION_LONG_A==NULL){

View file

@ -1,31 +1,31 @@
qbs*oldstr3899=NULL;
qbs*oldstr3882=NULL;
if(_SUB_PATH_SLASH_CORRECT_STRING_A->tmp||_SUB_PATH_SLASH_CORRECT_STRING_A->fixed||_SUB_PATH_SLASH_CORRECT_STRING_A->readonly){
oldstr3899=_SUB_PATH_SLASH_CORRECT_STRING_A;
if (oldstr3899->cmem_descriptor){
_SUB_PATH_SLASH_CORRECT_STRING_A=qbs_new_cmem(oldstr3899->len,0);
oldstr3882=_SUB_PATH_SLASH_CORRECT_STRING_A;
if (oldstr3882->cmem_descriptor){
_SUB_PATH_SLASH_CORRECT_STRING_A=qbs_new_cmem(oldstr3882->len,0);
}else{
_SUB_PATH_SLASH_CORRECT_STRING_A=qbs_new(oldstr3899->len,0);
_SUB_PATH_SLASH_CORRECT_STRING_A=qbs_new(oldstr3882->len,0);
}
memcpy(_SUB_PATH_SLASH_CORRECT_STRING_A->chr,oldstr3899->chr,oldstr3899->len);
memcpy(_SUB_PATH_SLASH_CORRECT_STRING_A->chr,oldstr3882->chr,oldstr3882->len);
}
int32 *_SUB_PATH_SLASH_CORRECT_LONG_X=NULL;
if(_SUB_PATH_SLASH_CORRECT_LONG_X==NULL){
_SUB_PATH_SLASH_CORRECT_LONG_X=(int32*)mem_static_malloc(4);
*_SUB_PATH_SLASH_CORRECT_LONG_X=0;
}
int64 fornext_value3901;
int64 fornext_finalvalue3901;
int64 fornext_step3901;
uint8 fornext_step_negative3901;
byte_element_struct *byte_element_3902=NULL;
if (!byte_element_3902){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3902=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3902=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3884;
int64 fornext_finalvalue3884;
int64 fornext_step3884;
uint8 fornext_step_negative3884;
byte_element_struct *byte_element_3885=NULL;
if (!byte_element_3885){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3885=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3885=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value3904;
int64 fornext_finalvalue3904;
int64 fornext_step3904;
uint8 fornext_step_negative3904;
byte_element_struct *byte_element_3905=NULL;
if (!byte_element_3905){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3905=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3905=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3887;
int64 fornext_finalvalue3887;
int64 fornext_step3887;
uint8 fornext_step_negative3887;
byte_element_struct *byte_element_3888=NULL;
if (!byte_element_3888){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3888=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3888=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,14 +1,14 @@
qbs *_FUNC_GETESCAPEDPATH_STRING_GETESCAPEDPATH=NULL;
if (!_FUNC_GETESCAPEDPATH_STRING_GETESCAPEDPATH)_FUNC_GETESCAPEDPATH_STRING_GETESCAPEDPATH=qbs_new(0,0);
qbs*oldstr3906=NULL;
qbs*oldstr3889=NULL;
if(_FUNC_GETESCAPEDPATH_STRING_PATH_NAME->tmp||_FUNC_GETESCAPEDPATH_STRING_PATH_NAME->fixed||_FUNC_GETESCAPEDPATH_STRING_PATH_NAME->readonly){
oldstr3906=_FUNC_GETESCAPEDPATH_STRING_PATH_NAME;
if (oldstr3906->cmem_descriptor){
_FUNC_GETESCAPEDPATH_STRING_PATH_NAME=qbs_new_cmem(oldstr3906->len,0);
oldstr3889=_FUNC_GETESCAPEDPATH_STRING_PATH_NAME;
if (oldstr3889->cmem_descriptor){
_FUNC_GETESCAPEDPATH_STRING_PATH_NAME=qbs_new_cmem(oldstr3889->len,0);
}else{
_FUNC_GETESCAPEDPATH_STRING_PATH_NAME=qbs_new(oldstr3906->len,0);
_FUNC_GETESCAPEDPATH_STRING_PATH_NAME=qbs_new(oldstr3889->len,0);
}
memcpy(_FUNC_GETESCAPEDPATH_STRING_PATH_NAME->chr,oldstr3906->chr,oldstr3906->len);
memcpy(_FUNC_GETESCAPEDPATH_STRING_PATH_NAME->chr,oldstr3889->chr,oldstr3889->len);
}
qbs *_FUNC_GETESCAPEDPATH_STRING_BUF=NULL;
if (!_FUNC_GETESCAPEDPATH_STRING_BUF)_FUNC_GETESCAPEDPATH_STRING_BUF=qbs_new(0,0);
@ -22,11 +22,11 @@ if(_FUNC_GETESCAPEDPATH_UBYTE_A==NULL){
_FUNC_GETESCAPEDPATH_UBYTE_A=(uint8*)mem_static_malloc(1);
*_FUNC_GETESCAPEDPATH_UBYTE_A=0;
}
int64 fornext_value3908;
int64 fornext_finalvalue3908;
int64 fornext_step3908;
uint8 fornext_step_negative3908;
byte_element_struct *byte_element_3909=NULL;
if (!byte_element_3909){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3909=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3909=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3891;
int64 fornext_finalvalue3891;
int64 fornext_step3891;
uint8 fornext_step_negative3891;
byte_element_struct *byte_element_3892=NULL;
if (!byte_element_3892){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3892=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3892=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,16 +1,16 @@
qbs *_FUNC_FIXDIRECTORYNAME_STRING_FIXDIRECTORYNAME=NULL;
if (!_FUNC_FIXDIRECTORYNAME_STRING_FIXDIRECTORYNAME)_FUNC_FIXDIRECTORYNAME_STRING_FIXDIRECTORYNAME=qbs_new(0,0);
qbs*oldstr3910=NULL;
qbs*oldstr3893=NULL;
if(_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME->tmp||_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME->fixed||_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME->readonly){
oldstr3910=_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME;
if (oldstr3910->cmem_descriptor){
_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME=qbs_new_cmem(oldstr3910->len,0);
oldstr3893=_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME;
if (oldstr3893->cmem_descriptor){
_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME=qbs_new_cmem(oldstr3893->len,0);
}else{
_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME=qbs_new(oldstr3910->len,0);
_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME=qbs_new(oldstr3893->len,0);
}
memcpy(_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME->chr,oldstr3910->chr,oldstr3910->len);
memcpy(_FUNC_FIXDIRECTORYNAME_STRING_DIR_NAME->chr,oldstr3893->chr,oldstr3893->len);
}
byte_element_struct *byte_element_3911=NULL;
if (!byte_element_3911){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3911=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3911=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3894=NULL;
if (!byte_element_3894){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3894=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3894=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,12 +1,12 @@
qbs*oldstr3912=NULL;
qbs*oldstr3895=NULL;
if(_SUB_PURGETEMPORARYBUILDFILES_STRING_OS->tmp||_SUB_PURGETEMPORARYBUILDFILES_STRING_OS->fixed||_SUB_PURGETEMPORARYBUILDFILES_STRING_OS->readonly){
oldstr3912=_SUB_PURGETEMPORARYBUILDFILES_STRING_OS;
if (oldstr3912->cmem_descriptor){
_SUB_PURGETEMPORARYBUILDFILES_STRING_OS=qbs_new_cmem(oldstr3912->len,0);
oldstr3895=_SUB_PURGETEMPORARYBUILDFILES_STRING_OS;
if (oldstr3895->cmem_descriptor){
_SUB_PURGETEMPORARYBUILDFILES_STRING_OS=qbs_new_cmem(oldstr3895->len,0);
}else{
_SUB_PURGETEMPORARYBUILDFILES_STRING_OS=qbs_new(oldstr3912->len,0);
_SUB_PURGETEMPORARYBUILDFILES_STRING_OS=qbs_new(oldstr3895->len,0);
}
memcpy(_SUB_PURGETEMPORARYBUILDFILES_STRING_OS->chr,oldstr3912->chr,oldstr3912->len);
memcpy(_SUB_PURGETEMPORARYBUILDFILES_STRING_OS->chr,oldstr3895->chr,oldstr3895->len);
}
qbs *_SUB_PURGETEMPORARYBUILDFILES_STRING_MAKE=NULL;
if (!_SUB_PURGETEMPORARYBUILDFILES_STRING_MAKE)_SUB_PURGETEMPORARYBUILDFILES_STRING_MAKE=qbs_new(0,0);

View file

@ -1,14 +1,14 @@
qbs *_FUNC_MAKENMOUTPUTFILENAME_STRING_MAKENMOUTPUTFILENAME=NULL;
if (!_FUNC_MAKENMOUTPUTFILENAME_STRING_MAKENMOUTPUTFILENAME)_FUNC_MAKENMOUTPUTFILENAME_STRING_MAKENMOUTPUTFILENAME=qbs_new(0,0);
qbs*oldstr3913=NULL;
qbs*oldstr3896=NULL;
if(_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE->tmp||_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE->fixed||_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE->readonly){
oldstr3913=_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE;
if (oldstr3913->cmem_descriptor){
_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE=qbs_new_cmem(oldstr3913->len,0);
oldstr3896=_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE;
if (oldstr3896->cmem_descriptor){
_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE=qbs_new_cmem(oldstr3896->len,0);
}else{
_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE=qbs_new(oldstr3913->len,0);
_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE=qbs_new(oldstr3896->len,0);
}
memcpy(_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE->chr,oldstr3913->chr,oldstr3913->len);
memcpy(_FUNC_MAKENMOUTPUTFILENAME_STRING_LIBFILE->chr,oldstr3896->chr,oldstr3896->len);
}
qbs *_FUNC_MAKENMOUTPUTFILENAME_STRING_DYN=NULL;
if (!_FUNC_MAKENMOUTPUTFILENAME_STRING_DYN)_FUNC_MAKENMOUTPUTFILENAME_STRING_DYN=qbs_new(0,0);

View file

@ -1,14 +1,14 @@
qbs *_FUNC_GETELEMENT_STRING_GETELEMENT=NULL;
if (!_FUNC_GETELEMENT_STRING_GETELEMENT)_FUNC_GETELEMENT_STRING_GETELEMENT=qbs_new(0,0);
qbs*oldstr3914=NULL;
qbs*oldstr3897=NULL;
if(_FUNC_GETELEMENT_STRING_A->tmp||_FUNC_GETELEMENT_STRING_A->fixed||_FUNC_GETELEMENT_STRING_A->readonly){
oldstr3914=_FUNC_GETELEMENT_STRING_A;
if (oldstr3914->cmem_descriptor){
_FUNC_GETELEMENT_STRING_A=qbs_new_cmem(oldstr3914->len,0);
oldstr3897=_FUNC_GETELEMENT_STRING_A;
if (oldstr3897->cmem_descriptor){
_FUNC_GETELEMENT_STRING_A=qbs_new_cmem(oldstr3897->len,0);
}else{
_FUNC_GETELEMENT_STRING_A=qbs_new(oldstr3914->len,0);
_FUNC_GETELEMENT_STRING_A=qbs_new(oldstr3897->len,0);
}
memcpy(_FUNC_GETELEMENT_STRING_A->chr,oldstr3914->chr,oldstr3914->len);
memcpy(_FUNC_GETELEMENT_STRING_A->chr,oldstr3897->chr,oldstr3897->len);
}
int32 *_FUNC_GETELEMENT_LONG_P=NULL;
if(_FUNC_GETELEMENT_LONG_P==NULL){
@ -25,7 +25,7 @@ if(_FUNC_GETELEMENT_LONG_I==NULL){
_FUNC_GETELEMENT_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_GETELEMENT_LONG_I=0;
}
byte_element_struct *byte_element_3915=NULL;
if (!byte_element_3915){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3915=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3915=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3898=NULL;
if (!byte_element_3898){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3898=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3898=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,14 +1,14 @@
qbs *_FUNC_GETELEMENTS_STRING_GETELEMENTS=NULL;
if (!_FUNC_GETELEMENTS_STRING_GETELEMENTS)_FUNC_GETELEMENTS_STRING_GETELEMENTS=qbs_new(0,0);
qbs*oldstr3916=NULL;
qbs*oldstr3899=NULL;
if(_FUNC_GETELEMENTS_STRING_A->tmp||_FUNC_GETELEMENTS_STRING_A->fixed||_FUNC_GETELEMENTS_STRING_A->readonly){
oldstr3916=_FUNC_GETELEMENTS_STRING_A;
if (oldstr3916->cmem_descriptor){
_FUNC_GETELEMENTS_STRING_A=qbs_new_cmem(oldstr3916->len,0);
oldstr3899=_FUNC_GETELEMENTS_STRING_A;
if (oldstr3899->cmem_descriptor){
_FUNC_GETELEMENTS_STRING_A=qbs_new_cmem(oldstr3899->len,0);
}else{
_FUNC_GETELEMENTS_STRING_A=qbs_new(oldstr3916->len,0);
_FUNC_GETELEMENTS_STRING_A=qbs_new(oldstr3899->len,0);
}
memcpy(_FUNC_GETELEMENTS_STRING_A->chr,oldstr3916->chr,oldstr3916->len);
memcpy(_FUNC_GETELEMENTS_STRING_A->chr,oldstr3899->chr,oldstr3899->len);
}
int32 *_FUNC_GETELEMENTS_LONG_P=NULL;
if(_FUNC_GETELEMENTS_LONG_P==NULL){
@ -30,7 +30,7 @@ if(_FUNC_GETELEMENTS_LONG_I1POS==NULL){
_FUNC_GETELEMENTS_LONG_I1POS=(int32*)mem_static_malloc(4);
*_FUNC_GETELEMENTS_LONG_I1POS=0;
}
byte_element_struct *byte_element_3917=NULL;
if (!byte_element_3917){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3917=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3917=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3900=NULL;
if (!byte_element_3900){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3900=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3900=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,22 +1,22 @@
qbs*oldstr3918=NULL;
qbs*oldstr3901=NULL;
if(_SUB_INSERTELEMENTS_STRING_A->tmp||_SUB_INSERTELEMENTS_STRING_A->fixed||_SUB_INSERTELEMENTS_STRING_A->readonly){
oldstr3918=_SUB_INSERTELEMENTS_STRING_A;
if (oldstr3918->cmem_descriptor){
_SUB_INSERTELEMENTS_STRING_A=qbs_new_cmem(oldstr3918->len,0);
oldstr3901=_SUB_INSERTELEMENTS_STRING_A;
if (oldstr3901->cmem_descriptor){
_SUB_INSERTELEMENTS_STRING_A=qbs_new_cmem(oldstr3901->len,0);
}else{
_SUB_INSERTELEMENTS_STRING_A=qbs_new(oldstr3918->len,0);
_SUB_INSERTELEMENTS_STRING_A=qbs_new(oldstr3901->len,0);
}
memcpy(_SUB_INSERTELEMENTS_STRING_A->chr,oldstr3918->chr,oldstr3918->len);
memcpy(_SUB_INSERTELEMENTS_STRING_A->chr,oldstr3901->chr,oldstr3901->len);
}
qbs*oldstr3919=NULL;
qbs*oldstr3902=NULL;
if(_SUB_INSERTELEMENTS_STRING_ELEMENTS->tmp||_SUB_INSERTELEMENTS_STRING_ELEMENTS->fixed||_SUB_INSERTELEMENTS_STRING_ELEMENTS->readonly){
oldstr3919=_SUB_INSERTELEMENTS_STRING_ELEMENTS;
if (oldstr3919->cmem_descriptor){
_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new_cmem(oldstr3919->len,0);
oldstr3902=_SUB_INSERTELEMENTS_STRING_ELEMENTS;
if (oldstr3902->cmem_descriptor){
_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new_cmem(oldstr3902->len,0);
}else{
_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new(oldstr3919->len,0);
_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new(oldstr3902->len,0);
}
memcpy(_SUB_INSERTELEMENTS_STRING_ELEMENTS->chr,oldstr3919->chr,oldstr3919->len);
memcpy(_SUB_INSERTELEMENTS_STRING_ELEMENTS->chr,oldstr3902->chr,oldstr3902->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_value3921;
int64 fornext_finalvalue3921;
int64 fornext_step3921;
uint8 fornext_step_negative3921;
int64 fornext_value3904;
int64 fornext_finalvalue3904;
int64 fornext_step3904;
uint8 fornext_step_negative3904;

View file

@ -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*oldstr3922=NULL;
qbs*oldstr3905=NULL;
if(_FUNC_NUMELEMENTS_STRING_A->tmp||_FUNC_NUMELEMENTS_STRING_A->fixed||_FUNC_NUMELEMENTS_STRING_A->readonly){
oldstr3922=_FUNC_NUMELEMENTS_STRING_A;
if (oldstr3922->cmem_descriptor){
_FUNC_NUMELEMENTS_STRING_A=qbs_new_cmem(oldstr3922->len,0);
oldstr3905=_FUNC_NUMELEMENTS_STRING_A;
if (oldstr3905->cmem_descriptor){
_FUNC_NUMELEMENTS_STRING_A=qbs_new_cmem(oldstr3905->len,0);
}else{
_FUNC_NUMELEMENTS_STRING_A=qbs_new(oldstr3922->len,0);
_FUNC_NUMELEMENTS_STRING_A=qbs_new(oldstr3905->len,0);
}
memcpy(_FUNC_NUMELEMENTS_STRING_A->chr,oldstr3922->chr,oldstr3922->len);
memcpy(_FUNC_NUMELEMENTS_STRING_A->chr,oldstr3905->chr,oldstr3905->len);
}
int32 *_FUNC_NUMELEMENTS_LONG_P=NULL;
if(_FUNC_NUMELEMENTS_LONG_P==NULL){

View file

@ -1,12 +1,12 @@
qbs*oldstr3923=NULL;
qbs*oldstr3906=NULL;
if(_SUB_REMOVEELEMENTS_STRING_A->tmp||_SUB_REMOVEELEMENTS_STRING_A->fixed||_SUB_REMOVEELEMENTS_STRING_A->readonly){
oldstr3923=_SUB_REMOVEELEMENTS_STRING_A;
if (oldstr3923->cmem_descriptor){
_SUB_REMOVEELEMENTS_STRING_A=qbs_new_cmem(oldstr3923->len,0);
oldstr3906=_SUB_REMOVEELEMENTS_STRING_A;
if (oldstr3906->cmem_descriptor){
_SUB_REMOVEELEMENTS_STRING_A=qbs_new_cmem(oldstr3906->len,0);
}else{
_SUB_REMOVEELEMENTS_STRING_A=qbs_new(oldstr3923->len,0);
_SUB_REMOVEELEMENTS_STRING_A=qbs_new(oldstr3906->len,0);
}
memcpy(_SUB_REMOVEELEMENTS_STRING_A->chr,oldstr3923->chr,oldstr3923->len);
memcpy(_SUB_REMOVEELEMENTS_STRING_A->chr,oldstr3906->chr,oldstr3906->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_value3925;
int64 fornext_finalvalue3925;
int64 fornext_step3925;
uint8 fornext_step_negative3925;
byte_element_struct *byte_element_3926=NULL;
if (!byte_element_3926){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3926=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3926=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3908;
int64 fornext_finalvalue3908;
int64 fornext_step3908;
uint8 fornext_step_negative3908;
byte_element_struct *byte_element_3909=NULL;
if (!byte_element_3909){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3909=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3909=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -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*oldstr3927=NULL;
qbs*oldstr3910=NULL;
if(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->tmp||_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->fixed||_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->readonly){
oldstr3927=_FUNC_COUNTFUNCTIONELEMENTS_STRING_A;
if (oldstr3927->cmem_descriptor){
_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new_cmem(oldstr3927->len,0);
oldstr3910=_FUNC_COUNTFUNCTIONELEMENTS_STRING_A;
if (oldstr3910->cmem_descriptor){
_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new_cmem(oldstr3910->len,0);
}else{
_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new(oldstr3927->len,0);
_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new(oldstr3910->len,0);
}
memcpy(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->chr,oldstr3927->chr,oldstr3927->len);
memcpy(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->chr,oldstr3910->chr,oldstr3910->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_3928=NULL;
if (!byte_element_3928){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3928=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3928=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3911=NULL;
if (!byte_element_3911){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3911=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3911=(byte_element_struct*)mem_static_malloc(12);
}
static int32 sc_3930;
static int32 sc_3913;

View file

@ -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*oldstr3931=NULL;
qbs*oldstr3914=NULL;
if(_FUNC_HASFUNCTIONELEMENT_STRING_A->tmp||_FUNC_HASFUNCTIONELEMENT_STRING_A->fixed||_FUNC_HASFUNCTIONELEMENT_STRING_A->readonly){
oldstr3931=_FUNC_HASFUNCTIONELEMENT_STRING_A;
if (oldstr3931->cmem_descriptor){
_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new_cmem(oldstr3931->len,0);
oldstr3914=_FUNC_HASFUNCTIONELEMENT_STRING_A;
if (oldstr3914->cmem_descriptor){
_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new_cmem(oldstr3914->len,0);
}else{
_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new(oldstr3931->len,0);
_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new(oldstr3914->len,0);
}
memcpy(_FUNC_HASFUNCTIONELEMENT_STRING_A->chr,oldstr3931->chr,oldstr3931->len);
memcpy(_FUNC_HASFUNCTIONELEMENT_STRING_A->chr,oldstr3914->chr,oldstr3914->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_3932=NULL;
if (!byte_element_3932){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3932=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3932=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3915=NULL;
if (!byte_element_3915){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3915=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3915=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_3933=NULL;
if (!byte_element_3933){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3933=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3933=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3916=NULL;
if (!byte_element_3916){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3916=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3916=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_3935=NULL;
if (!byte_element_3935){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3935=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3935=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3918=NULL;
if (!byte_element_3918){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3918=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3918=(byte_element_struct*)mem_static_malloc(12);
}
static int32 sc_3936;
static int32 sc_3919;

View file

@ -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*oldstr3937=NULL;
qbs*oldstr3920=NULL;
if(_FUNC_ISVALIDARGSET_STRING_FORMAT->tmp||_FUNC_ISVALIDARGSET_STRING_FORMAT->fixed||_FUNC_ISVALIDARGSET_STRING_FORMAT->readonly){
oldstr3937=_FUNC_ISVALIDARGSET_STRING_FORMAT;
if (oldstr3937->cmem_descriptor){
_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new_cmem(oldstr3937->len,0);
oldstr3920=_FUNC_ISVALIDARGSET_STRING_FORMAT;
if (oldstr3920->cmem_descriptor){
_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new_cmem(oldstr3920->len,0);
}else{
_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new(oldstr3937->len,0);
_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new(oldstr3920->len,0);
}
memcpy(_FUNC_ISVALIDARGSET_STRING_FORMAT->chr,oldstr3937->chr,oldstr3937->len);
memcpy(_FUNC_ISVALIDARGSET_STRING_FORMAT->chr,oldstr3920->chr,oldstr3920->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_value3939;
int64 fornext_finalvalue3939;
int64 fornext_step3939;
uint8 fornext_step_negative3939;
byte_element_struct *byte_element_3940=NULL;
if (!byte_element_3940){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3940=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3940=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3922;
int64 fornext_finalvalue3922;
int64 fornext_step3922;
uint8 fornext_step_negative3922;
byte_element_struct *byte_element_3923=NULL;
if (!byte_element_3923){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3923=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3923=(byte_element_struct*)mem_static_malloc(12);
}
static int32 sc_3941;
static int32 sc_3924;

View file

@ -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*oldstr3942=NULL;
qbs*oldstr3925=NULL;
if(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_A->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_A->readonly){
oldstr3942=_FUNC_GL2QB_TYPE_CONVERT_STRING_A;
if (oldstr3942->cmem_descriptor){
_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new_cmem(oldstr3942->len,0);
oldstr3925=_FUNC_GL2QB_TYPE_CONVERT_STRING_A;
if (oldstr3925->cmem_descriptor){
_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new_cmem(oldstr3925->len,0);
}else{
_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new(oldstr3942->len,0);
_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new(oldstr3925->len,0);
}
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->chr,oldstr3942->chr,oldstr3942->len);
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->chr,oldstr3925->chr,oldstr3925->len);
}
qbs*oldstr3943=NULL;
qbs*oldstr3926=NULL;
if(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->readonly){
oldstr3943=_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL;
if (oldstr3943->cmem_descriptor){
_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new_cmem(oldstr3943->len,0);
oldstr3926=_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL;
if (oldstr3926->cmem_descriptor){
_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new_cmem(oldstr3926->len,0);
}else{
_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new(oldstr3943->len,0);
_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new(oldstr3926->len,0);
}
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->chr,oldstr3943->chr,oldstr3943->len);
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->chr,oldstr3926->chr,oldstr3926->len);
}
qbs*oldstr3944=NULL;
qbs*oldstr3927=NULL;
if(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->readonly){
oldstr3944=_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP;
if (oldstr3944->cmem_descriptor){
_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new_cmem(oldstr3944->len,0);
oldstr3927=_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP;
if (oldstr3927->cmem_descriptor){
_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new_cmem(oldstr3927->len,0);
}else{
_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new(oldstr3944->len,0);
_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new(oldstr3927->len,0);
}
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->chr,oldstr3944->chr,oldstr3944->len);
memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->chr,oldstr3927->chr,oldstr3927->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);

View file

@ -1,44 +1,44 @@
qbs *_FUNC_READCHUNK_STRING_READCHUNK=NULL;
if (!_FUNC_READCHUNK_STRING_READCHUNK)_FUNC_READCHUNK_STRING_READCHUNK=qbs_new(0,0);
qbs*oldstr3946=NULL;
qbs*oldstr3929=NULL;
if(_FUNC_READCHUNK_STRING_A->tmp||_FUNC_READCHUNK_STRING_A->fixed||_FUNC_READCHUNK_STRING_A->readonly){
oldstr3946=_FUNC_READCHUNK_STRING_A;
if (oldstr3946->cmem_descriptor){
_FUNC_READCHUNK_STRING_A=qbs_new_cmem(oldstr3946->len,0);
oldstr3929=_FUNC_READCHUNK_STRING_A;
if (oldstr3929->cmem_descriptor){
_FUNC_READCHUNK_STRING_A=qbs_new_cmem(oldstr3929->len,0);
}else{
_FUNC_READCHUNK_STRING_A=qbs_new(oldstr3946->len,0);
_FUNC_READCHUNK_STRING_A=qbs_new(oldstr3929->len,0);
}
memcpy(_FUNC_READCHUNK_STRING_A->chr,oldstr3946->chr,oldstr3946->len);
memcpy(_FUNC_READCHUNK_STRING_A->chr,oldstr3929->chr,oldstr3929->len);
}
qbs*oldstr3947=NULL;
qbs*oldstr3930=NULL;
if(_FUNC_READCHUNK_STRING_LAST_CHARACTER->tmp||_FUNC_READCHUNK_STRING_LAST_CHARACTER->fixed||_FUNC_READCHUNK_STRING_LAST_CHARACTER->readonly){
oldstr3947=_FUNC_READCHUNK_STRING_LAST_CHARACTER;
if (oldstr3947->cmem_descriptor){
_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new_cmem(oldstr3947->len,0);
oldstr3930=_FUNC_READCHUNK_STRING_LAST_CHARACTER;
if (oldstr3930->cmem_descriptor){
_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new_cmem(oldstr3930->len,0);
}else{
_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new(oldstr3947->len,0);
_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new(oldstr3930->len,0);
}
memcpy(_FUNC_READCHUNK_STRING_LAST_CHARACTER->chr,oldstr3947->chr,oldstr3947->len);
memcpy(_FUNC_READCHUNK_STRING_LAST_CHARACTER->chr,oldstr3930->chr,oldstr3930->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_value3949;
int64 fornext_finalvalue3949;
int64 fornext_step3949;
uint8 fornext_step_negative3949;
byte_element_struct *byte_element_3950=NULL;
if (!byte_element_3950){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3950=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3950=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3932;
int64 fornext_finalvalue3932;
int64 fornext_step3932;
uint8 fornext_step_negative3932;
byte_element_struct *byte_element_3933=NULL;
if (!byte_element_3933){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3933=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3933=(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_3951=NULL;
if (!byte_element_3951){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3951=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3951=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3934=NULL;
if (!byte_element_3934){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3934=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3934=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -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_3955=NULL;
if (!byte_element_3955){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3955=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3955=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3938=NULL;
if (!byte_element_3938){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3938=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3938=(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_value3957;
int64 fornext_finalvalue3957;
int64 fornext_step3957;
uint8 fornext_step_negative3957;
byte_element_struct *byte_element_3958=NULL;
if (!byte_element_3958){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3958=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3958=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3940;
int64 fornext_finalvalue3940;
int64 fornext_step3940;
uint8 fornext_step_negative3940;
byte_element_struct *byte_element_3941=NULL;
if (!byte_element_3941){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3941=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3941=(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_value3960;
int64 fornext_finalvalue3960;
int64 fornext_step3960;
uint8 fornext_step_negative3960;
byte_element_struct *byte_element_3961=NULL;
if (!byte_element_3961){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3961=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3961=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3943;
int64 fornext_finalvalue3943;
int64 fornext_step3943;
uint8 fornext_step_negative3943;
byte_element_struct *byte_element_3944=NULL;
if (!byte_element_3944){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3944=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3944=(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_3962=NULL;
if (!byte_element_3962){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3962=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3962=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3945=NULL;
if (!byte_element_3945){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3945=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3945=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_3963=NULL;
if (!byte_element_3963){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3963=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3963=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3946=NULL;
if (!byte_element_3946){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3946=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3946=(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_3964=NULL;
if (!byte_element_3964){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3964=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3964=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3947=NULL;
if (!byte_element_3947){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3947=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3947=(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_value3966;
int64 fornext_finalvalue3966;
int64 fornext_step3966;
uint8 fornext_step_negative3966;
int64 fornext_value3949;
int64 fornext_finalvalue3949;
int64 fornext_step3949;
uint8 fornext_step_negative3949;
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_3973=NULL;
if (!byte_element_3973){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3973=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3973=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3956=NULL;
if (!byte_element_3956){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3956=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3956=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_3974=NULL;
if (!byte_element_3974){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3974=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3974=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3957=NULL;
if (!byte_element_3957){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3957=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3957=(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_3975=NULL;
if (!byte_element_3975){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3975=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3975=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3958=NULL;
if (!byte_element_3958){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3958=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3958=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_3976=NULL;
if (!byte_element_3976){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3976=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3976=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3959=NULL;
if (!byte_element_3959){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3959=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3959=(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_value3983;
int64 fornext_finalvalue3983;
int64 fornext_step3983;
uint8 fornext_step_negative3983;
int64 fornext_value3966;
int64 fornext_finalvalue3966;
int64 fornext_step3966;
uint8 fornext_step_negative3966;
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);

View file

@ -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_value3987;
int64 fornext_finalvalue3987;
int64 fornext_step3987;
uint8 fornext_step_negative3987;
int64 fornext_value3970;
int64 fornext_finalvalue3970;
int64 fornext_step3970;
uint8 fornext_step_negative3970;
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 pass3988;
int32 pass3971;
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_value3990;
int64 fornext_finalvalue3990;
int64 fornext_step3990;
uint8 fornext_step_negative3990;
int64 fornext_value3973;
int64 fornext_finalvalue3973;
int64 fornext_step3973;
uint8 fornext_step_negative3973;
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);

View file

@ -1,17 +1,17 @@
byte_element_struct *byte_element_3991=NULL;
if (!byte_element_3991){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3991=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3991=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3974=NULL;
if (!byte_element_3974){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3974=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3974=(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_3992=NULL;
if (!byte_element_3992){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3992=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3992=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3975=NULL;
if (!byte_element_3975){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3975=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3975=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_3993=NULL;
if (!byte_element_3993){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3993=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3993=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3976=NULL;
if (!byte_element_3976){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3976=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3976=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,14 +1,14 @@
qbs *_FUNC_INIGETSECTION_STRING_INIGETSECTION=NULL;
if (!_FUNC_INIGETSECTION_STRING_INIGETSECTION)_FUNC_INIGETSECTION_STRING_INIGETSECTION=qbs_new(0,0);
qbs*oldstr3994=NULL;
qbs*oldstr3977=NULL;
if(_FUNC_INIGETSECTION_STRING___SECTION->tmp||_FUNC_INIGETSECTION_STRING___SECTION->fixed||_FUNC_INIGETSECTION_STRING___SECTION->readonly){
oldstr3994=_FUNC_INIGETSECTION_STRING___SECTION;
if (oldstr3994->cmem_descriptor){
_FUNC_INIGETSECTION_STRING___SECTION=qbs_new_cmem(oldstr3994->len,0);
oldstr3977=_FUNC_INIGETSECTION_STRING___SECTION;
if (oldstr3977->cmem_descriptor){
_FUNC_INIGETSECTION_STRING___SECTION=qbs_new_cmem(oldstr3977->len,0);
}else{
_FUNC_INIGETSECTION_STRING___SECTION=qbs_new(oldstr3994->len,0);
_FUNC_INIGETSECTION_STRING___SECTION=qbs_new(oldstr3977->len,0);
}
memcpy(_FUNC_INIGETSECTION_STRING___SECTION->chr,oldstr3994->chr,oldstr3994->len);
memcpy(_FUNC_INIGETSECTION_STRING___SECTION->chr,oldstr3977->chr,oldstr3977->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_value3996;
int64 fornext_finalvalue3996;
int64 fornext_step3996;
uint8 fornext_step_negative3996;
int64 fornext_value3999;
int64 fornext_finalvalue3999;
int64 fornext_step3999;
uint8 fornext_step_negative3999;
int64 fornext_value4001;
int64 fornext_finalvalue4001;
int64 fornext_step4001;
uint8 fornext_step_negative4001;
int64 fornext_value4003;
int64 fornext_finalvalue4003;
int64 fornext_step4003;
uint8 fornext_step_negative4003;
byte_element_struct *byte_element_4004=NULL;
if (!byte_element_4004){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4004=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4004=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3979;
int64 fornext_finalvalue3979;
int64 fornext_step3979;
uint8 fornext_step_negative3979;
int64 fornext_value3982;
int64 fornext_finalvalue3982;
int64 fornext_step3982;
uint8 fornext_step_negative3982;
int64 fornext_value3984;
int64 fornext_finalvalue3984;
int64 fornext_step3984;
uint8 fornext_step_negative3984;
int64 fornext_value3986;
int64 fornext_finalvalue3986;
int64 fornext_step3986;
uint8 fornext_step_negative3986;
byte_element_struct *byte_element_3987=NULL;
if (!byte_element_3987){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3987=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3987=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,22 +1,22 @@
qbs *_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION=NULL;
if (!_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION)_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION=qbs_new(0,0);
qbs*oldstr4005=NULL;
qbs*oldstr3988=NULL;
if(_FUNC_INIFORMATSECTION_STRING___SECTION->tmp||_FUNC_INIFORMATSECTION_STRING___SECTION->fixed||_FUNC_INIFORMATSECTION_STRING___SECTION->readonly){
oldstr4005=_FUNC_INIFORMATSECTION_STRING___SECTION;
if (oldstr4005->cmem_descriptor){
_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new_cmem(oldstr4005->len,0);
oldstr3988=_FUNC_INIFORMATSECTION_STRING___SECTION;
if (oldstr3988->cmem_descriptor){
_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new_cmem(oldstr3988->len,0);
}else{
_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new(oldstr4005->len,0);
_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new(oldstr3988->len,0);
}
memcpy(_FUNC_INIFORMATSECTION_STRING___SECTION->chr,oldstr4005->chr,oldstr4005->len);
memcpy(_FUNC_INIFORMATSECTION_STRING___SECTION->chr,oldstr3988->chr,oldstr3988->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_4006=NULL;
if (!byte_element_4006){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4006=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4006=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3989=NULL;
if (!byte_element_3989){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3989=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3989=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4007=NULL;
if (!byte_element_4007){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4007=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4007=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3990=NULL;
if (!byte_element_3990){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3990=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3990=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,34 +1,34 @@
qbs *_FUNC_READSETTING_STRING_READSETTING=NULL;
if (!_FUNC_READSETTING_STRING_READSETTING)_FUNC_READSETTING_STRING_READSETTING=qbs_new(0,0);
qbs*oldstr4008=NULL;
qbs*oldstr3991=NULL;
if(_FUNC_READSETTING_STRING_FILE->tmp||_FUNC_READSETTING_STRING_FILE->fixed||_FUNC_READSETTING_STRING_FILE->readonly){
oldstr4008=_FUNC_READSETTING_STRING_FILE;
if (oldstr4008->cmem_descriptor){
_FUNC_READSETTING_STRING_FILE=qbs_new_cmem(oldstr4008->len,0);
oldstr3991=_FUNC_READSETTING_STRING_FILE;
if (oldstr3991->cmem_descriptor){
_FUNC_READSETTING_STRING_FILE=qbs_new_cmem(oldstr3991->len,0);
}else{
_FUNC_READSETTING_STRING_FILE=qbs_new(oldstr4008->len,0);
_FUNC_READSETTING_STRING_FILE=qbs_new(oldstr3991->len,0);
}
memcpy(_FUNC_READSETTING_STRING_FILE->chr,oldstr4008->chr,oldstr4008->len);
memcpy(_FUNC_READSETTING_STRING_FILE->chr,oldstr3991->chr,oldstr3991->len);
}
qbs*oldstr4009=NULL;
qbs*oldstr3992=NULL;
if(_FUNC_READSETTING_STRING___SECTION->tmp||_FUNC_READSETTING_STRING___SECTION->fixed||_FUNC_READSETTING_STRING___SECTION->readonly){
oldstr4009=_FUNC_READSETTING_STRING___SECTION;
if (oldstr4009->cmem_descriptor){
_FUNC_READSETTING_STRING___SECTION=qbs_new_cmem(oldstr4009->len,0);
oldstr3992=_FUNC_READSETTING_STRING___SECTION;
if (oldstr3992->cmem_descriptor){
_FUNC_READSETTING_STRING___SECTION=qbs_new_cmem(oldstr3992->len,0);
}else{
_FUNC_READSETTING_STRING___SECTION=qbs_new(oldstr4009->len,0);
_FUNC_READSETTING_STRING___SECTION=qbs_new(oldstr3992->len,0);
}
memcpy(_FUNC_READSETTING_STRING___SECTION->chr,oldstr4009->chr,oldstr4009->len);
memcpy(_FUNC_READSETTING_STRING___SECTION->chr,oldstr3992->chr,oldstr3992->len);
}
qbs*oldstr4010=NULL;
qbs*oldstr3993=NULL;
if(_FUNC_READSETTING_STRING___KEY->tmp||_FUNC_READSETTING_STRING___KEY->fixed||_FUNC_READSETTING_STRING___KEY->readonly){
oldstr4010=_FUNC_READSETTING_STRING___KEY;
if (oldstr4010->cmem_descriptor){
_FUNC_READSETTING_STRING___KEY=qbs_new_cmem(oldstr4010->len,0);
oldstr3993=_FUNC_READSETTING_STRING___KEY;
if (oldstr3993->cmem_descriptor){
_FUNC_READSETTING_STRING___KEY=qbs_new_cmem(oldstr3993->len,0);
}else{
_FUNC_READSETTING_STRING___KEY=qbs_new(oldstr4010->len,0);
_FUNC_READSETTING_STRING___KEY=qbs_new(oldstr3993->len,0);
}
memcpy(_FUNC_READSETTING_STRING___KEY->chr,oldstr4010->chr,oldstr4010->len);
memcpy(_FUNC_READSETTING_STRING___KEY->chr,oldstr3993->chr,oldstr3993->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_4011=NULL;
if (!byte_element_4011){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4011=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4011=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_3994=NULL;
if (!byte_element_3994){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3994=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3994=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value4013;
int64 fornext_finalvalue4013;
int64 fornext_step4013;
uint8 fornext_step_negative4013;
int64 fornext_value4015;
int64 fornext_finalvalue4015;
int64 fornext_step4015;
uint8 fornext_step_negative4015;
byte_element_struct *byte_element_4016=NULL;
if (!byte_element_4016){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4016=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4016=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value3996;
int64 fornext_finalvalue3996;
int64 fornext_step3996;
uint8 fornext_step_negative3996;
int64 fornext_value3998;
int64 fornext_finalvalue3998;
int64 fornext_step3998;
uint8 fornext_step_negative3998;
byte_element_struct *byte_element_3999=NULL;
if (!byte_element_3999){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3999=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3999=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4017=NULL;
if (!byte_element_4017){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4017=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4017=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4000=NULL;
if (!byte_element_4000){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4000=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4000=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4018=NULL;
if (!byte_element_4018){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4018=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4018=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4001=NULL;
if (!byte_element_4001){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4001=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4001=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4019=NULL;
if (!byte_element_4019){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4019=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4019=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4002=NULL;
if (!byte_element_4002){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4002=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4002=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -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_value4021;
int64 fornext_finalvalue4021;
int64 fornext_step4021;
uint8 fornext_step_negative4021;
int64 fornext_value4023;
int64 fornext_finalvalue4023;
int64 fornext_step4023;
uint8 fornext_step_negative4023;
int64 fornext_value4004;
int64 fornext_finalvalue4004;
int64 fornext_step4004;
uint8 fornext_step_negative4004;
int64 fornext_value4006;
int64 fornext_finalvalue4006;
int64 fornext_step4006;
uint8 fornext_step_negative4006;

View file

@ -1,42 +1,42 @@
qbs*oldstr4024=NULL;
qbs*oldstr4007=NULL;
if(_SUB_WRITESETTING_STRING_FILE->tmp||_SUB_WRITESETTING_STRING_FILE->fixed||_SUB_WRITESETTING_STRING_FILE->readonly){
oldstr4024=_SUB_WRITESETTING_STRING_FILE;
if (oldstr4024->cmem_descriptor){
_SUB_WRITESETTING_STRING_FILE=qbs_new_cmem(oldstr4024->len,0);
oldstr4007=_SUB_WRITESETTING_STRING_FILE;
if (oldstr4007->cmem_descriptor){
_SUB_WRITESETTING_STRING_FILE=qbs_new_cmem(oldstr4007->len,0);
}else{
_SUB_WRITESETTING_STRING_FILE=qbs_new(oldstr4024->len,0);
_SUB_WRITESETTING_STRING_FILE=qbs_new(oldstr4007->len,0);
}
memcpy(_SUB_WRITESETTING_STRING_FILE->chr,oldstr4024->chr,oldstr4024->len);
memcpy(_SUB_WRITESETTING_STRING_FILE->chr,oldstr4007->chr,oldstr4007->len);
}
qbs*oldstr4025=NULL;
qbs*oldstr4008=NULL;
if(_SUB_WRITESETTING_STRING___SECTION->tmp||_SUB_WRITESETTING_STRING___SECTION->fixed||_SUB_WRITESETTING_STRING___SECTION->readonly){
oldstr4025=_SUB_WRITESETTING_STRING___SECTION;
if (oldstr4025->cmem_descriptor){
_SUB_WRITESETTING_STRING___SECTION=qbs_new_cmem(oldstr4025->len,0);
oldstr4008=_SUB_WRITESETTING_STRING___SECTION;
if (oldstr4008->cmem_descriptor){
_SUB_WRITESETTING_STRING___SECTION=qbs_new_cmem(oldstr4008->len,0);
}else{
_SUB_WRITESETTING_STRING___SECTION=qbs_new(oldstr4025->len,0);
_SUB_WRITESETTING_STRING___SECTION=qbs_new(oldstr4008->len,0);
}
memcpy(_SUB_WRITESETTING_STRING___SECTION->chr,oldstr4025->chr,oldstr4025->len);
memcpy(_SUB_WRITESETTING_STRING___SECTION->chr,oldstr4008->chr,oldstr4008->len);
}
qbs*oldstr4026=NULL;
qbs*oldstr4009=NULL;
if(_SUB_WRITESETTING_STRING___KEY->tmp||_SUB_WRITESETTING_STRING___KEY->fixed||_SUB_WRITESETTING_STRING___KEY->readonly){
oldstr4026=_SUB_WRITESETTING_STRING___KEY;
if (oldstr4026->cmem_descriptor){
_SUB_WRITESETTING_STRING___KEY=qbs_new_cmem(oldstr4026->len,0);
oldstr4009=_SUB_WRITESETTING_STRING___KEY;
if (oldstr4009->cmem_descriptor){
_SUB_WRITESETTING_STRING___KEY=qbs_new_cmem(oldstr4009->len,0);
}else{
_SUB_WRITESETTING_STRING___KEY=qbs_new(oldstr4026->len,0);
_SUB_WRITESETTING_STRING___KEY=qbs_new(oldstr4009->len,0);
}
memcpy(_SUB_WRITESETTING_STRING___KEY->chr,oldstr4026->chr,oldstr4026->len);
memcpy(_SUB_WRITESETTING_STRING___KEY->chr,oldstr4009->chr,oldstr4009->len);
}
qbs*oldstr4027=NULL;
qbs*oldstr4010=NULL;
if(_SUB_WRITESETTING_STRING___VALUE->tmp||_SUB_WRITESETTING_STRING___VALUE->fixed||_SUB_WRITESETTING_STRING___VALUE->readonly){
oldstr4027=_SUB_WRITESETTING_STRING___VALUE;
if (oldstr4027->cmem_descriptor){
_SUB_WRITESETTING_STRING___VALUE=qbs_new_cmem(oldstr4027->len,0);
oldstr4010=_SUB_WRITESETTING_STRING___VALUE;
if (oldstr4010->cmem_descriptor){
_SUB_WRITESETTING_STRING___VALUE=qbs_new_cmem(oldstr4010->len,0);
}else{
_SUB_WRITESETTING_STRING___VALUE=qbs_new(oldstr4027->len,0);
_SUB_WRITESETTING_STRING___VALUE=qbs_new(oldstr4010->len,0);
}
memcpy(_SUB_WRITESETTING_STRING___VALUE->chr,oldstr4027->chr,oldstr4027->len);
memcpy(_SUB_WRITESETTING_STRING___VALUE->chr,oldstr4010->chr,oldstr4010->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_value4029;
int64 fornext_finalvalue4029;
int64 fornext_step4029;
uint8 fornext_step_negative4029;
int64 fornext_value4031;
int64 fornext_finalvalue4031;
int64 fornext_step4031;
uint8 fornext_step_negative4031;
byte_element_struct *byte_element_4032=NULL;
if (!byte_element_4032){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4032=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4032=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value4012;
int64 fornext_finalvalue4012;
int64 fornext_step4012;
uint8 fornext_step_negative4012;
int64 fornext_value4014;
int64 fornext_finalvalue4014;
int64 fornext_step4014;
uint8 fornext_step_negative4014;
byte_element_struct *byte_element_4015=NULL;
if (!byte_element_4015){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4015=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4015=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4033=NULL;
if (!byte_element_4033){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4033=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4033=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4016=NULL;
if (!byte_element_4016){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4016=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4016=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4034=NULL;
if (!byte_element_4034){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4034=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4034=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4017=NULL;
if (!byte_element_4017){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4017=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4017=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4035=NULL;
if (!byte_element_4035){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4035=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4035=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4018=NULL;
if (!byte_element_4018){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4018=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4018=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4036=NULL;
if (!byte_element_4036){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4036=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4036=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4019=NULL;
if (!byte_element_4019){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4019=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4019=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,19 +1,19 @@
qbs*oldstr4037=NULL;
qbs*oldstr4020=NULL;
if(_SUB_INILOAD_STRING_FILE->tmp||_SUB_INILOAD_STRING_FILE->fixed||_SUB_INILOAD_STRING_FILE->readonly){
oldstr4037=_SUB_INILOAD_STRING_FILE;
if (oldstr4037->cmem_descriptor){
_SUB_INILOAD_STRING_FILE=qbs_new_cmem(oldstr4037->len,0);
oldstr4020=_SUB_INILOAD_STRING_FILE;
if (oldstr4020->cmem_descriptor){
_SUB_INILOAD_STRING_FILE=qbs_new_cmem(oldstr4020->len,0);
}else{
_SUB_INILOAD_STRING_FILE=qbs_new(oldstr4037->len,0);
_SUB_INILOAD_STRING_FILE=qbs_new(oldstr4020->len,0);
}
memcpy(_SUB_INILOAD_STRING_FILE->chr,oldstr4037->chr,oldstr4037->len);
memcpy(_SUB_INILOAD_STRING_FILE->chr,oldstr4020->chr,oldstr4020->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_4038=NULL;
if (!byte_element_4038){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4038=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4038=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4021=NULL;
if (!byte_element_4021){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4021=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4021=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -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*oldstr4040=NULL;
qbs*oldstr4023=NULL;
if(_FUNC_FILETOBUF_STRING_FILESPEC->tmp||_FUNC_FILETOBUF_STRING_FILESPEC->fixed||_FUNC_FILETOBUF_STRING_FILESPEC->readonly){
oldstr4040=_FUNC_FILETOBUF_STRING_FILESPEC;
if (oldstr4040->cmem_descriptor){
_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new_cmem(oldstr4040->len,0);
oldstr4023=_FUNC_FILETOBUF_STRING_FILESPEC;
if (oldstr4023->cmem_descriptor){
_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new_cmem(oldstr4023->len,0);
}else{
_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new(oldstr4040->len,0);
_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new(oldstr4023->len,0);
}
memcpy(_FUNC_FILETOBUF_STRING_FILESPEC->chr,oldstr4040->chr,oldstr4040->len);
memcpy(_FUNC_FILETOBUF_STRING_FILESPEC->chr,oldstr4023->chr,oldstr4023->len);
}
int16 *_FUNC_FILETOBUF_INTEGER_HAN=NULL;
if(_FUNC_FILETOBUF_INTEGER_HAN==NULL){

View file

@ -1,12 +1,12 @@
qbs*oldstr4041=NULL;
qbs*oldstr4024=NULL;
if(_SUB_BUFTOFILE_STRING_FILESPEC->tmp||_SUB_BUFTOFILE_STRING_FILESPEC->fixed||_SUB_BUFTOFILE_STRING_FILESPEC->readonly){
oldstr4041=_SUB_BUFTOFILE_STRING_FILESPEC;
if (oldstr4041->cmem_descriptor){
_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new_cmem(oldstr4041->len,0);
oldstr4024=_SUB_BUFTOFILE_STRING_FILESPEC;
if (oldstr4024->cmem_descriptor){
_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new_cmem(oldstr4024->len,0);
}else{
_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new(oldstr4041->len,0);
_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new(oldstr4024->len,0);
}
memcpy(_SUB_BUFTOFILE_STRING_FILESPEC->chr,oldstr4041->chr,oldstr4041->len);
memcpy(_SUB_BUFTOFILE_STRING_FILESPEC->chr,oldstr4024->chr,oldstr4024->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_4042=NULL;
if (!byte_element_4042){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4042=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4042=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4025=NULL;
if (!byte_element_4025){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4025=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4025=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -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_4043=NULL;
if (!byte_element_4043){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4043=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4043=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4026=NULL;
if (!byte_element_4026){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4026=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4026=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,12 +1,12 @@
qbs*oldstr4044=NULL;
qbs*oldstr4027=NULL;
if(_SUB_WRITEBUFLINE_STRING_TEXT->tmp||_SUB_WRITEBUFLINE_STRING_TEXT->fixed||_SUB_WRITEBUFLINE_STRING_TEXT->readonly){
oldstr4044=_SUB_WRITEBUFLINE_STRING_TEXT;
if (oldstr4044->cmem_descriptor){
_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new_cmem(oldstr4044->len,0);
oldstr4027=_SUB_WRITEBUFLINE_STRING_TEXT;
if (oldstr4027->cmem_descriptor){
_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new_cmem(oldstr4027->len,0);
}else{
_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new(oldstr4044->len,0);
_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new(oldstr4027->len,0);
}
memcpy(_SUB_WRITEBUFLINE_STRING_TEXT->chr,oldstr4044->chr,oldstr4044->len);
memcpy(_SUB_WRITEBUFLINE_STRING_TEXT->chr,oldstr4027->chr,oldstr4027->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_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);
byte_element_struct *byte_element_4028=NULL;
if (!byte_element_4028){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4028=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4028=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4046=NULL;
if (!byte_element_4046){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4046=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4046=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4029=NULL;
if (!byte_element_4029){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4029=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4029=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4047=NULL;
if (!byte_element_4047){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4047=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4047=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4030=NULL;
if (!byte_element_4030){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4030=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4030=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,12 +1,12 @@
qbs*oldstr4049=NULL;
qbs*oldstr4032=NULL;
if(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->tmp||_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->fixed||_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->readonly){
oldstr4049=_SUB_WRITEBUFRAWDATA_STRING_RAWDATA;
if (oldstr4049->cmem_descriptor){
_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new_cmem(oldstr4049->len,0);
oldstr4032=_SUB_WRITEBUFRAWDATA_STRING_RAWDATA;
if (oldstr4032->cmem_descriptor){
_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new_cmem(oldstr4032->len,0);
}else{
_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new(oldstr4049->len,0);
_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new(oldstr4032->len,0);
}
memcpy(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->chr,oldstr4049->chr,oldstr4049->len);
memcpy(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->chr,oldstr4032->chr,oldstr4032->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_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);
byte_element_struct *byte_element_4033=NULL;
if (!byte_element_4033){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4033=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4033=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4051=NULL;
if (!byte_element_4051){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4051=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4051=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4034=NULL;
if (!byte_element_4034){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4034=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4034=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -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_4053=NULL;
if (!byte_element_4053){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4053=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4053=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4036=NULL;
if (!byte_element_4036){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4036=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4036=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -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_4055=qbs_new(0,0);
static qbs *sc_4038=qbs_new(0,0);

View file

@ -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*oldstr4056=NULL;
qbs*oldstr4039=NULL;
if(_FUNC_OPENBUFFER_STRING_SBMODE->tmp||_FUNC_OPENBUFFER_STRING_SBMODE->fixed||_FUNC_OPENBUFFER_STRING_SBMODE->readonly){
oldstr4056=_FUNC_OPENBUFFER_STRING_SBMODE;
if (oldstr4056->cmem_descriptor){
_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new_cmem(oldstr4056->len,0);
oldstr4039=_FUNC_OPENBUFFER_STRING_SBMODE;
if (oldstr4039->cmem_descriptor){
_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new_cmem(oldstr4039->len,0);
}else{
_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new(oldstr4056->len,0);
_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new(oldstr4039->len,0);
}
memcpy(_FUNC_OPENBUFFER_STRING_SBMODE->chr,oldstr4056->chr,oldstr4056->len);
memcpy(_FUNC_OPENBUFFER_STRING_SBMODE->chr,oldstr4039->chr,oldstr4039->len);
}
qbs*oldstr4057=NULL;
qbs*oldstr4040=NULL;
if(_FUNC_OPENBUFFER_STRING_SBNAME->tmp||_FUNC_OPENBUFFER_STRING_SBNAME->fixed||_FUNC_OPENBUFFER_STRING_SBNAME->readonly){
oldstr4057=_FUNC_OPENBUFFER_STRING_SBNAME;
if (oldstr4057->cmem_descriptor){
_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new_cmem(oldstr4057->len,0);
oldstr4040=_FUNC_OPENBUFFER_STRING_SBNAME;
if (oldstr4040->cmem_descriptor){
_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new_cmem(oldstr4040->len,0);
}else{
_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new(oldstr4057->len,0);
_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new(oldstr4040->len,0);
}
memcpy(_FUNC_OPENBUFFER_STRING_SBNAME->chr,oldstr4057->chr,oldstr4057->len);
memcpy(_FUNC_OPENBUFFER_STRING_SBNAME->chr,oldstr4040->chr,oldstr4040->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_value4059;
int32 fornext_finalvalue4059;
int32 fornext_step4059;
uint8 fornext_step_negative4059;
static qbs *sc_4060=qbs_new(0,0);
int32 pass4061;
int16 pass4062;
int32 pass4063;
int16 pass4064;
int32 pass4065;
int16 pass4066;
int32 fornext_value4042;
int32 fornext_finalvalue4042;
int32 fornext_step4042;
uint8 fornext_step_negative4042;
static qbs *sc_4043=qbs_new(0,0);
int32 pass4044;
int16 pass4045;
int32 pass4046;
int16 pass4047;
int32 pass4048;
int16 pass4049;

View file

@ -1,23 +1,23 @@
qbs*oldstr4067=NULL;
qbs*oldstr4050=NULL;
if(_SUB_CLEARBUFFERS_STRING_SBNAME->tmp||_SUB_CLEARBUFFERS_STRING_SBNAME->fixed||_SUB_CLEARBUFFERS_STRING_SBNAME->readonly){
oldstr4067=_SUB_CLEARBUFFERS_STRING_SBNAME;
if (oldstr4067->cmem_descriptor){
_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr4067->len,0);
oldstr4050=_SUB_CLEARBUFFERS_STRING_SBNAME;
if (oldstr4050->cmem_descriptor){
_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr4050->len,0);
}else{
_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new(oldstr4067->len,0);
_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new(oldstr4050->len,0);
}
memcpy(_SUB_CLEARBUFFERS_STRING_SBNAME->chr,oldstr4067->chr,oldstr4067->len);
memcpy(_SUB_CLEARBUFFERS_STRING_SBNAME->chr,oldstr4050->chr,oldstr4050->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_value4069;
int32 fornext_finalvalue4069;
int32 fornext_step4069;
uint8 fornext_step_negative4069;
int32 fornext_value4071;
int32 fornext_finalvalue4071;
int32 fornext_step4071;
uint8 fornext_step_negative4071;
int32 fornext_value4052;
int32 fornext_finalvalue4052;
int32 fornext_step4052;
uint8 fornext_step_negative4052;
int32 fornext_value4054;
int32 fornext_finalvalue4054;
int32 fornext_step4054;
uint8 fornext_step_negative4054;

View file

@ -1,23 +1,23 @@
qbs*oldstr4072=NULL;
qbs*oldstr4055=NULL;
if(_SUB_WRITEBUFFERS_STRING_SBNAME->tmp||_SUB_WRITEBUFFERS_STRING_SBNAME->fixed||_SUB_WRITEBUFFERS_STRING_SBNAME->readonly){
oldstr4072=_SUB_WRITEBUFFERS_STRING_SBNAME;
if (oldstr4072->cmem_descriptor){
_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr4072->len,0);
oldstr4055=_SUB_WRITEBUFFERS_STRING_SBNAME;
if (oldstr4055->cmem_descriptor){
_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr4055->len,0);
}else{
_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new(oldstr4072->len,0);
_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new(oldstr4055->len,0);
}
memcpy(_SUB_WRITEBUFFERS_STRING_SBNAME->chr,oldstr4072->chr,oldstr4072->len);
memcpy(_SUB_WRITEBUFFERS_STRING_SBNAME->chr,oldstr4055->chr,oldstr4055->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_value4074;
int32 fornext_finalvalue4074;
int32 fornext_step4074;
uint8 fornext_step_negative4074;
int32 fornext_value4076;
int32 fornext_finalvalue4076;
int32 fornext_step4076;
uint8 fornext_step_negative4076;
int32 fornext_value4057;
int32 fornext_finalvalue4057;
int32 fornext_step4057;
uint8 fornext_step_negative4057;
int32 fornext_value4059;
int32 fornext_finalvalue4059;
int32 fornext_step4059;
uint8 fornext_step_negative4059;

View file

@ -8,36 +8,36 @@ if(_FUNC_IDE_LONG_CMD==NULL){
_FUNC_IDE_LONG_CMD=(int32*)mem_static_malloc(4);
*_FUNC_IDE_LONG_CMD=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_4060=NULL;
if (!byte_element_4060){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4060=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4060=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDE_LONG_L=NULL;
if(_FUNC_IDE_LONG_L==NULL){
_FUNC_IDE_LONG_L=(int32*)mem_static_malloc(4);
*_FUNC_IDE_LONG_L=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_4061=NULL;
if (!byte_element_4061){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4061=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4061=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDE_LONG_I=NULL;
if(_FUNC_IDE_LONG_I==NULL){
_FUNC_IDE_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_IDE_LONG_I=0;
}
int64 fornext_value4080;
int64 fornext_finalvalue4080;
int64 fornext_step4080;
uint8 fornext_step_negative4080;
int64 fornext_value4063;
int64 fornext_finalvalue4063;
int64 fornext_step4063;
uint8 fornext_step_negative4063;
int32 *_FUNC_IDE_LONG_INDENT=NULL;
if(_FUNC_IDE_LONG_INDENT==NULL){
_FUNC_IDE_LONG_INDENT=(int32*)mem_static_malloc(4);
*_FUNC_IDE_LONG_INDENT=0;
}
byte_element_struct *byte_element_4081=NULL;
if (!byte_element_4081){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4081=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4081=(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_IDE_STRING_LAYOUT2=NULL;
if (!_FUNC_IDE_STRING_LAYOUT2)_FUNC_IDE_STRING_LAYOUT2=qbs_new(0,0);
@ -51,51 +51,51 @@ if(_FUNC_IDE_LONG_IGNORESP==NULL){
_FUNC_IDE_LONG_IGNORESP=(int32*)mem_static_malloc(4);
*_FUNC_IDE_LONG_IGNORESP=0;
}
int64 fornext_value4083;
int64 fornext_finalvalue4083;
int64 fornext_step4083;
uint8 fornext_step_negative4083;
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);
int64 fornext_value4066;
int64 fornext_finalvalue4066;
int64 fornext_step4066;
uint8 fornext_step_negative4066;
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_IDE_LONG_A=NULL;
if(_FUNC_IDE_LONG_A==NULL){
_FUNC_IDE_LONG_A=(int32*)mem_static_malloc(4);
*_FUNC_IDE_LONG_A=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_4068=NULL;
if (!byte_element_4068){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4068=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4068=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value4087;
int64 fornext_finalvalue4087;
int64 fornext_step4087;
uint8 fornext_step_negative4087;
int64 fornext_value4070;
int64 fornext_finalvalue4070;
int64 fornext_step4070;
uint8 fornext_step_negative4070;
qbs *_FUNC_IDE_STRING_INDENT=NULL;
if (!_FUNC_IDE_STRING_INDENT)_FUNC_IDE_STRING_INDENT=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_4071=NULL;
if (!byte_element_4071){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4071=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4071=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value4090;
int64 fornext_finalvalue4090;
int64 fornext_step4090;
uint8 fornext_step_negative4090;
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);
int64 fornext_value4073;
int64 fornext_finalvalue4073;
int64 fornext_step4073;
uint8 fornext_step_negative4073;
byte_element_struct *byte_element_4074=NULL;
if (!byte_element_4074){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4074=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4074=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDE_STRING_STATUS__ASCII_CHR_046__PROGRESS=NULL;
if (!_FUNC_IDE_STRING_STATUS__ASCII_CHR_046__PROGRESS)_FUNC_IDE_STRING_STATUS__ASCII_CHR_046__PROGRESS=qbs_new(0,0);
int32 pass4092;
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);
int32 pass4075;
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);
}
int32 pass4094;
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);
int32 pass4077;
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);
}
int32 pass4096;
int32 pass4079;

File diff suppressed because it is too large Load diff

View file

@ -1,20 +1,20 @@
qbs *_SUB_UPDATETITLEOFMAINWINDOW_STRING_SFNAME=NULL;
if (!_SUB_UPDATETITLEOFMAINWINDOW_STRING_SFNAME)_SUB_UPDATETITLEOFMAINWINDOW_STRING_SFNAME=qbs_new(0,0);
byte_element_struct *byte_element_4760=NULL;
if (!byte_element_4760){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4760=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4760=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4743=NULL;
if (!byte_element_4743){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4743=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4743=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_SUB_UPDATETITLEOFMAINWINDOW_STRING_A=NULL;
if (!_SUB_UPDATETITLEOFMAINWINDOW_STRING_A)_SUB_UPDATETITLEOFMAINWINDOW_STRING_A=qbs_new(0,0);
byte_element_struct *byte_element_4761=NULL;
if (!byte_element_4761){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4761=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4761=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4744=NULL;
if (!byte_element_4744){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4744=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4744=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4762=NULL;
if (!byte_element_4762){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4762=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4762=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4745=NULL;
if (!byte_element_4745){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4745=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4745=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_4763=NULL;
if (!byte_element_4763){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4763=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4763=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_4746=NULL;
if (!byte_element_4746){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4746=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4746=(byte_element_struct*)mem_static_malloc(12);
}

File diff suppressed because it is too large Load diff

View file

@ -1,12 +1,12 @@
qbs*oldstr5069=NULL;
qbs*oldstr5052=NULL;
if(_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE->tmp||_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE->fixed||_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE->readonly){
oldstr5069=_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE;
if (oldstr5069->cmem_descriptor){
_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE=qbs_new_cmem(oldstr5069->len,0);
oldstr5052=_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE;
if (oldstr5052->cmem_descriptor){
_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE=qbs_new_cmem(oldstr5052->len,0);
}else{
_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE=qbs_new(oldstr5069->len,0);
_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE=qbs_new(oldstr5052->len,0);
}
memcpy(_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE->chr,oldstr5069->chr,oldstr5069->len);
memcpy(_SUB_SHOWVWATCHPANEL_STRING_CURRENTSCOPE->chr,oldstr5052->chr,oldstr5052->len);
}
int32 *_SUB_SHOWVWATCHPANEL_LONG_FG=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_FG==NULL){
@ -20,35 +20,35 @@ _SUB_SHOWVWATCHPANEL_LONG_BG=(int32*)mem_static_malloc(4);
}
qbs *_SUB_SHOWVWATCHPANEL_STRING_TITLE=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_TITLE)_SUB_SHOWVWATCHPANEL_STRING_TITLE=qbs_new(0,0);
byte_element_struct *byte_element_5070=NULL;
if (!byte_element_5070){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5070=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5070=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5053=NULL;
if (!byte_element_5053){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5053=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5053=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5071=NULL;
if (!byte_element_5071){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5071=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5071=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5054=NULL;
if (!byte_element_5054){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5054=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5054=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5072=NULL;
if (!byte_element_5072){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5072=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5072=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5055=NULL;
if (!byte_element_5055){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5055=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5055=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_SHOWVWATCHPANEL_LONG_VWATCHPANELLIMIT=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_VWATCHPANELLIMIT==NULL){
_SUB_SHOWVWATCHPANEL_LONG_VWATCHPANELLIMIT=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_VWATCHPANELLIMIT=0;
}
int32 pass5073;
int32 pass5074;
int32 pass5075;
int32 pass5076;
int32 pass5056;
int32 pass5057;
int32 pass5058;
int32 pass5059;
int32 *_SUB_SHOWVWATCHPANEL_LONG_X=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_X==NULL){
_SUB_SHOWVWATCHPANEL_LONG_X=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_X=0;
}
byte_element_struct *byte_element_5077=NULL;
if (!byte_element_5077){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5077=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5077=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5060=NULL;
if (!byte_element_5060){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5060=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5060=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_SHOWVWATCHPANEL_LONG_Y=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_Y==NULL){
@ -77,7 +77,7 @@ _SUB_SHOWVWATCHPANEL_LONG_SHADOWLENGTH=(int32*)mem_static_malloc(4);
}
qbs *_SUB_SHOWVWATCHPANEL_STRING_TEMP=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_TEMP)_SUB_SHOWVWATCHPANEL_STRING_TEMP=qbs_new(0,0);
int32 pass5078;
int32 pass5061;
int32 *_SUB_SHOWVWATCHPANEL_LONG_ACTUALLONGESTVARNAME=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_ACTUALLONGESTVARNAME==NULL){
_SUB_SHOWVWATCHPANEL_LONG_ACTUALLONGESTVARNAME=(int32*)mem_static_malloc(4);
@ -90,19 +90,19 @@ _SUB_SHOWVWATCHPANEL_LONG_DISPLAYFORMATBUTTON=(int32*)mem_static_malloc(4);
}
qbs *_SUB_SHOWVWATCHPANEL_STRING_TEMP2=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_TEMP2)_SUB_SHOWVWATCHPANEL_STRING_TEMP2=qbs_new(0,0);
int32 pass5080;
int32 pass5063;
int32 *_SUB_SHOWVWATCHPANEL_LONG_TEMPINDEX=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_TEMPINDEX==NULL){
_SUB_SHOWVWATCHPANEL_LONG_TEMPINDEX=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_TEMPINDEX=0;
}
int32 pass5081;
int32 pass5064;
int32 *_SUB_SHOWVWATCHPANEL_LONG_TEMPTOTALARRAYINDEXES=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_TEMPTOTALARRAYINDEXES==NULL){
_SUB_SHOWVWATCHPANEL_LONG_TEMPTOTALARRAYINDEXES=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_TEMPTOTALARRAYINDEXES=0;
}
int32 pass5082;
int32 pass5065;
qbs *_SUB_SHOWVWATCHPANEL_STRING_TEMPARRAYINDEXES=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_TEMPARRAYINDEXES)_SUB_SHOWVWATCHPANEL_STRING_TEMPARRAYINDEXES=qbs_new(0,0);
int32 *_SUB_SHOWVWATCHPANEL_LONG_TEMPELEMENT=NULL;
@ -110,49 +110,49 @@ if(_SUB_SHOWVWATCHPANEL_LONG_TEMPELEMENT==NULL){
_SUB_SHOWVWATCHPANEL_LONG_TEMPELEMENT=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_TEMPELEMENT=0;
}
int32 pass5083;
int32 pass5066;
int32 *_SUB_SHOWVWATCHPANEL_LONG_TEMPELEMENTOFFSET=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_TEMPELEMENTOFFSET==NULL){
_SUB_SHOWVWATCHPANEL_LONG_TEMPELEMENTOFFSET=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_TEMPELEMENTOFFSET=0;
}
int32 pass5084;
int32 pass5067;
int32 *_SUB_SHOWVWATCHPANEL_LONG_TEMPSTORAGE=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_TEMPSTORAGE==NULL){
_SUB_SHOWVWATCHPANEL_LONG_TEMPSTORAGE=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_TEMPSTORAGE=0;
}
int32 pass5085;
int32 pass5068;
qbs *_SUB_SHOWVWATCHPANEL_STRING_THISNAME=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_THISNAME)_SUB_SHOWVWATCHPANEL_STRING_THISNAME=qbs_new(0,0);
byte_element_struct *byte_element_5086=NULL;
if (!byte_element_5086){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5086=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5086=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5069=NULL;
if (!byte_element_5069){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5069=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5069=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_SHOWVWATCHPANEL_LONG_J=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_J==NULL){
_SUB_SHOWVWATCHPANEL_LONG_J=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_J=0;
}
int64 fornext_value5088;
int64 fornext_finalvalue5088;
int64 fornext_step5088;
uint8 fornext_step_negative5088;
int64 fornext_value5071;
int64 fornext_finalvalue5071;
int64 fornext_step5071;
uint8 fornext_step_negative5071;
qbs *_SUB_SHOWVWATCHPANEL_STRING_TEMPELEMENTLIST=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_TEMPELEMENTLIST)_SUB_SHOWVWATCHPANEL_STRING_TEMPELEMENTLIST=qbs_new(0,0);
byte_element_struct *byte_element_5089=NULL;
if (!byte_element_5089){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5089=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5089=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5072=NULL;
if (!byte_element_5072){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5072=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5072=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5090=NULL;
if (!byte_element_5090){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5090=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5090=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5073=NULL;
if (!byte_element_5073){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5073=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5073=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_SUB_SHOWVWATCHPANEL_STRING_ITEM=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_ITEM)_SUB_SHOWVWATCHPANEL_STRING_ITEM=qbs_new(0,0);
byte_element_struct *byte_element_5091=NULL;
if (!byte_element_5091){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5091=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5091=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5074=NULL;
if (!byte_element_5074){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5074=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5074=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_SUB_SHOWVWATCHPANEL_STRING_TEMPVARTYPE=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_TEMPVARTYPE)_SUB_SHOWVWATCHPANEL_STRING_TEMPVARTYPE=qbs_new(0,0);
@ -163,26 +163,26 @@ _SUB_SHOWVWATCHPANEL_LONG_THISISASTRING=(int32*)mem_static_malloc(4);
}
qbs *_SUB_SHOWVWATCHPANEL_STRING_TEMPVALUE=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_TEMPVALUE)_SUB_SHOWVWATCHPANEL_STRING_TEMPVALUE=qbs_new(0,0);
byte_element_struct *byte_element_5092=NULL;
if (!byte_element_5092){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5092=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5092=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5075=NULL;
if (!byte_element_5075){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5075=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5075=(byte_element_struct*)mem_static_malloc(12);
}
static int32 sc_5093;
byte_element_struct *byte_element_5094=NULL;
if (!byte_element_5094){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5094=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5094=(byte_element_struct*)mem_static_malloc(12);
static int32 sc_5076;
byte_element_struct *byte_element_5077=NULL;
if (!byte_element_5077){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5077=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5077=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5095=NULL;
if (!byte_element_5095){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5095=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5095=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5078=NULL;
if (!byte_element_5078){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5078=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5078=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5096=NULL;
if (!byte_element_5096){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5096=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5096=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5079=NULL;
if (!byte_element_5079){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5079=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5079=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5098=NULL;
if (!byte_element_5098){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5098=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5098=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5081=NULL;
if (!byte_element_5081){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5081=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5081=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_SHOWVWATCHPANEL_LONG_K=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_K==NULL){
@ -193,42 +193,42 @@ qbs *_SUB_SHOWVWATCHPANEL_STRING_TEMP3=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_TEMP3)_SUB_SHOWVWATCHPANEL_STRING_TEMP3=qbs_new(0,0);
qbs *_SUB_SHOWVWATCHPANEL_STRING_CONDITION=NULL;
if (!_SUB_SHOWVWATCHPANEL_STRING_CONDITION)_SUB_SHOWVWATCHPANEL_STRING_CONDITION=qbs_new(0,0);
byte_element_struct *byte_element_5099=NULL;
if (!byte_element_5099){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5099=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5099=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5082=NULL;
if (!byte_element_5082){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5082=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5082=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5100=NULL;
if (!byte_element_5100){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5100=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5100=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5083=NULL;
if (!byte_element_5083){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5083=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5083=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5101=NULL;
if (!byte_element_5101){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5101=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5101=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5084=NULL;
if (!byte_element_5084){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5084=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5084=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5102=NULL;
if (!byte_element_5102){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5102=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5102=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5085=NULL;
if (!byte_element_5085){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5085=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5085=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5103=NULL;
if (!byte_element_5103){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5103=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5103=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5086=NULL;
if (!byte_element_5086){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5086=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5086=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_SHOWVWATCHPANEL_LONG_X2=NULL;
if(_SUB_SHOWVWATCHPANEL_LONG_X2==NULL){
_SUB_SHOWVWATCHPANEL_LONG_X2=(int32*)mem_static_malloc(4);
*_SUB_SHOWVWATCHPANEL_LONG_X2=0;
}
int64 fornext_value5105;
int64 fornext_finalvalue5105;
int64 fornext_step5105;
uint8 fornext_step_negative5105;
int32 pass5106;
int32 pass5107;
int32 pass5108;
int32 pass5109;
int32 pass5110;
int32 pass5111;
int32 pass5112;
int32 pass5113;
int32 pass5114;
int32 pass5115;
int64 fornext_value5088;
int64 fornext_finalvalue5088;
int64 fornext_step5088;
uint8 fornext_step_negative5088;
int32 pass5089;
int32 pass5090;
int32 pass5091;
int32 pass5092;
int32 pass5093;
int32 pass5094;
int32 pass5095;
int32 pass5096;
int32 pass5097;
int32 pass5098;

View file

@ -3,37 +3,37 @@ if(_FUNC_MULTISEARCH_LONG_MULTISEARCH==NULL){
_FUNC_MULTISEARCH_LONG_MULTISEARCH=(int32*)mem_static_malloc(4);
*_FUNC_MULTISEARCH_LONG_MULTISEARCH=0;
}
qbs*oldstr5116=NULL;
qbs*oldstr5099=NULL;
if(_FUNC_MULTISEARCH_STRING___FULLTEXT->tmp||_FUNC_MULTISEARCH_STRING___FULLTEXT->fixed||_FUNC_MULTISEARCH_STRING___FULLTEXT->readonly){
oldstr5116=_FUNC_MULTISEARCH_STRING___FULLTEXT;
if (oldstr5116->cmem_descriptor){
_FUNC_MULTISEARCH_STRING___FULLTEXT=qbs_new_cmem(oldstr5116->len,0);
oldstr5099=_FUNC_MULTISEARCH_STRING___FULLTEXT;
if (oldstr5099->cmem_descriptor){
_FUNC_MULTISEARCH_STRING___FULLTEXT=qbs_new_cmem(oldstr5099->len,0);
}else{
_FUNC_MULTISEARCH_STRING___FULLTEXT=qbs_new(oldstr5116->len,0);
_FUNC_MULTISEARCH_STRING___FULLTEXT=qbs_new(oldstr5099->len,0);
}
memcpy(_FUNC_MULTISEARCH_STRING___FULLTEXT->chr,oldstr5116->chr,oldstr5116->len);
memcpy(_FUNC_MULTISEARCH_STRING___FULLTEXT->chr,oldstr5099->chr,oldstr5099->len);
}
qbs*oldstr5117=NULL;
qbs*oldstr5100=NULL;
if(_FUNC_MULTISEARCH_STRING___SEARCHSTRING->tmp||_FUNC_MULTISEARCH_STRING___SEARCHSTRING->fixed||_FUNC_MULTISEARCH_STRING___SEARCHSTRING->readonly){
oldstr5117=_FUNC_MULTISEARCH_STRING___SEARCHSTRING;
if (oldstr5117->cmem_descriptor){
_FUNC_MULTISEARCH_STRING___SEARCHSTRING=qbs_new_cmem(oldstr5117->len,0);
oldstr5100=_FUNC_MULTISEARCH_STRING___SEARCHSTRING;
if (oldstr5100->cmem_descriptor){
_FUNC_MULTISEARCH_STRING___SEARCHSTRING=qbs_new_cmem(oldstr5100->len,0);
}else{
_FUNC_MULTISEARCH_STRING___SEARCHSTRING=qbs_new(oldstr5117->len,0);
_FUNC_MULTISEARCH_STRING___SEARCHSTRING=qbs_new(oldstr5100->len,0);
}
memcpy(_FUNC_MULTISEARCH_STRING___SEARCHSTRING->chr,oldstr5117->chr,oldstr5117->len);
memcpy(_FUNC_MULTISEARCH_STRING___SEARCHSTRING->chr,oldstr5100->chr,oldstr5100->len);
}
qbs *_FUNC_MULTISEARCH_STRING_FULLTEXT=NULL;
if (!_FUNC_MULTISEARCH_STRING_FULLTEXT)_FUNC_MULTISEARCH_STRING_FULLTEXT=qbs_new(0,0);
qbs *_FUNC_MULTISEARCH_STRING_SEARCHSTRING=NULL;
if (!_FUNC_MULTISEARCH_STRING_SEARCHSTRING)_FUNC_MULTISEARCH_STRING_SEARCHSTRING=qbs_new(0,0);
byte_element_struct *byte_element_5118=NULL;
if (!byte_element_5118){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5118=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5118=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5101=NULL;
if (!byte_element_5101){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5101=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5101=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5119=NULL;
if (!byte_element_5119){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5119=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5119=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5102=NULL;
if (!byte_element_5102){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5102=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5102=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_MULTISEARCH_LONG_FINDPLUS=NULL;
if(_FUNC_MULTISEARCH_LONG_FINDPLUS==NULL){
@ -42,7 +42,7 @@ _FUNC_MULTISEARCH_LONG_FINDPLUS=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_MULTISEARCH_STRING_THISTERM=NULL;
if (!_FUNC_MULTISEARCH_STRING_THISTERM)_FUNC_MULTISEARCH_STRING_THISTERM=qbs_new(0,0);
byte_element_struct *byte_element_5121=NULL;
if (!byte_element_5121){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5121=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5121=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5104=NULL;
if (!byte_element_5104){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5104=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5104=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,24 +1,24 @@
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_IDEVARIABLEWATCHBOX=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_IDEVARIABLEWATCHBOX)_FUNC_IDEVARIABLEWATCHBOX_STRING_IDEVARIABLEWATCHBOX=qbs_new(0,0);
qbs*oldstr5122=NULL;
qbs*oldstr5105=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE->tmp||_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE->fixed||_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE->readonly){
oldstr5122=_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE;
if (oldstr5122->cmem_descriptor){
_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE=qbs_new_cmem(oldstr5122->len,0);
oldstr5105=_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE;
if (oldstr5105->cmem_descriptor){
_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE=qbs_new_cmem(oldstr5105->len,0);
}else{
_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE=qbs_new(oldstr5122->len,0);
_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE=qbs_new(oldstr5105->len,0);
}
memcpy(_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE->chr,oldstr5122->chr,oldstr5122->len);
memcpy(_FUNC_IDEVARIABLEWATCHBOX_STRING_CURRENTSCOPE->chr,oldstr5105->chr,oldstr5105->len);
}
qbs*oldstr5123=NULL;
qbs*oldstr5106=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER->tmp||_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER->fixed||_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER->readonly){
oldstr5123=_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER;
if (oldstr5123->cmem_descriptor){
_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER=qbs_new_cmem(oldstr5123->len,0);
oldstr5106=_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER;
if (oldstr5106->cmem_descriptor){
_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER=qbs_new_cmem(oldstr5106->len,0);
}else{
_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER=qbs_new(oldstr5123->len,0);
_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER=qbs_new(oldstr5106->len,0);
}
memcpy(_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER->chr,oldstr5123->chr,oldstr5123->len);
memcpy(_FUNC_IDEVARIABLEWATCHBOX_STRING_FILTER->chr,oldstr5106->chr,oldstr5106->len);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_FOCUS=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_FOCUS==NULL){
@ -54,9 +54,9 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_MAXMODULENAMELEN==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_MAXMODULENAMELEN=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_MAXMODULENAMELEN=0;
}
byte_element_struct *byte_element_5124=NULL;
if (!byte_element_5124){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5124=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5124=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5107=NULL;
if (!byte_element_5107){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5107=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5107=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_MAXTYPELEN=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_MAXTYPELEN==NULL){
@ -95,10 +95,10 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_X==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_X=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_X=0;
}
int64 fornext_value5126;
int64 fornext_finalvalue5126;
int64 fornext_step5126;
uint8 fornext_step_negative5126;
int64 fornext_value5109;
int64 fornext_finalvalue5109;
int64 fornext_step5109;
uint8 fornext_step_negative5109;
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_SEARCHTERM=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_SEARCHTERM)_FUNC_IDEVARIABLEWATCHBOX_STRING_SEARCHTERM=qbs_new(0,0);
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_FIRSTRUN=NULL;
@ -148,9 +148,9 @@ _FUNC_IDEVARIABLEWATCHBOX_LONG_VARLISTBOX=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_L=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_L)_FUNC_IDEVARIABLEWATCHBOX_STRING_L=qbs_new(0,0);
byte_element_struct *byte_element_5127=NULL;
if (!byte_element_5127){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5127=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5127=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5110=NULL;
if (!byte_element_5110){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5110=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5110=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMP=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMP)_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMP=qbs_new(0,0);
@ -164,10 +164,10 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_BUTTONSET==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_BUTTONSET=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_BUTTONSET=0;
}
int64 fornext_value5129;
int64 fornext_finalvalue5129;
int64 fornext_step5129;
uint8 fornext_step_negative5129;
int64 fornext_value5112;
int64 fornext_finalvalue5112;
int64 fornext_step5112;
uint8 fornext_step_negative5112;
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_F=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_F==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_F=(int32*)mem_static_malloc(4);
@ -183,10 +183,10 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_CY==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_CY=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_CY=0;
}
int64 fornext_value5132;
int64 fornext_finalvalue5132;
int64 fornext_step5132;
uint8 fornext_step_negative5132;
int64 fornext_value5115;
int64 fornext_finalvalue5115;
int64 fornext_step5115;
uint8 fornext_step_negative5115;
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_LASTFOCUS=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_LASTFOCUS==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_LASTFOCUS=(int32*)mem_static_malloc(4);
@ -244,9 +244,9 @@ _FUNC_IDEVARIABLEWATCHBOX_LONG_OLDALT=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_ALTLETTER=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_ALTLETTER)_FUNC_IDEVARIABLEWATCHBOX_STRING_ALTLETTER=qbs_new(0,0);
byte_element_struct *byte_element_5135=NULL;
if (!byte_element_5135){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5135=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5135=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5118=NULL;
if (!byte_element_5118){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5118=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5118=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_K=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_K==NULL){
@ -258,10 +258,10 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_INFO==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_INFO=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_INFO=0;
}
int64 fornext_value5137;
int64 fornext_finalvalue5137;
int64 fornext_step5137;
uint8 fornext_step_negative5137;
int64 fornext_value5120;
int64 fornext_finalvalue5120;
int64 fornext_step5120;
uint8 fornext_step_negative5120;
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_T=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_T==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_T=(int32*)mem_static_malloc(4);
@ -272,20 +272,20 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_FOCUSOFFSET==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_FOCUSOFFSET=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_FOCUSOFFSET=0;
}
byte_element_struct *byte_element_5138=NULL;
if (!byte_element_5138){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5138=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5138=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5121=NULL;
if (!byte_element_5121){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5121=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5121=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value5140;
int64 fornext_finalvalue5140;
int64 fornext_step5140;
uint8 fornext_step_negative5140;
int64 fornext_value5123;
int64 fornext_finalvalue5123;
int64 fornext_step5123;
uint8 fornext_step_negative5123;
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_VARTYPE=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_VARTYPE)_FUNC_IDEVARIABLEWATCHBOX_STRING_VARTYPE=qbs_new(0,0);
int64 fornext_value5142;
int64 fornext_finalvalue5142;
int64 fornext_step5142;
uint8 fornext_step_negative5142;
int64 fornext_value5125;
int64 fornext_finalvalue5125;
int64 fornext_step5125;
uint8 fornext_step_negative5125;
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_DLGTITLE=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_DLGTITLE)_FUNC_IDEVARIABLEWATCHBOX_STRING_DLGTITLE=qbs_new(0,0);
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_DLGPROMPT=NULL;
@ -314,15 +314,15 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPSTORAGE==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPSTORAGE=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPSTORAGE=0;
}
byte_element_struct *byte_element_5145=NULL;
if (!byte_element_5145){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5145=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5145=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5128=NULL;
if (!byte_element_5128){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5128=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5128=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPELEMENTOFFSET=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPELEMENTOFFSET)_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPELEMENTOFFSET=qbs_new(0,0);
byte_element_struct *byte_element_5146=NULL;
if (!byte_element_5146){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5146=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5146=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5129=NULL;
if (!byte_element_5129){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5129=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5129=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPISUDT=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPISUDT==NULL){
@ -331,20 +331,20 @@ _FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPISUDT=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_V=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_V)_FUNC_IDEVARIABLEWATCHBOX_STRING_V=qbs_new(0,0);
int32 pass5147;
int32 pass5148;
int32 pass5130;
int32 pass5131;
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_OK=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_OK==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_OK=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_OK=0;
}
byte_element_struct *byte_element_5149=NULL;
if (!byte_element_5149){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5149=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5149=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5132=NULL;
if (!byte_element_5132){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5132=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5132=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5151=NULL;
if (!byte_element_5151){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5151=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5151=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5134=NULL;
if (!byte_element_5134){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5134=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5134=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_RESULT=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_RESULT==NULL){
@ -365,18 +365,18 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_THISUDT==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_THISUDT=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_THISUDT=0;
}
int64 fornext_value5154;
int64 fornext_finalvalue5154;
int64 fornext_step5154;
uint8 fornext_step_negative5154;
int32 pass5156;
int32 pass5157;
int64 fornext_value5137;
int64 fornext_finalvalue5137;
int64 fornext_step5137;
uint8 fornext_step_negative5137;
int32 pass5139;
int32 pass5140;
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_TYP=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_TYP==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_TYP=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_TYP=0;
}
int32 pass5158;
int32 pass5141;
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_RESULT=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_RESULT)_FUNC_IDEVARIABLEWATCHBOX_STRING_RESULT=qbs_new(0,0);
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_STORAGESLOT=NULL;
@ -384,39 +384,39 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_STORAGESLOT==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_STORAGESLOT=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_STORAGESLOT=0;
}
byte_element_struct *byte_element_5161=NULL;
if (!byte_element_5161){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5161=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5161=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5144=NULL;
if (!byte_element_5144){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5144=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5144=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5162=NULL;
if (!byte_element_5162){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5162=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5162=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5145=NULL;
if (!byte_element_5145){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5145=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5145=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_A2=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_A2)_FUNC_IDEVARIABLEWATCHBOX_STRING_A2=qbs_new(0,0);
byte_element_struct *byte_element_5164=NULL;
if (!byte_element_5164){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5164=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5164=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5147=NULL;
if (!byte_element_5147){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5147=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5147=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_J=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_J==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_J=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_J=0;
}
byte_element_struct *byte_element_5165=NULL;
if (!byte_element_5165){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5165=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5165=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5148=NULL;
if (!byte_element_5148){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5148=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5148=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_THISWIDTH=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_THISWIDTH==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_THISWIDTH=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_THISWIDTH=0;
}
static int32 sc_5166;
int32 pass5167;
byte_element_struct *byte_element_5168=NULL;
if (!byte_element_5168){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5168=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5168=(byte_element_struct*)mem_static_malloc(12);
static int32 sc_5149;
int32 pass5150;
byte_element_struct *byte_element_5151=NULL;
if (!byte_element_5151){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5151=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5151=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_OP1=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_OP1)_FUNC_IDEVARIABLEWATCHBOX_STRING_OP1=qbs_new(0,0);
@ -433,25 +433,25 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPELEMENT==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPELEMENT=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPELEMENT=0;
}
byte_element_struct *byte_element_5170=NULL;
if (!byte_element_5170){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5170=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5170=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5153=NULL;
if (!byte_element_5153){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5153=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5153=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5171=NULL;
if (!byte_element_5171){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5171=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5171=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5154=NULL;
if (!byte_element_5154){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5154=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5154=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5173=NULL;
if (!byte_element_5173){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5173=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5173=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5156=NULL;
if (!byte_element_5156){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5156=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5156=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5174=NULL;
if (!byte_element_5174){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5174=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5174=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5157=NULL;
if (!byte_element_5157){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5157=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5157=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5175=NULL;
if (!byte_element_5175){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5175=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5175=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5158=NULL;
if (!byte_element_5158){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5158=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5158=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_LONGESTVARNAME=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_LONGESTVARNAME==NULL){
@ -465,12 +465,12 @@ _FUNC_IDEVARIABLEWATCHBOX_LONG_TOTALSELECTEDVARIABLES=(int32*)mem_static_malloc(
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_MSG=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_MSG)_FUNC_IDEVARIABLEWATCHBOX_STRING_MSG=qbs_new(0,0);
int64 fornext_value5177;
int64 fornext_finalvalue5177;
int64 fornext_step5177;
uint8 fornext_step_negative5177;
int32 pass5178;
int32 pass5179;
int64 fornext_value5160;
int64 fornext_finalvalue5160;
int64 fornext_step5160;
uint8 fornext_step_negative5160;
int32 pass5161;
int32 pass5162;
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_C=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_C==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_C=(int32*)mem_static_malloc(4);
@ -498,33 +498,33 @@ _FUNC_IDEVARIABLEWATCHBOX_LONG_PERCENTAGECHARS=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_PERCENTAGEMSG=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_PERCENTAGEMSG)_FUNC_IDEVARIABLEWATCHBOX_STRING_PERCENTAGEMSG=qbs_new(0,0);
byte_element_struct *byte_element_5180=NULL;
if (!byte_element_5180){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5180=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5180=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5163=NULL;
if (!byte_element_5163){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5163=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5163=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_THISLEN=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_THISLEN==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_THISLEN=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_THISLEN=0;
}
int32 pass5182;
int32 pass5165;
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMP2=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMP2)_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMP2=qbs_new(0,0);
int32 pass5184;
byte_element_struct *byte_element_5185=NULL;
if (!byte_element_5185){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5185=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5185=(byte_element_struct*)mem_static_malloc(12);
int32 pass5167;
byte_element_struct *byte_element_5168=NULL;
if (!byte_element_5168){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5168=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5168=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_LENGTH=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_LENGTH==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_LENGTH=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_LENGTH=0;
}
int32 pass5187;
int32 pass5189;
byte_element_struct *byte_element_5190=NULL;
if (!byte_element_5190){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5190=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5190=(byte_element_struct*)mem_static_malloc(12);
int32 pass5170;
int32 pass5172;
byte_element_struct *byte_element_5173=NULL;
if (!byte_element_5173){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5173=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5173=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_THISTEMPELEMENT=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_THISTEMPELEMENT)_FUNC_IDEVARIABLEWATCHBOX_STRING_THISTEMPELEMENT=qbs_new(0,0);
@ -535,9 +535,9 @@ if(_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPELEMENTOFFSET==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPELEMENTOFFSET=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_TEMPELEMENTOFFSET=0;
}
byte_element_struct *byte_element_5196=NULL;
if (!byte_element_5196){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5196=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5196=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5179=NULL;
if (!byte_element_5179){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5179=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5179=(byte_element_struct*)mem_static_malloc(12);
}
float *_FUNC_IDEVARIABLEWATCHBOX_SINGLE_LASTCLICK=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_SINGLE_LASTCLICK==NULL){
@ -551,60 +551,60 @@ _FUNC_IDEVARIABLEWATCHBOX_LONG_CLICKEDITEM=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPPROMPT=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPPROMPT)_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPPROMPT=qbs_new(0,0);
int32 pass5197;
int32 pass5198;
byte_element_struct *byte_element_5199=NULL;
if (!byte_element_5199){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5199=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5199=(byte_element_struct*)mem_static_malloc(12);
int32 pass5180;
int32 pass5181;
byte_element_struct *byte_element_5182=NULL;
if (!byte_element_5182){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5182=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5182=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5201=NULL;
if (!byte_element_5201){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5201=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5201=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5184=NULL;
if (!byte_element_5184){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5184=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5184=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5203=NULL;
if (!byte_element_5203){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5203=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5203=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5186=NULL;
if (!byte_element_5186){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5186=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5186=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value5205;
int64 fornext_finalvalue5205;
int64 fornext_step5205;
uint8 fornext_step_negative5205;
int32 pass5207;
int32 pass5208;
int64 fornext_value5188;
int64 fornext_finalvalue5188;
int64 fornext_step5188;
uint8 fornext_step_negative5188;
int32 pass5190;
int32 pass5191;
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_LONGESTELEMENTNAME=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_LONGESTELEMENTNAME==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_LONGESTELEMENTNAME=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_LONGESTELEMENTNAME=0;
}
byte_element_struct *byte_element_5210=NULL;
if (!byte_element_5210){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5210=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5210=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5193=NULL;
if (!byte_element_5193){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5193=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5193=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5211=NULL;
if (!byte_element_5211){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5211=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5211=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5194=NULL;
if (!byte_element_5194){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5194=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5194=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5212=NULL;
if (!byte_element_5212){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5212=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5212=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5195=NULL;
if (!byte_element_5195){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5195=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5195=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5214=NULL;
if (!byte_element_5214){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5214=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5214=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5197=NULL;
if (!byte_element_5197){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5197=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5197=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5215=NULL;
if (!byte_element_5215){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5215=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5215=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5198=NULL;
if (!byte_element_5198){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5198=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5198=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_PROPOSEDTITLE=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_PROPOSEDTITLE)_FUNC_IDEVARIABLEWATCHBOX_STRING_PROPOSEDTITLE=qbs_new(0,0);
int64 fornext_value5217;
int64 fornext_finalvalue5217;
int64 fornext_step5217;
uint8 fornext_step_negative5217;
byte_element_struct *byte_element_5218=NULL;
if (!byte_element_5218){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5218=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5218=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5200;
int64 fornext_finalvalue5200;
int64 fornext_step5200;
uint8 fornext_step_negative5200;
byte_element_struct *byte_element_5201=NULL;
if (!byte_element_5201){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5201=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5201=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_THISSCOPE=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_THISSCOPE)_FUNC_IDEVARIABLEWATCHBOX_STRING_THISSCOPE=qbs_new(0,0);
@ -612,95 +612,95 @@ qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_ITEM=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_ITEM)_FUNC_IDEVARIABLEWATCHBOX_STRING_ITEM=qbs_new(0,0);
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_L3=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_L3)_FUNC_IDEVARIABLEWATCHBOX_STRING_L3=qbs_new(0,0);
byte_element_struct *byte_element_5219=NULL;
if (!byte_element_5219){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5219=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5219=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5202=NULL;
if (!byte_element_5202){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5202=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5202=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value5221;
int64 fornext_finalvalue5221;
int64 fornext_step5221;
uint8 fornext_step_negative5221;
int32 pass5222;
int32 pass5223;
int64 fornext_value5225;
int64 fornext_finalvalue5225;
int64 fornext_step5225;
uint8 fornext_step_negative5225;
byte_element_struct *byte_element_5226=NULL;
if (!byte_element_5226){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5226=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5226=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5204;
int64 fornext_finalvalue5204;
int64 fornext_step5204;
uint8 fornext_step_negative5204;
int32 pass5205;
int32 pass5206;
int64 fornext_value5208;
int64 fornext_finalvalue5208;
int64 fornext_step5208;
uint8 fornext_step_negative5208;
byte_element_struct *byte_element_5209=NULL;
if (!byte_element_5209){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5209=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5209=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5227=NULL;
if (!byte_element_5227){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5227=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5227=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5210=NULL;
if (!byte_element_5210){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5210=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5210=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5229=NULL;
if (!byte_element_5229){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5229=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5229=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5212=NULL;
if (!byte_element_5212){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5212=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5212=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_ITEMTOSELECT=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_ITEMTOSELECT==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_ITEMTOSELECT=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_ITEMTOSELECT=0;
}
byte_element_struct *byte_element_5230=NULL;
if (!byte_element_5230){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5230=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5230=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5213=NULL;
if (!byte_element_5213){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5213=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5213=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5231=NULL;
if (!byte_element_5231){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5231=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5231=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5214=NULL;
if (!byte_element_5214){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5214=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5214=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_THISNAME=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_THISNAME)_FUNC_IDEVARIABLEWATCHBOX_STRING_THISNAME=qbs_new(0,0);
byte_element_struct *byte_element_5232=NULL;
if (!byte_element_5232){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5232=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5232=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5215=NULL;
if (!byte_element_5215){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5215=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5215=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5234=NULL;
if (!byte_element_5234){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5234=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5234=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5217=NULL;
if (!byte_element_5217){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5217=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5217=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_TEXT=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_TEXT)_FUNC_IDEVARIABLEWATCHBOX_STRING_TEXT=qbs_new(0,0);
byte_element_struct *byte_element_5235=NULL;
if (!byte_element_5235){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5235=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5235=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5218=NULL;
if (!byte_element_5218){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5218=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5218=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5236=NULL;
if (!byte_element_5236){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5236=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5236=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5219=NULL;
if (!byte_element_5219){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5219=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5219=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5237=NULL;
if (!byte_element_5237){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5237=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5237=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5220=NULL;
if (!byte_element_5220){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5220=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5220=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5238=NULL;
if (!byte_element_5238){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5238=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5238=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5221=NULL;
if (!byte_element_5221){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5221=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5221=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5239=NULL;
if (!byte_element_5239){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5239=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5239=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5222=NULL;
if (!byte_element_5222){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5222=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5222=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEVARIABLEWATCHBOX_LONG_THISISASTRING=NULL;
if(_FUNC_IDEVARIABLEWATCHBOX_LONG_THISISASTRING==NULL){
_FUNC_IDEVARIABLEWATCHBOX_LONG_THISISASTRING=(int32*)mem_static_malloc(4);
*_FUNC_IDEVARIABLEWATCHBOX_LONG_THISISASTRING=0;
}
byte_element_struct *byte_element_5240=NULL;
if (!byte_element_5240){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5240=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5240=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5223=NULL;
if (!byte_element_5223){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5223=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5223=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5241=NULL;
if (!byte_element_5241){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5241=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5241=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5224=NULL;
if (!byte_element_5224){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5224=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5224=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPVALUE=NULL;
if (!_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPVALUE)_FUNC_IDEVARIABLEWATCHBOX_STRING_TEMPVALUE=qbs_new(0,0);
static int32 sc_5243;
byte_element_struct *byte_element_5244=NULL;
if (!byte_element_5244){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5244=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5244=(byte_element_struct*)mem_static_malloc(12);
static int32 sc_5226;
byte_element_struct *byte_element_5227=NULL;
if (!byte_element_5227){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5227=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5227=(byte_element_struct*)mem_static_malloc(12);
}
static int32 sc_5245;
static int32 sc_5228;

View file

@ -1,24 +1,24 @@
qbs *_FUNC_IDEELEMENTWATCHBOX_STRING_IDEELEMENTWATCHBOX=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_STRING_IDEELEMENTWATCHBOX)_FUNC_IDEELEMENTWATCHBOX_STRING_IDEELEMENTWATCHBOX=qbs_new(0,0);
qbs*oldstr5246=NULL;
qbs*oldstr5229=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH->tmp||_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH->fixed||_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH->readonly){
oldstr5246=_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH;
if (oldstr5246->cmem_descriptor){
_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH=qbs_new_cmem(oldstr5246->len,0);
oldstr5229=_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH;
if (oldstr5229->cmem_descriptor){
_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH=qbs_new_cmem(oldstr5229->len,0);
}else{
_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH=qbs_new(oldstr5246->len,0);
_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH=qbs_new(oldstr5229->len,0);
}
memcpy(_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH->chr,oldstr5246->chr,oldstr5246->len);
memcpy(_FUNC_IDEELEMENTWATCHBOX_STRING_CURRENTPATH->chr,oldstr5229->chr,oldstr5229->len);
}
qbs*oldstr5247=NULL;
qbs*oldstr5230=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES->tmp||_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES->fixed||_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES->readonly){
oldstr5247=_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES;
if (oldstr5247->cmem_descriptor){
_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES=qbs_new_cmem(oldstr5247->len,0);
oldstr5230=_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES;
if (oldstr5230->cmem_descriptor){
_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES=qbs_new_cmem(oldstr5230->len,0);
}else{
_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES=qbs_new(oldstr5247->len,0);
_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES=qbs_new(oldstr5230->len,0);
}
memcpy(_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES->chr,oldstr5247->chr,oldstr5247->len);
memcpy(_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES->chr,oldstr5230->chr,oldstr5230->len);
}
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_FOCUS=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_FOCUS==NULL){
@ -67,9 +67,9 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_TOTALELEMENTS==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_TOTALELEMENTS=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_TOTALELEMENTS=0;
}
byte_element_struct *byte_element_5248=NULL;
if (!byte_element_5248){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5248=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5248=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5231=NULL;
if (!byte_element_5231){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5231=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5231=(byte_element_struct*)mem_static_malloc(12);
}
ptrszint *_FUNC_IDEELEMENTWATCHBOX_ARRAY_UDT_VARDLGLIST=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_ARRAY_UDT_VARDLGLIST){
@ -122,10 +122,10 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_BUTTONSET==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_BUTTONSET=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_BUTTONSET=0;
}
int64 fornext_value5250;
int64 fornext_finalvalue5250;
int64 fornext_step5250;
uint8 fornext_step_negative5250;
int64 fornext_value5233;
int64 fornext_finalvalue5233;
int64 fornext_step5233;
uint8 fornext_step_negative5233;
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_F=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_F==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_F=(int32*)mem_static_malloc(4);
@ -141,10 +141,10 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_CY==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_CY=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_CY=0;
}
int64 fornext_value5253;
int64 fornext_finalvalue5253;
int64 fornext_step5253;
uint8 fornext_step_negative5253;
int64 fornext_value5236;
int64 fornext_finalvalue5236;
int64 fornext_step5236;
uint8 fornext_step_negative5236;
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_LASTFOCUS=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_LASTFOCUS==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_LASTFOCUS=(int32*)mem_static_malloc(4);
@ -152,9 +152,9 @@ _FUNC_IDEELEMENTWATCHBOX_LONG_LASTFOCUS=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEELEMENTWATCHBOX_STRING_TEMP=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_STRING_TEMP)_FUNC_IDEELEMENTWATCHBOX_STRING_TEMP=qbs_new(0,0);
byte_element_struct *byte_element_5254=NULL;
if (!byte_element_5254){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5254=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5254=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5237=NULL;
if (!byte_element_5237){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5237=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5237=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_CHANGE=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_CHANGE==NULL){
@ -183,9 +183,9 @@ _FUNC_IDEELEMENTWATCHBOX_LONG_OLDALT=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEELEMENTWATCHBOX_STRING_ALTLETTER=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_STRING_ALTLETTER)_FUNC_IDEELEMENTWATCHBOX_STRING_ALTLETTER=qbs_new(0,0);
byte_element_struct *byte_element_5256=NULL;
if (!byte_element_5256){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5256=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5256=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5239=NULL;
if (!byte_element_5239){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5239=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5239=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_K=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_K==NULL){
@ -197,10 +197,10 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_INFO==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_INFO=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_INFO=0;
}
int64 fornext_value5258;
int64 fornext_finalvalue5258;
int64 fornext_step5258;
uint8 fornext_step_negative5258;
int64 fornext_value5241;
int64 fornext_finalvalue5241;
int64 fornext_step5241;
uint8 fornext_step_negative5241;
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_T=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_T==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_T=(int32*)mem_static_malloc(4);
@ -221,33 +221,33 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_TOGGLEANDRETURN==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_TOGGLEANDRETURN=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_TOGGLEANDRETURN=0;
}
int64 fornext_value5260;
int64 fornext_finalvalue5260;
int64 fornext_step5260;
uint8 fornext_step_negative5260;
int64 fornext_value5243;
int64 fornext_finalvalue5243;
int64 fornext_step5243;
uint8 fornext_step_negative5243;
qbs *_FUNC_IDEELEMENTWATCHBOX_STRING_VARTYPE=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_STRING_VARTYPE)_FUNC_IDEELEMENTWATCHBOX_STRING_VARTYPE=qbs_new(0,0);
int64 fornext_value5262;
int64 fornext_finalvalue5262;
int64 fornext_step5262;
uint8 fornext_step_negative5262;
int64 fornext_value5264;
int64 fornext_finalvalue5264;
int64 fornext_step5264;
uint8 fornext_step_negative5264;
int64 fornext_value5245;
int64 fornext_finalvalue5245;
int64 fornext_step5245;
uint8 fornext_step_negative5245;
int64 fornext_value5247;
int64 fornext_finalvalue5247;
int64 fornext_step5247;
uint8 fornext_step_negative5247;
qbs *_FUNC_IDEELEMENTWATCHBOX_STRING_THISNAME=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_STRING_THISNAME)_FUNC_IDEELEMENTWATCHBOX_STRING_THISNAME=qbs_new(0,0);
byte_element_struct *byte_element_5265=NULL;
if (!byte_element_5265){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5265=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5265=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5248=NULL;
if (!byte_element_5248){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5248=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5248=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5266=NULL;
if (!byte_element_5266){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5266=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5266=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5249=NULL;
if (!byte_element_5249){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5249=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5249=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5267=NULL;
if (!byte_element_5267){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5267=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5267=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5250=NULL;
if (!byte_element_5250){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5250=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5250=(byte_element_struct*)mem_static_malloc(12);
}
float *_FUNC_IDEELEMENTWATCHBOX_SINGLE_LASTCLICK=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_SINGLE_LASTCLICK==NULL){
@ -259,10 +259,10 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_CLICKEDITEM==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_CLICKEDITEM=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_CLICKEDITEM=0;
}
int64 fornext_value5269;
int64 fornext_finalvalue5269;
int64 fornext_step5269;
uint8 fornext_step_negative5269;
int64 fornext_value5252;
int64 fornext_finalvalue5252;
int64 fornext_step5252;
uint8 fornext_step_negative5252;
qbs *_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES2=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES2)_FUNC_IDEELEMENTWATCHBOX_STRING_ELEMENTINDEXES2=qbs_new(0,0);
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_THISUDT=NULL;
@ -270,13 +270,13 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_THISUDT==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_THISUDT=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_THISUDT=0;
}
int64 fornext_value5271;
int64 fornext_finalvalue5271;
int64 fornext_step5271;
uint8 fornext_step_negative5271;
int64 fornext_value5254;
int64 fornext_finalvalue5254;
int64 fornext_step5254;
uint8 fornext_step_negative5254;
qbs *_FUNC_IDEELEMENTWATCHBOX_STRING_V=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_STRING_V)_FUNC_IDEELEMENTWATCHBOX_STRING_V=qbs_new(0,0);
int32 pass5273;
int32 pass5256;
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_OK2=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_OK2==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_OK2=(int32*)mem_static_malloc(4);
@ -287,10 +287,10 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_X==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_X=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_X=0;
}
int64 fornext_value5275;
int64 fornext_finalvalue5275;
int64 fornext_step5275;
uint8 fornext_step_negative5275;
int64 fornext_value5258;
int64 fornext_finalvalue5258;
int64 fornext_step5258;
uint8 fornext_step_negative5258;
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_THISTYPE=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_THISTYPE==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_THISTYPE=(int32*)mem_static_malloc(4);
@ -301,38 +301,38 @@ if(_FUNC_IDEELEMENTWATCHBOX_LONG_THISLEN==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_THISLEN=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_THISLEN=0;
}
int64 fornext_value5277;
int64 fornext_finalvalue5277;
int64 fornext_step5277;
uint8 fornext_step_negative5277;
int64 fornext_value5260;
int64 fornext_finalvalue5260;
int64 fornext_step5260;
uint8 fornext_step_negative5260;
int32 *_FUNC_IDEELEMENTWATCHBOX_LONG_THISELEMENT=NULL;
if(_FUNC_IDEELEMENTWATCHBOX_LONG_THISELEMENT==NULL){
_FUNC_IDEELEMENTWATCHBOX_LONG_THISELEMENT=(int32*)mem_static_malloc(4);
*_FUNC_IDEELEMENTWATCHBOX_LONG_THISELEMENT=0;
}
byte_element_struct *byte_element_5278=NULL;
if (!byte_element_5278){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5278=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5278=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5261=NULL;
if (!byte_element_5261){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5261=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5261=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5279=NULL;
if (!byte_element_5279){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5279=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5279=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5262=NULL;
if (!byte_element_5262){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5262=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5262=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5280=NULL;
if (!byte_element_5280){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5280=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5280=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5263=NULL;
if (!byte_element_5263){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5263=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5263=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEELEMENTWATCHBOX_STRING_TEXT=NULL;
if (!_FUNC_IDEELEMENTWATCHBOX_STRING_TEXT)_FUNC_IDEELEMENTWATCHBOX_STRING_TEXT=qbs_new(0,0);
byte_element_struct *byte_element_5281=NULL;
if (!byte_element_5281){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5281=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5281=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5264=NULL;
if (!byte_element_5264){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5264=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5264=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5282=NULL;
if (!byte_element_5282){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5282=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5282=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5265=NULL;
if (!byte_element_5265){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5265=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5265=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5283=NULL;
if (!byte_element_5283){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5283=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5283=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5266=NULL;
if (!byte_element_5266){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5266=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5266=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,14 +1,14 @@
qbs *_FUNC_FORMATRANGE_STRING_FORMATRANGE=NULL;
if (!_FUNC_FORMATRANGE_STRING_FORMATRANGE)_FUNC_FORMATRANGE_STRING_FORMATRANGE=qbs_new(0,0);
qbs*oldstr5284=NULL;
qbs*oldstr5267=NULL;
if(_FUNC_FORMATRANGE_STRING___TEXT->tmp||_FUNC_FORMATRANGE_STRING___TEXT->fixed||_FUNC_FORMATRANGE_STRING___TEXT->readonly){
oldstr5284=_FUNC_FORMATRANGE_STRING___TEXT;
if (oldstr5284->cmem_descriptor){
_FUNC_FORMATRANGE_STRING___TEXT=qbs_new_cmem(oldstr5284->len,0);
oldstr5267=_FUNC_FORMATRANGE_STRING___TEXT;
if (oldstr5267->cmem_descriptor){
_FUNC_FORMATRANGE_STRING___TEXT=qbs_new_cmem(oldstr5267->len,0);
}else{
_FUNC_FORMATRANGE_STRING___TEXT=qbs_new(oldstr5284->len,0);
_FUNC_FORMATRANGE_STRING___TEXT=qbs_new(oldstr5267->len,0);
}
memcpy(_FUNC_FORMATRANGE_STRING___TEXT->chr,oldstr5284->chr,oldstr5284->len);
memcpy(_FUNC_FORMATRANGE_STRING___TEXT->chr,oldstr5267->chr,oldstr5267->len);
}
qbs *_FUNC_FORMATRANGE_STRING_TEMP=NULL;
if (!_FUNC_FORMATRANGE_STRING_TEMP)_FUNC_FORMATRANGE_STRING_TEMP=qbs_new(0,0);
@ -27,13 +27,13 @@ if(_FUNC_FORMATRANGE_LONG_I==NULL){
_FUNC_FORMATRANGE_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_FORMATRANGE_LONG_I=0;
}
int64 fornext_value5286;
int64 fornext_finalvalue5286;
int64 fornext_step5286;
uint8 fornext_step_negative5286;
byte_element_struct *byte_element_5287=NULL;
if (!byte_element_5287){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5287=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5287=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5269;
int64 fornext_finalvalue5269;
int64 fornext_step5269;
uint8 fornext_step_negative5269;
byte_element_struct *byte_element_5270=NULL;
if (!byte_element_5270){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5270=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5270=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_FORMATRANGE_LONG_V=NULL;
if(_FUNC_FORMATRANGE_LONG_V==NULL){

View file

@ -1,24 +1,24 @@
qbs *_FUNC_EXPANDARRAY_STRING_EXPANDARRAY=NULL;
if (!_FUNC_EXPANDARRAY_STRING_EXPANDARRAY)_FUNC_EXPANDARRAY_STRING_EXPANDARRAY=qbs_new(0,0);
qbs*oldstr5288=NULL;
qbs*oldstr5271=NULL;
if(_FUNC_EXPANDARRAY_STRING___INDEXES->tmp||_FUNC_EXPANDARRAY_STRING___INDEXES->fixed||_FUNC_EXPANDARRAY_STRING___INDEXES->readonly){
oldstr5288=_FUNC_EXPANDARRAY_STRING___INDEXES;
if (oldstr5288->cmem_descriptor){
_FUNC_EXPANDARRAY_STRING___INDEXES=qbs_new_cmem(oldstr5288->len,0);
oldstr5271=_FUNC_EXPANDARRAY_STRING___INDEXES;
if (oldstr5271->cmem_descriptor){
_FUNC_EXPANDARRAY_STRING___INDEXES=qbs_new_cmem(oldstr5271->len,0);
}else{
_FUNC_EXPANDARRAY_STRING___INDEXES=qbs_new(oldstr5288->len,0);
_FUNC_EXPANDARRAY_STRING___INDEXES=qbs_new(oldstr5271->len,0);
}
memcpy(_FUNC_EXPANDARRAY_STRING___INDEXES->chr,oldstr5288->chr,oldstr5288->len);
memcpy(_FUNC_EXPANDARRAY_STRING___INDEXES->chr,oldstr5271->chr,oldstr5271->len);
}
qbs*oldstr5289=NULL;
qbs*oldstr5272=NULL;
if(_FUNC_EXPANDARRAY_STRING___PATH->tmp||_FUNC_EXPANDARRAY_STRING___PATH->fixed||_FUNC_EXPANDARRAY_STRING___PATH->readonly){
oldstr5289=_FUNC_EXPANDARRAY_STRING___PATH;
if (oldstr5289->cmem_descriptor){
_FUNC_EXPANDARRAY_STRING___PATH=qbs_new_cmem(oldstr5289->len,0);
oldstr5272=_FUNC_EXPANDARRAY_STRING___PATH;
if (oldstr5272->cmem_descriptor){
_FUNC_EXPANDARRAY_STRING___PATH=qbs_new_cmem(oldstr5272->len,0);
}else{
_FUNC_EXPANDARRAY_STRING___PATH=qbs_new(oldstr5289->len,0);
_FUNC_EXPANDARRAY_STRING___PATH=qbs_new(oldstr5272->len,0);
}
memcpy(_FUNC_EXPANDARRAY_STRING___PATH->chr,oldstr5289->chr,oldstr5289->len);
memcpy(_FUNC_EXPANDARRAY_STRING___PATH->chr,oldstr5272->chr,oldstr5272->len);
}
int32 *_FUNC_EXPANDARRAY_LONG_TOTALINDEXES=NULL;
if(_FUNC_EXPANDARRAY_LONG_TOTALINDEXES==NULL){
@ -34,21 +34,21 @@ if(_FUNC_EXPANDARRAY_LONG_I==NULL){
_FUNC_EXPANDARRAY_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_EXPANDARRAY_LONG_I=0;
}
int64 fornext_value5291;
int64 fornext_finalvalue5291;
int64 fornext_step5291;
uint8 fornext_step_negative5291;
int64 fornext_value5274;
int64 fornext_finalvalue5274;
int64 fornext_step5274;
uint8 fornext_step_negative5274;
qbs *_FUNC_EXPANDARRAY_STRING_TEMP=NULL;
if (!_FUNC_EXPANDARRAY_STRING_TEMP)_FUNC_EXPANDARRAY_STRING_TEMP=qbs_new(0,0);
byte_element_struct *byte_element_5292=NULL;
if (!byte_element_5292){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5292=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5292=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5275=NULL;
if (!byte_element_5275){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5275=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5275=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5293=NULL;
if (!byte_element_5293){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5293=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5293=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5276=NULL;
if (!byte_element_5276){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5276=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5276=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5294=NULL;
if (!byte_element_5294){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5294=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5294=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5277=NULL;
if (!byte_element_5277){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5277=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5277=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,14 +1,14 @@
qbs *_FUNC_PARSERANGE_STRING_PARSERANGE=NULL;
if (!_FUNC_PARSERANGE_STRING_PARSERANGE)_FUNC_PARSERANGE_STRING_PARSERANGE=qbs_new(0,0);
qbs*oldstr5295=NULL;
qbs*oldstr5278=NULL;
if(_FUNC_PARSERANGE_STRING___TEXT->tmp||_FUNC_PARSERANGE_STRING___TEXT->fixed||_FUNC_PARSERANGE_STRING___TEXT->readonly){
oldstr5295=_FUNC_PARSERANGE_STRING___TEXT;
if (oldstr5295->cmem_descriptor){
_FUNC_PARSERANGE_STRING___TEXT=qbs_new_cmem(oldstr5295->len,0);
oldstr5278=_FUNC_PARSERANGE_STRING___TEXT;
if (oldstr5278->cmem_descriptor){
_FUNC_PARSERANGE_STRING___TEXT=qbs_new_cmem(oldstr5278->len,0);
}else{
_FUNC_PARSERANGE_STRING___TEXT=qbs_new(oldstr5295->len,0);
_FUNC_PARSERANGE_STRING___TEXT=qbs_new(oldstr5278->len,0);
}
memcpy(_FUNC_PARSERANGE_STRING___TEXT->chr,oldstr5295->chr,oldstr5295->len);
memcpy(_FUNC_PARSERANGE_STRING___TEXT->chr,oldstr5278->chr,oldstr5278->len);
}
int8 *_FUNC_PARSERANGE_BYTE_ZEROINCLUDED=NULL;
if(_FUNC_PARSERANGE_BYTE_ZEROINCLUDED==NULL){
@ -29,13 +29,13 @@ if(_FUNC_PARSERANGE_LONG_READING==NULL){
_FUNC_PARSERANGE_LONG_READING=(int32*)mem_static_malloc(4);
*_FUNC_PARSERANGE_LONG_READING=0;
}
int64 fornext_value5297;
int64 fornext_finalvalue5297;
int64 fornext_step5297;
uint8 fornext_step_negative5297;
byte_element_struct *byte_element_5298=NULL;
if (!byte_element_5298){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5298=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5298=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5280;
int64 fornext_finalvalue5280;
int64 fornext_step5280;
uint8 fornext_step_negative5280;
byte_element_struct *byte_element_5281=NULL;
if (!byte_element_5281){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5281=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5281=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_PARSERANGE_LONG_V=NULL;
if(_FUNC_PARSERANGE_LONG_V==NULL){
@ -47,17 +47,17 @@ if(_FUNC_PARSERANGE_LONG_PREVCHAR==NULL){
_FUNC_PARSERANGE_LONG_PREVCHAR=(int32*)mem_static_malloc(4);
*_FUNC_PARSERANGE_LONG_PREVCHAR=0;
}
byte_element_struct *byte_element_5300=NULL;
if (!byte_element_5300){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5300=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5300=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5283=NULL;
if (!byte_element_5283){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5283=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5283=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_PARSERANGE_STRING_V1=NULL;
if (!_FUNC_PARSERANGE_STRING_V1)_FUNC_PARSERANGE_STRING_V1=qbs_new(0,0);
qbs *_FUNC_PARSERANGE_STRING_V2=NULL;
if (!_FUNC_PARSERANGE_STRING_V2)_FUNC_PARSERANGE_STRING_V2=qbs_new(0,0);
byte_element_struct *byte_element_5301=NULL;
if (!byte_element_5301){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5301=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5301=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5284=NULL;
if (!byte_element_5284){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5284=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5284=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_PARSERANGE_STRING_RETURNVALUE=NULL;
if (!_FUNC_PARSERANGE_STRING_RETURNVALUE)_FUNC_PARSERANGE_STRING_RETURNVALUE=qbs_new(0,0);
@ -66,13 +66,13 @@ if(_FUNC_PARSERANGE_LONG_I==NULL){
_FUNC_PARSERANGE_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_PARSERANGE_LONG_I=0;
}
int64 fornext_value5303;
int64 fornext_finalvalue5303;
int64 fornext_step5303;
uint8 fornext_step_negative5303;
byte_element_struct *byte_element_5304=NULL;
if (!byte_element_5304){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5304=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5304=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5286;
int64 fornext_finalvalue5286;
int64 fornext_step5286;
uint8 fornext_step_negative5286;
byte_element_struct *byte_element_5287=NULL;
if (!byte_element_5287){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5287=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5287=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_PARSERANGE_LONG_V1=NULL;
if(_FUNC_PARSERANGE_LONG_V1==NULL){
@ -84,31 +84,31 @@ if(_FUNC_PARSERANGE_LONG_V2==NULL){
_FUNC_PARSERANGE_LONG_V2=(int32*)mem_static_malloc(4);
*_FUNC_PARSERANGE_LONG_V2=0;
}
byte_element_struct *byte_element_5305=NULL;
if (!byte_element_5305){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5305=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5305=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5288=NULL;
if (!byte_element_5288){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5288=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5288=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5306=NULL;
if (!byte_element_5306){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5306=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5306=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5289=NULL;
if (!byte_element_5289){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5289=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5289=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5307=NULL;
if (!byte_element_5307){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5307=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5307=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5290=NULL;
if (!byte_element_5290){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5290=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5290=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5308=NULL;
if (!byte_element_5308){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5308=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5308=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5291=NULL;
if (!byte_element_5291){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5291=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5291=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value5310;
int64 fornext_finalvalue5310;
int64 fornext_step5310;
uint8 fornext_step_negative5310;
byte_element_struct *byte_element_5311=NULL;
if (!byte_element_5311){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5311=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5311=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5293;
int64 fornext_finalvalue5293;
int64 fornext_step5293;
uint8 fornext_step_negative5293;
byte_element_struct *byte_element_5294=NULL;
if (!byte_element_5294){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5294=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5294=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5312=NULL;
if (!byte_element_5312){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5312=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5312=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5295=NULL;
if (!byte_element_5295){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5295=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5295=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -49,26 +49,26 @@ _FUNC_IDECALLSTACKBOX_LONG_I=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDECALLSTACKBOX_STRING_TEMP2=NULL;
if (!_FUNC_IDECALLSTACKBOX_STRING_TEMP2)_FUNC_IDECALLSTACKBOX_STRING_TEMP2=qbs_new(0,0);
byte_element_struct *byte_element_5314=NULL;
if (!byte_element_5314){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5314=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5314=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5297=NULL;
if (!byte_element_5297){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5297=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5297=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5315=NULL;
if (!byte_element_5315){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5315=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5315=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5298=NULL;
if (!byte_element_5298){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5298=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5298=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5316=NULL;
if (!byte_element_5316){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5316=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5316=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5299=NULL;
if (!byte_element_5299){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5299=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5299=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5317=NULL;
if (!byte_element_5317){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5317=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5317=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5300=NULL;
if (!byte_element_5300){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5300=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5300=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value5319;
int64 fornext_finalvalue5319;
int64 fornext_step5319;
uint8 fornext_step_negative5319;
int64 fornext_value5302;
int64 fornext_finalvalue5302;
int64 fornext_step5302;
uint8 fornext_step_negative5302;
int32 *_FUNC_IDECALLSTACKBOX_LONG_F=NULL;
if(_FUNC_IDECALLSTACKBOX_LONG_F==NULL){
_FUNC_IDECALLSTACKBOX_LONG_F=(int32*)mem_static_malloc(4);
@ -84,10 +84,10 @@ if(_FUNC_IDECALLSTACKBOX_LONG_CY==NULL){
_FUNC_IDECALLSTACKBOX_LONG_CY=(int32*)mem_static_malloc(4);
*_FUNC_IDECALLSTACKBOX_LONG_CY=0;
}
int64 fornext_value5322;
int64 fornext_finalvalue5322;
int64 fornext_step5322;
uint8 fornext_step_negative5322;
int64 fornext_value5305;
int64 fornext_finalvalue5305;
int64 fornext_step5305;
uint8 fornext_step_negative5305;
int32 *_FUNC_IDECALLSTACKBOX_LONG_LASTFOCUS=NULL;
if(_FUNC_IDECALLSTACKBOX_LONG_LASTFOCUS==NULL){
_FUNC_IDECALLSTACKBOX_LONG_LASTFOCUS=(int32*)mem_static_malloc(4);
@ -120,9 +120,9 @@ _FUNC_IDECALLSTACKBOX_LONG_OLDALT=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDECALLSTACKBOX_STRING_ALTLETTER=NULL;
if (!_FUNC_IDECALLSTACKBOX_STRING_ALTLETTER)_FUNC_IDECALLSTACKBOX_STRING_ALTLETTER=qbs_new(0,0);
byte_element_struct *byte_element_5324=NULL;
if (!byte_element_5324){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5324=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5324=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5307=NULL;
if (!byte_element_5307){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5307=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5307=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDECALLSTACKBOX_LONG_K=NULL;
if(_FUNC_IDECALLSTACKBOX_LONG_K==NULL){
@ -134,10 +134,10 @@ if(_FUNC_IDECALLSTACKBOX_LONG_INFO==NULL){
_FUNC_IDECALLSTACKBOX_LONG_INFO=(int32*)mem_static_malloc(4);
*_FUNC_IDECALLSTACKBOX_LONG_INFO=0;
}
int64 fornext_value5326;
int64 fornext_finalvalue5326;
int64 fornext_step5326;
uint8 fornext_step_negative5326;
int64 fornext_value5309;
int64 fornext_finalvalue5309;
int64 fornext_step5309;
uint8 fornext_step_negative5309;
int32 *_FUNC_IDECALLSTACKBOX_LONG_T=NULL;
if(_FUNC_IDECALLSTACKBOX_LONG_T==NULL){
_FUNC_IDECALLSTACKBOX_LONG_T=(int32*)mem_static_malloc(4);

View file

@ -3,7 +3,7 @@ if(_SUB_IDEBOX_LONG_Y2==NULL){
_SUB_IDEBOX_LONG_Y2=(int32*)mem_static_malloc(4);
*_SUB_IDEBOX_LONG_Y2=0;
}
int64 fornext_value5328;
int64 fornext_finalvalue5328;
int64 fornext_step5328;
uint8 fornext_step_negative5328;
int64 fornext_value5311;
int64 fornext_finalvalue5311;
int64 fornext_step5311;
uint8 fornext_step_negative5311;

View file

@ -3,20 +3,20 @@ if(_SUB_IDEBOXSHADOW_LONG_Y2==NULL){
_SUB_IDEBOXSHADOW_LONG_Y2=(int32*)mem_static_malloc(4);
*_SUB_IDEBOXSHADOW_LONG_Y2=0;
}
int64 fornext_value5330;
int64 fornext_finalvalue5330;
int64 fornext_step5330;
uint8 fornext_step_negative5330;
int64 fornext_value5313;
int64 fornext_finalvalue5313;
int64 fornext_step5313;
uint8 fornext_step_negative5313;
int32 *_SUB_IDEBOXSHADOW_LONG_X2=NULL;
if(_SUB_IDEBOXSHADOW_LONG_X2==NULL){
_SUB_IDEBOXSHADOW_LONG_X2=(int32*)mem_static_malloc(4);
*_SUB_IDEBOXSHADOW_LONG_X2=0;
}
int64 fornext_value5332;
int64 fornext_finalvalue5332;
int64 fornext_step5332;
uint8 fornext_step_negative5332;
int64 fornext_value5334;
int64 fornext_finalvalue5334;
int64 fornext_step5334;
uint8 fornext_step_negative5334;
int64 fornext_value5315;
int64 fornext_finalvalue5315;
int64 fornext_step5315;
uint8 fornext_step_negative5315;
int64 fornext_value5317;
int64 fornext_finalvalue5317;
int64 fornext_step5317;
uint8 fornext_step_negative5317;

View file

@ -58,51 +58,51 @@ if(_FUNC_IDECHANGE_LONG_X==NULL){
_FUNC_IDECHANGE_LONG_X=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_X=0;
}
int64 fornext_value5336;
int64 fornext_finalvalue5336;
int64 fornext_step5336;
uint8 fornext_step_negative5336;
byte_element_struct *byte_element_5337=NULL;
if (!byte_element_5337){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5337=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5337=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5319;
int64 fornext_finalvalue5319;
int64 fornext_step5319;
uint8 fornext_step_negative5319;
byte_element_struct *byte_element_5320=NULL;
if (!byte_element_5320){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5320=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5320=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDECHANGE_LONG_I=NULL;
if(_FUNC_IDECHANGE_LONG_I==NULL){
_FUNC_IDECHANGE_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_I=0;
}
int32 pass5338;
int32 pass5339;
int32 pass5321;
int32 pass5322;
int32 *_FUNC_IDECHANGE_LONG_PREVFOCUS=NULL;
if(_FUNC_IDECHANGE_LONG_PREVFOCUS==NULL){
_FUNC_IDECHANGE_LONG_PREVFOCUS=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_PREVFOCUS=0;
}
byte_element_struct *byte_element_5340=NULL;
if (!byte_element_5340){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5340=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5340=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5323=NULL;
if (!byte_element_5323){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5323=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5323=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5341=NULL;
if (!byte_element_5341){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5341=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5341=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5324=NULL;
if (!byte_element_5324){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5324=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5324=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5342=NULL;
if (!byte_element_5342){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5342=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5342=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5325=NULL;
if (!byte_element_5325){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5325=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5325=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5343=NULL;
if (!byte_element_5343){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5343=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5343=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5326=NULL;
if (!byte_element_5326){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5326=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5326=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDECHANGE_LONG_BUTTONSID=NULL;
if(_FUNC_IDECHANGE_LONG_BUTTONSID==NULL){
_FUNC_IDECHANGE_LONG_BUTTONSID=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_BUTTONSID=0;
}
int64 fornext_value5345;
int64 fornext_finalvalue5345;
int64 fornext_step5345;
uint8 fornext_step_negative5345;
int64 fornext_value5328;
int64 fornext_finalvalue5328;
int64 fornext_step5328;
uint8 fornext_step_negative5328;
int32 *_FUNC_IDECHANGE_LONG_LASTFOCUS=NULL;
if(_FUNC_IDECHANGE_LONG_LASTFOCUS==NULL){
_FUNC_IDECHANGE_LONG_LASTFOCUS=(int32*)mem_static_malloc(4);
@ -150,9 +150,9 @@ _FUNC_IDECHANGE_LONG_OLDALT=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDECHANGE_STRING_ALTLETTER=NULL;
if (!_FUNC_IDECHANGE_STRING_ALTLETTER)_FUNC_IDECHANGE_STRING_ALTLETTER=qbs_new(0,0);
byte_element_struct *byte_element_5348=NULL;
if (!byte_element_5348){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5348=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5348=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5331=NULL;
if (!byte_element_5331){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5331=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5331=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDECHANGE_LONG_K=NULL;
if(_FUNC_IDECHANGE_LONG_K==NULL){
@ -164,10 +164,10 @@ if(_FUNC_IDECHANGE_LONG_INFO==NULL){
_FUNC_IDECHANGE_LONG_INFO=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_INFO=0;
}
int64 fornext_value5350;
int64 fornext_finalvalue5350;
int64 fornext_step5350;
uint8 fornext_step_negative5350;
int64 fornext_value5333;
int64 fornext_finalvalue5333;
int64 fornext_step5333;
uint8 fornext_step_negative5333;
int32 *_FUNC_IDECHANGE_LONG_T=NULL;
if(_FUNC_IDECHANGE_LONG_T==NULL){
_FUNC_IDECHANGE_LONG_T=(int32*)mem_static_malloc(4);
@ -178,22 +178,22 @@ if(_FUNC_IDECHANGE_LONG_FOCUSOFFSET==NULL){
_FUNC_IDECHANGE_LONG_FOCUSOFFSET=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_FOCUSOFFSET=0;
}
byte_element_struct *byte_element_5351=NULL;
if (!byte_element_5351){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5351=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5351=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5334=NULL;
if (!byte_element_5334){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5334=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5334=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDECHANGE_LONG_LN=NULL;
if(_FUNC_IDECHANGE_LONG_LN==NULL){
_FUNC_IDECHANGE_LONG_LN=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_LN=0;
}
byte_element_struct *byte_element_5352=NULL;
if (!byte_element_5352){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5352=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5352=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5335=NULL;
if (!byte_element_5335){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5335=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5335=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5353=NULL;
if (!byte_element_5353){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5353=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5353=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5336=NULL;
if (!byte_element_5336){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5336=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5336=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDECHANGE_STRING_S=NULL;
if (!_FUNC_IDECHANGE_STRING_S)_FUNC_IDECHANGE_STRING_S=qbs_new(0,0);
@ -207,10 +207,10 @@ if(_FUNC_IDECHANGE_LONG_Y==NULL){
_FUNC_IDECHANGE_LONG_Y=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_Y=0;
}
int64 fornext_value5355;
int64 fornext_finalvalue5355;
int64 fornext_step5355;
uint8 fornext_step_negative5355;
int64 fornext_value5338;
int64 fornext_finalvalue5338;
int64 fornext_step5338;
uint8 fornext_step_negative5338;
int32 *_FUNC_IDECHANGE_LONG_MAXPROGRESSWIDTH=NULL;
if(_FUNC_IDECHANGE_LONG_MAXPROGRESSWIDTH==NULL){
_FUNC_IDECHANGE_LONG_MAXPROGRESSWIDTH=(int32*)mem_static_malloc(4);
@ -249,21 +249,21 @@ if(_FUNC_IDECHANGE_LONG_C==NULL){
_FUNC_IDECHANGE_LONG_C=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGE_LONG_C=0;
}
byte_element_struct *byte_element_5356=NULL;
if (!byte_element_5356){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5356=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5356=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5339=NULL;
if (!byte_element_5339){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5339=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5339=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5357=NULL;
if (!byte_element_5357){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5357=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5357=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5340=NULL;
if (!byte_element_5340){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5340=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5340=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5358=NULL;
if (!byte_element_5358){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5358=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5358=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5341=NULL;
if (!byte_element_5341){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5341=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5341=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5359=NULL;
if (!byte_element_5359){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5359=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5359=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5342=NULL;
if (!byte_element_5342){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5342=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5342=(byte_element_struct*)mem_static_malloc(12);
}
int8 *_FUNC_IDECHANGE_BYTE_COMMENT=NULL;
if(_FUNC_IDECHANGE_BYTE_COMMENT==NULL){
@ -275,21 +275,21 @@ if(_FUNC_IDECHANGE_BYTE_QUOTE==NULL){
_FUNC_IDECHANGE_BYTE_QUOTE=(int8*)mem_static_malloc(1);
*_FUNC_IDECHANGE_BYTE_QUOTE=0;
}
byte_element_struct *byte_element_5360=NULL;
if (!byte_element_5360){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5360=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5360=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5343=NULL;
if (!byte_element_5343){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5343=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5343=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5361=NULL;
if (!byte_element_5361){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5361=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5361=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5344=NULL;
if (!byte_element_5344){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5344=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5344=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5362=NULL;
if (!byte_element_5362){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5362=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5362=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5345=NULL;
if (!byte_element_5345){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5345=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5345=(byte_element_struct*)mem_static_malloc(12);
}
int32 pass5363;
int8 pass5364;
int64 fornext_value5366;
int64 fornext_finalvalue5366;
int64 fornext_step5366;
uint8 fornext_step_negative5366;
int32 pass5346;
int8 pass5347;
int64 fornext_value5349;
int64 fornext_finalvalue5349;
int64 fornext_step5349;
uint8 fornext_step_negative5349;

View file

@ -1,41 +1,41 @@
qbs*oldstr5367=NULL;
qbs*oldstr5350=NULL;
if(_SUB_FINDQUOTECOMMENT_STRING_TEXT->tmp||_SUB_FINDQUOTECOMMENT_STRING_TEXT->fixed||_SUB_FINDQUOTECOMMENT_STRING_TEXT->readonly){
oldstr5367=_SUB_FINDQUOTECOMMENT_STRING_TEXT;
if (oldstr5367->cmem_descriptor){
_SUB_FINDQUOTECOMMENT_STRING_TEXT=qbs_new_cmem(oldstr5367->len,0);
oldstr5350=_SUB_FINDQUOTECOMMENT_STRING_TEXT;
if (oldstr5350->cmem_descriptor){
_SUB_FINDQUOTECOMMENT_STRING_TEXT=qbs_new_cmem(oldstr5350->len,0);
}else{
_SUB_FINDQUOTECOMMENT_STRING_TEXT=qbs_new(oldstr5367->len,0);
_SUB_FINDQUOTECOMMENT_STRING_TEXT=qbs_new(oldstr5350->len,0);
}
memcpy(_SUB_FINDQUOTECOMMENT_STRING_TEXT->chr,oldstr5367->chr,oldstr5367->len);
memcpy(_SUB_FINDQUOTECOMMENT_STRING_TEXT->chr,oldstr5350->chr,oldstr5350->len);
}
int32 *_SUB_FINDQUOTECOMMENT_LONG_CURSOR=NULL;
if(_SUB_FINDQUOTECOMMENT_LONG_CURSOR==NULL){
_SUB_FINDQUOTECOMMENT_LONG_CURSOR=(int32*)mem_static_malloc(4);
*_SUB_FINDQUOTECOMMENT_LONG_CURSOR=0;
}
byte_element_struct *byte_element_5368=NULL;
if (!byte_element_5368){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5368=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5368=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5351=NULL;
if (!byte_element_5351){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5351=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5351=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5369=NULL;
if (!byte_element_5369){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5369=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5369=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5352=NULL;
if (!byte_element_5352){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5352=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5352=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_FINDQUOTECOMMENT_LONG_FIND_K=NULL;
if(_SUB_FINDQUOTECOMMENT_LONG_FIND_K==NULL){
_SUB_FINDQUOTECOMMENT_LONG_FIND_K=(int32*)mem_static_malloc(4);
*_SUB_FINDQUOTECOMMENT_LONG_FIND_K=0;
}
int64 fornext_value5371;
int64 fornext_finalvalue5371;
int64 fornext_step5371;
uint8 fornext_step_negative5371;
static qbs *sc_5372=qbs_new(0,0);
byte_element_struct *byte_element_5373=NULL;
if (!byte_element_5373){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5373=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5373=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5354;
int64 fornext_finalvalue5354;
int64 fornext_step5354;
uint8 fornext_step_negative5354;
static qbs *sc_5355=qbs_new(0,0);
byte_element_struct *byte_element_5356=NULL;
if (!byte_element_5356){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5356=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5356=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5374=NULL;
if (!byte_element_5374){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5374=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5374=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5357=NULL;
if (!byte_element_5357){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5357=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5357=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -37,10 +37,10 @@ if(_FUNC_IDECHANGEIT_LONG_W==NULL){
_FUNC_IDECHANGEIT_LONG_W=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGEIT_LONG_W=0;
}
int64 fornext_value5376;
int64 fornext_finalvalue5376;
int64 fornext_step5376;
uint8 fornext_step_negative5376;
int64 fornext_value5359;
int64 fornext_finalvalue5359;
int64 fornext_step5359;
uint8 fornext_step_negative5359;
int32 *_FUNC_IDECHANGEIT_LONG_F=NULL;
if(_FUNC_IDECHANGEIT_LONG_F==NULL){
_FUNC_IDECHANGEIT_LONG_F=(int32*)mem_static_malloc(4);
@ -56,10 +56,10 @@ if(_FUNC_IDECHANGEIT_LONG_CY==NULL){
_FUNC_IDECHANGEIT_LONG_CY=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGEIT_LONG_CY=0;
}
int64 fornext_value5379;
int64 fornext_finalvalue5379;
int64 fornext_step5379;
uint8 fornext_step_negative5379;
int64 fornext_value5362;
int64 fornext_finalvalue5362;
int64 fornext_step5362;
uint8 fornext_step_negative5362;
int32 *_FUNC_IDECHANGEIT_LONG_LASTFOCUS=NULL;
if(_FUNC_IDECHANGEIT_LONG_LASTFOCUS==NULL){
_FUNC_IDECHANGEIT_LONG_LASTFOCUS=(int32*)mem_static_malloc(4);
@ -92,9 +92,9 @@ _FUNC_IDECHANGEIT_LONG_OLDALT=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDECHANGEIT_STRING_ALTLETTER=NULL;
if (!_FUNC_IDECHANGEIT_STRING_ALTLETTER)_FUNC_IDECHANGEIT_STRING_ALTLETTER=qbs_new(0,0);
byte_element_struct *byte_element_5381=NULL;
if (!byte_element_5381){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5381=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5381=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5364=NULL;
if (!byte_element_5364){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5364=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5364=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDECHANGEIT_LONG_K=NULL;
if(_FUNC_IDECHANGEIT_LONG_K==NULL){
@ -106,10 +106,10 @@ if(_FUNC_IDECHANGEIT_LONG_INFO==NULL){
_FUNC_IDECHANGEIT_LONG_INFO=(int32*)mem_static_malloc(4);
*_FUNC_IDECHANGEIT_LONG_INFO=0;
}
int64 fornext_value5383;
int64 fornext_finalvalue5383;
int64 fornext_step5383;
uint8 fornext_step_negative5383;
int64 fornext_value5366;
int64 fornext_finalvalue5366;
int64 fornext_step5366;
uint8 fornext_step_negative5366;
int32 *_FUNC_IDECHANGEIT_LONG_T=NULL;
if(_FUNC_IDECHANGEIT_LONG_T==NULL){
_FUNC_IDECHANGEIT_LONG_T=(int32*)mem_static_malloc(4);

View file

@ -3,29 +3,29 @@ if(_SUB_IDEDELLINE_LONG_B==NULL){
_SUB_IDEDELLINE_LONG_B=(int32*)mem_static_malloc(4);
*_SUB_IDEDELLINE_LONG_B=0;
}
int64 fornext_value5385;
int64 fornext_finalvalue5385;
int64 fornext_step5385;
uint8 fornext_step_negative5385;
int64 fornext_value5368;
int64 fornext_finalvalue5368;
int64 fornext_step5368;
uint8 fornext_step_negative5368;
int32 *_SUB_IDEDELLINE_LONG_Y=NULL;
if(_SUB_IDEDELLINE_LONG_Y==NULL){
_SUB_IDEDELLINE_LONG_Y=(int32*)mem_static_malloc(4);
*_SUB_IDEDELLINE_LONG_Y=0;
}
int64 fornext_value5387;
int64 fornext_finalvalue5387;
int64 fornext_step5387;
uint8 fornext_step_negative5387;
int64 fornext_value5389;
int64 fornext_finalvalue5389;
int64 fornext_step5389;
uint8 fornext_step_negative5389;
int64 fornext_value5370;
int64 fornext_finalvalue5370;
int64 fornext_step5370;
uint8 fornext_step_negative5370;
int64 fornext_value5372;
int64 fornext_finalvalue5372;
int64 fornext_step5372;
uint8 fornext_step_negative5372;
int32 *_SUB_IDEDELLINE_LONG_TEXTLEN=NULL;
if(_SUB_IDEDELLINE_LONG_TEXTLEN==NULL){
_SUB_IDEDELLINE_LONG_TEXTLEN=(int32*)mem_static_malloc(4);
*_SUB_IDEDELLINE_LONG_TEXTLEN=0;
}
byte_element_struct *byte_element_5390=NULL;
if (!byte_element_5390){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5390=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5390=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5373=NULL;
if (!byte_element_5373){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5373=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5373=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -20,16 +20,16 @@ if(_SUB_IDEDRAWOBJ_LONG_X2==NULL){
_SUB_IDEDRAWOBJ_LONG_X2=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWOBJ_LONG_X2=0;
}
int32 pass5391;
int32 pass5392;
int32 pass5393;
byte_element_struct *byte_element_5394=NULL;
if (!byte_element_5394){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5394=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5394=(byte_element_struct*)mem_static_malloc(12);
int32 pass5374;
int32 pass5375;
int32 pass5376;
byte_element_struct *byte_element_5377=NULL;
if (!byte_element_5377){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5377=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5377=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5395=NULL;
if (!byte_element_5395){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5395=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5395=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5378=NULL;
if (!byte_element_5378){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5378=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5378=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEDRAWOBJ_LONG_CX=NULL;
if(_SUB_IDEDRAWOBJ_LONG_CX==NULL){
@ -41,9 +41,9 @@ if(_SUB_IDEDRAWOBJ_LONG_TX==NULL){
_SUB_IDEDRAWOBJ_LONG_TX=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWOBJ_LONG_TX=0;
}
byte_element_struct *byte_element_5396=NULL;
if (!byte_element_5396){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5396=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5396=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5379=NULL;
if (!byte_element_5379){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5379=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5379=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEDRAWOBJ_LONG_SX1=NULL;
if(_SUB_IDEDRAWOBJ_LONG_SX1==NULL){
@ -60,16 +60,16 @@ if(_SUB_IDEDRAWOBJ_LONG_COLORCHAR==NULL){
_SUB_IDEDRAWOBJ_LONG_COLORCHAR=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWOBJ_LONG_COLORCHAR=0;
}
int64 fornext_value5398;
int64 fornext_finalvalue5398;
int64 fornext_step5398;
uint8 fornext_step_negative5398;
byte_element_struct *byte_element_5399=NULL;
if (!byte_element_5399){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5399=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5399=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5381;
int64 fornext_finalvalue5381;
int64 fornext_step5381;
uint8 fornext_step_negative5381;
byte_element_struct *byte_element_5382=NULL;
if (!byte_element_5382){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5382=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5382=(byte_element_struct*)mem_static_malloc(12);
}
int32 pass5400;
int32 pass5401;
int32 pass5383;
int32 pass5384;
int32 *_SUB_IDEDRAWOBJ_LONG_W=NULL;
if(_SUB_IDEDRAWOBJ_LONG_W==NULL){
_SUB_IDEDRAWOBJ_LONG_W=(int32*)mem_static_malloc(4);
@ -102,19 +102,19 @@ if(_SUB_IDEDRAWOBJ_LONG_I2==NULL){
_SUB_IDEDRAWOBJ_LONG_I2=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWOBJ_LONG_I2=0;
}
int64 fornext_value5403;
int64 fornext_finalvalue5403;
int64 fornext_step5403;
uint8 fornext_step_negative5403;
byte_element_struct *byte_element_5404=NULL;
if (!byte_element_5404){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5404=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5404=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5386;
int64 fornext_finalvalue5386;
int64 fornext_step5386;
uint8 fornext_step_negative5386;
byte_element_struct *byte_element_5387=NULL;
if (!byte_element_5387){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5387=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5387=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_SUB_IDEDRAWOBJ_STRING_A2=NULL;
if (!_SUB_IDEDRAWOBJ_STRING_A2)_SUB_IDEDRAWOBJ_STRING_A2=qbs_new(0,0);
byte_element_struct *byte_element_5405=NULL;
if (!byte_element_5405){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5405=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5405=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5388=NULL;
if (!byte_element_5388){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5388=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5388=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEDRAWOBJ_LONG_CHARACTER=NULL;
if(_SUB_IDEDRAWOBJ_LONG_CHARACTER==NULL){
@ -131,25 +131,25 @@ if(_SUB_IDEDRAWOBJ_LONG_CF==NULL){
_SUB_IDEDRAWOBJ_LONG_CF=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWOBJ_LONG_CF=0;
}
byte_element_struct *byte_element_5407=NULL;
if (!byte_element_5407){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5407=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5407=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5390=NULL;
if (!byte_element_5390){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5390=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5390=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5409=NULL;
if (!byte_element_5409){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5409=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5409=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5392=NULL;
if (!byte_element_5392){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5392=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5392=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5410=NULL;
if (!byte_element_5410){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5410=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5410=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5393=NULL;
if (!byte_element_5393){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5393=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5393=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5413=NULL;
if (!byte_element_5413){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5413=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5413=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5396=NULL;
if (!byte_element_5396){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5396=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5396=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5415=NULL;
if (!byte_element_5415){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5415=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5415=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5398=NULL;
if (!byte_element_5398){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5398=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5398=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEDRAWOBJ_LONG_TNUM=NULL;
if(_SUB_IDEDRAWOBJ_LONG_TNUM==NULL){
@ -166,20 +166,20 @@ if(_SUB_IDEDRAWOBJ_LONG_Q==NULL){
_SUB_IDEDRAWOBJ_LONG_Q=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWOBJ_LONG_Q=0;
}
int32 pass5419;
int32 pass5420;
int32 pass5402;
int32 pass5403;
int32 *_SUB_IDEDRAWOBJ_LONG_C=NULL;
if(_SUB_IDEDRAWOBJ_LONG_C==NULL){
_SUB_IDEDRAWOBJ_LONG_C=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWOBJ_LONG_C=0;
}
int64 fornext_value5422;
int64 fornext_finalvalue5422;
int64 fornext_step5422;
uint8 fornext_step_negative5422;
byte_element_struct *byte_element_5423=NULL;
if (!byte_element_5423){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5423=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5423=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5405;
int64 fornext_finalvalue5405;
int64 fornext_step5405;
uint8 fornext_step_negative5405;
byte_element_struct *byte_element_5406=NULL;
if (!byte_element_5406){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5406=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5406=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEDRAWOBJ_LONG_WHITESPACE=NULL;
if(_SUB_IDEDRAWOBJ_LONG_WHITESPACE==NULL){
@ -201,15 +201,15 @@ if(_SUB_IDEDRAWOBJ_LONG_N2==NULL){
_SUB_IDEDRAWOBJ_LONG_N2=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWOBJ_LONG_N2=0;
}
int64 fornext_value5425;
int64 fornext_finalvalue5425;
int64 fornext_step5425;
uint8 fornext_step_negative5425;
byte_element_struct *byte_element_5426=NULL;
if (!byte_element_5426){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5426=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5426=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5408;
int64 fornext_finalvalue5408;
int64 fornext_step5408;
uint8 fornext_step_negative5408;
byte_element_struct *byte_element_5409=NULL;
if (!byte_element_5409){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5409=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5409=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5427=NULL;
if (!byte_element_5427){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5427=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5427=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5410=NULL;
if (!byte_element_5410){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5410=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5410=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,11 +1,11 @@
int32 pass5433;
int32 pass5434;
int32 pass5416;
int32 pass5417;
int32 *_SUB_IDEDRAWPAR_LONG_X=NULL;
if(_SUB_IDEDRAWPAR_LONG_X==NULL){
_SUB_IDEDRAWPAR_LONG_X=(int32*)mem_static_malloc(4);
*_SUB_IDEDRAWPAR_LONG_X=0;
}
byte_element_struct *byte_element_5435=NULL;
if (!byte_element_5435){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5435=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5435=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5418=NULL;
if (!byte_element_5418){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5418=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5418=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,33 +1,33 @@
qbs *_FUNC_IDEFILEEXISTS_STRING_IDEFILEEXISTS=NULL;
if (!_FUNC_IDEFILEEXISTS_STRING_IDEFILEEXISTS)_FUNC_IDEFILEEXISTS_STRING_IDEFILEEXISTS=qbs_new(0,0);
qbs*oldstr5436=NULL;
qbs*oldstr5419=NULL;
if(_FUNC_IDEFILEEXISTS_STRING_F->tmp||_FUNC_IDEFILEEXISTS_STRING_F->fixed||_FUNC_IDEFILEEXISTS_STRING_F->readonly){
oldstr5436=_FUNC_IDEFILEEXISTS_STRING_F;
if (oldstr5436->cmem_descriptor){
_FUNC_IDEFILEEXISTS_STRING_F=qbs_new_cmem(oldstr5436->len,0);
oldstr5419=_FUNC_IDEFILEEXISTS_STRING_F;
if (oldstr5419->cmem_descriptor){
_FUNC_IDEFILEEXISTS_STRING_F=qbs_new_cmem(oldstr5419->len,0);
}else{
_FUNC_IDEFILEEXISTS_STRING_F=qbs_new(oldstr5436->len,0);
_FUNC_IDEFILEEXISTS_STRING_F=qbs_new(oldstr5419->len,0);
}
memcpy(_FUNC_IDEFILEEXISTS_STRING_F->chr,oldstr5436->chr,oldstr5436->len);
memcpy(_FUNC_IDEFILEEXISTS_STRING_F->chr,oldstr5419->chr,oldstr5419->len);
}
int32 *_FUNC_IDEFILEEXISTS_LONG_L=NULL;
if(_FUNC_IDEFILEEXISTS_LONG_L==NULL){
_FUNC_IDEFILEEXISTS_LONG_L=(int32*)mem_static_malloc(4);
*_FUNC_IDEFILEEXISTS_LONG_L=0;
}
byte_element_struct *byte_element_5437=NULL;
if (!byte_element_5437){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5437=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5437=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5420=NULL;
if (!byte_element_5420){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5420=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5420=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5439=NULL;
if (!byte_element_5439){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5439=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5439=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5422=NULL;
if (!byte_element_5422){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5422=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5422=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEFILEEXISTS_STRING_M=NULL;
if (!_FUNC_IDEFILEEXISTS_STRING_M)_FUNC_IDEFILEEXISTS_STRING_M=qbs_new(0,0);
byte_element_struct *byte_element_5440=NULL;
if (!byte_element_5440){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5440=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5440=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5423=NULL;
if (!byte_element_5423){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5423=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5423=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEFILEEXISTS_LONG_RESULT=NULL;
if(_FUNC_IDEFILEEXISTS_LONG_RESULT==NULL){

View file

@ -58,38 +58,38 @@ if(_FUNC_IDEFIND_LONG_X==NULL){
_FUNC_IDEFIND_LONG_X=(int32*)mem_static_malloc(4);
*_FUNC_IDEFIND_LONG_X=0;
}
int64 fornext_value5442;
int64 fornext_finalvalue5442;
int64 fornext_step5442;
uint8 fornext_step_negative5442;
byte_element_struct *byte_element_5443=NULL;
if (!byte_element_5443){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5443=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5443=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5425;
int64 fornext_finalvalue5425;
int64 fornext_step5425;
uint8 fornext_step_negative5425;
byte_element_struct *byte_element_5426=NULL;
if (!byte_element_5426){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5426=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5426=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEFIND_LONG_I=NULL;
if(_FUNC_IDEFIND_LONG_I==NULL){
_FUNC_IDEFIND_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_IDEFIND_LONG_I=0;
}
int32 pass5444;
int32 pass5445;
int32 pass5427;
int32 pass5428;
int32 *_FUNC_IDEFIND_LONG_PREVFOCUS=NULL;
if(_FUNC_IDEFIND_LONG_PREVFOCUS==NULL){
_FUNC_IDEFIND_LONG_PREVFOCUS=(int32*)mem_static_malloc(4);
*_FUNC_IDEFIND_LONG_PREVFOCUS=0;
}
byte_element_struct *byte_element_5446=NULL;
if (!byte_element_5446){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5446=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5446=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5429=NULL;
if (!byte_element_5429){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5429=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5429=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5447=NULL;
if (!byte_element_5447){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5447=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5447=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5430=NULL;
if (!byte_element_5430){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5430=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5430=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value5449;
int64 fornext_finalvalue5449;
int64 fornext_step5449;
uint8 fornext_step_negative5449;
int64 fornext_value5432;
int64 fornext_finalvalue5432;
int64 fornext_step5432;
uint8 fornext_step_negative5432;
int32 *_FUNC_IDEFIND_LONG_F=NULL;
if(_FUNC_IDEFIND_LONG_F==NULL){
_FUNC_IDEFIND_LONG_F=(int32*)mem_static_malloc(4);
@ -105,10 +105,10 @@ if(_FUNC_IDEFIND_LONG_CY==NULL){
_FUNC_IDEFIND_LONG_CY=(int32*)mem_static_malloc(4);
*_FUNC_IDEFIND_LONG_CY=0;
}
int64 fornext_value5452;
int64 fornext_finalvalue5452;
int64 fornext_step5452;
uint8 fornext_step_negative5452;
int64 fornext_value5435;
int64 fornext_finalvalue5435;
int64 fornext_step5435;
uint8 fornext_step_negative5435;
int32 *_FUNC_IDEFIND_LONG_LASTFOCUS=NULL;
if(_FUNC_IDEFIND_LONG_LASTFOCUS==NULL){
_FUNC_IDEFIND_LONG_LASTFOCUS=(int32*)mem_static_malloc(4);
@ -141,9 +141,9 @@ _FUNC_IDEFIND_LONG_OLDALT=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEFIND_STRING_ALTLETTER=NULL;
if (!_FUNC_IDEFIND_STRING_ALTLETTER)_FUNC_IDEFIND_STRING_ALTLETTER=qbs_new(0,0);
byte_element_struct *byte_element_5454=NULL;
if (!byte_element_5454){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5454=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5454=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5437=NULL;
if (!byte_element_5437){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5437=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5437=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEFIND_LONG_K=NULL;
if(_FUNC_IDEFIND_LONG_K==NULL){
@ -155,10 +155,10 @@ if(_FUNC_IDEFIND_LONG_INFO==NULL){
_FUNC_IDEFIND_LONG_INFO=(int32*)mem_static_malloc(4);
*_FUNC_IDEFIND_LONG_INFO=0;
}
int64 fornext_value5456;
int64 fornext_finalvalue5456;
int64 fornext_step5456;
uint8 fornext_step_negative5456;
int64 fornext_value5439;
int64 fornext_finalvalue5439;
int64 fornext_step5439;
uint8 fornext_step_negative5439;
int32 *_FUNC_IDEFIND_LONG_T=NULL;
if(_FUNC_IDEFIND_LONG_T==NULL){
_FUNC_IDEFIND_LONG_T=(int32*)mem_static_malloc(4);
@ -169,23 +169,23 @@ if(_FUNC_IDEFIND_LONG_FOCUSOFFSET==NULL){
_FUNC_IDEFIND_LONG_FOCUSOFFSET=(int32*)mem_static_malloc(4);
*_FUNC_IDEFIND_LONG_FOCUSOFFSET=0;
}
byte_element_struct *byte_element_5457=NULL;
if (!byte_element_5457){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5457=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5457=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5440=NULL;
if (!byte_element_5440){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5440=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5440=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEFIND_STRING_S=NULL;
if (!_FUNC_IDEFIND_STRING_S)_FUNC_IDEFIND_STRING_S=qbs_new(0,0);
int8 pass5458;
int8 pass5441;
int32 *_FUNC_IDEFIND_LONG_LN=NULL;
if(_FUNC_IDEFIND_LONG_LN==NULL){
_FUNC_IDEFIND_LONG_LN=(int32*)mem_static_malloc(4);
*_FUNC_IDEFIND_LONG_LN=0;
}
byte_element_struct *byte_element_5459=NULL;
if (!byte_element_5459){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5459=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5459=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5442=NULL;
if (!byte_element_5442){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5442=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5442=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5460=NULL;
if (!byte_element_5460){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5460=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5460=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5443=NULL;
if (!byte_element_5443){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5443=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5443=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -27,6 +27,101 @@ if(_SUB_IDEFINDAGAIN_LONG_LOOPED==NULL){
_SUB_IDEFINDAGAIN_LONG_LOOPED=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_LOOPED=0;
}
byte_element_struct *byte_element_5444=NULL;
if (!byte_element_5444){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5444=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5444=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5445=NULL;
if (!byte_element_5445){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5445=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5445=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5446=NULL;
if (!byte_element_5446){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5446=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5446=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5447=NULL;
if (!byte_element_5447){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5447=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5447=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5448=NULL;
if (!byte_element_5448){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5448=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5448=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5449=NULL;
if (!byte_element_5449){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5449=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5449=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5450=NULL;
if (!byte_element_5450){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5450=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5450=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEFINDAGAIN_LONG_X1=NULL;
if(_SUB_IDEFINDAGAIN_LONG_X1==NULL){
_SUB_IDEFINDAGAIN_LONG_X1=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_X1=0;
}
byte_element_struct *byte_element_5451=NULL;
if (!byte_element_5451){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5451=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5451=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5452=NULL;
if (!byte_element_5452){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5452=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5452=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEFINDAGAIN_LONG_X=NULL;
if(_SUB_IDEFINDAGAIN_LONG_X==NULL){
_SUB_IDEFINDAGAIN_LONG_X=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_X=0;
}
int32 *_SUB_IDEFINDAGAIN_LONG_XX=NULL;
if(_SUB_IDEFINDAGAIN_LONG_XX==NULL){
_SUB_IDEFINDAGAIN_LONG_XX=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_XX=0;
}
int64 fornext_value5454;
int64 fornext_finalvalue5454;
int64 fornext_step5454;
uint8 fornext_step_negative5454;
int32 *_SUB_IDEFINDAGAIN_LONG_XXO=NULL;
if(_SUB_IDEFINDAGAIN_LONG_XXO==NULL){
_SUB_IDEFINDAGAIN_LONG_XXO=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_XXO=0;
}
int32 *_SUB_IDEFINDAGAIN_LONG_XX2=NULL;
if(_SUB_IDEFINDAGAIN_LONG_XX2==NULL){
_SUB_IDEFINDAGAIN_LONG_XX2=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_XX2=0;
}
int64 fornext_value5456;
int64 fornext_finalvalue5456;
int64 fornext_step5456;
uint8 fornext_step_negative5456;
byte_element_struct *byte_element_5457=NULL;
if (!byte_element_5457){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5457=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5457=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5458=NULL;
if (!byte_element_5458){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5458=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5458=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEFINDAGAIN_LONG_WHOLE=NULL;
if(_SUB_IDEFINDAGAIN_LONG_WHOLE==NULL){
_SUB_IDEFINDAGAIN_LONG_WHOLE=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_WHOLE=0;
}
int32 *_SUB_IDEFINDAGAIN_LONG_C=NULL;
if(_SUB_IDEFINDAGAIN_LONG_C==NULL){
_SUB_IDEFINDAGAIN_LONG_C=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_C=0;
}
byte_element_struct *byte_element_5459=NULL;
if (!byte_element_5459){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5459=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5459=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5460=NULL;
if (!byte_element_5460){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5460=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5460=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5461=NULL;
if (!byte_element_5461){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5461=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5461=(byte_element_struct*)mem_static_malloc(12);
@ -39,98 +134,3 @@ byte_element_struct *byte_element_5463=NULL;
if (!byte_element_5463){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5463=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5463=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5464=NULL;
if (!byte_element_5464){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5464=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5464=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5465=NULL;
if (!byte_element_5465){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5465=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5465=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5466=NULL;
if (!byte_element_5466){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5466=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5466=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5467=NULL;
if (!byte_element_5467){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5467=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5467=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEFINDAGAIN_LONG_X1=NULL;
if(_SUB_IDEFINDAGAIN_LONG_X1==NULL){
_SUB_IDEFINDAGAIN_LONG_X1=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_X1=0;
}
byte_element_struct *byte_element_5468=NULL;
if (!byte_element_5468){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5468=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5468=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5469=NULL;
if (!byte_element_5469){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5469=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5469=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEFINDAGAIN_LONG_X=NULL;
if(_SUB_IDEFINDAGAIN_LONG_X==NULL){
_SUB_IDEFINDAGAIN_LONG_X=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_X=0;
}
int32 *_SUB_IDEFINDAGAIN_LONG_XX=NULL;
if(_SUB_IDEFINDAGAIN_LONG_XX==NULL){
_SUB_IDEFINDAGAIN_LONG_XX=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_XX=0;
}
int64 fornext_value5471;
int64 fornext_finalvalue5471;
int64 fornext_step5471;
uint8 fornext_step_negative5471;
int32 *_SUB_IDEFINDAGAIN_LONG_XXO=NULL;
if(_SUB_IDEFINDAGAIN_LONG_XXO==NULL){
_SUB_IDEFINDAGAIN_LONG_XXO=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_XXO=0;
}
int32 *_SUB_IDEFINDAGAIN_LONG_XX2=NULL;
if(_SUB_IDEFINDAGAIN_LONG_XX2==NULL){
_SUB_IDEFINDAGAIN_LONG_XX2=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_XX2=0;
}
int64 fornext_value5473;
int64 fornext_finalvalue5473;
int64 fornext_step5473;
uint8 fornext_step_negative5473;
byte_element_struct *byte_element_5474=NULL;
if (!byte_element_5474){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5474=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5474=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5475=NULL;
if (!byte_element_5475){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5475=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5475=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDEFINDAGAIN_LONG_WHOLE=NULL;
if(_SUB_IDEFINDAGAIN_LONG_WHOLE==NULL){
_SUB_IDEFINDAGAIN_LONG_WHOLE=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_WHOLE=0;
}
int32 *_SUB_IDEFINDAGAIN_LONG_C=NULL;
if(_SUB_IDEFINDAGAIN_LONG_C==NULL){
_SUB_IDEFINDAGAIN_LONG_C=(int32*)mem_static_malloc(4);
*_SUB_IDEFINDAGAIN_LONG_C=0;
}
byte_element_struct *byte_element_5476=NULL;
if (!byte_element_5476){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5476=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5476=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5477=NULL;
if (!byte_element_5477){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5477=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5477=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5478=NULL;
if (!byte_element_5478){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5478=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5478=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5479=NULL;
if (!byte_element_5479){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5479=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5479=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5480=NULL;
if (!byte_element_5480){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5480=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5480=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -18,10 +18,10 @@ if(_FUNC_IDEHBAR_LONG_X2==NULL){
_FUNC_IDEHBAR_LONG_X2=(int32*)mem_static_malloc(4);
*_FUNC_IDEHBAR_LONG_X2=0;
}
int64 fornext_value5484;
int64 fornext_finalvalue5484;
int64 fornext_step5484;
uint8 fornext_step_negative5484;
int64 fornext_value5467;
int64 fornext_finalvalue5467;
int64 fornext_step5467;
uint8 fornext_step_negative5467;
float *_FUNC_IDEHBAR_SINGLE_P=NULL;
if(_FUNC_IDEHBAR_SINGLE_P==NULL){
_FUNC_IDEHBAR_SINGLE_P=(float*)mem_static_malloc(4);

View file

@ -3,21 +3,21 @@ if(_FUNC_IDEHLEN_LONG_IDEHLEN==NULL){
_FUNC_IDEHLEN_LONG_IDEHLEN=(int32*)mem_static_malloc(4);
*_FUNC_IDEHLEN_LONG_IDEHLEN=0;
}
qbs*oldstr5485=NULL;
qbs*oldstr5468=NULL;
if(_FUNC_IDEHLEN_STRING_A->tmp||_FUNC_IDEHLEN_STRING_A->fixed||_FUNC_IDEHLEN_STRING_A->readonly){
oldstr5485=_FUNC_IDEHLEN_STRING_A;
if (oldstr5485->cmem_descriptor){
_FUNC_IDEHLEN_STRING_A=qbs_new_cmem(oldstr5485->len,0);
oldstr5468=_FUNC_IDEHLEN_STRING_A;
if (oldstr5468->cmem_descriptor){
_FUNC_IDEHLEN_STRING_A=qbs_new_cmem(oldstr5468->len,0);
}else{
_FUNC_IDEHLEN_STRING_A=qbs_new(oldstr5485->len,0);
_FUNC_IDEHLEN_STRING_A=qbs_new(oldstr5468->len,0);
}
memcpy(_FUNC_IDEHLEN_STRING_A->chr,oldstr5485->chr,oldstr5485->len);
memcpy(_FUNC_IDEHLEN_STRING_A->chr,oldstr5468->chr,oldstr5468->len);
}
byte_element_struct *byte_element_5486=NULL;
if (!byte_element_5486){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5486=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5486=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5469=NULL;
if (!byte_element_5469){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5469=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5469=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5487=NULL;
if (!byte_element_5487){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5487=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5487=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5470=NULL;
if (!byte_element_5470){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5470=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5470=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,25 +1,25 @@
qbs*oldstr5488=NULL;
qbs*oldstr5471=NULL;
if(_SUB_IDEHPRINT_STRING_A->tmp||_SUB_IDEHPRINT_STRING_A->fixed||_SUB_IDEHPRINT_STRING_A->readonly){
oldstr5488=_SUB_IDEHPRINT_STRING_A;
if (oldstr5488->cmem_descriptor){
_SUB_IDEHPRINT_STRING_A=qbs_new_cmem(oldstr5488->len,0);
oldstr5471=_SUB_IDEHPRINT_STRING_A;
if (oldstr5471->cmem_descriptor){
_SUB_IDEHPRINT_STRING_A=qbs_new_cmem(oldstr5471->len,0);
}else{
_SUB_IDEHPRINT_STRING_A=qbs_new(oldstr5488->len,0);
_SUB_IDEHPRINT_STRING_A=qbs_new(oldstr5471->len,0);
}
memcpy(_SUB_IDEHPRINT_STRING_A->chr,oldstr5488->chr,oldstr5488->len);
memcpy(_SUB_IDEHPRINT_STRING_A->chr,oldstr5471->chr,oldstr5471->len);
}
int32 *_SUB_IDEHPRINT_LONG_I=NULL;
if(_SUB_IDEHPRINT_LONG_I==NULL){
_SUB_IDEHPRINT_LONG_I=(int32*)mem_static_malloc(4);
*_SUB_IDEHPRINT_LONG_I=0;
}
int64 fornext_value5490;
int64 fornext_finalvalue5490;
int64 fornext_step5490;
uint8 fornext_step_negative5490;
byte_element_struct *byte_element_5491=NULL;
if (!byte_element_5491){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5491=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5491=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5473;
int64 fornext_finalvalue5473;
int64 fornext_step5473;
uint8 fornext_step_negative5473;
byte_element_struct *byte_element_5474=NULL;
if (!byte_element_5474){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5474=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5474=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_SUB_IDEHPRINT_STRING_C=NULL;
if (!_SUB_IDEHPRINT_STRING_C)_SUB_IDEHPRINT_STRING_C=qbs_new(0,0);

View file

@ -1,45 +1,45 @@
qbs*oldstr5493=NULL;
qbs*oldstr5476=NULL;
if(_SUB_IDEINSLINE_STRING_TEXT->tmp||_SUB_IDEINSLINE_STRING_TEXT->fixed||_SUB_IDEINSLINE_STRING_TEXT->readonly){
oldstr5493=_SUB_IDEINSLINE_STRING_TEXT;
if (oldstr5493->cmem_descriptor){
_SUB_IDEINSLINE_STRING_TEXT=qbs_new_cmem(oldstr5493->len,0);
oldstr5476=_SUB_IDEINSLINE_STRING_TEXT;
if (oldstr5476->cmem_descriptor){
_SUB_IDEINSLINE_STRING_TEXT=qbs_new_cmem(oldstr5476->len,0);
}else{
_SUB_IDEINSLINE_STRING_TEXT=qbs_new(oldstr5493->len,0);
_SUB_IDEINSLINE_STRING_TEXT=qbs_new(oldstr5476->len,0);
}
memcpy(_SUB_IDEINSLINE_STRING_TEXT->chr,oldstr5493->chr,oldstr5493->len);
memcpy(_SUB_IDEINSLINE_STRING_TEXT->chr,oldstr5476->chr,oldstr5476->len);
}
int32 *_SUB_IDEINSLINE_LONG_B=NULL;
if(_SUB_IDEINSLINE_LONG_B==NULL){
_SUB_IDEINSLINE_LONG_B=(int32*)mem_static_malloc(4);
*_SUB_IDEINSLINE_LONG_B=0;
}
int64 fornext_value5495;
int64 fornext_finalvalue5495;
int64 fornext_step5495;
uint8 fornext_step_negative5495;
int64 fornext_value5478;
int64 fornext_finalvalue5478;
int64 fornext_step5478;
uint8 fornext_step_negative5478;
int32 *_SUB_IDEINSLINE_LONG_Y=NULL;
if(_SUB_IDEINSLINE_LONG_Y==NULL){
_SUB_IDEINSLINE_LONG_Y=(int32*)mem_static_malloc(4);
*_SUB_IDEINSLINE_LONG_Y=0;
}
int64 fornext_value5497;
int64 fornext_finalvalue5497;
int64 fornext_step5497;
uint8 fornext_step_negative5497;
int64 fornext_value5499;
int64 fornext_finalvalue5499;
int64 fornext_step5499;
uint8 fornext_step_negative5499;
int64 fornext_value5480;
int64 fornext_finalvalue5480;
int64 fornext_step5480;
uint8 fornext_step_negative5480;
int64 fornext_value5482;
int64 fornext_finalvalue5482;
int64 fornext_step5482;
uint8 fornext_step_negative5482;
int32 *_SUB_IDEINSLINE_LONG_TEXTLEN=NULL;
if(_SUB_IDEINSLINE_LONG_TEXTLEN==NULL){
_SUB_IDEINSLINE_LONG_TEXTLEN=(int32*)mem_static_malloc(4);
*_SUB_IDEINSLINE_LONG_TEXTLEN=0;
}
byte_element_struct *byte_element_5500=NULL;
if (!byte_element_5500){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5500=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5500=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5483=NULL;
if (!byte_element_5483){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5483=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5483=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5501=NULL;
if (!byte_element_5501){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5501=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5501=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5484=NULL;
if (!byte_element_5484){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5484=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5484=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,44 +1,44 @@
qbs *_FUNC_IDEINPUTBOX_STRING_IDEINPUTBOX=NULL;
if (!_FUNC_IDEINPUTBOX_STRING_IDEINPUTBOX)_FUNC_IDEINPUTBOX_STRING_IDEINPUTBOX=qbs_new(0,0);
qbs*oldstr5502=NULL;
qbs*oldstr5485=NULL;
if(_FUNC_IDEINPUTBOX_STRING_TITLE->tmp||_FUNC_IDEINPUTBOX_STRING_TITLE->fixed||_FUNC_IDEINPUTBOX_STRING_TITLE->readonly){
oldstr5502=_FUNC_IDEINPUTBOX_STRING_TITLE;
if (oldstr5502->cmem_descriptor){
_FUNC_IDEINPUTBOX_STRING_TITLE=qbs_new_cmem(oldstr5502->len,0);
oldstr5485=_FUNC_IDEINPUTBOX_STRING_TITLE;
if (oldstr5485->cmem_descriptor){
_FUNC_IDEINPUTBOX_STRING_TITLE=qbs_new_cmem(oldstr5485->len,0);
}else{
_FUNC_IDEINPUTBOX_STRING_TITLE=qbs_new(oldstr5502->len,0);
_FUNC_IDEINPUTBOX_STRING_TITLE=qbs_new(oldstr5485->len,0);
}
memcpy(_FUNC_IDEINPUTBOX_STRING_TITLE->chr,oldstr5502->chr,oldstr5502->len);
memcpy(_FUNC_IDEINPUTBOX_STRING_TITLE->chr,oldstr5485->chr,oldstr5485->len);
}
qbs*oldstr5503=NULL;
qbs*oldstr5486=NULL;
if(_FUNC_IDEINPUTBOX_STRING_CAPTION->tmp||_FUNC_IDEINPUTBOX_STRING_CAPTION->fixed||_FUNC_IDEINPUTBOX_STRING_CAPTION->readonly){
oldstr5503=_FUNC_IDEINPUTBOX_STRING_CAPTION;
if (oldstr5503->cmem_descriptor){
_FUNC_IDEINPUTBOX_STRING_CAPTION=qbs_new_cmem(oldstr5503->len,0);
oldstr5486=_FUNC_IDEINPUTBOX_STRING_CAPTION;
if (oldstr5486->cmem_descriptor){
_FUNC_IDEINPUTBOX_STRING_CAPTION=qbs_new_cmem(oldstr5486->len,0);
}else{
_FUNC_IDEINPUTBOX_STRING_CAPTION=qbs_new(oldstr5503->len,0);
_FUNC_IDEINPUTBOX_STRING_CAPTION=qbs_new(oldstr5486->len,0);
}
memcpy(_FUNC_IDEINPUTBOX_STRING_CAPTION->chr,oldstr5503->chr,oldstr5503->len);
memcpy(_FUNC_IDEINPUTBOX_STRING_CAPTION->chr,oldstr5486->chr,oldstr5486->len);
}
qbs*oldstr5504=NULL;
qbs*oldstr5487=NULL;
if(_FUNC_IDEINPUTBOX_STRING_INITIALVALUE->tmp||_FUNC_IDEINPUTBOX_STRING_INITIALVALUE->fixed||_FUNC_IDEINPUTBOX_STRING_INITIALVALUE->readonly){
oldstr5504=_FUNC_IDEINPUTBOX_STRING_INITIALVALUE;
if (oldstr5504->cmem_descriptor){
_FUNC_IDEINPUTBOX_STRING_INITIALVALUE=qbs_new_cmem(oldstr5504->len,0);
oldstr5487=_FUNC_IDEINPUTBOX_STRING_INITIALVALUE;
if (oldstr5487->cmem_descriptor){
_FUNC_IDEINPUTBOX_STRING_INITIALVALUE=qbs_new_cmem(oldstr5487->len,0);
}else{
_FUNC_IDEINPUTBOX_STRING_INITIALVALUE=qbs_new(oldstr5504->len,0);
_FUNC_IDEINPUTBOX_STRING_INITIALVALUE=qbs_new(oldstr5487->len,0);
}
memcpy(_FUNC_IDEINPUTBOX_STRING_INITIALVALUE->chr,oldstr5504->chr,oldstr5504->len);
memcpy(_FUNC_IDEINPUTBOX_STRING_INITIALVALUE->chr,oldstr5487->chr,oldstr5487->len);
}
qbs*oldstr5505=NULL;
qbs*oldstr5488=NULL;
if(_FUNC_IDEINPUTBOX_STRING_VALIDINPUT->tmp||_FUNC_IDEINPUTBOX_STRING_VALIDINPUT->fixed||_FUNC_IDEINPUTBOX_STRING_VALIDINPUT->readonly){
oldstr5505=_FUNC_IDEINPUTBOX_STRING_VALIDINPUT;
if (oldstr5505->cmem_descriptor){
_FUNC_IDEINPUTBOX_STRING_VALIDINPUT=qbs_new_cmem(oldstr5505->len,0);
oldstr5488=_FUNC_IDEINPUTBOX_STRING_VALIDINPUT;
if (oldstr5488->cmem_descriptor){
_FUNC_IDEINPUTBOX_STRING_VALIDINPUT=qbs_new_cmem(oldstr5488->len,0);
}else{
_FUNC_IDEINPUTBOX_STRING_VALIDINPUT=qbs_new(oldstr5505->len,0);
_FUNC_IDEINPUTBOX_STRING_VALIDINPUT=qbs_new(oldstr5488->len,0);
}
memcpy(_FUNC_IDEINPUTBOX_STRING_VALIDINPUT->chr,oldstr5505->chr,oldstr5505->len);
memcpy(_FUNC_IDEINPUTBOX_STRING_VALIDINPUT->chr,oldstr5488->chr,oldstr5488->len);
}
int32 *_FUNC_IDEINPUTBOX_LONG_FOCUS=NULL;
if(_FUNC_IDEINPUTBOX_LONG_FOCUS==NULL){
@ -72,24 +72,24 @@ if(_FUNC_IDEINPUTBOX_LONG_I==NULL){
_FUNC_IDEINPUTBOX_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_IDEINPUTBOX_LONG_I=0;
}
int32 pass5506;
int32 pass5489;
int32 *_FUNC_IDEINPUTBOX_LONG_PREVFOCUS=NULL;
if(_FUNC_IDEINPUTBOX_LONG_PREVFOCUS==NULL){
_FUNC_IDEINPUTBOX_LONG_PREVFOCUS=(int32*)mem_static_malloc(4);
*_FUNC_IDEINPUTBOX_LONG_PREVFOCUS=0;
}
byte_element_struct *byte_element_5507=NULL;
if (!byte_element_5507){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5507=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5507=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5490=NULL;
if (!byte_element_5490){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5490=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5490=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5508=NULL;
if (!byte_element_5508){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5508=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5508=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5491=NULL;
if (!byte_element_5491){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5491=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5491=(byte_element_struct*)mem_static_malloc(12);
}
int64 fornext_value5510;
int64 fornext_finalvalue5510;
int64 fornext_step5510;
uint8 fornext_step_negative5510;
int64 fornext_value5493;
int64 fornext_finalvalue5493;
int64 fornext_step5493;
uint8 fornext_step_negative5493;
int32 *_FUNC_IDEINPUTBOX_LONG_F=NULL;
if(_FUNC_IDEINPUTBOX_LONG_F==NULL){
_FUNC_IDEINPUTBOX_LONG_F=(int32*)mem_static_malloc(4);
@ -105,10 +105,10 @@ if(_FUNC_IDEINPUTBOX_LONG_CY==NULL){
_FUNC_IDEINPUTBOX_LONG_CY=(int32*)mem_static_malloc(4);
*_FUNC_IDEINPUTBOX_LONG_CY=0;
}
int64 fornext_value5513;
int64 fornext_finalvalue5513;
int64 fornext_step5513;
uint8 fornext_step_negative5513;
int64 fornext_value5496;
int64 fornext_finalvalue5496;
int64 fornext_step5496;
uint8 fornext_step_negative5496;
int32 *_FUNC_IDEINPUTBOX_LONG_LASTFOCUS=NULL;
if(_FUNC_IDEINPUTBOX_LONG_LASTFOCUS==NULL){
_FUNC_IDEINPUTBOX_LONG_LASTFOCUS=(int32*)mem_static_malloc(4);
@ -141,9 +141,9 @@ _FUNC_IDEINPUTBOX_LONG_OLDALT=(int32*)mem_static_malloc(4);
}
qbs *_FUNC_IDEINPUTBOX_STRING_ALTLETTER=NULL;
if (!_FUNC_IDEINPUTBOX_STRING_ALTLETTER)_FUNC_IDEINPUTBOX_STRING_ALTLETTER=qbs_new(0,0);
byte_element_struct *byte_element_5515=NULL;
if (!byte_element_5515){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5515=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5515=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5498=NULL;
if (!byte_element_5498){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5498=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5498=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_FUNC_IDEINPUTBOX_LONG_K=NULL;
if(_FUNC_IDEINPUTBOX_LONG_K==NULL){
@ -155,10 +155,10 @@ if(_FUNC_IDEINPUTBOX_LONG_INFO==NULL){
_FUNC_IDEINPUTBOX_LONG_INFO=(int32*)mem_static_malloc(4);
*_FUNC_IDEINPUTBOX_LONG_INFO=0;
}
int64 fornext_value5517;
int64 fornext_finalvalue5517;
int64 fornext_step5517;
uint8 fornext_step_negative5517;
int64 fornext_value5500;
int64 fornext_finalvalue5500;
int64 fornext_step5500;
uint8 fornext_step_negative5500;
int32 *_FUNC_IDEINPUTBOX_LONG_T=NULL;
if(_FUNC_IDEINPUTBOX_LONG_T==NULL){
_FUNC_IDEINPUTBOX_LONG_T=(int32*)mem_static_malloc(4);
@ -169,23 +169,23 @@ if(_FUNC_IDEINPUTBOX_LONG_FOCUSOFFSET==NULL){
_FUNC_IDEINPUTBOX_LONG_FOCUSOFFSET=(int32*)mem_static_malloc(4);
*_FUNC_IDEINPUTBOX_LONG_FOCUSOFFSET=0;
}
byte_element_struct *byte_element_5518=NULL;
if (!byte_element_5518){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5518=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5518=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5501=NULL;
if (!byte_element_5501){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5501=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5501=(byte_element_struct*)mem_static_malloc(12);
}
byte_element_struct *byte_element_5519=NULL;
if (!byte_element_5519){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5519=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5519=(byte_element_struct*)mem_static_malloc(12);
byte_element_struct *byte_element_5502=NULL;
if (!byte_element_5502){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5502=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5502=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_FUNC_IDEINPUTBOX_STRING_A=NULL;
if (!_FUNC_IDEINPUTBOX_STRING_A)_FUNC_IDEINPUTBOX_STRING_A=qbs_new(0,0);
qbs *_FUNC_IDEINPUTBOX_STRING_TEMPA=NULL;
if (!_FUNC_IDEINPUTBOX_STRING_TEMPA)_FUNC_IDEINPUTBOX_STRING_TEMPA=qbs_new(0,0);
int64 fornext_value5521;
int64 fornext_finalvalue5521;
int64 fornext_step5521;
uint8 fornext_step_negative5521;
byte_element_struct *byte_element_5522=NULL;
if (!byte_element_5522){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5522=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5522=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5504;
int64 fornext_finalvalue5504;
int64 fornext_step5504;
uint8 fornext_step_negative5504;
byte_element_struct *byte_element_5505=NULL;
if (!byte_element_5505){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5505=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5505=(byte_element_struct*)mem_static_malloc(12);
}

View file

@ -1,12 +1,12 @@
qbs*oldstr5523=NULL;
qbs*oldstr5506=NULL;
if(_SUB_IDENEWSF_STRING_SF->tmp||_SUB_IDENEWSF_STRING_SF->fixed||_SUB_IDENEWSF_STRING_SF->readonly){
oldstr5523=_SUB_IDENEWSF_STRING_SF;
if (oldstr5523->cmem_descriptor){
_SUB_IDENEWSF_STRING_SF=qbs_new_cmem(oldstr5523->len,0);
oldstr5506=_SUB_IDENEWSF_STRING_SF;
if (oldstr5506->cmem_descriptor){
_SUB_IDENEWSF_STRING_SF=qbs_new_cmem(oldstr5506->len,0);
}else{
_SUB_IDENEWSF_STRING_SF=qbs_new(oldstr5523->len,0);
_SUB_IDENEWSF_STRING_SF=qbs_new(oldstr5506->len,0);
}
memcpy(_SUB_IDENEWSF_STRING_SF->chr,oldstr5523->chr,oldstr5523->len);
memcpy(_SUB_IDENEWSF_STRING_SF->chr,oldstr5506->chr,oldstr5506->len);
}
qbs *_SUB_IDENEWSF_STRING_A=NULL;
if (!_SUB_IDENEWSF_STRING_A)_SUB_IDENEWSF_STRING_A=qbs_new(0,0);
@ -27,22 +27,22 @@ if(_SUB_IDENEWSF_LONG_X==NULL){
_SUB_IDENEWSF_LONG_X=(int32*)mem_static_malloc(4);
*_SUB_IDENEWSF_LONG_X=0;
}
int64 fornext_value5525;
int64 fornext_finalvalue5525;
int64 fornext_step5525;
uint8 fornext_step_negative5525;
byte_element_struct *byte_element_5526=NULL;
if (!byte_element_5526){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5526=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5526=(byte_element_struct*)mem_static_malloc(12);
int64 fornext_value5508;
int64 fornext_finalvalue5508;
int64 fornext_step5508;
uint8 fornext_step_negative5508;
byte_element_struct *byte_element_5509=NULL;
if (!byte_element_5509){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5509=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5509=(byte_element_struct*)mem_static_malloc(12);
}
qbs *_SUB_IDENEWSF_STRING_NEWSF=NULL;
if (!_SUB_IDENEWSF_STRING_NEWSF)_SUB_IDENEWSF_STRING_NEWSF=qbs_new(0,0);
int32 pass5527;
int32 pass5528;
int32 pass5529;
byte_element_struct *byte_element_5530=NULL;
if (!byte_element_5530){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5530=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5530=(byte_element_struct*)mem_static_malloc(12);
int32 pass5510;
int32 pass5511;
int32 pass5512;
byte_element_struct *byte_element_5513=NULL;
if (!byte_element_5513){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_5513=(byte_element_struct*)(mem_static_pointer-12); else byte_element_5513=(byte_element_struct*)mem_static_malloc(12);
}
int32 *_SUB_IDENEWSF_LONG_Y=NULL;
if(_SUB_IDENEWSF_LONG_Y==NULL){

Some files were not shown because too many files have changed in this diff Show more