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

 * Definition of the Abstract Syntax data structure components

    34

 */

    35

    36

#include <stdio.h>

    37

#include <stdlib.h>	/* required for exit() */

    38

#include <string.h>

    39

    40

#include "absyntax.hh"

    41

//#include "../stage1_2/iec.hh" /* required for BOGUS_TOKEN_ID, etc... */

    42

#include "visitor.hh"

    43

#include "../main.hh" // required for ERROR() and ERROR_MSG() macros.

    44

    45

    46

    47

/* The base class of all symbols */

    48

symbol_c::symbol_c(

    49

                   int first_line, int first_column, const char *ffile, long int first_order,

    50

                   int last_line,  int last_column,  const char *lfile, long int last_order ) {

    51

  this->first_file   = ffile,

    52

  this->first_line   = first_line;

    53

  this->first_column = first_column;

    54

  this->first_order  = first_order;

    55

  this->last_file    = lfile,

    56

  this->last_line    = last_line;

    57

  this->last_column  = last_column;

    58

  this->last_order   = last_order;

    59

  this->parent       = NULL;

    60

  this->datatype     = NULL;

    61

  this->scope        = NULL;

    62

  this->const_value._real64.status   = cs_undefined;

    63

  this->const_value._int64.status    = cs_undefined;

    64

  this->const_value._uint64.status   = cs_undefined;

    65

  this->const_value._bool.status     = cs_undefined;

    66

}

    67

    68

    69

    70

token_c::token_c(const char *value, 

    71

                 int fl, int fc, const char *ffile, long int forder,

    72

                 int ll, int lc, const char *lfile, long int lorder)

    73

  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {

    74

  this->value = value;

    75

//  printf("New token: %s\n", value);

    76

}

    77

    78

    79

    80

    81

# define LIST_CAP_INIT 8

    82

# define LIST_CAP_INCR 8

    83

    84

list_c::list_c(

    85

               int fl, int fc, const char *ffile, long int forder,

    86

               int ll, int lc, const char *lfile, long int lorder)

    87

  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder),c(LIST_CAP_INIT) {

    88

  n = 0;

    89

  elements = (symbol_c**)malloc(LIST_CAP_INIT*sizeof(symbol_c*));

    90

  if (NULL == elements) ERROR_MSG("out of memory");

    91

}

    92

    93

    94

list_c::list_c(symbol_c *elem, 

    95

               int fl, int fc, const char *ffile, long int forder,

    96

               int ll, int lc, const char *lfile, long int lorder)

    97

  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder),c(LIST_CAP_INIT) { 

    98

  n = 0;

    99

  elements = (symbol_c**)malloc(LIST_CAP_INIT*sizeof(symbol_c*));

   100

  if (NULL == elements) ERROR_MSG("out of memory");

   101

  add_element(elem); 

   102

}

   103

   104

   105

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

   106

void list_c::add_element(symbol_c *elem) {

   107

  // printf("list_c::add_element()\n");

   108

  if (c <= n)

   109

    if (!(elements=(symbol_c**)realloc(elements,(c+=LIST_CAP_INCR)*sizeof(symbol_c *))))

   110

      ERROR_MSG("out of memory");

   111

  elements[n++] = elem;

   112

   113

  if (NULL == elem) return;

   114

  /* Sometimes add_element() is called in stage3 or stage4 to temporarily add an AST symbol to the list.

   115

   * Since this symbol already belongs in some other place in the aST, it will have the 'parent' pointer set, 

   116

   * and so we must not overwrite it. We only set the 'parent' pointer on new symbols that have the 'parent'

   117

   * pointer still set to NULL.

   118

   */

   119

  if (NULL == elem->parent) elem->parent = this;  

   120

   121

  /* adjust the location parameters, taking into account the new element. */

   122

  if (NULL == first_file) {

   123

    first_file = elem->first_file;

   124

    first_line = elem->first_line;

   125

    first_column = elem->first_column;

   126

  }

   127

  if ((first_line == elem->first_line) && (first_column > elem->first_column)) {

   128

    first_column = elem->first_column;

   129

  }

   130

  if (first_line > elem->first_line) {

   131

    first_line = elem->first_line;

   132

    first_column = elem->first_column;

   133

  }

   134

  if (NULL == last_file) {

   135

    last_file = elem->last_file;

   136

    last_line = elem->last_line;

   137

    last_column = elem->last_column;

   138

  }

   139

  if ((last_line == elem->last_line) &&

   140

      (last_column < elem->last_column)) {

   141

    last_column = elem->last_column;

   142

  }

   143

  if (last_line < elem->last_line) {

   144

    last_line = elem->last_line;

   145

    last_column = elem->last_column;

   146

  }

   147

}

   148

   149

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

   150

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

   151

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

   152

