---

dts.c

#include "config.h"
#include "dts.h"
#include "parser.h"    /* just for N_I */

objref* objref_obtain_local(char* r) {
    NOT_IMPLEMENTED;
}

void objref_release(objref* r) {
    NOT_IMPLEMENTED;
}


#if 0

    NEEDS TO BE UPDATES WITH ALL THE NAME CHANGES.

/*
  $Id: dts_8c-source.html,v 1.10 2001/10/10 20:40:59 sandro Exp $
*/

#include <assert.h>
#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <search.h>            /* obviously a hack! */


#include "rdf.h"


typedef struct add_s {
  Symbol subject, predicate, object;
  struct add_s *next;
} Add;

typedef struct include_s {
  Symbol inner;
  struct include_s *next;
} Include;
    
struct _object {
  int refcount;
  char *swid;
  char *litval;          /* fold this into swid with data:? */
  char *localname;       /* fold this into swid with genid */
  Add *adds;
  Include *includes;
  int mark;
};


void fprint_sym(FILE *f, Symbol s) {
    assert(0);
}

void add(Symbol set, Symbol subject, Symbol predicate, Symbol object) {
  Add *previous_adds = set->adds;

  fprintf(stderr, "add: ");
  fprint_sym(stderr, set);
  fprint_sym(stderr, subject);
  fprint_sym(stderr, predicate);
  fprint_sym(stderr, object);
  fprintf(stderr, "\n");

  set->adds = (Add *) malloc(sizeof(struct add_s));
  keepsym(subject);
  keepsym(predicate);
  keepsym(object);
  set->adds->subject = subject;
  set->adds->subject = predicate;
  set->adds->subject = object;
  set->adds->next = previous_adds;
}

void include(Symbol outer, Symbol inner) {
  Include *previous_includes = outer->includes;

  fprintf(stderr, "include:");
  fprint_sym(stderr, outer);
  fprint_sym(stderr, inner);
  fprintf(stderr, "\n");

  outer->includes = (Include *) malloc(sizeof(struct include_s));
  outer->includes->inner = inner;
  keepsym(inner);
  outer->includes->next = previous_includes;
}

void keepsym(Symbol s) {
  assert(s->refcount > 0);
  s->refcount++;
}

void releasesym(Symbol s) {

  fprintf(stderr, "release:");
  fprint_sym(stderr, s);
  fprintf(stderr, "\n");

  assert(s->refcount > 0);
  s->refcount--;
  if (s->refcount) return;

  fprintf(stderr, "--- refcount reached zero, freeing\n");

  free(s->swid);
  free(s->litval);

  {
    Add *this;
    Add *next = s->adds;
    while (next) {
      this = next;
      releasesym(this->subject);
      releasesym(this->predicate);
      releasesym(this->object);
      next = this->next;
      free(this);
    }
  }

  {
    Include *this;
    Include *next = s->includes;
    while (next) {
      this = next;
      releasesym(this->inner);
      next = this->next;
      free(this);
    }
  }

  free(s);
  fprintf(stderr, "--- done with releasesym");
  fprint_sym(stderr, s);
  fprintf(stderr, "\n");

}

void reify_statement_sets(Symbol outer_set, Symbol flat_set);
void datafy(Symbol s);

static int genid_count = 0;
void genify_m(Symbol s) {
  if (marked(s)) return;
  mark(s);
  
  {
    Add *this;
    for (this = s->adds; this; this = this->next) {
      genify_m(this->subject);
      genify_m(this->predicate);
      genify_m(this->object);
    }
  }

  {
    Include *this;
    for (this = s->includes; this; this = this->next) {
      /* it's odd to reach the symbol via inclusion, but
     I guess it works.   The included set symbol itself 
     would not be genified if we had just used copy. */
      genify_m(this->inner);
    }
  }  


  /* alternate version 
  {
    Add *add;
    Include *include;
    for (add = use_top->adds; add; add = add->next) {
      genify_m(add->subject);
      genify_m(add->predicate);
      genify_m(add->object);
    }
    for (include = use_top->includes; include; include = include->next) {
      genify_m(include->inner);
    }
  }  
  */

  if (!s->swid) {
    static char buf[80];
    sprintf(buf, "genid:%d", genid_count++);
    s->swid = (char *) strdup(buf);
  }

}

void genify(Symbol s) {
  mark_begin();
  genify_m(s);
  mark_end();
}

