refactoring insert filter api.

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

diff --git a/src/control/test_texteditor_insertfilter.c b/src/control/test_texteditor_insertfilter.c
index 5a72152..ae001d2 100644 (file)
--- a/src/control/test_texteditor_insertfilter.c
+++ b/src/control/test_texteditor_insertfilter.c
@@ -36,6 +36,7 @@
 #include       <tcode.h>
 
 #include    <tad/tadlangcode.h>
+#include    <tad/taddecoder.h>
 
 #include    <unittest_driver.h>
 
@@ -44,39 +45,94 @@ typedef struct {
        W len;
 } test_texteditor_insertfilter_expected;
 
+LOCAL Bool test_texteditor_insertfilter_cmpsegment(test_texteditor_insertfilter_expected *expected, tadsegment *result)
+{
+       Bool ok = True;
+
+       switch (result->type) {
+       case TADSEGMENT_TYPE_VARIABLE:
+               if (result->value.variable.rawlen != expected->len) {
+                       printf("VAR: return length failure: expected = %d, result = %d\n", expected->len, result->value.variable.rawlen);
+                       ok = False;
+               } else if (memcmp(result->value.variable.raw, expected->data, expected->len) != 0) {
+                       printf("VAR: return data failure\n");
+                       ok = False;
+               }
+               return ok;
+       case TADSEGMENT_TYPE_CHARACTOR:
+               if (expected->len != sizeof(TC)) {
+                       printf("CH: return length failure: expected = %d\n", expected->len);
+                       ok = False;
+               } else if (memcmp((UB*)&result->value.ch, expected->data, expected->len) != 0) {
+                       printf("CH: return data failure: expected = %04x, result = %04x\n", *(TC*)expected->data, result->value.ch);
+                       ok = False;
+               }
+               return ok;
+       case TADSEGMENT_TYPE_LANGCODE:
+               ok = tadlangcodecmpTC((TC*)expected->data, expected->len/sizeof(TC), &result->value.lang);
+               if (ok == False) {
+                       printf("LANG: langcode faiure\n");
+               }
+               return ok;
+       }
+       return False;
+}
+
 LOCAL UNITTEST_RESULT test_texteditor_insertfilter_common(tadlangcode lang, RATIO w_ratio, UB *data, W len, test_texteditor_insertfilter_expected *expected, W expected_len)
 {
        texteditor_insertfilter_t filter;
-       texteditor_insertfilter_result result;
-       Bool cont;
-       W i;
+       texteditor_insertfilterresult_t *result;
+       taddecoder_t decoder;
+       tadsegment segment, *filterd;
+       Bool cont, ok;
+       W i, err;
        UNITTEST_RESULT ret = UNITTEST_RESULT_PASS;
 
-       texteditor_insertfilter_initialize(&filter, &lang, w_ratio, data, len);
+       texteditor_insertfilter_initialize(&filter, &lang, w_ratio);
 
-       for (i = 0;; i++) {
-               cont = texteditor_insertfilter_next(&filter, &result);
+       taddecoder_initialize(&decoder, (TC*)data, len/sizeof(TC));
+
+       for (i = 0;;) {
+               cont = taddecoder_next(&decoder, &segment);
                if (cont == False) {
                        break;
                }
-               if (i >= expected_len) {
-                       continue;
-               }
-               if (result.len != expected[i].len) {
-                       printf("return length failure[%d]: expected = %d, result = %d\n", i, expected[i].len, result.len);
+               err = texteditor_insertfilter_put(&filter, &segment, &result);
+               if (err < 0) {
                        ret = UNITTEST_RESULT_FAIL;
-                       continue;
+                       break;
+               }
+               for (;; i++) {
+                       cont = texteditor_insertfilterresult_next(result, &filterd);
+                       if (cont == False) {
+                               break;
+                       }
+                       ok = test_texteditor_insertfilter_cmpsegment(expected + i, filterd);
+                       if (ok == False) {
+                               printf("segment[%d] fail\n", i);
+                               ret = UNITTEST_RESULT_FAIL;
+                       }
+               }
+       }
+       texteditor_insertfilter_endinput(&filter, &result);
+       for (;; i++) {
+               cont = texteditor_insertfilterresult_next(result, &filterd);
+               if (cont == False) {
+                       break;
                }
-               if (memcmp(result.data, expected[i].data, result.len) != 0) {
-                       printf("return data failure[%d]\n", i);
+               ok = test_texteditor_insertfilter_cmpsegment(expected + i, filterd);
+               if (ok == False) {
                        ret = UNITTEST_RESULT_FAIL;
                }
        }
+
        if (i != expected_len) {
                printf("iteration number failure: expected = %d, result = %d\n", expected_len, i);
                ret = UNITTEST_RESULT_FAIL;
        }
 
+       taddecoder_finalize(&decoder);
+
        texteditor_insertfilter_finalize(&filter);
 
        return ret;

diff --git a/src/control/test_texteditor_textfragment.c b/src/control/test_texteditor_textfragment.c
index 7634bc6..b2f8e33 100644 (file)
--- a/src/control/test_texteditor_textfragment.c
+++ b/src/control/test_texteditor_textfragment.c
@@ -34,6 +34,8 @@
 #include       <bstring.h>
 #include       <tcode.h>
 
+#include    <tad/taddecoder.h>
+
 #include    <unittest_driver.h>
 
 LOCAL UNITTEST_RESULT test_texteditor_textfragment_1()
@@ -64,6 +66,33 @@ typedef struct {
        W expected_segment_num;
 } test_texteditor_insertcontext_t;
 
+LOCAL W test_texteditor_textfragment_inserttestdata(texteditor_insertcontext_t *context, test_data_t *testdata)
+{
+       taddecoder_t decoder;
+       tadsegment segment;
+       Bool cont;
+       W err = 0;
+
+       taddecoder_initialize(&decoder, testdata->data, testdata->len / sizeof(TC));
+
+       for (;;) {
+               cont = taddecoder_next(&decoder, &segment);
+               if (cont == False) {
+                       break;
+               }
+
+               err = texteditor_insertcontext_insert(context, &segment);
+               if (err < 0) {
+                       printf("texteditor_insertcontext_insert error\n");
+                       break;
+               }
+       }
+
+       taddecoder_finalize(&decoder);
+
+       return err;
+}
+
 LOCAL W test_texteditor_textfragment_initialvalue(texteditor_textfragment_t *fragment, test_data_t *original)
 {
        texteditor_insertcontext_t context;
@@ -75,9 +104,8 @@ LOCAL W test_texteditor_textfragment_initialvalue(texteditor_textfragment_t *fra
                return err;
        }
 
-       err = texteditor_insertcontext_insert(&context, (UB*)original->data, original->len);
+       err = test_texteditor_textfragment_inserttestdata(&context, original);
        if (err < 0) {
-               printf("texteditor_insertcontext_insert error\n");
                texteditor_insertcontext_finalize(&context);
                return err;
        }
@@ -110,7 +138,7 @@ LOCAL UNITTEST_RESULT test_texteditor_insertcontext_common(test_texteditor_inser
                result = UNITTEST_RESULT_FAIL;
        } else {
                for (i = 0; i < testdata->insert_len; i++) {
-                       err = texteditor_insertcontext_insert(&context, (UB*)testdata->insert[i].data, testdata->insert[i].len);
+                       err = test_texteditor_textfragment_inserttestdata(&context, testdata->insert + i);
                        if (err < 0) {
                                printf("tadfragment_cursor_insert error\n");
                                result = UNITTEST_RESULT_FAIL;

diff --git a/src/control/texteditor_insertfilter.c b/src/control/texteditor_insertfilter.c
index 314e1b4..611d8c4 100644 (file)
--- a/src/control/texteditor_insertfilter.c
+++ b/src/control/texteditor_insertfilter.c
@@ -27,10 +27,13 @@
 #include       "texteditor_insertfilter.h"
 
 #include       <bstdio.h>
+#include       <bassert.h>
 
 #include       <tad/taditerator.h>
 #include       <tad/tadstack.h>
 
+#include       "texteditor_stackfilter.h"
+
 #ifdef BCHAN_CONFIG_DEBUG
 # define DP(arg) printf arg
 # define DP_ER(msg, err) printf("%s (%d/%x)\n", msg, err>>16, err)
@@ -45,155 +48,6 @@
 #define DP_STATE(s) /**/
 #endif
 
-LOCAL Bool texteditor_insertfilter_stackfilter(texteditor_insertfilter_t *filter, taditerator_result *result)
-{
-       W nestlevel, err;
-       TADSTACK_DATATYPE type;
-
-       for (;;) {
-               taditerator_next2(&filter->iterator, result);
-               if (result->type == TADITERATOR_RESULTTYPE_END) {
-                       break;
-               }
-
-               if (result->type == TADITERATOR_RESULTTYPE_CHARCTOR) {
-                       tadstack_inputcharactor(&filter->tadstack, result->segment);
-               } else if (result->type == TADITERATOR_RESULTTYPE_SEGMENT) {
-                       tadstack_inputvsegment(&filter->tadstack, result->segment, result->data, result->segsize);
-               }
-
-               nestlevel = tadstack_nestlevel(&filter->tadstack);
-               if (nestlevel != 0) {
-                       continue;
-               }
-               err = tadstack_currentdata(&filter->tadstack, &type);
-               if (type != TADSTACK_DATATYPE_TEXT) {
-                       continue;
-               }
-
-               return True;
-       }
-
-       return False;
-}
-
-struct texteditor_insertfilter_innerresult_ {
-       enum {
-               INNERRESULT_VARIABLE,
-               INNERRESULT_STRING,
-               INNERRESULT_LANGCODE,
-       } type;
-       UB *data;
-       W len;
-       struct {
-               UB segid;
-               UW len;
-               UB *data;
-       } variable;
-};
-typedef struct texteditor_insertfilter_innerresult_ texteditor_insertfilter_innerresult;
-
-LOCAL Bool texteditor_insertfilter_langcode(texteditor_insertfilter_t *filter, texteditor_insertfilter_innerresult *result)
-{
-       taditerator_result iter_result;
-       Bool reading_lang = False, cont;
-       TC *lang_start = NULL;
-
-       for (;;) {
-               cont = texteditor_insertfilter_stackfilter(filter, &iter_result);
-               if (cont == False) {
-                       break;
-               }
-
-               if (reading_lang != False) {
-                       if (iter_result.type != TADITERATOR_RESULTTYPE_CHARCTOR) {
-                               /* format error */
-                               break;
-                       }
-                       if (lang_start == NULL) {
-                               break;
-                       }
-                       if (iter_result.segment == 0xFEFE) {
-                               continue;
-                       }
-                       result->type = INNERRESULT_LANGCODE;
-                       result->data = (UB*)lang_start;
-                       result->len = (iter_result.pos - lang_start + 1) * sizeof(TC);
-                       TCtotadlangcode((TC*)result->data, result->len / sizeof(TC), &filter->current.lang);
-                       reading_lang = False;
-                       lang_start = NULL;
-               }
-
-               if (iter_result.type == TADITERATOR_RESULTTYPE_CHARCTOR) {
-                       if ((iter_result.segment & 0xFF00) == 0xFE00) {
-                               if (iter_result.segment == 0xFEFE) {
-                                       reading_lang = True;
-                                       lang_start = iter_result.pos;
-                               } else {
-                                       result->type = INNERRESULT_LANGCODE;
-                                       result->data = (UB*)iter_result.pos;
-                                       result->len = sizeof(TC);
-                                       TCtotadlangcode((TC*)result->data, result->len / sizeof(TC), &filter->current.lang);
-                                       return True;
-                               }
-                       } else {
-                               result->type = INNERRESULT_STRING;
-                               result->data = (UB*)iter_result.pos;
-                               result->len = sizeof(TC);
-                               return True;
-                       }
-               } else if (iter_result.type == TADITERATOR_RESULTTYPE_SEGMENT) {
-                       result->type = INNERRESULT_VARIABLE;
-                       result->data = (UB*)iter_result.pos;
-                       if (iter_result.vseg.l->len == 0xFFFF) {
-                               result->len = 2 + 2 + 4 + iter_result.vseg.l->llen;
-                       } else {
-                               result->len = 2 + 2 + iter_result.vseg.l->len;
-                       }
-                       result->variable.segid = iter_result.segment & 0xFF;
-                       result->variable.len = iter_result.segsize;
-                       result->variable.data = iter_result.data;
-                       return True;
-               }
-       }
-
-       return False;
-}
-
-LOCAL Bool texteditor_insertfilter_chratio(texteditor_insertfilter_t *filter, texteditor_insertfilter_innerresult *result)
-{
-       Bool cont;
-       UB subid;
-
-       for (;;) {
-               cont = texteditor_insertfilter_langcode(filter, result);
-               if (cont == False) {
-                       break;
-               }
-
-               if (result->type != INNERRESULT_VARIABLE) {
-                       return True;
-               }
-
-               if (result->variable.segid != TS_TFONT) {
-                       continue;
-               }
-               if (result->variable.len < 6) {
-                       continue;
-               }
-               subid = *(UH*)result->variable.data >> 8;
-               if (subid != 3) {
-                       continue;
-               }
-
-               filter->current.w_ratio = *((UH*)result->variable.data + 5);
-
-               return True;
-       }
-
-       return False;
-}
-
 /* */
 
 LOCAL Bool texteditor_insertfilter_w_ratio_isZenkaku(RATIO w_ratio)
@@ -219,196 +73,205 @@ LOCAL Bool texteditor_insertfilter_w_ratio_isSystemScript(tadlangcode *lang)
 
 /* */
 
-LOCAL TC texteditor_insertfilter_systemlangcode[] = { 0xFE21 };
-#define TEXTEDITOR_INSERTFILTER_SYSTEMLANGCODE_LENGTH 1
-
 LOCAL TC textediter_insertfilter_zenkakufusen[] = { 0xFFA2, 0x0006, 0x0300, 0x0101, 0x0101 };
 LOCAL TC textediter_insertfilter_hankakufusen[] = { 0xFFA2, 0x0006, 0x0300, 0x0101, 0x0102 };
 #define TEXTEDITOR_INSERTFILTER_FUSEN_LENGTH 5
 
-LOCAL VOID texteditor_insertfilter_setresult_systemlangcode(texteditor_insertfilter_result *result)
+LOCAL VOID texteditor_insertfilter_pushback_segment(texteditor_insertfilter_t *filter, tadsegment *segment)
 {
-       result->data = (UB*)texteditor_insertfilter_systemlangcode;
-       result->len = TEXTEDITOR_INSERTFILTER_SYSTEMLANGCODE_LENGTH * sizeof(TC);
+       assert(filter->result_buffer.used < TEXTEDITOR_INSERTFILTER_RESULT_BUFFER_LEN);
+       filter->result_buffer.segs[filter->result_buffer.used] = *segment;
+       filter->result_buffer.used++;
 }
 
-LOCAL VOID texteditor_insertfilter_setresult_firstlangcode(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result)
+LOCAL VOID texteditor_insertfilter_pushback_zenkakufusen(texteditor_insertfilter_t *filter)
 {
-       result->len = tadlangcodetoTC(&filter->first.lang, filter->buffer, TEXTEDITOR_INSERTFILTER_TEXTBUFFER_SIZE) * sizeof(TC);
-       result->data = (UB*)filter->buffer;
+       tadsegment segment;
+       segment.type = TADSEGMENT_TYPE_VARIABLE;
+       segment.value.variable.raw = (UB*)textediter_insertfilter_zenkakufusen;
+       segment.value.variable.rawlen = TEXTEDITOR_INSERTFILTER_FUSEN_LENGTH * sizeof(TC);
+       texteditor_insertfilter_pushback_segment(filter, &segment);
 }
 
-LOCAL VOID texteditor_insertfilter_setresult_zenkakufusen(texteditor_insertfilter_result *result)
+LOCAL VOID texteditor_insertfilter_pushback_hankakufusen(texteditor_insertfilter_t *filter)
 {
-       result->data = (UB*)textediter_insertfilter_zenkakufusen;
-       result->len = TEXTEDITOR_INSERTFILTER_FUSEN_LENGTH * sizeof(TC);
+       tadsegment segment;
+       segment.type = TADSEGMENT_TYPE_VARIABLE;
+       segment.value.variable.raw = (UB*)textediter_insertfilter_hankakufusen;
+       segment.value.variable.rawlen = TEXTEDITOR_INSERTFILTER_FUSEN_LENGTH * sizeof(TC);
+       texteditor_insertfilter_pushback_segment(filter, &segment);
 }
 
-LOCAL VOID texteditor_insertfilter_setresult_hankakufusen(texteditor_insertfilter_result *result)
+LOCAL VOID texteditor_insertfilter_pushback_systemlangcode(texteditor_insertfilter_t *filter)
 {
-       result->data = (UB*)textediter_insertfilter_hankakufusen;
-       result->len = TEXTEDITOR_INSERTFILTER_FUSEN_LENGTH * sizeof(TC);
+       tadsegment segment;
+       segment.type = TADSEGMENT_TYPE_LANGCODE;
+       segment.value.lang = (tadlangcode){0, 0x21};
+       texteditor_insertfilter_pushback_segment(filter, &segment);
 }
 
-/* */
+LOCAL VOID texteditor_insertfilter_pushback_firstlangcode(texteditor_insertfilter_t *filter)
+{
+       tadsegment segment;
+       segment.type = TADSEGMENT_TYPE_LANGCODE;
+       segment.value.lang = filter->first.lang;
+       texteditor_insertfilter_pushback_segment(filter, &segment);
+}
 
-LOCAL Bool texteditor_insertfilter_next_terminate(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result)
+LOCAL W texteditor_insertfilter_put_filtering(texteditor_insertfilter_t *filter, tadsegment *segment)
 {
-       Bool ok, zen;
+       W ret;
+       Bool cont;
+       tadsegment *result;
+       UB segid, subid, *segdata;
+       UW seglen;
 
-       if (filter->first.w_ratio != filter->current.w_ratio) {
-               filter->state = TEXTEDITOR_INSTERTFILTER_STATE_LAST_LANGCODE;
-               zen = texteditor_insertfilter_w_ratio_isZenkaku(filter->first.w_ratio);
-               if (zen == False) {
-                       texteditor_insertfilter_setresult_hankakufusen(result);
-               } else {
-                       texteditor_insertfilter_setresult_zenkakufusen(result);
-               }
-               return True;
+       ret = texteditor_stackfilter_setinput(&filter->stack, segment);
+       if (ret == TEXTEDITOR_STACKFILTER_SETINPUT_RESULT_FORMAT_ERROR) {
+               return TEXTEDITOR_INSERTFILTER_PUT_RESULT_FORMAT_ERROR;
        }
-       ok = tadlangcodecmp(&filter->first.lang, &filter->current.lang);
-       if (ok == False) {
-               filter->state = TEXTEDITOR_INSTERTFILTER_STATE_LAST;
-               texteditor_insertfilter_setresult_firstlangcode(filter, result);
-               return True;
+       for(;;) {
+               cont = texteditor_stackfilter_getoutput(&filter->stack, &result);
+               if (cont == False) {
+                       break;
+               }
+
+               if (result->type == TADSEGMENT_TYPE_VARIABLE) {
+                       tadsegment_getvariable(result, &segid, &seglen, &segdata);
+                       if (segid != TS_TFONT) {
+                               continue;
+                       }
+                       if (seglen < 6) {
+                               continue;
+                       }
+                       subid = *(UH*)segdata >> 8;
+                       if (subid != 3) {
+                               continue;
+                       }
+
+                       filter->current.w_ratio = *((UH*)segdata + 5);
+               } else if (result->type == TADSEGMENT_TYPE_LANGCODE) {
+                       filter->current.lang = result->value.lang;
+               }
+
+               texteditor_insertfilter_pushback_segment(filter, result);
        }
 
-       return False;
+       return TEXTEDITOR_INSERTFILTER_PUT_RESULT_OK;
 }
 
-LOCAL Bool texteditor_insertfilter_next_state_start(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result)
+LOCAL W texteditor_insertfilter_put_state_start(texteditor_insertfilter_t *filter, tadsegment *segment, texteditor_insertfilterresult_t **result)
 {
-       texteditor_insertfilter_innerresult inner_result;
-       Bool cont, ok;
+       Bool ok;
 
        ok = texteditor_insertfilter_w_ratio_isZenkaku(filter->first.w_ratio);
        if (ok == False) {
-               filter->state = TEXTEDITOR_INSTERTFILTER_STATE_FIRST_LANGCODE;
-               texteditor_insertfilter_setresult_zenkakufusen(result);
-               return True;
+               texteditor_insertfilter_pushback_zenkakufusen(filter);
        }
        ok = texteditor_insertfilter_w_ratio_isSystemScript(&filter->first.lang);
        if (ok == False) {
-               filter->state = TEXTEDITOR_INSTERTFILTER_STATE_RUNNING;
-               texteditor_insertfilter_setresult_systemlangcode(result);
-               return True;
+               texteditor_insertfilter_pushback_systemlangcode(filter);
        }
 
-       cont = texteditor_insertfilter_chratio(filter, &inner_result);
-       if (cont == False) {
-               return texteditor_insertfilter_next_terminate(filter, result);
-       }
+       *result = &filter->result;
 
-       filter->state = TEXTEDITOR_INSTERTFILTER_STATE_RUNNING;
-       result->data = inner_result.data;
-       result->len = inner_result.len;
+       filter->state = TEXTEDITOR_INSERTFILTER_STATE_RUNNING;
 
-       return True;
+       return texteditor_insertfilter_put_filtering(filter, segment);
 }
 
-LOCAL Bool texteditor_insertfilter_next_state_langcode(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result)
+LOCAL W texteditor_insertfilter_put_state_running(texteditor_insertfilter_t *filter, tadsegment *segment, texteditor_insertfilterresult_t **result)
 {
-       texteditor_insertfilter_innerresult inner_result;
-       Bool cont, ok;
-
-       ok = texteditor_insertfilter_w_ratio_isSystemScript(&filter->first.lang);
-       if (ok == False) {
-               filter->state = TEXTEDITOR_INSTERTFILTER_STATE_RUNNING;
-               texteditor_insertfilter_setresult_systemlangcode(result);
-               return True;
-       }
+       filter->result_buffer.used = 0;
+       filter->result_buffer.consumed = 0;
 
-       cont = texteditor_insertfilter_chratio(filter, &inner_result);
-       if (cont == False) {
-               return texteditor_insertfilter_next_terminate(filter, result);
-       }
-
-       filter->state = TEXTEDITOR_INSTERTFILTER_STATE_RUNNING;
-       result->data = inner_result.data;
-       result->len = inner_result.len;
+       *result = &filter->result;
 
-       return True;
+       return texteditor_insertfilter_put_filtering(filter, segment);
 }
 
-LOCAL Bool texteditor_insertfilter_next_state_running(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result)
+EXPORT W texteditor_insertfilter_put(texteditor_insertfilter_t *filter, tadsegment *segment, texteditor_insertfilterresult_t **result)
 {
-       texteditor_insertfilter_innerresult inner_result;
-       Bool cont;
-
-       cont = texteditor_insertfilter_chratio(filter, &inner_result);
-       if (cont == False) {
-               return texteditor_insertfilter_next_terminate(filter, result);
+       switch (filter->state) {
+       case TEXTEDITOR_INSERTFILTER_STATE_START:
+               DP_STATE("put:STATE_START");
+               return texteditor_insertfilter_put_state_start(filter, segment, result);
+       case TEXTEDITOR_INSERTFILTER_STATE_RUNNING:
+               DP_STATE("put:STATE_RUNNING");
+               return texteditor_insertfilter_put_state_running(filter, segment, result);
+       case TEXTEDITOR_INSERTFILTER_STATE_END:
+               DP_STATE("put:STATE_END");
+               return TEXTEDITOR_INSERTFILTER_PUT_RESULT_FORMAT_ERROR;
        }
-
-       filter->state = TEXTEDITOR_INSTERTFILTER_STATE_RUNNING;
-       result->data = inner_result.data;
-       result->len = inner_result.len;
-
-       return True;
+       return TEXTEDITOR_INSERTFILTER_PUT_RESULT_FORMAT_ERROR;
 }
 
-LOCAL Bool texteditor_insertfilter_next_state_last_langcode(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result)
+EXPORT VOID texteditor_insertfilter_endinput(texteditor_insertfilter_t *filter, texteditor_insertfilterresult_t **result)
 {
-       Bool ok;
+       Bool ok, zen;
 
-       ok = tadlangcodecmp(&filter->first.lang, &filter->current.lang);
-       if (ok == False) {
-               filter->state = TEXTEDITOR_INSTERTFILTER_STATE_LAST;
-               texteditor_insertfilter_setresult_firstlangcode(filter, result);
-               return True;
-       }
+       filter->result_buffer.used = 0;
+       filter->result_buffer.consumed = 0;
+       *result = &filter->result;
 
-       return False;
+       switch (filter->state) {
+       case TEXTEDITOR_INSERTFILTER_STATE_START:
+               DP_STATE("end:STATE_START");
+               break;
+       case TEXTEDITOR_INSERTFILTER_STATE_RUNNING:
+               DP_STATE("end:STATE_RUNNING");
+               if (filter->first.w_ratio != filter->current.w_ratio) {
+                       zen = texteditor_insertfilter_w_ratio_isZenkaku(filter->first.w_ratio);
+                       if (zen == False) {
+                               texteditor_insertfilter_pushback_hankakufusen(filter);
+                       } else {
+                               texteditor_insertfilter_pushback_zenkakufusen(filter);
+                       }
+               }
+               ok = tadlangcodecmp(&filter->first.lang, &filter->current.lang);
+               if (ok == False) {
+                       texteditor_insertfilter_pushback_firstlangcode(filter);
+               }
+               break;
+       case TEXTEDITOR_INSERTFILTER_STATE_END:
+               DP_STATE("end:STATE_END");
+               break;
+       }
 }
 
-LOCAL Bool texteditor_insertfilter_next_state_last(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result)
+EXPORT Bool texteditor_insertfilterresult_next(texteditor_insertfilterresult_t *result, tadsegment **segment)
 {
-       return False;
-}
+       texteditor_insertfilter_t *filter = result->filter;
 
-EXPORT Bool texteditor_insertfilter_next(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result)
-{
-       Bool cont = False;
+       if (filter->result_buffer.consumed >= filter->result_buffer.used) {
+               return False;
+       }
 
-       switch (filter->state) {
-       case TEXTEDITOR_INSTERTFILTER_STATE_START:
-               DP_STATE("STATE_START");
-               cont = texteditor_insertfilter_next_state_start(filter, result);
-               break;
-       case TEXTEDITOR_INSTERTFILTER_STATE_FIRST_LANGCODE:
-               DP_STATE("STATE_FIRST_LANGCODE");
-               cont = texteditor_insertfilter_next_state_langcode(filter, result);
-               break;
-       case TEXTEDITOR_INSTERTFILTER_STATE_RUNNING:
-               DP_STATE("STATE_RUNNING");
-               cont = texteditor_insertfilter_next_state_running(filter, result);
-               break;
-       case TEXTEDITOR_INSTERTFILTER_STATE_LAST_LANGCODE:
-               DP_STATE("STATE_LAST_LANGCODE");
-               cont = texteditor_insertfilter_next_state_last_langcode(filter, result);
-               break;
-       case TEXTEDITOR_INSTERTFILTER_STATE_LAST:
-               DP_STATE("STATE_LAST");
-               cont = texteditor_insertfilter_next_state_last(filter, result);
-               break;
+       *segment = filter->result_buffer.segs + filter->result_buffer.consumed;
+       filter->result_buffer.consumed++;
+
+       if (filter->result_buffer.consumed >= filter->result_buffer.used) {
+               filter->result_buffer.used = 0;
+               filter->result_buffer.consumed = 0;
        }
 
-       return cont;
+       return True;
 }
 
-EXPORT VOID texteditor_insertfilter_initialize(texteditor_insertfilter_t *filter, tadlangcode *lang, RATIO w_ratio, UB *data, W len)
+EXPORT VOID texteditor_insertfilter_initialize(texteditor_insertfilter_t *filter, tadlangcode *lang, RATIO w_ratio)
 {
-       filter->state = TEXTEDITOR_INSTERTFILTER_STATE_START;
+       texteditor_stackfilter_initialize(&filter->stack);
+       filter->state = TEXTEDITOR_INSERTFILTER_STATE_START;
        filter->first.lang = *lang;
        filter->first.w_ratio = w_ratio;
        filter->current.lang = (tadlangcode){0, 0x21};
        filter->current.w_ratio = 0x0101;
-       tadstack_initialize(&filter->tadstack);
-       taditerator_initialize(&filter->iterator, (TC*)data, len / sizeof(TC));
+       filter->result_buffer.used = 0;
+       filter->result_buffer.consumed = 0;
+       filter->result.filter = filter;
 }
 
 EXPORT VOID texteditor_insertfilter_finalize(texteditor_insertfilter_t *filter)
 {
-       taditerator_finalize(&filter->iterator);
-       tadstack_finalize(&filter->tadstack);
+       texteditor_stackfilter_finalize(&filter->stack);
 }

diff --git a/src/control/texteditor_insertfilter.h b/src/control/texteditor_insertfilter.h
index af33b5d..d84022d 100644 (file)
--- a/src/control/texteditor_insertfilter.h
+++ b/src/control/texteditor_insertfilter.h
@@ -29,21 +29,23 @@
 #include       <tad/tadstack.h>
 #include       <tad/taditerator.h>
 #include       <tad/tadlangcode.h>
+#include       "texteditor_stackfilter.h"
 
 #ifndef __TEXTEDITOR_INSERTFILTER_H__
 #define __TEXTEDITOR_INSERTFILTER_H__
 
-#define TEXTEDITOR_INSERTFILTER_TEXTBUFFER_SIZE 10
+typedef struct texteditor_insertfilter_t_ texteditor_insertfilter_t;
+typedef struct texteditor_insertfilterresult_t_ texteditor_insertfilterresult_t;
 
-/* Functionality name: texteditor */
-/* Detail name: insertfilter */
+struct texteditor_insertfilterresult_t_ {
+       texteditor_insertfilter_t *filter;
+};
 struct texteditor_insertfilter_t_ {
+       texteditor_stackfilter_t stack;
        enum {
-               TEXTEDITOR_INSTERTFILTER_STATE_START,
-               TEXTEDITOR_INSTERTFILTER_STATE_FIRST_LANGCODE,
-               TEXTEDITOR_INSTERTFILTER_STATE_RUNNING,
-               TEXTEDITOR_INSTERTFILTER_STATE_LAST_LANGCODE,
-               TEXTEDITOR_INSTERTFILTER_STATE_LAST,
+               TEXTEDITOR_INSERTFILTER_STATE_START,
+               TEXTEDITOR_INSERTFILTER_STATE_RUNNING,
+               TEXTEDITOR_INSERTFILTER_STATE_END,
        } state;
        struct {
                tadlangcode lang;
@@ -53,24 +55,21 @@ struct texteditor_insertfilter_t_ {
                tadlangcode lang;
                RATIO w_ratio;
        } current;
-       tadstack_t tadstack;
-       taditerator_t iterator;
-       TC buffer[TEXTEDITOR_INSERTFILTER_TEXTBUFFER_SIZE];
-};
-typedef struct texteditor_insertfilter_t_ texteditor_insertfilter_t;
-
-/* Functionality name: texteditor */
-/* Detail name: insertfilter */
-/* Data structure identifier: result */
-struct texteditor_insertfilter_result_ {
-       UB *data;
-       W len;
+       struct {
+#define TEXTEDITOR_INSERTFILTER_RESULT_BUFFER_LEN (3)
+               tadsegment segs[TEXTEDITOR_INSERTFILTER_RESULT_BUFFER_LEN];
+               W used;
+               W consumed;
+       } result_buffer;
+       texteditor_insertfilterresult_t result;
 };
-typedef struct texteditor_insertfilter_result_ texteditor_insertfilter_result;
 
-IMPORT VOID texteditor_insertfilter_initialize(texteditor_insertfilter_t *filter, tadlangcode *lang, RATIO w_ratio, UB *data, W len);
+IMPORT VOID texteditor_insertfilter_initialize(texteditor_insertfilter_t *filter, tadlangcode *lang, RATIO w_ratio);
 IMPORT VOID texteditor_insertfilter_finalize(texteditor_insertfilter_t *filter);
-
-IMPORT Bool texteditor_insertfilter_next(texteditor_insertfilter_t *filter, texteditor_insertfilter_result *result);
+IMPORT W texteditor_insertfilter_put(texteditor_insertfilter_t *filter, tadsegment *segment, texteditor_insertfilterresult_t **result);
+#define TEXTEDITOR_INSERTFILTER_PUT_RESULT_OK (0)
+#define TEXTEDITOR_INSERTFILTER_PUT_RESULT_FORMAT_ERROR (-1)
+IMPORT VOID texteditor_insertfilter_endinput(texteditor_insertfilter_t *filter, texteditor_insertfilterresult_t **result);
+IMPORT Bool texteditor_insertfilterresult_next(texteditor_insertfilterresult_t *filter, tadsegment **segment);
 
 #endif

diff --git a/src/control/texteditor_textfragment.c b/src/control/texteditor_textfragment.c
index 1ea2218..565b2d0 100644 (file)
--- a/src/control/texteditor_textfragment.c
+++ b/src/control/texteditor_textfragment.c
@@ -103,30 +103,26 @@ LOCAL W texteditor_insertcontext_bufferprepair(tadfragment_cursor_t *src, texted
        return 0;
 }
 
-LOCAL W texteditor_insertcontext_bufferappend(texteditor_characterstate_t *state, tadlangcode *lang, Bool is_hankaku, UB *insert_data, W insert_len, tadfragment_cursor_t *dest)
+LOCAL W texteditor_insertcontext_bufferappend(texteditor_characterstate_t *state, texteditor_insertfilterresult_t *result, tadfragment_cursor_t *dest)
 {
-       texteditor_insertfilter_t filter;
-       texteditor_insertfilter_result filter_result;
-       tadsegment segment;
+       tadsegment *segment;
        W err = 0;
        Bool cont;
 
-       texteditor_insertfilter_initialize(&filter, lang, (is_hankaku != False) ? 0x0102 : 0x0101, insert_data, insert_len);
        for (;;) {
-               cont = texteditor_insertfilter_next(&filter, &filter_result);
+               cont = texteditor_insertfilterresult_next(result, &segment);
                if (cont == False) {
                        break;
                }
 
-               err = tadfragment_cursor_insert(dest, filter_result.data, filter_result.len);
+               err = tadfragment_cursor_insertsegment(dest, segment);
                if (err < 0) {
                        break;
                }
 
-               tadfragment_cursor_getdata(dest, &segment);
-               texteditor_charactorstate_input(state, &segment);
+               tadfragment_cursor_getdata(dest, segment);
+               texteditor_charactorstate_input(state, segment);
        }
-       texteditor_insertfilter_finalize(&filter);
 
        return err;
 }
@@ -163,15 +159,11 @@ LOCAL W texteditor_insertcontext_bufferafterappend(texteditor_characterstate_t *
        return err;
 }
 
-EXPORT W texteditor_insertcontext_insert(texteditor_insertcontext_t *ctx, UB *data, W len)
+EXPORT W texteditor_insertcontext_insert(texteditor_insertcontext_t *ctx, tadsegment *segment)
 {
-       tadlangcode lang;
-       Bool is_hankaku;
-
-       is_hankaku = texteditor_characterstate_ishankaku(&ctx->state);
-       texteditor_characterstate_getlangcode(&ctx->state, &lang);
-
-       return texteditor_insertcontext_bufferappend(&ctx->state, &lang, is_hankaku, data, len, &ctx->dest.cursor);
+       texteditor_insertfilterresult_t *result;
+       texteditor_insertfilter_put(&ctx->filter, segment, &result);
+       return texteditor_insertcontext_bufferappend(&ctx->state, result, &ctx->dest.cursor);
 }
 
 EXPORT W texteditor_insertcontext_initialize(texteditor_insertcontext_t *ctx, texteditor_textfragment_t *target, GID gid, W pos)
@@ -198,6 +190,8 @@ EXPORT W texteditor_insertcontext_initialize(texteditor_insertcontext_t *ctx, te
        ctx->pos_state.is_hankaku = texteditor_characterstate_ishankaku(&ctx->state);
        texteditor_characterstate_getlangcode(&ctx->state, &ctx->pos_state.lang);
 
+       texteditor_insertfilter_initialize(&ctx->filter, &ctx->pos_state.lang, (ctx->pos_state.is_hankaku != False) ? 0x0102 : 0x0101);
+
        return 0;
 
 error_prepair:
@@ -214,6 +208,15 @@ EXPORT W texteditor_insertcontext_finalize(texteditor_insertcontext_t *ctx)
 {
        W len, err = 0;
        UB *data;
+       texteditor_insertfilterresult_t *result;
+
+       texteditor_insertfilter_endinput(&ctx->filter, &result);
+       err = texteditor_insertcontext_bufferappend(&ctx->state, result, &ctx->dest.cursor);
+       if (err < 0) {
+               tadfragment_cursor_finalize(&ctx->dest.cursor);
+               tadfragment_cursor_finalize(&ctx->target_cursor);
+               goto finalize;
+       }
 
        err = texteditor_insertcontext_bufferafterappend(&ctx->state, &ctx->target_cursor, &ctx->dest.cursor);
        if (err < 0) {
@@ -232,6 +235,7 @@ EXPORT W texteditor_insertcontext_finalize(texteditor_insertcontext_t *ctx)
 
 finalize:
 
+       texteditor_insertfilter_finalize(&ctx->filter);
        texteditor_characterstate_finalize(&ctx->state);
        tadfragment_finalize(&ctx->dest.fragment);
 

diff --git a/src/control/texteditor_textfragment.h b/src/control/texteditor_textfragment.h
index af76ef4..b544ef5 100644 (file)
--- a/src/control/texteditor_textfragment.h
+++ b/src/control/texteditor_textfragment.h
@@ -62,12 +62,13 @@ struct texteditor_insertcontext_t_ {
                tadlangcode lang;
                Bool is_hankaku;
        } pos_state;
+       texteditor_insertfilter_t filter;
        GID gid;
 };
 typedef struct texteditor_insertcontext_t_ texteditor_insertcontext_t;
 
 IMPORT W texteditor_insertcontext_initialize(texteditor_insertcontext_t *ctx, texteditor_textfragment_t *target, GID gid, W pos);
 IMPORT W texteditor_insertcontext_finalize(texteditor_insertcontext_t *ctx);
-IMPORT W texteditor_insertcontext_insert(texteditor_insertcontext_t *ctx, UB *data, W len);
+IMPORT W texteditor_insertcontext_insert(texteditor_insertcontext_t *ctx, tadsegment *segment);
 
 #endif