17

# Get definitions

    18

from plcopen.structures import *

    19

    20

#import pprint

    21

#pp = pprint.PrettyPrinter(indent=4)

    22

    23

def ANY_to_compiler_test_type_GEN(typename, paramname):

    24

    """

    25

    Convert ANY_XXX IEC type declaration into IEC2CC's generated type test.

    26

    This tests are defined in search_expression_type.cc 

    27

    """

    28

    return {"ANY" : "",

    29

    "ANY_BIT" : "if(search_expression_type->is_binary_type(%(paramname)s_type_symbol))",

    30

    "ANY_NBIT" : "if(search_expression_type->is_nbinary_type(%(paramname)s_type_symbol))",

    31

    "ANY_NUM" : "if(search_expression_type->is_num_type(%(paramname)s_type_symbol))",

    32

    "ANY_REAL" : "if(search_expression_type->is_real_type(%(paramname)s_type_symbol))",

    33

    "ANY_INT" : "if(search_expression_type->is_integer_type(%(paramname)s_type_symbol))"

    34

    }.get(typename,

    35

        "if (typeid(*last_type_symbol) == typeid(%(typename)s_type_name_c))")%{

    36

                "paramname" : paramname, "typename": typename.lower()}

    37

    38

def recurse_and_indent(fdecls, indent, do_type_search_only = False, do_il = False):

    39

    """

    40

    This function generate visit(function_invocation) code for 

    41

        - ST code generator

    42

        - IL code generator

    43

        - search_expression_type class for ST

    44

        - search_expression_type class for IL

    45

    46

    Input data is a 

    47

    "{fname : {IN[0]paramname : {IN[0]paramtype : {IN[1]paraname : {IN[1]paramtype : {... : {IN[N]paraname : {IN[N]paramtype : (fdecl,)}}}}}}"

    48

    nested dictionary structure.

    49

    """

    50

    if type(fdecls) != type(tuple()):

    51

        res = ""

    52

        for Paramname, ParamTypes in fdecls.iteritems():

    53

            if do_il:

    54

                res += """

    55

{"""

    56

                if not do_type_search_only:

    57

                    res += """

    58

    /* Get the value from a foo(<param_name> = <param_value>) style call */

    59

    symbol_c *%(input_name)s_param_value = &this->default_variable_name;

    60

"""%{"input_name":Paramname}

    61

                res += """

    62

    symbol_c *%(input_name)s_type_symbol = param_data_type;

    63

    last_type_symbol = param_data_type;

    64

"""%{"input_name":Paramname}

    65

            else:

    66

                res += """

    67

{

    68

    identifier_c param_name("%(input_name)s");

    69

    /* Get the value from a foo(<param_name> = <param_value>) style call */

    70

    symbol_c *%(input_name)s_param_value = function_call_param_iterator.search(&param_name);

    71

    72

    /* Get the value from a foo(<param_value>) style call */

    73

    if (%(input_name)s_param_value == NULL)

    74

      %(input_name)s_param_value = function_call_param_iterator.next();

    75

    symbol_c *%(input_name)s_type_symbol = search_expression_type->get_type(%(input_name)s_param_value);

    76

    last_type_symbol = last_type_symbol && search_expression_type->is_same_type(%(input_name)s_type_symbol, last_type_symbol) ? search_expression_type->common_type(%(input_name)s_type_symbol, last_type_symbol) : %(input_name)s_type_symbol ;

    77

"""%{"input_name":Paramname}

    78

    79

            for ParamType,NextParamDecl in ParamTypes.iteritems():

    80

    81

                res += """    

    82

    %(type_test)s

    83

    {

    84

%(if_good_type_code)s

    85

    }

    86

"""%{

    87

    "type_test":ANY_to_compiler_test_type_GEN(ParamType,Paramname), 

    88

    "if_good_type_code":recurse_and_indent(NextParamDecl,indent,do_type_search_only).replace('\n','\n    ')}

    89

    90

            res += """    

    91

    ERROR;

    92

}

    93

"""

    94

    95

        return res.replace('\n','\n'+indent)

    96

    else:

    97

        res = "\n"

    98

        fdecl=fdecls[0]

    99

   100

        result_type_rule = fdecl["return_type_rule"]

   101

        res += {

   102

            "copy_input" : "symbol_c * return_type_symbol = last_type_symbol;\n",

   103

            "defined" : "symbol_c * return_type_symbol = &search_constant_type_c::%s_type_name;\n"%fdecl["outputs"][0][1].lower(),

   104

            }.get(result_type_rule, "symbol_c * return_type_symbol = %s;\n"%result_type_rule)

   105

   106

        if not do_type_search_only:

   107

            code_gen = eval(fdecl["python_eval_c_code_format"])

   108

   109

            code_gen_dic_decl = {}

   110

            for paramname,paramtype,unused in fdecl["inputs"]:

   111

                code_gen_dic_decl[paramname+"_value"] = '");\n%s_param_value->accept(*this);\ns4o.print("'%(paramname)

   112

                code_gen_dic_decl[paramname+"_type"] = '");\n%s_type_symbol->accept(*this);\ns4o.print("'%(paramname)

   113

            code_gen_dic_decl["return_type"] = '");\nreturn_type_symbol->accept(*this);\ns4o.print("'

   114

            code_gen_dic_decl["param_count"] = '");\ns4o.print_integer(nb_param);\ns4o.print("'

   115

            code_gen_dic_decl["start_bool_filter"] = '");\nif (search_expression_type->is_bool_type(last_type_symbol))\n  s4o.print("('

   116

            code_gen_dic_decl["end_bool_filter"] = '");\nif (search_expression_type->is_bool_type(last_type_symbol)) {\n  s4o.print("&1");\n  s4o.print(")");\n}\ns4o.print("'

   117

   118

            if type(code_gen) == type(tuple()):

   119

                res += 's4o.print("%s");\n'%(code_gen[0]%code_gen_dic_decl)

   120

                static_param_accept_list = []

   121

                for paramname,paramtype,unused in fdecl["inputs"]:

   122

                    static_param_accept_list.append("%s_param_value->accept(*this);\n"%(paramname))

   123

                res += ('s4o.print("%s");\n'%(code_gen[1])).join(static_param_accept_list)

   124

                code = 's4o.print("%s");\nparam_value->accept(*this);\n'%(code_gen[1])

   125

                end_code = 's4o.print("%s");\nreturn NULL;\n'%(code_gen[2]%code_gen_dic_decl)

   126

            else:

   127

                code = ''

   128

                end_code = ('s4o.print("' + code_gen%code_gen_dic_decl + '");\nreturn NULL;\n').replace('s4o.print("");\n','')

   129

   130

            if fdecl["extensible"]:

   131

                res += ("""

   132

int base_num = %d;

   133

symbol_c *param_value = NULL;

   134

do{

   135

    char my_name[10];

   136

    sprintf(my_name, "IN%%d", base_num++);

   137

    identifier_c param_name(my_name);

   138

   139

    /* Get the value from a foo(<param_name> = <param_value>) style call */

   140

    param_value = function_call_param_iterator.search(&param_name);

   141

   142

    /* Get the value from a foo(<param_value>) style call */

   143

    if (param_value == NULL)

   144

      param_value = function_call_param_iterator.next();

   145

    if (param_value != NULL){

   146

        symbol_c *current_type_symbol = search_expression_type->get_type(param_value);

   147

        last_type_symbol = last_type_symbol && search_expression_type->is_same_type(current_type_symbol, last_type_symbol) ? search_expression_type->common_type(current_type_symbol, last_type_symbol) : current_type_symbol ;

   148

   149

        /*Function specific CODE */

   150

        %s

   151

    }

   152

   153

}while(param_value != NULL);

   154

%s

   155

"""%(fdecl["baseinputnumber"]+2, code.replace('\n','\n        '), end_code))

   156

            else:

   157

                #res += code + end_code

   158

                res += end_code

   159

        else:

   160

            res += "return return_type_symbol;\n"

   161

   162

   163

        return res.replace('\n','\n'+indent)

   164

   165

