aux::tokenizer::token tk = m_tok.current_token();

  if (is_command(tk))
  {
    if (std::strncmp(tk.ptr, "#PAGE_PLOT", tk.len) == 0)
    {
      parse_page_plot_cmd();
    }
    else
    if (std::strncmp(tk.ptr, "#WELL", tk.len) == 0)
    {
      parse_well_cmd();
    }
    else
    if (std::strncmp(tk.ptr, "#PWDW", tk.len) == 0)
    {
      parse_pwdw_cmd();
    }
    else
    if ()
    // . . .
    // и дальше штук двадцать

the_map[tk.ptr]();

is_command(tk) ? !std::strncmp(tk.ptr, "#PAGE_PLOT", tk.len) ? parse_page_plot_cmd() : !std::strncmp(tk.ptr, "#WELL", tk.len) ? parse_well_cmd() : .......

K>  aux::tokenizer::token tk = m_tok.current_token();

K>  if (is_command(tk))
K>  {
K>    if (std::strncmp(tk.ptr, "#PAGE_PLOT", tk.len) == 0)
K>    {
K>      parse_page_plot_cmd();
K>    }
K>    else
K>    if (std::strncmp(tk.ptr, "#WELL", tk.len) == 0)
K>    {
K>      parse_well_cmd();
K>    }
K>    else
K>    if (std::strncmp(tk.ptr, "#PWDW", tk.len) == 0)
K>    {
K>      parse_pwdw_cmd();
K>    }
K>    else
K>    if ()
K>    // . . .
K>    // и дальше штук двадцать
K>

struct ComandInfo {
   const char* name;
   void (*handler) ();
};
static const CommandInfo COMMANDS [] = {
   { "#PAGE_PLOT", &parse_page_plot_cmd },
   ...
};

for (int i = 0; i != ARRAY_SIZE (COMMANDS); ++i) {
   if (strncmp (COMMANDS [i].name, tk.ptr) == 0) {
      COMMANDS [i].handler ();
      break;
   }
}

V>the_map[tk.ptr]();
V>

parser::parser()
{
  m_handlers_map["#PAGE_PLOT"] = &parse_page_plot_cmd();
  m_handlers_map["#WELL"]      = &parse_well_cmd();
  m_handlers_map["#PWDW"]      = &parse_pwdw_cmd();
  // . . .
}

void parser::parse_line(const char* line)
{
  m_tok.set_str(line);

  if (m_tok.next())
  {
    aux::tokenizer::token tk = m_tok.current_token();

    if (is_command(tk))
    {
      the_map[std::string(tk.ptr, tk.len)]();
    }
  }
}

V>Не ГИС часом пишешь?

>   aux::tokenizer::token tk = m_tok.current_token();
>
>   if (is_command(tk))
>   {
>     if (std::strncmp(tk.ptr, "#PAGE_PLOT", tk.len) == 0)
>     {
>       parse_page_plot_cmd();
>     }
>     else
>     if (std::strncmp(tk.ptr, "#WELL", tk.len) == 0)
>     {
>       parse_well_cmd();
>     }
>     else
>     if (std::strncmp(tk.ptr, "#PWDW", tk.len) == 0)
>     {
>       parse_pwdw_cmd();
>     }
>     else
>     if ()
>     // . . .
>     // и дальше штук двадцать
>

typedef void(function_t)();
function_t* functions[N];
// ...
if(is_command(tk))
{
     size_t const h(hash(tk));
     if(h < N)
         functions[h]();
}

K>  aux::tokenizer::token tk = m_tok.current_token();

K>  if (is_command(tk))
K>  {
K>    if (std::strncmp(tk.ptr, "#PAGE_PLOT", tk.len) == 0)
K>    {
K>      parse_page_plot_cmd();
K>    }
K>    else
K>    if (std::strncmp(tk.ptr, "#WELL", tk.len) == 0)
K>    {
K>      parse_well_cmd();
K>    }
K>    else
K>    if (std::strncmp(tk.ptr, "#PWDW", tk.len) == 0)
K>    {
K>      parse_pwdw_cmd();
K>    }
K>    else
K>    if ()
K>    // . . .
K>    // и дальше штук двадцать
K>

inline int compare(const aux::tokenizer::token& tk, const char* s)
{
  return std::strncmp(tk.ptr, s, tk.len);
}

struct less_token
{
  typedef aux::tokenizer::token token;

  bool operator()(const char* lhs, const char* rhs) const { return strcmp(lhs,rhs)<0; }
  bool operator()(const token& lhs, const char* rhs) const { return compare(lhs,rhs)<0; }
  bool operator()(const char* lhs, const token& rhs) const { return compare(rhs,lhs)>0; }
};
struct match_token
{
  typedef aux::tokenizer::token token;

  bool operator()(const char* lhs, const char* rhs) const { return strcmp(lhs,rhs)==0; }
  bool operator()(const token& lhs, const char* rhs) const { return compare(lhs,rhs)==0; }
  bool operator()(const char* lhs, const token& rhs) const { return compare(rhs,lhs)==0; }
};

typedef std::pair<const char*, void (YourClass::*)()> command_entry;

const command_entry commands[] =
{
  std::make_pair("#PAGE_PLOT", &YourClass::parse_page_plot_cmd),
  std::make_pair("#WELL",      &YourClass::parse_well_cmd),
  ...
};
const size_t commands_count = sizeof(commands)/sizeof(commands[0]);
const command_entry* commands_end = commands + commands_count;

struct match_command
{
  bool operator()(const command_entry& lhs, const token& rhs) const { return compare(rhs, lhs.first) == 0; }
};

YourClass::parse()
{
  aux::tokenizer::token tk = m_tok.current_token();
  command_entry* cmd = std::find_if(commands, commands_end, tk, match_command());
  if(cmd != commands_end)
    (this->*(cmd->second))();
}

inline UINT    hash(const char* str)
{
    UINT nHash = 0;
    while (*str)
        nHash = (nHash<<5) + nHash + *str++;
    return nHash;
}

inline UINT    hash(const char* str, size_t count)
{
    UINT nHash = 0;
    size_t    i = 0;
    while ( i<count )
        nHash = (nHash<<5) + nHash + str[i++];
    return nHash;
}

typedef    void (*PFn)();
typedef    std::map<UINT, PFn>    func_map_t;

void F1()
{
}

void F2()
{
}

void F3()
{
}

int _tmain(int argc, _TCHAR* argv[])
{
    func_map_t    handlers;
    handlers[hash("#PAGE_PLOT")] = F1;
    handlers[hash("#WELL")] = F2;
    handlers[hash("#PWDW")] = F3;

    handlers[hash("#WELL")]();

    return 0;
}

>> typedef std::pair<const char*, void (YourClass::*)()> command_entry;
ME>// ...
>>     (this->*(cmd->second))();
>> }
>>

ME>А простые ф-ции нынче в опале?

std::pair<const char*, void(*)()>

make_pair("xxx", parse_xxx)

(cmd->second)()

typedef void (*ParseFunc)(YourContext*);

std::pair<const char*, ParseFunc>

this_context->m_tok

(cmd->second)(this_context)

_>Насколько я понял словарь фиксированный, тогда можно сделать для него ДКА (детерминированный конечный автомат). Если памяти не жалко, то можно сделать O(m), где m — длина конкретной строки, а не количество слов в словаре, т.е. очень быстро . Пример как делать ДКА

Автор: sergey_shandar
Дата: 13.04.04

.

aux::tokenizer::token tk = m_tok.current_token();
...

К>YourClass::parse()
К>{
К>  aux::tokenizer::token tk = m_tok.current_token();
К>  command_entry* cmd = std::find_if(commands, commands_end, tk, match_command());
К>  if(cmd != commands_end)
К>    (this->*(cmd->second))();
К>}
К>

 (this->*(cmd->second))();

K>  aux::tokenizer::token tk = m_tok.current_token();

K>  if (is_command(tk))
K>  {
K>    if (std::strncmp(tk.ptr, "#PAGE_PLOT", tk.len) == 0)
K>    {
K>      parse_page_plot_cmd();
K>    }
K>    else
K>    if (std::strncmp(tk.ptr, "#WELL", tk.len) == 0)
K>    {
K>      parse_well_cmd();
K>    }
K>    else
K>    if (std::strncmp(tk.ptr, "#PWDW", tk.len) == 0)
K>    {
K>      parse_pwdw_cmd();
K>    }
K>    else
K>    if ()
K>    // . . .
K>    // и дальше штук двадцать
K>

#include <iostream>
#include <map>

#include <windows.h>


// #PAGE_PLOT
// #WELL
// #PWDW



int automata_parse( const char* input, int* automata[] )
{
    int state_num = 1;
    while( true )
    {
        state_num = (automata[ state_num ])[ *input ++ ];
        if( state_num == 0 ) return 0;
        else if( state_num == 17 ) return 1;
        else if( state_num == 18 ) return 2;
        else if( state_num == 19 ) return 3;
    }


    return 0;
}

int map_parse( const char* input, std::map< const char*, int>& map_ )
{
    return map_[ input ];
}


int main()
{

        int state1[ 256 ] = {0};
    state1[ '#' ] = 2;

    int state2[ 256 ] = {0};
    state2[ 'P' ] = 3;
    state2[ 'W' ] = 14;

    int state3[ 256 ] = {0};
    state3[ 'A' ] = 4;
    state3[ 'W' ] = 5;

    int state4[ 256 ] = {0};
    state4[ 'G' ] = 6;

    int state6[ 256 ] = {0};
    state6[ 'E' ] = 7;

    int state7[ 256 ] = {0};
    state7[ '_' ] = 8;
        
    int state8[ 256 ] = {0};
    state8[ 'P' ] = 9;

    int state9[ 256 ] = {0};
    state9[ 'L' ] = 10;

    int state10[ 256 ] = {0};
    state10[ 'O' ] = 11;

    int state11[ 256 ] = {0};
    state11[ 'T' ] = 17;

    int state5[ 256 ] = {0};
    state5[ 'W' ] = 12;

    int state12[ 256 ] = {0};
    state12[ 'D' ] = 13;

    int state13[ 256 ] = {0};
    state13[ 'W' ] = 18;

    int state14[ 256 ] = {0};
    state14[ 'E' ] = 15;

    int state15[ 256 ] = {0};
    state15[ 'L' ] = 16;

    int state16[ 256 ] = {0};
    state16[ 'L' ] = 19;

    int* automata[] = { 0, state1, state2, state3, state4, state5, state6, state7, state8, state9, state10,
                        state11, state12, state13, state14, state15, state16, 0, 0, 0 };

    std::map< const char*, int > map_;
    map_[ "#PAGE_PLOT" ] = 1;
    map_[ "#PWDW" ] = 2;
    map_[ "#WELL" ] = 3;


    LARGE_INTEGER  first;
    QueryPerformanceCounter( &first );
    std::cout << automata_parse( "#WELL", automata ) << std::endl;
//    std::cout << map_parse( "#WELL", map_ ) << std::endl;
    LARGE_INTEGER  second;
    QueryPerformanceCounter( &second );
    std::cout << "time = " << (DWORD)(second.QuadPart-first.QuadPart) << std::endl;

    return 0;
}