1

/*

     2

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

     3

 *

     4

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

     6

 *

     7

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

     8

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

     9

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

    10

 *  (at your option) any later version.

    11

 *

    12

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

    13

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

    14

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

 *  GNU General Public License for more details.

    16

 *

    17

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

    18

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

    19

 *

    20

 *

    21

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

    22

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

    23

 */

    24

    25

/*

    26

 * An IEC 61131-3 compiler.

    27

 *

    28

 * Based on the

    29

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

    30

 *

    31

 */

    32

    33

/*

    34

 * Stage 2

    35

 * =======

    36

 *

    37

 *  This file contains the syntax definition of the textual

    38

 *  languages IL and ST, as well as the textual version of SFC.

    39

 *  The syntax parser, comprising the 2nd stage of the overall 

    40

 *  compiler, is generated by runing bison on this file.

    41

 */

    42

    43

    44

    45

    46

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

    47

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

    48

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

    49

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

    50

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

    51

/*******   The following syntax does not have any conflicts.    *******/

    52

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

    53

/*******   P L E A S E    K E E P    I T    T H A T    W A Y !  *******/

    54

/*******   ===================================================  *******/

    55

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

    56

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

    57

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

    58

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

    59

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

    60

    61

    62

    63

    64

%{

    65

#include <string.h>	/* required for strdup()  */

    66

    67

    68

/* declare the token parser generated by flex... */

    69

int yylex(void);

    70

    71

/* declare the error handler defined at the end of this file */

    72

void yyerror (const char *error_msg);

    73

    74

/* produce a more verbose parsing error message */

    75

#define YYERROR_VERBOSE

    76

    77

/* Include debuging code.

    78

 * Printing of debug info must then be activated by setting

    79

 * the variable yydebug to 1.

    80

 */

    81

#define YYDEBUG 0

    82

    83

    84

/* file with declaration of absyntax classes... */

    85

#include "../absyntax/absyntax.hh"

    86

    87

/* file with declaration of token constants. Generated by bison! */

    88

#include "iec.y.hh"

    89

    90

/* The interface through which bison and flex interact. */

    91

#include "stage1_2_priv.hh"

    92

    93

    94

/* an ugly hack!!

    95

 * We will probably not need it when we decide

    96

 *  to cut down the abstract syntax down to size.

    97

 *  We keep it as it is until we get to write

    98

 *  stages 3 and 4 of the compiler. Who knows,

    99

 *  we might just find out that we really do need

   100

 *  the abstract syntax tree to stay as it is

   101

 *  afterall!

   102

 */

   103

/* for each element <elem> in list_c * <list>

   104

 * execute the code <code>

   105

 */

   106

#define FOR_EACH_ELEMENT(elem, list, code) {		\

   107

  symbol_c *elem;					\

   108

  for(int i = 0; i < list->n; i++) {			\

   109

    elem = list->elements[i];				\

   110

    code;						\

   111

  }							\

   112

}

   113

   114

   115

   116

/* Macros used to pass the line and column locations when

   117

 * creating a new object for the abstract syntax tree.

   118

 */

   119

#define locloc(foo) foo.first_line, foo.first_column, foo.last_line, foo.last_column

   120

#define   locf(foo) foo.first_line, foo.first_column

   121

#define   locl(foo) foo.last_line,  foo.last_column

   122

   123

   124

   125

/* A macro for printing out internal parser errors... */

   126

#define ERROR error_exit(__FILE__,__LINE__)

   127

/* function defined in main.cc */

   128

extern void error_exit(const char *file_name, int line_no);

   129

   130

   131

   132

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

   133

/* global variables...   */

   134

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

   135

/* NOTE: For some strange reason bison ver 2.3 is including these declarations

   136

 *       in the iec.y.hh file, which is in turn included by flex.

   137

 *       We cannot therefore define any variables over here, but merely declare 

   138

 *       their existance (otherwise we get errors when linking the code, since we

   139

 *       would get a new variable defined each time iec.y.hh is included!).

   140

 *       Even though the variables are declared 'extern' over here, they will in

   141

 *       fact be defined towards the end of this same file (i.e. in the prologue)

   142

 */

   143

   144

   145

/* NOTE: These variable are really parameters we would like the stage2__ function to pass

   146

 *       to the yyparse() function. However, the yyparse() function is created automatically

   147

 *       by bison, so we cannot add parameters to this function. The only other

   148

 *       option is to use global variables! yuck!

   149

 */

   150

   151

