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

        return ret

   211

   212

    def CTNSearch(self, criteria):

   213

        variables = self.GetVariables()

   214

        results = []

   215

        tagname = self.CTNFullName()

   216

        for index, var in enumerate(variables):

   217

            varname = var["Name"]

   218

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

   219

                            for result in TestTextElement(varname, criteria)])

   220

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

   221

                        for result in TestTextElement(

   222

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

   223

        return results

   224

   225

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

   226

#                      Current Buffering Management Functions

   227

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

   228

   229

    def Copy(self, model):

   230

        """

   231

        Return a copy of the codefile model

   232

        """

   233

        return deepcopy(model)

   234

   235

    def CreateCodeFileBuffer(self, saved):

   236

        self.Buffering = False

   237

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

   238

   239

    def BufferCodeFile(self):

   240

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

   241

   242

    def StartBuffering(self):

   243

        self.Buffering = True

   244

   245

    def EndBuffering(self):

   246

        if self.Buffering:

   247

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

   248

            self.Buffering = False

   249

   250

    def MarkCodeFileAsSaved(self):

   251

        self.EndBuffering()

   252

        self.CodeFileBuffer.CurrentSaved()

   253

   254

    def CodeFileIsSaved(self):

   255

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

   256

   257

    def LoadPrevious(self):

   258

        self.EndBuffering()

   259

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

   260

   261

    def LoadNext(self):

   262

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

   263

   264

    def GetBufferState(self):

   265

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

   266

        last = self.CodeFileBuffer.IsLast()

   267

        return not first, not last