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

# Copyright (C) 2017: Andrey Skvortsov

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

# This program is free software; you can redistribute it and/or

    13

# modify it under the terms of the GNU General Public License

    14

# as published by the Free Software Foundation; either version 2

    15

# of the License, or (at your option) any later version.

    16

#

    17

# This program is distributed in the hope that it will be useful,

    18

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

# You should have received a copy of the GNU General Public License

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

from xml.dom import minidom

    27

from types import StringType, UnicodeType, TupleType

    28

from lxml import etree

    29

from copy import deepcopy

    30

import os

    31

import sys

    32

import re

    33

import datetime

    34

import util.paths as paths

    35

from time import localtime

    36

from collections import OrderedDict, namedtuple

    37

    38

from plcopen import *

    39

from graphics.GraphicCommons import *

    40

from PLCGenerator import *

    41

    42

duration_model = re.compile("(?:([0-9]{1,2})h)?(?:([0-9]{1,2})m(?!s))?(?:([0-9]{1,2})s)?(?:([0-9]{1,3}(?:\.[0-9]*)?)ms)?")

    43

    44

ITEMS_EDITABLE = [ITEM_PROJECT,

    45

                  ITEM_POU,

    46

                  ITEM_VARIABLE,

    47

                  ITEM_TRANSITION,

    48

                  ITEM_ACTION,

    49

                  ITEM_CONFIGURATION,

    50

                  ITEM_RESOURCE,

    51

                  ITEM_DATATYPE

    52

                 ] = range(8)

    53

    54

ITEMS_UNEDITABLE = [ITEM_DATATYPES,

    55

                    ITEM_FUNCTION,

    56

                    ITEM_FUNCTIONBLOCK,

    57

                    ITEM_PROGRAM,

    58

                    ITEM_TRANSITIONS,

    59

                    ITEM_ACTIONS,

    60

                    ITEM_CONFIGURATIONS,

    61

                    ITEM_RESOURCES,

    62

                    ITEM_PROPERTIES

    63

                   ] = range(8, 17)

    64

    65

ITEMS_VARIABLE = [ITEM_VAR_LOCAL,

    66

                  ITEM_VAR_GLOBAL,

    67

                  ITEM_VAR_EXTERNAL,

    68

                  ITEM_VAR_TEMP,

    69

                  ITEM_VAR_INPUT,

    70

                  ITEM_VAR_OUTPUT,

    71

                  ITEM_VAR_INOUT

    72

                 ] = range(17, 24)

    73

    74

VAR_CLASS_INFOS = {

    75

    "Local":    ("localVars",    ITEM_VAR_LOCAL),

    76

    "Global":   ("globalVars",   ITEM_VAR_GLOBAL),

    77

    "External": ("externalVars", ITEM_VAR_EXTERNAL),

    78

    "Temp":     ("tempVars",     ITEM_VAR_TEMP),

    79

    "Input":    ("inputVars",    ITEM_VAR_INPUT),

    80

    "Output":   ("outputVars",   ITEM_VAR_OUTPUT),

    81

    "InOut":    ("inOutVars",    ITEM_VAR_INOUT)}

    82

    83

POU_TYPES = {"program": ITEM_PROGRAM,

    84

             "functionBlock": ITEM_FUNCTIONBLOCK,

    85

             "function": ITEM_FUNCTION,

    86

            }

    87

    88

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    89

                   LOCATION_MODULE,

    90

                   LOCATION_GROUP,

    91

                   LOCATION_VAR_INPUT,

    92

                   LOCATION_VAR_OUTPUT,

    93

                   LOCATION_VAR_MEMORY] = range(6)

    94

    95

ScriptDirectory = paths.AbsDir(__file__)

    96

    97

    98

def GetUneditableNames():

    99

    _ = lambda x: x

   100

    return [_("User-defined POUs"), _("Functions"), _("Function Blocks"),

   101

            _("Programs"), _("Data Types"), _("Transitions"), _("Actions"),

   102

            _("Configurations"), _("Resources"), _("Properties")]

   103

   104

   105

UNEDITABLE_NAMES = GetUneditableNames()

   106

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   107

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   108

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   109

   110

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

   111

#                 Helper object for loading library in xslt stylesheets

   112

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

   113

   114

   115

