parser.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>             /* EXIT_SUCCESS */
#include <errno.h>
#include <string.h>
#include "pair.h"
#include "lexer.h"
#include "template.h"
#include "translator.h"
#include "parser.h"

#define EVAL(expr, err) if (expr) { errno = err; perror(pcerr); iret = EXIT_FAILURE; goto cleanup; }

#define ALLOC(str, vector) EVAL((str = (char *) realloc(str, vector + sizeof('\0'))) == NULL, ENOMEM)

#define STRCAT(stra, strb) ALLOC(stra, strlen(stra) + strlen(strb)); strcat(stra, strb)

#define STRSUB(stra, strb, offset) ALLOC(stra, offset); sprintf(stra, "%.*s", offset, strb)

#define NONE(a) a = (char *) malloc(0)

int parse(char *pcin)
{
  int i, iret = EXIT_SUCCESS;
  const char *pcmaskbase = "<[[:space:]]*?(%s)+?(.*?)>(.*?)</\\%d>";
  const char *pcdiv = "|";
  const char *pcerr = "parser.c parse()";
  char NONE(*pcmaskelement), NONE(*pcmask);

  /* Initialize template list. */
  EVAL(template(&te) != EXIT_SUCCESS, PARSE_ERR);

  /* Goal: element mask of the form `math|chem|music|...'. */
  for (i = 0; i < te.i; i++) {
    STRCAT(pcmaskelement, (te.pten + i)->pcclass);
    STRCAT(pcmaskelement, pcdiv);
  }

  /* Elide the terminal divider. */
  *(pcmaskelement + strlen(pcmaskelement) - strlen(pcdiv)) = '\0';

  /* Slight superfluity when %d recombined as integer; and on single-character classes. */
  ALLOC(pcmask, strlen(pcmaskelement) + strlen(pcmaskbase));
  sprintf(pcmask, pcmaskbase, pcmaskelement, PARSE_ELEMENT);

  /* Perform tokenization with callback.
     Important implication: class name associated with content is always the first pair! */
  EVAL(lex(pcin, pcmask, parsetag) != EXIT_SUCCESS, EINVAL);

 cleanup:
  templatefree(&te);
  free(pcmaskelement);
  free(pcmask);
  return iret;
}

void parsetag(char *pc)
{
  int i, ire, aisub[PARSE_ARGS * PARSE_VECTOR], iret; /* iret: macro placeholder */
  pcre *pre;
  const char *pcre;
  const char *pcmask = "^<[[:space:]]*([^[:space:]]+)(.*?)>(.*)<";
  const char *pcerr = "parser.c parsetag()";
  char NONE(*pcclass), NONE(*pcpairs), NONE(*pccontent);
  pair_t pa;

  EVAL((pre = pcre_compile(pcmask, PARSE_OPT, &pcre, &ire, NULL)) == NULL, EINVAL);
  EVAL(pcre_exec(pre, NULL, pc, strlen(pc), 0, 0, aisub, 12) < PARSE_MATCH, EINVAL);
  STRSUB(pcclass, pc + aisub[PARSE_CLASS * PARSE_ARG + PARSE_BEGIN], aisub[PARSE_CLASS * PARSE_ARG + PARSE_END] - aisub[PARSE_CLASS * PARSE_ARG + PARSE_BEGIN]);
  STRSUB(pcpairs, pc + aisub[PARSE_PAIRS * PARSE_ARG + PARSE_BEGIN], aisub[PARSE_PAIRS * PARSE_ARG + PARSE_END] - aisub[PARSE_PAIRS * PARSE_ARG + PARSE_BEGIN]);
  STRSUB(pccontent, pc + aisub[PARSE_CONTENT * PARSE_ARG + PARSE_BEGIN], aisub[PARSE_CONTENT * PARSE_ARG + PARSE_END] - aisub[PARSE_CONTENT * PARSE_ARG + PARSE_BEGIN]);
  
  /* Shine constructor. */
  PAIRNEW(pa);
  /* Construct pair devised of class and content. */
  addpair(pcclass, pccontent, &pa);
  
  for (i = 0; i < te.i; i++) {
    if (strcmp(pcclass, (te.pten + i)->pcclass) == 0) {
      translate((te.pten + i)->pcdigest, &pa);
    }
  }

 cleanup:
  free(pcclass);
  free(pcpairs);
  free(pccontent);
}

---