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

 * Declaration of the Abstract Syntax data structure components

    34

 */

    35

    36

/*

    37

 * ABSYNTAX.H

    38

 *

    39

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

    40

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

    41

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

    42

 * the relavent code.

    43

 */

    44

    45

#ifndef _ABSYNTAX_HH

    46

#define _ABSYNTAX_HH

    47

    48

    49

#include <stdio.h> // required for NULL

    50

#include <vector>

    51

#include <map>

    52

#include <string>

    53

#include <stdint.h>  // required for uint64_t, etc...

    54

#include "../main.hh" // required for uint8_t, real_64_t, ..., and the macros INT8_MAX, REAL32_MAX, ... */

    55

    56

    57

    58

    59

/* Forward declaration of the visitor interface

    60

 * declared in the visitor.hh file

    61

 * We cannot include the visitor.hh file, as it will

    62

 * include this same file first, as it too requires references

    63

 * to the abstract syntax classes defined here.

    64

 */

    65

class visitor_c; // forward declaration

    66

    67

    68

class symbol_c; // forward declaration

    69

    70

    71

    72

    73

    74

    75

    76

/* Case insensitive string compare */

    77

  /* Case insensitive string compare copied from

    78

   * "The C++ Programming Language" - 3rd Edition

    79

   * by Bjarne Stroustrup, ISBN 0201889544.

    80

   */

    81

class nocasecmp_c {

    82

    public:

    83

      bool operator() (const std::string& x, const std::string& y) const {

    84

        std::string::const_iterator ix = x.begin();

    85

        std::string::const_iterator iy = y.begin();

    86

    87

        for(; (ix != x.end()) && (iy != y.end()) && (toupper(*ix) == toupper(*iy)); ++ix, ++iy);

    88

        if (ix == x.end()) return (iy != y.end());

    89

        if (iy == y.end()) return false;

    90

        return (toupper(*ix) < toupper(*iy));

    91

      };

    92

  };

    93

    94

    95

    96

/*** constant folding ***/

    97

/* During stage 3 (semantic analysis/checking) we will be doing constant folding.

    98

 * That algorithm will anotate the abstract syntax tree with the result of operations

    99

 * on literals (i.e. 44 + 55 will store the result 99).

   100

 * Since the same source code (e.g. 1 + 0) may actually be a BOOL or an ANY_INT,

   101

 * or an ANY_BIT, we need to handle all possibilities, and determine the result of the

   102

 * operation assuming each type.

   103

 * For this reason, we have one entry for each possible type, with some expressions

   104

 * having more than one entry filled in!

   105

 */    

   106

class const_value_c {

   107

  public:

   108

    typedef enum { cs_undefined,   /* not defined/not yet evaluated --> const_value is not valid! */

   109

                   cs_non_const,   /* we have determined that expression is not a const value --> const_value is not valid! */

   110

                   cs_const_value, /* const value is valid */

   111

                   cs_overflow     /* result produced overflow or underflow --> const_value is not valid! */

   112

                 } const_status_t;

   113

   114

    template<typename value_type> class const_value__ {

   115

      const_status_t status;  

   116

      value_type     value;

   117

   118

      public:

   119

      const_value__(void): status(cs_undefined), value(0) {};

   120

   121

      value_type get(void)              {return value;}

   122

      void       set(value_type value_) {status = cs_const_value; value = value_;}

   123

      void       set_overflow(void)     {status = cs_overflow   ;}

   124

      void       set_nonconst(void)     {status = cs_non_const  ;}

   125

      bool       is_valid    (void)     {return (status == cs_const_value);}

   126

      bool       is_overflow (void)     {return (status == cs_overflow   );}

   127

      bool       is_nonconst (void)     {return (status == cs_non_const  );}

   128

      bool       is_undefined(void)     {return (status == cs_undefined  );}

   129

      bool       is_zero     (void)     {return (is_valid() && (get() == 0));}

   130

   131

      /* comparison operator */

   132

      bool operator==(const const_value__ cv) {

   133

        return (    ((status!=cs_const_value) && (status==cv.status)) 

   134

                 || ((status==cs_const_value) && (value ==cv.value )));

   135

      }

   136

   137

    };

   138

   139

    const_value__< int64_t>  _int64; /* status is initialised to UNDEFINED */

   140

    const_value__<uint64_t> _uint64; /* status is initialised to UNDEFINED */

   141

    const_value__<real64_t> _real64; /* status is initialised to UNDEFINED */

   142

    const_value__<bool    >   _bool; /* status is initialised to UNDEFINED */

   143