class LibraryResolver(etree.Resolver):

   116

   117

    def __init__(self, controller, debug=False):

   118

        self.Controller = controller

   119

        self.Debug = debug

   120

   121

    def resolve(self, url, pubid, context):

   122

        lib_name = os.path.basename(url)

   123

        if lib_name in ["project", "stdlib", "extensions"]:

   124

            lib_el = etree.Element(lib_name)

   125

            if lib_name == "project":

   126

                lib_el.append(deepcopy(self.Controller.GetProject(self.Debug)))

   127

            elif lib_name == "stdlib":

   128

                for lib in StdBlckLibs.values():

   129

                    lib_el.append(deepcopy(lib))

   130

            else:

   131

                for ctn in self.Controller.ConfNodeTypes:

   132

                    lib_el.append(deepcopy(ctn["types"]))

   133

            return self.resolve_string(etree.tostring(lib_el), context)

   134

   135

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

   136

#           Helpers functions for translating list of arguments

   137

#                       from xslt to valid arguments

   138

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

   139

   140

   141

_StringValue = lambda x: x

   142

_BoolValue = lambda x: x in ["true", "0"]

   143

   144

   145

def _translate_args(translations, args):

   146

    return [translate(arg[0]) if len(arg) > 0 else None

   147

            for translate, arg in

   148

            zip(translations, args)]

   149

   150

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

   151

#                 Helpers object for generating pou var list

   152

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

   153

   154

   155

class _VariableInfos(object):

   156

    __slots__ = ["Name", "Class", "Option", "Location", "InitialValue",

   157

                 "Edit", "Documentation", "Type", "Tree", "Number"]

   158

   159

    def __init__(self, *args):

   160

        for attr, value in zip(self.__slots__, args):

   161

            setattr(self, attr, value if value is not None else "")

   162

   163

    def copy(self):

   164

        return _VariableInfos(*[getattr(self, attr) for attr in self.__slots__])

   165

   166

   167

class VariablesInfosFactory:

   168

   169

    def __init__(self, variables):

   170

        self.Variables = variables

   171

        self.TreeStack = []

   172

        self.Type = None

   173

        self.Dimensions = None

   174

   175

    def SetType(self, context, *args):

   176

        self.Type = args[0][0]

   177

   178

    def GetType(self):

   179

        if len(self.Dimensions) > 0:

   180

            return ("array", self.Type, self.Dimensions)

   181

        return self.Type

   182

   183

    def GetTree(self):

   184

        return (self.TreeStack.pop(-1), self.Dimensions)

   185

   186

    def AddDimension(self, context, *args):

   187

        self.Dimensions.append(tuple(

   188

            _translate_args([_StringValue] * 2, args)))

   189

   190

    def AddTree(self, context, *args):

   191

        self.TreeStack.append([])

   192

        self.Dimensions = []

   193

   194

    def AddVarToTree(self, context, *args):

   195

        var = (args[0][0], self.Type, self.GetTree())

   196

        self.TreeStack[-1].append(var)

   197

   198

    def AddVariable(self, context, *args):

   199

        self.Variables.append(_VariableInfos(*(_translate_args(

   200

            [_StringValue] * 5 + [_BoolValue] + [_StringValue], args) +

   201

            [self.GetType(), self.GetTree()])))

   202

   203

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

   204

#            Helpers object for generating pou variable instance list

   205

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

   206

   207

   208

def class_extraction(value):

   209

    class_type = {

   210

        "configuration": ITEM_CONFIGURATION,

   211

        "resource": ITEM_RESOURCE,

   212

        "action": ITEM_ACTION,

   213

        "transition": ITEM_TRANSITION,

   214

        "program": ITEM_PROGRAM}.get(value)

   215

    if class_type is not None:

   216

        return class_type

   217

   218

    pou_type = POU_TYPES.get(value)

   219

    if pou_type is not None:

   220

        return pou_type

   221

   222

    var_type = VAR_CLASS_INFOS.get(value)

   223

    if var_type is not None:

   224

        return var_type[1]

   225

   226

    return None

   227

   228

   229

class _VariablesTreeItemInfos(object):

   230

    __slots__ = ["name", "var_class", "type", "edit", "debug", "variables"]

   231

   232

    def __init__(self, *args):

   233

        for attr, value in zip(self.__slots__, args):

   234

            setattr(self, attr, value if value is not None else "")

   235

   236

    def copy(self):

   237

        return _VariableTreeItem(*[getattr(self, attr) for attr in self.__slots__])

   238

   239

   240

class VariablesTreeInfosFactory:

   241

   242

    def __init__(self):

   243

        self.Root = None

   244

   245

    def GetRoot(self):

   246

        return self.Root

   247

   248

    def SetRoot(self, context, *args):

   249

        self.Root = _VariablesTreeItemInfos(

   250

            *([''] + _translate_args(

   251

                [class_extraction, _StringValue] + [_BoolValue] * 2,

   252

                args) + [[]]))

   253

   254

    def AddVariable(self, context, *args):

   255

        if self.Root is not None:

   256

            self.Root.variables.append(_VariablesTreeItemInfos(

   257

                *(_translate_args(

   258

                    [_StringValue, class_extraction, _StringValue] +

   259

                    [_BoolValue] * 2, args) + [[]])))

   260

   261

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

   262

