d0p1/ack
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Remove defunct pmfiles.

Browse source 
--HG--
branch : default-branch
This commit is contained in:
David Given 2016-06-03 13:56:50 +02:00
parent 9d620ad1c2
commit 88bd7ce126
106 changed files with 0 additions and 5840 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
first/ack-custom.pm
View file

@ -1,21 +0,0 @@
-- $Source$
-- $State$
-- Custom rules used by the ACK build process.
preprocess = simple {
class = "preprocess",
outputs = {"%U%-%I%"},
command = {
"cpp -I%HEADERDIR% %in% > %out[1]%"
}
}
-- Revision history
-- $Log$
-- Revision 1.2 2007-02-20 00:32:58 dtrg
-- Changed the 'preprocess' rule to use the system C preprocessor.
--
-- Revision 1.1 2006/07/22 00:49:48 dtrg
-- First version in CVS.
--

33
first/ack.pm
View file

@ -1,33 +0,0 @@
-- $Source$
-- $State$
-- Provides rules for building things with the half-built ACK itself.
ACKBUILDFLAGS = {"-m%PLATFORM%", "%OPTIMISATION%"}
ACKDEFINES = EMPTY
ACKINCLUDES = EMPTY
ackfile = simple_with_clike_dependencies {
class = "ackfile",
CINCLUDES = {REDIRECT, "ACKINCLUDES"},
command = {
"%BINDIR%bin/ack %ACKBUILDFLAGS% %ACKINCLUDES:cincludes% %ACKDEFINES:cdefines% -c -o %out% %in%"
},
outputs = {"%U%-%I%.o"},
}
ackprogram = simple {
class = "ackprogram",
command = {
"%BINDIR%bin/ack %ACKBUILDFLAGS% -o %out% %in%"
},
outputs = {"%U%-%I%"},
}
acklibrary = simple {
class = "acklibrary",
command = {
"%RM% %out% && %BINDIR%bin/aal cr %out% %in%"
},
outputs = {"%U%-%I%.a"},
}

238
first/c.pm
View file

@ -1,238 +0,0 @@
-- $Id$
-- $HeadURL: https://primemover.svn.sf.net/svnroot/primemover/pm/lib/c.pm $
-- $LastChangedDate: 2007-02-24 01:37:06 +0000 (Sat, 24 Feb 2007) $
-- pm includefile to compile *host* C programs.
-- Standard Lua boilerplate.
local io_open = io.open
local string_gsub = string.gsub
local string_gfind = string.gfind
local string_find = string.find
local table_insert = table.insert
local table_getn = table.getn
local filetime = pm.filetime
-- Define some variables.
CCOMPILER = "gcc"
CXXCOMPILER = "g++"
CC = "%CCOMPILER% %CBUILDFLAGS% %CDYNINCLUDES:cincludes% %CINCLUDES:cincludes% %CDEFINES:cdefines% %CEXTRAFLAGS% -c -o %out% %in%"
CXX = "%CXXCOMPILER% %CBUILDFLAGS% %CDYNINCLUDES:cincludes% %CINCLUDES:cincludes% %CDEFINES:cdefines% %CEXTRAFLAGS% -c -o %out% %in%"
CPROGRAM = "%CCOMPILER% %CBUILDFLAGS% %CLINKFLAGS% %CEXTRAFLAGS% -o %out% %in% %CLIBRARIES:clibraries%"
CXXPROGRAM = "%CXXCOMPILER% %CBUILDFLAGS% %CLINKFLAGS% %CEXTRAFLAGS% -o %out% %in% %CLIBRARIES:clibraries%"
CLIBRARY = "rm -f %out% && ar cr %out% %in% && ranlib %out%"
CBUILDFLAGS = {"-g"}
CINCLUDES = EMPTY
CDEFINES = EMPTY
CEXTRAFLAGS = EMPTY
CLINKFLAGS = EMPTY
CDYNINCLUDES = EMPTY
CLIBRARIES = EMPTY
--- Custom string modifiers -------------------------------------------------
local function prepend(rule, arg, prefix)
if (arg == EMPTY) then
return EMPTY
end
local t = {}
for i, j in ipairs(arg) do
t[i] = prefix..j
end
return t
end
function pm.stringmodifier.cincludes(rule, arg)
return prepend(rule, arg, "-I")
end
function pm.stringmodifier.cdefines(rule, arg)
return prepend(rule, arg, "-D")
end
function pm.stringmodifier.clibraries(rule, arg)
if (arg == EMPTY) then
return EMPTY
end
local t = {}
for i, j in ipairs(arg) do
if string_find(j, "%.a$") then
t[i] = j
else
t[i] = "-l"..j
end
end
return t
end
--- Manage C file dependencies ----------------------------------------------
local dependency_cache = {}
local function calculate_dependencies(filename, includes)
-- Cache values, so we don't recalculate dependencies needlessly.
local o = dependency_cache[filename]
if o then
return o
end
local deps = {}
deps[filename] = true
local calcdeps = 0
calcdeps = function(filename, file)
file = file or io_open(filename)
if not file then
return
end
local localincludes = string_gsub(filename, "/[^/]*$", "")
if localincludes then
localincludes = {localincludes, unpack(includes)}
else
localincludes = includes
end
for line in file:lines() do
local _, _, f = string_find(line, '^[ \t]*#[ \t]*include[ \t]*["<]([^"]+)[">]')
if f then
for _, path in ipairs(localincludes) do
local subfilename = path.."/"..f
local subfile = io_open(subfilename)
if subfile then
if not deps[subfilename] then
deps[subfilename] = true
calcdeps(subfilename, subfile)
end
break
end
end
end
end
-- Explicit close to avoid having to wait for the garbage collector
-- to free up the underlying fd.
file:close()
end
calcdeps(filename)
o = {}
for i, _ in pairs(deps) do
table_insert(o, i)
end
dependency_cache[filename] = o
return o
end
-- This clause specialises 'simple' to add support for smart dependencies of C
-- files.
simple_with_clike_dependencies = simple {
class = "simple_with_clike_dependencies",
makedepends = {"%CDEPENDS%"},
__init = function(self, p)
simple.__init(self, p)
-- If we're a class, don't verify.
if ((type(p) == "table") and p.class) then
return
end
-- If dynamicheaders is an object, turn it into a singleton list.
if self.dynamicheaders then
if (type(self.dynamicheaders) ~= "table") then
self:__error("doesn't know what to do with dynamicheaders, which ",
"should be a list or an object but was a ", type(self.dynamicheaders))
end
if self.dynamicheaders.class then
self.dynamicheaders = {self.dynamicheaders}
end
end
end,
__dependencies = function(self, inputs, outputs)
local cincludes = self:__index("CINCLUDES")
if (type(cincludes) == "string") then
cincludes = {cincludes}
end
local includes = {}
for _, i in ipairs(cincludes) do
table_insert(includes, self:__expand(i))
end
local input = self:__expand(inputs[1])
local depends = calculate_dependencies(input, includes)
if not depends then
self:__error("could not determine the dependencies for ",
pm.rendertable({input}))
end
if pm.verbose then
pm.message('"', input, '" appears to depend on ',
pm.rendertable(depends))
end
return depends
end,
__buildadditionalchildren = function(self)
self.CDYNINCLUDES = {}
if self.dynamicheaders then
for _, i in ipairs(self.dynamicheaders) do
local o = i:__build()
if o[1] then
table_insert(self.CDYNINCLUDES, (string_gsub(o[1], "/[^/]*$", "")))
end
end
end
-- If no paths on the list, replace the list with EMPTY so it doesn't
-- expand to anything.
if (table_getn(self.CDYNINCLUDES) == 0) then
self.CDYNINCLUDES = EMPTY
end
end
}
-- These are the publically useful clauses.
cfile = simple_with_clike_dependencies {
class = "cfile",
command = {"%CC%"},
outputs = {"%U%-%I%.o"},
}
cxxfile = simple_with_clike_dependencies {
class = "cxxfile",
command = {"%CXX%"},
outputs = {"%U%-%I%.o"},
}
cprogram = simple {
class = "cprogram",
command = {"%CPROGRAM%"},
outputs = {"%U%-%I%"},
}
cxxprogram = simple {
class = "cxxprogram",
command = {"%CXXPROGRAM%"},
outputs = {"%U%-%I%"},
}
clibrary = simple {
class = "clibrary",
command = {
"%CLIBRARY%"
},
outputs = {"%U%-%I%.a"},
}

37
first/llgen.pm
View file

