%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 1996-2013. All Rights Reserved.
%%
%% 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
%% Erlang Public License along with this software. If not, it can be
%% retrieved online at http://www.erlang.org/.
%%
%% Software distributed under the License is distributed on an "AS IS"
%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%% the License for the specific language governing rights and limitations
%% under the License.
%%
%% %CopyrightEnd%
%%
-module(edlin).
%% A simple Emacs-like line editor.
%% About Latin-1 characters: see the beginning of erl_scan.erl.
-export([init/0,start/1,start/2,edit_line/2,prefix_arg/1]).
-export([erase_line/1,erase_inp/1,redraw_line/1]).
-export([length_before/1,length_after/1,prompt/1]).
-export([current_line/1, current_chars/1]).
%%-export([expand/1]).
-export([edit_line1/2]).
-import(lists, [reverse/1, reverse/2]).
-export([over_word/3]).
%% A Continuation has the structure:
%% {line,Prompt,CurrentLine,EditPrefix}
%% init()
%% Initialise the line editor. This must be done once per process using
%% the editor.
init() ->
put(kill_buffer, []).
%% start(Prompt)
%% edit(Characters, Continuation)
%% Return
%% {done,Line,Rest,Requests}
%% {more_chars,Cont,Requests}
%% {blink,Cont,Requests}
%% {undefined,Char,Rest,Cont,Requests}
start(Pbs) ->
start(Pbs, none).
%% Only two modes used: 'none' and 'search'. Other modes can be
%% handled inline through specific character handling.
start(Pbs, Mode) ->
{more_chars,{line,Pbs,{[],[]},Mode},[{put_chars,unicode,Pbs}]}.
edit_line(Cs, {line,P,L,{blink,N}}) ->
edit(Cs, P, L, none, [{move_rel,N}]);
edit_line(Cs, {line,P,L,M}) ->
edit(Cs, P, L, M, []).
edit_line1(Cs, {line,P,L,{blink,N}}) ->
edit(Cs, P, L, none, [{move_rel,N}]);
edit_line1(Cs, {line,P,{[],[]},none}) ->
{more_chars, {line,P,{lists:reverse(Cs),[]},none},[{put_chars, unicode, Cs}]};
edit_line1(Cs, {line,P,L,M}) ->
edit(Cs, P, L, M, []).
edit([C|Cs], P, Line, {blink,_}, [_|Rs]) -> %Remove blink here
edit([C|Cs], P, Line, none, Rs);
edit([C|Cs], P, {Bef,Aft}, Prefix, Rs0) ->
case key_map(C, Prefix) of
meta ->
edit(Cs, P, {Bef,Aft}, meta, Rs0);
meta_o ->
edit(Cs, P, {Bef,Aft}, meta_o, Rs0);
meta_csi ->
edit(Cs, P, {Bef,Aft}, meta_csi, Rs0);
meta_meta ->
edit(Cs, P, {Bef,Aft}, meta_meta, Rs0);
{csi, _} = Csi ->
edit(Cs, P, {Bef,Aft}, Csi, Rs0);
meta_left_sq_bracket ->
edit(Cs, P, {Bef,Aft}, meta_left_sq_bracket, Rs0);
search_meta ->
edit(Cs, P, {Bef,Aft}, search_meta, Rs0);
search_meta_left_sq_bracket ->
edit(Cs, P, {Bef,Aft}, search_meta_left_sq_bracket, Rs0);
ctlx ->
edit(Cs, P, {Bef,Aft}, ctlx, Rs0);
new_line ->
{done, reverse(Bef, Aft ++ "\n"), Cs,
reverse(Rs0, [{move_rel,length(Aft)},{put_chars,unicode,"\n"}])};
redraw_line ->
Rs1 = erase(P, Bef, Aft, Rs0),
Rs = redraw(P, Bef, Aft, Rs1),
edit(Cs, P, {Bef,Aft}, none, Rs);
tab_expand ->
{expand, Bef, Cs,
{line, P, {Bef, Aft}, none},
reverse(Rs0)};
%% tab ->
%% %% Always redraw the line since expand/1 might have printed
%% %% possible expansions.
%% case expand(Bef) of
%% {yes,Str} ->
%% edit([redraw_line|
%% (Str ++ Cs)], P, {Bef,Aft}, none, Rs0);
%% no ->
%% %% don't beep if there's only whitespace before
%% %% us - user may have pasted in a lot of indented stuff.
%% case whitespace_only(Bef) of
%% false ->
%% edit([redraw_line|Cs], P, {Bef,Aft}, none,
%% [beep|Rs0]);
%% true ->
%% edit([redraw_line|Cs], P, {Bef,Aft}, none, [Rs0])
%% end
%% end;
{undefined,C} ->
{undefined,{none,Prefix,C},Cs,{line,P,{Bef,Aft},none},
reverse(Rs0)};
Op ->
case do_op(Op, Bef, Aft, Rs0) of
{blink,N,Line,Rs} ->
edit(Cs, P, Line, {blink,N}, Rs);
{Line, Rs, Mode} -> % allow custom modes from do_op
edit(Cs, P, Line, Mode, Rs);
{Line,Rs} ->
edit(Cs, P, Line, none, Rs)
end
end;
edit([], P, L, {blink,N}, Rs) ->
{blink,{line,P,L,{blink,N}},reverse(Rs)};
edit([], P, L, Prefix, Rs) ->
{more_chars,{line,P,L,Prefix},reverse(Rs)};
edit(eof, _, {Bef,Aft}, _, Rs) ->
{done,reverse(Bef, Aft),[],reverse(Rs, [{move_rel,length(Aft)}])}.
%% %% Assumes that arg is a string
%% %% Horizontal whitespace only.
%% whitespace_only([]) ->
%% true;
%% whitespace_only([C|Rest]) ->
%% case C of
%% $\s ->
%% whitespace_only(Rest);
%% $\t ->
%% whitespace_only(Rest);
%% _ ->
%% false
%% end.
%% prefix_arg(Argument)
%% Take a prefix argument and return its numeric value.
prefix_arg(none) -> 1;
prefix_arg({ctlu,N}) -> N;
prefix_arg(N) -> N.
%% key_map(Char, Prefix)
%% Map a character and a prefix to an action.
key_map(A, _) when is_atom(A) -> A; % so we can push keywords
key_map($\^A, none) -> beginning_of_line;
key_map($\^B, none) -> backward_char;
key_map($\^D, none) -> forward_delete_char;
key_map($\^E, none) -> end_of_line;
key_map($\^F, none) -> forward_char;
key_map($\^H, none) -> backward_delete_char;
key_map($\t, none) -> tab_expand;
key_map($\^L, none) -> redraw_line;
key_map($\n, none) -> new_line;
key_map($\^K, none) -> kill_line;
key_map($\r, none) -> new_line;
key_map($\^T, none) -> transpose_char;
key_map($\^U, none) -> ctlu;
key_map($\^], none) -> auto_blink;
key_map($\^X, none) -> ctlx;
key_map($\^Y, none) -> yank;
key_map($\^W, none) -> backward_kill_word;
key_map($\e, none) -> meta;
key_map($), Prefix) when Prefix =/= meta,
Prefix =/= search,
Prefix =/= search_meta -> {blink,$),$(};
key_map($}, Prefix) when Prefix =/= meta,
Prefix =/= search,
Prefix =/= search_meta -> {blink,$},${};
key_map($], Prefix) when Prefix =/= meta,
Prefix =/= search,
Prefix =/= search_meta -> {blink,$],$[};
key_map($B, meta) -> backward_word;
key_map($D, meta) -> kill_word;
key_map($F, meta) -> forward_word;
key_map($T, meta) -> transpose_word;
key_map($Y, meta) -> yank_pop;
key_map($b, meta) -> backward_word;
key_map($d, meta) -> kill_word;
key_map($f, meta) -> forward_word;
key_map($t, meta) -> transpose_word;
key_map($y, meta) -> yank_pop;
key_map($O, meta) -> meta_o;
key_map($H, meta_o) -> beginning_of_line;
key_map($F, meta_o) -> end_of_line;
key_map($\177, none) -> backward_delete_char;
key_map($\177, meta) -> backward_kill_word;
key_map($[, meta) -> meta_left_sq_bracket;
key_map($D, meta_left_sq_bracket) -> backward_char;
key_map($C, meta_left_sq_bracket) -> forward_char;
% support a few <CTRL>+<CURSOR LEFT|RIGHT> combinations...
% - forward: \e\e[C, \e[5C, \e[1;5C
% - backward: \e\e[D, \e[5D, \e[1;5D
key_map($\e, meta) -> meta_meta;
key_map($[, meta_meta) -> meta_csi;
key_map($C, meta_csi) -> forward_word;
key_map($D, meta_csi) -> backward_word;
key_map($1, meta_left_sq_bracket) -> {csi, "1"};
key_map($5, meta_left_sq_bracket) -> {csi, "5"};
key_map($5, {csi, "1;"}) -> {csi, "1;5"};
key_map($C, {csi, "5"}) -> forward_word;
key_map($C, {csi, "1;5"}) -> forward_word;
key_map($D, {csi, "5"}) -> backward_word;
key_map($D, {csi, "1;5"}) -> backward_word;
key_map($;, {csi, "1"}) -> {csi, "1;"};
key_map(C, none) when C >= $\s ->
{insert,C};
%% for search, we need smarter line handling and so
%% we cheat a bit on the dispatching, and allow to
%% return a mode.
key_map($\^H, search) -> {search, backward_delete_char};
key_map($\177, search) -> {search, backward_delete_char};
key_map($\^R, search) -> {search, skip_up};
key_map($\^S, search) -> {search, skip_down};
key_map($\n, search) -> {search, search_found};
key_map($\r, search) -> {search, search_found};
key_map($\^A, search) -> {search, search_quit};
key_map($\^B, search) -> {search, search_quit};
key_map($\^D, search) -> {search, search_quit};
key_map($\^E, search) -> {search, search_quit};
key_map($\^F, search) -> {search, search_quit};
key_map($\t, search) -> {search, search_quit};
key_map($\^L, search) -> {search, search_quit};
key_map($\^T, search) -> {search, search_quit};
key_map($\^U, search) -> {search, search_quit};
key_map($\^], search) -> {search, search_quit};
key_map($\^X, search) -> {search, search_quit};
key_map($\^Y, search) -> {search, search_quit};
key_map($\e, search) -> search_meta;
key_map($[, search_meta) -> search_meta_left_sq_bracket;
key_map(_, search_meta) -> {search, search_quit};
key_map(_C, search_meta_left_sq_bracket) -> {search, search_quit};
key_map(C, search) -> {insert_search,C};
key_map(C, _) -> {undefined,C}.
%% do_op(Action, Before, After, Requests)
do_op({insert,C}, Bef, [], Rs) ->
{{[C|Bef],[]},[{put_chars, unicode,[C]}|Rs]};
do_op({insert,C}, Bef, Aft, Rs) ->
{{[C|Bef],Aft},[{insert_chars, unicode, [C]}|Rs]};
%% Search mode prompt always looks like (search)`$TERMS': $RESULT.
%% the {insert_search, _} handlings allow to share this implementation
%% correctly with group.erl. This module provides $TERMS, and group.erl
%% is in charge of providing $RESULT.
%% This require a bit of trickery. Because search disables moving around
%% on the line (left/right arrow keys and other shortcuts that just exit
%% search mode), we can use the Bef and Aft variables to hold each
%% part of the line. Bef takes charge of "(search)`$TERMS" and Aft
%% takes charge of "': $RESULT".
do_op({insert_search, C}, Bef, [], Rs) ->
Aft="': ",
{{[C|Bef],Aft},
[{insert_chars, unicode, [C]++Aft}, {delete_chars,-3} | Rs],
search};
do_op({insert_search, C}, Bef, Aft, Rs) ->
Offset= length(Aft),
NAft = "': ",
{{[C|Bef],NAft},
[{insert_chars, unicode, [C]++NAft}, {delete_chars,-Offset} | Rs],
search};
do_op({search, backward_delete_char}, [_|Bef], Aft, Rs) ->
Offset= length(Aft)+1,
NAft = "': ",
{{Bef,NAft},
[{insert_chars, unicode, NAft}, {delete_chars,-Offset}|Rs],
search};
do_op({search, backward_delete_char}, [], _Aft, Rs) ->
Aft="': ",
{{[],Aft}, Rs, search};
do_op({search, skip_up}, Bef, Aft, Rs) ->
Offset= length(Aft),
NAft = "': ",
{{[$\^R|Bef],NAft}, % we insert ^R as a flag to whoever called us
[{insert_chars, unicode, NAft}, {delete_chars,-Offset}|Rs],
search};
do_op({search, skip_down}, Bef, Aft, Rs) ->
Offset= length(Aft),
NAft = "': ",
{{[$\^S|Bef],NAft}, % we insert ^S as a flag to whoever called us
[{insert_chars, unicode, NAft}, {delete_chars,-Offset}|Rs],
search};
do_op({search, search_found}, _Bef, Aft, Rs) ->
"': "++NAft = Aft,
{{[],NAft},
[{put_chars, unicode, "\n"}, {move_rel,-length(Aft)} | Rs],
search_found};
do_op({search, search_quit}, _Bef, Aft, Rs) ->
"': "++NAft = Aft,
{{[],NAft},
[{put_chars, unicode, "\n"}, {move_rel,-length(Aft)} | Rs],
search_quit};
%% do blink after $$
do_op({blink,C,M}, Bef=[$$,$$|_], Aft, Rs) ->
N = over_paren(Bef, C, M),
{blink,N+1,{[C|Bef],Aft},[{move_rel,-(N+1)},{insert_chars, unicode,[C]}|Rs]};
%% don't blink after a $
do_op({blink,C,_}, Bef=[$$|_], Aft, Rs) ->
do_op({insert,C}, Bef, Aft, Rs);
%do_op({blink,C,M}, Bef, [], Rs) ->
% N = over_paren(Bef, C, M),
% {blink,N+1,{[C|Bef],[]},[{move_rel,-(N+1)},{put_chars,[C]}|Rs]};
do_op({blink,C,M}, Bef, Aft, Rs) ->
case over_paren(Bef, C, M) of
beep ->
{{[C|Bef], Aft}, [beep,{insert_chars, unicode, [C]}|Rs]};
N -> {blink,N+1,{[C|Bef],Aft},
[{move_rel,-(N+1)},{insert_chars, unicode,[C]}|Rs]}
end;
do_op(auto_blink, Bef, Aft, Rs) ->
case over_paren_auto(Bef) of
{N, Paren} ->
{blink,N+1,
{[Paren|Bef], Aft},[{move_rel,-(N+1)},{insert_chars, unicode,[Paren]}|Rs]};
% N is likely 0
N -> {blink,N+1,{Bef,Aft},
[{move_rel,-(N+1)}|Rs]}
end;
do_op(forward_delete_char, Bef, [_|Aft], Rs) ->
{{Bef,Aft},[{delete_chars,1}|Rs]};
do_op(backward_delete_char, [_|Bef], Aft, Rs) ->
{{Bef,Aft},[{delete_chars,-1}|Rs]};
do_op(transpose_char, [C1,C2|Bef], [], Rs) ->
{{[C2,C1|Bef],[]},[{put_chars, unicode,[C1,C2]},{move_rel,-2}|Rs]};
do_op(transpose_char, [C2|Bef], [C1|Aft], Rs) ->
{{[C2,C1|Bef],Aft},[{put_chars, unicode,[C1,C2]},{move_rel,-1}|Rs]};
do_op(kill_word, Bef, Aft0, Rs) ->
{Aft1,Kill0,N0} = over_non_word(Aft0, [], 0),
{Aft,Kill,N} = over_word(Aft1, Kill0, N0),
put(kill_buffer, reverse(Kill)),
{{Bef,Aft},[{delete_chars,N}|Rs]};
do_op(backward_kill_word, Bef0, Aft, Rs) ->
{Bef1,Kill0,N0} = over_non_word(Bef0, [], 0),
{Bef,Kill,N} = over_word(Bef1, Kill0, N0),
put(kill_buffer, Kill),
{{Bef,Aft},[{delete_chars,-N}|Rs]};
do_op(kill_line, Bef, Aft, Rs) ->
put(kill_buffer, Aft),
{{Bef,[]},[{delete_chars,length(Aft)}|Rs]};
do_op(yank, Bef, [], Rs) ->
Kill = get(kill_buffer),
{{reverse(Kill, Bef),[]},[{put_chars, unicode,Kill}|Rs]};
do_op(yank, Bef, Aft, Rs) ->
Kill = get(kill_buffer),
{{reverse(Kill, Bef),Aft},[{insert_chars, unicode,Kill}|Rs]};
do_op(forward_char, Bef, [C|Aft], Rs) ->
{{[C|Bef],Aft},[{move_rel,1}|Rs]};
do_op(backward_char, [C|Bef], Aft, Rs) ->
{{Bef,[C|Aft]},[{move_rel,-1}|Rs]};
do_op(forward_word, Bef0, Aft0, Rs) ->
{Aft1,Bef1,N0} = over_non_word(Aft0, Bef0, 0),
{Aft,Bef,N} = over_word(Aft1, Bef1, N0),
{{Bef,Aft},[{move_rel,N}|Rs]};
do_op(backward_word, Bef0, Aft0, Rs) ->
{Bef1,Aft1,N0} = over_non_word(Bef0, Aft0, 0),
{Bef,Aft,N} = over_word(Bef1, Aft1, N0),
{{Bef,Aft},[{move_rel,-N}|Rs]};
do_op(beginning_of_line, [C|Bef], Aft, Rs) ->
{{[],reverse(Bef, [C|Aft])},[{move_rel,-(length(Bef)+1)}|Rs]};
do_op(beginning_of_line, [], Aft, Rs) ->
{{[],Aft},Rs};
do_op(end_of_line, Bef, [C|Aft], Rs) ->
{{reverse(Aft, [C|Bef]),[]},[{move_rel,length(Aft)+1}|Rs]};
do_op(end_of_line, Bef, [], Rs) ->
{{Bef,[]},Rs};
do_op(ctlu, Bef, Aft, Rs) ->
put(kill_buffer, Bef),
{{[], Aft}, [{delete_chars, -length(Bef)} | Rs]};
do_op(beep, Bef, Aft, Rs) ->
{{Bef,Aft},[beep|Rs]};
do_op(_, Bef, Aft, Rs) ->
{{Bef,Aft},[beep|Rs]}.
%% over_word(Chars, InitialStack, InitialCount) ->
%% {RemainingChars,CharStack,Count}
%% over_non_word(Chars, InitialStack, InitialCount) ->
%% {RemainingChars,CharStack,Count}
%% Step over word/non-word characters pushing the stepped over ones on
%% the stack.
over_word(Cs, Stack, N) ->
L = length([1 || $\' <- Cs]),
case L rem 2 of
0 ->
over_word1(Cs, Stack, N);
1 ->
until_quote(Cs, Stack, N)
end.
until_quote([$\'|Cs], Stack, N) ->
{Cs, [$\'|Stack], N+1};
until_quote([C|Cs], Stack, N) ->
until_quote(Cs, [C|Stack], N+1).
over_word1([$\'=C|Cs], Stack, N) ->
until_quote(Cs, [C|Stack], N+1);
over_word1(Cs, Stack, N) ->
over_word2(Cs, Stack, N).
over_word2([C|Cs], Stack, N) ->
case word_char(C) of
true -> over_word2(Cs, [C|Stack], N+1);
false -> {[C|Cs],Stack,N}
end;
over_word2([], Stack, N) when is_integer(N) ->
{[],Stack,N}.
over_non_word([C|Cs], Stack, N) ->
case word_char(C) of
true -> {[C|Cs],Stack,N};
false -> over_non_word(Cs, [C|Stack], N+1)
end;
over_non_word([], Stack, N) ->
{[],Stack,N}.
word_char(C) when C >= $A, C =< $Z -> true;
word_char(C) when C >= $À, C =< $Þ, C =/= $× -> true;
word_char(C) when C >= $a, C =< $z -> true;
word_char(C) when C >= $ß, C =< $ÿ, C =/= $÷ -> true;
word_char(C) when C >= $0, C =< $9 -> true;
word_char(C) when C =:= $_ -> true;
word_char(C) when C =:= $. -> true; % accept dot-separated names
word_char(_) -> false.
%% over_white(Chars, InitialStack, InitialCount) ->
%% {RemainingChars,CharStack,Count}
%% over_white([$\s|Cs], Stack, N) ->
%% over_white(Cs, [$\s|Stack], N+1);
%% over_white([$\t|Cs], Stack, N) ->
%% over_white(Cs, [$\t|Stack], N+1);
%% over_white(Cs, Stack, N) ->
%% {Cs,Stack,N}.
%% over_paren(Chars, Paren, Match)
%% over_paren(Chars, Paren, Match, Depth, N)
%% Step over parentheses until matching Paren is found at depth 0. Don't
%% do proper parentheses matching check. Paren has NOT been added.
over_paren(Chars, Paren, Match) ->
over_paren(Chars, Paren, Match, 1, 1, []).
over_paren([C,$$,$$|Cs], Paren, Match, D, N, L) ->
over_paren([C|Cs], Paren, Match, D, N+2, L);
over_paren([_,$$|Cs], Paren, Match, D, N, L) ->
over_paren(Cs, Paren, Match, D, N+2, L);
over_paren([Match|_], _Paren, Match, 1, N, _) ->
N;
over_paren([Match|Cs], Paren, Match, D, N, [Match|L]) ->
over_paren(Cs, Paren, Match, D-1, N+1, L);
over_paren([Paren|Cs], Paren, Match, D, N, L) ->
over_paren(Cs, Paren, Match, D+1, N+1, [Match|L]);
over_paren([$)|Cs], Paren, Match, D, N, L) ->
over_paren(Cs, Paren, Match, D, N+1, [$(|L]);
over_paren([$]|Cs], Paren, Match, D, N, L) ->
over_paren(Cs, Paren, Match, D, N+1, [$[|L]);
over_paren([$}|Cs], Paren, Match, D, N, L) ->
over_paren(Cs, Paren, Match, D, N+1, [${|L]);
over_paren([$(|Cs], Paren, Match, D, N, [$(|L]) ->
over_paren(Cs, Paren, Match, D, N+1, L);
over_paren([$[|Cs], Paren, Match, D, N, [$[|L]) ->
over_paren(Cs, Paren, Match, D, N+1, L);
over_paren([${|Cs], Paren, Match, D, N, [${|L]) ->
over_paren(Cs, Paren, Match, D, N+1, L);
over_paren([$(|_], _, _, _, _, _) ->
beep;
over_paren([$[|_], _, _, _, _, _) ->
beep;
over_paren([${|_], _, _, _, _, _) ->
beep;
over_paren([_|Cs], Paren, Match, D, N, L) ->
over_paren(Cs, Paren, Match, D, N+1, L);
over_paren([], _, _, _, _, _) ->
0.
over_paren_auto(Chars) ->
over_paren_auto(Chars, 1, 1, []).
over_paren_auto([C,$$,$$|Cs], D, N, L) ->
over_paren_auto([C|Cs], D, N+2, L);
over_paren_auto([_,$$|Cs], D, N, L) ->
over_paren_auto(Cs, D, N+2, L);
over_paren_auto([$(|_], _, N, []) ->
{N, $)};
over_paren_auto([$[|_], _, N, []) ->
{N, $]};
over_paren_auto([${|_], _, N, []) ->
{N, $}};
over_paren_auto([$)|Cs], D, N, L) ->
over_paren_auto(Cs, D, N+1, [$(|L]);
over_paren_auto([$]|Cs], D, N, L) ->
over_paren_auto(Cs, D, N+1, [$[|L]);
over_paren_auto([$}|Cs], D, N, L) ->
over_paren_auto(Cs, D, N+1, [${|L]);
over_paren_auto([$(|Cs], D, N, [$(|L]) ->
over_paren_auto(Cs, D, N+1, L);
over_paren_auto([$[|Cs], D, N, [$[|L]) ->
over_paren_auto(Cs, D, N+1, L);
over_paren_auto([${|Cs], D, N, [${|L]) ->
over_paren_auto(Cs, D, N+1, L);
over_paren_auto([_|Cs], D, N, L) ->
over_paren_auto(Cs, D, N+1, L);
over_paren_auto([], _, _, _) ->
0.
%% erase_line(Line)
%% erase_inp(Line)
%% redraw_line(Line)
%% length_before(Line)
%% length_after(Line)
%% prompt(Line)
%% current_line(Line)
%% Various functions for accessing bits of a line.
erase_line({line,Pbs,{Bef,Aft},_}) ->
reverse(erase(Pbs, Bef, Aft, [])).
erase_inp({line,_,{Bef,Aft},_}) ->
reverse(erase([], Bef, Aft, [])).
erase(Pbs, Bef, Aft, Rs) ->
[{delete_chars,-length(Pbs)-length(Bef)},{delete_chars,length(Aft)}|Rs].
redraw_line({line,Pbs,{Bef,Aft},_}) ->
reverse(redraw(Pbs, Bef, Aft, [])).
redraw(Pbs, Bef, Aft, Rs) ->
[{move_rel,-length(Aft)},{put_chars, unicode,reverse(Bef, Aft)},{put_chars, unicode,Pbs}|Rs].
length_before({line,Pbs,{Bef,_Aft},_}) ->
length(Pbs) + length(Bef).
length_after({line,_,{_Bef,Aft},_}) ->
length(Aft).
prompt({line,Pbs,_,_}) ->
Pbs.
current_line({line,_,{Bef, Aft},_}) ->
reverse(Bef, Aft ++ "\n").
current_chars({line,_,{Bef,Aft},_}) ->
reverse(Bef, Aft).
%% %% expand(CurrentBefore) ->
%% %% {yes,Expansion} | no
%% %% Try to expand the word before as either a module name or a function
%% %% name. We can handle white space around the seperating ':' but the
%% %% function name must be on the same line. CurrentBefore is reversed
%% %% and over_word/3 reverses the characters it finds. In certain cases
%% %% possible expansions are printed.
%% expand(Bef0) ->
%% {Bef1,Word,_} = over_word(Bef0, [], 0),
%% case over_white(Bef1, [], 0) of
%% {[$:|Bef2],_White,_Nwh} ->
%% {Bef3,_White1,_Nwh1} = over_white(Bef2, [], 0),
%% {_,Mod,_Nm} = over_word(Bef3, [], 0),
%% expand_function_name(Mod, Word);
%% {_,_,_} ->
%% expand_module_name(Word)
%% end.
%% expand_module_name(Prefix) ->
%% match(Prefix, code:all_loaded(), ":").
%% expand_function_name(ModStr, FuncPrefix) ->
%% Mod = list_to_atom(ModStr),
%% case erlang:module_loaded(Mod) of
%% true ->
%% L = apply(Mod, module_info, []),
%% case lists:keyfind(exports, 1, L) of
%% {_, Exports} ->
%% match(FuncPrefix, Exports, "(");
%% _ ->
%% no
%% end;
%% false ->
%% no
%% end.
%% match(Prefix, Alts, Extra) ->
%% Matches = match1(Prefix, Alts),
%% case longest_common_head([N || {N,_} <- Matches]) of
%% {partial, []} ->
%% print_matches(Matches),
%% no;
%% {partial, Str} ->
%% case lists:nthtail(length(Prefix), Str) of
%% [] ->
%% print_matches(Matches),
%% {yes, []};
%% Remain ->
%% {yes, Remain}
%% end;
%% {complete, Str} ->
%% {yes, lists:nthtail(length(Prefix), Str) ++ Extra};
%% no ->
%% no
%% end.
%% %% Print the list of names L in multiple columns.
%% print_matches(L) ->
%% io:nl(),
%% col_print(lists:sort(L)),
%% ok.
%% col_print([]) -> ok;
%% col_print(L) -> col_print(L, field_width(L), 0).
%% col_print(X, Width, Len) when Width + Len > 79 ->
%% io:nl(),
%% col_print(X, Width, 0);
%% col_print([{H0,A}|T], Width, Len) ->
%% H = if
%% %% If the second element is an integer, we assume it's an
%% %% arity, and meant to be printed.
%% integer(A) ->
%% H0 ++ "/" ++ integer_to_list(A);
%% true ->
%% H0
%% end,
%% io:format("~-*s",[Width,H]),
%% col_print(T, Width, Len+Width);
%% col_print([], _, _) ->
%% io:nl().
%% field_width([{H,_}|T]) -> field_width(T, length(H)).
%% field_width([{H,_}|T], W) ->
%% case length(H) of
%% L when L > W -> field_width(T, L);
%% _ -> field_width(T, W)
%% end;
%% field_width([], W) when W < 40 ->
%% W + 4;
%% field_width([], _) ->
%% 40.
%% match1(Prefix, Alts) ->
%% match1(Prefix, Alts, []).
%% match1(Prefix, [{H,A}|T], L) ->
%% case prefix(Prefix, Str = atom_to_list(H)) of
%% true ->
%% match1(Prefix, T, [{Str,A}|L]);
%% false ->
%% match1(Prefix, T, L)
%% end;
%% match1(_, [], L) ->
%% L.
%% longest_common_head([]) ->
%% no;
%% longest_common_head(LL) ->
%% longest_common_head(LL, []).
%% longest_common_head([[]|_], L) ->
%% {partial, reverse(L)};
%% longest_common_head(LL, L) ->
%% case same_head(LL) of
%% true ->
%% [[H|_]|_] = LL,
%% LL1 = all_tails(LL),
%% case all_nil(LL1) of
%% false ->
%% longest_common_head(LL1, [H|L]);
%% true ->
%% {complete, reverse([H|L])}
%% end;
%% false ->
%% {partial, reverse(L)}
%% end.
%% same_head([[H|_]|T1]) -> same_head(H, T1).
%% same_head(H, [[H|_]|T]) -> same_head(H, T);
%% same_head(_, []) -> true;
%% same_head(_, _) -> false.
%% all_tails(LL) -> all_tails(LL, []).
%% all_tails([[_|T]|T1], L) -> all_tails(T1, [T|L]);
%% all_tails([], L) -> L.
%% all_nil([]) -> true;
%% all_nil([[] | Rest]) -> all_nil(Rest);
%% all_nil(_) -> false.
