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 <string>

    52

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

    53

    54

    55

/* Determine, for the current platform, which data type (float, double or long double) uses 64 bits. */

    56

/* NOTE: We cant use sizeof() in pre-processor directives, so we have to do it another way... */

    57

/* CURIOSITY: We can use sizeof() and offsetof() inside static_assert() but:

    58

 *          - this only allows us to make assertions, and not #define new macros

    59

 *          - is only available in the C standard [ISO/IEC 9899:2011] and the C++ 0X draft standard [Becker 2008]. It is not available in C99.

    60

 *          https://www.securecoding.cert.org/confluence/display/seccode/DCL03-C.+Use+a+static+assertion+to+test+the+value+of+a+constant+expression

    61

 *         struct {int a, b, c, d} header_t;

    62

 *  e.g.:  static_assert(offsetof(struct header_t, c) == 8, "Compile time error message.");

    63

 */

    64

    65

#include <float.h>

    66

#if    (LDBL_MANT_DIG == 53) /* NOTE: 64 bit IEC559 real has 53 bits for mantissa! */

    67

  #define long_double long double

    68

  #define real64_t long_double /* so we can later use #if (real64_t == long_double) directives in the code! */

    69

#elif  ( DBL_MANT_DIG == 53) /* NOTE: 64 bit IEC559 real has 53 bits for mantissa! */

    70

  #define real64_t double

    71

#elif  ( FLT_MANT_DIG == 53) /* NOTE: 64 bit IEC559 real has 53 bits for mantissa! */

    72

  #define real64_t float

    73

#else 

    74

  #error Could not find a 64 bit floating point data type on this platform. Aborting...

    75

#endif

    76

    77

    78

/* Forward declaration of the visitor interface

    79

 * declared in the visitor.hh file

    80

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

    81

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

    82

 * to the abstract syntax classes defined here.

    83

 */

    84

class visitor_c; // forward declaration

    85

    86

    87

class symbol_c; // forward declaration

    88

    89

    90

    91

    92

    93

    94

    95

    96

    97

    98

    99

/* The base class of all symbols */

   100

class symbol_c {

   101

   102

  public:

   103

    /*

   104

     * Line number for the purposes of error checking.

   105

     * Annotated (inserted) by stage1_2

   106

     */

   107

    int first_line;

   108

    int first_column;

   109

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

   110

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

   111

    int last_line;

   112

    int last_column;

   113

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

   114

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

   115

   116

   117

    /*

   118

     * Annotations produced during stage 3

   119

     */

   120

    /*** Data type analysis ***/

   121

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

   122

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

   123

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

   124

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

   125

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

   126

     */

   127

    symbol_c *datatype;

   128

   129

    /*** constant folding ***/

   130

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

   131

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

   132

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

   133

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

   134

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

   135

     * operation assuming each type.

   136

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

   137

     * having more than one entry filled in!

   138

     */

   139

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

   140

                   cs_const_value, /* const value is valid */

   141

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

   142

                 } const_status_t;

   143

   144

    typedef struct {

   145

        const_status_t status;

   146

        real64_t       value; 

   147

    } const_value_real64_t;

   148

    const_value_real64_t *const_value_real64; /* when NULL --> UNDEFINED */

   149

   150

    typedef struct {

   151

        const_status_t status;

   152

        int64_t        value; 

   153

    } const_value_int64_t;

   154

    const_value_int64_t *const_value_int64; /* when NULL --> UNDEFINED */

   155

   156

    typedef struct {

   157

        const_status_t status;

   158

        uint64_t       value; 

   159

    } const_value_uint64_t;

   160

    const_value_uint64_t *const_value_uint64; /* when NULL --> UNDEFINED */

   161

   162

    typedef struct {

   163

        const_status_t status;

   164

        bool           value; 

   165

    } const_value_bool_t;

   166

    const_value_bool_t *const_value_bool; /* when NULL --> UNDEFINED */

   167

   168

   169

  public:

   170

    /* default constructor */

   171

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

   172

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

   173

            );

   174

   175

    /* default destructor */

   176

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

   177

    virtual ~symbol_c(void) {return;};

   178

   179

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

   180

};

   181

   182

   183

class token_c: public symbol_c {

   184

  public:

   185

    /* the value of the symbol. */

   186

    const char *value;

   187

   188

  public:

   189

    token_c(const char *value, 

   190

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

   191

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

   192

           );

   193

};

   194

   195

   196

 /* a list of symbols... */

   197

class list_c: public symbol_c {

   198

  public:

   199

    int n;

   200

    symbol_c **elements;

   201

   202

  public:

   203

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

   204

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

   205

          );

   206

   207

    list_c(symbol_c *elem, 

   208

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

   209

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

   210

          );

   211

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

   212

    virtual void add_element(symbol_c *elem);

   213

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

   214

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

   215

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

   216

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

   217

     /* remove element at position pos. */

   218

    virtual void remove_element(int pos = 0);

   219

};

   220

   221

   222

   223

   224

#define SYM_LIST(class_name_c, ...)											\

   225

