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

import string, os, sys, re

    26

    27

LANGUAGES = ["IL","ST","FBD","LD","SFC"]

    28

    29

LOCATIONDATATYPES = {"X" : ["BOOL"],

    30

                     "B" : ["SINT", "USINT", "BYTE", "STRING"],

    31

                     "W" : ["INT", "UINT", "WORD", "WSTRING"],

    32

                     "D" : ["DINT", "UDINT", "REAL", "DWORD"],

    33

                     "L" : ["LINT", "ULINT", "LREAL", "LWORD"]} 

    34

    35

_ = lambda x:x

    36

    37

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

    38

#                        Function Block Types definitions

    39

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

    40

    41

    42

"""

    43

Ordored list of common Function Blocks defined in the IEC 61131-3

    44

Each block have this attributes:

    45

    - "name" : The block name

    46

    - "type" : The block type. It can be "function", "functionBlock" or "program"

    47

    - "extensible" : Boolean that define if the block is extensible

    48

    - "inputs" : List of the block inputs

    49

    - "outputs" : List of the block outputs

    50

    - "comment" : Comment that will be displayed in the block popup

    51

    - "generate" : Method that generator will call for generating ST block code

    52

Inputs and outputs are a tuple of characteristics that are in order:

    53

    - The name

    54

    - The data type

    55

    - The default modifier which can be "none", "negated", "rising" or "falling"

    56

"""

    57

    58

