/*

args_4: Command line arguments parsing library
Yauheni A. Akhotnikau (C) 2002-2003
eao197@yahoo.com
-------------------------------------------------

Permission is granted to anyone to use this software for any purpose on any
computer system, and to redistribute it freely, subject to the following
restrictions:

1. This software is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. The origin of this software must not be misrepresented, either by
   explicit claim or by omission.

3. Altered versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

-------------------------------------------------

*/
/*
    Данный пример использования библиотеки args-4
    создан из кода реально работающей утилиты,
    которая выполняет низкоуровневое редактирование
    информации в файлах на SIM-картах.
*/

#include <cassert>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <cstring>
#include <cerrno>

#include <args_4/h/args.hpp>
#include <args_4/h/args_iostream.hpp>

const int   c_invalid_argv = 1;
const int   c_invalid_file_name = 2;
const int   c_pcsc_error = 3;
const int   c_invalid_input = 4;

//
// arg_file_path_t
//

/*
    Класс для разбора аргумента командной строки

    -file-path <file-path>

    где file-path задан в виде:

    XXXX[/XXXX[/XXXX[...]]

    XXXX - шестнадцатиразрядное шестнадцатиричное число.
*/
class   arg_file_path_t :
    public args_4::cmd_str_value_t
{
    typedef args_4::cmd_str_value_t base_type_t;
    public :
        arg_file_path_t(
            const char * name,
            bool mandatory );
        virtual ~arg_file_path_t();

        // Будем выполнять собственную
        // обработку параметров.
        virtual int
        process_params(
            args_4::word_container_t & words,
            args_4::error_stream_t * error_stream );

        // Получить количество разобранных значений.
        unsigned int
        query_value_count() const
        {
            return m_value_count;
        }

        // Получить вектор значений.
        const unsigned short *
        query_values() const
        {
            return m_values;
        }

    protected :
        // Вектор полученных значений.
        unsigned short  m_values[ 16 ];
        // Количество занятых элементов в m_values.
        unsigned int    m_value_count;

        int
        parse_str_value(
            args_4::error_stream_t * error_stream );
};

//
// arg_file_path_t
//

arg_file_path_t::arg_file_path_t(
    const char * name,
    bool mandatory )
    :
        base_type_t( name, mandatory ),
        m_value_count( 0 )
{
}

arg_file_path_t::~arg_file_path_t() {
}

int
arg_file_path_t::process_params(
    args_4::word_container_t & words,
    args_4::error_stream_t * error_stream )
{
    // Пусть базовый класс извлечет параметр.
    int ret_code = base_type_t::process_params(
        words, error_stream );
    if( args_4::c_ok == ret_code ) {
        // Успешно извлечен параметр аргумента.
        // Теперь его нужно разобрать
        ret_code = parse_str_value( error_stream );
    }

    return ret_code;
}

int
arg_file_path_t::parse_str_value(
    args_4::error_stream_t * error_stream )
{
    // Максимальная длина имени одного файла.
    const size_t c_max_str_file_id_len = 4;

    // Максимальное количество имен файлов в пути.
    const size_t c_max_path_deep =
        sizeof( m_values ) / sizeof( m_values[ 0 ] );

    const char * str_value = query_value();
    char str_file_id[ c_max_str_file_id_len + 1 ];
    size_t file_id_len = 0;
    bool is_invalid_format = false;

    // Посимвольно просматриваем все строковое значение
    // и выделяем имена отдельных файлов.
    while( *str_value && !is_invalid_format )
    {
        if( file_id_len != c_max_str_file_id_len )
        {
            if( isxdigit( *str_value ) )
            {
                str_file_id[ file_id_len++ ] = *str_value;
                if( file_id_len == c_max_str_file_id_len )
                {
                    // Накопили достаточно символов для
                    // преобразования в число
                    unsigned int file_id = 0;

                    str_file_id[ file_id_len ] = 0;
                    sscanf( str_file_id, "%x", &file_id );
                    if( m_value_count != c_max_path_deep )
                        m_values[ m_value_count++ ] = file_id;
                    else
                        // Слишком длинный путь к файлу.
                        is_invalid_format = true;
                }
            }
            else
                is_invalid_format = true;
        }
        else
        {
            if( ’/’ != *str_value )
                is_invalid_format = true;
            else
                file_id_len = 0;
        }

        ++str_value;
    }

    if( is_invalid_format )
    {
        if( error_stream ) {
            error_stream->out( query_name() ).out(
                ": " ).out( "invalid file path format\n" );
        }

        return args_4::c_invalid_value;
    }

    return args_4::c_ok;
}