   144

    /* default constructor and destructor */

   145

     const_value_c(void) {};

   146

    ~const_value_c(void) {};

   147

   148

    /* comparison operator */

   149

    bool operator==(const const_value_c cv)

   150

      {return ((_int64==cv._int64) && (_uint64==cv._uint64) && (_real64==cv._real64) && (_bool==cv._bool));}                                                     

   151

   152

    /* return true if at least one of the const values (int, real, ...) is a valid const value */

   153

    bool is_const(void) 

   154

      {return (_int64.is_valid() || _uint64.is_valid() || _real64.is_valid() || _bool.is_valid());}   

   155

};

   156

   157

// A forward declaration

   158

class token_c;

   159

   160

/* The base class of all symbols */

   161

class symbol_c {

   162

   163

  public:

   164

    /* WARNING: only use this method for debugging purposes!! */

   165

    virtual const char *absyntax_cname(void) {return "symbol_c";};

   166

   167

    /*

   168

     * Annotations produced during stage 1_2

   169

     */    

   170

    /* Points to the parent symbol in the AST, i.e. the symbol in the AST that will contain the current symbol */

   171

    symbol_c *parent;

   172

    /* Some symbols may not be tokens, but may be clearly identified by a token.

   173

     * For e.g., a FUNCTION declaration is not itself a token, but may be clearly identified by the

   174

     * token_c object that contains it's name. Another example is an element in a STRUCT declaration,

   175

     * where the structure_element_declaration_c is not itself a token, but can be clearly identified

   176

     * by the structure_element_name

   177

     * To make it easier to find these tokens from the top level object, we will have the stage1_2 populate this

   178

     * token_c *token wherever it makes sense.

   179

     * NOTE: This was a late addition to the AST. Not all objects may be currently so populated.

   180

     *       If you need this please make sure the bison code is populating it correctly for your use case.

   181

     */

   182

    token_c  *token;

   183

   184

    /* Line number for the purposes of error checking.  */

   185

    int first_line;

   186

    int first_column;

   187

    const char *first_file;  /* filename referenced by first line/column */

   188

    long int first_order;    /* relative order in which it is read by lexcial analyser */

   189

    int last_line;

   190

    int last_column;

   191

    const char *last_file;  /* filename referenced by last line/column */

   192

    long int last_order;    /* relative order in which it is read by lexcial analyser */

   193

   194

   195

    /*

   196

     * Annotations produced during stage 3

   197

     */    

   198

    /*** Data type analysis ***/

   199

    std::vector <symbol_c *> candidate_datatypes; /* All possible data types the expression/literal/etc. may take. Filled in stage3 by fill_candidate_datatypes_c class */

   200

    /* Data type of the expression/literal/etc. Filled in stage3 by narrow_candidate_datatypes_c 

   201

     * If set to NULL, it means it has not yet been evaluated.

   202

     * If it points to an object of type invalid_type_name_c, it means it is invalid.

   203

     * Otherwise, it points to an object of the apropriate data type (e.g. int_type_name_c, bool_type_name_c, ...)

   204

     */

   205

    symbol_c *datatype;

   206

    /* The POU in which the symbolic variable (or structured variable, or array variable, or located variable, - any more?)

   207

     * was declared. This will point to a Configuration, Resource, Program, FB, or Function.

   208

     * This is set in stage 3 by the datatype analyser algorithm (fill/narrow) for the symbols:

   209

     *  symbolic_variable_c, array_variable_c, structured_variable_c

   210

     */

   211

    symbol_c *scope;    

   212

   213

    /*** constant folding ***/

   214

    /* If the symbol has a constant numerical value, this will be set to that value by constant_folding_c */

   215

    const_value_c const_value;

   216

   217

    /*** Enumeration datatype checking ***/    

   218

    /* Not all symbols will contain the following anotations, which is why they are not declared here in symbol_c

   219

     * They will be declared only inside the symbols that require them (have a look at absyntax.def)

   220

     */

   221

    typedef std::multimap<std::string, symbol_c *, nocasecmp_c> enumvalue_symtable_t;

   222

   223

    /*

   224

     * Annotations produced during stage 4

   225

     */

   226

    /* Since we support several distinct stage_4 implementations, having explicit entries for each

   227

     * possible use would quickly get out of hand.

   228

     * We therefore simply add a map, that each stage 4 may use for all its needs.

   229

     */

   230

    typedef std::map<std::string, symbol_c *> anotations_map_t;

   231

    anotations_map_t anotations_map;

   232

   233

   234

  public:

   235

    /* default constructor */

   236

