1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *  Copyright (C) 2003-2011  Mario de Sousa (msousa@fe.up.pt)

     4

 *  Copyright (C) 2007-2011  Laurent Bessard and Edouard Tisserant

     5

 *

     6

 *  This program is free software: you can redistribute it and/or modify

     7

 *  it under the terms of the GNU General Public License as published by

     8

 *  the Free Software Foundation, either version 3 of the License, or

     9

 *  (at your option) any later version.

    10

 *

    11

 *  This program is distributed in the hope that it will be useful,

    12

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    13

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    14

 *  GNU General Public License for more details.

    15

 *

    16

 *  You should have received a copy of the GNU General Public License

    17

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    18

 *

    19

 *

    20

 * This code is made available on the understanding that it will not be

    21

 * used in safety-critical situations without a full and competent review.

    22

 */

    23

    24

/*

    25

 * An IEC 61131-3 compiler.

    26

 *

    27

 * Based on the

    28

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    29

 *

    30

 */

    31

    32

    33

/*

    34

 * Definition of the Abstract Syntax data structure components

    35

 */

    36

    37

    38

/*

    39

 * ABSYNTAX.DEF

    40

 *

    41

 * This generates the parse tree structure used to bind the components

    42

 * identified by Bison in the correct syntax order. At the end of the

    43

 * Bison analysis the tree is walked in a sequential fashion generating

    44

 * the relavent code.

    45

 */

    46

    47

    48

    49

    50

    51

    52

/*****************************************************************/

    53

/*****************************************************************/

    54

/*****************************************************************/

    55

/*****************************************************************/

    56

/*                                                               */

    57

/*      safe<xxxxxx> Symbols are defined in:                     */

    58

/*      PLCopen - Technical Committee 5                          */

    59

/*      Safety Software Technical Specification,                 */

    60

/*      Part 1: Concepts and Function Blocks,                    */

    61

/*      Version 1.0 – Official Release - 2006-01-31              */

    62

/*                                                               */

    63

/*****************************************************************/

    64

/*****************************************************************/

    65

/*****************************************************************/

    66

/*****************************************************************/

    67

    68

    69

    70

    71

    72

    73

/*****************************************************************/

    74

/*****************************************************************/

    75

/*****************************************************************/

    76

/*****************************************************************/

    77

/*                                                               */

    78

/*             Symbols defined in:                               */

    79

/*      FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)          */

    80

/*                                                               */

    81

/*****************************************************************/

    82

/*****************************************************************/

    83

/*****************************************************************/

    84

/*****************************************************************/

    85

    86

/* Based on the                                    */

    87

/* FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10) */

    88

    89

    90

/* EN/ENO */

    91

/* NOTE we store 'EN' and 'ENO' tokens in an identifier_c

    92

 *      as they may be used as variables, and it is much easier 

    93

 *      to handle them (fewer special cases) if we do it that way...

    94

 */

    95

/*

    96

SYM_REF0(en_param_c)

    97

SYM_REF0(eno_param_c)

    98

*/

    99

   100

/* A class used to identify an entry (literal, variable, etc...) in the abstract syntax tree with an invalid data type */

   101

/* This is only used from stage3 onwards. Stages 1 and 2 will never create any instances of invalid_type_name_c */

   102

SYM_REF0(invalid_type_name_c)

   103

   104

   105

   106

/********************/

   107

/* 2.1.6 - Pragmas  */

   108

/********************/

   109

SYM_REF0(disable_code_generation_pragma_c)

   110

SYM_REF0(enable_code_generation_pragma_c)

   111

SYM_TOKEN(pragma_c)

   112

   113

   114

/***************************/

   115

/* B 0 - Programming Model */

   116

/***************************/

   117

/* enumvalue_symtable is filled in by enum_declaration_check_c, during stage3 semantic verification, with a list of all enumerated constants declared inside this POU */

   118

SYM_LIST(library_c, enumvalue_symtable_t enumvalue_symtable;)

   119

   120

   121

/*************************/

   122

/* B.1 - Common elements */

   123

/*************************/

   124

/*******************************************/

   125

/* B 1.1 - Letters, digits and identifiers */

   126

/*******************************************/

   127

SYM_TOKEN(identifier_c)

   128

/* A special identifier class, used for identifiers that have been previously declared as a derived datatype */

   129

/*  This is currently needed because generate_c stage 4 needs to handle the array datatype identifiers differently to all other identifiers. */

   130

