fix result structure.

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

diff --git a/src/tad/tadlexer_le.c b/src/tad/tadlexer_le.c
index 8cfa288..263f9c0 100644 (file)
--- a/src/tad/tadlexer_le.c
+++ b/src/tad/tadlexer_le.c
@@ -29,7 +29,38 @@
 #include       <basic.h>
 #include       <bstdio.h>
 
-IMPORT VOID tadlexer_le_inputbyte(tadlexer_le_t *lexer, UB b, tadlexer_le_result **result, W *result_len)
+#define TADLEXER_LE_FLAG_FIXED_SEGMENT       0x00000001
+#define TADLEXER_LE_FLAG_VARIABLE_SEGMENT    0x00000002
+#define TADLEXER_LE_FLAG_SEGMENTID_DETERMINE 0x00000004
+#define TADLEXER_LE_FLAG_LENGTH_DETERMINE    0x00000008
+#define TADLEXER_LE_FLAG_READING_DATA        0x00000010
+
+EXPORT Bool tadlexer_le_result_is_fixedsegment(tadlexer_le_result *result)
+{
+       return ((result->flag & TADLEXER_LE_FLAG_FIXED_SEGMENT) != 0) ? True : False;
+}
+
+EXPORT Bool tadlexer_le_result_is_variablesegment(tadlexer_le_result *result)
+{
+       return ((result->flag & TADLEXER_LE_FLAG_VARIABLE_SEGMENT) != 0) ? True : False;
+}
+
+EXPORT Bool tadlexer_le_result_is_segmentid_determined(tadlexer_le_result *result)
+{
+       return ((result->flag & TADLEXER_LE_FLAG_SEGMENTID_DETERMINE) != 0) ? True : False;
+}
+
+EXPORT Bool tadlexer_le_result_is_lengthdetermined(tadlexer_le_result *result)
+{
+       return ((result->flag & TADLEXER_LE_FLAG_LENGTH_DETERMINE) != 0) ? True : False;
+}
+
+EXPORT Bool tadlexer_le_result_is_readingdata(tadlexer_le_result *result)
+{
+       return ((result->flag & TADLEXER_LE_FLAG_READING_DATA) != 0) ? True : False;
+}
+
+EXPORT VOID tadlexer_le_inputbyte(tadlexer_le_t *lexer, UB b, tadlexer_le_result **result, W *result_len)
 {
        *result = &lexer->buf;
        *result_len = 1;
@@ -38,37 +69,43 @@ IMPORT VOID tadlexer_le_inputbyte(tadlexer_le_t *lexer, UB b, tadlexer_le_result
        case HTTP_TADLEXER_LE_STATE_START:
                lexer->segid = b;
                lexer->state = HTTP_TADLEXER_LE_STATE_FIRST_BYTE;
-               lexer->buf.type = HTTP_TADLEXER_LE_RESULT_FIRST_BYTE;
+               lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
+               lexer->buf.flag = 0;
                break;
        case HTTP_TADLEXER_LE_STATE_FIRST_BYTE:
                if ((b == 0xFF)&&(((lexer->segid) & 0x80) == 0x80)) {
                        lexer->state = HTTP_TADLEXER_LE_STATE_SEGLEN_FIRST;
-                       lexer->buf.type = HTTP_TADLEXER_LE_RESULT_DETERMINE_VARIABLE_SEGMENT;
+                       lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
+                       lexer->buf.flag = TADLEXER_LE_FLAG_VARIABLE_SEGMENT | TADLEXER_LE_FLAG_SEGMENTID_DETERMINE;
+                       lexer->buf.val.seg.id = lexer->segid;
                } else {
                        lexer->state = HTTP_TADLEXER_LE_STATE_START;
-                       lexer->buf.type = HTTP_TADLEXER_LE_RESULT_DETERMINE_FIXED_SEGMENT;
+                       lexer->buf.type = TADLEXER_LE_RESULTTYPE_SEGMENT_END;
+                       lexer->buf.flag = TADLEXER_LE_FLAG_FIXED_SEGMENT;
                        lexer->buf.val.ch = lexer->segid | (b << 8);
                }
                break;
        case HTTP_TADLEXER_LE_STATE_SEGLEN_FIRST:
                lexer->len = b;
                lexer->state = HTTP_TADLEXER_LE_STATE_SEGLEN_SECOND;
-               lexer->buf.type = HTTP_TADLEXER_LE_RESULT_READING_SEGMENT_LENGTH;
+               lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
                break;
        case HTTP_TADLEXER_LE_STATE_SEGLEN_SECOND:
                lexer->len |= b << 8;
                if (lexer->len == 0) {
                        lexer->state = HTTP_TADLEXER_LE_STATE_START;
-                       lexer->buf.type = HTTP_TADLEXER_LE_RESULT_DETERMINE_DATA_EMPTY;
+                       lexer->buf.type = TADLEXER_LE_RESULTTYPE_SEGMENT_END;
+                       lexer->buf.flag |= TADLEXER_LE_FLAG_LENGTH_DETERMINE;
                        lexer->buf.val.seg.id = lexer->segid;
                        lexer->buf.val.seg.len = 0;
                } else if (lexer->len == 0xFFFF) {
                        lexer->state = HTTP_TADLEXER_LE_STATE_LSEGLEN_FIRST;
-                       lexer->buf.type = HTTP_TADLEXER_LE_RESULT_READING_SEGMENT_LENGTH;
+                       lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
                } else {
                        lexer->state = HTTP_TADLEXER_LE_STATE_DATA;
                        lexer->len_read = 0;
-                       lexer->buf.type = HTTP_TADLEXER_LE_RESULT_DETERMINE_SEGMENT_LENGTH;
+                       lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
+                       lexer->buf.flag |= TADLEXER_LE_FLAG_LENGTH_DETERMINE;
                        lexer->buf.val.seg.id = lexer->segid;
                        lexer->buf.val.seg.len = lexer->len;
                }
@@ -76,45 +113,47 @@ IMPORT VOID tadlexer_le_inputbyte(tadlexer_le_t *lexer, UB b, tadlexer_le_result
        case HTTP_TADLEXER_LE_STATE_LSEGLEN_FIRST:
                lexer->len = b;
                lexer->state = HTTP_TADLEXER_LE_STATE_LSEGLEN_SECOND;
-               lexer->buf.type = HTTP_TADLEXER_LE_RESULT_READING_SEGMENT_LENGTH;
+               lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
                break;
        case HTTP_TADLEXER_LE_STATE_LSEGLEN_SECOND:
                lexer->len |= b << 8;
                lexer->state = HTTP_TADLEXER_LE_STATE_LSEGLEN_THIRD;
-               lexer->buf.type = HTTP_TADLEXER_LE_RESULT_READING_SEGMENT_LENGTH;
+               lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
                break;
        case HTTP_TADLEXER_LE_STATE_LSEGLEN_THIRD:
                lexer->len |= b << 16;
                lexer->state = HTTP_TADLEXER_LE_STATE_LSEGLEN_FORTH;
-               lexer->buf.type = HTTP_TADLEXER_LE_RESULT_READING_SEGMENT_LENGTH;
+               lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
                break;
        case HTTP_TADLEXER_LE_STATE_LSEGLEN_FORTH:
                lexer->len |= b << 24;
                lexer->state = HTTP_TADLEXER_LE_STATE_DATA;
                lexer->len_read = 0;
-               lexer->buf.type = HTTP_TADLEXER_LE_RESULT_DETERMINE_SEGMENT_LENGTH;
+               lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
+               lexer->buf.flag |= TADLEXER_LE_FLAG_LENGTH_DETERMINE;
                lexer->buf.val.seg.id = lexer->segid;
                lexer->buf.val.seg.len = lexer->len;
                break;
        case HTTP_TADLEXER_LE_STATE_DATA:
+               lexer->buf.flag |= TADLEXER_LE_FLAG_READING_DATA;
                lexer->len_read++;
                if (lexer->len_read == lexer->len) {
                        lexer->state = HTTP_TADLEXER_LE_STATE_START;
-                       lexer->buf.type = HTTP_TADLEXER_LE_RESULT_READING_DATA_END;
+                       lexer->buf.type = TADLEXER_LE_RESULTTYPE_SEGMENT_END;
                } else {
-                       lexer->buf.type = HTTP_TADLEXER_LE_RESULT_READING_DATA;
+                       lexer->buf.type = TADLEXER_LE_RESULTTYPE_READING_SEGMENT;
                }
                break;
        }
 }
 
-IMPORT VOID tadlexer_le_initialize(tadlexer_le_t *lexer)
+EXPORT VOID tadlexer_le_initialize(tadlexer_le_t *lexer)
 {
        lexer->state = HTTP_TADLEXER_LE_STATE_START;
        lexer->segid = 0;
        lexer->len = 0;
 }
 
-IMPORT VOID tadlexer_le_finalize(tadlexer_le_t *lexer)
+EXPORT VOID tadlexer_le_finalize(tadlexer_le_t *lexer)
 {
 }

diff --git a/src/tad/tadlexer_le.h b/src/tad/tadlexer_le.h
index d04d85a..8f99d50 100644 (file)
--- a/src/tad/tadlexer_le.h
+++ b/src/tad/tadlexer_le.h
@@ -40,15 +40,10 @@
 /* Data structure identifier: result */
 struct tadlexer_le_result_ {
        enum {
-               HTTP_TADLEXER_LE_RESULT_FIRST_BYTE,
-               HTTP_TADLEXER_LE_RESULT_DETERMINE_FIXED_SEGMENT,
-               HTTP_TADLEXER_LE_RESULT_DETERMINE_VARIABLE_SEGMENT,
-               HTTP_TADLEXER_LE_RESULT_READING_SEGMENT_LENGTH,
-               HTTP_TADLEXER_LE_RESULT_DETERMINE_SEGMENT_LENGTH,
-               HTTP_TADLEXER_LE_RESULT_DETERMINE_DATA_EMPTY,
-               HTTP_TADLEXER_LE_RESULT_READING_DATA,
-               HTTP_TADLEXER_LE_RESULT_READING_DATA_END,
+               TADLEXER_LE_RESULTTYPE_READING_SEGMENT,
+               TADLEXER_LE_RESULTTYPE_SEGMENT_END,
        } type;
+       UW flag;
        union {
                TC ch;
                struct {
@@ -59,6 +54,12 @@ struct tadlexer_le_result_ {
 };
 typedef struct tadlexer_le_result_ tadlexer_le_result;
 
+IMPORT Bool tadlexer_le_result_is_fixedsegment(tadlexer_le_result *result);
+IMPORT Bool tadlexer_le_result_is_variablesegment(tadlexer_le_result *result);
+IMPORT Bool tadlexer_le_result_is_segmentid_determined(tadlexer_le_result *result);
+IMPORT Bool tadlexer_le_result_is_lengthdetermined(tadlexer_le_result *result);
+IMPORT Bool tadlexer_le_result_is_readingdata(tadlexer_le_result *result);
+
 /* Functionality name: tadlexer */
 /* Detail name: le */
 struct tadlexer_le_t_ {

diff --git a/src/tad/test_tadlexer_le.c b/src/tad/test_tadlexer_le.c
index 638a357..fdf0198 100644 (file)
--- a/src/tad/test_tadlexer_le.c
+++ b/src/tad/test_tadlexer_le.c
@@ -28508,6 +28508,7 @@ LOCAL UNITTEST_RESULT test_tadlexer_le_common(UB *data, W len, test_tadlexer_le_
        tadlexer_le_t lexer;
        tadlexer_le_result *result;
        W i, result_len, j;
+       Bool ok;
        UNITTEST_RESULT ret = UNITTEST_RESULT_PASS;
 
        tadlexer_le_initialize(&lexer);
@@ -28516,75 +28517,68 @@ LOCAL UNITTEST_RESULT test_tadlexer_le_common(UB *data, W len, test_tadlexer_le_
        for (i = 0; i < len; i++) {
                tadlexer_le_inputbyte(&lexer, data[i], &result, &result_len);
                switch (result->type) {
-               case HTTP_TADLEXER_LE_RESULT_FIRST_BYTE:
-                       break;
-               case HTTP_TADLEXER_LE_RESULT_DETERMINE_FIXED_SEGMENT:
-                       if (j >= expected_len) {
-                               break;
-                       }
-                       if (expected[j].type != TEST_TADLEXER_LE_CH) {
-                               printf("type fail [%d]: expected charactor but segument\n", j);
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       if (expected[j].ch != result->val.ch) {
-                               printf("charactor fail [%d]: result = %04x, expected = %04x\n", j, result->val.ch, expected[j].ch);
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       j++;
-                       break;
-               case HTTP_TADLEXER_LE_RESULT_DETERMINE_VARIABLE_SEGMENT:
-                       break;
-               case HTTP_TADLEXER_LE_RESULT_READING_SEGMENT_LENGTH:
-                       break;
-               case HTTP_TADLEXER_LE_RESULT_DETERMINE_SEGMENT_LENGTH:
-                       if (expected[j].type != TEST_TADLEXER_LE_SEGMENT) {
-                               printf("type fail [%d]: expected segment but charactor\n", j);
-                               ret = UNITTEST_RESULT_FAIL;
+               case TADLEXER_LE_RESULTTYPE_READING_SEGMENT:
+                       ok = tadlexer_le_result_is_variablesegment(result);
+                       if (ok != False) {
+                               if (expected[j].type != TEST_TADLEXER_LE_SEGMENT) {
+                                       printf("type fail [%d]: expected segment but charactor\n", j);
+                                       ret = UNITTEST_RESULT_FAIL;
+                               }
                        }
-                       if (expected[j].segid != result->val.seg.id) {
-                               printf("segment id fail [%d]: result = %02x, expected = %02x\n", j, result->val.seg.id, expected[j].segid);
-                               ret = UNITTEST_RESULT_FAIL;
+                       ok = tadlexer_le_result_is_segmentid_determined(result);
+                       if (ok != False) {
+                               if (expected[j].segid != result->val.seg.id) {
+                                       printf("segment id fail [%d]: result = %02x, expected = %02x\n", j, result->val.seg.id, expected[j].segid);
+                                       ret = UNITTEST_RESULT_FAIL;
+                               }
                        }
-                       if (expected[j].len != result->val.seg.len) {
-                               printf("segment length fail [%d]: result = %d, expected = %d\n", j, result->val.seg.len, expected[j].len);
-                               ret = UNITTEST_RESULT_FAIL;
+                       ok = tadlexer_le_result_is_lengthdetermined(result);
+                       if (ok != False) {
+                               if (expected[j].len != result->val.seg.len) {
+                                       printf("segment length fail [%d]: result = %d, expected = %d\n", j, result->val.seg.len, expected[j].len);
+                                       ret = UNITTEST_RESULT_FAIL;
+                               }
                        }
                        break;
-               case HTTP_TADLEXER_LE_RESULT_DETERMINE_DATA_EMPTY:
-                       if (expected[j].type != TEST_TADLEXER_LE_SEGMENT) {
-                               printf("type fail [%d]: expected segment but charactor\n", j);
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       if (expected[j].segid != result->val.seg.id) {
-                               printf("segment id fail [%d]: result = %02x, expected = %02x\n", j, result->val.seg.id, expected[j].segid);
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       if (expected[j].len != result->val.seg.len) {
-                               printf("segment length fail [%d]: result = %d, expected = %d\n", j, result->val.seg.len, expected[j].len);
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       j++;
-                       break;
-               case HTTP_TADLEXER_LE_RESULT_READING_DATA:
-                       if (expected[j].type != TEST_TADLEXER_LE_SEGMENT) {
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       if (expected[j].segid != result->val.seg.id) {
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       if (expected[j].len != result->val.seg.len) {
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       break;
-               case HTTP_TADLEXER_LE_RESULT_READING_DATA_END:
-                       if (expected[j].type != TEST_TADLEXER_LE_SEGMENT) {
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       if (expected[j].segid != result->val.seg.id) {
-                               ret = UNITTEST_RESULT_FAIL;
-                       }
-                       if (expected[j].len != result->val.seg.len) {
-                               ret = UNITTEST_RESULT_FAIL;
+               case TADLEXER_LE_RESULTTYPE_SEGMENT_END:
+                       ok = tadlexer_le_result_is_variablesegment(result);
+                       if (ok != False) {
+                               if (expected[j].type != TEST_TADLEXER_LE_SEGMENT) {
+                                       printf("type fail [%d]: expected segment but charactor\n", j);
+                                       ret = UNITTEST_RESULT_FAIL;
+                               }
+                               ok = tadlexer_le_result_is_segmentid_determined(result);
+                               if (ok != False) {
+                                       if (expected[j].segid != result->val.seg.id) {
+                                               printf("segment id fail [%d]: result = %02x, expected = %02x\n", j, result->val.seg.id, expected[j].segid);
+                                               ret = UNITTEST_RESULT_FAIL;
+                                       }
+                               } else {
+                                       printf("segment id is not determined\n");
+                                       ret = UNITTEST_RESULT_FAIL;
+                               }
+                               ok = tadlexer_le_result_is_lengthdetermined(result);
+                               if (ok != False) {
+                                       if (expected[j].len != result->val.seg.len) {
+                                               printf("segment length fail [%d]: result = %d, expected = %d\n", j, result->val.seg.len, expected[j].len);
+                                               ret = UNITTEST_RESULT_FAIL;
+                                       }
+                               } else {
+                                       printf("segment length is not determined\n");
+                                       ret = UNITTEST_RESULT_FAIL;
+                               }
+                       } else {
+                               ok = tadlexer_le_result_is_fixedsegment(result);
+                               if (ok != False) {
+                                       if (expected[j].type != TEST_TADLEXER_LE_CH) {
+                                               printf("type fail [%d]: expected charactor but segument\n", j);
+                                               ret = UNITTEST_RESULT_FAIL;
+                                       }
+                                       if (expected[j].ch != result->val.ch) {
+                                               printf("charactor fail [%d]: result = %04x, expected = %04x\n", j, result->val.ch, expected[j].ch);
+                                               ret = UNITTEST_RESULT_FAIL;
+                                       }
+                               }
                        }
                        j++;
                        break;