code
string | signature
string | docstring
string | loss_without_docstring
float64 | loss_with_docstring
float64 | factor
float64 |
|---|---|---|---|---|---|
expr = make_typecast(TYPE.ubyte, p[2], p.lineno(1))
p[0] = make_sentence('ON_' + p[3], expr, *p[4])
|
def p_on_goto(p)
|
statement : ON expr goto label_list
| 13.080999 | 11.270522 | 1.160638 |
p[0] = p[1]
entry = check_and_make_label(p[3], p.lineno(3))
p[1].append(entry)
|
def p_label_list_list(p)
|
label_list : label_list COMMA ID
| label_list COMMA NUMBER
| 5.602915 | 5.719975 | 0.979535 |
if not FUNCTION_LEVEL: # At less one level, otherwise, this return is from a GOSUB
p[0] = make_sentence('RETURN')
return
if FUNCTION_LEVEL[-1].kind != KIND.sub:
syntax_error(p.lineno(1), 'Syntax Error: Functions must RETURN a value, or use EXIT FUNCTION instead.')
p[0] = None
return
p[0] = make_sentence('RETURN', FUNCTION_LEVEL[-1])
|
def p_return(p)
|
statement : RETURN
| 11.921975 | 11.29665 | 1.055355 |
if not FUNCTION_LEVEL: # At less one level
syntax_error(p.lineno(1), 'Syntax Error: Returning value out of FUNCTION')
p[0] = None
return
if FUNCTION_LEVEL[-1].kind is None: # This function was not correctly declared.
p[0] = None
return
if FUNCTION_LEVEL[-1].kind != KIND.function:
syntax_error(p.lineno(1), 'Syntax Error: SUBs cannot return a value')
p[0] = None
return
if is_numeric(p[2]) and FUNCTION_LEVEL[-1].type_ == TYPE.string:
syntax_error(p.lineno(2), 'Type Error: Function must return a string, not a numeric value')
p[0] = None
return
if not is_numeric(p[2]) and FUNCTION_LEVEL[-1].type_ != TYPE.string:
syntax_error(p.lineno(2), 'Type Error: Function must return a numeric value, not a string')
p[0] = None
return
p[0] = make_sentence('RETURN', FUNCTION_LEVEL[-1],
make_typecast(FUNCTION_LEVEL[-1].type_, p[2],
p.lineno(1)))
|
def p_return_expr(p)
|
statement : RETURN expr
| 3.587158 | 3.501323 | 1.024515 |
p[0] = make_sentence('PAUSE',
make_typecast(TYPE.uinteger, p[2], p.lineno(1)))
|
def p_pause(p)
|
statement : PAUSE expr
| 18.491669 | 12.852 | 1.438816 |
i = 2 if isinstance(p[2], Symbol) or p[2] is None else 3
if p[i] is None or p[i + 2] is None:
p[0] = None
return
p[0] = make_sentence('POKE',
make_typecast(TYPE.uinteger, p[i], p.lineno(i + 1)),
make_typecast(TYPE.ubyte, p[i + 2], p.lineno(i + 1)))
|
def p_poke(p)
|
statement : POKE expr COMMA expr
| POKE LP expr COMMA expr RP
| 4.381898 | 4.023418 | 1.089098 |
i = 2 if isinstance(p[2], Symbol) or p[2] is None else 3
if p[i + 1] is None or p[i + 3] is None:
p[0] = None
return
p[0] = make_sentence('POKE',
make_typecast(TYPE.uinteger, p[i + 1], p.lineno(i + 2)),
make_typecast(p[i], p[i + 3], p.lineno(i + 3))
)
|
def p_poke2(p)
|
statement : POKE numbertype expr COMMA expr
| POKE LP numbertype expr COMMA expr RP
| 4.184278 | 3.760634 | 1.112652 |
p[0] = make_sentence('OUT',
make_typecast(TYPE.uinteger, p[2], p.lineno(3)),
make_typecast(TYPE.ubyte, p[4], p.lineno(4)))
|
def p_out(p)
|
statement : OUT expr COMMA expr
| 8.113892 | 6.494341 | 1.249379 |
p[0] = make_sentence(p[1], make_typecast(TYPE.ubyte, p[2], p.lineno(1)))
|
def p_simple_instruction(p)
|
statement : ITALIC expr
| BOLD expr
| INK expr
| PAPER expr
| BRIGHT expr
| FLASH expr
| OVER expr
| INVERSE expr
| 13.803857 | 13.618524 | 1.013609 |
if p[2].type_ != TYPE.string:
api.errmsg.syntax_error_expected_string(p.lineno(1), p[2].type_)
if len(p) == 5:
if p[3].upper() not in ('SCREEN', 'SCREEN$'):
syntax_error(p.lineno(3), 'Unexpected "%s" ID. Expected "SCREEN$" instead' % p[3])
return None
else:
# ZX Spectrum screen start + length
# This should be stored in a architecture-dependant file
start = make_number(16384, lineno=p.lineno(1))
length = make_number(6912, lineno=p.lineno(1))
else:
start = p[4]
length = p[6]
p[0] = make_sentence(p[1], p[2], start, length)
|
def p_save_code(p)
|
statement : SAVE expr CODE expr COMMA expr
| SAVE expr ID
| SAVE expr ARRAY_ID
| 6.570807 | 6.26389 | 1.048998 |
if p[2].type_ != TYPE.string:
api.errmsg.syntax_error_expected_string(p.lineno(1), p[2].type_)
if len(p) != 4:
entry = SYMBOL_TABLE.access_id(p[4], p.lineno(4))
if entry is None:
p[0] = None
return
entry.accessed = True
access = entry
start = make_unary(p.lineno(4), 'ADDRESS', access, type_=TYPE.uinteger)
if entry.class_ == CLASS.array:
length = make_number(entry.memsize, lineno=p.lineno(4))
else:
length = make_number(entry.type_.size, lineno=p.lineno(4))
else:
access = SYMBOL_TABLE.access_id('.ZXBASIC_USER_DATA', p.lineno(3))
start = make_unary(p.lineno(3), 'ADDRESS', access, type_=TYPE.uinteger)
access = SYMBOL_TABLE.access_id('.ZXBASIC_USER_DATA_LEN', p.lineno(3))
length = make_unary(p.lineno(3), 'ADDRESS', access, type_=TYPE.uinteger)
p[0] = make_sentence(p[1], p[2], start, length)
|
def p_save_data(p)
|
statement : SAVE expr DATA
| SAVE expr DATA ID
| SAVE expr DATA ID LP RP
| 4.100258 | 3.914079 | 1.047566 |
if p[2].type_ != TYPE.string:
api.errmsg.syntax_error_expected_string(p.lineno(3), p[2].type_)
if len(p) == 4:
if p[3].upper() not in ('SCREEN', 'SCREEN$', 'CODE'):
syntax_error(p.lineno(3), 'Unexpected "%s" ID. Expected "SCREEN$" instead' % p[3])
return None
else:
if p[3].upper() == 'CODE': # LOAD "..." CODE
start = make_number(0, lineno=p.lineno(3))
length = make_number(0, lineno=p.lineno(3))
else: # SCREEN$
start = make_number(16384, lineno=p.lineno(3))
length = make_number(6912, lineno=p.lineno(3))
else:
start = make_typecast(TYPE.uinteger, p[4], p.lineno(3))
if len(p) == 5:
length = make_number(0, lineno=p.lineno(3))
else:
length = make_typecast(TYPE.uinteger, p[6], p.lineno(5))
p[0] = make_sentence(p[1], p[2], start, length)
|
def p_load_code(p)
|
statement : load_or_verify expr ID
| load_or_verify expr CODE
| load_or_verify expr CODE expr
| load_or_verify expr CODE expr COMMA expr
| 3.688293 | 3.542309 | 1.041211 |
p[0] = make_binary(p.lineno(2), 'PLUS', p[1], p[3], lambda x, y: x + y)
|
def p_expr_plus_expr(p)
|
expr : expr PLUS expr
| 4.711815 | 3.787695 | 1.243979 |
p[0] = make_binary(p.lineno(2), 'MINUS', p[1], p[3], lambda x, y: x - y)
|
def p_expr_minus_expr(p)
|
expr : expr MINUS expr
| 5.100906 | 3.920805 | 1.300984 |
p[0] = make_binary(p.lineno(2), 'MUL', p[1], p[3], lambda x, y: x * y)
|
def p_expr_mul_expr(p)
|
expr : expr MUL expr
| 4.91337 | 3.746676 | 1.311394 |
p[0] = make_binary(p.lineno(2), 'DIV', p[1], p[3], lambda x, y: x / y)
|
def p_expr_div_expr(p)
|
expr : expr DIV expr
| 4.793365 | 3.647138 | 1.314281 |
p[0] = make_binary(p.lineno(2), 'MOD', p[1], p[3], lambda x, y: x % y)
|
def p_expr_mod_expr(p)
|
expr : expr MOD expr
| 4.670169 | 3.607288 | 1.294648 |
p[0] = make_binary(p.lineno(2), 'POW',
make_typecast(TYPE.float_, p[1], p.lineno(2)),
make_typecast(TYPE.float_, p[3], p.lexer.lineno),
lambda x, y: x ** y)
|
def p_expr_pow_expr(p)
|
expr : expr POW expr
| 5.001103 | 4.319982 | 1.157668 |
if p[1] is None or p[3] is None:
p[0] = None
return
if p[1].type_ in (TYPE.float_, TYPE.fixed):
p[1] = make_typecast(TYPE.ulong, p[1], p.lineno(2))
p[0] = make_binary(p.lineno(2), 'SHL', p[1],
make_typecast(TYPE.ubyte, p[3], p.lineno(2)),
lambda x, y: x << y)
|
def p_expr_shl_expr(p)
|
expr : expr SHL expr
| 3.840609 | 3.693069 | 1.039951 |
p[0] = make_binary(p.lineno(2), 'EQ', p[1], p[3], lambda x, y: x == y)
|
def p_expr_EQ_expr(p)
|
expr : expr EQ expr
| 4.409044 | 3.68931 | 1.195086 |
p[0] = make_binary(p.lineno(2), 'LT', p[1], p[3], lambda x, y: x < y)
|
def p_expr_LT_expr(p)
|
expr : expr LT expr
| 4.529357 | 3.601475 | 1.25764 |
p[0] = make_binary(p.lineno(2), 'LE', p[1], p[3], lambda x, y: x <= y)
|
def p_expr_LE_expr(p)
|
expr : expr LE expr
| 4.350905 | 3.514384 | 1.238028 |
p[0] = make_binary(p.lineno(2), 'GT', p[1], p[3], lambda x, y: x > y)
|
def p_expr_GT_expr(p)
|
expr : expr GT expr
| 4.536518 | 3.645022 | 1.244579 |
p[0] = make_binary(p.lineno(2), 'GE', p[1], p[3], lambda x, y: x >= y)
|
def p_expr_GE_expr(p)
|
expr : expr GE expr
| 4.382434 | 3.619401 | 1.210818 |
p[0] = make_binary(p.lineno(2), 'NE', p[1], p[3], lambda x, y: x != y)
|
def p_expr_NE_expr(p)
|
expr : expr NE expr
| 4.71502 | 3.767809 | 1.251396 |
p[0] = make_binary(p.lineno(2), 'OR', p[1], p[3], lambda x, y: x or y)
|
def p_expr_OR_expr(p)
|
expr : expr OR expr
| 4.483342 | 3.600883 | 1.245067 |
p[0] = make_binary(p.lineno(2), 'BOR', p[1], p[3], lambda x, y: x | y)
|
def p_expr_BOR_expr(p)
|
expr : expr BOR expr
| 4.225009 | 3.551007 | 1.189806 |
p[0] = make_binary(p.lineno(2), 'XOR', p[1], p[3], lambda x, y: (x and not y) or (not x and y))
|
def p_expr_XOR_expr(p)
|
expr : expr XOR expr
| 4.0563 | 3.537721 | 1.146586 |
p[0] = make_binary(p.lineno(2), 'BXOR', p[1], p[3], lambda x, y: x ^ y)
|
def p_expr_BXOR_expr(p)
|
expr : expr BXOR expr
| 4.400171 | 3.66864 | 1.199401 |
p[0] = make_binary(p.lineno(2), 'AND', p[1], p[3], lambda x, y: x and y)
|
def p_expr_AND_expr(p)
|
expr : expr AND expr
| 4.497256 | 3.689404 | 1.218966 |
p[0] = make_binary(p.lineno(2), 'BAND', p[1], p[3], lambda x, y: x & y)
|
def p_expr_BAND_expr(p)
|
expr : expr BAND expr
| 4.648108 | 3.894215 | 1.193593 |
p[0] = make_number(PI, lineno=p.lineno(1), type_=TYPE.float_)
|
def p_expr_PI(p)
|
bexpr : PI
| 13.398783 | 11.884665 | 1.127401 |
entry = SYMBOL_TABLE.access_var(p[1], p.lineno(1), default_type=TYPE.string)
p[0] = None
if entry is None:
return
entry.accessed = True
p[0] = make_strslice(p.lineno(1), entry, p[2][0], p[2][1])
|
def p_expr_id_substr(p)
|
string : ID substr
| 6.106311 | 6.002986 | 1.017212 |
if p[2].type_ != TYPE.string:
syntax_error(p.lexer.lineno,
"Expected a string type expression. "
"Got %s type instead" % TYPE.to_string(p[2].type_))
p[0] = None
else:
p[0] = make_strslice(p.lexer.lineno, p[2], p[4][0], p[4][1])
|
def p_string_expr_lp(p)
|
string : LP expr RP substr
| 4.432902 | 4.065531 | 1.090362 |
p[0] = (make_typecast(TYPE.uinteger, p[2], p.lineno(1)),
make_typecast(TYPE.uinteger, p[4], p.lineno(3)))
|
def p_subind_str(p)
|
substr : LP expr TO expr RP
| 5.527137 | 4.669818 | 1.183587 |
p[0] = (make_typecast(TYPE.uinteger, make_number(0, lineno=p.lineno(2)),
p.lineno(1)),
make_typecast(TYPE.uinteger, p[3], p.lineno(2)))
|
def p_subind_strTO(p)
|
substr : LP TO expr RP
| 6.882591 | 6.240368 | 1.102914 |
p[0] = (make_typecast(TYPE.uinteger,
make_number(0, lineno=p.lineno(2)),
p.lineno(1)),
make_typecast(TYPE.uinteger,
make_number(gl.MAX_STRSLICE_IDX, lineno=p.lineno(3)),
p.lineno(2)))
|
def p_subind_TO(p)
|
substr : LP TO RP
| 7.368354 | 6.798721 | 1.083785 |
entry = SYMBOL_TABLE.access_id(p[1], p.lineno(1), default_class=CLASS.var)
if entry is None:
p[0] = None
return
entry.accessed = True
if entry.type_ == TYPE.auto:
entry.type_ = _TYPE(gl.DEFAULT_TYPE)
api.errmsg.warning_implicit_type(p.lineno(1), p[1], entry.type_)
p[0] = entry
if entry.class_ == CLASS.array:
if not LET_ASSIGNMENT:
syntax_error(p.lineno(1), "Variable '%s' is an array and cannot be used in this context" % p[1])
p[0] = None
elif entry.kind == KIND.function: # Function call with 0 args
p[0] = make_call(p[1], p.lineno(1), make_arg_list(None))
elif entry.kind == KIND.sub: # Forbidden for subs
api.errmsg.syntax_error_is_a_sub_not_a_func(p.lineno(1), p[1])
p[0] = None
|
def p_id_expr(p)
|
bexpr : ID
| ARRAY_ID
| 5.204002 | 5.160819 | 1.008367 |
entry = SYMBOL_TABLE.access_id(p[2], p.lineno(2))
if entry is None:
p[0] = None
return
entry.accessed = True
result = make_unary(p.lineno(1), 'ADDRESS', entry, type_=_TYPE(gl.PTR_TYPE))
if is_dynamic(entry):
p[0] = result
else:
p[0] = make_constexpr(p.lineno(1), result)
|
def p_addr_of_id(p)
|
bexpr : ADDRESSOF ID
| ADDRESSOF ARRAY_ID
| 6.523564 | 6.542233 | 0.997146 |
# This can be a function call or a string index
p[0] = make_call(p[1], p.lineno(1), p[2])
if p[0] is None:
return
if p[0].token in ('STRSLICE', 'VAR', 'STRING'):
entry = SYMBOL_TABLE.access_call(p[1], p.lineno(1))
entry.accessed = True
return
# TODO: Check that arrays really needs kind=function to be set
# Both array accesses and functions are tagged as functions
# functions also has the class_ attribute set to 'function'
p[0].entry.set_kind(KIND.function, p.lineno(1))
p[0].entry.accessed = True
|
def p_idcall_expr(p)
|
func_call : ID arg_list %prec UMINUS
| 8.876058 | 9.246631 | 0.959923 |
# This is an array access
p[0] = make_call(p[1], p.lineno(1), p[2])
if p[0] is None:
return
entry = SYMBOL_TABLE.access_call(p[1], p.lineno(1))
entry.accessed = True
|
def p_arr_access_expr(p)
|
func_call : ARRAY_ID arg_list
| 6.008319 | 5.657715 | 1.061969 |
i = 2 if p[1].upper() == 'LET' else 1
id_ = p[i]
arg_list = p[i + 1]
substr = p[i + 2]
expr_ = p[i + 4]
p[0] = make_array_substr_assign(p.lineno(i), id_, arg_list, substr, expr_)
|
def p_let_arr_substr(p)
|
statement : LET ARRAY_ID arg_list substr EQ expr
| ARRAY_ID arg_list substr EQ expr
| 4.14689 | 3.152788 | 1.315309 |
i = 2 if p[1].upper() == 'LET' else 1
id_ = p[i]
arg_list = p[i + 2]
substr = (arg_list.children.pop().value,
make_number(gl.MAX_STRSLICE_IDX, lineno=p.lineno(i + 3)))
expr_ = p[i + 6]
p[0] = make_array_substr_assign(p.lineno(i), id_, arg_list, substr, expr_)
|
def p_let_arr_substr_in_args(p)
|
statement : LET ARRAY_ID LP arguments TO RP EQ expr
| ARRAY_ID LP arguments TO RP EQ expr
| 6.682819 | 5.961768 | 1.120946 |
i = 2 if p[1].upper() == 'LET' else 1
id_ = p[i]
arg_list = p[i + 2]
top_ = p[i + 5]
substr = (make_number(0, lineno=p.lineno(i + 4)), top_)
expr_ = p[i + 8]
p[0] = make_array_substr_assign(p.lineno(i), id_, arg_list, substr, expr_)
|
def p_let_arr_substr_in_args2(p)
|
statement : LET ARRAY_ID LP arguments COMMA TO expr RP EQ expr
| ARRAY_ID LP arguments COMMA TO expr RP EQ expr
| 5.289701 | 4.502932 | 1.174724 |
i = 2 if p[1].upper() == 'LET' else 1
id_ = p[i]
arg_list = p[i + 2]
substr = (make_number(0, lineno=p.lineno(i + 4)),
make_number(gl.MAX_STRSLICE_IDX, lineno=p.lineno(i + 3)))
expr_ = p[i + 7]
p[0] = make_array_substr_assign(p.lineno(i), id_, arg_list, substr, expr_)
|
def p_let_arr_substr_in_args3(p)
|
statement : LET ARRAY_ID LP arguments COMMA TO RP EQ expr
| ARRAY_ID LP arguments COMMA TO RP EQ expr
| 5.898282 | 5.108395 | 1.154625 |
i = 2 if p[1].upper() == 'LET' else 1
id_ = p[i]
arg_list = p[i + 2]
substr = (arg_list.children.pop().value, p[i + 4])
expr_ = p[i + 7]
p[0] = make_array_substr_assign(p.lineno(i), id_, arg_list, substr, expr_)
|
def p_let_arr_substr_in_args4(p)
|
statement : LET ARRAY_ID LP arguments TO expr RP EQ expr
| ARRAY_ID LP arguments TO expr RP EQ expr
| 4.855766 | 4.173727 | 1.163413 |
p[0] = None
if p[3] is None:
return
result = make_array_access(p[2], p.lineno(2), p[3])
if result is None:
return
result.entry.accessed = True
p[0] = make_unary(p.lineno(1), 'ADDRESS', result, type_=_TYPE(gl.PTR_TYPE))
|
def p_addr_of_array_element(p)
|
bexpr : ADDRESSOF ARRAY_ID arg_list
| 7.588006 | 7.225612 | 1.050154 |
args = make_arg_list(make_argument(p[2], p.lineno(2)))
p[0] = make_call(p[1], p.lineno(1), args)
if p[0] is None:
return
if p[0].token in ('STRSLICE', 'VAR', 'STRING'):
entry = SYMBOL_TABLE.access_call(p[1], p.lineno(1))
entry.accessed = True
return
# TODO: Check that arrays really needs kind=function to be set
# Both array accesses and functions are tagged as functions
# functions also has the class_ attribute set to 'function'
p[0].entry.set_kind(KIND.function, p.lineno(1))
p[0].entry.accessed = True
|
def p_bexpr_func(p)
|
bexpr : ID bexpr
| 8.14694 | 8.119308 | 1.003403 |
if p[1] is None or p[3] is None:
p[0] = None
else:
p[0] = make_arg_list(p[1], make_argument(p[3], p.lineno(2)))
|
def p_arguments(p)
|
arguments : arguments COMMA expr
| 3.386444 | 3.181715 | 1.064345 |
if p[1] is None:
p[0] = None
return
p[0] = p[1]
p[0].local_symbol_table = SYMBOL_TABLE.table[SYMBOL_TABLE.current_scope]
p[0].locals_size = SYMBOL_TABLE.leave_scope()
FUNCTION_LEVEL.pop()
p[0].entry.body = p[2]
entry = p[0].entry
entry.forwarded = False
|
def p_funcdecl(p)
|
function_declaration : function_header function_body
| 5.795475 | 5.014967 | 1.155636 |
if p[2] is None:
if FUNCTION_LEVEL:
FUNCTION_LEVEL.pop()
return
if p[2].entry.forwarded:
syntax_error(p.lineno(1), "duplicated declaration for function '%s'" % p[2].name)
p[2].entry.forwarded = True
SYMBOL_TABLE.leave_scope()
FUNCTION_LEVEL.pop()
|
def p_funcdeclforward(p)
|
function_declaration : DECLARE function_header_pre
| 5.587156 | 5.219336 | 1.070473 |
if p[1] is None or p[2] is None:
p[0] = None
return
forwarded = p[1].entry.forwarded
p[0] = p[1]
p[0].appendChild(p[2])
p[0].params_size = p[2].size
lineno = p.lineno(3)
previoustype_ = p[0].type_
if not p[3].implicit or p[0].entry.type_ is None or p[0].entry.type_ == TYPE.unknown:
p[0].type_ = p[3]
if p[3].implicit and p[0].entry.kind == KIND.function:
api.errmsg.warning_implicit_type(p[3].lineno, p[0].entry.name, p[0].type_)
if forwarded and previoustype_ != p[0].type_:
api.errmsg.syntax_error_func_type_mismatch(lineno, p[0].entry)
p[0] = None
return
if forwarded: # Was predeclared, check parameters match
p1 = p[0].entry.params # Param list previously declared
p2 = p[2].children
if len(p1) != len(p2):
api.errmsg.syntax_error_parameter_mismatch(lineno, p[0].entry)
p[0] = None
return
for a, b in zip(p1, p2):
if a.name != b.name:
warning(lineno, "Parameter '%s' in function '%s' has been renamed to '%s'" %
(a.name, p[0].name, b.name))
if a.type_ != b.type_ or a.byref != b.byref:
api.errmsg.syntax_error_parameter_mismatch(lineno, p[0].entry)
p[0] = None
return
p[0].entry.params = p[2]
if FUNCTION_LEVEL[-1].kind == KIND.sub and not p[3].implicit:
syntax_error(lineno, 'SUBs cannot have a return type definition')
p[0] = None
return
if FUNCTION_LEVEL[-1].kind == KIND.function:
api.check.check_type_is_explicit(p[0].lineno, p[0].entry.name, p[3])
if p[0].entry.convention == CONVENTION.fastcall and len(p[2]) > 1:
kind = 'SUB' if FUNCTION_LEVEL[-1].kind == KIND.sub else 'FUNCTION'
warning(lineno, "%s '%s' declared as FASTCALL with %i parameters" % (kind, p[0].entry.name,
len(p[2])))
|
def p_function_header_pre(p)
|
function_header_pre : function_def param_decl typedef
| 3.405586 | 3.339495 | 1.019791 |
p[0] = make_func_declaration(p[3], p.lineno(3))
SYMBOL_TABLE.enter_scope(p[3])
FUNCTION_LEVEL.append(SYMBOL_TABLE.get_entry(p[3]))
FUNCTION_LEVEL[-1].convention = p[2]
if p[0] is not None:
kind = KIND.sub if p[1] == 'SUB' else KIND.function # Must be 'function' or 'sub'
FUNCTION_LEVEL[-1].set_kind(kind, p.lineno(1))
|
def p_function_def(p)
|
function_def : FUNCTION convention ID
| SUB convention ID
| 4.992749 | 4.27156 | 1.168835 |
p[0] = p[1]
if p[0] is not None:
p[0].byref = OPTIONS.byref.value
|
def p_param_definition(p)
|
param_definition : param_def
| 6.533885 | 6.129395 | 1.065992 |
if p[2] is not None:
api.check.check_type_is_explicit(p.lineno(1), p[1], p[2])
p[0] = make_param_decl(p[1], p.lineno(1), p[2])
|
def p_param_def_type(p)
|
param_def : ID typedef
| 4.50899 | 4.165435 | 1.082477 |
if not FUNCTION_LEVEL:
syntax_error(p.lineno(3), "Unexpected token 'END %s'. No Function or Sub has been defined." % p[2])
p[0] = None
return
a = FUNCTION_LEVEL[-1].kind
if a not in (KIND.sub, KIND.function): # This function/sub was not correctly declared, so exit now
p[0] = None
return
i = 2 if p[1] == 'END' else 3
b = p[i].lower()
if a != b:
syntax_error(p.lineno(i), "Unexpected token 'END %s'. Should be 'END %s'" % (b.upper(), a.upper()))
p[0] = None
else:
p[0] = None if p[1] == 'END' else p[1]
|
def p_function_body(p)
|
function_body : program_co END FUNCTION
| program_co END SUB
| statements_co END FUNCTION
| statements_co END SUB
| co_statements_co END FUNCTION
| co_statements_co END SUB
| END FUNCTION
| END SUB
| 4.607241 | 4.333879 | 1.063076 |
# Epsilon. Defaults to float
p[0] = make_type(_TYPE(gl.DEFAULT_TYPE).name, p.lexer.lineno, implicit=True)
|
def p_type_def_empty(p)
|
typedef :
| 28.659843 | 25.763851 | 1.112405 |
if p[2].type_ == TYPE.string:
p[0] = make_builtin(p.lineno(1), 'USR_STR', p[2], type_=TYPE.uinteger)
else:
p[0] = make_builtin(p.lineno(1), 'USR',
make_typecast(TYPE.uinteger, p[2], p.lineno(1)),
type_=TYPE.uinteger)
|
def p_expr_usr(p)
|
bexpr : USR bexpr %prec UMINUS
| 4.084735 | 3.798563 | 1.075337 |
p[0] = make_builtin(p.lineno(1), 'PEEK',
make_typecast(TYPE.uinteger, p[2], p.lineno(1)),
type_=TYPE.ubyte)
|
def p_expr_peek(p)
|
bexpr : PEEK bexpr %prec UMINUS
| 11.84656 | 10.616777 | 1.115834 |
p[0] = make_builtin(p.lineno(1), 'PEEK',
make_typecast(TYPE.uinteger, p[5], p.lineno(4)),
type_=p[3])
|
def p_expr_peektype_(p)
|
bexpr : PEEK LP numbertype COMMA expr RP
| 11.902032 | 8.938004 | 1.331621 |
entry = SYMBOL_TABLE.access_array(p[3], p.lineno(3))
if entry is None:
p[0] = None
return
entry.accessed = True
if p[1] == 'LBOUND':
p[0] = make_number(entry.bounds[OPTIONS.array_base.value].lower,
p.lineno(3), TYPE.uinteger)
else:
p[0] = make_number(entry.bounds[OPTIONS.array_base.value].upper,
p.lineno(3), TYPE.uinteger)
|
def p_expr_lbound(p)
|
bexpr : LBOUND LP ARRAY_ID RP
| UBOUND LP ARRAY_ID RP
| 4.239104 | 3.919416 | 1.081565 |
entry = SYMBOL_TABLE.access_array(p[3], p.lineno(3))
if entry is None:
p[0] = None
return
entry.accessed = True
num = make_typecast(TYPE.uinteger, p[5], p.lineno(6))
if is_number(num):
if num.value == 0: # 0 => Number of dims
p[0] = make_number(len(entry.bounds), p.lineno(3), TYPE.uinteger)
return
val = num.value - 1
if val < 0 or val >= len(entry.bounds):
syntax_error(p.lineno(6), "Dimension out of range")
p[0] = None
return
if p[1] == 'LBOUND':
p[0] = make_number(entry.bounds[val].lower, p.lineno(3), TYPE.uinteger)
else:
p[0] = make_number(entry.bounds[val].upper, p.lineno(3), TYPE.uinteger)
return
if p[1] == 'LBOUND':
entry.lbound_used = True
else:
entry.ubound_used = True
p[0] = make_builtin(p.lineno(1), p[1], [entry, num], type_=TYPE.uinteger)
|
def p_expr_lbound_expr(p)
|
bexpr : LBOUND LP ARRAY_ID COMMA expr RP
| UBOUND LP ARRAY_ID COMMA expr RP
| 3.110783 | 3.066242 | 1.014526 |
arg = p[2]
if arg is None:
p[0] = None
elif isinstance(arg, symbols.VAR) and arg.class_ == CLASS.array:
p[0] = make_number(len(arg.bounds), lineno=p.lineno(1)) # Do constant folding
elif arg.type_ != TYPE.string:
api.errmsg.syntax_error_expected_string(p.lineno(1), TYPE.to_string(arg.type_))
p[0] = None
elif is_string(arg): # Constant string?
p[0] = make_number(len(arg.value), lineno=p.lineno(1)) # Do constant folding
else:
p[0] = make_builtin(p.lineno(1), 'LEN', arg, type_=TYPE.uinteger)
|
def p_len(p)
|
bexpr : LEN bexpr %prec UMINUS
| 4.991635 | 4.812018 | 1.037327 |
if TYPE.to_type(p[3].lower()) is not None:
p[0] = make_number(TYPE.size(TYPE.to_type(p[3].lower())),
lineno=p.lineno(3))
else:
entry = SYMBOL_TABLE.get_id_or_make_var(p[3], p.lineno(1))
p[0] = make_number(TYPE.size(entry.type_), lineno=p.lineno(3))
|
def p_sizeof(p)
|
bexpr : SIZEOF LP type RP
| SIZEOF LP ID RP
| SIZEOF LP ARRAY_ID RP
| 4.187574 | 4.23591 | 0.988589 |
if is_number(p[2]): # A constant is converted to string directly
p[0] = symbols.STRING(str(p[2].value), p.lineno(1))
else:
p[0] = make_builtin(p.lineno(1), 'STR',
make_typecast(TYPE.float_, p[2], p.lineno(1)),
type_=TYPE.string)
|
def p_str(p)
|
string : STR expr %prec UMINUS
| 7.638995 | 7.120584 | 1.072805 |
arg_list = make_arg_list(make_argument(p[2], p.lineno(1)))
arg_list[0].value = make_typecast(TYPE.ubyte, arg_list[0].value, p.lineno(1))
p[0] = make_builtin(p.lineno(1), 'CHR', arg_list, type_=TYPE.string)
|
def p_chr_one(p)
|
string : CHR bexpr %prec UMINUS
| 5.976623 | 5.721181 | 1.044648 |
if len(p[2]) < 1:
syntax_error(p.lineno(1), "CHR$ function need at less 1 parameter")
p[0] = None
return
for i in range(len(p[2])): # Convert every argument to 8bit unsigned
p[2][i].value = make_typecast(TYPE.ubyte, p[2][i].value, p.lineno(1))
p[0] = make_builtin(p.lineno(1), 'CHR', p[2], type_=TYPE.string)
|
def p_chr(p)
|
string : CHR arg_list
| 5.837439 | 5.422186 | 1.076584 |
def val(s):
try:
x = float(s)
except:
x = 0
warning(p.lineno(1), "Invalid string numeric constant '%s' evaluated as 0" % s)
return x
if p[2].type_ != TYPE.string:
api.errmsg.syntax_error_expected_string(p.lineno(1), TYPE.to_string(p[2].type_))
p[0] = None
else:
p[0] = make_builtin(p.lineno(1), 'VAL', p[2], lambda x: val(x), type_=TYPE.float_)
|
def p_val(p)
|
bexpr : VAL bexpr %prec UMINUS
| 6.270342 | 5.976487 | 1.049169 |
def asc(x):
if len(x):
return ord(x[0])
return 0
if p[2] is None:
p[0] = None
return
if p[2].type_ != TYPE.string:
api.errmsg.syntax_error_expected_string(p.lineno(1), TYPE.to_string(p[2].type_))
p[0] = None
else:
p[0] = make_builtin(p.lineno(1), 'CODE', p[2], lambda x: asc(x), type_=TYPE.ubyte)
|
def p_code(p)
|
bexpr : CODE bexpr %prec UMINUS
| 5.65918 | 5.551692 | 1.019361 |
sgn = lambda x: x < 0 and -1 or x > 0 and 1 or 0 # noqa
if p[2].type_ == TYPE.string:
syntax_error(p.lineno(1), "Expected a numeric expression, got TYPE.string instead")
p[0] = None
else:
if is_unsigned(p[2]) and not is_number(p[2]):
warning(p.lineno(1), "Sign of unsigned value is always 0 or 1")
p[0] = make_builtin(p.lineno(1), 'SGN', p[2], lambda x: sgn(x), type_=TYPE.byte_)
|
def p_sgn(p)
|
bexpr : SGN bexpr %prec UMINUS
| 5.600882 | 5.287463 | 1.059276 |
p[0] = make_builtin(p.lineno(1), p[1],
make_typecast(TYPE.float_, p[2], p.lineno(1)),
{'SIN': math.sin,
'COS': math.cos,
'TAN': math.tan,
'ASN': math.asin,
'ACS': math.acos,
'ATN': math.atan,
'LN': lambda y: math.log(y, math.exp(1)), # LN(x)
'EXP': math.exp,
'SQR': math.sqrt
}[p[1]])
|
def p_expr_trig(p)
|
bexpr : math_fn bexpr %prec UMINUS
| 3.772734 | 3.663732 | 1.029752 |
if is_unsigned(p[2]):
p[0] = p[2]
warning(p.lineno(1), "Redundant operation ABS for unsigned value")
return
p[0] = make_builtin(p.lineno(1), 'ABS', p[2], lambda x: x if x >= 0 else -x)
|
def p_abs(p)
|
bexpr : ABS bexpr %prec UMINUS
| 5.265609 | 4.889056 | 1.07702 |
if not is_static(lower, upper):
syntax_error(lineno, 'Array bounds must be constants')
return None
if isinstance(lower, SymbolVAR):
lower = lower.value
if isinstance(upper, SymbolVAR):
upper = upper.value
lower.value = int(lower.value)
upper.value = int(upper.value)
if lower.value < 0:
syntax_error(lineno, 'Array bounds must be greater than 0')
return None
if lower.value > upper.value:
syntax_error(lineno, 'Lower array bound must be less or equal to upper one')
return None
return SymbolBOUND(lower.value, upper.value)
|
def make_node(lower, upper, lineno)
|
Creates an array bound
| 2.849437 | 2.692198 | 1.058405 |
s = [ord(x) for x in str(number)] + [14] # Bytes of string representation in bytes
if number == int(number) and abs(number) < 65536: # integer form?
sign = 0xFF if number < 0 else 0
b = [0, sign] + self.numberLH(number) + [0]
else: # Float form
(C, ED, LH) = fp.immediate_float(number)
C = C[:2] # Remove 'h'
ED = ED[:4] # Remove 'h'
LH = LH[:4] # Remove 'h'
b = [int(C, 16)] # Convert to BASE 10
b += [int(ED[:2], 16), int(ED[2:], 16)]
b += [int(LH[:2], 16), int(LH[2:], 16)]
return s + b
|
def number(self, number)
|
Returns a floating point (or integer) number for a BASIC
program. That is: It's ASCII representation followed by 5 bytes
in floating point or integer format (if number in (-65535 + 65535)
| 4.958018 | 4.504028 | 1.100796 |
result = []
def shift(string_):
string_ = string_.strip() # Remove spaces and tabs
if not string_: # Avoid empty strings
return '', ''
i = string_.find(' ')
if i == -1:
command_ = string_
string_ = ''
else:
command_ = string_[:i]
string_ = string_[i:]
return command_, string_
command, string = shift(string)
while command != '':
result += self.token(command)
|
def parse_sentence(self, string)
|
Parses the given sentence. BASIC commands must be
types UPPERCASE and as SEEN in ZX BASIC. e.g. GO SUB for gosub, etc...
| 4.184609 | 3.903068 | 1.072133 |
result = [TOKENS[sentence[0]]]
for i in sentence[1:]: # Remaining bytes
if isinstance(i, str):
result.extend(self.literal(i))
elif isinstance(i, float) or isinstance(i, int): # A number?
result.extend(self.number(i))
else:
result.extend(i) # Must be another thing
return result
|
def sentence_bytes(self, sentence)
|
Return bytes of a sentence.
This is a very simple parser. Sentence is a list of strings and numbers.
1st element of sentence MUST match a token.
| 4.818674 | 3.954213 | 1.218617 |
if line_number is None:
line_number = self.current_line + 10
self.current_line = line_number
sep = []
result = []
for sentence in sentences:
result.extend(sep)
result.extend(self.sentence_bytes(sentence))
sep = [ord(':')]
result.extend([ENTER])
result = self.line_number(line_number) + self.numberLH(len(result)) + result
return result
|
def line(self, sentences, line_number=None)
|
Return the bytes for a basic line.
If no line number is given, current one + 10 will be used
Sentences if a list of sentences
| 4.786629 | 4.187497 | 1.143076 |
self.bytes += self.line(sentences, line_number)
|
def add_line(self, sentences, line_number=None)
|
Add current line to the output.
See self.line() for more info
| 13.230838 | 9.740096 | 1.358389 |
offset = 0
# Now we must typecast each argument to a u16 (POINTER) type
# i is the dimension ith index, b is the bound
for i, b in zip(self.arglist, self.entry.bounds):
tmp = i.children[0]
if is_number(tmp) or is_const(tmp):
if offset is not None:
offset = offset * b.count + tmp.value
else:
offset = None
break
if offset is not None:
offset = TYPE.size(gl.SIZE_TYPE) + TYPE.size(gl.BOUND_TYPE) * len(self.arglist) + offset * self.type_.size
return offset
|
def offset(self)
|
If this is a constant access (e.g. A(1))
return the offset in bytes from the beginning of the
variable in memory.
Otherwise, if it's not constant (e.g. A(i))
returns None
| 8.535506 | 8.091328 | 1.054896 |
assert isinstance(arglist, SymbolARGLIST)
variable = gl.SYMBOL_TABLE.access_array(id_, lineno)
if variable is None:
return None
if len(variable.bounds) != len(arglist):
syntax_error(lineno, "Array '%s' has %i dimensions, not %i" %
(variable.name, len(variable.bounds), len(arglist)))
return None
# Checks for array subscript range if the subscript is constant
# e.g. A(1) is a constant subscript access
for i, b in zip(arglist, variable.bounds):
btype = gl.SYMBOL_TABLE.basic_types[gl.BOUND_TYPE]
lower_bound = NUMBER(b.lower, type_=btype, lineno=lineno)
i.value = BINARY.make_node('MINUS',
TYPECAST.make_node(btype, i.value, lineno),
lower_bound, lineno, func=lambda x, y: x - y,
type_=btype)
if is_number(i.value) or is_const(i.value):
val = i.value.value
if val < 0 or val > b.count:
warning(lineno, "Array '%s' subscript out of range" % id_)
# Returns the variable entry and the node
return cls(variable, arglist, lineno)
|
def make_node(cls, id_, arglist, lineno)
|
Creates an array access. A(x1, x2, ..., xn)
| 5.521015 | 5.287175 | 1.044228 |
r';'
t.lexer.push_state('asmcomment')
t.type = 'TOKEN'
t.value = ';'
return t
|
def t_INITIAL_COMMENT(self, t)
|
r';
| 10.788827 | 9.163746 | 1.177338 |
r'\r?\n'
t.lexer.lineno += 1
t.lexer.pop_state()
return t
|
def t_prepro_define_defargs_defargsopt_defexpr_pragma_NEWLINE(self, t)
|
r'\r?\n
| 7.573233 | 4.712564 | 1.60703 |
r'[_\\]\r?\n'
t.lexer.lineno += 1
t.value = t.value[1:]
t.type = 'NEWLINE'
return t
|
def t_prepro_define_pragma_defargs_defargsopt_CONTINUE(self, t)
|
r'[_\\]\r?\n
| 8.02008 | 3.439822 | 2.331539 |
r'[_a-zA-Z][_a-zA-Z0-9]*' # preprocessor directives
t.type = reserved_directives.get(t.value.lower(), 'ID')
if t.type == 'DEFINE':
t.lexer.begin('define')
elif t.type == 'PRAGMA':
t.lexer.begin('pragma')
return t
|
def t_prepro_ID(self, t)
|
r'[_a-zA-Z][_a-zA-Z0-9]*
| 3.261953 | 3.093597 | 1.054421 |
r'\#' # Only matches if at beginning of line and "#"
if t.value == '#' and self.find_column(t) == 1:
t.lexer.push_state('prepro')
|
def t_INIIAL_sharp(self, t)
|
r'\#
| 12.955275 | 9.94838 | 1.30225 |
return '%s#line %i "%s"\n' % (prefix, self.lex.lineno, os.path.basename(self.filestack[-1][0]))
|
def put_current_line(self, prefix='')
|
Returns line and file for include / end of include sequences.
| 6.924366 | 5.376084 | 1.287994 |
if filename != STDIN and filename in [x[0] for x in self.filestack]: # Already included?
self.warning(' Recursive inclusion')
self.filestack.append([filename, 1, self.lex, self.input_data])
self.lex = lex.lex(object=self)
result = self.put_current_line() # First #line start with \n (EOL)
try:
if filename == STDIN:
self.input_data = sys.stdin.read()
else:
self.input_data = api.utils.read_txt_file(filename)
if len(self.input_data) and self.input_data[-1] != EOL:
self.input_data += EOL
except IOError:
self.input_data = EOL
self.lex.input(self.input_data)
return result
|
def include(self, filename)
|
Changes FILENAME and line count
| 4.964256 | 4.75024 | 1.045054 |
assert isinstance(entry, SymbolVAR)
self.aliased_by.append(entry)
|
def add_alias(self, entry)
|
Adds id to the current list 'aliased_by'
| 17.979586 | 9.208713 | 1.952454 |
entry.add_alias(self)
self.alias = entry
self.scope = entry.scope # Local aliases can be "global" (static)
self.byref = entry.byref
self.offset = entry.offset
self.addr = entry.addr
|
def make_alias(self, entry)
|
Make this variable an alias of another one
| 7.387589 | 6.80212 | 1.086072 |
# This can be done 'cause LABEL is just a dummy descent of VAR
assert isinstance(var_instance, SymbolVAR)
from symbols import LABEL
var_instance.__class__ = LABEL
var_instance.class_ = CLASS.label
var_instance._scope_owner = []
return var_instance
|
def to_label(var_instance)
|
Converts a var_instance to a label one
| 17.435301 | 17.378731 | 1.003255 |
assert isinstance(var_instance, SymbolVAR)
from symbols import FUNCTION
var_instance.__class__ = FUNCTION
var_instance.class_ = CLASS.function
var_instance.reset(lineno=lineno)
return var_instance
|
def to_function(var_instance, lineno=None)
|
Converts a var_instance to a function one
| 7.037368 | 7.14356 | 0.985135 |
assert isinstance(var_instance, SymbolVAR)
from symbols import BOUNDLIST
from symbols import VARARRAY
assert isinstance(bounds, BOUNDLIST)
var_instance.__class__ = VARARRAY
var_instance.class_ = CLASS.array
var_instance.bounds = bounds
return var_instance
|
def to_vararray(var_instance, bounds)
|
Converts a var_instance to a var array one
| 6.19634 | 6.352321 | 0.975445 |
output = []
oper = ins.quad[1]
indirect = (oper[0] == '*')
if indirect:
oper = oper[1:]
I = int(oper)
if I >= 0:
I += 4 # Return Address + "push IX"
output.append('push ix')
output.append('pop hl')
output.append('ld de, %i' % I)
output.append('add hl, de')
if indirect:
output.append('ld e, (hl)')
output.append('inc hl')
output.append('ld h, (hl)')
output.append('ld l, e')
output.append('push hl')
return output
|
def _paddr(ins)
|
Returns code sequence which points to
local variable or parameter (HL)
| 4.866277 | 4.831728 | 1.007151 |
output = []
indirect = offset[0] == '*'
if indirect:
offset = offset[1:]
I = int(offset)
if I >= 0: # If it is a parameter, round up to even bytes
I += 4 + (size % 2 if not indirect else 0) # Return Address + "push IX"
ix_changed = (indirect or size < 5) and (abs(I) + size) > 127 # Offset > 127 bytes. Need to change IX
if ix_changed: # more than 1 byte
output.append('push ix')
output.append('ld de, %i' % I)
output.append('add ix, de')
I = 0
elif size == 5: # For floating point numbers we always use DE as IX offset
output.append('push ix')
output.append('pop hl')
output.append('ld de, %i' % I)
output.append('add hl, de')
I = 0
if indirect:
output.append('ld h, (ix%+i)' % (I + 1))
output.append('ld l, (ix%+i)' % I)
if size == 1:
output.append('ld a, (hl)')
elif size == 2:
output.append('ld c, (hl)')
output.append('inc hl')
output.append('ld h, (hl)')
output.append('ld l, c')
elif size == 4:
output.append('call __ILOAD32')
REQUIRES.add('iload32.asm')
else: # Floating point
output.append('call __ILOADF')
REQUIRES.add('iloadf.asm')
else:
if size == 1:
output.append('ld a, (ix%+i)' % I)
else:
if size <= 4: # 16/32bit integer, low part
output.append('ld l, (ix%+i)' % I)
output.append('ld h, (ix%+i)' % (I + 1))
if size > 2: # 32 bit integer, high part
output.append('ld e, (ix%+i)' % (I + 2))
output.append('ld d, (ix%+i)' % (I + 3))
else: # Floating point
output.append('call __PLOADF')
REQUIRES.add('ploadf.asm')
if ix_changed:
output.append('pop ix')
return output
|
def _pload(offset, size)
|
Generic parameter loading.
Emmits output code for setting IX at the right location.
size = Number of bytes to load:
1 => 8 bit value
2 => 16 bit value / string
4 => 32 bit value / f16 value
5 => 40 bit value
| 3.572556 | 3.517706 | 1.015593 |
output = _pload(ins.quad[2], 4)
output.append('push de')
output.append('push hl')
return output
|
def _pload32(ins)
|
Loads from stack pointer (SP) + X, being
X 2st parameter.
1st operand must be a SIGNED integer.
2nd operand cannot be an immediate nor an address.
| 11.639693 | 17.752546 | 0.655663 |
output = _pload(ins.quad[2], 5)
output.extend(_fpush())
return output
|
def _ploadf(ins)
|
Loads from stack pointer (SP) + X, being
X 2st parameter.
1st operand must be a SIGNED integer.
| 19.983324 | 28.334488 | 0.705265 |
output = _pload(ins.quad[2], 2)
if ins.quad[1][0] != '$':
output.append('call __LOADSTR')
REQUIRES.add('loadstr.asm')
output.append('push hl')
return output
|
def _ploadstr(ins)
|
Loads from stack pointer (SP) + X, being
X 2st parameter.
1st operand must be a SIGNED integer.
2nd operand cannot be an immediate nor an address.
| 12.955679 | 16.693541 | 0.776089 |
output = _pload(ins.quad[2], 2)
if ins.quad[1][0] != '$':
output.append('call __LOADSTR')
REQUIRES.add('loadstr.asm')
return output
|
def _fploadstr(ins)
|
Loads from stack pointer (SP) + X, being
X 2st parameter.
1st operand must be a SIGNED integer.
Unlike ploadstr, this version does not push the result
back into the stack.
| 15.357583 | 19.834904 | 0.774271 |
value = ins.quad[2]
offset = ins.quad[1]
indirect = offset[0] == '*'
size = 0
if indirect:
offset = offset[1:]
size = 1
I = int(offset)
if I >= 0:
I += 4 # Return Address + "push IX"
if not indirect:
I += 1 # F flag ignored
if is_int(value):
output = []
else:
output = _8bit_oper(value)
ix_changed = not (-128 + size <= I <= 127 - size) # Offset > 127 bytes. Need to change IX
if ix_changed: # more than 1 byte
output.append('push ix')
output.append('pop hl')
output.append('ld de, %i' % I)
output.append('add hl, de')
if indirect:
if ix_changed:
output.append('ld c, (hl)')
output.append('inc hl')
output.append('ld h, (hl)')
output.append('ld l, c')
else:
output.append('ld h, (ix%+i)' % (I + 1))
output.append('ld l, (ix%+i)' % I)
if is_int(value):
output.append('ld (hl), %i' % int8(value))
else:
output.append('ld (hl), a')
return output
# direct store
if ix_changed:
if is_int(value):
output.append('ld (hl), %i' % int8(value))
else:
output.append('ld (hl), a')
return output
if is_int(value):
output.append('ld (ix%+i), %i' % (I, int8(value)))
else:
output.append('ld (ix%+i), a' % I)
return output
|
def _pstore8(ins)
|
Stores 2nd parameter at stack pointer (SP) + X, being
X 1st parameter.
1st operand must be a SIGNED integer.
| 3.777392 | 3.802476 | 0.993403 |
value = ins.quad[2]
offset = ins.quad[1]
indirect = offset[0] == '*'
size = 1
if indirect:
offset = offset[1:]
I = int(offset)
if I >= 0:
I += 4 # Return Address + "push IX"
if is_int(value):
output = []
else:
output = _16bit_oper(value)
ix_changed = not (-128 + size <= I <= 127 - size) # Offset > 127 bytes. Need to change IX
if indirect:
if is_int(value):
output.append('ld hl, %i' % int16(value))
output.append('ld bc, %i' % I)
output.append('call __PISTORE16')
REQUIRES.add('istore16.asm')
return output
# direct store
if ix_changed: # more than 1 byte
if not is_int(value):
output.append('ex de, hl')
output.append('push ix')
output.append('pop hl')
output.append('ld bc, %i' % I)
output.append('add hl, bc')
if is_int(value):
v = int16(value)
output.append('ld (hl), %i' % (v & 0xFF))
output.append('inc hl')
output.append('ld (hl), %i' % (v >> 8))
return output
else:
output.append('ld (hl), e')
output.append('inc hl')
output.append('ld (hl), d')
return output
if is_int(value):
v = int16(value)
output.append('ld (ix%+i), %i' % (I, v & 0xFF))
output.append('ld (ix%+i), %i' % (I + 1, v >> 8))
else:
output.append('ld (ix%+i), l' % I)
output.append('ld (ix%+i), h' % (I + 1))
return output
|
def _pstore16(ins)
|
Stores 2nd parameter at stack pointer (SP) + X, being
X 1st parameter.
1st operand must be a SIGNED integer.
| 3.780642 | 3.84485 | 0.9833 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.