1

#!/usr/bin/env python

     2

# -*- coding: utf-8 -*-

     3

     4

#This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     5

#based on the plcopen standard. 

     6

#

     7

#Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     8

#

     9

#See COPYING file for copyrights details.

    10

#

    11

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

    12

#modify it under the terms of the GNU General Public

    13

#License as published by the Free Software Foundation; either

    14

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

    15

#

    16

#This library 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 GNU

    19

#General Public License for more details.

    20

#

    21

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

    22

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

    23

#Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    24

    25

from xmlclass import *

    26

from structures import *

    27

from types import *

    28

import os, re

    29

    30

"""

    31

Dictionary that makes the relation between var names in plcopen and displayed values

    32

"""

    33

VarTypes = {"Local" : "localVars", "Temp" : "tempVars", "Input" : "inputVars",

    34

            "Output" : "outputVars", "InOut" : "inOutVars", "External" : "externalVars",

    35

            "Global" : "globalVars", "Access" : "accessVars"}

    36

    37

searchResultVarTypes = {

    38

    "inputVars": "var_input",

    39

    "outputVars": "var_output",

    40

    "inOutVars": "var_inout"

    41

}

    42

    43

"""

    44

Define in which order var types must be displayed

    45

"""

    46

VarOrder = ["Local","Temp","Input","Output","InOut","External","Global","Access"]

    47

    48

"""

    49

Define which action qualifier must be associated with a duration 

    50

"""

    51

QualifierList = {"N" : False, "R" : False, "S" : False, "L" : True, "D" : True, 

    52

    "P" : False, "P0" : False, "P1" : False, "SD" : True, "DS" : True, "SL" : True}

    53

    54

    55

FILTER_ADDRESS_MODEL = "(%%[IQM](?:[XBWDL])?)(%s)((?:\.[0-9]+)*)" 

    56

    57

def update_address(address, address_model, new_leading):

    58

    result = address_model.match(address)

    59

    if result is None:

    60

        return address

    61

    groups = result.groups()

    62

    return groups[0] + new_leading + groups[2]

    63

    64

def _init_and_compare(function, v1, v2):

    65

    if v1 is None:

    66

        return v2

    67

    if v2 is not None:

    68

        return function(v1, v2)

    69

    return v1

    70

    71

"""

    72

Helper class for bounding_box calculation 

    73

"""

    74

class rect:

    75

    76

    def __init__(self, x=None, y=None, width=None, height=None):

    77

        self.x_min = x

    78

        self.x_max = None

    79

        self.y_min = y

    80

        self.y_max = None

    81

        if width is not None and x is not None:

    82

            self.x_max = x + width

    83

        if height is not None and y is not None:

    84

            self.y_max = y + height

    85

    86

    def update(self, x, y):

    87

        self.x_min = _init_and_compare(min, self.x_min, x)

    88

        self.x_max = _init_and_compare(max, self.x_max, x)

    89

        self.y_min = _init_and_compare(min, self.y_min, y)

    90

        self.y_max = _init_and_compare(max, self.y_max, y)

    91

    92

    def union(self, rect):

    93

        self.x_min = _init_and_compare(min, self.x_min, rect.x_min)

    94

        self.x_max = _init_and_compare(max, self.x_max, rect.x_max)

    95

        self.y_min = _init_and_compare(min, self.y_min, rect.y_min)

    96

        self.y_max = _init_and_compare(max, self.y_max, rect.y_max)

    97

    98

    def bounding_box(self):

    99

        width = height = None

   100

        if self.x_min is not None and self.x_max is not None:

   101

            width = self.x_max - self.x_min

   102

        if self.y_min is not None and self.y_max is not None:

   103

            height = self.y_max - self.y_min

   104

        return self.x_min, self.y_min, width, height

   105

   106

def TextLenInRowColumn(text):

   107

    if text == "":

   108

        return (0, 0)

   109

    lines = text.split("\n")

   110

    return len(lines) - 1, len(lines[-1])

   111

   112

