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

/*             Symbols 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

SYM_REF0(safebool_type_name_c)

    64

    65

    66

    67

    68

    69

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

    70

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

    71

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

    72

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

    73

/*                                                               */

    74

/*             Symbols defined in:                               */

    75

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

    76

/*                                                               */

    77

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

    78

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

    79

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

    80

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

    81

    82

/* Based on the                                    */

    83

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

    84

    85

    86

/* EN/ENO */

    87

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

    88

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

    89

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

    90

 */

    91

/*

    92

SYM_REF0(en_param_c)

    93

SYM_REF0(eno_param_c)

    94

*/

    95

    96

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

    97

/* 2.1.6 - Pragmas */

    98

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

    99

SYM_TOKEN(pragma_c)

   100

   101

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

   102

/* B 0 - Programming Model */

   103

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

   104

SYM_LIST(library_c)

   105

   106

   107

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

   108

/* B.1 - Common elements */

   109

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

   110

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

   111

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

   112

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

   113

SYM_TOKEN(identifier_c)

   114

   115

   116

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

   117

/* B 1.2 - Constants */

   118

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

   119

   120

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

   121

/* B 1.2.1 - Numeric Literals */

   122

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

   123

SYM_TOKEN(real_c)

   124

SYM_TOKEN(integer_c)

   125

SYM_TOKEN(binary_integer_c)

   126

SYM_TOKEN(octal_integer_c)

   127

SYM_TOKEN(hex_integer_c)

   128

   129

/* Note:

   130

 * We do not have signed_integer_c and signed_real_c classes.

   131

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

   132

 * preceded by a unary minus operator.

   133

 */

   134

/* Not required:

   135

SYM_TOKEN(signed_integer_c)

   136

SYM_TOKEN(signed_real_c)

   137

*/

   138

   139

SYM_REF1(neg_literal_c, exp)

   140

   141

/* Not required:

   142

SYM_REF2(numeric_literal_c, type, value)

   143

*/

   144

SYM_REF2(integer_literal_c, type, value)

   145

SYM_REF2(real_literal_c, type, value)

   146

SYM_REF2(bit_string_literal_c, type, value)

   147

SYM_REF2(boolean_literal_c, type, value)

   148

   149

/* helper class for boolean_literal_c */

   150

SYM_REF0(boolean_true_c)

   151

   152

/* helper class for boolean_literal_c */

   153

SYM_REF0(boolean_false_c)

   154

   155

   156

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

   157

/* B.1.2.2   Character Strings */

   158

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

   159

SYM_TOKEN(double_byte_character_string_c)

   160

SYM_TOKEN(single_byte_character_string_c)

   161

   162

   163

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

   164

/* B 1.2.3 - Time Literals */

   165

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

   166

   167

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

   168

/* B 1.2.3.1 - Duration */

   169

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

   170

SYM_REF0(neg_time_c)

   171

SYM_REF2(duration_c, neg, interval)

   172

SYM_TOKEN(fixed_point_c)

   173

SYM_REF2(days_c, days, hours)

   174

SYM_REF2(hours_c, hours, minutes)

   175

SYM_REF2(minutes_c, minutes, seconds)

   176

SYM_REF2(seconds_c, seconds, milliseconds)

   177

SYM_REF1(milliseconds_c, milliseconds)

   178

   179

   180

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

   181

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

   182

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

   183

SYM_REF1(time_of_day_c, daytime)

   184

SYM_REF3(daytime_c, day_hour, day_minute, day_second)

   185

SYM_REF1(date_c, date_literal)

   186

SYM_REF3(date_literal_c, year, month, day)

   187

SYM_REF2(date_and_time_c, date_literal, daytime)

   188

   189

   190

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

   191

/* B.1.3 - Data types */

   192

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

   193

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

   194

/* B 1.3.1 - Elementary Data Types */

   195

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

   196

SYM_REF0(time_type_name_c)

   197

SYM_REF0(bool_type_name_c)

   198

SYM_REF0(sint_type_name_c)

   199

SYM_REF0(int_type_name_c)

   200

