;; -*- Hen -*-
;;
;;  A grammar for the Ersatz template library.
;;
;;
;; Copyright 2012 Ivan Raikov and the Okinawa Institute of
;; Science and Technology.
;;
;; This program is free software: you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation, either version 3 of the
;; License, or (at your option) any later version.
;;
;; This program is distributed in the hope that it will be useful, but
;; WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;; General Public License for more details.
;;
;; A full copy of the GPL license can be found at
;; <http://www.gnu.org/licenses/>.
;;

(require-extension lalr)

(define template-parser

  (lalr-parser

   (output:  parser "ersatz.grm.scm")

   (out-table: "ersatz.grm.out")

   ;; --- token definitions

   (IF ELSE ELSEIF ENDIF FOR ENDFOR SET EXTENDS INCLUDE MACRO IDENT
    ENDMACRO BLOCK ENDBLOCK FILTER ENDFILTER CALL ENDCALL IMPORT FROM
    WITH ENDWITH WITHOUT CONTEXT AUTOESCAPE ENDAUTOESCAPE EOF INT FLOAT
    STRING TEXT EXPAND ENDEXPAND TRUE FALSE NULL 
    COLON RBRACE RBRACKET RPAREN

    (left:  OR AND LT GT EQEQ NEQ PLUS MINUS TIMES DIV MOD VLINE DOT COMMA)
    (right: POWER LBRACE LBRACKET LPAREN IN IS AS)
    (nonassoc: EQ NOT UMINUS)
    )

   ;; Toplevel entry point 

   (input
    () : '()
    (stmts) : (reverse $1)
    )
    
   (stmts
    (stmt) :  (list $1)
    (stmt stmts) : (cons $1 $2 )
    )

   (stmt
    (EXPAND expr ENDEXPAND)      : (ExpandStatement $2) 
    (error ENDEXPAND)
    (SET ident-list EQ expr)     : (SetStatement (SetExpr $2) $4)
    (EXTENDS STRING)             : (ExtendsStatement $2)
    (BLOCK ident ENDBLOCK)       : (BlockStatement $2 '())
    (BLOCK ident stmts ENDBLOCK) : (BlockStatement $2 $3)
    (error ENDBLOCK)
    (FILTER ident stmts ENDFILTER) : (FilterStatement $2 $3)
    (error ENDFILTER)
    (INCLUDE STRING context-part)  : (IncludeStatement $2 $3)
    (IMPORT STRING as-part)        : (ImportStatement $2 $3)
    (FROM STRING IMPORT expr-list) : (FromImportStatement $2 $4)
    (MACRO ident LPAREN expr-list RPAREN stmts ENDMACRO) : (MacroStatement $2 $4 $6)
    (error ENDMACRO)
    (CALL opt-args ident LPAREN expr-list RPAREN stmts ENDCALL) : (CallStatement $3 $2 $5 $7) 
    (error ENDCALL)
    (IF if-chain else-part ENDIF) : (IfStatement $2 $3) 
    (error ENDIF)
    (FOR ident-list IN expr stmts ENDFOR)  : (ForStatement (SetExpr $2) $4 $5)
    (FOR ident IN expr stmts ENDFOR)       : (ForStatement $2 $4 $5)
    (error ENDFOR)
    (WITH expr-list stmts ENDWITH) : (WithStatement $2 $3) 
    (error ENDWITH)
    (AUTOESCAPE expr stmts ENDAUTOESCAPE) : (AutoEscapeStatement $2 $3) 
    (error ENDAUTOESCAPE )
    (TEXT) : (TextStatement $1)
    )


   (if-chain
    (expr stmts) : (list (cons $1 $2))
    (expr stmts ELSEIF if-chain) : (cons (cons $1 $2) $4 )
    (error ENDIF)
    )

   (else-part
    () : '()
    (ELSE stmts) : $2 
    )

   (as-part
    () : #f
    (AS ident) : (ident-expr->name $2) 
    )

   (context-part
    () : #t
    (WITH CONTEXT) : #t
    (WITHOUT CONTEXT) : #f
    )


   
   (expr
    (expr1)                         : $1
    (expr LBRACKET STRING RBRACKET) : (DotExpr $1 (IdentExpr (string->symbol $3)))
    (NOT expr)                      : (NotOpExpr $2)
;;    (MINUS expr)                    : (NegativeOpExpr $2)
    (expr PLUS expr)                : (PlusOpExpr $1 $3)
    (expr MINUS expr)               : (MinusOpExpr $1 $3) 
    (expr DIV expr)                 : (DivOpExpr $1 $3) 
    (expr MOD expr)                 : (ModOpExpr $1 $3)
    (expr TIMES expr)               : (TimesOpExpr $1 $3) 
    (expr POWER expr)               : (PowerOpExpr $1 $3) 
    (expr EQEQ expr)                : (EqEqOpExpr $1 $3) 
    (expr LT EQ expr)               : (LtEqOpExpr $1 $4) 
    (expr GT EQ expr)               : (GtEqOpExpr $1 $4) 
    (expr AND expr)                 : (AndOpExpr $1 $3) 
    (expr OR expr)                  : (OrOpExpr $1 $3) 
    (expr NEQ expr)                 : (NotEqOpExpr $1 $3) 
    (expr LT expr)                  : (LtOpExpr $1 $3) 
    (expr GT expr)                  : (GtOpExpr $1 $3) 
    (expr IN expr)                  : (InOpExpr $1 $3) 
    (expr VLINE expr)               : (ApplyExpr $3 (list $1))
    (expr IS expr expr)             : (TestOpExpr $1 (ApplyExpr $3 (list $4)))
    (expr IS expr)                  : (TestOpExpr $1 $3) 
    (ident EQ expr)                 : (KeywordExpr $1 $3) 
    (ident AS ident)                : (AliasExpr $1 $3) 
    )

    (expr1 
     (expr0)                          : $1
     (expr1 LPAREN expr-list RPAREN ) : (ApplyExpr $1 $3)
     (LBRACKET expr-list RBRACKET)    : (ListExpr $2)
     (LPAREN expr-list RPAREN)        : (SetExpr $2) 
     (LBRACE assoc-list RBRACE)       : (ObjExpr $2) 
     )

    (expr0
     (ident)                         : $1 
     (INT)                           : (LiteralExpr (Tint $1))
     (FLOAT)                         : (LiteralExpr (Tfloat $1))
     (TRUE)                          : (LiteralExpr (Tbool #t))
     (FALSE)                         : (LiteralExpr (Tbool #f))
     (STRING)                        : (LiteralExpr (Tstr $1))
     (NULL)                          : (LiteralExpr (Tnull))
     (expr DOT ident)                : (DotExpr $1 $3)
     (LPAREN expr RPAREN)            : $2)

    (expr-list
     () : (list)
     (expr) : (list $1)
     (expr COMMA expr-list) : (cons $1 $3)
     )


   (ident-list
    (ident) : (list $1)
    (ident COMMA ident-list) : (cons $1 $3)
    )

   (ident
    (IDENT) : (IdentExpr $1) 
    )

   (assoc-list
    (assoc) :  (list $1)
    (assoc COMMA assoc-list) : (cons $1 $3)
    )

   (assoc
    (expr COLON expr) : (cons $1 $3))
   
   
   (opt-args
    () : (list)
    (LPAREN expr-list RPAREN) : $2
    )


))