SYM_TOKEN(derived_datatype_identifier_c) 

   131

SYM_TOKEN(poutype_identifier_c) 

   132

   133

   134

/*********************/

   135

/* B 1.2 - Constants */

   136

/*********************/

   137

/*********************************/

   138

/* B 1.2.XX - Reference Literals */

   139

/*********************************/

   140

/* defined in IEC 61131-3 v3 - Basically the 'NULL' keyword! */

   141

SYM_REF0(ref_value_null_literal_c)

   142

   143

/******************************/

   144

/* B 1.2.1 - Numeric Literals */

   145

/******************************/

   146

SYM_TOKEN(real_c)

   147

SYM_TOKEN(integer_c)

   148

SYM_TOKEN(binary_integer_c)

   149

SYM_TOKEN(octal_integer_c)

   150

SYM_TOKEN(hex_integer_c)

   151

   152

/* Note:

   153

 * We do not have signed_integer_c and signed_real_c classes.

   154

 * These are stored in the parse tree as a integer_c or real_c

   155

 * preceded by a unary minus operator if they are inside an expression,

   156

 * or a neg_integer_c and neg_real_c when used outside an ST expression.

   157

 */

   158

/* Not required:

   159

SYM_TOKEN(signed_integer_c)

   160

SYM_TOKEN(signed_real_c)

   161

*/

   162

   163

/* NOTE: literal __values__ are stored directly in classes such as:

   164

 *          - real_c

   165

 *          - integer_c

   166

 *          - binary_integer_c

   167

 *          - etc...

   168

 *

   169

 *       However, for both the real_c and the integer_c, if they are preceded 

   170

 *       by a '-' negation sign, they are further encapsulated inside 

   171

 *       a neg_literal_c (i.e. the neg_literal_c will point to the 

   172

 *       real_c or integer_c with the value being negated.

   173

 *          neg_literal_c -> integer_literal_c

   174

 *                OR

   175

 *          neg_literal_c -> real_literal_c

   176

 *

   177

 *       However, this has since been changed to...

   178

 *        - replace the neg_literal_c with two distinc classes

   179

 *              (neg_integer_c and neg_real_c), one for each

   180

 *              lietral type. 

   181

 *

   182

 *       This change was done in order to ease the writing of semantic verification (stage3) code.

   183

 *       However, that version of the code has since been replaced by a newer and better algoritm.

   184

 *       This means the above change can now be undone, but there is really no need to undo it,

   185

 *       so we leave it as it is.

   186

 */  

   187

SYM_REF1(neg_real_c, exp)

   188

SYM_REF1(neg_integer_c, exp)

   189

   190

/* Not required:

   191

SYM_REF2(numeric_literal_c, type, value)

   192

*/

   193

SYM_REF2(integer_literal_c, type, value)

   194

SYM_REF2(real_literal_c, type, value)

   195

SYM_REF2(bit_string_literal_c, type, value)

   196

/* A typed or untyped boolean literal... */

   197

/* type may be NULL */

   198

SYM_REF2(boolean_literal_c, type, value)

   199

   200

/* helper class for boolean_literal_c */

   201

SYM_REF0(boolean_true_c)

   202

   203

/* helper class for boolean_literal_c */

   204

SYM_REF0(boolean_false_c)

   205

   206

   207

/*******************************/

   208

/* B.1.2.2   Character Strings */

   209

/*******************************/

   210

SYM_TOKEN(double_byte_character_string_c)

   211

SYM_TOKEN(single_byte_character_string_c)

   212

   213

   214

/***************************/

   215

/* B 1.2.3 - Time Literals */

   216

/***************************/

   217

   218

/************************/

   219

/* B 1.2.3.1 - Duration */

   220

/************************/

   221

SYM_REF0(neg_time_c)

   222

SYM_REF3(duration_c, type_name, neg, interval)

   223

SYM_REF5(interval_c, days, hours, minutes, seconds, milliseconds)

   224

SYM_TOKEN(fixed_point_c)

   225

/*

   226

SYM_REF2(days_c, days, hours)

   227

SYM_REF2(hours_c, hours, minutes)

   228

SYM_REF2(minutes_c, minutes, seconds)

   229

SYM_REF2(seconds_c, seconds, milliseconds)

   230

SYM_REF1(milliseconds_c, milliseconds)

   231

*/

   232

   233

/************************************/

   234

/* B 1.2.3.2 - Time of day and Date */

   235

/************************************/

   236

