def test_real(self):
KSP.set_compiled(True)
x = kArrReal()
x.append(2.0)
self.assertEqual(Output().pop(), '?kArrReal0[0] := 2.0')
self.assertEqual(x[0].val, '?kArrReal0[0]')
self.assertEqual(x._get_compiled(), '?kArrReal0')
x.append(3.0)
self.assertEqual(Output().pop(), '?kArrReal0[1] := 3.0')
self.assertEqual(x[1].val, '?kArrReal0[1]')
self.assertEqual(x._get_runtime(), [2.0, 3.0])
self.assertEqual(x._generate_init(), ['declare ?kArrReal0[2]'])
y = kArrReal([1.0, 2.0, 3.0])
y.append(4.0)
self.assertEqual(Output().pop(), '?kArrReal1[3] := 4.0')
self.assertEqual(y._get_runtime(), [1.0, 2.0, 3.0, 4.0])
self.assertEqual(y._generate_init(),
['declare ?kArrReal1[4] := (1.0, 2.0, 3.0)'])
IName.set_compact(True)
z = kArrReal([1.0, 2.0], 'z')
self.assertEqual(z.name(), '?z3yxf')
self.assertEqual(z[1].val, '?z3yxf[1]')
self.assertEqual(z[1]._get_runtime(), 2.0)
z.read()
self.assertEqual(Output().pop(), 'read_persistent_var(?z3yxf)')
self.assertEqual(
z._generate_init(),
['declare ?z3yxf[2] := (1.0, 2.0)', 'make_persistent(?z3yxf)'])
preserved = kArrReal(name='preserved', preserve=True)
self.assertEqual(preserved.name(), '?preserved')
def test_func(self):
x = self.MyFunc('my_func',
args=OrderedDict(arg1=int, arg2=BuiltInIntVar))
self.assertEqual(x.id, 0)
bi = BuiltInIntVar('BI', def_val=1)
val = x(2, bi)
self.assertEqual(val._get_compiled(), 'my_func(2, $BI)')
self.assertEqual(val._get_runtime(), 3)
val = x(val, bi)
self.assertEqual(val._get_compiled(), 'my_func(my_func(2, $BI), $BI)')
self.assertEqual(val._get_runtime(), 4)
y = self.MyFuncInt('y_func',
args=OrderedDict(arg1=int, arg2=BuiltInIntVar))
self.assertEqual(y.id, 2)
val = y(x(1, bi), bi)
self.assertEqual(val._get_compiled(), 'y_func(my_func(1, $BI), $BI)')
self.assertEqual(val._get_runtime(), 3)
KSP.set_compiled(True)
self.assertEqual((y(1, bi) + x(2, bi)).expand(),
'y_func(1, $BI) + my_func(2, $BI)')
Output().refresh()
y(1, bi)
self.assertEqual(Output().get()[-1], 'y_func(1, $BI)')
Output().refresh()
y(x(1, bi), bi)
self.assertEqual(unpack_lines(Output().get()),
'y_func(my_func(1, $BI), $BI)')
def test_arrays(self):
KSP.set_compiled(True)
stack = Stack('test',
kArrInt,
10)
arr = kArrInt([1, 2, 3, 4, 5])
returned = stack.push(arr)[0]
self.assertIsInstance(returned, StackFrameArray)
self.assertEqual(
returned[1].val,
'%_stack_test_arr[1 + (0 + ' +
'%_stack_test_idx[$_stack_test_pointer])]')
idx = kInt(4)
self.assertEqual(
returned[idx].val,
'%_stack_test_arr[$kInt0 + (0 + ' +
'%_stack_test_idx[$_stack_test_pointer])]')
with self.assertRaises(IndexError):
returned[idx + 1].val
stack.pop()
returned = stack.push(kLoc(int, 5))[0]
self.assertIsInstance(returned, StackFrameArray)
self.assertEqual(
returned[1].val,
'%_stack_test_arr[1 + (0 + ' +
'%_stack_test_idx[$_stack_test_pointer])]')
idx = kInt(4)
self.assertEqual(returned[idx].val,
'%_stack_test_arr[$kInt1 + (0 + ' +
'%_stack_test_idx[$_stack_test_pointer])]')
with self.assertRaises(IndexError):
returned[idx + 1].val
def test_calls(self):
KSP.set_compiled(True)
self.method()
self.assertEqual(
unpack_lines(Output().get()),
call_out.format(method=Function.get_func_name(self.method)))
Output().refresh()
x = kInt(name='x')
self.method(x)
self.assertEqual(x._get_compiled(), '$x')
self.assertEqual(x._get_runtime(), 3)
self.assertEqual(
unpack_lines(Output().get()),
call_with_out.format(method=Function.get_func_name(self.method)))
Output().refresh()
self.inlined = True
self.method(x, inline=True)
self.assertEqual(unpack_lines(Output().get()), inlined_out)
Output().refresh()
arr = kArrInt([1, 2, 3, 4, 5])
@func
def foo(loc: kArg(int, 5) = arr):
with For(arr=loc) as seq:
for item in seq:
self.method(item)
foo()
# test for excluding from generation without
# "calling" it
@func
def bar(var: int):
self.method()
bar(1, inline=True)
generated_exec = KspObject.generate_all_executables()
self.maxDiff = None
self.assertEqual(
unpack_lines(generated_exec),
executables.format(method=Function.get_func_name(self.method),
foo=Function.get_func_name(foo)))
Output().refresh()
@func
def foobar(arg=kLoc(int)):
self.method(arg)
KSP.in_init(True)
foobar()
KSP.in_init(False)
self.assertEqual(unpack_lines(Output().get()), invoked_in_init)
def test_pop(self):
KSP.set_compiled(True)
stack = Stack('test',
kArrInt,
10)
with self.assertRaises(IndexError):
stack.pop()
stack.push(kLoc(int), kLoc(int, 2), kLoc(int))
stack.pop()
self.assertEqual(Output().pop(), 'dec($_stack_test_pointer)')
def runTest(self):
KSP.set_compiled(True)
x = kInt(name='x')
y = kInt(name='y')
self.assertEqual((x + y).expand(), '$x + $y')
self.assertEqual((x + y + x).expand(), '$x + $y + $x')
self.assertEqual((x + (y + x)).expand(), '$x + ($y + $x)')
self.assertEqual((x + y * x).expand(), '$x + $y * $x')
self.assertEqual(((x + y) * x).expand(), '($x + $y) * $x')
self.assertEqual((x * (y * x)).expand(), '$x * ($y * $x)')
self.assertEqual((x * x * y | y * x).expand(),
'$x * $x * $y .or. $y * $x')
self.assertEqual((x * (x * y | y * x)).expand(),
'$x * ($x * $y .or. $y * $x)')
def runTest(self):
x = kInt(2, 'x')
y = kLoc(int)
z = kLoc(int, 5)
arr = kArrInt([0] * 10, 'arr', size=10)
with self.assertRaises(TypeError):
StackFrame(1, 1, 1)
with self.assertRaises(TypeError):
StackFrame(x, (y, 1), z)
KSP.set_compiled(True)
frame = StackFrame(arr, (x, y), kInt(2, 'idx', is_local=True))
x, y = frame.vars
self.assertEqual(x._get_compiled(), '%arr[0 + $idx]')
self.assertEqual(x._get_runtime(), 2)
self.assertEqual(y._get_compiled(), '%arr[1 + $idx]')
self.assertEqual(y._get_runtime(), 0)
def test_compiled(self):
KSP.set_compiled(True)
x = kInt(1, 'x')
y = kInt(2, 'y')
with If((x < y) | (x == 1)):
check()
x <<= y
with If(y == 2):
check()
y += 1
with Else((x == 1) & (y == 2)):
check()
y += 1
with Else():
check()
x -= 1
self.assertEqual(unpack_lines(Output().get()), if_lines)
def runTest(self):
KSP.set_compiled(True)
arr = kArrInt([1, 2, 3, 4, 5])
f_arr = StackFrameArray(arr, 2, 5)
idx = kInt(2)
self.assertEqual(f_arr[idx].val, '%kArrInt0[$kInt0 + 2]')
self.assertEqual(f_arr[idx]._get_runtime(), 5)
f_arr[idx] <<= 3
self.assertEqual(f_arr[idx].val, '%kArrInt0[$kInt0 + 2]')
self.assertEqual(f_arr[idx]._get_runtime(), 3)
with For(arr=f_arr) as s:
for idx, i in enumerate(s):
self.assertEqual(
i.val,
'%kArrInt0[%_for_loop_idx[$_for_loop_curr_idx] + 2]')
for idx, val in enumerate(f_arr.iter_runtime()):
self.assertEqual(val, arr[idx + 2]._get_runtime())
def test_kVar(self):
x = kVar()
x <<= 1
self.assertEqual(x.val, 1)
arr_x = kVar(size=2)
arr_x <<= [1, 2]
self.assertIsInstance(arr_x, kArrInt)
self.assertEqual(arr_x[0].val, 1)
KSP.set_compiled(True)
y = kVar(name='y')
with self.assertRaises(AttributeError):
y.val
y <<= 'string'
self.assertIsInstance(y, kStr)
self.assertEqual(y.val, '@y')
self.assertEqual(y._get_runtime(), 'string')
z = kVar(1.0, 'z')
self.assertIsInstance(z, kReal)
self.assertEqual(z.val, '~z')
self.assertEqual(z._get_runtime(), 1.0)
IName.set_compact(True)
myvar = kVar(1)
self.assertEqual(myvar.val, '$nyxgq')
preserved = kVar(1, 'preserved', preserve=True)
self.assertEqual(preserved.val, '$preserved')
preserved.read()
self.assertEqual(Output().pop(), 'read_persistent_var($preserved)')
self.assertEqual(
preserved._generate_init(),
['declare $preserved := 1', 'make_persistent($preserved)'])
test = kVar(myvar)
self.assertEqual(test._get_runtime(), 1)
def test_int(self):
KSP.set_compiled(True)
x = kArrInt()
x.append(2)
self.assertEqual(Output().pop(), '%kArrInt0[0] := 2')
self.assertEqual(x[0].val, '%kArrInt0[0]')
self.assertEqual(x._get_compiled(), '%kArrInt0')
x.append(3)
self.assertEqual(Output().pop(), '%kArrInt0[1] := 3')
self.assertEqual(x[1].val, '%kArrInt0[1]')
self.assertEqual(x._get_runtime(), [2, 3])
self.assertEqual(x._generate_init(), ['declare %kArrInt0[2]'])
y = kArrInt([1, 2, 3])
y.append(4)
self.assertEqual(Output().pop(), '%kArrInt1[3] := 4')
self.assertEqual(y._get_runtime(), [1, 2, 3, 4])
self.assertEqual(y._generate_init(),
['declare %kArrInt1[4] := (1, 2, 3)'])
IName.set_compact(True)
z = kArrInt([1, 2], 'z')
self.assertEqual(z.name(), '%z3yxf')
self.assertEqual(z[1].val, '%z3yxf[1]')
self.assertEqual(z[1]._get_runtime(), 2)
z.read()
self.assertEqual(Output().pop(), 'read_persistent_var(%z3yxf)')
self.assertEqual(
z._generate_init(),
['declare %z3yxf[2] := (1, 2)', 'make_persistent(%z3yxf)'])
preserved = kArrInt(name='preserved', preserve=True)
self.assertEqual(preserved.name(), '%preserved')
big = list(range(0, 1000000))
big_arr = kArrInt(big)
self.assertEqual(big_arr[3]._get_runtime(), 3)
def test_str(self):
KSP.set_compiled(True)
x = kArrStr()
x.append('2')
self.assertEqual(Output().pop(), '!kArrStr0[0] := "2"')
self.assertEqual(x[0].val, '!kArrStr0[0]')
self.assertEqual(x._get_compiled(), '!kArrStr0')
x.append('3')
self.assertEqual(Output().pop(), '!kArrStr0[1] := "3"')
self.assertEqual(x[1].val, '!kArrStr0[1]')
self.assertEqual(x._get_runtime(), ['2', '3'])
self.assertEqual(x._generate_init(), ['declare !kArrStr0[2]'])
y = kArrStr(['1', '2', '3'])
y.append('4')
self.assertEqual(Output().pop(), '!kArrStr1[3] := "4"')
self.assertEqual(y._get_runtime(), ['1', '2', '3', '4'])
self.assertEqual(y._generate_init(), [
'declare !kArrStr1[4]', '!kArrStr1[0] := "1"',
'!kArrStr1[1] := "2"', '!kArrStr1[2] := "3"'
])
IName.set_compact(True)
string = kStr('string', 'str_var', preserve=True)
z = kArrStr(['1', string], 'z')
self.assertEqual(z.name(), '!z3yxf')
self.assertEqual(z[1].val, '!z3yxf[1]')
self.assertEqual(z[1]._get_runtime(), 'string')
z.read()
self.assertEqual(Output().pop(), 'read_persistent_var(!z3yxf)')
self.assertEqual(z._generate_init(), [
'declare !z3yxf[2]', '!z3yxf[0] := "1"', '!z3yxf[1] := @str_var',
'make_persistent(!z3yxf)'
])
preserved = kArrStr(name='preserved', preserve=True)
self.assertEqual(preserved.name(), '!preserved')
def test_push(self):
self.maxDiff = None
KSP.set_compiled(True)
stack = Stack('test',
kArrInt,
10)
x = kInt(1, 'x')
y = kInt(2, 'y')
arr = kArrInt([3, 4, 5])
ret_x, ret_y, ret_arr = stack.push(x, y, arr)
self.assertEqual(
ret_x._get_compiled(),
'%_stack_test_arr[0 +' +
' %_stack_test_idx[$_stack_test_pointer]]')
self.assertEqual(
ret_y._get_compiled(),
'%_stack_test_arr[1 +' +
' %_stack_test_idx[$_stack_test_pointer]]')
self.assertEqual(ret_x._get_runtime(), 1)
self.assertEqual(ret_y._get_runtime(), 2)
# print(ret_arr._get_runtime())
with For(arr=ret_arr) as s:
for idx, var in enumerate(s):
self.assertEqual(
var._get_compiled(),
'%_stack_test_arr[%_for_loop_idx[' +
f'$_for_loop_curr_idx] + (2 + ' +
'%_stack_test_idx[$_stack_test_pointer])]')
self.assertEqual(var._get_runtime(),
arr[idx]._get_runtime())
if KSP.is_compiled():
# print(unpack_lines(Output().get()))
self.assertEqual(unpack_lines(Output().get()), push_output)
Output().refresh()
stack.push(kLoc(int), kLoc(int, 3), kLoc(int))
self.assertEqual(unpack_lines(Output().get()), push_lvl2_output)
def runTest(self):
KSP.set_compiled(True)
stack = MultiStack('test', 10)
_int1 = kInt(1)
_int2 = kInt(2)
_int_arr = kArrInt([3, 4])
_str1 = kStr('1')
_str2 = kStr('2')
_str_arr = kArrStr(['3', '4'])
_real1 = kReal(1.0)
_real2 = kReal(2.0)
_real_arr = kArrReal([3.0, 4.0])
self.assertTrue(stack.is_empty())
_int1, _int2, _int_arr, _str1, _str2, _str_arr, _real1, \
_real2, _real_arr = stack.push(_int1,
_int2,
_int_arr,
_str1,
_str2,
_str_arr,
_real1,
_real2,
_real_arr)
self.assertFalse(stack.is_empty())
self.assertEqual(_int1.val,
'%_stack_test_int_arr[0 + ' +
'%_stack_test_int_idx[$_stack_test_int_pointer]]')
self.assertEqual(_int1._get_runtime(), 1)
self.assertEqual(_int2.val,
'%_stack_test_int_arr[1 + ' +
'%_stack_test_int_idx[$_stack_test_int_pointer]]')
self.assertEqual(_int2._get_runtime(), 2)
self.assertEqual(_int_arr[0].val,
'%_stack_test_int_arr[0 + (2 + ' +
'%_stack_test_int_idx[$_stack_test_int_pointer])]')
self.assertEqual(_int_arr[0]._get_runtime(), 3)
self.assertEqual(_int_arr[1].val,
'%_stack_test_int_arr[1 + (2 + ' +
'%_stack_test_int_idx[$_stack_test_int_pointer])]')
self.assertEqual(_int_arr[1]._get_runtime(), 4)
self.assertEqual(_str1.val,
'!_stack_test_str_arr[0 + ' +
'%_stack_test_str_idx[$_stack_test_str_pointer]]')
self.assertEqual(_str1._get_runtime(), '1')
self.assertEqual(_str2.val,
'!_stack_test_str_arr[1 + ' +
'%_stack_test_str_idx[$_stack_test_str_pointer]]')
self.assertEqual(_str2._get_runtime(), '2')
self.assertEqual(_str_arr[0].val,
'!_stack_test_str_arr[0 + (2 + ' +
'%_stack_test_str_idx[$_stack_test_str_pointer])]')
self.assertEqual(_str_arr[0]._get_runtime(), '3')
self.assertEqual(_str_arr[1].val,
'!_stack_test_str_arr[1 + (2 + ' +
'%_stack_test_str_idx[$_stack_test_str_pointer])]')
self.assertEqual(_str_arr[1]._get_runtime(), '4')
self.assertEqual(
_real1.val,
'?_stack_test_real_arr[0 + ' +
'%_stack_test_real_idx[$_stack_test_real_pointer]]')
self.assertEqual(_real1._get_runtime(), 1.0)
self.assertEqual(
_real2.val,
'?_stack_test_real_arr[1 + ' +
'%_stack_test_real_idx[$_stack_test_real_pointer]]')
self.assertEqual(_real2._get_runtime(), 2.0)
self.assertEqual(
_real_arr[0].val,
'?_stack_test_real_arr[0 + (2 + ' +
'%_stack_test_real_idx[$_stack_test_real_pointer])]')
self.assertEqual(_real_arr[0]._get_runtime(), 3.0)
self.assertEqual(
_real_arr[1].val,
'?_stack_test_real_arr[1 + (2 + ' +
'%_stack_test_real_idx[$_stack_test_real_pointer])]')
self.assertEqual(_real_arr[1]._get_runtime(), 4.0)
Output().refresh()
loc_int, loc_str_arr = stack.push(kLoc(int), kLoc(str, 2))
self.assertEqual(unpack_lines(Output().get()), multi_push)
with self.assertRaises(IndexError):
stack.push(kLoc(str, 5))
Output().refresh()
stack.pop()
self.assertEqual(Output().get(), [
'dec($_stack_test_int_pointer)',
'dec($_stack_test_str_pointer)'
])
Output().refresh()
stack.pop()
self.assertEqual(Output().get(), [
'dec($_stack_test_int_pointer)',
'dec($_stack_test_str_pointer)',
'dec($_stack_test_real_pointer)'
])
self.assertTrue(stack.is_empty())
def runTest(self):
self.setUp()
self.code()
self.setUp()
KSP.set_compiled(True)
self.code()
def test_message(self):
KSP.set_compiled(True)
message(3)
self.assertEqual(Output().pop(), 'message(3)')
message(2, 'string')
self.assertEqual(Output().pop(), 'message(2 & ", " & "string")')
message(2, 'string', sep=':')
with self.assertRaises(AttributeError):
message(2, 'string', sep='\n')
self.assertEqual(Output().pop(), 'message(2 & ":" & "string")')
set_controller(1, 5)
self.assertEqual(Output().pop(), 'set_controller(1, 5)')
self.assertEqual(CC[1]._get_runtime(), 5)
arr = kArrInt(sequence=list(range(11)))
self.assertEqual(arr._get_runtime(),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
get_event_ids(arr)
self.assertEqual(arr._get_runtime(), [0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0])
Output().refresh()
seq = [1, 2, 3, 4]
arr1, arr2, arr3 = kArrInt(seq), kArrInt(seq), \
kArrInt([2, 3, 4, 5])
self.assertTrue(array_equal(arr1, arr2))
self.assertEqual(Output().pop(), 'array_equal(%kArrInt1, %kArrInt2)')
self.assertFalse(array_equal(arr1, arr3)._get_runtime())
self.assertEqual(Output().pop(), 'array_equal(%kArrInt1, %kArrInt3)')
self.assertEqual(num_elements(arr1)._get_runtime(), 4)
self.assertEqual(
num_elements(arr1)._get_compiled(), 'num_elements(%kArrInt1)')
self.assertEqual(search(arr3, 4)._get_runtime(), 2)
self.assertEqual(
search(arr3, 4)._get_compiled(), 'search(%kArrInt3, 4)')
x = kInt(4, 'x')
self.assertEqual(
search(arr3, x)._get_compiled(), 'search(%kArrInt3, $x)')
self.assertEqual(search(arr3, x)._get_runtime(), 2)
arr2[1]._set_runtime(5)
self.assertEqual(arr2._get_runtime(), [1, 5, 3, 4])
sort(arr2, 0)
self.assertEqual(arr2._get_runtime(), [1, 3, 4, 5])
sort(arr2, 3)
self.assertEqual(arr2._get_runtime(), [5, 4, 3, 1])
KSP.set_compiled(False)
self.assertTrue(get_key_color(0) == KEY_COLOR_NONE.id)
set_key_color(0, KEY_COLOR_BLUE)
self.assertFalse(get_key_color(0) == KEY_COLOR_NONE.id)
self.assertTrue(get_key_color(0) == KEY_COLOR_BLUE.id)
set_key_type(3, NI_KEY_TYPE_DEFAULT)
self.assertEqual(get_key_type(3), NI_KEY_TYPE_DEFAULT.id)
KSP.set_compiled(True)
self.assertEqual(get_key_name(2)._get_runtime(), '')
set_key_name(2, 'named')
self.assertEqual(get_key_name(2)._get_runtime(), 'named')
with self.assertRaises(RuntimeError):
set_key_pressed(1, 1)
set_key_pressed_support(1)
set_key_pressed(1, 1)
self.assertEqual(get_key_triggerstate(1)._get_runtime(), 1)
self.assertEqual(
get_key_triggerstate(1).val, 'get_key_triggerstate(1)')
self.assertEqual(
get_engine_par(ENGINE_PAR_RELEASE_TRIGGER, 1, 1,
-1)._get_runtime(), 1)
self.assertEqual(
get_engine_par_disp(ENGINE_PAR_RELEASE_TRIGGER, 1, 1,
-1)._get_runtime(), 'display')
set_engine_par(ENGINE_PAR_RELEASE_TRIGGER, 50, 1, 1, -1)
self.assertEqual(
get_engine_par(ENGINE_PAR_RELEASE_TRIGGER, 1, 1,
-1)._get_runtime(), 50)
self.assertEqual(
get_engine_par_disp(ENGINE_PAR_RELEASE_TRIGGER, 1, 1,
-1)._get_runtime(), '50')
SET_CONDITION(NO_SYS_SCRIPT_RLS_TRIG)
self.assertEqual(Output().pop(),
'SET_CONDITION(NO_SYS_SCRIPT_RLS_TRIG)')
pgs_create_key('key', 2)
self.assertEqual(Output().pop(), 'pgs_create_key(key, 2)')
pgs_create_str_key('key')
self.assertEqual(Output().pop(), 'pgs_create_str_key(key)')
self.assertEqual(pgs_key_exists('key')._get_runtime(), int(1))
self.assertEqual(pgs_str_key_exists('key')._get_runtime(), int(1))
with self.assertRaises(IndexError):
pgs_set_key_val('key', 2, 1)
pgs_set_key_val('key', 1, 1)
self.assertEqual(Output().pop(), 'pgs_set_key_val(key, 1, 1)')
self.assertEqual(pgs_get_key_val('key', 1)._get_runtime(), 1)
pgs_set_str_key_val('key', 'string')
self.assertEqual(Output().pop(), 'pgs_set_str_key_val(key, "string")')
self.assertEqual(pgs_get_str_key_val('key')._get_runtime(), 'string')
def test_return(self):
KSP.set_compiled(False)
self.main()
def test_generator(self):
KSP.set_compiled(True)
self.main()
def test_simple_out(self):
KSP.set_compiled(True)
self.simple_for()
def test_step_out(self):
KSP.set_compiled(False)
self.step()
def test_start_return(self):
KSP.set_compiled(True)
self.start()
def test_start_out(self):
KSP.set_compiled(False)
self.start()
def test_folded_returns(self):
KSP.set_compiled(False)
self.folded_for()
def test_simple_returns(self):
KSP.set_compiled(False)
self.simple_for()
def test_step_return(self):
KSP.set_compiled(True)
self.step()
def test_folded_out(self):
KSP.set_compiled(True)
self.folded_for()
def _generate_code(self):
print('generating code')
refresh_all()
KSP.set_compiled(True)
KSP.in_init(True)
if self._compact:
IName.set_compact(True)
# try:
self.main()
# except AttributeError:
# raise RuntimeError(
# '''all KSP objects attemped to appear in the code
# has to be placed inside function, which is assigned
# to script main attribute''')
try:
kLog()
if kLog()._path:
KSP.in_init(False)
persistence_changed(kLog()._log_arr_pers)
KSP.in_init(True)
except TypeError as e:
if str(e).startswith('__init__()'):
pass
else:
raise e
print('getting lines of regular operations')
regular = Output().get()
print('getting inits of declared objects')
obj_init = KspObject.generate_all_inits()
print('getting inits of NativeControls params')
ctrls = KspNativeControlMeta.generate_init_code()
print('getting lines of init callback, pasted as decorated funcs')
init_cb = InitCallback.generate_body()[1:-1]
KSP.in_init(False)
print('generating other callbacks')
cbs = Callback.get_all_bodies()
print('generating functions bodies')
funcs = list()
for f in Function._functions.values():
funcs = f._generate_executable()
break
# funcs = KspObject.generate_all_executables()
out = list()
print('joining the code')
localtime = time.asctime(time.localtime(time.time()))
out.append('{ Compiled on %s }' % localtime)
out.append('on init')
if self._title:
out.append(f'set_script_title("{self._title}")')
out.extend(FuncStack()._init_lines)
out.extend(obj_init)
out.extend(ctrls)
out.extend(regular)
out.extend(init_cb)
out.append('end on')
out.extend(funcs)
out.extend(cbs)
print('wrapping long lines')
out = self._check_length(out)
KSP.set_compiled(False)
print('sucsessfully generated')
return out
