mcode-0.6.0/ 40775 764 764 0 7002102251 11225 5 ustar steve steve mcode-0.6.0/mlib/ 40775 764 764 0 7002102251 12150 5 ustar steve steve mcode-0.6.0/mlib/c/ 40775 764 764 0 7002102251 12372 5 ustar steve steve mcode-0.6.0/mlib/c/README 100664 764 764 210 6715540134 13340 0 ustar steve steve These files implement a set of tags for writing C programs. Everything
is based on base.py and the other output types inherit from it.
mcode-0.6.0/mlib/c/__init__.py 100664 764 764 110 6715540134 14570 0 ustar steve steve # Do not remove this file it is needed in order to do
# import Dir.foo
mcode-0.6.0/mlib/c/base.py 100664 764 764 16550 7000175471 14016 0 ustar steve steve #
# Prototype section definition class
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
import os
import proto.base
import ostream, cmds
import mcode, options
#
# This is a prototype definition file for C source files.
# The class is not designed to be used directly, it is subclassed to
# produce the required output type.
#
# It implements the following tags:
"""
>>name name [ section ]
Anything here is copyright text
>>description
You can have documentation that applies to the whole file
rather than individual functions here.
>>extern
code that is outside of any function, for example inludes, defines
and declarations etc.
>>function name
return-type
type arg1; Description of arg1
...
>>description
decumentation for the function
>>code
The code for the function
"""
#
import expr, string
import ccmds, cmds
import util
from util import fatal
class base(proto.base.base):
comment_strings = ('','','') # Need to be overriden as appropriate
# A list of all 'empty' tags, ie those that do not end or start a section
empty = ("set", "unset", "header", "target", "make")
# Container tags. This is a set of (TAG, (TAG-LIST)).
# If the current tag is TAG, then any tag that is not in TAG-LIST (and
# is not in empty) will end TAG. For the case when no tag is open
# only the TAG-LIST corresponding to the TAG "" can appear.
containers = [
[None, ["name", "function", "extern", "headerdef"]],
["function", ["description", "code"]],
]
#The project defined headers.
proj_headers = []
proj_headers_last = []
def __init__(self):
self.headers = []
self.headerdefs = []
self.functions = []
self.D_headerdef = util.Section()
self.D_headerdef.need_decl = 0
self.D_headerdef.functions = []
# The tags defined by this class, the ones beginning B_ are for
# start tags and the ones beginning E_ are for implied end tags.
# The name. Followed by a name and an optional section
def B_name(self, m, args):
ostream.delete("copyright")
try:
self.name = args[0]
m.setvar('name', args[0])
except IndexError:
fatal("No name given on name line")
if len(args) > 1:
self.section = args[1]
m.setvar('section', args[1])
self.func_num = 0
s = ostream.open("copyright")
m.pushoutput(s)
m.filters = [ cmds.line_out ]
# A header file
def B_header(self, m, args):
# Save in list, make sure no duplicates
for h in args:
if h and not h in self.headers:
self.headers.append(h)
"""
# Get the base name of the header
(dir, name) = os.path.split(h)
if dir == "" and name[0] != '<':
dir = util.getconfig("HEADERDEF_DIR") % {
"top": util.gettop()
}
self.headers.append(os.path.join(dir, name))
"""
def B_headerdef(self, m, args):
hdefopts = [
{options.NAME: "decls",
options.FLAG: "d",
options.LONG: "decls",
},
{options.NAME: "local",
options.FLAG: "l",
options.LONG: "local",
},
]
op = options.Options(hdefopts)
op.process_args(args, "headerdef")
filelist = op.get_file_list()
filename = filelist[0]
if filelist is None or len(filelist) < 1:
raise mcode.error, "No filename supplied for headerdef"
filename = filelist[0]
# Get the base name of the header
(dir, name) = os.path.split(filename)
if dir == "" and not op.get_option("local"):
dir = util.getconfig("HEADERDEF_DIR") % {"top": util.gettop()}
if op.get_option("decls"):
self.D_headerdef.decl_file = os.path.join(dir, name)
self.D_headerdef.need_decl = 1
# Add to the list of generated header for this file.
# We also note if this section is continuing a previous
# definition of the header.
try:
if (dir, name) in self.D_headerdef.genhfiles:
self.D_headerdef.iscontinuation = 1
else:
self.D_headerdef.genhfiles.append( (dir, name) )
self.D_headerdef.iscontinuation = 0
except AttributeError:
self.D_headerdef.genhfiles = [(dir, name)]
self.D_headerdef.iscontinuation = 0
# Now add the header so that we get it ourselves.
self.B_header(m, [name])
self.D_headerdef.currhfile = (dir, name)
# The beginning of a function. Takes the function name
def B_function(self, m, args):
if len(args) < 1:
raise mcode.error, "Missing function name"
m.setvar("func_name", args[0]) # Or should we use vars?
# Create vars to keep track of function arguments
m.func_return = None
m.args = []
m.filters = [ ccmds.cdefextract ]
def B_description(self, m, args):
m.filters = [cmds.dotformat]
def B_code(self, m, args):
m.setvar("func_type", m.func_return)
pass
def B_extern(self, m, args):
pass
def B_set(self, m, args):
# set name value [...]
# Get the list on the value side, if there is exactly one item
# in the list and it is a string, then that string is the value
# otherwise we evaluate the list as an expression.
name = args[0]
vallist = args[1:]
if len(vallist) == 1 and type(vallist[0]) == type(""):
m.setvar(name, vallist[0])
else:
m.setvar(name, expr.expr(m, vallist))
def B_unset(self, m, args):
m.unsetvar(args[0])
def B_target(self, m, args):
pass
def B_make(self, m, args):
pass
def E_name(self, m):
pass
def E_function(self, m):
fn = {}
if m.func_return is None:
m.func_return = "void"
fn['return'] = m.func_return;
fn['args'] = m.args;
fn['name'] = m.getvar("func_name");
self.current_func = fn
self.functions.append(fn)
if self.D_headerdef.need_decl:
self.D_headerdef.functions.append(fn)
# Start the new header with the copyright, taken from the dot-m
# file.
def write_copyright(self, m, cstrings=None, descrip=None):
if cstrings is None:
cstrings = self.comment_strings
cr = ostream.open("copyright")
m.ostream.write(cstrings[0] + '\n')
for line in cr.readlines():
if descrip:
x = string.find(line, "File: ")
if x >= 0:
line = line[:x] + descrip
m.ostream.write(cstrings[1] + line+'\n')
m.ostream.write(cstrings[2] + '\n')
def end_file(self, m, name):
proto.base.base.end_file(self, m, name)
self.D_headerdef.need_decl = 0
def U_format_func(self, fn, func_dec=0):
"""Returns the given function formated as a string to fit
nicely on an 80 column screen
"""
str = fn['return']
if str is None: return ""
if str[-1:] != '*':
str = str + ' '
if func_dec:
str = str + '\n'
str = str + fn['name'] + '('
# The output position is the length of the last line.
l = string.split(str, '\n')
outpos = len(l[len(l)-1])
sep = ''
if fn['args']:
for a in fn['args']:
if a.has_key('stdarg'):
s = "..."
else:
s = a['decl']
if outpos + len(s) > 75:
str = str + sep + '\n ' + s
outpos = 8 + len(s)
else:
str = str + sep + s
outpos = outpos + len(s + sep)
sep = ', '
else:
str = str + "void"
str = str + ')'
return str
def U_findheader(self, name):
hdir = util.getconfig("HEADERDEF_DIR") % {
"top": util.gettop()
}
dirlist = [".", hdir]
for d in dirlist:
if os.access(os.path.join(d, name), os.F_OK):
return os.path.join(d, name)
return None
mcode-0.6.0/mlib/c/ccmds.py 100664 764 764 3656 6725737373 14202 0 ustar steve steve #
# Useful functions for formats based around C code
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
import mcode
import re
import string
re_name = re.compile(r"^.*[ \t][*(]*([a-zA-Z0-9_]+)\)?((\[.*\])??|(\(.*\))??)[ \t]*$")
re_space = re.compile("[ \t]+")
# Function to extract C function definitions.
def cdefextract(m, line):
# If this is the first then it is the return type
if m.func_return is None:
m.func_return = string.strip(line)
return
line = string.strip(line)
if not line:
return
# Otherwise could be an argument definition
try:
d = {}
# First get out the declaration, everything before the semi-colon
if line[0:3] == "...":
d['stdarg'] = 1
semi = 3
else:
try:
semi = string.index(line, ';')
except ValueError:
raise mcode.error, "There is no semicolon to end declaration"
decl = line[:semi]
d['decl'] = re_space.sub(' ', decl)
n = string.count(decl, '(')
if n > 1:
i = string.index(decl, '(')
i = string.index(decl, '(', i+1)
decl = decl[:i]
name = re_name.search(decl)
if name:
d['name'] = name.group(1)
if m.options.debug>0:
print "== decl='%s', name='%s'" % (decl, name.group(1))
else:
d['name'] = ''
# The comment is everything after
comment = string.strip(line[semi+1:])
# If started with // then strip that off
if comment[:2] == "//":
comment = comment[2:]
d['comment'] = string.strip(comment)
# m.args must have been created or else this will silently fail
m.args.append(d)
except AttributeError, msg:
pass
mcode-0.6.0/mlib/c/code.py 100664 764 764 10777 7000175471 14023 0 ustar steve steve #
# Prototype section definition class
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
from base import base
from cmds import *
import ostream, options
# Allow the use of super
global super
super = base
class code(super):
comment_strings = ('/*', ' * ', ' */')
def __init__(self):
super.__init__(self)
def begin(self, m):
self.obody = ostream.open("body")
self.oextern = ostream.open("extern")
self.oextern2 = ostream.open("extern2")
# Include the project defined headers
self.B_header(m, self.proj_headers)
def begin_file(self, m, name):
extra_headers = util.getconfig("COMM_HEADERS")
if extra_headers:
hl = string.split(extra_headers)
self.B_header(m, hl)
def B_description(self, m, args):
super.B_description(self, m, args)
desc = ostream.open("description", type='text')
desc.set_linelen(50)
desc.set_prefix(self.comment_strings)
desc.begin()
m.pushoutput(desc)
m.filters.append(expand)
m.filters.append(line_out)
def B_code(self, m, args):
super.B_code(self, m, args)
m.pushoutput(ostream.open("code"))
self.U_code_setoutline(m)
m.filters.append(expand)
m.filters.append(line_out)
def B_extern(self, m, args):
super.B_extern(self, m, args)
extopts = [
{options.NAME: "after",
options.FLAG: "a",
options.LONG: "after",
},
]
op = options.Options(extopts)
op.process_args(args, "extern")
if op.get_option("after"):
m.pushoutput(self.oextern2)
else:
m.pushoutput(self.oextern)
self.U_code_setoutline(m)
m.filters.append(expand)
m.filters.append(line_out)
def E_extern(self, m):
m.pushoutput(self.oextern)
self.U_code_setoutline(m, 1)
m.popoutput()
# End tags do not have arguments as they do not actually appear in the
# file.
def E_description(self, m):
# Write out the argument descriptions. If none given
# then nothing is written out, so has to be saved to
# strings first
#
astr = []
for a in m.args:
if a["comment"]:
astr.append(" %-9s - %s\n" % (a["name"], a["comment"]))
if astr:
m.ostream.write(" \n");
m.ostream.write(" Arguments:\n");
for as in astr:
m.ostream.write(as);
m.ostream.end()
m.popoutput()
def E_function(self, m):
super.E_function(self, m)
# Add the saved comment
desc = ostream.open("description", type='text')
ostream.appendfile(self.obody, desc)
# Add the function start
self.obody.write(self.U_format_func(self.current_func, func_dec=1))
self.obody.write('\n{\n')
# Add the saved code
code = ostream.open("code")
ostream.appendfile(self.obody, code)
m.pushoutput(self.obody)
self.U_code_setoutline(m, 1)
m.popoutput()
self.obody.write("}\n\n")
ostream.delete("description")
ostream.delete("code")
def E_headerdef(self, m):
#super.E_headerdef(self, m)
m.pushoutput(self.obody)
self.U_code_setoutline(m, 1)
m.popoutput()
def end(self, m):
# Add headers that should come last
self.B_header(m, self.proj_headers_last)
m.pushoutput(m.output)
self.write_copyright(m)
m.popoutput()
#cr = ostream.open("copyright")
#try: ostream.appendfile(m.output, cr)
#except: pass
m.output.write('\n\n')
# Do the headers
try:
for h in self.headers:
if h is None:
m.output.write("\n")
continue
if h[0] != '<':
h = '"' + h + '"'
m.output.write('#include %s\n' % h)
except AttributeError:
pass
m.output.write('\n')
ostream.appendfile(m.output, self.oextern)
m.output.write('\n')
try:
# Now do the static functions
m.output.write("/* Static functions */\n");
for fn in self.functions:
if fn['return'][:6] == "static":
m.output.write(self.U_format_func(fn))
m.output.write(";\n")
except AttributeError:
pass
# Now the second extern section
m.output.write('\n')
ostream.appendfile(m.output, self.oextern2)
m.output.write('\n')
ostream.appendfile(m.output, self.obody)
# Internal use functions
def U_code_setoutline(self, m, end=0):
try:
junk = m.vars['srclines']
if end > 0:
offset = -1
else:
offset = 1
if m.lineno:
m.ostream.write('#line %d "%s"\n' % (m.lineno+offset,
m.istream.name))
except:
pass
mcode-0.6.0/mlib/c/default.py 100664 764 764 1253 6715540135 14507 0 ustar steve steve #
# Prototype section definition class
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# This is the default if no format type is specified
# It just inherits directly from code which is the default.
#
from code import code
class default(code):
pass
mcode-0.6.0/mlib/c/header.py 100664 764 764 3616 6720077113 14315 0 ustar steve steve #
# File: header.py - Create header files from a set of M files.
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
import string
import util, mcode, cmds
import c.base
super=c.base.base
class header(c.base.base):
# Comment strings for header files.
comment_strings = ('/*',' * ',' */')
def __init__(self):
super.__init__(self)
self.D_headerdef = util.Section()
self.D_headerdef.decl_file = None
self.D_headerdef.need_decl = 0
self.D_headerdef.functions = []
def B_headerdef(self, m, args):
super.B_headerdef(self, m, args)
section = self.D_headerdef
(dir, name) = section.currhfile
try:
mode = 'w'
if self.D_headerdef.iscontinuation:
mode = 'a'
filename = dir+name
f = open(filename, mode)
except IOError:
raise mcode.error, "Could not open file " + filename
m.pushoutput(f)
m.filters = [cmds.expand, cmds.line_out]
if not section.iscontinuation:
descrip = "File: %s" % (name)
self.write_copyright(m, self.comment_strings, descrip)
def E_headerdef(self, m):
m.popoutput()
def end_file(self, m, name):
super.end_file(self, m, name)
# If decl_file is set then we should write out the non-static
# declarations to it.
if self.D_headerdef.decl_file is not None:
# Now do the non-static functions
f = open(self.D_headerdef.decl_file, "a")
for fn in self.D_headerdef.functions:
if fn['return'][:6] != "static":
f.write(self.U_format_func(fn))
f.write(";\n")
f.close()
self.D_headerdef.functions = []
mcode-0.6.0/mlib/c/make.py 100664 764 764 11063 7002075066 14014 0 ustar steve steve #
# File: make.py - make file generation for C code files
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
import c.base
import util
import options
# Separator for files in OBJECT list etc.
FILESEP = " \\\n "
####
## The skeleton makefile
MAKESKEL = """
TOP = %(top)s
include $(TOP)/make.conf
TARGETS = %(targets)s
OBJS = %(objs)s
GENCFILES = %(cfiles)s
GENHFILES = %(hfiles)s
%(objlists)s
# Build all the targets.
#
all: $(TARGETS) $(OBJS)
%(buildlines)s
install: all
%(install)s
# Remove all object files and exectutables
#
clean:
rm -f $(TARGETS) $(OBJS) core a.out
# Remove all generated and built files.
#
clobber: clean
rm -f $(GENCFILES) $(GENHFILES) Makefile
cfiles: $(GENCFILES)
hfiles headers:
mcode -f header *.m
.SUFFIXES: .m
.m.c:
mcode $(MCODEFLAGS) -o $@ $<
"""
### End of skeleton makefile
class make(c.base.base):
def __init__(self):
c.base.base.__init__(self)
self.D_make = util.Section()
self.D_make.mfiles = []
self.D_make.targets = []
self.D_make.depends = {}
self.D_make.objects = {}
def B_target(self, m, args):
self.D_make.target = args[0]
self.D_make.targets.append(args[0])
self.D_make.objects[self.D_make.target] = []
def B_make(self, m, args):
makeopts = [
{
options.NAME: "objects",
options.FLAG: "o",
options.LONG: "objects",
},
{
options.NAME: "libs",
options.FLAG: "l",
options.LONG: "libs",
},
]
op = options.Options(makeopts)
op.process_args(args, "headerdef")
filelist = op.get_file_list()
val = op.get_option("objects")
if val:
self.D_make.objects[self.D_make.target].append(filelist);
def end_file(self, m, args):
# Save this M file name
try:
self.D_make.mfiles.append(self.name)
except AttributeError:
import mcode
raise mcode.error("No name directive in one of the input files")
# Collect its dependancies
self.D_make.depends[self.name] = []
for h in self.headers:
hpath = self.U_findheader(h)
if hpath:
self.D_make.depends[self.name].append(hpath)
self.headers = []
def end(self, m):
#print self.D_make.mfiles
#print self.D_make.depends
if self.D_make.mfiles:
pass
self.U_make_cvsignore()
import sys, util, string
#print "TOP", util.gettop()
objs = []
cfiles = []
for mf in self.D_make.mfiles:
base = mf[:-2] # Stip the .m
objs.append(base + ".o")
cfiles.append(base + ".c")
objlists = []
targets = []
buildlines = []
for t in self.D_make.targets:
targets.append(t)
if t == []: continue
oline = string.upper(t) + "OBJS = "
for o in self.D_make.objects[t]:
oline = oline + " \\\n\t" + string.join(o, " ")
objlists.append(oline)
bl = t + ": $(" + string.upper(t) + "OBJS)\n"
bl = "%s: $(%sOBJS)\n" % (t, string.upper(t))
bl = bl + "\t$(CC) $(CFLAGS) -o %s $(%sOBJS) $(LIBS)\n" % (
t, string.upper(t))
buildlines.append(bl)
installlines = []
for t in self.D_make.targets:
l = "\t$(INSTALL) -s %s $(INSTDIR)" % (t)
installlines.append(l)
hfiles = []
try:
for (dir, name) in self.D_headerdef.genhfiles:
hfiles.append(dir+name)
except AttributeError:
pass
# Write out the makefile from the skeleton.
#
m.output.write(MAKESKEL % {
"top": util.gettop(),
"objs": string.join(objs, FILESEP),
"cfiles": string.join(cfiles, FILESEP),
"hfiles": string.join(hfiles, FILESEP),
"objlists": string.join(objlists, "\n\n"),
"targets": string.join(targets, FILESEP),
"buildlines": string.join(buildlines, "\n\n"),
"install": string.join(installlines, "\n"),
}
)
for targ in self.D_make.depends.keys():
for dep in self.D_make.depends[targ]:
if dep[0] == '<': continue
targ = targ[:-2] + ".o"
m.output.write("%s: %s\n" % (targ, dep))
# Utility routines start with a 'U' and the section name that
# they are belong to.
def U_make_cvsignore(self):
# This will have to be more complex for shared header file
# directories
cvsig = open(".cvsignore", "w")
for mf in self.D_make.mfiles:
cvsig.write(mf[:-2] + ".c\n")
for tg in self.D_make.targets:
cvsig.write(tg + '\n')
cvsig.write("Makefile\n")
cvsig.write("*.mdml *.mdml.gz *.mid\n") # XXX should not be here
cvsig.write(".cvsignore\n")
mcode-0.6.0/mlib/c/quickdoc.py 100664 764 764 10257 7002075066 14705 0 ustar steve steve #
# Prototype section definition class
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
from base import base
from cmds import *
import ostream, options
# Allow the use of super
global super
super = base
class quickdoc(super):
comment_strings = ('')
def __init__(self):
super.__init__(self)
def begin(self, m):
self.obody = ostream.open("body")
self.oextern = ostream.open("extern")
self.oextern2 = ostream.open("extern2")
self.oheaders = ostream.open("headers");
# Include the project defined headers
self.B_header(m, self.proj_headers)
def begin_file(self, m, name):
extra_headers = util.getconfig("COMM_HEADERS")
if extra_headers:
hl = string.split(extra_headers)
self.B_header(m, hl)
def B_description(self, m, args):
super.B_description(self, m, args)
desc = ostream.open("description", type='text')
desc.set_linelen(50)
# desc.set_prefix(self.comment_strings)
desc.begin()
m.pushoutput(desc)
m.filters.append(expand)
m.filters.append(fixsgml)
m.filters.append(line_out)
def B_code(self, m, args):
super.B_code(self, m, args)
def B_extern(self, m, args):
super.B_extern(self, m, args)
extopts = [
{options.NAME: "after",
options.FLAG: "a",
options.LONG: "after",
},
]
op = options.Options(extopts)
op.process_args(args, "extern")
if op.get_option("after"):
m.pushoutput(self.oextern2)
else:
m.pushoutput(self.oextern)
m.filters.append(expand)
m.filters.append(fixsgml)
m.filters.append(line_out)
def B_headerdef(self, m, args):
super.B_headerdef(self, m, args)
section = self.D_headerdef
(dir, name) = section.currhfile
m.pushoutput(self.oheaders)
m.filters.append(expand)
m.filters.append(fixsgml)
m.filters.append(line_out)
self.oheaders.write("Header file %s
\n" % name)
def E_headerdef(self, m):
m.popoutput()
# End tags do not have arguments as they do not actually appear in the
# file.
def E_description(self, m):
# Write out the argument descriptions. If none given
# then nothing is written out, so has to be saved to
# strings first
#
astr = []
for a in m.args:
if a["comment"]:
astr.append(" %-9s - %s\n" % (a["name"], a["comment"]))
if astr:
#m.ostream.write(" Arguments:\n");
for as in astr:
pass
#m.ostream.write(as);
m.ostream.end()
m.popoutput()
def E_function(self, m):
super.E_function(self, m)
rettype = self.current_func['return']
try:
nostatic = m.getvar("no-static")
except:
nostatic = 0
if nostatic and rettype[:6] == "static":
return
# Add the function start
self.obody.write("")
self.obody.write(self.U_format_func(self.current_func, func_dec=1))
self.obody.write("\n")
# Add the saved comment
desc = ostream.open("description", type='text')
ostream.appendfile(self.obody, desc)
ostream.delete("description")
def end(self, m):
# Add headers that should come last
self.B_header(m, self.proj_headers_last)
m.output.write('\n')
m.output.write('
Documentation\n')
m.output.write('\n');
m.output.write('\n')
m.output.write('\n');
m.pushoutput(m.output)
self.write_copyright(m)
m.popoutput()
m.output.write('\n\n')
m.output.write('File level definitions
')
m.output.write('')
ostream.appendfile(m.output, self.oextern)
# Now the second extern section
ostream.appendfile(m.output, self.oextern2)
# Header definitions
ostream.appendfile(m.output, self.oheaders)
m.output.write('\n')
m.output.write('Quick function reference
\n')
ostream.appendfile(m.output, self.obody)
m.output.write('\n')
mcode-0.6.0/mlib/__init__.py 100664 764 764 0 6715540134 14304 0 ustar steve steve mcode-0.6.0/mlib/proto/ 40775 764 764 0 7002102251 13313 5 ustar steve steve mcode-0.6.0/mlib/proto/__init__.py 100664 764 764 110 6715540135 15512 0 ustar steve steve # Do not remove this file it is needed in order to do
# import Dir.foo
mcode-0.6.0/mlib/proto/base.py 100664 764 764 5010 6717123527 14715 0 ustar steve steve #
# Prototype section definition class
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#
# This is a prototype definition file. This is an empty prototype class
# that provides just the required methods. It is to be expected that
# real format types would override many of these methods.
#
import copy
class base:
# A list of all 'empty' tags, ie those that do not end or start a section
empty = []
# Container tags. This is a set of (TAG, (TAG-LIST)).
# If the current tag is TAG, then any tag that is not in TAG-LIST (and
# is not in empty) will end TAG. For the case when no tag is open
# only the TAG-LIST corresponding to the TAG "" can appear.
containers = []
# A set of additional command line options that this format recognises
"""
# All apart from name are optional, although you should have one
# or both of 'flag' and 'long' set in each entry.
{
'name': "optionname", # The program name for this option
'flag': "c", # the flag on the command line (-c)
'arg': "file", # if the option takes an argument this must
# be set and names it for usage.
'long': "file-name" # a long option (--file-name)
'help_text': "Help string"
},
"""
extra_options = [ ]
# Called at the beginning of processing, could initialise the class
def begin(self, m):
pass
# Called at the beginning of a new file
def begin_file(self, m, name):
pass
# Called at the end of a file
def end_file(self, m, name):
pass
# Called after all files are processed. Should write the
# output.
def end(self, m):
pass
# This method will be called to give a chance for the class
# to modify its behaviour depending on the command line
# options in effect.
def set_options(self, opts):
self.options = opts
# Certain tags may want to override the action taken on a contained
# tag. You can do this by pushing the current set of definitions,
# setting the actions that you want, and then poping back the
# original set later.
#
def pushfuncs(self):
self._saved_atts = copy.copy(self.__dict__)
def popfuncs(self):
self.__dict__ = self._saved_atts
mcode-0.6.0/COPYING 100664 764 764 43105 7002102106 12377 0 ustar steve steve GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C) 19yy
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
mcode-0.6.0/ChangeLog 100664 764 764 13156 7002075161 13133 0 ustar steve steve 1999-10-16 Steve Ratcliffe
* mlib/c/make.py, mlib/c/quickdoc.py:
Diagnose the problem of not having a name directive.
quickdoc: allow to select if static functions are included.
1999-10-11 Steve Ratcliffe
* mlib/c/quickdoc.py: Change to a nicer colour background.
1999-10-10 Steve Ratcliffe
* mlib/c/base.py, mlib/c/code.py, ostream.py:
Improvements to the top of function comment. More consistant
spacing, no extra empty lines.
1999-10-03 Steve Ratcliffe
* mlib/c/make.py: add stripflags to install
* mlib/c/quickdoc.py: add style
1999-09-19 Steve Ratcliffe
* REL-1-5-0
* mlib/c/make.py: Installation targets are now created.
1999-08-19 Steve Ratcliffe
* cmds.py, mlib/c/make.py, mstate.py, vars.py:
Allow setting the escape char to something else
1999-08-11 Steve Ratcliffe
* mlib/c/base.py, mlib/c/code.py, mlib/c/make.py, cmds.py, expr.py, vars.py:
add unset, if function has no args it is declared (void).
Various bug fixes.
1999-07-25 Steve Ratcliffe
* mlib/c/code.py: Improved src line number feature
1999-07-24 Steve Ratcliffe
* cmds.py:
Added routine to deal with output to SGML. All special characters
are quoted.
* mlib/c/make.py: Clean up targets on a clean
* mlib/c/quickdoc.py: added
1999-07-22 Steve Ratcliffe
* mstate.py:
Fix finding of mlib.conf when called from a different directory.
Expand variables on section begin lines.
* ostream.py: Suppress blank lines at the end of functions
* mlib/c/code.py:
Don't print out argument descriptions that do not have an
associated comment.
* mlib/c/make.py: add headers target
1999-07-16 Steve Ratcliffe
* mlib/c/base.py, mlib/c/code.py, mlib/c/make.py, mstate.py, util.py:
Project header changes, makefile and extern.
1999-07-10 Steve Ratcliffe
* mlib/c/base.py, mlib/c/code.py, mlib/c/make.py:
After mostly working makefile generation
1999-06-04 Steve Ratcliffe
* ChangeLog: latest changes
* mlib/c/base.py, mlib/c/ccmds.py, mlib/c/code.py, mlib/c/make.py,
mcode.py, mstate.py, ostream.py, util.py:
Numerous changes to:
work in different directories to the code
Add argument descriptions to function header comment
Project configuration
* test/bar.m, test/m.m:
make test examples work with the new section names
1999-05-17 Steve Ratcliffe
* mlib/c/base.py, mlib/c/code.py, mlib/c/header.py:
Header def section tidied up
1999-05-16 Steve Ratcliffe
* ostream.py:
Allow simple formatting in descriptions. For example a blank
line will now appear in the comment and lines beginning with
white space will appear as-is in the output.
* mcode.py, mlib/c/base.py, mlib/c/code.py, mlib/c/header.py,
mlib/c/make.py, mstate.py, ostream.py, test/foo.m, util.py:
Further tidyups and modifications for project
configuration and makefile generation.
1999-05-14 Steve Ratcliffe
* mcode.py, mlib/c/base.py, mlib/c/code.py, mlib/proto/base.py,
mstate.py, util.py:
Updates for headerdef and project configuration
1999-05-11 Steve Ratcliffe
* vars.py: Give error on undefined variable. Not sure if this is the
correct thing to do or should it return empty string.
* mstate.py:
Tidied up the state transition code. It is now simpler to understand
and also now correctly detects and diagnoses element that are
not valid in the current context.
1999-05-10 Steve Ratcliffe
* mlib/c/base.py, mlib/c/code.py, mstate.py, options.py, util.py:
Fixed auto-generation of prototypes and cleaned
it up. Also fixed the annoying bug where end tags were immune to
Attribute errors
* mlib/c/base.py, mlib/c/ccmds.py, mlib/c/code.py,
mlib/c/default.py, mlib/proto/__init__.py, mlib/proto/base.py,
mlib/__init__.py, mlib/c/README, mlib/c/__init__.py:
Moved mcodelib to mlib
1999-05-09 Steve Ratcliffe
* mcodelib/C/base.py, mcodelib/C/code.py, mstate.py, ostream.py:
Clean up of the commenting character stuff
* mcodelib/C/code.py, mcode.py, options.py:
Allow the output of source line references
* mcodelib/C/base.py, mstate.py, ostream.py, util.py:
Changes to allow the creation of header files from
the dot-m file.
* mcodelib/C/base.py, mcodelib/C/code.py:
Auto static function declaration.
* mcodelib/C/base.py: The header is an empty command
* mcodelib/C/base.py, mcodelib/C/code.py: Add header section command.
Catch our own generated errors
* Makefile, Makefile.conf, mcode.py: Names in makefiles
Catch our own generated errors
* mstate.py:
Better error reporting including filename and line numbers.
1999-05-07 Steve Ratcliffe
* Makefile.conf: Config variables
* mcodelib/C/base.py, mcodelib/C/code.py, mcodelib/__init__.py, Makefile, mcode.py, util.py:
Changes to allow installation
1999-05-06 Steve Ratcliffe
* mcode.py: Trap keyboard interrupts
* options.py: Added symbolic names for the options description.
1999-04-29 Steve Ratcliffe
* expr.py: non-change for testing
1999-04-27 Steve Ratcliffe
* mstate.py: Unqualified method name fixed
* mcodelib/proto/__init__.py, mcodelib/proto/base.py, test/bar.m, test/foo.m, test/m.m, mcodelib/C/README, mcodelib/C/__init__.py, mcodelib/C/base.py, mcodelib/C/ccmds.py, mcodelib/C/code.py, mcodelib/C/default.py:
First versions
* Makefile, cmds.py, code.mi, copy, expr.py, mcode.py, mstate.py, options.py, ostream.py, tags.py, util.py, vars.py:
First version
mcode-0.6.0/Makefile 100664 764 764 444 6715305406 12765 0 ustar steve steve
include Makefile.conf
all:
install:
mkdir -p $(INSTDIR)
cp -r * $(INSTDIR)
python $(PYTHONDIR)/compileall.py $(INSTDIR)
chmod a+x $(INSTDIR)/mcode.py
if [ ! -f $(BINDIR)/mcode ]; then ln -s $(INSTDIR)/mcode.py $(BINDIR)/mcode;\
fi
clean:
find . -name '*.py[co]' -print | xargs rm
mcode-0.6.0/Makefile.conf 100664 764 764 162 6715305406 13706 0 ustar steve steve
PYTHONDIR = /usr/lib/python1.5
INSTDIR = $(PYTHONDIR)/site-packages/MCODE
BINDIR = /usr/local/bin
INSTALL = cp
mcode-0.6.0/README 100664 764 764 2746 7002102106 12212 0 ustar steve steve
This is mcode, a code/documentation generation system.
Written by Steve Ratcliffe
Project home page http://www.parabola.demon.co.uk/mcode/
See the file COPYING for licensing details.
Introduction
------------
This system is designed to make programming and its documentation a little
easier. It allows code, programming documentation, makefile information
and header file information to be stored in the same file. The mcode
program then generates makefiles and code files and documentation files.
It doesn't try to do anything too clever, I prefer to keep these
things simple or else they start to take over and become unintelligible
to anyone who hasn't seen them before.
It is designed to be configurable to different projects, each of which
may have completely different requirements. In general, mcode will be
especially useful where there is a lot of boiler-plate type code in
each file.
The project that I am using it for at present is Melys. It provides the
following functionality for this project:
- Generation of C files with nicely formatted comments at the
beginning of each function.
- Generation of files that include function prototypes.
- Automatic generation of static function prototypes within a
file.
- Quick reference documentation of the functions.
- Generation of the makefiles.
- Generation of code to create and copy a set of objects within
the program.
- Skeleton code for a gtk widget can be generated and quickly
filled in.
mcode-0.6.0/cmds.py 100664 764 764 5703 6756765667 12700 0 ustar steve steve #
# Commands that can be used in confuration files.
#
# Copyright (C) 1999 Steve Ratcliffe
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
#
# A bunch of filters that can be used by the formatting code.
# Each filter takes a m state argument and an input line. It returns
# the line, modified as appropriate. Return None to stop further
# processing.
#
import string
import util
from util import fatal, debug
# A simple filter that writes the line to the current output
# stream.
def line_out(m, line):
m.ostream.write(line)
# Characters that are allowed in variable names
var_chars = string.letters + "_" + string.digits
# Expand the variables in the line. A variable is like @varname or @{varname}
#
def expand(m, line):
escapechar = m.escapechar
if escapechar in line:
result = ''
restart = 0 # point at which to re-start scanning
llen = len(line)
while 1:
# Find the next '@' in the line
try:
start = string.index(line[restart:], escapechar) + 1
start = start+restart
except ValueError:
break
# Get the variable name. Two cases: @foo and @{foo}
i = 0; brace = 0
while start+i < llen:
c = line[start+i]
if i == 0 and c == '{':
brace = 1
start = start+1
if brace > 0:
if line[start+i] == '}':
end = start + i
i = i-1
break
else:
if line[start+i] not in var_chars:
end = start + i
break
i = i+1
# Exctract the name
name = line[start:end]
if name == escapechar:
val = escapechar
else:
val = m.getvar(name)
# Adjust for braces @{foo}
if brace:
end = end+1 # Need to step over the closing brace
start = start-1 # Need to step before the opening brace
# Replace the variable with its value
result = result + line[restart:start-1] + val
# Start scanning from end of this variable
restart = end
# Add the rest of the line and return the whole line
return result + line[end:]
else:
return line
# A function to recognise formatting instructions written as dot commands
# for example .A or .arg
#
def dotformat(m, line):
if len(line)>0 and line[0] == '.':
# This is just a very temp rendition
debug("Dotcmd:", line, level=2)
l = util.argsplit(line, conv=0)[1:]
return string.join(l)
else:
return line
# A function that fixes lines for sgml/html output. It deals with
# the characters '<' '&' etc in the line
#
def fixsgml(m, line):
result = ''
for c in line:
if c == '<':
c = "<"
elif c == '>':
c = ">"
elif c == '&':
c = "&"
elif c == '"':
c = """
result = result + c
return result
mcode-0.6.0/code.mi 100664 764 764 1123 6711331743 12600 0 ustar steve steve
>>%SECTION SET
@
>>%SECTION TITLE
@
@
>>%SECTION FUNCTION
@
@
@