/*

 * Copyright (C) 2005 to 2014 by Jonathan Duddington

 * email: jonsd@users.sourceforge.net

 * Copyright (C) 2013-2017 Reece H. Dunn

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, see: <http://www.gnu.org/licenses/>.

 */

#include "config.h"

#include <ctype.h>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <wctype.h>

#include <wchar.h>

#include <assert.h>

#include <espeak-ng/espeak_ng.h>

#include <espeak-ng/speak_lib.h>

#include <espeak-ng/encoding.h>

#include "common.h"                // for GetFileLength, strncpy0

#include "dictionary.h"

#include "numbers.h"                       // for LookupAccentedLetter, Look...

#include "phoneme.h"                       // for PHONEME_TAB, phVOWEL, phon...

#include "readclause.h"                    // for WordToString2

#include "speech.h"                        // for path_home

#include "compiledict.h"                   // for DecodeRule

#include "synthdata.h"                     // for PhonemeCode, InterpretPhoneme

#include "synthesize.h"                    // for STRESS_IS_PRIMARY, phoneme...

#include "translate.h"                     // for Translator, utf8_in, LANGU...

static int LookupFlags(Translator *tr, const char *word, unsigned int flags_out[2]);

static void DollarRule(char *word[], char *word_start, int consumed, int group_length, char word_buf[N_WORD_BYTES], Translator *tr, int command, int *failed, int *add_points);

typedef struct {

  int points;

  const char *phonemes;

  int end_type;

  char *del_fwd;

} MatchRecord;

int dictionary_skipwords;

char dictionary_name[40];

// accented characters which indicate (in some languages) the start of a separate syllable

static const unsigned short diereses_list[7] = { 0xe4, 0xeb, 0xef, 0xf6, 0xfc, 0xff, 0 };

// convert characters to an approximate 7 bit ascii equivalent

// used for checking for vowels (up to 0x259=schwa)

#define N_REMOVE_ACCENT  0x25e

static const unsigned char remove_accent[N_REMOVE_ACCENT] = {

  'a', 'a', 'a', 'a', 'a', 'a', 'a', 'c', 'e', 'e', 'e', 'e', 'i', 'i', 'i', 'i',  // 0c0

  'd', 'n', 'o', 'o', 'o', 'o', 'o',   0, 'o', 'u', 'u', 'u', 'u', 'y', 't', 's',  // 0d0

  'a', 'a', 'a', 'a', 'a', 'a', 'a', 'c', 'e', 'e', 'e', 'e', 'i', 'i', 'i', 'i',  // 0e0

  'd', 'n', 'o', 'o', 'o', 'o', 'o',   0, 'o', 'u', 'u', 'u', 'u', 'y', 't', 'y',  // 0f0

  'a', 'a', 'a', 'a', 'a', 'a', 'c', 'c', 'c', 'c', 'c', 'c', 'c', 'c', 'd', 'd',  // 100

  'd', 'd', 'e', 'e', 'e', 'e', 'e', 'e', 'e', 'e', 'e', 'e', 'g', 'g', 'g', 'g',  // 110

  'g', 'g', 'g', 'g', 'h', 'h', 'h', 'h', 'i', 'i', 'i', 'i', 'i', 'i', 'i', 'i',  // 120

  'i', 'i', 'i', 'i', 'j', 'j', 'k', 'k', 'k', 'l', 'l', 'l', 'l', 'l', 'l', 'l',  // 130

  'l', 'l', 'l', 'n', 'n', 'n', 'n', 'n', 'n', 'n', 'n', 'n', 'o', 'o', 'o', 'o',  // 140

  'o', 'o', 'o', 'o', 'r', 'r', 'r', 'r', 'r', 'r', 's', 's', 's', 's', 's', 's',  // 150

  's', 's', 't', 't', 't', 't', 't', 't', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',  // 160

  'u', 'u', 'u', 'u', 'w', 'w', 'y', 'y', 'y', 'z', 'z', 'z', 'z', 'z', 'z', 's',  // 170

  'b', 'b', 'b', 'b',   0,   0, 'o', 'c', 'c', 'd', 'd', 'd', 'd', 'd', 'e', 'e',  // 180

  'e', 'f', 'f', 'g', 'g', 'h', 'i', 'i', 'k', 'k', 'l', 'l', 'm', 'n', 'n', 'o',  // 190

  'o', 'o', 'o', 'o', 'p', 'p', 'y',   0,   0, 's', 's', 't', 't', 't', 't', 'u',  // 1a0

  'u', 'u', 'v', 'y', 'y', 'z', 'z', 'z', 'z', 'z', 'z', 'z',   0,   0,   0, 'w',  // 1b0

  't', 't', 't', 'k', 'd', 'd', 'd', 'l', 'l', 'l', 'n', 'n', 'n', 'a', 'a', 'i',  // 1c0

  'i', 'o', 'o', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'e', 'a', 'a',  // 1d0

  'a', 'a', 'a', 'a', 'g', 'g', 'g', 'g', 'k', 'k', 'o', 'o', 'o', 'o', 'z', 'z',  // 1e0

  'j', 'd', 'd', 'd', 'g', 'g', 'w', 'w', 'n', 'n', 'a', 'a', 'a', 'a', 'o', 'o',  // 1f0

  'a', 'a', 'a', 'a', 'e', 'e', 'e', 'e', 'i', 'i', 'i', 'i', 'o', 'o', 'o', 'o',  // 200

  'r', 'r', 'r', 'r', 'u', 'u', 'u', 'u', 's', 's', 't', 't', 'y', 'y', 'h', 'h',  // 210

  'n', 'd', 'o', 'o', 'z', 'z', 'a', 'a', 'e', 'e', 'o', 'o', 'o', 'o', 'o', 'o',  // 220

  'o', 'o', 'y', 'y', 'l', 'n', 't', 'j', 'd', 'q', 'a', 'c', 'c', 'l', 't', 's',  // 230

  'z',   0,   0, 'b', 'u', 'v', 'e', 'e', 'j', 'j', 'q', 'q', 'r', 'r', 'y', 'y',  // 240

  'a', 'a', 'a', 'b', 'o', 'c', 'd', 'd', 'e', 'e', 'e', 'e', 'e', 'e'

};

