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

                    (fname, lnum, src) = ((self.CODEFILE_NAME,) + error)

   121

                    self.GetCTRoot().logger.write_warning(XSDSchemaErrorMessage.format(a1 = fname, a2 = lnum, a3 = src))

   122

                self.CreateCodeFileBuffer(True)

   123

            except Exception, exc:

   124

                msg = _("Couldn't load confnode parameters {a1} :\n {a2}").format(a1 = CTNName, a2 = unicode(exc))

   125

                self.GetCTRoot().logger.write_error(msg)

   126

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

   127

        else:

   128

            self.CodeFile = self.CodeFileParser.CreateRoot()

   129

            self.CreateCodeFileBuffer(False)

   130

            self.OnCTNSave()

   131

   132

    def GetBaseTypes(self):

   133

        return self.GetCTRoot().GetBaseTypes()

   134

   135

    def GetDataTypes(self, basetypes = False):

   136

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

   137

   138

    def GenerateNewName(self, format, start_idx):

   139

        return self.GetCTRoot().GenerateNewName(

   140

            None, None, format, start_idx,

   141

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

   142

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

   143

   144

    def SetVariables(self, variables):

   145

        self.CodeFile.variables.setvariable([])

   146

        for var in variables:

   147

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

   148

            variable.setname(var["Name"])

   149

            variable.settype(var["Type"])

   150

            variable.setinitial(var["Initial"])

   151

            variable.setdesc(var["Description"])

   152

            variable.setonchange(var["OnChange"])

   153

            variable.setopts(var["Options"])

   154

            self.CodeFile.variables.appendvariable(variable)

   155

   156

    def GetVariables(self):

   157

        datas = []

   158

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

   159

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

   160

                          "Type" : var.gettype(), 

   161

                          "Initial" : var.getinitial(),

   162

                          "Description" : var.getdesc(),

   163

                          "OnChange"    : var.getonchange(),

   164

                          "Options"     : var.getopts(),

   165

                         })

   166

        return datas

   167

   168

    def SetTextParts(self, parts):

   169

        for section in self.SECTIONS_NAMES:

   170

            section_code = parts.get(section)

   171

            if section_code is not None:

   172

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

   173

   174

    def GetTextParts(self):

   175

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

   176

                     for section in self.SECTIONS_NAMES])

   177

   178

    def CTNTestModified(self):

   179

        return self.ChangesToSave or not self.CodeFileIsSaved()    

   180

   181

    def OnCTNSave(self, from_project_path=None):

   182

        filepath = self.CodeFileName()

   183

   184

        xmlfile = open(filepath,"w")

   185

        xmlfile.write(etree.tostring(

   186

            self.CodeFile, 

   187

            pretty_print=True, 

   188

            xml_declaration=True, 

   189

            encoding='utf-8'))

   190

        xmlfile.close()

   191

   192

        self.MarkCodeFileAsSaved()

   193

        return True

   194

   195

    def CTNGlobalInstances(self):

   196

        variables = self.CodeFileVariables(self.CodeFile)

   197

        ret =  [(variable.getname(),

   198

                 variable.gettype(),

   199

                 variable.getinitial()) 

   200

                for variable in variables]

   201

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

   202

                for variable in variables

   203

                if variable.getonchange()])

   204

        return ret

   205

   206

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

   207

#                      Current Buffering Management Functions

   208

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

   209

   210

    """

   211

    Return a copy of the codefile model

   212

    """

   213

    def Copy(self, model):

   214

        return deepcopy(model)

   215

   216

    def CreateCodeFileBuffer(self, saved):

   217

        self.Buffering = False

   218

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

   219

   220

    def BufferCodeFile(self):

   221

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

   222

   223

    def StartBuffering(self):

   224

        self.Buffering = True

   225

   226

    def EndBuffering(self):

   227

        if self.Buffering:

   228

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

   229

            self.Buffering = False

   230

   231

    def MarkCodeFileAsSaved(self):

   232

        self.EndBuffering()

   233

        self.CodeFileBuffer.CurrentSaved()

   234

   235

    def CodeFileIsSaved(self):

   236

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

   237

   238

    def LoadPrevious(self):

   239

        self.EndBuffering()

   240

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

   241

   242

    def LoadNext(self):

   243

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

   244

   245

    def GetBufferState(self):

   246

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

   247

        last = self.CodeFileBuffer.IsLast()

   248

        return not first, not last

   249