###################################################################

   166

###                                                             ###

   167

###                           MAIN                              ###

   168

###                                                             ###

   169

###################################################################

   170

   171

"""

   172

Reorganize std_decl from structure.py

   173

into a nested dictionnary structure (i.e. a tree):

   174

"{fname : {IN[0]paramname : {IN[0]paramtype : {IN[1]paraname : {IN[1]paramtype : {... : {IN[N]paraname : {IN[N]paramtype : (fdecl,)}}}}}}"

   175

Keep ptrack of original declaration order in a 

   176

separated list called official_order

   177

"""

   178

std_fdecls = {}

   179

official_order = []

   180

for section in std_decl:

   181

    for fdecl in section["list"]:

   182

        if len(official_order)==0 or official_order[-1] != fdecl["name"]:

   183

            official_order.append(fdecl["name"])

   184

        # store all func by name in a dict

   185

        std_fdecls_fdecl_name = std_fdecls.get(fdecl["name"], {})

   186

        current = std_fdecls_fdecl_name

   187

        for i in fdecl["inputs"]:

   188

            current[i[0]] = current.get(i[0], {})

   189

            current = current[i[0]]

   190

            last = current

   191

            current[i[1]] = current.get(i[1], {})

   192

            current = current[i[1]]

   193

        last[i[1]]=(fdecl,)

   194

        std_fdecls[fdecl["name"]] = std_fdecls_fdecl_name

   195

   196

