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 = [

    45

    ITEM_PROJECT,

    46

    ITEM_POU,

    47

    ITEM_VARIABLE,

    48

    ITEM_TRANSITION,

    49

    ITEM_ACTION,

    50

    ITEM_CONFIGURATION,

    51

    ITEM_RESOURCE,

    52

    ITEM_DATATYPE

    53

] = range(8)

    54

    55

ITEMS_UNEDITABLE = [

    56

    ITEM_DATATYPES,

    57

    ITEM_FUNCTION,

    58

    ITEM_FUNCTIONBLOCK,

    59

    ITEM_PROGRAM,

    60

    ITEM_TRANSITIONS,

    61

    ITEM_ACTIONS,

    62

    ITEM_CONFIGURATIONS,

    63

    ITEM_RESOURCES,

    64

    ITEM_PROPERTIES

    65

] = range(8, 17)

    66

    67

ITEMS_VARIABLE = [

    68

    ITEM_VAR_LOCAL,

    69

    ITEM_VAR_GLOBAL,

    70

    ITEM_VAR_EXTERNAL,

    71

    ITEM_VAR_TEMP,

    72

    ITEM_VAR_INPUT,

    73

    ITEM_VAR_OUTPUT,

    74

    ITEM_VAR_INOUT

    75

] = range(17, 24)

    76

    77

