August 22 2014: Parsing Symbols

The parser is now parsing simple symbols and adding them to a dictionary
of symbols. It still doesn't parse using parentheses though, and
therefore may still be up for some large changes, though it seems like
it is nearly ready.

Modified files:
	css_muncher:
		Commented out non-functional lines

	datastructures:
		Added a reverse method to the stack, which reverses the
		order of the elements in the stack. I.E, the first
		element would be last, the second element is second to
		last, etc...

	bnfLexer:
		Removed the expression token type.
		Added semicolon token type, which terminates a line,
		like in C.
		Added an undefined token type, which is given when none
		of the other token types are used. It replaces the
		expression token type.

	parser:
		Removed the symbol class.

		Added Symbol builder class, which builds the parse trees
		for the different symbols.
		Implemented the symbol building in the symbol builder.
		There are three layers to the symbol builder.
		blocks:
			-- Used in the make stacks method
			-- Turned into stacks
			A list of stacks that contain raw tokens
			representing the symbols.
		stacks:
			-- Used in the generate method
			-- Turned into symbols
			A list of stacks containing pieces of
			statemachines that will eventually become
			symbols.
		Symbols:
			This is a dictionary of symbols in the final
			representation. The key is the name of the
			grammar rule, and the value is the state
			machine.

			e.g
			If some grammar rule is defined by
			<CONCATENATE> ::= _a_ + _b_;
			in the bnf grammar file, it would be accessed
			with the key "CONCATENATE".
			This would return the state machine representing
			_a_ + _b_.

		make_stacks is implemented, though may be changed to
		handle parentheses.

		generate is implemented, though may be changed to handle
		parentheses.

		The parser class currently only test the symbol building
		class right now. It only has an initialization method,
		which loads the tokens for the grammar and calls the
		methods to convert them into symbols. This process may
		be automated by the symbol builder in the initialization
		steps.

	css.bnf:
		Added some new test cases and modified the names of
		others. These changes simply make it more readable.
		Also added comments to describe what each test case is
		doing.

The parser is getting closer. The next thing that needs to be
implemented is parenthesis handling. The items in the parentheses need
to be turned into state machines before the rest of the symbol can be
converted. This should happen recursively to quickly handle cases with
nested parenthesis groups.