path: root/server/src/parser/grammar.lua

local re = require 'parser.relabel'
local m = require 'lpeglabel'
local calcline = require 'parser.calcline'

local scriptBuf = ''
local compiled = {}
local parser

local defs = setmetatable({}, {__index = function (self, key)
    self[key] = function (...)
        if parser[key] then
            return parser[key](...)
        end
    end
    return self[key]
end})

defs.nl = (m.P'\r\n' + m.S'\r\n') / function ()
    if parser.nl then
        return parser.nl()
    end
end
defs.s  = m.S' \t'
defs.S  = - defs.s
defs.ea = '\a'
defs.eb = '\b'
defs.ef = '\f'
defs.en = '\n'
defs.er = '\r'
defs.et = '\t'
defs.ev = '\v'
local eof = re.compile '!. / %{SYNTAX_ERROR}'

local function grammar(tag)
    return function (script)
        scriptBuf = script .. '\r\n' .. scriptBuf
        compiled[tag] = re.compile(scriptBuf, defs) * eof
    end
end

local labels = {

}

local function errorpos(lua, pos, err)
    local row, col = calcline.rowcol(lua, pos)
    local str = calcline.line(lua, row)
    return {
        lua = lua,
        line = row,
        pos = col,
        err = err,
        code = str,
        level = 'error',
    }
end

grammar 'Comment' [[
Comment         <-  '--' (LongComment / ShortComment)
LongComment     <-  '[' {:eq: '='* :} '[' CommentClose
CommentClose    <-  ']' =eq ']' / . CommentClose
ShortComment    <-  (!%nl .)*
]]

grammar 'Sp' [[
Sp  <-  (Comment / %nl / %s)*
]]

grammar 'Common' [[
Cut         <-  ![a-zA-Z0-9_]
X16         <-  [a-fA-F0-9]

AND         <-  Sp 'and'      Cut
BREAK       <-  Sp 'break'    Cut
DO          <-  Sp 'do'       Cut
ELSE        <-  Sp 'else'     Cut
ELSEIF      <-  Sp 'elseif'   Cut
END         <-  Sp 'end'      Cut
FALSE       <-  Sp {}         -> FALSE
                'false'       Cut
FOR         <-  Sp 'for'      Cut
FUNCTION    <-  Sp 'function' Cut
GOTO        <-  Sp 'goto'     Cut
IF          <-  Sp 'if'       Cut
IN          <-  Sp 'in'       Cut
LOCAL       <-  Sp 'local'    Cut
NIL         <-  Sp {}         -> NIL
                'nil'         Cut
NOT         <-  Sp 'not'      Cut
OR          <-  Sp 'or'       Cut
REPEAT      <-  Sp 'repeat'   Cut
RETURN      <-  Sp 'return'   Cut
THEN        <-  Sp 'then'     Cut
TRUE        <-  Sp {}         -> TRUE
                'true'        Cut
UNTIL       <-  Sp 'until'    Cut
WHILE       <-  Sp 'while'    Cut

Esc         <-  '\' EChar
EChar       <-  'a' -> ea
            /   'b' -> eb
            /   'f' -> ef
            /   'n' -> en
            /   'r' -> er
            /   't' -> et
            /   'v' -> ev
            /   '\'
            /   '"'
            /   "'"
            /   %nl
            /   'z' (%nl / %s)* -> ''
            /   'x' X16 X16
            /   [0-9] [0-9]? [0-9]?
            /   'u{' X16^+1^-6 '}'

Comp        <-  Sp CompList
CompList    <-  '<='
            /   '>='
            /   '<'
            /   '>'
            /   '~='
            /   '=='
BOR         <-  Sp '|'
BXOR        <-  Sp '~'
BAND        <-  Sp '&'
Bshift      <-  Sp BshiftList
BshiftList  <-  '<<'
            /   '>>'
Concat      <-  Sp '..'
Adds        <-  Sp AddsList
AddsList    <-  '+'
            /   '-'
Muls        <-  Sp MulsList
MulsList    <-  '*'
            /   '//'
            /   '/'
            /   '%'
Unary       <-  Sp UnaryList
UnaryList   <-  'not'
            /   '#'
            /   '-'
            /   '~'
POWER       <-  Sp '^'

PL          <-  Sp '('
PR          <-  Sp ')'
BL          <-  Sp '['
BR          <-  Sp ']'
TL          <-  Sp '{'
TR          <-  Sp '}'
COMMA       <-  Sp ','
SEMICOLON   <-  Sp ';'
DOTS        <-  Sp {} -> DOTSPos
                '...' -> DOTS
DOT         <-  Sp '.'
COLON       <-  Sp {} -> COLONPos
                ':'   -> COLON
LABEL       <-  Sp '::'
ASSIGN      <-  Sp '='
]]

grammar 'Nil' [[
Nil         <-  NIL
]]

grammar 'Boolean' [[
Boolean     <-  TRUE
            /   FALSE
]]

grammar 'String' [[
String      <-  Sp ({} StringDef {})
            ->  String
StringDef   <-  '"' {(Esc / !%nl !'"' .)*} -> ShortString '"'
            /   "'" {(Esc / !%nl !"'" .)*} -> ShortString "'"
            /   '[' {:eq: '='* :} '[' {(!StringClose .)*} -> LongString StringClose
StringClose <-  ']' =eq ']'
]]

