2013-09-09 16:28:02 -04:00
|
|
|
|
|
|
|
|
-- main.lua
|
|
|
|
|
|
|
|
|
|
-- Implements the plugin entrypoint (in this case the entire plugin)
|
2013-07-30 10:02:20 -04:00
|
|
|
|
2013-07-30 11:26:06 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-09-11 10:57:57 -04:00
|
|
|
-- Global variables:
|
|
|
|
|
g_Plugin = nil;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-07-30 11:26:06 -04:00
|
|
|
|
2013-07-30 10:02:20 -04:00
|
|
|
function Initialize(Plugin)
|
2013-09-11 10:57:57 -04:00
|
|
|
g_Plugin = Plugin;
|
|
|
|
|
|
2013-09-12 12:46:37 -04:00
|
|
|
Plugin:SetName("APIDump");
|
|
|
|
|
Plugin:SetVersion(1);
|
2013-07-30 10:02:20 -04:00
|
|
|
|
|
|
|
|
LOG("Initialized " .. Plugin:GetName() .. " v." .. Plugin:GetVersion())
|
|
|
|
|
|
|
|
|
|
-- dump all available API functions and objects:
|
2013-09-10 16:02:18 -04:00
|
|
|
-- DumpAPITxt();
|
2013-09-09 16:28:02 -04:00
|
|
|
|
2013-09-10 16:02:18 -04:00
|
|
|
-- Dump all available API object in HTML format into a subfolder:
|
|
|
|
|
DumpAPIHtml();
|
2013-09-11 10:57:57 -04:00
|
|
|
|
2013-07-30 10:02:20 -04:00
|
|
|
return true
|
|
|
|
|
end
|
|
|
|
|
|
2013-07-30 11:26:06 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-09-10 16:02:18 -04:00
|
|
|
function DumpAPITxt()
|
2013-07-30 10:02:20 -04:00
|
|
|
LOG("Dumping all available functions to API.txt...");
|
|
|
|
|
function dump (prefix, a, Output)
|
|
|
|
|
for i, v in pairs (a) do
|
|
|
|
|
if (type(v) == "table") then
|
|
|
|
|
if (GetChar(i, 1) ~= ".") then
|
|
|
|
|
if (v == _G) then
|
2013-09-09 16:28:02 -04:00
|
|
|
-- LOG(prefix .. i .. " == _G, CYCLE, ignoring");
|
2013-07-30 10:02:20 -04:00
|
|
|
elseif (v == _G.package) then
|
2013-09-09 16:28:02 -04:00
|
|
|
-- LOG(prefix .. i .. " == _G.package, ignoring");
|
2013-07-30 10:02:20 -04:00
|
|
|
else
|
|
|
|
|
dump(prefix .. i .. ".", v, Output)
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
elseif (type(v) == "function") then
|
|
|
|
|
if (string.sub(i, 1, 2) ~= "__") then
|
|
|
|
|
table.insert(Output, prefix .. i .. "()");
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
local Output = {};
|
|
|
|
|
dump("", _G, Output);
|
|
|
|
|
|
|
|
|
|
table.sort(Output);
|
|
|
|
|
local f = io.open("API.txt", "w");
|
|
|
|
|
for i, n in ipairs(Output) do
|
|
|
|
|
f:write(n, "\n");
|
|
|
|
|
end
|
|
|
|
|
f:close();
|
|
|
|
|
LOG("API.txt written.");
|
|
|
|
|
end
|
2013-09-09 16:28:02 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-09-10 16:02:18 -04:00
|
|
|
|
|
|
|
|
function CreateAPITables()
|
2013-09-09 16:28:02 -04:00
|
|
|
--[[
|
|
|
|
|
We want an API table of the following shape:
|
|
|
|
|
local API = {
|
2013-09-11 10:57:57 -04:00
|
|
|
{
|
|
|
|
|
Name = "cCuboid",
|
2013-09-09 16:28:02 -04:00
|
|
|
Functions = {
|
2013-09-11 10:57:57 -04:00
|
|
|
{Name = "Sort"},
|
|
|
|
|
{Name = "IsInside"}
|
2013-09-09 16:28:02 -04:00
|
|
|
},
|
|
|
|
|
Constants = {
|
|
|
|
|
}
|
2013-09-13 04:51:01 -04:00
|
|
|
Descendants = {}, -- Will be filled by ReadDescriptions(), array of class APIs (references to other member in the tree)
|
2013-09-09 16:28:02 -04:00
|
|
|
}},
|
2013-09-11 10:57:57 -04:00
|
|
|
{
|
|
|
|
|
Name = "cBlockArea",
|
2013-09-09 16:28:02 -04:00
|
|
|
Functions = {
|
2013-09-11 10:57:57 -04:00
|
|
|
{Name = "Clear"},
|
|
|
|
|
{Name = "CopyFrom"},
|
2013-09-09 16:28:02 -04:00
|
|
|
...
|
|
|
|
|
}
|
|
|
|
|
Constants = {
|
2013-09-11 10:57:57 -04:00
|
|
|
{Name = "baTypes", Value = 0},
|
|
|
|
|
{Name = "baMetas", Value = 1},
|
2013-09-09 16:28:02 -04:00
|
|
|
...
|
|
|
|
|
}
|
|
|
|
|
...
|
|
|
|
|
}}
|
|
|
|
|
};
|
|
|
|
|
local Globals = {
|
|
|
|
|
Functions = {
|
|
|
|
|
...
|
|
|
|
|
},
|
|
|
|
|
Constants = {
|
|
|
|
|
...
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
--]]
|
|
|
|
|
|
2013-09-13 04:51:01 -04:00
|
|
|
local Globals = {Functions = {}, Constants = {}, Descendants = {}};
|
2013-09-09 16:28:02 -04:00
|
|
|
local API = {};
|
|
|
|
|
|
2013-09-13 08:05:18 -04:00
|
|
|
local function Add(a_APIContainer, a_ObjName, a_ObjValue)
|
|
|
|
|
if (type(a_ObjValue) == "function") then
|
|
|
|
|
table.insert(a_APIContainer.Functions, {Name = a_ObjName});
|
2013-09-13 04:51:01 -04:00
|
|
|
elseif (
|
2013-09-13 08:05:18 -04:00
|
|
|
(type(a_ObjValue) == "number") or
|
|
|
|
|
(type(a_ObjValue) == "string")
|
2013-09-13 04:51:01 -04:00
|
|
|
) then
|
2013-09-13 08:05:18 -04:00
|
|
|
table.insert(a_APIContainer.Constants, {Name = a_ObjName, Value = a_ObjValue});
|
2013-09-09 16:28:02 -04:00
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2013-09-11 10:57:57 -04:00
|
|
|
local function ParseClass(a_ClassName, a_ClassObj)
|
2013-09-13 04:51:01 -04:00
|
|
|
local res = {Name = a_ClassName, Functions = {}, Constants = {}, Descendants = {}};
|
2013-09-09 16:28:02 -04:00
|
|
|
for i, v in pairs(a_ClassObj) do
|
|
|
|
|
Add(res, i, v);
|
|
|
|
|
end
|
|
|
|
|
return res;
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
for i, v in pairs(_G) do
|
2013-09-13 10:38:39 -04:00
|
|
|
if (
|
|
|
|
|
(v ~= _G) and -- don't want the global namespace
|
|
|
|
|
(v ~= _G.packages) and -- don't want any packages
|
2013-09-14 10:27:12 -04:00
|
|
|
(v ~= _G[".get"]) and
|
|
|
|
|
(v ~= g_APIDesc)
|
2013-09-13 10:38:39 -04:00
|
|
|
) then
|
|
|
|
|
if (type(v) == "table") then
|
|
|
|
|
table.insert(API, ParseClass(i, v));
|
|
|
|
|
else
|
|
|
|
|
Add(Globals, i, v);
|
|
|
|
|
end
|
2013-09-09 16:28:02 -04:00
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2013-09-10 16:02:18 -04:00
|
|
|
return API, Globals;
|
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function DumpAPIHtml()
|
|
|
|
|
LOG("Dumping all available functions and constants to API subfolder...");
|
|
|
|
|
|
|
|
|
|
local API, Globals = CreateAPITables();
|
2013-09-14 10:20:54 -04:00
|
|
|
|
|
|
|
|
-- Sort the classes by name:
|
|
|
|
|
table.sort(API,
|
|
|
|
|
function (c1, c2)
|
|
|
|
|
return (string.lower(c1.Name) < string.lower(c2.Name));
|
|
|
|
|
end
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
-- Add Globals into the API:
|
2013-09-11 10:57:57 -04:00
|
|
|
Globals.Name = "Globals";
|
|
|
|
|
table.insert(API, Globals);
|
|
|
|
|
|
|
|
|
|
-- Read in the descriptions:
|
|
|
|
|
ReadDescriptions(API);
|
2013-09-09 16:28:02 -04:00
|
|
|
|
2013-09-10 16:02:18 -04:00
|
|
|
-- Create a "class index" file, write each class as a link to that file,
|
|
|
|
|
-- then dump class contents into class-specific file
|
|
|
|
|
local f = io.open("API/index.html", "w");
|
2013-09-11 15:21:51 -04:00
|
|
|
if (f == nil) then
|
|
|
|
|
-- Create the output folder
|
|
|
|
|
os.execute("mkdir API");
|
|
|
|
|
local err;
|
|
|
|
|
f, err = io.open("API/index.html", "w");
|
|
|
|
|
if (f == nil) then
|
|
|
|
|
LOGINFO("Cannot output HTML API: " .. err);
|
|
|
|
|
return;
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2013-09-10 16:02:18 -04:00
|
|
|
f:write([[<html><head><title>MCServer API - class index</title>
|
|
|
|
|
<link rel="stylesheet" type="text/css" href="main.css" />
|
|
|
|
|
</head><body>
|
|
|
|
|
<ul>
|
|
|
|
|
]]);
|
2013-09-11 10:57:57 -04:00
|
|
|
for i, cls in ipairs(API) do
|
|
|
|
|
f:write("<li><a href=\"" .. cls.Name .. ".html\">" .. cls.Name .. "</a></li>\n");
|
2013-09-13 04:22:04 -04:00
|
|
|
WriteHtmlClass(cls, API);
|
2013-09-09 16:28:02 -04:00
|
|
|
end
|
2013-09-10 16:02:18 -04:00
|
|
|
f:write("</ul></body></html>");
|
2013-09-09 16:28:02 -04:00
|
|
|
f:close();
|
2013-09-11 15:21:51 -04:00
|
|
|
|
2013-09-13 10:26:17 -04:00
|
|
|
-- Copy the CSS file to the output folder (overwrite any existing):
|
|
|
|
|
cssf = io.open("API/main.css", "w");
|
|
|
|
|
if (cssf ~= nil) then
|
|
|
|
|
cssfi = io.open(g_Plugin:GetLocalDirectory() .. "/main.css", "r");
|
|
|
|
|
if (cssfi ~= nil) then
|
|
|
|
|
local CSS = cssfi:read("*all");
|
|
|
|
|
cssf:write(CSS);
|
|
|
|
|
cssfi:close();
|
|
|
|
|
end
|
|
|
|
|
cssf:close();
|
|
|
|
|
end
|
|
|
|
|
|
2013-09-11 15:21:51 -04:00
|
|
|
LOG("API subfolder written");
|
2013-09-10 16:02:18 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-09-11 10:57:57 -04:00
|
|
|
|
|
|
|
|
function ReadDescriptions(a_API)
|
2013-09-13 08:05:18 -04:00
|
|
|
-- Returns true if the function (specified by its fully qualified name) is to be ignored
|
|
|
|
|
local function IsFunctionIgnored(a_FnName)
|
|
|
|
|
for i, name in ipairs(g_APIDesc.IgnoreFunctions) do
|
|
|
|
|
if (a_FnName:match(name)) then
|
|
|
|
|
return true;
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
return false;
|
|
|
|
|
end
|
|
|
|
|
|
2013-09-11 10:57:57 -04:00
|
|
|
local UnexportedDocumented = {}; -- List of API objects that are documented but not exported, simply a list of names
|
2013-09-13 08:05:18 -04:00
|
|
|
|
2013-09-11 10:57:57 -04:00
|
|
|
for i, cls in ipairs(a_API) do
|
2013-09-14 02:38:39 -04:00
|
|
|
-- Rename special functions:
|
|
|
|
|
for j, fn in ipairs(cls.Functions) do
|
|
|
|
|
if (fn.Name == ".call") then
|
|
|
|
|
fn.DocID = "constructor";
|
|
|
|
|
fn.Name = "() <i>(constructor)</i>";
|
|
|
|
|
elseif (fn.Name == ".add") then
|
|
|
|
|
fn.DocID = "operator_plus";
|
|
|
|
|
fn.Name = "<i>operator +</i>";
|
|
|
|
|
elseif (fn.Name == ".div") then
|
|
|
|
|
fn.DocID = "operator_div";
|
|
|
|
|
fn.Name = "<i>operator /</i>";
|
|
|
|
|
elseif (fn.Name == ".mul") then
|
|
|
|
|
fn.DocID = "operator_mul";
|
|
|
|
|
fn.Name = "<i>operator *</i>";
|
|
|
|
|
elseif (fn.Name == ".sub") then
|
|
|
|
|
fn.DocID = "operator_sub";
|
|
|
|
|
fn.Name = "<i>operator -</i>";
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2013-09-11 10:57:57 -04:00
|
|
|
local APIDesc = g_APIDesc.Classes[cls.Name];
|
|
|
|
|
if (APIDesc ~= nil) then
|
|
|
|
|
cls.Desc = APIDesc.Desc;
|
2013-09-13 04:51:01 -04:00
|
|
|
|
|
|
|
|
-- Process inheritance:
|
|
|
|
|
if (APIDesc.Inherits ~= nil) then
|
|
|
|
|
for j, icls in ipairs(a_API) do
|
|
|
|
|
if (icls.Name == APIDesc.Inherits) then
|
|
|
|
|
table.insert(icls.Descendants, cls);
|
|
|
|
|
cls.Inherits = icls;
|
|
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
end
|
2013-09-14 10:52:15 -04:00
|
|
|
|
|
|
|
|
cls.Undocumented = {}; -- This will contain all the API objects that are not documented
|
|
|
|
|
|
|
|
|
|
local DoxyFunctions = {}; -- This will contain all the API functions together with their documentation
|
|
|
|
|
|
|
|
|
|
local function AddFunction(a_Name, a_Params, a_Return, a_Notes)
|
|
|
|
|
table.insert(DoxyFunctions, {Name = a_Name, Params = a_Params, Return = a_Return, Notes = a_Notes});
|
|
|
|
|
end
|
2013-09-11 10:57:57 -04:00
|
|
|
|
|
|
|
|
if (APIDesc.Functions ~= nil) then
|
|
|
|
|
-- Assign function descriptions:
|
|
|
|
|
for j, func in ipairs(cls.Functions) do
|
2013-09-14 02:38:39 -04:00
|
|
|
local FnName = func.DocID or func.Name;
|
2013-09-13 10:04:32 -04:00
|
|
|
local FnDesc = APIDesc.Functions[FnName];
|
2013-09-14 10:52:15 -04:00
|
|
|
if (FnDesc == nil) then
|
|
|
|
|
-- No description for this API function
|
|
|
|
|
AddFunction(func.Name);
|
|
|
|
|
table.insert(cls.Undocumented, func.Name);
|
|
|
|
|
else
|
|
|
|
|
-- Description is available
|
|
|
|
|
if (FnDesc[1] == nil) then
|
|
|
|
|
-- Single function definition
|
|
|
|
|
AddFunction(func.Name, FnDesc.Params, FnDesc.Return, FnDesc.Notes);
|
|
|
|
|
else
|
|
|
|
|
-- Multiple function overloads
|
|
|
|
|
for k, desc in ipairs(FnDesc) do
|
|
|
|
|
AddFunction(func.Name, desc.Params, desc.Return, desc.Notes);
|
|
|
|
|
end -- for k, desc - FnDesc[]
|
|
|
|
|
end
|
2013-09-11 10:57:57 -04:00
|
|
|
FnDesc.IsExported = true;
|
|
|
|
|
end
|
|
|
|
|
end -- for j, func
|
|
|
|
|
|
2013-09-14 10:52:15 -04:00
|
|
|
-- Replace functions with their described and overload-expanded versions:
|
|
|
|
|
cls.Functions = DoxyFunctions;
|
|
|
|
|
|
2013-09-11 10:57:57 -04:00
|
|
|
-- Add all non-exported function descriptions to UnexportedDocumented:
|
|
|
|
|
for j, func in pairs(APIDesc.Functions) do
|
|
|
|
|
-- TODO
|
|
|
|
|
end
|
|
|
|
|
end -- if (APIDesc.Functions ~= nil)
|
|
|
|
|
|
|
|
|
|
if (APIDesc.Constants ~= nil) then
|
|
|
|
|
-- Assign constant descriptions:
|
|
|
|
|
for j, cons in ipairs(cls.Constants) do
|
|
|
|
|
local CnDesc = APIDesc.Constants[cons.Name];
|
2013-09-14 10:52:15 -04:00
|
|
|
if (CnDesc == nil) then
|
|
|
|
|
-- Not documented
|
|
|
|
|
table.insert(cls.Undocumented, cons.Name);
|
|
|
|
|
else
|
2013-09-11 10:57:57 -04:00
|
|
|
cons.Notes = CnDesc.Notes;
|
|
|
|
|
CnDesc.IsExported = true;
|
|
|
|
|
end
|
|
|
|
|
end -- for j, cons
|
|
|
|
|
|
|
|
|
|
-- Add all non-exported constant descriptions to UnexportedDocumented:
|
|
|
|
|
for j, cons in pairs(APIDesc.Constants) do
|
|
|
|
|
-- TODO
|
|
|
|
|
end
|
|
|
|
|
end -- if (APIDesc.Constants ~= nil)
|
2013-09-13 08:05:18 -04:00
|
|
|
end -- if (APIDesc ~= nil)
|
2013-09-14 02:27:31 -04:00
|
|
|
|
|
|
|
|
-- Remove ignored functions:
|
|
|
|
|
local NewFunctions = {};
|
|
|
|
|
for j, fn in ipairs(cls.Functions) do
|
|
|
|
|
if (not(IsFunctionIgnored(cls.Name .. "." .. fn.Name))) then
|
|
|
|
|
table.insert(NewFunctions, fn);
|
|
|
|
|
end
|
|
|
|
|
end -- for j, fn
|
|
|
|
|
cls.Functions = NewFunctions;
|
2013-09-14 10:20:54 -04:00
|
|
|
|
|
|
|
|
-- Sort the functions (they may have been renamed):
|
|
|
|
|
table.sort(cls.Functions,
|
|
|
|
|
function(f1, f2)
|
2013-09-14 10:52:15 -04:00
|
|
|
if (f1.Name == f2.Name) then
|
|
|
|
|
-- Same name, either comparing the same function to itself, or two overloads, in which case compare the params
|
|
|
|
|
if ((f1.Params == nil) or (f2.Params == nil)) then
|
|
|
|
|
return 0;
|
|
|
|
|
end
|
|
|
|
|
return (f1.Params < f2.Params);
|
|
|
|
|
end
|
2013-09-14 10:20:54 -04:00
|
|
|
return (f1.Name < f2.Name);
|
|
|
|
|
end
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
-- Sort the constants:
|
|
|
|
|
table.sort(cls.Constants,
|
|
|
|
|
function(c1, c2)
|
|
|
|
|
return (c1.Name < c2.Name);
|
|
|
|
|
end
|
|
|
|
|
);
|
2013-09-13 04:51:01 -04:00
|
|
|
end -- for i, cls
|
2013-09-13 08:05:18 -04:00
|
|
|
|
2013-09-13 04:51:01 -04:00
|
|
|
-- Sort the descendants lists:
|
|
|
|
|
for i, cls in ipairs(a_API) do
|
|
|
|
|
table.sort(cls.Descendants,
|
|
|
|
|
function(c1, c2)
|
|
|
|
|
return (c1.Name < c2.Name);
|
|
|
|
|
end
|
|
|
|
|
);
|
|
|
|
|
end -- for i, cls
|
2013-09-11 10:57:57 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-09-13 04:22:04 -04:00
|
|
|
function WriteHtmlClass(a_ClassAPI, a_AllAPI)
|
2013-09-11 10:57:57 -04:00
|
|
|
local cf, err = io.open("API/" .. a_ClassAPI.Name .. ".html", "w");
|
2013-09-10 16:02:18 -04:00
|
|
|
if (cf == nil) then
|
|
|
|
|
return;
|
|
|
|
|
end
|
2013-09-09 16:28:02 -04:00
|
|
|
|
2013-09-13 05:22:27 -04:00
|
|
|
-- Make a link out of anything with the special linkifying syntax {{link|title}}
|
2013-09-10 16:02:18 -04:00
|
|
|
local function LinkifyString(a_String)
|
2013-09-14 02:41:48 -04:00
|
|
|
local txt = a_String:gsub("{{([^|]*)|([^}]*)}}", "<a href=\"%1.html\">%2</a>") -- {{link|title}}
|
|
|
|
|
txt = txt:gsub("{{([^|]*)}}", "<a href=\"%1.html\">%1</a>") -- {{LinkAndTitle}}
|
|
|
|
|
return txt;
|
2013-09-10 16:02:18 -04:00
|
|
|
end
|
|
|
|
|
|
2013-09-13 04:22:04 -04:00
|
|
|
-- Writes a table containing all functions in the specified list, with an optional "inherited from" header when a_InheritedName is valid
|
|
|
|
|
local function WriteFunctions(a_Functions, a_InheritedName)
|
|
|
|
|
if (#a_Functions == 0) then
|
|
|
|
|
return;
|
|
|
|
|
end
|
2013-09-14 10:20:54 -04:00
|
|
|
|
2013-09-13 04:22:04 -04:00
|
|
|
if (a_InheritedName ~= nil) then
|
|
|
|
|
cf:write("<h2>Functions inherited from " .. a_InheritedName .. "</h2>");
|
|
|
|
|
end
|
|
|
|
|
cf:write("<table><tr><th>Name</th><th>Parameters</th><th>Return value</th><th>Notes</th></tr>\n");
|
|
|
|
|
for i, func in ipairs(a_Functions) do
|
|
|
|
|
cf:write("<tr><td>" .. func.Name .. "</td>");
|
|
|
|
|
cf:write("<td>" .. LinkifyString(func.Params or "").. "</td>");
|
|
|
|
|
cf:write("<td>" .. LinkifyString(func.Return or "").. "</td>");
|
|
|
|
|
cf:write("<td>" .. LinkifyString(func.Notes or "") .. "</td></tr>\n");
|
|
|
|
|
end
|
|
|
|
|
cf:write("</table>\n");
|
|
|
|
|
end
|
2013-09-13 04:51:01 -04:00
|
|
|
|
|
|
|
|
local function WriteDescendants(a_Descendants)
|
|
|
|
|
if (#a_Descendants == 0) then
|
|
|
|
|
return;
|
|
|
|
|
end
|
|
|
|
|
cf:write("<ul>");
|
|
|
|
|
for i, desc in ipairs(a_Descendants) do
|
|
|
|
|
cf:write("<li><a href=\"".. desc.Name .. ".html\">" .. desc.Name .. "</a>");
|
|
|
|
|
WriteDescendants(desc.Descendants);
|
|
|
|
|
cf:write("</li>\n");
|
|
|
|
|
end
|
|
|
|
|
cf:write("</ul>\n");
|
|
|
|
|
end
|
2013-09-13 04:22:04 -04:00
|
|
|
|
|
|
|
|
-- Build an array of inherited classes chain:
|
|
|
|
|
local InheritanceChain = {};
|
2013-09-13 04:51:01 -04:00
|
|
|
local CurrInheritance = a_ClassAPI.Inherits;
|
2013-09-13 04:22:04 -04:00
|
|
|
while (CurrInheritance ~= nil) do
|
|
|
|
|
table.insert(InheritanceChain, CurrInheritance);
|
2013-09-13 04:51:01 -04:00
|
|
|
CurrInheritance = CurrInheritance.Inherits;
|
2013-09-13 04:22:04 -04:00
|
|
|
end
|
|
|
|
|
|
2013-09-11 10:57:57 -04:00
|
|
|
cf:write([[<html><head><title>MCServer API - ]] .. a_ClassAPI.Name .. [[</title>
|
2013-09-10 16:02:18 -04:00
|
|
|
<link rel="stylesheet" type="text/css" href="main.css" />
|
|
|
|
|
</head><body>
|
|
|
|
|
<h1>Contents</h1>
|
|
|
|
|
<ul>
|
|
|
|
|
]]);
|
|
|
|
|
|
2013-09-13 04:51:01 -04:00
|
|
|
local HasInheritance = ((#a_ClassAPI.Descendants > 0) or (a_ClassAPI.Inherits ~= nil));
|
|
|
|
|
|
2013-09-10 16:02:18 -04:00
|
|
|
-- Write the table of contents:
|
2013-09-13 04:51:01 -04:00
|
|
|
if (HasInheritance) then
|
2013-09-13 04:22:04 -04:00
|
|
|
cf:write("<li><a href=\"#inherits\">Inheritance</a></li>\n");
|
2013-09-10 16:02:18 -04:00
|
|
|
end
|
2013-09-13 04:22:04 -04:00
|
|
|
cf:write("<li><a href=\"#constants\">Constants</a></li>\n");
|
|
|
|
|
cf:write("<li><a href=\"#functions\">Functions</a></li>\n");
|
2013-09-10 16:02:18 -04:00
|
|
|
cf:write("</ul>");
|
|
|
|
|
|
|
|
|
|
-- Write the class description:
|
2013-09-13 04:22:04 -04:00
|
|
|
cf:write("<a name=\"desc\"><h1>" .. a_ClassAPI.Name .. " class</h1></a>\n");
|
2013-09-11 10:57:57 -04:00
|
|
|
if (a_ClassAPI.Desc ~= nil) then
|
2013-09-10 16:02:18 -04:00
|
|
|
cf:write("<p>");
|
2013-09-13 05:22:27 -04:00
|
|
|
cf:write(LinkifyString(a_ClassAPI.Desc));
|
2013-09-10 16:02:18 -04:00
|
|
|
cf:write("</p>\n");
|
|
|
|
|
end;
|
|
|
|
|
|
2013-09-13 04:22:04 -04:00
|
|
|
-- Write the inheritance, if available:
|
2013-09-13 04:51:01 -04:00
|
|
|
if (HasInheritance) then
|
2013-09-13 04:22:04 -04:00
|
|
|
cf:write("<a name=\"inherits\"><h1>Inheritance</h1></a>\n");
|
2013-09-13 04:51:01 -04:00
|
|
|
if (#InheritanceChain > 0) then
|
|
|
|
|
cf:write("<p>This class inherits from the following parent classes:<ul>\n");
|
|
|
|
|
for i, cls in ipairs(InheritanceChain) do
|
|
|
|
|
cf:write("<li><a href=\"" .. cls.Name .. ".html\">" .. cls.Name .. "</a></li>\n");
|
|
|
|
|
end
|
|
|
|
|
cf:write("</ul></p>\n");
|
|
|
|
|
end
|
|
|
|
|
if (#a_ClassAPI.Descendants > 0) then
|
|
|
|
|
cf:write("<p>This class has the following descendants:\n");
|
|
|
|
|
WriteDescendants(a_ClassAPI.Descendants);
|
|
|
|
|
cf:write("</p>\n");
|
2013-09-10 16:02:18 -04:00
|
|
|
end
|
|
|
|
|
end
|
|
|
|
|
|
2013-09-13 04:22:04 -04:00
|
|
|
-- Write the constants:
|
|
|
|
|
cf:write("<a name=\"constants\"><h1>Constants</h1></a>\n");
|
|
|
|
|
cf:write("<table><tr><th>Name</th><th>Value</th><th>Notes</th></tr>\n");
|
|
|
|
|
for i, cons in ipairs(a_ClassAPI.Constants) do
|
|
|
|
|
cf:write("<tr><td>" .. cons.Name .. "</td>");
|
|
|
|
|
cf:write("<td>" .. cons.Value .. "</td>");
|
|
|
|
|
cf:write("<td>" .. LinkifyString(cons.Notes or "") .. "</td></tr>\n");
|
|
|
|
|
end
|
|
|
|
|
cf:write("</table>\n");
|
|
|
|
|
|
|
|
|
|
-- Write the functions, including the inherited ones:
|
|
|
|
|
cf:write("<a name=\"functions\"><h1>Functions</h1></a>\n");
|
|
|
|
|
WriteFunctions(a_ClassAPI.Functions, nil);
|
|
|
|
|
for i, cls in ipairs(InheritanceChain) do
|
|
|
|
|
WriteFunctions(cls.Functions, cls.Name);
|
2013-09-10 16:02:18 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
|
|
cf:write("</body></html>");
|
|
|
|
|
cf:close();
|
2013-09-09 16:28:02 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-09-11 15:21:51 -04:00
|
|
|
|
