1

/*

     2

 * (c) 2003 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

 * Stage 2

    27

 * =======

    28

 *

    29

 *  This file contains the syntax definition of the textual

    30

 *  languages IL and ST. The syntax parser, comprising the

    31

 *  2nd stage of the overall compiler, is generated by runing

    32

 *  bison on this file.

    33

 */

    34

    35

    36

    37

    38

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

    39

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

    40

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

    41

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

    42

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

    43

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

    44

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

    45

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

    46

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

    47

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

    48

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

    49

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

    50

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

    51

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

    52

    53

    54

    55

    56

%{

    57

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

    58

    59

    60

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

    61

int yylex(void);

    62

    63

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

    64

void yyerror (const char *error_msg);

    65

    66

/* produce a more verbose parsing error message */

    67

#define YYERROR_VERBOSE

    68

    69

/* Include debuging code.

    70

 * Printing of debug info must then be activated by setting

    71

 * the variable yydebug to 1.

    72

 */

    73

#define YYDEBUG 0

    74

    75

    76

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

    77

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

    78

    79

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

    80

// #include "iec.y.hh"

    81

    82

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

    83

#include "stage1_2_priv.hh"

    84

    85

    86

/* an ugly hack!!

    87

 * We will probably not need it when we decide

    88

 *  to cut down the abstract syntax down to size.

    89

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

    90

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

    91

 *  we might just find out that we really do need

    92

 *  the abstract syntax tree to stay as it is

    93

 *  afterall!

    94

 */

    95

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

    96

 * execute the code <code>

    97

 */

    98

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

    99

  symbol_c *elem;					\

   100

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

   101

    elem = list->elements[i];				\

   102

    code;						\

   103

  }							\

   104

}

   105

   106

   107

   108

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

   109

 * creating a new object for the abstract syntax tree.

   110

 */

   111

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

   112

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

   113

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

   114

   115

   116

   117

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

   118

#define ERROR error_exit(__FILE__,__LINE__)

   119

/* function defined in main.cc */

   120

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

   121

   122

   123

   124

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

   125

/* global variables...   */

   126

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

   127

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

   128

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

   129

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

   130

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

   131

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

   132

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

   133

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

   134

 */

   135

   136

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

   137

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

   138

 * but disallows them in user code...

   139

 */

   140

extern bool allow_function_overloading;

   141

   142

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

   143

 * by bison.

   144

 */

   145

extern symbol_c *tree_root;

   146

   147

   148

   149

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

   150

/* forward declarations */

   151

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

   152

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

   153

   154

/* Convert an il_operator_c into an identifier_c */

   155

symbol_c *il_operator_c_2_identifier_c(symbol_c *il_operator);

   156

   157

/* print an error message */

   158

void print_err_msg(const char *filename, int lineno, const char *additional_error_msg);

   159

   160

%}

   161

   162

   163

   164

   165

// %glr-parser

   166

// %expect-rr 1

   167

   168

   169

   170

   171

%union {

   172

    symbol_c 	*leaf;

   173

    list_c	*list;

   174

    char 	*ID;	/* token value */

   175

    struct {

   176

      symbol_c	*first;

   177

      symbol_c	*second;

   178

      symbol_c	*third;

   179

      symbol_c	*fourth;

   180

    } tmp_symbol; /* used as a temorary reference to symbols by:

   181

                                     il_simple_operator_clash_il_operand

   182

                                     transaction_tmp

   183

                                     action_tmp

   184

                             */

   185

}

   186

   187

/*

   188

 TODO: DO we need to define a destructor do free

   189

       memory when recovering from errors, or do the

   190

       class destructors already handle this?

   191

       Following is example on how to define

   192

       detructors, using the syntax:

   193

       %destructor { CODE } SYMBOLS

   194

%union

   195

      {

   196

        char *string;

   197

      }

   198

      %token <string> STRING

   199

      %type  <string> string

   200

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

   201

*/

   202

   203

   204

   205

   206

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

   207

/* Prelimenary constructs... */

   208

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

   209

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

   210

 * after all includes have already been processed.

   211

 *

   212

 * Flex automatically returns the token with value 0

   213

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

   214

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

   215

 * to detect the very end of the input files.

   216

 */

   217

%token END_OF_INPUT 0

   218

   219

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

   220

/* USE 1:

   221

 * ======

   222

 * This token is currently also being used as the default

   223

 * initialisation value of the token_id member in

   224

 * the symbol_c base class.

   225

 *

   226

 * USE 2

   227

 * =====

   228

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

   229

 * mysterious reduce/reduce conflicts due to the fact

   230

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

   231

 * This means that bison cannot handle it without some

   232

 * caoxing from ourselves. We will then need this token

   233

 * to do the coaxing...

   234

 */

   235

%token BOGUS_TOKEN_ID

   236

   237

   238