int
do_main_work(
    const char * reader_name,
    const arg_file_path_t & file_path,
    const args_4::cmd_str_value_t & arg_chv1,
    const args_4::cmd_str_value_t & arg_chv2,
    const args_4::cmd_uint_value_t & arg_offs,
    bool is_write,
    bool ascii_dump,
    const args_4::cmd_str_value_t & arg_dbg_stream )
{
// Реальный код изъят.
    return 0;
}

// Разбор response-файла.
bool
parse_resp_file(
    const char * resp_file_name,
    // Аргументы, которые могут быть указаны
    // в response-файле.
    // Последний элемент должен содержать 0
    args_4::cmd_t ** args )
{
    assert( resp_file_name );
    assert( args );

    // Создаем и инициализируем парсер, который будет
    // разбирать входной файл.
    args_4::cmd_parser_t args_parser;
    for( ; *args; ++args )
        args_parser.add_cmd( *args );

    // Входной поток.
    args_4::words_from_file_t words_container(
        resp_file_name );
    // Поток ошибок.
    args_4::iostream_error_stream_t args_error_stream;

    // Выполняем разбор.
    int error = args_parser.parse( words_container,
        &args_error_stream );
    if( args_4::c_ok == error )
        // Разбор завершен успешно.
        return true;

    // Определяем причину неудачи.

    if( args_4::c_io_error == error )
    {
        // Произошла ошибка ввода-вывода
        std::cerr << resp_file_name << ": "
            << strerror(
                words_container.query_last_io_result() )
            << std::endl;
    }
    else
        // Произошла какая-то другая ошибка.
        std::cerr << "error in response file: "
            << resp_file_name << std::endl;

    return false;
}

// Разбор всех аргументов. Начиная с командной строки и
// заканчивая response-файлами.
bool
parse_args(
    int argc, char ** argv,
    // Эти три параметра имеют осмысленные названия,
    // т.к. они могут быть определены только в
    // определенных сочетаниях.
    args_4::cmd_t & arg_file,
    args_4::cmd_t & arg_file_path,
    args_4::cmd_t & arg_reader,
    // Реальные имена и типы остальных параметров для
    // разбора не имеют значения.
    args_4::cmd_t & arg4,
    args_4::cmd_t & arg5,
    args_4::cmd_t & arg6,
    args_4::cmd_t & arg7,
    args_4::cmd_t & arg8,
    args_4::cmd_t & arg9 )
{
    // Аргумент response-файл скрывается от прикладной
    // программы, т.к. ей об этом знать не обязательно.
    args_4::cmd_response_file_t arg_resp_file;

    // Создаем и инициализируем парсер.
    args_4::cmd_parser_t parser;
    parser.add_cmds( &arg_file, &arg_file_path,
        &arg_reader, &arg4, &arg5, &arg6,
        &arg7, &arg8, &arg9,
        &arg_resp_file, 0 );

    // Входной поток.
    args_4::words_from_argv_t   words( argc, argv );
    // Поток ошибок.
    args_4::iostream_error_stream_t error_stream;
    bool is_success = true;

    // Выполняем разбор.
    int error_code = parser.parse( words, &error_stream );
    if( args_4::c_ok == error_code )
    {
        // Разбор прошел успешно. Проводим дальнейший анализ.

        // Если есть response-файлы, то они должны быть
        // обработаны.
        if( arg_resp_file.is_defined() )
        {
            // Нужно обрабатывать response-файлы
            args_4::cmd_t * args[] = {
                &arg_file, &arg_file_path,
                &arg_reader, &arg4, &arg5, &arg6,
                &arg7, &arg8, &arg9,
                0
            };
            for( size_t i = 0, i_max =
                arg_resp_file.query_value_count();
                i != i_max; ++i )
                if( !parse_resp_file(
                    arg_resp_file.query_value( i ), args ) )
                    is_success = false;
        }

        // Анализ допустимости сочетаний некоторых
        // аргументов.

        if( !arg_reader.is_defined() ) {
            std::cerr << "reader name must be specified"
                << std::endl;
            is_success = false;
        }

        if( arg_file.is_defined() == arg_file_path.is_defined() ) {
            std::cerr << "either ’-file’ or ’-file-path’"
                " must be specified"
                << std::endl;
            is_success = false;
        }
    }
    else
        is_success = false;

    return is_success;
}