    symbol_c(int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */

   237

             int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */

   238

            );

   239

   240

    /* default destructor */

   241

    /* must be virtual so compiler does not complain... */ 

   242

    virtual ~symbol_c(void) {return;};

   243

   244

    virtual void *accept(visitor_c &visitor) {return NULL;};

   245

};

   246

   247

   248

   249

   250

class token_c: public symbol_c {

   251

  public:

   252

    /* WARNING: only use this method for debugging purposes!! */

   253

    virtual const char *absyntax_cname(void) {return "token_c";};

   254

   255

    /* the value of the symbol. */

   256

    const char *value;

   257

   258

  public:

   259

    token_c(const char *value, 

   260

            int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */

   261

            int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */

   262

           );

   263

};

   264

   265

   266

   267

   268

 /* a list of symbols... */

   269

class list_c: public symbol_c {

   270

  public:

   271

    /* WARNING: only use this method for debugging purposes!! */

   272

    virtual const char *absyntax_cname(void) {return "list_c";};

   273

   274

    int c,n; /* c: current capacity of list (malloc'd memory);  n: current number of elements in list */

   275

  private:

   276

//     symbol_c **elements;

   277

    typedef struct {

   278

      const char *token_value;

   279

      symbol_c   *symbol;

   280

    } element_entry_t;

   281

    element_entry_t *elements;

   282

   283

   284

  public:

   285

    list_c(int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */

   286

           int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */

   287

          );

   288

   289

    list_c(symbol_c *elem, 

   290

           int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0, /* order in which it is read by lexcial analyser */

   291

           int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0  /* order in which it is read by lexcial analyser */

   292

          );

   293

     /* get element in position pos of the list */

   294

    virtual symbol_c *get_element(int pos);

   295

     /* find element associated to token value */

   296

    virtual symbol_c *find_element(symbol_c   *token);

   297

    virtual symbol_c *find_element(const char *token_value);

   298

     /* append a new element to the end of the list */

   299

    virtual void add_element(symbol_c *elem);

   300

    virtual void add_element(symbol_c *elem, symbol_c   *token);

   301

    virtual void add_element(symbol_c *elem, const char *token_value);

   302

     /* insert a new element before position pos. */

   303

     /* To insert into the begining of list, call with pos=0  */

   304

     /* To insert into the end of list, call with pos=list->n */

   305

    virtual void insert_element(symbol_c *elem, const char *token_value, int pos = 0);

   306

    virtual void insert_element(symbol_c *elem, symbol_c   *token,       int pos = 0);

   307

    virtual void insert_element(symbol_c *elem,                          int pos = 0);

   308

    //virtual void insert_element(symbol_c *elem, int pos, std::string map_ref);

   309

     /* remove element at position pos. */

   310

    virtual void remove_element(int pos = 0);

   311

     /* remove all elements from list. Does not delete the elements in the list! */ 

   312

    virtual void clear(void);

   313

};

   314

   315

   316

   317

   318

   319

   320

   321

   322

   323

#define SYM_LIST(class_name_c, ...)											\

   324

class class_name_c:	public list_c {											\

   325

  public:														\

   326

    __VA_ARGS__														\

   327

  public:														\

   328