%type <leaf>	start

   239

   240

%type <leaf>	any_identifier

   241

   242

%token <ID>	prev_declared_variable_name_token

   243

%token <ID>	prev_declared_fb_name_token

   244

%type <leaf>	prev_declared_variable_name

   245

%type <leaf>	prev_declared_fb_name

   246

   247

%token  <ID>	prev_declared_simple_type_name_token

   248

%token  <ID>	prev_declared_subrange_type_name_token

   249

%token  <ID>	prev_declared_enumerated_type_name_token

   250

%token  <ID>	prev_declared_array_type_name_token

   251

%token  <ID>	prev_declared_structure_type_name_token

   252

%token  <ID>	prev_declared_string_type_name_token

   253

   254

%type  <leaf>	prev_declared_simple_type_name

   255

%type  <leaf>	prev_declared_subrange_type_name

   256

%type  <leaf>	prev_declared_enumerated_type_name

   257

%type  <leaf>	prev_declared_array_type_name

   258

%type  <leaf>	prev_declared_structure_type_name

   259

%type  <leaf>	prev_declared_string_type_name

   260

   261

%token <ID>	prev_declared_derived_function_name_token

   262

%token <ID>	prev_declared_derived_function_block_name_token

   263

%token <ID>	prev_declared_program_type_name_token

   264

%type  <leaf>	prev_declared_derived_function_name

   265

%type  <leaf>	prev_declared_derived_function_block_name

   266

%type  <leaf>	prev_declared_program_type_name

   267

   268

   269

   270

   271

/* The pragmas... */

   272

%token <ID>	pragma_token

   273

%type <leaf>	pragma

   274

   275

   276

/* Where do these tokens belong ?? */

   277

/* TODO: get the syntax parser to handle these tokens... */

   278

%token	EN

   279

%token	ENO

   280

   281

   282

   283

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

   284

/* B 0 - Programming Model */

   285

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

   286

%type <list>	library

   287

%type <leaf>	library_element_declaration

   288

   289

   290

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

   291

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

   292

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

   293

/* Done totally within flex...

   294

  letter

   295

  digit

   296

  octal_digit

   297

  hex_digit

   298

*/

   299

%token <ID>	identifier_token

   300

%type  <leaf>	identifier

   301

   302

   303

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

   304

/* B 1.2 - Constants */

   305

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

   306

%type <leaf>	constant

   307

/* a helper symbol for expression */

   308

%type  <leaf> non_negative_constant

   309

   310

   311

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

   312

/* B 1.2.1 - Numeric Literals */

   313

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

   314

/* Done totally within flex...

   315

  bit

   316

*/

   317

%type  <leaf> numeric_literal

   318

/* helper symbol for non_negative_constant */

   319

%type  <leaf> non_negative_numeric_literal

   320

%type  <leaf> integer_literal

   321

%type  <leaf> signed_integer

   322

/* a helper symbol for non_negative_constant */

   323

%type  <leaf> non_negative_signed_integer

   324

%token <ID>   integer_token

   325

%type  <leaf> integer

   326

%token <ID>   binary_integer_token

   327

%type  <leaf> binary_integer

   328

%token <ID>   octal_integer_token

   329

%type  <leaf> octal_integer

   330

%token <ID>   hex_integer_token

   331

%type  <leaf> hex_integer

   332

%token <ID>   real_token

   333

%type  <leaf> real

   334

%type  <leaf> signed_real

   335

/* helper symbol for non_negative_real_literal */

   336

%type  <leaf> non_negative_signed_real

   337

%type  <leaf> real_literal

   338

/* helper symbol for non_negative_numeric_literal */

   339

%type  <leaf> non_negative_real_literal

   340

// %type  <leaf> exponent

   341

%type  <leaf> bit_string_literal

   342

%type  <leaf> boolean_literal

   343

   344

%token FALSE

   345

%token TRUE

   346

   347

   348

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

   349

/* B 1.2.2 - Character Strings */

   350

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

   351

%token <ID>   single_byte_character_string_token

   352

%token <ID>   double_byte_character_string_token

   353

   354

%type  <leaf> character_string

   355

%type  <leaf> single_byte_character_string

   356

%type  <leaf> double_byte_character_string

   357

   358

   359

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

   360

/* B 1.2.3 - Time Literals */

   361

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

   362

%type  <leaf> time_literal

   363

   364

   365

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

   366

/* B 1.2.3.1 - Duration */

   367

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

   368

%type  <leaf>	duration

   369

%type  <leaf>	interval

   370

%type  <leaf>	days

   371

%type  <leaf>	fixed_point

   372

%type  <leaf>	hours

   373

%type  <leaf>	minutes

   374

%type  <leaf>	seconds

   375

%type  <leaf>	milliseconds

   376

   377

