/* liblouis Braille Translation and Back-Translation Library

   Copyright (C) 2016 Mike Gray, American Printing House for the Blind

   This file is part of liblouis.

   liblouis is free software: you can redistribute it and/or modify it

   under the terms of the GNU Lesser General Public License as published

   by the Free Software Foundation, either version 2.1 of the License, or

   (at your option) any later version.

   liblouis 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

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with liblouis. If not, see <http://www.gnu.org/licenses/>.

*/

#include "config.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include "internal.h"

//#define CHECK_OUTPUT_DEFINED

/////

// TODO: these functions are static and copied serveral times

int translation_direction = 1;

static TranslationTableCharacter *

findCharOrDots(widechar c, int m, const TranslationTableHeader *table) {

  /* Look up character or dot pattern in the appropriate

   * table. */

  static TranslationTableCharacter noChar = { NULL, -1, 0, 0, 0, CTC_Space, 0, 0, 32, 0,

    0 };

  static TranslationTableCharacter noDots = { NULL, -1, 0, 0, 0, CTC_Space, 0, 0,

    LOU_DOTS, 0, 0 };

  TranslationTableCharacter *notFound;

  TranslationTableCharacter *character;

  TranslationTableOffset bucket;

  unsigned long int makeHash = _lou_charHash(c);

  if (m == 0) {

    bucket = table->characters[makeHash];

    notFound = &noChar;

  } else {

    bucket = table->dots[makeHash];

    notFound = &noDots;

  }

  while (bucket) {

    character = (TranslationTableCharacter *)&table->ruleArea[bucket];

    if (character->value == c) return character;

    bucket = character->next;

  }

  notFound->value = c;

  return notFound;

}

static int

checkAttr(const widechar c, const TranslationTableCharacterAttributes a,

    const TranslationTableHeader *table) {

  return (((findCharOrDots(c, translation_direction ? 0 : 1, table))->attributes & a)

          ? 1

          : 0);

}

/////

enum pattern_type {

  PTN_ERROR,

  PTN_START,

  PTN_GROUP,

  PTN_NOT,

  PTN_ONE_MORE,

  PTN_ZERO_MORE,

  PTN_OPTIONAL,

  PTN_ALTERNATE,

  PTN_ANY,

  PTN_ATTRIBUTES,

  PTN_CHARS,

  PTN_HOOK,

  PTN_END_OF_INPUT,

  PTN_END = 0xffff,

};

#define EXPR_TYPE_IN(at, buffer) (buffer[(at) + 0])

#define EXPR_PRV_IN(at, buffer) (buffer[(at) + 1])

#define EXPR_NXT_IN(at, buffer) (buffer[(at) + 2])

#define EXPR_DATA_0_IN(at, buffer) (buffer[(at) + 3])

#define EXPR_DATA_1_IN(at, buffer) (buffer[(at) + 4])

#define EXPR_DATA_2_IN(at, buffer) (buffer[(at) + 5])

#define EXPR_DATA_IN(at, buffer) ((widechar *)&buffer[(at) + 3])

#define EXPR_CONST_DATA_IN(at, buffer) ((const widechar *)&buffer[(at) + 3])

#define EXPR_TYPE(at) EXPR_TYPE_IN((at), expr_data)

#define EXPR_PRV(at) EXPR_PRV_IN((at), expr_data)

#define EXPR_NXT(at) EXPR_NXT_IN((at), expr_data)

#define EXPR_DATA_0(at) EXPR_DATA_0_IN((at), expr_data)

#define EXPR_DATA_1(at) EXPR_DATA_1_IN((at), expr_data)

#define EXPR_DATA_2(at) EXPR_DATA_2_IN((at), expr_data)

#define EXPR_DATA(at) EXPR_DATA_IN((at), expr_data)

#define EXPR_CONST_DATA(at) EXPR_CONST_DATA_IN((at), expr_data)

#ifdef CHECK_OUTPUT_DEFINED

#ifndef DEBUG

#define DEBUG

#endif

#define START 0

#define CALL 1

#define RETURN 2

#define SHOW 3

#define CHECK_OUTPUT(type, ret, line, msg)                                              \

  {                                                                                   \

    do_output(type, ret, line, input[*input_crs], input_minmax, *input_crs,         \

        input_dir, expr_data, expr_crs, notOperator, loop_crs, loop_cnts, msg); \

  }