// Разбор аргументов и выполнение основной работы.
int
do_work(
    int argc, char ** argv )
{
    /* Аргумент ’-reader’ является обязательным. Но
        объект arg_reader специально объявляется
        необязательным аргументом. Сделано это из-за
        того, что при наличии response-файлов
        разбором аргументов будут заниматься несколько
        объектов-парсеров. Если бы arg_reader был
        обязательным аргументом, то часть
        объектов-парсеров выдавало бы ошибку о том,
        что обязательный аргумент ’-reader’ не определен.
        Хотя, на самом деле, этот аргумент определен
        в другом входном потоке, обрабатываемом
        другим парсером.
    */
    args_4::cmd_str_value_t arg_reader( "-reader", false );

    args_4::cmd_str_value_t arg_chv1( "-chv1", false );
    args_4::cmd_str_value_t arg_chv2( "-chv2", false );
    args_4::cmd_str_value_t arg_file( "-file", false );
    arg_file_path_t arg_file_path( "-file-path", false );
    args_4::cmd_on_off_switch_t arg_write( "-w", false );
    args_4::cmd_on_off_switch_t arg_ascii( "-ascii", false );
    args_4::cmd_uint_value_t arg_offset( "-offset", false );
    args_4::cmd_str_value_t arg_dbg_stream( "-dbg-stream", false );

    // Производим разбор аргументов.
    if( parse_args( argc, argv, arg_file, arg_file_path,
        arg_reader, arg_chv1, arg_chv2, arg_write,
        arg_ascii, arg_offset, arg_dbg_stream ) )
    {
//Часть кода про проверке допустимости значений некоторых
//аргументов изъята.

        return do_main_work( arg_reader.query_value(),
            arg_file_path, arg_chv1, arg_chv2,
            arg_offset, arg_write.is_defined(),
            arg_ascii.is_defined(),
            arg_dbg_stream );
    }

    return c_invalid_argv;
}

int
show_usage_and_exit() {
    std::cout << "SmartCard file viewer and editor (in hex format)\n"
        "sc_hed <args>*\n"
        "where args are:\n"
        "\t-reader <reader name> (mandatory)\n"
        "\t-chv1 <CHV1 value>\n"
        "\t-chv2 <CHV2 value>\n"
        "\t-file <GSM file name>\n"
        "\t-file-path <XXXX[/XXXX[/XXXX[...]]]>\n"
        "\t-w\n"
        "\t-offset <offset | record num>\n"
        "\t-ascii\n"
        "\t-dbg-stream <file name>\n"
        "\t@<file name>\n"
        "Either ’-file’ or ’-file-path’ must be specified.\n"
        "Data will be read from standard input"
        << std::endl;

    return 0;
}

int
main( int argc, char ** argv )
{
    // Если не задано аргументов, то печатаем справку и
    // завершаемся. Если аргументы заданы, то пытаемся
    // их разобрать и выполнить работу.
    return ( 1 == argc ?
        show_usage_and_exit() :
        do_work( argc, argv ) );
}

Оглавление

Глава 1args-4 Титульная страница

1.1 Что такое args-4

1.1.1 История

1.2 Аргументы и параметры

1.3 Применение args-4

Глава 2args-4 Алфавитный указатель пространства имен

2.1 args-4 Пространства имен

Глава 3args-4 Иерархический список классов

3.1 args-4 Иерархия классов

Глава 4args-4 Алфавитный указатель классов

4.1 args-4 Классы

Глава 5args-4 Список файлов

5.1 args-4 Файлы

Глава 6args-4 Пространства имен

