1

/*

     2

 *  matiec - a compiler for the programming languages defined in IEC 61131-3

     3

 *  Copyright (C) 2012  Mario de Sousa (msousa@fe.up.pt)

     4

 *

     5

 *  This program is free software: you can redistribute it and/or modify

     6

 *  it under the terms of the GNU General Public License as published by

     7

 *  the Free Software Foundation, either version 3 of the License, or

     8

 *  (at your option) any later version.

     9

 *

    10

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

    11

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    12

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    13

 *  GNU General Public License for more details.

    14

 *

    15

 *  You should have received a copy of the GNU General Public License

    16

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

    17

 *

    18

 *

    19

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

    20

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

    21

 */

    22

    23

/*

    24

 * An IEC 61131-3 compiler.

    25

 *

    26

 * Based on the

    27

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

    28

 *

    29

 */

    30

    31

    32

/*

    33

 * Some classes to help with debuging.

    34

 *

    35

 * These classes will print out the current state of a symbol or a portion of the Abstract Syntax Tree.

    36

 */

    37

    38

/* TODO: Use a class similar to stage4out_c so that we can have nice indentation when printing an AST

    39

 *       Create a template so that we can TRACE the execution of other visitor classes doing usefull work!

    40

 */

    41

    42

    43

    44

#include <unistd.h>

    45

#include <stdio.h>  /* required for NULL */

    46

#include "absyntax_utils.hh"

    47

#include "../absyntax/visitor.hh"

    48

    49

    50

    51

    52

static void dump_cvalue(const_value_c const_value) {

    53

  fprintf(stderr, "constv{");

    54

  if      (const_value._real64.is_valid   ()) fprintf(stderr, "%f",        const_value._real64.get());

    55

  else if (const_value._real64.is_overflow()) fprintf(stderr, "ov");

    56

  else if (const_value._real64.is_nonconst()) fprintf(stderr, "nc");

    57

  else                                        fprintf(stderr, "?");

    58

  fprintf(stderr, ", i=");

    59

  if      (const_value. _int64.is_valid   ()) fprintf(stderr, "%"PRId64"", const_value. _int64.get());

    60

  else if (const_value. _int64.is_overflow()) fprintf(stderr, "ov");

    61

  else if (const_value. _int64.is_nonconst()) fprintf(stderr, "nc");

    62

  else                                        fprintf(stderr, "?");

    63

  fprintf(stderr, ", u=");

    64

  if      (const_value._uint64.is_valid   ()) fprintf(stderr, "%"PRIu64"", const_value._uint64.get());

    65

  else if (const_value._uint64.is_overflow()) fprintf(stderr, "ov");

    66

  else if (const_value._uint64.is_nonconst()) fprintf(stderr, "nc");

    67

  else                                        fprintf(stderr, "?");

    68

  fprintf(stderr, ", b=");

    69

  if      (const_value.  _bool.is_valid   ()) fprintf(stderr, "%d",        const_value.  _bool.get()?1:0);

    70

  else if (const_value.  _bool.is_overflow()) fprintf(stderr, "ov");

    71

  else if (const_value.  _bool.is_nonconst()) fprintf(stderr, "nc");

    72

  else                                        fprintf(stderr, "?");

    73

  fprintf(stderr, "}");

    74

}

    75

    76

    77

    78

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

    79

/* Class to print a symbol       */

    80

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

    81

    82

    83

class print_symbol_c: public fcall_visitor_c { 

    84

  public:

    85

    static void print(symbol_c *symbol);

    86

    87

  protected:

    88

    void fcall(symbol_c *symbol);  

    89

    /* AST symbols with extra data have their own specialised methods for printing that data */

    90

    void *visit(il_instruction_c *symbol);

    91

    92

  private:

    93

    static print_symbol_c *singleton;

    94

    95

    void dump_symbol(symbol_c* symbol);

    96

};

    97

    98

    99

   100

   101

print_symbol_c *print_symbol_c::singleton = NULL;

   102

   103

   104

void print_symbol_c::print(symbol_c* symbol) {

   105

  if (NULL == singleton)   singleton = new print_symbol_c();

   106

  if (NULL == singleton)   ERROR;

   107

   108

  symbol->accept(*singleton);

   109

}

   110

   111

   112

   113

   114

   115

void print_symbol_c::fcall(symbol_c* symbol) {

   116

  dump_symbol(symbol);

   117

  fprintf(stderr, "\n");

   118

}

   119

   120

   121

   122

