remove old tokenchecker.

git-svn-id: http://svn.sourceforge.jp/svnroot/bchan/bchan/trunk@48 20a0b8eb-f62a-4a12-8fe1-b598822500fb

diff --git a/src/parselib.c b/src/parselib.c
index 7bc85a8..0aaab98 100644 (file)
--- a/src/parselib.c
+++ b/src/parselib.c
@@ -40,95 +40,10 @@
 # define DP_ER(msg, err) /**/
 #endif
 
-EXPORT VOID tokenchecker_initialize(tokenchecker_t *checker, tokenchecker_valuetuple_t *namelist, B *endchars)
-{
-       W i;
-
-       for (i=1;;i++) {
-               if (namelist[i].name == NULL) {
-                       break;
-               }
-       }
-
-       checker->NameList = namelist;
-       checker->num_of_list = i;
-       checker->pos_of_EachString = 0;
-       checker->StartIndex_of_list = 1;
-       checker->EndIndex_of_list = i;
-       checker->flg_notexist = 0;
-       checker->endtokens = endchars;
-}
-
-EXPORT VOID tokenchecker_resetstate(tokenchecker_t *checker)
-{
-       checker->pos_of_EachString = 0;
-       checker->StartIndex_of_list = 1;
-       checker->EndIndex_of_list = checker->num_of_list;
-       checker->flg_notexist = 0;
-}
-
-EXPORT W tokenchecker_inputcharacter(tokenchecker_t *checker, UB c)
-{
-       W i;
-       tokenchecker_valuetuple_t *NameList = checker->NameList;
-
-       for (i=0;;i++) {
-               if ((checker->endtokens)[i] == '\0') {
-                       break;
-               }
-               if (c == (checker->endtokens)[i]) {
-                       if (checker->flg_notexist) {
-                               return TOKENCHECK_NOMATCH;
-                       }
-                       if ((NameList[checker->StartIndex_of_list]).name[checker->pos_of_EachString] == '\0') {
-                               /*List's Name End and receive EndToken = found match string*/
-                               return (NameList[checker->StartIndex_of_list]).val;
-                       }
-                       /*List's Name continue but receive endtoken.*/
-                       return TOKENCHECK_NOMATCH;
-               }
-       }
-
-       if (checker->flg_notexist) {
-               return TOKENCHECK_NOMATCH;
-       }
-
-       for (i=checker->StartIndex_of_list;i<checker->EndIndex_of_list;i++) {
-               if ( (NameList[i]).name[checker->pos_of_EachString] == c ) {
-                       break;
-               }
-       }
-       if (i==checker->EndIndex_of_list) { /*receive char is not matched.*/
-               checker->flg_notexist = 1;
-               return TOKENCHECK_NOMATCH;
-       }
-       checker->StartIndex_of_list = i;
-       for (i=i+1;i<checker->EndIndex_of_list;i++) {
-               if ( (NameList[i]).name[checker->pos_of_EachString] != c ) {
-                       break;
-               }
-       }
-       checker->EndIndex_of_list = i;
-
-       if ((NameList[checker->StartIndex_of_list]).name[checker->pos_of_EachString] == '\0') {
-               /*Don't recive endtoken but List's Name is end.*/
-               checker->flg_notexist = 1;
-               return TOKENCHECK_NOMATCH;
-       }
-       checker->pos_of_EachString++;
-       return TOKENCHECK_CONTINUE;
-}
-
-EXPORT VOID tokenchecker_getparsingstring(tokenchecker_t *checker, UB **str, W *len)
-{
-       *str = (checker->NameList[checker->StartIndex_of_list]).name;
-       *len = checker->pos_of_EachString + 1;
-}
-
-#define TOKENCHECKER2_FLAG_NOTEXIST 0x00000001
-#define TOKENCHECKER2_FLAG_AFTERENDCHAR 0x00000002
+#define TOKENCHECKER_FLAG_NOTEXIST 0x00000001
+#define TOKENCHECKER_FLAG_AFTERENDCHAR 0x00000002
 