static int Reverse4Bytes(int word)

{

  // reverse the order of bytes from little-endian to big-endian

#ifdef ARCH_BIG

  int ix;

  int word2 = 0;

  for (ix = 0; ix <= 24; ix += 8) {

    word2 = word2 << 8;

    word2 |= (word >> ix) & 0xff;

  }

  return word2;

#else

  return word;

#endif

}

static void InitGroups(Translator *tr)

{

  // Called after dictionary 1 is loaded, to set up table of entry points for translation rule chains

  // for single-letters and two-letter combinations

  int ix;

  char *p;

  char *p_name;

  unsigned char c, c2;

  int len;

  tr->n_groups2 = 0;

  for (ix = 0; ix < 256; ix++) {

    tr->groups1[ix] = NULL;

    tr->groups2_count[ix] = 0;

    tr->groups2_start[ix] = 255; // indicates "not set"

  }

  memset(tr->letterGroups, 0, sizeof(tr->letterGroups));

  memset(tr->groups3, 0, sizeof(tr->groups3));

  p = tr->data_dictrules;

  // If there are no rules in the dictionary, compile_dictrules will not

  // write a RULE_GROUP_START (written in the for loop), but will write

  // a RULE_GROUP_END.

  if (*p != RULE_GROUP_END) while (*p != 0) {

    if (*p != RULE_GROUP_START) {

      fprintf(stderr, "Bad rules data in '%s_dict' at 0x%x (%c)\n", dictionary_name, (unsigned int)(p - tr->data_dictrules), *p);

      break;

    }

    p++;

    if (p[0] == RULE_REPLACEMENTS) {

      p = (char *)(((intptr_t)p+4) & ~3); // advance to next word boundary

      tr->langopts.replace_chars = (unsigned char *)p;

      while ( !is_str_totally_null(p, 4) ) {

        p++;

      }

      while (*p != RULE_GROUP_END) p++;

      p++;

      continue;

    }

    if (p[0] == RULE_LETTERGP2) {

      ix = p[1] - 'A';

      if (ix < 0)

        ix += 256;

      p += 2;

      if ((ix >= 0) && (ix < N_LETTER_GROUPS))

        tr->letterGroups[ix] = p;

    } else {

      len = strlen(p);

      p_name = p;

      c = p_name[0];

      c2 = p_name[1];

      p += (len+1);

      if (len == 1)

        tr->groups1[c] = p;

      else if (len == 0)

        tr->groups1[0] = p;

      else if (c == 1) {

        // index by offset from letter base

        tr->groups3[c2 - 1] = p;

      } else {

        if (tr->groups2_start[c] == 255)

          tr->groups2_start[c] = tr->n_groups2;

        tr->groups2_count[c]++;

        tr->groups2[tr->n_groups2] = p;

        tr->groups2_name[tr->n_groups2++] = (c + (c2 << 8));

      }

    }

    // skip over all the rules in this group

    while (*p != RULE_GROUP_END)

      p += (strlen(p) + 1);

    p++;

  }

}

