From 402c38b218f960b8cc14591ab919da889289801e Mon Sep 17 00:00:00 2001 From: ornse01 Date: Thu, 5 Dec 2013 16:26:26 +0000 Subject: [PATCH] implement TC language code short format. git-svn-id: http://svn.sourceforge.jp/svnroot/bchan/bchanf/trunk@593 20a0b8eb-f62a-4a12-8fe1-b598822500fb --- src/tad/tadlangcode.c | 161 +++++++++++++++++++ src/tad/tadlangcode.h | 75 +++++++++ src/tad/test_tadlangcode.c | 389 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 625 insertions(+) create mode 100644 src/tad/tadlangcode.c create mode 100644 src/tad/tadlangcode.h create mode 100644 src/tad/test_tadlangcode.c diff --git a/src/tad/tadlangcode.c b/src/tad/tadlangcode.c new file mode 100644 index 0000000..71fa6a0 --- /dev/null +++ b/src/tad/tadlangcode.c @@ -0,0 +1,161 @@ +/* + * tadlangcode.c + * + * Copyright (c) 2013 project bchan + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ + +#include "tadlangcode.h" + +#include + +#ifdef BCHAN_CONFIG_DEBUG +# define DP(arg) printf arg +# define DP_ER(msg, err) printf("%s (%d/%x)\n", msg, err>>16, err) +#else +# define DP(arg) /**/ +# define DP_ER(msg, err) /**/ +#endif + +EXPORT TADLANGCODE_PARSER_RESULT tadlangcode_parser_inputchar(tadlangcode_parser_t *parser, TC ch) +{ + switch (parser->state) { + case TADLANGCODE_PARSER_STATE_START: + if ((ch & 0xFF00) != 0xFE00) { + return TADLANGCODE_PARSER_RESULT_INVALID; + } + if (ch == 0xFEFE) { + parser->state = TADLANGCODE_PARSER_STATE_LANGCODE; + parser->iter = 1; + return TADLANGCODE_PARSER_RESULT_CONTINUE; + } + parser->state = TADLANGCODE_PARSER_STATE_DETERMINED; + parser->iter = 0; + parser->code = ch & 0xFF; + return TADLANGCODE_PARSER_RESULT_DETERMINED; + case TADLANGCODE_PARSER_STATE_LANGCODE: + if (ch == 0xFEFE) { + parser->iter += 2; + return TADLANGCODE_PARSER_RESULT_CONTINUE; + } + if ((ch & 0xFF00) == 0x0000) { + parser->state = TADLANGCODE_PARSER_STATE_DETERMINED; + parser->code = ch & 0xFF; + return TADLANGCODE_PARSER_RESULT_DETERMINED; + } + if ((ch & 0xFF00) == 0xFE00) { + parser->state = TADLANGCODE_PARSER_STATE_DETERMINED; + parser->iter += 1; + parser->code = ch & 0xFF; + return TADLANGCODE_PARSER_RESULT_DETERMINED; + } + return TADLANGCODE_PARSER_RESULT_INVALID; + case TADLANGCODE_PARSER_STATE_DETERMINED: + return TADLANGCODE_PARSER_RESULT_INVALID; + } + return TADLANGCODE_PARSER_RESULT_INVALID; +} + +EXPORT W tadlangcode_parser_getlangcode(tadlangcode_parser_t *parser, tadlangcode *langcode) +{ + if (parser->state != TADLANGCODE_PARSER_STATE_DETERMINED) { + return -1; /* TODO */ + } + langcode->iter = parser->iter; + langcode->code = parser->code; + return 0; +} + +EXPORT VOID tadlangcode_parser_initialize(tadlangcode_parser_t *parser) +{ + parser->state = TADLANGCODE_PARSER_STATE_START; + parser->iter = 0; + parser->code = 0; +} + +EXPORT VOID tadlangcode_parser_finalize(tadlangcode_parser_t *parser) +{ +} + +EXPORT W tadlangcodetoTC(tadlangcode *src, TC *dest, W dest_len) +{ + W i, req_len; + + req_len = 2 + (src->iter+1)/2*2; + + if (dest == NULL || dest_len < 0) { + return req_len / sizeof(TC); + } + + for (i = 0; i < (src->iter + 1) / 2; i++) { + dest[i] = 0xFEFE; + } + if (src->iter % 2 == 1) { + dest[i] = src->code; + } else { + dest[i] = 0xFE00 | src->code; + } + + return req_len / sizeof(TC); +} + +EXPORT W TCtotadlangcode(TC *src, W src_len, tadlangcode *dest) +{ + tadlangcode_parser_t parser; + W i, err; + TADLANGCODE_PARSER_RESULT result; + + tadlangcode_parser_initialize(&parser); + + for (i = 0; i < src_len; i++) { + result = tadlangcode_parser_inputchar(&parser, src[i]); + if (result == TADLANGCODE_PARSER_RESULT_DETERMINED) { + break; + } + } + + err = tadlangcode_parser_getlangcode(&parser, dest); + + tadlangcode_parser_finalize(&parser); + + return err; +} + +EXPORT Bool tadlangcodecmpTC(TC *str, W len, tadlangcode *langcode) +{ + W err; + tadlangcode lang; + + err = TCtotadlangcode(str, len, &lang); + if (err < 0) { + return False; + } + return tadlangcodecmp(&lang, langcode); +} + +EXPORT Bool tadlangcodecmp(tadlangcode *langcode1, tadlangcode *langcode2) +{ + if ((langcode1->iter == langcode2->iter)&&(langcode1->code == langcode2->code)) { + return True; + } + return False; +} diff --git a/src/tad/tadlangcode.h b/src/tad/tadlangcode.h new file mode 100644 index 0000000..5c1902e --- /dev/null +++ b/src/tad/tadlangcode.h @@ -0,0 +1,75 @@ +/* + * tadlangcode.h + * + * Copyright (c) 2013 project bchan + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ + +/* Vendor name: */ +/* Functionality name: tadlangcode */ +/* Detail name: */ + +#include + +#ifndef __TADLANGCODE_H__ +#define __TADLANGCODE_H__ + +struct tadlangcode_ { + UW iter; + UB code; +}; +typedef struct tadlangcode_ tadlangcode; + +IMPORT W tadlangcodetoTC(tadlangcode *src, TC *dest, W dest_len); +IMPORT W TCtotadlangcode(TC *src, W src_len, tadlangcode *dest); +IMPORT Bool tadlangcodecmpTC(TC *str, W len, tadlangcode *langcode); +IMPORT Bool tadlangcodecmp(tadlangcode *langcode1, tadlangcode *langcode2); + +/* Functionality name: tadlangcode */ +/* Detail name: parser */ +struct tadlangcode_parser_t_ { + enum { + TADLANGCODE_PARSER_STATE_START, + TADLANGCODE_PARSER_STATE_LANGCODE, + TADLANGCODE_PARSER_STATE_DETERMINED, + } state; + UW iter; + UB code; +}; +typedef struct tadlangcode_parser_t_ tadlangcode_parser_t; + +/* Functionality name: tadlangcode */ +/* Detail name: parser */ +/* Data structure identifier: result */ +enum TADLANGCODE_PARSER_RESULT_ { + TADLANGCODE_PARSER_RESULT_CONTINUE, + TADLANGCODE_PARSER_RESULT_INVALID, + TADLANGCODE_PARSER_RESULT_DETERMINED, +}; +typedef enum TADLANGCODE_PARSER_RESULT_ TADLANGCODE_PARSER_RESULT; + +IMPORT VOID tadlangcode_parser_initialize(tadlangcode_parser_t *parser); +IMPORT VOID tadlangcode_parser_finalize(tadlangcode_parser_t *parser); +IMPORT TADLANGCODE_PARSER_RESULT tadlangcode_parser_inputchar(tadlangcode_parser_t *parser, TC ch); +IMPORT W tadlangcode_parser_getlangcode(tadlangcode_parser_t *parser, tadlangcode *langcode); + +#endif diff --git a/src/tad/test_tadlangcode.c b/src/tad/test_tadlangcode.c new file mode 100644 index 0000000..89e90d2 --- /dev/null +++ b/src/tad/test_tadlangcode.c @@ -0,0 +1,389 @@ +/* + * test_tadlangcode.c + * + * Copyright (c) 2013 project bchan + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would be + * appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not be + * misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + */ + +#include "test_tad.h" + +#include "tadlangcode.h" + +#include +#include +#include +#include +#include + +#include + +LOCAL UNITTEST_RESULT test_TCtotadlangcode_common(TC *testdata, W testdata_len, tadlangcode *expected) +{ + W err; + Bool cmp; + tadlangcode result; + + err = TCtotadlangcode(testdata, testdata_len, &result); + if (err < 0) { + return UNITTEST_RESULT_FAIL; + } + cmp = tadlangcodecmp(&result, expected); + if (cmp == False) { + return UNITTEST_RESULT_FAIL; + } + return UNITTEST_RESULT_PASS; +} + +LOCAL UNITTEST_RESULT test_TCtotadlangcode_1() +{ + TC testdata[] = {0xFE21}; + W testdata_len = 1; + tadlangcode expected = {0, 0x21}; + return test_TCtotadlangcode_common(testdata, testdata_len, &expected); +} + +LOCAL UNITTEST_RESULT test_TCtotadlangcode_2() +{ + TC testdata[] = {0xFE22}; + W testdata_len = 1; + tadlangcode expected = {0, 0x22}; + return test_TCtotadlangcode_common(testdata, testdata_len, &expected); +} + +LOCAL UNITTEST_RESULT test_TCtotadlangcode_3() +{ + TC testdata[] = {0xFEFE, 0xFE21}; + W testdata_len = 2; + tadlangcode expected = {2, 0x21}; + return test_TCtotadlangcode_common(testdata, testdata_len, &expected); +} + +LOCAL UNITTEST_RESULT test_TCtotadlangcode_4() +{ + TC testdata[] = {0xFEFE, 0x0021}; + W testdata_len = 2; + tadlangcode expected = {1, 0x21}; + return test_TCtotadlangcode_common(testdata, testdata_len, &expected); +} + +LOCAL UNITTEST_RESULT test_TCtotadlangcode_5() +{ + TC testdata[] = {0xFEFE, 0xFEFE, 0xFE21}; + W testdata_len = 3; + tadlangcode expected = {4, 0x21}; + return test_TCtotadlangcode_common(testdata, testdata_len, &expected); +} + +LOCAL UNITTEST_RESULT test_TCtotadlangcode_6() +{ + TC testdata[] = {0xFEFE, 0xFEFE, 0x0021}; + W testdata_len = 3; + tadlangcode expected = {3, 0x21}; + return test_TCtotadlangcode_common(testdata, testdata_len, &expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodetoTC_common(tadlangcode *testdata, TC *expected, W expected_len) +{ + W len; + TC *str; + + len = tadlangcodetoTC(testdata, NULL, 1); + if (len != expected_len) { + printf("tadlangcodetoTC length check 1 error\n"); + return UNITTEST_RESULT_FAIL; + } + + str = malloc(sizeof(TC)*len); + if (str == NULL) { + return UNITTEST_RESULT_FAIL; + } + + len = tadlangcodetoTC(testdata, str, -1); + if (len != expected_len) { + free(str); + printf("tadlangcodetoTC length check 2 error\n"); + return UNITTEST_RESULT_FAIL; + } + + len = tadlangcodetoTC(testdata, str, len); + if (len != expected_len) { + free(str); + printf("tadlangcodetoTC converted length error\n"); + return UNITTEST_RESULT_FAIL; + } + if (tc_strncmp(str, expected, len) != 0) { + free(str); + printf("tadlangcodetoTC convarted string error\n"); + return UNITTEST_RESULT_FAIL; + } + + free(str); + + return UNITTEST_RESULT_PASS; +} + +LOCAL UNITTEST_RESULT test_tadlangcodetoTC_1() +{ + tadlangcode testdata = {0, 0x21}; + TC expected[] = {0xFE21}; + W expected_len = 1; + return test_tadlangcodetoTC_common(&testdata, expected, expected_len); +} + +LOCAL UNITTEST_RESULT test_tadlangcodetoTC_2() +{ + tadlangcode testdata = {0, 0x22}; + TC expected[] = {0xFE22}; + W expected_len = 1; + return test_tadlangcodetoTC_common(&testdata, expected, expected_len); +} + +LOCAL UNITTEST_RESULT test_tadlangcodetoTC_3() +{ + tadlangcode testdata = {2, 0x21}; + TC expected[] = {0xFEFE, 0xFE21}; + W expected_len = 2; + return test_tadlangcodetoTC_common(&testdata, expected, expected_len); +} + +LOCAL UNITTEST_RESULT test_tadlangcodetoTC_4() +{ + tadlangcode testdata = {1, 0x21}; + TC expected[] = {0xFEFE, 0x0021}; + W expected_len = 2; + return test_tadlangcodetoTC_common(&testdata, expected, expected_len); +} + +LOCAL UNITTEST_RESULT test_tadlangcodetoTC_5() +{ + tadlangcode testdata = {4, 0x21}; + TC expected[] = {0xFEFE, 0xFEFE, 0xFE21}; + W expected_len = 3; + return test_tadlangcodetoTC_common(&testdata, expected, expected_len); +} + +LOCAL UNITTEST_RESULT test_tadlangcodetoTC_6() +{ + tadlangcode testdata = {3, 0x21}; + TC expected[] = {0xFEFE, 0xFEFE, 0x0021}; + W expected_len = 3; + return test_tadlangcodetoTC_common(&testdata, expected, expected_len); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_common(tadlangcode *testdata1, TC *testdata2, W testdata2_len, Bool expected) +{ + Bool ret; + UNITTEST_RESULT result = UNITTEST_RESULT_PASS; + + ret = tadlangcodecmpTC(testdata2, testdata2_len, testdata1); + if (ret == False) { + if (expected != False) { + result = UNITTEST_RESULT_FAIL; + } + } else { + if (expected == False) { + result = UNITTEST_RESULT_FAIL; + } + } + + return result; +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_1() +{ + tadlangcode testdata1 = {0, 0x21}; + TC testdata2[] = {0xFE21}; + W testdata2_len = 1; + Bool expected = True; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_2() +{ + tadlangcode testdata1 = {0, 0x22}; + TC testdata2[] = {0xFE22}; + W testdata2_len = 1; + Bool expected = True; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_3() +{ + tadlangcode testdata1 = {2, 0x21}; + TC testdata2[] = {0xFEFE, 0xFE21}; + W testdata2_len = 2; + Bool expected = True; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_4() +{ + tadlangcode testdata1 = {1, 0x21}; + TC testdata2[] = {0xFEFE, 0x0021}; + W testdata2_len = 2; + Bool expected = True; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_5() +{ + tadlangcode testdata1 = {4, 0x21}; + TC testdata2[] = {0xFEFE, 0xFEFE, 0xFE21}; + W testdata2_len = 3; + Bool expected = True; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_6() +{ + tadlangcode testdata1 = {3, 0x21}; + TC testdata2[] = {0xFEFE, 0xFEFE, 0x0021}; + W testdata2_len = 3; + Bool expected = True; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_7() +{ + tadlangcode testdata1 = {0, 0x21}; + TC testdata2[] = {0xFE22}; + W testdata2_len = 1; + Bool expected = False; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_8() +{ + tadlangcode testdata1 = {2, 0x21}; + TC testdata2[] = {0xFEFE, 0xFE22}; + W testdata2_len = 2; + Bool expected = False; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmpTC_9() +{ + tadlangcode testdata1 = {4, 0x21}; + TC testdata2[] = {0xFEFE, 0xFEFE, 0xFE22}; + W testdata2_len = 3; + Bool expected = False; + return test_tadlangcodecmpTC_common(&testdata1, testdata2, testdata2_len, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmp_common(tadlangcode *testdata1, tadlangcode *testdata2, Bool expected) +{ + Bool ret; + UNITTEST_RESULT result = UNITTEST_RESULT_PASS; + + ret = tadlangcodecmp(testdata1, testdata2); + if (ret == False) { + if (expected != False) { + result = UNITTEST_RESULT_FAIL; + } + } else { + if (expected == False) { + result = UNITTEST_RESULT_FAIL; + } + } + + return result; +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmp_1() +{ + tadlangcode testdata1 = {0, 0x21}; + tadlangcode testdata2 = {0, 0x21}; + Bool expected = True; + return test_tadlangcodecmp_common(&testdata1, &testdata2, expected); +} + + +LOCAL UNITTEST_RESULT test_tadlangcodecmp_2() +{ + tadlangcode testdata1 = {0, 0x21}; + tadlangcode testdata2 = {0, 0x22}; + Bool expected = False; + return test_tadlangcodecmp_common(&testdata1, &testdata2, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmp_3() +{ + tadlangcode testdata1 = {0, 0x21}; + tadlangcode testdata2 = {1, 0x21}; + Bool expected = False; + return test_tadlangcodecmp_common(&testdata1, &testdata2, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmp_4() +{ + tadlangcode testdata1 = {1, 0x21}; + tadlangcode testdata2 = {1, 0x21}; + Bool expected = True; + return test_tadlangcodecmp_common(&testdata1, &testdata2, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmp_5() +{ + tadlangcode testdata1 = {1, 0x21}; + tadlangcode testdata2 = {1, 0x22}; + Bool expected = False; + return test_tadlangcodecmp_common(&testdata1, &testdata2, expected); +} + +LOCAL UNITTEST_RESULT test_tadlangcodecmp_6() +{ + tadlangcode testdata1 = {1, 0x21}; + tadlangcode testdata2 = {2, 0x21}; + Bool expected = False; + return test_tadlangcodecmp_common(&testdata1, &testdata2, expected); +} + +EXPORT VOID test_tadlangcode_main(unittest_driver_t *driver) +{ + UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_1); + UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_2); + UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_3); + UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_4); + UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_5); + UNITTEST_DRIVER_REGIST(driver, test_TCtotadlangcode_6); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_1); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_2); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_3); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_4); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_5); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodetoTC_6); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_1); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_2); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_3); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_4); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_5); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_6); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_7); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_8); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmpTC_9); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_1); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_2); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_3); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_4); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_5); + UNITTEST_DRIVER_REGIST(driver, test_tadlangcodecmp_6); +} -- 2.11.0