| /** \file consoleui.cpp . |
| ----------------------------------------------------------------------------- |
| |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| |
| ----------------------------------------------------------------------------- |
| |
| Options used to be of the form "-opt value" or "-switch" |
| APR follows standard convention of short and long options, e.g. |
| "-c -x" "-cx" "--opt value" "--opt=value" "--switch" |
| |
| -------------------------------------------------------------------------- */ |
| |
| #ifndef __UIMA_CONSOLEUI_CPP |
| #define __UIMA_CONSOLEUI_CPP |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Include dependencies */ |
| /* ----------------------------------------------------------------------- */ |
| |
| #include <vector> |
| #include "uima/pragmas.hpp" //must be first include to surpress warnings |
| #include "uima/consoleui.hpp" |
| #include "apr_strings.h" |
| #include "apr_version.h" |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Constants */ |
| /* ----------------------------------------------------------------------- */ |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Types / Classes */ |
| /* ----------------------------------------------------------------------- */ |
| using namespace std; |
| namespace uima { |
| namespace util { |
| |
| /* ----------------------------------------------------------------------- */ |
| /* Implementation */ |
| /* ----------------------------------------------------------------------- */ |
| |
| // ----------------------------------------------------------------------- |
| // Conctructor & Destructor |
| // ----------------------------------------------------------------------- |
| ConsoleUI::ConsoleUI(int argc, char * argv[], |
| const char * cpszTitle, const char * cpszCopyright) |
| : iv_bQuiet(false), |
| iv_cpszHelp(NULL), |
| iv_szProcessName(strdup("")), |
| iv_currentArg(99999) { |
| // Catch any APR errors here in case caller does not expect this constructor to fail |
| try { |
| |
| apr_status_t rv = apr_initialize(); |
| if (rv != APR_SUCCESS) { |
| char errBuf[256]; |
| apr_strerror(rv, errBuf, sizeof(errBuf)); |
| UIMA_EXC_THROW_NEW(AprFailureException, |
| UIMA_ERR_APR_FAILURE, |
| ErrorMessage(UIMA_MSG_ID_EXC_APR_ERROR,errBuf), |
| ErrorMessage(UIMA_MSG_ID_EXCON_APR_FUNCTION,"apr_initialize"), |
| ErrorInfo::unrecoverable); |
| } |
| |
| rv = apr_pool_create(&consPool, NULL); |
| if (rv != APR_SUCCESS) { |
| UIMA_EXC_THROW_NEW(ExcOutOfMemory, |
| UIMA_ERR_ENGINE_OUT_OF_MEMORY, |
| UIMA_MSG_ID_EXC_OUT_OF_MEMORY, |
| ErrorMessage(UIMA_MSG_ID_EXCON_CREATING_POOL_FOR_CLASS,"uima::util::ConsoleUI"), |
| ErrorInfo::unrecoverable); |
| } |
| |
| iv_cpszUsage[0] = iv_cpszUsage[1] = ""; |
| iv_argc = argc; |
| iv_argv = (const char**) argv; |
| // Get program name from first arg |
| if ( cpszTitle != NULL ) { |
| util::Filename progname(argv[0]); |
| iv_szProcessName = (char *)apr_palloc(consPool, 1+strlen(progname.getName())); |
| progname.extractBaseName(iv_szProcessName); |
| cout << endl << iv_szProcessName << " - " << cpszTitle; |
| if ( cpszCopyright != NULL ) |
| cout << " " << cpszCopyright; |
| cout << " [APR version " << apr_version_string() << "]" << endl; |
| } |
| |
| // Log and rethrow and APR failures |
| } catch (Exception & rclException) { |
| cerr << rclException; |
| UIMA_EXC_RETHROW(rclException, |
| ErrorMessage(UIMA_MSG_ID_EXCON_CONSTRUCTING_CLASS,"uima::util::ConsoleUI")); |
| } |
| } |
| |
| /* ----------------------------------------------------------------------- */ |
| ConsoleUI::~ConsoleUI(void) { |
| if (consPool != NULL) |
| apr_pool_destroy(consPool); |
| apr_terminate(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Save the help string and check that all options are legal |
| // ------------------------------------------------------------------------ |
| |
| void ConsoleUI::handleUsageHelp(const char * cpszUsage, const char * cpszHelp, const char * cpszHelpFlags) { |
| std::vector<const char *> opts; // Vector of possible option (start points) |
| unsigned int i; |
| apr_status_t rv; |
| unsigned int nHelpFlags; |
| |
| if (cpszHelpFlags == NULL) |
| cpszHelpFlags = "[--help | -?]\t\n"; |
| iv_cpszUsage[0] = cpszHelpFlags; |
| iv_cpszUsage[1] = cpszUsage; |
| iv_cpszHelp = cpszHelp; |
| |
| // Step thru the usage msg to and create a vector addressing the start of each option |
| // Options can be switches or take a value, and be marked as optional (most options are |
| // are optional [!] but taftest_app requires one and only one of --config & --configs) |
| |
| // --opt --opt <val> --opt=<val> |
| // [--opt] [--opt <val>] [--opt=<val>] [-c] [-f foo] [-x | -y] |
| |
| // Assume a long option starts with -- preceeded by [ or whitespace |
| // Assume a short option starts with - preceeded by [ or space and is followed by ] or space |
| |
| // First process help flags then the remainder of the usage message. |
| for ( i = 0; i < 2; ++i ) { |
| const char * str = iv_cpszUsage[i]; |
| if ( *str == '-' && *++str == '-' ) // Check for initial -- where str[-1] would be bad! |
| opts.push_back(str); |
| while ((str = strchr(str+1, '-')) != NULL) { |
| if ( ( str[1]=='-' && (str[-1]=='[' || isspace(str[-1])) ) || |
| ( str[1]!='-' && isgraph(str[1]) && (str[-1]=='[' || str[-1]==' ') && (str[2]==']' || str[2]==' ') ) ) |
| opts.push_back(++str); |
| } |
| if (i == 0) |
| nHelpFlags = opts.size(); |
| } |
| |
| iv_pOpts = (apr_getopt_option_t *)apr_palloc( consPool, (opts.size()+1) * sizeof(apr_getopt_option_t) ); |
| |
| // Process short and long options in two passes as must use a wierd value for optch to |
| // locate long options, so can have no more than 47 long options (1 - '0') |
| |
| int j = 0; |
| const char * opt, * str; |
| int k = 0; |
| char helpChars[20]; |
| |
| for ( i = 0; i < opts.size(); ++i ) { |
| opt = opts[i]; |
| if ( *opt == '-' ) { // Long option |
| str = strpbrk( ++opt, "]= \n" ); |
| if (str == NULL) // Must be last option! |
| str = opt + strlen(opt); |
| iv_pOpts[j].name = apr_pstrndup(consPool, opt, str - opt); |
| iv_pOpts[j].has_arg = (*str == '=' || (*str == ' ' && *(str+1) == '<')); |
| iv_pOpts[j].optch = j+1; // Use 1-based index as "short" option |
| if (i < nHelpFlags) |
| helpChars[k++] = j+1; |
| ++j; |
| } |
| } |
| iv_maxOptIndex = j; // Largest wierd value marking a long option |
| // NOTE: should check that this is < any alphanumeric char, i.e. < 48 ('0') |
| |
| for ( i = 0; i < opts.size(); ++i ) { |
| opt = opts[i]; |
| if ( *opt != '-' ) { // Short option |
| iv_pOpts[j].optch = *opt; // Use real character |
| iv_pOpts[j].name = NULL; |
| iv_pOpts[j++].has_arg = (opt[1] == ' ' && opt[2] != '|' ); |
| if (i < nHelpFlags) |
| helpChars[k++] = *opt; |
| } |
| } |
| iv_pOpts[j].optch = 0; // Mark end of list |
| helpChars[k] = '\0'; |
| |
| #ifndef NDEBUG |
| // Dump all legal options when called with just 1 arg of "--" |
| if ( iv_argc == 2 && strcmp(iv_argv[1],"--")==0 ) |
| debugDisplayOptions(j); |
| #endif |
| |
| // Set up processing of interleaved options and arguments |
| apr_getopt_init(&iv_hGetopt, consPool, iv_argc, iv_argv); |
| iv_hGetopt->interleave = 1; |
| |
| // Can't have more options than args! |
| iv_pFoundOpts = (found_opt_t *)apr_palloc(consPool, iv_argc * sizeof(found_opt_t)); |
| iv_nFoundOpts = 0; |
| |
| // Check that provided options are valid and save them. |
| int index; |
| const char * optarg; |
| bool needHelp = false; |
| |
| while ((rv = apr_getopt_long(iv_hGetopt, iv_pOpts, &index, &optarg)) == APR_SUCCESS) { |
| iv_pFoundOpts[iv_nFoundOpts].index = index; |
| iv_pFoundOpts[iv_nFoundOpts++].value = optarg; |
| if (strchr(helpChars,index) != NULL) |
| needHelp = true; |
| } |
| |
| // Two errors are: Invalid option & missing argument |
| // getopt prints these on error streamwith fprintf(stderr but can override |
| // via iv_hGetopt->errfn typedef void( apr_getopt_err_fn_t)(void *arg, const char *err,...) |
| |
| if ( rv != APR_EOF ) |
| displayUsage(); |
| |
| // Args are valid ... now check for the help flags |
| else |
| if (needHelp) |
| displayHelp(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Search for a specified option and return its value |
| // ------------------------------------------------------------------------ |
| |
| bool ConsoleUI::hasOption(const char * cpszArgument, const char *& cpszrValue) const { |
| for ( int i = 0; i < iv_nFoundOpts; ++i ) { |
| int index = iv_pFoundOpts[i].index; // Index if a long option or a single char |
| if ( index > iv_maxOptIndex ) { |
| if ( cpszArgument[0] == index && cpszArgument[1] == '\0' ) { |
| cpszrValue = iv_pFoundOpts[i].value; |
| return true; |
| } |
| } else |
| if ( strcmp(cpszArgument, iv_pOpts[index-1].name) == 0 ) { |
| cpszrValue = iv_pFoundOpts[i].value; |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // ------------------------------------------------------------------------ |
| // Routine to help debug problems with parsing Usage msg |
| // ------------------------------------------------------------------------ |
| |
| #ifndef NDEBUG |
| void ConsoleUI::debugDisplayOptions(int numOpts) { |
| int i; |
| const char * valMsg[] = { "\n", " <value>\n" |
| }; |
| |
| cout << "DEBUG: Found " << numOpts << " options in Help message" << endl; |
| for ( i = 0; i < iv_maxOptIndex; ++i ) |
| cout << " --" << iv_pOpts[i].name << valMsg[iv_pOpts[i].has_arg]; |
| for ( i = iv_maxOptIndex; i < numOpts; ++i ) |
| cout << " -" << (char)iv_pOpts[i].optch << valMsg[iv_pOpts[i].has_arg]; |
| } |
| #endif |
| |
| } // namespace util |
| } // namespace uima |
| |
| #endif /* __UIMA_CONSOLEUI_CPP */ |
| |
| /* <EOF> */ |