int LoadDictionary(Translator *tr, const char *name, int no_error)

{

  int hash;

  char *p;

  int *pw;

  int length;

  FILE *f;

  int size;

  char fname[N_PATH_BUF];

  if (dictionary_name != name)

    snprintf(dictionary_name, sizeof(dictionary_name), "%s", name); // currently loaded dictionary name

  if (tr->dictionary_name != name)

    snprintf(tr->dictionary_name, sizeof(tr->dictionary_name), "%s", name);

  // Load a pronunciation data file into memory

  // bytes 0-3:  offset to rules data

  // bytes 4-7:  number of hash table entries

  snprintf(fname, sizeof(fname), "%s%c%s_dict", path_home, PATHSEP, name);

  size = GetFileLength(fname);

  if (tr->data_dictlist != NULL) {

    free(tr->data_dictlist);

    tr->data_dictlist = NULL;

  }

  f = fopen(fname, "rb");

  if ((f == NULL) || (size <= 0)) {

    if (no_error == 0)

      fprintf(stderr, "Can't read dictionary file: '%s'\n", fname);

    if (f != NULL)

      fclose(f);

    return 1;

  }

  if ((tr->data_dictlist = malloc(size)) == NULL) {

    fclose(f);

    return 3;

  }

  size = fread(tr->data_dictlist, 1, size, f);

  fclose(f);

  pw = (int *)(tr->data_dictlist);

  length = Reverse4Bytes(pw[1]);

  if (size <= (N_HASH_DICT + sizeof(int)*2)) {

    fprintf(stderr, "Empty _dict file: '%s\n", fname);

    return 2;

  }

  if ((Reverse4Bytes(pw[0]) != N_HASH_DICT) ||

      (length <= 0) || (length > 0x8000000)) {

    fprintf(stderr, "Bad data: '%s' (%x length=%x)\n", fname, Reverse4Bytes(pw[0]), length);

    return 2;

  }

  tr->data_dictrules = &(tr->data_dictlist[length]);

  // set up indices into data_dictrules

  InitGroups(tr);

  // set up hash table for data_dictlist

  p = &(tr->data_dictlist[8]);

  for (hash = 0; hash < N_HASH_DICT; hash++) {

    tr->dict_hashtab[hash] = p;

    while ((length = *(uint8_t *)p) != 0)

      p += length;

    p++; // skip over the zero which terminates the list for this hash value

  }

  if ((tr->dict_min_size > 0) && (size < (unsigned int)tr->dict_min_size))

    fprintf(stderr, "Full dictionary is not installed for '%s'\n", name);

  return 0;

}

/* Generate a hash code from the specified string

    This is used to access the dictionary_2 word-lookup dictionary

 */

int HashDictionary(const char *string)

{

  int c;

  int chars = 0;

  int hash = 0;

  while ((c = (*string++ & 0xff)) != 0) {

    hash = hash * 8 + c;

    hash = (hash & 0x3ff) ^ (hash >> 8); // exclusive or

    chars++;

  }

  return (hash+chars) & 0x3ff; // a 10 bit hash code

}

/* Translate a phoneme string from ascii mnemonics to internal phoneme numbers,

   from 'p' up to next blank .

   Returns advanced 'p'

   outptr contains encoded phonemes, unrecognized phoneme stops the encoding

   bad_phoneme must point to char array of length 2 of more

 */

const char *EncodePhonemes(const char *p, char *outptr, int *bad_phoneme)

