| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include <precomp.h> |
| #include <cosv/commandline.hxx> |
| |
| // NOT FULLY DECLARED SERVICES |
| #include <cosv/file.hxx> |
| |
| |
| namespace csv |
| { |
| |
| namespace |
| { |
| |
| const intt C_nNoOption = -1; |
| |
| const char * sIncludeOptionShort = "-A:"; |
| const char * sIncludeOptionLong = "--Arguments:"; |
| const uintt nIncludeOptionShort_Length = strlen(sIncludeOptionShort); |
| const uintt nIncludeOptionLong_Length = strlen(sIncludeOptionLong); |
| |
| |
| /** Analyses, if an option is the one to include a file with |
| further command line arguments. |
| */ |
| bool IsIncludeOption( |
| const String & i_option ); |
| |
| /** Gets the file name from an include-arguments-option. |
| */ |
| String IncludeFile_fromIncludeOption( |
| const String & i_option ); |
| |
| |
| bool |
| IsIncludeOption(const String & i_option) |
| { |
| return strncmp(i_option, sIncludeOptionShort, nIncludeOptionShort_Length) == 0 |
| OR |
| strncmp(i_option, sIncludeOptionLong, nIncludeOptionLong_Length) == 0; |
| } |
| |
| String |
| IncludeFile_fromIncludeOption(const String & i_option) |
| { |
| if ( strncmp(i_option, sIncludeOptionShort, nIncludeOptionShort_Length) |
| == 0 ) |
| { |
| return String(i_option, nIncludeOptionShort_Length, str::maxsize); |
| } |
| else |
| if ( strncmp(i_option, sIncludeOptionLong, nIncludeOptionLong_Length) |
| == 0 ) |
| { |
| return String(i_option, nIncludeOptionLong_Length, str::maxsize); |
| } |
| return String::Null_(); |
| } |
| |
| |
| } // end anonymous namespace |
| |
| |
| |
| |
| /** Local helper class for searching a possible option name in a vector of |
| ->OptionDescription. |
| */ |
| struct CommandLine:: |
| FindOptionByText |
| { |
| bool operator()( |
| const CommandLine::OptionDescription & |
| i_option ) |
| { return i_option.sText == sOption; } |
| |
| /// @param i_searchText [i_searchText != ""] |
| FindOptionByText( |
| const String & i_option ) |
| : sOption(i_option) { } |
| private: |
| const String sOption; |
| }; |
| |
| |
| typedef std::vector<StringVector::const_iterator> StringCIteratorList; |
| typedef std::vector<intt> OptionIdList; |
| |
| bool |
| CommandLine::Interpret( int argc, |
| char * argv[] ) |
| { |
| Get_Arguments(argc,argv); |
| csv_assert(aOptionPoints.size() == aOptionIds.size()); |
| |
| StringVector::const_iterator |
| itNext = aCommandLine.begin(); |
| ++itNext; // Move 1 forward from program name. |
| StringVector::const_iterator |
| itEnd = aCommandLine.end(); |
| StringCIteratorList::const_iterator |
| itOptPtsEnd = aOptionPoints.end(); |
| |
| OptionIdList::const_iterator |
| itOptIds = aOptionIds.begin(); |
| for ( StringCIteratorList::const_iterator itOptPts = aOptionPoints.begin(); |
| itOptPts != itOptPtsEnd AND bIsOk; |
| ++itOptPts, ++itOptIds ) |
| { |
| // May be, there are arguments which do not belong to the last option: |
| // itNext != *is |
| Handle_FreeArguments(itNext, *itOptPts); |
| |
| itNext = do_HandleOption( *itOptIds, |
| *itOptPts + 1, |
| itOptPts+1 == itOptPtsEnd ? itEnd : *(itOptPts+1) ); |
| csv_assert(itNext <= itEnd); |
| } // end for (is) |
| Handle_FreeArguments(itNext, itEnd); |
| |
| return bIsOk; |
| } |
| |
| CommandLine::CommandLine() |
| : aOptions(), |
| aCommandLine(), |
| bIsOk(false) |
| { |
| } |
| |
| void |
| CommandLine::Add_Option( intt i_id, |
| String i_text ) |
| { |
| aOptions.push_back(OptionDescription( i_id, |
| i_text )); |
| } |
| |
| void |
| CommandLine::Get_Arguments( int argc, |
| char * argv[] ) |
| { |
| aCommandLine.erase(aCommandLine.begin(),aCommandLine.end()); |
| aCommandLine.reserve(argc); |
| |
| char ** pArgEnd = argv + argc; |
| for ( char ** pArg = &argv[0]; |
| pArg != pArgEnd; |
| ++pArg ) |
| { |
| Store_Argument(*pArg); |
| } // end for |
| Find_OptionPoints(); |
| bIsOk = true; |
| } |
| |
| intt |
| CommandLine::Find_Option( const String & i_text ) const |
| { |
| if (i_text.empty()) |
| return C_nNoOption; |
| |
| FindOptionByText aSearch(i_text); |
| OptionList::const_iterator |
| itFound = std::find_if( aOptions.begin(), |
| aOptions.end(), |
| aSearch ); |
| if (itFound != aOptions.end()) |
| { |
| return (*itFound).nId; |
| } |
| return C_nNoOption; |
| } |
| |
| bool |
| CommandLine::Store_Argument( const String & i_arg ) |
| { |
| if ( NOT IsIncludeOption(i_arg) ) |
| { |
| aCommandLine.push_back(i_arg); |
| return true; |
| } |
| |
| return Try2Include_Options(i_arg); |
| } |
| |
| void |
| CommandLine::Find_OptionPoints() |
| { |
| StringVector::const_iterator itEnd = aCommandLine.end(); |
| for ( StringVector::const_iterator it = aCommandLine.begin() + 1; |
| it != itEnd; |
| ++it ) |
| { |
| intt nOption = Find_Option(*it); |
| if (nOption != C_nNoOption) |
| { |
| aOptionPoints.push_back(it); |
| aOptionIds.push_back(nOption); |
| } |
| } // end for (i) |
| } |
| |
| void |
| CommandLine::Handle_FreeArguments( StringVector::const_iterator i_begin, |
| StringVector::const_iterator i_end ) |
| { |
| for ( StringVector::const_iterator it = i_begin; |
| it != i_end AND bIsOk; |
| ++it ) |
| { |
| do_HandleFreeArgument(*it); |
| } |
| } |
| |
| bool |
| CommandLine::Try2Include_Options(const String & i_includeOption) |
| { |
| static StringVector |
| aIncludedOptionFiles_; |
| |
| const String |
| aOptionFile(IncludeFile_fromIncludeOption(i_includeOption)); |
| |
| // Avoid recursion deadlock 1 |
| if ( std::find( aIncludedOptionFiles_.begin(), |
| aIncludedOptionFiles_.end(), |
| aOptionFile ) |
| != aIncludedOptionFiles_.end() ) |
| { |
| Cerr() << "\nError: Self inclusion of option file " |
| << aOptionFile |
| << ".\n" |
| << Endl(); |
| return false; |
| } |
| |
| // Avoid recursion deadlock 2 |
| aIncludedOptionFiles_.push_back(aOptionFile); |
| |
| bool ok = Include_Options(aOptionFile); |
| |
| // Avoid recursion deadlock 3 |
| aIncludedOptionFiles_.pop_back(); |
| |
| return ok; |
| } |
| |
| bool |
| CommandLine::Include_Options( const String & i_optionsFile ) |
| { |
| StreamStr |
| aIncludedText(500); |
| bool ok = Load_Options(aIncludedText, i_optionsFile); |
| if (NOT ok) |
| return false; |
| |
| StringVector |
| aIncludedOptions; |
| Split(aIncludedOptions, aIncludedText.c_str()); |
| |
| StringVector::const_iterator itEnd = aIncludedOptions.end(); |
| for ( StringVector::const_iterator it = aIncludedOptions.begin(); |
| it != itEnd; |
| ++it ) |
| { |
| Store_Argument(*it); |
| } // end for |
| |
| return true; |
| } |
| |
| bool |
| CommandLine::Load_Options( StreamStr & o_text, |
| const String & i_optionsFile ) |
| { |
| if (i_optionsFile.empty()) |
| return false; |
| |
| File |
| aOptionsFile(i_optionsFile, CFM_READ); |
| OpenCloseGuard |
| aOFGuard(aOptionsFile); |
| if (NOT aOFGuard) |
| { |
| Cerr() << "\nError: Options file " |
| << i_optionsFile |
| << " not found.\n" |
| << Endl(); |
| return false; |
| } |
| |
| StreamStr |
| aLoad(aOptionsFile); |
| o_text.swap(aLoad); |
| return true; |
| } |
| |
| |
| |
| |
| /****************** OptionDescription ***********************/ |
| |
| |
| CommandLine:: |
| OptionDescription::OptionDescription( intt i_id, |
| String i_text ) |
| : nId(i_id), |
| sText(i_text) |
| { |
| } |
| |
| |
| |
| |
| } // namespace csv |
