beremiz: comparison plugger.py

equal deleted inserted replaced

-:e007d9d466d7
+:585d5b387b6a
 def PlugImport(self, src_PlugPath):
 shutil.copytree(src_PlugPath, self.PlugPath)
 return True
-def PlugGenerate_C(self, buildpath, current_location, locations, logger):
+def PlugGenerate_C(self, buildpath, locations, logger):
 """
 Generate C code
-@param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)
 @param locations: List of complete variables locations \
 [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)
 "NAME" : name of the variable (generally "__IW0_1_2" style)
 "DIR" : direction "Q","I" or "M"
 "SIZE" : size "X", "B", "W", "D", "L"
 "LOC" : tuple of interger for IEC location (0,1,2,...)
 }, ...]
 @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
 """
-logger.write_warning(".".join(map(lambda x:str(x), current_location)) + " -> Nothing yo do\n")
+logger.write_warning(".".join(map(lambda x:str(x), self.GetCurrentLocation())) + " -> Nothing yo do\n")
 return [],""
-def _Generate_C(self, buildpath, current_location, locations, logger):
+def _Generate_C(self, buildpath, locations, logger):
 # Generate plugins [(Cfiles, CFLAGS)], LDFLAGS
-PlugCFilesAndCFLAGS, PlugLDFLAGS = self.PlugGenerate_C(buildpath, current_location, locations, logger)
+PlugCFilesAndCFLAGS, PlugLDFLAGS = self.PlugGenerate_C(buildpath, locations, logger)
 # recurse through all childs, and stack their results
 for PlugChild in self.IterChilds():
-# Compute child's IEC location
+new_location = PlugChild.GetCurrentLocation()
-if current_location:
+# How deep are we in the tree ?
-new_location = current_location + (self.BaseParams.getIEC_Channel())
+depth=len(new_location)
-else:
-# root
-new_location = ()
-# Get childs [(Cfiles, CFLAGS)], LDFLAGS
 CFilesAndCFLAGS, LDFLAGS = \
 PlugChild._Generate_C(
 #keep the same path
 buildpath,
-# but update location (add curent IEC channel at the end)
-new_location,
 # filter locations that start with current IEC location
-[loc for loc in locations if loc["LOC"][0:len(new_location)] == new_location ],
+[loc for loc in locations if loc["LOC"][0:depth] == new_location ],
 #propagete logger
 logger)
 # stack the result
 PlugCFilesAndCFLAGS += CFilesAndCFLAGS
 PlugLDFLAGS += LDFLAGS
 def GetChildByIECLocation(self, Location):
 return self._GetChildBySomething('_',"IEC_Channel", Name)
 def GetCurrentLocation(self):
+"""
+@return:  Tupple containing plugin IEC location of current plugin : %I0.0.4.5 => (0,0,4,5)
+"""
 return self.PlugParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(),)
 def GetPlugRoot(self):
 return self.PlugParent.GetPlugRoot()
 # Fetch the plugin
 PlugInstance = self.GetChildByName(PlugName)
 # Ask to his parent to remove it
 PlugInstance.PlugParent._doRemoveChild(PlugInstance)
-def PlugAddChild(self, PlugName, PlugType):
+def PlugAddChild(self, PlugName, PlugType, logger):
 """
 Create the plugins that may be added as child to this node self
 @param PlugType: string desining the plugin class name (get name from PlugChildsTypes)
 @param PlugName: string for the name of the plugin instance
 """
 _self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel())
 # Call the plugin real __init__
 if getattr(PlugClass, "__init__", None):
 PlugClass.__init__(_self)
 #Load and init all the childs
-_self.LoadChilds()
+_self.LoadChilds(logger)
 else:
 # If plugin do not have corresponding file/dirs - they will be created on Save
 # Set plugin name
 _self.BaseParams.setName(PlugName)
 os.mkdir(_self.PlugPath())
 xmlfile = open(self.PluginXmlFilePath(PlugName), 'r')
 tree = minidom.parse(xmlfile)
 self.PlugParams[1].loadXMLTree(tree.childNodes[0])
 xmlfile.close()
-def LoadChilds(self):
+def LoadChilds(self, logger):
 # Iterate over all PlugName@PlugType in plugin directory, and try to open them
 for PlugDir in os.listdir(self.PlugPath()):
 if os.path.isdir(os.path.join(self.PlugPath(), PlugDir)) and \
 PlugDir.count(NameTypeSeparator) == 1:
-#try:
+pname, ptype = PlugDir.split(NameTypeSeparator)
-self.PlugAddChild(*PlugDir.split(NameTypeSeparator))
+try:
-#except Exception, e:
+self.PlugAddChild(pname, ptype, logger)
-#    print e
+except Exception, e:
+logger.write_error("Could not add child \"%s\", type %s :\n%s\n"%(pname, ptype, str(e)))
 def _GetClassFunction(name):
 def GetRootClass():
 return getattr(__import__("plugins." + name), name).RootClass
 return GetRootClass
 self.PluggedChilds = {}
 # Keep track of the root plugin (i.e. project path)
 self.ProjectPath = ProjectPath
 return None
-def LoadProject(self, ProjectPath):
+def LoadProject(self, ProjectPath, logger):
 """
 Load a project contained in a folder
 @param ProjectPath: path of the project folder
 """
 # Verify that project contains a PLCOpen program
 #Load the plugin.xml file into parameters members
 result = self.LoadXMLParams()
 if result:
 return result
 #Load and init all the childs
-self.LoadChilds()
+self.LoadChilds(logger)
 return None
 def SaveProject(self):
 if not self.PLCManager.SaveXMLFile():
 self.PLCManager.SaveXMLFile(os.path.join(self.ProjectPath, 'plc.xml'))
 return self.ProjectPath
 def PluginXmlFilePath(self, PlugName=None):
 return os.path.join(self.PlugPath(PlugName), "beremiz.xml")
-def PlugGenerate_C(self, buildpath, current_location, locations, logger):
+def PlugGenerate_C(self, buildpath, locations, logger):
 """
 Generate C code
-@param current_location: Tupple containing plugin IEC location : %I0.0.4.5 => (0,0,4,5)
 @param locations: List of complete variables locations \
 [(IEC_loc, IEC_Direction, IEC_Type, Name)]\
 ex: [((0,0,4,5),'I','STRING','__IX_0_0_4_5'),...]
 @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND
 """
 # Eventually create build dir
 if not os.path.exists(buildpath):
 os.mkdir(buildpath)
+logger.flush()
 logger.write("Start build in %s\n" % buildpath)
 # Generate SoftPLC code
 if not self._Generate_SoftPLC(logger):
 logger.write_error("SoftPLC code generation failed !\n")
 return False
 logger.write("SoftPLC code generation successfull\n")
 # Generate C code and compilation params from plugin hierarchy
-#try:
+try:
 CFilesAndCFLAGS, LDFLAGS = self._Generate_C(
 buildpath,
-None, #root has no location
+self.PLCGeneratedLocatedVars,
-self.PLCGeneratedLocatedVars,
+logger)
-logger)
+except Exception, msg:
-#except Exception, msg:
+logger.write_error("Plugins code generation Failed !\n")
-#    logger.write_error("Plugins code generation Failed !\n")
+logger.write_error(str(msg))
-#    logger.write_error(str(msg))
+return False
-#    return False
 logger.write("Plugins code generation successfull\n")
 # Compile the resulting code into object files.
 for CFile, CFLAG in CFilesAndCFLAGS:

changeset 24	585d5b387b6a
parent 23	e007d9d466d7
child 25	fa7503684c28