{

  int ix;

  unsigned char c;

  int count;     // num. of matching characters

  int max;       // highest num. of matching found so far

  int max_ph;    // corresponding phoneme with highest matching

  int consumed;

  unsigned int mnemonic_word;

  if (bad_phoneme != NULL)

    *bad_phoneme = 0;

  // skip initial blanks

  while ((uint8_t)*p < 0x80 && isspace(*p))

    p++;

  while (((c = *p) != 0) && !isspace(c)) {

    consumed = 0;

    switch (c)

    {

    case '|':

      // used to separate phoneme mnemonics if needed, to prevent characters being treated

      // as a multi-letter mnemonic

      if ((c = p[1]) == '|') {

        // treat double || as a word-break symbol, drop through

        // to the default case with c = '|'

      } else {

        p++;

        break;

      }

    default:

      // lookup the phoneme mnemonic, find the phoneme with the highest number of

      // matching characters

      max = -1;

      max_ph = 0;

      for (ix = 1; ix < n_phoneme_tab; ix++) {

        if (phoneme_tab[ix] == NULL)

          continue;

        if (phoneme_tab[ix]->type == phINVALID)

          continue; // this phoneme is not defined for this language

        count = 0;

        mnemonic_word = phoneme_tab[ix]->mnemonic;

        while (((c = p[count]) > ' ') && (count < 4) &&

               (c == ((mnemonic_word >> (count*8)) & 0xff)))

          count++;

        if ((count > max) &&

            ((count == 4) || (((mnemonic_word >> (count*8)) & 0xff) == 0))) {

          max = count;

          max_ph = phoneme_tab[ix]->code;

        }

      }

      if (max_ph == 0) {

        // not recognised, report and ignore

        if (bad_phoneme != NULL)

          utf8_in(bad_phoneme, p);

        *outptr++ = 0;

        return p+1;

      }

      if (max <= 0)

        max = 1;

      p += (consumed + max);

      *outptr++ = (char)(max_ph);

      if (max_ph == phonSWITCH) {

        // Switch Language: this phoneme is followed by a text string

        char *p_lang = outptr;

        while (!isspace(c = *p) && (c != 0)) {

          p++;

          *outptr++ = tolower(c);

        }

        *outptr = 0;

        if (c == 0) {

          if (strcmp(p_lang, ESPEAKNG_DEFAULT_VOICE) == 0) {

            *p_lang = 0; // don't need ESPEAKNG_DEFAULT_VOICE, it's assumed by default

            return p;

          }

        } else

          *outptr++ = '|'; // more phonemes follow, terminate language string with separator

      }

      break;

    }

  }

  // terminate the encoded string

  *outptr = 0;

  return p;

}

void DecodePhonemes(const char *inptr, char *outptr)

{

  // Translate from internal phoneme codes into phoneme mnemonics

  unsigned char phcode;

  unsigned char c;

  unsigned int mnem;

  PHONEME_TAB *ph;

  static const char stress_chars[] = "==,,'*  ";

  sprintf(outptr, "* ");

  while ((phcode = *inptr++) > 0) {

    if (phcode == 255)

      continue; // indicates unrecognised phoneme

    if ((ph = phoneme_tab[phcode]) == NULL)

      continue;

    if ((ph->type == phSTRESS) && (ph->std_length <= 4) && (ph->program == 0)) {

      if (ph->std_length > 1)

        *outptr++ = stress_chars[ph->std_length];

    } else {

      mnem = ph->mnemonic;

      while ((c = (mnem & 0xff)) != 0) {

        *outptr++ = c;

        mnem = mnem >> 8;

      }

      if (phcode == phonSWITCH) {

        while (isalpha(*inptr))

          *outptr++ = *inptr++;

      }

    }

  }

  *outptr = 0; // string terminator

}

// using Kirschenbaum to IPA translation, ascii 0x20 to 0x7f

static const unsigned short ipa1[96] = {

  0x20,  0x21,  0x22,  0x2b0, 0x24,  0x25,  0x0e6, 0x2c8, 0x28,  0x29,  0x27e, 0x2b,  0x2cc, 0x2d,  0x2e,  0x2f,

  0x252, 0x31,  0x32,  0x25c, 0x34,  0x35,  0x36,  0x37,  0x275, 0x39,  0x2d0, 0x2b2, 0x3c,  0x3d,  0x3e,  0x294,

  0x259, 0x251, 0x3b2, 0xe7,  0xf0,  0x25b, 0x46,  0x262, 0x127, 0x26a, 0x25f, 0x4b,  0x26b, 0x271, 0x14b, 0x254,

  0x3a6, 0x263, 0x280, 0x283, 0x3b8, 0x28a, 0x28c, 0x153, 0x3c7, 0xf8,  0x292, 0x32a, 0x5c,  0x5d,  0x5e,  0x5f,

  0x60,  0x61,  0x62,  0x63,  0x64,  0x65,  0x66,  0x261, 0x68,  0x69,  0x6a,  0x6b,  0x6c,  0x6d,  0x6e,  0x6f,

  0x70,  0x71,  0x72,  0x73,  0x74,  0x75,  0x76,  0x77,  0x78,  0x79,  0x7a,  0x7b,  0x7c,  0x7d,  0x303, 0x7f

};

