1

import os, re, traceback

     2

     3

from copy import deepcopy

     4

from lxml import etree

     5

from xmlclass import GenerateParserFromXSDstring

     6

     7

from PLCControler import UndoBuffer

     8

from ConfigTreeNode import XSDSchemaErrorMessage

     9

    10

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

    11

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

    12

            xmlns:xhtml="http://www.w3.org/1999/xhtml">

    13

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

    14

    <xsd:complexType>

    15

      <xsd:sequence>

    16

        %(includes_section)s

    17

        <xsd:element name="variables">

    18

          <xsd:complexType>

    19

            <xsd:sequence>

    20

              <xsd:element name="variable" minOccurs="0" maxOccurs="unbounded">

    21

                <xsd:complexType>

    22

                  <xsd:attribute name="name" type="xsd:string" use="required"/>

    23

                  <xsd:attribute name="type" type="xsd:string" use="required"/>

    24

                  <xsd:attribute name="class" use="optional">

    25

                    <xsd:simpleType>

    26

                      <xsd:restriction base="xsd:string">

    27

                        <xsd:enumeration value="input"/>

    28

                        <xsd:enumeration value="memory"/>

    29

                        <xsd:enumeration value="output"/>

    30

                      </xsd:restriction>

    31

                    </xsd:simpleType>

    32

                  </xsd:attribute>

    33

                  <xsd:attribute name="initial" type="xsd:string" use="optional" default=""/>

    34

                </xsd:complexType>

    35

              </xsd:element>

    36

            </xsd:sequence>

    37

          </xsd:complexType>

    38

        </xsd:element>

    39

        %(sections)s

    40

      </xsd:sequence>

    41

    </xsd:complexType>

    42

  </xsd:element>

    43

  <xsd:complexType name="CodeText">

    44

    <xsd:annotation>

    45

      <xsd:documentation>Formatted text according to parts of XHTML 1.1</xsd:documentation>

    46

    </xsd:annotation>

    47

    <xsd:sequence>

    48

      <xsd:any namespace="http://www.w3.org/1999/xhtml" processContents="lax"/>

    49

    </xsd:sequence>

    50

  </xsd:complexType>

    51

