parser_module.py

import re
import os
import generic_regexes
import parser_instructions
import flow_chart_graphics
import remi.gui as gui

"""
 This parses dat and src files
 analyzed instructions
"""

def fread_lines(file_path_and_name):
 content = None
 with open(file_path_and_name, "r") as f:
 content = f.readlines()
 return content


class MouseNavArea(gui.Container):
 zoom_absolute_position = 1.0
 zoom_min_value = 0.0
 def __init__(self, *args, **kwargs):
 gui.Container.__init__(self, *args, **kwargs)
 self.style['overflow'] = 'hidden'
 self.style['outline'] = '1px solid gray'
 self.style['zoom'] = '1.0'
 self.onmousemove.do(self.center_view)
 self.onwheel.do(self.zoom, js_prevent_default=True, js_stop_propagation=True)
 
 
 @gui.decorate_set_on_listener("(self, emitter, deltaY)")
 @gui.decorate_event_js("var params={};" \
 "params['deltaY']=event.deltaY;" \
 "remi.sendCallbackParam('%(emitter_identifier)s','%(event_name)s',params);")
 def onwheel(self, deltaY):
 """Called when the mouse cursor moves inside the Widget.

 Args:
 deltaY (float): the relative scroll value
 """
 return (deltaY,)

 def center_view(self, emitter, x, y):
 x = float(x)
 wself = float(gui.from_pix(self.css_width))

 y = float(y)
 hself = float(gui.from_pix(self.css_height))

 offset_x = wself * self.zoom_absolute_position
 offset_y = hself * self.zoom_absolute_position
 for c in self.children.values():
 c.css_position = 'relative'
 wchild = wself
 try:
 wchild = gui.from_pix(c.css_width)
 except:
 wchild = float(c.attr_width)
 wchild = wchild * self.zoom_absolute_position
 
 if wself < wchild:
 left = offset_x/2 -(wchild+offset_x-wself) * (x/wself)
 #left = left + offset/2 - offset * (x/wself)
 c.css_left = gui.to_pix( left / self.zoom_absolute_position )
 else:
 c.css_left = "0px"


 hchild = hself
 try:
 hchild = gui.from_pix(c.css_height)
 except:
 hchild = float(c.attr_height)
 hchild = hchild * self.zoom_absolute_position
 
 if hself < hchild:
 top = offset_y/2-(hchild+offset_y-hself) * (y/hself)
 #top = top + offset/2 - offset * (y/hself)
 c.css_top = gui.to_pix( top / self.zoom_absolute_position )
 else:
 c.css_top = "0px"
 
 def zoom(self, emitter, relative_value):
 self.zoom_absolute_position = min(max(self.zoom_min_value, self.zoom_absolute_position - float(relative_value)*0.0003), 2.0)
 self.set_zoom( self.zoom_absolute_position )

 def set_zoom(self, value):
 self.zoom_absolute_position = value
 for c in self.children.values():
 c.style['zoom'] = str(value)