#else

#define CHECK_OUTPUT(type, ret, line, msg) \

  { ; }

#endif

struct expression {

  widechar type;

  widechar prv;

  widechar nxt;

  widechar data[1];

};

/* gdb won't know what this is unless it is actually used */

#ifdef DEBUG

static struct expression *expr_debug;

#endif

////////////////////////////////////////////////////////////////////////////////

static char spaces[] = "..............................";

static int space = 30;

static void

pattern_output_expression(

    const widechar *expr_data, int expr_crs, const TranslationTableHeader *table) {

  int i;

  if (expr_crs == PTN_END) return;

  while (EXPR_TYPE(expr_crs) != PTN_END) {

    printf("%s%d", &spaces[space], expr_crs);

    if (expr_crs < 100) printf(" ");

    if (expr_crs < 10) printf(" ");

    for (i = 0; i < 13 - (30 - space); i++) printf(" ");

    switch (EXPR_TYPE(expr_crs)) {

    case PTN_START:

      printf("START\t%d\t%d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs));

      break;

    case PTN_GROUP:

      printf("(    \t%d\t%d\t-> %d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs),

          EXPR_DATA_0(expr_crs));

      space--;

      if (space < 0) space = 0;

      pattern_output_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      space++;

      if (space > 30) space = 30;

      break;

    case PTN_NOT:

      printf("!    \t%d\t%d\t-> %d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs),

          EXPR_DATA_0(expr_crs));

      space--;

      if (space < 0) space = 0;

      pattern_output_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      space++;

      if (space > 30) space = 30;

      break;

    case PTN_ONE_MORE:

      printf("+    \t%d\t%d\t-> %d\t#%d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs),

          EXPR_DATA_0(expr_crs), EXPR_DATA_1(expr_crs));

      space--;

      if (space < 0) space = 0;

      pattern_output_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      space++;

      if (space > 30) space = 30;

      break;

    case PTN_ZERO_MORE:

      printf("*    \t%d\t%d\t-> %d\t#%d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs),

          EXPR_DATA_0(expr_crs), EXPR_DATA_1(expr_crs));

      space--;

      if (space < 0) space = 0;

      pattern_output_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      space++;

      if (space > 30) space = 30;

      break;

    case PTN_OPTIONAL:

      printf("?    \t%d\t%d\t-> %d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs),

          EXPR_DATA_0(expr_crs));

      space--;

      if (space < 0) space = 0;

      pattern_output_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      space++;

      if (space > 30) space = 30;

      break;

    case PTN_ALTERNATE:

      printf("|    \t%d\t%d\t-> %d\t-> %d\n", EXPR_PRV(expr_crs),

          EXPR_NXT(expr_crs), EXPR_DATA_0(expr_crs), EXPR_DATA_1(expr_crs));

      space--;

      if (space < 0) space = 0;

      pattern_output_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      pattern_output_expression(expr_data, EXPR_DATA_1(expr_crs), table);

      space++;

      if (space > 30) space = 30;

      break;

    case PTN_ANY:

      printf(".    \t%d\t%d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs));

      break;

    case PTN_ATTRIBUTES:

      printf("%%    \t%d\t%d\t", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs));

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[0] >> 16)) printf("0");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[1] >> 16)) printf("1");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[2] >> 16)) printf("2");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[3] >> 16)) printf("3");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[4] >> 16)) printf("4");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[5] >> 16)) printf("5");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[6] >> 16)) printf("6");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[7] >> 16)) printf("7");

      if (EXPR_DATA_0(expr_crs) & (CTC_EndOfInput >> 16)) printf("^");

      if (EXPR_DATA_1(expr_crs) & CTC_Space) printf("_");

      if (EXPR_DATA_1(expr_crs) & CTC_Digit) printf("#");

      if (EXPR_DATA_1(expr_crs) & CTC_Letter) printf("a");

      if (EXPR_DATA_1(expr_crs) & CTC_UpperCase) printf("u");

      if (EXPR_DATA_1(expr_crs) & CTC_LowerCase) printf("l");

      if (EXPR_DATA_1(expr_crs) & CTC_Punctuation) printf(".");

      if (EXPR_DATA_1(expr_crs) & CTC_Sign) printf("$");

      if (EXPR_DATA_1(expr_crs) & CTC_SeqDelimiter) printf("~");

      if (EXPR_DATA_1(expr_crs) & CTC_SeqBefore) printf("<");

      if (EXPR_DATA_1(expr_crs) & CTC_SeqAfter) printf(">");

      puts("");

      break;

    case PTN_CHARS:

      printf("[]   \t%d\t%d\t", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs));

      for (i = 0; i < EXPR_DATA_0(expr_crs); i++)

        printf("%c", EXPR_CONST_DATA(expr_crs)[i + 1]);

      puts("");

      break;

    case PTN_HOOK:

      printf("@    \t%d\t%d\t", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs));

      for (i = 0; i < EXPR_DATA_0(expr_crs); i++)

        printf("%c", EXPR_CONST_DATA(expr_crs)[i + 1]);

      puts("");

      break;

    case PTN_END_OF_INPUT:

      printf("^    \t%d\t%d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs));

      break;

    default:

      printf("%d?    \t%d\t%d\n", EXPR_TYPE(expr_crs), EXPR_PRV(expr_crs),

          EXPR_NXT(expr_crs));

      break;

    }

    expr_crs = EXPR_NXT(expr_crs);

  }

  printf("%s%d", &spaces[space], expr_crs);

  if (expr_crs < 100) printf(" ");

  if (expr_crs < 10) printf(" ");

  for (i = 0; i < 13 - (30 - space); i++) printf(" ");

  printf("END\t%d\t%d\n", EXPR_PRV(expr_crs), EXPR_NXT(expr_crs));

  fflush(stdout);

  return;

}

