►Compilers – 2023/  24
►3 CPSC 411 Infrastructure Package
▼3.1 Language Reference Implementations
On this page:
exprs-lang-v9
exprs-lang-v9?
interp-exprs-lang-v9
exprs-unique-lang-v9
exprs-unique-lang-v9?
interp-exprs-unique-lang-v9
exprs-unsafe-data-lang-v9
exprs-unsafe-data-lang-v9?
interp-exprs-unsafe-data-lang-v9
exprs-unsafe-lang-v9
exprs-unsafe-lang-v9?
interp-exprs-unsafe-lang-v9
just-exprs-lang-v9
just-exprs-lang-v9?
interp-just-exprs-lang-v9
lam-opticon-lang-v9
lam-opticon-lang-v9?
interp-lam-opticon-lang-v9
lam-free-lang-v9
lam-free-lang-v9?
interp-lam-free-lang-v9
closure-lang-v9
closure-lang-v9?
interp-closure-lang-v9
hoisted-lang-v9
hoisted-lang-v9?
interp-hoisted-lang-v9
proc-exposed-lang-v9
proc-exposed-lang-v9?
interp-proc-exposed-lang-v9
8.10
    contents  ← prev  up  next → 
3.1.11 v9 Languages

 (require cpsc411/langs/v9) package: cpsc411-lib

exprs-lang-v9 : grammar?

  p ::= (module (define x (lambda (x ...) value)) ... value)
     
  value ::= triv
  | (let ([x value] ...) value)
  | (if value value value)
  | (call value value ...)
     
  triv ::= x
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
  | (lambda (x ...) value)
     
  x ::= name?
  | prim-f
     
  prim-f ::= binop
  | unop
     
  binop ::= *
  | +
  | -
  | eq?
  | <
  | <=
  | >
  | >=
     
  unop ::= fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | procedure?
  | vector?
  | cons
  | car
  | cdr
  | make-vector
  | vector-length
  | vector-set!
  | vector-ref
  | procedure-arity
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(exprs-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the exprs-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-exprs-lang-v9 a) → any/c

  a : exprs-lang-v9?
Evaluates a exprs-lang-v9 program to a value.

exprs-unique-lang-v9 : grammar?

  p ::= (module (define aloc (lambda (aloc ...) value)) ... value)
     
  value ::= triv
  | (call value value ...)
  | (let ([aloc value] ...) value)
  | (if value value value)
     
  triv ::= aloc
  | prim-f
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
  | (lambda (aloc ...) value)
     
  prim-f ::= *
  | +
  | -
  | eq?
  | <
  | <=
  | >
  | >=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | procedure?
  | vector?
  | cons
  | car
  | cdr
  | make-vector
  | vector-length
  | vector-set!
  | vector-ref
  | procedure-arity
     
  aloc ::= aloc?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(exprs-unique-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the exprs-unique-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-exprs-unique-lang-v9 a) → any/c

  a : exprs-unique-lang-v9?
Evaluates a exprs-unique-lang-v9 program to a value.

exprs-unsafe-data-lang-v9 : grammar?

  p ::= (module (define aloc (lambda (aloc ...) value)) ... value)
     
  value ::= triv
  | (primop value ...)
  | (call value value ...)
  | (let ([aloc value] ...) value)
  | (if value value value)
  | (begin effect ... value)
     
  effect ::= (primop value ...)
  | (begin effect ... effect)
     
  triv ::= aloc
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
  | (lambda (aloc ...) value)
     
  primop ::= unsafe-fx*
  | unsafe-fx+
  | unsafe-fx-
  | eq?
  | unsafe-fx<
  | unsafe-fx<=
  | unsafe-fx>
  | unsafe-fx>=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | vector?
  | procedure?
  | cons
  | unsafe-car
  | unsafe-cdr
  | unsafe-make-vector
  | unsafe-vector-length
  | unsafe-vector-set!
  | unsafe-vector-ref
  | unsafe-procedure-arity
     
  aloc ::= aloc?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(exprs-unsafe-data-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the exprs-unsafe-data-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-exprs-unsafe-data-lang-v9 a) → any/c

  a : exprs-unsafe-data-lang-v9?
Evaluates a exprs-unsafe-data-lang-v9 program to a value.

