#include "all.h"

/*
    Описание формата:
    <формат> ::= <массив> | <формат> [ "." ] <массив> ;
  -- следующие в памяти друг за другом фрагменты
  -- точка только для читабельности
    <массив> ::= <блок> | "(" <формат> ")" <блок> ] ;
  -- повторяющиеся фрагменты
    <блок> ::= [ <счетчик> ] [ <направление> ] ;
  -- простые блоки
    <счетчик> ::= NUM | "N" ;
  -- NUM байт (или повторов предыдущего блока),
  -- N - "до конца строки" (по умолчанию)
    <направление> ::= "D" | "B"
  -- в прямом (D, по умолчанию) или обратном (B) порядке
    Порядок:
  "естественным" порядком считается порядок, при котором самый правый
  бит - самый значащий (внутри байтов он поддерживается автоматически,
  при хранении байтов в памяти в виде строки или слова - обратный,
  т.е. естественным считается "B" (он же "NB"));
    Ограничения:
  В случае если лень ставить D, нужно поставить точку между <массивами>;
  NUM - неотрицательное десятичное число.
    Расширения:
  В любом месте можно поставить имя в кавычках (апострофах).
*/

BYTE lexlit[] = {      /* лексемы */
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 8, 0, 0, 0, 0, 8,     '(', ')', 0, 0, 0, 0, '.', 0,
    9, 9, 9, 9, 9, 9, 9, 9,     9, 9, 0, 0, 0, 0, 0, 0,
    0, 0, 'B', 0, 'D', 0, 0, 0, 0, 0, 0, 0, 0, 0, 'N', 0,
    0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 'B', 0, 'D', 0, 0, 0, 0, 0, 0, 0, 0, 0, 'N', 0,
    0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,     0, 0, 0, 0, 0, 0, 0, 0
};

int num;
STRING str;

static BYTE get_lex(i)   /* лексический анализатор */
    STRING *i;
{
    num = 0;
    if (lexlit[**i] == 8) {  /* имя в кавычках */
  str = ++(*i);
  while (lexlit[*(*i)++] != 8);
  num = *i - str - 1;
  return 8;
    }    
    if (lexlit[**i] != 9)
  return lexlit[*(*i)++];
    while (lexlit[**i] == 9)    /* число */
  num = num * 10 + *(*i)++ - '0';
    return 9;
}

STRUCT(block) {    /* узел дерева */
    TREE(block)
    STRING name;    /* указатель на имя, хранящееся в формате */
    int ns;  /* длина имени */
    int thr;    /* # текущего прохода */
    int n, d;    /* число подблоков, направление */
    int s;  /* сумма длин подблоков */
    int is;  /* сам или входит в блок с выбранным именем */
    int s_nm;    /* сумма длин подблоков нужного имени */
};

DEL0(block)    /* деструктор узла */
TFREE(block)    /* деструктор дерева */

static add_block(cur)    /* добавить младшего сына */
    pblock *cur;
{
    pblock t;
    t = (*cur)->child;
    if (!t) {
  MALLOC(t, block)
  (*cur)->child = t;
    } else {
  while (!t->next)
   t = t->next;
  MALLOC(t->next, block)
  t = t->next;
    }
    t->dad = *cur;
    *cur = t;
}

static add_next(cur)    /* добавить брата */
    pblock *cur;
{
    pblock t;
    MALLOC(t, block)
    (*cur)->next = t;
    t->dad = (*cur)->dad;
    *cur = t;
}

static get_sum(cur, nm, ns, is)    /* расчет длины подблоков */
    STRING nm;  /* с учетом имени */
    pblock cur;
{
    pblock t;
    if (!is && nm && cur->name && cur->ns == ns
  && !strncmp(nm, cur->name, cur->ns))
  is =1;
    cur->is = is;
    if (t = cur->child)
  while (t) {
   cur->s += get_sum(t, nm, ns, is) * t->n;
   cur->s_nm += t->s_nm * t->n;
   t = t->next;
  }
    else {
  cur->s = 1;
  if (is)
   cur->s_nm = 1;
    }
    return cur->s;
}

