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

    30

from copy import deepcopy

    31

from lxml import etree

    32

from xmlclass import GenerateParserFromXSDstring

    33

    34

from PLCControler import UndoBuffer

    35

from ConfigTreeNode import XSDSchemaErrorMessage

    36

    37

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

    38

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

    39

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

    40

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

    41

    <xsd:complexType>

    42

      <xsd:sequence>

    43

        %(includes_section)s

    44

        <xsd:element name="variables">

    45

          <xsd:complexType>

    46

            <xsd:sequence>

    47

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

    48

                <xsd:complexType>

    49

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

    50

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

    51

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

    52

                    <xsd:simpleType>

    53

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

    54

                        <xsd:enumeration value="input"/>

    55

                        <xsd:enumeration value="memory"/>

    56

                        <xsd:enumeration value="output"/>

    57

                      </xsd:restriction>

    58

                    </xsd:simpleType>

    59

                  </xsd:attribute>

    60

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

    61

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

    62

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

    63

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

    64

                </xsd:complexType>

    65

              </xsd:element>

    66

            </xsd:sequence>

    67

          </xsd:complexType>

    68

        </xsd:element>

    69

        %(sections)s

    70

      </xsd:sequence>

    71

    </xsd:complexType>

    72

  </xsd:element>

    73

  <xsd:complexType name="CodeText">

    74

    <xsd:annotation>

    75

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

    76

    </xsd:annotation>

    77

    <xsd:sequence>

    78

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

    79

    </xsd:sequence>

    80

  </xsd:complexType>

    81

</xsd:schema>"""

    82

    83

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

    84

    85

    86

class CodeFile:

    87

    88

    CODEFILE_NAME = "CodeFile"

    89

    SECTIONS_NAMES = []

    90

    91

    def __init__(self):

    92

        sections_str = {"codefile_name": self.CODEFILE_NAME}

    93

        if "includes" in self.SECTIONS_NAMES:

    94

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

    95

        else:

    96

            sections_str["includes_section"] = ""

    97

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

    98

            [SECTION_TAG_ELEMENT % name

    99

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

   100

   101

        self.CodeFileParser = GenerateParserFromXSDstring(

   102

            CODEFILE_XSD % sections_str)

   103

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

   104

   105

        filepath = self.CodeFileName()

   106

   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)

   126

            except Exception, exc:

   127

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

   128

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

   129

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

   130

        else:

   131

            self.CodeFile = self.CodeFileParser.CreateRoot()

   132

            self.CreateCodeFileBuffer(False)

   133

            self.OnCTNSave()

   134

   135

    def GetBaseTypes(self):

   136

        return self.GetCTRoot().GetBaseTypes()

   137

   138

    def GetDataTypes(self, basetypes=False):

   139

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

   140

   141

    def GenerateNewName(self, format, start_idx):

   142

        return self.GetCTRoot().GenerateNewName(

   143

            None, None, format, start_idx,

   144

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

   145

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

   146

   147

    def SetVariables(self, variables):

   148

        self.CodeFile.variables.setvariable([])

   149

        for var in variables:

   150

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

   151

            variable.setname(var["Name"])

   152

            variable.settype(var["Type"])

   153

            variable.setinitial(var["Initial"])

   154

            variable.setdesc(var["Description"])

   155

            variable.setonchange(var["OnChange"])

   156

            variable.setopts(var["Options"])

   157

            self.CodeFile.variables.appendvariable(variable)

   158

   159

    def GetVariables(self):

   160

        datas = []

   161

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

   162

            datas.append({

   163

                "Name":        var.getname(),

   164

                "Type":        var.gettype(),

   165

                "Initial":     var.getinitial(),

   166

                "Description": var.getdesc(),

   167

                "OnChange":    var.getonchange(),

   168

                "Options":     var.getopts(),

   169

            })

   170

        return datas

   171

   172

    def SetTextParts(self, parts):

   173

        for section in self.SECTIONS_NAMES:

   174

            section_code = parts.get(section)

   175

            if section_code is not None:

   176

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

   177

   178

    def GetTextParts(self):

   179

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

   180

                     for section in self.SECTIONS_NAMES])

   181

   182

    def CTNTestModified(self):

   183

        return self.ChangesToSave or not self.CodeFileIsSaved()

   184

   185

    def OnCTNSave(self, from_project_path=None):

   186

        filepath = self.CodeFileName()

   187

   188

        xmlfile = open(filepath, "w")

   189

        xmlfile.write(etree.tostring(

   190

            self.CodeFile,

   191

            pretty_print=True,

   192

            xml_declaration=True,

   193

            encoding='utf-8'))

   194

        xmlfile.close()

   195

   196

        self.MarkCodeFileAsSaved()

   197

        return True

   198

   199

    def CTNGlobalInstances(self):

   200

        variables = self.CodeFileVariables(self.CodeFile)

   201

        ret = [(variable.getname(),

   202

                variable.gettype(),

   203

                variable.getinitial())

   204

               for variable in variables]

   205

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

   206

                    for variable in variables

   207

                    if variable.getonchange()])

   208

        return ret

   209

   210

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

   211

#                      Current Buffering Management Functions

   212

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

   213

   214

    """

   215

    Return a copy of the codefile model

   216

    """

   217

    def Copy(self, model):

   218

        return deepcopy(model)

   219

   220

    def CreateCodeFileBuffer(self, saved):

   221

        self.Buffering = False

   222

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

   223

   224

    def BufferCodeFile(self):

   225

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

   226

   227

    def StartBuffering(self):

   228

        self.Buffering = True

   229

   230

    def EndBuffering(self):

   231

        if self.Buffering:

   232

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

   233

            self.Buffering = False

   234

   235

    def MarkCodeFileAsSaved(self):

   236

        self.EndBuffering()

   237

        self.CodeFileBuffer.CurrentSaved()

   238

   239

    def CodeFileIsSaved(self):

   240

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

   241

   242

    def LoadPrevious(self):

   243

        self.EndBuffering()

   244

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

   245

   246

    def LoadNext(self):

   247

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

   248

   249

    def GetBufferState(self):

   250

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

   251

        last = self.CodeFileBuffer.IsLast()

   252

        return not first, not last