趣味编程：从字符串中提取信息（C语言版本）

大概就是如下一个字符串

cpu-3.0g--color-red-green-black--price-5000-8000--weight-'3-'--keywords-'levi''s'

要拆分成如下格式

{ "cpu", "3.0g" },

{ "color", "red", "green", "black" },

{ "price", "5000", "8000" },

{ "weight", "3-" },

{ "keywords", "levi's" }, 

原题目要求地址如下

http://www.cnblogs.com/JeffreyZhao/archive/2009/10/12/code-for-fun-tokenizer.html 

老赵的C#语言版本如下 

http://www.cnblogs.com/JeffreyZhao/archive/2009/10/21/code-for-fun-tokenizer-answer-1.html

最近学C语言， 我翻译成c语言的了，在dev-c++4.9.9.2编译运行通过，代码如下

代码

#include  < stdio.h >

#define  MAX_TOKEN_LEN  20

const  e_arg_invalid  =   - 1 ;
const  e_token_overfllow  =   - 2 ;
const  s_ok  =   0 ;
int  last_error  =   0 ;

void *  p1( char  ch);
void *  p2( char  ch);
void *  p3( char  ch);
void *  p4( char  ch);
void *  p5( char  ch);

typedef  void *  ( * fn_parse)( char  c);
void  aggregate(fn_parse parse,  char *  input){
      while ( * input  !=   ' /0 ' ){
         if (last_error  ==  s_ok){
            parse  =  (fn_parse)( * parse)( * input);
            input ++ ;
        } else {
            printf( " ocurr an error:%d " , last_error);
             break ;
        }
     }
}

struct  token{
        char *  inner_token;
        int  index;
};
void  append( struct  token *  t,  char  ch){
      if (t  ->  index ++   >  MAX_TOKEN_LEN){
         last_error  =  e_token_overfllow;
          return ;
     }
     t  ->  inner_token[ t  ->  index ]  =  ch;
}
struct  token *  current_token;
void  reset(){
   current_token  =  ( struct  token * )malloc( sizeof ( struct  token));
   current_token  ->  inner_token  =  ( char * )calloc(MAX_TOKEN_LEN,  sizeof ( char ));
   current_token  ->  index  =   - 1 ;
}

struct  token_group{
        struct  token **  tokens;
        int  index;
};
void  append2( struct  token_group *  g,  struct  token *  t){
    struct  token *  tt;
   
    if ( g  ->  index ++   >  MAX_TOKEN_LEN ){
      last_error  =  e_token_overfllow;
       return ;
   }
   tt  =  g  ->  tokens[ 0 ];
   g  ->  tokens[g  ->  index]  =  t;
}            
struct  token_group *  current_group;
void  reset2(){
   current_group  =  ( struct  token_group * )malloc( sizeof ( struct  token_group));
   current_group  ->  index  =   - 1 ;
   current_group  ->  tokens  =  ( struct  token ** )calloc(MAX_TOKEN_LEN,  sizeof ( struct  token ** ));
}

struct  parse_result{
    struct  token_group **  groups;
    int  index;

};
void  append3( struct  parse_result *  ret, struct  token_group *  g){
   if ( ret  ->  index ++   >  MAX_TOKEN_LEN ){
      last_error  =  e_token_overfllow;
       return ;
  }
  ret  ->  groups[ret  ->  index]  =  g;
}            
struct  parse_result *  result;
void  reset3(){
   result  =  ( struct  parse_result * )malloc( sizeof ( struct  parse_result));
   result  ->  index  =   - 1 ;
   result  ->  groups  =  ( struct  token_group ** )calloc(MAX_TOKEN_LEN,  sizeof ( struct  token_group ** ));
}

void *  p1( char  ch){
    if  (ch  ==   ' - ' ){
      last_error  =  e_arg_invalid;
       return  NULL;
   }
    if  (ch  ==   ' / '' ){
       return  p5;
   }
    else {
      append(current_token,  ch );
       return  p4;
   }
}

void *  p2( char  ch){
    if  (ch  ==   ' - ' ){
      append3(result, current_group );
      reset2();
       return  p1;
   }
    else   if  (ch  ==   ' / '' ){
       return  p5;
   }
    else {
      append(current_token, ch);
       return  p4;
   }
}
void *  p3( char  ch){
    if  (ch  ==   ' / '' ){
      append(current_token,  ' / '' );
       return  p5;
   }
    else   if  (ch  ==   ' - ' ){
      append2(current_group, current_token);
      reset();
       return  p2;
   }
    else {
      last_error  =  e_arg_invalid;
       return  NULL;
   }
}
void *  p4( char  ch){
    if  (ch  ==   ' / '' ){
      last_error  =  e_arg_invalid;
       return  NULL;
   }
    if  (ch  ==   ' - ' ){
      append2(current_group, current_token);
      reset();
       return  p2;
   }
    else {
      append(current_token, ch);
       return  p4;
   }
}
void *  p5( char  ch){
    if  (ch  ==   ' / '' ){
       return  p3;
   }
    else  {
      append(current_token, ch);
       return  p5;
   }
}

void  test_parse(){
    int  i, j;
    struct  token_group *  group;
    struct  token *  t;
   
   reset();
   reset2();
   reset3();
   
    char *  str  =   " cpu-3.0g--color-red-green-black--price-5000-8000--weight-'3-'--keywords-'levi''s' " ;
   aggregate( & p1, str);
   append2(current_group, current_token);
   append3(result, current_group );

    for (i  =   0 ; i  <=  result  ->  index; i ++ ){
      group  =  result  ->  groups[i];
      printf( " group:%d/r/n " , i);
       for (j  =   0 ; j  <=  group  ->  index; j ++ ){
         t  =  group  ->  tokens[j];
         printf( " /ttoken:%d-%s/r/n " , j, t  ->  inner_token);
      }      
   }
   
    for (i  =   0 ; i  <=  result  ->  index; i ++ ){
      group  =  result  ->  groups[i];
       for (j  =   0 ; j  <=  group  ->  index; j ++ ){
         t  =  group  ->  tokens[j];
         free(t  ->  inner_token);
         free(t);
      }
      free(group  ->  tokens);
      free(group);
   }
   free(result  ->  groups);
}

int  main( void )
{
     int  key;
    test_parse();
    scanf( " %d " , & key);        
}

 

运行结果如下：

group:0

        token:0-cpu

        token:1-3.0g

group:1

        token:0-color

        token:1-red

        token:2-green

        token:3-black

group:2

        token:0-price

        token:1-5000

        token:2-8000

group:3

        token:0-weight

        token:1-3-

group:4

        token:0-keywords

        token:1-levi's