- ";
list_begin_tags(olist) ->
"
- ".
list_end_tags() ->
"
".
chg_list_lvl(#state{list_lvl = Lvl} = S, Lvl) ->
S;
chg_list_lvl(#state{list_lvl = OldLvl,
list_type_stack = [ListType|_]} = S,
NewLvl) when OldLvl > NewLvl ->
chg_list_lvl(S, ListType, NewLvl).
chg_list_lvl(#state{list_lvl = Lvl} = S, _ListType, Lvl) ->
S;
chg_list_lvl(#state{list_p_stack = LPS,
list_type_stack = LTS,
delayed_array_ix = IX,
list_lvl = OldLvl} = S,
ListType,
Lvl) when OldLvl < Lvl ->
chg_list_lvl(put_line(S#state{list_type_stack = [ListType|LTS],
list_p_stack = [{unknown, IX} | LPS],
delayed_array_ix = IX+2,
list_lvl = OldLvl+1},
list_begin_tags(ListType)),
Lvl);
chg_list_lvl(#state{list_p_stack = [_ | LPS],
list_type_stack = [_|LTS],
list_lvl = OldLvl} = S0,
ListType,
Lvl) ->
S1 = list_use_p(S0, no), % Ignored if already determined
chg_list_lvl(put_line(S1#state{list_p_stack = LPS,
list_type_stack = LTS,
list_lvl = OldLvl-1},
list_end_tags()),
ListType,
Lvl).
list_strip(uolist, Str) ->
case list_strip(Str) of
[C | Cs] when C == $*; C == $+; C == $- ->
list_strip(Cs);
_ ->
exit({unexpected_unordered_list_item, Str})
end;
list_strip(olist, Str) ->
case strip_head(list_strip(Str), lists:seq($0, $9)) of
[$. | Cs] ->
list_strip(Cs);
_ ->
exit({unexpected_ordered_list_item, Str})
end.
list_strip(S) ->
strip_head(S, [$ ,$\t]).
%%
%% Block quote
%%
rm_bquote(0, 0, Str) ->
Str;
rm_bquote(0, BQLvl, [$>|Cs]) ->
rm_bquote(0, BQLvl-1, Cs);
rm_bquote(0, BQLvl, [C|Cs]) when C == $ ; C == $\t ->
rm_bquote(0, BQLvl, Cs);
rm_bquote(TxtLvl, BQLvl, " " ++ Cs) ->
" " ++ rm_bquote(TxtLvl-1, BQLvl, Cs);
rm_bquote(TxtLvl, BQLvl, [$\t|Cs]) ->
[$\t | rm_bquote(TxtLvl-1, BQLvl, Cs)].
chg_bq_lvl(Lvl, #state{bq_lvl = Lvl} = S) ->
S;
chg_bq_lvl(NewLvl, #state{bq_lvl = Lvl} = S) when NewLvl > Lvl ->
chg_bq_lvl(NewLvl,
put_line(end_p(end_code(S#state{bq_lvl = Lvl+1})), ""));
chg_bq_lvl(NewLvl, #state{bq_lvl = Lvl} = S) ->
chg_bq_lvl(NewLvl,
put_line(end_p(end_code(S#state{bq_lvl = Lvl-1})), "
")).
%%
%% Resolve link
%%
resolve_link(#state{line = Line} = S) ->
{Key, Url, Title} = resolve_link(Line, start, "", "", ""),
write_delayed(S, Key, {Url, Title}).
resolve_link("[" ++ Rest, start, "", "", "") ->
resolve_link(Rest, key, "", "", "");
resolve_link([_|Cs], start, "", "", "") ->
resolve_link(Cs, start, "", "", "");
resolve_link("]:" ++ Rest, key, Yek, "", "") ->
resolve_link(Rest, url, Yek, "", "");
resolve_link([C|Cs], url, Yek, Lru, "") when C == $"; C == $' -> %"
resolve_link(Cs, {title, C}, Yek, Lru, "");
resolve_link([$(|Cs], url, Yek, Lru, "") ->
resolve_link(Cs, {title, $)}, Yek, Lru, "");
resolve_link([C|Cs], {title, C}, Yek, Lru, Eltit) ->
resolve_link(Cs, drop, Yek, Lru, Eltit);
resolve_link([C|Cs], key, Yek, "", "") ->
resolve_link(Cs, key, [C|Yek], "", "");
resolve_link([C|Cs], url, Yek, Lru, "") ->
resolve_link(Cs, url, Yek, [C|Lru], "");
resolve_link([C|Cs], {title, _} = T, Yek, Lru, Eltit) ->
resolve_link(Cs, T, Yek, Lru, [C|Eltit]);
resolve_link([_|Cs], drop, Yek, Lru, Eltit) ->
resolve_link(Cs, drop, Yek, Lru, Eltit);
resolve_link([], _, Yek, Lru, Eltit) ->
{ws_strip(lists:reverse(Yek)),
ws_strip(md_strip_n_reverse(Lru)),
ws_strip(lists:reverse(Eltit))}.
%% Remove .md at end of references.
md_strip_n_reverse(Lru) ->
md_strip_n_reverse(Lru,[]).
md_strip_n_reverse("\ndm."++Lru,Acc) ->
md_strip_n_reverse(Lru,Acc);
md_strip_n_reverse("#dm."++Lru,Acc) ->
md_strip_n_reverse(Lru,[$#|Acc]);
md_strip_n_reverse([C|T],Acc) ->
md_strip_n_reverse(T,[C|Acc]);
md_strip_n_reverse([], Acc) ->
Acc.
%%
%% Misc
%%
ws_strip(S) ->
strip(S, [$ ,$\t,$\n,$\r]).
%ws_strip_head(S) ->
% strip_head(S, [$ ,$\t,$\n,$\r]).
%hws_strip_head(S) ->
% strip_head(S, [$ ,$\t]).
%hws_strip(S) ->
% strip(S, [$ ,$\t]).
strip([], _StripList) ->
[];
strip([C|Cs] = Str, StripList) ->
case lists:member(C, StripList) of
true -> strip(Cs, StripList);
false -> lists:reverse(pirts(lists:reverse(Str), StripList))
end.
pirts([], _StripList) ->
[];
pirts([C|Cs] = Str, StripList) ->
case lists:member(C, StripList) of
true -> pirts(Cs, StripList);
false -> Str
end.
strip_head([C|Cs] = Str, StripList) ->
case lists:member(C, StripList) of
true -> strip_head(Cs, StripList);
false -> Str
end.
type("[" ++ Cs) ->
type_resolve_link(Cs);
type(" [" ++ Cs) ->
type_resolve_link(Cs);
type("==" ++ Cs) ->
case type_same(Cs, $=) of
true -> {marker, h1};
_ -> {text, 0}
end;
type("--" ++ Cs) ->
case type_same(Cs, $-) of
true -> {marker, h2};
_ -> {text, 0}
end;
type(Str) ->
type_cont(Str).
type_resolve_link([]) ->
{text, 0};
type_resolve_link("]:" ++ _) ->
resolve_link;
type_resolve_link([_|Cs]) ->
type_resolve_link(Cs).
type_bquote(Str, N) ->
case type(Str) of
{bquote, N, M} ->
{bquote, N, M+1};
_ ->
{bquote, N, 1}
end.
type_same([C|Cs], C) ->
type_same(Cs, C);
type_same([_|Cs], _) ->
case type_cont(Cs) of
blank -> true;
_ -> false
end.
type_cont(Str) ->
type_cont(Str, 0, true).
type_cont(" " ++ Str, N, true) ->
type_cont(Str, N+1, true);
type_cont([$\t| Str], N, true) ->
type_cont(Str, N+1, true);
type_cont([C|Str], N, _) when C == $ ; C == $\t; C == $\n; C == $\r ->
type_cont(Str, N, false);
type_cont([], _, _) ->
blank;
type_cont(">" ++ Cs, N, _) ->
type_bquote(Cs, N);
type_cont(" >" ++ Cs, N, _) ->
type_bquote(Cs, N);
type_cont(" >" ++ Cs, N, _) ->
type_bquote(Cs, N);
type_cont(" >" ++ Cs, N, _) ->
type_bquote(Cs, N);
type_cont([C,$ |_], N, _) when C == $*; C == $+; C == $- ->
{uolist, N};
type_cont([C,$\t |_], N, _) when C == $*; C == $+; C == $- ->
{uolist, N};
type_cont([C|Cs], N, _) when $0 =< C, C =< $9 ->
case type_olist(Cs) of
true -> {olist, N};
false -> {text, N}
end;
type_cont("%CopyrightBegin%" ++ _, _, _) ->
copyright_begin;
type_cont("%CopyrightEnd%" ++ _, _, _) ->
copyright_end;
type_cont(_, N, _) ->
{text, N}.
type_olist([C|Cs]) when $0 =< C, C =< $9 ->
type_olist(Cs);
type_olist([$.,$ |_]) ->
true;
type_olist([$.,$\t|_]) ->
true;
type_olist(_) ->
false.
end_all(S) ->
chg_list_lvl(end_p(end_code(S)), 0).
get_line(#state{next_line = eof} = S) ->
S#state{prev_line = S#state.line,
prev_type = S#state.type,
line = eof,
type = blank,
bq_type = 0};
get_line(#state{ifile = IFile, line_no = LNO, copyright = CR} = S0) ->
NewLine = file_read_line(IFile, LNO),
S1 = case {CR, type(NewLine)} of
{false, copyright_begin} ->
S0#state{copyright = true,
next_line = "",
next_type = blank};
{true, copyright_end} ->
S0#state{copyright = false,
next_line = "",
next_type = blank};
{true, NextType} ->
S0#state{next_line = NewLine,
next_type = NextType,
copyright_data = [NewLine|S0#state.copyright_data]};
{false, NextType} ->
S0#state{next_line = NewLine,
next_type = NextType}
end,
S1#state{line_no = S0#state.line_no + 1,
line = S0#state.next_line,
type = S0#state.next_type,
bq_type = S0#state.bq_next_type,
prev_line = S0#state.line,
prev_type = S0#state.type,
bq_next_type = 0}.
write_delayed(#state{delayed_array = DA} = S,
IX,
Value) when is_integer(IX) ->
S#state{delayed_array = array:set(IX, Value, DA)};
write_delayed(#state{delayed_tree = DT} = S, Key, Value) ->
S#state{delayed_tree = gb_trees:enter(Key, Value, DT)}.
read_delayed(#state{delayed_array = DA}, IX) when is_integer(IX) ->
array:get(IX, DA);
read_delayed(#state{delayed_tree = DT}, Key) ->
gb_trees:lookup(Key, DT).
put_delayed(#state{out = Out} = S, Key) ->
S#state{out = [{delayed, Key} | Out]}.
put_delayed(#state{out = Out} = S, Key, Data) ->
S#state{out = [{delayed, Key, Data} | Out]}.
put_chars(#state{out = Out} = S, Chars) ->
S#state{out = [Chars | Out]}.
put_line(#state{out = Out} = S, String) ->
S#state{out = [[String, nl()] | Out]}.
complete_output(#state{out = Out} = S) ->
complete_output(create_copyright_notice(create_toc(S)), Out, []).
complete_output(S, [], Out) ->
S#state{delayed_array = [],
out = ["", nl(),
"", nl(),
Out]};
complete_output(S, [{delayed, IX}|Rest], Out) ->
complete_output(S, Rest, [read_delayed(S, IX)|Out]);
complete_output(S, [{delayed, {internal, Key0}, {link, Text, _Line}}|Rest], Out) ->
Key = [C || C <- Key0, C =/= $_],
case read_delayed(S, {internal, Key}) of
{value, {Url, _}} ->
complete_output(S, Rest, [mk_link(Text, Url)|Out]);
none ->
Url = "#" ++ Key0,
complete_output(S, Rest, [mk_link(Text, Url)|Out])
end;
complete_output(S, [{delayed, Key, {link, Text, Line}}|Rest], Out) ->
case read_delayed(S, Key) of
{value, {Url, _Title}} ->
complete_output(S, Rest, [mk_link(Text, Url)|Out]);
none ->
{File, _} = S#state.ifile,
error(File, Line, "Link definition name `~ts' not found~n", [Key])
end;
complete_output(S, [{delayed, Key, {image, _Text, Line}}|Rest], Out) ->
case read_delayed(S, Key) of
{value, {Url, Title}} ->
complete_output(S, Rest, [mk_image(Title, Url)|Out]);
none ->
{File, _} = S#state.ifile,
error(File, Line, "Image definition name `~ts' not found~n", [Key])
end;
complete_output(S, [["","\n"]=ParaStart,
Contents,
["","\n"]=ParaEnd|Rest], Out) ->
case is_image_tag(Contents) of
true ->
%% Get rid of the paragraph around an image tag. It would mess up
%% figure numbering.
complete_output(S, Rest, [Contents|Out]);
false ->
complete_output(S, [Contents,ParaEnd|Rest], [ParaStart|Out])
end;
complete_output(S, [Next|Rest], Out) ->
complete_output(S, Rest, [Next|Out]).
is_image_tag("
true;
is_image_tag([[_|_]=H | _]) ->
is_image_tag(H);
is_image_tag(_) ->
false.
write_output(_OFD, []) ->
ok;
write_output(OFD, [O|Os]) ->
file_write(OFD, O),
write_output(OFD, Os).
error(FStr, Args) ->
io:format(standard_error, "ERROR: " ++ FStr ++ "~n", Args),
stop(1).
error(File, Line, FStr, Args) ->
io:format(standard_error, "~s:~p: ERROR: " ++ FStr ++ "~n",
[File | [Line | Args]]),
stop(1).
stop() -> init:stop(), receive after infinity -> ok end.
stop(Status) -> init:stop(Status), receive after infinity -> ok end.
%%
%% I/O
%%
nl() ->
io_lib:nl().
file_wopen(File) ->
case file:open(File, [write, delayed_write]) of
{ok, FD} -> {File, FD};
{error, Reason} -> error("Failed to open `~s' for writing: ~p~n",
[File, Reason])
end.
file_ropen(File) ->
case file:open(File, [read, binary]) of
{ok, FD} -> {File, FD};
{error, Reason} -> error("Failed to open `~s' for reading: ~p~n",
[File, Reason])
end.
file_read_line({File, FD}, LineNo) ->
case file:read_line(FD) of
{ok, Line} -> unicode:characters_to_list(Line, utf8);
eof -> eof;
{error, Error} -> error(File,LineNo,"Reading line failed: ~p~n",[Error])
end.
file_write({File, FD}, Data) ->
case file:write(FD, unicode:characters_to_binary(Data, unicode, utf8)) of
ok -> ok;
{error, Reason} ->
error("Writing to file `~s' failed: ~p~n", [File, Reason])
end.
file_close({File, FD}) ->
case file:close(FD) of
ok -> ok;
{error, Reason} -> error("Closing file `~s' failed: ~p~n",[File,Reason])
end.
%%
%% EOF
%%