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

from plcopen.plcopen import TestTextElement

    40

from editors.CodeFileEditor import GetSectionsText

    41

    42

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

    43

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

    44

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

    45

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

    46

    <xsd:complexType>

    47

      <xsd:sequence>

    48

        %(includes_section)s

    49

        <xsd:element name="variables">

    50

          <xsd:complexType>

    51

            <xsd:sequence>

    52

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

    53

                <xsd:complexType>

    54

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

    55

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

    56

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

    57

                    <xsd:simpleType>

    58

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

    59

                        <xsd:enumeration value="input"/>

    60

                        <xsd:enumeration value="memory"/>

    61

                        <xsd:enumeration value="output"/>

    62

                      </xsd:restriction>

    63

                    </xsd:simpleType>

    64

                  </xsd:attribute>

    65

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

    66

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

    67

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

    68

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

    69

                </xsd:complexType>

    70

              </xsd:element>

    71

            </xsd:sequence>

    72

          </xsd:complexType>

    73

        </xsd:element>

    74

        %(sections)s

    75

      </xsd:sequence>

    76

    </xsd:complexType>

    77

  </xsd:element>

    78

  <xsd:complexType name="CodeText">

    79

    <xsd:annotation>

    80

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

    81

    </xsd:annotation>

    82

    <xsd:sequence>

    83

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

    84

    </xsd:sequence>

    85

  </xsd:complexType>

    86

</xsd:schema>"""

    87

    88

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

    89

    90

    91

class CodeFile(object):

    92

    93

    CODEFILE_NAME = "CodeFile"

    94

    SECTIONS_NAMES = []

    95

    96

    def __init__(self):

    97

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    98

        if "includes" in self.SECTIONS_NAMES:

    99

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

   100

        else:

   101

            sections_str["includes_section"] = ""

   102

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

   103

            [SECTION_TAG_ELEMENT % name

   104

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

   105

   106

        self.CodeFileParser = GenerateParserFromXSDstring(

   107

            CODEFILE_XSD % sections_str)

   108

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

   109

   110

        filepath = self.CodeFileName()

   111

        if os.path.isfile(filepath):

   112

            xmlfile = open(filepath, 'r')

   113

            codefile_xml = xmlfile.read()

   114

            xmlfile.close()

   115

   116

            codefile_xml = codefile_xml.replace(

   117

                '<%s>' % self.CODEFILE_NAME,

   118

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

   119

            for cre, repl in [

   120

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

   121

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

   122

                codefile_xml = cre.sub(repl, codefile_xml)

   123

   124

            try:

   125

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

   126

                if error is not None:

   127

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

   128

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

   129

                self.CreateCodeFileBuffer(True)

   130

            except Exception as exc:

   131

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

   132

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

   133

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

   134

                raise Exception

   135

        else:

   136

            self.CodeFile = self.CodeFileParser.CreateRoot()

   137

            self.CreateCodeFileBuffer(False)

   138

            self.OnCTNSave()

   139

   140

    def GetBaseTypes(self):

   141

        return self.GetCTRoot().GetBaseTypes()

   142

   143

    def GetDataTypes(self, basetypes=False):

   144

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

   145

   146

    def GenerateNewName(self, name, format):

   147

        return self.GetCTRoot().GenerateNewName(

   148

            None, name, format,

   149

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

   150

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

   151

   152

    def SetVariables(self, variables):

   153

        self.CodeFile.variables.setvariable([])

   154

        for var in variables:

   155

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

   156

            variable.setname(var["Name"])

   157

            variable.settype(var["Type"])

   158

            variable.setinitial(var["Initial"])

   159

            variable.setdesc(var["Description"])

   160

            variable.setonchange(var["OnChange"])

   161

            variable.setopts(var["Options"])

   162

            self.CodeFile.variables.appendvariable(variable)

   163

   164

    def GetVariables(self):

   165

        datas = []

   166

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

   167

            datas.append({

   168

                "Name":        var.getname(),

   169

                "Type":        var.gettype(),

   170

                "Initial":     var.getinitial(),

   171

                "Description": var.getdesc(),

   172

                "OnChange":    var.getonchange(),

   173

                "Options":     var.getopts(),

   174

            })

   175

        return datas

   176

   177

    def SetTextParts(self, parts):

   178

        for section in self.SECTIONS_NAMES:

   179

            section_code = parts.get(section)

   180

            if section_code is not None:

   181

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

   182

   183

    def GetTextParts(self):

   184

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

   185

                     for section in self.SECTIONS_NAMES])

   186

   187

    def CTNTestModified(self):

   188

        return self.ChangesToSave or not self.CodeFileIsSaved()

   189

   190

    def OnCTNSave(self, from_project_path=None):

   191

        filepath = self.CodeFileName()

   192

   193

        xmlfile = open(filepath, "w")

   194

        xmlfile.write(etree.tostring(

   195

            self.CodeFile,

   196

            pretty_print=True,

   197

            xml_declaration=True,

   198

            encoding='utf-8'))

   199

        xmlfile.close()

   200

   201

        self.MarkCodeFileAsSaved()

   202

        return True

   203

   204

    def CTNGlobalInstances(self):

   205

        variables = self.CodeFileVariables(self.CodeFile)

   206

        ret = [(variable.getname(),

   207

                variable.gettype(),

   208

                variable.getinitial())

   209

               for variable in variables]

   210

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

   211

                    for variable in variables

   212

                    if variable.getonchange()])

   213

        return ret

   214

   215

    def CTNSearch(self, criteria):

   216

        variables = self.GetVariables()

   217

        results = []

   218

        tagname = self.CTNFullName()

   219

        for index, var in enumerate(variables):

   220

            varname = var["Name"]

   221

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

   222

                            for result in TestTextElement(varname, criteria)])

   223

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

   224

                        for result in TestTextElement(

   225

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

   226

        return results

   227

   228

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

   229

#                      Current Buffering Management Functions

   230

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

   231

   232

    def Copy(self, model):

   233

        """

   234

        Return a copy of the codefile model

   235

        """

   236

        return deepcopy(model)

   237

   238

    def CreateCodeFileBuffer(self, saved):

   239

        self.Buffering = False

   240

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

   241

   242

    def BufferCodeFile(self):

   243

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

   244

   245

    def StartBuffering(self):

   246

        self.Buffering = True

   247

   248

    def EndBuffering(self):

   249

        if self.Buffering:

   250

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

   251

            self.Buffering = False

   252

   253

    def MarkCodeFileAsSaved(self):

   254

        self.EndBuffering()

   255

        self.CodeFileBuffer.CurrentSaved()

   256

   257

    def CodeFileIsSaved(self):

   258

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

   259

   260

    def LoadPrevious(self):

   261

        self.EndBuffering()

   262

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

   263

   264

    def LoadNext(self):

   265

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

   266

   267

    def GetBufferState(self):

   268

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

   269

        last = self.CodeFileBuffer.IsLast()

   270

        return not first, not last