yll.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include <isa/yll.h>
   4
   5 #define FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
   6 #define FL_SET(l, f)    ((l) |= (f))
   7 #define FL_CLR(l, f)    ((l) &= ~(f))
   8 #define FL_ISSET(l, f)  ((l) & (f))
   9
  10 #define F_INIT(p, f)    FL_INIT((p)->flags, f)  /* Structure element flags. */
  11 #define F_SET(p, f)     FL_SET((p)->flags, f)
  12 #define F_CLR(p, f)     FL_CLR((p)->flags, f)
  13 #define F_ISSET(p, f)   FL_ISSET((p)->flags, f)
  14
  15 static void yll_emit_space(YllEmitter *e)
  16 {
  17     if (F_ISSET(e->stack, YLL_ADD_SPACE))
  18         fprintf(e->out, " ");
  19     F_CLR(e->stack, YLL_ADD_SPACE);
  20 }
  21
  22 static void yll_emit_transfer(YllEmitter *e)
  23 {
  24     yll_emit_space(e);
  25     if (e->transfer) {
  26         fprintf(e->out, "!%s", e->transfer);
  27         e->transfer = 0;
  28         F_SET(e->stack, YLL_ADD_SPACE);
  29     }
  30 }
  31
  32 static void yll_push(YllEmitter *e, YllEmitterNode *n)
  33 {
  34     n->next = e->stack;
  35     e->stack = n;
  36     n->flags = e->flags;
  37     e->flags = 0;
  38     e->indent += 2;
  39 }
  40
  41 static void yll_pop(YllEmitter *e)
  42 {
  43     YllEmitterNode *n = e->stack;
  44     e->stack = e->stack->next;
  45     S_FREE(n);
  46     e->indent -= 2;
  47 }
  48
  49 static void next_doc(YllEmitter *e)
  50 {
  51     fprintf(e->out, "--- ");
  52 }
  53
  54 static void next_anchor(YllEmitter *e)
  55 {
  56     YllAnchorNode *n = (YllAnchorNode*) e->stack;
  57     SYMID a = n->anchor;
  58     yll_pop(e);
  59     e->stack->nextf(e);
  60     fprintf(e->out, "&%d", a);
  61     F_SET(e->stack, YLL_ADD_SPACE);
  62 }
  63
  64 static void next_seq(YllEmitter *e)
  65 {
  66     YllSeqNode *n = (YllSeqNode*) e->stack;
  67     if (F_ISSET(e->stack, YLL_INLINE_SEQ)) {
  68         if (!n->first)
  69             fprintf(e->out, ", ");
  70     } else
  71         fprintf(e->out, "\n%*s- ", e->indent, "");
  72     n->first = 0;
  73 }
  74
  75 static void next_map_val(YllEmitter *e);
  76
  77 static void next_map_key(YllEmitter *e)
  78 {
  79     F_CLR(e->stack, YLL_ADD_SPACE);
  80     fprintf(e->out, "\n%*s", e->indent, "");
  81     e->stack->nextf = next_map_val;
  82 }
  83
  84 static void next_map_val(YllEmitter *e)
  85 {
  86     fprintf(e->out, ": ");
  87     e->stack->nextf = next_map_key;
  88 }
  89
  90 YllEmitter* yll_new_emitter() {
  91     YllEmitter *e;
  92     YllEmitterNode *n;
  93     e = S_ALLOC(YllEmitter);
  94     n = S_ALLOC(YllEmitterNode);
  95     n->nextf = next_doc;
  96     e->last_anchor = 0;
  97     e->stack = 0;
  98     e->flags = 0;
  99     e->transfer = 0;
 100     yll_push(e, n);
 101     e->indent = -2;
 102     return e;
 103 }
 104
 105 void yll_emitter_handler(YllEmitter *e, YllOutputHandler hdlr)
 106 {
 107 }
 108
 109 void yll_free_emitter(YllEmitter *e)
 110 {
 111     fprintf(e->out, "\n");
 112     yll_pop(e);
 113     S_FREE(e);
 114 }
 115
 116 void yll_emitter_start_seq(YllEmitter *e)
 117 {
 118     YllSeqNode * n;
 119     e->stack->nextf(e);
 120     n = S_ALLOC(YllSeqNode);
 121     n->en.nextf = next_seq;
 122     n->first = 1;
 123     yll_push(e, (YllEmitterNode *)n);
 124     yll_emit_transfer(e);
 125     if (F_ISSET(&n->en, YLL_INLINE_SEQ))
 126         fprintf(e->out, "[");
 127 }
 128
 129 void yll_emitter_end_seq(YllEmitter *e)
 130 {
 131     YllSeqNode *n = (YllSeqNode*) e->stack;
 132     if (F_ISSET(e->stack, YLL_INLINE_SEQ))
 133         fprintf(e->out, "]");
 134     else if (n->first) {
 135         if (F_ISSET(e->stack, YLL_ADD_SPACE))
 136             fprintf(e->out, " ");
 137         fprintf(e->out, "[]");
 138     }
 139     yll_pop(e);
 140 }
 141
 142 void yll_emitter_start_map(YllEmitter *e)
 143 {
 144     YllEmitterNode * n;
 145     e->stack->nextf(e);
 146     n = S_ALLOC(YllEmitterNode);
 147     n->nextf = next_map_key;
 148     yll_push(e, n);
 149     yll_emit_transfer(e);
 150 }
 151
 152 void yll_emitter_end_map(YllEmitter *e)
 153 {
 154     yll_pop(e);
 155 }
 156
 157 SYMID yll_emitter_anchor(YllEmitter *e)
 158 {
 159     YllAnchorNode * n;
 160     SYMID a = ++e->last_anchor;
 161     n = S_ALLOC(YllAnchorNode);
 162     n->anchor = a;
 163     n->en.nextf = next_anchor;
 164     yll_push(e, (YllEmitterNode *)n);
 165     return a;
 166 }
 167
 168 void yll_emitter_alias(YllEmitter *e, SYMID id)
 169 {
 170     e->stack->nextf(e);
 171     fprintf(e->out, "*%d", id);
 172 }
 173
 174 void yll_emitter_write_string(YllEmitter *e, const char *str)
 175 {
 176     e->stack->nextf(e);
 177     yll_emit_transfer(e);
 178     yll_emit_space(e);
 179     if (strpbrk(str, "[]#:-"))
 180         fputc('"', e->out);
 181     fprintf(e->out, "%s", str);
 182     if (strpbrk(str, "[]#:-"))
 183         fputc('"', e->out);
 184 }
 185
 186 void yll_emitter_write_int(YllEmitter *e, int i)
 187 {
 188     e->stack->nextf(e);
 189     yll_emit_transfer(e);
 190     yll_emit_space(e);
 191     fprintf(e->out, "%d", i);
 192 }
 193
 194 void yll_emitter_write_null(YllEmitter *e)
 195 {
 196     e->stack->nextf(e);
 197     yll_emit_transfer(e);
 198     yll_emit_space(e);
 199     fprintf(e->out, "~");
 200 }
 201
 202 void yll_emitter_set_options(YllEmitter *e, YllOption o)
 203 {
 204     F_SET(e, o);
 205 }
 206
 207 void yll_emitter_set_transfer(YllEmitter *e, const char *t)
 208 {
 209     e->transfer = t;
 210 }