Compiler Project (Bali#) Grammar Spring 2008

File			-> (ClassDefinition | DelegateDefinition)*
DelegateDefinition	-> delegate type name ( [type (, type)*]);
ClassDefinition		-> class name { (classMember)* }

classMember		-> public (Method | MemberVariable)
	Method		-> type name ([type name (, type name)*]) statementBlock
	MemberVariable	-> type name ;

statement		-> (ifStatement | whileLoop | expressionStatement | statementBlock | returnStatement | (my localVariableDeclaration) )
statementBlock		-> {statement*}
ifStatement		-> if(expression) statement [else statement]
whileLoop		-> while(expression) statement
returnStatement		-> return expression ;
expressionStatement	-> [expression] ;
localVariableDeclaration	-> type name [= expression] ;

expression		-> e1
e1			-> e2 (= e2)*
e2			-> e3 ((||) e3)*
e3			-> e4 ((&&) e4)*
e4			-> e5 ((< | > | <= | =< | >= | => | == | !=) e5)*
e5			-> e6 ((+ | -) e6)*
e6			-> e7 ((* | / | %) e7)*
e7			-> e8 (functionCall)*
e8			-> (! | - | * | cast<type>)* e9
e9			-> literal | objectConstructor | reference | (expression) | builtInFunction

builtInFunction		-> sizeof(Type) | ((malloc|print)(expression))
objectConstructor		-> new name functionCall
reference			-> (name | this) (.name)*
functionCall		-> ([e1 (, e1)*] )
literal			-> number | string | character | true | false | null

type			-> name (*)*

Notes:

• Comments: Anything following a # on a line is considered to be a comment. This doesn't show up in the grammar above because it's handled by the scanner (Scanner212.java).
• Keywords:
• All functions have the following built in functions:
  • malloc, fail (raises an exception), free (though this may remain unimplemented), sizeof, print
• Types are declared in the global space. There is a single global variable called Main which represents the instance of the class that contains that main method (for the program) that was created upon launch.

Sample Programs

Hello World

class Main
{
	public int BaliMain()
	{
		print("hello world");
	}
}

Sring Example

delegate bool LinkedListCallback(int v, int* state);
class String
{
	private char* _InternalString = null;
	int GetPrimitiveStringLength(char * s)
	{
		if(s == null) return 0;
		char * c = s;
		int length = 0;
		while(*c != '\0') { c = c+1; length++; }
		return length;
	}
	char* ClonePrimitiveString(char* s)
	{
		if(s == null) return castnull;

		int l;
		char* NewPrimitiveString = malloc(sizeof(char) * (l=GetPrimitiveStringLength(s)));
		for(int i=0;i<l;i++) *(NewPrimitiveString + i) = *(s+i);
		return NewPrimitiveString;
	}

	String String(char *s)
	{
		_InternalString = ClonePrimitiveString(s);
	}
}

Linked List Example

delegate bool LinkedListCallback(int, int*);
class LinkedList
{
	public LinkedListNode *_FirstNode = null;
	public LinkedListNode *_LastNode = null;
	public int _Length = 0;
	public int Length() { return _Length; }
	public LinkedList LinkedList() { }
	public LinkedListNode Add(int v)
	{
		local LinkedListNode* n = new LinkedListNode(v);
		if(_FirstNode == null) _FirstNode = _LastNode = n;
		_LastNode.SetNext(n);
		_LastNode = n;
	}
	public bool RemoveDefaultCallback(int v, int* state)
	{
		return v == *(caststate);
	}
	public int RemoveValue(int v)
	{
		int* ValueToRemove = cast malloc(sizeof(int));
		*ValueToRemove = v;
		Remove(RemoveDefaultCallback, ValueToRemove);
		free(ValueToRemove);
	}
	public int Remove(LinkedListCallback cb, int* state)
	{
		# left as an excersize
	}
	public int PrintCallback(int v, int* state) { print(v); }
	public int Print() { Enumerate(PrintCallback); }
	public int Enumerate(LinkedListCallback cb)
	{
		local LinkedListNode* n = _FirstNode;
		while(n != castnull)
		{
			cb(n);
			n = n.Next();
		}
	}
}
class LinkedListNode
{
	public int _Value; public LinkedListNode _Next = null;
	public LinkedListNode Next() { return _Next; }
	public int SetNext(LinkedListNode n) { _Next = n; }
	public LinkedListNode LinkedListNode(int n)
	{
		_Value = n;
	}
}
class Main
{
	public int main()
	{
		print("hello world");
		local LinkedList* List = new LinkedList();
		List.Add(1);
		List.Add(1);
		List.Add(2);
		List.Add(1);
		List.Add(2);
		List.Add(1);
		List.Add(1);
		List.Add(3);
		List.Add(1);
		List.Add(3);

		List.Remove(1);
		List.Remove(3);
		print(List.Length);
		List.Print();
	}
}