VAR_CLASS_INFOS = {

    78

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

    79

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

    80

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

    81

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

    82

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

    83

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

    84

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

    85

    86

POU_TYPES = {

    87

    "program": ITEM_PROGRAM,

    88

    "functionBlock": ITEM_FUNCTIONBLOCK,

    89

    "function": ITEM_FUNCTION,

    90

}

    91

    92

LOCATIONS_ITEMS = [LOCATION_CONFNODE,

    93

                   LOCATION_MODULE,

    94

                   LOCATION_GROUP,

    95

                   LOCATION_VAR_INPUT,

    96

                   LOCATION_VAR_OUTPUT,

    97

                   LOCATION_VAR_MEMORY] = range(6)

    98

    99

ScriptDirectory = paths.AbsDir(__file__)

   100

   101

   102

def GetUneditableNames():

   103

    _ = NoTranslate

   104

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

   105

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

   106

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

   107

   108

   109

UNEDITABLE_NAMES = GetUneditableNames()

   110

[USER_DEFINED_POUS, FUNCTIONS, FUNCTION_BLOCKS, PROGRAMS,

   111

 DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

   112

 RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

   113

   114

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

   115

#                 Helper object for loading library in xslt stylesheets

   116

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

   117

   118

   119

class LibraryResolver(etree.Resolver):

   120

   121

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

   122

        self.Controller = controller

   123

        self.Debug = debug

   124

   125

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

   126

        lib_name = os.path.basename(url)

   127

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

   128

            lib_el = etree.Element(lib_name)

   129

            if lib_name == "project":

   130

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

   131

            elif lib_name == "stdlib":

   132

                for lib in StdBlckLibs.values():

   133

                    lib_el.append(deepcopy(lib))

   134

            else:

   135

                for ctn in self.Controller.ConfNodeTypes:

   136

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

   137

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

   138

   139

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

   140

#           Helpers functions for translating list of arguments

   141

#                       from xslt to valid arguments

   142

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

   143

   144

   145

def _StringValue(x):

   146

    return x

   147

   148

   149

def _BoolValue(x):

   150

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

   151

   152

   153

def _translate_args(translations, args):

   154

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

   155

            for translate, arg in

   156

            zip(translations, args)]

   157

   158

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

   159

#                 Helpers object for generating pou var list

   160

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

   161

   162

   163

class _VariableInfos(object):

   164

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

   165

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

   166

   167

    def __init__(self, *args):

   168

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

   169

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

   170

   171

    def copy(self):

   172

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

   173

   174

   175

class VariablesInfosFactory:

   176

   177

    def __init__(self, variables):

   178

        self.Variables = variables

   179

        self.TreeStack = []

   180

        self.Type = None

   181

        self.Dimensions = None

   182

   183

    def SetType(self, context, *args):

   184

        self.Type = args[0][0]

   185

   186

    def GetType(self):

   187

        if len(self.Dimensions) > 0:

   188

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

   189

        return self.Type

   190

   191

    def GetTree(self):

   192

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

   193

   194

    def AddDimension(self, context, *args):

   195

        self.Dimensions.append(tuple(

   196

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

   197

   198

    def AddTree(self, context, *args):

   199

        self.TreeStack.append([])

   200

        self.Dimensions = []

   201

   202

    def AddVarToTree(self, context, *args):

   203

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

   204

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

   205

   206

    def AddVariable(self, context, *args):

   207

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

   208

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

   209

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

   210

   211

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

   212

#            Helpers object for generating pou variable instance list

   213

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

   214

   215

   216

def class_extraction(value):

   217

    class_type = {

   218

        "configuration": ITEM_CONFIGURATION,

   219

        "resource": ITEM_RESOURCE,

   220

        "action": ITEM_ACTION,

   221

        "transition": ITEM_TRANSITION,

   222

        "program": ITEM_PROGRAM}.get(value)

   223

    if class_type is not None:

   224

        return class_type

   225

   226

    pou_type = POU_TYPES.get(value)

   227

    if pou_type is not None:

   228

        return pou_type

   229

   230

    var_type = VAR_CLASS_INFOS.get(value)

   231

    if var_type is not None:

   232

        return var_type[1]

   233

   234

    return None

   235

   236

   237

class _VariablesTreeItemInfos(object):

   238

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

   239

   240

    def __init__(self, *args):

   241

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

   242

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

   243

   244

    def copy(self):

   245

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

   246

   247

   248

class VariablesTreeInfosFactory:

   249

   250

    def __init__(self):

   251

        self.Root = None

   252

   253

    def GetRoot(self):

   254

        return self.Root

   255

   256

    def SetRoot(self, context, *args):

   257

        self.Root = _VariablesTreeItemInfos(

   258

            *([''] + _translate_args(

   259

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

   260

                args) + [[]]))

   261

   262

    def AddVariable(self, context, *args):

   263

        if self.Root is not None:

   264

            self.Root.variables.append(_VariablesTreeItemInfos(

   265

                *(_translate_args(

   266

                    [_StringValue, class_extraction, _StringValue] +

   267

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

   268

   269

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

   270

#            Helpers object for generating instances path list

   271

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

   272

   273

   274

class InstancesPathFactory:

   275

   276

    def __init__(self, instances):

   277

        self.Instances = instances

   278

   279

    def AddInstance(self, context, *args):

   280

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

   281

   282

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

   283

#            Helpers object for generating instance tagname

   284

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

   285

   286

   287

class InstanceTagName:

   288

   289

    def __init__(self, controller):

   290

        self.Controller = controller

   291

        self.TagName = None

   292

   293

    def GetTagName(self):

   294

        return self.TagName

   295

   296

    def ConfigTagName(self, context, *args):

   297

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

   298

   299

    def ResourceTagName(self, context, *args):

   300

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

   301

   302

    def PouTagName(self, context, *args):

   303

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

   304

   305

    def ActionTagName(self, context, *args):

   306

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

   307

   308

    def TransitionTagName(self, context, *args):

   309

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

   310

   311

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

   312

#           Helpers object for generating pou block instances list

   313

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

   314

   315

   316

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

   317

   318

_BlockInstanceInfos = namedtuple(

   319

    "BlockInstanceInfos",

   320

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

   321

   322

_BlockSpecificValues = (

   323

    namedtuple("BlockSpecificValues",

   324

               ["name", "execution_order"]),

   325

    [_StringValue, int])

   326

_VariableSpecificValues = (

   327

    namedtuple("VariableSpecificValues",

   328

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

   329

    [_StringValue, _StringValue, int])

   330

_ConnectionSpecificValues = (

   331

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

   332

    [_StringValue])

   333

   334

_PowerRailSpecificValues = (

   335

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

   336

    [int])

   337

   338

_LDElementSpecificValues = (

   339

    namedtuple("LDElementSpecificValues",

   340

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

   341

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

   342

   343

_DivergenceSpecificValues = (

   344

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

   345

    [int])

   346

   347

_SpecificValuesTuples = {

   348

    "comment": (

   349

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

   350

        [_StringValue]),

   351

    "input": _VariableSpecificValues,

   352

    "output": _VariableSpecificValues,

   353

    "inout": _VariableSpecificValues,

   354

    "connector": _ConnectionSpecificValues,

   355

    "continuation": _ConnectionSpecificValues,

   356

    "leftPowerRail": _PowerRailSpecificValues,

   357

    "rightPowerRail": _PowerRailSpecificValues,

   358

    "contact": _LDElementSpecificValues,

   359

    "coil": _LDElementSpecificValues,

   360

    "step": (

   361

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

   362

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

   363

    "transition": (

   364

        namedtuple("TransitionSpecificValues",

   365

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

   366

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

   367

    "selectionDivergence": _DivergenceSpecificValues,

   368

    "selectionConvergence": _DivergenceSpecificValues,

   369

    "simultaneousDivergence": _DivergenceSpecificValues,

   370

    "simultaneousConvergence": _DivergenceSpecificValues,

   371

    "jump": (

   372

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

   373

        [_StringValue]),

   374

    "actionBlock": (

   375

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

   376

        [lambda x: x]),

   377

}

   378

   379

_InstanceConnectionInfos = namedtuple(

   380

    "InstanceConnectionInfos",

   381

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

   382

   383

_ConnectionLinkInfos = namedtuple(

   384

    "ConnectionLinkInfos",

   385

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

   386

   387

   388

class _ActionInfos(object):

   389

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

   390

   391

    def __init__(self, *args):

   392

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

   393

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

   394

   395

    def copy(self):

   396

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

   397

   398

   399

class BlockInstanceFactory:

   400

   401

    def __init__(self, block_instances):

   402

        self.BlockInstances = block_instances

   403

        self.CurrentInstance = None

   404

        self.SpecificValues = None

   405

        self.CurrentConnection = None

   406

        self.CurrentLink = None

   407

   408

    def SetSpecificValues(self, context, *args):

   409

        self.SpecificValues = list(args)

   410

        self.CurrentInstance = None

   411

        self.CurrentConnection = None

   412

        self.CurrentLink = None

   413

   414

    def AddBlockInstance(self, context, *args):

   415

        specific_values_tuple, specific_values_translation = \

   416

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

   417

   418

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

   419

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

   420

            self.SpecificValues.append([None])

   421

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

   422

            self.SpecificValues.append([[]])

   423

        specific_values = specific_values_tuple(*_translate_args(

   424

            specific_values_translation, self.SpecificValues))

   425

        self.SpecificValues = None

   426

   427

        self.CurrentInstance = _BlockInstanceInfos(

   428

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

   429

              [specific_values, [], []]))

   430

   431

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

   432

   433

    def AddInstanceConnection(self, context, *args):

   434

        connection_args = _translate_args(

   435

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

   436

   437

        self.CurrentConnection = _InstanceConnectionInfos(

   438

            *(connection_args[1:4] + [

   439

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

   440

   441

        if self.CurrentInstance is not None:

   442

            if connection_args[0] == "input":

   443

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

   444

            else:

   445

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

   446

        else:

   447

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

   448

   449

    def AddConnectionLink(self, context, *args):

   450

        self.CurrentLink = _ConnectionLinkInfos(

   451

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

   452

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

   453

   454

    def AddLinkPoint(self, context, *args):

   455

        self.CurrentLink.points.append(_Point(

   456

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

   457

   458

    def AddAction(self, context, *args):

   459

        if len(self.SpecificValues) == 0:

   460

            self.SpecificValues.append([[]])

   461

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

   462

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

   463

   464

   465

pou_block_instances_xslt = etree.parse(

   466

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

   467

   468

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

   469

#                         Undo Buffer for PLCOpenEditor

   470

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

   471

   472

# Length of the buffer

   473

UNDO_BUFFER_LENGTH = 20

   474

   475

   476

class UndoBuffer:

   477

    """

   478

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

   479

    """

   480

   481

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

   482

        """

   483

        Constructor initialising buffer

   484

        """

   485

        self.Buffer = []