%type  <leaf>	integer_d

   378

%type  <leaf>	integer_h

   379

%type  <leaf>	integer_m

   380

%type  <leaf>	integer_s

   381

%type  <leaf>	integer_ms

   382

%type  <leaf>	fixed_point_d

   383

%type  <leaf>	fixed_point_h

   384

%type  <leaf>	fixed_point_m

   385

%type  <leaf>	fixed_point_s

   386

%type  <leaf>	fixed_point_ms

   387

   388

%token <ID>	fixed_point_token

   389

%token <ID>	fixed_point_d_token

   390

%token <ID>	integer_d_token

   391

%token <ID>	fixed_point_h_token

   392

%token <ID>	integer_h_token

   393

%token <ID>	fixed_point_m_token

   394

%token <ID>	integer_m_token

   395

%token <ID>	fixed_point_s_token

   396

%token <ID>	integer_s_token

   397

%token <ID>	fixed_point_ms_token

   398

%token <ID>	integer_ms_token

   399

   400

%token TIME

   401

%token T_SHARP

   402

   403

   404

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

   405

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

   406

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

   407

%type  <leaf>	time_of_day

   408

%type  <leaf>	daytime

   409

%type  <leaf>	day_hour

   410

%type  <leaf>	day_minute

   411

%type  <leaf>	day_second

   412

%type  <leaf>	date

   413

%type  <leaf>	date_literal

   414

%type  <leaf>	year

   415

%type  <leaf>	month

   416

%type  <leaf>	day

   417

%type  <leaf>	date_and_time

   418

   419

%token TIME_OF_DAY

   420

%token DATE

   421

%token D_SHARP

   422

%token DATE_AND_TIME

   423

   424

   425

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

   426

/* B 1.3 - Data Types */

   427

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

   428

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

   429

// %type  <leaf> data_type_name

   430

%type  <leaf> non_generic_type_name

   431

   432

   433

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

   434

/* B 1.3.1 - Elementary Data Types */

   435

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

   436

/* NOTES:

   437

 *

   438

 *    - To make the definition of bit_string_literal more

   439

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

   440

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

   441

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

   442

 *      Note that the definition of bit_string_type_name

   443

 *      (according to the spec) includes the above elements

   444

 *      and an extra BOOL.

   445

 *      We could use an extra construct with the first four

   446

 *      elements to be used solely in the definition of

   447

 *      bit_string_literal, but with the objective of not

   448

 *      having to replicate the actions (if we ever need

   449

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

   450

 *      bit_string_type_name and the extra grouping), we

   451

 *      have re-defined bit_string_type_name as only including

   452

 *      the first four elements.

   453

 *      In order to have our parser implement the specification

   454

 *      correctly we have augmented every occurence of

   455

 *      bit_string_type_name in other rules with the BOOL

   456

 *      token. Since bit_string_type_name only appears in

   457

 *      the rule for elementary_type_name, this does not

   458

 *      seem to be a big concession to make!

   459

 *

   460

 *    - We have added a helper symbol to concentrate the

   461

 *      instantiation of STRING and WSTRING into a single

   462

 *      location (elementary_string_type_name).

   463

 *      These two elements show up in several other rules,

   464

 *      but we want to create the equivalent abstract syntax

   465

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

   466

 *      possible future changes easier to edit...

   467

 */

   468

%type  <leaf>	elementary_type_name

   469

%type  <leaf>	numeric_type_name

   470

%type  <leaf>	integer_type_name

   471

%type  <leaf>	signed_integer_type_name

   472

%type  <leaf>	unsigned_integer_type_name

   473

%type  <leaf>	real_type_name

   474

%type  <leaf>	date_type_name

   475

%type  <leaf>	bit_string_type_name

   476

/* helper symbol to concentrate the instantiation

   477

 * of STRING and WSTRING into a single location

   478

 */

   479

%type  <leaf>	elementary_string_type_name

   480

   481

%token BYTE

   482

%token WORD

   483

%token DWORD

   484

%token LWORD

   485

   486

%token LREAL

   487

%token REAL

   488

   489

%token SINT

   490

%token INT

   491

%token DINT

   492

%token LINT

   493

   494

%token USINT

   495

%token UINT

   496

%token UDINT

   497

%token ULINT

   498

   499

%token WSTRING

   500

%token STRING

   501

%token BOOL

   502

   503

// %token TIME

   504

// %token DATE

   505

// %token DATE_AND_TIME

   506

%token DT

   507

// %token TIME_OF_DAY

   508

%token TOD

   509

   510

   511

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

   512

/* B 1.3.2 - Generic data types */

   513

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

   514

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

   515

// %type  <leaf>	generic_type_name

   516

   517

/* The following tokens do not seem to be used either

   518

 * but we declare them so they become reserved words...

   519

 */

   520

%token ANY