static void

pattern_output(const widechar *expr_data, const TranslationTableHeader *table) {

  printf("%d    \tlength\n", expr_data[0]);

  printf("%d    \tloops\n", expr_data[1]);

  if (expr_data[0] > 0 && expr_data[0] != PTN_END)

    pattern_output_expression(expr_data, 2, table);

}

static void

pattern_print_expression(

    const widechar *expr_data, int expr_crs, const TranslationTableHeader *table) {

  int i;

  if (expr_crs == PTN_END) return;

  while (EXPR_TYPE(expr_crs) != PTN_END) {

    switch (EXPR_TYPE(expr_crs)) {

    case PTN_START:

      break;

    case PTN_GROUP:

      printf(" (");

      pattern_print_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      printf(") ");

      break;

    case PTN_NOT:

      printf("!");

      pattern_print_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      break;

    case PTN_ONE_MORE:

      pattern_print_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      printf("+");

      break;

    case PTN_ZERO_MORE:

      pattern_print_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      printf("*");

      break;

    case PTN_OPTIONAL:

      pattern_print_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      printf("?");

      break;

    case PTN_ALTERNATE:

      pattern_print_expression(expr_data, EXPR_DATA_0(expr_crs), table);

      printf(" | ");

      pattern_print_expression(expr_data, EXPR_DATA_1(expr_crs), table);

      break;

    case PTN_ANY:

      printf(".");

      break;

    case PTN_ATTRIBUTES:

      printf("%%[");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[0] >> 16)) printf("0");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[1] >> 16)) printf("1");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[2] >> 16)) printf("2");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[3] >> 16)) printf("3");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[4] >> 16)) printf("4");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[5] >> 16)) printf("5");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[6] >> 16)) printf("6");

      if (EXPR_DATA_0(expr_crs) & (table->numberedAttributes[7] >> 16)) printf("7");

      if (EXPR_DATA_0(expr_crs) & (CTC_EndOfInput >> 16)) printf("^");

      if (EXPR_DATA_1(expr_crs) & CTC_Space) printf("_");

      if (EXPR_DATA_1(expr_crs) & CTC_Digit) printf("#");

      if (EXPR_DATA_1(expr_crs) & CTC_Letter) printf("a");

      if (EXPR_DATA_1(expr_crs) & CTC_UpperCase) printf("u");

      if (EXPR_DATA_1(expr_crs) & CTC_LowerCase) printf("l");

      if (EXPR_DATA_1(expr_crs) & CTC_Punctuation) printf(".");

      if (EXPR_DATA_1(expr_crs) & CTC_Sign) printf("$");

      if (EXPR_DATA_1(expr_crs) & CTC_SeqDelimiter) printf("~");

      if (EXPR_DATA_1(expr_crs) & CTC_SeqBefore) printf("<");

      if (EXPR_DATA_1(expr_crs) & CTC_SeqAfter) printf(">");

      printf("]");

      break;

    case PTN_CHARS:

      if (EXPR_DATA_0(expr_crs) == 1)

        printf("%c", EXPR_DATA_1(expr_crs));

      else {

        printf("[");

        for (i = 0; i < EXPR_DATA_0(expr_crs); i++)

          printf("%c", EXPR_CONST_DATA(expr_crs)[i + 1]);

        printf("]");

      }

      break;

    case PTN_HOOK:

      printf("@[");

      for (i = 0; i < EXPR_DATA_0(expr_crs); i++)

        printf("%c", EXPR_CONST_DATA(expr_crs)[i + 1]);

      printf("]");

      break;

    case PTN_END_OF_INPUT:

      printf("^");

      break;

      // default:  printf("%d?\n", EXPR_TYPE(expr_crs));  break;

    }

    expr_crs = EXPR_NXT(expr_crs);

  }

  return;

}

