Re: LALR Parser problem

This is a multi-part message in MIME format.

------=_NextPart_000_7bca_3d9f_1ae0
Content-Type: text/plain; charset=iso-8859-1; format=flowed

Oups, sorry, the attachment was missing.... Here it is.

--Dominique


------=_NextPart_000_7bca_3d9f_1ae0
Content-Type: text/x-scheme; name="parser.scm"
Content-Transfer-Encoding: 8bit
Content-Disposition: attachment; filename="parser.scm"

;;
;; parser 
;;
;; Takes a lex function with no parameters as a parameter
;; Expects that tokens are pairs, with a number in 
;; the CAR, the token number, and any value in the CDR,
;; the token attribute.
(define sisc-cep-parser
  (lalr-parser

   ;; --- Options 
   ;; output a parser, called sisc-cep-parser, in a separate file - sisc-cep-parser.yy.scm,
   (output:    sisc-cep-parser "sisc-cep-parser.yy.scm")
   ;; output the LALR table to sisc-cep.out
   (out-table: "sisc-cep.out")
   ;; there should be no conflict
   (expect:    0)

   ;; --- token definitions
   (CEP-STRING CEP-NUM CEP-BOOL INTERVAL-STRING TIME-STRING ;;Value tokens
               CREATE SELECT EVENT INIT INIT-LIST TERM TERM-LIST WHERE
;;Empty tokens
               LKEY LKEYS GKEY GKEYS START ADD IGNORE DISCARD AS STRICT
               CONJ
               SEQ PAR DISJ NTH ATMOST ATLEAST UNLESS AT EVERY AFTER
               REPLACE ALL ANY NEW OLD MAX CONSUME ROWS RANGE LP RP LCB
               RCB < > = GE LE NE DOT COMMA AND OR EXCLAMATION-NOT NOT
               TODO EOF
               (left: + -)
               (left: * /))

   ;; --- rules

   (ce-def
    (CREATE CEP-STRING select-clause) : (make-ce-syntax-obj $2 (first $3) (cadr $3) (caddr $3)))


   (select-clause
    (SELECT map-expr init-clause) : (list $2 (car $3) (cadr $3)))

   (init-clause
    (INIT-LIST init-expr-list event-clause) : (list (cadr $3) (make-ice-syntax-obj (first $3)
                                                                                   (make-ctx-tmp-schema $2 (cadr (caddr $3))) (caddr (caddr $3)) (first (caddr $3))))
    (INIT init-expr event-clause)           : (list (cadr $3) (make-ice-syntax-obj (first $3)
                                                                                   (make-ctx-tmp-schema $2 (cadr (caddr $3))) (caddr (caddr $3)) (first (caddr $3))))
    (event-clause)                          : (list (cadr $1) (make-ice-syntax-obj (first $1) (make-ctx-tmp-schema '() (cadr (caddr $1)))
                                                                                   (caddr (caddr $1))
                                                                                   (first (caddr $1)))))


   (event-clause
    (EVENT event-expr where-clause) : (list $2 (first $3) (cadr $3)))


   (where-clause
    (WHERE where-expr lkeyby-clause) : (list $2 $3)
    (lkeyby-clause)                  : (list '() $1))


   (lkeyby-clause
    (LKEYS LP key RP keylist term-clause) : (list (list $3 $5) (first $6) (cadr $6))
    (LKEYS key term-clause)               : (list $2 (first $3) (cadr $3))
    (term-clause)                         : (list '() (first $1) (cadr $1)))


   (term-clause
    (TERM-LIST term-expr-list gkeyby-clause) : (list $2 $3)
    (TERM term-expr gkeyby-clause)           : (list $2 $3)
    (gkeyby-clause)                          : (list '() $1))


   (gkeyby-clause
    (GKEYS LP key RP keylist) : (list $3 $5)
    (GKEYS key)               : (list $2)
    ()                        : '())

   (internal-init-clause
    (INIT-LIST init-expr-list internal-event-clause) : (cons $2 $3)
    (INIT init-expr internal-event-clause)           : (cons $2 $3)
    (internal-event-clause)                          : (cons '() $1))

   (internal-event-clause
    (event-expr lkeyby-clause) : (cons $1 $2))

   (map-expr
    (*) : (list 'all))

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

   (init-expr
    (START)                           : (list 'start)
    (CEP-STRING rename icc threshold) : (list $1 $2 $3 $4)
    ()                                : (list 'start))

   (rename
    (AS CEP-STRING) : (list $2)
    ()              : '())

   ;; icc = init correlation code
   (icc
    (< ADD >)    : (list 'add)
    (< IGNORE >) : (list 'ignore)
    ()           : (list 'ignore))

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

   ;; tcc = term correlation code
   (term-expr
    (time-span tcc)                         : (list $1 $2)
    (CEP-STRING rename term-opts threshold) : (list $1 $2 $3 $4)
    ()                                      : '())

   (term-opts
    (< tquant COMMA tcc >) : (list $2 $4)
    (< tquant >)           : (list $2 'discard)
    (< tcc >)              : (list '+ $2)
    ()                     : (list 'discard '+))

   (tquant
    (NEW) : (list 'new)
    (OLD) : (list 'old)
    (+)   : (list '+))

   (tcc
    (TERM)    : (list 'term)
    (DISCARD) : (list 'discard)
    ()        : (list 'discard))

   (event-expr
    (seq)     : $1
    (par)     : $1
    (disj)    : $1
    (conj)    : $1
    (no-way)  : $1
    (unless)  : $1
    (nth)     : $1
    (atmost)  : $1
    (atleast) : $1
    (at)      : $1
    (every)   : $1
    (after)   : $1)


   (operand-list
    (join-operand rest-operand-list) : (list $1 $2))

   (rest-operand-list
    (COMMA join-operand rest-operand-list) : (list $2 $3)
    ()                                     : '())

   (counting-operand-list
    (counting-operand rest-counting-operand-list) : (list $1 $2))

   (rest-counting-operand-list
    (COMMA counting-operand rest-counting-operand-list) : (list $2 $3)
    ()                                                  : '())

   (join-operand
    (CEP-STRING rename < join-operand-cfg > threshold) : (make-operand $1 $2 $6 '() '() (list-ref $4 2) (list-ref $4 0) (list-ref $4 1) '() '() '() '())
    (CEP-STRING rename threshold)                      : (make-default-operand $1 $2 $3)
    (LP internal-init-clause RP)                       : (make-operand '() '() '() '() '() '() '() '() '() '() $2 '() '())) ;; internal operand

   (counting-operand
    (CEP-STRING rename < counting-operand-cfg > threshold) : (make-operand $1 $2 $6 '() '() (list-ref $4 2) (list-ref $4 0) (list-ref $4 1) '() '() '() '())
    (CEP-STRING rename threshold)                          : (make-default-counting-operand $1 $2 $3)
    (LP internal-init-clause RP)                           : (make-operand '() '() '() '() '() '() '() '() '() '() $2 '() '()))

   (not-operand
    (CEP-STRING rename threshold) : (make-default-not-operand $1 $2 $3)
    (LP internal-init-clause RP)  : (make-operand '() '() '() '() '() '() '() '() '() '() $2 '() '()))

   (join-operand-cfg
    (select COMMA consume COMMA rows COMMA range) : (list $1 $3 $5 $7)
    (select COMMA consume COMMA rows )            : (list $1 $3 $5 'unbounded)
    (select COMMA consume COMMA range)            : (list $1 $3 'unbounded $5)
    (select COMMA consume )                       : (list $1 $3 'unbounded 'unbounded)
    (select COMMA rows COMMA range)               : (list $1 #f $3  $5)
    (select COMMA rows)                           : (list $1 #f $3 'unbounded)
    (select COMMA range)                          : (list $1 #f 'unbounded $3)
    (select)                                      : (list $1 #f 'unbounded 'unbounded)
    (consume COMMA rows COMMA range)              : (list (list 'any 'new 1) $1 $3 $5)
    (consume COMMA rows)                          : (list (list 'any 'new 1) $1 $3 'unbounded )
    (consume COMMA range)                         : (list (list 'any 'new 1) $1 'unbounded $3)
    (consume)                                     : (list (list 'any 'new 1) $1 'unbounded 'unbounded)
    (rows COMMA range)                            : (list (list 'any 'new 1) #f $1 $3)
    (rows)                                        : (list (list 'any 'new 1) #f $1 'unbounded)
    (range)                                       : (list (list 'any 'new 1) #f 'unbounded $1))

   (counting-operand-cfg
    (CEP-NUM COMMA join-operand-cfg) : (list $1 $3)
    (join-operand-cfg)               : $1)

   (strictness
    (STRICT) : 'strict
    (ANY)    : 'any)

   (order
    (NEW) : 'new
    (OLD) : 'old)

   (keylist
    (COMMA LP key RP keylist) : (cons $3 $5)
    ()                        : '())

   (key
    (event-key event-keylist) : '())

   (event-keylist
    (COMMA event-key event-keylist) : (cons $2 $3)
    ()                              : '())

   (event-key
    (CEP-STRING DOT CEP-STRING) : (cons $1 $3))

   (where-expr
    (TODO) : '()
    ()     : '())

   (cond-expr
    (TODO) : '()
    ()     : '())

   (threshold
    (LCB tcond RCB) : (list $2)
    ()              : '())

   (tcond
    (TODO) : '()
    ()     : '())

   (aggfn-expr
    (TODO) : '()
    ()     : '())

   (time-span
    (INTERVAL-STRING) : $1)

   (time-expr
    (TIME-STRING) : $1)

   (acc
    (ADD)     : (list 'add)
    (IGNORE)  : (list 'ignore)
    (REPLACE) : (list 'replace)
    ()        : (list 'add))

   (internal-acc
    (ADD) : (list 'add)
    ()    : (list 'add))


   ;;
   ;; PROBLEMATIC PATTERNS
   ;; All of the following patterns cause problems with the Sisc LALR(1)    parser
   ;; Whichever pattern is first causes an error (i.e. interchanging    their
   ;; order gives the same error, but with different values.
   ;; e.g. running (include "sisc-cep-parser.scm") with conj before seq 
   ;; gives:
   ;; Error: unused arguments (conj)
   ;; ?:?:?: <from call to apply>
   ;; ?:?:?: <from call to/argument of cons>
   ;; ?:?:?: <from call to cons>
   ;; ?:?:?: <indeterminate call>
   ;; ?:?:?: <from call to apply>
   ;; file:/auto/homes/do244/devel/workspace/KawaCEP/lalr.scm:1688:26:   <indeterminate call>
   ;; ?:?:?: <from call to/argument of datum->syntax-object>
   ;; ?:?:?: <indeterminate call> [Repeated 4 times]
   ;; ?:?:?: <from call to/argument of list> [Repeated 3 times]
   ;; ?:?:?: <indeterminate call> [Repeated twice]
   ;; ?:?:?: <from call to/argument of cons> [Repeated 4 times]
   ;; ?:?:?: <indeterminate call> [Repeated 4 times]
   ;;
   ;;
   ;; If instead they are rearranged so that seq comes before 
   ;; conj we get:
   ;;
   ;; Error: unused arguments (seq)
   ;; ?:?:?: <from call to apply>
   ;; ?:?:?: <from call to/argument of cons>
   ;; ?:?:?: <from call to cons>
   ;; etc..

   (conj
    (AND LP operand-list RP) : (make-operator 'and $3 '() '()))

   (seq
    (SEQ LP operand-list RP) : (make-operator 'seq $3 '() '()))

   (par
    (PAR LP operand-list RP) : (make-operator 'sim $3 '() '()))

   (disj
    (DISJ LP operand-list RP) : (make-operator 'or $3 '() '()))

   (no-way
    (NOT LP not-operand RP) : (make-operator 'not $3 '() '()))

   (unless
       (UNLESS LP join-operand not-operand RP) : (make-operator 'unless (list $3 $4) '() '()))

   (nth
    (NTH LP CEP-NUM COMMA counting-operand-list RP) : (make-operator 'nth (list $5) (make-op-params '() $3) '()))

   (atmost
    (ATMOST LP CEP-NUM COMMA counting-operand-list RP) : (make-operator 'atmost (list $5) (make-op-params '() $3 '()) '()))

   (atleast
    (ATLEAST LP CEP-NUM COMMA counting-operand-list RP) : (make-operator 'atleast (list $5) (make-op-params '() $3 '()) '()))

   (at
    (AT time-expr) : (make-operator 'at '() (make-op-params '() '() $2) '()))

   (every
    (EVERY time-span) : (make-operator 'every '() (make-op-params '() '() $2)))

   (after
    (AFTER join-operand COMMA time-span COMMA acc) : (make-op-params 'after (list $2) (make-op-params '() '() $4 $6) '()))

   (select
    (strictness order max) : (list $1 $2 $3)
    (strictness order)     : (list $1 $2 1)
    (strictness max)       : (list $1 'new $2)
    (strictness)           : (list $1 'new 1)
    (order max)            : (list 'any $1 $2)
    (order)                : (list 'any $1 1)
    (max)                  : (list 'any 'new $1)
    (ALL)                  : (list 'all))

   (max
    (MAX CEP-NUM) : $2
    (+)           : '+)

   (consume
    (EXCLAMATION-NOT CONSUME) : (list #f)
    (CONSUME)                 : (list #t))

   (rows
    (ROWS CEP-NUM) : $2)

   (range
    (RANGE INTERVAL-STRING) : $2)

   ;; END PROBLEMATIC PATTERNS
   ))


------=_NextPart_000_7bca_3d9f_1ae0
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

------------------------------------------------------------------------------
Open Source Business Conference (OSBC), March 24-25, 2009, San Francisco, CA
-OSBC tackles the biggest issue in open source: Open Sourcing the Enterprise
-Strategies to boost innovation and cut costs with open source participation
-Receive a $600 discount off the registration fee with the source code: SFAD
http://p.sf.net/sfu/XcvMzF8H
------=_NextPart_000_7bca_3d9f_1ae0
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

_______________________________________________
Sisc-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/sisc-users

------=_NextPart_000_7bca_3d9f_1ae0--