def handle_for(block, instance_vars, stack): validate_for_loop_syntax(block) tokens = clean_up_list_elems(flatten_list(re.split("for\s*\(", block))) tokens = clean_up_list_elems(flatten_list(list(map(lambda x: re.split("\)\s*\{", x), tokens)))) tokens = clean_up_list_elems(flatten_list(list(map(lambda x: re.split("\}", x), tokens)))) tokens = tokens[0].split(";") + [tokens[1]] initialize, condition, update, statements = tokens assign_variable(initialize, instance_vars, stack) """ evaluated_condition = evaluate_expression(condition, instance_vars, stack) if type(evaluated_condition) is not bool: raise InvalidForLoopException("Boolean condition is of wrong type") """ while evaluate_expression(condition, instance_vars, stack): parse_eval(statements, instance_vars, stack) assign_variable(update, instance_vars, stack) # Assumes well-formed expression. var_name = initialize.split(" ")[1] get_variable_frame(var_name, instance_vars, stack).pop(var_name) return
def handle_conditional_statements(if_else_block, instance_vars, stack): has_else_clause = verify_if_else_syntax(if_else_block) # Tokenize if-else block: split conditions from statements tokens = clean_up_list_elems(flatten_list(re.split("\s*\}\s*else if\s*\(", if_else_block))) # Split by } else if ( tokens = clean_up_list_elems(flatten_list(list(map(lambda elem: re.split("\s*if\s*\(", elem), tokens)))) # Split by if ( tokens = clean_up_list_elems(flatten_list(list(map(lambda elem: re.split("\s*\}\s*else\s*\{", elem), tokens)))) # Split by } else {, insert True as condition if has_else_clause: tokens.insert(-1, "True") tokens = clean_up_list_elems(flatten_list(list(map(lambda elem: re.split("\s*\)\s*\{", elem), tokens)))) # Split by ) { tokens = clean_up_list_elems(flatten_list(list(map(lambda elem: re.split("\}", elem), tokens)))) # Split by } # Split tokens into list of conditions and statements conditions_list, statements_list = [], [] for index in range(0, len(tokens)): if index % 2 == 0: # Even, is a condition. conditions_list.append(tokens[index]) else: statements_list.append(tokens[index]) assert len(conditions_list) == len(statements_list), "conditions_list and statements_list are of different lengths" # Check the conditions; if True, return the associated statements for index in range(0, len(conditions_list)): curr_condition = evaluate_expression(conditions_list[index]) if type(curr_condition) is not bool: raise InvalidIfElseBlockException("Condition parsed was not a boolean expression. Condition was: " + str(curr_condition)) if curr_condition: return statements_list[index] return None
def handle_for(block, instance_vars, stack): validate_for_loop_syntax(block) tokens = clean_up_list_elems(flatten_list(re.split("for\s*\(", block))) tokens = clean_up_list_elems( flatten_list(list(map(lambda x: re.split("\)\s*\{", x), tokens)))) tokens = clean_up_list_elems( flatten_list(list(map(lambda x: re.split("\}", x), tokens)))) tokens = tokens[0].split(";") + [tokens[1]] initialize, condition, update, statements = tokens assign_variable(initialize, instance_vars, stack) """ evaluated_condition = evaluate_expression(condition, instance_vars, stack) if type(evaluated_condition) is not bool: raise InvalidForLoopException("Boolean condition is of wrong type") """ while evaluate_expression(condition, instance_vars, stack): parse_eval(statements, instance_vars, stack) assign_variable(update, instance_vars, stack) # Assumes well-formed expression. var_name = initialize.split(" ")[1] get_variable_frame(var_name, instance_vars, stack).pop(var_name) return
def handle_conditional_statements(if_else_block, instance_vars, stack): #import javarepl# import evaluate_expression has_else_clause = verify_if_else_syntax(if_else_block) # Tokenize if-else block: split conditions from statements tokens = clean_up_list_elems( flatten_list(re.split("\s*\}\s*else if\s*\(", if_else_block))) # Split by } else if ( tokens = clean_up_list_elems( flatten_list( list(map(lambda elem: re.split("\s*if\s*\(", elem), tokens)))) # Split by if ( tokens = clean_up_list_elems( flatten_list( list(map(lambda elem: re.split("\s*\}\s*else\s*\{", elem), tokens)))) # Split by } else {, insert True as condition if has_else_clause: tokens.insert(-1, "True") tokens = clean_up_list_elems( flatten_list( list(map(lambda elem: re.split("\s*\)\s*\{", elem), tokens)))) # Split by ) { tokens = clean_up_list_elems( flatten_list(list(map(lambda elem: re.split("\}", elem), tokens)))) # Split by } # Split tokens into list of conditions and statements conditions_list, statements_list = [], [] for index in range(0, len(tokens)): if index % 2 == 0: # Even, is a condition. conditions_list.append(tokens[index]) else: statements_list.append(tokens[index]) assert len(conditions_list) == len( statements_list ), "conditions_list and statements_list are of different lengths" # Check the conditions; if True, return the associated statements for index in range(0, len(conditions_list)): curr_condition = evaluate_expression(conditions_list[index], instance_vars, stack) if type(curr_condition) is not bool: raise InvalidIfElseBlockException( "Condition parsed was not a boolean expression. Condition was: " + str(curr_condition)) if curr_condition: return statements_list[index] return None
def handle_while(block, instance_vars, stack): validate_while_loop_syntax(block) tokens = clean_up_list_elems(flatten_list(re.split("while\s*\(", block))) tokens = clean_up_list_elems(flatten_list(list(map(lambda x: re.split("\)\s*\{", x), tokens)))) tokens = clean_up_list_elems(flatten_list(list(map(lambda x: re.split("\}", x), tokens)))) assert len(tokens) == 2, "There should be 2 tokens, but there are " + str(len(tokens)) condition, statements = tokens[0], tokens[1] while evaluate_expression(condition, instance_vars, stack): parse_eval(statements, instance_vars, stack) # We will NOT support different scoping for variables inside. return # Call parse_eval with instance_vars
def handle_while(block, instance_vars, stack): validate_while_loop_syntax(block) tokens = clean_up_list_elems(flatten_list(re.split("while\s*\(", block))) tokens = clean_up_list_elems(flatten_list(list(map(lambda x: re.split("\)\s*\{", x), tokens)))) tokens = clean_up_list_elems(flatten_list(list(map(lambda x: re.split("\}", x), tokens)))) print("tokens: " + str(tokens)) assert len(tokens) == 2, "There should be 2 tokens, but there are " + str(len(tokens)) condition, statements = tokens[0], tokens[1] while evaluate_expression(condition): parse_eval(statements, instance_vars, stack) # We will NOT support different scoping for variables inside. return # Call parse_eval with instance_vars
def split_declaration(declaration): declaration_tokens = clean_up_list_elems(declaration.split(" ")) if len(declaration_tokens) == 1: # Represents an assignment statement to a variable previously declared. datatype, name = None, declaration_tokens[0].strip() elif len(declaration_tokens) == 2: # Represents an assignment statement to a variable being declared now. datatype, name = declaration_tokens[0].strip(), declaration_tokens[1].strip() else: raise InvalidDeclarationException("Invalid declaration provided: " + str(declaration)) return datatype, name
def handle_for(block, instance_vars, stack): validate_for_loop_syntax(block) tokens = clean_up_list_elems(flatten_list(re.split("for\s*\(", block))) tokens = clean_up_list_elems(flatten_list(list(map(lambda x: re.split("\)\s*\{", x), tokens)))) tokens = clean_up_list_elems(flatten_list(list(map(lambda x: re.split("\}", x), tokens)))) print("tokens: " + str(tokens)) tokens = tokens[0].split(";") + [tokens[1]] print("tokens: " + str(tokens)) initialize, condition, update, statements = tokens print("tokens: " + str(tokens)) assign_variable(initialize, instance_vars, stack) evaluated_condition = evaluate_expression(condition) if type(evaluated_condition) is not bool: raise InvalidForLoopException("Boolean condition is of wrong type") while evaluated_condition: parse_eval(statements, instance_vars, stack) assign_variable(update, instance_vars, stack) return
def split_declaration(declaration): declaration_tokens = clean_up_list_elems(declaration.split(" ")) if len( declaration_tokens ) == 1: # Represents an assignment statement to a variable previously declared. datatype, name = None, declaration_tokens[0].strip() elif len( declaration_tokens ) == 2: # Represents an assignment statement to a variable being declared now. datatype, name = declaration_tokens[0].strip( ), declaration_tokens[1].strip() else: raise InvalidDeclarationException("Invalid declaration provided: " + str(declaration)) return datatype, name