#            Helpers object for generating instances path list

   263

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

   264

   265

   266

class InstancesPathFactory:

   267

   268

    def __init__(self, instances):

   269

        self.Instances = instances

   270

   271

    def AddInstance(self, context, *args):

   272

        self.Instances.append(args[0][0])

   273

   274

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

   275

#            Helpers object for generating instance tagname

   276

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

   277

   278

   279

class InstanceTagName:

   280

   281

    def __init__(self, controller):

   282

        self.Controller = controller

   283

        self.TagName = None

   284

   285

    def GetTagName(self):

   286

        return self.TagName

   287

   288

    def ConfigTagName(self, context, *args):

   289

        self.TagName = self.Controller.ComputeConfigurationName(args[0][0])

   290

   291

    def ResourceTagName(self, context, *args):

   292

        self.TagName = self.Controller.ComputeConfigurationResourceName(args[0][0], args[1][0])

   293

   294

    def PouTagName(self, context, *args):

   295

        self.TagName = self.Controller.ComputePouName(args[0][0])

   296

   297

    def ActionTagName(self, context, *args):

   298

        self.TagName = self.Controller.ComputePouActionName(args[0][0], args[0][1])

   299

   300

    def TransitionTagName(self, context, *args):

   301

        self.TagName = self.Controller.ComputePouTransitionName(args[0][0], args[0][1])

   302

   303

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

   304

#           Helpers object for generating pou block instances list

   305

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

   306

   307

   308

_Point = namedtuple("Point", ["x", "y"])

   309

   310

_BlockInstanceInfos = namedtuple("BlockInstanceInfos",

   311

    ["type", "id", "x", "y", "width", "height", "specific_values", "inputs", "outputs"])

   312

   313

_BlockSpecificValues = (

   314

    namedtuple("BlockSpecificValues",

   315

               ["name", "execution_order"]),

   316

    [_StringValue, int])

   317

_VariableSpecificValues = (

   318

    namedtuple("VariableSpecificValues",

   319

               ["name", "value_type", "execution_order"]),

   320

    [_StringValue, _StringValue, int])

   321

_ConnectionSpecificValues = (

   322

    namedtuple("ConnectionSpecificValues", ["name"]),

   323

    [_StringValue])

   324

   325

_PowerRailSpecificValues = (

   326

    namedtuple("PowerRailSpecificValues", ["connectors"]),

   327

    [int])

   328

   329

_LDElementSpecificValues = (

   330

    namedtuple("LDElementSpecificValues",

   331

               ["name", "negated", "edge", "storage", "execution_order"]),

   332

    [_StringValue, _BoolValue, _StringValue, _StringValue, int])

   333

   334

_DivergenceSpecificValues = (

   335

    namedtuple("DivergenceSpecificValues", ["connectors"]),

   336

    [int])

   337

   338

_SpecificValuesTuples = {

   339

    "comment": (

   340

        namedtuple("CommentSpecificValues", ["content"]),

   341

        [_StringValue]),

   342

    "input": _VariableSpecificValues,

   343

    "output": _VariableSpecificValues,

   344

    "inout": _VariableSpecificValues,

   345

    "connector": _ConnectionSpecificValues,

   346

    "continuation": _ConnectionSpecificValues,

   347

    "leftPowerRail": _PowerRailSpecificValues,

   348

    "rightPowerRail": _PowerRailSpecificValues,

   349

    "contact": _LDElementSpecificValues,

   350

    "coil": _LDElementSpecificValues,

   351

    "step": (

   352

        namedtuple("StepSpecificValues", ["name", "initial", "action"]),

   353

        [_StringValue, _BoolValue, lambda x: x]),

   354

    "transition": (

   355

        namedtuple("TransitionSpecificValues",

   356

                   ["priority", "condition_type", "condition", "connection"]),

   357

        [int, _StringValue, _StringValue, lambda x: x]),

   358

    "selectionDivergence": _DivergenceSpecificValues,

   359

    "selectionConvergence": _DivergenceSpecificValues,

   360

    "simultaneousDivergence": _DivergenceSpecificValues,

   361

    "simultaneousConvergence": _DivergenceSpecificValues,

   362

    "jump": (

   363

        namedtuple("JumpSpecificValues", ["target"]),

   364

        [_StringValue]),

   365

    "actionBlock": (

   366

        namedtuple("ActionBlockSpecificValues", ["actions"]),

   367

        [lambda x: x]),

   368

}

   369

   370

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   371

    ["name", "negated", "edge", "position", "links"])

   372

   373

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   374

    ["refLocalId", "formalParameter", "points"])

   375

   376

   377