void list_c::insert_element(symbol_c *elem, int pos) {

   153

  if((pos<0) || (n<pos)) ERROR;

   154

   155

  /* add new element to end of list. Basically alocate required memory... */

   156

  /* will also increment n by 1 ! */

   157

  add_element(elem);

   158

  /* if not inserting into end position, shift all elements up one position, to open up a slot in pos for new element */

   159

  if(pos < (n-1)){ 

   160

    for(int i=n-2 ; i>=pos ; --i) elements[i+1] = elements[i];

   161

    elements[pos] = elem;

   162

  }

   163

}

   164

   165

   166

/* remove element at position pos. */

   167

void list_c::remove_element(int pos) {

   168

  if((pos<0) || (n<=pos)) ERROR;

   169

   170

  /* Shift all elements down one position, starting at the entry to delete. */

   171

  for (int i = pos; i < n-1; i++) elements[i] = elements[i+1];

   172

  /* corrent the new size */

   173

  n--;

   174

  /* elements = (symbol_c **)realloc(elements, n * sizeof(symbol_c *)); */

   175

  /* TODO: adjust the location parameters, taking into account the removed element. */

   176

}

   177

   178

   179

/* remove element at position pos. */

   180

void list_c::clear(void) {

   181

  n = 0;

   182

  /* TODO: adjust the location parameters, taking into account the removed element. */

   183

}

   184

   185

   186

#define SYM_LIST(class_name_c, ...)								\

   187

class_name_c::class_name_c(									\

   188

                           int fl, int fc, const char *ffile, long int forder,			\

   189

                           int ll, int lc, const char *lfile, long int lorder)			\

   190

                        :list_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {}		\

   191

class_name_c::class_name_c(symbol_c *elem, 							\

   192

                           int fl, int fc, const char *ffile, long int forder,			\

   193

                           int ll, int lc, const char *lfile, long int lorder)			\

   194

			:list_c(elem, fl, fc, ffile, forder, ll, lc, lfile, lorder) {}		\

   195

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   196

   197

#define SYM_TOKEN(class_name_c, ...)								\

   198

class_name_c::class_name_c(const char *value, 							\

   199

                           int fl, int fc, const char *ffile, long int forder,			\

   200

                           int ll, int lc, const char *lfile, long int lorder)			\

   201

			:token_c(value, fl, fc, ffile, forder, ll, lc, lfile, lorder) {}	\

   202

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   203

   204

#define SYM_REF0(class_name_c, ...)								\

   205

class_name_c::class_name_c(									\

   206

                           int fl, int fc, const char *ffile, long int forder,			\

   207

                           int ll, int lc, const char *lfile, long int lorder)			\

   208

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {}		\

   209

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   210

   211

   212

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

   213

class_name_c::class_name_c(symbol_c *ref1,							\

   214

                           int fl, int fc, const char *ffile, long int forder,			\

   215

                           int ll, int lc, const char *lfile, long int lorder)			\

   216

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   217

  this->ref1 = ref1;										\

   218

  if  (NULL != ref1)   ref1->parent = this;							\

   219

}												\

   220

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   221

   222

   223

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

   224

class_name_c::class_name_c(symbol_c *ref1,							\

   225

			   symbol_c *ref2,							\

   226

                           int fl, int fc, const char *ffile, long int forder,			\

   227

                           int ll, int lc, const char *lfile, long int lorder)			\

   228

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   229

  this->ref1 = ref1;										\

   230

  this->ref2 = ref2;										\

   231

  if  (NULL != ref1)   ref1->parent = this;							\

   232

  if  (NULL != ref2)   ref2->parent = this;										\

   233

}												\

   234

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   235

   236

   237

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

   238

