--- /dev/null
+/*
+** Copyright 2011 Double Precision, Inc.
+** See COPYING for distribution information.
+**
+*/
+
+#include "unicode_config.h"
+#include "unicode.h"
+
+#include <unistd.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include "linebreaktab_internal.h"
+
+#include "linebreaktab.h"
+
+#define UNICODE_LB_SOT 0xFF
+
+struct unicode_lb_info {
+ int (*cb_func)(int, void *);
+ void *cb_arg;
+
+ int opts;
+
+ uint8_t savedclass;
+ size_t savedcmcnt;
+
+ uint8_t prevclass;
+ uint8_t prevclass_nsp;
+
+ int (*next_handler)(struct unicode_lb_info *, uint8_t);
+ int (*end_handler)(struct unicode_lb_info *);
+};
+
+
+/* http://www.unicode.org/reports/tr14/#Algorithm */
+
+static int next_def(unicode_lb_info_t, uint8_t);
+static int end_def(unicode_lb_info_t);
+
+static int next_lb25_seenophy(unicode_lb_info_t, uint8_t);
+static int end_lb25_seenophy(unicode_lb_info_t);
+
+static int next_lb25_seennu(unicode_lb_info_t, uint8_t);
+
+static int next_lb25_seennuclcp(unicode_lb_info_t, uint8_t);
+
+static void unicode_lb_reset(unicode_lb_info_t i)
+{
+ i->prevclass=i->prevclass_nsp=UNICODE_LB_SOT;
+ i->next_handler=next_def;
+ i->end_handler=end_def;
+}
+
+unicode_lb_info_t unicode_lb_init(int (*cb_func)(int, void *),
+ void *cb_arg)
+{
+ unicode_lb_info_t i=calloc(1, sizeof(struct unicode_lb_info));
+
+ i->cb_func=cb_func;
+ i->cb_arg=cb_arg;
+
+ unicode_lb_reset(i);
+ return i;
+}
+
+int unicode_lb_end(unicode_lb_info_t i)
+{
+ int rc=(*i->end_handler)(i);
+
+ free(i);
+ return rc;
+}
+
+void unicode_lb_set_opts(unicode_lb_info_t i, int opts)
+{
+ i->opts=opts;
+}
+
+/* Default end handler has nothing to do */
+
+static int end_def(unicode_lb_info_t i)
+{
+ /* LB3 N/A */
+ return 0;
+}
+#define RESULT(x) (*i->cb_func)((x), i->cb_arg)
+
+int unicode_lb_next_cnt(unicode_lb_info_t i,
+ const unicode_char *chars,
+ size_t cnt)
+{
+ while (cnt)
+ {
+ int rc=unicode_lb_next(i, *chars);
+
+ if (rc)
+ return rc;
+
+ ++chars;
+ --cnt;
+ }
+ return 0;
+}
+
+int unicode_lb_lookup(unicode_char ch)
+{
+ return unicode_tab_lookup(ch,
+ unicode_indextab,
+ sizeof(unicode_indextab)
+ / sizeof(unicode_indextab[0]),
+ unicode_rangetab,
+ unicode_classtab,
+ UNICODE_LB_AL /* XX, LB1 */);
+}
+
+int unicode_lb_next(unicode_lb_info_t i,
+ unicode_char ch)
+{
+ return (*i->next_handler)(i, (i->opts & UNICODE_LB_OPT_DASHWJ) &&
+ (ch == 0x2012 || ch == 0x2013)
+ ? UNICODE_LB_WJ:unicode_lb_lookup(ch));
+}
+
+static int next_def_nolb25(unicode_lb_info_t i,
+ uint8_t uclass,
+ int nolb25);
+
+/*
+** Default logic for next unicode char.
+*/
+static int next_def(unicode_lb_info_t i,
+ uint8_t uclass)
+{
+ return next_def_nolb25(i, uclass, 0);
+}
+
+static int next_def_nolb25(unicode_lb_info_t i,
+ uint8_t uclass,
+
+ /* Flag -- recursively invoked after discarding LB25 */
+ int nolb25)
+{
+
+ /* Retrieve the previous unicode character's linebreak class. */
+
+ uint8_t prevclass=i->prevclass;
+ uint8_t prevclass_nsp=i->prevclass_nsp;
+
+ /* Save this unicode char's linebreak class, for the next goaround */
+ i->prevclass=uclass;
+
+ if (uclass != UNICODE_LB_SP)
+ i->prevclass_nsp=uclass;
+
+ if (uclass == UNICODE_LB_NU)
+ i->next_handler=next_lb25_seennu; /* LB25 */
+
+ if (prevclass == UNICODE_LB_SOT)
+ {
+ if (uclass == UNICODE_LB_CM) /* LB9 */
+ i->prevclass=i->prevclass_nsp=uclass=UNICODE_LB_AL;
+
+ return RESULT(UNICODE_LB_NONE); /* LB2 */
+ }
+
+ if (prevclass == UNICODE_LB_CR && uclass == UNICODE_LB_LF)
+ return RESULT(UNICODE_LB_NONE); /* LB5 */
+
+ switch (prevclass) {
+ case UNICODE_LB_BK:
+ case UNICODE_LB_CR:
+ case UNICODE_LB_LF:
+ case UNICODE_LB_NL:
+
+ if (uclass == UNICODE_LB_CM)
+ {
+ i->prevclass=i->prevclass_nsp=uclass=UNICODE_LB_AL;
+ /* LB9 */
+ }
+
+ return RESULT(UNICODE_LB_MANDATORY); /* LB4, LB5 */
+
+ case UNICODE_LB_SP:
+ case UNICODE_LB_ZW:
+ if (uclass == UNICODE_LB_CM)
+ i->prevclass=i->prevclass_nsp=uclass=UNICODE_LB_AL;
+ /* LB10 */
+ break;
+ default:
+ break;
+ }
+
+ switch (uclass) {
+
+ /* LB6: */
+ case UNICODE_LB_BK:
+ case UNICODE_LB_CR:
+ case UNICODE_LB_LF:
+ case UNICODE_LB_NL:
+
+ /* LB7: */
+ case UNICODE_LB_SP:
+ case UNICODE_LB_ZW:
+
+ return RESULT(UNICODE_LB_NONE);
+ default:
+ break;
+ }
+
+ if (prevclass_nsp == UNICODE_LB_ZW)
+ return RESULT(UNICODE_LB_ALLOWED); /* LB8 */
+
+ if (uclass == UNICODE_LB_CM)
+ {
+ i->prevclass=prevclass;
+ i->prevclass_nsp=prevclass_nsp;
+ return RESULT(UNICODE_LB_NONE); /* LB9 */
+ }
+
+ if (prevclass == UNICODE_LB_WJ || uclass == UNICODE_LB_WJ)
+ return RESULT(UNICODE_LB_NONE); /* LB11 */
+
+ if (prevclass == UNICODE_LB_GL)
+ return RESULT(UNICODE_LB_NONE); /* LB12 */
+
+ if (uclass == UNICODE_LB_GL &&
+ prevclass != UNICODE_LB_SP &&
+ prevclass != UNICODE_LB_BA &&
+ prevclass != UNICODE_LB_HY)
+ return RESULT(UNICODE_LB_NONE); /* LB12a */
+
+
+ switch (uclass) {
+ case UNICODE_LB_SY:
+ if (i->opts & UNICODE_LB_OPT_SYBREAK)
+ {
+ if (prevclass == UNICODE_LB_SP)
+ return RESULT(UNICODE_LB_ALLOWED);
+ }
+
+ case UNICODE_LB_CL:
+ case UNICODE_LB_CP:
+ case UNICODE_LB_EX:
+ case UNICODE_LB_IS:
+ return RESULT(UNICODE_LB_NONE); /* LB13 */
+ default:
+ break;
+ }
+
+ if ((i->opts & UNICODE_LB_OPT_SYBREAK) && prevclass == UNICODE_LB_SY)
+ switch (uclass) {
+ case UNICODE_LB_EX:
+ case UNICODE_LB_AL:
+ case UNICODE_LB_ID:
+ return RESULT(UNICODE_LB_NONE);
+ }
+
+ if (prevclass_nsp == UNICODE_LB_OP)
+ return RESULT(UNICODE_LB_NONE); /* LB14 */
+
+ if (prevclass_nsp == UNICODE_LB_QU && uclass == UNICODE_LB_OP)
+ return RESULT(UNICODE_LB_NONE); /* LB15 */
+
+ if ((prevclass_nsp == UNICODE_LB_CL || prevclass_nsp == UNICODE_LB_CP)
+ && uclass == UNICODE_LB_NS)
+ return RESULT(UNICODE_LB_NONE); /* LB16 */
+
+ if (prevclass_nsp == UNICODE_LB_B2 && uclass == UNICODE_LB_B2)
+ return RESULT(UNICODE_LB_NONE); /* LB17 */
+
+ if (prevclass == UNICODE_LB_SP)
+ return RESULT(UNICODE_LB_ALLOWED); /* LB18 */
+
+ if (uclass == UNICODE_LB_QU || prevclass == UNICODE_LB_QU)
+ return RESULT(UNICODE_LB_NONE); /* LB19 */
+
+ if (uclass == UNICODE_LB_CB || prevclass == UNICODE_LB_CB)
+ return RESULT(UNICODE_LB_ALLOWED); /* LB20 */
+
+ /* LB21: */
+
+ switch (uclass) {
+ case UNICODE_LB_BA:
+ case UNICODE_LB_HY:
+ case UNICODE_LB_NS:
+ return RESULT(UNICODE_LB_NONE);
+ default:
+ break;
+ }
+
+ if (prevclass == UNICODE_LB_BB)
+ return RESULT(UNICODE_LB_NONE);
+
+ if (uclass == UNICODE_LB_IN)
+ switch (prevclass) {
+ case UNICODE_LB_AL:
+ case UNICODE_LB_ID:
+ case UNICODE_LB_IN:
+ case UNICODE_LB_NU:
+ return RESULT(UNICODE_LB_NONE); /* LB22 */
+ default:
+ break;
+ }
+
+
+ if (prevclass == UNICODE_LB_ID && uclass == UNICODE_LB_PO)
+ return RESULT(UNICODE_LB_NONE); /* LB23 */
+ if (prevclass == UNICODE_LB_AL && uclass == UNICODE_LB_NU)
+ return RESULT(UNICODE_LB_NONE); /* LB23 */
+
+ if (prevclass == UNICODE_LB_NU && uclass == UNICODE_LB_AL)
+ return RESULT(UNICODE_LB_NONE); /* LB23 */
+
+
+ if (prevclass == UNICODE_LB_PR && uclass == UNICODE_LB_ID)
+ return RESULT(UNICODE_LB_NONE); /* LB24 */
+ if (prevclass == UNICODE_LB_PR && uclass == UNICODE_LB_AL)
+ return RESULT(UNICODE_LB_NONE); /* LB24 */
+ if (prevclass == UNICODE_LB_PO && uclass == UNICODE_LB_AL)
+ return RESULT(UNICODE_LB_NONE); /* LB24 */
+
+ if ((i->opts & UNICODE_LB_OPT_PRBREAK) && uclass == UNICODE_LB_PR)
+ switch (prevclass) {
+ case UNICODE_LB_PR:
+ case UNICODE_LB_AL:
+ case UNICODE_LB_ID:
+ return RESULT(UNICODE_LB_NONE);
+ }
+
+ if (!nolb25 &&
+ (prevclass == UNICODE_LB_PR || prevclass == UNICODE_LB_PO))
+ {
+ if (uclass == UNICODE_LB_NU)
+ return RESULT(UNICODE_LB_NONE); /* LB25 */
+
+ if (uclass == UNICODE_LB_OP || uclass == UNICODE_LB_HY)
+ {
+ i->prevclass=prevclass;
+ i->prevclass_nsp=prevclass_nsp;
+
+ i->savedclass=uclass;
+ i->savedcmcnt=0;
+ i->next_handler=next_lb25_seenophy;
+ i->end_handler=end_lb25_seenophy;
+ return 0;
+ }
+ }
+
+ if ((prevclass == UNICODE_LB_OP || prevclass == UNICODE_LB_HY) &&
+ uclass == UNICODE_LB_NU)
+ return RESULT(UNICODE_LB_NONE); /* LB25 */
+
+ /*****/
+
+ if (prevclass == UNICODE_LB_JL)
+ switch (uclass) {
+ case UNICODE_LB_JL:
+ case UNICODE_LB_JV:
+ case UNICODE_LB_H2:
+ case UNICODE_LB_H3:
+ return RESULT(UNICODE_LB_NONE); /* LB26 */
+ default:
+ break;
+ }
+
+ if ((prevclass == UNICODE_LB_JV ||
+ prevclass == UNICODE_LB_H2) &&
+ (uclass == UNICODE_LB_JV ||
+ uclass == UNICODE_LB_JT))
+ return RESULT(UNICODE_LB_NONE); /* LB26 */
+
+ if ((prevclass == UNICODE_LB_JT ||
+ prevclass == UNICODE_LB_H3) &&
+ uclass == UNICODE_LB_JT)
+ return RESULT(UNICODE_LB_NONE); /* LB26 */
+
+
+ switch (prevclass) {
+ case UNICODE_LB_JL:
+ case UNICODE_LB_JV:
+ case UNICODE_LB_JT:
+ case UNICODE_LB_H2:
+ case UNICODE_LB_H3:
+ if (uclass == UNICODE_LB_IN || uclass == UNICODE_LB_PO)
+ return RESULT(UNICODE_LB_NONE); /* LB27 */
+ default:
+ break;
+ }
+
+ switch (uclass) {
+ case UNICODE_LB_JL:
+ case UNICODE_LB_JV:
+ case UNICODE_LB_JT:
+ case UNICODE_LB_H2:
+ case UNICODE_LB_H3:
+ if (prevclass == UNICODE_LB_PR)
+ return RESULT(UNICODE_LB_NONE); /* LB27 */
+ default:
+ break;
+ }
+
+ if (prevclass == UNICODE_LB_AL && uclass == UNICODE_LB_AL)
+ return RESULT(UNICODE_LB_NONE); /* LB28 */
+
+ if (prevclass == UNICODE_LB_IS && uclass == UNICODE_LB_AL)
+ return RESULT(UNICODE_LB_NONE); /* LB29 */
+
+ if ((prevclass == UNICODE_LB_AL || prevclass == UNICODE_LB_NU) &&
+ uclass == UNICODE_LB_OP)
+ return RESULT(UNICODE_LB_NONE); /* LB30 */
+
+ if ((uclass == UNICODE_LB_AL || uclass == UNICODE_LB_NU) &&
+ prevclass == UNICODE_LB_CP)
+ return RESULT(UNICODE_LB_NONE); /* LB30 */
+
+ return RESULT(UNICODE_LB_ALLOWED); /* LB31 */
+}
+
+/*
+** Seen (PR|PO)(OP|HY), without returning the linebreak property for the second
+** character, but NU did not follow. Backtrack.
+*/
+
+static int unwind_lb25_seenophy(unicode_lb_info_t i)
+{
+ int rc;
+
+ /*uint8_t class=i->savedclass;*/
+ int nolb25_flag=1;
+
+ i->next_handler=next_def;
+ i->end_handler=end_def;
+
+ do
+ {
+ rc=next_def_nolb25(i, i->savedclass, nolb25_flag);
+
+ if (rc)
+ return rc;
+
+ /*class=UNICODE_LB_CM;*/
+ nolb25_flag=0;
+ } while (i->savedcmcnt--);
+ return 0;
+}
+
+/*
+** Seen (PR|PO)(OP|HY), without returning the linebreak property for the second
+** character. If there's now a NU, we found the modified LB25 regexp.
+*/
+
+static int next_lb25_seenophy(unicode_lb_info_t i,
+ uint8_t uclass)
+{
+ int rc;
+
+ if (uclass == UNICODE_LB_CM)
+ {
+ ++i->savedcmcnt; /* Keep track of CMs, and try again */
+ return 0;
+ }
+
+ if (uclass != UNICODE_LB_NU)
+ {
+ rc=unwind_lb25_seenophy(i);
+
+ if (rc)
+ return rc;
+
+ return next_def_nolb25(i, uclass, 0);
+ }
+
+ do
+ {
+ rc=RESULT(UNICODE_LB_NONE); /* (OP|HY) feedback */
+
+ if (rc)
+ return rc;
+ } while (i->savedcmcnt--);
+
+ i->next_handler=next_lb25_seennu;
+ i->end_handler=end_def;
+ i->prevclass=i->prevclass_nsp=uclass;
+ return RESULT(UNICODE_LB_NONE);
+}
+
+/*
+** Seen (PR|PO)(OP|HY), and now The End. Unwind, and give up.
+*/
+
+static int end_lb25_seenophy(unicode_lb_info_t i)
+{
+ int rc=unwind_lb25_seenophy(i);
+
+ if (rc == 0)
+ rc=end_def(i);
+ return rc;
+}
+
+/*
+** Seen an NU, modified LB25 regexp.
+*/
+static int next_lb25_seennu(unicode_lb_info_t i, uint8_t uclass)
+{
+ if (uclass == UNICODE_LB_NU || uclass == UNICODE_LB_SY ||
+ uclass == UNICODE_LB_IS)
+ {
+ i->prevclass=i->prevclass_nsp=uclass;
+ return RESULT(UNICODE_LB_NONE);
+ }
+
+ if (uclass == UNICODE_LB_CM)
+ return RESULT(UNICODE_LB_NONE); /* LB9 */
+
+ if (uclass == UNICODE_LB_CL || uclass == UNICODE_LB_CP)
+ {
+ i->prevclass=i->prevclass_nsp=uclass;
+ i->next_handler=next_lb25_seennuclcp;
+ i->end_handler=end_def;
+ return RESULT(UNICODE_LB_NONE);
+ }
+
+ i->next_handler=next_def;
+ i->end_handler=end_def;
+
+ if (uclass == UNICODE_LB_PR || uclass == UNICODE_LB_PO)
+ {
+ i->prevclass=i->prevclass_nsp=uclass;
+ return RESULT(UNICODE_LB_NONE);
+ }
+
+ return next_def(i, uclass); /* Not a prefix, process normally */
+}
+
+/*
+** Seen CL|CP, in the modified LB25 regexp.
+*/
+static int next_lb25_seennuclcp(unicode_lb_info_t i, uint8_t uclass)
+{
+ if (uclass == UNICODE_LB_CM)
+ return RESULT(UNICODE_LB_NONE); /* LB9 */
+
+ i->next_handler=next_def;
+ i->end_handler=end_def;
+
+ if (uclass == UNICODE_LB_PR || uclass == UNICODE_LB_PO)
+ {
+ i->prevclass=i->prevclass_nsp=uclass;
+
+ return RESULT(UNICODE_LB_NONE);
+ }
+
+ return next_def(i, uclass);
+}
+
+/******************/
+
+struct unicode_lbc_info {
+ unicode_lb_info_t handle;
+
+ struct unicode_buf buf;
+
+ size_t buf_ptr;
+
+ int (*cb_func)(int, unicode_char, void *);
+ void *cb_arg;
+};
+
+static int unicode_lbc_callback(int value, void *ptr)
+{
+ unicode_lbc_info_t h=(unicode_lbc_info_t)ptr;
+
+ if (h->buf_ptr >= unicode_buf_len(&h->buf))
+ {
+ errno=EINVAL;
+ return -1; /* Shouldn't happen */
+ }
+
+ return (*h->cb_func)(value, unicode_buf_ptr(&h->buf)[h->buf_ptr++],
+ h->cb_arg);
+}
+
+unicode_lbc_info_t unicode_lbc_init(int (*cb_func)(int, unicode_char, void *),
+ void *cb_arg)
+{
+ unicode_lbc_info_t h=
+ (unicode_lbc_info_t)calloc(1, sizeof(struct unicode_lbc_info));
+
+ if (!h)
+ return NULL;
+
+ h->cb_func=cb_func;
+ h->cb_arg=cb_arg;
+
+ if ((h->handle=unicode_lb_init(unicode_lbc_callback, h)) == NULL)
+ {
+ free(h);
+ return NULL;
+ }
+ unicode_buf_init(&h->buf, (size_t)-1);
+ return h;
+}
+
+void unicode_lbc_set_opts(unicode_lbc_info_t i, int opts)
+{
+ unicode_lb_set_opts(i->handle, opts);
+}
+
+int unicode_lbc_next(unicode_lbc_info_t i, unicode_char ch)
+{
+ if (i->buf_ptr >= unicode_buf_len(&i->buf))
+ {
+ i->buf_ptr=0;
+ unicode_buf_clear(&i->buf);
+ }
+
+ unicode_buf_append(&i->buf, &ch, 1);
+ return unicode_lb_next(i->handle, ch);
+}
+
+int unicode_lbc_end(unicode_lbc_info_t i)
+{
+ int rc=unicode_lb_end(i->handle);
+
+ unicode_buf_deinit(&i->buf);
+ free(i);
+ return rc;
+}
HCoop / hcoop / debian / courier-authlib.git / blobdiff