-EXPORT VOID tokenchecker2_initialize(tokenchecker2_t *checker, tokenchecker_valuetuple_t *namelist, W namelistnum, B *endchars)
+EXPORT VOID tokenchecker_initialize(tokenchecker_t *checker, tokenchecker_valuetuple_t *namelist, W namelistnum, B *endchars)
 {
        checker->namelist = namelist;
        checker->namelistnum = namelistnum;
@@ -139,7 +54,7 @@ EXPORT VOID tokenchecker2_initialize(tokenchecker2_t *checker, tokenchecker_valu
        checker->flag = 0;
 }
 
-EXPORT VOID tokenchecker2_clear(tokenchecker2_t *checker)
+EXPORT VOID tokenchecker_clear(tokenchecker_t *checker)
 {
        checker->stringindex = 0;
        checker->listindex_start = 0;
@@ -147,13 +62,13 @@ EXPORT VOID tokenchecker2_clear(tokenchecker2_t *checker)
        checker->flag = 0;
 }
 
-EXPORT W tokenchecker2_inputchar(tokenchecker2_t *checker, UB c, W *val)
+EXPORT W tokenchecker_inputchar(tokenchecker_t *checker, UB c, W *val)
 {
        W i;
        tokenchecker_valuetuple_t *namelist = checker->namelist;
 
-       if ((checker->flag & TOKENCHECKER2_FLAG_AFTERENDCHAR) != 0) {
-               return TOKENCHECKER2_AFTER_END;
+       if ((checker->flag & TOKENCHECKER_FLAG_AFTERENDCHAR) != 0) {
+               return TOKENCHECKER_AFTER_END;
        }
 
        for (i = 0;; i++) {
@@ -161,22 +76,22 @@ EXPORT W tokenchecker2_inputchar(tokenchecker2_t *checker, UB c, W *val)
                        break;
                }
                if (c == (checker->endtokens)[i]) {
-                       checker->flag |= TOKENCHECKER2_FLAG_AFTERENDCHAR;
-                       if ((checker->flag & TOKENCHECKER2_FLAG_NOTEXIST) != 0) {
-                               return TOKENCHECKER2_NOMATCH;
+                       checker->flag |= TOKENCHECKER_FLAG_AFTERENDCHAR;
+                       if ((checker->flag & TOKENCHECKER_FLAG_NOTEXIST) != 0) {
+                               return TOKENCHECKER_NOMATCH;
                        }
                        if ((namelist[checker->listindex_start]).name[checker->stringindex] == '\0') {
                                /*List's Name End and receive EndToken = found match string*/
                                *val = (namelist[checker->listindex_start]).val;
-                               return TOKENCHECKER2_DETERMINE;
+                               return TOKENCHECKER_DETERMINE;
                        }
                        /*List's Name continue but receive endtoken.*/
-                       return TOKENCHECKER2_NOMATCH;
+                       return TOKENCHECKER_NOMATCH;
                }
        }
 
-       if ((checker->flag & TOKENCHECKER2_FLAG_NOTEXIST) != 0) {
-               return TOKENCHECKER2_CONTINUE_NOMATCH;
+       if ((checker->flag & TOKENCHECKER_FLAG_NOTEXIST) != 0) {
+               return TOKENCHECKER_CONTINUE_NOMATCH;
        }
 
        for (i = checker->listindex_start; i < checker->listindex_end; i++) {
@@ -185,8 +100,8 @@ EXPORT W tokenchecker2_inputchar(tokenchecker2_t *checker, UB c, W *val)
                }
        }
        if (i == checker->listindex_end) { /*receive char is not matched.*/
-               checker->flag &= TOKENCHECKER2_FLAG_NOTEXIST;
-               return TOKENCHECKER2_CONTINUE_NOMATCH;
+               checker->flag &= TOKENCHECKER_FLAG_NOTEXIST;
+               return TOKENCHECKER_CONTINUE_NOMATCH;
        }
        checker->listindex_start = i;
        for (i = i+1; i < checker->listindex_end; i++) {
@@ -198,15 +113,15 @@ EXPORT W tokenchecker2_inputchar(tokenchecker2_t *checker, UB c, W *val)
 
        if ((namelist[checker->listindex_start]).name[checker->stringindex] == '\0') {
                /*Don't recive endtoken but List's Name is end.*/
-               checker->flag |= TOKENCHECKER2_FLAG_NOTEXIST;
-               return TOKENCHECKER2_CONTINUE_NOMATCH;
+               checker->flag |= TOKENCHECKER_FLAG_NOTEXIST;
+               return TOKENCHECKER_CONTINUE_NOMATCH;
        }
        checker->stringindex++;
 
-       return TOKENCHECKER2_CONTINUE;
+       return TOKENCHECKER_CONTINUE;
 }
 
-EXPORT VOID tokenchecker2_getlastmatchedstring(tokenchecker2_t *checker, UB **str, W *len)
+EXPORT VOID tokenchecker_getlastmatchedstring(tokenchecker_t *checker, UB **str, W *len)
 {
        *str = (checker->namelist[checker->listindex_start]).name;
        *len = checker->stringindex;
@@ -257,7 +172,7 @@ EXPORT charreferparser_result_t charreferparser_parsechar(charreferparser_t *par
                }
                /* TODO */
                parser->state = NAMED;
-               tokenchecker2_inputchar(&parser->named, ch, &val);
+               tokenchecker_inputchar(&parser->named, ch, &val);
                parser->charnumber = -1;
                return CHARREFERPARSER_RESULT_CONTINUE;
        case RECIEVE_NUMBER:
@@ -294,9 +209,9 @@ EXPORT charreferparser_result_t charreferparser_parsechar(charreferparser_t *par
                }
                return CHARREFERPARSER_RESULT_INVALID;
        case NAMED:
-               ret = tokenchecker2_inputchar(&parser->named, ch, &val);
+               ret = tokenchecker_inputchar(&parser->named, ch, &val);
                if (ch == ';') {
-                       if (ret == TOKENCHECKER2_DETERMINE) {
+                       if (ret == TOKENCHECKER_DETERMINE) {
                                parser->charnumber = val;
                        }
                        parser->state = DETERMINED;
@@ -328,14 +243,14 @@ EXPORT VOID charreferparser_resetstate(charreferparser_t *parser)
 {
        parser->state = START;
        parser->charnumber = 0;
-       tokenchecker2_clear(&(parser->named));
+       tokenchecker_clear(&(parser->named));
 }
 
 EXPORT W charreferparser_initialize(charreferparser_t *parser)
 {
        parser->state = START;
        parser->charnumber = 0;
-       tokenchecker2_initialize(&(parser->named), nList_nameref, 4, eToken_nameref);
+       tokenchecker_initialize(&(parser->named), nList_nameref, 4, eToken_nameref);
        return 0;
 }
 

diff --git a/src/parselib.h b/src/parselib.h
index ec4a844..3fe3155 100644 (file)
--- a/src/parselib.h
+++ b/src/parselib.h
@@ -37,25 +37,6 @@ struct tokenchecker_valuetuple_t_ {
 
 typedef struct  tokenchecker_t_ tokenchecker_t;
 struct  tokenchecker_t_ {
-       tokenchecker_valuetuple_t *NameList;
-       W num_of_list;
-       W pos_of_EachString;
-       W StartIndex_of_list;
-       W EndIndex_of_list;
-       W flg_notexist;
-       B *endtokens;
-};
-
-#define TOKENCHECK_CONTINUE 0
-#define TOKENCHECK_NOMATCH -1
-
-IMPORT VOID tokenchecker_initialize(tokenchecker_t *checker, tokenchecker_valuetuple_t *namelist, B *endchars);
-IMPORT VOID tokenchecker_resetstate(tokenchecker_t *checker);
-IMPORT W tokenchecker_inputcharacter(tokenchecker_t *checker, UB c);
-IMPORT VOID tokenchecker_getparsingstring(tokenchecker_t *checker, UB **str, W *len);
-
-typedef struct  tokenchecker2_t_ tokenchecker2_t;
-struct  tokenchecker2_t_ {
        tokenchecker_valuetuple_t *namelist;
        W namelistnum;
        B *endtokens;
@@ -66,18 +47,18 @@ struct  tokenchecker2_t_ {
 };
 
 enum {
-       TOKENCHECKER2_CONTINUE,
-       TOKENCHECKER2_CONTINUE_NOMATCH,
-       TOKENCHECKER2_DETERMINE,
-       TOKENCHECKER2_NOMATCH,
-       TOKENCHECKER2_AFTER_END
+       TOKENCHECKER_CONTINUE,
+       TOKENCHECKER_CONTINUE_NOMATCH,
+       TOKENCHECKER_DETERMINE,
+       TOKENCHECKER_NOMATCH,
+       TOKENCHECKER_AFTER_END
 };
 
-IMPORT VOID tokenchecker2_initialize(tokenchecker2_t *checker, tokenchecker_valuetuple_t *namelist, W namelistnum, B *endchars);
-IMPORT VOID tokenchecker2_finalize(tokenchecker2_t *checker);
-IMPORT VOID tokenchecker2_clear(tokenchecker2_t *checker);
-IMPORT W tokenchecker2_inputchar(tokenchecker2_t *checker, UB c, W *val);
-IMPORT VOID tokenchecker2_getlastmatchedstring(tokenchecker2_t *checker, UB **str, W *len);
+IMPORT VOID tokenchecker_initialize(tokenchecker_t *checker, tokenchecker_valuetuple_t *namelist, W namelistnum, B *endchars);
+IMPORT VOID tokenchecker_finalize(tokenchecker_t *checker);
+IMPORT VOID tokenchecker_clear(tokenchecker_t *checker);
+IMPORT W tokenchecker_inputchar(tokenchecker_t *checker, UB c, W *val);
+IMPORT VOID tokenchecker_getlastmatchedstring(tokenchecker_t *checker, UB **str, W *len);
 
 typedef struct charreferparser_t_ charreferparser_t;
 struct charreferparser_t_ {
@@ -91,7 +72,7 @@ struct charreferparser_t_ {
                INVALID,
                DETERMINED
        } state;
-       tokenchecker2_t named;
+       tokenchecker_t named;
        W charnumber;
 };
 

diff --git a/src/parser.c b/src/parser.c
index c633f3a..d59ced8 100644 (file)
--- a/src/parser.c
+++ b/src/parser.c
@@ -82,8 +82,8 @@ struct datparser_t_ {
                STATE_URL_SUBSTATE_SCHEME,
                STATE_URL_SUBSTATE_REM,
        } state_url_substate;
-       tokenchecker2_t elmname;
-       tokenchecker2_t urlscheme;
+       tokenchecker_t elmname;
+       tokenchecker_t urlscheme;
        charreferparser_t charref;
        datparser_res_t *resbuffer;
        W elmnameid;
@@ -357,10 +357,10 @@ LOCAL W datparser_parsechar_start_trigger(datparser_t *parser, UB ch, Bool issec
                }
                parser->state = STATE_CHARREF;
        } else {
-               ret = tokenchecker2_inputchar(&(parser->urlscheme), ch, &val);
-               if ((ret == TOKENCHECKER2_NOMATCH)||(ret == TOKENCHECKER2_CONTINUE_NOMATCH)) {
-                       tokenchecker2_clear(&(parser->urlscheme));
-               } else if (ret == TOKENCHECKER2_CONTINUE) {
+               ret = tokenchecker_inputchar(&(parser->urlscheme), ch, &val);
+               if ((ret == TOKENCHECKER_NOMATCH)||(ret == TOKENCHECKER_CONTINUE_NOMATCH)) {
+                       tokenchecker_clear(&(parser->urlscheme));
+               } else if (ret == TOKENCHECKER_CONTINUE) {
                        parser->state = STATE_URL;
                        parser->state_url_substate = STATE_URL_SUBSTATE_SCHEME;
                        return DATPARSER_PARSECHAR_CONTINUE;
@@ -404,14 +404,14 @@ LOCAL W datparser_parsechar_lstn_trigger(datparser_t *parser, UB ch, Bool isseco
        } else {
                parser->state = STATE_ELEMENT;
                parser->state_element_substate = STATE_ELEMENT_SUBSTATE_ELMNAME;
-               tokenchecker2_clear(&(parser->elmname));
-               ret = tokenchecker2_inputchar(&(parser->elmname), ch, &val);
-               if (ret == TOKENCHECKER2_NOMATCH) {
+               tokenchecker_clear(&(parser->elmname));
+               ret = tokenchecker_inputchar(&(parser->elmname), ch, &val);
+               if (ret == TOKENCHECKER_NOMATCH) {
                        parser->state_element_substate = STATE_ELEMENT_SUBSTATE_REM;
                        return DATPARSER_PARSECHAR_CONTINUE;
                }
-               if (!((ret == TOKENCHECKER2_CONTINUE)
-                         ||(ret == TOKENCHECKER2_CONTINUE_NOMATCH))) {
+               if (!((ret == TOKENCHECKER_CONTINUE)
+                         ||(ret == TOKENCHECKER_CONTINUE_NOMATCH))) {
                        return -1; /* TODO */
                }
        }
@@ -434,8 +434,8 @@ LOCAL W datparser_parsechar_element_trigger(datparser_t *parser, UB ch, Bool iss
                return DATPARSER_PARSECHAR_CONTINUE;
        }
 
-       ret = tokenchecker2_inputchar(&(parser->elmname), ch, &val);
-       if (ret == TOKENCHECKER2_NOMATCH) {
+       ret = tokenchecker_inputchar(&(parser->elmname), ch, &val);
+       if (ret == TOKENCHECKER_NOMATCH) {
                if ((ch == '>')&&(issecondbyte == False)) {
                        parser->state = STATE_START;
                } else {
@@ -444,11 +444,11 @@ LOCAL W datparser_parsechar_element_trigger(datparser_t *parser, UB ch, Bool iss
                }
                return DATPARSER_PARSECHAR_CONTINUE;
        }
-       if ((ret == TOKENCHECKER2_CONTINUE)
-               ||(ret == TOKENCHECKER2_CONTINUE_NOMATCH)) {
+       if ((ret == TOKENCHECKER_CONTINUE)
+               ||(ret == TOKENCHECKER_CONTINUE_NOMATCH)) {
                return DATPARSER_PARSECHAR_CONTINUE;
        }
-       if (ret == TOKENCHECKER2_DETERMINE) {
+       if (ret == TOKENCHECKER_DETERMINE) {
                if ((ch == '>')&&(issecondbyte == False)) {
                        err = datparser_appendconvertedelementinfo(parser, val, res);
                        if (err < 0) {
@@ -489,9 +489,9 @@ LOCAL W datparser_parsechar_url_trigger(datparser_t *parser, UB ch, Bool issecon
        UB *str;
 
        if (parser->state_url_substate == STATE_URL_SUBSTATE_SCHEME) {
-               ret = tokenchecker2_inputchar(&(parser->urlscheme), ch, &val);
-               if ((ret == TOKENCHECKER2_NOMATCH)||(ret == TOKENCHECKER2_CONTINUE_NOMATCH)) {
-                       tokenchecker2_getlastmatchedstring(&(parser->urlscheme), &str, &len);
+               ret = tokenchecker_inputchar(&(parser->urlscheme), ch, &val);
+               if ((ret == TOKENCHECKER_NOMATCH)||(ret == TOKENCHECKER_CONTINUE_NOMATCH)) {
+                       tokenchecker_getlastmatchedstring(&(parser->urlscheme), &str, &len);
                        err = datparser_outputconvertingstring(parser, str, len, res);
                        if (err < 0) {
                                return err;
@@ -500,7 +500,7 @@ LOCAL W datparser_parsechar_url_trigger(datparser_t *parser, UB ch, Bool issecon
                        if (err < 0) {
                                return err;
                        }
-                       tokenchecker2_clear(&(parser->urlscheme));
+                       tokenchecker_clear(&(parser->urlscheme));
                        if (ch == '<') {
                                parser->state = STATE_LSTN;
                        } else {
@@ -508,7 +508,7 @@ LOCAL W datparser_parsechar_url_trigger(datparser_t *parser, UB ch, Bool issecon
                        }
                        return DATPARSER_PARSECHAR_CONTINUE;
                }
-               if (ret == TOKENCHECKER2_CONTINUE) {
+               if (ret == TOKENCHECKER_CONTINUE) {
                        return DATPARSER_PARSECHAR_CONTINUE;
                }
 
@@ -516,7 +516,7 @@ LOCAL W datparser_parsechar_url_trigger(datparser_t *parser, UB ch, Bool issecon
                if (err < 0) {
                        return err;
                }
-               tokenchecker2_getlastmatchedstring(&(parser->urlscheme), &str, &len);
+               tokenchecker_getlastmatchedstring(&(parser->urlscheme), &str, &len);
                err = datparser_outputconvertingstring(parser, str, len, res);
                if (err < 0) {
                        return err;
@@ -526,7 +526,7 @@ LOCAL W datparser_parsechar_url_trigger(datparser_t *parser, UB ch, Bool issecon
                        return err;
                }
 
-               tokenchecker2_clear(&(parser->urlscheme));
+               tokenchecker_clear(&(parser->urlscheme));
                parser->state_url_substate = STATE_URL_SUBSTATE_REM;
        } else if (parser->state_url_substate == STATE_URL_SUBSTATE_REM) {
                if ((ch == ' ')||(ch == '\n')) { /* check other chars. */
@@ -643,8 +643,8 @@ EXPORT VOID datparser_clear(datparser_t *parser)
        parser->state = STATE_START;
 
        datparsr_res_clear(parser->resbuffer);
-       tokenchecker2_clear(&(parser->elmname));
-       tokenchecker2_clear(&(parser->urlscheme));
+       tokenchecker_clear(&(parser->elmname));
+       tokenchecker_clear(&(parser->urlscheme));
 }
 
 LOCAL tokenchecker_valuetuple_t nList_elmname[] = {
@@ -702,8 +702,8 @@ EXPORT datparser_t* datparser_new(datcache_t *cache)
                free(parser);
                return NULL;
        }
-       tokenchecker2_initialize(&(parser->elmname), nList_elmname, 8, eToken_elmname);
-       tokenchecker2_initialize(&(parser->urlscheme), nList_urlscheme, 3, eToken_urlscheme);
+       tokenchecker_initialize(&(parser->elmname), nList_elmname, 8, eToken_elmname);
+       tokenchecker_initialize(&(parser->urlscheme), nList_urlscheme, 3, eToken_urlscheme);
        charreferparser_initialize(&(parser->charref));
 
        return parser;

diff --git a/src/test_parselib.c b/src/test_parselib.c
index a355691..5397265 100644 (file)
--- a/src/test_parselib.c
+++ b/src/test_parselib.c
@@ -261,28 +261,28 @@ LOCAL UB test_tokenchecker_testdata_etoken_0001[] = ":>";
 
 LOCAL TEST_RESULT test_tokenchecker_1()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i, j, len, len2, val, ret;
        UB *str, *str2;
 
        str = strdup(test_tokenchecker_testdata_tuple_0001[0].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
 
        for (i = 0; i < len; i++) {
-               ret = tokenchecker2_inputchar(&checker, str[i], &val);
-               if (ret != TOKENCHECKER2_CONTINUE) {
-                       printf("tokenchecker2_inputchar fail: right string\n");
+               ret = tokenchecker_inputchar(&checker, str[i], &val);
+               if (ret != TOKENCHECKER_CONTINUE) {
+                       printf("tokenchecker_inputchar fail: right string\n");
                        free(str);
                        return TEST_RESULT_FAIL;
                }
-               tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+               tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
                if (strncmp(str, str2, len2) != 0) {
-                       printf("tokenchecker2_getlastmatchedstring fail: right string\n");
+                       printf("tokenchecker_getlastmatchedstring fail: right string\n");
                        printf(" ");
                        for (j = 0; j < len; j++) {
                                printf("%c", str[j]);
@@ -296,26 +296,26 @@ LOCAL TEST_RESULT test_tokenchecker_1()
                        return TEST_RESULT_FAIL;
                }
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_DETERMINE) {
-               printf("tokenchecker2_inputchar fail: end character\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_DETERMINE) {
+               printf("tokenchecker_inputchar fail: end character\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
        if (val != 1) {
-               printf("tokenchecker2_inputchar fail: select value\n");
+               printf("tokenchecker_inputchar fail: select value\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+       tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
        if (strncmp(str, str2, len2) != 0) {
-               printf("tokenchecker2_getlastmatchedstring fail: end token\n");
+               printf("tokenchecker_getlastmatchedstring fail: end token\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_AFTER_END) {
-               printf("tokenchecker2_inputchar fail: after end\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_AFTER_END) {
+               printf("tokenchecker_inputchar fail: after end\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
@@ -326,28 +326,28 @@ LOCAL TEST_RESULT test_tokenchecker_1()
 
 LOCAL TEST_RESULT test_tokenchecker_2()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i, j, len, len2, val, ret;
        UB *str, *str2;
 
        str = strdup(test_tokenchecker_testdata_tuple_0001[1].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
 
        for (i = 0; i < len; i++) {
-               ret = tokenchecker2_inputchar(&checker, str[i], &val);
-               if (ret != TOKENCHECKER2_CONTINUE) {
-                       printf("tokenchecker2_inputchar fail: right string\n");
+               ret = tokenchecker_inputchar(&checker, str[i], &val);
+               if (ret != TOKENCHECKER_CONTINUE) {
+                       printf("tokenchecker_inputchar fail: right string\n");
                        free(str);
                        return TEST_RESULT_FAIL;
                }
-               tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+               tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
                if (strncmp(str, str2, len2) != 0) {
-                       printf("tokenchecker2_getlastmatchedstring fail: right string\n");
+                       printf("tokenchecker_getlastmatchedstring fail: right string\n");
                        printf(" ");
                        for (j = 0; j < len; j++) {
                                printf("%c", str[j]);
@@ -361,26 +361,26 @@ LOCAL TEST_RESULT test_tokenchecker_2()
                        return TEST_RESULT_FAIL;
                }
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_DETERMINE) {
-               printf("tokenchecker2_inputchar fail: end character\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_DETERMINE) {
+               printf("tokenchecker_inputchar fail: end character\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
        if (val != 2) {
-               printf("tokenchecker2_inputchar fail: select value\n");
+               printf("tokenchecker_inputchar fail: select value\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+       tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
        if (strncmp(str, str2, len2) != 0) {
-               printf("tokenchecker2_getlastmatchedstring fail: end token\n");
+               printf("tokenchecker_getlastmatchedstring fail: end token\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_AFTER_END) {
-               printf("tokenchecker2_inputchar fail: after end\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_AFTER_END) {
+               printf("tokenchecker_inputchar fail: after end\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
@@ -391,28 +391,28 @@ LOCAL TEST_RESULT test_tokenchecker_2()
 
 LOCAL TEST_RESULT test_tokenchecker_3()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i, j, len, len2, val, ret;
        UB *str, *str2;
 
        str = strdup(test_tokenchecker_testdata_tuple_0001[2].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
 
        for (i = 0; i < len; i++) {
-               ret = tokenchecker2_inputchar(&checker, str[i], &val);
-               if (ret != TOKENCHECKER2_CONTINUE) {
-                       printf("tokenchecker2_inputchar fail: right string\n");
+               ret = tokenchecker_inputchar(&checker, str[i], &val);
+               if (ret != TOKENCHECKER_CONTINUE) {
+                       printf("tokenchecker_inputchar fail: right string\n");
                        free(str);
                        return TEST_RESULT_FAIL;
                }
-               tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+               tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
                if (strncmp(str, str2, len2) != 0) {
-                       printf("tokenchecker2_getlastmatchedstring fail: right string\n");
+                       printf("tokenchecker_getlastmatchedstring fail: right string\n");
                        printf(" ");
                        for (j = 0; j < len; j++) {
                                printf("%c", str[j]);
@@ -426,26 +426,26 @@ LOCAL TEST_RESULT test_tokenchecker_3()
                        return TEST_RESULT_FAIL;
                }
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_DETERMINE) {
-               printf("tokenchecker2_inputchar fail: end character\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_DETERMINE) {
+               printf("tokenchecker_inputchar fail: end character\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
        if (val != 3) {
-               printf("tokenchecker2_inputchar fail: select value\n");
+               printf("tokenchecker_inputchar fail: select value\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+       tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
        if (strncmp(str, str2, len2) != 0) {
-               printf("tokenchecker2_getlastmatchedstring fail: end token\n");
+               printf("tokenchecker_getlastmatchedstring fail: end token\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_AFTER_END) {
-               printf("tokenchecker2_inputchar fail: after end\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_AFTER_END) {
+               printf("tokenchecker_inputchar fail: after end\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
@@ -456,28 +456,28 @@ LOCAL TEST_RESULT test_tokenchecker_3()
 
 LOCAL TEST_RESULT test_tokenchecker_4()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i, j, len, len2, val, ret;
        UB *str, *str2;
 
        str = strdup(test_tokenchecker_testdata_tuple_0001[3].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
 
        for (i = 0; i < len; i++) {
-               ret = tokenchecker2_inputchar(&checker, str[i], &val);
-               if (ret != TOKENCHECKER2_CONTINUE) {
-                       printf("tokenchecker2_inputchar fail: right string\n");
+               ret = tokenchecker_inputchar(&checker, str[i], &val);
+               if (ret != TOKENCHECKER_CONTINUE) {
+                       printf("tokenchecker_inputchar fail: right string\n");
                        free(str);
                        return TEST_RESULT_FAIL;
                }
-               tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+               tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
                if (strncmp(str, str2, len2) != 0) {
-                       printf("tokenchecker2_getlastmatchedstring fail: right string\n");
+                       printf("tokenchecker_getlastmatchedstring fail: right string\n");
                        printf(" ");
                        for (j = 0; j < len; j++) {
                                printf("%c", str[j]);
@@ -491,26 +491,26 @@ LOCAL TEST_RESULT test_tokenchecker_4()
                        return TEST_RESULT_FAIL;
                }
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_DETERMINE) {
-               printf("tokenchecker2_inputchar fail: end character\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_DETERMINE) {
+               printf("tokenchecker_inputchar fail: end character\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
        if (val != 4) {
-               printf("tokenchecker2_inputchar fail: select value\n");
+               printf("tokenchecker_inputchar fail: select value\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+       tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
        if (strncmp(str, str2, len2) != 0) {
-               printf("tokenchecker2_getlastmatchedstring fail: end token\n");
+               printf("tokenchecker_getlastmatchedstring fail: end token\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_AFTER_END) {
-               printf("tokenchecker2_inputchar fail: after end\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_AFTER_END) {
+               printf("tokenchecker_inputchar fail: after end\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
@@ -521,28 +521,28 @@ LOCAL TEST_RESULT test_tokenchecker_4()
 
 LOCAL TEST_RESULT test_tokenchecker_5()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i, j, len, len2, val, ret;
        UB *str, *str2;
 
        str = strdup(test_tokenchecker_testdata_tuple_0001[4].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
 
        for (i = 0; i < len; i++) {
-               ret = tokenchecker2_inputchar(&checker, str[i], &val);
-               if (ret != TOKENCHECKER2_CONTINUE) {
-                       printf("tokenchecker2_inputchar fail: right string\n");
+               ret = tokenchecker_inputchar(&checker, str[i], &val);
+               if (ret != TOKENCHECKER_CONTINUE) {
+                       printf("tokenchecker_inputchar fail: right string\n");
                        free(str);
                        return TEST_RESULT_FAIL;
                }
-               tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+               tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
                if (strncmp(str, str2, len2) != 0) {
-                       printf("tokenchecker2_getlastmatchedstring fail: right string\n");
+                       printf("tokenchecker_getlastmatchedstring fail: right string\n");
                        printf(" ");
                        for (j = 0; j < len; j++) {
                                printf("%c", str[j]);
@@ -556,26 +556,26 @@ LOCAL TEST_RESULT test_tokenchecker_5()
                        return TEST_RESULT_FAIL;
                }
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_DETERMINE) {
-               printf("tokenchecker2_inputchar fail: end character\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_DETERMINE) {
+               printf("tokenchecker_inputchar fail: end character\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
        if (val != 5) {
-               printf("tokenchecker2_inputchar fail: select value\n");
+               printf("tokenchecker_inputchar fail: select value\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+       tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
        if (strncmp(str, str2, len2) != 0) {
-               printf("tokenchecker2_getlastmatchedstring fail: end token\n");
+               printf("tokenchecker_getlastmatchedstring fail: end token\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_AFTER_END) {
-               printf("tokenchecker2_inputchar fail: after end\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_AFTER_END) {
+               printf("tokenchecker_inputchar fail: after end\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
@@ -586,28 +586,28 @@ LOCAL TEST_RESULT test_tokenchecker_5()
 
 LOCAL TEST_RESULT test_tokenchecker_6()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i, j, len, len2, val, ret;
        UB *str, *str2;
 
        str = strdup(test_tokenchecker_testdata_tuple_0001[5].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
 
        for (i = 0; i < len; i++) {
-               ret = tokenchecker2_inputchar(&checker, str[i], &val);
-               if (ret != TOKENCHECKER2_CONTINUE) {
-                       printf("tokenchecker2_inputchar fail: right string\n");
+               ret = tokenchecker_inputchar(&checker, str[i], &val);
+               if (ret != TOKENCHECKER_CONTINUE) {
+                       printf("tokenchecker_inputchar fail: right string\n");
                        free(str);
                        return TEST_RESULT_FAIL;
                }
-               tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+               tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
                if (strncmp(str, str2, len2) != 0) {
-                       printf("tokenchecker2_getlastmatchedstring fail: right string\n");
+                       printf("tokenchecker_getlastmatchedstring fail: right string\n");
                        printf(" ");
                        for (j = 0; j < len; j++) {
                                printf("%c", str[j]);
@@ -621,26 +621,26 @@ LOCAL TEST_RESULT test_tokenchecker_6()
                        return TEST_RESULT_FAIL;
                }
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_DETERMINE) {
-               printf("tokenchecker2_inputchar fail: end character\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_DETERMINE) {
+               printf("tokenchecker_inputchar fail: end character\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
        if (val != 6) {
-               printf("tokenchecker2_inputchar fail: select value\n");
+               printf("tokenchecker_inputchar fail: select value\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+       tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
        if (strncmp(str, str2, len2) != 0) {
-               printf("tokenchecker2_getlastmatchedstring fail: end token\n");
+               printf("tokenchecker_getlastmatchedstring fail: end token\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_AFTER_END) {
-               printf("tokenchecker2_inputchar fail: after end\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_AFTER_END) {
+               printf("tokenchecker_inputchar fail: after end\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
@@ -651,28 +651,28 @@ LOCAL TEST_RESULT test_tokenchecker_6()
 
 LOCAL TEST_RESULT test_tokenchecker_7()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i, j, len, len2, val, ret;
        UB *str, *str2;
 
        str = strdup(test_tokenchecker_testdata_tuple_0001[6].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
 
        for (i = 0; i < len; i++) {
-               ret = tokenchecker2_inputchar(&checker, str[i], &val);
-               if (ret != TOKENCHECKER2_CONTINUE) {
-                       printf("tokenchecker2_inputchar fail: right string\n");
+               ret = tokenchecker_inputchar(&checker, str[i], &val);
+               if (ret != TOKENCHECKER_CONTINUE) {
+                       printf("tokenchecker_inputchar fail: right string\n");
                        free(str);
                        return TEST_RESULT_FAIL;
                }
-               tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+               tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
                if (strncmp(str, str2, len2) != 0) {
-                       printf("tokenchecker2_getlastmatchedstring fail: right string\n");
+                       printf("tokenchecker_getlastmatchedstring fail: right string\n");
                        printf(" ");
                        for (j = 0; j < len; j++) {
                                printf("%c", str[j]);
@@ -686,26 +686,26 @@ LOCAL TEST_RESULT test_tokenchecker_7()
                        return TEST_RESULT_FAIL;
                }
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_DETERMINE) {
-               printf("tokenchecker2_inputchar fail: end character\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_DETERMINE) {
+               printf("tokenchecker_inputchar fail: end character\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
        if (val != 7) {
-               printf("tokenchecker2_inputchar fail: select value\n");
+               printf("tokenchecker_inputchar fail: select value\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       tokenchecker2_getlastmatchedstring(&checker, &str2, &len2);
+       tokenchecker_getlastmatchedstring(&checker, &str2, &len2);
        if (strncmp(str, str2, len2) != 0) {
-               printf("tokenchecker2_getlastmatchedstring fail: end token\n");
+               printf("tokenchecker_getlastmatchedstring fail: end token\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
-       ret = tokenchecker2_inputchar(&checker, ':', &val);
-       if (ret != TOKENCHECKER2_AFTER_END) {
-               printf("tokenchecker2_inputchar fail: after end\n");
+       ret = tokenchecker_inputchar(&checker, ':', &val);
+       if (ret != TOKENCHECKER_AFTER_END) {
+               printf("tokenchecker_inputchar fail: after end\n");
                free(str);
                return TEST_RESULT_FAIL;
        }
@@ -714,30 +714,30 @@ LOCAL TEST_RESULT test_tokenchecker_7()
        return TEST_RESULT_PASS;
 }
 
-LOCAL TEST_RESULT test_tokenchecker_nomatch_getlastmatchedstring_sequence(tokenchecker2_t *checker, W num, UB *teststr, W teststr_len)
+LOCAL TEST_RESULT test_tokenchecker_nomatch_getlastmatchedstring_sequence(tokenchecker_t *checker, W num, UB *teststr, W teststr_len)
 {
        W i, j, len2, ret, val;
        UB *str2;
 
        for (i = 0; i < num; i++) {
-               ret = tokenchecker2_inputchar(checker, teststr[i], &val);
-               if (ret != TOKENCHECKER2_CONTINUE) {
-                       printf("tokenchecker2_inputchar fail: right string\n");
+               ret = tokenchecker_inputchar(checker, teststr[i], &val);
+               if (ret != TOKENCHECKER_CONTINUE) {
+                       printf("tokenchecker_inputchar fail: right string\n");
                        return TEST_RESULT_FAIL;
                }
        }
-       ret = tokenchecker2_inputchar(checker, 'z', &val);
-       if (ret != TOKENCHECKER2_CONTINUE_NOMATCH) {
-               printf("tokenchecker2_inputchar fail: nomatch char\n");
+       ret = tokenchecker_inputchar(checker, 'z', &val);
+       if (ret != TOKENCHECKER_CONTINUE_NOMATCH) {
+               printf("tokenchecker_inputchar fail: nomatch char\n");
                return TEST_RESULT_FAIL;
        }
-       tokenchecker2_getlastmatchedstring(checker, &str2, &len2);
+       tokenchecker_getlastmatchedstring(checker, &str2, &len2);
        if (len2 != num) {
-               printf("tokenchecker2_getlastmatchedstring fail: length\n");
+               printf("tokenchecker_getlastmatchedstring fail: length\n");
                return TEST_RESULT_FAIL;
        }
        if (strncmp(teststr, str2, len2) != 0) {
-               printf("tokenchecker2_getlastmatchedstring fail: nomatch string\n");
+               printf("tokenchecker_getlastmatchedstring fail: nomatch string\n");
                printf(" ");
                for (j = 0; j < len2; j++) {
                        printf("%c", teststr[j]);
@@ -755,7 +755,7 @@ LOCAL TEST_RESULT test_tokenchecker_nomatch_getlastmatchedstring_sequence(tokenc
 
 LOCAL TEST_RESULT test_tokenchecker_8()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i,len;
        UB *str;
        TEST_RESULT result;
@@ -763,7 +763,7 @@ LOCAL TEST_RESULT test_tokenchecker_8()
        str = strdup(test_tokenchecker_testdata_tuple_0001[0].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
@@ -773,7 +773,7 @@ LOCAL TEST_RESULT test_tokenchecker_8()
                if (result != TEST_RESULT_PASS) {
                        return result;
                }
-               tokenchecker2_clear(&checker);
+               tokenchecker_clear(&checker);
        }
 
        free(str);
@@ -783,7 +783,7 @@ LOCAL TEST_RESULT test_tokenchecker_8()
 
 LOCAL TEST_RESULT test_tokenchecker_9()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i,len;
        UB *str;
        TEST_RESULT result;
@@ -791,7 +791,7 @@ LOCAL TEST_RESULT test_tokenchecker_9()
        str = strdup(test_tokenchecker_testdata_tuple_0001[1].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
@@ -801,7 +801,7 @@ LOCAL TEST_RESULT test_tokenchecker_9()
                if (result != TEST_RESULT_PASS) {
                        return result;
                }
-               tokenchecker2_clear(&checker);
+               tokenchecker_clear(&checker);
        }
 
        free(str);
@@ -811,7 +811,7 @@ LOCAL TEST_RESULT test_tokenchecker_9()
 
 LOCAL TEST_RESULT test_tokenchecker_10()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i,len;
        UB *str;
        TEST_RESULT result;
@@ -819,7 +819,7 @@ LOCAL TEST_RESULT test_tokenchecker_10()
        str = strdup(test_tokenchecker_testdata_tuple_0001[2].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
@@ -829,7 +829,7 @@ LOCAL TEST_RESULT test_tokenchecker_10()
                if (result != TEST_RESULT_PASS) {
                        return result;
                }
-               tokenchecker2_clear(&checker);
+               tokenchecker_clear(&checker);
        }
 
        free(str);
@@ -839,7 +839,7 @@ LOCAL TEST_RESULT test_tokenchecker_10()
 
 LOCAL TEST_RESULT test_tokenchecker_11()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i,len;
        UB *str;
        TEST_RESULT result;
@@ -847,7 +847,7 @@ LOCAL TEST_RESULT test_tokenchecker_11()
        str = strdup(test_tokenchecker_testdata_tuple_0001[3].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
@@ -857,7 +857,7 @@ LOCAL TEST_RESULT test_tokenchecker_11()
                if (result != TEST_RESULT_PASS) {
                        return result;
                }
-               tokenchecker2_clear(&checker);
+               tokenchecker_clear(&checker);
        }
 
        free(str);
@@ -867,7 +867,7 @@ LOCAL TEST_RESULT test_tokenchecker_11()
 
 LOCAL TEST_RESULT test_tokenchecker_12()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i,len;
        UB *str;
        TEST_RESULT result;
@@ -875,7 +875,7 @@ LOCAL TEST_RESULT test_tokenchecker_12()
        str = strdup(test_tokenchecker_testdata_tuple_0001[4].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
@@ -885,7 +885,7 @@ LOCAL TEST_RESULT test_tokenchecker_12()
                if (result != TEST_RESULT_PASS) {
                        return result;
                }
-               tokenchecker2_clear(&checker);
+               tokenchecker_clear(&checker);
        }
 
        free(str);
@@ -895,7 +895,7 @@ LOCAL TEST_RESULT test_tokenchecker_12()
 
 LOCAL TEST_RESULT test_tokenchecker_13()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i,len;
        UB *str;
        TEST_RESULT result;
@@ -903,7 +903,7 @@ LOCAL TEST_RESULT test_tokenchecker_13()
        str = strdup(test_tokenchecker_testdata_tuple_0001[5].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
@@ -913,7 +913,7 @@ LOCAL TEST_RESULT test_tokenchecker_13()
                if (result != TEST_RESULT_PASS) {
                        return result;
                }
-               tokenchecker2_clear(&checker);
+               tokenchecker_clear(&checker);
        }
 
        free(str);
@@ -923,7 +923,7 @@ LOCAL TEST_RESULT test_tokenchecker_13()
 
 LOCAL TEST_RESULT test_tokenchecker_14()
 {
-       tokenchecker2_t checker;
+       tokenchecker_t checker;
        W i,len;
        UB *str;
        TEST_RESULT result;
@@ -931,7 +931,7 @@ LOCAL TEST_RESULT test_tokenchecker_14()
        str = strdup(test_tokenchecker_testdata_tuple_0001[6].name);
        len = strlen(str);
 
-       tokenchecker2_initialize(&checker,
+       tokenchecker_initialize(&checker,
                                                         test_tokenchecker_testdata_tuple_0001,
                                                         7,
                                                         test_tokenchecker_testdata_etoken_0001);
@@ -941,7 +941,7 @@ LOCAL TEST_RESULT test_tokenchecker_14()
                if (result != TEST_RESULT_PASS) {
                        return result;
                }
-               tokenchecker2_clear(&checker);
+               tokenchecker_clear(&checker);
        }
 
        free(str);