6.1 Пространство имен args_4

6.1.1 Подробное описание

Классы

Переменные

6.1.2 Переменные

6.1.2.1 const int args_4::c_new_line_in_string = 504

6.1.2.2 const int args_4::c_quote_in_word = 506

Глава 7args-4 Классы

7.1 Класс args_4::cmd_on_off_switch_t

7.1.1 Подробное описание

Открытые члены

Защищенные данные

7.1.2 Конструктор(ы)

7.1.2.1 args_4::cmd_on_off_switch_t::cmd_on_off_switch_t (const char * name, bool mandatory)

7.1.3 Методы

7.1.3.1 bool args_4::cmd_on_off_switch_t::is_defined () const [virtual]

7.1.3.2 bool args_4::cmd_on_off_switch_t::is_mandatory () const [virtual]

7.1.3.3 int args_4::cmd_on_off_switch_t::process_params (word_container_t & words, error_stream_t * error_stream) [virtual]

7.1.4 Данные класса

7.1.4.1 bool args_4::cmd_on_off_switch_t::m_is_defined [protected]

7.1.4.2 bool args_4::cmd_on_off_switch_t::m_is_mandatory [protected]

7.2 Класс args_4::cmd_parser_t

7.2.1 Подробное описание

Открытые члены

Защищенные члены

Защищенные данные

7.2.2 Конструктор(ы)

7.2.2.1 args_4::cmd_parser_t::cmd_parser_t (bool is_word_backing_enabled = false)

7.2.3 Методы

7.2.3.1 void args_4::cmd_parser_t::add_cmds (cmd_t * p1, ...)

7.2.3.2 cmd_t * args_4::cmd_parser_t::find_cmd_by_name (const char * name) [protected]

7.2.3.3 int args_4::cmd_parser_t::parse (word_container_t & words, error_stream_t * error_stream)

7.2.3.4 int args_4::cmd_parser_t::process_cmd (const char * name, word_container_t & words) [protected]

7.2.4 Данные класса

7.2.4.1 error_stream_t*args_4::cmd_parser_t::m_error_stream [protected]

7.3 Класс args_4::cmd_response_file_t

7.3.1 Подробное описание

Открытые члены

Защищенные данные

7.3.2 Конструктор(ы)

7.3.2.1 args_4::cmd_response_file_t::cmd_response_file_t (char first_char = ’@’)

7.3.3 Методы

7.3.3.1 bool args_4::cmd_response_file_t::compare_name (const char * name) const [virtual]

7.3.3.2 int args_4::cmd_response_file_t::process_params (word_container_t & words, error_stream_t * error_stream) [virtual]

7.3.4 Данные класса

7.3.4.1 char args_4::cmd_response_file_t::m_first_char [protected]

7.4 Класс args_4::cmd_str_value_t

7.4.1 Подробное описание

Открытые члены

Защищенные данные

7.4.2 Конструктор(ы)

7.4.2.1 args_4::cmd_str_value_t::cmd_str_value_t (const char * name, bool mandatory)

7.4.3 Методы

7.4.3.1 bool args_4::cmd_str_value_t::is_defined () const [virtual]

7.4.3.2 bool args_4::cmd_str_value_t::is_mandatory () const [virtual]

7.4.3.3 int args_4::cmd_str_value_t::process_params (word_container_t & words, error_stream_t * error_stream) [virtual]

7.4.3.4 const char * args_4::cmd_str_value_t::query_value () const

7.4.4 Данные класса

7.4.4.1 bool args_4::cmd_str_value_t::m_is_defined [protected]

7.4.4.2 bool args_4::cmd_str_value_t::m_is_mandatory [protected]

7.4.4.3 char*args_4::cmd_str_value_t::m_value [protected]

7.5 Класс args_4::cmd_strvector_value_t

7.5.1 Подробное описание

Открытые члены

Защищенные данные

Глава 1
args-4 Титульная страница

Глава 2
args-4 Алфавитный указатель пространства имен

Глава 3
args-4 Иерархический список классов

Глава 4
args-4 Алфавитный указатель классов

Глава 5
args-4 Список файлов

Глава 6
args-4 Пространства имен

Глава 7
args-4 Классы