The Image type wasn't respecting the min coordinates of a buffer_t
Fixed a bug for pipeline dimensionalities >= 10
Sped up the Scope class by using a custom Stack object.

The custom stack object stores the first element in the container, which
speeds up the common case for Scope of one-element stacks.

This change speeds up compilation of local laplacian by ~30%
Remove redundant -lpngs in bilateral grid Makefile
Remove redundant -lpngs in blur makefile
Comment out unused functions in CodeGen_ARM

to satisfy -pedantic
Remove default cases from switch statements.

To satisfy -pedantic.
Hide local checkouts of lpng and lz

These will be created by yet-to-be-committed 
testing scripts.
Made compilation of x86, arm, and opencl targets conditional

This way you can e.g. compile a version that uses an llvm without arm support.
Added a 5-arg extern macro.
Made bitwise ops work more gracefully on mixed types.
Added string.h to image_io for strcmp.
Stack bugfix.

Wasn't setting _empty correctly on tail stack when pushing.
Fix linker error for pipeline_c for ptx.

Doesn't actually use ptx, but it tries to link to it and fails.
Added the scripts I'm using for nightly testing.
Added "make clean" for wavelet in test_apps
Add built-in lerp operator to Halide. Documentation in IROperator.h doc comment.

Includes correctness tests and tests for compilation error messages.

Also made two changes to allow writing a test cases that takes and
returns bool values. (Which are packed in an 8-bit byte.)
Added ability for Funcs to return multiple outputs (Tuples).

Tuples are not first-class types. Instead, Function objects have an array
of value Exprs instead of just one. Provide nodes therefore now take
an array of values, and call nodes have an extra int selecting which value
from the call this Expr refers to. Realize nodes now take an array of Types.

The storage flattening pass is now also responsible for unpacking the
multi-valued provide into multiple store statements, and for converting
the realize nodes into multiple nested allocate nodes. Each element of the
tuple gets its own buffer_t. I.e. things are stored in struct-of-arrays
format.

One example of why this functionality is necessary is multi-dimensional
argmax. It was not possible to express before this.

The semantics aren't quite right yet though, All tuple elements should be
computed before any are stored (to avoid RAW hazards in reductions), but this
is not yet the case (see the TODO in StorageFlattening).

Also, you can't realize multi-valued Funcs yet. There's some front-end
plumbing necessary first.
llvm trunk no longer has TargetOptions::RealignStack

It's now a Function attribute. Seems to be on by default.
Merge branch 'lerp'