###################################################################

   197

   198

"""

   199

Generate the long enumeration of std function types

   200

"""

   201

function_type_decl =  """

   202

/****

   203

 * IEC 61131-3 standard function lib

   204

 * generated code, do not edit by hand

   205

 */

   206

typedef enum {

   207

"""

   208

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   209

    function_type_decl += "    function_"+fname.lower()+",\n"

   210

   211

function_type_decl += """    function_none

   212

} function_type_t;

   213

"""

   214

###################################################################

   215

"""

   216

Generate the funct that return enumerated according function name

   217

"""

   218

get_function_type_decl = """

   219

/****

   220

 * IEC 61131-3 standard function lib

   221

 * generated code, do not edit by hand

   222

 */

   223

function_type_t get_function_type(identifier_c *function_name) {

   224

"""

   225

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   226

    get_function_type_decl += """

   227

if (!strcasecmp(function_name->value, "%s"))

   228

    return function_%s;

   229

"""%(fname,fname.lower())

   230

   231

get_function_type_decl += """

   232

    else return function_none;

   233

}

   234

   235

"""

   236

###################################################################

   237

"""

   238

Generate the part of generate_cc_st_c::visit(function_invocation)

   239

that is responsible to generate C code for std lib calls.

   240

"""

   241

st_code_gen = """

   242

/****

   243

 * IEC 61131-3 standard function lib

   244

 * generated code, do not edit by hand

   245

 */

   246

switch(current_function_type){

   247

"""

   248

   249

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   250

    st_code_gen += """

   251

/****

   252

 *%s

   253

 */

   254

    case function_%s :

   255

    {

   256

        symbol_c *last_type_symbol = NULL;

   257

"""    %(fname, fname.lower())

   258

    indent =  "    "

   259

   260

    st_code_gen += recurse_and_indent(fdecls, indent).replace('\n','\n    ')

   261

   262

    st_code_gen += """

   263

    }/*function_%s*/

   264

    break;

   265

"""    %(fname.lower())

   266

st_code_gen +=  """

   267

    case function_none :

   268

    ERROR;

   269

}

   270

return NULL;

   271

"""

   272

   273

###################################################################

   274

"""

   275

Generate the part of generate_cc_il_c::visit(il_function_call)

   276

that is responsible to generate C code for std lib calls.

   277

"""

   278

il_code_gen = """

   279

/****

   280

 * IEC 61131-3 standard function lib

   281

 * generated code, do not edit by hand

   282

 */

   283

switch(current_function_type){

   284

"""

   285

   286

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   287

    il_code_gen += """

   288

/****

   289

 *%s

   290

 */

   291

    case function_%s :

   292

    {

   293

        symbol_c *last_type_symbol = NULL;

   294

"""    %(fname, fname.lower())

   295

    indent =  "    "

   296

   297

    il_code_gen += recurse_and_indent(fdecls, indent, do_il=True).replace('\n','\n    ')

   298

   299

    il_code_gen += """

   300

    }/*function_%s*/

   301

    break;

   302

"""    %(fname.lower())

   303

