%% ===================================================================== %% This library is free software; you can redistribute it and/or modify %% it under the terms of the GNU Lesser General Public License as %% published by the Free Software Foundation; either version 2 of the %% License, or (at your option) any later version. %% %% This library is distributed in the hope that it will be useful, but %% WITHOUT ANY WARRANTY; without even the implied warranty of %% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU %% Lesser General Public License for more details. %% %% You should have received a copy of the GNU Lesser General Public %% License along with this library; if not, write to the Free Software %% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 %% USA %% %% @author Richard Carlsson <carlsson.richard@gmail.com> %% @author Kenneth Lundin <kenneth@erix.ericsson.se> %% @copyright 2001-2004 Richard Carlsson %% @see edoc_layout %% @end %% ===================================================================== %% @doc The OTP SGML layout module for EDoc. See the module {@link edoc} %% for details on usage. %% Note that this is written so that it is *not* depending on edoc.hrl! -module(otpsgml_layout). -export([module/2, package/2, overview/2,type/1]). -import(edoc_report, [report/2]). -include_lib("xmerl/include/xmerl.hrl"). -define(SGML_EXPORT, xmerl_otpsgml). -define(DEFAULT_XML_EXPORT, ?SGML_EXPORT). -define(STYLESHEET, "stylesheet.css"). -define(NL, "\n"). -define(DESCRIPTION_TITLE, "Description"). -define(DESCRIPTION_LABEL, "description"). -define(DATA_TYPES_TITLE, "Data Types"). -define(DATA_TYPES_LABEL, "types"). -define(FUNCTION_INDEX_TITLE, "Function Index"). -define(FUNCTION_INDEX_LABEL, "index"). -define(FUNCTIONS_TITLE, "Function Details"). -define(FUNCTIONS_LABEL, "functions"). %% @doc The layout function. %% %% Options: %% <dl> %% <dt>{@type {index_columns, integer()@}} %% </dt> %% <dd>Specifies the number of column pairs used for the function %% index tables. The default value is 1. %% </dd> %% <dt>{@type {stylesheet, string()@}} %% </dt> %% <dd>Specifies the URI used for referencing the stylesheet. The %% default value is `"stylesheet.css"'. If an empty string is %% specified, no stylesheet reference will be generated. %% </dd> %% <dt>{@type {xml_export, Module::atom()@}} %% </dt> %% <dd>Specifies an {@link //xmerl. `xmerl'} callback module to be %% used for exporting the documentation. See {@link %% //xmerl/xmerl:export_simple/3} for details. %% </dd> %% </dl> %% %% @see edoc:layout/2 -record(opts, {root, stylesheet, index_columns}). module(Element, Options) -> XML = layout_module(Element, init_opts(Element, Options)), Export = proplists:get_value(xml_export, Options, ?DEFAULT_XML_EXPORT), xmerl:export_simple([XML], Export, []). % Put layout options in a data structure for easier access. init_opts(Element, Options) -> R = #opts{root = get_attrval(root, Element), index_columns = proplists:get_value(index_columns, Options, 1) }, case proplists:get_value(stylesheet, Options) of undefined -> S = edoc_lib:join_uri(R#opts.root, ?STYLESHEET), R#opts{stylesheet = S}; "" -> R; % don't use any stylesheet S when is_list(S) -> R#opts{stylesheet = S}; _ -> report("bad value for option `stylesheet'.", []), exit(error) end. %% ===================================================================== %% XML-BASED LAYOUT ENGINE %% ===================================================================== %% We assume that we have expanded XML data. %% <!ELEMENT module (moduleName, moduleFullName, behaviour*, description?, %% author*, version?, since?, copyright?, deprecated?, %% see*, reference*, typedecls?, functions)> %% <!ATTLIST module %% root CDATA #IMPLIED> %% <!ELEMENT moduleName (#PCDATA)> %% <!ELEMENT moduleFullName (#PCDATA)> %% <!ELEMENT behaviour (#PCDATA)> %% <!ATTLIST behaviour %% href CDATA #IMPLIED> %% <!ELEMENT description (briefDescription, fullDescription?)> %% <!ELEMENT briefDescription (#PCDATA)> %% <!ELEMENT fullDescription (#PCDATA)> %% <!ELEMENT author EMPTY> %% <!ATTLIST author %% name CDATA #REQUIRED %% email CDATA #IMPLIED %% website CDATA #IMPLIED> %% <!ELEMENT version (#PCDATA)> %% <!ELEMENT since (#PCDATA)> %% <!ELEMENT copyright (#PCDATA)> %% <!ELEMENT deprecated (description)> %% <!ELEMENT see (#PCDATA)> %% <!ATTLIST see %% name CDATA #REQUIRED %% href CDATA #IMPLIED> %% <!ELEMENT reference (#PCDATA)> %% <!ELEMENT typedecls (typedecl+)> %% <!ELEMENT functions (function+)> layout_module(#xmlElement{name = module, content = Es}=E, _Opts) -> Name = get_attrval(name, E), Desc = get_content(description, Es), ShortDesc = get_content(briefDescription, Desc), FullDesc = get_content(fullDescription, Desc), Functions = [E || E <- get_content(functions, Es)], SortedFs = lists:sort([{function_name(E), E} || E <- Functions]), Types = get_content(typedecls, Es), SortedTs = lists:sort([{type_name(E), E} || E <- Types]), Header = {header, [ ?NL,{title, [Name]}, ?NL,{prepared, [""]}, ?NL,{responsible, [""]}, ?NL,{docno, ["1"]}, ?NL,{approved, [""]}, ?NL,{checked, [""]}, ?NL,{date, [""]}, ?NL,{rev, ["A"]}, ?NL,{file, [Name++".sgml"]} ]}, Module = {module, [Name]}, ModuleSummary = {modulesummary, ShortDesc}, {Short,Long} = find_first_p(FullDesc,[]), Description = {description, [?NL,{p,Short}|Long]++[?NL|types(SortedTs)]}, Funcs = functions(SortedFs), Authors = {authors, authors(Es)}, See = sees1(Es), {erlref, [ ?NL,Header, ?NL,Module, ?NL,ModuleSummary, ?NL,Description, ?NL,Funcs, ?NL,See, ?NL,Authors ] }. stylesheet(Opts) -> case Opts#opts.stylesheet of undefined -> []; CSS -> [{link, [{rel, "stylesheet"}, {type, "text/css"}, {href, CSS}], []}, ?NL] end. % doc_index(FullDesc, Functions, Types) -> % case doc_index_rows(FullDesc, Functions, Types) of % [] -> []; % Rs -> % [{ul, [{li, [{a, [{href, local_label(R)}], [T]}]} % || {T, R} <- Rs]}] % end. % doc_index_rows(FullDesc, Functions, Types) -> % (if FullDesc == [] -> []; % true -> [{?DESCRIPTION_TITLE, ?DESCRIPTION_LABEL}] % end % ++ if Types == [] -> []; % true -> [{?DATA_TYPES_TITLE, ?DATA_TYPES_LABEL}] % end % ++ if Functions == [] -> []; % true -> [{?FUNCTION_INDEX_TITLE, ?FUNCTION_INDEX_LABEL}, % {?FUNCTIONS_TITLE, ?FUNCTIONS_LABEL}] % end). % function_index(Fs, Cols) -> % case function_index_rows(Fs, Cols, []) of % [] -> []; % Rows -> % [?NL, % {h2, [{a, [{name, ?FUNCTION_INDEX_LABEL}], % [?FUNCTION_INDEX_TITLE]}]}, % ?NL, % {table, [{width, "100%"}, {border, 1}], Rows}, % ?NL] % end. % function_index_rows(Fs, Cols, Title) -> % Rows = (length(Fs) + (Cols - 1)) div Cols, % (if Title == [] -> []; % true -> [{tr, [{th, [{colspan, Cols * 2}, {align, left}], % [Title]}]}, % ?NL] % end % ++ lists:flatmap(fun index_row/1, % edoc_lib:transpose(edoc_lib:segment(Fs, Rows)))). % index_row(Fs) -> % [{tr, lists:flatmap(fun index_col/1, Fs)}, ?NL]. % index_col({Name, F=#xmlElement{content = Es}}) -> % [{td, [{valign, "top"}], label_href([Name], F)}, % {td, index_desc(Es)}]. index_desc(Es) -> Desc = get_content(description, Es), case get_content(briefDescription, Desc) of [] -> equiv(Es); % no description at all if no equiv ShortDesc -> ShortDesc end. % label_href(Content, F) -> % case get_attrval(label, F) of % "" -> Content; % Ref -> [{a, [{href, local_label(Ref)}], Content}] % end. %% <!ELEMENT function (args, typespec?, equiv?, description?, since?, %% deprecated?, see*)> %% <!ATTLIST function %% name CDATA #REQUIRED %% arity CDATA #REQUIRED %% exported NMTOKEN(yes | no) #REQUIRED %% label CDATA #IMPLIED> %% <!ELEMENT args (arg*)> %% <!ELEMENT arg description?> %% <!ATTLIST arg name CDATA #REQUIRED> %% <!ELEMENT equiv (expr, see?)> %% <!ELEMENT expr (#PCDATA)> % functions(Fs) -> % Es = lists:flatmap(fun ({Name, E}) -> function(Name, E) end, Fs), % if Es == [] -> []; % true -> % [?NL, % {h2, [{a, [{name, ?FUNCTIONS_LABEL}], [?FUNCTIONS_TITLE]}]}, % ?NL | Es] % end. functions(Fs) -> Es = lists:flatmap(fun ({Name, E}) -> function(Name, E) end, Fs), if Es == [] -> []; true -> {funcs, Es} end. % is_exported(E) -> % case get_attrval(exported, E) of % "yes" -> true; % _ -> false % end. % function(Name, E=#xmlElement{content = Es}) -> % ([?NL, {h3, label_anchor([Name], E)}, ?NL] % ++ case typespec(get_content(typespec, Es)) of % [] -> % signature(get_content(arguments, Es), % get_text(functionName, Es)); % Spec -> Spec % end % ++ equiv(Es) % ++ deprecated(Es, "function") % ++ fulldesc(Es) % ++ since(Es) % ++ sees(Es)). function(_Name, E=#xmlElement{content = Es}) -> TypeSpec = get_content(typespec, Es), [?NL,{func, [ ?NL, {name, % case typespec(get_content(typespec, Es)) of case funcheader(TypeSpec) of [] -> signature(get_content(args, Es), get_attrval(name, E)); Spec -> Spec end }, ?NL,{fsummary, fsummary(Es)}, % ?NL,{type, local_types(TypeSpec)}, ?NL,local_types(TypeSpec), ?NL,{desc, label_anchor(E)++fulldesc(Es)++sees(Es)} ]}]. fsummary([]) -> ["\s"]; fsummary(Es) -> Desc = get_content(description, Es), case get_content(briefDescription, Desc) of [] -> fsummary_equiv(Es); % no description at all if no equiv ShortDesc -> ShortDesc end. fsummary_equiv(Es) -> case get_content(equiv, Es) of [] -> ["\s"]; Es1 -> case get_content(expr, Es1) of [] -> ["\s"]; [Expr] -> ["Equivalent to ", Expr, ".",?NL] end end. function_name(E) -> get_attrval(name, E) ++ "/" ++ get_attrval(arity, E). label_anchor(E) -> case get_attrval(label, E) of "" -> []; Ref -> [{marker, [{id, Ref}],[]},?NL] end. label_anchor(Content, E) -> case get_attrval(label, E) of "" -> Content; Ref -> {p,[{marker, [{id, Ref}],[]}, {em, Content}]} end. %% <!ELEMENT args (arg*)> %% <!ELEMENT arg (argName, description?)> %% <!ELEMENT argName (#PCDATA)> %% This is currently only done for functions without type spec. signature(Es, Name) -> % [{tt, [Name, "("] ++ seq(fun arg/1, Es) ++ [") -> term()", ?NL]}]. [Name, "("] ++ seq(fun arg/1, Es) ++ [") -> term()", ?NL]. arg(#xmlElement{content = Es}) -> [get_text(argName, Es)]. %% <!ELEMENT typespec (erlangName, type, localdef*)> % typespec([]) -> []; % typespec(Es) -> % [{p, ([{tt, ([t_name(get_elem(qualifiedName, Es))] % ++ t_type(get_content(type, Es)))}] % ++ local_defs(get_elem(definition, Es)))}, % ?NL]. funcheader([]) -> []; funcheader(Es) -> [t_name(get_elem(erlangName, Es))] ++ t_utype(get_elem(type, Es)). local_types([]) -> []; local_types(Es) -> local_defs2(get_elem(localdef, Es)). local_defs2([]) -> []; local_defs2(Es) -> {type,[?NL | [{v, localdef(E)} || E <- Es]]}. %% <!ELEMENT typedecl (typedef, description?)> %% <!ELEMENT typedef (erlangName, argtypes, type?, localdef*)> types([]) -> []; types(Ts) -> Es = lists:flatmap(fun ({Name, E}) -> typedecl(Name, E) end, Ts), [?NL, % {h2, [{a, [{name, ?DATA_TYPES_LABEL}], % [?DATA_TYPES_TITLE]}]}, % ?NL | Es] {p,[{marker, [{id, ?DATA_TYPES_LABEL}],[]}, {em,[?DATA_TYPES_TITLE]}]}, ?NL, {taglist,[?NL|Es]}]. %%type(Name, E=#xmlElement{content = Es}) -> %% ([?NL, {h3, label_anchor([Name, "()"], E)}, ?NL] %% ++ [{p, typedef(get_content(typedef, Es))}, ?NL] %% ++ fulldesc(Es)). typedecl(_Name, #xmlElement{content = Es}) -> [{tag, typedef(get_content(typedef, Es))},?NL,{item,fulldesc(Es)},?NL]. type_name(#xmlElement{content = Es}) -> t_name(get_elem(erlangName, get_content(typedef, Es))). typedef(Es) -> Name = ([t_name(get_elem(erlangName, Es)), "("] ++ seq(fun t_utype_elem/1, get_content(argtypes, Es), [")"])), (case get_elem(type, Es) of [] -> [{b, ["abstract datatype"]}, ": ", {tt, Name}]; Type -> [{tt, Name ++ [" = "] ++ t_utype(Type)}] end ++ local_defs(get_elem(localdef, Es))). local_defs([]) -> []; local_defs(Es) -> [?NL, {ul, [{li, [{tt, localdef(E)}]} || E <- Es]}]. localdef(E = #xmlElement{content = Es}) -> (case get_elem(typevar, Es) of [] -> label_anchor(t_abstype(get_content(abstype, Es)), E); [V] -> t_var(V) end ++ [" = "] ++ t_utype(get_elem(type, Es))). fulldesc(Es) -> case get_content(fullDescription, get_content(description, Es)) of % [] -> [?NL]; [] -> index_desc(Es); % Desc -> [{p, Desc}, ?NL] Desc -> {Short,Long} = find_first_p(Desc,[]), [?NL,{p,Short}|Long] ++[?NL] end. find_first_p([#xmlElement{name=p}|_]=Long,Short) -> {lists:reverse(Short),Long}; find_first_p([H|T],Short) -> find_first_p(T,[H|Short]); find_first_p([],Short) -> {lists:reverse(Short),[]}. sees1(Es) -> case get_elem(see, Es) of [] -> []; Es1 -> {section,[{title,["See also"]},{p,seq(fun see/1, Es1, [])}]} end. sees(Es) -> case get_elem(see, Es) of [] -> []; Es1 -> [{p, [{em, ["See also:"]}, " "] ++ seq(fun see/1, Es1, ["."])}, ?NL] end. see(E=#xmlElement{content = Es}) -> see(E,Es). see(E, Es) -> case get_attrval(href, E) of "" -> Es; Ref -> case lists:reverse(Ref) of "lmgs.ppa_"++Ppa -> App = lists:reverse(Ppa), [{seealso, [{marker, App++"_app"}], [App]},"(6)"]; "lmgs."++Dom -> Mod = lists:reverse(Dom), [{seealso, [{marker, Mod}], [Mod]},"(3)"]; _ -> [{seealso, [{marker, Ref}], Es}] end end. equiv(Es) -> case get_content(equiv, Es) of [] -> ["\s"]; Es1 -> case get_content(expr, Es1) of [] -> []; [Expr] -> % Expr1 = {tt, [Expr]}, % Expr1 = {c, [Expr]}, Expr1 = [Expr], Expr2 = case get_elem(see, Es1) of [] -> {c,Expr1}; [E=#xmlElement{}] -> % see(E,Expr1) case get_attrval(href, E) of "" -> {c,Expr1}; Ref -> {seealso, [{marker, Ref}], Expr1} end end, [{p, ["Equivalent to ", Expr2, "."]}, ?NL] end end. % replace_minus_with_percent([$-|T]) -> % [$%|T]; % replace_minus_with_percent([H|T]) -> % [H|replace_minus_with_percent(T)]. copyright(Es) -> case get_content(copyright, Es) of [] -> []; Es1 -> [{p, ["Copyright \251 " | Es1]}, ?NL] end. version(Es) -> case get_content(version, Es) of [] -> []; Es1 -> [{p, [{b, ["Version:"]}, " " | Es1]}, ?NL] end. since(Es) -> case get_content(since, Es) of [] -> []; Es1 -> [{p, [{b, ["Introduced in:"]}, " " | Es1]}, ?NL] end. deprecated(Es, S) -> Es1 = get_content(description, get_content(deprecated, Es)), case get_content(fullDescription, Es1) of [] -> []; Es2 -> [{p, [{b, ["This " ++ S ++ " is deprecated:"]}, " " | Es2]}, ?NL] end. % behaviours(Es) -> % case get_elem(behaviour, Es) of % [] -> []; % Es1 -> % [{p, [{b, ["Behaviour:"]}, " "] ++ seq(fun behaviour/1, Es1, ["."])}, % ?NL] % end. % behaviour(E=#xmlElement{content = Es}) -> % case get_attrval(href, E) of % "" -> [{tt, Es}]; % Ref -> [{a, [{href, Ref}], [{tt, Es}]}] % end. authors(Es) -> case get_elem(author, Es) of [] -> [?NL,{aname,["\s"]},?NL,{email,["\s"]}]; Es1 -> [?NL|seq(fun author/1, Es1, [])] % % [{p, [{b, ["Authors:"]}, " "] ++ seq(fun author/1, Es1, ["."])}, % ?NL] end. %% <!ATTLIST author %% name CDATA #REQUIRED %% email CDATA #IMPLIED %% website CDATA #IMPLIED> author(E=#xmlElement{}) -> Name = case get_attrval(name, E) of [] -> "\s"; N -> N end, Mail = case get_attrval(email, E) of [] -> "\s"; M -> M end, [?NL,{aname,[Name]},?NL,{email,[Mail]}]. % author(E=#xmlElement{}) -> % Name = get_attrval(name, E), % Mail = get_attrval(email, E), % URI = get_attrval(website, E), % (if Name == Mail -> % [{a, [{href, "mailto:" ++ Mail}],[{tt, [Mail]}]}]; % true -> % if Mail == "" -> [Name]; % true -> [Name, " (", {a, [{href, "mailto:" ++ Mail}], % [{tt, [Mail]}]}, ")"] % end % end % ++ if URI == "" -> []; % true -> [" [", {em, ["web site:"]}, " ", % {tt, [{a, [{href, URI}], [URI]}]}, "]"] % end). references(Es) -> case get_elem(reference, Es) of [] -> []; Es1 -> [{p, [{b, ["References"]}, {ul, [{li, C} || #xmlElement{content = C} <- Es1]}]}, ?NL] end. t_name([E]) -> N = get_attrval(name, E), case get_attrval(module, E) of "" -> N; M -> S = M ++ ":" ++ N, case get_attrval(app, E) of "" -> S; A -> "//" ++ A ++ "/" ++ S end end. t_utype([E]) -> t_utype_elem(E). t_utype_elem(E=#xmlElement{content = Es}) -> case get_attrval(name, E) of "" -> t_type(Es); Name -> T = t_type(Es), case T of [Name] -> T; % avoid generating "Foo::Foo" T -> [Name] ++ ["::"] ++ T end end. t_type([E=#xmlElement{name = typevar}]) -> t_var(E); t_type([E=#xmlElement{name = atom}]) -> t_atom(E); t_type([E=#xmlElement{name = integer}]) -> t_integer(E); t_type([E=#xmlElement{name = float}]) -> t_float(E); t_type([#xmlElement{name = nil}]) -> t_nil(); t_type([#xmlElement{name = list, content = Es}]) -> t_list(Es); t_type([#xmlElement{name = tuple, content = Es}]) -> t_tuple(Es); t_type([#xmlElement{name = 'fun', content = Es}]) -> t_fun(Es); t_type([E = #xmlElement{name = abstype, content = Es}]) -> T = t_abstype(Es), % see(E,T); case get_attrval(href, E) of "" -> T; % Ref -> [{seealso, [{marker, Ref}], T}] _Ref -> T end; t_type([#xmlElement{name = union, content = Es}]) -> t_union(Es). t_var(E) -> [get_attrval(name, E)]. t_atom(E) -> [get_attrval(value, E)]. t_integer(E) -> [get_attrval(value, E)]. t_float(E) -> [get_attrval(value, E)]. t_nil() -> ["[]"]. t_list(Es) -> ["["] ++ t_utype(get_elem(type, Es)) ++ ["]"]. t_tuple(Es) -> ["{"] ++ seq(fun t_utype_elem/1, Es, ["}"]). t_fun(Es) -> ["("] ++ seq(fun t_utype_elem/1, get_content(argtypes, Es), [") -> "] ++ t_utype(get_elem(type, Es))). t_abstype(Es) -> % ([t_name(get_elem(qualifiedName, Es)), "("] % ++ seq(fun t_type_elem/1, get_elem(type, Es), [")"])). case split_at_colon(t_name(get_elem(erlangName, Es)),[]) of {Mod,Type} -> [Type, "("] ++ seq(fun t_utype_elem/1, get_elem(type, Es), [")"]) ++ [" (see module ", Mod, ")"]; Type -> [Type, "("] ++ seq(fun t_utype_elem/1, get_elem(type, Es), [")"]) end. %% Split at one colon, but not at two (or more) split_at_colon([$:,$:|_]=Rest,Acc) -> lists:reverse(Acc)++Rest; split_at_colon([$:|Type],Acc) -> {lists:reverse(Acc),Type}; split_at_colon([Char|Rest],Acc) -> split_at_colon(Rest,[Char|Acc]); split_at_colon([],Acc) -> lists:reverse(Acc). % t_par(Es) -> % T = t_type(get_content(type, Es)), % case get_elem(variable, Es) of % [] -> T; % [V0] -> case t_variable(V0) of % T -> T; % V -> V ++ ["::"] ++ T % end % end. % t_par_elem(#xmlElement{content = Es}) -> t_par(Es). t_union(Es) -> seq(fun t_utype_elem/1, Es, " | ", []). seq(F, Es) -> seq(F, Es, []). seq(F, Es, Tail) -> seq(F, Es, ", ", Tail). seq(F, [E], _Sep, Tail) -> F(E) ++ Tail; seq(F, [E | Es], Sep, Tail) -> F(E) ++ [Sep] ++ seq(F, Es, Sep, Tail); seq(_F, [], _Sep, Tail) -> Tail. get_elem(Name, [#xmlElement{name = Name} = E | Es]) -> [E | get_elem(Name, Es)]; get_elem(Name, [_ | Es]) -> get_elem(Name, Es); get_elem(_, []) -> []. get_attr(Name, [#xmlAttribute{name = Name} = A | As]) -> [A | get_attr(Name, As)]; get_attr(Name, [_ | As]) -> get_attr(Name, As); get_attr(_, []) -> []. get_attrval(Name, #xmlElement{attributes = As}) -> case get_attr(Name, As) of [#xmlAttribute{value = V}] -> V; [] -> "" end. get_content(Name, Es) -> case get_elem(Name, Es) of [#xmlElement{content = Es1}] -> Es1; [] -> [] end. get_text(Name, Es) -> case get_content(Name, Es) of [#xmlText{value = Text}] -> Text; [] -> "" end. % local_label(R) -> % "#" ++ R. xml(Title, CSS, Body) -> {html, [?NL, {head, [?NL, {title, [Title]}, ?NL] ++ CSS}, ?NL, {body, [{bgcolor, "white"}], Body}, ?NL] }. %% --------------------------------------------------------------------- type(E) -> type(E, []). % type(E, Ds) -> % xmerl:export_simple_content(t_utype_elem(E) ++ local_defs(Ds), % ?HTML_EXPORT). type(E, Ds) -> xmerl:export_simple_content(t_utype_elem(E) ++ local_defs(Ds), ?SGML_EXPORT). package(E=#xmlElement{name = package, content = Es}, Options) -> Opts = init_opts(E, Options), Name = get_text(packageName, Es), Title = io_lib:fwrite("Package ~s", [Name]), Desc = get_content(description, Es), % ShortDesc = get_content(briefDescription, Desc), FullDesc = get_content(fullDescription, Desc), Body = ([?NL, {h1, [Title]}, ?NL] % ++ ShortDesc ++ copyright(Es) ++ deprecated(Es, "package") ++ version(Es) ++ since(Es) ++ authors(Es) ++ references(Es) ++ sees(Es) ++ FullDesc), XML = xml(Title, stylesheet(Opts), Body), xmerl:export_simple([XML], ?SGML_EXPORT, []). overview(E=#xmlElement{name = overview, content = Es}, Options) -> Opts = init_opts(E, Options), Title = get_text(title, Es), Desc = get_content(description, Es), % ShortDesc = get_content(briefDescription, Desc), FullDesc = get_content(fullDescription, Desc), Body = ([?NL, {h1, [Title]}, ?NL] % ++ ShortDesc ++ copyright(Es) ++ version(Es) ++ since(Es) ++ authors(Es) ++ references(Es) ++ sees(Es) ++ FullDesc), XML = xml(Title, stylesheet(Opts), Body), xmerl:export_simple([XML], ?SGML_EXPORT, []).