SYM_REF2(time_of_day_c, type_name, daytime)

   237

SYM_REF3(daytime_c, day_hour, day_minute, day_second)

   238

SYM_REF2(date_c, type_name, date_literal)

   239

SYM_REF3(date_literal_c, year, month, day)

   240

SYM_REF3(date_and_time_c, type_name, date_literal, daytime)

   241

   242

   243

/**********************/

   244

/* B.1.3 - Data types */

   245

/**********************/

   246

/***********************************/

   247

/* B 1.3.1 - Elementary Data Types */

   248

/***********************************/

   249

SYM_REF0(time_type_name_c)

   250

SYM_REF0(bool_type_name_c)

   251

SYM_REF0(sint_type_name_c)

   252

SYM_REF0(int_type_name_c)

   253

SYM_REF0(dint_type_name_c)

   254

SYM_REF0(lint_type_name_c)

   255

SYM_REF0(usint_type_name_c)

   256

SYM_REF0(uint_type_name_c)

   257

SYM_REF0(udint_type_name_c)

   258

SYM_REF0(ulint_type_name_c)

   259

SYM_REF0(real_type_name_c)

   260

SYM_REF0(lreal_type_name_c)

   261

SYM_REF0(date_type_name_c)

   262

SYM_REF0(tod_type_name_c)

   263

SYM_REF0(dt_type_name_c)

   264

SYM_REF0(byte_type_name_c)

   265

SYM_REF0(word_type_name_c)

   266

SYM_REF0(dword_type_name_c)

   267

SYM_REF0(lword_type_name_c)

   268

SYM_REF0(string_type_name_c)

   269

SYM_REF0(wstring_type_name_c)

   270

SYM_REF0(void_type_name_c) /* a non-standard extension! */

   271

   272

  /*****************************************************************/

   273

  /* Keywords defined in "Safety Software Technical Specification" */

   274

  /*****************************************************************/

   275

   276

SYM_REF0(safetime_type_name_c)

   277

SYM_REF0(safebool_type_name_c)

   278

SYM_REF0(safesint_type_name_c)

   279

SYM_REF0(safeint_type_name_c)

   280

SYM_REF0(safedint_type_name_c)

   281

SYM_REF0(safelint_type_name_c)

   282

SYM_REF0(safeusint_type_name_c)

   283

SYM_REF0(safeuint_type_name_c)

   284

SYM_REF0(safeudint_type_name_c)

   285

SYM_REF0(safeulint_type_name_c)

   286

SYM_REF0(safereal_type_name_c)

   287

SYM_REF0(safelreal_type_name_c)

   288

SYM_REF0(safedate_type_name_c)

   289

SYM_REF0(safetod_type_name_c)

   290

SYM_REF0(safedt_type_name_c)

   291

SYM_REF0(safebyte_type_name_c)

   292

SYM_REF0(safeword_type_name_c)

   293

SYM_REF0(safedword_type_name_c)

   294

SYM_REF0(safelword_type_name_c)

   295

SYM_REF0(safestring_type_name_c)

   296

SYM_REF0(safewstring_type_name_c)

   297

   298

   299

/********************************/

   300

/* B.1.3.2 - Generic data types */

   301

/********************************/

   302

   303

/* ANY is currently only allowed when defining REF_TO ANY datatypes

   304

 * (equivalent to a (void *)). This is a non standard extension to the

   305

 * standard.

   306

 * Standard library function that use the generic datatypes (ANY_***) are

   307

 * currently handed as overloaded functions, and do not therefore require

   308

 * the use of the generic datatype keywords.

   309

 */

   310

SYM_REF0(generic_type_any_c)            // ANY

   311

/*

   312

SYM_REF0(generic_type_any_derived_c)    // ANY_DERIVED

   313

SYM_REF0(generic_type_any_elementary_c) // ANY_ELEMENTARY

   314

SYM_REF0(generic_type_any_magnitude_c)  // ANY_MAGNITUDE

   315

SYM_REF0(generic_type_any_num_c)        // ANY_NUM

   316

SYM_REF0(generic_type_any_real_c)       // ANY_REAL

   317

SYM_REF0(generic_type_any_int_c)        // ANY_INT

   318

SYM_REF0(generic_type_any_bit_c)        // ANY_BIT

   319

SYM_REF0(generic_type_any_string_c)     // ANY_STRING

   320

SYM_REF0(generic_type_any_date_c)       // ANY_DATE

   321

*/

   322

   323

