immunio 1.2.1 → 2.0.2

data/lua-hooks/ext/lpeg/lptree.h

@@ -1,82 +0,0 @@
-/*  
-** $Id: lptree.h,v 1.3 2016/09/13 18:07:51 roberto Exp $
-*/
-
-#if !defined(lptree_h)
-#define lptree_h
-
-
-#include "lptypes.h" 
-
-
-/*
-** types of trees
-*/
-typedef enum TTag {
-  TChar = 0,  /* 'n' = char */
-  TSet,  /* the set is stored in next CHARSETSIZE bytes */
-  TAny,
-  TTrue,
-  TFalse,
-  TRep,  /* 'sib1'* */
-  TSeq,  /* 'sib1' 'sib2' */
-  TChoice,  /* 'sib1' / 'sib2' */
-  TNot,  /* !'sib1' */
-  TAnd,  /* &'sib1' */
-  TCall,  /* ktable[key] is rule's key; 'sib2' is rule being called */
-  TOpenCall,  /* ktable[key] is rule's key */
-  TRule,  /* ktable[key] is rule's key (but key == 0 for unused rules);
-             'sib1' is rule's pattern;
-             'sib2' is next rule; 'cap' is rule's sequential number */
-  TGrammar,  /* 'sib1' is initial (and first) rule */
-  TBehind,  /* 'sib1' is pattern, 'n' is how much to go back */
-  TCapture,  /* captures: 'cap' is kind of capture (enum 'CapKind');
-                ktable[key] is Lua value associated with capture;
-                'sib1' is capture body */
-  TRunTime  /* run-time capture: 'key' is Lua function;
-               'sib1' is capture body */
-} TTag;
-
-
-/*
-** Tree trees
-** The first child of a tree (if there is one) is immediately after
-** the tree.  A reference to a second child (ps) is its position
-** relative to the position of the tree itself.
-*/
-typedef struct TTree {
-  byte tag;
-  byte cap;  /* kind of capture (if it is a capture) */
-  unsigned short key;  /* key in ktable for Lua data (0 if no key) */
-  union {
-    int ps;  /* occasional second child */
-    int n;  /* occasional counter */
-  } u;
-} TTree;
-
-
-/*
-** A complete pattern has its tree plus, if already compiled,
-** its corresponding code
-*/
-typedef struct Pattern {
-  union Instruction *code;
-  int codesize;
-  TTree tree[1];
-} Pattern;
-
-
-/* number of children for each tree */
-extern const byte numsiblings[];
-
-/* access to children */
-#define sib1(t)         ((t) + 1)
-#define sib2(t)         ((t) + (t)->u.ps)
-
-
-
-
-
-
-#endif
-

data/lua-hooks/ext/lpeg/lptypes.h