class KRLModuleSrcFileParser(parser_instructions.KRLGenericParser, gui.HBox):
 file_path_name = '' # the str path and file
 def __init__(self, file_path_name):
 # read all instructions, parse and collect definitions
 self.krl_procedures_and_functions_list = []
 self.indent_comments = False
 self.file_path_name = file_path_name
 permissible_instructions = ['procedure begin', 'function begin']
 permissible_instructions_dictionary = {k:v for k,v in parser_instructions.instructions_defs.items() if k in permissible_instructions}
 parser_instructions.KRLGenericParser.__init__(self, permissible_instructions_dictionary)

 gui.HBox.__init__(self)
 self.css_align_items = 'flex-start'
 self.style['outline'] = '2px solid gray'
 #self.css_background_color = 'lightgray'
 self.append(gui.ListView(width=200, style={'margin': '0px'}), 'list')
 self.append(MouseNavArea(width=1000, height=650), 'container')
 
 self.children['list'].onselection.do(self.on_proc_list_selected)
 
 def on_proc_list_selected(self, widget, selected_key):
 w = gui.from_pix(self.children['container'].css_width)
 h = gui.from_pix(self.children['container'].css_height)
 self.children['container'].append(widget.children[selected_key].node, 'proc_to_view')
 widget.children[selected_key].node.draw()
 best_zoom = min(w/float(widget.children[selected_key].node.attr_width), h/float(widget.children[selected_key].node.attr_height))
 self.children['container'].set_zoom(best_zoom)
 self.children['container'].zoom_min_value = best_zoom


 def parse_single_instruction(self, code_line_original, code_line, instruction_name, match_groups, file_lines):
 translation_result_tmp = []

 if instruction_name == 'procedure begin':
 param_list = code_line.split('(')[1].split(')')[0].split(',')
 def filter_zero_sized(v):
 return len(v.strip()) > 0
 param_list = list(filter(filter_zero_sized,param_list))
 param_names = [x.split(':')[0].strip() for x in param_list]
 param_direction = [x.split(':')[1].strip() for x in param_list]
 param_names = [re.sub(generic_regexes.index_3d, '', x) for x in param_names]
 is_global = not match_groups[0] is None 
 procedure_name = match_groups[2]
 #translation_result_tmp.append("@global_defs.interruptable_function_decorator")
 
 node = parser_instructions.KRLProcedureParser( procedure_name, param_names )
 

 #self.append(node)
 li = gui.ListItem(node.name)
 li.node = node
 self.children['list'].append(li)
 _translation_result_tmp, file_lines = node.parse(file_lines)

 proc_def = "void " + procedure_name + "("
 parameters_def = []
 index = 0
 for param in param_names:
 if len(param.strip()):
 if param in node.local_variables.keys():
 parameters_def.append( node.local_variables[param] + ("&" if param_direction[index].lower() == 'out' else "") + " " + param )
 index += 1
 proc_def += ", ".join(parameters_def)
 proc_def += "){"
 translation_result_tmp.append( proc_def )

 if len(_translation_result_tmp):
 translation_result_tmp.extend(_translation_result_tmp)

 #translation_result_tmp.extend("}")

 if is_global:
 parser_instructions.add_user_global_def('\n'.join(translation_result_tmp))
 
 if instruction_name == 'function begin':
 param_list = code_line.split('(')[1].split(')')[0].split(',')
 def filter_zero_sized(v):
 return len(v.strip()) > 0
 param_list = list(filter(filter_zero_sized,param_list))
 param_names = [x.split(':')[0].strip() for x in param_list]
 param_direction = [x.split(':')[1].strip() for x in param_list]
 param_names = [re.sub(generic_regexes.index_3d, '', x) for x in param_names]
 procedure_name = match_groups[3]
 is_global = not match_groups[0] is None 
 return_value_type_name = match_groups[2]
 #translation_result_tmp.append("@global_defs.interruptable_function_decorator")
 #translation_result_tmp.append( "def " + procedure_name + "(" + ", ".join(param_names) + "): #function returns %s"%return_value_type_name )

 node = parser_instructions.KRLFunctionParser( procedure_name, param_names, return_value_type_name )

 li = gui.ListItem(node.name)
 li.node = node
 self.children['list'].append(li)
 _translation_result_tmp, file_lines = node.parse(file_lines)

 func_def = return_value_type_name + " " + procedure_name + "("
 parameters_def = []
 index = 0
 for param in param_names:
 if len(param.strip()):
 if param in node.local_variables.keys():
 parameters_def.append( node.local_variables[param] + ("&" if param_direction[index].lower() == 'out' else "") + " " + param )
 index += 1
 func_def += ", ".join(parameters_def)
 func_def += "){"
 translation_result_tmp.append( func_def )

 if len(_translation_result_tmp):
 translation_result_tmp.extend(_translation_result_tmp)

 #translation_result_tmp.extend("}")

 if is_global:
 parser_instructions.add_user_global_def('\n'.join(translation_result_tmp))
 
 _translation_result_tmp, file_lines = parser_instructions.KRLGenericParser.parse_single_instruction(self, code_line_original, code_line, instruction_name, match_groups, file_lines)
 if len(_translation_result_tmp):
 translation_result_tmp.extend(_translation_result_tmp)

 return translation_result_tmp, file_lines


class KRLModuleDatFileParser(parser_instructions.KRLGenericParser):
 file_path_name = '' # the str path and file
 
 def __init__(self, file_path_name):
 # read all instructions, parse and collect definitions
 self.indent_comments = False
 self.file_path_name = file_path_name
 permissible_instructions = ['dat begin', 'dat end', 'enum definition', 'struc declaration']
 permissible_instructions_dictionary = {k:v for k,v in parser_instructions.instructions_defs.items() if k in permissible_instructions}
 parser_instructions.KRLGenericParser.__init__(self, permissible_instructions_dictionary)
 permissible_instructions = ['variable declaration', 'variable assignment']
 permissible_instructions_dictionary = {k:v for k,v in parser_instructions.instructions_defs.items() if k in permissible_instructions}
 self.permissible_instructions_dictionary.update(permissible_instructions_dictionary)
 

class KRLModule(gui.VBox):
 name = ''
 module_dat = None # KRLDat instance
 module_src = None # KRLSrc instance
 def __init__(self, module_name, dat_path_and_file = '', src_path_and_file = '', imports_to_prepend = '', *args, **kwargs):
 super(KRLModule, self).__init__(*args, **kwargs)
 self.css_align_items = 'flex-start'
 self.append(gui.Label("MODULE: %s"%module_name, style={'font-weight':'bolder', 'font-size':'20px'}))
 self.name = module_name
 if len(dat_path_and_file):
 self.module_dat = KRLModuleDatFileParser(dat_path_and_file)

 #it seems to have no relevance in flowcharts
 #self.module_dat.text = "DAT %s"%module_name
 #self.append(self.module_dat)
 
 file_lines = fread_lines(dat_path_and_file)
 translation_result, file_lines = self.module_dat.parse(file_lines)
 with open(os.path.dirname(os.path.abspath(__file__)) + "/%s.h"%self.name, 'w+') as f:
 f.write(imports_to_prepend)
 for l in translation_result:
 f.write(l + '\n')
 
 if len(src_path_and_file):
 has_dat = not (self.module_dat is None)
 self.module_src = KRLModuleSrcFileParser(src_path_and_file)
 self.append(self.module_src)
 file_lines = fread_lines(src_path_and_file)
 translation_result, file_lines = self.module_src.parse(file_lines)
 with open(os.path.dirname(os.path.abspath(__file__)) + "/%s.c"%self.name, 'w+') as f:
 if not has_dat:
 f.write(imports_to_prepend)
 f.write('#include "%s.h"\n'%self.name)
 for l in translation_result:
 f.write(l + '\n')