class class_name_c:	public list_c {											\

   226

  public:														\

   227

    __VA_ARGS__														\

   228

  public:														\

   229

    class_name_c(													\

   230

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

   231

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

   232

    class_name_c(symbol_c *elem, 											\

   233

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

   234

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

   235

    virtual void *accept(visitor_c &visitor);										\

   236

};

   237

   238

   239

#define SYM_TOKEN(class_name_c, ...)											\

   240

class class_name_c: 	public token_c {										\

   241

  public:														\

   242

    __VA_ARGS__														\

   243

  public:														\

   244

    class_name_c(const char *value, 											\

   245

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

   246

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

   247

    virtual void *accept(visitor_c &visitor);										\

   248

};

   249

   250

   251

#define SYM_REF0(class_name_c, ...)											\

   252

class class_name_c: public symbol_c {											\

   253

  public:														\

   254

    __VA_ARGS__														\

   255

  public:														\

   256

    class_name_c(		 											\

   257

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

   258

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

   259

    virtual void *accept(visitor_c &visitor);										\

   260

};

   261

   262

   263

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

   264

class class_name_c: public symbol_c {											\

   265

  public:														\

   266

    symbol_c *ref1;													\

   267

    __VA_ARGS__														\

   268

  public:														\

   269

    class_name_c(symbol_c *ref1,											\

   270

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

   271

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

   272

    virtual void *accept(visitor_c &visitor);										\

   273

};

   274

   275

   276

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

   277

class class_name_c: public symbol_c {											\

   278

  public:														\

   279

    symbol_c *ref1;													\

   280

    symbol_c *ref2;													\

   281

    __VA_ARGS__														\

   282

  public:														\

   283

    class_name_c(symbol_c *ref1,											\

   284

		 symbol_c *ref2 = NULL,											\

   285

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

   286

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

   287

    virtual void *accept(visitor_c &visitor);										\

   288

};

   289

   290

   291

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

   292

class class_name_c: public symbol_c {											\

   293

  public:														\

   294

    symbol_c *ref1;													\

   295

    symbol_c *ref2;													\

   296

    symbol_c *ref3;													\

   297

    __VA_ARGS__														\

   298

  public:														\

   299

    class_name_c(symbol_c *ref1,											\

   300

		 symbol_c *ref2,											\

   301

		 symbol_c *ref3,											\

   302

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

   303

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

   304

    virtual void *accept(visitor_c &visitor);										\

   305

};

   306

   307

   308

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

   309

class class_name_c: public symbol_c {											\

   310

  public:														\

   311

    symbol_c *ref1;													\

   312

    symbol_c *ref2;													\

   313

    symbol_c *ref3;													\

   314

    symbol_c *ref4;													\

   315

    __VA_ARGS__														\

   316

  public:														\

   317

    class_name_c(symbol_c *ref1,											\

   318

		 symbol_c *ref2,											\

   319

		 symbol_c *ref3,											\

   320

		 symbol_c *ref4 = NULL,											\

   321

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

   322

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

   323

    virtual void *accept(visitor_c &visitor);										\

   324

};

   325

   326

   327

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

   328

class class_name_c: public symbol_c {											\

   329

  public:														\

   330

    symbol_c *ref1;													\

   331

    symbol_c *ref2;													\

   332

    symbol_c *ref3;													\

   333

    symbol_c *ref4;													\

   334

    symbol_c *ref5;													\

   335

    __VA_ARGS__														\

   336

  public:														\

   337

    class_name_c(symbol_c *ref1,											\

   338

		 symbol_c *ref2,											\

   339

		 symbol_c *ref3,											\

   340

		 symbol_c *ref4,											\

   341

		 symbol_c *ref5,											\

   342

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

   343

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

   344

    virtual void *accept(visitor_c &visitor);										\

   345

};

   346

   347

   348

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

   349

class class_name_c: public symbol_c {											\

   350

  public:														\

   351

    symbol_c *ref1;													\

   352

    symbol_c *ref2;													\

   353

    symbol_c *ref3;													\

   354

    symbol_c *ref4;													\

   355

    symbol_c *ref5;													\

   356

    symbol_c *ref6;													\

   357

    __VA_ARGS__														\

   358

  public:														\

   359

    class_name_c(symbol_c *ref1,											\

   360

		 symbol_c *ref2,											\

   361

		 symbol_c *ref3,											\

   362

		 symbol_c *ref4,											\

   363

		 symbol_c *ref5,											\

   364

		 symbol_c *ref6 = NULL,											\

   365

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

   366

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

   367

    virtual void *accept(visitor_c &visitor);										\

   368

};

   369

   370

   371

#include "absyntax.def"

   372

   373

   374

   375

#undef SYM_LIST

   376

#undef SYM_TOKEN

   377

#undef SYM_REF0

   378

#undef SYM_REF1

   379

#undef SYM_REF2

   380

#undef SYM_REF3

   381

#undef SYM_REF4

   382

#undef SYM_REF5

   383

#undef SYM_REF6

   384

   385

#endif /*  _ABSYNTAX_HH */