Implement implicit "OR".

If an identifier is given without a keyword, the most recent keyword is assumed. For example,

   not host vs and ace

is short for

   not host vs and host ace

Which should not be confused with

   not ( host vs or ace )

This patch fixes issue #17.

src/pf/parse.lua

@@ -216,12 +216,15 @@ local function tokens(str)
       local tok = next(opts)
       assert(tok == expected, "expected "..expected..", got: "..tok)
    end
+   local function put(tok)
+      str = string.sub(str, 1, pos - 1)..tok..string.sub(str, pos + 1)
+   end
    local function check(expected, opts)
       if peek(opts) ~= expected then return false end
       next()
       return true
    end
-   return { peek = peek, next = next, consume = consume, check = check }
+   return { peek = peek, next = next, consume = consume, check = check, put = put }
 end
 
 local addressables = set(
@@ -619,6 +622,16 @@ function parse_arithmetic(lexer, tok, max_precedence, parsed_exp)
    end
 end
 
+local last_keyword = (function()
+   local keyword = nil
+   return function(arg)
+      if arg ~= nil then
+         keyword = arg
+      end
+      return keyword
+   end
+end)()
+
 local function parse_primitive_or_arithmetic(lexer)
    local tok = lexer.next({maybe_arithmetic=true})
    if (type(tok) == 'number' or tok == 'len' or
@@ -627,15 +640,18 @@ local function parse_primitive_or_arithmetic(lexer)
    end
 
    local parser = primitives[tok]
-   if parser then return parser(lexer, tok) end
+   if parser then
+      last_keyword(tok)
+      return parser(lexer, tok)
+   else
+      lexer.put(tok)
+      local parser = primitives[last_keyword()]
+      if parser then
+         return parser(lexer, last_keyword())
+      end
+   end
 
-   -- At this point the official pcap grammar is squirrely.  It says:
-   -- "If an identifier is given without a keyword, the most recent
-   -- keyword is assumed.  For example, `not host vs and ace' is
-   -- short for `not host vs and host ace` and which should not be
-   -- confused with `not (host vs or ace)`."  For now we punt on this
-   -- part of the grammar.
-   error("keyword elision not implemented "..tok)
+   error(string.format("Unexpected token: %s", tok))
 end
 
 local logical_precedence = {
@@ -703,6 +719,7 @@ function parse(str)
    if not lexer.peek({maybe_arithmetic=true}) then return { 'true' } end
    local expr = parse_logical(lexer)
    assert(not lexer.peek(), "unexpected token", lexer.peek())
+   last_keyword("")
    return expr
 end
 
@@ -788,5 +805,9 @@ function selftest ()
                     { "-", { "-", { "[ip]", 2, 1 },
                        { "<<", { "&", { "[ip]", 0, 1 }, 15 }, 2 } },
                     { ">>", { "&", { "[tcp]", 12, 1 }, 240 }, 2 } }, 0 } })
+   parse_test("not host vs and ace",
+              { 'not', { 'and', { 'host', 'vs' }, { 'host', 'ace' } } } )
+   parse_test("not ( host vs or ace )",
+              { 'not', { 'or', { 'host', 'vs' }, { 'host', 'ace' } } } )
    print("OK")
 end