grammar 'Number' [[
Number      <-  Sp {}     -> NumberPos
                NumberDef -> Number
NumberDef   <-  Number16 / Number10

Number10    <-  Integer10 Float10
Integer10   <-  '0' / [1-9] [0-9]*
Float10     <-  ('.' [0-9]*)? ([eE] [+-]? [1-9]? [0-9]*)?

Number16    <-  Integer16 Float16
Integer16   <-  '0' [xX] X16*
Float16     <-  ('.' X16*)? ([pP] [+-]? [1-9]? [0-9]*)?
]]

grammar 'Name' [[
Name        <-  Sp {} -> NamePos
                {[a-zA-Z_] [a-zA-Z0-9_]*} -> Name
]]

grammar 'Exp' [[
Exp         <-  ExpOr
ExpOr       <-  ExpAnd     (OR     ExpAnd)*
ExpAnd      <-  ExpCompare (AND    ExpCompare)*
ExpCompare  <-  ExpBor     (Comp   ExpBor)*
ExpBor      <-  ExpBxor    (BOR    ExpBxor)*
ExpBxor     <-  ExpBand    (BXOR   ExpBand)*
ExpBand     <-  ExpBshift  (BAND   ExpBshift)*
ExpBshift   <-  ExpConcat  (Bshift ExpConcat)*
ExpConcat   <-  ExpAdds    (Concat ExpAdds)*
ExpAdds     <-  ExpMuls    (Adds   ExpMuls)*
ExpMuls     <-  ExpUnary   (Muls   ExpUnary)*
ExpUnary    <-             (Unary  ExpPower)
            /                      ExpPower
ExpPower    <-  ExpUnit    (POWER  ExpUnary)*
ExpUnit     <-  Nil
            /   Boolean
            /   String
            /   Number
            /   DOTS
            /   Table
            /   Function
            /   Simple

Simple      <-  (Prefix (Suffix)*)
            ->  Simple
Prefix      <-  PL Exp PR
            /   Name
ColonName   <-  (COLON Name)
            ->  ColonName
Suffix      <-  DOT Name
            /   ColonName
            /   Table
            /   String
            /   BL Exp BR
            /   PL ArgList? PR

ArgList     <-  (Arg (COMMA Arg)*)?
            ->  ArgList
Arg         <-  DOTS
            /   Exp

Table       <-  (TL TableFields? TR)
            ->  Table
TableFields <-  TableField (TableSep TableField)* TableSep?
TableSep    <-  COMMA / SEMICOLON
TableField  <-  NewIndex / NewField / Exp
NewIndex    <-  (BL Exp BR ASSIGN Exp)
            ->  NewIndex
NewField    <-  Name ASSIGN Exp

Function    <-  FunctionLoc / FunctionDef
FunctionLoc <-  (LOCAL FUNCTION FuncName PL ArgList PR) -> FunctionLoc
                    (!END Action)*                      -> Function
                END
FunctionDef <-  (FUNCTION FuncName PL ArgList PR) -> FunctionDef
                    (!END Action)*                -> Function
                END
FuncName    <-  (Name (FuncSuffix)*)?
            ->  FuncName
FuncSuffix  <-  DOT Name
            /   ColonName

-- 纯占位，修改了 `relabel.lua` 使重复定义不抛错
Action      <-  !. .
]]

grammar 'Action' [[
Action      <-  SEMICOLON / Do / Break / Return / Label / GoTo / If / For / While / Repeat / Function / Set / Local / Call

ExpList     <-  Exp (COMMA Exp)*
NameList    <-  (Name (COMMA Name)*)        -> NameList
SimpleList  <-  (Simple (COMMA Simple)*)    -> SimpleList

Do          <-  DO                  -> DoDef
                    (!END Action)*  -> Do
                END

Break       <-  BREAK

Return      <-  RETURN !END ExpList?

Label       <-  LABEL Name LABEL

GoTo        <-  GOTO Name

If          <-  IfPart
                ElseIfPart*
                ElsePart?
                END
            ->  EndIf
IfPart      <-  (IF Exp THEN)                       -> IfDef
                    (!ELSEIF !ELSE !END Action)*    -> If
ElseIfPart  <-  (ELSEIF Exp THEN)                   -> ElseIfDef
                    (!ELSE !ELSEIF !END Action)*    -> ElseIf
ElsePart    <-  ELSE                                -> ElseDef
                    (!END Action)*                  -> Else

For         <-  Loop / In

Loop        <-  (FOR LoopStart LoopFinish LoopStep? DO) -> LoopDef
                    (!END Action)*                      -> Loop
                END
LoopStart   <-  (Name ASSIGN Exp)                       -> LoopStart
LoopFinish  <-  COMMA Exp
LoopStep    <-  COMMA Exp

In          <-  (FOR NameList IN ExpList DO)    -> InDef
                    (!END Action)*              -> In
                END

While       <-  (WHILE Exp DO)      -> WhileDef
                    (!END Action)*  -> While
                END

Repeat      <-  REPEAT                  -> RepeatDef
                    (!UNTIL Action)*    -> Repeat
                (UNTIL Exp)             -> Until

Set         <-  (LOCAL NameList ASSIGN ExpList)
            ->  LocalSet
            /   (SimpleList ASSIGN ExpList)
            ->  Set

Local       <-  LOCAL NameList
            ->  LocalVar

Call        <-  Simple
            ->  Call
]]

grammar 'Lua' [[
Lua         <-  (Sp Action)* Sp
]]

return function (lua, mode, parser_)
    parser = parser_ or {}
    mode = mode or 'lua'
    local r, e, pos = compiled[mode]:match(lua)
    if not r then
        local err = errorpos(lua, pos, e)
        return nil, err
    end

    return r
end