1

/*

     2

 * (c) 2003-2007 Mario de Sousa

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

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

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

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

    14

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

    15

 */

    16

    17

/*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

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

    22

 *

    23

 */

    24

    25

/*

    26

 * Definition of the Abstract Syntax data structure components

    27

 */

    28

    29

    30

/*

    31

 * ABSYNTAX.DEF

    32

 *

    33

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

    34

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

    35

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

    36

 * the relavent code.

    37

 */

    38

    39

    40

    41

    42

    43

    44

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

    45

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

    46

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

    47

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

    48

/*                                                               */

    49

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

    50

/*      PLCopen - Technical Committee 5                          */

    51

/*      Safety Software Technical Specification,                 */

    52

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

    53

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

    54

/*                                                               */

    55

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

    56

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

    57

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

    58

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

    59

    60

    61

    62

    63

    64

    65

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

    66

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

    67

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

    68

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

    69

/*                                                               */

    70

/*             Symbols defined in:                               */

    71

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

    72

/*                                                               */

    73

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

    74

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

    75

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

    76

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

    77

    78

/* Based on the                                    */

    79

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

    80

    81

    82

/* EN/ENO */

    83

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

    84

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

    85

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

    86

 */

    87

/*

    88

SYM_REF0(en_param_c)

    89

SYM_REF0(eno_param_c)

    90

*/

    91

    92

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

    93

/* 2.1.6 - Pragmas */

    94

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

    95

SYM_TOKEN(pragma_c)

    96

    97

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

    98

/* B 0 - Programming Model */

    99

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

   100

SYM_LIST(library_c)

   101

   102

   103

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

   104

/* B.1 - Common elements */

   105

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

   106

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

   107

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

   108

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

   109

SYM_TOKEN(identifier_c)

   110

   111

   112

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

   113

/* B 1.2 - Constants */

   114

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

   115

   116

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

   117

/* B 1.2.1 - Numeric Literals */

   118

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

   119

SYM_TOKEN(real_c)

   120

SYM_TOKEN(integer_c)

   121

SYM_TOKEN(binary_integer_c)

   122

SYM_TOKEN(octal_integer_c)

   123

SYM_TOKEN(hex_integer_c)

   124

   125

/* Note:

   126

 * We do not have signed_integer_c and signed_real_c classes.

   127

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

   128

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

   129

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

   130

 */

   131

/* Not required:

   132

SYM_TOKEN(signed_integer_c)

   133

SYM_TOKEN(signed_real_c)

   134

*/

   135

   136

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

   137

 *          - real_c

   138

 *          - integer_c

   139

 *          - binary_integer_c

   140

 *          - etc...

   141

 *

   142

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

   143

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

   144

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

   145

 *       real_c or integer_c with the value being negated.

   146

 *          neg_literal_c -> integer_literal_c

   147

 *                OR

   148

 *          neg_literal_c -> real_literal_c

   149

 *

   150

 *      In the semantic verification and code generation stages of the compiler,

   151

 *      the integer_c is treated as a basic (undefined) data type, since an integer

   152

 *      constant may be used as a BYTE, BOOLEAN, REAL, etc..., depending on the

   153

 *      context in which it is used.

   154

 *      However, an integer_c that is preceded by a '-' may not be used

   155

 *      as an ANY_BIT data type (BYTE, BOOLEAN, WORD, ...).

   156

 *      We must therefore be able to determine, holding a simple pointer

   157

 *      to an integer_c, if that integer_c value is preceded by a '-'.

   158

 *      However, since the neg_literal_c points to the integer_c, and not

   159

 *      vice-versa, we can't determine that.

   160

 *      There are 3 simple ways of working around this:

   161

 *        - change the order of the pointers: 

   162

 *              have the integer_c and real_c point to the neg_literal_c

   163

 *        - maintain the order of the pointers, and

   164

 *              add redundant info to the integer_c and real_c

   165

 *        - replace the neg_literal_c with two distinc classes

   166

 *              (neg_integer_c and neg_real_c), one for each

   167

 *              lietral type. This means that we can now treat

   168

 *              each of these classes as an unknown data type

   169

 *              just as we do with the integer_c and real_c.

   170

 *

   171

 *      The second option is simply ugly.

   172

 *      and the first has a serious drawback: when generating code it is

   173

 *      easier to encapsulate the real or integer values inside prefix

   174

 *      and postfix symbols (e.g. NEG(<value>) - with postfix ')' )

   175

 *      if we keep the pointer order as is.

   176

 *

   177

 *      For the above reasoning, we use the third option.

   178

 */  

   179

