Add JSON escaping utility method.
Add method `GetAllAttributes`.

This method returns all attributes which the object has in an dictionary
which is safe for modifications.
API: Add methods for JSON conversion.

Adds some API methods which convert objects into JSON literals. There is
a common method `as_json` in `Object` class which is overridden in `Bool`,
`Iterable`, `Map`, `Int`, `Float`, `String` and `Void` which add support
for other JSON literals as well.

The default implementation simply converts the object into JSON object,
with objects attributes as it's keys and values.
Merge pull request #80 from peelonet/json

API: Add methods for JSON conversion.
Add URL class.

Adds an `Url` class which is (currently stub) object representation of
an URL. Also moves URL decoding utility method from `Utils` class to the
new `Url` class in an attempt to make `Utils` class slowly obsolete.
Move escaping methods to String class.

My opinion is that this is the most logical place for them. Also we can
slowly move methods out from `Utils` class and make it obsolete.
Merge pull request #81 from peelonet/string-changes

URL class and escaping methods
API: Add filtering/escaping methods to Object class.

This commit adds two escaping/filtering methods to `Object` class. You
can convert any object to either XML or JavaScript escaped string. This
is done by converting the object into a string (if it's not a string
already) and then applying the escaping method on the resulting string.
Add stream support to ByteString class.

Adds capability to "open" byte strings into streams.
Merge pull request #82 from peelonet/filter-methods

API: Add filtering/escaping methods to Object class.
Merge pull request #83 from peelonet/binarystream

Add stream support to ByteString class.
Update TODO.md
Use byte strings in various parts of the SAPI.

In order the increase performance and to decrease memory usage, this
commit modifies various parts of the SAPI, URL decoding and query string
parsing to use byte strings instead of Unicode strings. Decision to use
Unicode strings instead of byte strings for these functions was stupid
in the first place, because those strings need to be constantly encoded
and decoded which costs memory and CPU time.

Also added new SAPI/API method `IsSecure` to `Request` class which
attempts to find out whether the request was made through HTTPS or not.

As an intresting side note, when this is compiled with GCC 4.9.1 with
`-O3 -pipe` flags set, the builtin HTTPD crashes after first request
with error message "stack smashing detected". According to Google, this
error message is caused by an buffer overflow, but Valgrind is unable to
detect any and if compiled without those optimization flags HTTPD runs
happily without crashes. Most likely this happens because GCC has just
become so shitty and it's nowdays notorious for it's bugs. Use Clang
everywhere.
Merge pull request #84 from peelonet/binary-sapi-stuff

Use byte strings in various parts of the SAPI.
Stream piping.

Adds capability to pipe input from one stream to another.
Merge pull request #85 from peelonet/stream-pipes

Stream piping.
Throw statement.

1. Add support for `throw` statement which can be used to throw
   exceptions. Not very useful until we have a `try` exception which can
   catch them.

   `throw` statement can be used to throw new exceptions or previouly
   caught exceptions. Only objects which are instance of `Exception`
   class can be thrown, otherwise an `TypeError` is thrown.
2. Add support for `Interpreter` class to track caught exceptions,
   alongside with uncaught exceptions. Required for `throw` statement.
3. Fix minor yet annoying bugs where the number of required arguments
   was not properly converted to string in error messages.
Update README.md
Merge pull request #86 from peelonet/throw-statement

Throw statement.
Add support for try statement.

1. Modifies `Interpreter` class so that caught and uncaught exceptions
   are stored as `Value` instances, instead of `ExceptionObject`. This
   gives us more flexibility with AST.
2. Adds support for `try` statement which can be used to catch
   exceptions thrown either by API methods or `throw` statement.

   `try` statement has following kind of syntax:

   ```
   try:
       throw Exception("this is exception message");
   catch Exception ex:
       response.write("Exception caught: " + ex.message);
   else:
       response.write("No exception was thrown.");
   finally:
       response.write("This is always executed.")
   end try;
   ```

   There can be more than one `catch` statement to catch various kinds
   of exceptions. `catch` statements can also be completely omitted if
   an `else` or `finally` statement is provided.

   `catch` statements take an optional type and variable. Type is an
   type hint (the kind that is used in function parameters), thus it
   allows you to catch multiple kinds of exceptions with syntax like
   `IOError|TypeError|LookupError`. Type can also be omitted, in which
   case every kind of exception is caught. Variable can also be omitted.

   `try` statement can also have an `else` substatement, which is
   executed only if no exception was thrown in body of the `try`
   statement. This is ripped off from Python and is very handy
   sometimes.

   If `try` statement has an `finally` substatement, then that statement
   is always executed, no matter what happens. It is also kinda
   dangerous thing to have, if `finally` statement throws an exception
   things can go completely bonk with the interpreter, althought it
   doesn't crash or anything.