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

Config Tree Node base class.

    27

    28

- A Beremiz project is organized in a tree each node derivate from ConfigTreeNode

    29

- Project tree organization match filesystem organization of project directory.

    30

- Each node of the tree have its own xml configuration, whose grammar is defined for each node type, as XSD

    31

- ... TODO : document

    32

"""

    33

    34

from __future__ import absolute_import

    35

import os

    36

import traceback

    37

import types

    38

import shutil

    39

from operator import add

    40

from functools import reduce

    41

from builtins import str as text

    42

from past.builtins import execfile

    43

    44

from lxml import etree

    45

    46

from xmlclass import GenerateParserFromXSDstring

    47

from PLCControler import LOCATION_CONFNODE

    48

from editors.ConfTreeNodeEditor import ConfTreeNodeEditor

    49

    50

_BaseParamsParser = GenerateParserFromXSDstring("""<?xml version="1.0" encoding="ISO-8859-1" ?>

    51

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

    52

          <xsd:element name="BaseParams">

    53

            <xsd:complexType>

    54

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

    55

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

    56

              <xsd:attribute name="Enabled" type="xsd:boolean" use="optional" default="true"/>

    57

            </xsd:complexType>

    58

          </xsd:element>

    59

        </xsd:schema>""")

    60

    61

NameTypeSeparator = '@'

    62

XSDSchemaErrorMessage = _("{a1} XML file doesn't follow XSD schema at line {a2}:\n{a3}")

    63

    64

    65

class ConfigTreeNode(object):

    66

    """

    67

    This class is the one that define confnodes.

    68

    """

    69

    70

    XSD = None

    71

    CTNChildrenTypes = []

    72

    CTNMaxCount = None

    73

    ConfNodeMethods = []

    74

    LibraryControler = None

    75

    EditorType = ConfTreeNodeEditor

    76

    IconPath = None

    77

    78

    def _AddParamsMembers(self):

    79

        self.CTNParams = None

    80

        if self.XSD:

    81

            self.Parser = GenerateParserFromXSDstring(self.XSD)

    82

            obj = self.Parser.CreateRoot()

    83

            name = obj.getLocalTag()

    84

            self.CTNParams = (name, obj)

    85

            setattr(self, name, obj)

    86

    87

    def __init__(self):

    88

        # Create BaseParam

    89

        self.BaseParams = _BaseParamsParser.CreateRoot()

    90

        self.MandatoryParams = ("BaseParams", self.BaseParams)

    91

        self._AddParamsMembers()

    92

        self.Children = {}

    93

        self._View = None

    94

        # copy ConfNodeMethods so that it can be later customized

    95

        self.ConfNodeMethods = [dic.copy() for dic in self.ConfNodeMethods]

    96

    97

    def ConfNodeBaseXmlFilePath(self, CTNName=None):

    98

        return os.path.join(self.CTNPath(CTNName), "baseconfnode.xml")

    99

   100

    def ConfNodeXmlFilePath(self, CTNName=None):

   101

        return os.path.join(self.CTNPath(CTNName), "confnode.xml")

   102

   103

    def ConfNodePath(self):

   104

        return os.path.join(self.CTNParent.ConfNodePath(), self.CTNType)

   105

   106

    def CTNPath(self, CTNName=None, project_path=None):

   107

        if not CTNName:

   108

            CTNName = self.CTNName()

   109

        if not project_path:

   110

            project_path = self.CTNParent.CTNPath()

   111

        return os.path.join(project_path,

   112

                            CTNName + NameTypeSeparator + self.CTNType)

   113

   114

    def CTNName(self):

   115

        return self.BaseParams.getName()

   116

   117

    def CTNEnabled(self):

   118

        return self.BaseParams.getEnabled()

   119

   120

    def CTNFullName(self):

   121

        parent = self.CTNParent.CTNFullName()

   122

        if parent != "":

   123

            return parent + "." + self.CTNName()

   124

        return self.BaseParams.getName()

   125

   126

    def CTNSearch(self, criteria):

   127

        # TODO match config's fields name and fields contents

   128

        return reduce(add, [

   129

            CTNChild.CTNSearch(criteria)

   130

            for CTNChild in self.IterChildren()],[])

   131

   132

    def GetIconName(self):

   133

        return None

   134

   135

    def CTNTestModified(self):

   136

        return self.ChangesToSave

   137

   138

    def ProjectTestModified(self):

   139

        """

   140

        recursively check modified status

   141

        """

   142

        if self.CTNTestModified():

   143

            return True

   144

   145

        for CTNChild in self.IterChildren():

   146

            if CTNChild.ProjectTestModified():

   147

                return True

   148

   149

        return False

   150

   151

    def RemoteExec(self, script, **kwargs):

   152

        return self.CTNParent.RemoteExec(script, **kwargs)

   153

   154

    def OnCTNSave(self, from_project_path=None):

   155

        """Default, do nothing and return success"""

   156

        return True

   157

   158

    def GetParamsAttributes(self, path=None):

   159

        if path:

   160

            parts = path.split(".", 1)

   161

            if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

   162

                return self.MandatoryParams[1].getElementInfos(parts[0], parts[1])

   163

            elif self.CTNParams and parts[0] == self.CTNParams[0]:

   164

                return self.CTNParams[1].getElementInfos(parts[0], parts[1])

   165

        else:

   166

            params = []

   167

            if self.CTNParams:

   168

                params.append(self.CTNParams[1].getElementInfos(self.CTNParams[0]))

   169

            return params

   170

   171

    def SetParamsAttribute(self, path, value):

   172

        self.ChangesToSave = True

   173

        # Filter IEC_Channel and Name, that have specific behavior

   174

        if path == "BaseParams.IEC_Channel":

   175

            old_leading = ".".join(map(str, self.GetCurrentLocation()))

   176

            new_value = self.FindNewIEC_Channel(value)

   177

            if new_value != value:

   178

                new_leading = ".".join(map(str, self.CTNParent.GetCurrentLocation() + (new_value,)))

   179

                self.GetCTRoot().UpdateProjectVariableLocation(old_leading, new_leading)

   180

            return new_value, True

   181

        elif path == "BaseParams.Name":

   182

            res = self.FindNewName(value)

   183

            self.CTNRequestSave()

   184

            return res, True

   185

   186

        parts = path.split(".", 1)

   187

        if self.MandatoryParams and parts[0] == self.MandatoryParams[0]:

   188

            self.MandatoryParams[1].setElementValue(parts[1], value)

   189

            value = self.MandatoryParams[1].getElementInfos(parts[0], parts[1])["value"]

   190

        elif self.CTNParams and parts[0] == self.CTNParams[0]:

   191

            self.CTNParams[1].setElementValue(parts[1], value)

   192

            value = self.CTNParams[1].getElementInfos(parts[0], parts[1])["value"]

   193

        return value, False

   194

   195

    def CTNMakeDir(self):

   196

        os.mkdir(self.CTNPath())

   197

   198

    def CTNRequestSave(self, from_project_path=None):

   199

        if self.GetCTRoot().CheckProjectPathPerm(False):

   200

            # If confnode do not have corresponding directory

   201

            ctnpath = self.CTNPath()

   202

            if not os.path.isdir(ctnpath):

   203

                # Create it

   204

                os.mkdir(ctnpath)

   205

   206

            # generate XML for base XML parameters controller of the confnode

   207

            if self.MandatoryParams:

   208

                BaseXMLFile = open(self.ConfNodeBaseXmlFilePath(), 'w')

   209

                BaseXMLFile.write(etree.tostring(

   210

                    self.MandatoryParams[1],

   211

                    pretty_print=True,

   212

                    xml_declaration=True,

   213

                    encoding='utf-8'))

   214

                BaseXMLFile.close()

   215

   216

            # generate XML for XML parameters controller of the confnode

   217

            if self.CTNParams:

   218

                XMLFile = open(self.ConfNodeXmlFilePath(), 'w')

   219

                XMLFile.write(etree.tostring(

   220

                    self.CTNParams[1],

   221

                    pretty_print=True,

   222

                    xml_declaration=True,

   223

                    encoding='utf-8'))

   224

                XMLFile.close()

   225

   226

            # Call the confnode specific OnCTNSave method

   227

            result = self.OnCTNSave(from_project_path)

   228

            if not result:

   229

                return _("Error while saving \"%s\"\n") % self.CTNPath()

   230

   231

            # mark confnode as saved

   232

            self.ChangesToSave = False

   233

            # go through all children and do the same

   234

            for CTNChild in self.IterChildren():

   235

                CTNChildPath = None

   236

                if from_project_path is not None:

   237

                    CTNChildPath = CTNChild.CTNPath(project_path=from_project_path)

   238

                result = CTNChild.CTNRequestSave(CTNChildPath)

   239

                if result:

   240

                    return result

   241

        return None

   242

   243

    def CTNImport(self, src_CTNPath):

   244

        shutil.copytree(src_CTNPath, self.CTNPath)

   245

        return True

   246

   247

    def CTNGlobalInstances(self):

   248

        """

   249

        @return: [(instance_name, instance_type),...]

   250

        """

   251

        return []

   252

   253

    def _GlobalInstances(self):

   254

        instances = self.CTNGlobalInstances()

   255

        for CTNChild in self.IECSortedChildren():

   256

            instances.extend(CTNChild._GlobalInstances())

   257

        return instances

   258

   259

    def CTNGenerate_C(self, buildpath, locations):

   260

        """

   261

        Generate C code

   262

        @param locations: List of complete variables locations \

   263

            [{"IEC_TYPE" : the IEC type (i.e. "INT", "STRING", ...)

   264

            "NAME" : name of the variable (generally "__IW0_1_2" style)

   265

            "DIR" : direction "Q","I" or "M"

   266

            "SIZE" : size "X", "B", "W", "D", "L"

   267

            "LOC" : tuple of interger for IEC location (0,1,2,...)

   268

            }, ...]

   269

        @return: [(C_file_name, CFLAGS),...] , LDFLAGS_TO_APPEND

   270

        """

   271

        self.GetCTRoot().logger.write_warning(".".join(map(str, self.GetCurrentLocation())) + " -> Nothing to do\n")

   272

        return [], "", False

   273

   274

    def _Generate_C(self, buildpath, locations):

   275

        # Generate confnodes [(Cfiles, CFLAGS)], LDFLAGS, DoCalls, extra_files

   276

        # extra_files = [(fname,fobject), ...]

   277

        gen_result = self.CTNGenerate_C(buildpath, locations)

   278

        CTNCFilesAndCFLAGS, CTNLDFLAGS, DoCalls = gen_result[:3]

   279

        extra_files = gen_result[3:]

   280

        # if some files have been generated put them in the list with their location

   281

        if CTNCFilesAndCFLAGS:

   282

            LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), CTNCFilesAndCFLAGS, DoCalls)]

   283

        else:

   284

            LocationCFilesAndCFLAGS = []

   285

   286

        # confnode asks for some LDFLAGS

   287

        LDFLAGS = []

   288

        if CTNLDFLAGS is not None:

   289

            # LDFLAGS can be either string

   290

            if isinstance(CTNLDFLAGS, (str, text)):

   291

                LDFLAGS += [CTNLDFLAGS]

   292

            # or list of strings

   293

            elif isinstance(CTNLDFLAGS, list):

   294

                LDFLAGS += CTNLDFLAGS

   295

   296

        # recurse through all children, and stack their results

   297

        for CTNChild in self.IECSortedChildren():

   298

            new_location = CTNChild.GetCurrentLocation()

   299

            # How deep are we in the tree ?

   300

            depth = len(new_location)

   301

            _LocationCFilesAndCFLAGS, _LDFLAGS, _extra_files = \

   302

                CTNChild._Generate_C(

   303

                    # keep the same path

   304

                    buildpath,

   305

                    # filter locations that start with current IEC location

   306

                    [loc for loc in locations if loc["LOC"][0:depth] == new_location])

   307

            # stack the result

   308

            LocationCFilesAndCFLAGS += _LocationCFilesAndCFLAGS

   309

            LDFLAGS += _LDFLAGS

   310

            extra_files += _extra_files

   311

   312

        return LocationCFilesAndCFLAGS, LDFLAGS, extra_files

   313

   314

    def IterChildren(self):

   315

        for _CTNType, Children in self.Children.items():

   316

            for CTNInstance in Children:

   317

                yield CTNInstance

   318

   319

    def IECSortedChildren(self):

   320

        # reorder children by IEC_channels

   321

        ordered = [(chld.BaseParams.getIEC_Channel(), chld) for chld in self.IterChildren()]

   322

        if ordered:

   323

            ordered.sort()

   324

            return zip(*ordered)[1]

   325

        else:

   326

            return []

   327

   328

    def _GetChildBySomething(self, something, toks):

   329

        for CTNInstance in self.IterChildren():

   330

            # if match component of the name

   331

            if getattr(CTNInstance.BaseParams, something) == toks[0]:

   332

                # if Name have other components

   333

                if len(toks) >= 2:

   334

                    # Recurse in order to find the latest object

   335

                    return CTNInstance._GetChildBySomething(something, toks[1:])

   336

                # No sub name -> found

   337

                return CTNInstance

   338

        # Not found

   339

        return None

   340

   341

    def GetChildByName(self, Name):

   342

        if Name:

   343

            toks = Name.split('.')

   344

            return self._GetChildBySomething("Name", toks)

   345

        else:

   346

            return self

   347

   348

    def GetChildByIECLocation(self, Location):

   349

        if Location:

   350

            return self._GetChildBySomething("IEC_Channel", Location)

   351

        else:

   352

            return self

   353

   354

    def GetCurrentLocation(self):

   355

        """

   356

        @return:  Tupple containing confnode IEC location of current confnode : %I0.0.4.5 => (0,0,4,5)

   357

        """

   358

        return self.CTNParent.GetCurrentLocation() + (self.BaseParams.getIEC_Channel(),)

   359

   360

    def GetCurrentName(self):

   361

        """

   362

        @return:  String "ParentParentName.ParentName.Name"

   363

        """

   364

        return self.CTNParent._GetCurrentName() + self.BaseParams.getName()

   365

   366

    def _GetCurrentName(self):

   367

        """

   368

        @return:  String "ParentParentName.ParentName.Name."

   369

        """

   370

        return self.CTNParent._GetCurrentName() + self.BaseParams.getName() + "."

   371

   372

    def GetCTRoot(self):

   373

        return self.CTNParent.GetCTRoot()

   374

   375

    def GetFullIEC_Channel(self):

   376

        return ".".join([str(i) for i in self.GetCurrentLocation()]) + ".x"

   377

   378

    def GetLocations(self):

   379

        location = self.GetCurrentLocation()

   380

        return [loc for loc in self.CTNParent.GetLocations() if loc["LOC"][0:len(location)] == location]

   381

   382

    def GetVariableLocationTree(self):

   383

        '''

   384

        This function is meant to be overridden by confnodes.

   385

   386

        It should returns an list of dictionaries

   387

   388

        - IEC_type is an IEC type like BOOL/BYTE/SINT/...

   389

        - location is a string of this variable's location, like "%IX0.0.0"

   390

        '''

   391

        children = []

   392

        for child in self.IECSortedChildren():

   393

            children.append(child.GetVariableLocationTree())

   394

        return {"name": self.BaseParams.getName(),

   395

                "type": LOCATION_CONFNODE,

   396

                "location": self.GetFullIEC_Channel(),

   397

                "children": children}

   398

   399

    def FindNewName(self, DesiredName):

   400

        """

   401

        Changes Name to DesiredName if available, Name-N if not.

   402

        @param DesiredName: The desired Name (string)

   403

        """

   404

   405

        # Build a list of used Name out of parent's Children

   406

        AllNames = []

   407

        for CTNInstance in self.CTNParent.IterChildren():

   408

            if CTNInstance != self:

   409

                AllNames.append(CTNInstance.BaseParams.getName())

   410

   411

        # Find a free name, eventually appending digit

   412

        res = DesiredName

   413

        if DesiredName.endswith("_0"):

   414

            BaseDesiredName = DesiredName[:-2]

   415

        else:

   416

            BaseDesiredName = DesiredName

   417

        suffix = 1

   418

        while res in AllNames:

   419

            res = "%s_%d" % (BaseDesiredName, suffix)

   420

            suffix += 1

   421

   422

        # Check previous confnode existance

   423

        dontexist = self.BaseParams.getName() == "__unnamed__"

   424

        if not dontexist:

   425

            # Get old path

   426

            oldpath = self.CTNPath()

   427

        # Set the new name

   428

        self.BaseParams.setName(res)

   429

        # Rename confnode dir if exist

   430

        if not dontexist:

   431

            shutil.move(oldpath, self.CTNPath())

   432

        # warn user he has two left hands

   433

        if DesiredName != res:

   434

            msg = _("A child named \"{a1}\" already exists -> \"{a2}\"\n").format(a1=DesiredName, a2=res)

   435

            self.GetCTRoot().logger.write_warning(msg)

   436

        return res

   437

   438

    def GetAllChannels(self):

   439

        AllChannels = []

   440

        for CTNInstance in self.CTNParent.IterChildren():

   441

            if CTNInstance != self:

   442

                AllChannels.append(CTNInstance.BaseParams.getIEC_Channel())

   443

        AllChannels.sort()

   444

        return AllChannels

   445

   446

    def FindNewIEC_Channel(self, DesiredChannel):

   447

        """

   448

        Changes IEC Channel number to DesiredChannel if available, nearest available if not.

   449

        @param DesiredChannel: The desired IEC channel (int)

   450

        """

   451

        # Get Current IEC channel

   452

        CurrentChannel = self.BaseParams.getIEC_Channel()

   453

        # Do nothing if no change

   454

        # if CurrentChannel == DesiredChannel: return CurrentChannel

   455

        # Build a list of used Channels out of parent's Children

   456

        AllChannels = self.GetAllChannels()

   457

   458

        # Now, try to guess the nearest available channel

   459

        res = DesiredChannel

   460

        while res in AllChannels:  # While channel not free

   461

            if res < CurrentChannel:  # Want to go down ?

   462

                res -= 1  # Test for n-1

   463

                if res < 0:

   464

                    self.GetCTRoot().logger.write_warning(_("Cannot find lower free IEC channel than %d\n") % CurrentChannel)

   465

                    return CurrentChannel  # Can't go bellow 0, do nothing

   466

            else:  # Want to go up ?

   467

                res += 1  # Test for n-1

   468

        # Finally set IEC Channel

   469

        self.BaseParams.setIEC_Channel(res)

   470

        return res

   471

   472

    def GetContextualMenuItems(self):

   473

        return None

   474

   475

    def GetView(self):

   476

        if self._View is None and self.EditorType is not None:

   477

            app_frame = self.GetCTRoot().AppFrame

   478

            self._View = self.EditorType(app_frame.TabsOpened, self, app_frame)