~philho/+junk/Lua

#!Lua5.1.exe
--[[
String dump of any Lua object.

File/Project history:
 1.03 -- 2010/03/18 (PL) -- I dumped { 'a', 'b', 'c' } to { [1] = 'a', [2] = 'b', [3] = 'c' }
         which wasn't very nice. Now if I find a key of 1, I walk the array part of the table
         first then I dump the other keys.
 1.02 -- 2007/03/15 (PL) -- Special, compact handling of empty tables.
         Also corrected a bug in quotes around tostring result ("foo')
 1.01 -- 2006/11/07 (PL) -- Exclude keywords from "naked" string keys.
 1.00 -- 2006/07/13 (PL) -- Creation of this version.
 0.01 -- 2003/??/?? (PL) -- First version?
]]
--[[
Author: Philippe Lhoste <PhiLho(a)GMX.net> http://Phi.Lho.free.fr
Copyright notice: For details, see the following file:
http://Phi.Lho.free.fr/softwares/PhiLhoSoft/PhiLhoSoftLicense.txt
This program is distributed under the zlib/libpng license.
Copyright (c) 2006-2010 Philippe Lhoste / PhiLhoSoft
]]

--[[
Returns a textual representation of "any" Lua object,
including tables (and nested tables).
Functions are not decompiled (of course).
It sticks strictly to the real table constructor syntax,
so the result can be reparsed by Lua to recreate the object,
at least if there are NO complex objects (functions, userdata...).
It handles references correctly, except for cycles (a ref. b which ref. a).

Example of use:
For an indented dump:
  print(DumpObject(tableName))
For an inline dump:
  print(DumpObject(t, '', ' '))
]]
function DumpObject(objectToDump, indentUnit, newline)
	local function KeywordList(list)
		local kl = {}
		for i, v in ipairs(list) do
			kl[v] = i
		end
		return kl
	end

	-- We can write a = 1 in table constructor, but not for = 1 because for is a keyword.
	-- So we have to list all keywords to make a special rule for them.
	local keywords = KeywordList
	{
		'and', 'break',    'do',     'else', 'elseif', 'end',   'false',
		'for', 'function', 'if',     'in',   'local',  'nil',   'not',
		'or',  'repeat',   'return', 'then', 'true',   'until', 'while'
	}

	-- The string used to indent
	-- Give an empty string for no indentation
	if indentUnit == nil then
		indentUnit = "  " -- 2 spaces
	end
	-- Give an empty string or space to put all the dump in one line
	if newline == nil then
		newline = "\n"
	end

	-- Current indent level/string
	local indent = ""
	-- Table of visited tables, to handle cross-references
	local visited = {}
	-- Number of the currently visited table
	local tableIndex = 0
	-- We put the dump string fragments here, to concatenate them later
	local dump = {}
	-- Half backed tentative to handle cyclic references...
	local dumpAfter, daIndex = {}, 0

	-- In the following functions, the  bOnLeft parameter
	-- is true if we are on the left side of an assignment (=), false on the right side

	-- If on left of assignment, add brackets around the string,
	-- otherwise, leave it as is.
	local function GetLeftOrRight(str, bOnLeft)
		if bOnLeft then
			-- Index syntax
			return '[' .. str .. ']'
		else
			-- Plain object
			return str
		end
	end

	-- Add the right quotes around the string, depending on what we
	-- find in it, and if we are on left or on right of assignment.
	local function QuoteString(str, bOnLeft)
		if bOnLeft and string.find(str, '[^%w_]') == nil and not keywords[str] then
			-- String with variable syntax on the left side of '=': can be left unquoted
			return str
		end
		local qs
		if string.find(str, '[\\\r\n"]') == nil then
			-- No special chars, can just use double quotes
			qs = '"' .. str .. '"'
		elseif string.find(str, "[\\\r\n']") == nil then
			-- No special chars, can just use single quotes
			qs = "'" .. str .. "'"
		else
			-- Backslash or newline or double quotes in string, must use literal string
			if bOnLeft then
				-- We have to write [ [[...]] ] (with spaces) to avoid ambiguity
				qs = ' [[' .. str .. ']] '
			else
				qs = '[[' .. str .. ']]'
			end
		end
		return GetLeftOrRight(qs, bOnLeft)
	end

	-- Return a correctly quoted (or not) string representation
	-- of the given object.
	-- Must not be called with a table, which is processed separately.
	local function DumpItem(object, bOnLeft)
		local di = "UH?"
		local to = type(object)
		if to == "string" then
			di = QuoteString(object, bOnLeft)
		elseif to == "number" or to == "boolean" then
			di = GetLeftOrRight(tostring(object), bOnLeft)
		elseif to  == "nil" then -- If the first object is nil itself...
			return 'nil' -- Cannot happen on left, can it?
		elseif to  == "table" then
			di = "TABLE!" -- Should be tested before...
		else
			-- function, userdata, thread, ...
			-- Put the tostring result between double quotes
			-- It won't be restored correctly, but it won't give a syntax error...
			di = GetLeftOrRight('"' .. tostring(object) .. '"', bOnLeft)
		end
		return di
	end

	local function AddKeyValue(td, tdi, left, right)
		if tdi ~= 1 then
			-- Add field separator
			tdi = tdi + 1
			td[tdi] = "," .. newline
		end
		-- Add this field
		tdi = tdi + 1
		if left == nil then
			-- Successive numerical index, don't put a key
			td[tdi] = indent .. right
		else
			td[tdi] = indent .. left .. " = " .. right
		end
		return tdi
	end

	-- Walk the object (if it is a table) and build
	-- a string representation of the found objects.
	-- bForce bypasses the reference mechanism,
	-- forcing to dump the table (for referenced tables).
	local function DumpRecursively(object, bOnLeft, bForce)
		if type(object) == "table" then
			if visited[object].visits > 1 and not bForce then
				-- Cross-reference
				if object == objectToDump then
					-- Don't reference the root table! (trying to handle cycles)
					return nil
				else
					-- We have a referenced table, return its variable name
					return GetLeftOrRight("T" .. visited[object].idx, bOnLeft)
				end
			end

			local openBrace, closeBrace
			if bOnLeft then
				-- Using a raw table constructor as key!
				-- Only accessible by iteration...
				if next(object) == nil then	-- Empty table
					-- Use a lighter traditional representation
					openBrace = "[ {"; closeBrace = "} ]"
				else
					openBrace = "[ {" .. newline
					closeBrace = newline .. indent .. "} ]"
				end
			else
				if next(object) == nil then	-- Empty table
					-- Use a lighter traditional representation
					openBrace = "{"; closeBrace = "}"
				else
					openBrace = newline .. indent .. "{" .. newline
					closeBrace = newline .. indent .. "}"
				end
			end

			-- Start of table dump
			local td = { openBrace }
			local tdi = 1
			-- Indent more
			indent = indent .. indentUnit

			--Handle the array part, if any
			local lastNumericalIndex = 0
			if object[1] ~= nil then
				-- This table as an array section, perhaps with increasing numerical indices
				for i, v in ipairs(object) do
					lastNumericalIndex = i
					-- Add value without key
					local right = DumpRecursively(v, false, false)
					tdi = AddKeyValue(td, tdi, nil, string.gsub(right, '^\n%s*', '')) -- Skip initial newline if any
--~ 					tdi = AddKeyValue(td, tdi, nil, right)
				end
			end

			-- Walk the table
			local k, v = nil, nil
			repeat
				k, v = next(object, k)
				if k ~= nil then
					local bIsNumberKey = type(k) == "number"
					if not bIsNumberKey or bIsNumberKey and k > lastNumericalIndex then
						local left = DumpRecursively(k, true, false)
						local right = DumpRecursively(v, false, false)
						if right == nil then
							-- Tentative to handle cycles
							daIndex = daIndex + 1
							-- Incorrect, it must not be 'left' but the full path!
							dumpAfter[daIndex] = left .. " = T" .. visited[v].idx
						else
							tdi = AddKeyValue(td, tdi, left, right)
						end
					end
				end
			until k == nil

			-- Deindent
			indent = string.sub(indent, string.len(indentUnit) + 1)
			-- End of table
			tdi = tdi + 1
			td[tdi] = closeBrace
			return table.concat(td)
		else -- Not a table
			-- Return a string equivalence
			return DumpItem(object, bOnLeft)
		end
	end

	-- List cross references of the given object (must be a table).
	local function ListCrossReferences(object)
		if type(object) == "table" then
			if visited[object] ~= nil then
				-- Already seen, cross-reference
				visited[object].visits = visited[object].visits + 1
				return
			end
			-- First seen, number it
			tableIndex = tableIndex + 1
			visited[object] = { visits = 1, idx = tableIndex }

			-- Walk this table and see if it has other tables inside
			local k, v = nil, nil
			repeat
				k, v = next(object, k)
				if k ~= nil then
					ListCrossReferences(k)
					ListCrossReferences(v)
				end
			until k == nil
		end
	end

	-- Dump the tables referenced more than once,
	-- so they make easy to reference variables.
	local function DumpCrossReferences()
		local k, v = nil, nil
		repeat
			k, v = next(visited, k)
			if k ~= nil and v.visits > 1 and k ~= objectToDump then
				dump[v.idx] = "\nlocal T" .. v.idx .. " = " .. DumpRecursively(k, false, true)
			end
		until k == nil
	end

	-- List all cross-references of the (possibly) table
	ListCrossReferences(objectToDump)
	-- Dump the tables used in cross-references
	DumpCrossReferences()
	-- Add the main table
	dump[tableIndex + 1] = "\nlocal T = " .. DumpRecursively(objectToDump, false, true)
	-- Fill in the gaps, so concat could work
	for i = 1, tableIndex do
		if dump[i] == nil then
			dump[i] = ''
		end
	end
	return table.concat(dump) .. "\n" .. table.concat(dumpAfter)
end

--[[
Write a dump of the object (likely to be a table...)
to the given file.
It can be used with:
  table = dofile("DumpedTable.lua")
]]
function DumpObjectToFile(object, fileName, indentUnit, newline)
	local fh = io.open(fileName, "w")
	fh:write("do\n" .. DumpObject(object, indentUnit, newline) .. "\nreturn T\n\nend\n")
	fh:close()
end

--[[
For a quick in-line dump of a simple table (no cross-references)
without the initialization stuff.
]]
function FormatSimpleTable(t)
	return (string.gsub(string.gsub(DumpObject(t, '', ' '), "^\nlocal T = ", ""), "\n$", ""))
end