Self syntax (long)

[jecel@lsi.usp.br (Jecel Mattos de Assumpcao Jr.)]

Ivan Moore <ivan@cs.man.ac.uk> wrote on Fri, 27 May 94 13:39:21 BST:
> Does anyone have a Self parser (written in Self) that they would let me use?
> 
> thanks in advance,
   
I have a parser in C that I plan to rewrite in Self soon. Actually, the
only reason why I did it in C first is that my access to Self is very
limited. Meanwhile, you might get some use out of the syntax below.
Its main problem is that it doesn't work, but I found it easier to do
some ugly hacks in the parser rather than fixing the syntax. It is
easy to see that this is an adaptation of the parser in parser.self.
Some problems are:

1) resend - this has several problems. First of all, it interacts with
   the lexical scanner ( shown here as the <nowhite> token ). Another
   problem is that it overloads ".", which is already complicated by
   its use in numbers and at the end of expressions. But the real
   error in the syntax is that <resend> appears three times in a way
   that makes it necessary to look ahead many tokens. A very ugly hack
   was saving the "lastResend" in a global variable and using that
   when trying to match <resend> again in the same position in the
   input stream. Note that the <resend> may be empty and this means
   an implicit self receiver. Note that <nowhite> actually means no
   blanks, newlines, etc. and no delimiters either.

2) "-" - this is very nasty when followed by a number. You have to make
   the scanner work with the parser to find out if this is part of
   the number or not ( this is mentioned in the manual ).

3) "|" - you just have to note ( again in the manual ) that while
   binary selectors can have this character, by itself it is a delimiter 
   and not an binary selector.

4) inner methods - the syntax shown accepts inner methods that were
   eliminated in Self 2.0. I found it easier to write a quick hack
   to get rid of them.

5) keyword arguments - the syntax itself does not garantee that
   if you use the "cL" syntax for declaring a keyword slot that
   the arguments will be declared inside the method. You have to
   add an extra check for that ( which is wise anyway to check
   the number of arguments ).

With these hacks I was able to parse all of the Self 3.0 files ( though
it did complain of an extra "." in init.self ). Here is the syntax:

   expression ::= keyMess

   keyMess    ::= binMess ( kMess | <empty> ) |
		  resend kMess

   kMess      ::= smallKey argList

   argList    ::= keyMess ( capKey argList | <empty> )

   binMess    ::= unaryMess bList |
		  resend bMess bList

   bList      ::= bMess bList |
		  <empty>

   bMess      ::= operator ( unaryMess | keyMess )

   unaryMess  ::= primary ( uMess | <empty> )
		  resend uMess

   uMess      ::= identifier ( uMess | <empty> )

   resend     ::= "resend." <nowhite> |
		  identifier "." <nowhite> |
		  <empty>

   primary    ::= "self" |
		  number |
		  string |
		  method |
		  block  |
		  annotation

   method     ::= "(" slotList code ")"

   block      ::= "[" slotList code "]"

   annotation ::= "{" string primary "}"

   code       ::= "^" expression ( "." | <empty> ) |
		  expression ( "." code | <empty> ) |
		  <empty>

   slotList   ::= "|" sList |
		  <empty>

   sList      ::= "|" |
		  annotSlots sList |
		  slot ( "." sList | "|" )

   annotSlots ::= "{" string annotList

   annotList  ::= "}" |
		  annotSlots annotList |
		  slot ( "." annotList | "}" )

   slot       ::= privacy ( argSlot | dataSlot | bSlot | kSlot )

   privacy    ::= "^" |
		  "_" |
		  "^_" |
		  "_^" |
		  <empty>

   argSlot    ::= ":" identifier 

   dataSlot   ::= slotName ( "<-" expression | "=" expression | <empty> )

   bSlot      ::= operator ( "=" method | identifier "=" method )

   kslot      ::= smallKeyword ( identifier ceL "=" method | cL "=" method )

   cL         ::= capKeyword cL |
		  <empty>

   ceL        ::= capKeyword identifier ceL |
		  <empty>

   slotName   ::= identifier priority

   priority   ::= "*" |
		  <empty>

- Jecel