#define N_PHON_OUT  500  // realloc increment

static char *phon_out_buf = NULL;   // passes the result of GetTranslatedPhonemeString()

static unsigned int phon_out_size = 0;

char *WritePhMnemonic(char *phon_out, PHONEME_TAB *ph, PHONEME_LIST *plist, int use_ipa, int *flags)

{

  int c;

  int mnem;

  int len;

  bool first;

  int ix = 0;

  char *p;

  PHONEME_DATA phdata;

  if (ph->code == phonEND_WORD) {

    // ignore

    phon_out[0] = 0;

    return phon_out;

  }

  if (ph->code == phonSWITCH) {

    // the tone_ph field contains a phoneme table number

    p = phoneme_tab_list[plist->tone_ph].name;

    sprintf(phon_out, "(%s)", p);

    return phon_out + strlen(phon_out);

  }

  if (use_ipa) {

    // has an ipa name been defined for this phoneme ?

    phdata.ipa_string[0] = 0;

    if (plist == NULL)

      InterpretPhoneme2(ph->code, &phdata);

    else

      InterpretPhoneme(NULL, 0, plist, phoneme_list, &phdata, NULL);

    p = phdata.ipa_string;

    if (*p == 0x20) {

      // indicates no name for this phoneme

      *phon_out = 0;

      return phon_out;

    }

    if ((*p != 0) && ((*p & 0xff) < 0x20)) {

      // name starts with a flags byte

      if (flags != NULL)

        *flags = *p;

      p++;

    }

    len = strlen(p);

    if (len > 0) {

      strcpy(phon_out, p);

      phon_out += len;

      *phon_out = 0;

      return phon_out;

    }

  }

  first = true;

  for (mnem = ph->mnemonic; (c = mnem & 0xff) != 0; mnem = mnem >> 8) {

    if (c == '/')

      break; // discard phoneme variant indicator

    if (use_ipa) {

      // convert from ascii to ipa

      if (first && (c == '_'))

        break; // don't show pause phonemes

      if ((c == '#') && (ph->type == phVOWEL))

        break; // # is subscript-h, but only for consonants

      // ignore digits after the first character

      if (!first && IsDigit09(c))

        continue;

      if ((c >= 0x20) && (c < 128))

        c = ipa1[c-0x20];

      ix += utf8_out(c, &phon_out[ix]);

    } else

      phon_out[ix++] = c;

    first = false;

  }

  phon_out = &phon_out[ix];

  *phon_out = 0;

  return phon_out;

}

//// Extension: write phone mnemonic with stress

char *WritePhMnemonicWithStress(char *phon_out, PHONEME_TAB *ph, PHONEME_LIST *plist, int use_ipa, int *flags) {

  if (plist->synthflags & SFLAG_SYLLABLE) {

    unsigned char stress = plist->stresslevel;

    if (stress > 1) {

      int c = 0;

      if (stress > STRESS_IS_PRIORITY) {

        stress = STRESS_IS_PRIORITY;

      }

      if (use_ipa) {

        c = 0x2cc; // ipa, secondary stress

        if (stress > STRESS_IS_SECONDARY) {

          c = 0x02c8; // ipa, primary stress

        }

      } else {

        const char stress_chars[] = "==,,''";

        c = stress_chars[stress];

      }

      if (c != 0) {

        phon_out += utf8_out(c, phon_out);

      }

    }

  }

  return WritePhMnemonic(phon_out, ph, plist, use_ipa, flags);

}

////

const char *GetTranslatedPhonemeString(int phoneme_mode)

