RU beehive logo ITEC dept promo banner
ITEC 380
2022spring
ibarland

Interpreting A
(as developed in lecture)

The language A0

A0:

Expr ::= Num | Paren | BinOp | IfZero Paren ::= / Expr \ Interpretation: a parenthesized expression BinOp ::= ~ Op Expr Expr Interpretation: apply a binary operator Op ::= sum | dif | prd Interpretation: addition, subtraction, multiplication (resp.) IfZero ::= zro Expr ? Expr : Expr Interpretation: if 1st-expr is 0, eval to 2nd-expr, else 3rd-expr. Mnemonic: branch iffzero,ok? … else if :t: …

A1:see A2.html for details

Op ::= | mod Interpretation: “exponentiation”, “remainder1 Expr ::= | IfGT Interpretation: “if greater than” IfGT ::= grt Expr Expr ? Expr : Expr Interpretation: if first Expr is greater than second, result is the third Expr else the fourth.

A2:see A2.html for details

Expr ::= | Id | LetExpr Interpretation: identifier; let LetExpr ::= use Expr | Expr => Id Interpretation: bind Id to (result of) 2nd Expr; then eval 1st Expr w/ that binding

A4:to be changed see A4.html for details

Expr ::= | FuncExpr | FuncApplyExpr FuncExpr ::= fun Id -> Expr Interpretation: a function-value, with parameter Id and body-Expr. FuncApplyExpr ::= pass Expr |> Expr Interpretation: apply a function (2nd expr) to an argument (1st expr)
where Num is any numeric literal (as written in either Java or Racket, your choice2). For the provided parsers to work, whitespace is required between all terminals with the exception of punctuation.

Semantics (interpretation):

Some similar(??) languages:

Discussion


Where we're headed

A0 Implementations


Discuss the implementation

Once we've talked in class about internal-representation (and given examples of the W programs and corresponding internal-data), then we can discuss the provided-implementation, including recursive-descent parsing:

2018 version: The videos below are based on 2018fall's language, T0. So details of the syntax are different than this semester, and some statements might have different semantics, but overall the content is extremely similar to this semester's language.


1 Like remainder, except working for negative and fractional amounts. See homework for details.      
2 This is so we can just use our language's built-in number-parsing functions, without getting bogged down in tokening input. So racket implementations will allow exactly those strings recognized by number?, (including +nan.0, -inf.0, and 2+3i).

Similarly, if using Java, the semantics of A0's arithmetic will be similar to IEEE floating point arithmetic (rather than perfectly-correct arithmetic).

Don't confuse A0's class Num (which extends Expr) with the existing java.lang.Number, which doesn't extend Expr.

     

logo for creative commons by-attribution license
This page licensed CC-BY 4.0 Ian Barland
Page last generated
Please mail any suggestions
(incl. typos, broken links)
to ibarlandradford.edu
Rendered by Racket.