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

    97

    98

    99

   100

   101

   102

/* The base class of all symbols */

   103

class symbol_c {

   104

   105

  public:

   106

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

   107

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

   108

   109

    /*

   110

     * Line number for the purposes of error checking.

   111

     * Annotated (inserted) by stage1_2

   112

     */

   113

    int first_line;

   114

    int first_column;

   115

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

   116

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

   117

    int last_line;

   118

    int last_column;

   119

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

   120

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

   121

   122

   123

    /*

   124

     * Annotations produced during stage 3

   125

     */    

   126

    /*** Data type analysis ***/

   127

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

   128

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

   129

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

   130

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

   131

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

   132

     */

   133

    symbol_c *datatype;

   134

   135

    /*** constant folding ***/

   136

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

   137

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

   138

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

   139

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

   140

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

   141

     * operation assuming each type.

   142

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

   143

     * having more than one entry filled in!

   144

     */

   145

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

   146

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

   147

                   cs_const_value, /* const value is valid */

   148

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

   149

                 } const_status_t;

   150

   151

    typedef struct const_value_real64_s {const_status_t status;  real64_t  value;  const_value_real64_s (): status(cs_undefined), value(0.0)   {} } const_value_real64_t;

   152

    typedef struct const_value_int64_s  {const_status_t status;   int64_t  value;  const_value_int64_s  (): status(cs_undefined), value(0)     {} } const_value_int64_t;

   153

    typedef struct const_value_uint64_s {const_status_t status;  uint64_t  value;  const_value_uint64_s (): status(cs_undefined), value(0)     {} } const_value_uint64_t;

   154

    typedef struct const_value_bool_s   {const_status_t status;      bool  value;  const_value_bool_s   (): status(cs_undefined), value(false) {} } const_value_bool_t;

   155

   156

    typedef struct {

   157

      const_value_real64_t _real64; /* status is initialised to UNDEFINED */

   158

      const_value_int64_t   _int64; /* status is initialised to UNDEFINED */

   159

      const_value_uint64_t _uint64; /* status is initialised to UNDEFINED */

   160

      const_value_bool_t     _bool; /* status is initialised to UNDEFINED */

   161

    } const_value_t;

   162

    const_value_t const_value;

   163

   164

    /*** Enumeration datatype checking ***/    

   165

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

   166

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

   167

     */

   168

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

   169

   170

   171

  public:

   172

    /* default constructor */

   173

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

   174

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

   175

            );

   176

   177

    /* default destructor */

   178

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

   179

    virtual ~symbol_c(void) {return;};

   180

   181

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

   182

};

   183

   184

   185

   186

   187

class token_c: public symbol_c {

   188

  public:

   189

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

   190

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

   191

   192

    /* the value of the symbol. */

   193

    const char *value;

   194

   195

  public:

   196

    token_c(const char *value, 

   197

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

   198

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

   199

           );

   200

};

   201

   202

   203

   204

   205

 /* a list of symbols... */

   206

class list_c: public symbol_c {

   207

  public:

   208

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

   209

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

   210

   211

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

   212

    symbol_c **elements;

   213

   214

  public:

   215

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

   216

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

   217

          );

   218

   219

    list_c(symbol_c *elem, 

   220

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

   221

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

   222

          );

   223

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

   224

    virtual void add_element(symbol_c *elem);

   225

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

   226

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

   227

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

   228

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

   229

     /* remove element at position pos. */

   230

    virtual void remove_element(int pos = 0);

   231

};

   232

   233

   234

   235

   236

   237

   238

   239

   240

   241

#define SYM_LIST(class_name_c, ...)											\

   242

class class_name_c:	public list_c {											\

   243

  public:														\

   244

    __VA_ARGS__														\

   245

  public:														\

   246

