1

/*

     2

 * (c) 2003 Mario de Sousa

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

 * This program is distributed in the hope that it will be useful, but

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

 * This code is made available on the understanding that it will not be

    14

 * used in safety-critical situations without a full and competent review.

    15

 */

    16

    17

/*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

 * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22

 *

    23

 */

    24

    25

/*

    26

 * Definition of the Abstract Syntax data structure components

    27

 */

    28

    29

#include <stdio.h>

    30

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

    31

#include <string.h>

    32

    33

#include "absyntax.hh"

    34

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

    35

#include "visitor.hh"

    36

    37

#define ABORT(str) {printf("ERROR: %s\n", str); exit(0);}

    38

    39

    40

    41

    42

    43

    44

/* The base class of all symbols */

    45

symbol_c::symbol_c(void) {

    46

  this->first_line   = 0;

    47

  this->first_column = 0;

    48

  this->last_line    = 0;

    49

  this->last_column  = 0;

    50

}

    51

    52

symbol_c::symbol_c(int first_line, int first_column, int last_line, int last_column) {

    53

  this->first_line   = first_line;

    54

  this->first_column = first_column;

    55

  this->last_line    = last_line;

    56

  this->last_column  = last_column;

    57

}

    58

    59

    60

    61

token_c::token_c(const char *value, int fl, int fc, int ll, int lc)

    62

  :symbol_c(fl, fc, ll, lc) {

    63

  this->value = value;

    64

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

    65

}

    66

    67

    68

    69

    70

    71

    72

list_c::list_c(int fl, int fc, int ll, int lc)

    73

  :symbol_c(fl, fc, ll, lc) {

    74

  n = 0;

    75

  elements = NULL;

    76

}

    77

    78

list_c::list_c(symbol_c *elem, int fl, int fc, int ll, int lc)

    79

  :symbol_c(fl, fc, ll, lc) {

    80

  n = 0;

    81

  elements = NULL;

    82

  add_element(elem);

    83

}

    84

    85

/* insert a new element */

    86

void list_c::add_element(symbol_c *elem) {

    87

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

    88

  n++;

    89

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

    90

  if (elements == NULL)

    91

    ABORT("Out of memory");

    92

  elements[n - 1] = elem;

    93

    94

  if (elem == NULL)

    95

    return;

    96

    97

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

    98

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

    99

      (first_column > elem->first_column)) {

   100

    first_column = elem->first_column;

   101

  }

   102

  if (first_line > elem->first_line) {

   103

    first_line = elem->first_line;

   104

    first_column = elem->first_column;

   105

  }

   106

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

   107

      (last_column < elem->last_column)) {

   108

    last_column = elem->last_column;

   109

  }

   110

  if (last_line < elem->last_line) {

   111

    last_line = elem->last_line;

   112

    last_column = elem->last_column;

   113

  }

   114

}

   115

   116

   117

   118

   119

#define SYM_LIST(class_name_c)							\

   120

class_name_c::class_name_c(int fl, int fc, int ll, int lc)			\

   121

			:list_c(fl, fc, ll, lc) {}				\

   122

class_name_c::class_name_c(symbol_c *elem, int fl, int fc, int ll, int lc)	\

   123

			:list_c(elem, fl, fc, ll, lc) {}			\

   124

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

   125

   126

#define SYM_TOKEN(class_name_c)							\

   127

class_name_c::class_name_c(const char *value, int fl, int fc, int ll, int lc)	\

   128

			:token_c(value, fl, fc, ll, lc) {}			\

   129

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

   130

   131

#define SYM_REF0(class_name_c)					\

   132

class_name_c::class_name_c(int fl, int fc,			\

   133

			   int ll, int lc			\

   134

			  ): symbol_c(fl, fc, ll, lc) {}	\

   135

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

   136

   137

   138

#define SYM_REF1(class_name_c, ref1)			\

   139

class_name_c::class_name_c(symbol_c *ref1,		\

   140

			   int fl, int fc,		\

   141

			   int ll, int lc		\

   142

			  ): symbol_c(fl, fc, ll, lc) {	\

   143

  this->ref1 = ref1;					\

   144

}							\

   145

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

   146

   147

   148

#define SYM_REF2(class_name_c, ref1, ref2)		\

   149

class_name_c::class_name_c(symbol_c *ref1,		\

   150

			   symbol_c *ref2,		\

   151

			   int fl, int fc,		\

   152

			   int ll, int lc		\

   153

			  ): symbol_c(fl, fc, ll, lc) {	\

   154

  this->ref1 = ref1;					\

   155

  this->ref2 = ref2;					\

   156

}							\

   157

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

   158

   159

   160

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

   161

class_name_c::class_name_c(symbol_c *ref1,		\

   162

			   symbol_c *ref2,		\

   163

			   symbol_c *ref3,		\

   164

			   int fl, int fc,		\

   165

			   int ll, int lc		\

   166

			  ): symbol_c(fl, fc, ll, lc) {	\

   167

  this->ref1 = ref1;					\

   168

  this->ref2 = ref2;					\

   169

  this->ref3 = ref3;					\

   170

}							\

   171

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

   172

   173

   174

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

   175

class_name_c::class_name_c(symbol_c *ref1,		\

   176

			   symbol_c *ref2,		\

   177

			   symbol_c *ref3,		\

   178

			   symbol_c *ref4,		\

   179

			   int fl, int fc,		\

   180

			   int ll, int lc		\

   181

			  ): symbol_c(fl, fc, ll, lc) {	\

   182

  this->ref1 = ref1;					\

   183

  this->ref2 = ref2;					\

   184

  this->ref3 = ref3;					\

   185

  this->ref4 = ref4;					\

   186

}							\

   187

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

   188

   189

   190

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

   191

class_name_c::class_name_c(symbol_c *ref1,				\

   192

			   symbol_c *ref2,				\

   193

			   symbol_c *ref3,				\

   194

			   symbol_c *ref4,				\

   195

			   symbol_c *ref5,				\

   196

			   int fl, int fc,				\

   197

			   int ll, int lc				\

   198

			  ): symbol_c(fl, fc, ll, lc) {			\

   199

  this->ref1 = ref1;							\

   200

  this->ref2 = ref2;							\

   201

  this->ref3 = ref3;							\

   202

  this->ref4 = ref4;							\

   203

  this->ref5 = ref5;							\

   204

}									\

   205

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

   206

   207

   208

   209

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

   210

class_name_c::class_name_c(symbol_c *ref1,				\

   211

			   symbol_c *ref2,				\

   212

			   symbol_c *ref3,				\

   213

			   symbol_c *ref4,				\

   214

			   symbol_c *ref5,				\

   215

			   symbol_c *ref6,				\

   216

			   int fl, int fc,				\

   217

			   int ll, int lc				\

   218

			  ): symbol_c(fl, fc, ll, lc) {			\

   219

  this->ref1 = ref1;							\

   220

  this->ref2 = ref2;							\

   221

  this->ref3 = ref3;							\

   222

  this->ref4 = ref4;							\

   223

  this->ref5 = ref5;							\

   224

  this->ref6 = ref6;							\

   225

}									\

   226

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

   227

   228

   229

   230

#include "absyntax.def"

   231

   232

   233

   234

   235

#undef SYM_LIST

   236

#undef SYM_TOKEN

   237

#undef SYM_TOKEN

   238

#undef SYM_REF0

   239

#undef SYM_REF1

   240

#undef SYM_REF2

   241

#undef SYM_REF3

   242

#undef SYM_REF4

   243

#undef SYM_REF5

   244

#undef SYM_REF6

   245

   246

   247

   248

   249