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\t", symbol->first_file, symbol->first_line, symbol->first_column, symbol->last_line, symbol->last_column, symbol->absyntax_cname());

   124

   125

  fprintf(stderr, "  datatype=");

   126

  if (NULL == symbol->datatype)

   127

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

   128

  else {

   129

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

   130

  }

   131

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

   132

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

   133

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

   134

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

   135

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

   136

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

   137

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

   138

      else

   139

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

   140

  } else {

   141

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

   142

  }

   143

  fprintf(stderr, "}\t ");         

   144

   145

  /* print the const values... */

   146

  dump_cvalue(symbol->const_value);

   147

  fprintf(stderr, "\t");

   148

}

   149

   150

   151

   152

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

   153

   dump_symbol(symbol);

   154

   155

   /* 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. */

   156

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

   157

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

   158

   159

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

   160

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

   161

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

   162

    fprintf(stderr, "(NULL,");

   163

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

   164

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

   165

  else

   166

    fprintf(stderr, "(    ,");

   167

   168

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

   169

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

   170

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

   171

    fprintf(stderr, "NULL)");

   172

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

   173

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

   174

  else 

   175

    fprintf(stderr, "    )");

   176

   177

  fprintf(stderr, "\n");

   178

   179

  return NULL;

   180

};

   181

   182

   183

   184

   185

   186

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

   187

/* Class to print an AST         */

   188

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

   189

   190

class print_ast_c: public fcall_iterator_visitor_c { 

   191

  public:

   192

    static void print(symbol_c *symbol);

   193

    static void print(const char *str);

   194

   195

  protected:

   196

    void prefix_fcall(symbol_c *symbol);

   197

    void suffix_fcall(symbol_c *symbol);  

   198

   199

  private:

   200

    static print_ast_c *singleton;    

   201

};

   202

   203

   204

   205

   206

print_ast_c *print_ast_c::singleton = NULL;

   207

   208

   209

void print_ast_c::print(symbol_c* symbol) {

   210

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

   211

  if (NULL == singleton)   ERROR;

   212

   213

  symbol->accept(*singleton);

   214

}

   215

   216

   217

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

   218

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

   219

}

   220

   221

   222

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

   223

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

   224

   225

   226

   227

   228

   229

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

   230

/* The DEBUG class               */

   231

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

   232

   233

   234

   235

   236

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

   237

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

   238

}

   239

   240

void debug_c::print(const_value_c cvalue) {

   241

  dump_cvalue(cvalue);

   242

}

   243

   244

void debug_c::print(symbol_c *symbol) {

   245

  print_symbol_c::print(symbol);

   246

}

   247

   248

void debug_c::print_ast(symbol_c *symbol) {

   249

  print_ast_c::print(symbol);

   250

}

   251

   252

   253

   254

   255