immunio 1.1.13 → 1.1.15

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

@@ -1,5 +1,5 @@
 /*  
-** $Id: lptree.h,v 1.2 2013/03/24 13:51:12 roberto Exp $
+** $Id: lptree.h,v 1.3 2016/09/13 18:07:51 roberto Exp $
 */
 
 #if !defined(lptree_h)
@@ -13,38 +13,43 @@
 ** types of trees
 */
 typedef enum TTag {
-  TChar = 0, TSet, TAny,  /* standard PEG elements */
-  TTrue, TFalse,
-  TRep,
-  TSeq, TChoice,
-  TNot, TAnd,
-  TCall,
-  TOpenCall,
-  TRule,  /* sib1 is rule's pattern, sib2 is 'next' rule */
-  TGrammar,  /* sib1 is initial (and first) rule */
-  TBehind,  /* match behind */
-  TCapture,  /* regular capture */
-  TRunTime  /* run-time capture */
+  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;
 
-/* number of siblings for each tree */
-extern const byte numsiblings[];
-
 
 /*
 ** Tree trees
-** The first sibling of a tree (if there is one) is immediately after
-** the tree.  A reference to a second sibling (ps) is its position
-** relative to the position of the tree itself.  A key in ktable
-** uses the (unique) address of the original tree that created that
-** entry. NULL means no data.
+** 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 sibling */
+    int ps;  /* occasional second child */
     int n;  /* occasional counter */
   } u;
 } TTree;
