From a7431fc21032282fd2a9f389931355a99a0e4c4c Mon Sep 17 00:00:00 2001 From: Sunil Shetye Date: Wed, 4 Jul 2018 11:31:04 +0530 Subject: add type to expressions --- sci2jsyacc.py | 267 +++++++++++++++++++++++++++++++++++----------------------- 1 file changed, 162 insertions(+), 105 deletions(-) (limited to 'sci2jsyacc.py') diff --git a/sci2jsyacc.py b/sci2jsyacc.py index 52efc3e8..ce76535f 100755 --- a/sci2jsyacc.py +++ b/sci2jsyacc.py @@ -37,6 +37,14 @@ OBJECT_TYPE = 'object' STRING_TYPE = 'string' VECTOR_TYPE = 'vector' +PARSE_MAP = { + BOOLEAN_TYPE: 'parseBoolean', + DOUBLE_TYPE: 'parseFloat', + MATRIX_TYPE: 'inverse', + NULL_TYPE: 'parseFloat', + VECTOR_TYPE: 'inverse', +} + start = 'functionblocks' JOB_BLOCKS = {} @@ -353,9 +361,9 @@ def p_forstatement_for_start_step_end(p): | FOR VAR ASSIGNMENT expression COLON expression COLON expression DO EOL''' global INDENT_LEVEL var = p[2] - lstart = p[4] - lstep = int(p[6]) - lend = p[8] + lstart = p[4][0] + lstep = int(p[6][0]) + lend = p[8][0] if lstep > 0: endop = '<=' stepop = '+=' @@ -371,9 +379,9 @@ def p_forstatement_for_start_end(p): | FOR VAR ASSIGNMENT expression COLON expression DO EOL''' global INDENT_LEVEL var = p[2] - lstart = p[4] + lstart = p[4][0] lstep = 1 - lend = p[6] + lend = p[6][0] endop = '<=' stepop = '+=' add_local_var(var) @@ -392,7 +400,7 @@ def p_forstatement_for_list(p): def p_selectstatement_select(p): 'selectstatement : SELECT expression EOL' global INDENT_LEVEL - p[0] = '%*sswitch (%s) {\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2]) + p[0] = '%*sswitch (%s) {\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2][0]) INDENT_LEVEL += 1 def p_selectjobstatement_select(p): @@ -407,7 +415,7 @@ def p_casestatement_case(p): | CASE expression EOL''' global INDENT_LEVEL INDENT_LEVEL -= 1 - p[0] = '%*scase %s:\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2]) + p[0] = '%*scase %s:\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2][0]) INDENT_LEVEL += 1 def p_casejobstatement_case_job_define(p): @@ -437,14 +445,14 @@ def p_whilestatement_while_do(p): | WHILE expression THEN EOL | WHILE expression EOL''' global INDENT_LEVEL - p[0] = '%*swhile (%s) {\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2]) + p[0] = '%*swhile (%s) {\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2][0]) INDENT_LEVEL += 1 def p_ifstatement_if_then(p): '''ifstatement : IF expression THEN EOL | IF expression EOL''' global INDENT_LEVEL - p[0] = '%*sif (%s) {\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2]) + p[0] = '%*sif (%s) {\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2][0]) INDENT_LEVEL += 1 def p_elseifstatement_elseif_then(p): @@ -452,7 +460,7 @@ def p_elseifstatement_elseif_then(p): | ELSEIF expression EOL''' global INDENT_LEVEL INDENT_LEVEL -= 1 - p[0] = '%*s} else if (%s) {\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2]) + p[0] = '%*s} else if (%s) {\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[2][0]) INDENT_LEVEL += 1 def p_elsestatement_else(p): @@ -468,7 +476,8 @@ def p_elsestatement_else(p): def p_assignment_expression(p): 'assignment : lterm ASSIGNMENT expression' - p[0] = '%*s%s = %s' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[1], p[3]) + p[0] = '%*s%s = %s' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[1], p[3][0]) + add_var_vartype(p[1], p[3][1]) def p_getvalueassignment_getvalue_arguments(p): 'getvalueassignment : lterm ASSIGNMENT SCICOS_GETVALUE OPENBRACKET getvaluearguments CLOSEBRACKET' @@ -486,8 +495,14 @@ def p_getvalueassignment_getvalue_arguments(p): basevar = var[5:] else: basevar = var - add_global_var(var, force=True) - SET_BLOCK += "%*s%s = parseFloat((arguments[%d][\"%s\"]))\n" % (2 * INDENT_SIZE, ' ', var, 0, basevar) + add_global_var(var, force=True) + vartype = VAR_TYPES.get(basevar, DOUBLE_TYPE) + parsefunction = PARSE_MAP.get(vartype, 'parseFloat') + if parsefunction != '': + parsecall = '%s((arguments[%d][\"%s\"]))' % (parsefunction, 0, basevar) + else: + parsecall = 'arguments[%d][\"%s\"]' % (0, basevar) + SET_BLOCK += "%*s%s = %s\n" % (2 * INDENT_SIZE, ' ', var, parsecall) if idx < len(LABELS): OPTIONS_BLOCK += '%*s%s:[%s,%s],\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', basevar, LABELS[idx], var) idx += 1 @@ -498,7 +513,7 @@ def p_getvaluearguments_arg1_arg2_arg3_arg4(p): def p_getvaluearg1_expression(p): 'getvaluearg1 : expression' - p[0] = '%s' % (p[1]) + p[0] = '%s' % (p[1][0]) def p_getvaluearg2_list(p): '''getvaluearg2 : OPENSQBRACKET getvaluearg2arraylist CLOSESQBRACKET @@ -544,12 +559,12 @@ def p_getvaluearg2arraylistitem_string_string(p): def p_getvaluearg2arraylistitem_functionname_parameters(p): 'getvaluearg2arraylistitem : FUNCTIONNAME OPENBRACKET list CLOSEBRACKET' - p[0] = '%s(%s)' % (p[1], p[3]) + p[0] = '%s(%s)' % (p[1], p[3][0]) LABELS.append(p[0]) def p_getvaluearg3_list(p): 'getvaluearg3 : LIST OPENBRACKET getvaluelist CLOSEBRACKET' - p[0] = '%s(%s)' % (p[1], p[3]) + p[0] = '%s(%s)' % (p[1], p[3][0]) def p_getvaluearg3_var(p): 'getvaluearg3 : VAR' @@ -557,7 +572,7 @@ def p_getvaluearg3_var(p): def p_getvaluearg4_expression(p): 'getvaluearg4 : expression' - p[0] = '%s' % (p[1]) + p[0] = '%s' % (p[1][0]) # end define assignment @@ -577,24 +592,24 @@ def p_ltermarraylist_ltermvar(p): def p_termarrayarraylist_termarrayarraylist_semicolon_termarraylist(p): 'termarrayarraylist : termarrayarraylist SEMICOLON termarraylist' - p[0] = '%s,[%s]' % (p[1], p[3]) + p[0] = ('%s,[%s]' % (p[1][0], p[3][0]), p[1][1]) def p_termarrayarraylist_termarraylist_semicolon_termarraylist(p): 'termarrayarraylist : termarraylist SEMICOLON termarraylist' - p[0] = '[%s],[%s]' % (p[1], p[3]) + p[0] = ('[%s],[%s]' % (p[1][0], p[3][0]), p[1][1]) def p_termarraylist_termarraylist_comma_expression(p): '''termarraylist : termarraylist COMMA expression | termarraylist SPACE expression''' - p[0] = '%s,%s' % (p[1], p[3]) + p[0] = ('%s,%s' % (p[1][0], p[3][0]), p[1][1]) def p_termarraylist_expression(p): 'termarraylist : expression' - p[0] = '%s' % (p[1]) + p[0] = ('%s' % (p[1][0]), p[1][1]) def p_termarraylist_expression_colon_expression(p): 'termarraylist : expression COLON expression' - p[0] = '%s:%s' % (p[1], p[3]) + p[0] = ('%s:%s' % (p[1][0], p[3][0]), p[1][1]) # end define termarraylist @@ -602,35 +617,35 @@ def p_termarraylist_expression_colon_expression(p): def p_list_list_expression(p): 'list : list COMMA expression' - p[0] = '%s,%s' % (p[1], p[3]) + p[0] = ('%s,%s' % (p[1][0], p[3][0]), VECTOR_TYPE) def p_list_list_var_expression(p): 'list : list COMMA VAR ASSIGNMENT expression' - p[0] = '%s,%s=%s' % (p[1], p[3], p[5]) + p[0] = ('%s,%s=%s' % (p[1][0], p[3], p[5][0]), VECTOR_TYPE) def p_list_list_in_expression(p): 'list : list COMMA IN ASSIGNMENT expression' - p[0] = '%s,%s1=%s' % (p[1], p[3], p[5]) + p[0] = ('%s,%s1=%s' % (p[1][0], p[3], p[5][0]), VECTOR_TYPE) def p_list_expression(p): 'list : expression' - p[0] = '%s' % (p[1]) + p[0] = ('%s' % (p[1][0]), VECTOR_TYPE) def p_list_var_expression(p): 'list : VAR ASSIGNMENT expression' - p[0] = '%s=%s' % (p[1], p[3]) + p[0] = ('%s=%s' % (p[1], p[3][0]), VECTOR_TYPE) def p_list_in_expression(p): 'list : IN ASSIGNMENT expression' - p[0] = '%s1=%s' % (p[1], p[3]) + p[0] = ('%s1=%s' % (p[1], p[3][0]), VECTOR_TYPE) def p_getvaluelist_getvaluelist_expression(p): 'getvaluelist : getvaluelist COMMA expression' - p[0] = '%s,%s' % (p[1], p[3]) + p[0] = ('%s,%s' % (p[1][0], p[3][0]), VECTOR_TYPE) def p_getvaluelist_expression(p): 'getvaluelist : expression' - p[0] = '%s' % (p[1]) + p[0] = ('%s' % (p[1][0]), VECTOR_TYPE) # end define list @@ -639,18 +654,18 @@ def p_getvaluelist_expression(p): # (2+3) def p_expression_expression(p): 'expression : OPENBRACKET expression CLOSEBRACKET' - p[0] = '(%s)' % (p[2]) + p[0] = ('(%s)' % (p[2][0]), p[2][1]) # [2+1,1;3-1,2;4-1,3] def p_expression_termarrayarraylist(p): '''expression : OPENSQBRACKET termarrayarraylist CLOSESQBRACKET | OPENSQBRACKET termarrayarraylist SEMICOLON CLOSESQBRACKET''' - p[0] = '[%s]' % (p[2]) + p[0] = ('[%s]' % (p[2][0]), MATRIX_TYPE) # [2+1,1;] def p_expression_termarraylist_semicolon(p): '''expression : OPENSQBRACKET termarraylist SEMICOLON CLOSESQBRACKET''' - p[0] = '[[%s]]' % (p[2]) + p[0] = ('[[%s]]' % (p[2][0]), MATRIX_TYPE) # [2 3 4] # [2,3,4] @@ -658,37 +673,45 @@ def p_expression_termarraylist(p): '''expression : OPENSQBRACKET termarraylist CLOSESQBRACKET | OPENSQBRACKET termarraylist COMMA CLOSESQBRACKET | OPENSQBRACKET termarraylist SPACE CLOSESQBRACKET''' - p[0] = '[%s]' % (p[2]) + p[0] = ('[%s]' % (p[2][0]), VECTOR_TYPE) # [] def p_expression_empty(p): 'expression : OPENSQBRACKET CLOSESQBRACKET' - p[0] = '[]' + p[0] = ('[]', VECTOR_TYPE) def p_expression_term_transpose(p): 'expression : expression TRANSPOSE' - p[0] = 'transpose(%s)' % (p[1]) + p[0] = ('transpose(%s)' % (p[1][0]), p[1][1]) def p_expression_expression_multiplication_expression(p): 'expression : expression MULTIPLICATION expression' + if p[1][1] == p[3][1]: + vartype = p[1][1] + else: + vartype = STRING_TYPE if p[2] == '**': operator = '^' elif p[2] == '\\': operator = '\\' else: operator = p[2] - p[0] = '%s%s%s' % (p[1], operator, p[3]) + p[0] = ('%s%s%s' % (p[1][0], operator, p[3][0]), vartype) def p_expression_expression_addition_expression(p): 'expression : expression ADDITION expression' - p[0] = '%s%s%s' % (p[1], p[2], p[3]) + if p[1][1] == p[3][1]: + vartype = p[1][1] + else: + vartype = STRING_TYPE + p[0] = ('%s%s%s' % (p[1][0], p[2], p[3][0]), vartype) def p_expression_expression_comparison_expression(p): 'expression : expression COMPARISON expression' operator = p[2] if operator == '<>' or operator == '~=': operator = '!=' - p[0] = '%s%s%s' % (p[1], operator, p[3]) + p[0] = ('%s%s%s' % (p[1][0], operator, p[3][0]), BOOLEAN_TYPE) def p_expression_expression_logical_expression(p): 'expression : expression LOGICAL expression' @@ -697,23 +720,23 @@ def p_expression_expression_logical_expression(p): operator = '&&' elif operator == '|': operator = '||' - p[0] = '%s%s%s' % (p[1], operator, p[3]) + p[0] = ('%s%s%s' % (p[1][0], operator, p[3][0]), BOOLEAN_TYPE) def p_expression_addition_term(p): 'expression : ADDITION expression %prec UNARYADDITION' if p[1] == '-': - p[0] = '%s%s' % (p[1], p[2]) + p[0] = ('%s%s' % (p[1], p[2][0]), p[2][1]) else: - p[0] = '%s' % (p[2]) + p[0] = ('%s' % (p[2][0]), p[2][1]) def p_expression_not_expression(p): 'expression : NOT expression' operator = '!' - p[0] = '%s%s' % (operator, p[2]) + p[0] = ('%s%s' % (operator, p[2][0]), BOOLEAN_TYPE) def p_expression_term(p): 'expression : term' - p[0] = '%s' % (p[1]) + p[0] = p[1] # end define expression @@ -722,7 +745,7 @@ def p_expression_term(p): # A(2,3) def p_function_function_parameters(p): 'function : FUNCTIONNAME OPENBRACKET list CLOSEBRACKET' - p[0] = '%*s%s(%s)' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[1], p[3]) + p[0] = '%*s%s(%s)' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[1], p[3][0]) # A() def p_function_function(p): @@ -731,7 +754,7 @@ def p_function_function(p): def p_resumestatementblocks_resume(p): 'resumestatementblocks : lterm ASSIGNMENT RESUME OPENBRACKET expression CLOSEBRACKET EOL' - p[0] = '%*s%s = %s(%s)\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[1], p[3], p[5]) + p[0] = '%*s%s = %s(%s)\n' % (INDENT_LEVEL * INDENT_SIZE, ' ', p[1], p[3], p[5][0]) def p_clearvar_clear_var(p): 'clearvar : CLEAR VAR' @@ -748,25 +771,25 @@ def p_clearvar_clearvar_var(p): # B(2:$-1) def p_lterm_ltermvar_slice(p): 'lterm : ltermvar OPENBRACKET expression COLON expression CLOSEBRACKET' - p[0] = '%s.slice(%s-1,%s)' % (p[1], p[3], p[5]) + p[0] = '%s.slice(%s-1,%s)' % (p[1], p[3][0], p[5][0]) # B(2) def p_lterm_ltermvar_index(p): 'lterm : ltermvar OPENBRACKET expression CLOSEBRACKET' - p[0] = '%s[%s-1]' % (p[1], p[3]) + p[0] = '%s[%s-1]' % (p[1], p[3][0]) # B(2:$-1,1:n) def p_lterm_ltermvar_slice_slice(p): 'lterm : ltermvar OPENBRACKET expression COLON expression COMMA expression COLON expression CLOSEBRACKET' - p[0] = '%s.slice(%s-1,%s).slice(%s-1,%s)' % (p[1], p[3], p[5], p[7], p[9]) + p[0] = '%s.slice(%s-1,%s).slice(%s-1,%s)' % (p[1], p[3][0], p[5][0], p[7][0], p[9][0]) # B(2,3) # B($-2)(3) def p_lterm_ltermvar_index_index(p): '''lterm : ltermvar OPENBRACKET expression COMMA expression CLOSEBRACKET | ltermvar OPENBRACKET expression CLOSEOPENBRACKET expression CLOSEBRACKET''' - base = '%s[%s-1]' % (p[1], p[3]) - p[0] = '%s[%s-1]' % (base, p[5]) + base = '%s[%s-1]' % (p[1], p[3][0]) + p[0] = '%s[%s-1]' % (base, p[5][0]) # [A,B,C] def p_lterm_ltermarraylist(p): @@ -815,138 +838,137 @@ def p_ltermvar_prevar(p): # B(2:$-1) def p_term_slice(p): 'term : termvar OPENBRACKET expression COLON expression CLOSEBRACKET' - p[0] = '%s.slice(%s-1,%s)' % (p[1], p[3], p[5]) + p[0] = ('%s.slice(%s-1,%s)' % (p[1][0], p[3][0], p[5][0]), VECTOR_TYPE) # B(2:$-1,1) def p_term_slice_expression(p): 'term : termvar OPENBRACKET expression COLON expression COMMA expression CLOSEBRACKET' - p[0] = '%s.slice(%s-1,%s)[%s-1]' % (p[1], p[3], p[5], p[7]) + p[0] = ('%s.slice(%s-1,%s)[%s-1]' % (p[1][0], p[3][0], p[5][0], p[7][0]), VECTOR_TYPE) # B(:$-1) def p_term_left_slice(p): 'term : termvar OPENBRACKET COLON expression CLOSEBRACKET' - p[0] = '%s.slice(%s-1)' % (p[1], p[3]) + p[0] = ('%s.slice(%s-1)' % (p[1][0], p[3][0]), VECTOR_TYPE) # B(2:) def p_term_right_slice(p): 'term : termvar OPENBRACKET expression COLON CLOSEBRACKET' - p[0] = '%s.slice(%s-1,%s)' % (p[1], '1', p[4]) + p[0] = ('%s.slice(%s-1,%s)' % (p[1][0], '1', p[4][0]), VECTOR_TYPE) # B(:) def p_term_full_slice(p): 'term : termvar OPENBRACKET COLON CLOSEBRACKET' - p[0] = '%s.slice()' % (p[1]) + p[0] = ('%s.slice()' % (p[1][0]), VECTOR_TYPE) # B(:,1) def p_term_full_slice_expression(p): 'term : termvar OPENBRACKET COLON COMMA expression CLOSEBRACKET' - p[0] = '%s.slice()[%s-1]' % (p[1], p[5]) + p[0] = ('%s.slice()[%s-1]' % (p[1][0], p[5][0]), DOUBLE_TYPE) # B(1,:) def p_term_expression_full_slice(p): '''term : termvar OPENBRACKET expression COMMA COLON CLOSEBRACKET | termvar OPENBRACKET expression CLOSEOPENBRACKET COLON CLOSEBRACKET''' - base = '%s[%s-1]' % (p[1], p[3]) - p[0] = '%s.slice()' % (base) + base = '%s[%s-1]' % (p[1][0], p[3][0]) + p[0] = ('%s.slice()' % (base), VECTOR_TYPE) # B(1,1) # B($-2)(1) def p_term_expression_expression(p): '''term : termvar OPENBRACKET expression COMMA expression CLOSEBRACKET | termvar OPENBRACKET expression CLOSEOPENBRACKET expression CLOSEBRACKET''' - base = '%s[%s-1]' % (p[1], p[3]) - p[0] = '%s[%s-1]' % (base, p[5]) + base = '%s[%s-1]' % (p[1][0], p[3][0]) + p[0] = ('%s[%s-1]' % (base, p[5][0]), DOUBLE_TYPE) # B(:,:) def p_term_full_slice_full_slice(p): 'term : termvar OPENBRACKET COLON COMMA COLON CLOSEBRACKET' - p[0] = '%s.slice().slice()' % (p[1]) + p[0] = ('%s.slice().slice()' % (p[1][0]), DOUBLE_TYPE) # (1:10) def p_term_range(p): 'term : OPENBRACKET expression COLON expression CLOSEBRACKET' - p[0] = '[%s:%s]' % (p[2], p[4]) + p[0] = ('[%s:%s]' % (p[2][0], p[4][0]), VECTOR_TYPE) # 1:10:50 def p_term_range_step(p): 'term : expression COLON expression COLON expression' - p[0] = '[%s:%s:%s]' % (p[1], p[3], p[5]) + p[0] = ('[%s:%s:%s]' % (p[1][0], p[3][0], p[5][0]), VECTOR_TYPE) # B($-2) -# C('function parameter') def p_term_termvar_parameter(p): 'term : termvar OPENBRACKET expression CLOSEBRACKET' - p[0] = '%s[%s-1]' % (p[1], p[3]) + p[0] = ('%s[%s-1]' % (p[1][0], p[3][0]), DOUBLE_TYPE) -# B($-2)('function parameter')(3) +# B($-2)(1)(3) def p_term_termvar_parameter_parameter_parameter(p): 'term : termvar OPENBRACKET expression CLOSEOPENBRACKET expression CLOSEOPENBRACKET expression CLOSEBRACKET' - base = '%s[%s-1]' % (p[1], p[3]) - base = '%s[%s-1]' % (base, p[5]) - p[0] = '%s[%s-1]' % (base, p[7]) + base = '%s[%s-1]' % (p[1][0], p[3][0]) + base = '%s[%s-1]' % (base, p[5][0]) + p[0] = ('%s[%s-1]' % (base, p[7][0]), DOUBLE_TYPE) # B($-2)('function parameter')(3:4) def p_term_termvar_parameter_parameter_slice(p): 'term : termvar OPENBRACKET expression CLOSEOPENBRACKET expression CLOSEOPENBRACKET expression COLON expression CLOSEBRACKET' - base = '%s[%s-1]' % (p[1], p[3]) - base = '%s[%s-1]' % (base, p[5]) - p[0] = '%s.slice(%s-1,%s)' % (base, p[7], p[9]) + base = '%s[%s-1]' % (p[1][0], p[3][0]) + base = '%s[%s-1]' % (base, p[5][0]) + p[0] = ('%s.slice(%s-1,%s)' % (base, p[7][0], p[9][0]), STRING_TYPE) # part(x,1:10) def p_term_part_parameter_range(p): 'term : PART OPENBRACKET expression COMMA expression COLON expression CLOSEBRACKET' - p[0] = '%s(%s,%s,%s)' % (p[1], p[3], p[5], p[7]) + p[0] = ('%s(%s,%s,%s)' % (p[1], p[3][0], p[5][0], p[7][0]), STRING_TYPE) # part(x,1) def p_term_part_parameter_parameter(p): 'term : PART OPENBRACKET expression COMMA expression CLOSEBRACKET' - p[0] = '%s(%s,%s)' % (p[1], p[3], p[5]) + p[0] = ('%s(%s,%s)' % (p[1], p[3][0], p[5][0]), STRING_TYPE) # string(1:10) def p_term_string_range(p): 'term : STRING OPENBRACKET expression COLON expression CLOSEBRACKET' - p[0] = '%s(%s,%s)' % (p[1], p[3], p[5]) + p[0] = ('%s(%s,%s)' % (p[1], p[3][0], p[5][0]), STRING_TYPE) # string(x) def p_term_string_parameter(p): 'term : STRING OPENBRACKET expression CLOSEBRACKET' - p[0] = '%s(%s)' % (p[1], p[3]) + p[0] = ('%s(%s)' % (p[1], p[3][0]), STRING_TYPE) # A(2,3) def p_term_function_parameters(p): 'term : FUNCTIONNAME OPENBRACKET list CLOSEBRACKET' - p[0] = '%s(%s)' % (p[1], p[3]) + p[0] = ('%s(%s)' % (p[1], p[3][0]), DOUBLE_TYPE) # list(2,3) def p_term_list_parameters(p): 'term : LIST OPENBRACKET list CLOSEBRACKET' - p[0] = '%s(%s)' % (p[1], p[3]) + p[0] = ('%s(%s)' % (p[1], p[3][0]), VECTOR_TYPE) # gettext("abc") def p_term_gettext_parameter(p): 'term : GETTEXT OPENBRACKET expression CLOSEBRACKET' - p[0] = '%s' % (p[3]) + p[0] = ('%s' % (p[3][0]), STRING_TYPE) # A() def p_term_function(p): 'term : FUNCTIONNAME OPENBRACKET CLOSEBRACKET' - p[0] = '%s()' % (p[1]) + p[0] = ('%s()' % (p[1]), DOUBLE_TYPE) # list() def p_term_list(p): 'term : LIST OPENBRACKET CLOSEBRACKET' - p[0] = '%s()' % (p[1]) + p[0] = ('%s()' % (p[1]), VECTOR_TYPE) # $ def p_term_lastindex(p): 'term : LASTINDEX' - p[0] = '%s' % (p[1]) + p[0] = (p[1], DOUBLE_TYPE) # %xyz def p_term_prevar(p): '''term : PREVAR | PREVAR_SUBSTITUTE''' - p[0] = '%s' % (p[1]) + p[0] = (p[1], DOUBLE_TYPE) # %f def p_term_prevar_boolean(p): @@ -955,25 +977,25 @@ def p_term_prevar_boolean(p): value = 'true' elif p[1] == '%f': value = 'false' - p[0] = '%s' % (value) + p[0] = (value, BOOLEAN_TYPE) # 1+2*%i def p_term_prevar_complex1(p): 'expression : expression ADDITION expression MULTIPLICATION PREVAR_COMPLEX' if p[2] == '-': - imag = '%s%s' % (p[2], p[3]) + imag = '%s%s' % (p[2], p[3][0]) else: - imag = '%s' % (p[3]) - p[0] = 'math.complex(%s,%s)' % (p[1], imag) + imag = '%s' % (p[3][0]) + p[0] = ('math.complex(%s,%s)' % (p[1][0], imag), DOUBLE_TYPE) # 1+2*%i def p_term_prevar_complex2(p): 'expression : expression ADDITION PREVAR_COMPLEX MULTIPLICATION expression' if p[2] == '-': - imag = '%s%s' % (p[2], p[5]) + imag = '%s%s' % (p[2], p[5][0]) else: - imag = '%s' % (p[5]) - p[0] = 'math.complex(%s,%s)' % (p[1], imag) + imag = '%s' % (p[5][0]) + p[0] = ('math.complex(%s,%s)' % (p[1][0], imag), DOUBLE_TYPE) # %e %pi def p_term_prevar_float(p): @@ -984,40 +1006,66 @@ def p_term_prevar_float(p): flt = 'math.PI' else: flt = p[1] - p[0] = '%s' % (flt) + p[0] = (flt, DOUBLE_TYPE) def p_term_termvar(p): 'term : termvar' - p[0] = '%s' % (p[1]) + p[0] = p[1] # A.B def p_termvar_termvar_dot_var(p): 'termvar : termvar DOT VAR' - p[0] = '%s.%s' % (p[1], p[3]) + var = p[1][0] + if var[:5] == 'this.': + basevar = var[5:] + else: + basevar = var + add_object_var(basevar) + var = '%s.%s' % (var, p[3]) + if var[:5] == 'this.': + basevar = var[5:] + else: + basevar = var + vartype = VAR_TYPES[basevar] if basevar in VAR_TYPES else None + p[0] = (var, vartype) def p_termvar_termvar_dot_in(p): 'termvar : termvar DOT IN' - p[0] = '%s.%s1' % (p[1], p[3]) + var = p[1][0] + if var[:5] == 'this.': + basevar = var[5:] + else: + basevar = var + add_object_var(basevar) + var = '%s.%s1' % (var, p[3]) + if var[:5] == 'this.': + basevar = var[5:] + else: + basevar = var + vartype = VAR_TYPES[basevar] if basevar in VAR_TYPES else None + p[0] = (var, vartype) # A def p_termvar_var(p): 'termvar : VAR' var = p[1] add_global_var(var) + vartype = VAR_TYPES[var] if var in VAR_TYPES else None if var in GLOBAL_VARS: - p[0] = 'this.%s' % (var) + p[0] = ('this.%s' % (var), vartype) else: - p[0] = '%s' % (var) + p[0] = ('%s' % (var), vartype) # in def p_termvar_in(p): 'termvar : IN' var = p[1] + '1' add_global_var(var) + vartype = VAR_TYPES[var] if var in VAR_TYPES else None if var in GLOBAL_VARS: - p[0] = 'this.%s' % (var) + p[0] = ('this.%s' % (var), vartype) else: - p[0] = '%s' % (var) + p[0] = ('%s' % (var), vartype) # 5 # 3.4 @@ -1026,14 +1074,14 @@ def p_termvar_in(p): def p_term_number(p): 'term : NUMBER' number = re.sub(r'[de]', r'e', p[1], flags=re.IGNORECASE) - p[0] = '%s' % (number) + p[0] = ('%s' % (number), DOUBLE_TYPE) # 'abc' # "abc" def p_term_string(p): '''term : QSTRING | DQSTRING''' - p[0] = '%s' % (p[1]) + p[0] = ('%s' % (p[1]), STRING_TYPE) # end define term @@ -1062,15 +1110,24 @@ def getblocktype(module): return BLOCK_TYPE.get(module, 'BasicBlock') def add_local_var(var, force=False): - if force and var in GLOBAL_VARS: + if var[:5] == 'this.': + print('Syntax error: cannot add local variable:', var) + return + exists = var in GLOBAL_VARS + if force and exists: GLOBAL_VARS.remove(var) - if var not in GLOBAL_VARS: + exists = False + if not exists: LOCAL_VARS.add(var) def add_global_var(var, force=False): - if force and var in LOCAL_VARS: + if var[:5] == 'this.': + var = var[5:] + exists = var in LOCAL_VARS + if force and exists: LOCAL_VARS.remove(var) - if var not in LOCAL_VARS: + exists = False + if not exists: GLOBAL_VARS.add(var) def add_var_vartype(var, vartype): -- cgit