/* -- Jist.grm ------------------------------------------------------
*
*	Production rules for the Jist programming language.
*	Edit in picas with tabs at 4, 8, 12, 16.
*
*	Copyright 1997,1998,1999 Nikolas S. Boyd. All rights reserved.
*
*----------------------------------------------------------------- */

/* jist tokens */

<error>
<identifier>	=> keywordSearch8B    /* letter { letter | digit } */
<face>		/* class interface */
<final>		/* final */
<access>	/* public protected private packaged */
<storage>	/* transient volatile */
<service>	/* native synchronized */
<abstract>      /* abstract */
<static>	/* static */
<throws>	/* throws */
<keyword>	/* identifier: */
<operator>	=> operatorSearch8B   /* @ % ^ & * + - \ / ? | ~ < > , */
<assign>	/* := */
<equal>		/* = */
<bang>		/* ! */
<newTerm>	/* ( */
<endTerm>	/* ) */
<period>	/* . */
<colon>		/* : */
<comma>		/* , */
<semicolon>	/* ; */
<newBlock>	/* [ */
<endBlock>	/* ] */
<pound>		/* # */
<return>	/* ^ */
<as>		/* as */
<is>		/* is */
<Character>
<String>
<Symbol>
<Integer>
<Float>
<eof>

/* ----------------------- class file ----------------------- */

goal			-> classFile <eof>

classFile		-> imports? classDefinition

imports?		->
			-> imports

imports			->         importation
			-> imports importation

importation		-> import importName impend

import			-> <keyword>                => importKeyword8B
importName		-> <identifier>             => importName8B
impend			-> <semicolon>

/* ----------------------- class definition ----------------------- */

classDefinition		-> classSignature newClass members? endClass

classSignature		-> classDeclaration classExtensions?

classDeclaration	-> faceOptions? face faceName => defineClass8B

face			-> <face>    => saveFace8B
faceName		-> className => saveClass8B

classExtensions?	->
			-> classExtensions

classExtensions		->                         classExtension
			-> classExtensions cascade classExtension

classExtension		-> extension interfaceNames => extendClass8B

interfaceNames		->                      interfaceName
			-> interfaceNames comma interfaceName

extension		-> keyword   => extensionKeyword8B
interfaceName		-> className => extensionName8B

members?		->
			-> members

members			->         qualifiedMember
			-> members qualifiedMember

qualifiedMember		-> accessOptions? member

member			-> variable
			-> method

/* ----------------------- variables ----------------------- */

variable		-> variableDeclaration period => declareVariable8B

variableDeclaration	-> variableName variableType initialization?

variableType?		->
			-> variableType

variableType		-> is storageOptions? className => saveVariableType8B
variableName		-> localName => saveVariable8B

initialization?		->
			-> assign messageExpression => initializeVariable8B

/* ----------------------- methods and signatures ----------------------- */

method			-> methodSignature period      => saveMethod8B
			-> methodSignature methodBlock => saveMethod8B

methodSignature		-> methodPattern methodType? thrownClasses?

methodType?		->
			-> methodType

methodType		-> return className => saveMethodType8B

methodBlock		-> newBlock                blockContents? endBlock
nestedBlock		-> newScope nestedPattern? blockContents? endScope

nestedPattern?		->
			-> nestedPattern

nestedPattern		-> anonymous scopeArguments? scopeResult? bang => saveScope8B

scopeArguments?		->
			-> scopeArguments

scopeArguments		->                          argument
			-> scopeArguments anonymous argument

scopeResult?		->
			-> scopeResult

scopeResult		-> return className => scopeResult8B

methodPattern		-> unaryPattern   => savePattern8B
			-> binaryPattern  => savePattern8B
			-> keywordPattern => savePattern8B

unaryPattern		-> unarySelector

binaryPattern		-> binarySelectors argument

keywordPattern		-> keywordArgument naryArguments?

naryArguments?		->
			-> keywordArguments
			-> anonymousArguments

keywordArguments	->                  keywordArgument
			-> keywordArguments keywordArgument

keywordArgument		-> keyword argument

anonymousArguments	->                    anonymousArgument
			-> anonymousArguments anonymousArgument

anonymousArgument	-> anonymous argument

argument		-> argumentName argumentType 

argumentType		-> is argumentOption? className => saveArgumentType8B
argumentName		-> localName => saveArgument8B

blockContents?		->
			-> sequence

/* ----------------------- message expressions ----------------------- */

sequence		-> statements        => returnSelf8B
			-> statements result
			->            result

statements		->            statement
			-> statements statement

statement		-> expression period => saveStatement8B

result			->        expression => saveResult8B
			-> return expression => returnResult8B

expression		->             messageExpression cascades?
			-> assignments messageExpression cascades? => popAssigns8B

assignments		->             assignment
			-> assignments assignment

assignment		-> assignee assign => pushAssignment8B
assignee		-> localName variableType? => pushAssignee8B

cascades?		->
			-> cascades

cascades		->          cascadingMessage
			-> cascades cascadingMessage

cascadingMessage	-> cascader cascadedMessage

cascadedMessage		-> unarySelector     => sendUnaryCascade8B
			-> binaryMessage     => sendBinaryCascade8B
			-> extendedMessage   => sendKeywordCascade8B