@@ -55,16 +60,16 @@ typedef struct TTree {
 ** its corresponding code
 */
 typedef struct Pattern {
-  union LpegInstruction *code;
+  union Instruction *code;
   int codesize;
   TTree tree[1];
 } Pattern;
 
 
-/* number of siblings for each tree */
+/* number of children for each tree */
 extern const byte numsiblings[];
 
-/* access to siblings */
+/* access to children */
 #define sib1(t)         ((t) + 1)
 #define sib2(t)         ((t) + (t)->u.ps)
 

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

@@ -1,7 +1,7 @@
 /*
-** $Id: lptypes.h,v 1.10 2014/12/12 17:11:35 roberto Exp $
+** $Id: lptypes.h,v 1.16 2017/01/13 13:33:17 roberto Exp $
 ** LPeg - PEG pattern matching for Lua
-** Copyright 2007-2014, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
+** Copyright 2007-2017, Lua.org & PUC-Rio  (see 'lpeg.html' for license)
 ** written by Roberto Ierusalimschy
 */
 
@@ -19,7 +19,7 @@
 #include "lua.h"
 
 
-#define VERSION         "0.12.1"
+#define VERSION         "1.0.1"
 
 
 #define PATTERN_T	"lpeg-pattern"
@@ -27,37 +27,37 @@
 
 
 /*
-** compatibility with Lua 5.2
+** compatibility with Lua 5.1
 */
-#if (LUA_VERSION_NUM >= 502)
+#if (LUA_VERSION_NUM == 501)
 
-#undef lua_equal
-#define lua_equal(L,idx1,idx2)  lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#define lp_equal	lua_equal
 
-#undef lua_getfenv
-#define lua_getfenv	lua_getuservalue
-#undef lua_setfenv
-#define lua_setfenv	lua_setuservalue
+#define lua_getuservalue	lua_getfenv
+#define lua_setuservalue	lua_setfenv
 
-#undef lua_objlen
-#define lua_objlen	lua_rawlen
+#define lua_rawlen		lua_objlen
 
-#undef luaL_register
-#define luaL_register(L,n,f) \
-	{ if ((n) == NULL) luaL_setfuncs(L,f,0); else luaL_newlib(L,f); }
+#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         100
+#define MAXBACK         400
 #endif
 
 
-/* maximum number of rules in a grammar */
+/* maximum number of rules in a grammar (limited by 'unsigned char') */
 #if !defined(MAXRULES)
-#define MAXRULES        1000
+#define MAXRULES        250
 #endif
 
 
@@ -111,7 +111,7 @@ typedef struct Charset {
 
 
 /*
-** in capture LpegInstructions, 'kind' of capture and its offset are
+** 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)
@@ -130,14 +130,14 @@ typedef struct Charset {
 #define MAXPATTSIZE	(SHRT_MAX - 10)
 
 
-/* size (in elements) for an LpegInstruction plus extra l bytes */
-#define instsize(l)  (((l) + sizeof(LpegInstruction) - 1)/sizeof(LpegInstruction) + 1)
+/* 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 LpegInstruction */
+/* size (in elements) for a ISet instruction */
 #define CHARSETINSTSIZE		instsize(CHARSETSIZE)
 
-/* size (in elements) for a IFunc LpegInstruction */
+/* size (in elements) for a IFunc instruction */
 #define funcinstsize(p)		((p)->i.aux + 2)
 
 

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

@@ -1,5 +1,5 @@
 /*
-** $Id: lpvm.c,v 1.5 2013/04/12 16:29:49 roberto Exp $
+** $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)
 */
 
@@ -18,13 +18,13 @@
 
 /* initial size for call/backtrack stack */
 #if !defined(INITBACK)
-#define INITBACK	100
+#define INITBACK	MAXBACK
 #endif
 
 
 #define getoffset(p)	(((p) + 1)->offset)
 
-static const LpegInstruction giveup = {{IGiveup, 0, 0}};
+static const Instruction giveup = {{IGiveup, 0, 0}};
 
 
 /*
@@ -36,7 +36,7 @@ static const LpegInstruction giveup = {{IGiveup, 0, 0}};
 
 typedef struct Stack {
   const char *s;  /* saved position (or NULL for calls) */
-  const LpegInstruction *p;  /* next LpegInstruction */
+  const Instruction *p;  /* next instruction */
   int caplevel;
 } Stack;
 
@@ -45,14 +45,16 @@ typedef struct Stack {
 
 
 /*
-** Double the size of the array of captures
+** 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 ptop) {
+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 * sizeof(Capture));
+  memcpy(newc, cap, (captop - n) * sizeof(Capture));
   lua_replace(L, caplistidx(ptop));
   return newc;
 }
@@ -70,7 +72,7 @@ static Stack *doublestack (lua_State *L, Stack **stacklimit, int ptop) {
   max = lua_tointeger(L, -1);  /* maximum allowed size */
   lua_pop(L, 1);
   if (n >= max)  /* already at maximum size? */
-    luaL_error(L, "too many pending calls/choices");
+    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));
@@ -113,8 +115,8 @@ static int resdyncaptures (lua_State *L, int fr, int curr, int limit) {
 */
 static void adddyncaptures (const char *s, Capture *base, int n, int fd) {
   int i;
-  /* Cgroup capture is already there */
-  assert(base[0].kind == Cgroup && base[0].siz == 0);
+  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;
@@ -144,23 +146,24 @@ static int removedyncap (lua_State *L, Capture *capture,
 /*
 ** Opcode interpreter
 */
-const char *lpeg_match (lua_State *L, const char *o, const char *s, const char *e,
-                   LpegInstruction *op, Capture *capture, int ptop) {
+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 LpegInstruction *p = op;  /* current LpegInstruction */
+  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, stack - getstackbase(L, ptop), ndyncap, captop);
+             s, (int)(stack - getstackbase(L, ptop)), ndyncap, captop);
       printinst(op, p);
-      printcaplist(capture, capture + captop);
 #endif
     assert(stackidx(ptop) + ndyncap == lua_gettop(L) && ndyncap <= captop);
     switch ((Opcode)p->i.code) {
@@ -284,6 +287,9 @@ const char *lpeg_match (lua_State *L, const char *o, const char *s, const char *
           ndyncap -= removedyncap(L, capture, stack->caplevel, captop);
         captop = stack->caplevel;
         p = stack->p;
+#if defined(DEBUG)
+        printf("**FAIL**\n");
+#endif
         continue;
       }
       case ICloseRunTime: {
@@ -293,16 +299,19 @@ const char *lpeg_match (lua_State *L, const char *o, const char *s, const char *
         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 - rem;  /* update number of dynamic 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, ptop);
+            capture = doublecap(L, capture, captop, n + 2, ptop);
             capsize = 2 * captop;
           }
           /* add new captures to 'capture' list */
@@ -339,7 +348,7 @@ const char *lpeg_match (lua_State *L, const char *o, const char *s, const char *
         capture[captop].idx = p->i.key;
         capture[captop].kind = getkind(p);
         if (++captop >= capsize) {
-          capture = doublecap(L, capture, captop, ptop);
+          capture = doublecap(L, capture, captop, 0, ptop);
           capsize = 2 * captop;
         }
         p++;

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

@@ -8,7 +8,7 @@
 #include "lpcap.h"
 
 
-/* Virtual Machine's LpegInstructions */
+/* Virtual Machine's instructions */
 typedef enum Opcode {
   IAny, /* if no char, fail */
   IChar,  /* if char != aux, fail */
@@ -38,7 +38,7 @@ typedef enum Opcode {
 
 
 
-typedef union LpegInstruction {
+typedef union Instruction {
   struct Inst {
     byte code;
     byte aux;
@@ -46,12 +46,12 @@ typedef union LpegInstruction {
   } i;
   int offset;
   byte buff[1];
-} LpegInstruction;
+} Instruction;
 
 
-void printpatt (LpegInstruction *p, int n);
-const char *lpeg_match (lua_State *L, const char *o, const char *s, const char *e,
-                   LpegInstruction *op, Capture *capture, int ptop);
+void printpatt (Instruction *p, int n);
+const char *match (lua_State *L, const char *o, const char *s, const char *e,
+                   Instruction *op, Capture *capture, int ptop);
 
 
 #endif

data/lua-hooks/ext/lpeg/re.html

@@ -10,7 +10,7 @@
 </head>
 <body>
 
-<!-- $Id: re.html,v 1.21 2013/03/28 20:43:30 roberto Exp $ -->
+<!-- $Id: re.html,v 1.24 2016/09/20 17:41:27 roberto Exp $ -->
 
 <div id="container">
 	
@@ -296,7 +296,7 @@ it would be useful if each table had
 a <code>tag</code> field telling what non terminal
 that table represents.
 We can add such a tag using
-<a href="lpeg.html/#cap-g">named group captures</a>:
+<a href="lpeg.html#cap-g">named group captures</a>:
 </p>
 <pre class="example">
 x = re.compile[[
@@ -406,7 +406,7 @@ of patterns accepted by <code>re</code>.
 p = [=[
 
 pattern         &lt;- exp !.
-exp             &lt;- S (alternative / grammar)
+exp             &lt;- S (grammar / alternative)
 
 alternative     &lt;- seq ('/' S seq)*
 seq             &lt;- prefix*
@@ -450,7 +450,7 @@ print(re.match(p, p))   -- a self description must match itself
 <h2><a name="license">License</a></h2>
 
 <p>
-Copyright &copy; 2008-2010 Lua.org, PUC-Rio.
+Copyright &copy; 2008-2015 Lua.org, PUC-Rio.
 </p>
 <p>
 Permission is hereby granted, free of charge,
@@ -488,7 +488,7 @@ THE SOFTWARE.
 
 <div id="about">
 <p><small>
-$Id: re.html,v 1.21 2013/03/28 20:43:30 roberto Exp $
+$Id: re.html,v 1.24 2016/09/20 17:41:27 roberto Exp $
 </small></p>
 </div> <!-- id="about" -->
 

data/lua-hooks/ext/luajit/src/lib_init.c

@@ -9,6 +9,10 @@
 #define lib_init_c
 #define LUA_LIB
 
+/*
+luaL_openlibs is overridden in ext/all.c.
+This file is commented to prevent duplicated symbols.
+
 #include "lua.h"
 #include "lauxlib.h"
 #include "lualib.h"
@@ -16,24 +20,24 @@
 #include "lj_arch.h"
 
 static const luaL_Reg lj_lib_load[] = {
-  { "",			luaopen_base },
-  { LUA_LOADLIBNAME,	luaopen_package },
-  { LUA_TABLIBNAME,	luaopen_table },
-  { LUA_IOLIBNAME,	luaopen_io },
-  { LUA_OSLIBNAME,	luaopen_os },
-  { LUA_STRLIBNAME,	luaopen_string },
-  { LUA_MATHLIBNAME,	luaopen_math },
-  { LUA_DBLIBNAME,	luaopen_debug },
-  { LUA_BITLIBNAME,	luaopen_bit },
-  { LUA_JITLIBNAME,	luaopen_jit },
-  { NULL,		NULL }
+  { "",     luaopen_base },
+  { LUA_LOADLIBNAME,  luaopen_package },
+  { LUA_TABLIBNAME, luaopen_table },
+  { LUA_IOLIBNAME,  luaopen_io },
+  { LUA_OSLIBNAME,  luaopen_os },
+  { LUA_STRLIBNAME, luaopen_string },
+  { LUA_MATHLIBNAME,  luaopen_math },
+  { LUA_DBLIBNAME,  luaopen_debug },
+  { LUA_BITLIBNAME, luaopen_bit },
+  { LUA_JITLIBNAME, luaopen_jit },
+  { NULL,   NULL }
 };
 
 static const luaL_Reg lj_lib_preload[] = {
 #if LJ_HASFFI
-  { LUA_FFILIBNAME,	luaopen_ffi },
+  { LUA_FFILIBNAME, luaopen_ffi },
 #endif
-  { NULL,		NULL }
+  { NULL,   NULL }
 };
 
 LUALIB_API void luaL_openlibs(lua_State *L)
@@ -45,11 +49,11 @@ LUALIB_API void luaL_openlibs(lua_State *L)
     lua_call(L, 1, 0);
   }
   luaL_findtable(L, LUA_REGISTRYINDEX, "_PRELOAD",
-		 sizeof(lj_lib_preload)/sizeof(lj_lib_preload[0])-1);
+     sizeof(lj_lib_preload)/sizeof(lj_lib_preload[0])-1);
   for (lib = lj_lib_preload; lib->func; lib++) {
     lua_pushcfunction(L, lib->func);
     lua_setfield(L, -2, lib->name);
   }
   lua_pop(L, 1);
 }
-
+*/