The Compiler could be viewed as a black box that generates JAVA code
from SPCL program, as depicted from the figure. Within this black
box, there are roughly 5 different stages.

	- Lexer
	- Parser
	- Symbol Table Builder
	- Type Checker
	- Code Generator

- Lexer
	The lexer is responsible for stripping inputs into tokens
of predefined format. This component along with Parser, to be discussed
next, use Antlr's default error handling routine.

- Parser
	The parser is responsible for generating an internal
representation (AST) of the complete SPCL program.

- Symbol Table Builder
	This component uses Antlr's tree walking facility to generate
a tree walker. This tree walker is responsible for building a symbol
table for the corresponding AST.
	A symbol table stores information, such as ID, type, and scope
about all variables. Each table entry uses a homogenous infrastructure.
The type is the only way to tell whether certain piece of information is
relevant to a given variable.
	If something is wrong during this stage, e.g. variable is
redeclared, it'll report the error to an error handling routine.
At the end of the tree walking, it'll consult the error handling routine
and see if any error has been reported. If that is the case, the
compiler would refrain from going to the next stage.

- Type Checker
	This is another tree walker that walks the AST the same way as
in the previous stage. The only difference is that it doesn't do
anything but generate Exceptions. To be more precise, for every place
a reference to any variable is found, the actual variable type is checked
against the expected type. If something is wrong during this checking,
an error would be reported to the error handling routine.
	This component is separated from the previous stage for 2 reasons:
		- make the code more modular
		- SPCL is a language that inherently permits forward
		  reference, thus type checking cannot be done in one
		  pass of the AST.
	Similar to the previous stage, if anything is wrong, the compiler
would refrain from going to the next stage.

- Code Generator
	The role of this component is to generate JAVA codes that would
create and install the policy specified by the SPCL source program.
	This is the last stage of the compiler. When this point is reached,
it is assumed to contain no error. The connection with the error handling
routine is just a redundant safety feature that ensures all previous stages
are doing the right jobs.
	It may seem possible to combine this stage with the previous one.
However, they are separated from each other for 2 reasons:
		- make the code more modular
		- If something is wrong in the source program, it really
		  doesn't make sence to generate partial JAVA codes. Thus,
		  before generating anything, the code has to be checked.
	If something does go wrong in this stage, the compiler should stop
immediately.