    class_name_c(													\

   329

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   330

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   331

    class_name_c(symbol_c *elem, 											\

   332

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   333

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   334

    virtual void *accept(visitor_c &visitor);										\

   335

    /* WARNING: only use this method for debugging purposes!! */							\

   336

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   337

};

   338

   339

   340

#define SYM_TOKEN(class_name_c, ...)											\

   341

class class_name_c: 	public token_c {										\

   342

  public:														\

   343

    __VA_ARGS__														\

   344

  public:														\

   345

    class_name_c(const char *value, 											\

   346

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   347

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   348

    virtual void *accept(visitor_c &visitor);										\

   349

    /* WARNING: only use this method for debugging purposes!! */							\

   350

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   351

};

   352

   353

   354

#define SYM_REF0(class_name_c, ...)											\

   355

class class_name_c: public symbol_c {											\

   356

  public:														\

   357

    __VA_ARGS__														\

   358

  public:														\

   359

    class_name_c(		 											\

   360

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   361

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   362

    virtual void *accept(visitor_c &visitor);										\

   363

    /* WARNING: only use this method for debugging purposes!! */							\

   364

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   365

};

   366

   367

   368

#define SYM_REF1(class_name_c, ref1, ...)										\

   369

class class_name_c: public symbol_c {											\

   370

  public:														\

   371

    symbol_c *ref1;													\

   372

    __VA_ARGS__														\

   373

  public:														\

   374

    class_name_c(symbol_c *ref1 = NULL,											\

   375

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   376

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   377

    virtual void *accept(visitor_c &visitor);										\

   378

    /* WARNING: only use this method for debugging purposes!! */							\

   379

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   380

};

   381

   382

   383

#define SYM_REF2(class_name_c, ref1, ref2, ...)										\

   384

class class_name_c: public symbol_c {											\

   385

  public:														\

   386

    symbol_c *ref1;													\

   387

    symbol_c *ref2;													\

   388

    __VA_ARGS__														\

   389

  public:														\

   390

    class_name_c(symbol_c *ref1 = NULL,											\

   391

		 symbol_c *ref2 = NULL,											\

   392

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   393

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   394

    virtual void *accept(visitor_c &visitor);										\

   395

    /* WARNING: only use this method for debugging purposes!! */							\

   396

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   397

};

   398

   399

   400

#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)									\

   401

class class_name_c: public symbol_c {											\

   402

  public:														\

   403

    symbol_c *ref1;													\

   404

    symbol_c *ref2;													\

   405

    symbol_c *ref3;													\

   406

    __VA_ARGS__														\

   407

  public:														\

   408

    class_name_c(symbol_c *ref1 = NULL,											\

   409

		 symbol_c *ref2 = NULL,											\

   410

		 symbol_c *ref3 = NULL,											\

   411

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   412

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   413

    virtual void *accept(visitor_c &visitor);										\

   414

    /* WARNING: only use this method for debugging purposes!! */							\

   415

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   416

};

   417

   418

   419

#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)								\

   420

class class_name_c: public symbol_c {											\

   421

  public:														\

   422

    symbol_c *ref1;													\

   423

    symbol_c *ref2;													\

   424

    symbol_c *ref3;													\

   425

    symbol_c *ref4;													\

   426

    __VA_ARGS__														\

   427

  public:														\

   428

    class_name_c(symbol_c *ref1 = NULL,											\

   429

		 symbol_c *ref2 = NULL,											\

   430

		 symbol_c *ref3 = NULL,											\

   431

		 symbol_c *ref4 = NULL,											\

   432

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   433

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   434

    virtual void *accept(visitor_c &visitor);										\

   435

    /* WARNING: only use this method for debugging purposes!! */							\

   436

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   437

};

   438

   439

   440

#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)							\

   441

class class_name_c: public symbol_c {											\

   442

  public:														\

   443

    symbol_c *ref1;													\

   444

    symbol_c *ref2;													\

   445

    symbol_c *ref3;													\

   446

    symbol_c *ref4;													\

   447

    symbol_c *ref5;													\

   448

    __VA_ARGS__														\

   449

  public:														\

   450

    class_name_c(symbol_c *ref1 = NULL,											\

   451

		 symbol_c *ref2 = NULL,											\

   452

		 symbol_c *ref3 = NULL,											\

   453

		 symbol_c *ref4 = NULL,											\

   454

		 symbol_c *ref5 = NULL,											\

   455

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   456

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   457

    virtual void *accept(visitor_c &visitor);										\

   458

    /* WARNING: only use this method for debugging purposes!! */							\

   459

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   460

};

   461

   462

   463

#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)							\

   464

class class_name_c: public symbol_c {											\

   465

  public:														\

   466

    symbol_c *ref1;													\

   467

    symbol_c *ref2;													\

   468

    symbol_c *ref3;													\

   469

    symbol_c *ref4;													\

   470

    symbol_c *ref5;													\

   471

    symbol_c *ref6;													\

   472

    __VA_ARGS__														\

   473

  public:														\

   474

    class_name_c(symbol_c *ref1 = NULL,											\

   475

		 symbol_c *ref2 = NULL,											\

   476

		 symbol_c *ref3 = NULL,											\

   477

		 symbol_c *ref4 = NULL,											\

   478

		 symbol_c *ref5 = NULL,											\

   479

		 symbol_c *ref6 = NULL,											\

   480

                 int fl = 0, int fc = 0, const char *ffile = NULL /* filename */, long int forder=0,			\

   481

                 int ll = 0, int lc = 0, const char *lfile = NULL /* filename */, long int lorder=0);			\

   482

    virtual void *accept(visitor_c &visitor);										\

   483

    /* WARNING: only use this method for debugging purposes!! */							\

   484

    virtual const char *absyntax_cname(void) {return #class_name_c;};							\

   485

};

   486

   487

   488

#include "absyntax.def"

   489

   490

   491

   492