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 [

   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({"Name":        var.getname(),

   163

                          "Type":        var.gettype(),

   164

                          "Initial":     var.getinitial(),

   165

                          "Description": var.getdesc(),

   166

                          "OnChange":    var.getonchange(),

   167

                          "Options":     var.getopts(),

   168

                         })

   169

        return datas

   170

   171

    def SetTextParts(self, parts):

   172

        for section in self.SECTIONS_NAMES:

   173

            section_code = parts.get(section)

   174

            if section_code is not None:

   175

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

   176

   177

    def GetTextParts(self):

   178

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

   179

                     for section in self.SECTIONS_NAMES])

   180

   181

    def CTNTestModified(self):

   182

        return self.ChangesToSave or not self.CodeFileIsSaved()

   183

   184

    def OnCTNSave(self, from_project_path=None):

   185

        filepath = self.CodeFileName()

   186

   187

        xmlfile = open(filepath, "w")

   188

        xmlfile.write(etree.tostring(

   189

            self.CodeFile,

   190

            pretty_print=True,

   191

            xml_declaration=True,

   192

            encoding='utf-8'))

   193

        xmlfile.close()

   194

   195

        self.MarkCodeFileAsSaved()

   196

        return True

   197

   198

    def CTNGlobalInstances(self):

   199

        variables = self.CodeFileVariables(self.CodeFile)

   200

        ret = [(variable.getname(),

   201

                variable.gettype(),

   202

                variable.getinitial())

   203

                for variable in variables]

   204

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

   205

                for variable in variables

   206

                if variable.getonchange()])

   207

        return ret

   208

   209

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

   210

#                      Current Buffering Management Functions

   211

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

   212

   213

    """

   214

    Return a copy of the codefile model

   215

    """

   216

    def Copy(self, model):

   217

        return deepcopy(model)

   218

   219

    def CreateCodeFileBuffer(self, saved):

   220

        self.Buffering = False

   221

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

   222

   223

    def BufferCodeFile(self):

   224

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

   225

   226

    def StartBuffering(self):

   227

        self.Buffering = True

   228

   229

    def EndBuffering(self):

   230

        if self.Buffering:

   231

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

   232

            self.Buffering = False

   233

   234

    def MarkCodeFileAsSaved(self):

   235

        self.EndBuffering()

   236

        self.CodeFileBuffer.CurrentSaved()

   237

   238

    def CodeFileIsSaved(self):

   239

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

   240

   241

    def LoadPrevious(self):

   242

        self.EndBuffering()

   243

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

   244

   245

    def LoadNext(self):

   246

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

   247

   248

    def GetBufferState(self):

   249

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

   250

        last = self.CodeFileBuffer.IsLast()

   251

        return not first, not last