/********************************/

   324

/* B 1.3.3 - Derived data types */

   325

/********************************/

   326

/*  TYPE type_declaration_list END_TYPE */

   327

SYM_REF1(data_type_declaration_c, type_declaration_list)

   328

   329

/* helper symbol for data_type_declaration */

   330

SYM_LIST(type_declaration_list_c)

   331

   332

/*  simple_type_name ':' simple_spec_init */

   333

SYM_REF2(simple_type_declaration_c, simple_type_name, simple_spec_init)

   334

   335

   336

/* simple_specification ASSIGN constant */

   337

SYM_REF2(simple_spec_init_c, simple_specification, constant)

   338

   339

/*  subrange_type_name ':' subrange_spec_init */

   340

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   341

   342

/* subrange_specification ASSIGN signed_integer */

   343

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   344

   345

/*  integer_type_name '(' subrange')' */

   346

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   347

   348

/*  signed_integer DOTDOT signed_integer */

   349

/* dimension will be filled in during stage 3 (array_range_check_c) with the number of elements in this subrange */

   350

SYM_REF2(subrange_c, lower_limit, upper_limit, unsigned long long int dimension;)

   351

   352

/*  enumerated_type_name ':' enumerated_spec_init */

   353

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   354

   355

/* enumerated_specification ASSIGN enumerated_value */

   356

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   357

   358

/* helper symbol for enumerated_specification->enumerated_spec_init */

   359

/* enumerated_value_list ',' enumerated_value */

   360

SYM_LIST(enumerated_value_list_c)

   361

   362

/* enumerated_type_name '#' identifier */

   363

SYM_REF2(enumerated_value_c, type, value)

   364

   365

/*  identifier ':' array_spec_init */

   366

SYM_REF2(array_type_declaration_c, identifier, array_spec_init)

   367

   368

/* array_specification [ASSIGN array_initialization] */

   369

/* array_initialization may be NULL ! */

   370

SYM_REF2(array_spec_init_c, array_specification, array_initialization)

   371

   372

/* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */

   373

SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name)

   374

   375

/* helper symbol for array_specification */

   376

/* array_subrange_list ',' subrange */

   377

SYM_LIST(array_subrange_list_c)

   378

   379

/* array_initialization:  '[' array_initial_elements_list ']' */

   380

/* helper symbol for array_initialization */

   381

/* array_initial_elements_list ',' array_initial_elements */

   382

SYM_LIST(array_initial_elements_list_c)

   383

   384

/* integer '(' [array_initial_element] ')' */

   385

/* array_initial_element may be NULL ! */

   386

SYM_REF2(array_initial_elements_c, integer, array_initial_element)

   387

   388

/*  structure_type_name ':' structure_specification */

   389

SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)

   390

   391

/* structure_type_name ASSIGN structure_initialization */

   392

/* structure_initialization may be NULL ! */

   393

SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization)

   394

   395

/* helper symbol for structure_declaration */

   396

/* structure_declaration:  STRUCT structure_element_declaration_list END_STRUCT */

   397

/* structure_element_declaration_list structure_element_declaration ';' */

   398

SYM_LIST(structure_element_declaration_list_c)

   399

   400

/*  structure_element_name ':' *_spec_init */

   401

SYM_REF2(structure_element_declaration_c, structure_element_name, spec_init)

   402

   403

/* helper symbol for structure_initialization */

   404

/* structure_initialization: '(' structure_element_initialization_list ')' */

   405

/* structure_element_initialization_list ',' structure_element_initialization */

   406

SYM_LIST(structure_element_initialization_list_c)

   407

   408

/*  structure_element_name ASSIGN value */

   409

SYM_REF2(structure_element_initialization_c, structure_element_name, value)

   410

   411