static test_tree(cur, t)    /* тестовая выдача дерева блоков */
    pblock cur;
{
    pblock c;
    int i;
    for (i = 0; i < t; i++)
  printf("\t");
    printf("n=%d d=%d s=%d is=%d s_nm=%d",
  cur->n, cur->d, cur->s, cur->is, cur->s_nm);
    if (cur->name) {
  char *s;
  NALLOC(s, cur->name, cur->ns)
  printf("\t\"%s\"", s);
    }
    printf("\n");
    if (c = cur->child)
  test_tree(c, t + 1);
    if (c = cur->next)
  test_tree(c, t);
}

static build(o, cur, n, p, l)    /* генерация таблиы перестановок */
    pblock cur;  /* n - куда, p - откуда */
    int *o;
{
    pblock t;
    int i;
    if (!cur->n)  /* блок до конца строки */
  cur->n = (l - p) / cur->s;
    for (i = 0; i < cur->n; i++)    /* повтор подблоков */
  if (t = cur->child)    /* подблоки */
   build(o, t, n + i * cur->s,
    cur->d ? p + (cur->n - i - 1) * cur->s
     : p + i * cur->s, /* учет порядка */
    p + (i + 1) * cur->s);
  else   /* байты */
   o[n + i] = cur->d ? p + cur->n - i - 1 : p + i;
    n += cur->s * cur->n;
    if (t = cur->next)
  n = build(o, t, n, p + cur->s * cur->n, l);
    return n;
}

static build_nm(o, cur, n, p, l)    /* генерация таблиы перестановок */
    pblock cur;   /* с учетом имени */
    int *o;    /* n - куда, p - откуда */
{
    pblock t;
    int i;
    if (!cur->n)  /* блок до конца строки */
  cur->n = (l - p) / cur->s;
    for (i = 0; i < cur->n; i++)    /* повтор подблоков */
  if (t = cur->child)    /* подблоки */
   build_nm(o, t, n + i * cur->s_nm,
    cur->d ? p + (cur->n - i - 1) * cur->s
     : p + i * cur->s, /* учет порядка */
    p + (i + 1) * cur->s);
  else   /* байты */
   if (cur->is)
    o[n + i] = cur->d ? p + cur->n - i - 1 : p + i;
    n += cur->s_nm * cur->n;
    if (t = cur->next)
  n = build_nm(o, t, n, p + cur->s * cur->n, l);
    return n;
}

static build_n(cur, p, l)    /* пересчет полей  с учетом имени и, */
    pblock cur;  /* возможно (l != 0), длины входа */
{
    pblock t;
    int i, n;
    n = 0;
    if (!cur->is) {
  if (t = cur->child)
   n = build_n(t, p, p + cur->s) * cur->n;
    } else
  n = 1;
    if (l && !cur->n)  /* блок до конца строки */
  n *= (l - p) / cur->s;
    else if (t = cur->next)
  n += build_n(t, p + cur->s_nm * cur->n, l);
    return n;
}

static parser(root, f, l, nm, ns)  /* генерация дерева блоков */
    pblock root;
    BYTE *f;
    STRING nm;   /* с учетом имени */
{
    int c;
    pblock cur;
    cur = root;
    while (c = get_lex(&f)) {    /* взять лексему */
  if (c == '.')  /* принудительно следующий блок */
   add_next(&cur);
  if (c == '(') {  /* повторяющийся блок */
   if (cur->n)    /* следующий блок */
    add_next(&cur);
   add_block(&cur);
  } else if (c == 9) {    /* длина блока в подблоках */
   if (cur->n)    /* следующий блок */
    add_next(&cur);
   cur->n = num;
  } else if (c == 8) {    /* имя блока */
   cur->name = str;
   cur->ns = num;
  } else if (c == 'N') {    /* длина остается 0 */
   if (cur->n)    /* следующий блок */
    add_next(&cur);
  } else if (c == 'B')    /* обратный порядок в блоке */
   cur->d = 1;
     /* 'D' - ничего не делает */
  else if (c == ')')    /* конец блока */
   cur = cur->dad;
    }
    cur = root;
    while (cur) {   /* рассчитать длину подблоков */
  get_sum(cur, nm, ns, 0);
  cur = cur->next;
    }
    /* test_tree(root, 0); */
}

