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

    48

/* The base class of all symbols */

    49

symbol_c::symbol_c(

    50

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

    51

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

    52

  this->first_file   = ffile,

    53

  this->first_line   = first_line;

    54

  this->first_column = first_column;

    55

  this->first_order  = first_order;

    56

  this->last_file    = lfile,

    57

  this->last_line    = last_line;

    58

  this->last_column  = last_column;

    59

  this->last_order   = last_order;

    60

  this->parent       = NULL;

    61

  this->token        = NULL;

    62

  this->datatype     = NULL;

    63

  this->scope        = NULL;

    64

}

    65

    66

    67

    68

token_c::token_c(const char *value, 

    69

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

    70

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

    71

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

    72

  this->value = value;

    73

  this->token = this; // every token is its own reference token.

    74

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

    75

}

    76

    77

    78

    79

    80

# define LIST_CAP_INIT 8

    81

# define LIST_CAP_INCR 8

    82

    83

list_c::list_c(

    84

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

    85

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

    86

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

    87

  n = 0;

    88

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

    89

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

    90

}

    91

    92

    93

list_c::list_c(symbol_c *elem, 

    94

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

    95

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

    96

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

    97

  n = 0;

    98

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

    99

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

   100

  add_element(elem); 

   101

}

   102

   103

   104

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

   105

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

   106

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

   107

symbol_c *list_c::get_element(int pos) {return elements[pos].symbol;}

   108

   109

   110

   111

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

   112

/* find element associated to token value */

   113

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

   114

symbol_c *list_c::find_element(symbol_c *token) {

   115

  token_c *t = dynamic_cast<token_c *>(token);

   116

  if (t == NULL) ERROR;

   117

  return find_element((const char *)t->value);  

   118

}

   119

   120

symbol_c *list_c::find_element(const char *token_value) {

   121

  // We could use strcasecmp(), but it's best to always use the same 

   122

  // method of string comparison throughout matiec

   123

  nocasecmp_c ncc; 

   124

  for (int i = 0; i < n; i++) 

   125

    if (!ncc(elements[i].token_value, token_value))

   126

      return elements[i].symbol;

   127

   128

  return NULL; // not found

   129

}

   130

   131

   132

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

   133

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

   134

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

   135

void list_c::add_element(symbol_c *elem) {add_element(elem, elem);}

   136

   137

void list_c::add_element(symbol_c *elem, symbol_c *token) {

   138

  token_c *t =  (token == NULL)? NULL : token->token;

   139

  add_element(elem, (t == NULL)? NULL : t->value);

   140

}

   141

   142

void list_c::add_element(symbol_c *elem, const char *token_value) {

   143

  if (c <= n)

   144

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

   145

      ERROR_MSG("out of memory");

   146

  //elements[n++] = {token_value, elem};  // only available from C++11 onwards, best not use it for now.

   147

  elements[n].symbol      = elem;

   148

  elements[n].token_value = token_value;

   149

  n++;

   150

   151

  if (NULL == elem) return;

   152

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

   153

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

   154

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

   155

   * pointer still set to NULL.

   156

   */

   157

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

   158

   159

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

   160

  if (NULL == first_file) {

   161

    first_file = elem->first_file;

   162

    first_line = elem->first_line;

   163

    first_column = elem->first_column;

   164

  }

   165

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

   166

    first_column = elem->first_column;

   167

  }

   168

  if (first_line > elem->first_line) {

   169

    first_line = elem->first_line;

   170

    first_column = elem->first_column;

   171

  }

   172

  if (NULL == last_file) {

   173

    last_file = elem->last_file;

   174

    last_line = elem->last_line;

   175

    last_column = elem->last_column;

   176

  }

   177

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

   178

      (last_column < elem->last_column)) {

   179

    last_column = elem->last_column;

   180

  }

   181

  if (last_line < elem->last_line) {

   182

    last_line = elem->last_line;

   183

    last_column = elem->last_column;

   184

  }

   185

}

   186

   187

   188

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

   189

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

   190

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

   191

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

   192

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

   193

   194

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

   195

   196

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

   197

  token_c *t    =  (token == NULL)? NULL : token->token;

   198

  insert_element(elem, (t == NULL)? NULL : t->value, pos);

   199

}

   200

   201

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

   202

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

   203

   204

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

   205

  /* will also increment n by 1 ! */

   206

  add_element(elem);

   207

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

   208

  if(pos < (n-1)){ 

   209

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

   210

    elements[pos].symbol      = elem;

   211

    elements[pos].token_value = token_value;

   212

  }

   213

}

   214

   215

   216

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

   217

