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

    31

from copy import deepcopy

    32

from lxml import etree

    33

from xmlclass import GenerateParserFromXSDstring

    34

    35

from PLCControler import UndoBuffer

    36

from ConfigTreeNode import XSDSchemaErrorMessage

    37

    38

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

    39

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

    40

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

    41

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

    42

    <xsd:complexType>

    43

      <xsd:sequence>

    44

        %(includes_section)s

    45

        <xsd:element name="variables">

    46

          <xsd:complexType>

    47

            <xsd:sequence>

    48

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

    49

                <xsd:complexType>

    50

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

    51

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

    52

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

    53

                    <xsd:simpleType>

    54

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

    55

                        <xsd:enumeration value="input"/>

    56

                        <xsd:enumeration value="memory"/>

    57

                        <xsd:enumeration value="output"/>

    58

                      </xsd:restriction>

    59

                    </xsd:simpleType>

    60

                  </xsd:attribute>

    61

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

    62

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

    63

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

    64

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

    65

                </xsd:complexType>

    66

              </xsd:element>

    67

            </xsd:sequence>

    68

          </xsd:complexType>

    69

        </xsd:element>

    70

        %(sections)s

    71

      </xsd:sequence>

    72

    </xsd:complexType>

    73

  </xsd:element>

    74

  <xsd:complexType name="CodeText">

    75

    <xsd:annotation>

    76

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

    77

    </xsd:annotation>

    78

    <xsd:sequence>

    79

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

    80

    </xsd:sequence>

    81

  </xsd:complexType>

    82

</xsd:schema>"""

    83

    84

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

    85

    86

    87

class CodeFile(object):

    88

    89

    CODEFILE_NAME = "CodeFile"

    90

    SECTIONS_NAMES = []

    91

    92

    def __init__(self):

    93

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    94

        if "includes" in self.SECTIONS_NAMES:

    95

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

    96

        else:

    97

            sections_str["includes_section"] = ""

    98

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

    99

            [SECTION_TAG_ELEMENT % name

   100

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

   101

   102

        self.CodeFileParser = GenerateParserFromXSDstring(

   103

            CODEFILE_XSD % sections_str)

   104

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

   105

   106

        filepath = self.CodeFileName()

   107

        if os.path.isfile(filepath):

   108

            xmlfile = open(filepath, 'r')

   109

            codefile_xml = xmlfile.read()

   110

            xmlfile.close()

   111

   112

            codefile_xml = codefile_xml.replace(

   113

                '<%s>' % self.CODEFILE_NAME,

   114

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

   115

            for cre, repl in [

   116

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

   117

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

   118

                codefile_xml = cre.sub(repl, codefile_xml)

   119

   120

            try:

   121

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

   122

                if error is not None:

   123

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

   124

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

   125

                self.CreateCodeFileBuffer(True)

   127

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

   128

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

   129

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

   130

                raise Exception

   131

        else:

   132

            self.CodeFile = self.CodeFileParser.CreateRoot()

   133

            self.CreateCodeFileBuffer(False)

   134

            self.OnCTNSave()

   135

   136

    def GetBaseTypes(self):

   137

        return self.GetCTRoot().GetBaseTypes()

   138

   139

    def GetDataTypes(self, basetypes=False):

   140

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

   141

   142

    def GenerateNewName(self, name, format):

   143

        return self.GetCTRoot().GenerateNewName(

   144

            None, name, format,

   145

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

   146

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

   147

   148

    def SetVariables(self, variables):

   149

        self.CodeFile.variables.setvariable([])

   150

        for var in variables:

   151

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

   152

            variable.setname(var["Name"])

   153

            variable.settype(var["Type"])

   154

            variable.setinitial(var["Initial"])

   155

            variable.setdesc(var["Description"])

   156

            variable.setonchange(var["OnChange"])

   157

            variable.setopts(var["Options"])

   158

            self.CodeFile.variables.appendvariable(variable)

   159

   160

    def GetVariables(self):

   161

        datas = []

   162

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

   163

            datas.append({

   164

                "Name":        var.getname(),

   165

                "Type":        var.gettype(),

   166

                "Initial":     var.getinitial(),

   167

                "Description": var.getdesc(),

   168

                "OnChange":    var.getonchange(),

   169

                "Options":     var.getopts(),

   170

            })

   171

        return datas

   172

   173

    def SetTextParts(self, parts):

   174

        for section in self.SECTIONS_NAMES:

   175

            section_code = parts.get(section)

   176

            if section_code is not None:

   177

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

   178

   179

    def GetTextParts(self):

   180

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

   181

                     for section in self.SECTIONS_NAMES])

   182

   183

    def CTNTestModified(self):

   184

        return self.ChangesToSave or not self.CodeFileIsSaved()

   185

   186

    def OnCTNSave(self, from_project_path=None):

   187

        filepath = self.CodeFileName()

   188

   189

        xmlfile = open(filepath, "w")

   190

        xmlfile.write(etree.tostring(

   191

            self.CodeFile,

   192

            pretty_print=True,

   193

            xml_declaration=True,

   194

            encoding='utf-8'))

   195

        xmlfile.close()

   196

   197

        self.MarkCodeFileAsSaved()

   198

        return True

   199

   200

    def CTNGlobalInstances(self):

   201

        variables = self.CodeFileVariables(self.CodeFile)

   202

        ret = [(variable.getname(),

   203

                variable.gettype(),

   204

                variable.getinitial())

   205

               for variable in variables]

   206

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

   207

                    for variable in variables

   208

                    if variable.getonchange()])

   209

        return ret

   210

   211

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

   212

#                      Current Buffering Management Functions

   213

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

   214

   215

    def Copy(self, model):

   216

        """

   217

        Return a copy of the codefile model

   218

        """

   219

        return deepcopy(model)

   220

   221

    def CreateCodeFileBuffer(self, saved):

   222

        self.Buffering = False

   223

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

   224

   225

    def BufferCodeFile(self):

   226

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

   227

   228

    def StartBuffering(self):

   229

        self.Buffering = True

   230

   231

    def EndBuffering(self):

   232

        if self.Buffering:

   233

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

   234

            self.Buffering = False

   235

   236

    def MarkCodeFileAsSaved(self):

   237

        self.EndBuffering()

   238

        self.CodeFileBuffer.CurrentSaved()

   239

   240

    def CodeFileIsSaved(self):

   241

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

   242

   243

    def LoadPrevious(self):

   244

        self.EndBuffering()

   245

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

   246

   247

    def LoadNext(self):

   248

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

   249

   250

    def GetBufferState(self):

   251

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

   252

        last = self.CodeFileBuffer.IsLast()

   253

        return not first, not last