</xsd:schema>"""

    52

    53

SECTION_TAG_ELEMENT = "<xsd:element name=\"%s\" type=\"CodeText\"/>"

    54

    55

class CodeFile:

    56

    57

    CODEFILE_NAME = "CodeFile"

    58

    SECTIONS_NAMES = []

    59

    60

    def __init__(self):

    61

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    62

        if "includes" in self.SECTIONS_NAMES:

    63

            sections_str["includes_section"] = SECTION_TAG_ELEMENT % "includes"

    64

        else:

    65

            sections_str["includes_section"] = ""

    66

        sections_str["sections"] = "\n".join(

    67

            [SECTION_TAG_ELEMENT % name

    68

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

    69

    70

        self.CodeFileParser = GenerateParserFromXSDstring(

    71

            CODEFILE_XSD % sections_str)

    72

        self.CodeFileVariables = etree.XPath("variables/variable")

    73

    74

        filepath = self.CodeFileName()

    75

    76

        if os.path.isfile(filepath):

    77

            xmlfile = open(filepath, 'r')

    78

            codefile_xml = xmlfile.read()

    79

            xmlfile.close()

    80

    81

            codefile_xml = codefile_xml.replace(

    82

                '<%s>' % self.CODEFILE_NAME, 

    83

                '<%s xmlns:xhtml="http://www.w3.org/1999/xhtml">' % self.CODEFILE_NAME)

    84

            for cre, repl in [

    85

                (re.compile("(?<!<xhtml:p>)(?:<!\[CDATA\[)"), "<xhtml:p><![CDATA["),

    86

                (re.compile("(?:]]>)(?!</xhtml:p>)"), "]]></xhtml:p>")]:

    87

                codefile_xml = cre.sub(repl, codefile_xml)

    88

    89

            try:

    90

                self.CodeFile, error = self.CodeFileParser.LoadXMLString(codefile_xml)

    91

                if error is not None:

    92

                    self.GetCTRoot().logger.write_warning(

    93

                        XSDSchemaErrorMessage % ((self.CODEFILE_NAME,) + error))

    94

                self.CreateCodeFileBuffer(True)

    95

            except Exception, exc:

    96

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

    97

                self.GetCTRoot().logger.write_error(traceback.format_exc())

    98

        else:

    99

            self.CodeFile = self.CodeFileParser.CreateRoot()

   100

            self.CreateCodeFileBuffer(False)

   101

            self.OnCTNSave()

   102

   103

    def GetBaseTypes(self):

   104

        return self.GetCTRoot().GetBaseTypes()

   105

   106

    def GetDataTypes(self, basetypes = False):

   107

        return self.GetCTRoot().GetDataTypes(basetypes=basetypes)

   108

   109

    def GenerateNewName(self, format, start_idx):

   110

        return self.GetCTRoot().GenerateNewName(

   111

            None, None, format, start_idx,

   112

            dict([(var.getname().upper(), True) 

   113

                  for var in self.CodeFile.variables.getvariable()]))

   114

   115

    def SetVariables(self, variables):

   116

        self.CodeFile.variables.setvariable([])

   117

        for var in variables:

   118

            variable = self.CodeFileParser.CreateElement("variable", "variables")

   119

            variable.setname(var["Name"])

   120

            variable.settype(var["Type"])

   121

            variable.setinitial(var["Initial"])

   122

            self.CodeFile.variables.appendvariable(variable)

   123

   124

    def GetVariables(self):

   125

        datas = []

   126

        for var in self.CodeFileVariables(self.CodeFile):

   127

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

   128

                          "Type" : var.gettype(), 

   129

                          "Initial" : var.getinitial()})

   130

        return datas

   131

   132

    def SetTextParts(self, parts):

   133

        for section in self.SECTIONS_NAMES:

   134

            section_code = parts.get(section)

   135

            if section_code is not None:

   136

                getattr(self.CodeFile, section).setanyText(section_code)

   137

   138

    def GetTextParts(self):

   139

        return dict([(section, getattr(self.CodeFile, section).getanyText())

   140

                     for section in self.SECTIONS_NAMES])

   141

   142

    def CTNTestModified(self):

   143

        return self.ChangesToSave or not self.CodeFileIsSaved()    

   144

   145

    def OnCTNSave(self, from_project_path=None):

   146

        filepath = self.CodeFileName()

   147

   148

        xmlfile = open(filepath,"w")

   149

        xmlfile.write(etree.tostring(

   150

            self.CodeFile, 

   151

            pretty_print=True, 

   152

            xml_declaration=True, 

   153

            encoding='utf-8'))

   154

        xmlfile.close()

   155

   156

        self.MarkCodeFileAsSaved()

   157

        return True

   158

   159

    def CTNGlobalInstances(self):

   160

        current_location = self.GetCurrentLocation()

   161

        return [(variable.getname(),

   162

                 variable.gettype(),

   163

                 variable.getinitial())

   164

                for variable in self.CodeFileVariables(self.CodeFile)]

   165

   166

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

   167

#                      Current Buffering Management Functions

   168

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

   169

   170

    """

   171

    Return a copy of the codefile model

   172

    """

   173

    def Copy(self, model):

   174

        return deepcopy(model)

   175

   176

    def CreateCodeFileBuffer(self, saved):

   177

        self.Buffering = False

   178

        self.CodeFileBuffer = UndoBuffer(self.CodeFileParser.Dumps(self.CodeFile), saved)

   179

   180

    def BufferCodeFile(self):

   181

        self.CodeFileBuffer.Buffering(self.CodeFileParser.Dumps(self.CodeFile))

   182

   183

    def StartBuffering(self):

   184

        self.Buffering = True

   185

   186

    def EndBuffering(self):

   187

        if self.Buffering:

   188

            self.CodeFileBuffer.Buffering(self.CodeFileParser.Dumps(self.CodeFile))

   189

            self.Buffering = False

   190

   191

    def MarkCodeFileAsSaved(self):

   192

        self.EndBuffering()

   193

        self.CodeFileBuffer.CurrentSaved()

   194

   195

    def CodeFileIsSaved(self):

   196

        return self.CodeFileBuffer.IsCurrentSaved() and not self.Buffering

   197

   198

    def LoadPrevious(self):

   199

        self.EndBuffering()

   200

        self.CodeFile = self.CodeFileParser.Loads(self.CodeFileBuffer.Previous())

   201

   202

    def LoadNext(self):

   203

        self.CodeFile = self.CodeFileParser.Loads(self.CodeFileBuffer.Next())

   204

   205

    def GetBufferState(self):

   206

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

   207

        last = self.CodeFileBuffer.IsLast()

   208

        return not first, not last

   209