exprs-unsafe-lang-v9 : grammar?

  p ::= (module (define aloc (lambda (aloc ...) value)) ... value)
     
  value ::= triv
  | (primop value ...)
  | (unsafe-procedure-call value value ...)
  | (let ([aloc value] ...) value)
  | (if value value value)
  | (begin effect ... value)
     
  effect ::= (primop value ...)
  | (begin effect ... effect)
     
  triv ::= aloc
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
  | (lambda (aloc ...) value)
     
  primop ::= unsafe-fx*
  | unsafe-fx+
  | unsafe-fx-
  | eq?
  | unsafe-fx<
  | unsafe-fx<=
  | unsafe-fx>
  | unsafe-fx>=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | vector?
  | procedure?
  | cons
  | unsafe-car
  | unsafe-cdr
  | unsafe-make-vector
  | unsafe-vector-length
  | unsafe-vector-set!
  | unsafe-vector-ref
  | unsafe-procedure-arity
     
  aloc ::= aloc?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(exprs-unsafe-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the exprs-unsafe-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-exprs-unsafe-lang-v9 a) → any/c

  a : exprs-unsafe-lang-v9?
Evaluates a exprs-unsafe-lang-v9 program to a value.

just-exprs-lang-v9 : grammar?

  p ::= (module value)
     
  value ::= triv
  | (primop value ...)
  | (unsafe-procedure-call value value ...)
  | (letrec ([aloc (lambda (aloc ...) value)] ...) value)
  | (let ([aloc value] ...) value)
  | (if value value value)
  | (begin effect ... value)
     
  effect ::= (primop value ...)
  | (begin effect ... effect)
     
  triv ::= aloc
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
  | (lambda (aloc ...) value)
     
  primop ::= unsafe-fx*
  | unsafe-fx+
  | unsafe-fx-
  | eq?
  | unsafe-fx<
  | unsafe-fx<=
  | unsafe-fx>
  | unsafe-fx>=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | vector?
  | procedure?
  | cons
  | unsafe-car
  | unsafe-cdr
  | unsafe-make-vector
  | unsafe-vector-length
  | unsafe-vector-set!
  | unsafe-vector-ref
  | unsafe-procedure-arity
     
  aloc ::= aloc?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(just-exprs-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the just-exprs-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-just-exprs-lang-v9 a) → any/c

  a : just-exprs-lang-v9?
Evaluates a just-exprs-lang-v9 program to a value.

lam-opticon-lang-v9 : grammar?

  p ::= (module value)
     
  value ::= triv
  | (primop value ...)
  | (unsafe-procedure-call value value ...)
  | (letrec ([aloc (lambda (aloc ...) value)] ...) value)
  | (let ([aloc value] ...) value)
  | (if value value value)
  | (begin effect ... value)
     
  effect ::= (primop value ...)
  | (begin effect ... effect)
     
  triv ::= aloc
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
     
  primop ::= unsafe-fx*
  | unsafe-fx+
  | unsafe-fx-
  | eq?
  | unsafe-fx<
  | unsafe-fx<=
  | unsafe-fx>
  | unsafe-fx>=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | vector?
  | procedure?
  | cons
  | unsafe-car
  | unsafe-cdr
  | unsafe-make-vector
  | unsafe-vector-length
  | unsafe-vector-set!
  | unsafe-vector-ref
  | unsafe-procedure-arity
     
  aloc ::= aloc?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(lam-opticon-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the lam-opticon-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-lam-opticon-lang-v9 a) → any/c

  a : lam-opticon-lang-v9?
Evaluates a lam-opticon-lang-v9 program to a value.

lam-free-lang-v9 : grammar?

  p ::= (module value)
     
  info ::= ((free (aloc ...)) any ...)
     
  value ::= triv
  | (primop value ...)
  | (unsafe-procedure-call value value ...)
  | (letrec ([aloc (lambda info (aloc ...) value)] ...) value)
  | (let ([aloc value] ...) value)
  | (if value value value)
  | (begin effect ... value)
     
  effect ::= (primop value ...)
  | (begin effect ... effect)
     
  triv ::= aloc
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
     
  primop ::= unsafe-fx*
  | unsafe-fx+
  | unsafe-fx-
  | eq?
  | unsafe-fx<
  | unsafe-fx<=
  | unsafe-fx>
  | unsafe-fx>=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | vector?
  | procedure?
  | cons
  | unsafe-car
  | unsafe-cdr
  | unsafe-make-vector
  | unsafe-vector-length
  | unsafe-vector-set!
  | unsafe-vector-ref
  | unsafe-procedure-arity
     
  aloc ::= aloc?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(lam-free-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the lam-free-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-lam-free-lang-v9 a) → any/c

  a : lam-free-lang-v9?
