1

import os, re

     2

     3

from copy import deepcopy

     4

from lxml import etree

     5

from xmlclass import GenerateParserFromXSDstring

     6

     7

from PLCControler import UndoBuffer

     8

     9

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

    10

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

    11

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

    12

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

    13

    <xsd:complexType>

    14

      <xsd:sequence>

    15

        %(includes_section)s

    16

        <xsd:element name="variables">

    17

          <xsd:complexType>

    18

            <xsd:sequence>

    19

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

    20

                <xsd:complexType>

    21

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

    22

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

    23

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

    24

                    <xsd:simpleType>

    25

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

    26

                        <xsd:enumeration value="input"/>

    27

                        <xsd:enumeration value="memory"/>

    28

                        <xsd:enumeration value="output"/>

    29

                      </xsd:restriction>

    30

                    </xsd:simpleType>

    31

                  </xsd:attribute>

    32

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

    33

                </xsd:complexType>

    34

              </xsd:element>

    35

            </xsd:sequence>

    36

          </xsd:complexType>

    37

        </xsd:element>

    38

        %(sections)s

    39

      </xsd:sequence>

    40

    </xsd:complexType>

    41

  </xsd:element>

    42

  <xsd:complexType name="CodeText">

    43

    <xsd:annotation>

    44

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

    45

    </xsd:annotation>

    46

    <xsd:sequence>

    47

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

    48

    </xsd:sequence>

    49

  </xsd:complexType>

    50

</xsd:schema>"""

    51

    52

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

    53

    54

class CodeFile:

    55

    56

    CODEFILE_NAME = "CodeFile"

    57

    SECTIONS_NAMES = []

    58

    59

    def __init__(self):

    60

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    61

        if "includes" in self.SECTIONS_NAMES:

    62

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

    63

        else:

    64

            sections_str["includes_section"] = ""

    65

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

    66

            [SECTION_TAG_ELEMENT % name

    67

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

    68

    69

        self.CodeFileParser = GenerateParserFromXSDstring(

    70

            CODEFILE_XSD % sections_str)

    71

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

    72

    73

        filepath = self.CodeFileName()

    74

    75

        if os.path.isfile(filepath):

    76

            xmlfile = open(filepath, 'r')

    77

            codefile_xml = xmlfile.read()

    78

            xmlfile.close()

    79

    80

            codefile_xml = codefile_xml.replace(

    81

                '<%s>' % self.CODEFILE_NAME, 

    82

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

    83

            for cre, repl in [

    84

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

    85

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

    86

                codefile_xml = cre.sub(repl, codefile_xml)

    87

            self.CodeFile = etree.fromstring(codefile_xml, self.CodeFileParser)    

    88

            self.CreateCodeFileBuffer(True)

    89

    90

        else:

    91

            self.CodeFile = self.CodeFileParser.CreateRoot()

    92

            self.CreateCodeFileBuffer(False)

    93

            self.OnCTNSave()

    94

    95

    def GetBaseTypes(self):

    96

        return self.GetCTRoot().GetBaseTypes()

    97

    98

    def GetDataTypes(self, basetypes = False):

    99

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

   100

   101

    def GenerateNewName(self, format, start_idx):

   102

        return self.GetCTRoot().GenerateNewName(

   103

            None, None, format, start_idx,

   104

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

   105

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

   106

   107

    def SetVariables(self, variables):

   108

        self.CodeFile.variables.setvariable([])

   109

        for var in variables:

   110

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

   111

            variable.setname(var["Name"])

   112

            variable.settype(var["Type"])

   113

            variable.setinitial(var["Initial"])

   114

            self.CodeFile.variables.appendvariable(variable)

   115

   116

    def GetVariables(self):

   117

        datas = []

   118

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

   119

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

   120

                          "Type" : var.gettype(), 

   121

                          "Initial" : var.getinitial()})

   122

        return datas

   123

   124

    def SetTextParts(self, parts):

   125

        for section in self.SECTIONS_NAMES:

   126

            section_code = parts.get(section)

   127

            if section_code is not None:

   128

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

   129

   130

    def GetTextParts(self):

   131

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

   132

                     for section in self.SECTIONS_NAMES])

   133

   134

    def CTNTestModified(self):

   135

        return self.ChangesToSave or not self.CodeFileIsSaved()    

   136

   137

    def OnCTNSave(self, from_project_path=None):

   138

        filepath = self.CodeFileName()

   139

   140

        xmlfile = open(filepath,"w")

   141

        xmlfile.write(etree.tostring(

   142

            self.CodeFile, 

   143

            pretty_print=True, 

   144

            xml_declaration=True, 

   145

            encoding='utf-8'))

   146

        xmlfile.close()

   147

   148

        self.MarkCodeFileAsSaved()

   149

        return True

   150

   151

    def CTNGlobalInstances(self):

   152

        current_location = self.GetCurrentLocation()

   153

        return [(variable.getname(),

   154

                 variable.gettype(),

   155

                 variable.getinitial())

   156

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

   157

   158

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

   159

#                      Current Buffering Management Functions

   160

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

   161

   162

    """

   163

    Return a copy of the codefile model

   164

    """

   165

    def Copy(self, model):

   166

        return deepcopy(model)

   167

   168

    def CreateCodeFileBuffer(self, saved):

   169

        self.Buffering = False

   170

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

   171

   172

    def BufferCodeFile(self):

   173

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

   174

   175

    def StartBuffering(self):

   176

        self.Buffering = True

   177

   178

    def EndBuffering(self):

   179

        if self.Buffering:

   180

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

   181

            self.Buffering = False

   182

   183

    def MarkCodeFileAsSaved(self):

   184

        self.EndBuffering()

   185

        self.CodeFileBuffer.CurrentSaved()

   186

   187

    def CodeFileIsSaved(self):

   188

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

   189

   190

    def LoadPrevious(self):

   191

        self.EndBuffering()

   192

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

   193

   194

    def LoadNext(self):

   195

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

   196

   197

    def GetBufferState(self):

   198

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

   199

        last = self.CodeFileBuffer.IsLast()

   200

        return not first, not last

   201