mudgangster

lpprint.cc (5668B)

---

 /*
 ** $Id: lpprint.c,v 1.10 2016/09/13 16:06:03 roberto Exp $
 ** Copyright 2007, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
 */
 
 #include <ctype.h>
 #include <limits.h>
 #include <stdio.h>
 
 
 #include "lptypes.h"
 #include "lpprint.h"
 #include "lpcode.h"
 
 
 #if defined(LPEG_DEBUG)
 
 /*
 ** {======================================================
 ** Printing patterns (for debugging)
 ** =======================================================
 */
 
 
 void printcharset (const byte *st) {
   int i;
   printf("[");
   for (i = 0; i <= UCHAR_MAX; i++) {
     int first = i;
     while (testchar(st, i) && i <= UCHAR_MAX) i++;
     if (i - 1 == first)  /* unary range? */
       printf("(%02x)", first);
     else if (i - 1 > first)  /* non-empty range? */
       printf("(%02x-%02x)", first, i - 1);
   }
   printf("]");
 }
 
 
 static const char *capkind (int kind) {
   const char *const modes[] = {
     "close", "position", "constant", "backref",
     "argument", "simple", "table", "function",
     "query", "string", "num", "substitution", "fold",
     "runtime", "group"};
   return modes[kind];
 }
 
 
 static void printjmp (const Instruction *op, const Instruction *p) {
   printf("-> %d", (int)(p + (p + 1)->offset - op));
 }
 
 
 void printinst (const Instruction *op, const Instruction *p) {
   const char *const names[] = {
     "any", "char", "set",
     "testany", "testchar", "testset",
     "span", "behind",
     "ret", "end",
     "choice", "jmp", "call", "open_call",
     "commit", "partial_commit", "back_commit", "failtwice", "fail", "giveup",
      "fullcapture", "opencapture", "closecapture", "closeruntime"
   };
   printf("%02ld: %s ", (long)(p - op), names[p->i.code]);
   switch ((Opcode)p->i.code) {
     case IChar: {
       printf("'%c'", p->i.aux);
       break;
     }
     case ITestChar: {
       printf("'%c'", p->i.aux); printjmp(op, p);
       break;
     }
     case IFullCapture: {
       printf("%s (size = %d)  (idx = %d)",
              capkind(getkind(p)), getoff(p), p->i.key);
       break;
     }
     case IOpenCapture: {
       printf("%s (idx = %d)", capkind(getkind(p)), p->i.key);
       break;
     }
     case ISet: {
       printcharset((p+1)->buff);
       break;
     }
     case ITestSet: {
       printcharset((p+2)->buff); printjmp(op, p);
       break;
     }
     case ISpan: {
       printcharset((p+1)->buff);
       break;
     }
     case IOpenCall: {
       printf("-> %d", (p + 1)->offset);
       break;
     }
     case IBehind: {
       printf("%d", p->i.aux);
       break;
     }
     case IJmp: case ICall: case ICommit: case IChoice:
     case IPartialCommit: case IBackCommit: case ITestAny: {
       printjmp(op, p);
       break;
     }
     default: break;
   }
   printf("\n");
 }
 
 
 void printpatt (Instruction *p, int n) {
   Instruction *op = p;
   while (p < op + n) {
     printinst(op, p);
     p += sizei(p);
   }
 }
 
 
 #if defined(LPEG_DEBUG)
 static void printcap (Capture *cap) {
   printf("%s (idx: %d - size: %d) -> %p\n",
          capkind(cap->kind), cap->idx, cap->siz, cap->s);
 }
 
 
 void printcaplist (Capture *cap, Capture *limit) {
   printf(">======\n");
   for (; cap->s && (limit == NULL || cap < limit); cap++)
     printcap(cap);
   printf("=======\n");
 }
 #endif
 
 /* }====================================================== */
 
 
 /*
 ** {======================================================
 ** Printing trees (for debugging)
 ** =======================================================
 */
 
 static const char *tagnames[] = {
   "char", "set", "any",
   "true", "false",
   "rep",
   "seq", "choice",
   "not", "and",
   "call", "opencall", "rule", "grammar",
   "behind",
   "capture", "run-time"
 };
 
 
 void printtree (TTree *tree, int ident) {
   int i;
   for (i = 0; i < ident; i++) printf(" ");
   printf("%s", tagnames[tree->tag]);
   switch (tree->tag) {
     case TChar: {
       int c = tree->u.n;
       if (isprint(c))
         printf(" '%c'\n", c);
       else
         printf(" (%02X)\n", c);
       break;
     }
     case TSet: {
       printcharset(treebuffer(tree));
       printf("\n");
       break;
     }
     case TOpenCall: case TCall: {
       assert(sib2(tree)->tag == TRule);
       printf(" key: %d  (rule: %d)\n", tree->key, sib2(tree)->cap);
       break;
     }
     case TBehind: {
       printf(" %d\n", tree->u.n);
         printtree(sib1(tree), ident + 2);
       break;
     }
     case TCapture: {
       printf(" kind: '%s'  key: %d\n", capkind(tree->cap), tree->key);
       printtree(sib1(tree), ident + 2);
       break;
     }
     case TRule: {
       printf(" n: %d  key: %d\n", tree->cap, tree->key);
       printtree(sib1(tree), ident + 2);
       break;  /* do not print next rule as a sibling */
     }
     case TGrammar: {
       TTree *rule = sib1(tree);
       printf(" %d\n", tree->u.n);  /* number of rules */
       for (i = 0; i < tree->u.n; i++) {
         printtree(rule, ident + 2);
         rule = sib2(rule);
       }
       assert(rule->tag == TTrue);  /* sentinel */
       break;
     }
     default: {
       int sibs = numsiblings[tree->tag];
       printf("\n");
       if (sibs >= 1) {
         printtree(sib1(tree), ident + 2);
         if (sibs >= 2)
           printtree(sib2(tree), ident + 2);
       }
       break;
     }
   }
 }
 
 
 void printktable (lua_State *L, int idx) {
   int n, i;
   lua_getuservalue(L, idx);
   if (lua_isnil(L, -1))  /* no ktable? */
     return;
   n = lua_rawlen(L, -1);
   printf("[");
   for (i = 1; i <= n; i++) {
     printf("%d = ", i);
     lua_rawgeti(L, -1, i);
     if (lua_isstring(L, -1))
       printf("%s  ", lua_tostring(L, -1));
     else
       printf("%s  ", lua_typename(L, lua_type(L, -1)));
     lua_pop(L, 1);
   }
   printf("]\n");
   /* leave ktable at the stack */
 }
 
 /* }====================================================== */
 
 #endif