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

from util.TranslationCatalogs import NoTranslate

    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

    _ = NoTranslate

   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

def _StringValue(x):

   142

    return x

   143

   144

   145

def _BoolValue(x):

   146

    return x in ["true", "0"]

   147

   148

   149

def _translate_args(translations, args):

   150

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

   151

            for translate, arg in

   152

            zip(translations, args)]

   153

   154

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

   155

#                 Helpers object for generating pou var list

   156

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

   157

   158

   159

class _VariableInfos(object):

   160

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

   161

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

   162

   163

    def __init__(self, *args):

   164

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

   165

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

   166

   167

    def copy(self):

   168

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

   169

   170

   171

class VariablesInfosFactory:

   172

   173

    def __init__(self, variables):

   174

        self.Variables = variables

   175

        self.TreeStack = []

   176

        self.Type = None

   177

        self.Dimensions = None

   178

   179

    def SetType(self, context, *args):

   180

        self.Type = args[0][0]

   181

   182

    def GetType(self):

   183

        if len(self.Dimensions) > 0:

   184

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

   185

        return self.Type

   186

   187

    def GetTree(self):

   188

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

   189

   190

    def AddDimension(self, context, *args):

   191

        self.Dimensions.append(tuple(

   192

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

   193

   194

    def AddTree(self, context, *args):

   195

        self.TreeStack.append([])

   196

        self.Dimensions = []

   197

   198

    def AddVarToTree(self, context, *args):

   199

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

   200

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

   201

   202

    def AddVariable(self, context, *args):

   203

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

   204

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

   205

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

   206

   207

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

   208

#            Helpers object for generating pou variable instance list

   209

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

   210

   211

   212

def class_extraction(value):

   213

    class_type = {

   214

        "configuration": ITEM_CONFIGURATION,

   215

        "resource": ITEM_RESOURCE,

   216

        "action": ITEM_ACTION,

   217

        "transition": ITEM_TRANSITION,

   218

        "program": ITEM_PROGRAM}.get(value)

   219

    if class_type is not None:

   220

        return class_type

   221

   222

    pou_type = POU_TYPES.get(value)

   223

    if pou_type is not None:

   224

        return pou_type

   225

   226

    var_type = VAR_CLASS_INFOS.get(value)

   227

    if var_type is not None:

   228

        return var_type[1]

   229

   230

    return None

   231

   232

   233

class _VariablesTreeItemInfos(object):

   234

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

   235

   236

    def __init__(self, *args):

   237

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

   238

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

   239

   240

    def copy(self):

   241

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

   242

   243

   244

class VariablesTreeInfosFactory:

   245

   246

    def __init__(self):

   247

        self.Root = None

   248

   249

    def GetRoot(self):

   250

        return self.Root

   251

   252

    def SetRoot(self, context, *args):

   253

        self.Root = _VariablesTreeItemInfos(

   254

            *([''] + _translate_args(

   255

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

   256

                args) + [[]]))

   257

   258

    def AddVariable(self, context, *args):

   259

        if self.Root is not None:

   260

            self.Root.variables.append(_VariablesTreeItemInfos(

   261

                *(_translate_args(

   262

                    [_StringValue, class_extraction, _StringValue] +

   263

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

   264

   265

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

   266

#            Helpers object for generating instances path list

   267

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

   268

   269

   270

class InstancesPathFactory:

   271

   272

    def __init__(self, instances):

   273

        self.Instances = instances

   274

   275

    def AddInstance(self, context, *args):

   276

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

   277

   278

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

   279

#            Helpers object for generating instance tagname

   280

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

   281

   282

   283

class InstanceTagName:

   284

   285

    def __init__(self, controller):

   286

        self.Controller = controller

   287

        self.TagName = None

   288

   289

    def GetTagName(self):

   290

        return self.TagName

   291

   292

    def ConfigTagName(self, context, *args):

   293

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

   294

   295

    def ResourceTagName(self, context, *args):

   296

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

   297

   298

    def PouTagName(self, context, *args):

   299

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

   300

   301

    def ActionTagName(self, context, *args):

   302

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

   303

   304

    def TransitionTagName(self, context, *args):

   305

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

   306

   307

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

   308

#           Helpers object for generating pou block instances list

   309

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

   310

   311

   312

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

   313

   314

_BlockInstanceInfos = namedtuple("BlockInstanceInfos",

   315

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

   316

   317

_BlockSpecificValues = (

   318

    namedtuple("BlockSpecificValues",

   319

               ["name", "execution_order"]),

   320

    [_StringValue, int])

   321

_VariableSpecificValues = (

   322

    namedtuple("VariableSpecificValues",

   323

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

   324

    [_StringValue, _StringValue, int])

   325

_ConnectionSpecificValues = (

   326

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

   327

    [_StringValue])

   328

   329

_PowerRailSpecificValues = (

   330

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

   331

    [int])

   332

   333

_LDElementSpecificValues = (

   334

    namedtuple("LDElementSpecificValues",

   335

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

   336

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

   337

   338

_DivergenceSpecificValues = (

   339

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

   340

    [int])

   341

   342

_SpecificValuesTuples = {

   343

    "comment": (

   344

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

   345

        [_StringValue]),

   346

    "input": _VariableSpecificValues,

   347

    "output": _VariableSpecificValues,

   348

    "inout": _VariableSpecificValues,

   349

    "connector": _ConnectionSpecificValues,

   350

    "continuation": _ConnectionSpecificValues,

   351

    "leftPowerRail": _PowerRailSpecificValues,

   352

    "rightPowerRail": _PowerRailSpecificValues,

   353

    "contact": _LDElementSpecificValues,

   354

    "coil": _LDElementSpecificValues,

   355

    "step": (

   356

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

   357

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

   358

    "transition": (

   359

        namedtuple("TransitionSpecificValues",

   360

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

   361

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

   362

    "selectionDivergence": _DivergenceSpecificValues,

   363

    "selectionConvergence": _DivergenceSpecificValues,

   364

    "simultaneousDivergence": _DivergenceSpecificValues,

   365

    "simultaneousConvergence": _DivergenceSpecificValues,

   366

    "jump": (

   367

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

   368

        [_StringValue]),

   369

    "actionBlock": (

   370

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

   371

        [lambda x: x]),

   372

}

   373

   374

_InstanceConnectionInfos = namedtuple("InstanceConnectionInfos",

   375

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

   376

   377

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

   378

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

   379

   380

   381

class _ActionInfos(object):

   382

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

   383

   384

    def __init__(self, *args):

   385

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

   386

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

   387

   388

    def copy(self):

   389

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

   390

   391

   392

class BlockInstanceFactory:

   393

   394

    def __init__(self, block_instances):

   395

        self.BlockInstances = block_instances

   396

        self.CurrentInstance = None

   397

        self.SpecificValues = None

   398

        self.CurrentConnection = None

   399

        self.CurrentLink = None

   400

   401

    def SetSpecificValues(self, context, *args):

   402

        self.SpecificValues = list(args)

   403

        self.CurrentInstance = None

   404

        self.CurrentConnection = None

   405

        self.CurrentLink = None

   406

   407

    def AddBlockInstance(self, context, *args):

   408

        specific_values_tuple, specific_values_translation = \

   409

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

   410

   413

            self.SpecificValues.append([None])

   414

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

   415

            self.SpecificValues.append([[]])

   416

        specific_values = specific_values_tuple(*_translate_args(

   417

            specific_values_translation, self.SpecificValues))

   418

        self.SpecificValues = None

   419

   420

        self.CurrentInstance = _BlockInstanceInfos(

   421

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

   422

              [specific_values, [], []]))

   423

   424

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

   425

   426

    def AddInstanceConnection(self, context, *args):

   427

        connection_args = _translate_args(

   428

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

   429

   430

        self.CurrentConnection = _InstanceConnectionInfos(

   431

            *(connection_args[1:4] + [

   432

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

   433

   434

        if self.CurrentInstance is not None:

   435

            if connection_args[0] == "input":

   436

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

   437

            else:

   438

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

   439

        else:

   440

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

   441

   442

    def AddConnectionLink(self, context, *args):

   443

        self.CurrentLink = _ConnectionLinkInfos(

   444

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

   445

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

   446

   447

    def AddLinkPoint(self, context, *args):

   448

        self.CurrentLink.points.append(_Point(

   449

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

   450

   451

    def AddAction(self, context, *args):

   452

        if len(self.SpecificValues) == 0:

   453

            self.SpecificValues.append([[]])

   454

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

   455

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

   456

   457

   458

pou_block_instances_xslt = etree.parse(

   459

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

   460

   461

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

   462

#                         Undo Buffer for PLCOpenEditor

   463

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

   464

   465

# Length of the buffer

   466

UNDO_BUFFER_LENGTH = 20

   467

   468

   469

class UndoBuffer:

   470

    """

   471

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

   472

    """

   473

   474

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

   475

        """

   476

        Constructor initialising buffer

   477

        """

   478

        self.Buffer = []

   479

        self.CurrentIndex = -1

   480

        self.MinIndex = -1

   481

        self.MaxIndex = -1

   482

        # if current state is defined

   483

        if currentstate:

   484

            self.CurrentIndex = 0

   485

            self.MinIndex = 0

   486

            self.MaxIndex = 0

   487

        # Initialising buffer with currentstate at the first place

   488

        for i in xrange(UNDO_BUFFER_LENGTH):