from PLCControler import UndoBuffer

CODEFILE_XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

<xsd:element name="%(codefile_name)s">

<xsd:complexType>

<xsd:sequence>

[SECTION_TAG_ELEMENT % name

for name in self.SECTIONS_NAMES if name != "includes"])

CODEFILE_XSD % sections_str)

filepath = self.CodeFileName()

if os.path.isfile(filepath):

xmlfile = open(filepath, 'r')

xmlfile.close()

else:

self.CreateCodeFileBuffer(False)

self.OnCTNSave()

def SetVariables(self, variables):

self.CodeFile.variables.setvariable([])

for var in variables:

variable.setname(var["Name"])

variable.settype(var["Type"])

variable.setinitial(var["Initial"])

def GetVariables(self):

datas = []

datas.append({"Name" : var.getname(),

"Type" : var.gettype(),

"Initial" : var.getinitial()})

for section in self.SECTIONS_NAMES:

section_code = parts.get(section)

if section_code is not None:

def GetTextParts(self):

for section in self.SECTIONS_NAMES])

def CTNTestModified(self):

def OnCTNSave(self, from_project_path=None):

filepath = self.CodeFileName()

xmlfile = open(filepath,"w")

xmlfile.close()

self.MarkCodeFileAsSaved()

return [(variable.getname(),

variable.gettype(),

variable.getinitial())

#-------------------------------------------------------------------------------

# Current Buffering Management Functions

#-------------------------------------------------------------------------------

"""

Return a copy of the codefile model

"""

def Copy(self, model):

def CreateCodeFileBuffer(self, saved):

self.Buffering = False

def BufferCodeFile(self):

def StartBuffering(self):

self.Buffering = True

def EndBuffering(self):

if self.Buffering:

self.Buffering = False

def MarkCodeFileAsSaved(self):

def LoadPrevious(self):

self.EndBuffering()

def LoadNext(self):

def GetBufferState(self):

first = self.CodeFileBuffer.IsFirst() and not self.Buffering

import os,traceback,types

import shutil

from util.misc import GetClassImporter

from PLCControler import PLCControler, LOCATION_CONFNODE

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

<xsd:element name="BaseParams">

<xsd:complexType>

<xsd:attribute name="Enabled" type="xsd:boolean" use="optional" default="true"/>

</xsd:complexType>

</xsd:element>

NameTypeSeparator = '@'

def _AddParamsMembers(self):

self.CTNParams = None

if self.XSD:

def __init__(self):

# Create BaseParam

self.MandatoryParams = ("BaseParams", self.BaseParams)

self._AddParamsMembers()

self.Children = {}

# generate XML for base XML parameters controller of the confnode

if self.MandatoryParams:

BaseXMLFile = open(self.ConfNodeBaseXmlFilePath(),'w')

BaseXMLFile.close()

# generate XML for XML parameters controller of the confnode

if self.CTNParams:

XMLFile = open(self.ConfNodeXmlFilePath(),'w')

XMLFile.close()

# Call the confnode specific OnCTNSave method

if self.MandatoryParams:

try:

basexmlfile = open(self.ConfNodeBaseXmlFilePath(CTNName), 'r')

basexmlfile.close()

except Exception, exc:

self.GetCTRoot().logger.write_error(_("Couldn't load confnode base parameters %s :\n %s") % (CTNName, unicode(exc)))

if self.CTNParams:

try:

xmlfile = open(self.ConfNodeXmlFilePath(CTNName), 'r')

xmlfile.close()

except Exception, exc:

self.GetCTRoot().logger.write_error(_("Couldn't load confnode parameters %s :\n %s") % (CTNName, unicode(exc)))

tempvar = PLCOpenParser.CreateElement("variable", "globalVars")

tempvar.setname(var_name)

if var_type in self.GetBaseTypes():

var_type.lower()

if var_type in ["STRING", "WSTRING"]

else var_type, "dataType"))

varlists = [(varlist, varlist.getvariable()[:]) for varlist in configuration.getglobalVars()]

extra_variables = self.Controler.GetConfigurationExtraVariables()

# Generate any global variable in configuration

for varlist, varlist_variables in varlists:

(var.gettypeAsText(), (tagname, variable_type, var_number, "type"))]

# Generate variable initial value if exists