/* A global flag used to tell the parser if overloaded funtions should be allowed.

   152

 * The IEC 61131-3 standard allows overloaded funtions in the standard library,

   153

 * but disallows them in user code...

   154

 */

   155

extern bool allow_function_overloading;

   156

   157

/* A global flag used to tell the parser whether to include the full variable location

   158

 * when printing out error messages...

   159

 */

   160

extern bool full_token_loc;

   161

   162

/* A pointer to the root of the parsing tree that will be generated 

   163

 * by bison.

   164

 */

   165

extern symbol_c *tree_root;

   166

   167

   168

   169

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

   170

/* forward declarations */

   171

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

   172

/* The functions declared here are defined at the end of this file... */

   173

   174

/* Convert an il_operator_c into an identifier_c */

   175

symbol_c *il_operator_c_2_identifier_c(symbol_c *il_operator);

   176

   177

/* return if current token is a syntax element */

   178

/* ERROR_CHECK_BEGIN */

   179

bool is_current_syntax_token();

   180

/* ERROR_CHECK_END */

   181

   182

/* print an error message */

   183

void print_err_msg(int first_line,

   184

                   int first_column,

   185

                   int last_line,

   186

                   int last_column,

   187

                   const char *additional_error_msg);

   188

%}

   189

   190

   191

   192

   193

// %glr-parser

   194

// %expect-rr 1

   195

   196

   197

   198

   199

%union {

   200

    symbol_c 	*leaf;

   201

    list_c	*list;

   202

    char 	*ID;	/* token value */

   203

}

   204

   205

/*

   206

 TODO: DO we need to define a destructor do free

   207

       memory when recovering from errors, or do the

   208

       class destructors already handle this?

   209

       Following is example on how to define

   210

       detructors, using the syntax:

   211

       %destructor { CODE } SYMBOLS

   212

%union

   213

      {

   214

        char *string;

   215

      }

   216

      %token <string> STRING

   217

      %type  <string> string

   218

      %destructor { free ($$); } STRING string

   219

*/

   220

   221

   222

   223

   224

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

   225

/* Prelimenary helpful constructs... */

   226

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

   227

/* A token used to identify the very end of the input file

   228

 * after all includes have already been processed.

   229

 *

   230

 * Flex automatically returns the token with value 0

   231

 * at the end of the file. We therefore specify here

   232

 * a token with that exact same value here, so we can use it

   233

 * to detect the very end of the input files.

   234

 */

   235

%token END_OF_INPUT 0

   236

   237

/* A bogus token that, in principle, flex MUST NEVER generate */

   238

/* USE 1:

   239

 * ======

   240

 * This token is currently also being used as the default

   241

 * initialisation value of the token_id member in

   242

 * the symbol_c base class.

   243

 *

   244

 * USE 2

   245

 * =====

   246

 * This token may also be used in the future to remove

   247

 * mysterious reduce/reduce conflicts due to the fact

   248

 * that our grammar may not be LALR(1) but merely LR(1).

   249

 * This means that bison cannot handle it without some

   250

 * caoxing from ourselves. We will then need this token

   251

 * to do the coaxing...

   252

 */

   253

%token BOGUS_TOKEN_ID

   254

   255

%type <leaf>	start

   256

   257

%type <leaf>	any_identifier

   258

   259

%token <ID>	prev_declared_variable_name_token

   260

%token <ID>	prev_declared_direct_variable_token

   261

%token <ID>	prev_declared_fb_name_token

   262

%type <leaf>	prev_declared_variable_name

   263

%type <leaf>	prev_declared_direct_variable

   264

%type <leaf>	prev_declared_fb_name

   265

   266

%token  <ID>	prev_declared_simple_type_name_token

   267

%token  <ID>	prev_declared_subrange_type_name_token

   268

%token  <ID>	prev_declared_enumerated_type_name_token

   269

%token  <ID>	prev_declared_array_type_name_token

   270

%token  <ID>	prev_declared_structure_type_name_token

   271

%token  <ID>	prev_declared_string_type_name_token

   272

   273

%type  <leaf>	prev_declared_simple_type_name

   274

%type  <leaf>	prev_declared_subrange_type_name

   275

