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

/*

    34

 * VISITOR.HH

    35

 *

    36

 *

    37

 * The asbract syntax tree is scaned several times

    38

 * during the whole compilation process. For e.g., stage 3 verifies

    39

 * semantics, and stage 4 produces output.

    40

 *

    41

 * Since the number of functions that need to scan through

    42

 * the abtract syntax tree may increase in time, (e.g. new

    43

 * output formats, new semantic checks, etc...) while the

    44

 * abstract syntax tree class structure is pretty stable

    45

 * (i.e. the ST and IL languages will not be changing much...),

    46

 * we use the 'visitor' design patern.

    47

 *

    48

 * It is not strictly necessary to use this pattern, but it does

    49

 * have the advantage of bringing together the functions

    50

 * that implement the same algorithm, each on a different

    51

 * class of object in the abstract syntax tree.

    52

 *

    53

 *

    54

 * This file contains the interface that each visitor class

    55

 * must implement in order to be able to visit the abstract

    56

 * syntax tree (class visitor_c)

    57

 *

    58

 * Three implementations of this interface are also provided,

    59

 * that may be later extended to execute a particular algorithm.

    60

 *

    61

 * The null (class null_visitor_c) does nothing.

    62

 *

    63

 * The iterator (class iterator_visitor_c) iterates through

    64

 * every object in the syntax tree.

    65

 *

    66

 * The search class (class search_visitor_c) iterates through

    67

 * every object, until one returns a value != NULL.

    68

 */

    69

    70

    71

#ifndef _VISITOR_HH

    72

#define _VISITOR_HH

    73

    74

    75

    76

    77

#include "absyntax.hh"

    78

    79

    80

    81

#define SYM_LIST(class_name_c, ...)                                             virtual void *visit(class_name_c *symbol) = 0;

    82

#define SYM_TOKEN(class_name_c, ...)                                            virtual void *visit(class_name_c *symbol) = 0;

    83

#define SYM_REF0(class_name_c, ...)                                             virtual void *visit(class_name_c *symbol) = 0;

    84

#define SYM_REF1(class_name_c, ref1, ...)                                       virtual void *visit(class_name_c *symbol) = 0;

    85

#define SYM_REF2(class_name_c, ref1, ref2, ...)                                 virtual void *visit(class_name_c *symbol) = 0;

    86

#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)                           virtual void *visit(class_name_c *symbol) = 0;

    87

#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)                     virtual void *visit(class_name_c *symbol) = 0;

    88

#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)               virtual void *visit(class_name_c *symbol) = 0;

    89

#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)         virtual void *visit(class_name_c *symbol) = 0;

    90

    91

class visitor_c {

    92

  public:

    93

  #include "absyntax.def"

    94

    95

  virtual ~visitor_c(void);

    96

};

    97

    98

#undef SYM_LIST

    99

#undef SYM_TOKEN

   100

#undef SYM_REF0

   101

#undef SYM_REF1

   102

#undef SYM_REF2

   103

#undef SYM_REF3

   104

#undef SYM_REF4

   105

#undef SYM_REF5

   106

#undef SYM_REF6

   107

   108

   109

   110

   111

   112

   113

#define SYM_LIST(class_name_c, ...)                                             virtual void *visit(class_name_c *symbol);

   114

#define SYM_TOKEN(class_name_c, ...)                                            virtual void *visit(class_name_c *symbol);

   115

#define SYM_REF0(class_name_c, ...)                                             virtual void *visit(class_name_c *symbol);

   116

#define SYM_REF1(class_name_c, ref1, ...)                                       virtual void *visit(class_name_c *symbol);

   117

#define SYM_REF2(class_name_c, ref1, ref2, ...)                                 virtual void *visit(class_name_c *symbol);

   118

#define SYM_REF3(class_name_c, ref1, ref2, ref3, ...)                           virtual void *visit(class_name_c *symbol);

   119

#define SYM_REF4(class_name_c, ref1, ref2, ref3, ref4, ...)                     virtual void *visit(class_name_c *symbol);

   120

#define SYM_REF5(class_name_c, ref1, ref2, ref3, ref4, ref5, ...)               virtual void *visit(class_name_c *symbol);

   121

#define SYM_REF6(class_name_c, ref1, ref2, ref3, ref4, ref5, ref6, ...)         virtual void *visit(class_name_c *symbol);

   122

   123

   124

   125

   126

   127

class null_visitor_c: public visitor_c {

   128

  public:

   129

  #include "absyntax.def"

   130

   131

  virtual ~null_visitor_c(void);

   132

};

   133

   134

   135

   136

   137

   138

class fcall_visitor_c: public visitor_c {

   139

  public:

   140

  virtual void fcall(symbol_c *symbol) = 0;

   141

   142

  public:

   143

  #include "absyntax.def"

   144

   145

//   virtual ~fcall_visitor_c(void);

   146

};

   147

   148

   149

   150

   151

class iterator_visitor_c: public visitor_c {

   152

  protected:

   153

  void *visit_list(list_c *list);

   154

   155

  public:

   156

  #include "absyntax.def"

   157

   158

  virtual ~iterator_visitor_c(void);

   159

};

   160

   161

   162

   163

   164

   165

class fcall_iterator_visitor_c: public iterator_visitor_c {

   166

  public:

   167

  virtual void prefix_fcall(symbol_c *symbol);

   168

  virtual void suffix_fcall(symbol_c *symbol);

   169

   170

  public:

   171

  #include "absyntax.def"

   172

   173

  virtual ~fcall_iterator_visitor_c(void);

   174

};

   175

   176

   177

   178

   179

   180

class search_visitor_c: public visitor_c {

   181

  protected:

   182

  void *visit_list(list_c *list);

   183

   184

  public:

   185

  #include "absyntax.def"

   186

   187

  virtual ~search_visitor_c(void);

   188

};

   189

   190

   191

#undef SYM_LIST

   192

#undef SYM_TOKEN

   193

#undef SYM_REF0

   194

#undef SYM_REF1

   195

#undef SYM_REF2

   196

#undef SYM_REF3

   197

#undef SYM_REF4

   198

#undef SYM_REF5

   199

#undef SYM_REF6

   200

   201

   202

   203

   204

   205

   206

   207

   208

#endif /*  _VISITOR_HH */