SYM_REF1(neg_real_c, exp)

   180

SYM_REF1(neg_integer_c, exp)

   181

   182

/* Not required:

   183

SYM_REF2(numeric_literal_c, type, value)

   184

*/

   185

SYM_REF2(integer_literal_c, type, value)

   186

SYM_REF2(real_literal_c, type, value)

   187

SYM_REF2(bit_string_literal_c, type, value)

   188

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

   189

/* type may be NULL */

   190

SYM_REF2(boolean_literal_c, type, value)

   191

   192

/* helper class for boolean_literal_c */

   193

SYM_REF0(boolean_true_c)

   194

   195

/* helper class for boolean_literal_c */

   196

SYM_REF0(boolean_false_c)

   197

   198

   199

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

   200

/* B.1.2.2   Character Strings */

   201

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

   202

SYM_TOKEN(double_byte_character_string_c)

   203

SYM_TOKEN(single_byte_character_string_c)

   204

   205

   206

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

   207

/* B 1.2.3 - Time Literals */

   208

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

   209

   210

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

   211

/* B 1.2.3.1 - Duration */

   212

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

   213

SYM_REF0(neg_time_c)

   214

SYM_REF3(duration_c, type_name, neg, interval)

   215

SYM_TOKEN(fixed_point_c)

   216

SYM_REF2(days_c, days, hours)

   217

SYM_REF2(hours_c, hours, minutes)

   218

SYM_REF2(minutes_c, minutes, seconds)

   219

SYM_REF2(seconds_c, seconds, milliseconds)

   220

SYM_REF1(milliseconds_c, milliseconds)

   221

   222

   223

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

   224

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

   225

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

   226

SYM_REF2(time_of_day_c, type_name, daytime)

   227

SYM_REF3(daytime_c, day_hour, day_minute, day_second)

   228

SYM_REF2(date_c, type_name, date_literal)

   229

SYM_REF3(date_literal_c, year, month, day)

   230

SYM_REF3(date_and_time_c, type_name, date_literal, daytime)

   231

   232

   233

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

   234

/* B.1.3 - Data types */

   235

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

   236

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

   237

/* B 1.3.1 - Elementary Data Types */

   238

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

   239

SYM_REF0(time_type_name_c)

   240

SYM_REF0(bool_type_name_c)

   241

SYM_REF0(sint_type_name_c)

   242

SYM_REF0(int_type_name_c)

   243

SYM_REF0(dint_type_name_c)

   244

SYM_REF0(lint_type_name_c)

   245

SYM_REF0(usint_type_name_c)

   246

SYM_REF0(uint_type_name_c)

   247

SYM_REF0(udint_type_name_c)

   248

SYM_REF0(ulint_type_name_c)

   249

SYM_REF0(real_type_name_c)

   250

SYM_REF0(lreal_type_name_c)

   251

SYM_REF0(date_type_name_c)

   252

SYM_REF0(tod_type_name_c)

   253

SYM_REF0(dt_type_name_c)

   254

SYM_REF0(byte_type_name_c)

   255

SYM_REF0(word_type_name_c)

   256

SYM_REF0(dword_type_name_c)

   257

SYM_REF0(lword_type_name_c)

   258

SYM_REF0(string_type_name_c)

   259

SYM_REF0(wstring_type_name_c)

   260

   261

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

   262

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

   263

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

   264

   265

SYM_REF0(safetime_type_name_c)

   266

SYM_REF0(safebool_type_name_c)

   267

SYM_REF0(safesint_type_name_c)

   268

SYM_REF0(safeint_type_name_c)

   269

SYM_REF0(safedint_type_name_c)

   270

SYM_REF0(safelint_type_name_c)

   271

SYM_REF0(safeusint_type_name_c)

   272

SYM_REF0(safeuint_type_name_c)

   273

SYM_REF0(safeudint_type_name_c)

   274

SYM_REF0(safeulint_type_name_c)

   275

SYM_REF0(safereal_type_name_c)

   276

SYM_REF0(safelreal_type_name_c)

   277

SYM_REF0(safedate_type_name_c)

   278

SYM_REF0(safetod_type_name_c)

   279

SYM_REF0(safedt_type_name_c)

   280

SYM_REF0(safebyte_type_name_c)

   281

SYM_REF0(safeword_type_name_c)

   282

SYM_REF0(safedword_type_name_c)

   283

SYM_REF0(safelword_type_name_c)

   284

SYM_REF0(safestring_type_name_c)

   285

SYM_REF0(safewstring_type_name_c)

   286

   287

   288

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

   289

/* B.1.3.2 - Generic data types */

   290

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

   291

   292

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

   293