initial = var.getinitialValue()

config += [(" := ", ()),

(self.ComputeValue(initial.getvalue(), var_type), (tagname, variable_type, var_number, "initial value"))]

config += [(";\n", ())]

var_number += 1

config += [(" END_VAR\n", ())]

# Generate any resource in the configuration

for resource in configuration.getresource():

config += self.GenerateResource(resource, configuration.getname())

(var.gettypeAsText(), (tagname, variable_type, var_number, "type"))]

# Generate variable initial value if exists

initial = var.getinitialValue()

resrce += [(" := ", ()),

(self.ComputeValue(initial.getvalue(), var_type), (tagname, variable_type, var_number, "initial value"))]

resrce += [(";\n", ())]

args = []

single = task.getsingle()

# Single argument if exists

resrce += [("SINGLE := ", ()),

(single, (tagname, "task", task_number, "single")),

(",", ())]

# Interval argument if exists

interval = task.getinterval()

resrce += [("INTERVAL := ", ()),

(interval, (tagname, "task", task_number, "interval")),

(",", ())]

def GetTarget(self):

target = self.BeremizRoot.getTargetType()

if target.getcontent() is None:

target_name = self.GetDefaultTargetName()

return target

def GetParamsAttributes(self, path = None):

Return a Builder (compile C code into machine code)

"""

# Get target, module and class name

targetclass = targets.GetBuilder(targetname)

# if target already

"init_calls":"\n",

"cleanup_calls":"\n"

}

plc_main_code += targets.GetCode("plc_main_tail")

return plc_main_code

"publishFunction"]

EditorType = CFileEditor

def GetIconName(self):

return "Cfile"

# Adding includes

text += "/* User includes */\n"

text += "\n"

text += '#include "iec_types_all.h"\n\n'

# Adding user global variables and routines

text += "/* User internal user variables and routines */\n"

text += "\n"

# Adding Beremiz confnode functions

text += "/* Beremiz confnode functions */\n"

text += "int __init_%s(int argc,char **argv)\n{\n"%location_str

text += " return 0;\n}\n\n"

text += "void __cleanup_%s(void)\n{\n"%location_str

text += "\n}\n\n"

text += "void __retrieve_%s(void)\n{\n"%location_str

text += "\n}\n\n"

text += "void __publish_%s(void)\n{\n"%location_str

text += "\n}\n\n"

Gen_Cfile_path = os.path.join(buildpath, "CFile_%s.c"%location_str)

def GetChoiceCallBackFunction(self, choicectrl, path):

def OnChoiceChanged(event):

res = self.SetConfNodeParamsAttribute(path, choicectrl.GetStringSelection())

choicectrl.SetStringSelection(res)

event.Skip()

return OnChoiceChanged

from CodeFileTreeNode import CodeFile

class PythonFileCTNMixin(CodeFile):

filepath = self.PythonFileName()

if os.path.isfile(filepath):

xmlfile = open(filepath, 'r')

xmlfile.close()

def CodeFileName(self):

return os.path.join(self.CTNPath(), "pyfile.xml")

PostSectionsTexts = {}

def GetSection(self,section):

return self.PreSectionsTexts.get(section,"") + "\n" + \

self.PostSectionsTexts.get(section,"")

<?xml version="1.0" encoding="ISO-8859-1" ?>

<xsd:element name="Python">

</xsd:schema>

"""

Returns list of builder specific CFLAGS

"""

def getBuilderLDFLAGS(self):

"""

Returns list of builder specific LDFLAGS

