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

    27

import re

    28

import traceback

    29

from copy import deepcopy

    30

    31

from lxml import etree

    32

from xmlclass import GenerateParserFromXSDstring

    33

    34

from PLCControler import UndoBuffer

    35

from ConfigTreeNode import XSDSchemaErrorMessage

    36

    37

from plcopen.plcopen import TestTextElement

    38

from editors.CodeFileEditor import GetSectionsText

    39

    40

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

    41

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

    42

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

    43

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

    44

    <xsd:complexType>

    45

      <xsd:sequence>

    46

        %(includes_section)s

    47

        <xsd:element name="variables">

    48

          <xsd:complexType>

    49

            <xsd:sequence>

    50

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

    51

                <xsd:complexType>

    52

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

    53

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

    54

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

    55

                    <xsd:simpleType>

    56

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

    57

                        <xsd:enumeration value="input"/>

    58

                        <xsd:enumeration value="memory"/>

    59

                        <xsd:enumeration value="output"/>

    60

                      </xsd:restriction>

    61

                    </xsd:simpleType>

    62

                  </xsd:attribute>

    63

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

    64

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

    65

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

    66

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

    67

                </xsd:complexType>

    68

              </xsd:element>

    69

            </xsd:sequence>

    70

          </xsd:complexType>

    71

        </xsd:element>

    72

        %(sections)s

    73

      </xsd:sequence>

    74

    </xsd:complexType>

    75

  </xsd:element>

    76

  <xsd:complexType name="CodeText">

    77

    <xsd:annotation>

    78

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

    79

    </xsd:annotation>

    80

    <xsd:sequence>

    81

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

    82

    </xsd:sequence>

    83

  </xsd:complexType>

    84

</xsd:schema>"""

    85

    86

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

    87

    88

    89

class CodeFile(object):

    90

    91

    CODEFILE_NAME = "CodeFile"

    92

    SECTIONS_NAMES = []

    93

    94

    def __init__(self):

    95

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    96

        if "includes" in self.SECTIONS_NAMES:

    97

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

    98

        else:

    99

            sections_str["includes_section"] = ""

   100

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

   101

            [SECTION_TAG_ELEMENT % name

   102

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

   103

   104

        self.CodeFileParser = GenerateParserFromXSDstring(

   105

            CODEFILE_XSD % sections_str)

   106

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

   107

   108

        filepath = self.CodeFileName()

   109

        if os.path.isfile(filepath):

   110

            xmlfile = open(filepath, 'r')

   111

            codefile_xml = xmlfile.read()

   112

            xmlfile.close()

   113

   114

            codefile_xml = codefile_xml.replace(

   115

                '<%s>' % self.CODEFILE_NAME,

   116

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

   117

            for cre, repl in [

   118

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

   119

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

   120

                codefile_xml = cre.sub(repl, codefile_xml)

   121

   122

            try:

   123

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

   124

                if error is not None:

   125

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

   126

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

   127

                self.CreateCodeFileBuffer(True)

   128

            except Exception as exc:

   129

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

   130

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

   131

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

   132

                raise Exception

   133

        else:

   134

            self.CodeFile = self.CodeFileParser.CreateRoot()

   135

            self.CreateCodeFileBuffer(False)

   136

            self.OnCTNSave()

   137

   138

    def GetBaseTypes(self):

   139

        return self.GetCTRoot().GetBaseTypes()

   140

   141

    def GetDataTypes(self, basetypes=False):

   142

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

   143

   144

    def GenerateNewName(self, name, format):

   145

        return self.GetCTRoot().GenerateNewName(

   146

            None, name, format,

   147

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

   148

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

   149

   150

    def SetVariables(self, variables):

   151

        self.CodeFile.variables.setvariable([])

   152

        for var in variables:

   153

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

   154

            variable.setname(var["Name"])

   155

            variable.settype(var["Type"])

   156

            variable.setinitial(var["Initial"])

   157

            variable.setdesc(var["Description"])

   158

            variable.setonchange(var["OnChange"])

   159

            variable.setopts(var["Options"])

   160

            self.CodeFile.variables.appendvariable(variable)

   161

   162

    def GetVariables(self):

   163

        datas = []

   164

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

   165

            datas.append({

   166

                "Name":        var.getname(),

   167

                "Type":        var.gettype(),

   168

                "Initial":     var.getinitial(),

   169

                "Description": var.getdesc(),

   170

                "OnChange":    var.getonchange(),

   171

                "Options":     var.getopts(),

   172

            })

   173

        return datas

   174

   175

    def SetTextParts(self, parts):

   176

        for section in self.SECTIONS_NAMES:

   177

            section_code = parts.get(section)

   178

            if section_code is not None:

   179

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

   180

   181

    def GetTextParts(self):

   182

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

   183

                     for section in self.SECTIONS_NAMES])

   184

   185

    def CTNTestModified(self):

   186

        return self.ChangesToSave or not self.CodeFileIsSaved()

   187

   188

    def OnCTNSave(self, from_project_path=None):

   189

        filepath = self.CodeFileName()

   190

   191

        xmlfile = open(filepath, "w")

   192

        xmlfile.write(etree.tostring(

   193

            self.CodeFile,

   194

            pretty_print=True,

   195

            xml_declaration=True,

   196

            encoding='utf-8').decode())

   197

        xmlfile.close()

   198

   199

        self.MarkCodeFileAsSaved()

   200

        return True

   201

   202

    def CTNGlobalInstances(self):

   203

        variables = self.CodeFileVariables(self.CodeFile)

   204

        ret = [(variable.getname(),

   205

                variable.gettype(),

   206

                variable.getinitial())

   207

               for variable in variables]

   208

        return ret

   209

   210

    def CTNSearch(self, criteria):

   211

        variables = self.GetVariables()

   212

        results = []

   213

        tagname = self.CTNFullName()

   214

        for index, var in enumerate(variables):

   215

            varname = var["Name"]

   216

            results.extend([((tagname, "var_inout", index, "name"),) + result

   217

                            for result in TestTextElement(varname, criteria)])

   218

        results.extend([((tagname, "body"),) + result

   219

                        for result in TestTextElement(

   220

                            GetSectionsText(self, lambda x:""), criteria)])

   221

        return results

   222

   223

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

   224

#                      Current Buffering Management Functions

   225

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

   226

   227

    def Copy(self, model):

   228

        """

   229

        Return a copy of the codefile model

   230

        """

   231

        return deepcopy(model)

   232

   233

    def CreateCodeFileBuffer(self, saved):

   234

        self.Buffering = False

   235

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

   236

   237

    def BufferCodeFile(self):

   238

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

   239

   240

    def StartBuffering(self):

   241

        self.Buffering = True

   242

   243

    def EndBuffering(self):

   244

        if self.Buffering:

   245

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

   246

            self.Buffering = False

   247

   248

    def MarkCodeFileAsSaved(self):

   249

        self.EndBuffering()

   250

        self.CodeFileBuffer.CurrentSaved()

   251

   252

    def CodeFileIsSaved(self):

   253

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

   254

   255

    def LoadPrevious(self):

   256

        self.EndBuffering()

   257

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

   258

   259

    def LoadNext(self):

   260

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

   261

   262

    def GetBufferState(self):

   263

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

   264

        last = self.CodeFileBuffer.IsLast()

   265

        return not first, not last