class_name_c::class_name_c(symbol_c *ref1,							\

   239

			   symbol_c *ref2,							\

   240

			   symbol_c *ref3,							\

   241

                           int fl, int fc, const char *ffile, long int forder,			\

   242

                           int ll, int lc, const char *lfile, long int lorder)			\

   243

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   244

  this->ref1 = ref1;										\

   245

  this->ref2 = ref2;										\

   246

  this->ref3 = ref3;										\

   247

  if  (NULL != ref1)   ref1->parent = this;							\

   248

  if  (NULL != ref2)   ref2->parent = this;							\

   249

  if  (NULL != ref3)   ref3->parent = this;							\

   250

}												\

   251

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   252

   253

   254

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

   255

class_name_c::class_name_c(symbol_c *ref1,							\

   256

			   symbol_c *ref2,							\

   257

			   symbol_c *ref3,							\

   258

			   symbol_c *ref4,							\

   259

                           int fl, int fc, const char *ffile, long int forder,			\

   260

                           int ll, int lc, const char *lfile, long int lorder)			\

   261

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   262

  this->ref1 = ref1;										\

   263

  this->ref2 = ref2;										\

   264

  this->ref3 = ref3;										\

   265

  this->ref4 = ref4;										\

   266

  if  (NULL != ref1)   ref1->parent = this;							\

   267

  if  (NULL != ref2)   ref2->parent = this;							\

   268

  if  (NULL != ref3)   ref3->parent = this;							\

   269

  if  (NULL != ref4)   ref4->parent = this;							\

   270

}												\

   271

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   272

   273

   274

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

   275

class_name_c::class_name_c(symbol_c *ref1,							\

   276

			   symbol_c *ref2,							\

   277

			   symbol_c *ref3,							\

   278

			   symbol_c *ref4,							\

   279

			   symbol_c *ref5,							\

   280

                           int fl, int fc, const char *ffile, long int forder,			\

   281

                           int ll, int lc, const char *lfile, long int lorder)			\

   282

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   283

  this->ref1 = ref1;										\

   284

  this->ref2 = ref2;										\

   285

  this->ref3 = ref3;										\

   286

  this->ref4 = ref4;										\

   287

  this->ref5 = ref5;										\

   288

  if  (NULL != ref1)   ref1->parent = this;							\

   289

  if  (NULL != ref2)   ref2->parent = this;							\

   290

  if  (NULL != ref3)   ref3->parent = this;							\

   291

  if  (NULL != ref4)   ref4->parent = this;							\

   292

  if  (NULL != ref5)   ref5->parent = this;							\

   293

}												\

   294

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   295

   296

   297

   298

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

   299

class_name_c::class_name_c(symbol_c *ref1,							\

   300

			   symbol_c *ref2,							\

   301

			   symbol_c *ref3,							\

   302

			   symbol_c *ref4,							\

   303

			   symbol_c *ref5,							\

   304

			   symbol_c *ref6,							\

   305

                           int fl, int fc, const char *ffile, long int forder,			\

   306

                           int ll, int lc, const char *lfile, long int lorder)			\

   307

			  :symbol_c(fl, fc, ffile, forder, ll, lc, lfile, lorder) {		\

   308

  this->ref1 = ref1;										\

   309

  this->ref2 = ref2;										\

   310

  this->ref3 = ref3;										\

   311

  this->ref4 = ref4;										\

   312

  this->ref5 = ref5;										\

   313

  this->ref6 = ref6;										\

   314

  if  (NULL != ref1)   ref1->parent = this;							\

   315

  if  (NULL != ref2)   ref2->parent = this;							\

   316

  if  (NULL != ref3)   ref3->parent = this;							\

   317

  if  (NULL != ref4)   ref4->parent = this;							\

   318

  if  (NULL != ref5)   ref5->parent = this;							\

   319

  if  (NULL != ref6)   ref6->parent = this;							\

   320

}												\

   321

void *class_name_c::accept(visitor_c &visitor) {return visitor.visit(this);}

   322

   323

   324

   325

#include "absyntax.def"

   326

   327

   328

   329

   330

#undef SYM_LIST

   331

#undef SYM_TOKEN

   332

#undef SYM_TOKEN

   333

#undef SYM_REF0

   334

#undef SYM_REF1

   335

#undef SYM_REF2

   336

#undef SYM_REF3

   337

#undef SYM_REF4

   338

#undef SYM_REF5

   339

#undef SYM_REF6

   340

   341

   342

   343

   344