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

    def CTNSearch(self, criteria):

   214

        # TODO really search

   216

                ((self.CTNFullName(),"body"), (1,12),(1,15),"Bitch I'm a cow !")]

   217

   218

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

   219

#                      Current Buffering Management Functions

   220

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

   221

   222

    def Copy(self, model):

   223

        """

   224

        Return a copy of the codefile model

   225

        """

   226

        return deepcopy(model)

   227

   228

    def CreateCodeFileBuffer(self, saved):

   229

        self.Buffering = False

   230

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

   231

   232

    def BufferCodeFile(self):

   233

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

   234

   235

    def StartBuffering(self):

   236

        self.Buffering = True

   237

   238

    def EndBuffering(self):

   239

        if self.Buffering:

   240

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

   241

            self.Buffering = False

   242

   243

    def MarkCodeFileAsSaved(self):

   244

        self.EndBuffering()

   245

        self.CodeFileBuffer.CurrentSaved()

   246

   247

    def CodeFileIsSaved(self):

   248

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

   249

   250

    def LoadPrevious(self):

   251

        self.EndBuffering()

   252

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

   253

   254

    def LoadNext(self):

   255

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

   256

   257

    def GetBufferState(self):

   258

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

   259

        last = self.CodeFileBuffer.IsLast()

   260

        return not first, not last