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

 ****************************************************************

    35

 ****************************************************************

    36

 *********                                              *********

    37

 *********                                              *********

    38

 *********   O V E R A L L    A R C H I T E C T U R E   *********

    39

 *********                                              *********

    40

 *********                                              *********

    41

 ****************************************************************

    42

 ****************************************************************

    43

 ****************************************************************

    44

    45

 The compiler works in 4(+1) stages:

    46

 Stage 1   - Lexical analyser      - implemented with flex (iec.flex)

    47

 Stage 2   - Syntax parser         - implemented with bison (iec.y)

    48

 Stage 3   - Semantics analyser    - not yet implemented

    49

 Stage 4   - Code generator        - implemented in C++

    50

 Stage 4+1 - Binary code generator - gcc, javac, etc...

    51

    52

    53

 Data structures passed between stages, in global variables:

    54

 1->2   : tokens (int), and token values (char *)

    55

 2->1   : symbol tables (defined in symtable.hh)

    56

 2->3   : abstract syntax tree (tree of C++ classes, in absyntax.hh file)

    57

 3->4   : Same as 2->3

    58

 4->4+1 : file with program in c, java, etc...

    59

    60

    61

 The compiler works in several passes:

    62

 Pass 1: executes stages 1 and 2 simultaneously

    63

 Pass 2: executes stage 3

    64

 Pass 3: executes stage 4

    65

 Pass 4: executes stage 4+1

    66

*/

    67

    68

    69

    70

#include <stdio.h>

    71

#include <getopt.h>

    72

#include <string.h>

    73

#include <stdlib.h>

    74

#include <stdarg.h>

    75

#include <iostream>

    76

    77

    78

#include "config/config.h"

    79

#include "absyntax/absyntax.hh"

    80

#include "absyntax_utils/absyntax_utils.hh"

    81

#include "stage1_2/stage1_2.hh"

    82

#include "stage3/stage3.hh"

    83

#include "stage4/stage4.hh"

    84

#include "main.hh"

    85

    86

    87

#ifndef HGVERSION

    88

   #define HGVERSION ""

    89

#endif

    90

    91

    92

    93

void error_exit(const char *file_name, int line_no, const char *errmsg, ...) {

    94

  va_list argptr;

    95

  va_start(argptr, errmsg); /* second argument is last fixed pamater of error_exit() */

    96

    97

  fprintf(stderr, "\nInternal compiler error in file %s at line %d", file_name, line_no);

    98

  if (errmsg != NULL) {

    99

    fprintf(stderr, ": ");

   100

    vfprintf(stderr, errmsg, argptr);

   101

  } else {

   102

    fprintf(stderr, ".");

   103

  }

   104

  fprintf(stderr, "\n");

   105

  va_end(argptr);

   106

   107

  exit(EXIT_FAILURE);

   108

}

   109

   110

   111

static void printusage(const char *cmd) {

   112

  printf("\nsyntax: %s [<options>] [-O <output_options>] [-I <include_directory>] [-T <target_directory>] <input_file>\n", cmd);

   113

  printf(" -h : show this help message\n");

   114

  printf(" -v : print version number\n");  

   115

  printf(" -f : display full token location on error messages\n");

   116

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

   117

      /* whether we are supporting safe extensions          */

   118

      /* as defined in PLCopen - Technical Committee 5      */

   119

      /* Safety Software Technical Specification,           */

   120

      /* Part 1: Concepts and Function Blocks,              */

   121

      /* Version 1.0 is Official Release                    */

   122

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

   127

  printf(" -c : create conversion functions for enumerated data types\n");

   128

  printf(" -O : options for output (code generation) stage. Available options for %s are...\n", cmd);

   129

  stage4_print_options();

   130

  printf("\n");

   131

  printf("%s - Copyright (C) 2003-2014 \n"

   132

         "This program comes with ABSOLUTELY NO WARRANTY!\n"

   133

         "This is free software licensed under GPL v3, and you are welcome to redistribute it under the conditions specified by this license.\n", PACKAGE_NAME);

   134

}

   135

   136

   137

   138

