480 lines
12 KiB
C++
480 lines
12 KiB
C++
////////////////////////////////////////////////////////////////////////
|
|
// FILE: argparser.cpp
|
|
// AUTHOR: Johannes Winkelmann, jw@tks6.net
|
|
// COPYRIGHT: (c) 2002 by Johannes Winkelmann
|
|
// ---------------------------------------------------------------------
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 2 of the License, or
|
|
// (at your option) any later version.
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
using namespace std;
|
|
|
|
#include "argparser.h"
|
|
|
|
/*!
|
|
Construct a ArgParser object
|
|
\param argc argument count
|
|
\param argv argument vector
|
|
*/
|
|
ArgParser::ArgParser( int argc, char** argv )
|
|
: m_isCommandGiven( false ),
|
|
m_isTest( false ),
|
|
m_isAlternateConfigGiven( false ),
|
|
m_useCache( false ),
|
|
m_calledAsPrtCache( false ),
|
|
m_hasFilter( false ),
|
|
m_noStdConfig( false ),
|
|
m_writeLog( false ),
|
|
m_depSort( true ),
|
|
m_softdeps( false ),
|
|
m_revdep(false),
|
|
m_all( false ),
|
|
m_printPath( false ),
|
|
m_execPreInstall( false ),
|
|
m_execPostInstall( false ),
|
|
m_preferHigher( false ),
|
|
m_strictDiff( false ),
|
|
m_sysup( false ),
|
|
m_group( false ),
|
|
m_useRegex(false),
|
|
m_fullPath(false),
|
|
m_quick(false),
|
|
m_recursive(false),
|
|
m_printTree(false),
|
|
m_alternateConfigFile( "" ),
|
|
m_pkgmkArgs( "" ),
|
|
m_pkgaddArgs( "" ),
|
|
m_pkgrmArgs( "" ),
|
|
m_filter( "" ),
|
|
m_sortArgs( "" ),
|
|
m_commandName( "" ),
|
|
m_unknownOption( "" ),
|
|
m_installRoot( "" ),
|
|
m_ignore( "" ),
|
|
m_commandType(HELP),
|
|
m_argc( argc ),
|
|
m_argv( argv ),
|
|
m_verbose( 0 )
|
|
{
|
|
}
|
|
|
|
|
|
/*!
|
|
\return true if an alternate configuration file is given
|
|
*/
|
|
bool ArgParser::isAlternateConfigGiven() const
|
|
{
|
|
return m_isAlternateConfigGiven;
|
|
}
|
|
|
|
|
|
/*!
|
|
\return true if a command is given
|
|
*/
|
|
bool ArgParser::isCommandGiven() const
|
|
{
|
|
return m_isCommandGiven;
|
|
}
|
|
|
|
|
|
/*!
|
|
\return a list of arguments not processed by ArgParser
|
|
*/
|
|
const list<string>& ArgParser::otherArgs() const
|
|
{
|
|
return m_otherArgs;
|
|
}
|
|
|
|
|
|
/*!
|
|
\return what command was given
|
|
*/
|
|
ArgParser::Type ArgParser::commandType() const
|
|
{
|
|
return m_commandType;
|
|
}
|
|
|
|
|
|
/*!
|
|
\return addtional arguments to pkgmk
|
|
*/
|
|
const string& ArgParser::pkgmkArgs() const
|
|
{
|
|
return m_pkgmkArgs;
|
|
}
|
|
|
|
/*!
|
|
\return addtional arguments to pkgadd
|
|
*/
|
|
const string& ArgParser::pkgaddArgs() const
|
|
{
|
|
return m_pkgaddArgs;
|
|
}
|
|
|
|
/*!
|
|
\return the name of the alternative configuration file
|
|
*/
|
|
const string& ArgParser::alternateConfigFile() const
|
|
{
|
|
return m_alternateConfigFile;
|
|
}
|
|
|
|
/*!
|
|
parse the arguments
|
|
\return true on success
|
|
*/
|
|
bool ArgParser::parse() {
|
|
const int commandCount = 28;
|
|
string commands[commandCount] = { "help", "info", "version",
|
|
"search", "dsearch", "fsearch",
|
|
"cache", "install", "remove",
|
|
"current", "isinst", "diff",
|
|
"path", "printf", "readme",
|
|
"list", "listinst", "listorphans",
|
|
"lock", "unlock", "listlocked",
|
|
"cat", "ls", "edit", "dumpconfig",
|
|
"dup", "depends", "deptree"
|
|
};
|
|
|
|
Type commandID[commandCount] = { HELP, INFO, SHOW_VERSION,
|
|
SEARCH, DSEARCH, FSEARCH,
|
|
CREATE_CACHE, INSTALL, REMOVE,
|
|
CURRENT, ISINST, DIFF,
|
|
PATH, PRINTF, README,
|
|
LIST, LISTINST, LISTORPHANS,
|
|
LOCK, UNLOCK, LISTLOCKED,
|
|
CAT, LS, EDIT, DUMPCONFIG,
|
|
DUP, DEPENDS, DEPTREE
|
|
};
|
|
|
|
if ( m_argc < 2 ) {
|
|
return false;
|
|
}
|
|
|
|
// if called from a symlink ending on prt-cache, use cached
|
|
// access
|
|
string app = m_argv[0];
|
|
string::size_type pos = app.rfind( "/" );
|
|
if ( pos != string::npos ) {
|
|
app = app.substr( pos );
|
|
}
|
|
if ( app.find( "prt-cache" ) != string::npos ) {
|
|
m_useCache = true;
|
|
m_calledAsPrtCache = true;
|
|
}
|
|
|
|
for ( int i = 1; i < m_argc; ++i ) {
|
|
if ( m_argv[i][0] == '-' ) {
|
|
string s = m_argv[i];
|
|
if ( s == "-v" ) { m_verbose += 1;
|
|
} else if ( s == "-vv" ) { m_verbose += 2;
|
|
} else if ( s == "--test" ) { m_isTest = true;
|
|
} else if ( s == "--cache" ) { m_useCache = true;
|
|
} else if ( s == "--depsort" ) { m_depSort = true;
|
|
} else if ( s == "--nodeps" ) { m_depSort = false;
|
|
} else if ( s == "--softdeps" ) { m_softdeps = true;
|
|
} else if ( s == "--all" ) { m_all = true;
|
|
} else if ( s == "--path" ) { m_printPath = true;
|
|
} else if ( s == "--log" ) { m_writeLog = true;
|
|
} else if ( s == "--pre-install" ) { m_execPreInstall = true;
|
|
} else if ( s == "--post-install" ) { m_execPostInstall = true;
|
|
} else if ( s == "--install-scripts" ) { m_execPreInstall = true;
|
|
m_execPostInstall = true;
|
|
} else if ( s == "--no-std-config" ) { m_noStdConfig = true;
|
|
} else if ( s == "--prefer-higher" || s == "-ph" ) {
|
|
m_preferHigher = true;
|
|
} else if ( s == "--strict-diff" || s == "-sd" ) {
|
|
m_strictDiff = true;
|
|
} else if ( s == "--group" || s == "-g" ) { m_group = true;
|
|
} else if ( s == "--quick" || s == "-Q" ) { m_quick = true;
|
|
} else if ( s == "--regex" ) { m_useRegex = true;
|
|
} else if ( s == "--full" ) { m_fullPath = true;
|
|
} else if ( s == "--recursive" || s == "-R" ) { m_recursive = true;
|
|
} else if ( s == "--tree" || s == "-T" ) { m_printTree = true;
|
|
} else if ( s == "-f" ) { m_pkgaddArgs += " " + s;
|
|
} else if ( s == "-fi" ) { m_pkgaddArgs += " -f";
|
|
} else if ( s == "-fr" ) { m_pkgmkArgs += " -f";
|
|
} else if ( s == "-if" ) { m_pkgmkArgs += " " + s;
|
|
} else if ( s == "-uf" ) { m_pkgmkArgs += " " + s;
|
|
} else if ( s == "-im" ) { m_pkgmkArgs += " " + s;
|
|
} else if ( s == "-um" ) { m_pkgmkArgs += " " + s;
|
|
} else if ( s == "-is" ) { m_pkgmkArgs += " " + s;
|
|
} else if ( s == "-us" ) { m_pkgmkArgs += " " + s;
|
|
} else if ( s == "-kw" ) { m_pkgmkArgs += " " + s;
|
|
} else if ( s == "-ns" ) { m_pkgmkArgs += " " + s;
|
|
}
|
|
|
|
// substrings
|
|
else if ( s.substr( 0, 8 ) == "--margs=" ) {
|
|
m_pkgmkArgs += " " + s.substr( 8 );
|
|
} else if ( s.substr( 0, 8 ) == "--aargs=" ) {
|
|
m_pkgaddArgs += " " + s.substr( 8 );
|
|
} else if ( s.substr( 0, 8 ) == "--rargs=" ) {
|
|
m_pkgrmArgs = s.substr( 8 );
|
|
} else if ( s.substr( 0, 9 ) == "--filter=" ) {
|
|
m_filter = s.substr( 9 );
|
|
m_hasFilter = true;
|
|
} else if ( s.substr( 0, 7 ) == "--sort=" ) {
|
|
m_sortArgs = s.substr( 7 );
|
|
} else if ( s.substr( 0, 9 ) == "--config=" ) {
|
|
m_alternateConfigFile = s.substr( 9 );
|
|
m_isAlternateConfigGiven = true;
|
|
} else if ( s.substr( 0, 16 ) == "--config-append=" ) {
|
|
m_configData.push_back(make_pair(m_argv[i]+16,
|
|
CONFIG_APPEND ) );
|
|
} else if ( s.substr( 0, 17 ) == "--config-prepend=" ) {
|
|
m_configData.push_back(make_pair(m_argv[i]+17,
|
|
CONFIG_PREPEND ) );
|
|
} else if ( s.substr( 0, 13 ) == "--config-set=" ) {
|
|
m_configData.push_back(make_pair(m_argv[i]+13, CONFIG_SET ) );
|
|
} else if ( s.substr( 0, 15 ) == "--install-root=" ) {
|
|
m_installRoot = s.substr(15);
|
|
} else if ( s.substr( 0, 9 ) == "--ignore=" ) {
|
|
m_ignore = s.substr(9);
|
|
} else {
|
|
m_unknownOption = s;
|
|
return false;
|
|
}
|
|
} else {
|
|
if (!m_isCommandGiven) {
|
|
string s = m_argv[i];
|
|
if ( s == "grpinst") {
|
|
m_isCommandGiven = true;
|
|
m_commandType = INSTALL;
|
|
m_group = true;
|
|
cout << "Warning: grpinst is obsolescent";
|
|
cout << "; using install --group" << endl;
|
|
} else if (s == "depinst") {
|
|
m_isCommandGiven = true;
|
|
m_commandType = INSTALL;
|
|
m_depSort = true;
|
|
} else if (s == "update") {
|
|
m_isCommandGiven = true;
|
|
m_commandType = INSTALL;
|
|
} else if (s == "sysup") {
|
|
m_isCommandGiven = true;
|
|
m_commandType = DIFF;
|
|
m_sysup = true;
|
|
} else if (s == "quickdiff") {
|
|
m_isCommandGiven = true;
|
|
m_commandType = DIFF;
|
|
m_quick = true;
|
|
} else if (s == "quickdep") {
|
|
m_isCommandGiven = true;
|
|
m_commandType = DEPENDS;
|
|
m_quick = true;
|
|
} else if (s == "dependent") {
|
|
m_isCommandGiven = true;
|
|
m_commandType = DEPTREE;
|
|
m_revdep = true;
|
|
} else {
|
|
for ( int i = 0; i < commandCount; ++i ) {
|
|
if ( s == commands[i] ) {
|
|
m_isCommandGiven = true;
|
|
m_commandName = s;
|
|
m_commandType = commandID[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// first argument must be command
|
|
if ( !m_isCommandGiven ) {
|
|
return false;
|
|
}
|
|
} else {
|
|
m_otherArgs.push_back( m_argv[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
return m_isCommandGiven;
|
|
}
|
|
|
|
/*!
|
|
\return true whether --test has been specified
|
|
*/
|
|
bool ArgParser::isTest() const
|
|
{
|
|
return m_isTest;
|
|
}
|
|
|
|
/*!
|
|
\return the level of verbose: -v -> 1, -vv -> 2
|
|
*/
|
|
int ArgParser::verbose() const
|
|
{
|
|
return m_verbose;
|
|
}
|
|
|
|
/*!
|
|
\return whether --cache has been specified
|
|
*/
|
|
bool ArgParser::useCache() const
|
|
{
|
|
return m_useCache;
|
|
}
|
|
|
|
/*!
|
|
\return whether prt-get was called as 'prt-cache' or not
|
|
*/
|
|
bool ArgParser::wasCalledAsPrtCached() const
|
|
{
|
|
return m_calledAsPrtCache;
|
|
}
|
|
|
|
/*!
|
|
\return whether prt-get should write to a log file or not
|
|
*/
|
|
bool ArgParser::writeLog() const
|
|
{
|
|
return m_writeLog;
|
|
}
|
|
|
|
/*!
|
|
\return whether there was a --filter argument
|
|
*/
|
|
bool ArgParser::hasFilter() const
|
|
{
|
|
return m_hasFilter;
|
|
}
|
|
|
|
/*!
|
|
\return whether there was a --no-std-config argument
|
|
*/
|
|
bool ArgParser::noStdConfig() const
|
|
{
|
|
return m_noStdConfig;
|
|
}
|
|
|
|
/*!
|
|
\return the --filter="..." string
|
|
*/
|
|
const string& ArgParser::filter() const
|
|
{
|
|
return m_filter;
|
|
}
|
|
|
|
/*!
|
|
\return the --sort="..." string
|
|
*/
|
|
const string& ArgParser::sortArgs() const
|
|
{
|
|
return m_sortArgs;
|
|
}
|
|
|
|
bool ArgParser::depSort() const
|
|
{
|
|
return m_depSort;
|
|
}
|
|
|
|
bool ArgParser::followSoftdeps() const
|
|
{
|
|
return m_softdeps;
|
|
}
|
|
|
|
/*!
|
|
\return whether there was a --all argument
|
|
*/
|
|
bool ArgParser::all() const
|
|
{
|
|
return m_all;
|
|
}
|
|
|
|
bool ArgParser::printPath() const
|
|
{
|
|
return m_printPath;
|
|
}
|
|
|
|
bool ArgParser::revdep() const
|
|
{
|
|
return m_revdep;
|
|
}
|
|
|
|
bool ArgParser::quick() const
|
|
{
|
|
return m_quick;
|
|
}
|
|
|
|
bool ArgParser::recursive() const
|
|
{
|
|
return m_recursive;
|
|
}
|
|
|
|
bool ArgParser::printTree() const
|
|
{
|
|
return (m_printTree || m_commandName == "deptree");
|
|
}
|
|
|
|
const string& ArgParser::commandName() const
|
|
{
|
|
return m_commandName;
|
|
}
|
|
|
|
const string& ArgParser::unknownOption() const
|
|
{
|
|
return m_unknownOption;
|
|
}
|
|
|
|
bool ArgParser::execPreInstall() const
|
|
{
|
|
return m_execPreInstall;
|
|
}
|
|
|
|
bool ArgParser::execPostInstall() const
|
|
{
|
|
return m_execPostInstall;
|
|
}
|
|
|
|
const list< pair<char*, ArgParser::ConfigArgType> >
|
|
ArgParser::configData() const
|
|
{
|
|
return m_configData;
|
|
}
|
|
|
|
const string& ArgParser::installRoot() const
|
|
{
|
|
return m_installRoot;
|
|
}
|
|
|
|
const string& ArgParser::pkgrmArgs() const
|
|
{
|
|
return m_pkgrmArgs;
|
|
}
|
|
|
|
bool ArgParser::preferHigher() const
|
|
{
|
|
return m_preferHigher;
|
|
}
|
|
|
|
bool ArgParser::strictDiff() const
|
|
{
|
|
return m_strictDiff;
|
|
}
|
|
|
|
bool ArgParser::sysup() const
|
|
{
|
|
return m_sysup;
|
|
}
|
|
|
|
bool ArgParser::group() const
|
|
{
|
|
return m_group;
|
|
}
|
|
|
|
bool ArgParser::useRegex() const
|
|
{
|
|
return m_useRegex;
|
|
}
|
|
|
|
bool ArgParser::fullPath() const
|
|
{
|
|
return m_fullPath;
|
|
}
|
|
|
|
const string& ArgParser::ignore() const
|
|
{
|
|
return m_ignore;
|
|
}
|