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) {

   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

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

   129

  printf("\n");

   130

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

   131

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

   132

         "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);

   133

}

   134

   135

   136

   137

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

   138

  symbol_c *tree_root;

   139

  char * builddir = NULL;

   140

  stage1_2_options_t stage1_2_options;

   141

  int optres, errflg = 0;

   142

  int path_len;

   143

   144

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

   145

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

   146

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

   147

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

   148

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

   149

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

   150

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

   151

   152

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

   153

  /*   Parse command line options...        */

   154

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

   156

    switch(optres) {

   157

    case 'h':

   158

      printusage(argv[0]);

   159

      return 0;

   160

   161

    case 'v':

   163

      return 0;

   164

   165

    case 'f':

   166

      stage1_2_options.full_token_loc = true;

   167

      break;

   168

   169

    case 's':

   170

      stage1_2_options.safe_extensions = true;

   171

      break;

   172

   173

    case 'r':

   174

      stage1_2_options.ref_operator = true;

   175

      break;

   176

   177

    case 'c':

   178

      stage1_2_options.conversion_functions = true;

   179

      break;

   180

   181

    case 'n':

   182

      stage1_2_options.nested_comments = true;

   183

      break;

   184

   185

    case 'I':

   186

      /* NOTE: To improve the usability under windows:

   187

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

   188

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

   189

       *       slash terminator.

   190

       */

   191

      path_len = strlen(optarg) - 1;

   192

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

   193

      stage1_2_options.includedir = optarg;

   194

      break;

   195

   196

    case 'T':

   197

      /* NOTE: see note above */

   198

      path_len = strlen(optarg) - 1;

   199

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

   200

      builddir = optarg;

   201

      break;

   202

   208

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

   209

      errflg++;

   210

      break;

   211

   212

    case '?':

   213

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

   214

      errflg++;

   215

      break;

   216

   217

    default:

   218

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

   219

      errflg++;

   220

      break;

   221

    }

   222

  }

   223

   224

  if (optind == argc) {

   225

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

   226

    errflg++;

   227

  }

   228

   229

  if (optind > argc) {

   230

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

   231

    errflg++;

   232

  }

   233

   234

  if (errflg) {

   235

    printusage(argv[0]);

   236

    return EXIT_FAILURE;

   237

  }

   238

   239

   240

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

   241

  /*   Run the compiler...   */

   242

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

   243

  /* 1st Pass */

   244

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

   245

    return EXIT_FAILURE;

   246

   247

  /* 2nd Pass */

   248

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

   249

  absyntax_utils_init(tree_root);  

   250

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

   251

  //add_en_eno_param_decl_c::add_to(tree_root);

   252

   253

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

   254

  if (stage3(tree_root) < 0)

   255

    return EXIT_FAILURE;

   256

   257

  /* 3rd Pass */

   258

  if (stage4(tree_root, builddir) < 0)

   259

    return EXIT_FAILURE;

   260

   261

  /* 4th Pass */

   262

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

   263

  /* Currently implemented in the Makefile! */

   264

   265

  return 0;

   266

}

   267

   268