main.cpp

Go to the documentation of this file.

/*
 | Author: Michael Schmidt;
 |         Gunnar Jehl
 |
 | ************************* SOFTWARE LICENSE AGREEMENT ***********************
 | This source code is published under the BSD License.
 |
 | See file 'LICENSE.txt' that comes with this distribution or
 | http://dbis.informatik.uni-freiburg.de/index.php?project=GCX/license.php
 | for the full license agreement.
 |
 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 | POSSIBILITY OF SUCH DAMAGE.
 | ****************************************************************************
*/

#include <getopt.h>
#include <cstring>
#include <cstdlib>
#include "executor.h"
#include "version.h"
#include "debug.h"
#include "invalidargumentexception.h"
#include "stringdefs.h"

using namespace std;

#ifdef DBG_YACC

extern int yydebug;
#endif

Executor *exec = NULL;

enum short_opts {
    // query/xml/output informations
    opt_iqstream = '1',
    opt_ixstream = '2',
    opt_oestream = '3',
    opt_odstream = '4',
    opt_query_arg = 'q',
    opt_xml_arg = 'x',
    opt_eout_arg = 'e',
    opt_dout_arg = 'o',
    // debug options
    opt_debug = 'd',
    // processing options
    opt_streamdebug = 's',
    opt_streamnodebug = 'b',
    // misc options
    opt_fragmentxq = 'f',
    // info options
    opt_version = 'v',
    opt_about = 'a',
    opt_help = 'h',
};

static struct option long_options[] = {
    // query/xml/output informations
    {"iqstream", required_argument, 0, opt_iqstream},
    {"ixstream", required_argument, 0, opt_ixstream},
    {"oestream", required_argument, 0, opt_oestream},
    {"odstream", required_argument, 0, opt_odstream},
    {"query", required_argument, 0, opt_query_arg},
    {"xml", required_argument, 0, opt_xml_arg},
    {"eout", required_argument, 0, opt_eout_arg},
    {"dout", required_argument, 0, opt_dout_arg},
    // debug options
    {"debug", no_argument, 0, opt_debug},
    // processing options
    {"streamdebug", no_argument, 0, opt_streamdebug},
    {"streamnodebug", no_argument, 0, opt_streamnodebug},
    // misc options
    {"fragmentxq", no_argument, 0, opt_fragmentxq},
    // info options
    {"version", no_argument, 0, opt_version},
    {"about", no_argument, 0, opt_about},
    {"help", no_argument, 0, opt_help},
    {0, 0, 0, 0}
};

static struct descriptions {
    int val;

    const char *desc;
}
 options_descriptions[] = {
    // query/xml/output informations
    {
    opt_iqstream, ": input stream type of query"}, {
    opt_ixstream, ": input stream type of xml"}, {
    opt_oestream, ": output stream type of query result"}, {
    opt_odstream, ": output stream type of debug output"}, {
    opt_query_arg, ""}, {
    opt_xml_arg, ""}, {
    opt_eout_arg, ""}, {
    opt_dout_arg, ""},
        // debug options
    {
    opt_debug, ": print detailed debug information"},
        // processing options
    {
    opt_streamdebug, ": process stream only (with debug output)"}, {
    opt_streamnodebug, ": process stream only (without debug output)"},
        // misc options
    {
    opt_fragmentxq, ": print supported XQuery fragment (XQ)"},
        // info options
    {
    opt_version, ": print version number and compile flags"}, {
    opt_about, ": print about information"}, {
    opt_help, ": print this information"}
};

void printFragmentXQ() {
    cout << FRAGMENT_TXT << endl;       // see stringdefs.h
}

void printVersionNumber() {
    cout << "This Is \"GCX\" Version " << VERSION_NUMBER << endl;
    cout << "Compiled With The Following Flags:";
    cout << endl;

    cout << "  ROLE REFCOUNT      => " <<
#ifdef ROLE_REFCOUNT
        "on";
#else
        "off";
#endif // ifdef ROLE_REFCOUNT
    cout << endl;

    cout << "  NO_OPTIMIZATIONS   => " <<
#ifdef NO_OPTIMIZATIONS
        "on";
#else
        "off";
#endif // ifdef NO_OPTIMIZATIONS
    cout << endl;

    cout << "  REWRITE_VARSTEPS   => " <<
#ifdef REWRITE_VARSTEPS
        "on";
#else
        "off";
#endif // REWRITE_VARSTEPS
    cout << endl;

    cout << "  VALIDATION         => " <<
#ifdef VALIDATION
        "on";
#else
        "off";
#endif // VALIDATION
    cout << endl;
}

