---

abstract_grammar.c

/*
  


*/

static char id[] = "$Id: abstract__grammar_8c-source.html,v 1.10 2001/10/10 20:40:58 sandro Exp $";


#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <assert.h>

#include "abstract_grammar.h"

Grammar *new_grammar() {
  Grammar *g = dltree_alloc(sizeof(Grammar));
  return g;
}

Rule* add_charset(Grammar *g, char present[256]) {
    Charset *other;

    /* Look to see if we have a matching charset already */
    for (other = g->first_charset; other; other=other->next_in_grammar) {
    int i;
    for (i=0; i<256; i++) {
        if (other->present[i] != present[i]) goto no_match;
    }
    return other->rule;
    }

 no_match:
    {
    Charset *s = calloc(1, sizeof(Charset));
    int i;
    for (i=0; i<256; i++) {
        if (present[i]) s->bits++;
    }
    memcpy(s->present, present, 256*sizeof(char));
    memcpy(s->present_only_here, present, 256);
    
    s->rule = add_anonymous_rule(g);
    //fprintf(stderr, "MADE A CHARSET RULE %x\n", s->rule);
    s->next_in_grammar = g->first_charset;
    g->first_charset = s;
    return s->rule;
    }
}

static void fill_in_rule_for_charset(Grammar *g, Charset *s) 
{
    Rule *r1 = add_anonymous_rule(g);
    Term *t;
    Action *a;
    int c;
    Branch *b;

    //fprintf(stderr, "FILLED IN A CHARSET RULE %x\n", s->rule);
    for(c=0; c<=255; c++) {
    if (s->present_only_here[c]) {
        b = add_branch(r1);    
        t = add_term(b);
        t->type = literal;
        t->data.literal = (char) c;
        t->name = strdup("_charset_literal");
        
        a = (Action*) calloc(1, sizeof(Action));
        a->type = nop;
        t->actions = a;
    }
    }

    {
    struct charset_list_node *n;
    int count=0;
    for (n=s->inclusions; n; n=n->next) {
        b = add_branch(r1);
        t = add_term(b);
        t->type = rule_pointer;
        t->data.rule_pointer = n->charset->rule;
        t->name = strdup("_charset_subset");
        if (count++ > 32) {
        fprintf(stderr, "Warning, weird charset inclusions.\n");
        break;
        }
    }
    }

    b = add_branch(s->rule);    
    t = add_term(b);
    t->type = rule_pointer;
    t->data.rule_pointer = r1;
    t->name = strdup("_charset_action");
        
    a = (Action*) calloc(1, sizeof(Action));
    a->type = onechar;
    t->actions = a;
}

void post_process_charsets(Grammar *g) 
{
    /*
      for each charset, look for any other "sub" charsets, which have
      only bits that we have.  If we find one, remove its bits from
      present_only_here and add it to our inclusions list.

    */

    Charset *big;
    Charset *small;

    for (big = g->first_charset; big; big=big->next_in_grammar) {
    fprintf(stderr, "Does %s include anythig?\n", big->rule->name);
    for (small = g->first_charset; small; small=small->next_in_grammar) {
        int i;
        //if (big->bits <= small->bits) continue;
        if (big == small) continue;

        fprintf(stderr, "  Like %s?\n", small->rule->name);
        for (i=0; i<256; i++) {
        if (small->present[i] && !big->present[i]) goto next_small;
        }
        for (i=0; i<256; i++) {
        if (small->present[i]) big->present_only_here[i] = 0;
        }
        fprintf(stderr, "  yes!\n");
        {
        struct charset_list_node *n = 
            malloc(sizeof(struct charset_list_node));
        fprintf(stderr, "Including %s in %s\n", small->rule->name,
            big->rule->name);
        n->next = big->inclusions;
        big->inclusions = n;
        n->charset = small;
        }
        continue;
    next_small:
        fprintf(stderr, "   no\n");
    }
    }

    /*
      Write the appropriate rules for each one now 
    */
    for (big = g->first_charset; big; big=big->next_in_grammar){
    fill_in_rule_for_charset(g, big);
    }
}

Rule* add_anonymous_rule(Grammar *g) {
  static char buf[80];
  sprintf(buf, "_%d", ++(g->anons));
  return add_rule(g, buf);
}

Rule* add_rule(Grammar *g, char *name) {
  Rule *r = (Rule *) dltree_alloc(sizeof(Rule));
  dltree_append_child(g, r);
  r->name=strdup(name);
  return r;
}