class _ActionInfos(object):

   378

    __slots__ = ["qualifier", "type", "value", "duration", "indicator"]

   379

   380

    def __init__(self, *args):

   381

        for attr, value in zip(self.__slots__, args):

   382

            setattr(self, attr, value if value is not None else "")

   383

   384

    def copy(self):

   385

        return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])

   386

   387

   388

class BlockInstanceFactory:

   389

   390

    def __init__(self, block_instances):

   391

        self.BlockInstances = block_instances

   392

        self.CurrentInstance = None

   393

        self.SpecificValues = None

   394

        self.CurrentConnection = None

   395

        self.CurrentLink = None

   396

   397

    def SetSpecificValues(self, context, *args):

   398

        self.SpecificValues = list(args)

   399

        self.CurrentInstance = None

   400

        self.CurrentConnection = None

   401

        self.CurrentLink = None

   402

   403

    def AddBlockInstance(self, context, *args):

   404

        specific_values_tuple, specific_values_translation = \

   405

            _SpecificValuesTuples.get(args[0][0], _BlockSpecificValues)

   406

   407

        if (args[0][0] == "step" and len(self.SpecificValues) < 3 or

   408

            args[0][0] == "transition" and len(self.SpecificValues) < 4):

   409

            self.SpecificValues.append([None])

   410

        elif args[0][0] == "actionBlock" and len(self.SpecificValues) < 1:

   411

            self.SpecificValues.append([[]])

   412

        specific_values = specific_values_tuple(*_translate_args(

   413

            specific_values_translation, self.SpecificValues))

   414

        self.SpecificValues = None

   415

   416

        self.CurrentInstance = _BlockInstanceInfos(

   417

            *(_translate_args([_StringValue, int] + [float] * 4, args) +

   418

              [specific_values, [], []]))

   419

   420

        self.BlockInstances[self.CurrentInstance.id] = self.CurrentInstance

   421

   422

    def AddInstanceConnection(self, context, *args):

   423

        connection_args = _translate_args(

   424

            [_StringValue] * 2 + [_BoolValue, _StringValue] + [float] * 2, args)

   425

   426

        self.CurrentConnection = _InstanceConnectionInfos(

   427

            *(connection_args[1:4] + [

   428

                _Point(*connection_args[4:6]), []]))

   429

   430

        if self.CurrentInstance is not None:

   431

            if connection_args[0] == "input":

   432

                self.CurrentInstance.inputs.append(self.CurrentConnection)

   433

            else:

   434

                self.CurrentInstance.outputs.append(self.CurrentConnection)

   435

        else:

   436

            self.SpecificValues.append([self.CurrentConnection])

   437

   438

    def AddConnectionLink(self, context, *args):

   439

        self.CurrentLink = _ConnectionLinkInfos(

   440

            *(_translate_args([int, _StringValue], args) + [[]]))

   441

        self.CurrentConnection.links.append(self.CurrentLink)

   442

   443

    def AddLinkPoint(self, context, *args):

   444

        self.CurrentLink.points.append(_Point(

   445

            *_translate_args([float] * 2, args)))

   446

   447

    def AddAction(self, context, *args):

   448

        if len(self.SpecificValues) == 0:

   449

            self.SpecificValues.append([[]])

   450

        translated_args = _translate_args([_StringValue] * 5, args)

   451

        self.SpecificValues[0][0].append(_ActionInfos(*translated_args))

   452

   453

   454

pou_block_instances_xslt = etree.parse(

   455

    os.path.join(ScriptDirectory, "plcopen", "pou_block_instances.xslt"))

   456

   457

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

   458

#                         Undo Buffer for PLCOpenEditor

   459

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

   460

   461

# Length of the buffer

   462

UNDO_BUFFER_LENGTH = 20

   463

   464

   465

class UndoBuffer:

   466

    """

   467

    Class implementing a buffer of changes made on the current editing model

   468

    """

   469

   470

    def __init__(self, currentstate, issaved=False):

   471

        """

   472

        Constructor initialising buffer

   473

        """

   474

        self.Buffer = []

   475

        self.CurrentIndex = -1

   476

        self.MinIndex = -1

   477

        self.MaxIndex = -1

   478

        # if current state is defined

   479

        if currentstate:

   480

            self.CurrentIndex = 0

   481

            self.MinIndex = 0

   482

            self.MaxIndex = 0

   483

        # Initialising buffer with currentstate at the first place

   484

        for i in xrange(UNDO_BUFFER_LENGTH):

   485

            if i == 0:

   486

                self.Buffer.append(currentstate)

   487

            else:

   488

                self.Buffer.append(None)

   489

        # Initialising index of state saved