@@ -1,149 +0,0 @@
-/*
-** $Id: lptypes.h,v 1.16 2017/01/13 13:33:17 roberto Exp $
-** LPeg - PEG pattern matching for Lua
-** Copyright 2007-2017, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
-** written by Roberto Ierusalimschy
-*/
-
-#if !defined(lptypes_h)
-#define lptypes_h
-
-
-#if !defined(LPEG_DEBUG)
-#define NDEBUG
-#endif
-
-#include <assert.h>
-#include <limits.h>
-
-#include "lua.h"
-
-
-#define VERSION         "1.0.1"
-
-
-#define PATTERN_T	"lpeg-pattern"
-#define MAXSTACKIDX	"lpeg-maxstack"
-
-
-/*
-** compatibility with Lua 5.1
-*/
-#if (LUA_VERSION_NUM == 501)
-
-#define lp_equal	lua_equal
-
-#define lua_getuservalue	lua_getfenv
-#define lua_setuservalue	lua_setfenv
-
-#define lua_rawlen		lua_objlen
-
-#define luaL_setfuncs(L,f,n)	luaL_register(L,NULL,f)
-#define luaL_newlib(L,f)	luaL_register(L,"lpeg",f)
-
-#endif
-
-
-#if !defined(lp_equal)
-#define lp_equal(L,idx1,idx2)  lua_compare(L,(idx1),(idx2),LUA_OPEQ)
-#endif
-
-
-/* default maximum size for call/backtrack stack */
-#if !defined(MAXBACK)
-#define MAXBACK         400
-#endif
-
-
-/* maximum number of rules in a grammar (limited by 'unsigned char') */
-#if !defined(MAXRULES)
-#define MAXRULES        250
-#endif
-
-
-
-/* initial size for capture's list */
-#define INITCAPSIZE	32
-
-
-/* index, on Lua stack, for subject */
-#define SUBJIDX		2
-
-/* number of fixed arguments to 'match' (before capture arguments) */
-#define FIXEDARGS	3
-
-/* index, on Lua stack, for capture list */
-#define caplistidx(ptop)	((ptop) + 2)
-
-/* index, on Lua stack, for pattern's ktable */
-#define ktableidx(ptop)		((ptop) + 3)
-
-/* index, on Lua stack, for backtracking stack */
-#define stackidx(ptop)	((ptop) + 4)
-
-
-
-typedef unsigned char byte;
-
-
-#define BITSPERCHAR		8
-
-#define CHARSETSIZE		((UCHAR_MAX/BITSPERCHAR) + 1)
-
-
-
-typedef struct Charset {
-  byte cs[CHARSETSIZE];
-} Charset;
-
-
-
-#define loopset(v,b)    { int v; for (v = 0; v < CHARSETSIZE; v++) {b;} }
-
-/* access to charset */
-#define treebuffer(t)      ((byte *)((t) + 1))
-
-/* number of slots needed for 'n' bytes */
-#define bytes2slots(n)  (((n) - 1) / sizeof(TTree) + 1)
-
-/* set 'b' bit in charset 'cs' */
-#define setchar(cs,b)   ((cs)[(b) >> 3] |= (1 << ((b) & 7)))
-
-
-/*
-** in capture instructions, 'kind' of capture and its offset are
-** packed in field 'aux', 4 bits for each
-*/
-#define getkind(op)		((op)->i.aux & 0xF)
-#define getoff(op)		(((op)->i.aux >> 4) & 0xF)
-#define joinkindoff(k,o)	((k) | ((o) << 4))
-
-#define MAXOFF		0xF
-#define MAXAUX		0xFF
-
-
-/* maximum number of bytes to look behind */
-#define MAXBEHIND	MAXAUX
-
-
-/* maximum size (in elements) for a pattern */
-#define MAXPATTSIZE	(SHRT_MAX - 10)
-
-
-/* size (in elements) for an instruction plus extra l bytes */
-#define instsize(l)  (((l) + sizeof(Instruction) - 1)/sizeof(Instruction) + 1)
-
-
-/* size (in elements) for a ISet instruction */
-#define CHARSETINSTSIZE		instsize(CHARSETSIZE)
-
-/* size (in elements) for a IFunc instruction */
-#define funcinstsize(p)		((p)->i.aux + 2)
-
-
-
-#define testchar(st,c)	(((int)(st)[((c) >> 3)] & (1 << ((c) & 7))))
-
-
-#endif
-

data/lua-hooks/ext/lpeg/lpvm.c