void printAbout() {
    cout << LICENSE_TXT << endl;        // see stringdefs.h
    cout << "----------------------------------------" << endl << endl;
    cout <<
        "Contributors: Michael Schmidt (mschmidt@informatik.uni-freiburg.de), Author"
        << endl;
    cout <<
        "              Gunnar Jehl (jehl@informatik.uni-freiburg.de), Author" <<
        endl;
    cout << "              Christoph Koch (koch@cs.cornell.edu)" << endl;
    cout << "              Stefanie Scherzinger, Author" << endl;
}

void invalidCall(const char *exec_name) {
    cout << "Usage: " << exec_name << " [STD EVAL MODE] or" << endl;
    cout << "       " << exec_name << " [EXT EVAL MODE] or" << endl;
    cout << "       " << exec_name << " [INFO MODE]";
    cout << endl << endl;
    cout <<
        "[STD EVAL MODE] ::= --query <query_file> [--xml <xml_file>] [OPTION]?"
        << endl;
    cout <<
        "                   (--xml <xml_file> required if document is not given in query)"
        << endl;
    cout << "[EXT EVAL MODE] ::= [STREAM SPEC]+ [OPTION]?" << endl;
    cout << "  [OPTION] ::= choose one of the following" << endl;
    for (unsigned i = 8; long_options[i].name && i < 11; i++) {
        cout << "    --" << long_options[i].
            name << " " << options_descriptions[i].desc << endl;
    }
    cout << endl;
    cout << "  [STREAM SPEC] ::= choose one of the following" << endl;
    for (unsigned i = 0; long_options[i].name && i < 2; i++) {
        cout << "    --" << long_options[i].
            name << " [INPUT TYPE] [PARAM]? " << options_descriptions[i].
            desc << endl;
    }
    for (unsigned i = 2; long_options[i].name && i < 4; i++) {
        cout << "    --" << long_options[i].
            name << " [OUTPUT TYPE] [PARAM]? " << options_descriptions[i].
            desc << endl;
    }
    cout << endl;
    cout << "  [INPUT TYPE] ::= choose one of the following" << endl;
    cout << "    file : file input (DEFAULT)" << endl;
    cout <<
        "      -> when used with --iqstream provide parameter --query <query_file>"
        << endl;
    cout <<
        "      -> when used with --ixstream provide parameter --xml <xml_file>"
        << endl;
    cout << "         (required if document is not given in query)" << endl;
    cout <<
        "    null : no input (support only for --ixstream for debugging purposes)"
        << endl;
    cout << "    stdin : standard input (either for query or for xml document)"
        << endl;
    cout << endl;
    cout << "  [OUTPUT TYPE] ::= choose one of the following" << endl;
    cout << "    file : file output" << endl;
    cout <<
        "      -> when used with --oestream provide parameter --eout <eval_output_file>"
        << endl;
    cout <<
        "      -> when used with --odstream provide parameter --dout <debug_output_file>"
        << endl;
    cout << "    null : no output" << endl;
    cout << "    stdout : standard output (DEFAULT)" << endl;
    cout << endl;
    cout << "EXAMPLES:" << endl;
    cout << exec_name << " --query query.xq --xml doc.xml" << endl;
    cout <<
        "  => query input from file \"query.xq\" and xml input from file \"doc.xml\""
        << endl;
    cout << "  => query result output to stdout" << endl;
    cout << exec_name <<
        " --iqstream stdin --xml doc.xml --odstream file --dout debug.out --debug"
        << endl;
    cout << "  => query input from stdin and xml input from file \"doc.xml\"" <<
        endl;
    cout <<
        "  => debug output to file \"debug.out\" and query result output to stdout"
        << endl;
    cout << exec_name <<
        " --query query.xq --xml doc.xml --oestream file --eout result.xml --odstream null --debug"
        << endl;
    cout <<
        "  => query input from file \"query.xq\" and xml input from file \"doc.xml\""
        << endl;
    cout <<
        "  => discard debug output and query result output to file \"result.xml\""
        << endl;
    cout << endl;
    cout << "[INFO MODE] ::= choose one of the following" << endl;
    for (unsigned i = 11; long_options[i].name; i++) {
        cout << "    --" << long_options[i].
            name << " " << options_descriptions[i].desc << endl;
    }
}

ISTREAM_TYPE getInputStreamType(const char *arg) {
    if (strcmp(arg, "file") == 0) {
        return it_file;
    } else if (strcmp(arg, "null") == 0) {
        return it_null;
    } else if (strcmp(arg, "socket") == 0) {
        return it_socket;
    } else {
        return it_stdin;
    }
}

OSTREAM_TYPE getOutputStreamType(const char *arg) {
    if (strcmp(arg, "file") == 0) {
        return ot_file;
    } else if (strcmp(arg, "null") == 0) {
        return ot_null;
    } else if (strcmp(arg, "socket") == 0) {
        return ot_socket;
    } else {
        return ot_stdout;
    }
}