{

  /* Called after a clause has been translated into phonemes, in order

     to display the clause in phoneme mnemonic form.

     phoneme_mode

                   bit  1:   use IPA phoneme names

                   bit  7:   use tie between letters in multi-character phoneme names

                   bits 8-23 tie or separator character

   */

  int ix;

  unsigned int len;

  int phon_out_ix = 0;

  int stress;

  int c;

  char *p;

  char *buf;

  int count;

  int flags;

  int use_ipa;

  int use_tie;

  int separate_phonemes;

  char phon_buf[30];

  char phon_buf2[30];

  PHONEME_LIST *plist;

  static const char stress_chars[] = "==,,''";

  if (phon_out_buf == NULL) {

    phon_out_size = N_PHON_OUT;

    if ((phon_out_buf = (char *)malloc(phon_out_size)) == NULL) {

      phon_out_size = 0;

      return "";

    }

  }

  use_ipa = phoneme_mode & espeakPHONEMES_IPA;

  if (phoneme_mode & espeakPHONEMES_TIE) {

    use_tie = phoneme_mode >> 8;

    separate_phonemes = 0;

  } else {

    separate_phonemes = phoneme_mode >> 8;

    use_tie = 0;

  }

  for (ix = 1; ix < (n_phoneme_list-2); ix++) {

    buf = phon_buf;

    plist = &phoneme_list[ix];

    WritePhMnemonic(phon_buf2, plist->ph, plist, use_ipa, &flags);

    if (plist->newword & PHLIST_START_OF_WORD && !(plist->newword & (PHLIST_START_OF_SENTENCE | PHLIST_START_OF_CLAUSE)))

      *buf++ = ' ';

    if ((!plist->newword) || (separate_phonemes == ' ')) {

      if ((separate_phonemes != 0) && (ix > 1)) {

        utf8_in(&c, phon_buf2);

        if ((c < 0x2b0) || (c > 0x36f)) // not if the phoneme starts with a superscript letter

          buf += utf8_out(separate_phonemes, buf);

      }

    }

    if (plist->synthflags & SFLAG_SYLLABLE) {

      if ((stress = plist->stresslevel) > 1) {

        c = 0;

        if (stress > STRESS_IS_PRIORITY) stress = STRESS_IS_PRIORITY;

        if (use_ipa) {

          c = 0x2cc; // ipa, secondary stress

          if (stress > STRESS_IS_SECONDARY)

            c = 0x02c8; // ipa, primary stress

        } else

          c = stress_chars[stress];

        if (c != 0)

          buf += utf8_out(c, buf);

      }

    }

    flags = 0;

    count = 0;

    for (p = phon_buf2; *p != 0;) {

      p += utf8_in(&c, p);

      if (use_tie != 0) {

        // look for non-initial alphabetic character, but not diacritic, superscript etc.

        if ((count > 0) && !(flags & (1 << (count-1))) && ((c < 0x2b0) || (c > 0x36f)) && iswalpha(c))

          buf += utf8_out(use_tie, buf);

      }

      buf += utf8_out(c, buf);

      count++;

    }

    if (plist->ph->code != phonSWITCH) {

      if (plist->synthflags & SFLAG_LENGTHEN)

        buf = WritePhMnemonic(buf, phoneme_tab[phonLENGTHEN], plist, use_ipa, NULL);

      if ((plist->synthflags & SFLAG_SYLLABLE) && (plist->type != phVOWEL)) {

        // syllablic consonant

        buf = WritePhMnemonic(buf, phoneme_tab[phonSYLLABIC], plist, use_ipa, NULL);

      }

      if (plist->tone_ph > 0) {

        PHONEME_TAB *tone_ph = TonePhoneme(plist);

        if (tone_ph != NULL)

          buf = WritePhMnemonic(buf, tone_ph, plist, use_ipa, NULL);

      }

    }

    len = buf - phon_buf;

    if ((phon_out_ix + len) >= phon_out_size) {

      // enlarge the phoneme buffer

      phon_out_size = phon_out_ix + len + N_PHON_OUT;

      char *new_phon_out_buf = (char *)realloc(phon_out_buf, phon_out_size);

      if (new_phon_out_buf == NULL) {

        phon_out_size = 0;

        return "";

      } else

        phon_out_buf = new_phon_out_buf;

    }

    phon_buf[len] = 0;

    strcpy(&phon_out_buf[phon_out_ix], phon_buf);

    phon_out_ix += len;

  }

  if (!phon_out_buf)

    return "";

  phon_out_buf[phon_out_ix] = 0;

  return phon_out_buf;

}

static int LetterGroupNo(char *rule)

{

  /*

   * Returns number of letter group

   */

  int groupNo = *rule;

  groupNo = groupNo - 'A'; // subtracting 'A' makes letter_group equal to number in .Lxx definition

  if (groupNo < 0)         // fix sign if necessary

    groupNo += 256;

  return groupNo;

}

