(define-library (csc ir2)
  (export
    %apply
    %branch
    %closure
    %fix
    %globals
    %primitive
    %variable
    *globals*
    apply-arguments
    apply-procedure
    apply?
    atom-continuation
    atom-expression
    atom?
    branch-atom
    branch-false
    branch-true
    branch?
    call-closure-args
    call-closure-closure
    call-closure?
    closure-arguments
    closure-body
    closure-name
    closure-rest
    closure?
    fix-body
    fix-functions
    fix?
    globals?
    kargs-expression
    kargs-refs
    kargs?
    klabel-expression
    klabel?
    ktail?
    make-apply
    make-atom
    make-branch
    make-call-closure
    make-closure
    make-fix
    make-kargs
    make-klabel
    make-ktail
    make-primitive
    make-variable
    primitive-arguments
    primitive-continuation
    primitive-operation
    primitive-results
    primitive?
    variable-gensym
    variable?

    ; Re-exports from IR1.
    constant-expression
    constant?
    lexical-ref-gensym
    lexical-ref-name
    lexical-ref?
    library-ref-library
    library-ref-name
    library-ref?
    make-constant
    make-lexical-ref
    lexical-set-expression
    lexical-set-ref
    lexical-set?
    make-lexical-set
    make-library-ref)
  (import (scheme base)
          (only (csc ir1)
            constant?
            lexical-ref-gensym
            lexical-ref-name
            lexical-ref?
            lexical-set-expression
            lexical-set-ref
            lexical-set?
            library-ref-library
            library-ref-name
            library-ref?
            make-constant
            make-lexical-ref
            make-lexical-set
            make-library-ref)
          (only (csc list) all)
          (only (csc loop)
            loop
            return)
          (only (csc match)
            define-match-record-type
            match))
  (begin
    ; This library defines the intermediate representation IR2.
    ; It's CPS time bitch.

    ; CPS atom:
    ;   An atom is a value that can be computed immediately without
    ;   any subexpressions.
    ;   Atoms consist of
    ;     - constant,
    ;     - lexical-ref,
    ;     - library-ref,
    ;     - or globals.
    ;   After closure conversion, there are no more lexical refs.
    ;   Each lexical ref will be converted to a <variable>.


    ; A function argument or local variable.
    (define-match-record-type <variable>
      (make-variable gensym)
      variable?
      %variable
      (gensym variable-gensym))


    ; The globals array. This will eventually be stored in register 0.
    (define-match-record-type <globals>
      (make-globals)
      globals?
      %globals)


    ; A global instance of <globals>.
    ; Considered equal to calling (make-globals).
    (define *globals* (make-globals))


    ; CPS expressions:
    ;   CPS expressions are similar to IR1 expressions,
    ;   but constrained not to have any subexpressions except atoms.
    ;   And they take a continuation.


    ; A primitive encodes one of a number of primitive operations.
    ; Each operation takes a number of arguments,
    ; and binds some number of result variables.
    ; The known primitives are listed below, along with their arity.
    ;   - alloc: size -> result
    ;   - peek: pointer * offset -> result
    ;   - poke: word * pointer * offset -> ()
    (define-match-record-type <primitive>
      (make-primitive operation arguments results continuation)
      primitive?
      %primitive
      (operation primitive-operation)
      (arguments primitive-arguments)
      (results primitive-results)
      (continuation primitive-continuation))


    ; Branches depending on the given atom.
    ; If it is true, continue with continuation true.
    ; If false, continue with continuation false.
    (define-match-record-type <branch>
      (make-branch atom true false)
      branch?
      %branch
      (atom branch-atom)
      (true branch-true)
      (false branch-false))


    ; Applies a procedure to a list of arguments. Apply does not take a
    ; continuation. Instead the continuation will be passed as the first
    ; argument to the function.
    (define-match-record-type <apply>
      (make-apply procedure arguments)
      apply?
      %apply
      (procedure apply-procedure)
      (arguments apply-arguments))


    ; A procedure. All closures are allocated in a fix expression. A closure
    ; does not take a continuation. Instead, the procedure will accept the
    ; continuation as an argument.
    (define-match-record-type <closure>
      (make-closure name arguments body)
      closure?
      %closure
      (name closure-name)
      (arguments closure-arguments)
      (body closure-body))


    ; Defines a list of mutually recursive procedures.
    ; Functions is a list of closures, and body is an expression.
    (define-match-record-type <fix>
      (make-fix functions body)
      fix?
      %fix
      (functions fix-functions)
      (body fix-body))))