@@ -1,364 +0,0 @@
-/*
-** $Id: lpvm.c,v 1.9 2016/06/03 20:11:18 roberto Exp $
-** Copyright 2007, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
-*/
-
-#include <limits.h>
-#include <string.h>
-
-
-#include "lua.h"
-#include "lauxlib.h"
-
-#include "lpcap.h"
-#include "lptypes.h"
-#include "lpvm.h"
-#include "lpprint.h"
-
-
-/* initial size for call/backtrack stack */
-#if !defined(INITBACK)
-#define INITBACK	MAXBACK
-#endif
-
-
-#define getoffset(p)	(((p) + 1)->offset)
-
-static const Instruction giveup = {{IGiveup, 0, 0}};
-
-
-/*
-** {======================================================
-** Virtual Machine
-** =======================================================
-*/
-
-
-typedef struct Stack {
-  const char *s;  /* saved position (or NULL for calls) */
-  const Instruction *p;  /* next instruction */
-  int caplevel;
-} Stack;
-
-
-#define getstackbase(L, ptop)	((Stack *)lua_touserdata(L, stackidx(ptop)))
-
-
-/*
-** Make the size of the array of captures 'cap' twice as large as needed
-** (which is 'captop'). ('n' is the number of new elements.)
-*/
-static Capture *doublecap (lua_State *L, Capture *cap, int captop,
-                                         int n, int ptop) {
-  Capture *newc;
-  if (captop >= INT_MAX/((int)sizeof(Capture) * 2))
-    luaL_error(L, "too many captures");
-  newc = (Capture *)lua_newuserdata(L, captop * 2 * sizeof(Capture));
-  memcpy(newc, cap, (captop - n) * sizeof(Capture));
-  lua_replace(L, caplistidx(ptop));
-  return newc;
-}
-
-
-/*
-** Double the size of the stack
-*/
-static Stack *doublestack (lua_State *L, Stack **stacklimit, int ptop) {
-  Stack *stack = getstackbase(L, ptop);
-  Stack *newstack;
-  int n = *stacklimit - stack;  /* current stack size */
-  int max, newn;
-  lua_getfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX);
-  max = lua_tointeger(L, -1);  /* maximum allowed size */
-  lua_pop(L, 1);
-  if (n >= max)  /* already at maximum size? */
-    luaL_error(L, "backtrack stack overflow (current limit is %d)", max);
-  newn = 2 * n;  /* new size */
-  if (newn > max) newn = max;
-  newstack = (Stack *)lua_newuserdata(L, newn * sizeof(Stack));
-  memcpy(newstack, stack, n * sizeof(Stack));
-  lua_replace(L, stackidx(ptop));
-  *stacklimit = newstack + newn;
-  return newstack + n;  /* return next position */
-}
-
-
-/*
-** Interpret the result of a dynamic capture: false -> fail;
-** true -> keep current position; number -> next position.
-** Return new subject position. 'fr' is stack index where
-** is the result; 'curr' is current subject position; 'limit'
-** is subject's size.
-*/
-static int resdyncaptures (lua_State *L, int fr, int curr, int limit) {
-  lua_Integer res;
-  if (!lua_toboolean(L, fr)) {  /* false value? */
-    lua_settop(L, fr - 1);  /* remove results */
-    return -1;  /* and fail */
-  }
-  else if (lua_isboolean(L, fr))  /* true? */
-    res = curr;  /* keep current position */
-  else {
-    res = lua_tointeger(L, fr) - 1;  /* new position */
-    if (res < curr || res > limit)
-      luaL_error(L, "invalid position returned by match-time capture");
-  }
-  lua_remove(L, fr);  /* remove first result (offset) */
-  return res;
-}
-
-
-/*
-** Add capture values returned by a dynamic capture to the capture list
-** 'base', nested inside a group capture. 'fd' indexes the first capture
-** value, 'n' is the number of values (at least 1).
-*/
-static void adddyncaptures (const char *s, Capture *base, int n, int fd) {
-  int i;
-  base[0].kind = Cgroup;  /* create group capture */
-  base[0].siz = 0;
-  base[0].idx = 0;  /* make it an anonymous group */
-  for (i = 1; i <= n; i++) {  /* add runtime captures */
-    base[i].kind = Cruntime;
-    base[i].siz = 1;  /* mark it as closed */
-    base[i].idx = fd + i - 1;  /* stack index of capture value */
-    base[i].s = s;
-  }
-  base[i].kind = Cclose;  /* close group */
-  base[i].siz = 1;
-  base[i].s = s;
-}
-
-
-/*
-** Remove dynamic captures from the Lua stack (called in case of failure)
-*/
-static int removedyncap (lua_State *L, Capture *capture,
-                         int level, int last) {
-  int id = finddyncap(capture + level, capture + last);  /* index of 1st cap. */
-  int top = lua_gettop(L);
-  if (id == 0) return 0;  /* no dynamic captures? */
-  lua_settop(L, id - 1);  /* remove captures */
-  return top - id + 1;  /* number of values removed */
-}
-
-
-/*
-** Opcode interpreter
-*/
-const char *match (lua_State *L, const char *o, const char *s, const char *e,
-                   Instruction *op, Capture *capture, int ptop) {
-  Stack stackbase[INITBACK];
-  Stack *stacklimit = stackbase + INITBACK;
-  Stack *stack = stackbase;  /* point to first empty slot in stack */
-  int capsize = INITCAPSIZE;
-  int captop = 0;  /* point to first empty slot in captures */
-  int ndyncap = 0;  /* number of dynamic captures (in Lua stack) */
-  const Instruction *p = op;  /* current instruction */
-  stack->p = &giveup; stack->s = s; stack->caplevel = 0; stack++;
-  lua_pushlightuserdata(L, stackbase);
-  for (;;) {
-#if defined(DEBUG)
-      printf("-------------------------------------\n");
-      printcaplist(capture, capture + captop);
-      printf("s: |%s| stck:%d, dyncaps:%d, caps:%d  ",
-             s, (int)(stack - getstackbase(L, ptop)), ndyncap, captop);
-      printinst(op, p);
-#endif
-    assert(stackidx(ptop) + ndyncap == lua_gettop(L) && ndyncap <= captop);
-    switch ((Opcode)p->i.code) {
-      case IEnd: {
-        assert(stack == getstackbase(L, ptop) + 1);
-        capture[captop].kind = Cclose;
-        capture[captop].s = NULL;
-        return s;
-      }
-      case IGiveup: {
-        assert(stack == getstackbase(L, ptop));
-        return NULL;
-      }
-      case IRet: {
-        assert(stack > getstackbase(L, ptop) && (stack - 1)->s == NULL);
-        p = (--stack)->p;
-        continue;
-      }
-      case IAny: {
-        if (s < e) { p++; s++; }
-        else goto fail;
-        continue;
-      }
-      case ITestAny: {
-        if (s < e) p += 2;
-        else p += getoffset(p);
-        continue;
-      }
-      case IChar: {
-        if ((byte)*s == p->i.aux && s < e) { p++; s++; }
-        else goto fail;
-        continue;
-      }
-      case ITestChar: {
-        if ((byte)*s == p->i.aux && s < e) p += 2;
-        else p += getoffset(p);
-        continue;
-      }
-      case ISet: {
-        int c = (byte)*s;
-        if (testchar((p+1)->buff, c) && s < e)
-          { p += CHARSETINSTSIZE; s++; }
-        else goto fail;
-        continue;
-      }
-      case ITestSet: {
-        int c = (byte)*s;
-        if (testchar((p + 2)->buff, c) && s < e)
-          p += 1 + CHARSETINSTSIZE;
-        else p += getoffset(p);
-        continue;
-      }
-      case IBehind: {
-        int n = p->i.aux;
-        if (n > s - o) goto fail;
-        s -= n; p++;
-        continue;
-      }
-      case ISpan: {
-        for (; s < e; s++) {
-          int c = (byte)*s;
-          if (!testchar((p+1)->buff, c)) break;
-        }
-        p += CHARSETINSTSIZE;
-        continue;
-      }
-      case IJmp: {
-        p += getoffset(p);
-        continue;
-      }
-      case IChoice: {
-        if (stack == stacklimit)
-          stack = doublestack(L, &stacklimit, ptop);
-        stack->p = p + getoffset(p);
-        stack->s = s;
-        stack->caplevel = captop;
-        stack++;
-        p += 2;
-        continue;
-      }
-      case ICall: {
-        if (stack == stacklimit)
-          stack = doublestack(L, &stacklimit, ptop);
-        stack->s = NULL;
-        stack->p = p + 2;  /* save return address */
-        stack++;
-        p += getoffset(p);
-        continue;
-      }
-      case ICommit: {
-        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
-        stack--;
-        p += getoffset(p);
-        continue;
-      }
-      case IPartialCommit: {
-        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
-        (stack - 1)->s = s;
-        (stack - 1)->caplevel = captop;
-        p += getoffset(p);
-        continue;
-      }
-      case IBackCommit: {
-        assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL);
-        s = (--stack)->s;
-        captop = stack->caplevel;
-        p += getoffset(p);
-        continue;
-      }
-      case IFailTwice:
-        assert(stack > getstackbase(L, ptop));
-        stack--;
-        /* go through */
-      case IFail:
-      fail: { /* pattern failed: try to backtrack */
-        do {  /* remove pending calls */
-          assert(stack > getstackbase(L, ptop));
-          s = (--stack)->s;
-        } while (s == NULL);
-        if (ndyncap > 0)  /* is there matchtime captures? */
-          ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
-        captop = stack->caplevel;
-        p = stack->p;
-#if defined(DEBUG)
-        printf("**FAIL**\n");
-#endif
-        continue;
-      }
-      case ICloseRunTime: {
-        CapState cs;
-        int rem, res, n;
-        int fr = lua_gettop(L) + 1;  /* stack index of first result */
-        cs.s = o; cs.L = L; cs.ocap = capture; cs.ptop = ptop;
-        n = runtimecap(&cs, capture + captop, s, &rem);  /* call function */
-        captop -= n;  /* remove nested captures */
-        ndyncap -= rem;  /* update number of dynamic captures */
-        fr -= rem;  /* 'rem' items were popped from Lua stack */
-        res = resdyncaptures(L, fr, s - o, e - o);  /* get result */
-        if (res == -1)  /* fail? */
-          goto fail;
-        s = o + res;  /* else update current position */
-        n = lua_gettop(L) - fr + 1;  /* number of new captures */
-        ndyncap += n;  /* update number of dynamic captures */
-        if (n > 0) {  /* any new capture? */
-          if (fr + n >= SHRT_MAX)
-            luaL_error(L, "too many results in match-time capture");
-          if ((captop += n + 2) >= capsize) {
-            capture = doublecap(L, capture, captop, n + 2, ptop);
-            capsize = 2 * captop;
-          }
-          /* add new captures to 'capture' list */
-          adddyncaptures(s, capture + captop - n - 2, n, fr); 
-        }
-        p++;
-        continue;
-      }
-      case ICloseCapture: {
-        const char *s1 = s;
-        assert(captop > 0);
-        /* if possible, turn capture into a full capture */
-        if (capture[captop - 1].siz == 0 &&
-            s1 - capture[captop - 1].s < UCHAR_MAX) {
-          capture[captop - 1].siz = s1 - capture[captop - 1].s + 1;
-          p++;
-          continue;
-        }
-        else {
-          capture[captop].siz = 1;  /* mark entry as closed */
-          capture[captop].s = s;
-          goto pushcapture;
-        }
-      }
-      case IOpenCapture:
-        capture[captop].siz = 0;  /* mark entry as open */
-        capture[captop].s = s;
-        goto pushcapture;
-      case IFullCapture:
-        capture[captop].siz = getoff(p) + 1;  /* save capture size */
-        capture[captop].s = s - getoff(p);
-        /* goto pushcapture; */
-      pushcapture: {
-        capture[captop].idx = p->i.key;
-        capture[captop].kind = getkind(p);
-        if (++captop >= capsize) {
-          capture = doublecap(L, capture, captop, 0, ptop);
-          capsize = 2 * captop;
-        }
-        p++;
-        continue;
-      }
-      default: assert(0); return NULL;
-    }
-  }
-}
-
-/* }====================================================== */
-
-