static void

pattern_print(const widechar *expr_data, const TranslationTableHeader *table) {

  if (expr_data[0] > 0 && expr_data[0] != PTN_END)

    pattern_print_expression(expr_data, 2, table);

  puts("");

}

#ifdef CHECK_OUTPUT_DEFINED

static void

do_padd(const int value) {

  if (value < 100000) printf(" ");

  if (value < 10000) printf(" ");

  if (value < 1000) printf(" ");

  if (value < 100) printf(" ");

  if (value < 10) printf(" ");

}

static void

do_pad(const int value) {

  if (value < 100) printf(" ");

  if (value < 10) printf(" ");

}

static void

do_output(const int type, const int ret, const int line,

    const int input, const int input_minmax, const int input_crs, const int input_dir,

    const widechar *expr_data, const int expr_crs, const int notOperator,

    const int loop_crs, const int *loop_cnts,

    const char *msg) {

  switch (type) {

  case START:

    space--;

    if (space < 0) space = 0;

    printf("|%s()  ", &spaces[space]);

    break;

  case CALL:

    printf("|%s>   ", &spaces[space]);

    break;

  case RETURN:

    printf("|%s<%d  ", &spaces[space], ret);

    space++;

    if (space > 31) space = 31;

    break;

  case SHOW:

    printf("|%s    ", &spaces[space]);

    break;

  }

  printf("%d ", line);

  do_padd(line);

  switch (expr_data[expr_crs]) {

  case PTN_ERROR:

    printf("# ");

    break;

  case PTN_START:

    printf("> ");

    break;

  case PTN_END_OF_INPUT:

    printf("^ ");

    break;

  case PTN_ALTERNATE:

    printf("| ");

    break;

  case PTN_OPTIONAL:

    printf("? ");

    break;

  case PTN_ONE_MORE:

    printf("+ ");

    break;

  case PTN_ZERO_MORE:

    printf("* ");

    break;

  case PTN_NOT:

    printf("! ");

    break;

  case PTN_GROUP:

    printf("( ");

    break;

  case PTN_ANY:

    printf(". ");

    break;

  case PTN_ATTRIBUTES:

    printf("%% ");

    break;

  case PTN_CHARS:

    printf("[ ");

    break;

  case PTN_HOOK:

    printf("@ ");

    break;

  case PTN_END:

    printf("< ");

    break;

  default:

    printf("  ");

    break;

  }

  printf("%d ", expr_crs);

  do_padd(expr_crs);

  if (input > 31 && input < 127)

    printf("%c ", input);

  else

    printf("_ ");

  if (input_crs * input_dir >= input_minmax * input_dir)

    printf("#   ");

  else {

    printf("%d ", input_crs);

    do_pad(input_crs);

  }

  if (input_dir > 0)

    printf("<");

  else

    printf(">");

  printf("%d ", input_minmax);

  do_pad(input_minmax);

  if (notOperator)

    printf("!   ");

  else

    printf("    ");

  if (loop_crs) {

    printf("%d ", loop_crs);

    do_pad(loop_crs);

    printf("%d ", loop_cnts[EXPR_DATA_1(loop_crs)]);

    do_pad(loop_cnts[EXPR_DATA_1(loop_crs)]);

  } else

    printf("-   -   ");

  if (EXPR_TYPE(expr_crs) == PTN_ONE_MORE || EXPR_TYPE(expr_crs) == PTN_ZERO_MORE) {

    printf("%d ", loop_cnts[EXPR_DATA_1(expr_crs)]);

    do_pad(loop_cnts[EXPR_DATA_1(expr_crs)]);

  } else

    printf("-   ");

  if (msg) printf("%s", msg);

  puts("");

}

