Python wrapperxml.WrapperXml类代码示例

 def __init__(self, parent):
     self.parent = parent
     filepath = self.parent.projectpath + "/" +\
         SIMULATIONPATH + "/simulation" + XMLEXT
     if not sy.file_exist(filepath):
         raise PodError("No simulation project found", 3)
     WrapperXml.__init__(self, file=filepath)

 def __init__(self,project):
     self.project = project
     filepath = settings.projectpath+"/"+DRIVERSPATH+"/drivers"+XMLEXT
     if not sy.fileExist(filepath):
         raise Error("No driver project found",3)
     WrapperXml.__init__(self,file=filepath)
     self.bspdir = None

    def loadInstance(self,instancename):
        """ Load an instance from project directory
        """
        # load xml file
        WrapperXml.__init__(self,file=settings.projectpath + COMPONENTSPATH +"/"\
                + instancename + "/" + instancename + XMLEXT)

        # Fill objects list
        if self.getNode("interfaces") != None:
            for element in self.getSubNodeList("interfaces","interface"):
                self.interfaceslist.append(Interface(self,node=element))

        if self.getNode("generics") != None:
            for element in self.getSubNodeList("generics","generic"):
                self.genericslist.append(Generic(self,node=element))

        if self.getNode("hdl_files")!= None:
            for element in self.getSubNodeList("hdl_files","hdl_file"):
                self.hdl_fileslist.append(Hdl_file(self,node=element))

        if self.getNode("driver_files")!=None:
            for element in self.getSubNodeList("driver_files","driver_templates"):
                self.driver_templateslist.append(Driver_Templates(self,node=element))

        if self.getNode("interrupts")!=None:
            for element in self.getSubNodeList("interrupts","interrupt"):
                self.interruptslist.append(
                        self.getInterface(
                            element.getAttributeValue("interface")).getPort(
                                element.getAttributeValue("port")))

        self.setInstanceName(instancename)

 def __init__(self,parent):
     self.parent = parent
     filepath = settings.projectpath+"/"+SYNTHESISPATH+"/synthesis"+XMLEXT
     if not sy.fileExist(filepath):
         raise Error("No synthesis project found",3)
     WrapperXml.__init__(self,file=filepath)
     # adding path for toolchain plugin
     sys.path.append(settings.path+TOOLCHAINPATH+\
             SYNTHESISPATH+"/"+self.getName())

 def __init__(self, parent, **keys):
     """ init driver_templates,
         __init__(self,parent,node)
         __init__(self,parent,nodestring)
     """
     self.parent = parent
     if "node" in keys:
         WrapperXml.__init__(self, node=keys["node"])
     elif "nodestring" in keys:
         WrapperXml.__init__(self, nodestring=keys["nodestring"])
     else:
         raise PodError("Keys unknown in DriverTemplates init()", 0)

 def __init__(self, parent, **keys):
     """ init Generic,
         __init__(self,parent,node)
         __init__(self,parent,nodestring)
     """
     self.parent = parent
     if "node" in keys:
         WrapperXml.__init__(self, node=keys["node"])
     elif "nodestring" in keys:
         WrapperXml.__init__(self, nodestring=keys["nodestring"])
     else:
         raise PodError("Keys unknown in SimulationLib init()", 0)

 def __init__(self,filename):
     self.filename = os.path.expanduser(filename)
     if os.path.exists(self.filename):
         WrapperXml.__init__(self,file=self.filename)
     else:
         print filename + " doesn't exist, be created"
         WrapperXml.__init__(self,nodename="podconfig")
         self.addNode(nodename="libraries")
         self.savefile()
     # fill library path list:
     self.personal_lib_list =\
         [node.getAttribute("path") 
                 for node in self.getSubNodeList("libraries","lib")]

 def __init__(self, parent, **keys):
     """ init Slave,
         __init__(self,parent,node)
         __init__(self,parent,instancename,interfacename)
     """
     self.parent = parent
     if "node" in keys:
         WrapperXml.__init__(self, node=keys["node"])
     elif "instancename" in keys:
         WrapperXml.__init__(self, nodename="slave")
         self.instancename = keys["instancename"]
         self.interfacename = keys["interfacename"]
     else:
         raise PodError("Keys unknowns in Slave init()", 0)

 def __init__(self,parent,**keys):
     """ Init Hdl_file,
         __init__(self,parent,node)
         __init__(self,filename,istop,scope)
     """
     self.parent = parent
     self.parser = None
     if "node" in keys:
         WrapperXml.__init__(self,node=keys["node"])
     elif "filename" in keys:
         self.__initfilename(filename=keys["filename"],
                             istop=keys["istop"],scope=keys["scope"])
     else:
         raise Error("Keys unknown in Hdl_file",0)

    def __init__(self, parent, **keys):
        """ init Pin,
            __init__(self,parent,node)
            __init__(self,parent,num)
        """

        self.parent = parent

        if "node" in keys:
            WrapperXml.__init__(self, node=keys["node"])
        elif "num" in keys:
            WrapperXml.__init__(self, nodename="pin")
            self.num = keys["num"]
        else:
            raise PodError("Keys unknown in Pin", 0)

    def __init__(self, parent, **keys):
        """ Init HdlFile,
            __init__(self, parent, node)
            __init__(self, filename, istop, scope)
        """
        self.parent = parent
        self.parser = None
        if "node" in keys:
            WrapperXml.__init__(self,
                                node=keys["node"])

        elif "filename" in keys:
            WrapperXml.__init__(self, nodename="hdl_file")
            if keys["istop"] == 1:
                self.settop()
            self.scope = keys["scope"]
            self.filename = keys["filename"]
        else:
            raise PodError("Keys unknown in HdlFile", 0)

    def __init__(self, parent, **keys):
        """ Init port,
            __init__(self, parent, name)
            __init__(self, parent, wxml)
        """

        self.parent = parent

        if "name" in keys:
            WrapperXml.__init__(self, nodename="port")
            self.set_attr("name", keys["name"])
        elif "node" in keys:
            WrapperXml.__init__(self, node=keys["node"])
        else:
            raise PodError("Keys not known in Port ", 0)

        self.pinlist = []
        for element in self.get_nodes("pin"):
            pin = Pin(self, node=element)
            self.pinlist.append(pin)

    def load(self, instancename):
        """ Load an instance from project directory
        """
        # load xml file
        WrapperXml.__init__(self, file=self.parent.projectpath +
                            COMPONENTSPATH + "/" + instancename +
                            "/" + instancename + XMLEXT)

        # Fill objects list
        if self.get_node("interfaces") is not None:
            for element in self.get_subnodes("interfaces", "interface"):
                self._interfaceslist.append(Interface(self, node=element))

        if self.get_node("generics") is not None:
            for element in self.get_subnodes("generics", "generic"):
                self._genericslist.append(Generic(self, node=element))

        if self.get_node("hdl_files") is not None:
            for element in self.get_subnodes("hdl_files", "hdl_file"):
                self._hdl_fileslist.append(HdlFile(self, node=element))

        if self.get_node("driver_files") is not None:
            for element in\
                    self.get_subnodes("driver_files", "driver_templates"):
                self._driver_templateslist.append(
                    DriverTemplates(self, node=element))

        if self.get_node("interrupts") is not None:
            for element in self.get_subnodes("interrupts", "interrupt"):
                self._interruptslist.append(
                    self.get_interface(
                        element.get_attr_value("interface")).get_port(
                            element.get_attr_value("port")))

        if self.get_node("constraints") is not None:
            for element in self.get_subnodes("constraints", "constraint"):
                self._constraintslist.append(element)

        self.instancename = instancename

 def createComponent(self,componentname,libraryname,versionname):
     """ Creating new component 'componentname' for 
         library 'libraryname'
     """
     librarypath = settings.active_library.getLibraryPath(libraryname)
     componentpath = os.path.join(librarypath,componentname)
     # verify if component and version exist
     if sy.fileExist(os.path.join(componentpath,versionname+XMLEXT)):
             settings.active_component = None
             raise Error("Component version "+componentname+"."+versionname+\
                         " already exist")
     # make directories if component is really new
     if not sy.dirExist(componentpath):
         sy.makeDirectory(componentpath)
         sy.makeDirectory(os.path.join(componentpath,"hdl"))
         sy.makeDirectory(os.path.join(componentpath,"doc"))
         sy.makeDirectory(os.path.join(componentpath,"drivers_templates"))
     
     # create xml file
     WrapperXml.__init__(self,nodename="component")
     self.setName(componentname)
     self.saveComponent(os.path.join(componentpath,versionname))
     self.setVersionName(versionname)

    def __init__(self, projectpathname, void=0,
                 description="insert a description here"):
        """ create project if doesn't exist
        """
        self.void = void
        WrapperXml.__init__(self, nodename="void")
        self._instanceslist = []
        self._vhdl_version = "vhdl87"

        self.simulation = None
        self.synthesis = None
        self.driver = None

        self._library = Library(self)

        self.bspdir = None
        self.bspos = None
        if not self.void:
            if projectpathname.find(XMLEXT) >= 0:
                try:
                    self._projectpath =\
                        os.path.abspath(os.path.dirname(projectpathname))
                except IOError as error:
                    raise PodError(str(error), 0)
            else:
                self._projectpath = projectpathname
            SETTINGS.projectpath = self.projectpath
            SETTINGS.author = ""
            SETTINGS.active_project = self
            name = os.path.basename(projectpathname)
            if sy.file_exist(projectpathname):
                self.load_project(projectpathname)
            else:
                self.create_project(name)
            self.description = description

            SETTINGS.active_project = self