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>   // printf()

    71

#include <getopt.h>

    72

#include <string.h>

    73

#include <stdlib.h>  // EXIT_FAILURE

    74

#include "absyntax/absyntax.hh"  // symbol_c type

    75

    76

/* A macro for printing out internal parser errors... */

    77

#include <iostream> // required for std::cerr

    81

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

    85

  exit(EXIT_FAILURE);

    86

}

    87

    88

    89

    90

    91

#include "stage1_2/stage1_2.hh"

    92

#include "absyntax_utils/absyntax_utils.hh"

    93

    94

int stage3(symbol_c *tree_root);

    95

int stage4(symbol_c *tree_root, const char *builddir);

    96

    97

    98

static void printusage(const char *cmd) {

    99

  printf("syntax: %s [-h] [-f] [-s] [-I <include_directory>] [-T <target_directory>] <input_file>\n", cmd);

   100

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

   101

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

   102

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

   103

      /* whether we are suporting safe extensions           */

   104

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

   105

      /* Safety Software Technical Specification,           */

   106

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

   107

      /* Version 1.0 – Official Release                     */

   108

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

   109

  printf("  s : allow use of safe extensions\n");

   110

  printf("\n");

   111

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

   112

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

   113

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

   114

}

   115

   116

   117

   118

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

   119

  symbol_c *tree_root;

   120

  char * builddir = NULL;

   121

  stage1_2_options_t stage1_2_options = {false, false, NULL};

   122

  int optres, errflg = 0;

   123

/*

   124

  extern char *optarg;

   125

  extern int optind, optopt;

   126

*/

   127

   128

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

   129

  /*   Parse command line options...        */

   130

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

   131

  while ((optres = getopt(argc, argv, ":hfsI:T:")) != -1) {

   132

    switch(optres) {

   133

    case 'h':

   134

      printusage(argv[0]);

   135

      return 0;

   136

      break;

   137

    case 'f':

   138

      stage1_2_options.full_token_loc = true;

   139

      break;

   140

    case 's':

   141

      stage1_2_options.safe_extensions = true;

   142

      break;

   143

    case 'I':

   144

      stage1_2_options.includedir = optarg;

   145

      break;

   146

    case 'T':

   147

      builddir = optarg;

   148

      break;

   149

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

   150

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

   151

      errflg++;

   152

      break;

   153

    case '?':

   154

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

   155

      errflg++;

   156

      break;

   157

    default:

   158

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

   159

      errflg++;

   160

      break;

   161

    }

   162

  }

   163

   164

  if (optind == argc) {

   165

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

   166

    errflg++;

   167

  }

   168

   169

  if (optind > argc) {

   170

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

   171

    errflg++;

   172

  }

   173

   174

  if (errflg) {

   175

      printusage(argv[0]);

   176

      return EXIT_FAILURE;

   177

  }

   178

   179

   180

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

   181

  /*   Run the compiler...   */

   182

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

   183

  /* 1st Pass */

   184

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

   185

    return EXIT_FAILURE;

   186

   187

  /* 2nd Pass */

   188

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

   189

  absyntax_utils_init(tree_root);  

   190

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

   191

  //add_en_eno_param_decl_c::add_to(tree_root);

   192

   193

  /* Only very simple (not yet complete) data type checking currently implemented... */

   194

  if (stage3(tree_root) < 0)

   195

    return EXIT_FAILURE;

   196

   197

   198

  /* 3rd Pass */

   199

  if (stage4(tree_root, builddir) < 0)

   200

    return EXIT_FAILURE;

   201

   202

  /* 4th Pass */

   203

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

   204

  /* Currently implemented in the Makefile! */

   205

   206

  return 0;

   207

}

   208

   209