/* B 1.3.3 - Derived data types */

   294

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

   295

/*  TYPE type_declaration_list END_TYPE */

   296

SYM_REF1(data_type_declaration_c, type_declaration_list)

   297

   298

/* helper symbol for data_type_declaration */

   299

SYM_LIST(type_declaration_list_c)

   300

   301

/*  simple_type_name ':' simple_spec_init */

   302

SYM_REF2(simple_type_declaration_c, simple_type_name, simple_spec_init)

   303

   304

   305

/* simple_specification ASSIGN constant */

   306

SYM_REF2(simple_spec_init_c, simple_specification, constant)

   307

   308

/*  subrange_type_name ':' subrange_spec_init */

   309

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   310

   311

/* subrange_specification ASSIGN signed_integer */

   312

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   313

   314

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

   315

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   316

   317

/*  signed_integer DOTDOT signed_integer */

   318

SYM_REF2(subrange_c, lower_limit, upper_limit)

   319

   320

/*  enumerated_type_name ':' enumerated_spec_init */

   321

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   322

   323

/* enumerated_specification ASSIGN enumerated_value */

   324

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   325

   326

/* helper symbol for enumerated_specification->enumerated_spec_init */

   327

/* enumerated_value_list ',' enumerated_value */

   328

SYM_LIST(enumerated_value_list_c)

   329

   330

/* enumerated_type_name '#' identifier */

   331

SYM_REF2(enumerated_value_c, type, value)

   332

   333

/*  identifier ':' array_spec_init */

   334

SYM_REF2(array_type_declaration_c, identifier, array_spec_init)

   335

   336

/* array_specification [ASSIGN array_initialization} */

   337

/* array_initialization may be NULL ! */

   338

SYM_REF2(array_spec_init_c, array_specification, array_initialization)

   339

   340

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

   341

SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name)

   342

   343

/* helper symbol for array_specification */

   344

/* array_subrange_list ',' subrange */

   345

SYM_LIST(array_subrange_list_c)

   346

   347

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

   348

/* helper symbol for array_initialization */

   349

/* array_initial_elements_list ',' array_initial_elements */

   350

SYM_LIST(array_initial_elements_list_c)

   351

   352

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

   353

/* array_initial_element may be NULL ! */

   354

SYM_REF2(array_initial_elements_c, integer, array_initial_element)

   355

   356

/*  structure_type_name ':' structure_specification */

   357

SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)

   358

   359

/* structure_type_name ASSIGN structure_initialization */

   360

/* structure_initialization may be NULL ! */

   361

SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization)

   362

   363

/* helper symbol for structure_declaration */

   364

/* structure_declaration:  STRUCT structure_element_declaration_list END_STRUCT */

   365

/* structure_element_declaration_list structure_element_declaration ';' */

   366

SYM_LIST(structure_element_declaration_list_c)

   367

   368

/*  structure_element_name ':' *_spec_init */

   369

SYM_REF2(structure_element_declaration_c, structure_element_name, spec_init)

   370

   371

/* helper symbol for structure_initialization */

   372

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

   373

/* structure_element_initialization_list ',' structure_element_initialization */

   374

SYM_LIST(structure_element_initialization_list_c)

   375

   376

/*  structure_element_name ASSIGN value */

   377

SYM_REF2(structure_element_initialization_c, structure_element_name, value)

   378

   379

/*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   380

/*

   381

 * NOTE:

   382

 * (Summary: Contrary to what is expected, the

   383

 *           string_type_declaration_c is not used to store

   384

 *           simple string type declarations that do not include

   385

 *           size limits.

   386

 *           For e.g.:

   387

 *             str1_type: STRING := "hello!"

   388

 *           will be stored in a simple_type_declaration_c

   389

 *           instead of a string_type_declaration_c.

   390

 *           The following:

   391

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

   392

 *           will be stored in a sring_type_declaration_c

   393

 *

   394

 *           Read on for why this is done...

   395

 * End Summary)

   396

 *

   397

 * According to the spec, the valid construct

   398

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

   399

 * has two possible routes to type_declaration...

   400

 *

   401

 * Route 1:

   402

 * type_declaration: single_element_type_declaration

   403

 * single_element_type_declaration: simple_type_declaration

   404

 * simple_type_declaration: identifier ':' simple_spec_init

   405

 * simple_spec_init: simple_specification ASSIGN constant

   406

 * (shift:  identifier <- 'new_str_type')

   407

 * simple_specification: elementary_type_name

   408

 * elementary_type_name: STRING

   409

 * (shift: elementary_type_name <- STRING)

   410

 * (reduce: simple_specification <- elementary_type_name)

   411

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

   412

 * (reduce: simple_spec_init: simple_specification ASSIGN constant)

   413

 * (reduce: ...)

   414

 *

   415

 *

   416

 * Route 2:

   417

 * type_declaration: string_type_declaration

   418

 * string_type_declaration: identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init

   419

 * (shift:  identifier <- 'new_str_type')

   420

 * elementary_string_type_name: STRING

   421

 * (shift: elementary_string_type_name <- STRING)

   422

 * (shift: string_type_declaration_size <-  empty )

   423

 * string_type_declaration_init: ASSIGN character_string

   424

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

   425

 * (reduce: string_type_declaration_init <- ASSIGN character_string)

   426

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

   427

 * (reduce: type_declaration <- string_type_declaration)

   428

 *

   429

 *

   430

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

   431

 * the most sense. Unfortunately the construct 'simple_spec_init'

   432

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

   433

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

   434

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

   435

 * that the above declaration gets stored in a

   436

 * simple_type_declaration_c, and not in a string_type_declaration_c

   437

 * as would be expected!

   438

 */

   439