StdBlckLst = [{"name" : _("Standard function blocks"), "list":

    59

               [{"name" : "SR", "type" : "functionBlock", "extensible" : False, 

    60

                    "inputs" : [("S1","BOOL","none"),("R","BOOL","none")], 

    61

                    "outputs" : [("Q1","BOOL","none")],

    63

                {"name" : "RS", "type" : "functionBlock", "extensible" : False, 

    64

                    "inputs" : [("S","BOOL","none"),("R1","BOOL","none")], 

    65

                    "outputs" : [("Q1","BOOL","none")],

    67

                {"name" : "SEMA", "type" : "functionBlock", "extensible" : False, 

    68

                    "inputs" : [("CLAIM","BOOL","none"),("RELEASE","BOOL","none")], 

    69

                    "outputs" : [("BUSY","BOOL","none")],

    71

                {"name" : "R_TRIG", "type" : "functionBlock", "extensible" : False, 

    72

                    "inputs" : [("CLK","BOOL","none")], 

    73

                    "outputs" : [("Q","BOOL","none")],

    75

                {"name" : "F_TRIG", "type" : "functionBlock", "extensible" : False, 

    76

                    "inputs" : [("CLK","BOOL","none")], 

    77

                    "outputs" : [("Q","BOOL","none")],

    79

                {"name" : "CTU", "type" : "functionBlock", "extensible" : False, 

    80

                    "inputs" : [("CU","BOOL","rising"),("R","BOOL","none"),("PV","INT","none")], 

    81

                    "outputs" : [("Q","BOOL","none"),("CV","INT","none")],

    83

                {"name" : "CTD", "type" : "functionBlock", "extensible" : False, 

    84

                    "inputs" : [("CD","BOOL","rising"),("LD","BOOL","none"),("PV","INT","none")], 

    85

                    "outputs" : [("Q","BOOL","none"),("CV","INT","none")],

    87

                {"name" : "CTUD", "type" : "functionBlock", "extensible" : False, 

    88

                    "inputs" : [("CU","BOOL","rising"),("CD","BOOL","rising"),("R","BOOL","none"),("LD","BOOL","none"),("PV","INT","none")], 

    89

                    "outputs" : [("QU","BOOL","none"),("QD","BOOL","none"),("CV","INT","none")],

    91

                {"name" : "TP", "type" : "functionBlock", "extensible" : False, 

    92

                    "inputs" : [("IN","BOOL","none"),("PT","TIME","none")], 

    93

                    "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],

    95

                {"name" : "TON", "type" : "functionBlock", "extensible" : False, 

    96

                    "inputs" : [("IN","BOOL","none"),("PT","TIME","none")], 

    97

                    "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],

    99

                {"name" : "TOF", "type" : "functionBlock", "extensible" : False, 

   100

                    "inputs" : [("IN","BOOL","none"),("PT","TIME","none")], 

   101

                    "outputs" : [("Q","BOOL","none"),("ET","TIME","none")],

   103

                ]},

   104

              {"name" : _("Additional function blocks"), "list":

   105

               [{"name" : "RTC", "type" : "functionBlock", "extensible" : False, 

   106

                    "inputs" : [("IN","BOOL","none"),("PDT","DATE_AND_TIME","none")], 

   107

                    "outputs" : [("Q","BOOL","none"),("CDT","DATE_AND_TIME","none")],

   109

                {"name" : "INTEGRAL", "type" : "functionBlock", "extensible" : False, 

   110

                    "inputs" : [("RUN","BOOL","none"),("R1","BOOL","none"),("XIN","REAL","none"),("X0","REAL","none"),("CYCLE","TIME","none")], 

   111

                    "outputs" : [("Q","BOOL","none"),("XOUT","REAL","none")],

   113

                {"name" : "DERIVATIVE", "type" : "functionBlock", "extensible" : False, 

   114

                    "inputs" : [("RUN","BOOL","none"),("XIN","REAL","none"),("CYCLE","TIME","none")], 

   115

                    "outputs" : [("XOUT","REAL","none")],

   117

                {"name" : "PID", "type" : "functionBlock", "extensible" : False, 

   118

                    "inputs" : [("AUTO","BOOL","none"),("PV","REAL","none"),("SP","REAL","none"),("X0","REAL","none"),("KP","REAL","none"),("TR","REAL","none"),("TD","REAL","none"),("CYCLE","TIME","none")], 

   119

                    "outputs" : [("XOUT","REAL","none")],

   121

                {"name" : "RAMP", "type" : "functionBlock", "extensible" : False, 

   122

                    "inputs" : [("RUN","BOOL","none"),("X0","REAL","none"),("X1","REAL","none"),("TR","TIME","none"),("CYCLE","TIME","none")], 

   123

                    "outputs" : [("BUSY","BOOL","none"),("XOUT","REAL","none")],

   125

                {"name" : "HYSTERESIS", "type" : "functionBlock", "extensible" : False, 

   126

                    "inputs" : [("XIN1","REAL","none"),("XIN2","REAL","none"),("EPS","REAL","none")], 

   127

                    "outputs" : [("Q","BOOL","none")],

   129

##                {"name" : "RATIO_MONITOR", "type" : "functionBlock", "extensible" : False, 

   130

##                    "inputs" : [("PV1","REAL","none"),("PV2","REAL","none"),("RATIO","REAL","none"),("TIMON","TIME","none"),("TIMOFF","TIME","none"),("TOLERANCE","BOOL","none"),("RESET","BOOL","none"),("CYCLE","TIME","none")], 

   131

##                    "outputs" : [("ALARM","BOOL","none"),("TOTAL_ERR","BOOL","none")],

   133

                ]},

   134

             ]

   135

   136

   137

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

   138

#                           Data Types definitions

   139

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

   140

   141

"""

   142

Ordored list of common data types defined in the IEC 61131-3

   143

Each type is associated to his direct parent type. It defines then a hierarchy

   144

between type that permits to make a comparison of two types

   145

"""

   146

TypeHierarchy_list = [

   147

    ("ANY", None),

   148

    ("ANY_DERIVED", "ANY"),

   149

    ("ANY_ELEMENTARY", "ANY"),

   150

    ("ANY_MAGNITUDE", "ANY_ELEMENTARY"),

   151

    ("ANY_BIT", "ANY_ELEMENTARY"),

   152

    ("ANY_NBIT", "ANY_BIT"),

   153

    ("ANY_STRING", "ANY_ELEMENTARY"),

   154

    ("ANY_DATE", "ANY_ELEMENTARY"),

   155

    ("ANY_NUM", "ANY_MAGNITUDE"),

   156

    ("ANY_REAL", "ANY_NUM"),

   157

    ("ANY_INT", "ANY_NUM"),

   158

    ("ANY_SINT", "ANY_INT"),

   159

    ("ANY_UINT", "ANY_INT"),

   160

    ("BOOL", "ANY_BIT"),

   161

    ("SINT", "ANY_SINT"),

   162

    ("INT", "ANY_SINT"),

   163

    ("DINT", "ANY_SINT"),

   164

    ("LINT", "ANY_SINT"),

   165

    ("USINT", "ANY_UINT"),

   166

    ("UINT", "ANY_UINT"),

   167

    ("UDINT", "ANY_UINT"),

   168

    ("ULINT", "ANY_UINT"),

   169

    ("REAL", "ANY_REAL"),

   170

    ("LREAL", "ANY_REAL"),

   171

    ("TIME", "ANY_MAGNITUDE"),

   172

    ("DATE", "ANY_DATE"),

   173

    ("TOD", "ANY_DATE"),

   174

    ("DT", "ANY_DATE"),

   175

    ("STRING", "ANY_STRING"),

   176

    ("BYTE", "ANY_NBIT"),

   177

    ("WORD", "ANY_NBIT"),

   178

    ("DWORD", "ANY_NBIT"),

   179

    ("LWORD", "ANY_NBIT")

   180

    #("WSTRING", "ANY_STRING") # TODO

   181

]

   182

   183

TypeHierarchy = dict(TypeHierarchy_list)

   184

   185

"""

   186

returns true if the given data type is the same that "reference" meta-type or one of its types.

   187

"""

   188

def IsOfType(type, reference):

   189

    if reference is None:

   190

        return True

   191

    elif type == reference:

   192

        return True

   193

    else:

   194

        parent_type = TypeHierarchy[type]

   195

        if parent_type is not None:

   196

            return IsOfType(parent_type, reference)

   197

    return False

   198

   199

"""

   200

returns list of all types that correspont to the ANY* meta type

   201

"""

   202

def GetSubTypes(type):

   203

    return [typename for typename, parenttype in TypeHierarchy.items() if not typename.startswith("ANY") and IsOfType(typename, type)]

   204

   205

   206

DataTypeRange_list = [

   207

    ("SINT", (-2**7, 2**7 - 1)),

   208

    ("INT", (-2**15, 2**15 - 1)),

   209

    ("DINT", (-2**31, 2**31 - 1)),

   210

    ("LINT", (-2**31, 2**31 - 1)),

   211

    ("USINT", (0, 2**8 - 1)),

   212

    ("UINT", (0, 2**16 - 1)),

   213

    ("UDINT", (0, 2**31 - 1)),

   214

    ("ULINT", (0, 2**31 - 1))

   215

]

   216

   217

DataTypeRange = dict(DataTypeRange_list)

   218

   219

   220

   221

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

   222

#                             Test identifier

   223

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

   224

   225

IDENTIFIER_MODEL = re.compile(

   226

    "(?:%(letter)s|_(?:%(letter)s|%(digit)s))(?:_?(?:%(letter)s|%(digit)s))*$" %

   227

    {"letter": "[a-zA-Z]", "digit": "[0-9]"})

   228

   229

# Test if identifier is valid

   230

def TestIdentifier(identifier):

   231

     return IDENTIFIER_MODEL.match(identifier) is not None

   232

   233

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

   234

#                        Standard functions list generation

   235

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

   236

   237

   238

"""

   239

take a .csv file and translate it it a "csv_table"

   240

"""            

   241

def csv_file_to_table(file):

   242

    return [ map(string.strip,line.split(';')) for line in file.xreadlines()]

   243

   244

"""

   245

seek into the csv table to a section ( section_name match 1st field )

   246

return the matching row without first field

   247

"""

   248

def find_section(section_name, table):

   249

    fields = [None]

   250

    while(fields[0] != section_name):

   251

        fields = table.pop(0)

   252

    return fields[1:]

   253

   254

"""

   255

extract the standard functions standard parameter names and types...

   256

return a { ParameterName: Type, ...}

   257

"""

   258

def get_standard_funtions_input_variables(table):

   259

    variables = find_section("Standard_functions_variables_types", table)

   260

    standard_funtions_input_variables = {}

   261

    fields = [True,True]

   262

    while(fields[1]):

   263

        fields = table.pop(0)

   264

        variable_from_csv = dict([(champ, val) for champ, val in zip(variables, fields[1:]) if champ!=''])

   265

        standard_funtions_input_variables[variable_from_csv['name']] = variable_from_csv['type']

   266

    return standard_funtions_input_variables

   267

   268

"""

   269

translate .csv file input declaration into PLCOpenEditor interessting values

   270

in : "(ANY_NUM, ANY_NUM)" and { ParameterName: Type, ...}

   271

return [("IN1","ANY_NUM","none"),("IN2","ANY_NUM","none")] 

   272

"""

   273

def csv_input_translate(str_decl, variables, base):

   274

    decl = str_decl.replace('(','').replace(')','').replace(' ','').split(',')

   275

    params = []

   276

   277

    len_of_not_predifined_variable = len([True for param_type in decl if param_type not in variables])

   278

   279

    for param_type in decl:

   280

        if param_type in variables.keys():

   281

            param_name = param_type

   282

            param_type = variables[param_type]

   283

        elif len_of_not_predifined_variable > 1:

   284

            param_name = "IN%d"%base

   285

            base += 1

   286

        else:

   287

            param_name = "IN"

   288

        params.append((param_name, param_type, "none"))

   289

    return params

   290

   291

   292

ANY_TO_ANY_LIST=[

   293

        # simple type conv are let as C cast

   294

        (("ANY_INT","ANY_BIT"),("ANY_NUM","ANY_BIT"), ("return_type", "__move_", "IN_type")),

   295

        (("ANY_REAL",),("ANY_REAL",), ("return_type", "__move_", "IN_type")),

   296

        # REAL_TO_INT

   297

        (("ANY_REAL",),("ANY_SINT",), ("return_type", "__real_to_sint", None)),

   298

        (("ANY_REAL",),("ANY_UINT",), ("return_type", "__real_to_uint", None)),

   299

        (("ANY_REAL",),("ANY_BIT",), ("return_type", "__real_to_bit", None)),

   300

        # TO_TIME

   301

        (("ANY_INT","ANY_BIT"),("ANY_DATE","TIME"), ("return_type", "__int_to_time", None)),

   302

        (("ANY_REAL",),("ANY_DATE","TIME"), ("return_type", "__real_to_time", None)),

   303

        (("ANY_STRING",), ("ANY_DATE","TIME"), ("return_type", "__string_to_time", None)),

   304

        # FROM_TIME

   305

        (("ANY_DATE","TIME"), ("ANY_REAL",), ("return_type", "__time_to_real", None)),

   306

        (("ANY_DATE","TIME"), ("ANY_INT","ANY_NBIT"), ("return_type", "__time_to_int", None)),

   307

        (("TIME",), ("ANY_STRING",), ("return_type", "__time_to_string", None)),

   308

        (("DATE",), ("ANY_STRING",), ("return_type", "__date_to_string", None)),

   309

        (("TOD",), ("ANY_STRING",), ("return_type", "__tod_to_string", None)),

   310

        (("DT",), ("ANY_STRING",), ("return_type", "__dt_to_string", None)),

   311

        # TO_STRING

   312

        (("BOOL",), ("ANY_STRING",), ("return_type", "__bool_to_string", None)),

   313

        (("ANY_BIT",), ("ANY_STRING",), ("return_type", "__bit_to_string", None)),

   314

        (("ANY_REAL",), ("ANY_STRING",), ("return_type", "__real_to_string", None)),

   315

        (("ANY_SINT",), ("ANY_STRING",), ("return_type", "__sint_to_string", None)),

   316

        (("ANY_UINT",), ("ANY_STRING",), ("return_type", "__uint_to_string", None)),

   317

        # FROM_STRING

   318

        (("ANY_STRING",), ("BOOL",), ("return_type", "__string_to_bool", None)),

   319

        (("ANY_STRING",), ("ANY_BIT",), ("return_type", "__string_to_bit", None)),

   320

        (("ANY_STRING",), ("ANY_SINT",), ("return_type", "__string_to_sint", None)),

   321

        (("ANY_STRING",), ("ANY_UINT",), ("return_type", "__string_to_uint", None)),

   322

        (("ANY_STRING",), ("ANY_REAL",), ("return_type", "__string_to_real", None))]

   323

   324

   325

BCD_TO_ANY_LIST=[

   326

        (("BYTE",),("USINT",), ("return_type", "__bcd_to_uint", None)),

   327

        (("WORD",),("UINT",), ("return_type", "__bcd_to_uint", None)),

   328

        (("DWORD",),("UDINT",), ("return_type", "__bcd_to_uint", None)),

   329

        (("LWORD",),("ULINT",), ("return_type", "__bcd_to_uint", None))]

   330

   331

   332

ANY_TO_BCD_LIST=[

   333

        (("USINT",),("BYTE",), ("return_type", "__uint_to_bcd", None)),

   334

        (("UINT",),("WORD",), ("return_type", "__uint_to_bcd", None)),

   335

        (("UDINT",),("DWORD",), ("return_type", "__uint_to_bcd", None)),

   336

        (("ULINT",),("LWORD",), ("return_type", "__uint_to_bcd", None))]

   337

   338

   339

def ANY_TO_ANY_FORMAT_GEN(any_to_any_list, fdecl):

   340

   341

    for (InTypes, OutTypes, Format) in any_to_any_list:

   342

        outs = reduce(lambda a,b: a or b, map(lambda testtype : IsOfType(fdecl["outputs"][0][1],testtype), OutTypes))

   343

        inps = reduce(lambda a,b: a or b, map(lambda testtype : IsOfType(fdecl["inputs"][0][1],testtype), InTypes))

   344

        if inps and outs and fdecl["outputs"][0][1] != fdecl["inputs"][0][1]:

   345

             return Format

   346

   347

    return None

   348

   349

   350

"""

   351

Returns this kind of declaration for all standard functions

   352

   353

            [{"name" : "Numerical", 'list': [   {   

   354

                'baseinputnumber': 1,

   355

                'comment': 'Addition',

   356

                'extensible': True,

   357

                'inputs': [   ('IN1', 'ANY_NUM', 'none'),

   358

                              ('IN2', 'ANY_NUM', 'none')],

   359

                'name': 'ADD',

   360

                'outputs': [('OUT', 'ANY_NUM', 'none')],

   361

                'type': 'function'}, ...... ] },.....]

   362

"""

   363

def get_standard_funtions(table):

   364

   365

    variables = get_standard_funtions_input_variables(table)

   366

   367

    fonctions = find_section("Standard_functions_type",table)

   368

   369

    Standard_Functions_Decl = []

   370

    Current_section = None

   371

   372

    translate = {

   373

            "extensible" : lambda x: {"yes":True, "no":False}[x],

   374

            "inputs" : lambda x:csv_input_translate(x,variables,baseinputnumber),

   375

            "outputs":lambda x:[("OUT",x,"none")]}

   376

   377

    for fields in table:

   378

        if fields[1]:

   379

            # If function section name given

   380

            if fields[0]:

   381

                words = fields[0].split('"')

   382

                if len(words) > 1:

   383

                    section_name = words[1]

   384

                else:

   385

                    section_name = fields[0]

   386

                Current_section = {"name" : section_name, "list" : []}

   387

                Standard_Functions_Decl.append(Current_section)

   388

                Function_decl_list = []

   389

            if Current_section:

   390

                Function_decl = dict([(champ, val) for champ, val in zip(fonctions, fields[1:]) if champ])

   391

                baseinputnumber = int(Function_decl.get("baseinputnumber",1))

   392

                Function_decl["baseinputnumber"] = baseinputnumber

   393

                for param, value in Function_decl.iteritems():

   394

                    if param in translate:

   395

                        Function_decl[param] = translate[param](value)

   396

                Function_decl["type"] = "function"

   397

   398

                if Function_decl["name"].startswith('*') or Function_decl["name"].endswith('*') :

   399

                    input_ovrloading_types = GetSubTypes(Function_decl["inputs"][0][1])

   400

                    output_types = GetSubTypes(Function_decl["outputs"][0][1])

   401

                else:

   402

                    input_ovrloading_types = [None]

   403

                    output_types = [None]

   404

   405

                funcdeclname_orig = Function_decl["name"]

   406

                funcdeclname = Function_decl["name"].strip('*_')

   407

                fdc = Function_decl["inputs"][:]

   408

                for intype in input_ovrloading_types:

   409

                    if intype != None:

   410

                        Function_decl["inputs"] = []

   411

                        for decl_tpl in fdc:

   412

                            if IsOfType(intype, decl_tpl[1]):

   413

                                Function_decl["inputs"] += [(decl_tpl[0], intype, decl_tpl[2])]

   414

                            else:

   415

                                Function_decl["inputs"] += [(decl_tpl)]

   416

   417

                            if funcdeclname_orig.startswith('*'):

   418

                                funcdeclin = intype + '_' + funcdeclname 

   419

                            else:

   420

                                funcdeclin = funcdeclname

   421

                    else:

   422

                        funcdeclin = funcdeclname

   423

   424

                    for outype in output_types:

   425

                        if outype != None:

   426

                            decl_tpl = Function_decl["outputs"][0]

   427

                            Function_decl["outputs"] = [ (decl_tpl[0] , outype,  decl_tpl[2])]

   428

                            if funcdeclname_orig.endswith('*'):

   429

                                funcdeclout =  funcdeclin + '_' + outype

   430

                            else:

   431

                                funcdeclout =  funcdeclin

   432

                        else:

   433

                            funcdeclout =  funcdeclin

   434

                        Function_decl["name"] = funcdeclout

   435

   436

   437

                        fdecl = Function_decl

   438

                        res = eval(Function_decl["python_eval_c_code_format"])

   439

   440

                        if res != None :

   441

                            # create the copy of decl dict to be appended to section

   442

                            Function_decl_copy = Function_decl.copy()

   443

                            Current_section["list"].append(Function_decl_copy)

   444

            else:

   445

                raise "First function must be in a category"

   446

   447

    return Standard_Functions_Decl

   448

   449

std_decl = get_standard_funtions(csv_file_to_table(open(os.path.join(os.path.split(__file__)[0],"iec_std.csv"))))#, True)

   450

   451

StdBlckLst.extend(std_decl)

   452

   453

# Dictionary to speedup block type fetching by name

   454

StdBlckDct = {}

   455

   456

for section in StdBlckLst:

   457

    for desc in section["list"]:

   458

        words = desc["comment"].split('"')

   459

        if len(words) > 1:

   460

            desc["comment"] = words[1]

   461

        desc["usage"] = (

   462

            "\n (" +

   463

            str([ " " + fctdecl[1]+":"+fctdecl[0] for fctdecl in desc["inputs"]]).strip("[]").replace("'",'') +

   464

            " ) => (" +

   465

            str([ " " + fctdecl[1]+":"+fctdecl[0] for fctdecl in desc["outputs"]]).strip("[]").replace("'",'') +

   466

            " )")

   467

        BlkLst = StdBlckDct.setdefault(desc["name"],[])

   468

        BlkLst.append((section["name"], desc))

   469

   470

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

   471

#                            Languages Keywords

   472

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

   473

   474

   475

# Keywords for Pou Declaration

   476

POU_BLOCK_START_KEYWORDS = ["FUNCTION", "FUNCTION_BLOCK", "PROGRAM"]

   477

POU_BLOCK_END_KEYWORDS = ["END_FUNCTION", "END_FUNCTION_BLOCK", "END_PROGRAM"]

   478

POU_KEYWORDS = ["EN", "ENO", "F_EDGE", "R_EDGE"] + POU_BLOCK_START_KEYWORDS + POU_BLOCK_END_KEYWORDS

   479

for category in StdBlckLst:

   480

    for block in category["list"]:

   481

        if block["name"] not in POU_KEYWORDS:

   482

            POU_KEYWORDS.append(block["name"])

   483

   484

   485

# Keywords for Type Declaration

   486

TYPE_BLOCK_START_KEYWORDS = ["TYPE", "STRUCT"]

   487

TYPE_BLOCK_END_KEYWORDS = ["END_TYPE", "END_STRUCT"]

   488

TYPE_KEYWORDS = ["ARRAY", "OF", "T", "D", "TIME_OF_DAY", "DATE_AND_TIME"] + TYPE_BLOCK_START_KEYWORDS + TYPE_BLOCK_END_KEYWORDS

   489

TYPE_KEYWORDS.extend([keyword for keyword in TypeHierarchy.keys() if keyword not in TYPE_KEYWORDS])

   490

   491

   492

# Keywords for Variable Declaration

   493

VAR_BLOCK_START_KEYWORDS = ["VAR", "VAR_INPUT", "VAR_OUTPUT", "VAR_IN_OUT", "VAR_TEMP", "VAR_EXTERNAL"]

   494

VAR_BLOCK_END_KEYWORDS = ["END_VAR"]

   495

VAR_KEYWORDS = ["AT", "CONSTANT", "RETAIN", "NON_RETAIN"] + VAR_BLOCK_START_KEYWORDS + VAR_BLOCK_END_KEYWORDS

   496

   497

   498

# Keywords for Configuration Declaration

   499

CONFIG_BLOCK_START_KEYWORDS = ["CONFIGURATION", "RESOURCE", "VAR_ACCESS", "VAR_CONFIG", "VAR_GLOBAL"]

   500

CONFIG_BLOCK_END_KEYWORDS = ["END_CONFIGURATION", "END_RESOURCE", "END_VAR"]

   501

CONFIG_KEYWORDS = ["ON", "PROGRAM", "WITH", "READ_ONLY", "READ_WRITE", "TASK"] + CONFIG_BLOCK_START_KEYWORDS + CONFIG_BLOCK_END_KEYWORDS

   502

   503

# Keywords for Structured Function Chart

   504

SFC_BLOCK_START_KEYWORDS = ["ACTION", "INITIAL_STEP", "STEP", "TRANSITION"]

   505

SFC_BLOCK_END_KEYWORDS = ["END_ACTION", "END_STEP", "END_TRANSITION"]

   506

SFC_KEYWORDS = ["FROM", "TO"] + SFC_BLOCK_START_KEYWORDS + SFC_BLOCK_END_KEYWORDS

   507

   508

   509

# Keywords for Instruction List

   510

IL_KEYWORDS = ["TRUE", "FALSE", "LD", "LDN", "ST", "STN", "S", "R", "AND", "ANDN", "OR", "ORN",

   511

 "XOR", "XORN", "NOT", "ADD", "SUB", "MUL", "DIV", "MOD", "GT", "GE", "EQ", "NE",

   512

 "LE", "LT", "JMP", "JMPC", "JMPCN", "CAL", "CALC", "CALCN", "RET", "RETC", "RETCN"]

   513

   514

   515

# Keywords for Structured Text

   516

ST_BLOCK_START_KEYWORDS = ["IF", "ELSIF", "ELSE", "CASE", "FOR", "WHILE", "REPEAT"]

   517

ST_BLOCK_END_KEYWORDS = ["END_IF", "END_CASE", "END_FOR", "END_WHILE", "END_REPEAT"]

   518

ST_KEYWORDS = ["TRUE", "FALSE", "THEN", "OF", "TO", "BY", "DO", "DO", "UNTIL", "EXIT", 

   519

 "RETURN", "NOT", "MOD", "AND", "XOR", "OR"] + ST_BLOCK_START_KEYWORDS + ST_BLOCK_END_KEYWORDS

   520

   521

# All the keywords of IEC

   522

IEC_BLOCK_START_KEYWORDS = []

   523

IEC_BLOCK_END_KEYWORDS = []

   524

IEC_KEYWORDS = ["E", "TRUE", "FALSE"]