static int IsLetterGroup(Translator *tr, char *word, int group, int pre)

{

  /* Match the word against a list of utf-8 strings.

   * returns length of matching letter group or -1

   *

   * How this works:

   *

   *       +-+

   *       |c|<-(tr->letterGroups[group])

   *       |0|

   *   *p->|c|<-len+              +-+

   *       |s|<----+              |a|<-(Actual word to be tested)

   *       |0|            *word-> |t|<-*w=word-len+1 (for pre-rule)

   *       |~|                    |a|<-*w=word       (for post-rule)

   *       |7|                    |s|

   *       +-+                    +-+

   *

   *     7=RULE_GROUP_END

   *     0=null terminator

   *     pre==1 — pre-rule

   *     pre==0 — post-rule

   */

  char *p; // group counter

  char *w; // word counter

  int len = 0, i;

  p = tr->letterGroups[group];

  if (p == NULL)

    return -1;

  while (*p != RULE_GROUP_END) {

    // If '~' (no character) is allowed in group, return 0.

    if (*p == '~')

      return 0;

    if (pre) {

      len = strlen(p);

      w = word;

      if (*w == 0)

        goto skip;

      for (i = 0; i < len-1; i++)

      {

        w--;

        if (*w == 0)

          // Not found, skip the rest of this group.

          goto skip;

      }

    } else

      w = word;

    //  Check current group

    while ((*p == *w) && (*w != 0)) {

      w++;

      p++;

    }

    if (*p == 0) { // Matched the current group.

      if (pre)

        return len;

      return w - word;

    }

    // No match, so skip the rest of this group.

skip:

    while (*p++ != 0)

      ;

  }

  // Not found

  return -1;

}

static int IsLetter(Translator *tr, int letter, int group)

{

  int letter2;

  if (tr->letter_groups[group] != NULL) {

    if (wcschr(tr->letter_groups[group], letter))

      return 1;

    return 0;

  }

  if (group > 7)

    return 0;

  if (tr->letter_bits_offset > 0) {

    if (((letter2 = (letter - tr->letter_bits_offset)) > 0) && (letter2 < 0x100))

      letter = letter2;

    else

      return 0;

  } else if ((letter >= 0xc0) && (letter < N_REMOVE_ACCENT))

    return tr->letter_bits[remove_accent[letter-0xc0]] & (1L << group);

  if ((letter >= 0) && (letter < 0x100))

    return tr->letter_bits[letter] & (1L << group);

  return 0;

}

int IsVowel(Translator *tr, int letter)

{

  return IsLetter(tr, letter, LETTERGP_VOWEL2);

}

int GetVowelStress(Translator *tr, unsigned char *phonemes, signed char *vowel_stress, int *vowel_count, int *stressed_syllable, int control)