int main(int argc, char **argv) {

   139

  symbol_c *tree_root;

   140

  char * builddir = NULL;

   141

  stage1_2_options_t stage1_2_options;

   142

  int optres, errflg = 0;

   143

  int path_len;

   144

   145

  /* Default values for the command line options... */

   146

  stage1_2_options.safe_extensions      = false; /* allow use of SAFExxx datatypes */

   147

  stage1_2_options.full_token_loc       = false; /* error messages specify full token location */

   148

  stage1_2_options.conversion_functions = false; /* Create a conversion function for derived datatype */

   149

  stage1_2_options.nested_comments      = false; /* Allow the use of nested comments. */

   150

  stage1_2_options.ref_operator         = false; /* Allow the use of REF() operator. */

   152

  stage1_2_options.includedir           = NULL;  /* Include directory, where included files will be searched for... */

   153

   154

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

   155

  /*   Parse command line options...        */

   156

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

   158

    switch(optres) {

   159

    case 'h':

   160

      printusage(argv[0]);

   161

      return 0;

   162

    case 'v':

   163

      fprintf(stdout, "%s version %s\n" "changeset id: %s\n", PACKAGE_NAME, PACKAGE_VERSION, HGVERSION);      

   164

      return 0;

   165

    case 'f':

   166

      stage1_2_options.full_token_loc = true;

   167

      break;

   168

    case 's':

   169

      stage1_2_options.safe_extensions = true;

   170

      break;

   175

    case 'r':

   176

      stage1_2_options.ref_operator = true;

   177

      break;

   178

    case 'c':

   179

      stage1_2_options.conversion_functions = true;

   180

      break;

   181

    case 'n':

   182

      stage1_2_options.nested_comments = true;

   183

      break;

   184

    case 'I':

   185

      /* NOTE: To improve the usability under windows:

   186

       *       We delete last char's path if it ends with "\".

   187

       *       In this way compiler front-end accepts paths with or without

   188

       *       slash terminator.

   189

       */

   190

      path_len = strlen(optarg) - 1;

   191

      if (optarg[path_len] == '\\') optarg[path_len]= '\0';

   192

      stage1_2_options.includedir = optarg;

   193

      break;

   194

    case 'T':

   195

      /* NOTE: see note above */

   196

      path_len = strlen(optarg) - 1;

   197

      if (optarg[path_len] == '\\') optarg[path_len]= '\0';

   198

      builddir = optarg;

   199

      break;

   200

    case 'O':

   201

      if (stage4_parse_options(optarg) < 0) errflg++;

   202

      break;

   203

    case ':':       /* -I, -T, or -O without operand */

   204

      fprintf(stderr, "Option -%c requires an operand\n", optopt);

   205

      errflg++;

   206

      break;

   207

    case '?':

   208

      fprintf(stderr, "Unrecognized option: -%c\n", optopt);

   209

      errflg++;

   210

      break;

   211

    default:

   212

      fprintf(stderr, "Unknown error while parsing command line options.");

   213

      errflg++;

   214

      break;

   215

    }

   216

  }

   217

   218

  if (optind == argc) {

   219

    fprintf(stderr, "Missing input file\n");

   220

    errflg++;

   221

  }

   222

   223

  if (optind > argc) {

   224

    fprintf(stderr, "Too many input files\n");

   225

    errflg++;

   226

  }

   227

   228

  if (errflg) {

   229

    printusage(argv[0]);

   230

    return EXIT_FAILURE;

   231

  }

   232

   233

   234

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

   235

  /*   Run the compiler...   */

   236

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

   237

  /* 1st Pass */

   238

  if (stage1_2(argv[optind], &tree_root, stage1_2_options) < 0)

   239

    return EXIT_FAILURE;

   240

   241

  /* 2nd Pass */

   242

    /* basically loads some symbol tables to speed up look ups later on */

   243

  absyntax_utils_init(tree_root);  

   244

    /* moved to bison, although it could perfectly well still be here instead of in bison code. */

   245

  //add_en_eno_param_decl_c::add_to(tree_root);

   246

   247

  /* Do semantic verification of code (data type and lvalue checking currently implemented) */

   248

  if (stage3(tree_root) < 0)

   249

    return EXIT_FAILURE;

   250

   251

  /* 3rd Pass */

   252

  if (stage4(tree_root, builddir) < 0)

   253

    return EXIT_FAILURE;

   254

   255

  /* 4th Pass */

   256

  /* Call gcc, g++, or whatever... */

   257

  /* Currently implemented in the Makefile! */

   258

   259

  return 0;

   260

}

   261

   262