~ubuntu-branches/debian/squeeze/erlang/squeeze

%% -*- erlang-indent-level: 4 -*-

%% ``The contents of this file are subject to the Erlang Public License,

%% Version 1.1, (the "License"); you may not use this file except in

%% compliance with the License. You should have received a copy of the

 

-import(lists, [member/2,map/2,foldl/3,foldr/3,mapfoldl/3,all/2,reverse/1]).

 

%% value_option(Flag, Default, Options) -> Value.

%% value_option(Flag, Default, OnOpt, OnVal, OffOpt, OffVal, Options) ->

%%              Value.

%%  The option handling functions.

 

 

bool_option(On, Off, Default, Opts) ->

    foldl(fun (Opt, _Def) when Opt =:= On -> true;

    "a binary field without size is only allowed at the end of a binary pattern";

format_error(typed_literal_string) ->

    "a literal string in a binary pattern must not have a type or a size";

format_error({bad_bitsize,Type}) ->

    io_lib:format("bad ~s bit size", [Type]);

%% --- behaviours ---

    io_lib:format("type ~w~s undefined", [TypeName, gen_type_paren(Arity)]);

format_error({unused_type, {TypeName, Arity}}) ->

    io_lib:format("type ~w~s is unused", [TypeName, gen_type_paren(Arity)]);

format_error({redefine_type, {TypeName, Arity}}) ->

    io_lib:format("type ~w~s already defined", 

                  [TypeName, gen_type_paren(Arity)]);

    rbia_fields(Fs, I+1, Acc);

rbia_fields([], _, Acc) -> Acc.

 

%%  Test if a general expression is a valid pattern expression.

 

is_pattern_expr(Expr) ->

                               {0,[],Bvt0,St0}, Es),

    {Esvt,Bvt,St1}.

 

    {Pevt,Bvt1,St1} = pat_bit_expr(E, Old, Bvt, St0),

    %% vtmerge or vtmerge_pat doesn't matter here

    {Sz1,Szvt,Bvt2,St2} = pat_bit_size(Sz0, vtmerge(Vt, Esvt), Bvt, St1),

    {Size1,vtmerge(Szvt,vtmerge(Pevt, Esvt)),

     vtmerge(Bvt2,vtmerge(Bvt, Bvt1)), St5}.

 

%% pat_bit_expr(Pattern, OldVarTable, BinVarTable,State) -> 

%%              {UpdVarTable,UpdBinVarTable,State}.

%%  Check pattern bit expression, only allow really valid patterns!

 

expr_bin(Es, Vt, St0, Check) ->

    {_Sz,Esvt,St1} = foldl(fun (E, Acc) -> bin_element(E, Vt, Acc, Check) end,

    {Esvt,St1}.

 

bin_element({bin_element,Line,E,Sz0,Ts}, Vt, {Size0,Esvt,St0}, Check) ->

%%   float == 32 or 64

 

bit_size_check(_Line, unknown, _, St) -> {unknown,St};

bit_size_check(Line, all, #bittype{type=Type}, St) ->

    end;

bit_size_check(Line, Size, #bittype{type=Type,unit=Unit}, St) ->

    Sz = Unit * Size,                           %Total number of bits!

add_bit_size(_Line, _Sz1, all, true, St) ->

    {all,St};

add_bit_size(_Line, all, _Sz2, _B, St) -> {all,St};

add_bit_size(_Line, unknown, _Sz2, _B, St) -> {unknown,St};

add_bit_size(_Line, _Sz1, unknown, _B, St) -> {unknown,St};

add_bit_size(_Line, Sz1, Sz2, _B, St) -> {Sz1 + Sz2,St}.

 

                  {vtmerge(Evt, Esvt),St1}

          end, {[],St}, Es).

 

%%  Test if a general expression is a guard test.

is_guard_test(E) ->

    is_guard_test2(E, dict:new()).

                end, start(), RecordAttributes),

    is_guard_test2(zip_file_and_line(Expression, "nofile"), St0#lint.records).

 

is_guard_test2({call,Line,{atom,Lr,record},[E,A]}, RDs) ->

    is_gexpr({call,Line,{atom,Lr,is_record},[E,A]}, RDs);

is_guard_test2({call,_Line,{atom,_La,Test},As}=Call, RDs) ->

    %%Everything else is a guard expression.

    is_gexpr(G, RDs).

 

%%  Test if an expression is a guard expression.

 

is_guard_expr(E) -> is_gexpr(E, []). 

type_def(Line, TypeName, ProtoType, Args, St0) ->

    TypeDefs = St0#lint.types,

    Arity = length(Args),

        true ->