void executeOnExit() {
    delete exec;

    exec = NULL;
}

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

#ifdef DBG_YACC
    yydebug = 1;
#endif

    ISTREAM_TYPE query_istream_type(it_file);
    ISTREAM_TYPE xml_istream_type(it_file);
    OSTREAM_TYPE eout_ostream_type(ot_stdout);
    OSTREAM_TYPE dout_ostream_type(ot_stdout);
    const char *query_arg(NULL);
    const char *xml_arg(NULL);
    const char *eout_arg(NULL);
    const char *dout_arg(NULL);
    bool debug(false);
    bool preprocess_stream_debug(false);
    bool preprocess_stream_no_debug(false);

    if (argc == 1) {
        invalidCall(argv[0]);
        return EXIT_SUCCESS;
    }

    unsigned idx = 0;
    unsigned req_arg = 0;

    for (unsigned i = 0; long_options[i].name; i++) {
        if (long_options[i].has_arg == required_argument) {
            req_arg++;
        }
    }
    char short_options[(sizeof (long_options) / sizeof (long_options[0]) - 1) +
                       req_arg];
    for (unsigned i = 0; long_options[i].name; i++) {
        short_options[idx++] = long_options[i].val;
        if (long_options[i].has_arg == required_argument) {
            short_options[idx++] = ':';
        }
    }

    while (1) {
        int option_index = 0;

        short_options[idx] = 0;
        int option_int = getopt_long(argc, argv, short_options, long_options,
                                     &option_index);

        if (option_int == -1) {
            break;
        }

        switch (option_int) {
            case 0:
                break;
            case opt_iqstream:
                if (optarg) {
                    query_istream_type = getInputStreamType(optarg);
                }
                break;
            case opt_ixstream:
                if (optarg) {
                    xml_istream_type = getInputStreamType(optarg);
                }
                break;
            case opt_oestream:
                if (optarg) {
                    eout_ostream_type = getOutputStreamType(optarg);
                }
                break;
            case opt_odstream:
                if (optarg) {
                    dout_ostream_type = getOutputStreamType(optarg);
                }
                break;
            case opt_query_arg:
                if (optarg) {
                    query_arg = optarg;
                }
                break;
            case opt_xml_arg:
                if (optarg) {
                    xml_arg = optarg;
                }
                break;
            case opt_eout_arg:
                if (optarg) {
                    eout_arg = optarg;
                }
                break;
            case opt_dout_arg:
                if (optarg) {
                    dout_arg = optarg;
                }
                break;
            case opt_debug:
                if (!preprocess_stream_no_debug) {
                    debug = true;
                }
                break;
            case opt_streamdebug:
                if (!preprocess_stream_no_debug && !debug) {
                    preprocess_stream_debug = true;
                    debug = true;
                }
                break;
            case opt_streamnodebug:
                if (!preprocess_stream_debug && !debug) {
                    preprocess_stream_no_debug = true;
                    debug = false;
                }
                break;
            case opt_fragmentxq:
                if (!preprocess_stream_no_debug && !preprocess_stream_debug
                    && !debug) {
                    printFragmentXQ();
                    return EXIT_SUCCESS;
                }
                break;
            case opt_version:
                if (!preprocess_stream_no_debug && !preprocess_stream_debug
                    && !debug) {
                    printVersionNumber();
                    return EXIT_SUCCESS;
                }
                break;
            case opt_about:
                if (!preprocess_stream_no_debug && !preprocess_stream_debug
                    && !debug) {
                    printAbout();
                    return EXIT_SUCCESS;
                }
                break;
            case opt_help:
                if (!preprocess_stream_no_debug && !preprocess_stream_debug
                    && !debug) {
                    invalidCall(argv[0]);
                    return EXIT_SUCCESS;
                }
                break;
            case '?':
                return EXIT_FAILURE;
            default:
                return EXIT_FAILURE;
        }
    }

    if (optind < argc) {
        cout << endl;
        cout << "non-option ARGV-element(s): ";
        while (optind < argc) {
            cout << argv[optind++] << endl;
        }
        return EXIT_FAILURE;
    }

    CmdLine *cmd =
        new CmdLine(query_istream_type, xml_istream_type, eout_ostream_type,
                    dout_ostream_type, query_arg, xml_arg, eout_arg, dout_arg,
                    debug, preprocess_stream_debug,
                    preprocess_stream_no_debug);

    try {
        cmd->checkIntegrity();
    }
    catch(InvalidArgumentException & e) {
        cout << e.getDebugMsg();
        return EXIT_FAILURE;
    }
    catch(Exception & e) {
        cout << e.getDebugMsg();
        return EXIT_FAILURE;
    }

    exec = new Executor(cmd);
    atexit(executeOnExit);
    exec->start();
    delete exec;

    exec = NULL;

    return EXIT_SUCCESS;
}

---