%%%----------------------------------------------------------------------
%%% File    : eed.erl
%%% Author  : Bjorn Gustavsson <bjorn@strider>
%%% Purpose : Unix `ed' look-alike.
%%% Created : 24 Aug 1997 by Bjorn Gustavsson <bjorn@strider>
%%%----------------------------------------------------------------------

-module(eed).
-author('bjorn@strider').

-export([edit/0, edit/1, file/1, cmd_line/1]).

-record(state, {dot = 0,			% Line number of dot.
		upto_dot = [],			% Lines up to dot (reversed).
		after_dot = [],			% Lines after dot.
		lines = 0,			% Total number of lines.
		print=false,			% Print after command.
		filename=[],			% Current file.
		pattern,			% Current pattern.
		in_global=false,		% True if executing global command.
		input=[],			% Global input stream.
		undo,				% Last undo state.
		marks=[],			% List of marks.
		modified=false,			% Buffer is modified.
		opts=[{prompt, ''}],		% Options.
		last_error,			% The last error encountered.
		input_fd			% Input file descriptor.
	       }).

-record(line, {contents,			% Contents of line.
	       mark=false			% Marked (for global prefix).
	      }).

cmd_line([Script]) ->
    file(Script),
    halt().

file(Script) ->
    case file:open(Script, [read]) of
	{ok,Fd} ->
	    loop(#state{input_fd=Fd}),
	    ok;
	{error,E} ->
	    {error,E}
    end.

edit() ->
    loop(#state{input_fd=group_leader()}).

edit(Name) ->
    loop(command([$e|Name], #state{input_fd=group_leader()})).

loop(St0) ->
    {ok, St1, Cmd} = get_line(St0),
    case catch command(lib:nonl(Cmd), St1) of
	{'EXIT', Reason} ->
	    %% XXX Should clear outstanding global command here.
	    loop(print_error({'EXIT', Reason}, St1));
	quit ->
	    ok;
	{error, Reason} ->
	    loop(print_error(Reason, St1));
	St2 when record(St2, state) ->
	    loop(St2)
    end.

command(Cmd, St) ->
    case parse_command(Cmd, St) of
	quit ->
	    quit;
	St1 when function(St1#state.print) ->
	    if
		St1#state.dot /= 0 ->
		    print_current(St1);
		true ->
		    ok
	    end,
	    St1#state{print=false};
	St1 when record(St1, state) ->
	    St1
    end.

get_line(St) ->
    Opts = St#state.opts,
    {value, {prompt, Prompt}} = lists:keysearch(prompt, 1, Opts),
    get_line(Prompt, St).

get_line(Prompt, St) when St#state.input == [] ->
    Line = get_line1(St#state.input_fd, Prompt, []),
    {ok, St, Line};
get_line(_, St) ->
    get_input(St#state.input, St, []).

get_input([eof], St, []) ->
    {ok, St, eof};
get_input([eof], St, Result) ->
    {ok, St#state{input=[eof]}, lists:reverse(Result)};
get_input([$\n|Rest], St, Result) ->
    {ok, St#state{input=Rest}, lists:reverse(Result)};
get_input([C|Rest], St, Result) ->
    get_input(Rest, St, [C|Result]).

get_line1(Io, Prompt, Result) ->
    get_line2(Io, io:get_line(Io, Prompt), Result).

get_line2(Io, eof, []) ->
    eof;
get_line2(Io, eof, Result) ->
    lists:reverse(Result);
get_line2(Io, [$\\, $\n], Result) ->
    get_line1(Io, '', [$\n|Result]);
get_line2(Io, [$\n], Result) ->
    lists:reverse(Result, [$\n]);
get_line2(Io, [C|Rest], Result) ->
    get_line2(Io, Rest, [C|Result]).

print_error(Reason, St0) ->
    St1 = St0#state{last_error=Reason},
    io:put_chars("?\n"),
    case lists:member(help_always, St1#state.opts) of
	true ->
	    help_command([], [], St1),
	    St1;
	false ->
	    St1
    end.

format_error(bad_command) -> "unknown command";
format_error(bad_filename) -> "illegal or missing filename";
format_error(bad_file) -> "cannot open input file";
format_error(bad_linenum) -> "line out of range";
format_error(bad_delimiter) -> "illegal or missing delimiter";
format_error(bad_undo) -> "nothing to undo";
format_error(bad_mark) -> "mark not lower case ascii";
format_error(bad_pattern) -> "invalid regular expression";
format_error(buffer_modified) -> "warning: expecting `w'";
format_error(nested_globals) -> "multiple globals not allowed";
format_error(nomatch) -> "search string not found";
format_error(missing_space) -> "no space after command";
format_error(garbage_after_command) -> "illegal suffix";
format_error(not_implemented) -> "not implemented yet";
format_error({'EXIT', {Code, {Mod, Func, Args}}}) ->
    lists:flatten(io_lib:format("aborted due to bug (~p)",
				[{Code, {Mod, Func, length(Args)}}]));