%type  <leaf>	prev_declared_enumerated_type_name

   276

%type  <leaf>	prev_declared_array_type_name

   277

%type  <leaf>	prev_declared_structure_type_name

   278

%type  <leaf>	prev_declared_string_type_name

   279

   280

%token <ID>	prev_declared_derived_function_name_token

   281

%token <ID>	prev_declared_derived_function_block_name_token

   282

%token <ID>	prev_declared_program_type_name_token

   283

%type  <leaf>	prev_declared_derived_function_name

   284

%type  <leaf>	prev_declared_derived_function_block_name

   285

%type  <leaf>	prev_declared_program_type_name

   286

   287

   288

   289

   290

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

   291

/* B XXX - Things that are missing from the standard, but should have been there! */

   292

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

   293

   294

/* Pragmas that our compiler will accept.

   295

 * See the comment in iec.flex for why these pragmas exist. 

   296

 */

   297

%token          disable_code_generation_pragma_token

   298

%token          enable_code_generation_pragma_token

   299

%type <leaf>	disable_code_generation_pragma

   300

%type <leaf>	enable_code_generation_pragma

   301

   302

   303

/* All other pragmas that we do not support... */

   304

/* In most stage 4, the text inside the pragmas will simply be copied to the output file.

   305

 * This allows us to insert C code (if using stage 4 generating C code) 

   306

 * inside/interningled with the IEC 61131-3 code!

   307

 */

   308

%token <ID>	pragma_token

   309

%type <leaf>	pragma

   310

   311

/* The joining of all previous pragmas, i.e. any possible pragma */

   312

%type <leaf>	any_pragma

   313

   314

   315

/* Where do these tokens belong?? They are missing from the standard! */

   316

/* NOTE: There are other tokens related to these 'EN' ENO', that are also 

   317

 * missing from the standard. However, their location in the annex B is 

   318

 * relatively obvious, so they have been inserted in what seems to us their 

   319

 * correct place in order to ease understanding of the parser...

   320

 */

   321

%token	EN

   322

%token	ENO

   323

%type <leaf>	en_identifier

   324

%type <leaf>	eno_identifier

   325

   326

   327

   328

   329

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

   330

/* B 0 - Programming Model */

   331

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

   332

%type <list>	library

   333

%type <leaf>	library_element_declaration

   334

   335

   336

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

   337

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

   338

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

   339

/* Done totally within flex...

   340

  letter

   341

  digit

   342

  octal_digit

   343

  hex_digit

   344

*/

   345

%token <ID>	identifier_token

   346

%type  <leaf>	identifier

   347

   348

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

   349

/* B 1.2 - Constants */

   350

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

   351

%type <leaf>	constant

   352

%type <leaf>	non_negative_constant

   353

   354

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

   355

/* B 1.2.1 - Numeric Literals */

   356

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

   357

/* Done totally within flex...

   358

  bit

   359

*/

   360

%type  <leaf> numeric_literal

   361

%type  <leaf> integer_literal

   362

%type  <leaf> signed_integer

   363

%token <ID>   integer_token

   364

%type  <leaf> integer

   365

%token <ID>   binary_integer_token

   366

%type  <leaf> binary_integer

   367

%token <ID>   octal_integer_token

   368

%type  <leaf> octal_integer

   369

%token <ID>   hex_integer_token

   370

%type  <leaf> hex_integer

   371

%token <ID>   real_token

   372

%type  <leaf> real

   373

%type  <leaf> signed_real

   374

%type  <leaf> real_literal

   375

// %type  <leaf> exponent

   376

%type  <leaf> bit_string_literal

   377

%type  <leaf> boolean_literal

   378

   379

%token safeboolean_true_literal_token

   380

%token safeboolean_false_literal_token

   381

%token boolean_true_literal_token

   382

%token boolean_false_literal_token

   383

   384

%token FALSE

   385

%token TRUE

   386

   387

   388

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

   389

/* B 1.2.2 - Character Strings */

   390

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

   391

%token <ID>   single_byte_character_string_token

   392

%token <ID>   double_byte_character_string_token

   393

   394

%type  <leaf> character_string

   395

%type  <leaf> single_byte_character_string

   396

%type  <leaf> double_byte_character_string

   397

   398

   399

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

   400

/* B 1.2.3 - Time Literals */

   401

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

   402