static int *make_o(f, l)  /* создать табоицу перестановки f->"" */
    STRING f;
{
    int *o;
    pblock root;   /* охватывающий блок */
    ALLOC(o, int, l)  /* выделить место под таблицу */
    MALLOC(root, block);
    parser(root, f, l, NULL, 0);    /* построение дерева блоков */
    build(o, root, 0, 0, l);    /* генерация таблицы */
    freeblock(root, 1);  /* удаление дерева */
    return o;
}

static int *make_o_nm(f, l, nm, lo)    /* создать табоицу перестановки f->"" */
    STRING f, nm;   /* с учетом имени */
    int *lo;
{
    int *o;
    pblock root;    /* охватывающий блок */
    ALLOC(o, int, l)   /* выделить место под таблицу */
    MALLOC(root, block);
    parser(root, f, l, nm, strlen(nm));    /* построение дерева блоков */
    *lo = build_nm(o, root, 0, 0, l);    /* генерация таблицы */
    freeblock(root, 1);   /* удаление дерева */
    return o;
}

gswap(fi, fo, ti, to, l)   /* копировать l байтов из ti в to, */
    STRING fi, fo, ti, to;   /* согласно форматов fi и fo */
{
    int i, *oi, *oo;
    oi = make_o(fi, l);   /* перестановочная таблица fi->"" */
    oo = make_o(fo, l);   /* перестановочная таблица fo->"" */
    for (i = 0; i < l; i++)   /* копирование ti->to с перестановкой */
  to[oo[i]] = ti[oi[i]];
}

gget(fi, fo, ti, to, l, nm)   /* вывести в to (согласно fo) все */
    STRING fi, fo, ti, to, nm;  /* значения полей с именем nm из ti */
{      /* (формата fi и длиной l) */
    int i, *oi, *oo, lo;    
    oi = make_o_nm(fi, l, nm, &lo);  /* перестановочная таблица fi->"" */
    if (lo) {    /* имя найдено */
  oo = make_o(fo, lo);  /* перестановочная таблица fo->"" */
  for (i = 0; i < lo; i++)    /* копирование ti->to с перестановкой */
   to[oo[i]] = ti[oi[i]];
    }
    return lo;
}

ggetnum(f, l, nm)    /* выдать количество полей  */
    STRING f, nm;    /* с именем nm из формата f */
{      /* при длине входного текста l */
    int n;
    pblock root;    /* охватывающий блок */
    MALLOC(root, block);
    parser(root, f, l, nm, strlen(nm));    /* построение дерева блоков */
    n = build_n(root, 0, l);  /* пересчет полей */
    freeblock(root, 1);   /* удаление дерева */
    return n;
}

gset(fi, fo, ti, to, l, nm)   /* заместить в ti (формата fi и */
    STRING fi, fo, ti, to, nm;  /* длины l) все поля с именем nm */
{      /* на to (формата fo) */
    int i, *oi, *oo, lo;    
    oi = make_o_nm(fi, l, nm, &lo);  /* перестановочная таблица fi->"" */
    if (lo) {    /* имя найдено */
  oo = make_o(fo, lo);  /* перестановочная таблица fo->"" */
  for (i = 0; i < lo; i++)    /* копирование to->ti с перестановкой */
   ti[oi[i]] = to[oo[i]];
    }
    return lo;
}

pname_list gfields(f)  /* выдергивание имен из формата; */
    STRING f;  /* имена остаются в формате, */
{    /* хранятся только указатели */
    pname_list x;
    int c;
    x = NULL;
    while (c = get_lex(&f))    {/* взять лексему */
  if (c == 8) {    /* имя блока */
   pname_list t;
   MALLOC(t, name_list)
   t->s = str;
   t->ns = num;
   t->next = x;
   x = t;
  }
    }
    return x;
}

BYTE I[900], O[900];

main()
{
    int i, l;
    STRING fi;
    pname_list p;
/*    scanf("%d", &l);
    read_hex(I, l);
    write_hex(I + 72 + 36, 32);
    printf("\n");
*/    fi = "'C_UZ'64.4'C_UZ_IMIT'4'IM_UZ'(32'C_LMK'.4'C_LMK_IMIT')20.4'C_FSG'.4'C_FSG_IMIT'";
/*    l = gget(fi, "", I, O, l, "C_LMK_IMIT");
    write_hex(O, l);
    printf("\n");
    p = gfields(fi);
*/    printf("%d\n", ggetnum(fi, 828, "C_LMK_IMIT"));
}