format_error(A) -> atom_to_list(A).



%%% Parsing commands.

parse_command(Cmd, St) ->
    parse_command(Cmd, St, []).

parse_command(Cmd, State, Nums) ->
    case get_one(Cmd, State) of
	{ok, Num, Rest, NewState} ->
	    parse_next_address(Rest, NewState, [Num|Nums]);
	false ->
	    parse_command1(Cmd, State, Nums)
    end.

parse_next_address([$,|Rest], State, Nums) ->
    parse_command(Rest, State, Nums);
parse_next_address([$;|Rest], State, [Num|Nums]) ->
    parse_command(Rest, move_to(Num, State), [Num|Nums]);
parse_next_address(Rest, State, Nums) ->
    parse_command1(Rest, State, Nums).

parse_command1([Letter|Rest], State, Nums) ->
    Cont = fun(Fun, NumLines, Def) ->
		   execute_command(Fun, NumLines, Def, State, Nums, Rest) end,
    parse_cmd_char(Letter, Cont);
parse_command1([], State, Nums) ->
    execute_command(fun print_command/3, 1, next, State, Nums, []).

get_one(Cmd, St) ->
    case get_address(Cmd, St) of
	{ok, Addr, Cmd1, St1} ->
	    get_one1(Cmd1, Addr, St1);
	false ->
	    get_one1(Cmd, false, St)
    end.

get_one1([D|Rest], false, St) when $0 =< D, D =< $9 ->
    get_one2(get_number([D|Rest]), 1, 0, St);
get_one1([D|Rest], Sum, St) when $0 =< D, D =< $9 ->
    get_one2(get_number([D|Rest]), 1, Sum, St);
get_one1([$+, D|Rest], Sum, St) when $0 =< D, D =< $9 ->
    get_one2(get_number([D|Rest]), 1, Sum, St);
get_one1([$-, D|Rest], Sum, St) when $0 =< D, D =< $9 ->
    get_one2(get_number([D|Rest]), -1, Sum, St);
get_one1([$+|Rest], Sum, St) ->
    get_one2({ok, 1, Rest}, 1, Sum, St);
get_one1([$-|Rest], Sum, St) ->
    get_one2({ok, 1, Rest}, -1, Sum, St);
get_one1(Cmd, false, St) ->
    false;
get_one1(Cmd, Sum, St) ->
    {ok, Sum, Cmd, St}.