"""

return self.CTRInstance.LDFLAGS + \

def GetBinaryCode(self):

try:

def build(self):

# Retrieve toolchain user parameters

self.compiler = toolchain_params.getCompiler()

self.linker = toolchain_params.getLinker()

value = infos["elmt_type"]["initial"]()

if infos["type"] != ANY:

DefaultElementClass.__setattr__(value, "tag", element_name)

return value

return [initial_value() for i in xrange(infos["minOccurs"])]

else:

if choices_dict.has_key(choice_name):

raise ValueError("'%s' element defined two times in choice" % choice_name)

choices_dict[choice_name] = infos

def GetContentInitial():

content_name, infos = choices[0]

classmembers["set%s" % elmtname] = generateSetMethod(elmtname)

classmembers["get%s" % elmtname] = generateGetMethod(elmtname)

classmembers["getElementAttributes"] = generateGetElementAttributes(self, classinfos)

classmembers["getElementInfos"] = generateGetElementInfos(self, classinfos)

classmembers["setElementValue"] = generateSetElementValue(self, classinfos)

element_infos["elmt_type"]["generate"](self, value)

else:

if name != "content"

else elements["content"]["elmt_type"]["choices_xpath"].path)

element_idx = elements.keys().index(name)

if element_idx > 0:

previous_elements_xpath = "|".join(map(

if x != "content"

else elements["content"]["elmt_type"]["choices_xpath"].path,

elements.keys()[:element_idx]))

elements[parts[0]]["elmt_type"]["facets"])

value = getattr(self, parts[0], "")

elif parts[0] == "content":

else:

attr = getattr(self, parts[0], None)

if attr is None:

return attr.getElementInfos(parts[0], parts[1])

elif elements.has_key("content"):

if len(parts) > 0:

elif classinfos.has_key("base"):

classinfos["base"].getElementInfos(name, path)

else:

if self.content is None:

value = ""

else:

elif element["elmt_type"]["type"] == SIMPLETYPE:

children.append({"name": element_name, "require": element["minOccurs"] != 0,

"type": gettypeinfos(element["elmt_type"]["basename"],

instance.setElementValue(None, value)

elif elements.has_key("content"):

if len(parts) > 0:

elif classinfos.has_key("base"):

classinfos["base"].setElementValue(self, path, value)

elif elements.has_key("content"):

if value == "":

if elements["content"]["minOccurs"] == 0:

else:

raise ValueError("\"content\" element is required!")

else:

def generateInitMethod(factory, classinfos):

def initMethod(self):

if classinfos.has_key("base"):

for attribute in classinfos["attributes"]:

attribute["attr_type"] = FindTypeInfos(factory, attribute["attr_type"])

if attribute["use"] == "required":

value = infos["elmt_type"]["initial"]()

DefaultElementClass.__setattr__(value, "tag", factory.etreeNamespaceFormat % attr)

setattr(self, attr, value)

else:

raise ValueError("Invalid class attribute!")

return addMethod

raise ValueError("Unknown \"%s\" choice type for \"content\"!" % content_type)

choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])

new_content = choices[content_type]["elmt_type"]["initial"]()

self.content = new_content

return new_content

return setChoiceMethod

choices[content_type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])

if maxOccurs == "unbounded" or len(self.content) < maxOccurs:

new_element = choices[content_type]["elmt_type"]["initial"]()

self.appendcontent(new_element)

return new_element

else:

choices[type]["elmt_type"] = FindTypeInfos(factory, choices[content_type]["elmt_type"])

if maxOccurs == "unbounded" or len(self.content) < maxOccurs:

new_element = choices[content_type]["elmt_type"]["initial"]()

self.insertcontent(index, new_element)

return new_element

else:

class DefaultElementClass(etree.ElementBase):

pass

def getLocalTag(self):

root = self.makeelement(

self.DefaultNamespaceFormat % self.BaseClass[0],

nsmap=self.RootNSMAP)

return root

return None

def CreateElement(self, element_tag, parent_tag=None):

new_element = self.GetElementClass(element_tag, parent_tag)()

DefaultElementClass.__setattr__(new_element, "tag", self.DefaultNamespaceFormat % element_tag)

return new_element

def GenerateParser(factory, xsdstring):

ComputedClasses = factory.CreateClasses()

if factory.FileName is not None and len(ComputedClasses) == 1:

ComputedClasses = ComputedClasses[factory.FileName]

UpdateXMLClassGlobals(ComputedClasses)

parser = XMLClassParser(

factory.BlockDefault = attributes["blockDefault"]

factory.FinalDefault = attributes["finalDefault"]

if factory.TargetNamespace is not None:

factory.Namespaces[factory.TargetNamespace] = {}

annotations, children = factory.ReduceElements(elements, True)

This function generate a xml from the xsd given as a string

"""

def GenerateParserFromXSDstring(xsdstring):

#-------------------------------------------------------------------------------

"anyType": {"type": COMPLEXTYPE, "extract": lambda x:None},

}