SYM_REF0(dint_type_name_c)

   201

SYM_REF0(lint_type_name_c)

   202

SYM_REF0(usint_type_name_c)

   203

SYM_REF0(uint_type_name_c)

   204

SYM_REF0(udint_type_name_c)

   205

SYM_REF0(ulint_type_name_c)

   206

SYM_REF0(real_type_name_c)

   207

SYM_REF0(lreal_type_name_c)

   208

SYM_REF0(date_type_name_c)

   209

SYM_REF0(tod_type_name_c)

   210

SYM_REF0(dt_type_name_c)

   211

SYM_REF0(byte_type_name_c)

   212

SYM_REF0(word_type_name_c)

   213

SYM_REF0(dword_type_name_c)

   214

SYM_REF0(lword_type_name_c)

   215

SYM_REF0(string_type_name_c)

   216

SYM_REF0(wstring_type_name_c)

   217

   218

/*

   219

SYM_REF0(constant_int_type_name_c)

   220

SYM_REF0(constant_real_type_name_c)

   221

*/

   222

   223

   224

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

   225

/* B.1.3.2 - Generic data types */

   226

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

   227

   228

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

   229

/* B 1.3.3 - Derived data types */

   230

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

   231

/*  TYPE type_declaration_list END_TYPE */

   232

SYM_REF1(data_type_declaration_c, type_declaration_list)

   233

   234

/* helper symbol for data_type_declaration */

   235

SYM_LIST(type_declaration_list_c)

   236

   237

/*  simple_type_name ':' simple_spec_init */

   238

SYM_REF2(simple_type_declaration_c, simple_type_name, simple_spec_init)

   239

   240

   241

/* simple_specification ASSIGN constant */

   242

SYM_REF2(simple_spec_init_c, simple_specification, constant)

   243

   244

/*  subrange_type_name ':' subrange_spec_init */

   245

SYM_REF2(subrange_type_declaration_c, subrange_type_name, subrange_spec_init)

   246

   247

/* subrange_specification ASSIGN signed_integer */

   248

SYM_REF2(subrange_spec_init_c, subrange_specification, signed_integer)

   249

   250

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

   251

SYM_REF2(subrange_specification_c, integer_type_name, subrange)

   252

   253

/*  signed_integer DOTDOT signed_integer */

   254

SYM_REF2(subrange_c, lower_limit, upper_limit)

   255

   256

/*  enumerated_type_name ':' enumerated_spec_init */

   257

SYM_REF2(enumerated_type_declaration_c, enumerated_type_name, enumerated_spec_init)

   258

   259

/* enumerated_specification ASSIGN enumerated_value */

   260

SYM_REF2(enumerated_spec_init_c, enumerated_specification, enumerated_value)

   261

   262

/* helper symbol for enumerated_specification->enumerated_spec_init */

   263

/* enumerated_value_list ',' enumerated_value */

   264

SYM_LIST(enumerated_value_list_c)

   265

   266

/* enumerated_type_name '#' identifier */

   267

SYM_REF2(enumerated_value_c, type, value)

   268

   269

/*  identifier ':' array_spec_init */

   270

SYM_REF2(array_type_declaration_c, identifier, array_spec_init)

   271

   272

/* array_specification [ASSIGN array_initialization} */

   273

/* array_initialization may be NULL ! */

   274

SYM_REF2(array_spec_init_c, array_specification, array_initialization)

   275

   276

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

   277

SYM_REF2(array_specification_c, array_subrange_list, non_generic_type_name)

   278

   279

/* helper symbol for array_specification */

   280

/* array_subrange_list ',' subrange */

   281

SYM_LIST(array_subrange_list_c)

   282

   283

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

   284

/* helper symbol for array_initialization */

   285

/* array_initial_elements_list ',' array_initial_elements */

   286

SYM_LIST(array_initial_elements_list_c)

   287

   288

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

   289

/* array_initial_element may be NULL ! */

   290

SYM_REF2(array_initial_elements_c, integer, array_initial_element)

   291

   292

/*  structure_type_name ':' structure_specification */

   293

SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)

   294

   295

/* structure_type_name ASSIGN structure_initialization */

   296

/* structure_initialization may be NULL ! */

   297

SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization)

   298

   299

/* helper symbol for structure_declaration */

   300

/* structure_declaration:  STRUCT structure_element_declaration_list END_STRUCT */

   301

/* structure_element_declaration_list structure_element_declaration ';' */

   302

SYM_LIST(structure_element_declaration_list_c)

   303

   304

/*  structure_element_name ':' *_spec_init */

   305

SYM_REF2(structure_element_declaration_c, structure_element_name, spec_init)

   306

   307

/* helper symbol for structure_initialization */

   308

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

   309

/* structure_element_initialization_list ',' structure_element_initialization */

   310

SYM_LIST(structure_element_initialization_list_c)

   311

   312

/*  structure_element_name ASSIGN value */

   313

SYM_REF2(structure_element_initialization_c, structure_element_name, value)

   314

   315

/*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   316

/*

   317

 * NOTE:

   318

 * (Summary: Contrary to what is expected, the

   319

 *           string_type_declaration_c is not used to store

   320

 *           simple string type declarations that do not include

   321

 *           size limits.

   322

 *           For e.g.:

   323

 *             str1_type: STRING := "hello!"

   324

 *           will be stored in a simple_type_declaration_c

   325

 *           instead of a string_type_declaration_c.

   326

 *           The following:

   327

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

   328

 *           will be stored in a sring_type_declaration_c

   329

 *

   330

 *           Read on for why this is done...

   331

 * End Summary)

   332

 *

   333

 * According to the spec, the valid construct

   334

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

   335

 * has two possible routes to type_declaration...

   336

 *

   337

 * Route 1:

   338

 * type_declaration: single_element_type_declaration

   339

 * single_element_type_declaration: simple_type_declaration

   340

 * simple_type_declaration: identifier ':' simple_spec_init

   341

 * simple_spec_init: simple_specification ASSIGN constant

   342

 * (shift:  identifier <- 'new_str_type')

   343

 * simple_specification: elementary_type_name

   344

 * elementary_type_name: STRING

   345

 * (shift: elementary_type_name <- STRING)

   346

 * (reduce: simple_specification <- elementary_type_name)

   347

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

   348

 * (reduce: simple_spec_init: simple_specification ASSIGN constant)

   349

 * (reduce: ...)

   350

 *

   351

 *

   352

 * Route 2:

   353

 * type_declaration: string_type_declaration

   354

 * string_type_declaration: identifier ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init

   355

 * (shift:  identifier <- 'new_str_type')

   356

 * elementary_string_type_name: STRING

   357

 * (shift: elementary_string_type_name <- STRING)

   358

 * (shift: string_type_declaration_size <-  empty )

   359

 * string_type_declaration_init: ASSIGN character_string

   360

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

   361

 * (reduce: string_type_declaration_init <- ASSIGN character_string)

   362

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

   363

 * (reduce: type_declaration <- string_type_declaration)

   364

 *

   365

 *

   366

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

   367

 * the most sense. Unfortunately the construct 'simple_spec_init'

   368

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

   369

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

   370

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

   371

 * that the above declaration gets stored in a

   372

 * simple_type_declaration_c, and not in a string_type_declaration_c

   373

 * as would be expected!

   374

 */

   375

/*  string_type_name ':' elementary_string_type_name string_type_declaration_size string_type_declaration_init */

   376

