;;; File: ast/exp-structs Author: John
;;; These ast structures define the expression syntax
;;; This is simplified; there are additional rules for associativity and
;;; precedence.
;;;
;;; <exp> -> <lambda-exp>
;;; -> <let-exp>
;;; -> <if-exp>
;;; -> <case-exp>
;;; -> <signature-exp>
;;; -> <exp> <op> <exp> ; treated like <fn-app>
;;; -> - <exp>
;;; -> <fn-app>
;;; -> <aexp>
;;;
(define-struct exp
(include ast-node))
;;; <lambda-exp> -> \ <apat> ... <apat> -> <exp>
(define-struct lambda
(include exp)
(slots
(pats (type (list pattern)))
(body (type exp))))
;;; <let-exp> -> let { <decls> [;] } in <exp>
(define-struct let
(include exp)
(slots
(decls (type (list decl)))
(body (type exp))))
;;; <if-exp> -> if <exp> then <exp> else <exp>
(define-struct if
(include exp)
(slots
(test-exp (type exp))
(then-exp (type exp))
(else-exp (type exp))))
;;; <case-exp> -> case <exp> of { <alts> [;] }
;;;
;;; <alts> -> <alt> ; ... ; <alt>
;;;
;;; <alt> -> <pat> -> exp [where { <decls> [;] } ]
;;; -> <pat> <gdpat> [where { <decls> [;] } ]
(define-struct case
(include exp)
(slots
(exp (type exp))
(alts (type (list alt)))))
(define-struct alt
(include ast-node)
(slots
(pat (type pattern))
;; defined in valdef-structs
(rhs-list (type (list guarded-rhs)))
(where-decls (type (list decl)))
;; used internally by cfn
(test (type (maybe exp)) (default '#f))
))
;;; <signature-exp> -> <exp> :: [<context> =>] <atype>
(define-struct exp-sign
(include exp)
(slots
(exp (type exp))
(signature (type signature))))
;;; <fn-app> -> <exp> <aexp>
(define-struct app
(include exp)
(predicate app?)
(slots
(fn (type exp))
(arg (type exp))))
;;; <aexp> -> <var> var-ref
;;; -> <con> con-ref
;;; -> <literal> const
;;; -> () constructor is Unit
;;; -> ( <exp> )
;;; -> ( <exp> , ... , <exp> ) constructor is a tuple
;;; -> [ <exp> , ... , <exp> ] list
;;; -> <sequence>
;;; -> [exp> | <qual> , ... , <qual>] list-comp
;;; -> ( <exp> <op> ) section-r
;;; -> ( <op> <exp> ) section-l
;;;
(define-struct aexp
(include exp))
(define-struct var-ref
(include aexp)
(predicate var-ref?)
(slots
(name (type symbol))
(var (type def))
(infix? (type bool) (bit #t))))
(define-struct con-ref
(include aexp)
(predicate con-ref?)
(slots
(name (type symbol))
(con (type def))
(infix? (type bool) (bit #t))))
(define-struct const
(include aexp)
(slots
(overloaded? (type bool) (default '#t) (bit #t))))
(define-struct integer-const
(include const)
(predicate integer-const?)
(slots
(value (type integer))))
(define-struct float-const
(include const)
(predicate float-const?)
(slots
(numerator (type integer))
(denominator (type integer))
(exponent (type integer))))
(define-struct char-const
(include const)
(predicate char-const?)
(slots
(value (type char))))
(define-struct string-const
(include const)
(predicate string-const?)
(slots
(value (type string))))
(define-struct list-exp
(include aexp)
(slots
(exps (type (list exp)))))
;;; <sequence> -> [ <exp> .. ] sequence
;;; -> [ <exp>, <exp> .. ] sequence-then
;;; -> [ <exp> .. <exp> ] sequence-to
;;; -> [ <exp>, <exp> .. <exp> ] sequence-then-to
(define-struct sequence
(include aexp)
(slots
(from (type exp))))
(define-struct sequence-to
(include aexp)
(slots
(from (type exp))
(to (type exp))))
(define-struct sequence-then
(include aexp)
(slots
(from (type exp))
(then (type exp))))
(define-struct sequence-then-to
(include aexp)
(slots
(from (type exp))
(then (type exp))
(to (type exp))))
(define-struct list-comp
(include aexp)
(slots
(exp (type exp))
(quals (type (list qual)))))
;;; Op on left
(define-struct section-l
(include aexp)
(slots
(exp (type exp))
(op (type exp)))) ; either con-ref or var-ref
(define-struct section-r
(include aexp)
(slots
(exp (type exp))
(op (type exp)))) ; either con-ref or var-ref
;;; <qual> -> <pat> <- <exp>
;;; -> <exp>
(define-struct qual
(include ast-node))
(define-struct qual-generator
(include qual)
(slots
(pat (type pattern))
(exp (type exp))))
(define-struct qual-filter
(include qual)
(slots
(exp (type exp))))
;;; This is used as the guard slot in a guarded-rhs to represent lack of a
;;; guard. This is the same as True.
(define-struct omitted-guard ; same as True; should print in the guardless form
(include exp))
;;; These structures are used by the precedence parser.
(define-struct pp-exp-list ; list of expressions & ops for the prec parser
(include exp)
(slots
(exps (type (list exp)))))
;; This is a place holder for unary negation in pp-exp expressions. It is
;; changed to call the negate function by the prec parser
(define-struct negate
(include exp)
(predicate negate?))
;; Note: operators are var / con structures with infix? set to #t
;;; The following ast nodes do not directly correspond to Haskell syntax.
;;; They are generated during internal code transformations.
;;; This returns a number (an Int) associated with the constructor of a
;;; value.
(define-struct con-number
(include exp)
(slots
(type (type algdata))
(value (type exp))))
;;; This selects a value (denoted by the Int in slot) from a data object
;;; created by a specified constructor.
(define-struct sel
(include exp)
(slots
(constructor (type con))
(slot (type int))
(value (type exp))))
;;; This returns True if the data value was built with the designated
;;; constructor
(define-struct is-constructor
(include exp)
(slots
(constructor (type con))
(value (type exp))))
;;; this is for the type checker only. It turns off
;;; type checking for the argument.
(define-struct cast
(include exp)
(slots
(exp (type exp))))
;; this is used as the body of the let generated by
;; dependency analysis
(define-struct void
(include exp)
(predicate void?))
;;; These structures are for the type checker. They serve as a placeholder
;;; for values which will evaluate to methods or dictionaries.
(define-struct placeholder
(include exp)
(predicate placeholder?)
(slots
(exp (type (maybe exp)))
(tyvar (type ntype))
(overloaded-var (type exp))
(enclosing-decls (type (list decl)))))
(define-struct method-placeholder
(include placeholder)
(predicate method-placeholder?)
(slots
;; the method to be dispatched
(method (type method-var))
))
(define-struct dict-placeholder
(include placeholder)
(predicate dict-placeholder?)
(slots
;; the class of dictionary needed
(class (type class))))
(define-struct recursive-placeholder
(include exp)
(slots
(var (type var))
(enclosing-decls (type (list decl)))
;; this holds the code associated with recursive
;; functions or variables. This code instantiates
;; the recursive context if necessary.
(exp (type (maybe exp)))
))
;;; This is used in primitive modules only. It holds the definition of
;;; a lisp level primitive.
(define-struct prim-definition
(include exp)
(slots
(lisp-name (type symbol))
(atts (type (list (tuple symbol t))))))
;;; This is used by the type checker to hang on to the original
;;; version of a program for message printing. This is removed by
;;; the cfn pass.
(define-struct save-old-exp
(include exp)
(slots
(old-exp (type exp))
(new-exp (type exp))))
;;; This is used for type checking overloaded methods.
(define-struct overloaded-var-ref
(include exp)
(slots
(var (type var))
(sig (type ntype))))
;;; These are used by the CFN.
(define-struct case-block
(include exp)
(slots
(block-name (type symbol))
(exps (type (list exp)))))
(define-struct return-from
(include exp)
(slots
(block-name (type symbol))
(exp (type exp))))
(define-struct and-exp
(include exp)
(slots
(exps (type (list exp)))))