#endif

////////////////////////////////////////////////////////////////////////////////

static int

pattern_compile_1(const widechar *input, const int input_max, int *input_crs,

    widechar *expr_data, const int expr_max, widechar *expr_crs, widechar *loop_cnts,

    TranslationTableHeader *table, const FileInfo *nested);

static int

pattern_compile_expression(const widechar *input, const int input_max, int *input_crs,

    widechar *expr_data, const int expr_max, widechar *expr_crs, widechar *loop_cnts,

    TranslationTableHeader *table, const FileInfo *nested) {

  widechar *data;

  int expr_start, expr_end, expr_sub, expr_crs_prv;

  int input_end;

  int attrs0, attrs1;

  int set, esc, nest, i;

  switch (input[*input_crs]) {

  case '(':

    if (*expr_crs + 10 >= expr_max) return 0;

    (*input_crs)++;

    if (*input_crs >= input_max) return 0;

    /* find closing parenthesis */

    nest = esc = 0;

    for (input_end = *input_crs; input_end < input_max; input_end++) {

      if (input[input_end] == '\\' && !esc) {

        esc = 1;

        continue;

      }

      if (input[input_end] == '(' && !esc)

        nest++;

      else if (input[input_end] == ')' && !esc) {

        if (nest)

          nest--;

        else

          break;

      }

      esc = 0;

    }

    if (input_end >= input_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_GROUP;

    /* compile sub expressions */

    expr_crs_prv = *expr_crs;

    *expr_crs += 4;

    EXPR_DATA_0(expr_crs_prv) = *expr_crs;

    expr_sub = *expr_crs;

    EXPR_TYPE(expr_sub) = PTN_ERROR;

    EXPR_PRV(expr_sub) = PTN_END;

    EXPR_NXT(expr_sub) = PTN_END;

    if (!pattern_compile_1(input, input_end, input_crs, expr_data, expr_max, expr_crs,

          loop_cnts, table, nested))

      return 0;

    (*input_crs)++;

    /* reset end expression */

    expr_end = *expr_crs;

    EXPR_NXT(expr_end) = expr_crs_prv;

    return *expr_crs += 3;

  case '!':

    if (*expr_crs + 10 >= expr_max) return 0;

    (*input_crs)++;

    EXPR_TYPE(*expr_crs) = PTN_NOT;

    expr_crs_prv = *expr_crs;

    *expr_crs += 4;

    EXPR_DATA_0(expr_crs_prv) = *expr_crs;

    /* create start expression */

    expr_start = *expr_crs;

    EXPR_TYPE(expr_start) = PTN_START;

    EXPR_PRV(expr_start) = PTN_END;

    *expr_crs += 3;

    EXPR_NXT(expr_start) = *expr_crs;

    /* compile sub expression */

    expr_sub = *expr_crs;

    EXPR_TYPE(expr_sub) = PTN_ERROR;

    EXPR_PRV(expr_sub) = expr_start;

    EXPR_NXT(expr_sub) = PTN_END;

    if (!pattern_compile_expression(input, input_max, input_crs, expr_data, expr_max,

          expr_crs, loop_cnts, table, nested))

      return 0;

    if (*expr_crs + 3 >= expr_max) return 0;

    EXPR_NXT(expr_sub) = *expr_crs;

    /* create end expression */

    expr_end = *expr_crs;

    EXPR_TYPE(expr_end) = PTN_END;

    EXPR_PRV(expr_end) = expr_sub;

    EXPR_NXT(expr_end) = expr_crs_prv;

    return *expr_crs += 3;

  case '+':

    if (*expr_crs + 5 >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_ONE_MORE;

    EXPR_DATA_1(*expr_crs) = (*loop_cnts)++;

    (*input_crs)++;

    return *expr_crs += 5;

  case '*':

    if (*expr_crs + 5 >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_ZERO_MORE;

    EXPR_DATA_1(*expr_crs) = (*loop_cnts)++;

    (*input_crs)++;

    return *expr_crs += 5;

  case '?':

    if (*expr_crs + 4 >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_OPTIONAL;

    (*input_crs)++;

    return *expr_crs += 4;

  case '|':

    if (*expr_crs + 5 >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_ALTERNATE;

    (*input_crs)++;

    return *expr_crs += 5;

  case '.':

    if (*expr_crs + 3 >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_ANY;

    (*input_crs)++;

    return *expr_crs += 3;

  case '%':

    if (*expr_crs + 5 >= expr_max) return 0;

    (*input_crs)++;

    if (*input_crs >= input_max) return 0;

    /* find closing bracket */

    if (input[*input_crs] == '[') {

      set = 1;

      (*input_crs)++;

      for (input_end = *input_crs; input_end < input_max; input_end++)

        if (input[input_end] == ']') break;

      if (input_end >= input_max) return 0;

    } else {

      set = 0;

      input_end = *input_crs + 1;

    }

    EXPR_TYPE(*expr_crs) = PTN_ATTRIBUTES;

    attrs0 = attrs1 = 0;

    for (; (*input_crs) < input_end; (*input_crs)++) {

      switch (input[*input_crs]) {

      case '_':

        attrs0 |= CTC_Space;

        break;

      case '#':

        attrs0 |= CTC_Digit;

        break;

      case 'a':

        attrs0 |= CTC_Letter;

        break;

      case 'u':

        attrs0 |= CTC_UpperCase;

        break;

      case 'l':

        attrs0 |= CTC_LowerCase;

        break;

      case '.':

        attrs0 |= CTC_Punctuation;

        break;

      case '$':

        attrs0 |= CTC_Sign;

        break;

      case 'm':

        attrs0 |= CTC_Math;

        break;

      case '~':

        attrs0 |= CTC_SeqDelimiter;

        break;

      case '<':

        attrs0 |= CTC_SeqBefore;

        break;

      case '>':

        attrs0 |= CTC_SeqAfter;

        break;

      case '0':

      case '1':

      case '2':

      case '3':

      case '4':

      case '5':

      case '6':

      case '7': {

        int k = input[*input_crs] - '0';

        TranslationTableCharacterAttributes a = table->numberedAttributes[k];

        if (!a) {

          // attribute not used before yet: assign it a value

          a = table->numberedAttributes[k] =

              table->nextNumberedCharacterClassAttribute;

          if (a > CTC_UserDefined8) {

            _lou_logMessage(LOU_LOG_ERROR,

                "%s:%d: error: Too many character attributes defined",

                nested->fileName, nested->lineNumber);

            return 0;

          }

          table->nextNumberedCharacterClassAttribute <<= 1;

        }

        attrs1 |= (a >> 16);

        break;

      }

      case '^':

        attrs1 |= (CTC_EndOfInput >> 16);

        break;

      default:

        return 0;

      }

    }

    EXPR_DATA_0(*expr_crs) = attrs1;

    EXPR_DATA_1(*expr_crs) = attrs0;

    if (set) (*input_crs)++;

    return *expr_crs += 5;

  case '[':

    (*input_crs)++;

    if (*input_crs >= input_max) return 0;

    /* find closing bracket */

    esc = 0;

    for (input_end = *input_crs; input_end < input_max; input_end++) {

      if (input[input_end] == '\\' && !esc) {

        esc = 1;

        continue;

      }

      if (input[input_end] == ']' && !esc) break;

      esc = 0;

    }

    if (input_end >= input_max) return 0;

    if (*expr_crs + 4 + (input_end - *input_crs) >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_CHARS;

    esc = 0;

    data = EXPR_DATA(*expr_crs);

    for (i = 1; *input_crs < input_end; (*input_crs)++) {

      if (input[*input_crs] == '\\' && !esc) {

        esc = 1;

        continue;

      }

      esc = 0;

      data[i++] = (widechar)input[*input_crs];

    }

    data[0] = i - 1;

    (*input_crs)++;

    return *expr_crs += 4 + data[0];

  case '@':

    (*input_crs)++;

    if (*input_crs >= input_max) return 0;

    /* find closing bracket */

    if (input[*input_crs] == '[') {

      set = 1;

      (*input_crs)++;

      for (input_end = *input_crs; input_end < input_max; input_end++)

        if (input[input_end] == ']') break;

      if (input_end >= input_max) return 0;

    } else {

      set = 0;

      input_end = *input_crs + 1;

    }

    if (*expr_crs + 4 + (input_end - *input_crs) >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_HOOK;

    esc = 0;

    data = EXPR_DATA(*expr_crs);

    for (i = 1; *input_crs < input_end; (*input_crs)++) {

      if (input[*input_crs] == '\\' && !esc) {

        esc = 1;

        continue;

      }

      esc = 0;

      data[i++] = (widechar)input[*input_crs];

    }

    data[0] = i - 1;

    if (set) (*input_crs)++;

    return *expr_crs += 4 + data[0];

  case '^':

  case '$':

    if (*expr_crs + 3 >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_END_OF_INPUT;

    (*input_crs)++;

    return *expr_crs += 3;

  case '\\':

    (*input_crs)++;

    if (*input_crs >= input_max) return 0;

  default:

    if (*expr_crs + 5 >= expr_max) return 0;

    EXPR_TYPE(*expr_crs) = PTN_CHARS;

    EXPR_DATA_0(*expr_crs) = 1;

    EXPR_DATA_1(*expr_crs) = (widechar)input[*input_crs];

    (*input_crs)++;

    return *expr_crs += 5;

  }

}

static int

pattern_insert_alternate(const widechar *input, const int input_max, int *input_crs,

    widechar *expr_data, const int expr_max, widechar *expr_crs, widechar *loop_cnts,

    int expr_insert, TranslationTableHeader *table, const FileInfo *nested) {

  int expr_group, expr_alt, expr_end;

  if (EXPR_TYPE(*expr_crs) == PTN_START) return 0;

  if (*expr_crs + 12 >= expr_max) return 0;

  /* setup alternate expression */

  expr_alt = *expr_crs;

  EXPR_TYPE(expr_alt) = PTN_ALTERNATE;

  EXPR_PRV(expr_alt) = PTN_END;

  EXPR_NXT(expr_alt) = PTN_END;

  *expr_crs += 5;

  /* setup group expression */

  expr_group = *expr_crs;

  EXPR_TYPE(expr_group) = PTN_GROUP;

  EXPR_PRV(expr_group) = PTN_END;

  EXPR_NXT(expr_group) = PTN_END;

  *expr_crs += 4;

  EXPR_DATA_0(expr_group) = *expr_crs;

  EXPR_TYPE(*expr_crs) = PTN_ERROR;

  EXPR_PRV(*expr_crs) = PTN_END;

  EXPR_NXT(*expr_crs) = PTN_END;

  if (!pattern_compile_1(input, input_max, input_crs, expr_data, expr_max, expr_crs,

        loop_cnts, table, nested))

    return 0;

  expr_end = *expr_crs;

  EXPR_NXT(expr_end) = expr_group;

  /* setup last end expression */

  if (*expr_crs + 3 >= expr_max) return 0;

  *expr_crs += 3;

  EXPR_TYPE(*expr_crs) = PTN_END;

  EXPR_NXT(*expr_crs) = PTN_END;

  /* replace insert expression with group expression using last end expression */

  EXPR_NXT(EXPR_PRV(expr_insert)) = expr_group;

  EXPR_PRV(expr_group) = EXPR_PRV(expr_insert);

  EXPR_NXT(expr_group) = *expr_crs;

  EXPR_PRV(*expr_crs) = expr_group;

  /* link alternate and insert expressions before group end expression */

  EXPR_NXT(EXPR_PRV(expr_end)) = expr_alt;

  EXPR_PRV(expr_alt) = EXPR_PRV(expr_end);

  EXPR_NXT(expr_alt) = expr_insert;

  EXPR_PRV(expr_insert) = expr_alt;

  EXPR_NXT(expr_insert) = expr_end;

  EXPR_PRV(expr_end) = expr_insert;

  return *expr_crs;