Adds a hy-phen-ator.

third_party/hyphen/hyphen.c

 /* Libhnj is dual licensed under LGPL and MPL. Boilerplate for both
  * licenses follows.
  */
 
 /* LibHnj - a library for high quality hyphenation and justification
  * Copyright (C) 1998 Raph Levien, 
  *           (C) 2001 ALTLinux, Moscow (http://www.alt-linux.org), 
  *           (C) 2001 Peter Novodvorsky (nidd@cs.msu.su)
  *           (C) 2006, 2007, 2008, 2010 László Németh (nemeth at OOo)
  *
@@ skipping 224 matching lines @@
   HashEntry *e;
 
   for (i = 0; i < HASH_SIZE; i++)
     for (e = global->entries[i]; e; e = e->next)
       if (e->val == state)
         return e->key;
   return NULL;
 }
 #endif
 
+#ifdef HYPHEN_CHROME_CLIENT
+typedef struct {
+  const unsigned char *data;
+  size_t offset;
+  size_t size;
+} hnj_file;
+
+static hnj_file *
+hnj_fopen (const unsigned char *data, size_t size)
+{
+  hnj_file *f;
+
+  f = hnj_malloc (sizeof(hnj_file));
+  if (f == NULL)
+    return NULL;
+  f->offset = 0;
+  f->data = data;
+  f->size = size;
+  return f;
+}
+
+static void
+hnj_fclose (hnj_file *f)
+{
+  hnj_free (f);
+}
+
+static char *
+hnj_fgets (char *s, int size, hnj_file *f)
+{
+  int i;
+
+  if (f->offset >= f->size)
+    return NULL;
+  for (i = 0; i < size - 1; i++) {
+    char c;
+
+    if (f->offset >= f->size)
+      break;
+    c = f->data[f->offset++];
+    if (c == '\r' || c == '\n')
+      break;
+    s[i] = c;
+  }
+  s[i] = '\0';
+  return s;
+}
+#else
+typedef FILE hnj_file;
+#define hnj_fopen(fn, mode) fopen((fn), (mode))
+#define hnj_fclose(f) fclose(f)
+#define hnj_fgets(s, size, f) fgets((s), (size), (f))
+#endif
+
+#ifdef HYPHEN_CHROME_CLIENT
+HyphenDict *
+hnj_hyphen_load (const unsigned char *data, size_t size)
+#else
 HyphenDict *
 hnj_hyphen_load (const char *fn)
+#endif
 {
   HyphenDict *dict[2];
   HashTab *hashtab;
-  FILE *f;
+  hnj_file *f;
   char buf[MAX_CHARS];
   char word[MAX_CHARS];
   char pattern[MAX_CHARS];
   char * repl;
   signed char replindex;
   signed char replcut;
   int state_num = 0, last_state;
   int i, j, k;
   char ch;
   int found;
   HashEntry *e;
   int nextlevel = 0;
 
-  f = fopen (fn, "r");
+#ifdef HYPHEN_CHROME_CLIENT
+  f = hnj_fopen (data, size);
+#else
+  f = hnj_fopen (fn, "r");
+#endif
   if (f == NULL)
     return NULL;
 
 // loading one or two dictionaries (separated by NEXTLEVEL keyword)
 for (k = 0; k == 0 || (k == 1 && nextlevel); k++) { 
   hashtab = hnj_hash_new ();
 #ifdef VERBOSE
   global = hashtab;
 #endif
   hnj_hash_insert (hashtab, "", 0);
   dict[k] = hnj_malloc (sizeof(HyphenDict));
   dict[k]->num_states = 1;
   dict[k]->states = hnj_malloc (sizeof(HyphenState));
   dict[k]->states[0].match = NULL;
   dict[k]->states[0].repl = NULL;
   dict[k]->states[0].fallback_state = -1;
   dict[k]->states[0].num_trans = 0;
   dict[k]->states[0].trans = NULL;
   dict[k]->nextlevel = NULL;
   dict[k]->lhmin = 0;
   dict[k]->rhmin = 0;
   dict[k]->clhmin = 0;
   dict[k]->crhmin = 0;
 
   /* read in character set info */
   if (k == 0) {
     for (i=0;i<MAX_NAME;i++) dict[k]->cset[i]= 0;
-    if (fgets(dict[k]->cset,  sizeof(dict[k]->cset),f) != NULL) {
+    if (hnj_fgets(dict[k]->cset,  sizeof(dict[k]->cset),f) != NULL) {
       for (i=0;i<MAX_NAME;i++)
         if ((dict[k]->cset[i] == '\r') || (dict[k]->cset[i] == '\n'))
           dict[k]->cset[i] = 0;
     } else {
       dict[k]->cset[0] = 0;
     }
     dict[k]->utf8 = (strcmp(dict[k]->cset, "UTF-8") == 0);
   } else {
     strcpy(dict[k]->cset, dict[0]->cset);
     dict[k]->utf8 = dict[0]->utf8;
   }
 
-  while (fgets (buf, sizeof(buf), f) != NULL)
+  while (hnj_fgets (buf, sizeof(buf), f) != NULL)
     {
       if (buf[0] != '%')
         {
           if (strncmp(buf, "NEXTLEVEL", 9) == 0) {
             nextlevel = 1;
             break;
           } else if (strncmp(buf, "LEFTHYPHENMIN", 13) == 0) {
             dict[k]->lhmin = atoi(buf + 13);
             continue;
           } else if (strncmp(buf, "RIGHTHYPHENMIN", 14) == 0) {
@@ skipping 45 matching lines @@
           i = 0;
           if (!repl) {
             /* Optimize away leading zeroes */
             for (; pattern[i] == '0'; i++);
           } else {
             if (*word == '.') i++;
             /* convert UTF-8 char. positions of discretionary hyph. replacements to 8-bit */
             if (dict[k]->utf8) {
                 int pu = -1;        /* unicode character position */
                 int ps = -1;        /* unicode start position (original replindex) */
-                int pc = (*word == '.') ? 1: 0; /* 8-bit character position */
+                size_t pc = (*word == '.') ? 1: 0; /* 8-bit character position */
                 for (; pc < (strlen(word) + 1); pc++) {
                 /* beginning of an UTF-8 character (not '10' start bits) */
                     if ((((unsigned char) word[pc]) >> 6) != 2) pu++;
                     if ((ps < 0) && (replindex == pu)) {
                         ps = replindex;
                         replindex = (signed char) pc;
                     }
                     if ((ps >= 0) && ((pu - ps) == replcut)) {
                         replcut = (signed char) (pc - replindex);
                         break;
@@ skipping 72 matching lines @@
           printf (" %c->%d\n", dict[k]->states[e->val].trans[j].ch,
                   dict[k]->states[e->val].trans[j].new_state);
       }
 #endif
 
 #ifndef VERBOSE
   hnj_hash_free (hashtab);
 #endif
   state_num = 0;
 }
-  fclose(f);
+  hnj_fclose(f);
   if (k == 2) dict[0]->nextlevel = dict[1];
   return dict[0];
 }
 
 void hnj_hyphen_free (HyphenDict *dict)
 {
   int state_num;
   HyphenState *hstate;
 
   for (state_num = 0; state_num < dict->num_states; state_num++)
@@ skipping 591 matching lines @@
   hnj_hyphen_hyph_(dict, word, word_size, hyphens, rep, pos, cut,
     clhmin, crhmin, 1, 1);
   hnj_hyphen_lhmin(dict->utf8, word, word_size, hyphens,
     rep, pos, cut, (lhmin > 0 ? lhmin : 2));
   hnj_hyphen_rhmin(dict->utf8, word, word_size, hyphens,
     rep, pos, cut, (rhmin > 0 ? rhmin : 2));
   if (hyphword) hnj_hyphen_hyphword(word, word_size, hyphens, hyphword, rep, pos, cut);
   if (dict->utf8) return hnj_hyphen_norm(word, word_size, hyphens, rep, pos, cut);
   return 0;
 }