Rule *obtain_rule(Grammar *g, char *name); /* add or lookup */

Branch* add_branch(Rule *r) {
  Branch *b = (Branch *) dltree_alloc(sizeof(Branch));
  dltree_append_child(r, b);
  return b;
}

Term *add_term(Branch *b) {
  Term *t = (Term *) dltree_alloc(sizeof(Term));
  dltree_append_child(b, t);
  t->type = unused;
  return t;
}

void grammar_copy_term(Term *t, Term *dest) {
  dest->type = t->type;
  switch(t->type) {
  case unused:
    break;
  case literal:
    dest->data.literal = t->data.literal;
    break;
  case rule_name: 
    dest->data.rule_name = strdup(t->data.rule_name);
    break;
  case rule_pointer: 
    dest->data.rule_pointer = t->data.rule_pointer;
    break;
  }
  dest->name = strdup(t->name);
  dest->actions = 0;   /*  XXX   for now, we're assuming we're not supposed to copy the actions */
}

void print_value(FILE *out, Value* value, int in_rule) {
  switch (value->type) {
  case unused: abort();
  case text_buffer:
      fprintf(out, "symbolFor(text_buffer(), sink->getSink())");
      break;
  case literal_string: 
      fprintf(out, "symbolFor(\"%s\", sink->getSink())", value->as.literal_string.string);
      break;
  case tuple: 
  { 
      Value *v = value->as.tuple.first;
      for ( ; v; v=v->next) {
      print_value(out, v, in_rule);
      if (v->next) fprintf(out, ", ");
      }
  }
  break;
  case rdfid:
      fprintf(out, "Symbol(space, \"%s\")", value->as.rdfid.id);
      break;
  case local_name:
      fprintf(out, "obtain_local(\"%s\")", value->as.local_name.name);
      break;
  case current_content:
  {
      if (in_rule) {
      fprintf(out, "$$.content");
      } else {
      fprintf(out, "result.content");
      }
      break;
  }
  case subst:
  {
      char var[16];

      if (in_rule) {
      if (value->as.subst.position == 0) {
          sprintf(var, "$$");
      } else {
          sprintf(var, "$%d", value->as.subst.position);
      }
      } else {
      sprintf(var, "result");
      }

      switch (value->as.subst.part) {
      case value_part:  
      fprintf(out, "%s.value", var); 
      break;
      case content_part:  
      fprintf(out, "%s.content", var); 
      break;
      case text_part:  
      fprintf(out, 
          "symbolFor(%s.text, %s.text_end, sink->getSink())",
          var, var); 
      break;
      }
      break;
  }
  }
}

void print_value_text(FILE *out, Value* value) {
    switch (value->type) {
    case unused: abort();
    case text_buffer:
    fprintf(out, "text_buffer()");
    break;
    case literal_string: 
    /* escaping for embedded quotes? */
    fprintf(out, "\"%s\"", value->as.literal_string.string);
    break;
    case tuple: 
    die("type mismatch, can't convert tuple to string");
    break;
    case current_content:
    die("type mismatch, can't convert current_content to string");
    break;
    case rdfid:
    die("type mismatch, can't convert rdfid to string");
    break;
    case local_name:
    die("type mismatch, can't convert local name to string");
    break;
    case subst:
    if (value->as.subst.position == 0) {
        fprintf(out, "$$");
    } else {
        fprintf(out, "$%d", value->as.subst.position);
    }
    switch (value->as.subst.part) {
    case value_part:
        die("type mismatch, can't convert value symbol to string"); break;
    case content_part:
        die("type mismatch, can't convert content symbol to string"); break;
    case text_part:  
        fprintf(out, ".text"); break;
    }
    break;
    }
}