messageExpression	-> unaryExpression
			-> binaryExpression
			-> keywordExpression => sendKeywords8B

unaryExpression		-> primary
			-> primary unaryMessages

binaryExpression	-> unaryExpression binaryMessages

simpleExpression	-> unaryExpression
			-> binaryExpression

keywordExpression	-> simpleExpression extendedMessage

unaryMessages		->               unarySelector => sendUnary8B
			-> unaryMessages unarySelector => sendUnary8B

binaryMessages		->                binaryMessage
			-> binaryMessages binaryMessage

binaryMessage		-> binaryOperator unaryExpression => sendBinary8B

anonymousMessages	->                   anonymousMessage
			-> anonymousMessages anonymousMessage

anonymousMessage	-> anonymousElement simpleExpression

keywordMessages		->                 keywordMessage
			-> keywordMessages keywordMessage

keywordMessage		-> keywordElement simpleExpression

anonymousElement	-> anonymous => pushKeyword8B
keywordElement		-> keyword   => pushKeyword8B

extendedMessage		-> keywordMessage naryMessages?

naryMessages?		->
			-> keywordMessages
			-> anonymousMessages

/* ----------------------- primitive elements ----------------------- */

primary			-> localName  cast? => pushVariable8B
			-> literal          => pushLiteral8B
			-> nestedBlock      => pushBlock8B
			-> nestedTerm cast? => pushTerm8B

cast?			->
			-> cast

cast			-> as className

nestedTerm		-> newTerm expression endTerm

literal			-> arrayConstant
			-> simpleConstant

arrayConstant		-> pound characterArray
			-> pound integerArray
			-> pound floatArray
			-> pound stringArray
			-> pound symbolArray

characterArray		-> <newTerm> characters <endTerm> => formCharacterArray8B

characters		->            character => collectCharacter8B
			-> characters character => collectCharacter8B

character		-> <Character>

integerArray		-> <newTerm> integers <endTerm> => formIntegerArray8B

integers		->          integer => collectInteger8B
			-> integers integer => collectInteger8B

integer			-> <Integer>

floatArray		-> <newTerm> floats <endTerm> => formFloatArray8B

floats			->        float => collectFloat8B
			-> floats float => collectFloat8B

float			-> <Float>

stringArray		-> <newTerm> strings <endTerm> => formStringArray8B

strings			->         string => collectString8B
			-> strings string => collectString8B

string			-> <String>

symbolArray		-> <newTerm> symbols <endTerm> => formSymbolArray8B

symbols			->         symbol => collectSymbol8B
			-> symbols symbol => collectSymbol8B

symbol			-> <Symbol>       => pushSymbol8B
			-> unarySelector
			-> binarySelector
			-> keyword

binaryOperator		-> binarySelectors => pushBinary8B

binarySelectors		->                 binarySelector
			-> binarySelectors binarySelector

simpleConstant		-> <Character> => saveCharacter8B
			-> <String>    => saveString8B
			-> <Symbol>    => saveSymbol8B
			-> <Integer>   => saveInteger8B
			-> <Float>     => saveFloat8B

period			-> <period>
equal			-> <equal>
as			-> <as>
is			-> <is>
comma			-> <comma>
bang			-> <bang>
pound			-> <pound>
return			-> <return>
throws			-> <throws>
cascade			-> <semicolon>

cascader		-> cascade      => cascadeReceiver8B

newTerm			-> <newTerm>    => newTerm8B
endTerm			-> <endTerm>    => endTerm8B
assign			-> <assign>     => findVariable8B
newScope		-> <newBlock>   => newScope8B
endScope		-> <endBlock>   => endScope8B
newBlock		-> <newBlock>   => newBlock8B
endBlock		-> <endBlock>   => endBlock8B
newClass		-> <newBlock>   => newClass8B
endClass		-> <endBlock>   => endClass8B
anonymous		-> <colon>      => formKeyword8B
keyword			-> <keyword>    => formKeyword8B
unarySelector		-> localName    => formSelector8B
binarySelector		-> <operator>   => formOperator8B
			-> equal        => formOperator8B
			-> comma        => formOperator8B

className		-> <identifier>
localName		-> <identifier>
			-> <face>


faceOptions?		->
			-> faceOptions

faceOptions		->             faceOption
			-> faceOptions faceOption

faceOption		-> <access>     => saveOption8B
			-> <final>      => saveOption8B
			-> <abstract>   => saveOption8B

accessOptions?		->
			-> accessOptions

accessOptions		->               accessOption
			-> accessOptions accessOption

accessOption		-> <access>     => saveOption8B
			-> <service>    => saveOption8B
			-> <abstract>   => saveOption8B

storageOptions?		->
			-> storageOptions

storageOptions		->                storageOption
			-> storageOptions storageOption

storageOption		-> <storage>    => saveOption8B
			-> <final>      => saveOption8B
			-> <static>     => saveOption8B

argumentOption?		->
			-> argumentOption

argumentOption		-> <final>      => saveOption8B

thrownClasses?		->
			-> throws thrownClasses

thrownClasses		->                     thrownClass
			-> thrownClasses comma thrownClass

thrownClass		-> className    => thrownClass8B

/* ----------------------- end of grammar ----------------------- */