1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

    26

import os, re, traceback

    27

    28

from copy import deepcopy

    29

from lxml import etree

    30

from xmlclass import GenerateParserFromXSDstring

    31

    32

from PLCControler import UndoBuffer

    33

from ConfigTreeNode import XSDSchemaErrorMessage

    34

    35

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

    36

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

    37

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

    38

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

    39

    <xsd:complexType>

    40

      <xsd:sequence>

    41

        %(includes_section)s

    42

        <xsd:element name="variables">

    43

          <xsd:complexType>

    44

            <xsd:sequence>

    45

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

    46

                <xsd:complexType>

    47

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

    48

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

    49

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

    50

                    <xsd:simpleType>

    51

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

    52

                        <xsd:enumeration value="input"/>

    53

                        <xsd:enumeration value="memory"/>

    54

                        <xsd:enumeration value="output"/>

    55

                      </xsd:restriction>

    56

                    </xsd:simpleType>

    57

                  </xsd:attribute>

    58

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

    59

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

    60

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

    61

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

    62

                </xsd:complexType>

    63

              </xsd:element>

    64

            </xsd:sequence>

    65

          </xsd:complexType>

    66

        </xsd:element>

    67

        %(sections)s

    68

      </xsd:sequence>

    69

    </xsd:complexType>

    70

  </xsd:element>

    71

  <xsd:complexType name="CodeText">

    72

    <xsd:annotation>

    73

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

    74

    </xsd:annotation>

    75

    <xsd:sequence>

    76

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

    77

    </xsd:sequence>

    78

  </xsd:complexType>

    79

</xsd:schema>"""

    80

    81

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

    82

    83

class CodeFile:

    84

    85

    CODEFILE_NAME = "CodeFile"

    86

    SECTIONS_NAMES = []

    87

    88

    def __init__(self):

    89

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    90

        if "includes" in self.SECTIONS_NAMES:

    91

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

    92

        else:

    93

            sections_str["includes_section"] = ""

    94

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

    95

            [SECTION_TAG_ELEMENT % name

    96

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

    97

    98

        self.CodeFileParser = GenerateParserFromXSDstring(

    99

            CODEFILE_XSD % sections_str)

   100

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

   101

   102

        filepath = self.CodeFileName()

   103

   104

        if os.path.isfile(filepath):

   105

            xmlfile = open(filepath, 'r')

   106

            codefile_xml = xmlfile.read()

   107

            xmlfile.close()

   108

   109

            codefile_xml = codefile_xml.replace(

   110

                '<%s>' % self.CODEFILE_NAME, 

   111

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

   112

            for cre, repl in [

   113

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

   114

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

   115

                codefile_xml = cre.sub(repl, codefile_xml)

   116

   117

            try:

   118

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

   119

                if error is not None:

   120

                    self.GetCTRoot().logger.write_warning(

   121

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

   122

                self.CreateCodeFileBuffer(True)

   123

            except Exception, exc:

   124

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

   125

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

   126

        else:

   127

            self.CodeFile = self.CodeFileParser.CreateRoot()

   128

            self.CreateCodeFileBuffer(False)

   129

            self.OnCTNSave()

   130

   131

    def GetBaseTypes(self):

   132

        return self.GetCTRoot().GetBaseTypes()

   133

   134

    def GetDataTypes(self, basetypes = False):

   135

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

   136

   137

    def GenerateNewName(self, format, start_idx):

   138

        return self.GetCTRoot().GenerateNewName(

   139

            None, None, format, start_idx,

   140

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

   141

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

   142

   143

    def SetVariables(self, variables):

   144

        self.CodeFile.variables.setvariable([])

   145

        for var in variables:

   146

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

   147

            variable.setname(var["Name"])

   148

            variable.settype(var["Type"])

   149

            variable.setinitial(var["Initial"])

   150

            variable.setdesc(var["Description"])

   151

            variable.setonchange(var["OnChange"])

   152

            variable.setopts(var["Options"])

   153

            self.CodeFile.variables.appendvariable(variable)

   154

   155

    def GetVariables(self):

   156

        datas = []

   157

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

   158

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

   159

                          "Type" : var.gettype(), 

   160

                          "Initial" : var.getinitial(),

   161

                          "Description" : var.getdesc(),

   162

                          "OnChange"    : var.getonchange(),

   163

                          "Options"     : var.getopts(),

   164

                         })

   165

        return datas

   166

   167

    def SetTextParts(self, parts):

   168

        for section in self.SECTIONS_NAMES:

   169

            section_code = parts.get(section)

   170

            if section_code is not None:

   171

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

   172

   173

    def GetTextParts(self):

   174

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

   175

                     for section in self.SECTIONS_NAMES])

   176

   177

    def CTNTestModified(self):

   178

        return self.ChangesToSave or not self.CodeFileIsSaved()    

   179

   180

    def OnCTNSave(self, from_project_path=None):

   181

        filepath = self.CodeFileName()

   182

   183

        xmlfile = open(filepath,"w")

   184

        xmlfile.write(etree.tostring(

   185

            self.CodeFile, 

   186

            pretty_print=True, 

   187

            xml_declaration=True, 

   188

            encoding='utf-8'))

   189

        xmlfile.close()

   190

   191

        self.MarkCodeFileAsSaved()

   192

        return True

   193

   194

    def CTNGlobalInstances(self):

   195

        variables = self.CodeFileVariables(self.CodeFile)

   196

        ret =  [(variable.getname(),

   197

                 variable.gettype(),

   198

                 variable.getinitial()) 

   199

                for variable in variables]

   200

        ret.extend([("On"+variable.getname()+"Change", "python_poll", "")

   201

                for variable in variables

   202

                if variable.getonchange()])

   203

        return ret

   204

   205

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

   206

#                      Current Buffering Management Functions

   207

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

   208

   209

    """

   210

    Return a copy of the codefile model

   211

    """

   212

    def Copy(self, model):

   213

        return deepcopy(model)

   214

   215

    def CreateCodeFileBuffer(self, saved):

   216

        self.Buffering = False

   217

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

   218

   219

    def BufferCodeFile(self):

   220

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

   221

   222

    def StartBuffering(self):

   223

        self.Buffering = True

   224

   225

    def EndBuffering(self):

   226

        if self.Buffering:

   227

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

   228

            self.Buffering = False

   229

   230

    def MarkCodeFileAsSaved(self):

   231

        self.EndBuffering()

   232

        self.CodeFileBuffer.CurrentSaved()

   233

   234

    def CodeFileIsSaved(self):

   235

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

   236

   237

    def LoadPrevious(self):

   238

        self.EndBuffering()

   239

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

   240

   241

    def LoadNext(self):

   242

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

   243

   244

    def GetBufferState(self):

   245

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

   246

        last = self.CodeFileBuffer.IsLast()

   247

        return not first, not last

   248