You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
601 lines
24 KiB
601 lines
24 KiB
-module(eFmtFormat).
|
|
|
|
-include("eFmt.hrl").
|
|
|
|
-compile(export_all).
|
|
|
|
%% Formatting functions of io library.
|
|
-export([
|
|
fwrite/2
|
|
, fwrite/3
|
|
, floatG/1
|
|
, scan/2
|
|
, build/1
|
|
, build/2
|
|
]).
|
|
|
|
%% 在字符串格式之后将参数格式化为Args。刚产生
|
|
%% 如果参数中有错误，则为错误。
|
|
%%
|
|
%% 要正确执行打印命令，我们需要计算
|
|
%% 当前缩进的所有内容。这可能非常
|
|
%% 价格昂贵，尤其是在不需要时，因此我们首先确定
|
|
%% 是否以及需要多长时间来计算缩进。我们的确是
|
|
%% 首先收集所有控制序列，然后
|
|
%% 相应的参数，然后计算打印顺序，然后
|
|
%% 然后构建输出。这种方法有一些缺点，它确实
|
|
%% 在格式字符串上两次传递并创建更多临时数据，
|
|
%% 并且还将控制字符的处理分为两个
|
|
%% 部分。
|
|
|
|
-spec fwrite(Format :: io:format(), Data :: [term()]) -> eFmt:chars().
|
|
fwrite(Format, Args) ->
|
|
build(scan(Format, Args)).
|
|
|
|
-spec fwrite(Format :: io:format(), Data :: [term()], Options :: [{'chars_limit', CharsLimit :: integer()}]) -> eFmt:chars().
|
|
fwrite(Format, Args, Options) ->
|
|
build(scan(Format, Args), Options).
|
|
|
|
|
|
%% Parse all control sequences in the format string.
|
|
-spec scan(Format :: io:format(), Data :: [term()]) -> FormatList :: [char() | eFmt:fmtSpec()].
|
|
|
|
%% 格式 ~F.P.PadModC
|
|
scan(Format, Args) ->
|
|
if
|
|
is_atom(Format) ->
|
|
doCollect(atom_to_binary(Format, utf8), Args, []);
|
|
is_list(Format) ->
|
|
doCollect(list_to_binary(Format), Args, []);
|
|
true ->
|
|
doCollect(Format, Args, [])
|
|
end.
|
|
|
|
doCollect(FmtBinStr, Args, Acc) ->
|
|
case binary:split(FmtBinStr, <<"~">>) of
|
|
[NotMatch] ->
|
|
[NotMatch | Acc];
|
|
[FPart, LPart] ->
|
|
doCollWidth(LPart, Args, 0, left, [FPart | Acc])
|
|
end.
|
|
|
|
doCollWidth(<<>>, _Args, _Width, _Adjust, Acc) ->
|
|
Acc;
|
|
doCollWidth(LPart, Args, Width, Adjust, Acc) ->
|
|
%% 匹配宽度
|
|
case LPart of
|
|
<<"-*", LeftLPart/binary>> ->
|
|
[WidthArgs | LeftArgs] = Args,
|
|
doCollPrecision(LeftLPart, LeftArgs, WidthArgs, left, Acc);
|
|
<<"-", LeftLPart/binary>> ->
|
|
doCollWidth(LeftLPart, Args, Width, left, Acc);
|
|
<<"*", LeftLPart/binary>> ->
|
|
[WidthArgs | LeftArgs] = Args,
|
|
doCollPrecision(LeftLPart, LeftArgs, WidthArgs, right, Acc);
|
|
<<WidthInt:8/integer, LeftLPart/binary>> ->
|
|
case WidthInt >= $0 andalso WidthInt =< $9 of
|
|
true ->
|
|
doCollWidth(LeftLPart, Args, 10 * Width + (WidthInt - $0), Adjust, Acc);
|
|
_ ->
|
|
case Width == 0 of
|
|
true ->
|
|
doCollPrecision(LPart, Args, none, Adjust, Acc);
|
|
_ ->
|
|
doCollPrecision(LPart, Args, Width, Adjust, Acc)
|
|
end
|
|
end
|
|
end.
|
|
|
|
doCollPrecision(LPart, Args, Width, Adjust, Acc) ->
|
|
case LPart of
|
|
<<".", LeftLPart/binary>> ->
|
|
doCollPrecision(LeftLPart, Args, Width, Adjust, 0, Acc);
|
|
_ ->
|
|
doCollPadChar(LPart, Args, Width, Adjust, none, Acc)
|
|
end.
|
|
|
|
doCollPrecision(LPart, Args, Width, Adjust, Precision, Acc) ->
|
|
case LPart of
|
|
<<"*", LeftLPart/binary>> ->
|
|
[PrecisionArgs | LeftArgs] = Args,
|
|
doCollPadChar(LeftLPart, LeftArgs, Width, Adjust, PrecisionArgs, Acc);
|
|
<<PrecisionInt:8/integer, LeftLPart/binary>> ->
|
|
case PrecisionInt >= $0 andalso PrecisionInt =< $9 of
|
|
true ->
|
|
doCollPrecision(LeftLPart, Args, Width, Adjust, 10 * Precision + (PrecisionInt - $0));
|
|
_ ->
|
|
case Precision == 0 of
|
|
true ->
|
|
doCollPadChar(LPart, Args, Width, Adjust, none, Acc);
|
|
_ ->
|
|
doCollPadChar(LPart, Args, Width, Adjust, Precision, Acc)
|
|
end
|
|
end
|
|
end.
|
|
|
|
doCollPadChar(LPart, Args, Width, Adjust, Precision, Acc) ->
|
|
case LPart of
|
|
<<".*", LeftLPart/binary>> ->
|
|
[PadChar | LeftArgs] = Args,
|
|
doCollEncoding(LeftLPart, LeftArgs, Width, Adjust, Precision, PadChar, Acc);
|
|
<<".", PadChar:8/integer, LeftLPart/binary>> ->
|
|
doCollEncoding(LeftLPart, Args, Width, Adjust, Precision, PadChar, Acc);
|
|
_ ->
|
|
doCollEncoding(LPart, Args, Width, Adjust, Precision, 32, Acc)
|
|
end.
|
|
|
|
doCollEncoding(LPart, Args, Width, Adjust, Precision, PadChar, Acc) ->
|
|
case LPart of
|
|
<<"t", LeftLPart/binary>> ->
|
|
%true = Char =/= $l,
|
|
doCollStrings(LeftLPart, Args, Width, Adjust, Precision, PadChar, unicode, Acc);
|
|
_ ->
|
|
doCollStrings(LPart, Args, Width, Adjust, Precision, PadChar, latin1, Acc)
|
|
end.
|
|
|
|
doCollStrings(LPart, Args, Width, Adjust, Precision, PadChar, Encoding, Acc) ->
|
|
case LPart of
|
|
<<"l", LeftLPart/binary>> ->
|
|
%true = Char =/= $t,
|
|
doCollCA(LeftLPart, Args, Width, Adjust, Precision, PadChar, Encoding, false, Acc);
|
|
_ ->
|
|
doCollCA(LPart, Args, Width, Adjust, Precision, PadChar, Encoding, true, Acc)
|
|
end.
|
|
|
|
doCollCA(LPart, Args, Width, Adjust, Precision, PadChar, Encoding, Strings, Acc) ->
|
|
<<CtlChar:8/integer, LeftLPart/binary>> = LPart,
|
|
case CtlChar of
|
|
$w -> [OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$p ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$W ->[OneArgs | LeftArgs] = Args, [Depth | LastArgs] = LeftArgs, As = [OneArgs, Depth], NextArgs = LastArgs;
|
|
$P -> [OneArgs | LeftArgs] = Args,[Depth | LastArgs] = LeftArgs, As = [OneArgs, Depth], NextArgs = LastArgs;
|
|
$s ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$e ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$f ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$g -> [OneArgs | LeftArgs] = Args,As = OneArgs, NextArgs = LeftArgs;
|
|
$b ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$B ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$x ->[OneArgs | LeftArgs] = Args, [Prefix | LastArgs] = LeftArgs, As = [OneArgs, Prefix], NextArgs = LastArgs;
|
|
$X -> [OneArgs | LeftArgs] = Args,[Prefix | LastArgs] = LeftArgs, As = [OneArgs, Prefix], NextArgs = LastArgs;
|
|
$+ -> [OneArgs | LeftArgs] = Args,As = OneArgs, NextArgs = LeftArgs;
|
|
$# ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$c ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs;
|
|
$~ -> As = undefined, NextArgs = Args;
|
|
$n -> As = undefined, NextArgs = Args;
|
|
$i ->[OneArgs | LeftArgs] = Args, As = OneArgs, NextArgs = LeftArgs
|
|
end,
|
|
FmtSpec = #fmtSpec{ctlChar = CtlChar, args = As, width = Width, adjust = Adjust, precision = Precision, padChar = PadChar, encoding = Encoding, strings = Strings},
|
|
doCollect(LeftLPart, NextArgs, [FmtSpec | Acc]).
|
|
|
|
%% Build the output text for a pre-parsed format list.
|
|
-spec build(FormatList :: [char() | eFmt:fmtSpec()]) -> eFmt:chars().
|
|
build(Cs) ->
|
|
build(Cs, []).
|
|
|
|
-spec build(FormatList :: [char() | eFmt:fmtSpec()], Options :: [{'chars_limit', CharsLimit :: integer()}]) -> eFmt:chars().
|
|
build(Cs, Options) ->
|
|
CharsLimit = getOpt(chars_limit, Options, -1),
|
|
ResList = buildSmall(Cs, []),
|
|
{P, S, W, Other} = cntSmall(ResList, 0, 0, 0, 0),
|
|
case P + S + W of
|
|
0 ->
|
|
ResList;
|
|
NumOfLimited ->
|
|
RemainChars = remainChars(CharsLimit, Other),
|
|
buildLimited(ResList, P, NumOfLimited, RemainChars, 0, [])
|
|
end.
|
|
|
|
%% build_small([Control]) -> eFmt:chars().
|
|
%% Interpret the control structures, but only the small ones. The big ones are saved for later.
|
|
%% build_limited([Control], NumberOfPps, NumberOfLimited, CharsLimit, Indentation)
|
|
%% Interpret the control structures. Count the number of print
|
|
%% remaining and only calculate indentation when necessary. Must also
|
|
%% be smart when calculating indentation for characters in format.
|
|
buildSmall([], Acc) -> Acc;
|
|
buildSmall([OneCA | Cs], Acc) ->
|
|
case OneCA of
|
|
#fmtSpec{ctlChar = CtlChar, args = Args, width = Width, adjust = Adjust, precision = Precision, padChar = PadChar, encoding = Encoding} ->
|
|
case ctlSmall(CtlChar, Args, Width, Adjust, Precision, PadChar, Encoding) of
|
|
not_small -> buildSmall(Cs, [OneCA | Acc]);
|
|
ignore -> buildSmall(Cs, Acc);
|
|
Str -> buildSmall(Cs, [Str | Acc])
|
|
end;
|
|
_ ->
|
|
buildSmall(Cs, [OneCA | Acc])
|
|
end.
|
|
|
|
%% control_small(FormatChar, [Argument], FieldWidth, Adjust, Precision,
|
|
%% PadChar, Encoding) -> String
|
|
%% control_limited(FormatChar, [Argument], FieldWidth, Adjust, Precision,
|
|
%% PadChar, Encoding, StringP, ChrsLim, Indentation) -> String
|
|
%% These are the dispatch functions for the various formatting controls.
|
|
|
|
ctlSmall($s, Args, Width, Adjust, Precision, PadChar, Encoding) when is_atom(Args) ->
|
|
case Encoding of
|
|
latin1 ->
|
|
AtomBinStr = eFmt:writeAtom(Args, latin1);
|
|
_ ->
|
|
AtomBinStr = eFmt:writeAtom(Args, uft8)
|
|
end,
|
|
string(AtomBinStr, Width, Adjust, Precision, PadChar, Encoding);
|
|
ctlSmall($e, Args, Width, Adjust, Precision, PadChar, _Encoding) when is_float(Args) ->
|
|
floatE(Args, Width, Adjust, Precision, PadChar);
|
|
ctlSmall($f, Args, Width, Adjust, Precision, PadChar, _Encoding) when is_float(Args) ->
|
|
floatF(Args, Width, Adjust, Precision, PadChar);
|
|
ctlSmall($g, Args, Width, Adjust, Precision, PadChar, _Encoding) when is_float(Args) ->
|
|
floatG(Args, Width, Adjust, Precision, PadChar);
|
|
ctlSmall($b, Args, Width, Adjust, Precision, PadChar, _Encoding) when is_integer(Args) ->
|
|
unPrefixedInt(Args, Width, Adjust, ?base(Precision), PadChar, true);
|
|
ctlSmall($B, Args, Width, Adjust, Precision, PadChar, _Encoding) when is_integer(Args) ->
|
|
unPrefixedInt(Args, Width, Adjust, ?base(Precision), PadChar, false);
|
|
ctlSmall($x, [Args, Prefix], Width, Adjust, Precision, PadChar, _Encoding) when is_integer(Args), is_atom(Prefix) ->
|
|
prefixedInt(Args, Width, Adjust, ?base(Precision), PadChar, atom_to_binary(Prefix, utf8), true);
|
|
ctlSmall($x, [Args, Prefix], Width, Adjust, Precision, PadChar, _Encoding) when is_integer(Args) ->
|
|
prefixedInt(Args, Width, Adjust, ?base(Precision), PadChar, Prefix, true);
|
|
ctlSmall($X, [Args, Prefix], Width, Adjust, Precision, PadChar, _Encoding) when is_integer(Args), is_atom(Prefix) ->
|
|
prefixedInt(Args, Width, Adjust, ?base(Precision), PadChar, atom_to_binary(Prefix, utf8), false);
|
|
ctlSmall($X, [Args, Prefix], Width, Adjust, Precision, PadChar, _Encoding) when is_integer(Args) ->
|
|
prefixedInt(Args, Width, Adjust, ?base(Precision), PadChar, Prefix, false);
|
|
ctlSmall($+, Args, Width, Adjust, Precision, PadChar, _Encoding) when is_integer(Args) ->
|
|
Base = ?base(Precision),
|
|
prefixedInt(Args, Width, Adjust, Base, PadChar, integer_to_binary(Base), $#, true);
|
|
ctlSmall($#, Args, Width, Adjust, Precision, PadChar, _Encoding) when is_integer(Args) ->
|
|
Base = ?base(Precision),
|
|
prefixedInt(Args, Width, Adjust, Base, PadChar, integer_to_binary(Base), $#, false);
|
|
ctlSmall($c,Args, Width, Adjust, Precision, PadChar, Encoding) when is_integer(Args) ->
|
|
case Encoding of
|
|
unicode ->
|
|
char(Args, Width, Adjust, Precision, PadChar);
|
|
_ ->
|
|
char(Args band 255, Width, Adjust, Precision, PadChar)
|
|
end;
|
|
ctlSmall($~, _Args, Width, Adjust, Precision, PadChar, _Encoding) -> char($~, Width, Adjust, Precision, PadChar);
|
|
ctlSmall($n, _Args, Width, Adjust, Precision, PadChar, _Encoding) -> newline(Width, Adjust, Precision, PadChar);
|
|
ctlSmall($i, _Args, _Width, _Adjust, _Precision, _PadChar, _Encoding) -> ignore;
|
|
ctlSmall(_C, _Args, _Width, _Adjust, _Precision, _PadChar, _Encoding) -> not_small.
|
|
|
|
cntSmall([], P, S, W, Other) ->
|
|
{P, S, W, Other};
|
|
cntSmall([OneRes | Cs], P, S, W, Other) ->
|
|
case OneRes of
|
|
#fmtSpec{ctlChar = CtlChar} ->
|
|
case CtlChar of
|
|
$p ->
|
|
cntSmall(Cs, P + 1, S, W, Other);
|
|
$P ->
|
|
cntSmall(Cs, P + 1, S, W, Other);
|
|
$w ->
|
|
cntSmall(Cs, P, S, W + 1, Other);
|
|
$W ->
|
|
cntSmall(Cs, P, S, W + 1, Other);
|
|
$s ->
|
|
cntSmall(Cs, P, S, W + 1, Other);
|
|
_ ->
|
|
cntSmall(Cs, P, S, W, Other)
|
|
end;
|
|
_ ->
|
|
if
|
|
is_binary(OneRes) orelse is_list(OneRes) ->
|
|
cntSmall(Cs, P, S, W, Other + eFmt:charsLen(OneRes));
|
|
is_integer(OneRes) ->
|
|
cntSmall(Cs, P, S, W, Other + 1);
|
|
true ->
|
|
cntSmall(Cs, P, S, W, Other)
|
|
end
|
|
end.
|
|
|
|
buildLimited([], _, _, _, _, Acc) -> Acc;
|
|
buildLimited([OneCA | Cs], NumOfPs, Count, MaxLen, I, Acc) ->
|
|
case OneCA of
|
|
#fmtSpec{ctlChar = CtlChar, args = Args, width = Width, adjust = Adjust, precision = Precision, padChar = PadChar, encoding = Encoding, strings = Strings} ->
|
|
MaxChars = if MaxLen < 0 -> MaxLen; true -> MaxLen div Count end,
|
|
IoListStr = ctlLimited(CtlChar, Args, Width, Adjust, Precision, PadChar, Encoding, Strings, MaxChars, I),
|
|
NewNumOfPs = decrPc(CtlChar, NumOfPs),
|
|
NewCount = Count - 1,
|
|
MaxLen = ?IIF(MaxLen < 0, MaxLen, remainChars(MaxLen, eFmt:charsLen(IoListStr))),
|
|
if
|
|
NewNumOfPs > 0 ->
|
|
buildLimited(Cs, NewNumOfPs, NewCount, MaxLen, I, [IoListStr | Acc]);
|
|
true ->
|
|
buildLimited(Cs, NewNumOfPs, NewCount, MaxLen, I, [IoListStr | Acc])
|
|
end;
|
|
_ ->
|
|
buildLimited(Cs, NumOfPs, Count, MaxLen, I + 1, [OneCA | Acc])
|
|
end.
|
|
|
|
decrPc($p, Pc) -> Pc - 1;
|
|
decrPc($P, Pc) -> Pc - 1;
|
|
decrPc(_, Pc) -> Pc.
|
|
|
|
%% (CtlChar, Args, Width, Adjust, Precision, PadChar, Encoding, Strings, MaxChars, I)
|
|
ctlLimited($s, Args, Width, Adjust, Precision, PadChar, Encoding, _Strings, CharsLimit, _I) ->
|
|
case Encoding of
|
|
latin1 ->
|
|
BinStr = erlang:iolist_to_binary(Args);
|
|
|
|
_ ->
|
|
BinStr = case catch unicode:characters_to_binary(Args, unicode) of
|
|
Str when is_binary(Str) -> Str;
|
|
_ -> toBinary(Args)
|
|
end
|
|
end,
|
|
TemBinStr = strToChars(BinStr, Width, CharsLimit),
|
|
string(TemBinStr, ?IIF(CharsLimit < 0 orelse Width =:= none, Width, max(3, min(Width, CharsLimit))), Adjust, Precision, PadChar, Encoding);
|
|
ctlLimited($w, Args, Width, Adjust, Precision, PadChar, Encoding, _Strings, CharsLimit, _I) ->
|
|
Chars = eFmt:doWrite(Args, -1, Encoding, CharsLimit),
|
|
term(Chars, Width, Adjust, Precision, PadChar);
|
|
ctlLimited($p, Args, Width, Adjust, Precision, PadChar, Encoding, Strings, CharsLimit, I) ->
|
|
print(Args, -1, Width, Adjust, Precision, PadChar, Encoding, Strings, CharsLimit, I);
|
|
ctlLimited($W, [Args, Depth], Width, Adjust, Precision, PadChar, Encoding, _Strings, CharsLimit, _I) ->
|
|
Chars = eFmt:doWrite(Args, Depth, Encoding, CharsLimit),
|
|
term(Chars, Width, Adjust, Precision, PadChar);
|
|
ctlLimited($P, [Args, Depth], Width, Adjust, Precision, PadChar, Encoding, Strings, CharsLimit, I) ->
|
|
print(Args, Depth, Width, Adjust, Precision, PadChar, Encoding, Strings, CharsLimit, I).
|
|
|
|
%% term(TermList, Field, Adjust, Precision, PadChar)
|
|
%% Output the characters in a term.
|
|
%% Adjust the characters within the field if length less than Max padding
|
|
%% with PadChar.
|
|
|
|
term(BinStrOrIoList, Width, Adjust, Precision, PadChar) ->
|
|
if
|
|
Width == none andalso Precision == none ->
|
|
BinStrOrIoList;
|
|
Width == none ->
|
|
StrLen = eFmt:charsLen(BinStrOrIoList),
|
|
NewPrecision = erlang:min(StrLen, Precision),
|
|
if
|
|
StrLen > NewPrecision ->
|
|
adjust(Adjust, makePadChars($*, NewPrecision, <<>>), <<>>);
|
|
true ->
|
|
adjust(Adjust, BinStrOrIoList, makePadChars(PadChar, Precision - StrLen, <<>>))
|
|
end;
|
|
true ->
|
|
StrLen = eFmt:charsLen(BinStrOrIoList),
|
|
NewPrecision = erlang:min(StrLen, case Precision of none -> Width; _ -> min(Precision, Width) end),
|
|
if
|
|
StrLen > NewPrecision ->
|
|
adjust(Adjust, makePadChars($*, NewPrecision, <<>>), makePadChars(PadChar, Width - NewPrecision, <<>>));
|
|
true ->
|
|
adjust(Adjust, BinStrOrIoList, makePadChars(PadChar, Width - StrLen, <<>>))
|
|
end
|
|
end.
|
|
|
|
%% print(Term, Depth, Field, Adjust, Precision, PadChar, Encoding,
|
|
%% Indentation)
|
|
%% Print a term. Field width sets maximum line length, Precision sets
|
|
%% initial indentation.
|
|
|
|
print(T, D, none, Adj, P, Pad, E, Str, ChLim, I) ->
|
|
print(T, D, 80, Adj, P, Pad, E, Str, ChLim, I);
|
|
print(T, D, F, Adj, none, Pad, E, Str, ChLim, I) ->
|
|
print(T, D, F, Adj, I + 1, Pad, E, Str, ChLim, I);
|
|
print(T, D, F, right, P, _Pad, Enc, Str, ChLim, _I) ->
|
|
Options = [{chars_limit, ChLim},
|
|
{column, P},
|
|
{line_length, F},
|
|
{depth, D},
|
|
{encoding, Enc},
|
|
{strings, Str}],
|
|
eFmt_pretty:print(T, Options).
|
|
|
|
floatE(Float, Width, Adjust, Precision, PadChar) ->
|
|
case Precision of
|
|
none ->
|
|
NewPrecision = 6;
|
|
_ ->
|
|
NewPrecision = Precision
|
|
end,
|
|
case Width of
|
|
none ->
|
|
float_to_binary(Float, [{scientific, NewPrecision}]);
|
|
_ ->
|
|
term(float_to_binary(Float, [{scientific, NewPrecision}]), Width, Adjust, Width, PadChar)
|
|
end.
|
|
|
|
floatF(Float, Width, Adjust, Precision, PadChar) ->
|
|
case Precision of
|
|
none ->
|
|
NewPrecision = 6;
|
|
_ ->
|
|
NewPrecision = Precision
|
|
end,
|
|
case Width of
|
|
none ->
|
|
float_to_binary(Float, [{decimals, NewPrecision}]);
|
|
_ ->
|
|
term(float_to_binary(Float, [{decimals, NewPrecision}]), Width, Adjust, Width, PadChar)
|
|
end.
|
|
|
|
%% fwrite_g(Float, Field, Adjust, Precision, PadChar)
|
|
%% Use the f form if Float is >= 0.1 and < 1.0e4,
|
|
%% and the prints correctly in the f form, else the e form.
|
|
%% Precision always means the # of significant digits.
|
|
floatG(Float, Width, Adjust, Precision, PadChar) ->
|
|
case Float > -10000.0 andalso Float < 10000.0 of
|
|
true ->
|
|
floatF(Float, Width, Adjust, Precision, PadChar);
|
|
_ ->
|
|
floatE(Float, Width, Adjust, Precision, PadChar)
|
|
end.
|
|
|
|
floatG(Float) ->
|
|
float_to_binary(Float, [{decimals, 6}]).
|
|
|
|
strToChars(BinStr, Width, CharsLimit) ->
|
|
ByteSize = byte_size(BinStr),
|
|
if
|
|
Width == none ->
|
|
case CharsLimit < 0 orelse CharsLimit >= ByteSize of
|
|
true ->
|
|
BinStr;
|
|
_ ->
|
|
<<(binary:part(BinStr, 0, CharsLimit))/binary, "...">>
|
|
end;
|
|
CharsLimit < 0 orelse CharsLimit >= Width ->
|
|
BinStr;
|
|
true ->
|
|
<<(binary:part(BinStr, 0, CharsLimit))/binary, "...">>
|
|
end.
|
|
|
|
string(Str, Width, Adjust, Precision, PadChar, Encoding) ->
|
|
if
|
|
Width == none andalso Precision == none ->
|
|
Str;
|
|
Precision == none ->
|
|
strField(Str, Width, Adjust, eFmt:charsLen(Str), PadChar, Encoding);
|
|
Width == none ->
|
|
strField(Str, Precision, left, eFmt:charsLen(Str), PadChar, Encoding);
|
|
true ->
|
|
StrLen = eFmt:charsLen(Str),
|
|
if
|
|
Width > Precision ->
|
|
if StrLen > Precision ->
|
|
adjust(Adjust, flatTrunc(Str, Precision, Encoding), makePadChars(PadChar, Width - Precision, <<>>));
|
|
StrLen < Precision ->
|
|
adjust(Adjust, [Str | makePadChars(PadChar, Precision - StrLen, <<>>)], makePadChars(PadChar, Width - Precision, <<>>));
|
|
true -> % N == P
|
|
adjust(Adjust, Str, makePadChars(PadChar, Width - Precision, <<>>))
|
|
end;
|
|
true -> % F == P
|
|
strField(Str, Width, Adjust, StrLen, PadChar, Encoding)
|
|
end
|
|
end.
|
|
|
|
strField(Str, Width, Adjust, StrLen, PadChar, Encoding) when StrLen > Width ->
|
|
if
|
|
StrLen > Width ->
|
|
flatTrunc(Str, Width, Encoding);
|
|
StrLen < Width ->
|
|
adjust(Adjust, Str, makePadChars(PadChar, Width - StrLen, <<>>));
|
|
true ->
|
|
Str
|
|
end.
|
|
|
|
flatTrunc(List, Width, _Encoding) ->
|
|
binary:part(iolist_to_binary(List), 0, Width).
|
|
|
|
makePadChars(Char, Cnt, BinStr) ->
|
|
case Cnt > 0 of
|
|
true ->
|
|
makePadChars(Cnt - 1, Char, <<BinStr/binary, (integer_to_binary(Char))/binary>>);
|
|
_ ->
|
|
BinStr
|
|
end.
|
|
|
|
adjust(left, Data, Pad) -> [Data, Pad];
|
|
adjust(right, Data, Pad) -> [Pad, Data].
|
|
|
|
unPrefixedInt(Int, Width, Adjust, Base, PadChar, Lowercase) ->
|
|
case Lowercase of
|
|
true ->
|
|
term(toLowerStr(integer_to_binary(Int, Base)), Width, Adjust, none, PadChar);
|
|
_ ->
|
|
term(integer_to_binary(Int, Base), Width, Adjust, none, PadChar)
|
|
end.
|
|
|
|
prefixedInt(Int, Width, Adjust, Base, PadChar, Prefix, Lowercase) ->
|
|
case Int < 0 of
|
|
true ->
|
|
case Lowercase of
|
|
true ->
|
|
term(<<"-", (toBinary(Prefix))/binary, (toLowerStr(integer_to_binary(-Int, Base)))/binary>>, Width, Adjust, none, PadChar);
|
|
_ ->
|
|
term(<<"-", (toBinary(Prefix))/binary, (integer_to_binary(-Int, Base))/binary>>, Width, Adjust, none, PadChar)
|
|
end;
|
|
_ ->
|
|
case Lowercase of
|
|
true ->
|
|
term(<<(toBinary(Prefix))/binary, (toLowerStr(integer_to_binary(Int, Base)))/binary>>, Width, Adjust, none, PadChar);
|
|
_ ->
|
|
term(<<(toBinary(Prefix))/binary, (integer_to_binary(Int, Base))/binary>>, Width, Adjust, none, PadChar)
|
|
end
|
|
end.
|
|
|
|
prefixedInt(Int, Width, Adjust, Base, PadChar, Prefix, Prefix2, Lowercase) ->
|
|
case Int < 0 of
|
|
true ->
|
|
case Lowercase of
|
|
true ->
|
|
term(<<"-", (toBinary(Prefix))/binary, Prefix2:8, (toLowerStr(integer_to_binary(-Int, Base)))/binary>>, Width, Adjust, none, PadChar);
|
|
_ ->
|
|
term(<<"-", (toBinary(Prefix))/binary, Prefix2:8, (integer_to_binary(-Int, Base))/binary>>, Width, Adjust, none, PadChar)
|
|
end;
|
|
_ ->
|
|
case Lowercase of
|
|
true ->
|
|
term(<<(toBinary(Prefix))/binary, Prefix2:8, (toLowerStr(integer_to_binary(Int, Base)))/binary>>, Width, Adjust, none, PadChar);
|
|
_ ->
|
|
term(<<(toBinary(Prefix))/binary, Prefix2:8, (integer_to_binary(Int, Base))/binary>>, Width, Adjust, none, PadChar)
|
|
end
|
|
end.
|
|
|
|
char(Char, Width, Adjust, Precision, PadChar) ->
|
|
if
|
|
Width == none andalso Precision == none ->
|
|
integer_to_binary(Char);
|
|
Precision == none ->
|
|
makePadChars(Char, Width, <<>>);
|
|
Width == none ->
|
|
makePadChars(Char, Precision, <<>>);
|
|
true ->
|
|
adjust(Adjust, makePadChars(Char, Precision, <<>>), makePadChars(PadChar, Width - Precision, <<>>))
|
|
end.
|
|
|
|
newline(none, _Adjust, _Precision, _PadChar) -> <<"\n">>;
|
|
newline(Width, Adjust, _Precision, _PadChar) ->
|
|
case Adjust of
|
|
right ->
|
|
makePadChars($\n, Width, <<>>);
|
|
_ ->
|
|
<<"\n">>
|
|
end.
|
|
|
|
remainChars(T, E) ->
|
|
if
|
|
T < 0 ->
|
|
T;
|
|
T >= E ->
|
|
T - E;
|
|
true ->
|
|
0
|
|
end.
|
|
|
|
getOpt(Key, TupleList, Default) ->
|
|
case lists:keyfind(Key, 1, TupleList) of
|
|
{_, Value} ->
|
|
Value;
|
|
_ ->
|
|
Default
|
|
end.
|
|
|
|
toLowerStr(BinStr) ->
|
|
<< begin
|
|
case C >= $A andalso C =< $Z of
|
|
true ->
|
|
<<(C + 32)>>;
|
|
_ ->
|
|
<<C>>
|
|
end
|
|
end || <<C:8>> <= BinStr
|
|
>>.
|
|
|
|
toUpperStr(BinStr) ->
|
|
<< begin
|
|
case C >= $a andalso C =< $z of
|
|
true ->
|
|
<<(C - 32)>>;
|
|
_ ->
|
|
<<C>>
|
|
end
|
|
end || <<C:8>> <= BinStr
|
|
>>.
|
|
|
|
toBinary(Value) when is_integer(Value) -> integer_to_binary(Value);
|
|
toBinary(Value) when is_list(Value) -> list_to_binary(Value);
|
|
toBinary(Value) when is_float(Value) -> float_to_binary(Value, [{decimals, 6}, compact]);
|
|
toBinary(Value) when is_atom(Value) -> atom_to_binary(Value, utf8);
|
|
toBinary(Value) when is_binary(Value) -> Value;
|
|
toBinary([Tuple | PropList] = Value) when is_list(PropList) and is_tuple(Tuple) ->
|
|
lists:map(fun({K, V}) -> {toBinary(K), toBinary(V)} end, Value);
|
|
toBinary(Value) -> term_to_binary(Value).
|