%type  <leaf> time_literal

   403

   404

   405

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

   406

/* B 1.2.3.1 - Duration */

   407

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

   408

%type  <leaf>	duration

   409

%type  <leaf>	interval

   410

%type  <leaf>	days

   411

%type  <leaf>	fixed_point

   412

%type  <leaf>	hours

   413

%type  <leaf>	minutes

   414

%type  <leaf>	seconds

   415

%type  <leaf>	milliseconds

   416

   417

%type  <leaf>	integer_d

   418

%type  <leaf>	integer_h

   419

%type  <leaf>	integer_m

   420

%type  <leaf>	integer_s

   421

%type  <leaf>	integer_ms

   422

%type  <leaf>	fixed_point_d

   423

%type  <leaf>	fixed_point_h

   424

%type  <leaf>	fixed_point_m

   425

%type  <leaf>	fixed_point_s

   426

%type  <leaf>	fixed_point_ms

   427

   428

%token <ID>	fixed_point_token

   429

%token <ID>	fixed_point_d_token

   430

%token <ID>	integer_d_token

   431

%token <ID>	fixed_point_h_token

   432

%token <ID>	integer_h_token

   433

%token <ID>	fixed_point_m_token

   434

%token <ID>	integer_m_token

   435

%token <ID>	fixed_point_s_token

   436

%token <ID>	integer_s_token

   437

%token <ID>	fixed_point_ms_token

   438

%token <ID>	integer_ms_token

   439

   440

// %token TIME

   441

%token T_SHARP

   442

   443

   444

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

   445

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

   446

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

   447

%type  <leaf>	time_of_day

   448

%type  <leaf>	daytime

   449

%type  <leaf>	day_hour

   450

%type  <leaf>	day_minute

   451

%type  <leaf>	day_second

   452

%type  <leaf>	date

   453

%type  <leaf>	date_literal

   454

%type  <leaf>	year

   455

%type  <leaf>	month

   456

%type  <leaf>	day

   457

%type  <leaf>	date_and_time

   458

   459

// %token TIME_OF_DAY

   460

// %token DATE

   461

%token D_SHARP

   462

// %token DATE_AND_TIME

   463

   464

   465

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

   466

/* B 1.3 - Data Types */

   467

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

   468

/* Strangely, the following symbol does seem to be required! */

   469

// %type  <leaf> data_type_name

   470

%type  <leaf> non_generic_type_name

   471

   472

   473

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

   474

/* B 1.3.1 - Elementary Data Types */

   475

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

   476

/* NOTES:

   477

 *

   478

 *    - To make the definition of bit_string_literal more

   479

 *      concise, it is useful to use an extra non-terminal

   480

 *      symbol (i.e. a grouping or construct) that groups the

   481

 *      following elements (BYTE, WORD, DWORD, LWORD).

   482

 *      Note that the definition of bit_string_type_name

   483

 *      (according to the spec) includes the above elements

   484

 *      and an extra BOOL.

   485

 *      We could use an extra construct with the first four

   486

 *      elements to be used solely in the definition of

   487

 *      bit_string_literal, but with the objective of not

   488

 *      having to replicate the actions (if we ever need

   489

 *      to change them, they would need to be changed in both

   490

 *      bit_string_type_name and the extra grouping), we

   491

 *      have re-defined bit_string_type_name as only including

   492

 *      the first four elements.

   493

 *      In order to have our parser implement the specification

   494

 *      correctly we have augmented every occurence of

   495

 *      bit_string_type_name in other rules with the BOOL

   496

 *      token. Since bit_string_type_name only appears in

   497

 *      the rule for elementary_type_name, this does not

   498

 *      seem to be a big concession to make!

   499

 *

   500

 *    - We have added a helper symbol to concentrate the

   501

 *      instantiation of STRING and WSTRING into a single

   502

 *      location (elementary_string_type_name).

   503

 *      These two elements show up in several other rules,

   504

 *      but we want to create the equivalent abstract syntax

   505

 *      in a single location of this file, in order to make

   506

 *      possible future changes easier to edit...

   507

 */

   508

%type  <leaf>	elementary_type_name

   509

%type  <leaf>	numeric_type_name

   510

%type  <leaf>	integer_type_name

   511

%type  <leaf>	signed_integer_type_name

   512

%type  <leaf>	unsigned_integer_type_name

   513