void write_n3(FILE* out, Symbol top);
void write_canonical(FILE* out, Symbol top);
void write_prolog_3(FILE* out, Symbol top, char* predicate);

void write_prolog_symbol(FILE* out, Symbol s) {
  if (s->swid) {
    fprintf(out, "'%s'", s->swid);
    return;
  }
  if (s->litval) {
    fprintf(out, "\"%s\"", s->litval);
    return;
  }
  assert(0);  /* there shouldn't be any anons at this point */
}

void write_prolog_4_masq(FILE* out, Symbol show_top, Symbol use_top, 
             char* predicate) {
  
  /* we use marks here to prevent repeatedly describing the same
     mentioned set.  it also avoids problems from mention-loops. */
  if (marked(use_top)) return;
  mark(use_top);

  {
    Add *this;
    for (this = use_top->adds; this; this = this->next) {
      fputs(predicate, out);
      fputs("(", out);
      write_prolog_symbol(out, show_top);
      fputs(", ", out);
      write_prolog_symbol(out, this->subject);
      fputs(", ", out);
      write_prolog_symbol(out, this->predicate);
      fputs(", ", out);
      write_prolog_symbol(out, this->object);
      fputs(")\n", out);

      write_prolog_4_masq(out, this->subject, this->subject, predicate);
      write_prolog_4_masq(out, this->predicate, this->predicate, predicate);
      write_prolog_4_masq(out, this->object, this->object, predicate);
    }

  }

  {
    Include *this;
    for (this = use_top->includes; this; this = this->next) {
      write_prolog_4_masq(out, show_top, this->inner, predicate);
    }
  }  

}

void write_prolog_4(FILE* out, Symbol top, char* predicate) {

  mark_begin();
  write_prolog_4_masq(out, top, top, predicate);
  mark_end();
}

static int current_mark=0;
static int marking = 0;

void mark_begin() {
  assert(!marking);
  marking = 1;
  current_mark++;
}

int marked(Symbol s) {
  return s->mark == current_mark;
}

void mark(Symbol s) {
  s->mark = current_mark;
}

void mark_end() {
  assert(marking);
  marking = 0;
}



int count_m(Symbol s) {
  int result = 1;
  if (marked(s)) return 0;
  mark(s);
  
  {
    Add *this;
    for (this = s->adds; this; this = this->next) {
      result += count_m(this->subject);
      result += count_m(this->predicate);
      result += count_m(this->object);
    }
  }

  {
    Include *this;
    for (this = s->includes; this; this = this->next) {
      /* it's odd to reach the symbol via inclusion, but
     I guess it works.   The included set symbol itself 
     would not be genified if we had just used copy. */
      result += count_m(this->inner);
    }
  }  

  return result;
}

int count(Symbol s) {
  int result;
  mark_begin();
  result = count_m(s);
  mark_end();
  return result;
}

/****************************************************************

    hack temporary implementation, using hsearch

****************************************************************/

#include <search.h>

#define BUFLEN 16384
static char buf[BUFLEN];
static int h_created = 0;

static Symbol makesym() {
  Symbol s = (Symbol) malloc(sizeof(struct _object));
  s->refcount = 1;
  s->swid = 0;
  s->litval = 0;
  s->adds = 0;
  s->includes = 0;
  return s;
}

Symbol obtain_anon() {
  return makesym();
}

static Symbol obtain(char type, char *name, int *created_p) {
  ENTRY e, *ep;
  if (snprintf(buf, BUFLEN, "%c %s", type, name) == -1) {
    fprintf(stderr, "string too long\n"); abort(0);
  }
  if (!h_created) { hcreate(100);  h_created++; }
  e.key = buf;
  ep = hsearch(e, FIND);
  if (ep) { *created_p = 0; return (Symbol) ep->data; }
  e.key = strdup(buf);
  e.data = (char*) obtain_anon();
  *created_p = 1;
  hsearch(e, ENTER);
  return (Symbol) e.data;
}

Symbol obtain_global(char *name) {
  int created;
  Symbol result = obtain('g', name, &created);
  if (created) {
    result->swid = strdup(name);
  }
  return result;
}

Symbol obtain_local(char *name) {
  int created;
  Symbol result = obtain('g', name, &created);
  if (created) {
    result->localname = strdup(name);
  }
  return result;
}

Symbol obtain_literal_utf8(char *text) {
  int created;
  Symbol result = obtain('g', text, &created);
  if (created) {
    result->litval = strdup(text);
  }
  return result;
}

#endif

---

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