1

/*

     2

 * (c) 2003 Mario de Sousa

     3

 *

     4

 * Offered to the public under the terms of the GNU General Public License

     5

 * as published by the Free Software Foundation; either version 2 of the

     6

 * License, or (at your option) any later version.

     7

 *

     8

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

     9

 * WITHOUT ANY WARRANTY; without even the implied warranty of

    10

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11

 * Public License for more details.

    12

 *

    13

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

    14

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

    15

 */

    16

    17

/*

    18

 * An IEC 61131-3 IL and ST compiler.

    19

 *

    20

 * Based on the

    21

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

    22

 *

    23

 */

    24

    25

/*

    26

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

    27

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

    28

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

    29

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

    30

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

    31

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

    32

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

    33

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

    34

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

    35

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

    36

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

    37

    38

 The compiler works in 4(+1) stages:

    39

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

    40

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

    41

 Stage 3   - Semantics analyser    - not yet implemented

    42

 Stage 4   - Code generator        - implemented in C++

    43

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

    44

    45

    46

 Data structures passed between stages, in global variables:

    47

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

    48

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

    49

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

    50

 3->4   : Same as 2->3

    51

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

    52

    53

    54

 The compiler works in several passes:

    55

 Pass 1: executes stages 1 and 2 simultaneously

    56

 Pass 2: executes stage 3

    57

 Pass 3: executes stage 4

    58

 Pass 4: executes stage 4+1

    59

*/

    60

    61

    62

    63

//#include <stdio.h>   // printf()

    64

#include <getopt.h>

    65

#include <string.h>

    66

#include <stdlib.h>  // EXIT_FAILURE

    67

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

    68

    69

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

    70

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

    71

#define ERROR error_exit(__FILE__,__LINE__)

    72

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

    73

  std::cerr << "\nInternal program error in file " << file_name

    74

            << " at line " << line_no << "\n\n\n";

    75

  exit(EXIT_FAILURE);

    76

}

    77

    78

    79

    80

    81

#include "stage1_2/stage1_2.hh"

    82

#include "absyntax_utils/absyntax_utils.hh"

    83

    84

//int stage3(symbol_c *tree_root);

    85

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

    86

    87

    88

static void printusage(const char *cmd) {

    89

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

    90

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

    91

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

    92

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

    93

      /* whether we are suporting safe extensions           */

    94

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

    95

      /* Safety Software Technical Specification,           */

    96

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

    97

      /* Version 1.0 – Official Release                     */

    98

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

    99

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

   100

}

   101

   102

   103

   104

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

   105

  symbol_c *tree_root;

   106

  char * builddir = NULL;

   107

  stage1_2_options_t stage1_2_options = {false, false, NULL};

   108

  int optres, errflg = 0;

   109

/*

   110

  extern char *optarg;

   111

  extern int optind, optopt;

   112

*/

   113

   114

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

   115

  /*   Parse command line options...        */

   116

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

   117

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

   118

    switch(optres) {

   119

    case 'h':

   120

      printusage(argv[0]);

   121

      return 0;

   122

      break;

   123

    case 'f':

   124

      stage1_2_options.full_token_loc = true;

   125

      break;

   126

    case 's':

   127

      stage1_2_options.safe_extensions = true;

   128

      break;

   129

    case 'I':

   130

      stage1_2_options.includedir = optarg;

   131

      break;

   132

    case 'T':

   133

      builddir = optarg;

   134

      break;

   135

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

   136

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

   137

      errflg++;

   138

      break;

   139

    case '?':

   140

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

   141

      errflg++;

   142

      break;

   143

    default:

   144

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

   145

      errflg++;

   146

      break;

   147

    }

   148

  }

   149

   150

  if (optind == argc) {

   151

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

   152

    errflg++;

   153

  }

   154

   155

  if (optind > argc) {

   156

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

   157

    errflg++;

   158

  }

   159

   160

  if (errflg) {

   161

      printusage(argv[0]);

   162

      return EXIT_FAILURE;

   163

  }

   164

   165

   166

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

   167

  /*   Run the compiler...   */

   168

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

   169

  /* 1st Pass */

   170

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

   171

    return EXIT_FAILURE;

   172

   173

  /* 2nd Pass */

   174

  absyntax_utils_init(tree_root);

   175

  /* not yet implemented... */

   176

  /*

   177

  if (stage3(tree_root) < 0)

   178

    return EXIT_FAILURE;

   179

  */

   180

   181

  /* 3rd Pass */

   182

  if (stage4(tree_root, builddir) < 0)

   183

    return EXIT_FAILURE;

   184

   185

  /* 4th Pass */

   186

  /* Currently implemented in the Makefile! */

   187

   188

  return 0;

   189

}

   190

   191