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

from __future__ import absolute_import

    27

import os

    28

import re

    29

import traceback

    30

from builtins import str as text

    31

from copy import deepcopy

    32

    33

from lxml import etree

    34

from xmlclass import GenerateParserFromXSDstring

    35

    36

from PLCControler import UndoBuffer

    37

from ConfigTreeNode import XSDSchemaErrorMessage

    38

    39

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

    40

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

    41

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

    42

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

    43

    <xsd:complexType>

    44

      <xsd:sequence>

    45

        %(includes_section)s

    46

        <xsd:element name="variables">

    47

          <xsd:complexType>

    48

            <xsd:sequence>

    49

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

    50

                <xsd:complexType>

    51

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

    52

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

    53

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

    54

                    <xsd:simpleType>

    55

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

    56

                        <xsd:enumeration value="input"/>

    57

                        <xsd:enumeration value="memory"/>

    58

                        <xsd:enumeration value="output"/>

    59

                      </xsd:restriction>

    60

                    </xsd:simpleType>

    61

                  </xsd:attribute>

    62

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

    63

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

    64

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

    65

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

    66

                </xsd:complexType>

    67

              </xsd:element>

    68

            </xsd:sequence>

    69

          </xsd:complexType>

    70

        </xsd:element>

    71

        %(sections)s

    72

      </xsd:sequence>

    73

    </xsd:complexType>

    74

  </xsd:element>

    75

  <xsd:complexType name="CodeText">

    76

    <xsd:annotation>

    77

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

    78

    </xsd:annotation>

    79

    <xsd:sequence>

    80

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

    81

    </xsd:sequence>

    82

  </xsd:complexType>

    83

</xsd:schema>"""

    84

    85

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

    86

    87

    88

class CodeFile(object):

    89

    90

    CODEFILE_NAME = "CodeFile"

    91

    SECTIONS_NAMES = []

    92

    93

    def __init__(self):

    94

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    95

        if "includes" in self.SECTIONS_NAMES:

    96

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

    97

        else:

    98

            sections_str["includes_section"] = ""

    99

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

   100

            [SECTION_TAG_ELEMENT % name

   101

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

   102

   103

        self.CodeFileParser = GenerateParserFromXSDstring(

   104

            CODEFILE_XSD % sections_str)

   105

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

   106

   107

        filepath = self.CodeFileName()

   108

        if os.path.isfile(filepath):

   109

            xmlfile = open(filepath, 'r')

   110

            codefile_xml = xmlfile.read()

   111

            xmlfile.close()

   112

   113

            codefile_xml = codefile_xml.replace(

   114

                '<%s>' % self.CODEFILE_NAME,

   115

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

   116

            for cre, repl in [

   117

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

   118

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

   119

                codefile_xml = cre.sub(repl, codefile_xml)

   120

   121

            try:

   122

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

   123

                if error is not None:

   124

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

   125

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

   126

                self.CreateCodeFileBuffer(True)

   127

            except Exception as exc:

   128

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

   129

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

   130

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

   131

                raise Exception

   132

        else:

   133

            self.CodeFile = self.CodeFileParser.CreateRoot()

   134

            self.CreateCodeFileBuffer(False)

   135

            self.OnCTNSave()

   136

   137

    def GetBaseTypes(self):

   138

        return self.GetCTRoot().GetBaseTypes()

   139

   140

    def GetDataTypes(self, basetypes=False):

   141

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

   142

   143

    def GenerateNewName(self, name, format):

   144

        return self.GetCTRoot().GenerateNewName(

   145

            None, name, format,

   146

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

   147

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

   148

   149

    def SetVariables(self, variables):

   150

        self.CodeFile.variables.setvariable([])

   151

        for var in variables:

   152

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

   153

            variable.setname(var["Name"])

   154

            variable.settype(var["Type"])

   155

            variable.setinitial(var["Initial"])

   156

            variable.setdesc(var["Description"])

   157

            variable.setonchange(var["OnChange"])

   158

            variable.setopts(var["Options"])

   159

            self.CodeFile.variables.appendvariable(variable)

   160

   161

    def GetVariables(self):

   162

        datas = []

   163

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

   164

            datas.append({

   165

                "Name":        var.getname(),

   166

                "Type":        var.gettype(),

   167

                "Initial":     var.getinitial(),

   168

                "Description": var.getdesc(),

   169

                "OnChange":    var.getonchange(),

   170

                "Options":     var.getopts(),

   171

            })

   172

        return datas

   173

   174

    def SetTextParts(self, parts):

   175

        for section in self.SECTIONS_NAMES:

   176

            section_code = parts.get(section)

   177

            if section_code is not None:

   178

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

   179

   180

    def GetTextParts(self):

   181

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

   182

                     for section in self.SECTIONS_NAMES])

   183

   184

    def CTNTestModified(self):

   185

        return self.ChangesToSave or not self.CodeFileIsSaved()

   186

   187

    def OnCTNSave(self, from_project_path=None):

   188

        filepath = self.CodeFileName()

   189

   190

        xmlfile = open(filepath, "w")

   191

        xmlfile.write(etree.tostring(

   192

            self.CodeFile,

   193

            pretty_print=True,

   194

            xml_declaration=True,

   195

            encoding='utf-8'))

   196

        xmlfile.close()

   197

   198

        self.MarkCodeFileAsSaved()

   199

        return True

   200

   201

    def CTNGlobalInstances(self):

   202

        variables = self.CodeFileVariables(self.CodeFile)

   203

        ret = [(variable.getname(),

   204

                variable.gettype(),

   205

                variable.getinitial())

   206

               for variable in variables]

   207

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

   208

                    for variable in variables

   209

                    if variable.getonchange()])

   210

        return ret

   211

   212

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

   213

#                      Current Buffering Management Functions

   214

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

   215

   216

    def Copy(self, model):

   217

        """

   218

        Return a copy of the codefile model

   219

        """

   220

        return deepcopy(model)

   221

   222

    def CreateCodeFileBuffer(self, saved):

   223

        self.Buffering = False

   224

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

   225

   226

    def BufferCodeFile(self):

   227

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

   228

   229

    def StartBuffering(self):

   230

        self.Buffering = True

   231

   232

    def EndBuffering(self):

   233

        if self.Buffering:

   234

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

   235

            self.Buffering = False

   236

   237

    def MarkCodeFileAsSaved(self):

   238

        self.EndBuffering()

   239

        self.CodeFileBuffer.CurrentSaved()

   240

   241

    def CodeFileIsSaved(self):

   242

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

   243

   244

    def LoadPrevious(self):

   245

        self.EndBuffering()

   246

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

   247

   248

    def LoadNext(self):

   249

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

   250

   251

    def GetBufferState(self):

   252

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

   253

        last = self.CodeFileBuffer.IsLast()

   254

        return not first, not last