t.Syntax ::= t.Module | t.Interface

t.Module ::= (MODULE t.ModuleName e.ModuleBody)

t.Interface ::= (INTERFACE t.InterfaceName e.InterfaceBody)

t.ModuleName ::= t.Name

t.InterfaceName ::= t.Name

e.ModuleBody ::= t.Item | e.ModuleBody t.Item 

t.Item ::= t.Function | t.Object | t.Const

s.Linkage ::= s.IntLinkage | s.ExtLinkage

s.IntLinkage ::= EXPORT | LOCAL

s.ExtLinkage ::= IMPORT

t.Function ::= (s.IntLinkage s.FunctionTag t.Pragma t.FunctionName
                t.InputFormat t.OutputFormat t.Branch) |
               (s.ExtLinkage s.FunctionTag t.Pragma t.FunctionName
                t.InputFormat t.OutputFormat)

s.FunctionTag ::= FUNC | FUNC?

t.Pragma ::= (PRAGMA e.PragmaBody)

e.PragmaBody ::= [Empty] | t.PragmaTerm e.PragmaBody

t.PragmaTerm ::= (FILE e.FileName)
               | (LINE s.Line s.Column)
	       | (TRACE e.TraceNames)

e.FileName ::= [Sequence of liters]

s.Line ::= [Number]

s.Column ::= [Number]

e.TraceNames ::= [Empty] | t.TraceName e.TraceNames

t.TraceName ::= t.Name

t.FunctionName ::= t.Name

t.InputFormat ::= t.FunFormat

t.OutputFormat ::= t.FunFormat

t.FunFormat ::= (e.HardExpression)

t.Format ::= (FORMAT t.Pragma e.HardExpression)

e.HardExpression ::= e.HardTerms
                   | e.HardTerms t.EVar e.HardTerms
		   | e.HardTerms t.VVar e.HardTerms

e.HardTerms ::= [Empty] | t.HardTerm e.HardTerms

t.HardTerm ::= t.Symbol | (PAREN e.HardExpression) | t.SVar | t.TVar

e.Block?! ::= t.Block | NOFAIL t.Block

t.Block ::= (BLOCK t.Pragma e.Branches)

e.Branches ::= [Empty] | t.Branch e.Branches

t.Branch ::= (BRANCH t.Pragma e.Sentence) 

e.Sentence ::= [Empty] | e.Block?! e.Sentence | t.Statement e.Sentence

t.Statement ::= t.Action | t.Operator | t.ComplexOperator

t.Operator ::= (CUT    t.Pragma)
             | (CUTALL t.Pragma)
	     | (STAKE  t.Pragma)
	     | (FAIL   t.Pragma)
	     | (ERROR  t.Pragma)

t.ComplexOperator ::= (NOT t.Branch)
                    | (ITER t.IterBody t.IterVars t.IterCondition)
		    | (TRY t.TryBranch e.CatchBlock)

t.IterBody ::= t.Branch

t.IterVars ::= t.Format

t.IterCondition ::= t.Branch

t.TryBranch ::= t.Branch

e.CatchBlock ::= e.Block?!

t.Action ::= t.Pattern | t.Result | t.Format | t.Block

t.Pattern ::= (LEFT  t.Pragma e.PatternExpression)
            | (RIGHT t.Pragma e.PatternExpression)

e.PatternExpression ::= [Empty] | t.PatternTerm e.PatternExpression

t.PatternTerm ::= t.Symbol | (PAREN e.PatternExpression) | t.Variable

t.Variable ::= t.EVar | t.VVar | t.TVar | t.Svar

t.EVar ::= (EVAR t.Pragma t.Name) | (EVAR)

t.VVar ::= (VVAR t.Pragma t.Name) | (VVAR)

t.TVar ::= (TVAR t.Pragma t.Name) | (TVAR)

t.SVar ::= (SVAR t.Pragma t.Name) | (SVAR)

t.Name ::= (e.QualifiedName)

e.QualifiedName ::= [Word] | e.QualifiedName [Word]

t.Result ::= (RESULT t.Pragma e.ResultExpression) 

e.ResultExpression ::= [Empty]
                     | e.Block?! e.ResultExpression
		     | t.ResultTerm e.ResultExpression

t.ResultTerm ::= t.Symbol | (PAREN e.ResultExpression) | t.Variable
               | (CALL t.Pragma e.ResultExpression)

t.Symbol ::= s.ObjectSymbol | (REF t.Name)

s.ObjectSymbol ::= [Symbol]

t.Object ::= (s.Linkage s.ObjectType t.Pragma t.ObjectName)

s.ObjectType ::= TABLE | BOX | STRING | VECTOR | CHANNEL

t.ObjectName ::= t.Name

t.Initializer ::= (EXEC e.ResultExpression)

t.Const ::= (s.Linkage CONST t.Pragma t.ConstName e.ConstExpression)

t.ConstName ::= t.Name

e.ConstExpression ::= [Empty] | t.ConstTerm e.ConstExpression

t.ConstTerm ::= t.Symbol | (PAREN e.ConstExpression)

