src/parser/parser_builder.cpp

   1 /*********************                                                        */
   2 /*! \file parser_builder.cpp
   3  ** \verbatim
   4  ** Original author: cconway
   5  ** Major contributors: mdeters
   6  ** Minor contributors (to current version): none
   7  ** This file is part of the CVC4 prototype.
   8  ** Copyright (c) 2009, 2010, 2011  The Analysis of Computer Systems Group (ACSys)
   9  ** Courant Institute of Mathematical Sciences
  10  ** New York University
  11  ** See the file COPYING in the top-level source directory for licensing
  12  ** information.\endverbatim
  13  **
  14  ** \brief A builder for parsers.
  15  **
  16  ** A builder for parsers.
  17  **/
  18
  19 #include <string>
  20
  21 #include "parser_builder.h"
  22 #include "input.h"
  23 #include "parser.h"
  24 #include "smt/smt.h"
  25 #include "smt2/smt2.h"
  26
  27 #include "expr/expr_manager.h"
  28 #include "util/options.h"
  29
  30 namespace CVC4 {
  31
  32 namespace parser {
  33
  34 ParserBuilder::ParserBuilder(ExprManager* exprManager,
  35                              const std::string& filename) :
  36   d_filename(filename),
  37   d_exprManager(exprManager) {
  38   init(exprManager,filename);
  39 }
  40
  41 ParserBuilder::ParserBuilder(ExprManager* exprManager,
  42                              const std::string& filename,
  43                              const Options& options) :
  44   d_filename(filename),
  45   d_exprManager(exprManager) {
  46   init(exprManager,filename);
  47   withOptions(options);
  48 }
  49
  50 void ParserBuilder::init(ExprManager* exprManager,
  51                          const std::string& filename) {
  52   d_inputType = FILE_INPUT;
  53   d_lang = language::input::LANG_AUTO;
  54   d_filename = filename;
  55   d_streamInput = NULL;
  56   d_exprManager = exprManager;
  57   d_checksEnabled = true;
  58   d_strictMode = false;
  59   d_mmap = false;
  60   d_parseOnly = false;
  61 }
  62
  63 Parser *ParserBuilder::build()
  64   throw (InputStreamException,AssertionException) {
  65   Input *input = NULL;
  66   switch( d_inputType ) {
  67   case FILE_INPUT:
  68     input = Input::newFileInput(d_lang,d_filename,d_mmap);
  69     break;
  70   case STREAM_INPUT:
  71     AlwaysAssert( d_streamInput != NULL,
  72                   "Uninitialized stream input in ParserBuilder::build()" );
  73     input = Input::newStreamInput(d_lang,*d_streamInput,d_filename);
  74     break;
  75   case STRING_INPUT:
  76     input = Input::newStringInput(d_lang,d_stringInput,d_filename);
  77     break;
  78   default:
  79     Unreachable();
  80   }
  81
  82   Parser *parser = NULL;
  83   switch(d_lang) {
  84   case language::input::LANG_SMTLIB:
  85     parser = new Smt(d_exprManager, input, d_strictMode, d_parseOnly);
  86     break;
  87   case language::input::LANG_SMTLIB_V2:
  88     parser = new Smt2(d_exprManager, input, d_strictMode, d_parseOnly);
  89     break;
  90   default:
  91     parser = new Parser(d_exprManager, input, d_strictMode, d_parseOnly);
  92   }
  93
  94   if( d_checksEnabled ) {
  95     parser->enableChecks();
  96   } else {
  97     parser->disableChecks();
  98   }
  99
 100   return parser;
 101 }
 102
 103 ParserBuilder& ParserBuilder::withChecks(bool flag) {
 104   d_checksEnabled = flag;
 105   return *this;
 106 }
 107
 108 ParserBuilder& ParserBuilder::withExprManager(ExprManager* exprManager) {
 109   d_exprManager = exprManager;
 110   return *this;
 111 }
 112
 113 ParserBuilder& ParserBuilder::withFileInput() {
 114   d_inputType = FILE_INPUT;
 115   return *this;
 116 }
 117
 118 ParserBuilder& ParserBuilder::withFilename(const std::string& filename) {
 119   d_filename = filename;
 120   return *this;
 121 }
 122
 123 ParserBuilder& ParserBuilder::withInputLanguage(InputLanguage lang) {
 124   d_lang = lang;
 125   return *this;
 126 }
 127
 128 ParserBuilder& ParserBuilder::withMmap(bool flag) {
 129   d_mmap = flag;
 130   return *this;
 131 }
 132
 133 ParserBuilder& ParserBuilder::withParseOnly(bool flag) {
 134   d_parseOnly = flag;
 135   return *this;
 136 }
 137
 138 ParserBuilder& ParserBuilder::withOptions(const Options& options) {
 139   return
 140     withInputLanguage(options.inputLanguage)
 141       .withMmap(options.memoryMap)
 142       .withChecks(options.semanticChecks)
 143       .withStrictMode(options.strictParsing)
 144       .withParseOnly(options.parseOnly);
 145   }
 146
 147 ParserBuilder& ParserBuilder::withStrictMode(bool flag) {
 148   d_strictMode = flag;
 149   return *this;
 150 }
 151
 152 ParserBuilder& ParserBuilder::withStreamInput(std::istream& input) {
 153   d_inputType = STREAM_INPUT;
 154   d_streamInput = &input;
 155   return *this;
 156 }
 157
 158 ParserBuilder& ParserBuilder::withStringInput(const std::string& input) {
 159   d_inputType = STRING_INPUT;
 160   d_stringInput = input;
 161   return *this;
 162 }
 163
 164 } /* namespace parser */
 165
 166 } /* namespace CVC4 */