{

  // control = 1, set stress to 1 for forced unstressed vowels

  unsigned char phcode;

  PHONEME_TAB *ph;

  unsigned char *ph_out = phonemes;

  int count = 1;

  int max_stress = -1;

  int ix;

  int j;

  int stress = -1;

  int primary_posn = 0;

  vowel_stress[0] = STRESS_IS_UNSTRESSED;

  while (((phcode = *phonemes++) != 0) && (count < (N_WORD_PHONEMES/2)-1)) {

    if ((ph = phoneme_tab[phcode]) == NULL)

      continue;

    if ((ph->type == phSTRESS) && (ph->program == 0)) {

      // stress marker, use this for the following vowel

      if (phcode == phonSTRESS_PREV) {

        // primary stress on preceding vowel

        j = count - 1;

        while ((j > 0) && (*stressed_syllable == 0) && (vowel_stress[j] < STRESS_IS_PRIMARY)) {

          if ((vowel_stress[j] != STRESS_IS_DIMINISHED) && (vowel_stress[j] != STRESS_IS_UNSTRESSED)) {

            // don't promote a phoneme which must be unstressed

            vowel_stress[j] = STRESS_IS_PRIMARY;

            if (max_stress < STRESS_IS_PRIMARY) {

              max_stress = STRESS_IS_PRIMARY;

              primary_posn = j;

            }

            /* reduce any preceding primary stress markers */

            for (ix = 1; ix < j; ix++) {

              if (vowel_stress[ix] == STRESS_IS_PRIMARY)

                vowel_stress[ix] = STRESS_IS_SECONDARY;

            }

            break;

          }

          j--;

        }

      } else {

        if ((ph->std_length < 4) || (*stressed_syllable == 0)) {

          stress = ph->std_length;

          if (stress > max_stress)

            max_stress = stress;

        }

      }

      continue;

    }

    if ((ph->type == phVOWEL) && !(ph->phflags & phNONSYLLABIC)) {

      vowel_stress[count] = (char)stress;

      if ((stress >= STRESS_IS_PRIMARY) && (stress >= max_stress)) {

        primary_posn = count;

        max_stress = stress;

      }

      if ((stress < 0) && (control & 1) && (ph->phflags & phUNSTRESSED))

        vowel_stress[count] = STRESS_IS_UNSTRESSED; // weak vowel, must be unstressed

      count++;

      stress = -1;

    } else if (phcode == phonSYLLABIC) {

      // previous consonant phoneme is syllablic

      vowel_stress[count] = (char)stress;

      if ((stress < 0) && (control & 1))

        vowel_stress[count] = STRESS_IS_UNSTRESSED; // syllabic consonant, usually unstressed

      count++;

    }

    *ph_out++ = phcode;

  }

  vowel_stress[count] = STRESS_IS_UNSTRESSED;

  *ph_out = 0;

  // has the position of the primary stress been specified by $1, $2, etc?

  if (*stressed_syllable > 0) {

    if (*stressed_syllable >= count)

      *stressed_syllable = count-1; // the final syllable

    vowel_stress[*stressed_syllable] = STRESS_IS_PRIMARY;

    max_stress = STRESS_IS_PRIMARY;

    primary_posn = *stressed_syllable;

  }

  if (max_stress == STRESS_IS_PRIORITY) {

    // priority stress, replaces any other primary stress marker

    for (ix = 1; ix < count; ix++) {

      if (vowel_stress[ix] == STRESS_IS_PRIMARY) {

        if (tr->langopts.stress_flags & S_PRIORITY_STRESS)

          vowel_stress[ix] = STRESS_IS_UNSTRESSED;

        else

          vowel_stress[ix] = STRESS_IS_SECONDARY;

      }

      if (vowel_stress[ix] == STRESS_IS_PRIORITY) {

        vowel_stress[ix] = STRESS_IS_PRIMARY;

        primary_posn = ix;

      }

    }

    max_stress = STRESS_IS_PRIMARY;

  }

  *stressed_syllable = primary_posn;

  *vowel_count = count;

  return max_stress;

}

const char stress_phonemes[] = {

  phonSTRESS_D, phonSTRESS_U, phonSTRESS_2, phonSTRESS_3,

  phonSTRESS_P, phonSTRESS_P2, phonSTRESS_TONIC

};

void SetWordStress(Translator *tr, char *output, unsigned int *dictionary_flags, int tonic, int control)

{

  /* Guess stress pattern of word.  This is language specific

     'output' is used for input and output

     'dictionary_flags' has bits 0-3   position of stressed vowel (if > 0)

                                       or unstressed (if == 7) or syllables 1 and 2 (if == 6)

                            bits 8...  dictionary flags

     If 'tonic' is set (>= 0), replace highest stress by this value.

     control:  bit 0   This is an individual symbol, not a word

              bit 1   Suffix phonemes are still to be added

   */

  unsigned char phcode;

  unsigned char *p;

  PHONEME_TAB *ph;

  int stress;

  int max_stress;

  int max_stress_input; // any stress specified in the input?

  int vowel_count; // num of vowels + 1

  int ix;

  int v;

  int v_stress;

  int stressed_syllable; // position of stressed syllable

  int max_stress_posn;

  char *max_output;

  int final_ph;

  int final_ph2;

  int mnem;

  int opt_length;

  int stressflags;

  int dflags = 0;

  int first_primary;

  int long_vowel;

  signed char vowel_stress[N_WORD_PHONEMES/2];

  char syllable_weight[N_WORD_PHONEMES/2];

  char vowel_length[N_WORD_PHONEMES/2];

  unsigned char phonetic[N_WORD_PHONEMES];

  static const char consonant_types[16] = { 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 };

  memset(syllable_weight, 0, sizeof(syllable_weight));

  memset(vowel_length, 0, sizeof(vowel_length));

  stressflags = tr->langopts.stress_flags;

  if (dictionary_flags != NULL)

    dflags = dictionary_flags[0];