25

"""

    26

    27

 THIS CODE GENARATES C++ CODE FOR IEC2CC COMPILER

    28

 GENERATED CODE IS :

    29

    30

function_type_decl.h - the long enumeration of std function types

    31

get_function_type_decl.c - the funct that return enumerated according function name

    32

st_code_gen.c - part of generate_cc_st_c::visit(function_invocation)

    33

                responsible to generate C code for std lib calls

    34

il_code_gen.c - part of generate_cc_il_c::visit(il_function_call)

    35

                responsible to generate C code for std lib calls

    36

search_type_code.c - called by search_expression_type_c::visit(function_invocation) 

    37

                     return type symbol for std function invocation

    38

    39

"""

    40

    41

# Get definitions

    42

from plcopen.structures import *

    43

    44

#import pprint

    45

#pp = pprint.PrettyPrinter(indent=4)

    46

    73

def ANY_to_compiler_test_type_GEN(typename, paramname):

    74

    """

    75

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

    76

    This tests are defined in search_expression_type.cc 

    77

    """

    78

    return {"ANY" : "",

    79

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

    80

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

    81

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

    82

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

    83

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

    84

    }.get(typename,

    85

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

    86

        "if(search_expression_type->is_same_type(&search_constant_type_c::%(typename)s_type_name, last_type_symbol))")%{

    87

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

    88

    89

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

    90

    """

    91

    This function generate visit(function_invocation) code for 

    92

        - ST code generator

    93

        - IL code generator

    94

        - search_expression_type class for ST

    95

        - search_expression_type class for IL

    96

    97

    Input data is a 

    98

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

    99

    nested dictionary structure.

   100

    """

   101

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

   102

        res = ""

   103

        for Paramname, ParamTypes in fdecls.iteritems():

   104

            if do_il:

   105

                res += """

   106

{"""

   107

                if not do_type_search_only:

   108

                    res += """

   109

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

   110

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

   111

"""%{"input_name":Paramname}

   112

                res += """

   113

    symbol_c *%(input_name)s_type_symbol = param_data_type;

   114

    last_type_symbol = param_data_type;

   115

"""%{"input_name":Paramname}

   116

            else:

   117

                res += """

   118

{

   119

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

   120

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

   121

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

   122

   123

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

   124

    if (%(input_name)s_param_value == NULL)

   125

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

   126

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

   127

    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 ;

   128

"""%{"input_name":Paramname}

   129

   130

            for ParamType,NextParamDecl in ParamTypes.iteritems():

   131

   132

                res += """    

   133

    %(type_test)s

   134

    {

   135

%(if_good_type_code)s

   136

    }

   137

"""%{

   138

    "type_test":ANY_to_compiler_test_type_GEN(ParamType,Paramname), 

   139

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

   140

   141

            res += """    

   142

    ERROR;

   143

}

   144

"""

   145

   146

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

   147

    else:

   148

        res = "\n"

   149

        fdecl=fdecls[0]

   150

   151

        result_type_rule = fdecl["return_type_rule"]

   152

        res += {

   153

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

   154

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

   155

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

   156

   157

        if not do_type_search_only:

   158

            code_gen = eval(fdecl["python_eval_c_code_format"])

   159

   160

            code_gen_dic_decl = {}

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

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

   168

            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("'

   169

   170

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

   171

                res += 's4o.indent_right();\n'

   172

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

   173

                static_param_accept_list = []

   174

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

   175

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

   176

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

   177

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

   178

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

   179

            else:

   180

                code = ''

   181

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

   182

   183

            if fdecl["extensible"]:

   184

                res += ("""

   185

int base_num = %d;

   186

symbol_c *param_value = NULL;

   187

do{

   188

    char my_name[10];

   189

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

   190

    identifier_c param_name(my_name);

   191

   192

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

   193

    param_value = function_call_param_iterator.search(&param_name);

   194

   195

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

   196

    if (param_value == NULL)

   197

      param_value = function_call_param_iterator.next();

   198

    if (param_value != NULL){

   199

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

   200

        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 ;

   201

   202

        /*Function specific CODE */

   203

        %s

   204

    }

   205

   206

}while(param_value != NULL);

   207

%s

   208

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

   209

            else:

   210

                #res += code + end_code

   211

                res += end_code

   212

        else:

   213

            res += "return return_type_symbol;\n"

   214

   215

   216

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

   217

   218

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

   219

###                                                             ###

   220

###                           MAIN                              ###

   221

###                                                             ###

   222

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

   223

   224

"""

   225

Reorganize std_decl from structure.py

   226

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

   227

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

   228

Keep ptrack of original declaration order in a 

   229

separated list called official_order

   230

"""

   231

std_fdecls = {}

   232

official_order = []

   233

for section in std_decl:

   234

    for fdecl in section["list"]:

   235

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

   236

            official_order.append(fdecl["name"])

   237

        # store all func by name in a dict

   238

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

   239

        current = std_fdecls_fdecl_name

   240

        for i in fdecl["inputs"]:

   241

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

   242

            current = current[i[0]]

   243

            last = current

   244

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

   245

            current = current[i[1]]

   246

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

   247

        std_fdecls[fdecl["name"]] = std_fdecls_fdecl_name

   248

   249

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

   250

   251

"""

   252

Generate the long enumeration of std function types

   253

"""

   255

/****

   256

 * IEC 61131-3 standard function lib

   257

 * generated code, do not edit by hand

   258

 */

   259

typedef enum {

   260

"""

   261

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

   262

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

   263

   264

function_type_decl += """    function_none

   265

} function_type_t;

   266

"""

   267

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

   268

"""

   269

Generate the funct that return enumerated according function name

   270

"""

   272

/****

   273

 * IEC 61131-3 standard function lib

   274

 * generated code, do not edit by hand

   275

 */

   276

function_type_t get_function_type(identifier_c *function_name) {

   277

"""

   278

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

   279

    get_function_type_decl += """

   280

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

   281

    return function_%s;

   282

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

   283

   284

get_function_type_decl += """

   285

    else return function_none;

   286

}

   287

   288

"""

   289

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

   290

"""

   291

Generate the part of generate_cc_st_c::visit(function_invocation)

   292

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

   293

"""

   295

/****

   296

 * IEC 61131-3 standard function lib

   297

 * generated code, do not edit by hand

   298

 */

   299

switch(current_function_type){

   300

"""

   301

   302

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

   303

    st_code_gen += """

   304

/****

   305

 *%s

   306

 */

   307

    case function_%s :

   308

    {

   309

        symbol_c *last_type_symbol = NULL;

   310

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

   311

    indent =  "    "

   312

   313

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

   314

   315

    st_code_gen += """

   316

    }/*function_%s*/

   317

    break;

   318

"""    %(fname.lower())

   319

st_code_gen +=  """

   320

    case function_none :

   321

    ERROR;

   322

}

   323

return NULL;

   324

"""

   325

   326

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

   327

"""

   328

Generate the part of generate_cc_il_c::visit(il_function_call)

   329

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

   330

"""

   332

/****

   333

 * IEC 61131-3 standard function lib

   334

 * generated code, do not edit by hand

   335

 */

   336

switch(current_function_type){

   337

"""

   338

   339

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

   340

    il_code_gen += """

   341

/****

   342

 *%s

   343

 */

   344

    case function_%s :

   345

    {

   346

        symbol_c *last_type_symbol = NULL;

   347

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

   348

    indent =  "    "

   349

   350

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

   351

   352

    il_code_gen += """

   353

    }/*function_%s*/

   354

    break;

   355

"""    %(fname.lower())

   356

il_code_gen +=  """

   357

    case function_none :

   358

    ERROR;

   359

}

   360

return NULL;

   361

"""

   362

   363

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

   364

"""

   365

Generate the part of search_expression_type_c::visit(function_invocation)

   366

that is responsible of returning type symbol for function invocation.

   367

"""

   369

/****

   370

 * IEC 61131-3 standard function lib

   371

 * generated code, do not edit by hand

   372

 */

   373

   374

void *compute_standard_function_st(function_invocation_c *symbol) {

   375

   376

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

   377

  function_call_param_iterator_c function_call_param_iterator(symbol);

   378

  search_expression_type_c* search_expression_type = this;

   379

   380

  switch(current_function_type){

   381

"""

   382

   383

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

   384

    search_type_code += """

   385

/****

   386

 *%s

   387

 */

   388

    case function_%s :

   389

    {

   390

        symbol_c *last_type_symbol = NULL;

   391

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

   392

    indent =  "    "

   393

   394

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

   395

   396

    search_type_code += """

   397

    }/*function_%s*/

   398

    break;

   399

"""    %(fname.lower())

   400

search_type_code += """

   401

    case function_none :

   402

    ERROR;

   403

  }

   404

  return NULL;

   405

}

   406

   407

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

   408

   409

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

   410

  function_call_param_iterator_c function_call_param_iterator(symbol);  

   411

  search_expression_type_c* search_expression_type = this;

   412

   413

  switch(current_function_type){

   414

"""

   415

   416

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

   417

    search_type_code += """

   418

/****

   419

 *%s

   420

 */

   421

    case function_%s :

   422

    {

   423

        symbol_c *last_type_symbol = NULL;

   424

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

   425

    indent =  "    "

   426

   427

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

   428

   429

    search_type_code += """

   430

    }/*function_%s*/

   431

    break;

   432

"""    %(fname.lower())

   433

search_type_code += """

   434

    case function_none :

   435

    ERROR;

   436

  }

   437

  return NULL;

   438

}

   439

"""

   440

   441

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

   442

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

   443

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

   444

"""

   445

Generate the standard_function_names[] for inclusion in bizon generated code

   446

"""

   447

standard_function_names = """

   448

/****

   449

 * IEC 61131-3 standard function lib

   450

 * generated code, do not edit by hand

   451

 */

   452

   453

const char *standard_function_names[] = {

   454

"""

   455

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

   456

    standard_function_names += "\""+fname+"\",\n"

   457

standard_function_names += """

   458

/* end of array marker! Do not remove! */

   459

NULL

   460

};

   461

   462

"""

   463

   464

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

   465

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

   466

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

   467

"""

   468

Generate the C implementation of the IEC standard function library.

   469

"""

   471

/****

   472

 * IEC 61131-3 standard function lib

   473

 * generated code, do not edit by hand

   474

 */

   475

   476

/* Macro that expand to subtypes */

   477

"""

   478

for typename, parenttypename in TypeHierarchy_list:

   479

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

   480

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

   481

        for typename2, parenttypename2 in TypeHierarchy_list:

   482

            if(parenttypename2 == typename):

   483

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

   484

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

   485

                else:

   486

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

   487

        iec_std_lib_generated +=  "\n"

   488

    else:

   489

        break

   490

   491

if len(sys.argv) != 2 :

   492

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

   493

    sys.exit(0)

   494

   495

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

   496

for path, name, ext in [

   497

        ('stage4/generate_cc','function_type_decl','h'),

   498

        ('stage4/generate_cc','get_function_type_decl','c'),

   499

        ('stage4/generate_cc','st_code_gen','c'),

   500

        ('stage4/generate_cc','il_code_gen','c'),

   501

        ('stage4/generate_cc','search_type_code','c'),

   502

        ('stage1_2','standard_function_names','c'),

   503

        ('lib', 'iec_std_lib_generated','h')

   504

        ]:

   505

    fd = open(os.path.join(sys.argv[1], path, name+'.'+ext),'w')

   506

    fd.write(eval(name))

   507

    fd.close()

   508

   509

#print "/* Code to eventually paste in iec_std_lib.h if type hierarchy changed */"

   510

#print "/* you also have to change iec_std_lib.h according to new types        */\n\n"

   511

#print iec_std_lib_generated