def TestTextElement(text, criteria):

   113

    lines = text.splitlines()

   114

    if not criteria["case_sensitive"]:

   115

        text = text.upper()

   116

    test_result = []

   117

    result = criteria["pattern"].search(text)

   118

    while result is not None:

   119

        start = TextLenInRowColumn(text[:result.start()])

   120

        end = TextLenInRowColumn(text[:result.end() - 1])

   121

        test_result.append((start, end, "\n".join(lines[start[0]:end[0] + 1])))

   122

        result = criteria["pattern"].search(text, result.end())

   123

    return test_result

   124

   125

PLCOpenClasses = GenerateClassesFromXSD(os.path.join(os.path.split(__file__)[0], "tc6_xml_v201.xsd"))

   126

   127

ElementNameToClass = {}

   128

   129

cls = PLCOpenClasses.get("formattedText", None)

   130

if cls:

   131

    def updateElementName(self, old_name, new_name):

   132

        text = self.text.decode("utf-8")

   133

        index = text.find(old_name)

   134

        while index != -1:

   135

            if index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_"):

   136

                index = text.find(old_name, index + len(old_name))

   137

            elif index < len(text) - len(old_name) and (text[index + len(old_name)].isalnum() or text[index + len(old_name)] == "_"):

   138

                index = text.find(old_name, index + len(old_name))

   139

            else:

   140

                text = text[:index] + new_name + text[index + len(old_name):]

   141

                index = text.find(old_name, index + len(new_name))

   142

        self.text = text.encode("utf-8")

   143

    setattr(cls, "updateElementName", updateElementName)

   144

   145

    def updateElementAddress(self, address_model, new_leading):

   146

        text = self.text.decode("utf-8")

   147

        startpos = 0

   148

        result = address_model.search(text, startpos)

   149

        while result is not None:

   150

            groups = result.groups()

   151

            new_address = groups[0] + new_leading + groups[2]

   152

            text = text[:result.start()] + new_address + text[result.end():]

   153

            startpos = result.start() + len(new_address)

   154

            result = address_model.search(self.text, startpos)

   155

        self.text = text.encode("utf-8")

   156

    setattr(cls, "updateElementAddress", updateElementAddress)

   157

   158

    def Search(self, criteria, parent_infos):

   159

        return [(tuple(parent_infos),) + result for result in TestTextElement(self.gettext(), criteria)]

   160

    setattr(cls, "Search", Search)

   161

   162

cls = PLCOpenClasses.get("project", None)

   163