/*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   412

/*

   413

 * NOTE:

   414

 * (Summary: Contrary to what is expected, the

   415

 *           string_type_declaration_c is not used to store

   416

 *           simple string type declarations that do not include

   417

 *           size limits.

   418

 *           For e.g.:

   419

 *             str1_type: STRING := "hello!"

   420

 *           will be stored in a simple_type_declaration_c

   421

 *           instead of a string_type_declaration_c.

   422

 *           The following:

   423

 *             str2_type: STRING [64] := "hello!"

   424

 *           will be stored in a sring_type_declaration_c

   425

 *

   426

 *           Read on for why this is done...

   427

 * End Summary)

   428

 *

   429

 * According to the spec, the valid construct

   430

 * TYPE new_str_type : STRING := "hello!"; END_TYPE

   431

 * has two possible routes to type_declaration...

   432

 *

   433

 * Route 1:

   434

 * type_declaration: single_element_type_declaration

   435

 * single_element_type_declaration: simple_type_declaration

   436

 * simple_type_declaration: identifier ':' simple_spec_init

   437

 * simple_spec_init: simple_specification ASSIGN constant

   438

 * (shift:  identifier <- 'new_str_type')

   439

 * simple_specification: elementary_type_name

   440

 * elementary_type_name: STRING

   441

 * (shift: elementary_type_name <- STRING)

   442

 * (reduce: simple_specification <- elementary_type_name)

   443

 * (shift: constant <- "hello!")

   444

 * (reduce: simple_spec_init: simple_specification ASSIGN constant)

   445

 * (reduce: ...)

   446

 *

   447

 *

   448

 * Route 2:

   449

 * type_declaration: string_type_declaration

   450

 * string_type_declaration: identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init

   451

 * (shift:  identifier <- 'new_str_type')

   452

 * elementary_string_type_name: STRING

   453

 * (shift: elementary_string_type_name <- STRING)

   454

 * (shift: string_type_declaration_size <-  empty )

   455

 * string_type_declaration_init: ASSIGN character_string

   456

 * (shift: character_string <- "hello!")

   457

 * (reduce: string_type_declaration_init <- ASSIGN character_string)

   458

 * (reduce: string_type_declaration <- identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init )

   459

 * (reduce: type_declaration <- string_type_declaration)

   460

 *

   461

 *

   462

 * At first glance it seems that removing route 1 would make

   463

 * the most sense. Unfortunately the construct 'simple_spec_init'

   464

 * shows up multiple times in other rules, so changing this construct

   465

 * would also mean changing all the rules in which it appears.

   466

 * I (Mario) therefore chose to remove route 2 instead. This means

   467

 * that the above declaration gets stored in a

   468

 * simple_type_declaration_c, and not in a string_type_declaration_c

   469

 * as would be expected!

   470

 */

   471

/*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   472

SYM_REF4(string_type_declaration_c,	string_type_name,

   473

					elementary_string_type_name,

   474

					string_type_declaration_size,

   475

					string_type_declaration_init) /* may be == NULL! */

   476

   477

   478

/* helper symbol for fb_name_decl_c */

   479

/* This symbol/leaf does not exist in the IEC standard syntax as an isolated symbol,

   480

 * as, for some reason, the standard syntax defines FB variable declarations in a slightly 

   481

 * different style as all other spec_init declarations. I.e., fr FBs variable declarations, 

   482

 * the standard defines a single leaf/node (fb_name_decl) that references:

   483

 *   a) the variable name list

   484

 *   b) the FB datatype

   485

 *   c) the FB intial value

   486

 *

   487

 * All other variable declarations break this out into two nodes:

   488

 *   1) references b) and c) above (usually named ***_spec_init)

   489

 *   2) references a), and node 1)

   490

 *

   491

 * In order to allow the datatype analyses to proceed without special cases, we will handle

   492

 * FB variable declarations in the same style. For this reason, we have added the

   493

 * following node to the Abstract Syntax Tree, even though it does not have a direct equivalent in 

   494

 * the standard syntax.

   495

 */

   496

/*  function_block_type_name ASSIGN structure_initialization */

   497

/* structure_initialization -> may be NULL ! */

   498

SYM_REF2(fb_spec_init_c, function_block_type_name, structure_initialization)

   499

   500

   501

/* Taken fron IEC 61131-3 v3

   502

 * // Table 14 - Reference operations

   503

 * Ref_Type_Decl  : Ref_Type_Name ':' Ref_Spec_Init ;

   504

 * Ref_Spec_Init  : Ref_Spec ( ':=' Ref_Value )? ;

   505

 * Ref_Spec       : 'REF_TO' Non_Gen_Type_Name ;

   506

 * Ref_Type_Name  : Identifier ;

   507

 * Ref_Name       : Identifier ;

   508

 * Ref_Value      : Ref_Addr | 'NULL' ;

   509

 * Ref_Addr       : 'REF' '(' (Symbolic_Variable | FB_Name | Class_Instance_Name ) ')' ;

   510

 * Ref_Assign     : Ref_Name ':=' (Ref_Name | Ref_Deref | Ref_Value ) ;