/* remove element at position pos. */

   218

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

   219

void list_c::remove_element(int pos) {

   220

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

   221

   222

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

   223

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

   224

  /* corrent the new size */

   225

  n--;

   226

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

   227

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

   228

}

   229

   230

   231

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

   232

/* Remove all elements from list. */

   233

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

   234

void list_c::clear(void) {

   235

  n = 0;

   236

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

   237

}

   238

   239

   240

#define SYM_LIST(class_name_c, ...)								\

   241

class_name_c::class_name_c(									\

   242

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

   243

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

   244

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

   245

class_name_c::class_name_c(symbol_c *elem, 							\

   246

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

   247

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

   248

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

   249

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

   250

   251

#define SYM_TOKEN(class_name_c, ...)								\

   252

class_name_c::class_name_c(const char *value, 							\

   253

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

   254

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

   255

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

   256

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

   257

   258

#define SYM_REF0(class_name_c, ...)								\

   259

class_name_c::class_name_c(									\

   260

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

   261

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

   262

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

   263

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

   264

   265

   266

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

   267

class_name_c::class_name_c(symbol_c *ref1,							\

   268

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

   269

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

   270

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

   271

  this->ref1 = ref1;										\

   272

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

   273

}												\

   274

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

   275

   276

   277

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

   278

class_name_c::class_name_c(symbol_c *ref1,							\

   279

			   symbol_c *ref2,							\

   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

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

   286

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

   287

}												\

   288

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

   289

   290

   291

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

   292

class_name_c::class_name_c(symbol_c *ref1,							\

   293

			   symbol_c *ref2,							\

   294

			   symbol_c *ref3,							\

   295

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

   296

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

   297

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

   298

  this->ref1 = ref1;										\

   299

  this->ref2 = ref2;										\

   300

  this->ref3 = ref3;										\

   301

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

   302

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

   303

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

   304

}												\

   305

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

   306

   307

   308

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

   309

class_name_c::class_name_c(symbol_c *ref1,							\

   310

			   symbol_c *ref2,							\

   311

			   symbol_c *ref3,							\

   312

			   symbol_c *ref4,							\

   313

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

   314

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

   315

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

   316

  this->ref1 = ref1;										\

   317

  this->ref2 = ref2;										\

   318

  this->ref3 = ref3;										\

   319

  this->ref4 = ref4;										\

   320

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

   321

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

   322

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

   323

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

   324

}												\

   325

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

   326

   327

   328

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

   329

class_name_c::class_name_c(symbol_c *ref1,							\

   330

			   symbol_c *ref2,							\

   331

			   symbol_c *ref3,							\

   332

			   symbol_c *ref4,							\

   333

			   symbol_c *ref5,							\

   334

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

   335

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

   336

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

   337

  this->ref1 = ref1;										\

   338

  this->ref2 = ref2;										\

   339

  this->ref3 = ref3;										\

   340

  this->ref4 = ref4;										\

   341

  this->ref5 = ref5;										\

   342

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

   343

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

   344

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

   345

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

   346

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

   347

}												\

   348

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

   349

   350

   351

   352

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

   353

class_name_c::class_name_c(symbol_c *ref1,							\

   354

			   symbol_c *ref2,							\

   355

			   symbol_c *ref3,							\

   356

			   symbol_c *ref4,							\

   357

			   symbol_c *ref5,							\

   358

			   symbol_c *ref6,							\

   359

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

   360

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

   361

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

   362

  this->ref1 = ref1;										\

   363

  this->ref2 = ref2;										\

   364

  this->ref3 = ref3;										\

   365

  this->ref4 = ref4;										\

   366

  this->ref5 = ref5;										\

   367

  this->ref6 = ref6;										\

   368

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

   369

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

   370

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

   371

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

   372

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

   373

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

   374

}												\

   375

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

   376

   377

   378

   379

#include "absyntax.def"

   380

   381

   382

   383

   384

#undef SYM_LIST

   385

#undef SYM_TOKEN

   386

#undef SYM_TOKEN

   387

#undef SYM_REF0

   388

#undef SYM_REF1

   389

#undef SYM_REF2

   390

#undef SYM_REF3

   391

#undef SYM_REF4

   392

#undef SYM_REF5

   393

#undef SYM_REF6

   394

   395

   396

   397

   398