void print_actions(FILE *out, Action* action, int last, Branch *b) {
  Action *a = action;
  if (a == 0 && !last) {
      return;
  }

  if (b) fprintf(out, "[YYVALID;]\n");    /* we don't really want backtracking, just a guarantee of the order in which things will get parsed */

  if (a && a->type == nop) {
      if (b) fprintf(out, "   { }");
      return;
  }

  fprintf(out, "\n      {\n");

  if (b) {
      fprintf(out, "        $$.content = symbolForAnonymous(\"content\", sink->getSink());\n");
      fprintf(out, "        $$.value = symbolForAnonymous(\"value\", sink->getSink());\n");
  }

  if (b) { 
      /* count back the number of character literals from the 
     first rule, or here if none */
      int bytes=0;
      int term=0;
      int i;
      DLTreeNode *n = b->tree.first;
      for (i=1; n; i++, n=n->next) {
      Term *t = (Term *)n;
      if ( t->type == literal ) {
          bytes += 1;  /*  strlen(t->data.literal)   WIDE?  */
      } else {
          term = i;
          break;
      }
      }

      if (a && a->type == onechar) { bytes=1; term=0; }

      if (term == 0) {
      fprintf(out, "        $$.text = yylex_buffer - %d;\n", bytes);
      } else {
      fprintf(out, "        $$.text = $%d.text - %d;\n", term, bytes);
      }

      fprintf(out, "        $$.text_end = yylex_buffer;\n");
  } 

  while (a) {
    fprintf(out, "        ");
    switch (a->type) {
    case unused: abort();
    case nop: break;
    case onechar: break;
    case addto: 
      fprintf(out, "sink->addTo(");
      print_value(out, a->as.addto.set, b!=0);
      fprintf(out, ", ");
      print_value(out, a->as.addto.object, b!=0);
      fprintf(out, ")");
      break;
    case includein: 
      fprintf(out, "sink->includeIn(");
      print_value(out, a->as.includein.outer, b!=0);
      fprintf(out, ", ");
      print_value(out, a->as.includein.inner, b!=0);
      fprintf(out, ")");
      break;
    case appendtotext:
      fprintf(out, "append_to_text_buffer(");
      print_value_text(out, a->as.appendtotext.text);
      fprintf(out, ")");
      break;
    case cleartext:
      fprintf(out, "clear_text_buffer()");
      break;
    }
      
    fprintf(out, ";\n");
    a = a->next;
  }
  fprintf(out, "      }\n");

}
void print_term(FILE *out, Grammar *g, Term *t) {
  switch(t->type) {
  case unused: fprintf(out, "<unused>"); 
    break;
  case literal: {
      char c = t->data.literal;
      /* HACK short term solution - what's generally portable for yaccs? */
      if (c == '\\') {
      fprintf(out, "'\\\\'");
      } else if (c == '\'') {
      fprintf(out, "'\\''");
      } else if (c == '\n') {
      fprintf(out, "'\\n'");
      } else if (c == '\r') {
      fprintf(out, "'\\r'");
      } else {
      fprintf(out, "'%c'", c);
      }
    }
    break;
  case rule_name: 
    /* we could resolve it, or just let yacc do it.... */
    fprintf(out, "%s", t->data.rule_name);
    break;
  case rule_pointer: 
    /* we could resolve it, or just let yacc do it.... */
    fprintf(out, "%s", t->data.rule_pointer->name);
    break;
  }
  assert(t->name);
#if COMMENT_YACC_RULES
  if (t->name[0] != '_') fprintf(out, " /*=\"%s\"*/  ", t->name);
#endif
}

void print_branch(FILE *out, Grammar *g, Branch *b) {
  DLTreeNode *n = b->tree.first;
  while (n) {
    print_term(out, g, (Term *)n);
    print_actions(out, ((Term *)n)->actions, (n->next == 0), b);
    n=n->next;
    if (n) fprintf(out, " ");
  }
}

void print_rule(FILE *out, Grammar *g, Rule *r) {
  DLTreeNode *n = r->tree.first;

  assert(n);  /* rule with no branches....?    nah.  */

  fprintf(out, "%s\n  : ", r->name);
  while (n) {
    print_branch(out, g, (Branch *)n);
    n=n->next;
    if (n) fprintf(out, "\n  | ");
  }
  fprintf(out, "\n");
  fprintf(out, "\n");
}

void print_grammar(FILE *out, Grammar *g) {
  DLTreeNode *n = g->tree.first;

  post_process_charsets(g);
  fprintf(out, "%%{\n\n");
  fprintf(out, "static char id[] = \"machine generated by blindfold (should have various version infos)\";\n");
  fprintf(out, "#include <parser_common_head.h>\n");
  fprintf(out, "\n%%}\n\n");
  fprintf(out, "%%%%\n");

  while (n) {
    print_rule(out, g, (Rule *)n);
    n=n->next;
  }

  fprintf(out, "%%%%\n");

  fprintf(out, "\n\nvoid top_level_actions()\n");
  print_actions(out, g->actions, 1, 0);
  fprintf(out, "\n");

  fprintf(out, "#include <parser_common_foot.h>\n");
}
  
 

---

Home to blindfold. This page generated via doxygen 1.2.11.1 Wed Oct 10 16:40:33 2001.