In this document:

  Terms in angle brackets are non-terminals.
  Terms by themselves are tokens (i.e., terminals).
  Terms in single quotes are lexemes.

LEXICAL ELEMENTS (Sec 10.2, p208)

keyword: 'class' | 'constructor' | 'function' | 'method' |
         'field' | 'static' | 'var' | 'int' | 'char' | 'boolean' |
         'void' | 'true' | 'false' |'null' | 'this' | 'let' | 'do' |
         'if' | 'else' | 'while' | 'return'

symbol: '{' | '}' | '(' | ')' | '[' | ']' | '.' | ',' | ';' |
        '+' | '-' | '*' | '/' | '&' | '|' | '<' | '>' | '=' | '~'

integerConstant: decimal integer in range 0...32767

stringConstant: Sequence of Unicode characters surrounded by double quotes
                (cannot contain newline or double quote characters)

identifier: Sequence of letters, digits, underscores NOT starting with a digit.

NOTE: The comment is NOT a lexical element and is simply skipped
comment: EOL - '//' ... '\n'
         BLK - '/*' ... '*/'

GRAMMAR  (Sec 10.2, pp208-9)

<class> => 
  'class' <className> '{' <classVarDec>* <subroutineDec>* '}'

<classVarDec> =>
  ('static' | 'field') <type> <varName> (',' <varName>)* ';'

<type> =>
  'int' | 'char' | 'boolean' | <className>

<subroutineDec> => 
  ('constructor' | 'function' | 'method') 
  ('void' | <type>) <subroutineName> '(' <parameterList> ')' 
  <subroutineBody>

<parameterList> =>
  (<type> <varName> (',' <type> <varName>)* )?

<subroutineBody> =>
  '{' <varDec>* <statements> '}'

<varDec> =>
  'var' <type> <varName> (',' <varName>)* ';'

<className> =>
  identifier

<subroutineName> =>
  identifier

<varName> =>
  identifier

<statements> =>
  <statement>*

<statement> =>
  <letStatement> | <ifStatement> | <whileStatement> |
  <doStatement> | <returnStatement>

<letStatement> =>
  'let' <varName> ('[' <expression> ']')? '=' <expression> ';'
  
<ifStatement> =>
  'if' '(' <expression> ')' '{' statements> '}'
  ('else' '{' statements> '}')?
  
<whileStatement> =>
  'while' '(' <expression> ')' '{' statements> '}'
  ('else' '{' statements> '}')?

<doStatement> =>
  'do' <subroutineCall> ';'

<returnStatement> =>
  'return' <expression>? ';'

<expression> =>
  <term> (<op> <term>)*

<term> =>
  integerConstant | stringConstant | keywordConstant |
  <varName> | <varName> '[' <expression> ']' | <subroutineCall> |
  '(' <expression> ')' | unaryOp <term>

<subroutineCall> =>
  <subroutineName> '(' <expressionList> ')' |
  (<className>|<varName>) '.' <subroutineName> '(' <expressionList> ')' 

<expressionList> =>
  (<expression> (',' <expression>)* )?

<op> =>
  '+' | '-' | '*' | '/' | '&' | '|' | '<' | '>' | '='

<unaryOp> =>
  '-' | '~' 

<keywordConstant> =>
  'true' | 'false' | 'null' | 'this'

JACK COMPILER GRAMMAR (as indicated by the XML output in Sec. 10.2.4)

<class>
<classVarDec>
<subroutineDec>
<parameterList>
<subroutineBody>
<varDec>
<statements>
<letStatement>
<ifStatement>
<whileStatement>
<doStatement>
<returnStatement>
<expression>
<term>
<expressionList>

GRAMMAR NON-TERMINALS THAT ARE "ABSORBED":

<className>
<type>
<subroutineName>
<varName>
<statement>
<subroutineCall>
<op>
<unaryOp>
<keywordConstant>

GRAMMAR after absorbing non-essential non-terminals.

<class> => 
  'class' identifier '{' <classVarDec>* <subroutineDec>* '}'

<classVarDec> =>
  ('static' | 'field') ('int' | 'char' | 'boolean' | identifier) identifier (',' identifier)* ';'

<subroutineDec> => 
  ('constructor' | 'function' | 'method') 
  ('void' | 'int' | 'char' | 'boolean' | identifier) identifier '(' <parameterList> ')' 
  <subroutineBody>

<parameterList> =>
  (<type> identifier (',' <type> identifier)* )?

<subroutineBody> =>
  '{' <varDec>* <statements> '}'

<varDec> =>
  'var' ('int' | 'char' | 'boolean' | identifier) identifier (',' identifier)* ';'

<statements> =>
  ( <letStatement> | <ifStatement> | <whileStatement> | <doStatement> | <returnStatement> )*

<letStatement> =>
  'let' identifier ('[' <expression> ']')? '=' <expression> ';'
  
<ifStatement> =>
  'if' '(' <expression> ')' '{' statements> '}'
  ('else' '{' statements> '}')?
  
<whileStatement> =>
  'while' '(' <expression> ')' '{' statements> '}'
  ('else' '{' statements> '}')?

<doStatement> =>
  'do' (identifier '.')? identifier '(' <expressionList> ')' ';'

<returnStatement> =>
  'return' <expression>? ';'

<expression> =>
  <term> (('+' | '-' | '*' | '/' | '&' | '|' | '<' | '>' | '=') <term>)*

<term> =>
  integerConstant | stringConstant | 'true' | 'false' | 'null' | 'this' |
  <varName> | <varName> '[' <expression> ']' | <subroutineCall> |
  '(' <expression> ')' | '-' | '~' <term>

<expressionList> =>
  (<expression> (',' <expression>)* )?