if cls:

   164

    cls.singleLineAttributes = False

   165

    cls.EnumeratedDataTypeValues = {}

   166

    cls.CustomDataTypeRange = {}

   167

    cls.CustomTypeHierarchy = {}

   168

    cls.ElementUsingTree = {}

   169

    cls.CustomBlockTypes = []

   170

   171

    def setname(self, name):

   172

        self.contentHeader.setname(name)

   173

    setattr(cls, "setname", setname)

   174

   175

    def getname(self):

   176

        return self.contentHeader.getname()

   177

    setattr(cls, "getname", getname)

   178

   179

    def getfileHeader(self):

   180

        fileheader = {}

   181

        for name, value in [("companyName", self.fileHeader.getcompanyName()),

   182

                            ("companyURL", self.fileHeader.getcompanyURL()),

   183

                            ("productName", self.fileHeader.getproductName()),

   184

                            ("productVersion", self.fileHeader.getproductVersion()),

   185

                            ("productRelease", self.fileHeader.getproductRelease()),

   186

                            ("creationDateTime", self.fileHeader.getcreationDateTime()),

   187

                            ("contentDescription", self.fileHeader.getcontentDescription())]:

   188

            if value is not None:

   189

                fileheader[name] = value

   190

            else:

   191

                fileheader[name] = ""

   192

        return fileheader

   193

    setattr(cls, "getfileHeader", getfileHeader)

   194

   195

    def setfileHeader(self, fileheader):

   196

        if fileheader.has_key("companyName"):

   197

            self.fileHeader.setcompanyName(fileheader["companyName"])

   198

        if fileheader.has_key("companyURL"):

   199

            self.fileHeader.setcompanyURL(fileheader["companyURL"])

   200

        if fileheader.has_key("productName"):

   201

            self.fileHeader.setproductName(fileheader["productName"])

   202

        if fileheader.has_key("productVersion"):

   203

            self.fileHeader.setproductVersion(fileheader["productVersion"])

   204

        if fileheader.has_key("productRelease"):

   205

            self.fileHeader.setproductRelease(fileheader["productRelease"])

   206

        if fileheader.has_key("creationDateTime"):

   207

            self.fileHeader.setcreationDateTime(fileheader["creationDateTime"])

   208

        if fileheader.has_key("contentDescription"):

   209

            self.fileHeader.setcontentDescription(fileheader["contentDescription"])

   210

    setattr(cls, "setfileHeader", setfileHeader)

   211

   212

    def getcontentHeader(self):

   213

        contentheader = {}

   214

        for name, value in [("projectName", self.contentHeader.getname()),

   215

                            ("projectVersion", self.contentHeader.getversion()),

   216

                            ("modificationDateTime", self.contentHeader.getmodificationDateTime()),

   217

                            ("organization", self.contentHeader.getorganization()),

   218

                            ("authorName", self.contentHeader.getauthor()),

   219

                            ("language", self.contentHeader.getlanguage())]:

   220

            if value is not None:

   221

                contentheader[name] = value

   222

            else:

   223

                contentheader[name] = ""

   224

        contentheader["pageSize"] = self.contentHeader.getpageSize()

   225

        contentheader["scaling"] = self.contentHeader.getscaling()

   226

        return contentheader

   227

    setattr(cls, "getcontentHeader", getcontentHeader)

   228

   229

    def setcontentHeader(self, contentheader):

   230

        if contentheader.has_key("projectName"):

   231

            self.contentHeader.setname(contentheader["projectName"])

   232

        if contentheader.has_key("projectVersion"):

   233

            self.contentHeader.setversion(contentheader["projectVersion"])

   234

        if contentheader.has_key("modificationDateTime"):

   235

            self.contentHeader.setmodificationDateTime(contentheader["modificationDateTime"])

   236

        if contentheader.has_key("organization"):

   237

            self.contentHeader.setorganization(contentheader["organization"])

   238

        if contentheader.has_key("authorName"):

   239

            self.contentHeader.setauthor(contentheader["authorName"])

   240

        if contentheader.has_key("language"):

   241

            self.contentHeader.setlanguage(contentheader["language"])

   242

        if contentheader.has_key("pageSize"):

   243

            self.contentHeader.setpageSize(*contentheader["pageSize"])

   244

        if contentheader.has_key("scaling"):

   245

            self.contentHeader.setscaling(contentheader["scaling"])

   246

    setattr(cls, "setcontentHeader", setcontentHeader)

   247

   248

    def getdataTypes(self):

   249

        return self.types.getdataTypeElements()

   250

    setattr(cls, "getdataTypes", getdataTypes)

   251

   252

    def getdataType(self, name):

   253

        return self.types.getdataTypeElement(name)

   254

    setattr(cls, "getdataType", getdataType)

   255

   256

    def appenddataType(self, name):

   257

        if self.CustomTypeHierarchy.has_key(name):

   258

            raise ValueError, "\"%s\" Data Type already exists !!!"%name

   259

        self.types.appenddataTypeElement(name)

   260

        self.AddCustomDataType(self.getdataType(name))

   261

    setattr(cls, "appenddataType", appenddataType)

   262

   263

    def insertdataType(self, index, datatype):

   264

        self.types.insertdataTypeElement(index, datatype)

   265

        self.AddCustomDataType(datatype)

   266

    setattr(cls, "insertdataType", insertdataType)

   267

   268

    def removedataType(self, name):

   269

        self.types.removedataTypeElement(name)

   270

        self.RefreshDataTypeHierarchy()

   271

        self.RefreshElementUsingTree()

   272

    setattr(cls, "removedataType", removedataType)

   273

   274

    def getpous(self):

   275

        return self.types.getpouElements()

   276

    setattr(cls, "getpous", getpous)

   277

   278

    def getpou(self, name):

   279

        return self.types.getpouElement(name)

   280

    setattr(cls, "getpou", getpou)

   281

   282

    def appendpou(self, name, pou_type, body_type):

   283

        self.types.appendpouElement(name, pou_type, body_type)

   284

        self.AddCustomBlockType(self.getpou(name))

   285

    setattr(cls, "appendpou", appendpou)

   286

   287

    def insertpou(self, index, pou):

   288

        self.types.insertpouElement(index, pou)

   289

        self.AddCustomBlockType(pou)

   290

    setattr(cls, "insertpou", insertpou)

   291

   292

    def removepou(self, name):

   293

        self.types.removepouElement(name)

   294

        self.RefreshCustomBlockTypes()

   295

        self.RefreshElementUsingTree()

   296

    setattr(cls, "removepou", removepou)

   297

   298

    def getconfigurations(self):

   299

        configurations = self.instances.configurations.getconfiguration()

   300

        if configurations:

   301

            return configurations

   302

        return []

   303

    setattr(cls, "getconfigurations", getconfigurations)

   304

   305

    def getconfiguration(self, name):

   306

        for configuration in self.instances.configurations.getconfiguration():

   307

            if configuration.getname() == name:

   308

                return configuration

   309

        return None

   310

    setattr(cls, "getconfiguration", getconfiguration)

   311

   312

    def addconfiguration(self, name):

   313

        for configuration in self.instances.configurations.getconfiguration():

   314

            if configuration.getname() == name:

   315

                raise ValueError, _("\"%s\" configuration already exists !!!")%name

   316

        new_configuration = PLCOpenClasses["configurations_configuration"]()

   317

        new_configuration.setname(name)

   318

        self.instances.configurations.appendconfiguration(new_configuration)

   319

    setattr(cls, "addconfiguration", addconfiguration)    

   320

   321

    def removeconfiguration(self, name):

   322

        found = False

   323

        for idx, configuration in enumerate(self.instances.configurations.getconfiguration()):

   324

            if configuration.getname() == name:

   325

                self.instances.configurations.removeconfiguration(idx)

   326

                found = True

   327

                break

   328

        if not found:

   329

            raise ValueError, ("\"%s\" configuration doesn't exist !!!")%name

   330

    setattr(cls, "removeconfiguration", removeconfiguration)

   331

   332

    def getconfigurationResource(self, config_name, name):

   333

        configuration = self.getconfiguration(config_name)

   334

        if configuration:

   335

            for resource in configuration.getresource():

   336

                if resource.getname() == name:

   337

                    return resource

   338

        return None

   339

    setattr(cls, "getconfigurationResource", getconfigurationResource)

   340

   341

    def addconfigurationResource(self, config_name, name):

   342

        configuration = self.getconfiguration(config_name)

   343

        if configuration:

   344

            for resource in configuration.getresource():

   345

                if resource.getname() == name:

   346

                    raise ValueError, _("\"%s\" resource already exists in \"%s\" configuration !!!")%(name, config_name)

   347

            new_resource = PLCOpenClasses["configuration_resource"]()

   348

            new_resource.setname(name)

   349

            configuration.appendresource(new_resource)

   350

    setattr(cls, "addconfigurationResource", addconfigurationResource)

   351

   352

    def removeconfigurationResource(self, config_name, name):

   353

        configuration = self.getconfiguration(config_name)

   354

        if configuration:

   355

            found = False

   356

            for idx, resource in enumerate(configuration.getresource()):

   357

                if resource.getname() == name:

   358

                    configuration.removeresource(idx)

   359

                    found = True

   360

                    break

   361

            if not found:

   362

                raise ValueError, _("\"%s\" resource doesn't exist in \"%s\" configuration !!!")%(name, config_name)

   363

    setattr(cls, "removeconfigurationResource", removeconfigurationResource)

   364

   365

    def updateElementName(self, old_name, new_name):

   366

        for datatype in self.types.getdataTypeElements():

   367

            datatype.updateElementName(old_name, new_name)

   368

        for pou in self.types.getpouElements():

   369

            pou.updateElementName(old_name, new_name)

   370

        for configuration in self.instances.configurations.getconfiguration():

   371

            configuration.updateElementName(old_name, new_name)

   372

    setattr(cls, "updateElementName", updateElementName)

   373

   374

    def updateElementAddress(self, old_leading, new_leading):

   375

        address_model = re.compile(FILTER_ADDRESS_MODEL % old_leading)

   376

        for pou in self.types.getpouElements():

   377

            pou.updateElementAddress(address_model, new_leading)

   378

        for configuration in self.instances.configurations.getconfiguration():

   379

            configuration.updateElementAddress(address_model, new_leading)

   380

    setattr(cls, "updateElementAddress", updateElementAddress)

   381

   382

    def removeVariableByAddress(self, address):

   383

        for pou in self.types.getpouElements():

   384

            pou.removeVariableByAddress(address)

   385

        for configuration in self.instances.configurations.getconfiguration():

   386

            configuration.removeVariableByAddress(address)

   387

    setattr(cls, "removeVariableByAddress", removeVariableByAddress)

   388

   389

    def removeVariableByFilter(self, leading):

   390

        address_model = re.compile(FILTER_ADDRESS_MODEL % leading)

   391

        for pou in self.types.getpouElements():

   392

            pou.removeVariableByFilter(address_model)

   393

        for configuration in self.instances.configurations.getconfiguration():

   394

            configuration.removeVariableByFilter(address_model)

   395

    setattr(cls, "removeVariableByFilter", removeVariableByFilter)

   396

   397

    def RefreshDataTypeHierarchy(self):

   398

        self.EnumeratedDataTypeValues = {}

   399

        self.CustomDataTypeRange = {}

   400

        self.CustomTypeHierarchy = {}

   401

        for datatype in self.getdataTypes():

   402

            self.AddCustomDataType(datatype)

   403

    setattr(cls, "RefreshDataTypeHierarchy", RefreshDataTypeHierarchy)

   404

   405

    def AddCustomDataType(self, datatype):

   406

        name = datatype.getname()

   407

        basetype_content = datatype.getbaseType().getcontent()

   408

        if basetype_content["value"] is None:

   409

            self.CustomTypeHierarchy[name] = basetype_content["name"]

   410

        elif basetype_content["name"] in ["string", "wstring"]:

   411

            self.CustomTypeHierarchy[name] = basetype_content["name"].upper()

   412

        elif basetype_content["name"] == "derived":

   413

            self.CustomTypeHierarchy[name] = basetype_content["value"].getname()

   414

        elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned"]:

   415

            range = (basetype_content["value"].range.getlower(), 

   416

                     basetype_content["value"].range.getupper())

   417

            self.CustomDataTypeRange[name] = range

   418

            base_type = basetype_content["value"].baseType.getcontent()

   419

            if base_type["value"] is None:

   420

                self.CustomTypeHierarchy[name] = base_type["name"]

   421

            else:

   422

                self.CustomTypeHierarchy[name] = base_type["value"].getname()

   423

        else:

   424

            if basetype_content["name"] == "enum":

   425

                values = []

   426

                for value in basetype_content["value"].values.getvalue():

   427

                    values.append(value.getname())

   428

                self.EnumeratedDataTypeValues[name] = values

   429

            self.CustomTypeHierarchy[name] = "ANY_DERIVED"

   430

    setattr(cls, "AddCustomDataType", AddCustomDataType)

   431

   432

    # Update Block types with user-defined pou added

   433

    def RefreshCustomBlockTypes(self):

   434

        # Reset the tree of user-defined pou cross-use

   435

        self.CustomBlockTypes = []

   436

        for pou in self.getpous():

   437

            self.AddCustomBlockType(pou)

   438

    setattr(cls, "RefreshCustomBlockTypes", RefreshCustomBlockTypes)

   439

   440

    def AddCustomBlockType(self, pou): 

   441

        pou_name = pou.getname()

   442

        pou_type = pou.getpouType()

   443

        block_infos = {"name" : pou_name, "type" : pou_type, "extensible" : False,

   444

                       "inputs" : [], "outputs" : [], "comment" : pou.getdescription(),

   445

                       "generate" : generate_block, "initialise" : initialise_block}

   446

        if pou.getinterface():

   447

            return_type = pou.interface.getreturnType()

   448

            if return_type:

   449

                var_type = return_type.getcontent()

   450

                if var_type["name"] == "derived":

   451

                    block_infos["outputs"].append(("", var_type["value"].getname(), "none"))

   452

                elif var_type["name"] in ["string", "wstring"]:

   453

                    block_infos["outputs"].append(("", var_type["name"].upper(), "none"))

   454

                else:

   455

                    block_infos["outputs"].append(("", var_type["name"], "none"))

   456

            for type, varlist in pou.getvars():

   457

                if type == "InOut":

   458

                    for var in varlist.getvariable():

   459

                        var_type = var.type.getcontent()

   460

                        if var_type["name"] == "derived":

   461

                            block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))

   462

                            block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))

   463

                        elif var_type["name"] in ["string", "wstring"]:

   464

                            block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))

   465

                            block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))

   466

                        else:

   467

                            block_infos["inputs"].append((var.getname(), var_type["name"], "none"))

   468

                            block_infos["outputs"].append((var.getname(), var_type["name"], "none"))

   469

                elif type == "Input":

   470

                    for var in varlist.getvariable():

   471

                        var_type = var.type.getcontent()

   472

                        if var_type["name"] == "derived":

   473

                            block_infos["inputs"].append((var.getname(), var_type["value"].getname(), "none"))

   474

                        elif var_type["name"] in ["string", "wstring"]:

   475

                            block_infos["inputs"].append((var.getname(), var_type["name"].upper(), "none"))

   476

                        else:

   477

                            block_infos["inputs"].append((var.getname(), var_type["name"], "none"))

   478

                elif type == "Output":

   479

                    for var in varlist.getvariable():

   480

                        var_type = var.type.getcontent()

   481

                        if var_type["name"] == "derived":

   482

                            block_infos["outputs"].append((var.getname(), var_type["value"].getname(), "none"))

   483

                        elif var_type["name"] in ["string", "wstring"]:

   484

                            block_infos["outputs"].append((var.getname(), var_type["name"].upper(), "none"))

   485

                        else:

   486

                            block_infos["outputs"].append((var.getname(), var_type["name"], "none"))    

   487

        block_infos["usage"] = "\n (%s) => (%s)" % (", ".join(["%s:%s" % (input[1], input[0]) for input in block_infos["inputs"]]),

   488

                                                    ", ".join(["%s:%s" % (output[1], output[0]) for output in block_infos["outputs"]]))

   489

        self.CustomBlockTypes.append(block_infos)

   490

    setattr(cls, "AddCustomBlockType", AddCustomBlockType)

   491

   492

    def RefreshElementUsingTree(self):

   493

        # Reset the tree of user-defined element cross-use

   494

        self.ElementUsingTree = {}

   495

        pous = self.getpous()

   496

        datatypes = self.getdataTypes()

   497

        # Reference all the user-defined elementu names and initialize the tree of 

   498

        # user-defined elemnt cross-use

   499

        elementnames = [datatype.getname() for datatype in datatypes] + \

   500

                       [pou.getname() for pou in pous]

   501

        for name in elementnames:

   502

            self.ElementUsingTree[name] = []

   503

        # Analyze each datatype

   504

        for datatype in datatypes:

   505

            name = datatype.getname()

   506

            basetype_content = datatype.baseType.getcontent()

   507

            if basetype_content["name"] == "derived":

   508

                typename = basetype_content["value"].getname()

   509

                if name in self.ElementUsingTree[typename]:

   510

                    self.ElementUsingTree[typename].append(name)

   511

            elif basetype_content["name"] in ["subrangeSigned", "subrangeUnsigned", "array"]:

   512

                base_type = basetype_content["value"].baseType.getcontent()

   513

                if base_type["name"] == "derived":

   514

                    typename = base_type["value"].getname()

   515

                    if self.ElementUsingTree.has_key(typename) and name not in self.ElementUsingTree[typename]:

   516

                        self.ElementUsingTree[typename].append(name)

   517

            elif basetype_content["name"] == "struct":

   518

                for element in basetype_content["value"].getvariable():

   519

                    type_content = element.type.getcontent()

   520

                    if type_content["name"] == "derived":

   521

                        typename = type_content["value"].getname()

   522

                        if self.ElementUsingTree.has_key(typename) and name not in self.ElementUsingTree[typename]:

   523

                            self.ElementUsingTree[typename].append(name)

   524

        # Analyze each pou

   525

        for pou in pous:

   526

            name = pou.getname()

   527

            if pou.interface:

   528

                # Extract variables from every varLists

   529

                for type, varlist in pou.getvars():

   530