First commit.
Moved the gitignore.
License is now GPL v2.
Removed an emacs backup; fixed .gitignore
I don't even remember.
Started work in earnest on this.

Have some basic expressions.

Main work has been on object model for operators, including functions
and casts.  Very basic examples working right now.
Have expressions basically working now, in a much better framework.
Is good, yes.

Got rid of emacs backups too, and added a gitignore for them.
Nearly everything works now.  Can almost fully parse example.cicl.

The basic program flow is (using "->" to mean "calls"):

input-text -> parse-c -> parse-c-blah -> make-c-blah -> print-object
(of type blah) [ -> get-representation (for operators) ].  The calls
in `parse-c*' are recursive.  It ends up being basically a recursive
descent parse.

`parse-c' hasn't been written yet, but will likely be the main entry
point for cicl expressions.  Of course, the user would never call it
directly.  Actually, I need to think about how to make sure user
defined macros aren't parsed as cicl code...

Either way, I can almost write C in Lisp!  Yay!

Next steps are getting the rest of the c statements in, and doing
pre-processor directives.
Stuff is working sort of.  I think I need to go and change the
recursive parsers so that they assume that their arguments are
actually already parsed, instead of recursively calling them
themselves.  In this way, I will be able to better integrate them with
lisp macros, since the macros will do the recursive parsing
automatically.

This commit is just before I start messing with that stuff, and
represents a more-or-less working state.
Everything works!!

Cicl macros are defined using defcmacro.  The reason for this is to
allow reparsing after expansion, and to not conflict with Common Lisp.
The macro implementation isn't the greatest: macro names are
registered in the *cicl-macros* special variable.  Also, macros are
actually _functions_.  This has a few advantages, however...

The first is that the macros can affect the active lisp environment,
without generating code that must be "hidden" from the cicl parser.
allowing you to add arbitrary concepts which can be supported by lisp
data strutures.  For example, using macros it would be possible to add
some simple static polymorphism, or to implement type checking for
user defined functions.  Perhaps later I will add support for hooking
in more directly to keywords like `defun' used.
Did some more refinement of load-hack and such.  Also, silveretta.cicl
and silveretta.c and input and output files from my silveretta
project.  It works!
Merge https://github.com/Fizzixnerd/cicl

Conflicts:
	.gitignore
	LICENSE