    class_name_c(													\

   247

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

   248

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

   249

    class_name_c(symbol_c *elem, 											\

   250

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

   251

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

   252

    virtual void *accept(visitor_c &visitor);										\

   253

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

   254

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

   255

};

   256

   257

   258

#define SYM_TOKEN(class_name_c, ...)											\

   259

class class_name_c: 	public token_c {										\

   260

  public:														\

   261

    __VA_ARGS__														\

   262

  public:														\

   263

    class_name_c(const char *value, 											\

   264

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

   265

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

   266

    virtual void *accept(visitor_c &visitor);										\

   267

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

   268

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

   269

};

   270

   271

   272

#define SYM_REF0(class_name_c, ...)											\

   273

class class_name_c: public symbol_c {											\

   274

  public:														\

   275

    __VA_ARGS__														\

   276

  public:														\

   277

    class_name_c(		 											\

   278

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

   279

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

   280

    virtual void *accept(visitor_c &visitor);										\

   281

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

   282

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

   283

};

   284

   285

   286

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

   287

class class_name_c: public symbol_c {											\

   288

  public:														\

   289

    symbol_c *ref1;													\

   290

    __VA_ARGS__														\

   291

  public:														\

   292

    class_name_c(symbol_c *ref1,											\

   293

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

   294

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

   295

    virtual void *accept(visitor_c &visitor);										\

   296

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

   297

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

   298

};

   299

   300

   301

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

   302

class class_name_c: public symbol_c {											\

   303

  public:														\

   304

    symbol_c *ref1;													\

   305

    symbol_c *ref2;													\

   306

    __VA_ARGS__														\

   307

  public:														\

   308

    class_name_c(symbol_c *ref1,											\

   309

		 symbol_c *ref2 = NULL,											\

   310

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

   311

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

   312

    virtual void *accept(visitor_c &visitor);										\

   313

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

   314

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

   315

};

   316

   317

   318

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

   319

class class_name_c: public symbol_c {											\

   320

  public:														\

   321

    symbol_c *ref1;													\

   322

    symbol_c *ref2;													\

   323

    symbol_c *ref3;													\

   324

    __VA_ARGS__														\

   325

  public:														\

   326

    class_name_c(symbol_c *ref1,											\

   327

		 symbol_c *ref2,											\

   328

		 symbol_c *ref3,											\

   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

    virtual void *accept(visitor_c &visitor);										\

   332

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

   333

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

   334

};

   335

   336

   337

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

   338

class class_name_c: public symbol_c {											\

   339

  public:														\

   340

    symbol_c *ref1;													\

   341

    symbol_c *ref2;													\

   342

    symbol_c *ref3;													\

   343

    symbol_c *ref4;													\

   344

    __VA_ARGS__														\

   345

  public:														\

   346

    class_name_c(symbol_c *ref1,											\

   347

		 symbol_c *ref2,											\

   348

		 symbol_c *ref3,											\

   349

		 symbol_c *ref4 = NULL,											\

   350

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

   351

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

   352

    virtual void *accept(visitor_c &visitor);										\

   353

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

   354

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

   355

};

   356

   357

   358

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

   359

class class_name_c: public symbol_c {											\

   360

  public:														\

   361

    symbol_c *ref1;													\

   362

    symbol_c *ref2;													\

   363

    symbol_c *ref3;													\

   364

    symbol_c *ref4;													\

   365

    symbol_c *ref5;													\

   366

    __VA_ARGS__														\

   367

  public:														\

   368

    class_name_c(symbol_c *ref1,											\

   369

		 symbol_c *ref2,											\

   370

		 symbol_c *ref3,											\

   371

		 symbol_c *ref4,											\

   372

		 symbol_c *ref5,											\

   373

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

   374

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

   375

    virtual void *accept(visitor_c &visitor);										\

   376

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

   377

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

   378

};

   379

   380

   381

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

   382

class class_name_c: public symbol_c {											\

   383

  public:														\

   384

    symbol_c *ref1;													\

   385

    symbol_c *ref2;													\

   386

    symbol_c *ref3;													\

   387

    symbol_c *ref4;													\

   388

    symbol_c *ref5;													\

   389

    symbol_c *ref6;													\

   390

    __VA_ARGS__														\

   391

  public:														\

   392

    class_name_c(symbol_c *ref1,											\

   393

		 symbol_c *ref2,											\

   394

		 symbol_c *ref3,											\

   395

		 symbol_c *ref4,											\

   396

		 symbol_c *ref5,											\

   397

		 symbol_c *ref6 = NULL,											\

   398

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

   399

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

   400

    virtual void *accept(visitor_c &visitor);										\

   401

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

   402

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

   403

};

   404

   405

   406

#include "absyntax.def"

   407

   408

   409

   410

#undef SYM_LIST

   411

#undef SYM_TOKEN

   412

#undef SYM_REF0

   413

#undef SYM_REF1

   414

#undef SYM_REF2

   415

#undef SYM_REF3

   416

#undef SYM_REF4

   417

#undef SYM_REF5

   418

#undef SYM_REF6

   419

   420

#endif /*  _ABSYNTAX_HH */