string.dump problems

[Philip Bock <phil@...>]

I've written a simple preprocessor in Lua, to preprocess Lua scripts.
Basically, it implements #include and #define, so I don't have to define
a large number of global variables for commonly used constants. (By the
way, will I really save anything doing it this way? I assume numerical
constants are more efficient than global variables.)

Anyway, I decided to build it into a function I can include with my
program to preprocess and then byte-compile source files, so I don't
have to package a seperate luac binary. My problem is that string.dump()
doesn't seem to be generating valid byte-code. If I execute the function
returned from loadstring(), I get the expected results. If I dump the
code my preprocessor generates, and run it through either luac or
luac.lua, I get the expected results.

The byte-code string.dump() generates seems to contain a copy of the
text of the source passed to loadstring. I notice that neither luac or
luac.lua seem to do this.

The source is attached. To test it, call it like this:

lua preprocess.lua infile.lua outfile

My platform is win32, in case that matters.

Thanks, Philip Bock

--[[
	This preprocessor was written for Lua scripts. It's not a C preprocessor,
	because it only understands the #include, #define, and #undef directives.
	No other features are supported, not even comments. No error checking
	is performed, so incorrect directives will result in mangled output.
]]

-- Main parser
function preprocess(infile, outfile, macros)
	for line in infile:lines() do
		-- Perfrom macro substitution
		for mname, mval in pairs(macros) do
			line = string.gsub(line, "([^%w_])"..mname.."([^%w_])", function (x, y) return x..mval..y end)
			line = string.gsub(line, "^"..mname.."$", mval)
			line = string.gsub(line, "^"..mname.."[^%w_]", function (x) return mval..x end)
			line = string.gsub(line, "[^%w_]"..mname.."$", function (x) return x..mval end)
		end

		-- Check for directives
		local _, _, directive, arguments = string.find(line, "^%#(%w+)%s+(.+)$")

		if (directive == nil) then -- No directives
			outfile:write(line.."\n")
		elseif (directive == "define") then
			local _, _, macro_name, macro_val = string.find(arguments, "^(%S+)%s+(%S+)")
			if (macro_val) then
				macros[macro_name] = macro_val
			else
				macros[macro_name] = 0
			end
		elseif (directive == "undef") then
			macros[arguments] = nil
		elseif (directive == "include") then
			local _, _, includefile = string.find(arguments, "^%p(.+)%p$")
			preprocess(assert(io.open(includefile, "r"), "Error opening #include file "..includefile), outfile, macros)
		else
			error("Unknown directive "..directive)
		end
	end
end

function luac(infilename, outfilename)
	local macros = {}
	local infile = assert(io.open(infilename, "r"))
	local outfile = assert(io.open(outfilename, "wb"))
	local tempfile = io.tmpfile()

	preprocess(infile, tempfile, macros)
	tempfile:seek("set")

	func = loadstring(tempfile:read("*a"))

	func()

	outfile:write(string.dump(func))

	tempfile:close()
	infile:close()
	outfile:close()
end

luac(arg[1], arg[2])