Markus Gaelli <gaelli at emergent.de> wrote:
> do you have a grammar for "standard"-squeak-smalltalk for SmaCC?

Yes, Look at SqueakScanner and SqueakParser classes in the Closure
Compiler.  For convenience I have copied their specs below.

Cheers,
Anthony


SCANNER

<decimalNumber>:	[0-9]+ (\. [0-9]+)? ;
<radixNumber>:		[0-9]+ r [0-9A-Z]+ (\. [0-9A-Z]+)? ;
<exponentNumber>:	(<decimalNumber> | <radixNumber>) e \-? [0-9]+ ;
<number>:			<decimalNumber> | <radixNumber> | <exponentNumber> ;
<negativeNumber>:	\- <number> ;
<string>:				\'  [^\']* \' (\' [^\']* \')* ;
<name>:				[a-zA-Z] [a-zA-Z0-9]* ;
<keyword>:			<name> \: ;
<multikeyword>:		<name> \: (<name> \: )+ ;
<binarySymbol>:		[\~\-\!\@\%\&\*\+\=\\\|\?\/\>\<\,]
[\~\!\@\%\&\*\+\=\\\|\?\/\>\<\,]* ;
<assignment>:		\: = | \_ ;
<alternateKeyword>:	\: <name> \: (<name> \:)* ;
<whitespace>:		\s+ ;
<comment>:			\" [^\"]* \" ;
<character>:			\$ . ;
<variableAssignment>:	<name> \: \= ;

<anyChar>:			. ; # For VW literal arrays that handle #(;) -> #(#';')


PARSER

%id <name> <negativeNumber> <binarySymbol>;
%start Sequence MethodPattern;

Method:
	MethodPattern Sequence						{#method:}
|	MethodPattern Primitive Sequence			{#methodPrim:}
|	MethodPattern Temporaries Primitive Statements {#methodTempsPrim:};

MethodPattern:
	<name>										{#unaryMessage:}
|	<binarySymbol> Variable						{#messagePart:}
|	KeywordMethodPattern						{#first:};

KeywordMethodPattern:
	<keyword> Variable							{#messagePart:}
|	KeywordMethodPattern <keyword> Variable	{#addMessagePart:};

Primitive:
	"<" PrimitiveMessage ">"						{#primitiveMessage:};

Sequence:
	Statements									{#sequence:}
|	Temporaries Statements						{#sequenceWithTemps:};

Temporaries:
	"||"											{#array}
|	"|" TemporaryVariables "|"					{#second:};

TemporaryVariables:
												{#array}
|	TemporaryVariables Variable				{#add:};

Statements:
												{#array}
|	StatementList "."?							{#first:}
|	StatementList "." "^" Expression "."?			{#returnAdd:}
|	"^" Expression "."?							{#return:};

StatementList:
	Expression									{#firstIn:}
|	StatementList "." Expression					{#add3:};

Block:
	"[" BlockArgs "|" Sequence "]"					{#blockWithArgs:}
|	"[" Sequence "]"								{#blockNoArgs:}
|	"[" BlockArgs "]"								{#blockArgs:}
|	"[" BlockArgs "||" TemporaryVariables "|" Statements "]"
{#blockWithTemps:};

BlockArgs:
	":" Variable									{#secondIn:}
|	BlockArgs ":" Variable						{#add3:};

Expression:
	Assignment									{#first:}
|	Cascade										{#first:}
|	Primary									{#first:};

Primary:
	"(" Expression ")"								{#second:}
|	Array										{#first:}
|	Block										{#first:}
|	Literal										{#first:}
|	Variable									{#first:};

Assignment:
	Variable <assignment> Expression				{#assignment:};

Cascade:
	MessageSend								{#first:}
|	Cascade ";" Message							{#cascade:};

MessageSend:
	KeywordMessageSend						{#first:}
|	BinaryMessageSend							{#first:}
|	UnaryMessageSend							{#first:};

Message:
	UnaryMessage								{#first:}
|	BinaryMessage								{#first:}
|	KeywordMessage							{#first:};

KeywordMessageSend:
	BinaryMessageSend KeywordMessage			{#messageSend:}
|	UnaryMessageSend KeywordMessage			{#messageSend:}
|	Primary KeywordMessage					{#messageSend:};

KeywordMessage:
	<keyword> KeywordArgument				{#messagePart:}
|	KeywordMessage <keyword> KeywordArgument {#addMessagePart:};

KeywordArgument:
	BinaryMessageSend							{#first:}
|	UnaryMessageSend							{#first:}
|	Primary									{#first:};

BinaryMessageSend:
	BinaryMessageSend BinaryMessage			{#messageSend:}
|	UnaryMessageSend BinaryMessage			{#messageSend:}
|	Primary BinaryMessage						{#messageSend:};

BinaryMessage :
	<binarySymbol> BinaryArgument				{#messagePart:};

BinaryArgument:
	UnaryMessageSend							{#first:}
|	Primary									{#first:};

UnaryMessageSend :
	UnaryMessageSend UnaryMessage			{#messageSend:}
|	Primary UnaryMessage						{#messageSend:};

UnaryMessage :
	<name>										{#unaryMessage:};

Array:
	"{" Statements "}"								{#array:};

Variable: 
	<name>										{#variable:};

Literal:
	"true"										{#litTrue:}
|	"false"										{#litFalse:}
|	"nil"										{#litNil:}
|	<number>									{#litNumber:}
|	<negativeNumber>							{#litNumber:} 
|	<character>									{#litChar:}
|	<string>										{#litString:}
|	"#" <string>									{#litStringSymbol:}
|	"#" <name>									{#litSymbol:}
|	"#" <binarySymbol>							{#litSymbol:}
|	"#" <keyword>								{#litSymbol:}
|	"#" <multikeyword>							{#litSymbol:}
|	"#" <alternateKeyword>						{#litSymbol:}
|	"#" "[" ByteArray "]"							{#litArray:}
|	"#" "(" LiteralArray ")"						{#litArray:};

ByteArray:
												{#byteStream}
|	ByteArray <number>							{#byteStreamPut:};

LiteralArray:
												{#stream}
|	LiteralArray ArrayLiteral					{#streamPut:};

ArrayLiteral:
	Literal										{#value:}
|	<name>										{#valueSymbol:}
|	<binarySymbol>								{#valueSymbol:}
|	<keyword>									{#valueSymbol:}
|	<multikeyword>								{#valueSymbol:}
|	<alternateKeyword>							{#valueSymbol:}
|	"(" LiteralArray ")"							{#contents2:}
|	"[" ByteArray "]"							{#contents2:}
|	<anyChar>									{#valueSymbol:};

PrimitiveMessage:
	| PrimitiveMessage <keyword>
	| PrimitiveMessage Literal
	| PrimitiveMessage "("
	| PrimitiveMessage ")"
	| PrimitiveMessage "{"
	| PrimitiveMessage "}"
	| PrimitiveMessage ";"
	| PrimitiveMessage "."
	| PrimitiveMessage <name>
	| PrimitiveMessage <binarySymbol>;