2015-08-02 12:12:44 +00:00
qbs *_FUNC_EVALUATECONST_STRING_EVALUATECONST=NULL;
if (!_FUNC_EVALUATECONST_STRING_EVALUATECONST)_FUNC_EVALUATECONST_STRING_EVALUATECONST=qbs_new(0,0);
2020-09-07 17:42:59 +00:00
qbs*oldstr3305=NULL;
2015-08-02 12:12:44 +00:00
if(_FUNC_EVALUATECONST_STRING_A2->tmp||_FUNC_EVALUATECONST_STRING_A2->fixed||_FUNC_EVALUATECONST_STRING_A2->readonly){
2020-09-07 17:42:59 +00:00
oldstr3305=_FUNC_EVALUATECONST_STRING_A2;
if (oldstr3305->cmem_descriptor){
_FUNC_EVALUATECONST_STRING_A2=qbs_new_cmem(oldstr3305->len,0);
2015-08-02 12:12:44 +00:00
}else{
2020-09-07 17:42:59 +00:00
_FUNC_EVALUATECONST_STRING_A2=qbs_new(oldstr3305->len,0);
2015-08-02 12:12:44 +00:00
}
2020-09-07 17:42:59 +00:00
memcpy(_FUNC_EVALUATECONST_STRING_A2->chr,oldstr3305->chr,oldstr3305->len);
2015-08-02 12:12:44 +00:00
}
qbs *_FUNC_EVALUATECONST_STRING_A=NULL;
if (!_FUNC_EVALUATECONST_STRING_A)_FUNC_EVALUATECONST_STRING_A=qbs_new(0,0);
ptrszint *_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK=NULL;
if (!_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK){
_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK=(ptrszint*)mem_static_malloc(9*ptrsz);
new_mem_lock();
mem_lock_tmp->type=4;
((ptrszint*)_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK)[8]=(ptrszint)mem_lock_tmp;
_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK[2]=0;
_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK[4]=2147483647;
_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK[5]=0;
_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK[6]=0;
_FUNC_EVALUATECONST_ARRAY_STRING_BLOCK[0]=(ptrszint)¬hingstring;
}
ptrszint *_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS=NULL;
if (!_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS){
_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS=(ptrszint*)mem_static_malloc(9*ptrsz);
new_mem_lock();
mem_lock_tmp->type=4;
((ptrszint*)_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS)[8]=(ptrszint)mem_lock_tmp;
_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS[2]=0;
_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS[4]=2147483647;
_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS[5]=0;
_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS[6]=0;
_FUNC_EVALUATECONST_ARRAY_INTEGER_STATUS[0]=(ptrszint)nothingvalue;
}
ptrszint *_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE=NULL;
if (!_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE){
_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE=(ptrszint*)mem_static_malloc(9*ptrsz);
new_mem_lock();
mem_lock_tmp->type=4;
((ptrszint*)_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE)[8]=(ptrszint)mem_lock_tmp;
_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE[2]=0;
_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE[4]=2147483647;
_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE[5]=0;
_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE[6]=0;
_FUNC_EVALUATECONST_ARRAY_LONG_BTYPE[0]=(ptrszint)nothingvalue;
}
int32 *_FUNC_EVALUATECONST_LONG_N=NULL;
if(_FUNC_EVALUATECONST_LONG_N==NULL){
_FUNC_EVALUATECONST_LONG_N=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_N=0;
}
int32 *_FUNC_EVALUATECONST_LONG_I=NULL;
if(_FUNC_EVALUATECONST_LONG_I==NULL){
_FUNC_EVALUATECONST_LONG_I=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_I=0;
}
2020-09-07 17:42:59 +00:00
int64 fornext_value3308;
int64 fornext_finalvalue3308;
int64 fornext_step3308;
uint8 fornext_step_negative3308;
2015-08-02 12:12:44 +00:00
int32 *_FUNC_EVALUATECONST_LONG_L=NULL;
if(_FUNC_EVALUATECONST_LONG_L==NULL){
_FUNC_EVALUATECONST_LONG_L=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_L=0;
}
int32 *_FUNC_EVALUATECONST_LONG_B=NULL;
if(_FUNC_EVALUATECONST_LONG_B==NULL){
_FUNC_EVALUATECONST_LONG_B=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_B=0;
}
2020-09-07 17:42:59 +00:00
int64 fornext_value3310;
int64 fornext_finalvalue3310;
int64 fornext_step3310;
uint8 fornext_step_negative3310;
2020-07-15 11:34:33 +00:00
qbs *_FUNC_EVALUATECONST_STRING_E=NULL;
if (!_FUNC_EVALUATECONST_STRING_E)_FUNC_EVALUATECONST_STRING_E=qbs_new(0,0);
2020-09-07 17:42:59 +00:00
int64 fornext_value3312;
int64 fornext_finalvalue3312;
int64 fornext_step3312;
uint8 fornext_step_negative3312;
byte_element_struct *byte_element_3313=NULL;
if (!byte_element_3313){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3313=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3313=(byte_element_struct*)mem_static_malloc(12);
2017-09-07 12:17:15 +00:00
}
2020-01-15 03:11:44 +00:00
int32 *_FUNC_EVALUATECONST_LONG_I2=NULL;
if(_FUNC_EVALUATECONST_LONG_I2==NULL){
_FUNC_EVALUATECONST_LONG_I2=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_I2=0;
}
2020-09-07 17:42:59 +00:00
int64 fornext_value3315;
int64 fornext_finalvalue3315;
int64 fornext_step3315;
uint8 fornext_step_negative3315;
byte_element_struct *byte_element_3316=NULL;
if (!byte_element_3316){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3316=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3316=(byte_element_struct*)mem_static_malloc(12);
2020-01-15 03:11:44 +00:00
}
2015-08-02 12:12:44 +00:00
int32 *_FUNC_EVALUATECONST_LONG_A=NULL;
if(_FUNC_EVALUATECONST_LONG_A==NULL){
_FUNC_EVALUATECONST_LONG_A=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_A=0;
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3317=NULL;
if (!byte_element_3317){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3317=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3317=(byte_element_struct*)mem_static_malloc(12);
2015-08-02 12:12:44 +00:00
}
int32 *_FUNC_EVALUATECONST_LONG_X=NULL;
if(_FUNC_EVALUATECONST_LONG_X==NULL){
_FUNC_EVALUATECONST_LONG_X=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_X=0;
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3318=NULL;
if (!byte_element_3318){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3318=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3318=(byte_element_struct*)mem_static_malloc(12);
2020-01-15 03:17:45 +00:00
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3319=NULL;
if (!byte_element_3319){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3319=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3319=(byte_element_struct*)mem_static_malloc(12);
2020-01-15 03:17:45 +00:00
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3320=NULL;
if (!byte_element_3320){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3320=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3320=(byte_element_struct*)mem_static_malloc(12);
2020-01-01 15:33:19 +00:00
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3321=NULL;
if (!byte_element_3321){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3321=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3321=(byte_element_struct*)mem_static_malloc(12);
2020-01-01 15:33:19 +00:00
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3322=NULL;
if (!byte_element_3322){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3322=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3322=(byte_element_struct*)mem_static_malloc(12);
2020-07-15 11:34:33 +00:00
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3323=NULL;
if (!byte_element_3323){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3323=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3323=(byte_element_struct*)mem_static_malloc(12);
2020-07-15 11:34:33 +00:00
}
2015-08-02 12:12:44 +00:00
int32 *_FUNC_EVALUATECONST_LONG_N2=NULL;
if(_FUNC_EVALUATECONST_LONG_N2==NULL){
_FUNC_EVALUATECONST_LONG_N2=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_N2=0;
}
2020-09-07 17:42:59 +00:00
int64 fornext_value3325;
int64 fornext_finalvalue3325;
int64 fornext_step3325;
uint8 fornext_step_negative3325;
2015-08-02 12:12:44 +00:00
qbs *_FUNC_EVALUATECONST_STRING_O=NULL;
if (!_FUNC_EVALUATECONST_STRING_O)_FUNC_EVALUATECONST_STRING_O=qbs_new(0,0);
long double *_FUNC_EVALUATECONST_FLOAT_R=NULL;
if(_FUNC_EVALUATECONST_FLOAT_R==NULL){
_FUNC_EVALUATECONST_FLOAT_R=(long double*)mem_static_malloc(32);
*_FUNC_EVALUATECONST_FLOAT_R=0;
}
int64 *_FUNC_EVALUATECONST_INTEGER64_R=NULL;
if(_FUNC_EVALUATECONST_INTEGER64_R==NULL){
_FUNC_EVALUATECONST_INTEGER64_R=(int64*)mem_static_malloc(8);
*_FUNC_EVALUATECONST_INTEGER64_R=0;
}
int32 *_FUNC_EVALUATECONST_LONG_ET=NULL;
if(_FUNC_EVALUATECONST_LONG_ET==NULL){
_FUNC_EVALUATECONST_LONG_ET=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_ET=0;
}
qbs *_FUNC_EVALUATECONST_STRING_EV=NULL;
if (!_FUNC_EVALUATECONST_STRING_EV)_FUNC_EVALUATECONST_STRING_EV=qbs_new(0,0);
qbs *_FUNC_EVALUATECONST_STRING_S1=NULL;
if (!_FUNC_EVALUATECONST_STRING_S1)_FUNC_EVALUATECONST_STRING_S1=qbs_new(0,0);
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3326=NULL;
if (!byte_element_3326){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3326=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3326=(byte_element_struct*)mem_static_malloc(12);
2015-08-02 12:12:44 +00:00
}
int32 *_FUNC_EVALUATECONST_LONG_S1SIZE=NULL;
if(_FUNC_EVALUATECONST_LONG_S1SIZE==NULL){
_FUNC_EVALUATECONST_LONG_S1SIZE=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_S1SIZE=0;
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3327=NULL;
if (!byte_element_3327){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3327=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3327=(byte_element_struct*)mem_static_malloc(12);
Pushed changes to enhance the Windows Console Experience
Window's CONSOLE support has been extended so that:
CSRLIN support added.
POS(0) support added.
LOCATE support added. (Works with optional parameters.)
COLOR support added.
SCREEN support added to get both character and color information of any point on the console.
tab() glitch fixed. (Which could cause an endless loop when printing with comma spaced text/numbers.)
_WIDTH support added.
_HEIGHT support added.
WIDTH support added, with 2 new parameters added so we can set the buffer width and buffer height also.
CLS support semi-added. (Doesn't accept colored backgrounds; it clears the screen black. I'm getting tired of working up console stuff which I probably won't ever use myself...)
SLEEP support added.
END support added so we now end with any keypress and not just enter.
_CONSOLEINPUT added, so we can tell the difference in mouse and keyboard input.
_CINP(toggle) support added, which allows us to get single character keystrokes from the console.
_CONSOLEFONT FontName, FontSize support added, which allows us to change the font and font size we use for the console.
_CONSOLECURSOR _SHOW|_HIDE, cursorsize support added, which allows us to show or hide the cursor in the console, and to change its size (from 0 to 100), as desired.
New keyboard commands added:
_CAPSLOCK -- returns 1 if caps lock is on, 0 if it isn't.
_NUMLOCK -- as above, but for num lock
_SCROLLOCK -- as above, but for scroll lock
_TOGGLE_CAPSLOCK -- toggles the caps lock state for us.
_TOGGLE_NUMLOCK -- same, but for num lock
_TOGGLE_SCROLLOCK -- same, but for scroll lock
2019-08-27 23:52:02 +00:00
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3328=NULL;
if (!byte_element_3328){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3328=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3328=(byte_element_struct*)mem_static_malloc(12);
2020-01-02 08:10:56 +00:00
}
2020-07-15 11:34:33 +00:00
qbs *_FUNC_EVALUATECONST_STRING_S2=NULL;
if (!_FUNC_EVALUATECONST_STRING_S2)_FUNC_EVALUATECONST_STRING_S2=qbs_new(0,0);
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3329=NULL;
if (!byte_element_3329){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3329=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3329=(byte_element_struct*)mem_static_malloc(12);
2020-01-02 08:10:56 +00:00
}
2020-07-15 11:34:33 +00:00
int32 *_FUNC_EVALUATECONST_LONG_S2SIZE=NULL;
if(_FUNC_EVALUATECONST_LONG_S2SIZE==NULL){
_FUNC_EVALUATECONST_LONG_S2SIZE=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_S2SIZE=0;
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3330=NULL;
if (!byte_element_3330){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3330=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3330=(byte_element_struct*)mem_static_malloc(12);
2020-07-15 11:34:33 +00:00
}
2020-09-07 17:42:59 +00:00
byte_element_struct *byte_element_3331=NULL;
if (!byte_element_3331){
if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3331=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3331=(byte_element_struct*)mem_static_malloc(12);
2020-07-15 11:34:33 +00:00
}
2020-09-07 17:42:59 +00:00
int32 pass3332;
2015-08-02 12:12:44 +00:00
int32 *_FUNC_EVALUATECONST_LONG_LINTEGER=NULL;
if(_FUNC_EVALUATECONST_LONG_LINTEGER==NULL){
_FUNC_EVALUATECONST_LONG_LINTEGER=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_LINTEGER=0;
}
long double *_FUNC_EVALUATECONST_FLOAT_L=NULL;
if(_FUNC_EVALUATECONST_FLOAT_L==NULL){
_FUNC_EVALUATECONST_FLOAT_L=(long double*)mem_static_malloc(32);
*_FUNC_EVALUATECONST_FLOAT_L=0;
}
int64 *_FUNC_EVALUATECONST_INTEGER64_L=NULL;
if(_FUNC_EVALUATECONST_INTEGER64_L==NULL){
_FUNC_EVALUATECONST_INTEGER64_L=(int64*)mem_static_malloc(8);
*_FUNC_EVALUATECONST_INTEGER64_L=0;
}
int32 *_FUNC_EVALUATECONST_LONG_RINTEGER=NULL;
if(_FUNC_EVALUATECONST_LONG_RINTEGER==NULL){
_FUNC_EVALUATECONST_LONG_RINTEGER=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_RINTEGER=0;
}
int32 *_FUNC_EVALUATECONST_LONG_U=NULL;
if(_FUNC_EVALUATECONST_LONG_U==NULL){
_FUNC_EVALUATECONST_LONG_U=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_U=0;
}
int32 *_FUNC_EVALUATECONST_LONG_LB=NULL;
if(_FUNC_EVALUATECONST_LONG_LB==NULL){
_FUNC_EVALUATECONST_LONG_LB=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_LB=0;
}
int32 *_FUNC_EVALUATECONST_LONG_RB=NULL;
if(_FUNC_EVALUATECONST_LONG_RB==NULL){
_FUNC_EVALUATECONST_LONG_RB=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_RB=0;
}
int32 *_FUNC_EVALUATECONST_LONG_OB=NULL;
if(_FUNC_EVALUATECONST_LONG_OB==NULL){
_FUNC_EVALUATECONST_LONG_OB=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_OB=0;
}
int32 *_FUNC_EVALUATECONST_LONG_LFB=NULL;
if(_FUNC_EVALUATECONST_LONG_LFB==NULL){
_FUNC_EVALUATECONST_LONG_LFB=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_LFB=0;
}
int32 *_FUNC_EVALUATECONST_LONG_RFB=NULL;
if(_FUNC_EVALUATECONST_LONG_RFB==NULL){
_FUNC_EVALUATECONST_LONG_RFB=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_RFB=0;
}
int32 *_FUNC_EVALUATECONST_LONG_LIB=NULL;
if(_FUNC_EVALUATECONST_LONG_LIB==NULL){
_FUNC_EVALUATECONST_LONG_LIB=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_LIB=0;
}
int32 *_FUNC_EVALUATECONST_LONG_RIB=NULL;
if(_FUNC_EVALUATECONST_LONG_RIB==NULL){
_FUNC_EVALUATECONST_LONG_RIB=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_RIB=0;
}
int32 *_FUNC_EVALUATECONST_LONG_F=NULL;
if(_FUNC_EVALUATECONST_LONG_F==NULL){
_FUNC_EVALUATECONST_LONG_F=(int32*)mem_static_malloc(4);
*_FUNC_EVALUATECONST_LONG_F=0;
}