void print_symbol_c::dump_symbol(symbol_c* symbol) {

   123

  fprintf(stderr, "(%s->%03d:%03d..%03d:%03d) \t%s", symbol->first_file, symbol->first_line, symbol->first_column, symbol->last_line, symbol->last_column, symbol->absyntax_cname());

   124

   125

  if ((NULL != symbol->token) && (NULL != symbol->token->value))

   126

    fprintf(stderr, "(%s)", symbol->token->value);

   127

   128

  fprintf(stderr, "\t  datatype=");

   129

  if (NULL == symbol->datatype)

   130

    fprintf(stderr, "NULL\t\t");

   131

  else {

   132

    fprintf(stderr, "%s", symbol->datatype->absyntax_cname());

   133

  }

   134

  fprintf(stderr, "\t<-{");

   135

  if (symbol->candidate_datatypes.size() == 0) {

   136

    fprintf(stderr, "\t\t\t\t\t");

   137

  } else if (symbol->candidate_datatypes.size() <= 2) {

   138

    for (unsigned int i = 0; i < 2; i++)

   139

      if (i < symbol->candidate_datatypes.size())

   140

        fprintf(stderr, " %s,", symbol->candidate_datatypes[i]->absyntax_cname());

   141

      else

   142

        fprintf(stderr, "\t\t\t");

   143

  } else {

   144

    fprintf(stderr, "(%lu)\t\t\t\t\t", (unsigned long int)symbol->candidate_datatypes.size());

   145

  }

   146

  fprintf(stderr, "}\t ");         

   147

   148

  /* print the const values... */

   149

  dump_cvalue(symbol->const_value);

   150

  fprintf(stderr, "\t");

   151

}

   152

   153

   154

   155

void *print_symbol_c::visit(il_instruction_c *symbol) {

   156

   dump_symbol(symbol);

   157

   158

   /* NOTE: std::map.size() returns a size_type, whose type is dependent on compiler/platform. To be portable, we need to do an explicit type cast. */

   159

  fprintf(stderr, "  prev_il_=%lu ", (unsigned long int)symbol->prev_il_instruction.size());

   160

  if (symbol->prev_il_instruction.size() == 0)

   161

    fprintf(stderr, "(----)");

   162

  else if (symbol->prev_il_instruction[0]->datatype == NULL)

   163

    fprintf(stderr, "(NULL)");

   164

  else if (!get_datatype_info_c::is_type_valid(symbol->prev_il_instruction[0]->datatype))

   165

    fprintf(stderr, "(****)");

   166

  else

   167

    fprintf(stderr, "(    )");

   168

   169

  fprintf(stderr, "  next_il_=%lu ", (unsigned long int)symbol->next_il_instruction.size());

   170

  if (symbol->next_il_instruction.size() == 0)

   171

    fprintf(stderr, "(----)");

   172

  else if (symbol->next_il_instruction[0]->datatype == NULL)

   173

    fprintf(stderr, "(NULL)");

   174

  else if (!get_datatype_info_c::is_type_valid(symbol->next_il_instruction[0]->datatype))

   175

    fprintf(stderr, "(****)");

   176

  else 

   177

    fprintf(stderr, "(    )");

   178

   179

  fprintf(stderr, "\n");

   180

   181

  return NULL;

   182

};

   183

   184

   185

   186

   187

   188

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

   189

/* Class to print an AST         */

   190

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

   191

   192

class print_ast_c: public fcall_iterator_visitor_c { 

   193

  public:

   194

    static void print(symbol_c *symbol);

   195

    static void print(const char *str);

   196

   197

  protected:

   198

    void prefix_fcall(symbol_c *symbol);

   199

    void suffix_fcall(symbol_c *symbol);  

   200

   201

  private:

   202

    static print_ast_c *singleton;    

   203

};

   204

   205

   206

   207

   208

print_ast_c *print_ast_c::singleton = NULL;

   209

   210

   211

void print_ast_c::print(symbol_c* symbol) {

   212

  if (NULL == singleton)   singleton = new print_ast_c();

   213

  if (NULL == singleton)   ERROR;

   214

   215

  symbol->accept(*singleton);

   216

}

   217

   218

   219

void print_ast_c::print(const char *str) {

   220

  fprintf(stderr, "%s", str);

   221

}

   222

   223

   224

void print_ast_c::prefix_fcall(symbol_c* symbol) {print_symbol_c::print(symbol);}

   225

void print_ast_c::suffix_fcall(symbol_c* symbol) {}

   226

   227

   228

   229

   230

   231

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

   232

/* The DEBUG class               */

   233

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

   234

   235

   236

   237

   238

void debug_c::print(const char *str) {

   239

  fprintf(stderr, "%s", str);

   240

}

   241

   242

void debug_c::print(const_value_c cvalue) {

   243

  dump_cvalue(cvalue);

   244

}

   245

   246

void debug_c::print(symbol_c *symbol) {

   247

  print_symbol_c::print(symbol);

   248

}

   249

   250

void debug_c::print_ast(symbol_c *symbol) {

   251

  print_ast_c::print(symbol);

   252

}

   253

   254

   255

   256

   257