il_code_gen +=  """

   304

    case function_none :

   305

    ERROR;

   306

}

   307

return NULL;

   308

"""

   309

   310

###################################################################

   311

"""

   312

Generate the part of search_expression_type_c::visit(function_invocation)

   313

that is responsible of returning type symbol for function invocation.

   314

"""

   315

search_type_code =  """

   316

/****

   317

 * IEC 61131-3 standard function lib

   318

 * generated code, do not edit by hand

   319

 */

   320

   321

void *compute_standard_function_st(function_invocation_c *symbol) {

   322

   323

  function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);

   324

  function_call_param_iterator_c function_call_param_iterator(symbol);

   325

  search_expression_type_c* search_expression_type = this;

   326

   327

  switch(current_function_type){

   328

"""

   329

   330

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   331

    search_type_code += """

   332

/****

   333

 *%s

   334

 */

   335

    case function_%s :

   336

    {

   337

        symbol_c *last_type_symbol = NULL;

   338

"""    %(fname, fname.lower())

   339

    indent =  "    "

   340

   341

    search_type_code += recurse_and_indent(fdecls, indent, True).replace('\n','\n    ')

   342

   343

    search_type_code += """

   344

    }/*function_%s*/

   345

    break;

   346

"""    %(fname.lower())

   347

search_type_code += """

   348

    case function_none :

   349

    ERROR;

   350

  }

   351

  return NULL;

   352

}

   353

   354

void *compute_standard_function_il(il_function_call_c *symbol, symbol_c *param_data_type) {

   355

   356

  function_type_t current_function_type = get_function_type((identifier_c *)symbol->function_name);

   357

  function_call_param_iterator_c function_call_param_iterator(symbol);  

   358

  search_expression_type_c* search_expression_type = this;

   359

   360

  switch(current_function_type){

   361

"""

   362

   363

for fname, fdecls in [ (fname,std_fdecls[fname]) for fname in official_order ]:

   364

    search_type_code += """

   365

/****

   366

 *%s

   367

 */

   368

    case function_%s :

   369

    {

   370

        symbol_c *last_type_symbol = NULL;

   371

"""    %(fname, fname.lower())

   372

    indent =  "    "

   373

   374

    search_type_code += recurse_and_indent(fdecls, indent, True, True).replace('\n','\n    ')

   375

   376

    search_type_code += """

   377

    }/*function_%s*/

   378

    break;

   379

"""    %(fname.lower())

   380

search_type_code += """

   381

    case function_none :

   382

    ERROR;

   383

  }

   384

  return NULL;

   385

}

   386

"""

   387

   388

###################################################################

   389

###################################################################

   390

###################################################################

   391

"""

   415

Generate the C implementation of the IEC standard function library.

   416

"""

   417

iec_std_lib_generated =  """

   418

/****

   419

 * IEC 61131-3 standard function lib

   420

 * generated code, do not edit by hand

   421

 */

   422

   423

/* Macro that expand to subtypes */

   424

"""

   425

for typename, parenttypename in TypeHierarchy_list:

   426

    if (typename.startswith("ANY")):

   427

        iec_std_lib_generated += "#define " + typename + "(DO)"

   428

        for typename2, parenttypename2 in TypeHierarchy_list:

   429

            if(parenttypename2 == typename):

   430

                if(typename2.startswith("ANY")):

   431

                    iec_std_lib_generated +=  " " + typename2 + "(DO)"

   432

                else:

   433

                    iec_std_lib_generated +=  " DO(" + typename2 + ")"

   434

        iec_std_lib_generated +=  "\n"

   435

    else:

   436

        break

   437

   438

if len(sys.argv) != 2 :

   439

    print "Usage: " + sys.argv[0] + "path_name\n -> create files in path_name"

   440

    sys.exit(0)

   441

   442

# Now, print that out, or write to files from sys.argv

   451

        ]:

   453

    fd.write(eval(name))

   454

    fd.close()