Ensure compile_flags.hrl is built even without make

Windows by default does not have a working make. This patch ensures
pure Erlang apps can be built with PropEr support despite the lack
of a native make command.
Merge pull request #51 from dch/master

Allows clean build on Windows without make
Cover-compiled modules are now more reliably check_spec'ed

check_spec indirectly used code:which/0 to load the BEAM of a targeted
module.   If the module was compiled with {cover_enabled, true}, proper
failed to load the BEAM and resorted to recompiling the module with a
hardcode list of compilation options.  If the targeted module depended
on any additional flags (such as include dirs), the compilation failed
and check_spec returned an error.

This fix uses code:get_object_code/1 (instead of code:which/1) to
retrieve the BEAM for a given module, sidestepping the need to
recompile any Cover-compiled modules.
Add option for specifing a list of MFAs to skip when checking a module's specs

PropEr's tight integration with Erlang's type system is very helpful.
However, there are times when one would like to check all of a
module's exported function specs except for a handful of specs.  The
'{skip_mfas, [<MFA>]}' option can be used for such times.
Merge pull request #57 from norton/norton-skip-mfas

Add option for specifing a list of MFAs to skip when checking a module's specs.
Put files in alphabetical order
Add option for specifing a callback function to check for false positives when checking a module's specs

````
{false_positive_mfas, fun((mfa(),[Arg::term()],{fail, Result::term()} | {error | exit | throw, Reason::term()}) -> boolean()) | undefined}
````

When checking a module's spec(s), PropEr will treat a counterexample
as a false positive if the user supplied function returns true.
Otherwise, PropEr will treat the counterexample as it normally does.
The inputs to the user supplied function are the MFA, the arguments
passed to the MFA, and the result returned from the MFA or an
exception with it's reason.  If needed, the user supplied function can
call erlang:get_stacktrace/0.  Default is undefined.

Other changes:

- Added new unit test "test/proper_specs_tests.erl".  There were no
  existing tests for PropEr's "check_specs" feature.

- Fixed TODO comment in "src/proper_typeserver.erl".  The old behavior
  was not correct in some cases when checking functions that triggered
  an exception.  See "proper_typeserver:apply_spec_test/6" for
  details.
Fix misunderstanding in handling of binary types
Extend the text and the list of those mentioned
Two binary tests and two bitstring tests (the latter commented out for now)
Cleanup .beam files under deps also
Fix dialyzer issue
Merge pull request #60 from norton/norton-fp-mfas

Add option for specifing a callback function to check for false positives when checking a module's specs
Hack to support arbitrary units in binary types
Better fix for the dialyzer call
Minor cleanup
Permit caller to "prime" PropEr's typeserver and random generator prior to testing

The motivation of this change request is to permit testing of a
module's exported functions by using both PropEr *and* Meck.  Before
Meck is enabled to mock a module, the cache of PropEr's typeserver
must be first populated.  Otherwise, PropEr is unable to gather a
module's specs.

Sample code to illustrate this technique:

````
-spec check_specs(module()) -> term().
check_specs(Mod) ->
    %% pass through to the original Function Under Test (FUT)
    check_specs(Mod, fun(_Module, _Fun, Args) -> meck:passthrough(Args) end, [], []).

-spec check_specs(module(), fun((module(), atom(), list()) -> term())) -> term().
check_specs(Mod, FUT) ->
    check_specs(Mod, FUT, [], []).

-spec check_specs(module(), fun((module(), atom(), list()) -> term()), proplist()) -> term().
check_specs(Mod, FUT, PropErOptions) ->
    check_specs(Mod, FUT, PropErOptions, []).

-spec check_specs(module(), fun((module(), atom(), list()) -> term()), proplist(), proplist()) -> term().
check_specs(Mod, FUT, PropErOptions, MeckOptions) ->
    proper:global_state_erase(),
    proper:global_state_init_size(1),
    case proper_typeserver:get_exp_specced(Mod) of
        {ok, MFAs} ->
            meck:new(Mod, MeckOptions),
            try
                %% @NOTE Expand MFA clauses for larger arity as needed
                Fun = fun({M,F,0}) ->
                              meck:expect(M,F, fun() -> FUT(M, F, []) end);
                         ({M,F,1}) ->
                              meck:expect(M,F, fun(A1) -> FUT(M, F, [A1]) end);
                         ({M,F,2}) ->
                              meck:expect(M,F, fun(A1, A2) -> FUT(M, F, [A1, A2]) end)
                      end,
                lists:foreach(Fun, MFAs),
                proper:check_specs(Mod, PropErOptions)
            after
                meck:unload(Mod)
            end;
        {error,Reason} ->
            error(Reason, [Mod, PropErOptions, MeckOptions])
    end.
````
Merge pull request #58 from norton/norton-restart

Permit caller to "prime" PropEr's typeserver and random generator prior to testing
Take out dialyzer_opts
Stregthen a spec