get_one2({ok, Number, Rest}, Mul, false, St) ->
    get_one1(Rest, St#state.dot+Mul*Number, St);
get_one2({ok, Number, Rest}, Mul, Sum, St) ->
    get_one1(Rest, Sum+Mul*Number, St).

get_number(Cmd) ->
    get_number(Cmd, 0).

get_number([D|Rest], Result) when $0 =< D, D =< $9 ->
    get_number(Rest, Result*10+D-$0);
get_number(Rest, Result) ->
    {ok, Result, Rest}.

get_address([$.|Rest], State) ->
    {ok, State#state.dot, Rest, State};
get_address([$$|Rest], State) ->
    {ok, State#state.lines, Rest, State};
get_address([$', Mark|Rest], St) when $a =< Mark, Mark =< $z ->
    case lists:keysearch(Mark, 2, St#state.marks) of
	{value, {Line, Mark}} ->
	    {ok, Line, Rest, St};
	false ->
	    {ok, 0, Rest, St}
    end;
get_address([$'|Rest], State) ->
    error(bad_mark);
get_address([$/|Rest], State) ->
    scan_forward($/, Rest, State);
get_address([$?|Rest], State) ->
    error(not_implemented);
get_address(Cmd, St) ->
    false.

scan_forward(End, Patt0, State) ->
    {ok, Rest, NewState} = get_pattern(End, Patt0, State),
    Dot = NewState#state.dot,
    After = NewState#state.after_dot,
    scan_forward1(Dot+1, After, NewState, Rest).

scan_forward1(Linenum, [Line|Rest], State, RestCmd) ->
    case regexp:first_match(Line#line.contents, State#state.pattern) of
	{match, _, _} ->
	    {ok, Linenum, RestCmd, State};
	nomatch ->
	    scan_forward1(Linenum+1, Rest, State, RestCmd)
    end;
scan_forward1(_, [], State, RestCmd) ->
    Dot = State#state.dot,
    Upto = State#state.upto_dot,
    case scan_forward2(Dot, Upto, State, RestCmd) of
	false ->
	    error(bad_linenum);
	Other ->
	    Other
    end.

scan_forward2(0, [], State, RestCmd) ->
    false;
scan_forward2(Linenum, [Line|Rest], State, RestCmd) ->
    case scan_forward2(Linenum-1, Rest, State, RestCmd) of
	false ->
	    case regexp:first_match(Line#line.contents, State#state.pattern) of
		{match, _, _} ->
		    {ok, Linenum, RestCmd, State};
		nomatch ->
		    false
	    end;
	Other ->
	    Other
    end.

parse_cmd_char($S, Cont) -> Cont(fun quest_command/3, 0, none);
parse_cmd_char($T, Cont) -> Cont(fun time_command/3, 0, none);
parse_cmd_char($=, Cont) -> Cont(fun print_linenum/3, 1, last);
parse_cmd_char($a, Cont) -> Cont(fun append_command/3, 1, dot);
parse_cmd_char($c, Cont) -> Cont(fun change_command/3, 2, dot);
parse_cmd_char($d, Cont) -> Cont(fun delete_command/3, 2, dot);
parse_cmd_char($e, Cont) -> Cont(fun enter_command/3, 0, none);
parse_cmd_char($E, Cont) -> Cont(fun enter_always_command/3, 0, none);
parse_cmd_char($f, Cont) -> Cont(fun file_command/3, 0, none);
parse_cmd_char($g, Cont) -> Cont(fun global_command/3, 2, all);
parse_cmd_char($h, Cont) -> Cont(fun help_command/3, 0, none);
parse_cmd_char($H, Cont) -> Cont(fun help_always_command/3, 0, none);
parse_cmd_char($i, Cont) -> Cont(fun insert_command/3, 1, dot);
parse_cmd_char($k, Cont) -> Cont(fun mark_command/3, 1, dot);
parse_cmd_char($l, Cont) -> Cont(fun list_command/3, 2, dot);
parse_cmd_char($m, Cont) -> Cont(fun move_command/3, 2, dot);
parse_cmd_char($n, Cont) -> Cont(fun number_command/3, 2, dot);
parse_cmd_char($p, Cont) -> Cont(fun print_command/3, 2, dot);
parse_cmd_char($P, Cont) -> Cont(fun prompt_command/3, 0, none);
parse_cmd_char($q, Cont) -> Cont(fun quit_command/3, 0, none);
parse_cmd_char($Q, Cont) -> Cont(fun quit_always_command/3, 0, none);
parse_cmd_char($r, Cont) -> Cont(fun read_command/3, 1, last);
parse_cmd_char($s, Cont) -> Cont(fun subst_command/3, 2, dot);
parse_cmd_char($t, Cont) -> Cont(fun transpose_command/3, 2, dot);
parse_cmd_char($u, Cont) -> Cont(fun undo_command/3, 0, none);
parse_cmd_char($v, Cont) -> Cont(fun vglobal_command/3, 2, all);
parse_cmd_char($w, Cont) -> Cont(fun write_command/3, 2, all);
parse_cmd_char(_, Cont)  -> error(bad_command).

execute_command(Fun, NumLines, Def, State, Nums, Rest) ->
    Lines = check_lines(NumLines, Def, Nums, State),
    Fun(Rest, Lines, State).

check_lines(0, _, [], _State) ->
    [];
check_lines(1, dot, [], #state{dot=Dot}) ->
    [Dot];
check_lines(1, next, [], State) when State#state.dot < State#state.lines ->
    [State#state.dot+1];
check_lines(1, last, [], State) ->
    [State#state.lines];
check_lines(1, _, [Num|_], State) when 0 =< Num, Num =< State#state.lines ->
    [Num];
check_lines(2, dot, [], #state{dot=Dot}) ->
    [Dot, Dot];
check_lines(2, all, [], #state{lines=Lines}) ->
    [1, Lines];
check_lines(2, _, [Num], State) when 0 =< Num, Num =< State#state.lines ->
    [Num, Num];
check_lines(2, _, [Num2, Num1|_], State)
when 0 =< Num1, Num1 =< Num2, Num2 =< State#state.lines ->
    [Num1, Num2];
check_lines(_, _, _, _) ->
    error(bad_linenum).


%%% Executing commands.

%% ($)= - print line number

print_linenum(Rest, [Line], State) ->
    NewState = check_trailing_p(Rest, State),
    io:format("~w\n", [Line]),
    NewState.

%% ? - print state (for debugging)

quest_command([], [], State) ->
    io:format("~p\n", [State]),
    State.

%% Tcmd - time command

time_command(Cmd, [], St) ->
    Fun = fun parse_command/2,
    erlang:garbage_collect(),
    {Elapsed, Val} = timer:tc(erlang, apply, [Fun, [Cmd, St]]),
    io:format("Time used: ~p s~n", [Elapsed/1000000.0]),
    case Val of
	{error, Reason} ->
	    throw({error, Reason});
	Other ->
	    Other
    end.

%% (.)a - append text

append_command(Rest, [Line], St0) ->
    St1 = save_for_undo(St0),
    append(move_to(Line, check_trailing_p(Rest, St1))).

append(St0) ->
    {ok, St1, Line0} = get_line('', St0),
    case Line0 of
	eof ->
	    St1;
	".\n" ->
	    St1;
	Line ->
	    append(insert_line(Line, St1))
    end.

%% (.,.)c

change_command(Rest, Lines, St0) ->
    St1 = delete_command(Rest, Lines, St0),
    St2 = append_command([], [St1#state.dot-1], St1),
    save_for_undo(St2, St0).

%% (.,.)d - delete lines

delete_command(Rest, [0, Last], St) ->
    error(bad_linenum);
delete_command(Rest, [First, Last], St0) ->
    St1 = check_trailing_p(Rest, save_for_undo(St0)),
    delete(Last-First+1, move_to(Last, St1)).

delete(0, St) when St#state.dot == St#state.lines ->
    St;
delete(0, St) ->
    next_line(St);
delete(Left, St0) ->
    St1 = delete_current_line(St0),
    delete(Left-1, St1).

%% e file - replace buffer with new file

enter_command(Name, [], St) when St#state.modified == true ->
    error(buffer_modified);
enter_command(Name, [], St0) ->
    enter_always_command(Name, [], St0).

%% E file - replace buffer with new file

enter_always_command(Name, [], St0) ->
    St1 = read_command(Name, [0], #state{filename=St0#state.filename,
					 opts=St0#state.opts}),
    St1#state{modified=false}.

%% f file - print filename; set filename

file_command([], [], St) ->
    io:format("~s~n", [St#state.filename]),
    St;
file_command([$_|Name0], [], St) ->
    Name = skip_blanks(Name0),
    file_command([], [], St#state{filename=Name});
file_command(_, _, _) ->
    error(missing_space).

%% (1,$)g/RE/commands - execute commands on all matching lines.
%% (1,$)v/RE/commands - execute commands on all non-matching lines.

global_command(Cmd, Lines, St) ->
    check_global0(true, Cmd, Lines, St).

vglobal_command(Cmd, Lines, St) ->
    check_global0(false, Cmd, Lines, St).

check_global0(_, _, _, St) when St#state.in_global == true ->
    error(nested_globals);
check_global0(Sense, [Sep|Pattern], Lines, St0) ->
    {ok, Cmd, St1} = get_pattern(Sep, Pattern, St0),
    St2 = mark(Sense, Lines, St1),
    do_global_command(Cmd, St2#state{in_global=true}, 0).
    
mark(Sense, [First, Last], St0) ->
    St1 = move_to(Last, St0),
    mark1(Sense, First-1, St1).

mark1(Sense, First, St) when St#state.dot == First ->
    St;
mark1(Sense, First, St) ->
    [Line|Prev] = St#state.upto_dot,
    NewLine = case match(St) of
		  true  -> Line#line{mark=Sense};
		  false -> Line#line{mark=not(Sense)}
	      end,
    mark1(Sense, First, prev_line(St#state{upto_dot=[NewLine|Prev]})).

do_global_command(Cmd, St0, Matches) ->
    case find_mark(St0) of
	{ok, St1} ->
	    St2 = St1#state{input=Cmd++[eof]},
	    {ok, St3, Cmd1} = get_line(St2),
	    St4 = command(Cmd1, St3),
	    %% XXX There might be several commands.
	    do_global_command(Cmd, St4, Matches+1);
	false when Matches == 0 ->
	    error(nomatch);
	false ->
	    St0#state{in_global=false, input=[]}
    end.

find_mark(State) ->
    find_mark(State#state.lines, State).

find_mark(0, _State) ->
    false;
find_mark(Limit, State) when State#state.dot == 0 ->
    find_mark(Limit, next_line(State));
find_mark(Limit, State) ->
    case State#state.upto_dot of
	[Line|Prev] when Line#line.mark == true ->
	    NewLine = Line#line{mark=false},
	    {ok, State#state{upto_dot=[NewLine|Prev]}};
	_Other ->
	    find_mark(Limit-1, wrap_next_line(State))
    end.

%% h - print info about last error

help_command([], [], St) ->
    case St#state.last_error of
	undefined ->
	    St;
	Reason ->
	    io:put_chars(format_error(Reason)),
	    io:nl(),
	    St
    end;
help_command(_, _, _) ->
    error(garbage_after_command).

%% H - toggle automatic help mode on/off

help_always_command([], [], St) ->
    Opts = St#state.opts,
    case lists:member(help_always, Opts) of
	true ->
	    St#state{opts=Opts--[help_always]};
	false ->
	    help_command([], [], St),
	    St#state{opts=[help_always|Opts]}
    end.

%% (.)i - insert text

insert_command(Rest, [0], State) ->
    error(bad_linenum);
insert_command(Rest, [Line], State) ->
    append_command(Rest, [Line-1], State).

%% (.)kx - mark line

mark_command(_, [0], St) ->
    error(bad_linenum);
mark_command([Mark|Rest], [Line], St) when $a =< Mark, Mark =< $z ->
    error(not_implemented);
mark_command(_, _, _) ->
    error(bad_mark).
    
%% (.,.)l - list lines

list_command(Rest, Lines, St) ->
    print([$l|Rest], Lines, St).

%% (.,.)m - move lines

move_command(Cmd, [First, Last], St) ->
    error(not_implemented).

%% (.,.)t - copy lines

transpose_command(Cmd, [First, Last], St) ->
    error(not_implemented).

%% (.,.)n - print lines with line numbers

number_command(Rest, Lines, St) ->
    print([$n|Rest], Lines, St).

%% (.,.)p - print lines

print_command(Rest, Lines, St) ->
    print([$p|Rest], Lines, St).

%% P - toggle prompt

prompt_command([], [], St) ->
    Opts = St#state.opts,
    case lists:keysearch(prompt, 1, Opts) of
	{value, {prompt, ''}} ->
	    St#state{opts=[{prompt, '*'}|Opts]};
	{value, Value} ->
	    St#state{opts=[{prompt, ''} | Opts--[Value]]}
    end;
prompt_command(_, _, _) ->
    error(garbage_after_command).

%% q - quit editor

quit_command([], [], _) ->
    quit;
quit_command(_, _, _) ->
    error(garbage_after_command).

%% Q - quit editor

quit_always_command([], [], _) ->
    quit;
quit_always_command(_, _, _) ->
    error(garbage_after_command).

%% ($)r file - read file

read_command([], _, St) when St#state.filename == [] ->
    error(bad_filename);
read_command([], [After], St) ->
    read(After, St#state.filename, St);
read_command([$ |Name0], [After], St) when St#state.filename == [] ->
    Name = skip_blanks(Name0),
    read(After, Name, St#state{filename=Name});
read_command([$ |Name0], [After], St) ->
    Name = skip_blanks(Name0),
    read(After, Name, St);
read_command(_, _, _) ->
    error(missing_space).

read(After, Name, St0) ->
    case file:read_file(Name) of
	{ok, Bin} ->
	    Chars = size(Bin),
	    St1 = move_to(After, St0),
	    St2 = insert_line(binary_to_list(Bin), St1),
	    io:format("~w~n", [Chars]),
	    St2;
	{error, _} ->
	    error(bad_file)
    end.

%% s/pattern/replacement/gp

subst_command(_, [0, _], _) ->
    error(bad_linenum);
subst_command([$ |Cmd0], [First, Last], St0) ->
    error(bad_delimiter);
subst_command([$\n|Cmd0], [First, Last], St0) ->
    error(bad_delimiter);
subst_command([Sep|Cmd0], [First, Last], St0) ->
    St1 = save_for_undo(St0),
    {ok, Cmd1, St2} = get_pattern(Sep, Cmd0, St1),
    {ok, Replacement, Cmd2} = get_replacement(Sep, Cmd1),
    {ok, Sub, Cmd3} = subst_check_gflag(Cmd2),
    St3 = check_trailing_p(Cmd3, St2),
    subst_command(Last-First+1, Sub, Replacement, move_to(First-1, St3), nomatch);
subst_command([], _, _) ->
    error(bad_delimiter).
    
subst_command(0, _, _, _, nomatch) ->
    error(nomatch);
subst_command(0, _, _, _, StLast) when record(StLast, state) ->
    StLast;
subst_command(Left, Sub, Repl, St0, LastMatch) ->
    St1 = next_line(St0),
    [Line|_] = St1#state.upto_dot,
    case regexp:Sub(Line#line.contents, St1#state.pattern, Repl) of
	{ok, _, 0} ->
	    subst_command(Left-1, Sub, Repl, St1, LastMatch);
	{ok, NewContents, _} ->
	    %% XXX This doesn't work with marks.
	    St2 = delete_current_line(St1),
	    St3 = insert_line(NewContents, St2),
	    subst_command(Left-1, Sub, Repl, St3, St3)
    end.

subst_check_gflag([$g|Cmd]) -> {ok, gsub, Cmd};
subst_check_gflag(Cmd)      -> {ok, sub, Cmd}.

%% u - undo

undo_command([], [], St) when St#state.undo == undefined ->
    error(bad_undo);
undo_command([], [], #state{undo=Undo}) ->
    Undo;
undo_command(_, _, _) ->
    error(garbage_after_command).

%% (1,$)w - write buffer to file

write_command(Cmd, [First, Last], St) ->
    error(not_implemented).
    

%%% Primitive buffer operations.

print_current(St) ->
    [Line|_] = St#state.upto_dot,
    Printer = St#state.print,
    Printer(Line#line.contents, St).

delete_current_line(St) when St#state.dot == 0 ->
    error(bad_linenum);
delete_current_line(St) ->
    Lines = St#state.lines,
    [_|Prev] = St#state.upto_dot,
    St#state{dot=St#state.dot-1, upto_dot=Prev, lines=Lines-1, modified=true}.
    
insert_line(Line, State) ->
    insert_line1(Line, State, []).

insert_line1([$\n|Rest], State, Result) ->
    NewState = insert_single_line(lists:reverse(Result, [$\n]), State),
    insert_line1(Rest, NewState, []);
insert_line1([C|Rest], State, Result) ->
    insert_line1(Rest, State, [C|Result]);
insert_line1([], State, []) ->
    State;
insert_line1([], State, Result) ->
    insert_single_line(lists:reverse(Result, [$\n]), State).

insert_single_line(Line0, State) ->
    Line = #line{contents=Line0},
    Dot = State#state.dot,
    Before = State#state.upto_dot,
    Lines = State#state.lines,
    %% XXX Avoid updating the record every time.
    State#state{dot=Dot+1, upto_dot=[Line|Before], lines=Lines+1, modified=true}.

move_to(Line, State) when Line < State#state.dot ->
    move_to(Line, prev_line(State));
move_to(Line, State) when State#state.dot < Line ->
    move_to(Line, next_line(State));
move_to(Line, State) when Line == State#state.dot ->
    State.

prev_line(State) ->
    Dot = State#state.dot,
    Before = State#state.upto_dot,
    After = State#state.after_dot,
    State#state{dot=Dot-1, upto_dot=tl(Before), after_dot=[hd(Before)|After]}.

next_line(State) ->
    Dot = State#state.dot,
    Before = State#state.upto_dot,
    After = State#state.after_dot,
    State#state{dot=Dot+1, upto_dot=[hd(After)|Before], after_dot=tl(After)}.

wrap_next_line(State) when State#state.dot == State#state.lines ->
    move_to(1, State);
wrap_next_line(State) ->
    next_line(State).


%%% Utilities.

get_pattern(End, Cmd, State) ->
    get_pattern(End, Cmd, State, []).

get_pattern(End, [End|Rest], State, []) when State#state.pattern /= undefined ->
    {ok, Rest, State};
get_pattern(End, [End|Rest], State, Result) ->
    case regexp:parse(lists:reverse(Result)) of
	{error, _} ->
	    error(bad_pattern);
	{ok, Re} ->
	    {ok, Rest, State#state{pattern=Re}}
    end;
get_pattern(End, [C|Rest], State, Result) ->
    get_pattern(End, Rest, State, [C|Result]);
get_pattern(End, [], State, Result) ->
    get_pattern(End, [End], State, Result).

get_replacement(End, Cmd) ->
    get_replacement(End, Cmd, []).

get_replacement(End, [End|Rest], Result) ->
    {ok, lists:reverse(Result), Rest};
get_replacement(End, [$\\, $&|Rest], Result) ->
    get_replacement(End, Rest, [$&, $\\|Result]);
get_replacement(End, [$\\, C|Rest], Result) ->
    get_replacement(End, Rest, [C|Result]);
get_replacement(End, [C|Rest], Result) ->
    get_replacement(End, Rest, [C|Result]);
get_replacement(End, [], Result) ->
    get_replacement(End, [End], Result).

check_trailing_p([$l], St) ->
    St#state{print=fun(Line, _) -> lister(Line, 0) end};
check_trailing_p([$n], St) ->
    St#state{print=fun numberer/2};
check_trailing_p([$p], St) ->
    St#state{print=fun(Line, _) -> io:put_chars(Line) end};
check_trailing_p([], State) ->
    State;
check_trailing_p(Other, State) ->
    error(garbage_after_command).

error(Reason) ->
    throw({error, Reason}).

match(State) when State#state.dot == 0 ->
    false;
match(State) ->
    [Line|_] = State#state.upto_dot,
    Re = State#state.pattern,
    case regexp:first_match(Line#line.contents, Re) of
	{match, _, _} -> true;
	nomatch       -> false
    end.

skip_blanks([$ |Rest]) ->
    skip_blanks(Rest);
skip_blanks(Rest) ->
    Rest.

print(Rest, [Line], St0) when Line > 0 ->
    St1 = check_trailing_p(Rest, St0),
    print(Line, move_to(Line-1, St1));
print(Rest, [First, Last], St0) when First > 0 ->
    St1 = check_trailing_p(Rest, St0),
    print(Last, move_to(First-1, St1)).

print(Last, St) when St#state.dot == Last ->
    St#state{print=false};
print(Last, St0) ->
    St1 = next_line(St0),
    print_current(St1),
    print(Last, St1).

lister(Rest, 64) ->
    io:put_chars("\\\n"),
    lister(Rest, 0);
lister([C|Rest], Num) ->
    list_char(C),
    lister(Rest, Num+1);
lister([], _) ->
    ok.

list_char($\t) ->
    io:put_chars("\\t");
list_char($\n) ->
    io:put_chars("$\n");
list_char(C) ->
    io:put_chars([C]).

numberer(Line, St) ->
    io:format("~w\t~s", [St#state.dot, Line]).

save_for_undo(St) ->
    St#state{undo=St#state{undo=undefined, print=false}}.

save_for_undo(St, OldSt) ->
    St#state{undo=OldSt#state{undo=undefined, print=false}}.