/*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   440

SYM_REF4(string_type_declaration_c,	string_type_name,

   441

					elementary_string_type_name,

   442

					string_type_declaration_size,

   443

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

   444

   445

   446

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

   447

/* B 1.4 - Variables */

   448

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

   449

SYM_REF1(symbolic_variable_c, var_name)

   450

   451

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

   452

/* B.1.4.1   Directly Represented Variables */

   453

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

   454

SYM_TOKEN(direct_variable_c)

   455

   456

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

   457

/* B.1.4.2   Multi-element Variables */

   458

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

   459

/*  subscripted_variable '[' subscript_list ']' */

   460

SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   461

   462

/* subscript_list ',' subscript */

   463

SYM_LIST(subscript_list_c)

   464

   465

/*  record_variable '.' field_selector */

   466

/*  WARNING: input and/or output variables of function blocks

   467

 *           may be accessed as fields of a structured variable!

   468

 *           Code handling a structured_variable_c must take

   469

 *           this into account!

   470

 */

   471

SYM_REF2(structured_variable_c, record_variable, field_selector)

   472

   473

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

   474

/* B 1.4.3 - Declaration & Initialisation */

   475

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

   476

SYM_REF0(constant_option_c)

   477

SYM_REF0(retain_option_c)

   478

SYM_REF0(non_retain_option_c)

   479

   480

/* option -> the RETAIN/NON_RETAIN/<NULL> directive... */

   481

/* NOTE: We need to implicitly define the EN and ENO function and FB parameters when the user

   482

 *       does not do it explicitly in the IEC 61131-3 source code. 

   483

 *       To be able to distinguish later on between implictly and explicitly defined

   484

 *       variables, we use the 'method' flag that allows us to remember

   485

 *       whether this declaration was in the original source code (method -> implicit_definition_c) 

   486

 *       or not (method -> explicit_definition_c).

   487

 */

   488

SYM_REF3(input_declarations_c, option, input_declaration_list, method)

   489

   490

/* helper symbol for input_declarations */

   491

SYM_LIST(input_declaration_list_c)

   492

   493

/* NOTE: The formal definition of the standard is erroneous, as it simply does not

   494

 *       consider the EN and ENO keywords!

   495

 *       The semantic description of the languages clearly states that these may be

   496

 *       used in several ways. One of them is to declare an EN input parameter, or

   497

 *       an ENO output parameter.

   498

 *       We have added the 'en_param_declaration_c' and 'eno_param_declaration_c' 

   499

 *       to cover for this.

   500

 *

   501

 *       We could have re-used the standard class used for all other input variables (with

   502

 *       an identifier set to 'EN' or 'ENO') however we may sometimes need to add this

   503

 *       declaration implicitly (if the user does not include it in the source

   504

 *       code himself), and it is good to know whether it was added implicitly or not.

   505

 *       So we create a new class that has a 'method' flag that allows us to remember

   506

 *       whether this declaration was in the original source code (method -> implicit_definition_c) 

   507

 *       or not (method -> explicit_definition_c).

   508

 */

   509

SYM_REF0(implicit_definition_c)

   510

SYM_REF0(explicit_definition_c)

   511

SYM_REF4(en_param_declaration_c, name, type, value, method)

   512

SYM_REF3(eno_param_declaration_c, name, type, method)

   513

   514

/* edge -> The F_EDGE or R_EDGE directive */

   515

SYM_REF2(edge_declaration_c, edge, var1_list)