@ -1,37 +0,0 @@
-- $Source$
-- $State$
-- This is unpleasant. LLgen can generate an arbitrary number of output files,
-- which means we need our own output filename generator.
LLgen = simple {
class = "LLgen",
command = {
"rm -f %out%",
"cd %out[1]:dirname% && %TOOLDIR%LLgen %in%"
},
outputs = {"%U%/" },
__outputs = function(self, inputs)
local o = simple.__outputs(self, inputs)[1]
local outputs = {o.."Lpars.h", o.."Lpars.c"}
for _, i in ipairs(inputs) do
i = string.gsub(i, "^.*/", "")
i = string.gsub(i, "%.g$", ".c")
table.insert(outputs, o..i)
end
return outputs
end
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-11-11 22:59:01 dtrg
-- Now uses the version of LLgen included with the ACK instead of the standalone version.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

18
first/yacc.pm
View file

@ -1,18 +0,0 @@
yacc = simple {
class = "yacc",
outputs = {"%U%/%I%.c"},
command = {
"yacc -t -b %out[1]:dirname%/y -d %in%",
"mv %out[1]:dirname%/y.tab.c %out[1]%"
}
}
flex = simple {
class = "flex",
outputs = {"%U%/%I%.c"},
command = {
"flex -s -t %in% > %out%"
}
}

45
lang/basic/lib/pmfile
View file

@ -1,45 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."lang/basic/lib/"
lang_basic_runtime = acklibrary {
ACKINCLUDES = {PARENT, "%ROOTDIR%h"},
ackfile (d.."fif.e"),
ackfile (d.."fef.e"),
ackfile (d.."setline.e"),
ackfile (d.."abs.c"),
ackfile (d.."asc.c"),
ackfile (d.."asrt.c"),
ackfile (d.."atn.c"),
ackfile (d.."chr.c"),
ackfile (d.."conversion.c"),
ackfile (d.."error.c"),
ackfile (d.."exp.c"),
ackfile (d.."file.c"),
ackfile (d.."hlt.c"),
ackfile (d.."io.c"),
ackfile (d.."log.c"),
ackfile (d.."mki.c"),
ackfile (d.."oct.c"),
ackfile (d.."peek.c"),
ackfile (d.."power.c"),
ackfile (d.."print.c"),
ackfile (d.."random.c"),
ackfile (d.."read.c"),
ackfile (d.."return.c"),
ackfile (d.."salloc.c"),
ackfile (d.."sgn.c"),
ackfile (d.."sin.c"),
ackfile (d.."sqt.c"),
ackfile (d.."stop.c"),
ackfile (d.."string.c"),
ackfile (d.."swap.c"),
ackfile (d.."trace.c"),
ackfile (d.."trap.c"),
ackfile (d.."write.c"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/libbasic.a")
}

7
lang/basic/pmfile
View file

@ -1,7 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/basic/"
include (d.."src/pmfile")
include (d.."lib/pmfile")

64
lang/basic/src/pmfile
View file

@ -1,64 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/basic/src/"
local lpars = LLgen {
file (d.."basic.g"),
}
local tokentab_h = simple {
outputs = {"%U%/token.h"},
command = {
"cd %out[1]:dirname% && %in[1]% %in[2]%"
},
file (d.."maketokentab"),
lpars
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
lpars,
tokentab_h
}
}
lang_basic_compiler = cprogram {
cfile_with_headers (d.."bem.c"),
cfile_with_headers (d.."symbols.c"),
cfile_with_headers (d.."initialize.c"),
cfile_with_headers (d.."compile.c"),
cfile_with_headers (d.."parsepar.c"),
cfile_with_headers (d.."gencode.c"),
cfile_with_headers (d.."util.c"),
cfile_with_headers (d.."graph.c"),
cfile_with_headers (d.."eval.c"),
cfile_with_headers (d.."func.c"),
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
lib_em_mes,
lib_emk,
lib_em_data,
lib_alloc,
lib_print,
lib_string,
lib_system,
outputs = {"%U%/em_bem"},
install = {
pm.install("%BINDIR%%PLATDEP%/em_bem"),
}
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-26 23:08:09 dtrg
-- Added support for the Basic compiler.
--

210
lang/cem/cemcom.ansi/pmfile
View file

@ -1,210 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/cemcom.ansi/"
local extract_parameters = simple {
outputs = {
"%U%/lint.h",
"%U%/pathlength.h",
"%U%/errout.h",
"%U%/idfsize.h",
"%U%/numsize.h",
"%U%/nparams.h",
"%U%/ifdepth.h",
"%U%/density.h",
"%U%/macbuf.h",
"%U%/strsize.h",
"%U%/trgt_sizes.h",
"%U%/botch_free.h",
"%U%/dataflow.h",
"%U%/debug.h",
"%U%/use_tmp.h",
"%U%/parbufsize.h",
"%U%/textsize.h",
"%U%/inputtype.h",
"%U%/nopp.h",
"%U%/nobitfield.h",
"%U%/spec_arith.h",
"%U%/static.h",
"%U%/nocross.h",
"%U%/regcount.h",
"%U%/dbsymtab.h",
},
command = {
"cd %out[1]:dirname% && %in[1]% %in[2]%"
},
file (d.."make.hfiles"),
file (d.."BigPars")
}
local lpars = LLgen {
simple {
outputs = {"%U%/tokenfile.g"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokfile"),
file (d.."tokenname.c")
},
file (d.."program.g"),
file (d.."declar.g"),
file (d.."expression.g"),
file (d.."statement.g"),
file (d.."ival.g"),
}
local allocd_header = simple {
class = "allocd_header",
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.allocd")
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
extract_parameters,
allocd_header { outputs = {"%U%/code.h"}, (d.."code.str") },
allocd_header { outputs = {"%U%/declar.h"}, (d.."declar.str") },
allocd_header { outputs = {"%U%/def.h"}, (d.."def.str") },
allocd_header { outputs = {"%U%/expr.h"}, (d.."expr.str") },
allocd_header { outputs = {"%U%/field.h"}, (d.."field.str") },
allocd_header { outputs = {"%U%/estack.h"}, (d.."estack.str") },
allocd_header { outputs = {"%U%/util.h"}, (d.."util.str") },
allocd_header { outputs = {"%U%/proto.h"}, (d.."proto.str") },
allocd_header { outputs = {"%U%/replace.h"}, (d.."replace.str") },
allocd_header { outputs = {"%U%/idf.h"}, (d.."idf.str") },
allocd_header { outputs = {"%U%/macro.h"}, (d.."macro.str") },
allocd_header { outputs = {"%U%/stack.h"}, (d.."stack.str") },
allocd_header { outputs = {"%U%/stmt.h"}, (d.."stmt.str") },
allocd_header { outputs = {"%U%/struct.h"}, (d.."struct.str") },
allocd_header { outputs = {"%U%/switch.h"}, (d.."switch.str") },
allocd_header { outputs = {"%U%/type.h"}, (d.."type.str") },
allocd_header { outputs = {"%U%/l_brace.h"}, (d.."l_brace.str") },
allocd_header { outputs = {"%U%/l_state.h"}, (d.."l_state.str") },
allocd_header { outputs = {"%U%/l_outdef.h"}, (d.."l_outdef.str") },
lpars
}
}
lang_cem_ansi_compiler = cprogram {
cfile_with_headers (d.."LLlex.c"),
cfile_with_headers (d.."LLmessage.c"),
cfile_with_headers (d.."arith.c"),
cfile_with_headers (d.."blocks.c"),
cfile_with_headers (d.."ch3.c"),
cfile_with_headers (d.."ch3bin.c"),
cfile_with_headers (d.."ch3mon.c"),
cfile_with_headers (d.."code.c"),
cfile_with_headers (d.."conversion.c"),
cfile_with_headers (d.."cstoper.c"),
cfile_with_headers (d.."dataflow.c"),
cfile_with_headers (d.."declarator.c"),
cfile_with_headers (d.."decspecs.c"),
cfile_with_headers (d.."domacro.c"),
cfile_with_headers (d.."dumpidf.c"),
cfile_with_headers (d.."error.c"),
cfile_with_headers (d.."eval.c"),
cfile_with_headers (d.."expr.c"),
cfile_with_headers (d.."field.c"),
cfile_with_headers (d.."fltcstoper.c"),
cfile_with_headers (d.."idf.c"),
cfile_with_headers (d.."init.c"),
cfile_with_headers (d.."input.c"),
cfile_with_headers (d.."l_comment.c"),
cfile_with_headers (d.."l_ev_ord.c"),
cfile_with_headers (d.."l_lint.c"),
cfile_with_headers (d.."l_misc.c"),
cfile_with_headers (d.."l_outdef.c"),
cfile_with_headers (d.."l_states.c"),
cfile_with_headers (d.."label.c"),
cfile_with_headers (d.."main.c"),
cfile_with_headers (d.."options.c"),
cfile_with_headers (d.."pragma.c"),
cfile_with_headers (d.."proto.c"),
cfile_with_headers (d.."replace.c"),
cfile_with_headers (d.."skip.c"),
cfile_with_headers (d.."stab.c"),
cfile_with_headers (d.."stack.c"),
cfile_with_headers (d.."struct.c"),
cfile_with_headers (d.."switch.c"),
cfile_with_headers (d.."tokenname.c"),
cfile_with_headers (d.."type.c"),
cfile_with_headers (d.."util.c"),
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
cfile_with_headers {
simple {
outputs = {"%U%-symbol2str.c"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokcase"),
file (d.."tokenname.c")
}
},
cfile_with_headers {
CINCLUDES = {PARENT, d},
tabgen (d.."char.tab")
},
cfile_with_headers {
simple {
outputs = {"%U%-next.c"},
command = {
"%in% > %out%"
},
file (d.."make.next"),
file (d.."code.str"),
file (d.."declar.str"),
file (d.."def.str"),
file (d.."expr.str"),
file (d.."field.str"),
file (d.."estack.str"),
file (d.."util.str"),
file (d.."proto.str"),
file (d.."replace.str"),
file (d.."idf.str"),
file (d.."macro.str"),
file (d.."stack.str"),
file (d.."stmt.str"),
file (d.."struct.str"),
file (d.."switch.str"),
file (d.."type.str"),
file (d.."l_brace.str"),
file (d.."l_state.str"),
file (d.."l_outdef.str"),
}
},
lib_em_mes,
lib_emk,
lib_em_data,
lib_input,
lib_assert,
lib_alloc,
lib_flt_arith,
lib_print,
lib_system,
lib_string,
outputs = {"%U%/em_cemcom.ansi"},
install = {
pm.install( BINDIR..PLATDEP.."/em_cemcom.ansi"),
pm.install(d.."cemcom.ansi.1", BINDIR.."/man/man1/cemcom.ansi.1"),
}
}

209
lang/cem/cemcom/pmfile
View file

@ -1,209 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/cemcom/"
local extract_parameters = simple {
outputs = {
"%U%/lint.h",
"%U%/pathlength.h",
"%U%/errout.h",
"%U%/idfsize.h",
"%U%/numsize.h",
"%U%/nparams.h",
"%U%/ifdepth.h",
"%U%/density.h",
"%U%/lapbuf.h",
"%U%/strsize.h",
"%U%/target_sizes.h",
"%U%/botch_free.h",
"%U%/dataflow.h",
"%U%/debug.h",
"%U%/use_tmp.h",
"%U%/parbufsize.h",
"%U%/textsize.h",
"%U%/inputtype.h",
"%U%/nopp.h",
"%U%/nobitfield.h",
"%U%/spec_arith.h",
"%U%/static.h",
"%U%/nofloat.h",
"%U%/noRoption.h",
"%U%/nocross.h",
"%U%/regcount.h",
"%U%/dbsymtab.h",
},
command = {
"cd %out[1]:dirname% && %in[1]% %in[2]%"
},
file (d.."make.hfiles"),
file (d.."BigPars")
}
local lpars = LLgen {
simple {
outputs = {"%U%/tokenfile.g"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokfile"),
file (d.."tokenname.c")
},
file (d.."program.g"),
file (d.."declar.g"),
file (d.."expression.g"),
file (d.."statement.g"),
file (d.."ival.g"),
}
local allocd_header = simple {
class = "allocd_header",
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.allocd")
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
extract_parameters,
allocd_header { outputs = {"%U%/code.h"}, (d.."code.str") },
allocd_header { outputs = {"%U%/declar.h"}, (d.."declar.str") },
allocd_header { outputs = {"%U%/def.h"}, (d.."def.str") },
allocd_header { outputs = {"%U%/expr.h"}, (d.."expr.str") },
allocd_header { outputs = {"%U%/field.h"}, (d.."field.str") },
allocd_header { outputs = {"%U%/estack.h"}, (d.."estack.str") },
allocd_header { outputs = {"%U%/util.h"}, (d.."util.str") },
allocd_header { outputs = {"%U%/decspecs.h"}, (d.."decspecs.str") },
allocd_header { outputs = {"%U%/idf.h"}, (d.."idf.str") },
allocd_header { outputs = {"%U%/macro.h"}, (d.."macro.str") },
allocd_header { outputs = {"%U%/stack.h"}, (d.."stack.str") },
allocd_header { outputs = {"%U%/stmt.h"}, (d.."stmt.str") },
allocd_header { outputs = {"%U%/struct.h"}, (d.."struct.str") },
allocd_header { outputs = {"%U%/switch.h"}, (d.."switch.str") },
allocd_header { outputs = {"%U%/type.h"}, (d.."type.str") },
allocd_header { outputs = {"%U%/l_brace.h"}, (d.."l_brace.str") },
allocd_header { outputs = {"%U%/l_state.h"}, (d.."l_state.str") },
allocd_header { outputs = {"%U%/l_outdef.h"}, (d.."l_outdef.str") },
lpars
}
}
lang_cem_compiler = cprogram {
cfile_with_headers (d.."LLlex.c"),
cfile_with_headers (d.."LLmessage.c"),
cfile_with_headers (d.."arith.c"),
cfile_with_headers (d.."asm.c"),
cfile_with_headers (d.."blocks.c"),
cfile_with_headers (d.."ch7.c"),
cfile_with_headers (d.."ch7bin.c"),
cfile_with_headers (d.."ch7mon.c"),
cfile_with_headers (d.."code.c"),
cfile_with_headers (d.."conversion.c"),
cfile_with_headers (d.."cstoper.c"),
cfile_with_headers (d.."dataflow.c"),
cfile_with_headers (d.."declarator.c"),
cfile_with_headers (d.."decspecs.c"),
cfile_with_headers (d.."domacro.c"),
cfile_with_headers (d.."dumpidf.c"),
cfile_with_headers (d.."error.c"),
cfile_with_headers (d.."eval.c"),
cfile_with_headers (d.."expr.c"),
cfile_with_headers (d.."field.c"),
cfile_with_headers (d.."idf.c"),
cfile_with_headers (d.."init.c"),
cfile_with_headers (d.."input.c"),
cfile_with_headers (d.."l_comment.c"),
cfile_with_headers (d.."l_ev_ord.c"),
cfile_with_headers (d.."l_lint.c"),
cfile_with_headers (d.."l_misc.c"),
cfile_with_headers (d.."l_outdef.c"),
cfile_with_headers (d.."l_states.c"),
cfile_with_headers (d.."label.c"),
cfile_with_headers (d.."main.c"),
cfile_with_headers (d.."options.c"),
cfile_with_headers (d.."replace.c"),
cfile_with_headers (d.."scan.c"),
cfile_with_headers (d.."skip.c"),
cfile_with_headers (d.."stack.c"),
cfile_with_headers (d.."struct.c"),
cfile_with_headers (d.."switch.c"),
cfile_with_headers (d.."tokenname.c"),
cfile_with_headers (d.."type.c"),
cfile_with_headers (d.."util.c"),
cfile_with_headers (d.."stab.c"),
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
cfile_with_headers {
simple {
outputs = {"%U%-symbol2str.c"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokcase"),
file (d.."tokenname.c")
}
},
cfile_with_headers {
CINCLUDES = {PARENT, d},
tabgen (d.."char.tab")
},
cfile_with_headers {
simple {
outputs = {"%U%-next.c"},
command = {
"%in% > %out%"
},
file (d.."make.next"),
file (d.."code.str"),
file (d.."declar.str"),
file (d.."decspecs.str"),
file (d.."def.str"),
file (d.."expr.str"),
file (d.."field.str"),
file (d.."estack.str"),
file (d.."util.str"),
file (d.."idf.str"),
file (d.."macro.str"),
file (d.."stack.str"),
file (d.."stmt.str"),
file (d.."struct.str"),
file (d.."switch.str"),
file (d.."type.str"),
file (d.."l_brace.str"),
file (d.."l_state.str"),
file (d.."l_outdef.str"),
}
},
lib_em_mes,
lib_emk,
lib_em_data,
lib_input,
lib_assert,
lib_alloc,
lib_flt_arith,
lib_print,
lib_system,
lib_string,
outputs = {"%U%/em_cemcom"},
install = {
pm.install( BINDIR..PLATDEP.."/em_cemcom"),
pm.install(d.."cemcom.1", BINDIR.."/man/man1/cemcom.1"),
}
}

132
lang/cem/cpp.ansi/pmfile
View file

@ -1,132 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/cpp.ansi/"
local extract_parameters = simple {
outputs = {
"%U%/pathlength.h",
"%U%/errout.h",
"%U%/idfsize.h",
"%U%/numsize.h",
"%U%/nparams.h",
"%U%/ifdepth.h",
"%U%/macbuf.h",
"%U%/strsize.h",
"%U%/botch_free.h",
"%U%/debug.h",
"%U%/parbufsize.h",
"%U%/textsize.h",
"%U%/inputtype.h",
"%U%/obufsize.h",
"%U%/dobits.h",
"%U%/ln_prefix.h",
},
command = {
"cd %out[1]:dirname% && %in[1]% %in[2]%"
},
file (d.."make.hfiles"),
file (d.."Parameters")
}
local lpars = LLgen {
simple {
outputs = {"%U%/tokenfile.g"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokfile"),
file (d.."tokenname.c")
},
file (d.."expression.g"),
}
local allocd_header = simple {
class = "allocd_header",
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.allocd")
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
extract_parameters,
allocd_header { outputs = {"%U%/replace.h"}, (d.."replace.str") },
allocd_header { outputs = {"%U%/macro.h"}, (d.."macro.str") },
lpars
}
}
tool_cpp_ansi = cprogram {
cfile_with_headers (d.."LLlex.c"),
cfile_with_headers (d.."LLmessage.c"),
cfile_with_headers (d.."ch3bin.c"),
cfile_with_headers (d.."ch3mon.c"),
cfile_with_headers (d.."domacro.c"),
cfile_with_headers (d.."error.c"),
cfile_with_headers (d.."idf.c"),
cfile_with_headers (d.."init.c"),
cfile_with_headers (d.."input.c"),
cfile_with_headers (d.."main.c"),
cfile_with_headers (d.."options.c"),
cfile_with_headers (d.."preprocess.c"),
cfile_with_headers (d.."replace.c"),
cfile_with_headers (d.."skip.c"),
cfile_with_headers (d.."tokenname.c"),
cfile_with_headers (d.."expr.c"),
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
cfile_with_headers {
simple {
outputs = {"%U%-symbol2str.c"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokcase"),
file (d.."tokenname.c")
}
},
cfile_with_headers {
CINCLUDES = {PARENT, d},
tabgen (d.."char.tab")
},
cfile_with_headers {
simple {
outputs = {"%U%-next.c"},
command = {
"%in% > %out%"
},
file (d.."make.next"),
file (d.."macro.str"),
file (d.."replace.str"),
}
},
lib_input,
lib_assert,
lib_alloc,
lib_print,
lib_system,
lib_string,
outputs = {"%U%/cpp.ansi"},
install = {
pm.install( BINDIR..PLATDEP.."/cpp.ansi"),
pm.install(d.."ncpp.6", BINDIR.."/man/man6/cpp.ansi.6"),
}
}

300
lang/cem/libcc.ansi/pmfile
View file

@ -1,300 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/libcc.ansi/"
local crt = ackfile {
ACKINCLUDES = {PARENT, "%ROOTDIR%h"},
file (d.."head_ac.e"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/c-ansi.o")
}
local libc = acklibrary {
ACKBUILDFLAGS = {PARENT, "-ansi"},
ACKINCLUDES = {PARENT, "%ROOTDIR%h", d.."headers"},
outputs = {"%U%/libc.a"},
-- assert
ackfile (d.."assert/assert.c"),
-- ctype
ackfile (d.."ctype/tolower.c"),
ackfile (d.."ctype/toupper.c"),
ackfile {
tabgen (d.."ctype/char.tab")
},
foreach {
rule = ackfile,
simple {
outputs = {
"%U%/isalnum.c",
"%U%/isalpha.c",
"%U%/iscntrl.c",
"%U%/isdigit.c",
"%U%/isgraph.c",
"%U%/islower.c",
"%U%/isprint.c",
"%U%/ispunct.c",
"%U%/isspace.c",
"%U%/isupper.c",
"%U%/isxdigit.c",
"%U%/isascii.c",
},
command = {
"cd %out[1]:dirname% && sh %in[1]%"
},
file (d.."ctype/genfiles")
}
},
-- errno
ackfile (d.."errno/errlist.c"),
-- locale
ackfile (d.."locale/localeconv.c"),
ackfile (d.."locale/setlocale.c"),
-- math
ackfile (d.."math/asin.c"),
ackfile (d.."math/atan2.c"),
ackfile (d.."math/atan.c"),
ackfile (d.."math/ceil.c"),
ackfile (d.."math/fabs.c"),
ackfile (d.."math/pow.c"),
ackfile (d.."math/log10.c"),
ackfile (d.."math/log.c"),
ackfile (d.."math/sin.c"),
ackfile (d.."math/sinh.c"),
ackfile (d.."math/sqrt.c"),
ackfile (d.."math/tan.c"),
ackfile (d.."math/tanh.c"),
ackfile (d.."math/exp.c"),
ackfile (d.."math/ldexp.c"),
ackfile (d.."math/fmod.c"),
ackfile (d.."math/floor.c"),
ackfile (d.."math/hugeval.c"),
ackfile (d.."math/frexp.e"),
ackfile (d.."math/modf.e"),
ackfile (d.."math/isnan.c"),
-- misc
ackfile (d.."misc/environ.c"),
--[[
ackfile (d.."misc/getgrent.c"),
ackfile (d.."misc/getopt.c"),
ackfile (d.."misc/getpass.c"),
ackfile (d.."misc/getpw.c"),
ackfile (d.."misc/getw.c"),
ackfile (d.."misc/putw.c"),
ackfile (d.."misc/putenv.c"),
ackfile (d.."misc/environ.c"),
ackfile (d.."misc/popen.c"),
ackfile (d.."misc/sleep.c"),
ackfile (d.."misc/termcap.c"),
ackfile (d.."misc/fdopen.c"),
ackfile (d.."misc/closedir.c"),
group {
ACKDEFINES = {PARENT, "UFS"},
ackfile (d.."misc/getdents.c")
},
ackfile (d.."misc/opendir.c"),
ackfile (d.."misc/readdir.c"),
ackfile (d.."misc/rewinddir.c"),
ackfile (d.."misc/seekdir.c"),
ackfile (d.."misc/telldir.c"),
ackfile (d.."misc/isatty.c"),
ackfile (d.."misc/mktemp.c"),
ackfile (d.."misc/hypot.c"),
--]]
-- setjmp
ackfile (d.."setjmp/setjmp.e"),
--ackfile (d.."setjmp/sigmisc.c"),
-- signal
ackfile (d.."signal/raise.c"),
-- stdio
ackfile (d.."stdio/tmpfile.c"),
ackfile (d.."stdio/tmpnam.c"),
-- ackfile (d.."stdio/rename.c"),
-- ackfile (d.."stdio/remove.c"),
ackfile (d.."stdio/fopen.c"),
ackfile (d.."stdio/freopen.c"),
ackfile (d.."stdio/setbuf.c"),
ackfile (d.."stdio/setvbuf.c"),
ackfile (d.."stdio/perror.c"),
ackfile (d.."stdio/fprintf.c"),
ackfile (d.."stdio/printf.c"),
ackfile (d.."stdio/sprintf.c"),
ackfile (d.."stdio/vfprintf.c"),
ackfile (d.."stdio/vprintf.c"),
ackfile (d.."stdio/vsprintf.c"),
ackfile (d.."stdio/doprnt.c"),
ackfile (d.."stdio/icompute.c"),
ackfile (d.."stdio/fscanf.c"),
ackfile (d.."stdio/scanf.c"),
ackfile (d.."stdio/sscanf.c"),
ackfile (d.."stdio/doscan.c"),
ackfile (d.."stdio/fgetc.c"),
ackfile (d.."stdio/fgets.c"),
ackfile (d.."stdio/getc.c"),
ackfile (d.."stdio/getchar.c"),
ackfile (d.."stdio/gets.c"),
ackfile (d.."stdio/putc.c"),
ackfile (d.."stdio/putchar.c"),
ackfile (d.."stdio/fputc.c"),
ackfile (d.."stdio/puts.c"),
ackfile (d.."stdio/fputs.c"),
ackfile (d.."stdio/ungetc.c"),
ackfile (d.."stdio/fread.c"),
ackfile (d.."stdio/fwrite.c"),
ackfile (d.."stdio/fgetpos.c"),
ackfile (d.."stdio/fsetpos.c"),
ackfile (d.."stdio/rewind.c"),
ackfile (d.."stdio/fseek.c"),
ackfile (d.."stdio/ftell.c"),
ackfile (d.."stdio/clearerr.c"),
ackfile (d.."stdio/feof.c"),
ackfile (d.."stdio/ferror.c"),
ackfile (d.."stdio/fileno.c"),
ackfile (d.."stdio/fltpr.c"),
ackfile (d.."stdio/ecvt.c"),
ackfile (d.."stdio/fillbuf.c"),
ackfile (d.."stdio/fclose.c"),
ackfile (d.."stdio/flushbuf.c"),
ackfile (d.."stdio/fflush.c"),
-- ackfile (d.."stdio/isatty.c"),
ackfile (d.."stdio/data.c"),
-- stdlib
ackfile (d.."stdlib/abort.c"),
ackfile (d.."stdlib/abs.c"),
ackfile (d.."stdlib/atof.c"),
ackfile (d.."stdlib/atoi.c"),
ackfile (d.."stdlib/atol.c"),
ackfile (d.."stdlib/bsearch.c"),
ackfile (d.."stdlib/div.c"),
ackfile (d.."stdlib/atexit.c"),
ackfile (d.."stdlib/exit.c"),
ackfile (d.."stdlib/getenv.c"),
ackfile (d.."stdlib/labs.c"),
ackfile (d.."stdlib/ldiv.c"),
ackfile (d.."stdlib/mblen.c"),
ackfile (d.."stdlib/mbstowcs.c"),
ackfile (d.."stdlib/mbtowc.c"),
ackfile (d.."stdlib/qsort.c"),
ackfile (d.."stdlib/rand.c"),
ackfile (d.."stdlib/strtod.c"),
ackfile (d.."stdlib/strtol.c"),
-- ackfile (d.."stdlib/system.c"),
ackfile (d.."stdlib/wcstombs.c"),
ackfile (d.."stdlib/wctomb.c"),
ackfile (d.."stdlib/ext_comp.c"),
ackfile {
simple {
outputs = {"%U%/malloc.c"},
command = {
"rm -f %out% && for i in %in[2-]%; do %in[1]% $i >> %out%; done"
},
file (d.."stdlib/malloc/add_file"),
file (d.."stdlib/malloc/READ_ME"),
file (d.."stdlib/malloc/size_type.h"),
file (d.."stdlib/malloc/param.h"),
file (d.."stdlib/malloc/impl.h"),
file (d.."stdlib/malloc/check.h"),
file (d.."stdlib/malloc/log.h"),
file (d.."stdlib/malloc/phys.h"),
file (d.."stdlib/malloc/mal.c"),
file (d.."stdlib/malloc/log.c"),
file (d.."stdlib/malloc/phys.c"),
file (d.."stdlib/malloc/check.c"),
}
},
-- string
ackfile (d.."string/memchr.c"),
ackfile (d.."string/memcmp.c"),
ackfile (d.."string/memcpy.c"),
ackfile (d.."string/memmove.c"),
ackfile (d.."string/memset.c"),
ackfile (d.."string/strcat.c"),
ackfile (d.."string/strchr.c"),
ackfile (d.."string/strcmp.c"),
ackfile (d.."string/strcoll.c"),
ackfile (d.."string/strcpy.c"),
ackfile (d.."string/strcspn.c"),
ackfile (d.."string/strerror.c"),
ackfile (d.."string/strncat.c"),
ackfile (d.."string/strncpy.c"),
ackfile (d.."string/strrchr.c"),
ackfile (d.."string/strstr.c"),
ackfile (d.."string/strlen.c"),
ackfile (d.."string/strtok.c"),
ackfile (d.."string/strpbrk.c"),
ackfile (d.."string/strspn.c"),
ackfile (d.."string/strncmp.c"),
ackfile (d.."string/strxfrm.c"),
-- time
ackfile (d.."time/ctime.c"),
ackfile (d.."time/asctime.c"),
ackfile (d.."time/localtime.c"),
ackfile (d.."time/clock.c"),
ackfile (d.."time/difftime.c"),
ackfile (d.."time/gmtime.c"),
ackfile (d.."time/mktime.c"),
ackfile (d.."time/strftime.c"),
ackfile (d.."time/time.c"),
ackfile (d.."time/tzset.c"),
ackfile (d.."time/misc.c"),
install = {
pm.install("%BINDIR%%PLATIND%/%PLATFORM%/libc.a")
}
}
local headers = group {
install = {
pm.install(d.."headers/sys/time.h", "%BINDIR%include/ansi/sys/time.h"),
pm.install(d.."headers/sys/ioctl.h", "%BINDIR%include/ansi/sys/ioctl.h"),
pm.install(d.."headers/assert.h", "%BINDIR%include/ansi/assert.h"),
pm.install(d.."headers/ctype.h", "%BINDIR%include/ansi/ctype.h"),
pm.install(d.."headers/errno.h", "%BINDIR%include/ansi/errno.h"),
pm.install(d.."headers/float.h", "%BINDIR%include/ansi/float.h"),
pm.install(d.."headers/limits.h", "%BINDIR%include/ansi/limits.h"),
pm.install(d.."headers/math.h", "%BINDIR%include/ansi/math.h"),
pm.install(d.."headers/setjmp.h", "%BINDIR%include/ansi/setjmp.h"),
pm.install(d.."headers/signal.h", "%BINDIR%include/ansi/signal.h"),
pm.install(d.."headers/stdarg.h", "%BINDIR%include/ansi/stdarg.h"),
pm.install(d.."headers/stddef.h", "%BINDIR%include/ansi/stddef.h"),
pm.install(d.."headers/stdint.h", "%BINDIR%include/ansi/stdint.h"),
pm.install(d.."headers/stdio.h", "%BINDIR%include/ansi/stdio.h"),
pm.install(d.."headers/stdlib.h", "%BINDIR%include/ansi/stdlib.h"),
pm.install(d.."headers/string.h", "%BINDIR%include/ansi/string.h"),
pm.install(d.."headers/time.h", "%BINDIR%include/ansi/time.h"),
pm.install(d.."headers/iso646.h", "%BINDIR%include/ansi/iso646.h"),
pm.install(d.."headers/stdbool.h", "%BINDIR%include/ansi/stdbool.h"),
pm.install(d.."headers/locale.h", "%BINDIR%include/ansi/locale.h"),
pm.install(d.."headers/tgmath.h", "%BINDIR%include/ansi/tgmath.h"),
}
}
lang_cem_ansi_runtime = group {
crt,
libc,
headers
}

94
lang/cem/libcc/gen/pmfile
View file

@ -1,94 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/libcc/gen/"
local head = acklibrary {
ackfile (d.."head_cc.e"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/c-knr.o")
}
local tail = acklibrary {
ackfile (d.."abs.c"),
ackfile (d.."atof.c"),
ackfile (d.."strtod.c"),
ackfile (d.."atoi.c"),
ackfile (d.."atol.c"),
ackfile (d.."strtol.c"),
ackfile (d.."bcmp.c"),
ackfile (d.."bfill.c"),
ackfile (d.."bmove.c"),
ackfile (d.."bzero.c"),
ackfile (d.."calloc.c"),
ackfile (d.."crypt.c"),
ackfile (d.."ctime.c"),
ackfile (d.."asctime.c"),
ackfile (d.."execvp.c"),
ackfile (d.."ffc.c"),
ackfile (d.."ffs.c"),
ackfile (d.."gcvt.c"),
ackfile (d.."ecvt.c"),
ackfile (d.."ext_comp.c"),
ackfile (d.."getlogin.c"),
ackfile (d.."index.c"),
ackfile (d.."l3.c"),
ackfile (d.."ldexp.c"),
ackfile (d.."localtime.c"),
ackfile (d.."gmtime.c"),
ackfile (d.."memccpy.c"),
ackfile (d.."memchr.c"),
ackfile (d.."memcmp.c"),
ackfile (d.."memcpy.c"),
ackfile (d.."memset.c"),
ackfile (d.."mktemp.c"),
ackfile (d.."monitor.c"),
ackfile (d.."perror.c"),
ackfile (d.."procentry.c"),
ackfile (d.."qsort.c"),
ackfile (d.."bsearch.c"),
ackfile (d.."rand.c"),
ackfile (d.."seekdir.c"),
ackfile (d.."sleep.c"),
ackfile (d.."stb.c"),
ackfile (d.."strstr.c"),
ackfile (d.."strchr.c"),
ackfile (d.."strcmp.c"),
ackfile (d.."strcspn.c"),
ackfile (d.."strncat.c"),
ackfile (d.."strrchr.c"),
ackfile (d.."strtok.c"),
ackfile (d.."strpbrk.c"),
ackfile (d.."strspn.c"),
ackfile (d.."swab.c"),
ackfile (d.."telldir.c"),
ackfile (d.."ttyslot.c"),
ackfile (d.."rindex.c"),
ackfile (d.."strncmp.c"),
ackfile (d.."ttyname.c"),
ackfile (d.."closedir.c"),
ackfile (d.."isatty.c"),
ackfile (d.."opendir.c"),
ackfile (d.."malloc.c"),
ackfile (d.."bcopy.c"),
ackfile (d.."readdir.c"),
ackfile (d.."strcat.c"),
ackfile (d.."strcpy.c"),
ackfile (d.."strlen.c"),
ackfile (d.."tzset.c"),
ackfile (d.."getenv.c"),
ackfile (d.."strncpy.c"),
ackfile (d.."_c2type.c"),
ackfile (d.."abort.e"),
ackfile (d.."frexp.e"),
ackfile (d.."modf.e"),
ackfile (d.."setjmp.e"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/libc-knr.a")
}
lang_cem_gen_runtime = group {
ACKINCLUDES = {PARENT, "%ROOTDIR%h"},
head,
tail
}

31
lang/cem/libcc/math/pmfile
View file

@ -1,31 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/libcc/math/"
lang_cem_math_runtime = acklibrary {
ACKINCLUDES = {PARENT, "%ROOTDIR%h"},
ackfile (d.."asin.c"),
ackfile (d.."atan2.c"),
ackfile (d.."atan.c"),
ackfile (d.."ceil.c"),
ackfile (d.."fabs.c"),
ackfile (d.."gamma.c"),
ackfile (d.."hypot.c"),
ackfile (d.."jn.c"),
ackfile (d.."j0.c"),
ackfile (d.."j1.c"),
ackfile (d.."log10.c"),
ackfile (d.."pow.c"),
ackfile (d.."log.c"),
ackfile (d.."sin.c"),
ackfile (d.."sinh.c"),
ackfile (d.."sqrt.c"),
ackfile (d.."tan.c"),
ackfile (d.."tanh.c"),
ackfile (d.."exp.c"),
ackfile (d.."floor.c"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/libm-knr.a")
}

101
lang/cem/libcc/mon/pmfile
View file

@ -1,101 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/libcc/mon/"
lang_cem_mon_runtime = acklibrary {
ACKINCLUDES = {PARENT, "%ROOTDIR%h", "%ROOTDIR%include/_tail_mon"},
ackfile (d.."exit.c"),
ackfile (d.."gtty.c"),
ackfile (d.."signal.c"),
ackfile (d.."stty.c"),
ackfile (d.."tell.c"),
ackfile (d.."time.c"),
ackfile (d.."cleanup.c"),
ackfile (d.."access.e"),
ackfile (d.."acct.e"),
ackfile (d.."alarm.e"),
ackfile (d.."brk.e"),
ackfile (d.."chdir.e"),
ackfile (d.."chmod.e"),
ackfile (d.."chown.e"),
ackfile (d.."chroot.e"),
ackfile (d.."close.e"),
ackfile (d.."creat.e"),
ackfile (d.."dup.e"),
ackfile (d.."dup2.e"),
ackfile (d.."execl.e"),
ackfile (d.."execle.e"),
ackfile (d.."execv.e"),
ackfile (d.."execve.e"),
ackfile (d.."fork.e"),
ackfile (d.."fstat.e"),
ackfile (d.."ftime.e"),
ackfile (d.."getegid.e"),
ackfile (d.."geteuid.e"),
ackfile (d.."getgid.e"),
ackfile (d.."getpid.e"),
ackfile (d.."getuid.e"),
ackfile (d.."ioctl.e"),
ackfile (d.."kill.e"),
ackfile (d.."link.e"),
ackfile (d.."lock.e"),
ackfile (d.."lseek.e"),
ackfile (d.."mknod.e"),
ackfile (d.."mount.e"),
ackfile (d.."mpxcall.e"),
ackfile (d.."nice.e"),
ackfile (d.."open.e"),
ackfile (d.."pause.e"),
ackfile (d.."pipe.e"),
ackfile (d.."prof.e"),
ackfile (d.."ptrace.e"),
ackfile (d.."read.e"),
ackfile (d.."sbrk.e"),
ackfile (d.."setgid.e"),
ackfile (d.."setuid.e"),
ackfile (d.."setsig.e"),
ackfile (d.."sigtrp.e"),
ackfile (d.."stat.e"),
ackfile (d.."stime.e"),
ackfile (d.."sync.e"),
ackfile (d.."times.e"),
ackfile (d.."umask.e"),
ackfile (d.."umount.e"),
ackfile (d.."unlink.e"),
ackfile (d.."utime.e"),
ackfile (d.."wait.e"),
ackfile (d.."write.e"),
ackfile (d.."errno.e"),
ackfile (d.."_alarm.e"),
ackfile (d.."_brk.e"),
ackfile (d.."_close.e"),
ackfile (d.."_creat.e"),
ackfile (d.."_dup.e"),
ackfile (d.."_dup2.e"),
ackfile (d.."_execl.e"),
ackfile (d.."_execve.e"),
ackfile (d.."_exit.e"),
ackfile (d.."_fork.e"),
ackfile (d.."_fstat.e"),
ackfile (d.."_ftime.e"),
ackfile (d.."_getpid.e"),
ackfile (d.."_gtty.c"),
ackfile (d.."_stty.c"),
ackfile (d.."_ioctl.e"),
ackfile (d.."_kill.e"),
ackfile (d.."_link.e"),
ackfile (d.."_lseek.e"),
ackfile (d.."_open.e"),
ackfile (d.."_pause.e"),
ackfile (d.."_pipe.e"),
ackfile (d.."_read.e"),
ackfile (d.."_sbrk.e"),
ackfile (d.."_times.e"),
ackfile (d.."_unlink.e"),
ackfile (d.."_wait.e"),
ackfile (d.."_write.e"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/libmon.a")
}

41
lang/cem/libcc/pmfile
View file

@ -1,41 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/libcc/"
include (d.."gen/pmfile")
include (d.."math/pmfile")
include (d.."mon/pmfile")
include (d.."stdio/pmfile")
local headers = group {
install = {
pm.install(d.."headers/assert.h", "%BINDIR%include/knr/assert.h"),
pm.install(d.."headers/ctype.h", "%BINDIR%include/knr/ctype.h"),
pm.install(d.."headers/errno.h", "%BINDIR%include/knr/errno.h"),
pm.install(d.."headers/fcntl.h", "%BINDIR%include/knr/fcntl.h"),
pm.install(d.."headers/grp.h", "%BINDIR%include/knr/grp.h"),
pm.install(d.."headers/math.h", "%BINDIR%include/knr/math.h"),
pm.install(d.."headers/pwd.h", "%BINDIR%include/knr/pwd.h"),
pm.install(d.."headers/setjmp.h", "%BINDIR%include/knr/setjmp.h"),
pm.install(d.."headers/sgtty.h", "%BINDIR%include/knr/sgtty.h"),
pm.install(d.."headers/signal.h", "%BINDIR%include/knr/signal.h"),
pm.install(d.."headers/stdio.h", "%BINDIR%include/knr/stdio.h"),
pm.install(d.."headers/time.h", "%BINDIR%include/knr/time.h"),
pm.install(d.."headers/varargs.h", "%BINDIR%include/knr/varargs.h"),
pm.install(d.."headers/sys/dir.h", "%BINDIR%include/knr/sys/dir.h"),
pm.install(d.."headers/sys/errno.h", "%BINDIR%include/knr/sys/errno.h"),
pm.install(d.."headers/sys/stat.h", "%BINDIR%include/knr/sys/stat.h"),
pm.install(d.."headers/sys/stdtypes.h", "%BINDIR%include/knr/sys/stdtypes.h"),
pm.install(d.."headers/sys/types.h", "%BINDIR%include/knr/sys/types.h"),
pm.install(d.."headers/sys/timeb.h", "%BINDIR%include/knr/sys/timeb.h"),
}
}
lang_cem_runtime = group {
headers,
lang_cem_gen_runtime,
lang_cem_math_runtime,
lang_cem_mon_runtime,
lang_cem_stdio_runtime
}

58
lang/cem/libcc/stdio/pmfile
View file

@ -1,58 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/libcc/stdio/"
lang_cem_stdio_runtime = acklibrary {
ACKINCLUDES = {PARENT, "%ROOTDIR%h"},
ackfile (d.."vsprintf.c"),
ackfile (d.."vfprintf.c"),
ackfile (d.."vprintf.c"),
ackfile (d.."termcap.c"),
ackfile (d.."getopt.c"),
ackfile (d.."clearerr.c"),
ackfile (d.."fgetc.c"),
ackfile (d.."fgets.c"),
ackfile (d.."fprintf.c"),
ackfile (d.."fputc.c"),
ackfile (d.."fputs.c"),
ackfile (d.."fread.c"),
ackfile (d.."freopen.c"),
ackfile (d.."fscanf.c"),
ackfile (d.."ftell.c"),
ackfile (d.."fwrite.c"),
ackfile (d.."getchar.c"),
ackfile (d.."getgrent.c"),
ackfile (d.."getpass.c"),
ackfile (d.."getpw.c"),
ackfile (d.."fopen.c"),
ackfile (d.."getpwent.c"),
ackfile (d.."gets.c"),
ackfile (d.."getw.c"),
ackfile (d.."popen.c"),
ackfile (d.."fdopen.c"),
ackfile (d.."printf.c"),
ackfile (d.."putchar.c"),
ackfile (d.."puts.c"),
ackfile (d.."putw.c"),
ackfile (d.."rewind.c"),
ackfile (d.."fseek.c"),
ackfile (d.."scanf.c"),
ackfile (d.."setbuf.c"),
ackfile (d.."sprintf.c"),
ackfile (d.."doprnt.c"),
ackfile (d.."fltpr.c"),
ackfile (d.."flushbuf.c"),
ackfile (d.."fclose.c"),
ackfile (d.."data.c"),
ackfile (d.."fflush.c"),
ackfile (d.."sscanf.c"),
ackfile (d.."doscan.c"),
ackfile (d.."fillbuf.c"),
ackfile (d.."system.c"),
ackfile (d.."timezone.c"),
ackfile (d.."ungetc.c"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/libc-stdio-knr.a")
}

9
lang/cem/pmfile
View file

@ -1,9 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/cem/"
-- include (d.."cemcom/pmfile")
include (d.."cemcom.ansi/pmfile")
-- include (d.."libcc/pmfile")
include (d.."libcc.ansi/pmfile")

177
lang/m2/comp/pmfile
View file

@ -1,177 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/m2/comp/"
local extract_parameters = simple {
outputs = {
"%U%/errout.h",
"%U%/idfsize.h",
"%U%/numsize.h",
"%U%/strsize.h",
"%U%/target_sizes.h",
"%U%/debugcst.h",
"%U%/inputtype.h",
"%U%/density.h",
"%U%/squeeze.h",
"%U%/strict3rd.h",
"%U%/nocross.h",
"%U%/nostrict.h",
"%U%/bigresult.h",
"%U%/dbsymtab.h",
"%U%/use_insert.h",
"%U%/uns_arith.h",
},
command = {
"cd %out[1]:dirname% && %in[1]% %in[2]%"
},
file (d.."make.hfiles"),
file (d.."BigPars")
}
local lpars = LLgen {
simple {
outputs = {"%U%/tokenfile.g"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokfile"),
file (d.."tokenname.c")
},
file (d.."program.g"),
file (d.."declar.g"),
file (d.."expression.g"),
file (d.."statement.g"),
}
local allocd_header = simple {
class = "allocd_header",
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.allocd")
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
extract_parameters,
allocd_header { outputs = {"%U%/def.h"}, (d.."def.H") },
allocd_header { outputs = {"%U%/type.h"}, (d.."type.H") },
allocd_header { outputs = {"%U%/real.h"}, (d.."real.H") },
allocd_header { outputs = {"%U%/node.h"}, (d.."node.H") },
lpars
}
}
lang_m2_compiler = cprogram {
CDEFINES = {PARENT, "STATIC=static"},
cfile_with_headers (d.."LLlex.c"),
cfile_with_headers (d.."LLmessage.c"),
cfile_with_headers (d.."error.c"),
cfile_with_headers (d.."main.c"),
cfile_with_headers (d.."tokenname.c"),
cfile_with_headers (d.."idf.c"),
cfile_with_headers (d.."input.c"),
cfile_with_headers (d.."type.c"),
cfile_with_headers (d.."def.c"),
cfile_with_headers (d.."misc.c"),
cfile_with_headers (d.."enter.c"),
cfile_with_headers (d.."defmodule.c"),
cfile_with_headers (d.."typequiv.c"),
cfile_with_headers (d.."node.c"),
cfile_with_headers (d.."cstoper.c"),
cfile_with_headers (d.."chk_expr.c"),
cfile_with_headers (d.."options.c"),
cfile_with_headers (d.."walk.c"),
cfile_with_headers (d.."desig.c"),
cfile_with_headers (d.."code.c"),
cfile_with_headers (d.."lookup.c"),
cfile_with_headers (d.."stab.c"),
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
cfile_with_headers {
simple {
outputs = {"%U%-symbol2str.c"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokcase"),
file (d.."tokenname.c")
}
},
cfile_with_headers {
CINCLUDES = {PARENT, d},
tabgen (d.."char.tab")
},
cfile_with_headers {
simple {
outputs = {"%U%-next.c"},
command = {
"%in% > %out%"
},
file (d.."make.next"),
file (d.."def.H"),
file (d.."type.H"),
file (d.."real.H"),
file (d.."node.H"),
file (d.."scope.C"),
file (d.."tmpvar.C"),
file (d.."casestat.C"),
}
},
cfile_with_headers {
allocd_header { outputs = {"%U%-scope.c"}, (d.."scope.C") }
},
cfile_with_headers {
allocd_header { outputs = {"%U%-tmpvar.c"}, (d.."tmpvar.C") }
},
cfile_with_headers {
allocd_header { outputs = {"%U%-casestat.c"}, (d.."casestat.C") }
},
lib_em_mes,
lib_emk,
lib_em_data,
lib_input,
lib_assert,
lib_alloc,
lib_flt_arith,
lib_print,
lib_string,
lib_system,
outputs = {"%U%/em_m2"},
install = {
pm.install( "%BINDIR%%PLATDEP%/em_m2"),
pm.install(d.."em_m2.6", "%BINDIR%/man/man6/em_m2.6"),
}
}
-- Revision history
-- $Log$
-- Revision 1.3 2006-10-15 00:28:11 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.2 2006/07/26 18:19:15 dtrg
-- Tweaked the CVS settings.
--
-- Revision 1.1 2006/07/26 17:12:19 dtrg
-- Added support for the Modula-2 compiler.

99
lang/m2/libm2/pmfile
View file

@ -1,99 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/m2/libm2/"
local headers = group {
install = {
pm.install(d.."Arguments.def", "%BINDIR%include/m2/Arguments.def"),
pm.install(d.."ArraySort.def", "%BINDIR%include/m2/ArraySort.def"),
pm.install(d.."ASCII.def", "%BINDIR%include/m2/ASCII.def"),
pm.install(d.."Conversion.def", "%BINDIR%include/m2/Conversion.def"),
pm.install(d.."CSP.def", "%BINDIR%include/m2/CSP.def"),
pm.install(d.."EM.def", "%BINDIR%include/m2/EM.def"),
pm.install(d.."Epilogue.def", "%BINDIR%include/m2/Epilogue.def"),
pm.install(d.."InOut.def", "%BINDIR%include/m2/InOut.def"),
pm.install(d.."MathLib0.def", "%BINDIR%include/m2/MathLib0.def"),
pm.install(d.."Mathlib.def", "%BINDIR%include/m2/Mathlib.def"),
pm.install(d.."PascalIO.def", "%BINDIR%include/m2/PascalIO.def"),
pm.install(d.."Processes.def", "%BINDIR%include/m2/Processes.def"),
pm.install(d.."random.def", "%BINDIR%include/m2/random.def"),
pm.install(d.."RealConver.def", "%BINDIR%include/m2/RealConver.def"),
pm.install(d.."RealInOut.def", "%BINDIR%include/m2/RealInOut.def"),
pm.install(d.."Semaphores.def", "%BINDIR%include/m2/Semaphores.def"),
pm.install(d.."Storage.def", "%BINDIR%include/m2/Storage.def"),
pm.install(d.."Streams.def", "%BINDIR%include/m2/Streams.def"),
pm.install(d.."Strings.def", "%BINDIR%include/m2/Strings.def"),
pm.install(d.."StripUnix.def", "%BINDIR%include/m2/StripUnix.def"),
pm.install(d.."Termcap.def", "%BINDIR%include/m2/Termcap.def"),
-- pm.install(d.."Terminal.def", "%BINDIR%include/m2/Terminal.def"),
pm.install(d.."Traps.def", "%BINDIR%include/m2/Traps.def"),
pm.install(d.."Unix.def", "%BINDIR%include/m2/Unix.def"),
pm.install(d.."XXTermcap.def", "%BINDIR%include/m2/XXTermcap.def"),
}
}
local head = ackfile {
file (d.."head_m2.e"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/modula2.o")
}
local tail = acklibrary {
ackfile (d.."Termcap.mod"),
ackfile (d.."CSP.mod"),
ackfile (d.."PascalIO.mod"),
ackfile (d.."RealInOut.mod"),
ackfile (d.."InOut.mod"),
ackfile (d.."Streams.mod"),
-- ackfile (d.."Terminal.mod"),
ackfile (d.."MathLib0.mod"),
ackfile (d.."Mathlib.mod"),
ackfile (d.."Processes.mod"),
ackfile (d.."RealConver.mod"),
ackfile (d.."Storage.mod"),
ackfile (d.."Conversion.mod"),
ackfile (d.."Semaphores.mod"),
ackfile (d.."random.mod"),
ackfile (d.."Strings.mod"),
ackfile (d.."ArraySort.mod"),
ackfile (d.."catch.c"),
ackfile (d.."Traps.mod"),
ackfile (d.."XXTermcap.c"),
ackfile (d.."dvi.c"),
ackfile (d.."Arguments.c"),
ackfile (d.."LtoUset.e"),
ackfile (d.."StrAss.c"),
ackfile (d.."cap.c"),
ackfile (d.."absd.c"),
ackfile (d.."absf.e"),
ackfile (d.."absi.c"),
ackfile (d.."absl.c"),
ackfile (d.."halt.c"),
ackfile (d.."SYSTEM.c"),
ackfile (d.."par_misc.e"),
ackfile (d.."init.c"),
ackfile (d.."sigtrp.c"),
ackfile (d.."store.c"),
ackfile (d.."confarray.c"),
ackfile (d.."load.c"),
ackfile (d.."blockmove.c"),
ackfile (d.."stackprio.c"),
ackfile (d.."ucheck.c"),
ackfile (d.."rcka.c"),
ackfile (d.."rcku.c"),
ackfile (d.."rcki.c"),
ackfile (d.."rckul.c"),
ackfile (d.."rckil.c"),
ackfile (d.."EM.e"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/libmodula2.a")
}
lang_m2_runtime = acklibrary {
ACKINCLUDES = {PARENT, "%ROOTDIR%h"},
headers,
head,
tail
}

7
lang/m2/pmfile
View file

@ -1,7 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/m2/"
include (d.."comp/pmfile")
include (d.."libm2/pmfile")

62
lang/occam/comp/pmfile
View file

@ -1,62 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/occam/comp/"
local lpars = LLgen {
file (d.."occam.g"),
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
lpars
}
}
lang_occam_compiler = cprogram {
CLIBRARIES = {PARENT, "fl"},
cfile_with_headers (d.."builtin.c"),
cfile_with_headers (d.."code.c"),
cfile_with_headers (d.."em.c"),
cfile_with_headers (d.."expr.c"),
cfile_with_headers (d.."keytab.c"),
cfile_with_headers (d.."report.c"),
cfile_with_headers (d.."symtab.c"),
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
cfile_with_headers {
flex (d.."lex.l")
},
lib_em_mes,
lib_emk,
lib_em_data,
-- lib_input,
-- lib_assert,
lib_alloc,
-- lib_flt_arith,
lib_print,
lib_string,
lib_system,
outputs = {"%U%/em_occam"},
install = {
pm.install("%BINDIR%%PLATDEP%/em_occam"),
}
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-10-15 00:28:12 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.1 2006/07/26 18:23:32 dtrg
-- Added support for the Occam compiler.
--

21
lang/occam/lib/pmfile
View file

@ -1,21 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/occam/lib/"
lang_occam_lib_runtime = acklibrary {
ACKINCLUDES = {PARENT, "%ROOTDIR%h"},
ackfile (d.."builtin.c"),
ackfile (d.."chan_strct.c"),
ackfile (d.."channel.c"),
ackfile (d.."co.c"),
ackfile (d.."misc.e"),
ackfile (d.."now.c"),
ackfile (d.."ocrt.c"),
ackfile (d.."par.c"),
ackfile (d.."par_misc.e"),
ackfile (d.."parco.c"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/liboccam.a")
}

20
lang/occam/pmfile
View file

@ -1,20 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/occam/"
include (d.."comp/pmfile")
include (d.."lib/pmfile")
local headers = group {
install = {
pm.install(d.."headers/dec.ocm", "%BINDIR%include/occam/dec.ocm"),
pm.install(d.."headers/printd.ocm", "%BINDIR%include/occam/printd.ocm"),
pm.install(d.."headers/prints.ocm", "%BINDIR%include/occam/prints.ocm"),
}
}
lang_occam_runtime = group {
headers,
lang_occam_lib_runtime
}

169
lang/pc/comp/pmfile
View file

@ -1,169 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/pc/comp/"
local extract_parameters = simple {
outputs = {
"%U%/debugcst.h",
"%U%/density.h",
"%U%/errout.h",
"%U%/idfsize.h",
"%U%/inputtype.h",
"%U%/numsize.h",
"%U%/strsize.h",
"%U%/target_sizes.h",
"%U%/nocross.h",
"%U%/dbsymtab.h",
},
command = {
"cd %out[1]:dirname% && %in[1]% %in[2]%"
},
file (d.."make.hfiles"),
file (d.."Parameters")
}
local lpars = LLgen {
simple {
outputs = {"%U%/tokenfile.g"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokfile"),
file (d.."tokenname.c")
},
file (d.."program.g"),
file (d.."declar.g"),
file (d.."expression.g"),
file (d.."statement.g"),
}
local allocd_header = simple {
class = "allocd_header",
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.allocd")
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
extract_parameters,
allocd_header { outputs = {"%U%/def.h"}, (d.."def.H") },
allocd_header { outputs = {"%U%/type.h"}, (d.."type.H") },
allocd_header { outputs = {"%U%/scope.h"}, (d.."scope.H") },
allocd_header { outputs = {"%U%/node.h"}, (d.."node.H") },
allocd_header { outputs = {"%U%/desig.h"}, (d.."desig.H") },
lpars
}
}
lang_pc_compiler = cprogram {
CDEFINES = {PARENT, "STATIC=static"},
cfile_with_headers (d.."LLlex.c"),
cfile_with_headers (d.."LLmessage.c"),
cfile_with_headers (d.."body.c"),
cfile_with_headers (d.."chk_expr.c"),
cfile_with_headers (d.."code.c"),
cfile_with_headers (d.."cstoper.c"),
cfile_with_headers (d.."def.c"),
cfile_with_headers (d.."desig.c"),
cfile_with_headers (d.."enter.c"),
cfile_with_headers (d.."error.c"),
cfile_with_headers (d.."idf.c"),
cfile_with_headers (d.."input.c"),
cfile_with_headers (d.."label.c"),
cfile_with_headers (d.."lookup.c"),
cfile_with_headers (d.."main.c"),
cfile_with_headers (d.."misc.c"),
cfile_with_headers (d.."node.c"),
cfile_with_headers (d.."options.c"),
cfile_with_headers (d.."progs.c"),
cfile_with_headers (d.."readwrite.c"),
cfile_with_headers (d.."scope.c"),
cfile_with_headers (d.."stab.c"),
cfile_with_headers (d.."tokenname.c"),
cfile_with_headers (d.."type.c"),
cfile_with_headers (d.."typequiv.c"),
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
cfile_with_headers {
simple {
outputs = {"%U%-symbol2str.c"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokcase"),
file (d.."tokenname.c")
}
},
cfile_with_headers {
CINCLUDES = {PARENT, d},
tabgen (d.."char.tab")
},
cfile_with_headers {
simple {
outputs = {"%U%-next.c"},
command = {
"%in% > %out%"
},
file (d.."make.next"),
file (d.."def.H"),
file (d.."type.H"),
file (d.."node.H"),
file (d.."scope.H"),
file (d.."desig.H"),
file (d.."tmpvar.C"),
file (d.."casestat.C"),
}
},
cfile_with_headers {
allocd_header { outputs = {"%U%-tmpvar.c"}, (d.."tmpvar.C") }
},
cfile_with_headers {
allocd_header { outputs = {"%U%-casestat.c"}, (d.."casestat.C") }
},
lib_em_mes,
lib_emk,
lib_em_data,
lib_input,
lib_assert,
lib_alloc,
lib_flt_arith,
lib_print,
lib_string,
lib_system,
outputs = {"%U%/em_pc"},
install = {
pm.install( "%BINDIR%%PLATDEP%/em_pc"),
pm.install(d.."em_pc.6", "%BINDIR%/man/man6/em_pc.6"),
}
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-10-15 00:28:11 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.1 2006/07/22 21:03:07 dtrg
-- Added support for the Pascal compiler.
--

95
lang/pc/libpc/pmfile
View file

@ -1,95 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/pc/libpc/"
head = ackfile {
file (d.."head_pc.e"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/pascal.o")
}
tail = acklibrary {
ackfile (d.."abi.c"),
ackfile (d.."abl.c"),
ackfile (d.."abr.c"),
ackfile (d.."arg.c"),
ackfile (d.."ass.c"),
ackfile (d.."asz.c"),
ackfile (d.."atn.c"),
ackfile (d.."bcp.c"),
ackfile (d.."bts.e"),
ackfile (d.."buff.c"),
ackfile (d.."clock.c"),
ackfile (d.."diag.c"),
ackfile (d.."dis.c"),
ackfile (d.."efl.c"),
ackfile (d.."eln.c"),
ackfile (d.."encaps.e"),
ackfile (d.."exp.c"),
ackfile (d.."get.c"),
ackfile (d.."gto.e"),
ackfile (d.."hlt.c"),
ackfile (d.."ini.c"),
ackfile (d.."catch.c"),
ackfile (d.."log.c"),
ackfile (d.."mdi.c"),
ackfile (d.."mdl.c"),
ackfile (d.."new.c"),
ackfile (d.."nobuff.c"),
ackfile (d.."notext.c"),
ackfile (d.."opn.c"),
ackfile (d.."hol0.e"),
ackfile (d.."pac.c"),
ackfile (d.."pclose.c"),
ackfile (d.."pcreat.c"),
ackfile (d.."pentry.c"),
ackfile (d.."perrno.c"),
ackfile (d.."pexit.c"),
ackfile (d.."popen.c"),
ackfile (d.."cls.c"),
ackfile (d.."put.c"),
ackfile (d.."rdc.c"),
ackfile (d.."rdl.c"),
ackfile (d.."rdr.c"),
ackfile (d.."rdi.c"),
ackfile (d.."rln.c"),
ackfile (d.."rf.c"),
ackfile (d.."rnd.c"),
ackfile (d.."sav.e"),
ackfile (d.."sig.e"),
ackfile (d.."sin.c"),
ackfile (d.."sqt.c"),
ackfile (d.."fef.e"),
ackfile (d.."string.c"),
ackfile (d.."trap.e"),
ackfile (d.."unp.c"),
ackfile (d.."uread.c"),
ackfile (d.."uwrite.c"),
ackfile (d.."wdw.c"),
ackfile (d.."incpt.c"),
ackfile (d.."wrc.c"),
ackfile (d.."wrf.c"),
ackfile (d.."wri.c"),
ackfile (d.."wrl.c"),
ackfile (d.."wrr.c"),
ackfile (d.."cvt.c"),
ackfile (d.."fif.e"),
ackfile (d.."wrz.c"),
ackfile (d.."wrs.c"),
ackfile (d.."outcpt.c"),
ackfile (d.."wf.c"),
ackfile (d.."nfa.c"),
ackfile (d.."rcka.c"),
ackfile (d.."trp.e"),
install = pm.install("%BINDIR%%PLATIND%/%PLATFORM%/libpascal.a")
}
lang_pc_runtime = group {
ACKINCLUDES = {PARENT, "%ROOTDIR%h"},
head,
tail
}

7
lang/pc/pmfile
View file

@ -1,7 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."lang/pc/"
include (d.."comp/pmfile")
include (d.."libpc/pmfile")

19
mach/6500/dl/pmfile
View file

@ -1,19 +0,0 @@
-- $Source$
-- $State$
local d = "mach/6500/dl/"
tool_6500_dl = cprogram {
cfile (d.."dl.c"),
lib_object,
outputs = {"%U%/dl"},
install = pm.install(BINDIR..PLATDEP.."/6500/dl")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

98
mach/6500/libem/pmfile
View file

@ -1,98 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/6500/libem/"
libem_6500 = acklibrary {
outputs = {"%U%/libem-%ARCH%.a"},
ackfile (d.."adi4.s"),
ackfile (d.."cmi.s"),
ackfile (d.."cmi4.s"),
ackfile (d.."sbi4.s"),
ackfile (d.."addsub.s"),
ackfile (d.."cmu4.s"),
ackfile (d.."dum_float.s"),
ackfile (d.."dvi4.s"),
ackfile (d.."dvu4.s"),
ackfile (d.."lar.s"),
ackfile (d.."lol.s"),
ackfile (d.."los.s"),
ackfile (d.."loil.s"),
ackfile (d.."loi1.s"),
ackfile (d.."loi.s"),
ackfile (d.."mli4.s"),
ackfile (d.."mlu.s"),
ackfile (d.."mlu4.s"),
ackfile (d.."mul4.s"),
ackfile (d.."rmi.s"),
ackfile (d.."rmi4.s"),
ackfile (d.."div4.s"),
ackfile (d.."rmu.s"),
ackfile (d.."dvi.s"),
ackfile (d.."rmu4.s"),
ackfile (d.."duv4.s"),
ackfile (d.."ngi4.s"),
ackfile (d.."rtt.s"),
ackfile (d.."ret.s"),
ackfile (d.."sar.s"),
ackfile (d.."aar.s"),
ackfile (d.."adi.s"),
ackfile (d.."sbi.s"),
ackfile (d.."mli.s"),
ackfile (d.."ngi.s"),
ackfile (d.."set.s"),
ackfile (d.."zer.s"),
ackfile (d.."stl.s"),
ackfile (d.."sts.s"),
ackfile (d.."sdl.s"),
ackfile (d.."sti.s"),
ackfile (d.."stil.s"),
ackfile (d.."blm.s"),
ackfile (d.."sti1.s"),
ackfile (d.."test2.s"),
ackfile (d.."testFFh.s"),
ackfile (d.."trap.s"),
ackfile (d.."ldi.s"),
ackfile (d.."data.s"),
ackfile (d.."zri.s"),
ackfile (d.."locaddr.s"),
ackfile (d.."and.s"),
ackfile (d.."asp.s"),
ackfile (d.."cii.s"),
ackfile (d.."cms.s"),
ackfile (d.."cmu.s"),
ackfile (d.."com.s"),
ackfile (d.."csa.s"),
ackfile (d.."csb.s"),
ackfile (d.."dup.s"),
ackfile (d.."dvu.s"),
ackfile (d.."exg.s"),
ackfile (d.."exg2.s"),
ackfile (d.."gto.s"),
ackfile (d.."indir.s"),
ackfile (d.."inn.s"),
ackfile (d.."ior.s"),
ackfile (d.."lcs.s"),
ackfile (d.."lxa1.s"),
ackfile (d.."lxa2.s"),
ackfile (d.."lxl.s"),
ackfile (d.."pro.s"),
ackfile (d.."rol.s"),
ackfile (d.."rol4.s"),
ackfile (d.."ror.s"),
ackfile (d.."ror4.s"),
ackfile (d.."sli.s"),
ackfile (d.."sli4.s"),
ackfile (d.."sri.s"),
ackfile (d.."sri4.s"),
ackfile (d.."teq.s"),
ackfile (d.."tge.s"),
ackfile (d.."tgt.s"),
ackfile (d.."tle.s"),
ackfile (d.."tlt.s"),
ackfile (d.."tne.s"),
ackfile (d.."xor.s"),
install = pm.install("%BINDIR%lib/%ARCH%/tail_em"),
}

33
mach/6500/pmfile
View file

@ -1,33 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/6500/"
include (d.."dl/pmfile")
include (d.."libem/pmfile")
mach_6500 = group {
ARCH = "6500",
proto_cg,
proto_as,
tool_6500_dl,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
support_6500 = group {
ARCH = "6500",
OPTIMISATION = "-O",
libem_6500,
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-10-15 00:28:12 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

16
mach/6800/pmfile
View file

@ -1,16 +0,0 @@
-- $Source$
-- $State$
mach_6800 = group {
ARCH = "6800",
proto_as,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:19 dtrg
-- First version in CVS.
--

16
mach/6805/pmfile
View file

@ -1,16 +0,0 @@
-- $Source$
-- $State$
mach_6805 = group {
ARCH = "6805",
proto_as,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

16
mach/6809/pmfile
View file

@ -1,16 +0,0 @@
-- $Source$
-- $State$
mach_6809 = group {
ARCH = "6809",
proto_as,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

19
mach/arm/cv/pmfile
View file

@ -1,19 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/arm/cv/"
tool_arm_cv = cprogram {
cfile (d.."cv.c"),
lib_object,
outputs = {"%U%/cv"},
install = pm.install(BINDIR.."%PLATDEP%/arm/dl")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

26
mach/arm/pmfile
View file

@ -1,26 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/arm/"
include (d.."cv/pmfile")
mach_arm = group {
ARCH = "arm",
proto_as,
proto_ncg { ARCHDIR = "arm" },
proto_top,
tool_arm_cv,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-07-22 12:31:19 dtrg
-- Added support for the top target peephole optimiser.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

19
mach/i386/cv/pmfile
View file

@ -1,19 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/i386/cv/"
tool_i386_cv = cprogram {
cfile (d.."cv.c"),
lib_object,
outputs = {"%U%/cv"},
install = pm.install(BINDIR.."%PLATDEP%/i386/dl")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

56
mach/i386/libem/pmfile
View file

@ -1,56 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/i386/libem/"
libem_i386 = acklibrary {
outputs = {"%U%/libem-%PLATFORM%.a"},
ackfile (d.."adi.s"),
ackfile (d.."and.s"),
ackfile (d.."blm.s"),
ackfile (d.."cii.s"),
ackfile (d.."cms.s"),
ackfile (d.."com.s"),
ackfile (d.."csa4.s"),
ackfile (d.."csb4.s"),
ackfile (d.."cuu.s"),
ackfile (d.."dup.s"),
ackfile (d.."dvi.s"),
ackfile (d.."dvu.s"),
ackfile (d.."error.s"),
ackfile (d.."exg.s"),
ackfile (d.."fp8087.s"),
ackfile (d.."fat.s"),
ackfile (d.."gto.s"),
ackfile (d.."iaar.s"),
ackfile (d.."ilar.s"),
ackfile (d.."inn.s"),
ackfile (d.."ior.s"),
ackfile (d.."isar.s"),
ackfile (d.."lar4.s"),
ackfile (d.."loi.s"),
ackfile (d.."mli.s"),
ackfile (d.."mon.s"),
ackfile (d.."ngi.s"),
ackfile (d.."nop.s"),
ackfile (d.."print.s"),
ackfile (d.."rck.s"),
ackfile (d.."rmi.s"),
ackfile (d.."rmu.s"),
ackfile (d.."rol.s"),
ackfile (d.."ror.s"),
ackfile (d.."sar4.s"),
ackfile (d.."sbi.s"),
ackfile (d.."set.s"),
ackfile (d.."sli.s"),
ackfile (d.."sri.s"),
ackfile (d.."sti.s"),
ackfile (d.."strhp.s"),
ackfile (d.."trp.s"),
ackfile (d.."unknown.s"),
ackfile (d.."xor.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libem.a"),
}

16
mach/i386/libend/pmfile
View file

@ -1,16 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/i386/libend/"
libend_i386 = acklibrary {
outputs = {"%U%/libend-%PLATFORM%.a"},
ackfile (d.."edata.s"),
ackfile (d.."em_end.s"),
ackfile (d.."end.s"),
ackfile (d.."etext.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libend.a"),
}

22
mach/i386/pmfile
View file

@ -1,22 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/i386/"
include (d.."libem/pmfile")
include (d.."libend/pmfile")
mach_i386 = group {
proto_as,
proto_ncg { ARCHDIR = "i386" },
ego_descr,
}
support_i386 = group {
OPTIMISATION = "-O",
libem_i386,
libend_i386,
}

49
mach/i80/libem/pmfile
View file

@ -1,49 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/i80/libem/"
libem_i80 = acklibrary {
outputs = {"%U%/libem-%PLATFORM%.a"},
ackfile (d.."aar2.s"),
ackfile (d.."adi4.s"),
ackfile (d.."and.s"),
ackfile (d.."blm.s"),
ackfile (d.."cii.s"),
ackfile (d.."cmi4.s"),
ackfile (d.."cms.s"),
ackfile (d.."com.s"),
ackfile (d.."csa.s"),
ackfile (d.."csb.s"),
ackfile (d.."dup.s"),
ackfile (d.."dvi2.s"),
ackfile (d.."exg.s"),
ackfile (d.."flp.s"),
ackfile (d.."inn.s"),
ackfile (d.."ior.s"),
ackfile (d.."lar2.s"),
ackfile (d.."mli2.s"),
ackfile (d.."mli4.s"),
ackfile (d.."mlu2.s"),
ackfile (d.."ngi4.s"),
ackfile (d.."nop.s"),
ackfile (d.."rol4.s"),
ackfile (d.."ror4.s"),
ackfile (d.."sar2.s"),
ackfile (d.."sbi4.s"),
ackfile (d.."set.s"),
ackfile (d.."set2.s"),
ackfile (d.."sli2.s"),
ackfile (d.."sli4.s"),
ackfile (d.."sri2.s"),
ackfile (d.."sri4.s"),
ackfile (d.."xor.s"),
ackfile (d.."loi.s"),
ackfile (d.."sti.s"),
ackfile (d.."dvi4.s"),
ackfile (d.."rck.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libem.a"),
}

16
mach/i80/libend/pmfile
View file

@ -1,16 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/i80/libend/"
libend_i80 = acklibrary {
outputs = {"%U%/libend-%PLATFORM%.a"},
ackfile (d.."edata.s"),
ackfile (d.."em_end.s"),
ackfile (d.."end.s"),
ackfile (d.."etext.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libend.a"),
}

25
mach/i80/pmfile
View file

@ -1,25 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/i80/"
include (d.."libem/pmfile")
include (d.."libend/pmfile")
mach_i80 = group {
ARCH = "i80",
proto_as,
proto_ncg { ARCHDIR = "i80" },
proto_top,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
support_i80 = group {
OPTIMISATION = "-O",
libem_i80,
libend_i80,
}

71
mach/i86/libem/pmfile
View file

@ -1,71 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/i86/libem/"
libem_i86 = acklibrary {
outputs = {"%U%/libem-%PLATFORM%.a"},
ackfile (d.."adi.s"),
ackfile (d.."and.s"),
ackfile (d.."cii.s"),
ackfile (d.."cms.s"),
ackfile (d.."cmi4.s"),
ackfile (d.."cmu4.s"),
ackfile (d.."com.s"),
ackfile (d.."csa2.s"),
ackfile (d.."csb2.s"),
ackfile (d.."csa4.s"),
ackfile (d.."csb4.s"),
ackfile (d.."cuu.s"),
ackfile (d.."dup.s"),
ackfile (d.."dvi.s"),
ackfile (d.."dvi4.s"),
ackfile (d.."dvu.s"),
ackfile (d.."dvu4.s"),
ackfile (d.."exg.s"),
ackfile (d.."fp8087.s"),
ackfile (d.."gto.s"),
ackfile (d.."iaar.s"),
ackfile (d.."ilar.s"),
ackfile (d.."inn.s"),
ackfile (d.."ior.s"),
ackfile (d.."isar.s"),
ackfile (d.."lar2.s"),
ackfile (d.."loi.s"),
ackfile (d.."mli.s"),
ackfile (d.."mli4.s"),
ackfile (d.."mon.s"),
ackfile (d.."ngi.s"),
ackfile (d.."nop.s"),
ackfile (d.."rck.s"),
ackfile (d.."rmi.s"),
ackfile (d.."rmi4.s"),
ackfile (d.."rmu.s"),
ackfile (d.."rmu4.s"),
ackfile (d.."rol.s"),
ackfile (d.."ror.s"),
ackfile (d.."sar2.s"),
ackfile (d.."sbi.s"),
ackfile (d.."set.s"),
ackfile (d.."sli.s"),
ackfile (d.."sri.s"),
ackfile (d.."sti.s"),
ackfile (d.."strhp.s"),
ackfile (d.."xor.s"),
ackfile (d.."error.s"),
ackfile (d.."unknown.s"),
ackfile (d.."fat.s"),
ackfile (d.."trp.s"),
ackfile (d.."print.s"),
ackfile (d.."ret6.s"),
ackfile (d.."ret8.s"),
ackfile (d.."lfr6.s"),
ackfile (d.."lfr8.s"),
ackfile (d.."retarea.s"),
ackfile (d.."blm.s"),
ackfile (d.."return.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libem.a"),
}

16
mach/i86/libend/pmfile
View file

@ -1,16 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/i86/libend/"
libend_i86 = acklibrary {
outputs = {"%U%/libend-%PLATFORM%.a"},
ackfile (d.."edata.s"),
ackfile (d.."em_end.s"),
ackfile (d.."end.s"),
ackfile (d.."etext.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libend.a"),
}

22
mach/i86/pmfile
View file

@ -1,22 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/i86/"
include (d.."libem/pmfile")
include (d.."libend/pmfile")
mach_i86 = group {
proto_as,
proto_ncg { ARCHDIR = "i86" },
ego_descr,
}
support_i86 = group {
OPTIMISATION = "-O",
ACKBUILDFLAGS = {PARENT, "-ansi"},
libem_i86,
libend_i86,
}

38
mach/m68020/libem/pmfile
View file

@ -1,38 +0,0 @@
-- $Source: /cvsroot/tack/Ack/mach/i386/libem/pmfile,v $
-- $State: Exp $
-- $Revision: 1.1 $
local d = ROOTDIR.."mach/m68020/libem/"
libem_m68020 = acklibrary {
outputs = {"%U%/libem-%PLATFORM%.a"},
ACKINCLUDES = {PARENT, ROOTDIR.."h"},
ackfile (d.."fp68881.s"),
ackfile (d.."aar.s"),
ackfile (d.."lar.s"),
ackfile (d.."sar.s"),
ackfile (d.."csa.s"),
ackfile (d.."csb.s"),
ackfile (d.."shp.s"),
ackfile (d.."set.s"),
ackfile (d.."inn.s"),
ackfile (d.."fat.s"),
ackfile (d.."trp.s"),
ackfile (d.."trpstr.c"),
ackfile (d.."mon.s"),
ackfile (d.."nop.s"),
ackfile (d.."dia.s"),
ackfile (d.."cii.s"),
ackfile (d.."cuu.s"),
ackfile (d.."cmi.s"),
ackfile (d.."cms.s"),
ackfile (d.."cmu.s"),
ackfile (d.."cvf.s"),
ackfile (d.."exg.s"),
ackfile (d.."los.s"),
ackfile (d.."sts.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libem.a"),
}

16
mach/m68020/libend/pmfile
View file

@ -1,16 +0,0 @@
-- $Source: /cvsroot/tack/Ack/mach/i386/libend/pmfile,v $
-- $State: Exp $
-- $Revision: 1.1 $
local d = ROOTDIR.."mach/m68020/libend/"
libend_m68020 = acklibrary {
outputs = {"%U%/libend-%PLATFORM%.a"},
ackfile (d.."edata.s"),
ackfile (d.."em_end.s"),
ackfile (d.."end.s"),
ackfile (d.."etext.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libend.a"),
}

23
mach/m68020/pmfile
View file

@ -1,23 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/m68020/"
include (d.."libem/pmfile")
include (d.."libend/pmfile")
mach_m68020 = group {
ARCH = "m68020",
proto_as,
proto_ncg { ARCHDIR = "m68020" },
proto_top,
ego_descr,
}
support_m68020 = group {
OPTIMISATION = "-O6",
libem_m68020,
libend_m68020,
}

30
mach/m68k2/pmfile
View file

@ -1,30 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/m68k2/"
mach_m68k2 = group {
ARCH = "m68k2",
proto_as,
proto_ncg { ARCHDIR = "m68020" },
proto_top,
ego_descr,
install = {
pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr"),
}
}
-- Revision history
-- $Log$
-- Revision 1.3 2006-07-22 12:31:19 dtrg
-- Added support for the top target peephole optimiser.
--
-- Revision 1.2 2006/07/22 00:52:01 dtrg
-- Added support for the ego global optimisation suite.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

25
mach/m68k4/pmfile
View file

@ -1,25 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/m68k4/"
mach_m68k4 = group {
ARCH = "m68k4",
proto_ncg { ARCHDIR = "m68020" },
ego_descr,
install = {
pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr"),
}
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-07-22 00:52:01 dtrg
-- Added support for the ego global optimisation suite.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

19
mach/ns/pmfile
View file

@ -1,19 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/ns/"
mach_ns = group {
ARCH = "ns",
proto_as,
proto_ncg { ARCHDIR = "ns" },
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

30
mach/pdp/pmfile
View file

@ -1,30 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/pdp/"
mach_pdp = group {
ARCH = "pdp",
proto_as,
proto_cg,
proto_ncg { ARCHDIR = "pdp" },
proto_top,
ego_descr,
install = {
pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr"),
}
}
-- Revision history
-- $Log$
-- Revision 1.3 2006-07-22 12:31:19 dtrg
-- Added support for the top target peephole optimiser.
--
-- Revision 1.2 2006/07/22 00:52:01 dtrg
-- Added support for the ego global optimisation suite.
--
-- Revision 1.1 2006/07/20 23:18:19 dtrg
-- First version in CVS.
--

30
mach/powerpc/libem/pmfile
View file

@ -1,30 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/powerpc/libem/"
libem_powerpc = acklibrary {
outputs = {"%U%/libem-%PLATFORM%.a"},
ACKINCLUDES = {PARENT, d},
ackfile (d.."ret.s"),
ackfile (d.."tge.s"),
ackfile (d.."csa.s"),
ackfile (d.."csb.s"),
ackfile (d.."los.s"),
ackfile (d.."sts.s"),
ackfile (d.."aar4.s"),
ackfile (d.."fef8.c"),
ackfile (d.."fif8.s"),
ackfile (d.."cif8.s"),
ackfile (d.."cuf8.s"),
ackfile (d.."cfi8.s"),
ackfile (d.."cfu8.s"),
ackfile (d.."fd_00000000.s"),
ackfile (d.."fd_80000000.s"),
ackfile (d.."fd_FFFFFFFF.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libem.a"),
}

16
mach/powerpc/libend/pmfile
View file

@ -1,16 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."mach/powerpc/libend/"
libend_powerpc = acklibrary {
outputs = {"%U%/libend-%PLATFORM%.a"},
ackfile (d.."edata.s"),
ackfile (d.."em_end.s"),
ackfile (d.."end.s"),
ackfile (d.."etext.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libend.a"),
}

23
mach/powerpc/pmfile
View file

@ -1,23 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/powerpc/"
include (d.."libem/pmfile")
include (d.."libend/pmfile")
mach_powerpc = group {
ARCH = "powerpc",
proto_as,
proto_ncg { ARCHDIR = "powerpc" },
proto_top,
-- ego_descr,
}
support_powerpc = group {
OPTIMISATION = "-O",
libem_powerpc,
libend_powerpc,
}

67
mach/proto/as/pmfile
View file

@ -1,67 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/proto/as/"
local parser = yacc {
simple {
outputs = {"%U%-%I%.y"},
command = {
"cd %out[1]:dirname% && "..
"%BINDIR%%PLATDEP%/cpp.ansi -P -I%ROOTDIR%mach/%ARCH%/as -I"..d.." %CINCLUDES:cincludes% %in[1]% > %out[1]%"
},
file (d.."comm2.y"),
}
}
local cfile_with_tables = cfile {
class = "cfile_with_tables",
CINCLUDES = {PARENT, "%ROOTDIR%mach/%ARCH%/as"},
dynamicheaders = {
parser,
}
}
proto_as = cprogram {
class = "proto_as",
cfile_with_tables (d.."comm3.c"),
cfile_with_tables (d.."comm4.c"),
cfile_with_tables (d.."comm5.c"),
cfile_with_tables (d.."comm6.c"),
cfile_with_tables (d.."comm7.c"),
cfile_with_tables (d.."comm8.c"),
cfile {
parser,
},
lib_object,
outputs = {"%U%/%PLATFORM%-as"},
install = pm.install(BINDIR.."%PLATDEP%/%PLATFORM%/as")
}
-- Revision history
-- $Log$
-- Revision 1.5 2007-04-21 22:55:59 dtrg
-- yacc source files are now run through the ANSI C preprocessor, not the K&R one.
--
-- Revision 1.4 2007/02/20 00:45:19 dtrg
-- Done a major overhaul of the way target include files are installed and
-- how platform libraries are built. The ARCH pm variable has now been
-- renamed PLATFORM (which is more accurate) and a different ARCH
-- variable added, which represents the CPU family rather than the
-- hardware platform.
--
-- Revision 1.3 2006/10/15 00:28:12 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.2 2006/07/30 23:41:16 dtrg
-- Broke dependency on tool_cpp in order to speed up the build.
--
-- Revision 1.1 2006/07/20 23:18:19 dtrg
-- First version in CVS.
--

67
mach/proto/cg/pmfile
View file

@ -1,67 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/proto/cg/"
local make_tables = cgg {
CGGINCLUDEDIR = (ROOTDIR.."mach/%PLATFORM%/cg/"),
file (ROOTDIR.."mach/%PLATFORM%/cg/table")
}
local cfile_with_tables = cfile {
class = "cfile_with_tables",
dynamicheaders = {
make_tables,
file (ROOTDIR.."mach/%PLATFORM%/cg/"),
file (ROOTDIR.."mach/")
}
}
proto_cg = cprogram {
class = "proto_cg",
cfile_with_tables (d.."codegen.c"),
cfile_with_tables (d.."compute.c"),
cfile_with_tables (d.."equiv.c"),
cfile_with_tables (d.."gencode.c"),
cfile_with_tables (d.."glosym.c"),
cfile_with_tables (d.."move.c"),
cfile_with_tables (d.."nextem.c"),
cfile_with_tables (d.."reg.c"),
cfile_with_tables (d.."regvar.c"),
cfile_with_tables (d.."salloc.c"),
cfile_with_tables (d.."state.c"),
cfile_with_tables (d.."subr.c"),
cfile_with_tables (d.."var.c"),
cfile_with_tables (d.."fillem.c"),
cfile_with_tables (d.."main.c"),
cfile {
ith { make_tables, i = 1 },
dynamicheaders = {
file (ROOTDIR.."mach/%PLATFORM%/cg/"),
file (d)
}
},
lib_em_data,
lib_flt_arith,
outputs = {"%U%/%PLATFORM%-cg"},
install = pm.install("%BINDIR%%PLATDEP%/%PLATFORM%/cg")
}
-- Revision history
-- $Log$
-- Revision 1.3 2007-02-20 00:45:19 dtrg
-- Done a major overhaul of the way target include files are installed and
-- how platform libraries are built. The ARCH pm variable has now been
-- renamed PLATFORM (which is more accurate) and a different ARCH
-- variable added, which represents the CPU family rather than the
-- hardware platform.
--
-- Revision 1.2 2006/10/15 00:28:12 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.1 2006/07/20 23:18:19 dtrg
-- First version in CVS.

57
mach/proto/ncg/pmfile
View file

@ -1,57 +0,0 @@
-- $Source: /cvsroot/tack/Ack/mach/proto/ncg/pmfile,v $
-- $State: Exp $
local d = ROOTDIR.."mach/proto/ncg/"
local make_tables = ncgg {
NCGGINCLUDEDIR = (ROOTDIR.."mach/%ARCHDIR%/ncg/"),
file (ROOTDIR.."mach/%ARCHDIR%/ncg/table")
}
local cfile_with_tables = cfile {
class = "cfile_with_tables",
dynamicheaders = {
make_tables,
}
}
proto_ncg = cprogram {
class = "proto_ncg",
exename = "ncg",
CINCLUDES = {
PARENT,
"mach/%PLATFORM%/ncg",
"mach/%ARCHDIR%/ncg",
"mach"
},
cfile_with_tables (d.."codegen.c"),
cfile_with_tables (d.."compute.c"),
cfile_with_tables (d.."equiv.c"),
cfile_with_tables (d.."fillem.c"),
cfile_with_tables (d.."gencode.c"),
cfile_with_tables (d.."glosym.c"),
cfile_with_tables (d.."label.c"),
cfile_with_tables (d.."main.c"),
cfile_with_tables (d.."move.c"),
cfile_with_tables (d.."nextem.c"),
cfile_with_tables (d.."reg.c"),
cfile_with_tables (d.."regvar.c"),
cfile_with_tables (d.."salloc.c"),
cfile_with_tables (d.."state.c"),
cfile_with_tables (d.."subr.c"),
cfile_with_tables (d.."var.c"),
cfile {
ith { make_tables, i = 1 },
CINCLUDES = {PARENT, d},
},
lib_em_data,
lib_flt_arith,
outputs = {"%U%/%PLATFORM%-%exename%"},
install = pm.install("%BINDIR%%PLATDEP%/%PLATFORM%/%exename%")
}

18
mach/proto/pmfile
View file

@ -1,18 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/proto/"
include (d.."as/pmfile")
include (d.."cg/pmfile")
include (d.."ncg/pmfile")
include (d.."top/pmfile")
-- Revision history
-- $Log$
-- Revision 1.2 2006-07-22 12:31:19 dtrg
-- Added support for the top target peephole optimiser.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

32
mach/proto/top/pmfile
View file

@ -1,32 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/proto/top/"
local make_tables = topgen {
file (ROOTDIR.."mach/%ARCH%/top/table")
}
local cfile_with_tables = cfile {
class = "cfile_with_tables",
dynamicheaders = {
make_tables,
}
}
proto_top = cprogram {
CINCLUDES = {
PARENT,
"mach/%ARCH%/ncg",
"mach",
d
},
cfile_with_tables (d.."queue.c"),
cfile_with_tables (d.."top.c"),
lib_string,
outputs = {"%U%/%ARCH%-top"},
install = pm.install("%BINDIR%%PLATDEP%/%PLATFORM%/top")
}

16
mach/s2650/pmfile
View file

@ -1,16 +0,0 @@
-- $Source$
-- $State$
mach_s2650 = group {
ARCH = "s2650",
proto_as,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

29
mach/vax4/pmfile
View file

@ -1,29 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/vax4/"
mach_vax4 = group {
ARCH = "vax4",
proto_as,
proto_cg,
proto_top,
ego_descr,
install = {
pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr"),
}
}
-- Revision history
-- $Log$
-- Revision 1.3 2006-07-22 12:31:19 dtrg
-- Added support for the top target peephole optimiser.
--
-- Revision 1.2 2006/07/22 00:52:01 dtrg
-- Added support for the ego global optimisation suite.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

19
mach/z80/pmfile
View file

@ -1,19 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/z80/"
mach_z80 = group {
ARCH = "z80",
proto_as,
proto_cg,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

19
mach/z8000/pmfile
View file

@ -1,19 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."mach/z8000/"
mach_z8000 = group {
ARCH = "z8000",
proto_as,
proto_cg,
install = pm.install("%ROOTDIR%/lib/%ARCH%/descr", "%BINDIR%%PLATIND%/%ARCH%/descr")
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:19 dtrg
-- First version in CVS.
--

29
modules/src/alloc/pmfile
View file

@ -1,29 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."modules/src/alloc/"
lib_alloc = file (LIBDIR.."liballoc.a")
module_alloc = clibrary {
cfile (d.."Malloc.c"),
cfile (d.."Salloc.c"),
cfile (d.."Srealloc.c"),
cfile (d.."Realloc.c"),
cfile (d.."botch.c"),
cfile (d.."clear.c"),
cfile (d.."st_alloc.c"),
cfile (d.."std_alloc.c"),
cfile (d.."No_Mem.c"),
outputs = {"%U%/liballoc.a"},
install = {
pm.install(LIBDIR.."liballoc.a"),
pm.install(d.."alloc.h", HEADERDIR.."alloc.h")
}
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

20
modules/src/assert/pmfile
View file

@ -1,20 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/assert/"
lib_assert = file (LIBDIR.."libassert.a")
module_assert = clibrary {
cfile (d.."BadAssert.c"),
outputs = {"%U%/libassert.a"},
install = {
pm.install(LIBDIR.."libassert.a")
}
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:19 dtrg
-- First version in CVS.
--

112
modules/src/em_code/pmfile
View file

@ -1,112 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/em_code/"
lib_eme = file (LIBDIR.."libeme.a")
lib_emk = file (LIBDIR.."libemk.a")
local em_codeMK_h = simple {
outputs = {"%U%-%I%.h"},
command = {
"%in[1]% %in[2]% "..d.."em.nogen > %out%",
"cat "..d.."em.nogen >> %out%"
},
install = pm.install(HEADERDIR.."em_codeEK.h"),
file (d.."make.em.gen"),
file ("%ROOTDIR%h/em_table")
}
local em_cfile = cfile {
class = "em_cfile",
dynamicheaders = em_codeMK_h
}
local library_core = group {
em_cfile (d.."bhcst.c"),
em_cfile (d.."bhdlb.c"),
em_cfile (d.."bhdnam.c"),
em_cfile (d.."bhfcon.c"),
em_cfile (d.."bhicon.c"),
em_cfile (d.."bhilb.c"),
em_cfile (d.."bhpnam.c"),
em_cfile (d.."bhucon.c"),
em_cfile (d.."crcst.c"),
em_cfile (d.."crdlb.c"),
em_cfile (d.."crdnam.c"),
em_cfile (d.."crxcon.c"),
em_cfile (d.."crilb.c"),
em_cfile (d.."crpnam.c"),
em_cfile (d.."crscon.c"),
em_cfile (d.."cst.c"),
em_cfile (d.."dfdlb.c"),
em_cfile (d.."dfdnam.c"),
em_cfile (d.."dfilb.c"),
em_cfile (d.."dlb.c"),
em_cfile (d.."dnam.c"),
em_cfile (d.."end.c"),
em_cfile (d.."endarg.c"),
em_cfile (d.."exc.c"),
em_cfile (d.."fcon.c"),
em_cfile (d.."getid.c"),
em_cfile (d.."icon.c"),
em_cfile (d.."ilb.c"),
em_cfile (d.."insert.c"),
em_cfile (d.."internerr.c"),
em_cfile (d.."msend.c"),
em_cfile (d.."op.c"),
em_cfile (d.."opcst.c"),
em_cfile (d.."opdlb.c"),
em_cfile (d.."opdnam.c"),
em_cfile (d.."opilb.c"),
em_cfile (d.."opnarg.c"),
em_cfile (d.."oppnam.c"),
em_cfile (d.."pnam.c"),
em_cfile (d.."pro.c"),
em_cfile (d.."pronarg.c"),
em_cfile (d.."msstart.c"),
em_cfile (d.."psdlb.c"),
em_cfile (d.."psdnam.c"),
em_cfile (d.."pspnam.c"),
em_cfile (d.."scon.c"),
em_cfile (d.."ucon.c"),
em_cfile (d.."C_out.c"),
em_cfile (d.."failed.c"),
em_cfile (d.."em.c")
}
module_eme = clibrary {
CDEFINES = {PARENT, "READABLE_EM"},
library_core,
outputs = {"%U%/libeme.a"},
install = {
pm.install(LIBDIR.."libeme.a")
}
}
module_emk = clibrary {
library_core,
outputs = {"%U%/libemk.a"},
install = {
pm.install(LIBDIR.."libemk.a")
}
}
module_em_code = group {
module_eme,
module_emk,
}
-- Revision history
-- $Log$
-- Revision 1.3 2007-02-25 12:46:41 dtrg
-- em_table is now in /h, not /etc.
--
-- Revision 1.2 2006/10/15 00:28:11 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

35
modules/src/em_mes/pmfile
View file

@ -1,35 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/em_mes/"
lib_em_mes = file (LIBDIR.."libem_mes.a")
local library_core = group {
cfile (d.."C_ms_err.c"),
cfile (d.."C_ms_opt.c"),
cfile (d.."C_ms_emx.c"),
cfile (d.."C_ms_reg.c"),
cfile (d.."C_ms_src.c"),
cfile (d.."C_ms_flt.c"),
cfile (d.."C_ms_com.c"),
cfile (d.."C_ms_par.c"),
cfile (d.."C_ms_ego.c"),
cfile (d.."C_ms_gto.c"),
cfile (d.."C_ms_stb.c"),
cfile (d.."C_ms_std.c"),
}
module_em_mes = clibrary {
library_core,
outputs = {"%U%/libem_mes.a"},
install = {
pm.install(LIBDIR.."libem_mes.a")
}
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:19 dtrg
-- First version in CVS.
--

35
modules/src/flt_arith/pmfile
View file

@ -1,35 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."modules/src/flt_arith/"
lib_flt_arith = file (LIBDIR.."libflt_arith.a")
module_flt_arith = clibrary {
cfile (d.."flt_ar2flt.c"),
cfile (d.."flt_div.c"),
cfile (d.."flt_flt2ar.c"),
cfile (d.."flt_modf.c"),
cfile (d.."flt_str2fl.c"),
cfile (d.."flt_cmp.c"),
cfile (d.."flt_add.c"),
cfile (d.."b64_add.c"),
cfile (d.."flt_mul.c"),
cfile (d.."flt_nrm.c"),
cfile (d.."b64_sft.c"),
cfile (d.."flt_umin.c"),
cfile (d.."flt_chk.c"),
cfile (d.."split.c"),
cfile (d.."ucmp.c"),
outputs = {"%U%/libflt_arith.a"},
install = {
pm.install(LIBDIR.."libflt_arith.a"),
pm.install(d.."flt_arith.h", HEADERDIR.."flt_arith.h")
}
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

17
modules/src/idf/pmfile
View file

@ -1,17 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/idf/"
module_idf = group {
install = {
pm.install(d.."idf_pkg.spec", HEADERDIR.."idf_pkg.spec"),
pm.install(d.."idf_pkg.body", HEADERDIR.."idf_pkg.body"),
}
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:19 dtrg
-- First version in CVS.
--

23
modules/src/input/pmfile
View file

@ -1,23 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/input/"
lib_input = file (LIBDIR.."libinput.a")
module_input = clibrary {
cfile (d.."AtEoIF.c"),
cfile (d.."AtEoIT.c"),
outputs = {"%U%/libinput.a"},
install = {
pm.install(LIBDIR.."libinput.a"),
pm.install(d.."inp_pkg.spec", HEADERDIR.."inp_pkg.spec"),
pm.install(d.."inp_pkg.body", HEADERDIR.."inp_pkg.body")
}
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

55
modules/src/object/pmfile
View file

@ -1,55 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/object/"
lib_object = file (LIBDIR.."libobject.a")
module_object = clibrary {
cfile (d.."rd_arhdr.c"),
cfile (d.."rd_bytes.c"),
cfile (d.."rd_int2.c"),
cfile (d.."rd_long.c"),
cfile (d.."rd_ranlib.c"),
cfile (d.."rd_unsig2.c"),
cfile (d.."rd.c"),
cfile (d.."wr_arhdr.c"),
cfile (d.."wr_bytes.c"),
cfile (d.."wr_int2.c"),
cfile (d.."wr_long.c"),
cfile (d.."wr_putc.c"),
cfile (d.."wr_ranlib.c"),
cfile (d.."wr.c"),
outputs = {"%U%/lib_object.a"},
install = {
pm.install(LIBDIR.."libobject.a")
}
}
--[[
# genmakefile
# This genmakefile doesn't have a real comment yet.
#
# $Source$
# $State$
push
addincludeq src/lib/object
hostlibrary $LIBDIR/libobject.a $OBJS
pop
# Revision history
# $Log$
# Revision 1.1 2006-07-20 23:18:18 dtrg
# First version in CVS.
#
--]]
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

27
modules/src/print/pmfile
View file

@ -1,27 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/print/"
lib_print = file (LIBDIR.."libprint.a")
module_print = clibrary {
cfile (d.."doprnt.c"),
cfile (d.."fprint.c"),
cfile (d.."print.c"),
cfile (d.."sprint.c"),
cfile (d.."format.c"),
outputs = {"%U%/libprint.a"},
install = {
pm.install("%LIBDIR%libprint.a"),
pm.install(d.."print.h", "%HEADERDIR%print.h")
}
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-07-22 20:59:22 dtrg
-- Changed to export a header file so it can be correctly referred to.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.

96
modules/src/read_em/pmfile
View file

@ -1,96 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/read_em/"
lib_read_emk = file (LIBDIR.."libread_emk.a")
lib_read_emkV = file (LIBDIR.."libread_emkV.a")
lib_read_emeV = file (LIBDIR.."libread_emeV.a")
local C_mnem_h = simple {
command = {"(cd "..d.." && sh %in[1]% %in[2]%) > %out%"},
outputs = {"%U%-%I%.h"},
install = pm.install(HEADERDIR.."C_mnem.h"),
file (ROOTDIR..d.."m_C_mnem"),
file ("%ROOTDIR%h/em_table")
}
local C_mnem_narg_h = simple {
command = {"(cd "..d.." && %in[1]% %in[2]%) > %out%"},
outputs = {"%U%-%I%.h"},
install = pm.install(HEADERDIR.."C_mnem_narg.h"),
file (ROOTDIR..d.."m_C_mnem_na"),
file ("%ROOTDIR%h/em_table")
}
local withdynamic = cfile {
dynamicheaders = {C_mnem_h, C_mnem_narg_h}
}
module_read_emk = clibrary {
CDEFINES = {PARENT, "PRIVATE=static", "EXPORT=", "NDEBUG"},
cfile (d.."EM_vars.c"),
cfile {
CDEFINES = {PARENT, "COMPACT"},
(d.."read_em.c")
},
withdynamic (d.."mkcalls.c"),
outputs = {"%U%/libread_emk.a"},
install = pm.install(LIBDIR.."libread_emk.a")
}
module_read_emkV = clibrary {
CDEFINES = {PARENT, "PRIVATE=static", "EXPORT=", "NDEBUG"},
cfile (d.."EM_vars.c"),
cfile {
CDEFINES = {PARENT, "COMPACT", "CHECKING"},
(d.."read_em.c")
},
withdynamic {
CDEFINES = {PARENT, "CHECKING"},
(d.."mkcalls.c"),
},
outputs = {"%U%/libread_emkV.a"},
install = pm.install(LIBDIR.."libread_emkV.a")
}
module_read_emeV = clibrary {
CDEFINES = {PARENT, "PRIVATE=static", "EXPORT=", "NDEBUG"},
cfile (d.."EM_vars.c"),
cfile {
CDEFINES = {PARENT, "CHECKING"},
(d.."read_em.c")
},
withdynamic {
CDEFINES = {PARENT, "CHECKING"},
(d.."mkcalls.c"),
},
outputs = {"%U%/lib_read_emeV.a"},
install = pm.install(LIBDIR.."libread_emeV.a")
}
module_read_em = group {
module_read_emk,
module_read_emkV,
module_read_emeV,
install = {
pm.install(d.."em_comp.h", HEADERDIR.."em_comp.h"),
}
}
-- Revision history
-- $Log$
-- Revision 1.3 2007-02-25 12:47:10 dtrg
-- em_table is now in /h, not /etc.
--
-- Revision 1.2 2006/10/15 00:28:11 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

41
modules/src/string/pmfile
View file

@ -1,41 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/string/"
lib_string = file (LIBDIR.."libstring.a")
module_string = clibrary {
cfile (d.."bts2str.c"),
cfile (d.."btscat.c"),
cfile (d.."btscmp.c"),
cfile (d.."btscpy.c"),
cfile (d.."btszero.c"),
cfile (d.."long2str.c"),
cfile (d.."str2bts.c"),
cfile (d.."str2long.c"),
-- cfile (d.."strcat.c"),
-- cfile (d.."strcmp.c"),
-- cfile (d.."strcpy.c"),
-- cfile (d.."strindex.c"),
-- cfile (d.."strlen.c"),
-- cfile (d.."strncat.c"),
-- cfile (d.."strncmp.c"),
-- cfile (d.."strncpy.c"),
-- cfile (d.."strrindex.c"),
cfile (d.."strzero.c"),
outputs = {"%U%/lib_string.a"},
install = {
pm.install(LIBDIR.."libstring.a")
}
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-07-23 19:58:27 dtrg
-- Modified to no longer build unoptimised duplicates of all the standard
-- string functions (strcpy, strlen, etc).
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

42
modules/src/system/pmfile
View file

@ -1,42 +0,0 @@
-- $Source$
-- $State$
local d = "modules/src/system/"
lib_system = file (LIBDIR.."libsystem.a")
module_system = clibrary {
cfile (d.."access.c"),
cfile (d.."break.c"),
cfile (d.."chmode.c"),
cfile (d.."close.c"),
cfile (d.."create.c"),
cfile (d.."filesize.c"),
cfile (d.."modtime.c"),
-- cfile (d.."lock.c"),
cfile (d.."open.c"),
cfile (d.."read.c"),
cfile (d.."remove.c"),
cfile (d.."stop.c"),
cfile (d.."system.c"),
cfile (d.."time.c"),
-- cfile (d.."unlock.c"),
cfile (d.."write.c"),
cfile (d.."seek.c"),
cfile (d.."rename.c"),
outputs = {"%U%/libsystem.a"},
install = {
pm.install(LIBDIR.."libsystem.a"),
pm.install(d.."system.h", HEADERDIR.."system.h")
}
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-07-26 12:40:59 dtrg
-- Changed to no longer build sys_lock() and sys_unlock(); they only work
-- on platforms that support hardlinks, and nobody uses them anyway.
--
-- Revision 1.1 2006/07/20 23:18:19 dtrg
-- First version in CVS.
--

29
plat/cpm/libsys/pmfile
View file

@ -1,29 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."plat/cpm/libsys/"
libsys_cpm = acklibrary {
ACKINCLUDES = {"%BINDIR%include"},
ackfile (d.."errno.s"),
ackfile (d.."_hol0.s"),
ackfile (d.."_bdos.s"),
ackfile (d.."_trap.s"),
ackfile (d.."_inn2.s"),
ackfile (d.."open.c"),
ackfile (d.."creat.c"),
ackfile (d.."close.c"),
ackfile (d.."read.c"),
ackfile (d.."write.c"),
ackfile (d.."brk.c"),
ackfile (d.."getpid.c"),
ackfile (d.."kill.c"),
ackfile (d.."isatty.c"),
ackfile (d.."lseek.c"),
ackfile (d.."time.c"),
ackfile (d.."signal.c"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libsys.a"),
}

47
plat/cpm/pmfile
View file

@ -1,47 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."plat/cpm/"
include (d.."libsys/pmfile")
local bootsector = ackfile {
file (d.."boot.s"),
install = pm.install("%BINDIR%lib/cpm/boot.o"),
}
local descr = group {
install = pm.install(d.."descr", "%BINDIR%%PLATIND%/%PLATFORM%/descr")
}
local headers = group {
install = {
pm.install(d.."include/ack/config.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/ack/config.h"),
pm.install(d.."include/unistd.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/unistd.h"),
pm.install(d.."include/cpm.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/cpm.h"),
}
}
platform_cpm = group {
ARCH = "i80",
PLATFORM = "cpm",
OPTIMISATION = "-O",
-- Ensure the descr and headers are installed first because we'll need
-- them to build the libraries.
descr,
headers,
-- Build the back-end support.
mach_i80,
support_i80,
lang_runtimes,
-- Build the CP/M syscall library.
libsys_cpm,
bootsector,
}

29
plat/linux/liblinux/pmfile
View file

@ -1,29 +0,0 @@
-- $Source: /cvsroot/tack/Ack/plat/linux386/libsys/pmfile,v $
-- $State: Exp $
-- $Revision: 1.1 $
local d = ROOTDIR.."plat/linux/liblinux/"
liblinux = acklibrary {
ACKINCLUDES = {"%BINDIR%include"},
ackfile (d.."errno.s"),
ackfile (d.."_hol0.s"),
ackfile (d.."brk.c"),
ackfile (d.."close.c"),
ackfile (d.."creat.c"),
ackfile (d.."getpid.c"),
ackfile (d.."gettimeofday.c"),
ackfile (d.."_exit.c"),
ackfile (d.."isatty.c"),
ackfile (d.."kill.c"),
ackfile (d.."lseek.c"),
ackfile (d.."open.c"),
ackfile (d.."read.c"),
ackfile (d.."sbrk.c"),
ackfile (d.."signal.c"),
ackfile (d.."write.c"),
install = pm.install("%BINDIR%lib/%PLATFORM%/liblinux.a"),
}

13
plat/linux386/libsys/pmfile
View file

@ -1,13 +0,0 @@
-- $Source: /cvsroot/tack/Ack/plat/linux386/libsys/pmfile,v $
-- $State: Exp $
-- $Revision: 1.1 $
local d = ROOTDIR.."plat/linux386/libsys/"
libsys_linux386 = acklibrary {
ACKINCLUDES = {"%BINDIR%include"},
ackfile (d.."_syscall.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libsys.a"),
}

48
plat/linux386/pmfile
View file

@ -1,48 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."plat/linux386/"
include (d.."libsys/pmfile")
include "plat/linux/liblinux/pmfile"
local bootsector = ackfile {
file (d.."boot.s"),
install = pm.install("%BINDIR%lib/linux386/boot.o"),
}
local descr = group {
install = pm.install(d.."descr", "%BINDIR%%PLATIND%/%PLATFORM%/descr")
}
local headers = group {
install = {
pm.install(d.."include/ack/config.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/ack/config.h"),
pm.install(d.."include/unistd.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/unistd.h"),
}
}
platform_linux386 = group {
ARCH = "i386",
PLATFORM = "linux386",
OPTIMISATION = "-O",
-- Ensure the descr and headers are installed first because we'll need it
-- to build the libraries.
descr,
headers,
-- Build the back-end support.
mach_i386,
support_i386,
lang_runtimes,
-- Build the PC standalone syscall library.
liblinux,
libsys_linux386,
bootsector,
}

13
plat/linux68k/libsys/pmfile
View file

@ -1,13 +0,0 @@
-- $Source: /cvsroot/tack/Ack/plat/linux386/libsys/pmfile,v $
-- $State: Exp $
-- $Revision: 1.1 $
local d = ROOTDIR.."plat/linux68k/libsys/"
libsys_linux68k = acklibrary {
ACKINCLUDES = {"%BINDIR%include"},
ackfile (d.."_syscall.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libsys.a"),
}

48
plat/linux68k/pmfile
View file

@ -1,48 +0,0 @@
-- $Source: /cvsroot/tack/Ack/plat/linux386/pmfile,v $
-- $State: Exp $
-- $Revision: 1.3 $
local d = ROOTDIR.."plat/linux68k/"
include (d.."libsys/pmfile")
include "plat/linux/liblinux/pmfile"
local bootsector = ackfile {
file (d.."boot.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/boot.o"),
}
local descr = group {
install = pm.install(d.."descr", "%BINDIR%%PLATIND%/%PLATFORM%/descr")
}
local headers = group {
install = {
pm.install(d.."include/ack/config.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/ack/config.h"),
pm.install(d.."include/unistd.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/unistd.h"),
}
}
platform_linux68k = group {
ARCH = "m68020",
PLATFORM = "linux68k",
OPTIMISATION = "-O6",
-- Ensure the descr and headers are installed first because we'll need it
-- to build the libraries.
descr,
headers,
-- Build the back-end support.
mach_m68020,
support_m68020,
lang_runtimes,
-- Build the PC standalone syscall library.
liblinux,
libsys_linux68k,
bootsector,
}

14
plat/linuxppc/libsys/pmfile
View file

@ -1,14 +0,0 @@
-- $Source: /cvsroot/tack/Ack/plat/linux386/libsys/pmfile,v $
-- $State: Exp $
-- $Revision: 1.1 $
local d = ROOTDIR.."plat/linuxppc/libsys/"
libsys_linuxppc = acklibrary {
ACKINCLUDES = {"%BINDIR%include"},
ackfile (d.."_syscall.s"),
ackfile (d.."trap.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libsys.a"),
}

48
plat/linuxppc/pmfile
View file

@ -1,48 +0,0 @@
-- $Source: /cvsroot/tack/Ack/plat/linux386/pmfile,v $
-- $State: Exp $
-- $Revision: 1.3 $
local d = ROOTDIR.."plat/linuxppc/"
include (d.."libsys/pmfile")
include "plat/linux/liblinux/pmfile"
local bootsector = ackfile {
file (d.."boot.s"),
install = pm.install("%BINDIR%lib/%PLATFORM%/boot.o"),
}
local descr = group {
install = pm.install(d.."descr", "%BINDIR%%PLATIND%/%PLATFORM%/descr")
}
local headers = group {
install = {
pm.install(d.."include/ack/config.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/ack/config.h"),
pm.install(d.."include/unistd.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/unistd.h"),
}
}
platform_linuxppc = group {
ARCH = "powerpc",
PLATFORM = "linuxppc",
OPTIMISATION = "-O",
-- Ensure the descr and headers are installed first because we'll need it
-- to build the libraries.
descr,
headers,
-- Build the back-end support.
mach_powerpc,
support_powerpc,
lang_runtimes,
-- Build the PC standalone syscall library.
liblinux,
libsys_linuxppc,
bootsector,
}

29
plat/pc86/libsys/pmfile
View file

@ -1,29 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."plat/pc86/libsys/"
libsys_pc86 = acklibrary {
ACKBUILDFLAGS = {PARENT, "-ansi"},
ACKINCLUDES = {"%BINDIR%include"},
ackfile (d.."errno.s"),
ackfile (d.."_hol0.s"),
ackfile (d.."_sys_rawread.s"),
ackfile (d.."_sys_rawwrite.s"),
ackfile (d.."open.c"),
ackfile (d.."creat.c"),
ackfile (d.."close.c"),
ackfile (d.."read.c"),
ackfile (d.."write.c"),
ackfile (d.."brk.c"),
ackfile (d.."getpid.c"),
ackfile (d.."kill.c"),
ackfile (d.."isatty.c"),
ackfile (d.."lseek.c"),
ackfile (d.."time.c"),
ackfile (d.."signal.c"),
install = pm.install("%BINDIR%lib/%PLATFORM%/libsys.a"),
}

46
plat/pc86/pmfile
View file

@ -1,46 +0,0 @@
-- $Source$
-- $State$
-- $Revision$
local d = ROOTDIR.."plat/pc86/"
include (d.."libsys/pmfile")
local bootsector = ackfile {
file (d.."boot.s"),
install = pm.install("%BINDIR%lib/pc86/boot.o"),
}
local descr = group {
install = pm.install(d.."descr", "%BINDIR%%PLATIND%/%PLATFORM%/descr")
}
local headers = group {
install = {
pm.install(d.."include/ack/config.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/ack/config.h"),
pm.install(d.."include/unistd.h", "%BINDIR%%PLATIND%/%PLATFORM%/include/unistd.h"),
}
}
platform_pc86 = group {
ARCH = "i86",
PLATFORM = "pc86",
OPTIMISATION = "-O",
-- Ensure the descr and headers are installed first because we'll need
-- them to build the libraries.
descr,
headers,
-- Build the back-end support.
mach_i86,
support_i86,
lang_runtimes,
-- Build the PC standalone syscall library.
libsys_pc86,
bootsector,
}

239
pmfile
View file

@ -1,239 +0,0 @@
-- $Id$
-- $Source$
-- $State$
include "first/c.pm"
include "first/yacc.pm"
include "first/llgen.pm"
include "config.pm"
include "first/ack.pm"
include "first/ack-custom.pm"
CINCLUDES = {
ROOTDIR.."h",
ROOTDIR.."modules/h",
HEADERDIR,
}
-- Load the pmfiles for the various modules.
include "util/data/pmfile"
include "util/LLgen/pmfile-ack"
include "modules/src/alloc/pmfile"
include "modules/src/assert/pmfile"
include "modules/src/system/pmfile"
include "modules/src/string/pmfile"
include "modules/src/read_em/pmfile"
include "modules/src/em_code/pmfile"
include "modules/src/em_mes/pmfile"
include "modules/src/print/pmfile"
include "modules/src/object/pmfile"
include "modules/src/idf/pmfile"
include "modules/src/input/pmfile"
include "modules/src/flt_arith/pmfile"
include "util/amisc/pmfile"
include "util/cmisc/pmfile"
include "util/ack/pmfile"
include "util/arch/pmfile"
-- include "util/cpp/pmfile"
include "lang/cem/cpp.ansi/pmfile"
include "util/cgg/pmfile"
include "util/ncgg/pmfile"
-- include "util/ceg/pmfile"
include "util/misc/pmfile"
include "util/opt/pmfile"
include "util/ego/pmfile"
include "util/topgen/pmfile"
include "util/led/pmfile"
include "lang/cem/pmfile"
include "lang/pc/pmfile"
include "lang/m2/pmfile"
-- include "lang/occam/pmfile"
-- include "lang/basic/pmfile"
include "mach/proto/pmfile"
--[[
include "mach/i386/pmfile"
include "mach/6500/pmfile"
include "mach/6800/pmfile"
include "mach/6805/pmfile"
include "mach/6809/pmfile"
include "mach/arm/pmfile"
include "mach/i80/pmfile"
include "mach/m68020/pmfile"
include "mach/m68k2/pmfile"
include "mach/m68k4/pmfile"
include "mach/ns/pmfile"
include "mach/pdp/pmfile"
include "mach/s2650/pmfile"
include "mach/vax4/pmfile"
include "mach/z80/pmfile"
include "mach/z8000/pmfile"
--]]
-- This is the list of language runtimes that is built for each architecture.
lang_runtimes = group {
-- lang_cem_runtime, -- K&R C (obsolete and useless)
lang_cem_ansi_runtime, -- ANSI C
lang_pc_runtime, -- Pascal
lang_m2_runtime, -- Modula-2
-- lang_occam_runtime, -- Occam 1 (obsolete and useless)
-- lang_basic_runtime, -- Basic
}
-- Include the platform descriptions.
include "mach/i86/pmfile" -- generic i86
include "plat/pc86/pmfile" -- PC standalone
include "mach/i386/pmfile" -- generic i386
include "plat/linux386/pmfile" -- Linux executables
include "mach/powerpc/pmfile" -- generic PowerPC
include "plat/linuxppc/pmfile" -- Linux executables
include "mach/m68020/pmfile" -- generic M68k
include "plat/linux68k/pmfile" -- Linux executables
include "mach/i80/pmfile" -- generic 8080
include "plat/cpm/pmfile" -- CP/M
default = group {
-- Lots of things use LLgen, so we need to build it first.
tool_LLgen,
-- Some of the dependency management across modules isn't entirely
-- complete, for simplicity; as a result, the order here is important.
-- In particular, referencing a library does not cause the library to
-- be built, hence the reason why the modules must be built first. Also,
-- some of these generate header files...
module_em_data,
module_system,
module_alloc,
module_assert,
module_string,
module_em_code,
module_read_em,
module_em_mes,
module_print,
module_object,
module_idf,
module_print,
module_input,
module_flt_arith,
tool_tabgen,
tool_aal,
tool_ack,
-- tool_cpp, -- K&R C
tool_cpp_ansi, -- ANSI C
tool_cgg,
tool_ncgg,
-- tool_ceg,
tool_em_decode,
tool_em_encode,
tool_esize,
tool_opt,
tool_ego,
tool_topgen,
tool_led,
tool_anm,
tool_ashow,
tool_asize,
tool_astrip,
tool_aslod,
tool_aelflod,
-- lang_cem_compiler,
lang_cem_ansi_compiler,
lang_pc_compiler,
lang_m2_compiler,
-- lang_occam_compiler,
-- lang_basic_compiler,
-- Build the code generators and the architecture-independent
-- libraries.
--[[
mach_6500,
lang_runtimes { ARCH="6500", OPTIMISATION="-O" },
mach_6800,
mach_6805,
mach_6809,
mach_arm, lang_runtimes { ARCH="arm", OPTIMISATION="-O" },
mach_m68020, lang_runtimes { ARCH="m68020", OPTIMISATION="-O" },
-- mach_m68k2, lang_runtimes { ARCH="m68k2", OPTIMISATION="-O" },
-- mach_m68k4, lang_runtimes { ARCH="m68k4", OPTIMISATION="-O" },
mach_ns, lang_runtimes { ARCH="ns", OPTIMISATION="-O" },
-- mach_pdp, lang_runtimes { ARCH="pdp", OPTIMISATION="-O" },
mach_s2650,
-- mach_vax4, lang_runtimes { ARCH="vax4", OPTIMISATION="-O" },
mach_z80, lang_runtimes { ARCH="z80", OPTIMISATION="-O" },
mach_z8000, lang_runtimes { ARCH="z8000", OPTIMISATION="-O" },
--]]
-- Build the platforms.
platform_pc86,
platform_linux386,
-- platform_linuxppc,
platform_linux68k,
platform_cpm,
}
-- Ensure that the work directories exist.
posix.mkdir(TEMPDIR)
posix.mkdir(HEADERDIR)
-- When doing the build, we want to ensure that the ACK looks in the staging
-- area for its files, and not in the final installation directory (because
-- we haven't been installed yet).
posix.putenv("ACKDIR="..BINDIR)
-- Build the configuration headers, rather crudely. FIXME.
configure = simple {
outputs = {HEADERDIR.."local.h", HEADERDIR.."em_path.h"},
command = "",
__dobuild = function(self, inputs, outputs)
-- Build 'local.h', rather crudely
local f = io.open(HEADERDIR.."local.h", "w")
f:write("#define VERSION 3\n") -- EM byte-code version
f:write("#define ACKM \"", DEFAULT_PLATFORM, "\"\n")
f:write("#define BIGMACHINE 1\n") -- No, we don't have a 16-bit architecture
f:write("#define SYS_5\n")
f:close()
-- Build 'em_path.h', rather crudely
local f = io.open(HEADERDIR.."em_path.h", "w")
f:write("#define TMP_DIR \"", ACK_TEMP_DIR, "\"\n")
f:write("#define EM_DIR \"", PREFIX, "\"\n")
f:write("#define ACK_PATH \"", PLATIND, "/descr\"\n")
f:close()
end
}
-- Once built, do the installation, rather crudely. FIXME.
install = simple {
outputs = {"dummy"},
command = "",
__dobuild = function(self, inputs, outputs)
os.execute("mkdir -p "..PREFIX)
os.execute("(cd "..BINDIR.." && tar chf - .) | (cd "..PREFIX.." && tar xvf -)")
end
}

127
util/LLgen/pmfile
View file

@ -1,127 +0,0 @@
-- $Source$
-- $State$
--
-- $Id$
--
-- This is the build file used to compile LLgen. It should be run through
-- Prime Mover (copy supplied). See the READ_ME file for more information.
include "c.pm"
-- Where is LLgen going to be installed eventually? (Needs trailing slash.)
PREFIX = PREFIX or "/usr/local/"
-- Where's LLgen's staging area? (Don't change. Needs trailing slash.)
INSTALLPATH = "bin/"
LLgen = cprogram {
CEXTRAFLAGS = '-DLIBDIR=\\"'..PREFIX..'share/LLgen\\" -DNON_CORRECTING',
-- This line is needed to work around an OSX bug --- Apple's hacked gcc's
-- preprocessor doesn't find LLgen.c's include files properly. Don't know
-- why.
CINCLUDES = {PARENT, "-Isrc"},
cfile "src/main.c",
cfile "src/gencode.c",
cfile "src/compute.c",
cfile "src/check.c",
cfile "src/reach.c",
cfile "src/global.c",
cfile "src/name.c",
cfile "src/sets.c",
cfile "src/alloc.c",
cfile "src/machdep.c",
cfile "src/cclass.c",
cfile "src/savegram.c",
-- These use pre-LLgen'd version of the files. If LLgen.g gets updated,
-- they need rebuilding. Use the bootstrap script to do this.
cfile "src/LLgen.c",
cfile "src/Lpars.c",
cfile "src/tokens.c",
outputs = {"%U%/LLgen"},
install = pm.install( INSTALLPATH.."bin/LLgen")
}
library = group {
install = {
pm.install("lib/rec", INSTALLPATH.."share/LLgen/rec"),
pm.install("lib/incl", INSTALLPATH.."share/LLgen/incl"),
pm.install("lib/nc_incl", INSTALLPATH.."share/LLgen/nc_incl"),
pm.install("lib/nc_rec", INSTALLPATH.."share/LLgen/nc_rec"),
}
}
manpage = group {
install = {
pm.install("doc/LLgen.1", INSTALLPATH.."man/man1/LLgen.1"),
}
}
documentation = group {
simple {
outputs = {"%U%-%I%.ps.gz"},
command = "refer -sA+T -p %in[1]% %in[2]% | groff -Tps -e -t -ms "..
"| gzip -c9 > %out[1]%",
file "doc/LLgen.refs",
file "doc/LLgen.n",
install = {
pm.install(INSTALLPATH.."share/doc/LLgen/LLgen.ps.gz")
}
},
simple {
outputs = {"%U%-%I%.ps.gz"},
command = "groff -Tps -e -t -p -ms %in% | gzip -c9 > %out[1]%",
file "doc/LLgen_NCER.n",
install = {
pm.install(INSTALLPATH.."share/doc/LLgen/NCER.ps.gz")
}
},
}
-- Default rule: builds everything into the staging area, but does nothing
-- else.
default = group {
LLgen, -- build LLgen itself
library, -- copy over the library
manpage, -- copy over the man page
documentation, -- build the two white papers
}
-- This rule will build everything, and then install it to its final location.
install = group {
default,
install = {
"mkdir -p %PREFIX%",
"(cd bin && tar chvf - $(find . ! -type d)) | (cd %PREFIX% && tar xUf -)"
}
}
-- Revision history
-- $Log$
-- Revision 1.5 2006-07-25 23:29:12 dtrg
-- Modified to not try to unlink directories when installing.
--
-- Revision 1.4 2006/07/25 23:22:58 dtrg
-- Updated to the latest version of pm which installs files with symlinks.
--
-- Revision 1.3 2006/07/23 20:33:26 dtrg
-- Added a workaround for an OSX compiler bug.
--
-- Revision 1.2 2006/07/21 11:15:14 dtrg
-- Updated to the latest version of pm.
--

61
util/ack/pmfile
View file

@ -1,61 +0,0 @@
-- $Source$
-- $State$
local d = "%ROOTDIR%util/ack/"
local mktable = cprogram {
cfile (d.."mktables.c")
}
local makeheaders = simple {
outputs= {"%U%/dmach.c", "%U%/intable.c"},
command = {
"cd %out[1]:dirname% && %in[1]% %BINDIR%lib"
},
mktable
}
tool_ack = cprogram {
cfile (d.."list.c"),
cfile (d.."data.c"),
cfile (d.."main.c"),
cfile (d.."scan.c"),
cfile (d.."svars.c"),
cfile (d.."trans.c"),
cfile (d.."util.c"),
cfile (d.."rmach.c"),
cfile (d.."run.c"),
cfile (d.."grows.c"),
cfile (d.."files.c"),
cfile {
CINCLUDES = {PARENT, d},
ith { makeheaders, i = 1 }
},
cfile {
CINCLUDES = {PARENT, d},
ith { makeheaders, i = 2 }
},
lib_string,
outputs = {"%U%/ack"},
install = {
pm.install("%BINDIR%bin/ack"),
pm.install("%ROOTDIR%/lib/descr/fe", "%BINDIR%%PLATIND%/descr/fe"),
pm.install(d.."ack.1.X", "%BINDIR%man/man1/ack.1")
}
}
-- Revision history
-- $Log$
-- Revision 1.3 2007-02-25 12:48:06 dtrg
-- Now installs the man page.
--
-- Revision 1.2 2006/10/15 00:28:12 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

35
util/amisc/pmfile
View file

@ -1,35 +0,0 @@
-- $Source$
-- $State$
local d = "util/amisc/"
local simple_tool = cprogram {
class = "simple_tool",
cfile (d.."%S%.c"),
lib_object,
outputs = {"%U%/%S%"},
install = {
pm.install("%U%/%S%", "%BINDIR%bin/%S%"),
pm.install(d.."%S%.1", "%BINDIR%man/man1/%S%.1")
}
}
tool_anm = simple_tool { S = "anm" }
tool_ashow = simple_tool { S = "ashow" }
tool_asize = simple_tool { S = "asize" }
tool_astrip = simple_tool { S = "astrip" }
tool_aslod = simple_tool { S = "aslod" }
tool_aelflod = simple_tool { S = "aelflod" }
-- Revision history
-- $Log$
-- Revision 1.3 2007-04-23 23:40:10 dtrg
-- Added the aelflod tool for generating ELF executables. Added documentation for aelflod and ashow. Now installs the documentation when built.
--
-- Revision 1.2 2006/10/16 23:25:56 dtrg
-- Added support for anm, asize, ashow, astrip and the new aslod tool.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.

31
util/arch/pmfile
View file

@ -1,31 +0,0 @@
-- $Source$
-- $State$
local d = "util/arch/"
tool_aal = cprogram {
CDEFINES = {PARENT, "AAL"},
cfile (d.."archiver.c"),
lib_print,
lib_string,
lib_system,
lib_object,
install = {
pm.install("%BINDIR%bin/aal"),
pm.install(d.."aal.1", "%BINDIR%man/man1/aal.1")
}
}
-- Revision history
-- $Log$
-- Revision 1.3 2006-10-15 00:28:12 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.2 2006/07/30 23:45:35 dtrg
-- Modified to install aal's manpage.
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

59
util/ceg/as_parser/pmfile
View file

@ -1,59 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."util/ceg/as_parser/"
local lpars = LLgen {
file (d.."pars.g")
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
lpars
}
}
tool_ceg_as_parser = cprogram {
CDEFINES = {PARENT, "FLEX"},
CLIBRARIES = {PARENT, "fl"},
cfile_with_headers (d.."conversion.c"),
cfile_with_headers (d.."help.c"),
cfile_with_headers {
flex {
file (d.."table.l")
}
},
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
lib_alloc,
lib_print,
lib_string,
lib_system,
outputs = {"%U%/as_parser"},
install = pm.install(BINDIR.."%PLATDEP%/ceg/as_parser/as_parser"),
}
tool_ceg_as_parser_eval = cprogram {
cfile (d.."eval/eval.c"),
outputs = {"%U%/eval"},
install = pm.install(BINDIR.."%PLATDEP%/ceg/as_parser/eval"),
}
-- Revision history
-- $Log$
-- Revision 1.2 2006-10-15 00:28:11 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.1 2006/07/20 23:18:18 dtrg
-- First version in CVS.
--

20
util/ceg/assemble/pmfile
View file

@ -1,20 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."util/ceg/assemble/"
tool_ceg_assemble = group {
install = {
pm.install(d.."as_assemble/assemble.c", BINDIR..PLATDEP.."/ceg/assemble/as_assemble/assemble.c"),
pm.install(d.."as_assemble/block_as.c", BINDIR..PLATDEP.."/ceg/assemble/as_assemble/block_as.c"),
pm.install(d.."obj_assemble/assemble.c", BINDIR..PLATDEP.."/ceg/assemble/obj_assemble/assemble.c"),
pm.install(d.."obj_assemble/block_as.c", BINDIR..PLATDEP.."/ceg/assemble/obj_assemble/block_as.c"),
pm.install(d.."obj_assemble/const.h", BINDIR..PLATDEP.."/ceg/assemble/obj_assemble/const.h"),
}
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:19 dtrg
-- First version in CVS.
--

89
util/ceg/ce_back/pmfile
View file

@ -1,89 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."util/ceg/ce_back/"
local function installmany(srcroot, destroot, list)
local o = {}
for _, i in ipairs(list) do
table.insert(o, pm.install(srcroot..i, destroot..i))
end
return o
end
tool_ceg_assemble = group {
install = installmany(d, BINDIR.."%PLATDEP%/ceg/ce_back/",
{
"as_back/back.h",
"as_back/bottom.c",
"as_back/bss.c",
"as_back/con1.c",
"as_back/con2.c",
"as_back/con4.c",
"as_back/do_close.c",
"as_back/do_open.c",
"as_back/end_back.c",
"as_back/gen1.c",
"as_back/gen2.c",
"as_back/gen4.c",
"as_back/header.h",
"as_back/init_back.c",
"as_back/reloc1.c",
"as_back/reloc2.c",
"as_back/reloc4.c",
"as_back/rom1.c",
"as_back/rom2.c",
"as_back/rom4.c",
"as_back/set_global.c",
"as_back/set_local.c",
"as_back/switchseg.c",
"as_back/symboldef.c",
"as_back/text1.c",
"as_back/text2.c",
"as_back/text4.c",
"as_back/dbsym.c",
"obj_back/back.h",
"obj_back/con2.c",
"obj_back/con4.c",
"obj_back/data.c",
"obj_back/data.h",
"obj_back/do_close.c",
"obj_back/do_open.c",
"obj_back/end_back.c",
"obj_back/extnd.c",
"obj_back/gen1.c",
"obj_back/gen2.c",
"obj_back/gen4.c",
"obj_back/hash.h",
"obj_back/header.h",
"obj_back/init_back.c",
"obj_back/label.c",
"obj_back/memory.c",
"obj_back/misc.c",
"obj_back/output.c",
"obj_back/reloc1.c",
"obj_back/reloc2.c",
"obj_back/reloc4.c",
"obj_back/relocation.c",
"obj_back/rom2.c",
"obj_back/rom4.c",
"obj_back/set_global.c",
"obj_back/set_local.c",
"obj_back/switchseg.c",
"obj_back/symboldef.c",
"obj_back/symtable.c",
"obj_back/text2.c",
"obj_back/text4.c",
"obj_back/common.c",
"obj_back/dbsym.c",
})
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:19 dtrg
-- First version in CVS.
--

21
util/ceg/pmfile
View file

@ -1,21 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."util/ceg/"
include (d.."as_parser/pmfile")
include (d.."assemble/pmfile")
include (d.."ce_back/pmfile")
tool_ceg = group {
tool_ceg_as_parser,
tool_ceg_as_parser_eval,
tool_ceg_assemble,
tool_ceg_ce_back,
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:18:18 dtrg
-- First version in CVS.
--

54
util/cgg/pmfile
View file

@ -1,54 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."util/cgg/"
local yacc_bootgram = yacc {
file (d.."bootgram.y")
}
tool_cgg = cprogram {
cfile (d.."main.c"),
cfile {
CINCLUDES = {PARENT, d},
yacc_bootgram,
},
cfile {
CINCLUDES = {PARENT, d},
flex {
file (d.."bootlex.l")
},
dynamicheaders = yacc_bootgram
},
CLIBRARIES = {PARENT, "fl"},
lib_em_data,
lib_assert,
lib_system,
install = pm.install(TOOLDIR.."cgg")
}
cgg = simple {
class = "cgg",
outputs = {"%U%/tables.c", "%U%/tables.h"},
command = {
"cd %out[1]:dirname% && (%BINDIR%%PLATDEP%/cpp -P -I%CGGINCLUDEDIR% %in% | %TOOLDIR%cgg)",
},
}
-- Revision history
-- $Log$
-- Revision 1.3 2006-10-15 00:28:12 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.2 2006/07/22 20:58:27 dtrg
-- cpp now gets installed in the right place.
--
-- Revision 1.1 2006/07/20 23:21:17 dtrg
-- First version in CVS.
--

25
util/cmisc/pmfile
View file

@ -1,25 +0,0 @@
-- $Source$
-- $State$
local d = "util/cmisc/"
tool_tabgen = cprogram {
cfile (d.."tabgen.c"),
outputs = {"%U%/tabgen"},
install = pm.install(TOOLDIR.."tabgen")
}
tabgen = simple {
class = "tabgen",
outputs = {"%U%-char.c"},
command = {
"%TOOLDIR%tabgen -f%in[1]% > %out[1]%"
},
}
-- Revision history
-- $Log$
-- Revision 1.1 2006-07-20 23:21:17 dtrg
-- First version in CVS.
--

123
util/cpp/pmfile
View file

@ -1,123 +0,0 @@
-- $Source$
-- $State$
local d = ROOTDIR.."util/cpp/"
local extract_parameters = simple {
outputs = {
"%U%/pathlength.h",
"%U%/errout.h",
"%U%/idfsize.h",
"%U%/numsize.h",
"%U%/nparams.h",
"%U%/ifdepth.h",
"%U%/lapbuf.h",
"%U%/strsize.h",
"%U%/botch_free.h",
"%U%/debug.h",
"%U%/parbufsize.h",
"%U%/textsize.h",
"%U%/inputtype.h",
"%U%/obufsize.h",
"%U%/dobits.h",
"%U%/line_prefix.h",
},
command = {
"cd %out[1]:dirname% && %in[1]% %in[2]%"
},
file (d.."make.hfiles"),
file (d.."Parameters")
}
local lpars = LLgen {
simple {
outputs = {"%U%/tokenfile.g"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokfile"),
file (d.."tokenname.c")
},
file (d.."expression.g")
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
file (d),
extract_parameters,
lpars
}
}
tool_cpp = cprogram {
cfile_with_headers (d.."LLlex.c"),
cfile_with_headers (d.."LLmessage.c"),
cfile_with_headers (d.."ch7bin.c"),
cfile_with_headers (d.."ch7mon.c"),
cfile_with_headers (d.."domacro.c"),
cfile_with_headers (d.."error.c"),
cfile_with_headers (d.."idf.c"),
cfile_with_headers (d.."init.c"),
cfile_with_headers (d.."input.c"),
cfile_with_headers (d.."main.c"),
cfile_with_headers (d.."options.c"),
cfile_with_headers (d.."preprocess.c"),
cfile_with_headers (d.."replace.c"),
cfile_with_headers (d.."scan.c"),
cfile_with_headers (d.."skip.c"),
cfile_with_headers (d.."tokenname.c"),
cfile_with_headers (d.."next.c"),
cfile_with_headers (d.."expr.c"),
foreach {
rule = cfile_with_headers,
ith { lpars, from=2 }
},
cfile_with_headers {
simple {
outputs = {"%U%-symbol2str.c"},
command = {
"%in[1]% < %in[2]% > %out[1]%"
},
file (d.."make.tokcase"),
file (d.."tokenname.c")
}
},
cfile_with_headers {
CINCLUDES = {PARENT, d},
tabgen (d.."char.tab")
},
lib_assert,
lib_print,
lib_alloc,
lib_system,
lib_string,
outputs = {"%U%/cpp"},
install = {
pm.install("%BINDIR%%PLATDEP%/cpp"),
pm.install(d.."cpp.6", "%BINDIR%man/man6/cpp.6")
}
}
-- Revision history
-- $Log$
-- Revision 1.4 2006-10-15 00:28:11 dtrg
-- Updated to the version 0.1 of Prime Mover (which involves some syntax changes).
--
-- Revision 1.3 2006/07/22 20:58:27 dtrg
-- cpp now gets installed in the right place.
--
-- Revision 1.2 2006/07/22 12:27:31 dtrg
-- Removed a huge, ancient comment dating from the genmake days.
--
-- Revision 1.1 2006/07/20 23:24:28 dtrg
-- First version in CVS.

57
util/data/pmfile
View file

@ -1,57 +0,0 @@
-- $Source$
-- $State$
local d = "util/data/"
local datafiles = simple {
outputs = {
"%U%/em_spec.h",
"%U%/em_pseu.h",
"%U%/em_mnem.h",
"%U%/em_flag.c",
"%U%/em_pseu.c",
"%U%/em_mnem.c"
},
command = {
"%in[1]% %in[2]% %out[1]:dirname% %out[1]:dirname%"
},
install = {
pm.install("%U%/em_spec.h", "%HEADERDIR%em_spec.h"),
pm.install("%U%/em_pseu.h", "%HEADERDIR%em_pseu.h"),
pm.install("%U%/em_mnem.h", "%HEADERDIR%em_mnem.h")
},
file (d.."new_table"),
file ("%ROOTDIR%h/em_table"),
}
local cfile_with_headers = cfile {
class = "cfile_with_headers",
dynamicheaders = {
datafiles,
}
}
module_em_data = clibrary {
cfile_with_headers (d.."em_ptyp.c"),
foreach {
rule = cfile_with_headers,
ith { datafiles, from=4 }
},
outputs = {"%U%/libem_data.a"},
install = pm.install("%LIBDIR%libem_data.a")
}
lib_em_data = file "%LIBDIR%libem_data.a"
-- Revision history
-- $Log$
-- Revision 1.2 2007-02-25 12:49:04 dtrg
-- new_table is now in /util/data, not /etc.
--
-- Revision 1.1 2006/07/20 23:24:28 dtrg
-- First version in CVS.
--

Some files were not shown because too many files have changed in this diff Show more