SYM_REF4(string_type_declaration_c,	string_type_name,

   377

					elementary_string_type_name,

   378

					string_type_declaration_size,

   379

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

   380

   381

   382

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

   383

/* B 1.4 - Variables */

   384

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

   385

SYM_REF1(symbolic_variable_c, var_name)

   386

   387

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

   388

/* B.1.4.1   Directly Represented Variables */

   389

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

   390

SYM_TOKEN(direct_variable_c)

   391

   392

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

   393

/* B.1.4.2   Multi-element Variables */

   394

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

   395

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

   396

SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   397

   398

/* subscript_list ',' subscript */

   399

SYM_LIST(subscript_list_c)

   400

   401

/*  record_variable '.' field_selector */

   402

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

   403

 *           may be accessed as fields of a structured variable!

   404

 *           Code handling a structured_variable_c must take

   405

 *           this into account!

   406

 */

   407

SYM_REF2(structured_variable_c, record_variable, field_selector)

   408

   409

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

   410

/* B 1.4.3 - Declaration & Initialisation */

   411

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

   412

SYM_REF0(constant_option_c)

   413

SYM_REF0(retain_option_c)

   414

SYM_REF0(non_retain_option_c)

   415

   416

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

   417

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

   418

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

   419

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

   420

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

   421

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

   422

 *       or not (method -> explicit_definition_c).

   423

 */

   424

SYM_REF3(input_declarations_c, option, input_declaration_list, method)

   425

   426

/* helper symbol for input_declarations */

   427

SYM_LIST(input_declaration_list_c)

   428

   429

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

   430

 *       consider the EN and ENO keywords!

   431

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

   432

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

   433

 *       an ENO output parameter.

   434

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

   435

 *       to cover for this.

   436

 *

   437

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

   438

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

   439

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

   440

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

   441

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

   442

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

   443

 *       or not (method -> explicit_definition_c).

   444

 */

   445

SYM_REF0(implicit_definition_c)

   446

SYM_REF0(explicit_definition_c)

   447

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

   448

SYM_REF3(eno_param_declaration_c, name, type, method)

   449

   450

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

   451

SYM_REF2(edge_declaration_c, edge, var1_list)

   452

   453

SYM_REF0(raising_edge_option_c)

   454

SYM_REF0(falling_edge_option_c)

   455

   456

/* spec_init is one of the following...

   457

 *    simple_spec_init_c *

   458

 *    subrange_spec_init_c *

   459

 *    enumerated_spec_init_c *

   460

 */

   461

SYM_REF2(var1_init_decl_c, var1_list, spec_init)

   462

   463

/* | var1_list ',' variable_name */

   464

SYM_LIST(var1_list_c)

   465

   466

/* var1_list ':' array_spec_init */

   467

SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   468

   469

/*  var1_list ':' initialized_structure */

   470

SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   471

   472

/* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */

   473

/* structure_initialization -> may be NULL ! */

   474

SYM_REF3(fb_name_decl_c, fb_name_list, function_block_type_name, structure_initialization)

   475

   476

/* fb_name_list ',' fb_name */

   477

SYM_LIST(fb_name_list_c)

   478

   479

/* VAR_OUTPUT [RETAIN | NON_RETAIN] var_init_decl_list END_VAR */

   480

/* option -> may be NULL ! */

   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(output_declarations_c, option, var_init_decl_list, method)

   489

   490

/*  VAR_IN_OUT var_declaration_list END_VAR */

   491

SYM_REF1(input_output_declarations_c, var_declaration_list)

   492

   493

/* helper symbol for input_output_declarations */

   494

/* var_declaration_list var_declaration ';' */

   495

SYM_LIST(var_declaration_list_c)

   496

   497

/*  var1_list ':' array_specification */

   498

SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   499

   500

/*  var1_list ':' structure_type_name */

   501

SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name)

   502

   503

/* VAR [CONSTANT] var_init_decl_list END_VAR */

   504

/* option -> may be NULL ! */

   505

SYM_REF2(var_declarations_c, option, var_init_decl_list)

   506

   507

/*  VAR RETAIN var_init_decl_list END_VAR */

   508

SYM_REF1(retentive_var_declarations_c, var_init_decl_list)

   509

   510

/*  VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */

   511

/* option -> may be NULL ! */

   512

SYM_REF2(located_var_declarations_c, option, located_var_decl_list)

   513

   514

/* helper symbol for located_var_declarations */

   515

/* located_var_decl_list located_var_decl ';' */

   516

SYM_LIST(located_var_decl_list_c)

   517

   518

/*  [variable_name] location ':' located_var_spec_init */

   519

/* variable_name -> may be NULL ! */