Evaluates a lam-free-lang-v9 program to a value.

closure-lang-v9 : grammar?

  p ::= (module value)
     
  value ::= triv
  | (primop value ...)
  | (closure-ref value value)
  | (closure-call value value ...)
  | (call value value ...)
  | (letrec ([label (lambda (aloc ...) value)] ...) value)
  | (cletrec ([aloc (make-closure label value ...)] ...) value)
  | (let ([aloc value] ...) value)
  | (if value value value)
  | (begin effect ... value)
     
  effect ::= (primop value ...)
  | (begin effect ... effect)
     
  triv ::= aloc
  | label
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
     
  primop ::= unsafe-fx*
  | unsafe-fx+
  | unsafe-fx-
  | eq?
  | unsafe-fx<
  | unsafe-fx<=
  | unsafe-fx>
  | unsafe-fx>=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | vector?
  | procedure?
  | cons
  | unsafe-car
  | unsafe-cdr
  | unsafe-make-vector
  | unsafe-vector-length
  | unsafe-vector-set!
  | unsafe-vector-ref
  | unsafe-procedure-arity
     
  aloc ::= aloc?
     
  label ::= label?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(closure-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the closure-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-closure-lang-v9 a) → any/c

  a : closure-lang-v9?
Evaluates a closure-lang-v9 program to a value.

hoisted-lang-v9 : grammar?

  p ::= (module (define label (lambda (aloc ...) value)) ... value)
     
  value ::= triv
  | (primop value ...)
  | (closure-ref value value)
  | (closure-call value value ...)
  | (call value value ...)
  | (cletrec ([aloc (make-closure label value ...)] ...) value)
  | (let ([aloc value] ...) value)
  | (if value value value)
  | (begin effect ... value)
     
  effect ::= (primop value ...)
  | (begin effect ... effect)
     
  triv ::= aloc
  | label
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
     
  primop ::= unsafe-fx*
  | unsafe-fx+
  | unsafe-fx-
  | eq?
  | unsafe-fx<
  | unsafe-fx<=
  | unsafe-fx>
  | unsafe-fx>=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | vector?
  | procedure?
  | cons
  | unsafe-car
  | unsafe-cdr
  | unsafe-make-vector
  | unsafe-vector-length
  | unsafe-vector-set!
  | unsafe-vector-ref
  | unsafe-procedure-arity
     
  aloc ::= aloc?
     
  label ::= label?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(hoisted-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the hoisted-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-hoisted-lang-v9 a) → any/c

  a : hoisted-lang-v9?
Evaluates a hoisted-lang-v9 program to a value.

proc-exposed-lang-v9 : grammar?

  p ::= (module (define label (lambda (aloc ...) value)) ... value)
     
  value ::= triv
  | (primop value ...)
  | (call value value ...)
  | (let ([aloc value] ...) value)
  | (if value value value)
  | (begin effect ... value)
     
  effect ::= (primop value ...)
  | (begin effect ... effect)
     
  triv ::= aloc
  | label
  | fixnum
  | #t
  | #f
  | empty
  | (void)
  | (error uint8)
  | ascii-char-literal
     
  primop ::= unsafe-fx*
  | unsafe-fx+
  | unsafe-fx-
  | eq?
  | unsafe-fx<
  | unsafe-fx<=
  | unsafe-fx>
  | unsafe-fx>=
  | fixnum?
  | boolean?
  | empty?
  | void?
  | ascii-char?
  | error?
  | not
  | pair?
  | vector?
  | procedure?
  | cons
  | unsafe-car
  | unsafe-cdr
  | unsafe-make-vector
  | unsafe-vector-length
  | unsafe-vector-set!
  | unsafe-vector-ref
  | make-procedure
  | unsafe-procedure-arity
  | unsafe-procedure-label
  | unsafe-procedure-ref
  | unsafe-procedure-set!
     
  aloc ::= aloc?
     
  label ::= label?
     
  fixnum ::= int61?
     
  uint8 ::= uint8?
     
  ascii-char-literal ::= ascii-char-literal?

procedure

(proc-exposed-lang-v9? a) → boolean?

  a : any/c
Decides whether a is a valid program in the proc-exposed-lang-v9 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure

(interp-proc-exposed-lang-v9 a) → any/c

  a : proc-exposed-lang-v9?
Evaluates a proc-exposed-lang-v9 program to a value.

    contents  ← prev  up  next →