RISCOS files by dschwertberger

13 files changed, 2607 insertions, 0 deletions

diff --git a/RISCOS/Makefile b/RISCOS/Makefile
new file mode 100644
index 0000000000..38973f0357
--- /dev/null
+++ b/RISCOS/Makefile
@@ -0,0 +1,418 @@
+# RISC OS Python
+LIBSROOT = $.AcornC_C++.Libraries
+
+# You may need to change some of the following
+OSLIB = $(LIBSROOT).OSLib
+CLIB = $(LIBSROOT).clib
+SOCKLIB = $(LIBSROOT).netlib
+DLKLIB = $(LIBSROOT).dlk
+ZLIB = $(LIBSROOT).zlib
+EXPAT = $(LIBSROOT).expat.lib
+
+OBJSCAN = $(DLKLIB).objscan
+MAKEDLK = $(DLKLIB).makedlk
+
+# change from time to time
+TARGET=Python21
+BUILD=10
+
+
+#
+# You shouldn't need to change anything below this line
+#
+OSLIBS = OSLib:Computer,OSLib:Core,OSLib:User
+
+DLKFLAG= -DDLK
+DLKOBJS = $(DLKLIB).o.dlk_load o.linktab
+
+HEADERS = @,@.^.Include,@.^.Modules,@.^.Objects,@.^.Python,$(CLIB),$(OSLIBS),$(DLKLIB)
+
+CC = cc -c -j$(HEADERS) $(DLKFLAG) -DRISCOS -DHAVE_CONFIG_H -wad -throwback
+#-depend !Depend
+CCEXPAT = cc -c -j$(HEADERS),$(EXPAT) $(DLKFLAG) -DHAVE_EXPAT_H -DRISCOS -DHAVE_CONFIG_H -wad -throwback
+
+LINK = link
+LINKFLAGS = -aif -NOUNUSED #-d
+LOADLIBS = $(CLIB).o.Stubs $(OSLIB).o.OSLib $(DLKOBJS)
+
+
+.c.o  :
+       $(CC) -o $@ $*.c
+
+
+# code for main Python binary
+MODULES_STATIC = \
+	@.^.Modules.o.python \
+	@.^.Modules.o.main \
+	Modules.o.config \
+	@.^.Modules.o.getbuildinfo \
+	Modules.o.getpath_riscos \
+	Modules.o.riscosmodule \
+	@.^.Modules.o._sre
+
+
+# dynamic Modules
+MODULES_DYNAMIC = \
+	@.^.Lib.array/pyd \
+	@.^.Lib.audioop/pyd \
+	@.^.Lib.binascii/pyd \
+	@.^.Lib.cmath/pyd \
+	@.^.Lib.cPickle/pyd \
+	@.^.Lib.cStringIO/pyd \
+	@.^.Lib.errno/pyd \
+	@.^.Lib.imageop/pyd \
+	@.^.Lib.math/pyd \
+	@.^.Lib.md5/pyd \
+	@.^.Lib.new/pyd \
+	@.^.Lib.operator/pyd \
+	@.^.Lib.parser/pyd \
+	@.^.Lib.pcre/pyd \
+	@.^.Lib.regex/pyd \
+	@.^.Lib.rgbimg/pyd \
+	@.^.Lib.rotor/pyd \
+	@.^.Lib.sha/pyd \
+	@.^.Lib.signal/pyd \
+	@.^.Lib.struct/pyd \
+	@.^.Lib.time/pyd \
+	@.^.Lib._locale/pyd \
+	@.^.Lib.zlib/pyd \
+	@.^.Lib.select/pyd \
+	@.^.Lib._socket/pyd \
+	@.^.Lib._codecs/pyd \
+	@.^.Lib._weakref/pyd \
+	@.^.Lib._testcapi/pyd \
+	@.^.Lib.unicodedata/pyd \
+	@.^.Lib.xreadlines/pyd \
+	@.^.Lib.pyexpat/pyd \
+	@.^.Lib.plat-riscos.drawf/pyd \
+	@.^.Lib.plat-riscos.swi/pyd
+
+	# @.^.Lib.soundex/pyd \
+	# leave  strop out? It's no longer in use for string operations
+	# @.^.Lib.mmap/pyd would it make sense? I read about a mmap
+	# implementation for RISC OS recently in usenet news.
+
+	#@.^.Lib.strop/pyd \
+	#@.^.Lib._sre/pyd \
+
+
+OBJECTS_PYTHON = \
+	@.^.Python.o.traceback \
+	@.^.Python.o.sysmodule \
+	@.^.Python.o.structmember \
+	@.^.Python.o.strdup \
+	@.^.Python.o.sigcheck \
+	@.^.Python.o.pythonrun \
+	@.^.Python.o.pystate \
+	@.^.Python.o.pyfpe \
+	@.^.Python.o.mystrtoul \
+	@.^.Python.o.modsupport \
+	@.^.Python.o.marshal \
+	@.^.Python.o.importdl \
+	@.^.Python.o.import \
+	@.^.Python.o.graminit \
+	@.^.Python.o.getversion \
+	@.^.Python.o.getplatform \
+	@.^.Python.o.getopt \
+	@.^.Python.o.getcopyright \
+	@.^.Python.o.getcompiler \
+	@.^.Python.o.getargs \
+	@.^.Python.o.frozenmain \
+	@.^.Python.o.frozen \
+	@.^.Python.o.errors \
+	@.^.Python.o.compile \
+	@.^.Python.o.ceval \
+	@.^.Python.o.bltinmodule \
+	@.^.Python.o.exceptions \
+	@.^.Python.o.hypot \
+	@.^.Python.o.codecs \
+	@.^.Python.o.symtable
+# @.^.Python.o.atof @.^.Python.o.strerror
+
+
+OBJECTS_RISCOS =  \
+	@.Python.o.dynload_riscos \
+	@.Python.o.getcwd_riscos \
+	@.Python.o.getmtime_riscos \
+	@.o.unixstuff
+
+
+OBJECTS_OBJECTS = \
+	@.^.Objects.o.typeobject \
+	@.^.Objects.o.tupleobject \
+	@.^.Objects.o.stringobject \
+	@.^.Objects.o.sliceobject \
+	@.^.Objects.o.rangeobject \
+	@.^.Objects.o.object \
+	@.^.Objects.o.moduleobject \
+	@.^.Objects.o.methodobject \
+	@.^.Objects.o.longobject \
+	@.^.Objects.o.listobject \
+	@.^.Objects.o.intobject \
+	@.^.Objects.o.funcobject \
+	@.^.Objects.o.frameobject \
+	@.^.Objects.o.floatobject \
+	@.^.Objects.o.fileobject \
+	@.^.Objects.o.dictobject \
+	@.^.Objects.o.complexobject \
+	@.^.Objects.o.cobject \
+	@.^.Objects.o.classobject \
+	@.^.Objects.o.cellobject \
+	@.^.Objects.o.bufferobject \
+	@.^.Objects.o.abstract \
+	@.^.Objects.o.unicodectype \
+	@.^.Objects.o.unicodeobject
+
+
+OBJECTS_PARSER = \
+	@.^.Parser.o.tokenizer \
+	@.^.Parser.o.printgrammar \
+	@.^.Parser.o.parsetok \
+	@.^.Parser.o.parser \
+	@.^.Parser.o.node \
+	@.^.Parser.o.myreadline \
+	@.^.Parser.o.metagrammar \
+	@.^.Parser.o.listnode \
+	@.^.Parser.o.intrcheck \
+	@.^.Parser.o.grammar1 \
+	@.^.Parser.o.grammar \
+	@.^.Parser.o.firstsets \
+	@.^.Parser.o.bitset \
+	@.^.Parser.o.acceler
+
+SUPPORT_FILES = @.^.!Boot @.^.!Run @.^.!Sprites @.^.!Sprites22 @.^.AddToPath
+
+OBJECTS = $(OBJECTS_PYTHON) $(OBJECTS_PARSER) $(MODULES_STATIC) $(OBJECTS_OBJECTS) $(OBJECTS_RISCOS)
+
+
+all: @.^.$(TARGET) $(MODULES_DYNAMIC) $(SUPPORT_FILES)
+
+@.^.Modules.o.getbuildinfo: @.^.Modules.c.getbuildinfo
+       $(CC) -DBUILD=$(BUILD) -o @.^.Modules.o.getbuildinfo @.^.Modules.c.getbuildinfo
+
+
+@.^.$(TARGET):  $(OBJECTS) o.linktab
+	$(LINK) -o @.^.$(TARGET) $(OBJECTS) $(LOADLIBS)
+
+
+#########################################################################
+# Support files
+@.^.!Boot: support.!Boot
+	copy support.!Boot @.^.!Boot ~C~VF
+	settype @.^.!Boot feb
+@.^.!Run:  support.!Run
+	copy support.!Run @.^.!Run ~C~VF
+	settype @.^.!Run feb
+@.^.!Sprites: support.!Sprites
+	copy support.!Sprites @.^.!Sprites ~C~VF
+	settype @.^.!Sprites ff9
+@.^.!Sprites22: support.!Sprites22
+	copy support.!Sprites22 @.^.!Sprites22 ~C~VF
+	settype @.^.!Sprites22 ff9
+@.^.AddToPath: support.AddToPath
+	copy support.AddToPath @.^.AddToPath ~C~VF
+	settype @.^.AddToPath ffc
+
+
+#########################################################################
+# Dynamic Modules
+#
+@.^.Lib.array/pyd: @.^.Modules.o.arraymodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.array/pyd -s s.linktab -o @.^.Modules.o.arraymodule -e initarray
+
+@.^.Lib.audioop/pyd: @.^.Modules.o.audioop # s.linktab
+	$(MAKEDLK) -d @.^.Lib.audioop/pyd -s s.linktab -o @.^.Modules.o.audioop -e initaudioop
+
+@.^.Lib.binascii/pyd: @.^.Modules.o.binascii s.linktab
+	$(MAKEDLK) -d @.^.Lib.binascii/pyd -s s.linktab -o @.^.Modules.o.binascii -e initbinascii
+
+@.^.Lib.cmath/pyd: @.^.Modules.o.cmathmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.cmath/pyd -s s.linktab -o @.^.Modules.o.cmathmodule -e initcmath
+
+@.^.Lib.cPickle/pyd: @.^.Modules.o.cPickle s.linktab
+	$(MAKEDLK) -d @.^.Lib.cPickle/pyd -s s.linktab -o @.^.Modules.o.cPickle -e initcPickle
+
+@.^.Lib.cStringIO/pyd: @.^.Modules.o.cStringIO s.linktab
+	$(MAKEDLK) -d @.^.Lib.cStringIO/pyd -s s.linktab -o @.^.Modules.o.cStringIO -e initcStringIO
+
+@.^.Lib.plat-riscos.drawf/pyd: Modules.o.drawfmodule #s.linktab
+	$(LINK) -aof -o Modules.o.drawflink Modules.o.drawfmodule $(OSLIB).o.OSLIB
+	$(MAKEDLK) -d @.^.Lib.plat-riscos.drawf/pyd -s s.linktab -o Modules.o.drawflink -e initdrawf
+
+@.^.Lib.errno/pyd: @.^.Modules.o.errnomodule #s.linktab
+	$(MAKEDLK) -d @.^.Lib.errno/pyd -s s.linktab -o @.^.Modules.o.errnomodule -e initerrno
+
+@.^.Lib.imageop/pyd: @.^.Modules.o.imageop s.linktab
+	$(MAKEDLK) -d @.^.Lib.imageop/pyd -s s.linktab -o @.^.Modules.o.imageop -e initimageop
+
+@.^.Lib.math/pyd: @.^.Modules.o.mathmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.math/pyd -s s.linktab -o @.^.Modules.o.mathmodule -e initmath
+
+@.^.Lib.mmap/pyd: @.^.Modules.o.mmapmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.mmap/pyd -s s.linktab -o @.^.Modules.o.mmapmodule -e initmmap
+
+@.^.Lib.md5/pyd: @.^.Modules.o.md5c @.^.Modules.o.md5module s.linktab
+	$(LINK) -aof -o @.^.Modules.o.md5link @.^.Modules.o.md5c @.^.Modules.o.md5module
+	$(MAKEDLK) -d @.^.Lib.md5/pyd -s s.linktab -o @.^.Modules.o.md5link -e initmd5
+
+@.^.Lib.new/pyd: @.^.Modules.o.newmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.new/pyd -s s.linktab -o @.^.Modules.o.newmodule -e initnew
+
+@.^.Lib.operator/pyd: @.^.Modules.o.operator s.linktab
+	$(MAKEDLK) -d @.^.Lib.operator/pyd -s s.linktab -o @.^.Modules.o.operator -e initoperator
+
+@.^.Lib.parser/pyd: @.^.Modules.o.parsermodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.parser/pyd -s s.linktab -o @.^.Modules.o.parsermodule -e initparser
+
+@.^.Lib.pcre/pyd: @.^.Modules.o.pcremodule @.^.Modules.o.pypcre s.linktab
+	$(LINK) -aof -o @.^.Modules.o.pcrelink @.^.Modules.o.pcremodule @.^.Modules.o.pypcre
+	$(MAKEDLK) -d @.^.Lib.pcre/pyd -s s.linktab -o @.^.Modules.o.pcrelink -e initpcre
+
+@.^.Lib.regex/pyd: @.^.Modules.o.regexmodule @.^.Modules.o.regexpr s.linktab
+	$(LINK) -aof -o @.^.Modules.o.regexlink @.^.Modules.o.regexmodule @.^.Modules.o.regexpr
+	$(MAKEDLK) -d @.^.Lib.regex/pyd -s s.linktab -o @.^.Modules.o.regexlink -e initregex
+
+@.^.Lib.rgbimg/pyd: @.^.Modules.o.rgbimgmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.rgbimg/pyd -s s.linktab -o @.^.Modules.o.rgbimgmodule -e initrgbimg
+
+@.^.Lib.rotor/pyd: @.^.Modules.o.rotormodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.rotor/pyd -s s.linktab -o @.^.Modules.o.rotormodule -e initrotor
+
+@.^.Lib.sha/pyd: @.^.Modules.o.shamodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.sha/pyd -s s.linktab -o @.^.Modules.o.shamodule -e initsha
+
+@.^.Lib.signal/pyd: @.^.Modules.o.signalmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.signal/pyd -s s.linktab -o @.^.Modules.o.signalmodule -e initsignal
+
+#@.^.Lib.soundex/pyd: @.^.Modules.o.soundex s.linktab
+#	$(MAKEDLK) -d @.^.Lib.soundex/pyd -s s.linktab -o @.^.Modules.o.soundex -e initsoundex
+
+@.^.Lib.strop/pyd: @.^.Modules.o.stropmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.strop/pyd -s s.linktab -o @.^.Modules.o.stropmodule -e initstrop
+
+@.^.Lib.struct/pyd: @.^.Modules.o.structmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.struct/pyd -s s.linktab -o @.^.Modules.o.structmodule -e initstruct
+
+@.^.Lib.plat-riscos.swi/pyd: Modules.o.swimodule s.linktab
+	$(LINK) -aof -o Modules.o.swilink Modules.o.swimodule $(OSLIB).o.OSLIB
+	$(MAKEDLK) -d @.^.Lib.plat-riscos.swi/pyd -s s.linktab -o Modules.o.swilink -e initswi
+
+@.^.Lib.time/pyd: @.^.Modules.o.timemodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.time/pyd -s s.linktab -o @.^.Modules.o.timemodule -e inittime
+
+@.^.Lib._locale/pyd: @.^.Modules.o._localemodule s.linktab
+	$(MAKEDLK) -d @.^.Lib._locale/pyd -s s.linktab -o @.^.Modules.o._localemodule -e init_locale
+
+@.^.Lib._sre/pyd: @.^.Modules.o._sre s.linktab
+	$(MAKEDLK) -d @.^.Lib._sre/pyd -s s.linktab -o @.^.Modules.o._sre -e init_sre
+
+@.^.Lib._codecs/pyd: @.^.Modules.o._codecsmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib._codecs/pyd -s s.linktab -o @.^.Modules.o._codecsmodule -e init_codecs
+
+@.^.Lib._weakref/pyd: @.^.Modules.o._weakref s.linktab
+	$(MAKEDLK) -d @.^.Lib._weakref/pyd -s s.linktab -o @.^.Modules.o._weakref -e init_weakref
+
+@.^.Lib._testcapi/pyd: @.^.Modules.o._testcapimodule s.linktab
+	$(MAKEDLK) -d @.^.Lib._testcapi/pyd -s s.linktab -o @.^.Modules.o._testcapimodule -e init_testcapi
+
+@.^.Lib.unicodedata/pyd: @.^.Modules.o.unicodedata s.linktab
+	$(MAKEDLK) -d @.^.Lib.unicodedata/pyd -s s.linktab -o @.^.Modules.o.unicodedata -e initunicodedata
+
+@.^.Lib.xreadlines/pyd: @.^.Modules.o.xreadlinesmodule s.linktab
+	$(MAKEDLK) -d @.^.Lib.xreadlines/pyd -s s.linktab -o @.^.Modules.o.xreadlinesmodule -e initxreadlines
+
+
+##@.^.Lib.mmap/pyd: @.^.Modules.o.mmapmodule s.linktab
+##	$(MAKEDLK) -d @.^.Lib.mmap/pyd -s s.linktab -o @.^.Modules.o.mmapmodule -e initmmap
+
+
+
+############################################################################
+# Dynamic Modules with other dependencies
+#
+@.^.Lib.select/pyd:  @.^.Modules.o.selectmodule s.linktab
+	$(LINK) -aof -o @.^.Modules.o.selectlink @.^.Modules.o.selectmodule $(SOCKLIB).o.socklib
+	$(MAKEDLK) -d @.^.Lib.select/pyd -s s.linktab -o @.^.Modules.o.selectlink -e initselect
+
+@.^.Modules.o.selectmodule: @.^.Modules.c.selectmodule
+	$(CC) -I$(SOCKLIB).include -o $@ @.^.Modules.c.selectmodule
+
+@.^.Lib._socket/pyd: @.^.Modules.o.socketmodule s.linktab 
+	$(LINK) -aof -o @.^.Modules.o._socketlink @.^.Modules.o.socketmodule $(SOCKLIB).o.inetlib $(SOCKLIB).o.unixlib $(SOCKLIB).o.socklib
+	$(MAKEDLK) -d @.^.Lib._socket/pyd -s s.linktab -o @.^.Modules.o._socketlink -e init_socket
+
+@.^.Modules.o.socketmodule: @.^.Modules.c.socketmodule
+	$(CC) -I$(SOCKLIB).include -o $@ @.^.Modules.c.socketmodule
+
+
+@.^.Lib.zlib/pyd: @.^.Modules.o.zlibmodule s.linktab
+	$(LINK) -aof -o @.^.Modules.o.zliblink @.^.Modules.o.zlibmodule $(ZLIB).zlib_lib
+	$(MAKEDLK) -d @.^.Lib.zlib/pyd -s s.linktab -o @.^.Modules.o.zliblink -e initzlib
+
+@.^.Modules.o.zlibmodule: @.^.Modules.c.zlibmodule
+	$(CC) -I$(ZLIB) -o $@ @.^.Modules.c.zlibmodule
+
+
+@.^.Lib.pyexpat/pyd: @.^.Modules.o.pyexpat s.linktab
+	$(LINK) -aof -o @.^.Modules.o.pyexpatlink @.^.Modules.o.pyexpat $(EXPAT).expat_lib
+	$(MAKEDLK) -d @.^.Lib.pyexpat/pyd -s s.linktab -o @.^.Modules.o.pyexpatlink -e initpyexpat
+
+@.^.Modules.o.pyexpat: @.^.Modules.c.pyexpat
+	$(CCEXPAT) -o $@ @.^.Modules.c.pyexpat
+
+
+##########################################################################
+
+o.linktab: s.linktab
+	ObjAsm s.linktab o.linktab
+
+s.linktab: $(OBJECTS)
+	$(OBJSCAN) -s s.linktab -o $(OBJECTS) $(clib).o.stubs
+
+
+clean:
+	create @.^.Objects.o.dummy
+	create @.^.Parser.o.dummy
+	create @.^.Modules.o.dummy
+	create o.dummy
+	create @.^.Python.o.dummy
+	create @.^.Lib.dummy/pyc
+	create @.^.Lib.dummy/pyo
+	create @.^.Lib.plat-riscos.dummy/pyc
+	create @.^.Lib.plat-riscos.dummy/pyo
+	create @.^.Lib.test.dummy/pyc
+	wipe @.^.Modules.o.* ~C ~V
+	wipe @.^.Objects.o.* ~C ~V
+	wipe @.^.Parser.o.* ~C ~V
+	wipe @.^.Python.o.* ~C ~V
+	wipe o.* ~C ~V
+	wipe @.^.Lib.*/pyc ~C~V
+	wipe @.^.Lib.*/pyo ~C~V
+	wipe @.^.Lib.plat-riscos.*/pyc ~C~V
+	wipe @.^.Lib.plat-riscos.*/pyo ~C~V
+	wipe @.^.Lib.test.*/pyc ~C~V
+
+rebuild: clean
+	create @.^.Lib.dummy/pyd
+	create @.^.$(TARGET)
+	create @.^.Lib.plat-riscos.dummy/pyd
+	create s.linktab
+	create o.linktab
+	wipe @.^.$(TARGET) ~C~V
+	wipe @.^.Lib.*/pyd ~C ~V
+	wipe @.^.Lib.plat-riscos.*/pyd ~C~V
+	wipe s.linktab ~C~V
+	wipe o.linktab ~C~V
+
+cdirs:
+	cdir @.Modules.o
+	cdir @.Python.o
+	cdir @.s
+	cdir @.o
+	cdir @.^.Python.o
+	cdir @.^.Parser.o
+	cdir @.^.Objects.o
+	cdir @.^.Modules.o
+
+
+# Dynamic dependencies:
diff --git a/RISCOS/Modules/config.c b/RISCOS/Modules/config.c
new file mode 100644
index 0000000000..75e056fd4d
--- /dev/null
+++ b/RISCOS/Modules/config.c
@@ -0,0 +1,68 @@
+/* -*- C -*- ***********************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI or Corporation for National Research Initiatives or
+CNRI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+While CWI is the initial source for this software, a modified version
+is made available by the Corporation for National Research Initiatives
+(CNRI) at the Internet address ftp://ftp.python.org.
+
+STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
+CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* Module configuration */
+
+/* !!! !!! !!! This file is edited by the makesetup script !!! !!! !!! */
+
+/* This file contains the table of built-in modules.
+   See init_builtin() in import.c. */
+
+#include "Python.h"
+
+
+/* -- ADDMODULE MARKER 1 -- */
+
+extern void PyMarshal_Init();
+extern void initimp();
+extern void initriscos();
+extern void initswi();
+
+struct _inittab _PyImport_Inittab[] = {
+
+	{"riscos", initriscos},
+
+/* -- ADDMODULE MARKER 2 -- */
+
+	/* This module "lives in" with marshal.c */
+	{"marshal", PyMarshal_Init},
+
+	/* This lives it with import.c */
+	{"imp", initimp},
+
+	/* These entries are here for sys.builtin_module_names */
+	{"__main__", NULL},
+	{"__builtin__", NULL},
+	{"sys", NULL},
+
+	/* Sentinel */
+	{0, 0}
+};
diff --git a/RISCOS/Modules/drawfmodule.c b/RISCOS/Modules/drawfmodule.c
new file mode 100644
index 0000000000..1ac4736582
--- /dev/null
+++ b/RISCOS/Modules/drawfmodule.c
@@ -0,0 +1,664 @@
+/* drawf  DrawFile functions */
+
+#include "h.os"
+#include "h.osfile"
+#include "h.drawfile"
+#include "Python.h"
+
+#include <limits.h>
+
+#define PyDrawF_Check(op) ((op)->ob_type == &PyDrawFType)
+#define HDRSIZE 40
+#define GRPHDRSIZE 36
+#define DRAWTYPE 0xaff
+#define NEXT(d) ((drawfile_object*)((char*)(d)+(d)->size))
+
+typedef struct
+{ PyObject_HEAD
+  drawfile_diagram *drawf;
+  int size; /*length in bytes*/
+  int nobjs;  /* no of objects */
+} PyDrawFObject;
+
+typedef struct dheader
+{  char tag [4];
+   int major_version;
+   int minor_version;
+   char source [12];
+   os_box bbox;
+} dheader;
+
+static PyObject *DrawFError; /* Exception drawf.error */
+static os_error *e;
+static PyTypeObject PyDrawFType;
+
+static dheader header=
+{ {'D','r','a','w'},
+  201,0,
+  {'P','y','t','h','o','n',' ',' ',' ',' ',' ',' '},
+  {INT_MAX,INT_MAX,INT_MIN,INT_MIN}
+};
+
+static PyObject *drawf_oserror(void)
+{ PyErr_SetString(DrawFError,e->errmess);
+  return 0;
+}
+
+static PyObject *drawf_error(char *s)
+{ PyErr_SetString(DrawFError,s);
+  return 0;
+}
+
+/* DrawFile commands */
+
+static void countobjs(PyDrawFObject *pd)
+{ int k=0,q;
+  drawfile_diagram *dd=pd->drawf;
+  drawfile_object *d=dd->objects;
+  char *end=(char*)dd+pd->size;
+  pd->nobjs=-1;
+  while((char*)d<end)
+  { k++;
+    q=d->size;
+    if(q<=0||q&3) return ;
+    d=NEXT(d);
+  }
+  if ((char*)d==end) pd->nobjs=k;
+}
+
+static drawfile_object *findobj(PyDrawFObject *pd,int n)
+{ drawfile_diagram *dd=pd->drawf;
+  drawfile_object *d=dd->objects;
+  for(;n>0;n--) d=NEXT(d);
+  return d;
+}
+
+static PyDrawFObject* new(int size)
+{ PyDrawFObject *b=PyObject_NEW(PyDrawFObject,&PyDrawFType);
+  if(!b) return NULL;
+  size+=HDRSIZE;
+  b->drawf=malloc(size);
+  if(!b->drawf)
+  { Py_DECREF(b);
+    return (PyDrawFObject*)PyErr_NoMemory();
+  }
+  b->size=size;
+  return b;
+}
+
+static void extend(os_box *b,os_box *c)
+{ if(b->x0>c->x0) b->x0=c->x0;
+  if(b->y0>c->y0) b->y0=c->y0;
+  if(b->x1<c->x1) b->x1=c->x1;
+  if(b->y1<c->y1) b->y1=c->y1;
+}
+
+static PyObject *DrawF_New(PyObject *self,PyObject *args)
+{ PyDrawFObject *b;
+  if(!PyArg_ParseTuple(args,"")) return NULL;
+  b=new(0);
+  if(!b) return NULL;
+  *((dheader*)b->drawf)=header;
+  b->nobjs=0;
+  return (PyObject *)b;
+}
+
+static PyObject *DrawF_Load(PyObject *self,PyObject *args)
+{ int size;
+  char *fname;
+  PyDrawFObject *b;
+  fileswitch_object_type ot;
+  if(!PyArg_ParseTuple(args,"s",&fname)) return NULL;
+  e=xosfile_read_no_path(fname,&ot,0,0,&size,0);
+  if(e) return drawf_oserror();
+  size-=HDRSIZE;
+  if(ot!=osfile_IS_FILE||size<0||size&3) return drawf_error("Bad draw file");
+  b=new(size);
+  if(!b) return NULL;
+  e=xosfile_load_stamped_no_path(fname,(byte*)(b->drawf),0,0,0,0,0);
+  if(e)
+  { Py_DECREF(b);
+    return drawf_oserror();
+  }
+  countobjs(b);
+  if(b->nobjs>=0) return (PyObject *)b;
+  Py_DECREF(b);
+  return drawf_error("Corrupt draw file");
+}
+
+
+static PyObject *DrawF_Save(PyDrawFObject *self,PyObject *arg)
+{ char *fname;
+  if(!PyArg_ParseTuple(arg,"s",&fname)) return NULL;
+  e=xosfile_save_stamped(fname,DRAWTYPE,
+  (byte*)(self->drawf),(byte*)(self->drawf)+self->size);
+  if (e) return drawf_oserror();
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *DrawF_Render(PyDrawFObject *self,PyObject *arg)
+{ int flags,trans,clip,flat;
+  if(!PyArg_ParseTuple(arg,"iiii",&flags,&trans,&clip,&flat)) return NULL;
+  e=xdrawfile_render((drawfile_render_flags)flags,self->drawf,self->size,
+  (os_trfm*)trans,(os_box*)clip,flat);
+  if(e) return drawf_oserror();
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *DrawF_Path(PyDrawFObject *self,PyObject *arg)
+{ PyObject *pl;
+  PyObject *dp=0;
+  os_colour fill;
+  os_colour outline;
+  int width,start=0;
+  drawfile_path_style style;
+  int size=40;
+  int n,i,element_count;
+  drawfile_diagram *diag;
+  drawfile_object *dobj;
+  drawfile_path *dpath;
+  draw_path *thepath;
+  draw_line_style line_style;
+  draw_dash_pattern *dash_pattern=0;
+  os_box *box;
+  long *pe;
+  if(!PyArg_ParseTuple(arg,"O!(iiii)|O!i",&PyList_Type,&pl,(int*)&fill,
+     (int*)&outline,&width,(int*)&style,&PyTuple_Type,&dp,&start)) return NULL;
+  if(dp)
+  { element_count=PyTuple_Size(dp);
+    size+=4*element_count+8;
+    style.flags|=drawfile_PATH_DASHED;
+  }
+  else style.flags&=~drawfile_PATH_DASHED;
+  n=PyList_Size(pl);
+  size+=4*n+8;
+  for(i=0;i<n;i++) if(!PyInt_Check(PyList_GetItem(pl,i))) size+=4;
+  diag=realloc(self->drawf,self->size+size);
+  if(!diag) return PyErr_NoMemory();
+  self->drawf=diag;
+  dobj=(drawfile_object*)((char*)diag+self->size);
+  dobj->type=drawfile_TYPE_PATH;
+  dobj->size=size;
+  dpath=&dobj->data.path;
+  self->size+=size;
+  self->nobjs++;
+  box=&dpath->bbox;
+  dpath->fill=fill;dpath->outline=outline;
+  dpath->width=width;dpath->style=style;
+  pe=(long*)&(dpath->path);
+  if(dp)
+  { dash_pattern=&(((drawfile_path_with_pattern*)dpath)->pattern);
+    dash_pattern->start=start;
+    dash_pattern->element_count=element_count;
+    for(i=0;i<element_count;i++)
+    { dash_pattern->elements[i]=(int)PyInt_AsLong(PyTuple_GetItem(dp,i));
+    }
+    pe+=element_count+2;
+  }
+  thepath=(draw_path*)pe;
+  *pe++=draw_MOVE_TO;
+  for(i=0;i<n;i++)
+  { PyObject *p=PyList_GetItem(pl,i);
+    if(PyInt_Check(p))
+      *pe++=PyInt_AsLong(p);
+    else
+    {
+      *pe++=PyInt_AsLong(PyTuple_GetItem(p,0));
+      *pe++=PyInt_AsLong(PyTuple_GetItem(p,1));
+    }
+  }
+  *pe=draw_END_PATH;
+  line_style.join_style=style.flags&3;
+  line_style.end_cap_style=(style.flags&3)>>2;
+  line_style.start_cap_style=(style.flags&3)>>4;
+  line_style.reserved=0;
+  line_style.mitre_limit=10;
+  line_style.start_cap_width=style.cap_width;
+  line_style.end_cap_width=style.cap_width;
+  line_style.start_cap_length=style.cap_length;
+  line_style.end_cap_length=style.cap_length;
+  e=xdraw_process_path(thepath,0x70000000,0,0,width,&line_style,dash_pattern,
+  (draw_output_path)((char*)box+0x80000000),0);
+  if(e) return drawf_oserror();
+
+  /* draw_process_path seems to have a bug:
+     If the bounding box size is zero, it returns 0x7FFFFFFF, ..., 0x80000000 instead of the
+     correct size. */
+  if (box->x0==0x7FFFFFFF)
+  {
+      /* path has zero extension, so forget it; it would be invisible anyway */
+      self->size-=size;
+      self->nobjs--;
+      diag=realloc(self->drawf,self->size);
+      if(!diag) return PyErr_NoMemory();
+      self->drawf=diag;
+  }
+  else
+      extend(&(diag->bbox),box);
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *DrawF_Text(PyDrawFObject *self,PyObject *arg)
+{ os_colour fill,bg_hint;
+  drawfile_text_style style;
+  int xsize,ysize,x,y;
+  int size,len;
+  char *text;
+  drawfile_diagram *diag;
+  drawfile_object *dobj;
+  drawfile_text *dtext;
+  os_box *box;
+  if(!PyArg_ParseTuple(arg,"(ii)s(iiiii)",&x,&y,&text,
+     (int*)&fill,(int*)&bg_hint,(int*)&style,&xsize,&ysize)) return NULL;
+  len=strlen(text);
+  size=((len+4)&(~3))+52;
+  diag=realloc(self->drawf,self->size+size);
+  if(!diag) return PyErr_NoMemory();
+  self->drawf=diag;
+  dobj=(drawfile_object*)((char*)diag+self->size);
+  dobj->type=drawfile_TYPE_TEXT;
+  dobj->size=size;
+  dtext=&dobj->data.text;
+  self->size+=size;
+  self->nobjs++;
+  dtext->fill=fill;
+  dtext->bg_hint=bg_hint;
+  dtext->style=style;
+  dtext->xsize=xsize;
+  dtext->ysize=ysize;
+  dtext->base.x=x;
+  dtext->base.y=y;
+  memset(dtext->text,0,(len+4)&(~3));
+  sprintf(dtext->text,"%s",text);
+  box=&(dtext->bbox);
+  box->x0=x;box->y0=y;box->x1=x+len*xsize;box->y1=y+ysize;
+  extend(&(diag->bbox),box);
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *DrawF_TText(PyDrawFObject *self,PyObject *arg)
+{ os_colour fill,bg_hint;
+  drawfile_text_style style;
+  int xsize,ysize,x,y;
+  int t1,t2,t3,t4,t5,t6;
+  int size,len;
+  char *text;
+  drawfile_diagram *diag;
+  drawfile_object *dobj;
+  drawfile_trfm_text *dtext;
+  os_box *box;
+  t1=1<<16;t2=0;
+  t3=0;t4=1<<16;
+  t5=t6=0;
+  if(!PyArg_ParseTuple(arg,"(ii)s(iiiii)|(iiiiii)",&x,&y,&text,
+     (int*)&fill,(int*)&bg_hint,(int*)&style,&xsize,&ysize,&t1,&t2,&t3,&t4,&t5,&t6)) return NULL;
+  len=strlen(text);
+  size=((len+4)&(~3))+52+28;
+  diag=realloc(self->drawf,self->size+size);
+  if(!diag) return PyErr_NoMemory();
+  self->drawf=diag;
+  dobj=(drawfile_object*)((char*)diag+self->size);
+  dobj->type=drawfile_TYPE_TRFM_TEXT;
+  dobj->size=size;
+  dtext=&dobj->data.trfm_text;
+  self->size+=size;
+  self->nobjs++;
+  dtext->trfm.entries[0][0]=t1;
+  dtext->trfm.entries[0][1]=t2;
+  dtext->trfm.entries[1][0]=t3;
+  dtext->trfm.entries[1][1]=t4;
+  dtext->trfm.entries[2][0]=t5;
+  dtext->trfm.entries[2][1]=t6;
+  dtext->flags=0;
+  dtext->fill=fill;
+  dtext->bg_hint=bg_hint;
+  dtext->style=style;
+  dtext->xsize=xsize;
+  dtext->ysize=ysize;
+  dtext->base.x=x;
+  dtext->base.y=y;
+  memset(dtext->text,0,(len+4)&(~3));
+  sprintf(dtext->text,"%s",text);
+  box=&(dtext->bbox);
+  box->x0=x;box->y0=y;box->x1=x+len*xsize;box->y1=y+ysize;
+  extend(&(diag->bbox),box);
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *DrawF_FontTable(PyDrawFObject *self,PyObject *arg)
+{ int size=8,n=0;
+  PyObject *d,*key,*value;
+  drawfile_diagram *diag;
+  drawfile_object *dobj;
+  char *dtable;
+  if(!PyArg_ParseTuple(arg,"O!",&PyDict_Type,&d)) return NULL;
+  while(PyDict_Next(d,&n,&key,&value))
+  { int m=PyString_Size(value);
+    if(m<0||!PyInt_Check(key)) return NULL;
+    size+=m+2;
+  }
+  size=(size+3)&(~3);
+  diag=realloc(self->drawf,self->size+size);
+  if(!diag) return PyErr_NoMemory();
+  self->drawf=diag;
+  dobj=(drawfile_object*)((char*)diag+self->size);
+  dobj->type=drawfile_TYPE_FONT_TABLE;
+  dobj->size=size;
+  dtable=(char*)(&dobj->data.font_table);
+  self->size+=size;
+  self->nobjs++;
+  memset(dtable,0,size-8);
+  n=0;
+  while(PyDict_Next(d,&n,&key,&value))
+  { int m=PyString_Size(value);
+    *dtable=(char)PyInt_AsLong(key);
+    strcpy(dtable+1,PyString_AsString(value));
+    dtable+=m+2;
+  }
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *DrawF_Group(PyDrawFObject *self,PyObject *arg)
+{ int size,n;
+  PyDrawFObject *g;
+  char *name="";
+  drawfile_diagram *diag;
+  drawfile_object *dobj;
+  drawfile_group *dgroup;
+  if(!PyArg_ParseTuple(arg,"O!|s",&PyDrawFType,(PyObject*)&g,&name))
+       return NULL;
+  size=g->size-4;
+  diag=realloc(self->drawf,self->size+size);
+  if(!diag) return PyErr_NoMemory();
+  self->drawf=diag;
+  self->nobjs++;
+  dobj=(drawfile_object*)((char*)diag+self->size);
+  self->size+=size;
+  dobj->type=drawfile_TYPE_GROUP;
+  dobj->size=g->size-4;
+  dgroup=&dobj->data.group;
+  dgroup->bbox=g->drawf->bbox;
+  memset(dgroup->name,' ',12);
+  n=strlen(name);
+  if(n>12) n=12;
+  memcpy(dgroup->name,name,n);
+  memcpy((char*)dgroup->objects,(char*)g->drawf+40,g->size-40);
+  extend(&(diag->bbox),&(dgroup->bbox));
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *DrawF_Find(PyDrawFObject *self,PyObject *arg)
+{ int x,y,n=0;
+  int r=-1;
+  drawfile_object *d;
+  if(!PyArg_ParseTuple(arg,"ii|i",&x,&y,&n)) return NULL;
+  if(n<self->nobjs&&n>=0)
+  { d=findobj(self,n);
+    while(n<self->nobjs)
+    { if(x>=d->data.text.bbox.x0&&x<=d->data.text.bbox.x1&&
+         y>=d->data.text.bbox.y0&&y<=d->data.text.bbox.y1) { r=n;break;}
+      n++;
+      d=NEXT(d);
+    }
+  }
+  return PyInt_FromLong(r);
+}
+
+
+static PyObject *DrawF_Box(PyDrawFObject *self,PyObject *arg)
+{ int n=-1;
+  os_box *box;
+  if(!PyArg_ParseTuple(arg,"|i",&n)) return NULL;
+  if(n>=self->nobjs|n<0) box=&(self->drawf->bbox);
+  else box=&(findobj(self,n)->data.text.bbox);
+  return Py_BuildValue("iiii",box->x0,box->y0,box->x1,box->y1);
+}
+
+static void SetBlock(drawfile_object *d,int size,int type,int offset,int value)
+{ char *end=(char*)d+size;
+  printf("s%d t%d o%d v%d\n",size,type,offset,value);
+  for(;(char*)d<end;d=NEXT(d))
+    if(d->type==type) ((int*)(d))[offset]=value;
+    else if(d->type==drawfile_TYPE_GROUP)
+           SetBlock((drawfile_object*)&d->data.group.objects,
+                    d->size,type,offset,value);
+  printf("SetBlock Done\n");
+}
+
+static PyObject *SetWord(PyDrawFObject *self,PyObject *arg,int type,int offset)
+{ int n=PyTuple_Size(arg);
+  int m,value,q;
+  PyObject *par;
+  drawfile_object *e,*d=self->drawf->objects;
+  if(n==0) return  drawf_error("Value Required");
+  par=PyTuple_GetItem(arg,0);
+  if(!PyInt_Check(par))
+  { PyErr_SetString(PyExc_TypeError,"Int Required");
+    return 0;
+  }
+  value=(int)PyInt_AsLong(par);
+  if(n==1) SetBlock(d,self->size-HDRSIZE,type,offset,value);
+  else
+  { for(m=1;m<n;m++)
+    { par=PyTuple_GetItem(arg,m);
+      if(!PyInt_Check(par))
+      { PyErr_SetString(PyExc_TypeError,"Int Required");
+        return 0;
+      }
+      q=(int)PyInt_AsLong(par);
+      if(q<0||q>=self->nobjs)
+      { PyErr_SetString(PyExc_ValueError,"Object out of range");
+        return 0;
+      }
+      e=d;
+      for(;q>0;q--) e=NEXT(e);
+      if(e->type==type)
+      { ((int*)(e))[offset]=value;
+      }
+      else if(e->type==drawfile_TYPE_GROUP)
+             SetBlock((drawfile_object*)&e->data.group.objects,
+                      e->size-GRPHDRSIZE,type,offset,value);
+    }
+  }
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *DrawF_PathFill(PyDrawFObject *self,PyObject *arg)
+{ return SetWord(self,arg,drawfile_TYPE_PATH,6);
+}
+
+static PyObject *DrawF_PathColour(PyDrawFObject *self,PyObject *arg)
+{ return SetWord(self,arg,drawfile_TYPE_PATH,7);
+}
+
+static PyObject *DrawF_TextColour(PyDrawFObject *self,PyObject *arg)
+{ return SetWord(self,arg,drawfile_TYPE_TEXT,6);
+}
+
+static PyObject *DrawF_TextBackground(PyDrawFObject *self,PyObject *arg)
+{ return SetWord(self,arg,drawfile_TYPE_TEXT,7);
+}
+
+static struct PyMethodDef PyDrawF_Methods[]=
+{
+  { "render",(PyCFunction)DrawF_Render,1},
+  { "save",(PyCFunction)DrawF_Save,1},
+  { "path",(PyCFunction)DrawF_Path,1},
+  { "text",(PyCFunction)DrawF_Text,1},
+  { "ttext",(PyCFunction)DrawF_TText,1},
+  { "fonttable",(PyCFunction)DrawF_FontTable,1},
+  { "group",(PyCFunction)DrawF_Group,1},
+  { "find",(PyCFunction)DrawF_Find,1},
+  { "box",(PyCFunction)DrawF_Box,1},
+  { "pathfill",(PyCFunction)DrawF_PathFill,1},
+  { "pathcolour",(PyCFunction)DrawF_PathColour,1},
+  { "textcolour",(PyCFunction)DrawF_TextColour,1},
+  { "textbackground",(PyCFunction)DrawF_TextBackground,1},
+  { NULL,NULL}		/* sentinel */
+};
+
+static int drawf_len(PyDrawFObject *b)
+{ return b->nobjs;
+}
+
+static PyObject *drawf_concat(PyDrawFObject *b,PyDrawFObject *c)
+{ int size=b->size+c->size-2*HDRSIZE;
+  PyDrawFObject *p=new(size);
+  drawfile_diagram *dd;
+  drawfile_object *d;
+  int n;
+  if(!p) return NULL;
+  dd=p->drawf;
+  d=(drawfile_object*)((char*)dd+b->size);
+  memcpy((char*)dd,(char*)(b->drawf),b->size);
+  memcpy(d,(char*)(c->drawf)+HDRSIZE,c->size-HDRSIZE);
+  p->nobjs=b->nobjs+c->nobjs;
+  for(n=c->nobjs;n>0;n--)
+  { extend(&(dd->bbox),&(d->data.path.bbox));
+    d=NEXT(d);
+  }
+  return (PyObject*)p;
+}
+
+static PyObject *drawf_repeat(PyDrawFObject *b,int i)
+{ PyErr_SetString(PyExc_IndexError,"drawf repetition not implemented");
+  return NULL;
+}
+
+static PyObject *drawf_item(PyDrawFObject *b,int i)
+{ PyDrawFObject *c;
+  int size;
+  drawfile_diagram *dd;
+  drawfile_object *d;
+  if(i<0||i>=b->nobjs)
+  { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
+    return NULL;
+  }
+  d=findobj(b,i);
+  size=(char*)findobj(b,i+1)-(char*)d;
+  c=new(size);
+  if(!c) return NULL;
+  dd=c->drawf;
+  *((dheader*)dd)=header;
+  memcpy(dd->objects,d,size);
+  c->nobjs=1;
+  extend(&(dd->bbox),&(d->data.path.bbox));
+  return (PyObject*)c;
+}
+
+static PyObject *drawf_slice(PyDrawFObject *b,int i,int j)
+{ PyDrawFObject *c;
+  int size,n;
+  drawfile_diagram *dd;
+  drawfile_object *d;
+  if(i<0||j>b->nobjs)
+  { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
+    return NULL;
+  }
+  d=findobj(b,i);
+  size=(char*)findobj(b,j)-(char*)d;
+  c=new(size);
+  if(!c) return NULL;
+  dd=c->drawf;
+  *((dheader*)dd)=header;
+  memcpy(dd->objects,d,size);
+  c->nobjs=j-i;
+  for(n=j-i;n>0;n--)
+  { extend(&(dd->bbox),&(d->data.path.bbox));
+    d=NEXT(d);
+  }
+  return (PyObject*)c;
+}
+
+static int drawf_ass_item(PyDrawFObject *b,int i,PyObject *v)
+{ PyErr_SetString(PyExc_IndexError,"drawf ass not implemented");
+  return NULL;
+}
+/*{ if(i<0||4*i>=b->length)
+  { PyErr_SetString(PyExc_IndexError,"drawf index out of range");
+    return -1;
+  }
+  if(!PyInt_Check(v))
+  { PyErr_SetString(PyExc_TypeError,"drawf item must be integer");
+    return -1;
+  }
+  ((long*)(b->drawf))[i]=PyInt_AsLong(v);
+  return 0;
+}
+*/
+
+static int drawf_ass_slice(PyDrawFObject *b,int i,int j,PyObject *v)
+{ PyErr_SetString(PyExc_IndexError,"drawf ass_slice not implemented");
+  return NULL;
+}
+
+static PySequenceMethods drawf_as_sequence=
+{ (inquiry)drawf_len,
+  (binaryfunc)drawf_concat,
+  (intargfunc)drawf_repeat,
+  (intargfunc)drawf_item,
+  (intintargfunc)drawf_slice,
+  (intobjargproc)drawf_ass_item,
+  (intintobjargproc)drawf_ass_slice,
+};
+
+static PyObject *PyDrawF_GetAttr(PyDrawFObject *s,char *name)
+{
+  if (!strcmp(name, "size")) return PyInt_FromLong((long)s->size);
+  if (!strcmp(name, "start")) return PyInt_FromLong((long)s->drawf);
+  if (!strcmp(name, "__members__"))
+  { PyObject *list = PyList_New(2);
+    if (list)
+    { PyList_SetItem(list, 0, PyString_FromString("size"));
+      PyList_SetItem(list, 1, PyString_FromString("start"));
+      if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;}
+    }
+    return list;
+  }
+  return Py_FindMethod(PyDrawF_Methods, (PyObject*) s,name);
+}
+
+static void PyDrawF_Dealloc(PyDrawFObject *b)
+{
+    if (b->drawf)
+        ;
+    else
+        PyMem_DEL(b->drawf);
+  PyMem_DEL(b);
+}
+
+static PyTypeObject PyDrawFType=
+{ PyObject_HEAD_INIT(&PyType_Type)
+  0,				/*ob_size*/
+  "drawf",			/*tp_name*/
+  sizeof(PyDrawFObject),	/*tp_size*/
+  0,				/*tp_itemsize*/
+	/* methods */
+  (destructor)PyDrawF_Dealloc,	/*tp_dealloc*/
+  0,				/*tp_print*/
+  (getattrfunc)PyDrawF_GetAttr,	/*tp_getattr*/
+  0,				/*tp_setattr*/
+  0,				/*tp_compare*/
+  0,				/*tp_repr*/
+  0,				/*tp_as_number*/
+  &drawf_as_sequence,		/*tp_as_sequence*/
+  0,				/*tp_as_mapping*/
+  0,                            /*tp_hash*/
+};
+
+
+
+static PyMethodDef DrawFMethods[]=
+{
+  { "load",DrawF_Load,1},
+  { "new",DrawF_New,1},
+  { NULL,NULL}		 /* Sentinel */
+};
+
+void initdrawf()
+{ PyObject *m, *d;
+  m = Py_InitModule("drawf", DrawFMethods);
+  d = PyModule_GetDict(m);
+  DrawFError=PyString_FromString("drawf.error");
+  PyDict_SetItemString(d,"error",DrawFError);
+}
diff --git a/RISCOS/Modules/getpath_riscos.c b/RISCOS/Modules/getpath_riscos.c
new file mode 100644
index 0000000000..7582b17306
--- /dev/null
+++ b/RISCOS/Modules/getpath_riscos.c
@@ -0,0 +1,56 @@
+#include "Python.h"
+#include "osdefs.h"
+
+static char *prefix,*exec_prefix,*progpath,*module_search_path=0;
+
+static void
+calculate_path()
+{ char *pypath=getenv("Python$Path");
+  if(pypath)
+  { module_search_path=malloc(strlen(pypath)+1);
+    if (module_search_path) sprintf(module_search_path,"%s",pypath);
+    else
+    {  /* We can't exit, so print a warning and limp along */
+       fprintf(stderr, "Not enough memory for dynamic PYTHONPATH.\n");
+       fprintf(stderr, "Using default static PYTHONPATH.\n");
+    }
+  }
+  if(!module_search_path) module_search_path = "<Python$Dir>.Lib";
+  prefix="";
+  exec_prefix=prefix;
+  progpath="<Python$Dir>";
+}
+
+/* External interface */
+
+char *
+Py_GetPath()
+{
+	if (!module_search_path)
+		calculate_path();
+	return module_search_path;
+}
+
+char *
+Py_GetPrefix()
+{
+	if (!module_search_path)
+		calculate_path();
+	return prefix;
+}
+
+char *
+Py_GetExecPrefix()
+{
+	if (!module_search_path)
+		calculate_path();
+	return exec_prefix;
+}
+
+char *
+Py_GetProgramFullPath()
+{
+	if (!module_search_path)
+		calculate_path();
+	return progpath;
+}
diff --git a/RISCOS/Modules/riscosmodule.c b/RISCOS/Modules/riscosmodule.c
new file mode 100644
index 0000000000..d378eba7fe
--- /dev/null
+++ b/RISCOS/Modules/riscosmodule.c
@@ -0,0 +1,283 @@
+/* RISCOS module implementation */
+
+#include "h.osfscontrol"
+#include "h.osgbpb"
+#include "h.os"
+#include "h.osfile"
+
+#include "Python.h"
+
+#include <errno.h>
+
+static os_error *e;
+
+static PyObject *RiscosError; /* Exception riscos.error */
+
+static PyObject *riscos_oserror(void)
+{ PyErr_SetString(RiscosError,e->errmess);
+  return 0;
+}
+
+static PyObject *riscos_error(char *s) { PyErr_SetString(RiscosError,s);return 0;}
+
+/* RISCOS file commands */
+
+static PyObject *riscos_remove(PyObject *self,PyObject *args)
+{       char *path1;
+	if (!PyArg_Parse(args, "s", &path1)) return NULL;
+	if (remove(path1)) return PyErr_SetFromErrno(RiscosError);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *riscos_rename(PyObject *self,PyObject *args)
+{	char *path1, *path2;
+	if (!PyArg_Parse(args, "(ss)", &path1, &path2)) return NULL;
+	if (rename(path1,path2)) return PyErr_SetFromErrno(RiscosError);;
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *riscos_system(PyObject *self,PyObject *args)
+{	char *command;
+	if (!PyArg_Parse(args, "s", &command)) return NULL;
+	return PyInt_FromLong(system(command));
+}
+
+static PyObject *riscos_chdir(PyObject *self,PyObject *args)
+{	char *path;
+	if (!PyArg_Parse(args, "s", &path)) return NULL;
+	e=xosfscontrol_dir(path);
+	if(e) return riscos_oserror();
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *canon(char *path)
+{ int len;
+  PyObject *obj;
+  char *buf;
+  e=xosfscontrol_canonicalise_path(path,0,0,0,0,&len);
+  if(e) return riscos_oserror();
+  obj=PyString_FromStringAndSize(NULL,-len);
+  if(obj==NULL) return NULL;
+  buf=PyString_AsString(obj);
+  e=xosfscontrol_canonicalise_path(path,buf,0,0,1-len,&len);
+  if(len!=1) return riscos_error("Error expanding path");
+  if(!e) return obj;
+  Py_DECREF(obj);
+  return riscos_oserror();
+}
+
+static PyObject *riscos_getcwd(PyObject *self,PyObject *args)
+{ if(!PyArg_NoArgs(args)) return NULL;
+  return canon("@");
+}
+
+static PyObject *riscos_expand(PyObject *self,PyObject *args)
+{	char *path;
+	if (!PyArg_Parse(args, "s", &path)) return NULL;
+        return canon(path);
+}
+
+static PyObject *riscos_mkdir(PyObject *self,PyObject *args)
+{	char *path;
+        int mode;
+        if (!PyArg_ParseTuple(args, "s|i", &path, &mode)) return NULL;
+        e=xosfile_create_dir(path,0);
+        if(e) return riscos_oserror();
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *riscos_listdir(PyObject *self,PyObject *args)
+{	char *path,buf[256];
+        PyObject *d, *v;
+        int c=0,count;
+	if (!PyArg_Parse(args, "s", &path)) return NULL;
+	d=PyList_New(0);
+	if(!d) return NULL;
+	for(;;)
+	{ e=xosgbpb_dir_entries(path,(osgbpb_string_list*)buf,
+	                             1,c,256,0,&count,&c);
+	  if(e)
+	  { Py_DECREF(d);return riscos_oserror();
+	  }
+	  if(count)
+	  { v=PyString_FromString(buf);
+	    if(!v) { Py_DECREF(d);return 0;}
+	    if(PyList_Append(d,v)) {Py_DECREF(d);Py_DECREF(v);return 0;}
+	  }
+	  if(c==-1) break;
+	}
+	return d;
+}
+
+static PyObject *riscos_stat(PyObject *self,PyObject *args)
+{	char *path;
+        int ob,len;
+        bits t=0;
+        bits ld,ex,at,ft,mode;
+	if (!PyArg_Parse(args, "s", &path)) return NULL;
+	e=xosfile_read_stamped_no_path(path,&ob,&ld,&ex,&len,&at,&ft);
+	if(e) return riscos_oserror();
+	switch (ob)
+	{ case osfile_IS_FILE:mode=0100000;break;  /* OCTAL */
+	  case osfile_IS_DIR:mode=040000;break;
+	  case osfile_IS_IMAGE:mode=0140000;break;
+	  default:return riscos_error("Not found");
+	}
+	if(ft!=-1) t=unixtime(ld,ex);
+	mode|=(at&7)<<6;
+	mode|=((at&112)*9)>>4;
+        return Py_BuildValue("(lllllllllllll)",
+		    (long)mode,/*st_mode*/
+		    0,/*st_ino*/
+		    0,/*st_dev*/
+		    0,/*st_nlink*/
+		    0,/*st_uid*/
+		    0,/*st_gid*/
+		    (long)len,/*st_size*/
+		    (long)t,/*st_atime*/
+		    (long)t,/*st_mtime*/
+		    (long)t,/*st_ctime*/
+		    (long)ft,/*file type*/
+		    (long)at,/*attributes*/
+		    (long)ob/*object type*/
+		    );
+}
+
+static PyObject *riscos_chmod(PyObject *self,PyObject *args)
+{	char *path;
+        bits mode;
+        bits attr;
+        attr=(mode&0x700)>>8;
+        attr|=(mode&7)<<4;
+	if (!PyArg_Parse(args, "(si)", &path,(int*)&mode)) return NULL;
+        e=xosfile_write_attr(path,attr);
+        if(e) return riscos_oserror();
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *riscos_utime(PyObject *self,PyObject *args)
+{	char *path;
+        int x,y;
+	if (!PyArg_Parse(args, "(s(ii))", &path,&x,&y)) return NULL;
+        e=xosfile_stamp(path);
+        if(e) return riscos_oserror();
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *riscos_settype(PyObject *self,PyObject *args)
+{	char *path,*name;
+        int type;
+	if (!PyArg_Parse(args, "(si)", &path,&type))
+	{ PyErr_Clear();
+	  if (!PyArg_Parse(args, "(ss)", &path,&name)) return NULL;
+	  e=xosfscontrol_file_type_from_string(name,(bits*)&type);
+	  if(e) return riscos_oserror();
+	}
+        e=xosfile_set_type(path,type);
+        if(e) return riscos_oserror();
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+static PyObject *riscos_getenv(PyObject *self,PyObject *args)
+{ char *name,*value;
+  if(!PyArg_Parse(args,"s",&name)) return NULL;
+  value=getenv(name);
+  if(value) return PyString_FromString(value);
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static PyObject *riscos_putenv(PyObject *self,PyObject *args)
+{ char *name,*value;
+  int len;
+  os_var_type type=os_VARTYPE_LITERAL_STRING;
+  if(!PyArg_ParseTuple(args,"ss|i",&name,&value,&type)) return NULL;
+  if(type!=os_VARTYPE_STRING&&type!=os_VARTYPE_MACRO&&type!=os_VARTYPE_EXPANDED
+                            &&type!=os_VARTYPE_LITERAL_STRING)
+    return riscos_error("Bad putenv type");
+  len=strlen(value);
+  if(type!=os_VARTYPE_LITERAL_STRING) len++;
+                          /* Other types need null terminator! */
+  e=xos_set_var_val(name,(byte*)value,len,0,type,0,0);
+  if(e) return riscos_oserror();
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static PyObject *riscos_delenv(PyObject *self,PyObject *args)
+{ char *name;
+  if(!PyArg_Parse(args,"s",&name)) return NULL;
+  e=xos_set_var_val(name,NULL,-1,0,0,0,0);
+  if(e) return riscos_oserror();
+  Py_INCREF(Py_None);
+  return Py_None;
+}
+
+static PyObject *riscos_getenvdict(PyObject *self,PyObject *args)
+{ PyObject *dict;
+  char value[257];
+  char *which="*";
+  int size;
+  char *context=NULL;
+  if(!PyArg_ParseTuple(args,"|s",&which)) return NULL;
+  dict = PyDict_New();
+  if (!dict) return NULL;
+  /* XXX This part ignores errors */
+  while(!xos_read_var_val(which,value,sizeof(value)-1,(int)context,
+         os_VARTYPE_EXPANDED,&size,(int *)&context,0))
+  { PyObject *v;
+    value[size]='\0';
+    v = PyString_FromString(value);
+    if (v == NULL) continue;
+    PyDict_SetItemString(dict, context, v);
+    Py_DECREF(v);
+  }
+  return dict;
+}
+
+static PyMethodDef riscos_methods[] = {
+
+	{"unlink",	riscos_remove},
+        {"remove",      riscos_remove},
+	{"rename",	riscos_rename},
+	{"system",	riscos_system},
+	{"rmdir",	riscos_remove},
+	{"chdir",	riscos_chdir},
+	{"getcwd",	riscos_getcwd},
+	{"expand",      riscos_expand},
+	{"mkdir",	riscos_mkdir,1},
+	{"listdir",	riscos_listdir},
+	{"stat",	riscos_stat},
+	{"lstat",	riscos_stat},
+        {"chmod",	riscos_chmod},
+	{"utime",	riscos_utime},
+	{"settype",	riscos_settype},
+	{"getenv",      riscos_getenv},
+	{"putenv",      riscos_putenv},
+	{"delenv",      riscos_delenv},
+	{"getenvdict",  riscos_getenvdict,1},
+	{NULL,		NULL}		 /* Sentinel */
+};
+
+
+
+void
+initriscos()
+{
+	PyObject *m, *d;
+
+	m = Py_InitModule("riscos", riscos_methods);
+	d = PyModule_GetDict(m);
+
+	/* Initialize riscos.error exception */
+	RiscosError = PyString_FromString("riscos.error");
+	if (RiscosError == NULL || PyDict_SetItemString(d, "error", RiscosError) != 0)
+		Py_FatalError("can't define riscos.error");
+}
diff --git a/RISCOS/Modules/swimodule.c b/RISCOS/Modules/swimodule.c
new file mode 100644
index 0000000000..12908d592c
--- /dev/null
+++ b/RISCOS/Modules/swimodule.c
@@ -0,0 +1,431 @@
+/* swi
+
+   RISC OS swi functions
+
+ 1.00               Chris Stretch
+
+
+ 1.01  12 May 1999  Laurence Tratt
+
+   * Changed swi.error to be a class based exception rather than string based
+   * Added swi.ArgError which is generated for errors when the user passes invalid arguments to
+       functions etc
+   * Added "errnum" attribute to swi.error, so one can now check to see what the error number was
+*/
+
+#include "h.os"
+#include "h.kernel"
+#include "Python.h"
+
+#include <errno.h>
+
+#define PyBlock_Check(op) ((op)->ob_type == &PyBlockType)
+
+
+static PyObject *SwiError; /* Exception swi.error */
+static PyObject *ArgError; /* Exception swi.ArgError */
+static os_error *e;
+
+static PyObject *swi_oserror(void)
+{ PyErr_SetString(SwiError,e->errmess);
+  PyObject_SetAttrString(PyErr_Occurred(), "errnum", PyInt_FromLong(e->errnum));
+  return 0;
+}
+
+static PyObject *swi_error(char *s)
+{ PyErr_SetString(ArgError,s);
+  return 0;
+}
+
+typedef struct
+{ PyObject_HEAD
+  void *block;
+  int length; /*length in bytes*/
+  int heap;
+} PyBlockObject;
+
+static PyTypeObject PyBlockType;
+
+/* block commands */
+
+static PyObject *PyBlock_New(PyObject *self,PyObject *args)
+{ int size;
+  PyBlockObject *b;
+  PyObject *init=0;
+  if(!PyArg_ParseTuple(args,"i|O",&size,&init)) return NULL;
+  if(size<1) size=1;
+  b=PyObject_NEW(PyBlockObject,&PyBlockType);
+  if(!b) return NULL;
+  b->block=malloc(4*size);
+  if(!b->block)
+  { Py_DECREF(b);
+    return PyErr_NoMemory();
+  }
+  b->length=4*size;
+  b->heap=1;
+  if(init)
+  { if(PyString_Check(init))
+    { int n=PyString_Size(init);
+      if (n>4*size) n=4*size;
+      memcpy(b->block,PyString_AsString(init),n);
+      memset((char*)b->block+n,0,4*size-n);
+    }
+    else
+    { int n,k;
+      long *p=(long*)b->block;
+      if(!PyList_Check(init)) goto fail;
+      n=PyList_Size(init);
+      if (n>size) n=size;
+      for(k=0;k<n;k++)
+      { PyObject *q=PyList_GetItem(init,k);
+        if(!PyInt_Check(q)) goto fail;
+        p[k]=PyInt_AsLong(q);
+      }
+      for(;k<size;k++) p[k]=0;
+    }
+  }
+  return (PyObject *)b;
+  fail:PyErr_SetString(PyExc_TypeError,
+     "block initialiser must be string or list of integers");
+  Py_DECREF(b);
+  return NULL;
+}
+
+static PyObject *PyRegister(PyObject *self,PyObject *args)
+{ int size,ptr;
+  PyBlockObject *b;
+  if(!PyArg_ParseTuple(args,"ii",&size,&ptr)) return NULL;
+  if(size<1) size=1;
+  b=PyObject_NEW(PyBlockObject,&PyBlockType);
+  if(!b) return NULL;
+  b->block=(void*)ptr;
+  b->length=4*size;
+  b->heap=0;
+  return (PyObject *)b;
+}
+
+static PyObject *PyBlock_ToString(PyBlockObject *self,PyObject *arg)
+{ int s=0,e=self->length;
+  if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
+  if(s<0||e>self->length||s>e)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return NULL;
+  }
+  return PyString_FromStringAndSize((char*)self->block+s,e-s);
+}
+
+static PyObject *PyBlock_NullString(PyBlockObject *self,PyObject *arg)
+{ int s=0,e=self->length,i;
+  char *p=(char*)self->block;
+  if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
+  if(s<0||e>self->length||s>e)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return NULL;
+  }
+  for(i=s;i<e;i++) if(p[i]==0) break;
+  return PyString_FromStringAndSize((char*)self->block+s,i-s);
+}
+
+static PyObject *PyBlock_CtrlString(PyBlockObject *self,PyObject *arg)
+{ int s=0,e=self->length,i;
+  char *p=(char*)self->block;
+  if(!PyArg_ParseTuple(arg,"|ii",&s,&e)) return NULL;
+  if(s<0||e>self->length||s>e)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return NULL;
+  }
+  for(i=s;i<e;i++) if(p[i]<32) break;
+  return PyString_FromStringAndSize((char*)self->block+s,i-s);
+}
+
+static PyObject *PyBlock_PadString(PyBlockObject *self,PyObject *arg)
+{ int s=0,e=self->length,n,m;
+  char *str;
+  char c;
+  char *p=(char*)self->block;
+  if(!PyArg_ParseTuple(arg,"s#c|ii",&str,&n,&c,&s,&e)) return NULL;
+  if(s<0||e>self->length||s>e)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return NULL;
+  }
+  m=e-s;
+  if(n>m) n=m;
+  memcpy(p+s,str,n);memset(p+s+n,c,m-n);
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *PyBlock_BitSet(PyBlockObject *self,PyObject *arg)
+{ int i,x,y;
+  int *p=(int*)self->block;
+  if(!PyArg_ParseTuple(arg,"iii",&i,&x,&y)) return NULL;
+  if(i<0||i>=self->length/4)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return NULL;
+  }
+  p[i]=(p[i]&y)^x;
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *PyBlock_Resize(PyBlockObject *self,PyObject *arg)
+{ int n;
+  if(!PyArg_ParseTuple(arg,"i",&n)) return NULL;
+  if(n<1) n=1;
+  if(self->heap)
+  { void *v=realloc(self->block,4*n);
+    if (!v) return PyErr_NoMemory();
+    self->block=v;
+  }
+  self->length=4*n;
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static PyObject *PyBlock_ToFile(PyBlockObject *self,PyObject *arg)
+{ int s=0,e=self->length/4;
+  PyObject *f;
+  FILE *fp;
+  if(!PyArg_ParseTuple(arg,"O|ii",&f,&s,&e)) return NULL;
+  fp=PyFile_AsFile(f);
+  if (!fp)
+  { PyErr_SetString(PyExc_TypeError, "arg must be open file");
+    return NULL;
+  }
+  fwrite((int*)(self->block)+s,4,e-s,fp);
+  Py_INCREF(Py_None);return Py_None;
+}
+
+static struct PyMethodDef PyBlock_Methods[]=
+{ { "tostring",(PyCFunction)PyBlock_ToString,1},
+  { "padstring",(PyCFunction)PyBlock_PadString,1},
+  { "nullstring",(PyCFunction)PyBlock_NullString,1},
+  { "ctrlstring",(PyCFunction)PyBlock_CtrlString,1},
+  { "bitset",(PyCFunction)PyBlock_BitSet,1},
+  { "resize",(PyCFunction)PyBlock_Resize,1},
+  { "tofile",(PyCFunction)PyBlock_ToFile,1},
+  { NULL,NULL}		/* sentinel */
+};
+
+static int block_len(PyBlockObject *b)
+{ return b->length/4;
+}
+
+static PyObject *block_concat(PyBlockObject *b,PyBlockObject *c)
+{ PyErr_SetString(PyExc_IndexError,"block concatenation not implemented");
+  return NULL;
+}
+
+static PyObject *block_repeat(PyBlockObject *b,int i)
+{ PyErr_SetString(PyExc_IndexError,"block repetition not implemented");
+  return NULL;
+}
+
+static PyObject *block_item(PyBlockObject *b,int i)
+{ if(i<0||4*i>=b->length)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return NULL;
+  }
+  return PyInt_FromLong(((long*)(b->block))[i]);
+}
+
+static PyObject *block_slice(PyBlockObject *b,int i,int j)
+{ int n,k;
+  long *p=b->block;
+  PyObject *result;
+  if(j>b->length/4) j=b->length/4;
+  if(i<0||i>j)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return NULL;
+  }
+  n=j-i;
+  result=PyList_New(n);
+  for(k=0;k<n;k++) PyList_SetItem(result,k,PyInt_FromLong(p[i+k]));
+  return result;
+}
+
+static int block_ass_item(PyBlockObject *b,int i,PyObject *v)
+{ if(i<0||i>=b->length/4)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return -1;
+  }
+  if(!PyInt_Check(v))
+  { PyErr_SetString(PyExc_TypeError,"block item must be integer");
+    return -1;
+  }
+  ((long*)(b->block))[i]=PyInt_AsLong(v);
+  return 0;
+}
+
+static int block_ass_slice(PyBlockObject *b,int i,int j,PyObject *v)
+{ int n,k;
+  long *p=b->block;
+  if(j>b->length/4) j=b->length/4;
+  if(i<0||i>j)
+  { PyErr_SetString(PyExc_IndexError,"block index out of range");
+    return -1;
+  }
+  if(!PyList_Check(v)) goto fail;
+  n=PyList_Size(v);
+  if(n>j-i) n=j-i;
+  for(k=0;k<n;k++)
+  { PyObject *q=PyList_GetItem(v,k);
+    if(!PyInt_Check(q)) goto fail;
+    p[i+k]=PyInt_AsLong(q);
+  }
+  for(;k<j-i;k++) p[i+k]=0;
+  return 0;
+  fail:PyErr_SetString(PyExc_TypeError,"block slice must be integer list");
+  return -1;
+}
+
+static PySequenceMethods block_as_sequence=
+{ (inquiry)block_len,		/*sq_length*/
+  (binaryfunc)block_concat,		/*sq_concat*/
+  (intargfunc)block_repeat,		/*sq_repeat*/
+  (intargfunc)block_item,		/*sq_item*/
+  (intintargfunc)block_slice,		/*sq_slice*/
+  (intobjargproc)block_ass_item,	/*sq_ass_item*/
+  (intintobjargproc)block_ass_slice,	/*sq_ass_slice*/
+};
+
+static PyObject *PyBlock_GetAttr(PyBlockObject *s,char *name)
+{
+  if (!strcmp(name, "length")) return PyInt_FromLong((long)s->length);
+  if (!strcmp(name, "start")) return PyInt_FromLong((long)s->block);
+  if (!strcmp(name,"end")) return PyInt_FromLong(((long)(s->block)+s->length));
+  if (!strcmp(name, "__members__"))
+  { PyObject *list = PyList_New(3);
+    if (list)
+    { PyList_SetItem(list, 0, PyString_FromString("length"));
+      PyList_SetItem(list, 1, PyString_FromString("start"));
+      PyList_SetItem(list, 2, PyString_FromString("end"));
+      if (PyErr_Occurred()) { Py_DECREF(list);list = NULL;}
+    }
+    return list;
+  }
+  return Py_FindMethod(PyBlock_Methods, (PyObject*) s,name);
+}
+
+static void PyBlock_Dealloc(PyBlockObject *b)
+{
+    if(b->heap) {
+        if (b->heap)
+            ;
+        else
+            PyMem_DEL(b->block);
+    }
+  PyMem_DEL(b);
+}
+
+static PyTypeObject PyBlockType=
+{ PyObject_HEAD_INIT(&PyType_Type)
+  0,				/*ob_size*/
+  "block",			/*tp_name*/
+  sizeof(PyBlockObject),	/*tp_size*/
+  0,				/*tp_itemsize*/
+	/* methods */
+  (destructor)PyBlock_Dealloc,	/*tp_dealloc*/
+  0,				/*tp_print*/
+  (getattrfunc)PyBlock_GetAttr,	/*tp_getattr*/
+  0,				/*tp_setattr*/
+  0,				/*tp_compare*/
+  0,				/*tp_repr*/
+  0,				/*tp_as_number*/
+  &block_as_sequence,		/*tp_as_sequence*/
+  0,				/*tp_as_mapping*/
+  0,                            /*tp_hash*/
+};
+
+/* swi commands */
+
+static PyObject *swi_swi(PyObject *self,PyObject *args)
+{ PyObject *name,*format,*result,*v;
+  int swino,carry,rno=0,j,n;
+  char *swiname,*fmt,*outfmt;
+  _kernel_swi_regs r;
+  PyBlockObject *ao;
+  if(args==NULL||!PyTuple_Check(args)||(n=PyTuple_Size(args))<2)
+  { PyErr_BadArgument(); return NULL;}
+  name=PyTuple_GetItem(args,0);
+  if(!PyArg_Parse(name,"i",&swino))
+  { PyErr_Clear();
+    if(!PyArg_Parse(name,"s",&swiname)) return NULL;
+    e=xos_swi_number_from_string(swiname,&swino);
+    if(e) return swi_oserror();
+  }
+  format=PyTuple_GetItem(args,1);
+  if(!PyArg_Parse(format,"s",&fmt)) return NULL;
+  j=2;
+  for(;;fmt++)
+  { switch(*fmt)
+    { case '.': rno++;continue;
+      case ';':case 0: goto swicall;
+      case '0':case '1':case '2':case '3':case '4':
+      case '5':case '6':case '7':case '8':case '9':
+        r.r[rno++]=*fmt-'0';continue;
+      case '-':r.r[rno++]=-1;continue;
+    }
+    if(j>=n) return swi_error("Too few arguments");
+    v=PyTuple_GetItem(args,j++);
+    switch(*fmt)
+    { case 'i':if(!PyArg_Parse(v,"i",&r.r[rno])) return NULL;
+               break;
+      case 's':if(!PyArg_Parse(v,"s",(char**)(&r.r[rno]))) return NULL;
+               break;
+      case 'b':if(!PyArg_Parse(v,"O",(PyObject**)&ao)) return NULL;
+               if(!PyBlock_Check(v)) return swi_error("Not a block");
+               r.r[rno]=(int)(ao->block);
+               break;
+      case 'e':if(!PyArg_Parse(v,"O",(PyObject**)&ao)) return NULL;
+               if(!PyBlock_Check(v)) return swi_error("Not a block");
+               r.r[rno]=(int)(ao->block)+ao->length;
+               break;
+      default:return swi_error("Odd format character");
+    }
+    rno++;
+  }
+  swicall:e=(os_error*)_kernel_swi_c(swino,&r,&r,&carry);
+  if(e) return swi_oserror();
+  if(*fmt==0) { Py_INCREF(Py_None);return Py_None;}
+  n=0;
+  for(outfmt=++fmt;*outfmt;outfmt++)  switch(*outfmt)
+  { case 'i':case 's':case '*':n++;break;
+    case '.':break;
+    default:return swi_error("Odd format character");
+  }
+  if(n==0) { Py_INCREF(Py_None);return Py_None;}
+  if(n!=1)
+  { result=PyTuple_New(n);
+    if(!result) return NULL;
+  }
+  rno=0;j=0;
+  for(;*fmt;fmt++)
+  {  switch(*fmt)
+    { case 'i':v=PyInt_FromLong((long)r.r[rno++]); break;
+      case 's':v=PyString_FromString((char*)(r.r[rno++])); break;
+      case '.':rno++; continue;
+      case '*':v=PyInt_FromLong((long)carry); break;
+    }
+    if(!v) goto fail;
+    if(n==1) return v;
+    PyTuple_SetItem(result,j,v);
+    j++;
+  }
+  return result;
+  fail:Py_DECREF(result);return 0;
+}
+
+static PyMethodDef SwiMethods[]=
+{ { "swi",swi_swi,1},
+  { "block",PyBlock_New,1},
+  { "register",PyRegister,1},
+  { NULL,NULL}		 /* Sentinel */
+};
+
+void initswi()
+{ PyObject *m, *d;
+  m = Py_InitModule("swi", SwiMethods);
+  d = PyModule_GetDict(m);
+  SwiError=PyErr_NewException("swi.error", NULL, NULL);
+  PyDict_SetItemString(d,"error",SwiError);
+  ArgError=PyErr_NewException("swi.ArgError", NULL, NULL);
+  PyDict_SetItemString(d,"ArgError",ArgError);
+}
diff --git a/RISCOS/Python/dynload_riscos.c b/RISCOS/Python/dynload_riscos.c
new file mode 100644
index 0000000000..3c4b1d7d67
--- /dev/null
+++ b/RISCOS/Python/dynload_riscos.c
@@ -0,0 +1,63 @@
+/***********************************************************
+Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
+The Netherlands.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the names of Stichting Mathematisch
+Centrum or CWI or Corporation for National Research Initiatives or
+CNRI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+While CWI is the initial source for this software, a modified version
+is made available by the Corporation for National Research Initiatives
+(CNRI) at the Internet address ftp://ftp.python.org.
+
+STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
+CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
+DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
+PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+/* This module provides the necessary stubs for when dynamic loading is
+   not present. */
+
+#include "Python.h"
+#include "importdl.h"
+
+#include "dlk.h"
+
+
+const struct filedescr _PyImport_DynLoadFiletab[] = {
+	{"/pyd", "rb", C_EXTENSION},
+	{0, 0}
+};
+
+void dynload_init_dummy()
+{
+}
+
+dl_funcptr _PyImport_GetDynLoadFunc(const char *fqname, const char *shortname,
+				    char *pathname, FILE *fp)
+{
+	int err;
+	char errstr[256];
+
+	err = dlk_load(pathname);
+	if (err)
+	{
+	  sprintf(errstr, "dlk failure %d", err);
+	  PyErr_SetString(PyExc_ImportError, errstr);
+	}
+	return dynload_init_dummy;
+}
diff --git a/RISCOS/Python/getcwd_riscos.c b/RISCOS/Python/getcwd_riscos.c
new file mode 100644
index 0000000000..0239e6ef74
--- /dev/null
+++ b/RISCOS/Python/getcwd_riscos.c
@@ -0,0 +1,5 @@
+char *getcwd(char *buf, int size)
+{
+  buf[0] = '\0';
+  return buf;
+}
diff --git a/RISCOS/Python/getmtime_riscos.c b/RISCOS/Python/getmtime_riscos.c
new file mode 100644
index 0000000000..cbd1669275
--- /dev/null
+++ b/RISCOS/Python/getmtime_riscos.c
@@ -0,0 +1,20 @@
+#include <stdio.h>
+
+#define __swi
+#include "osfile.h"
+
+long PyOS_GetLastModificationTime(char *path, FILE *fp)
+{
+  int obj;
+  bits load, exec, ftype;
+
+  if (xosfile_read_stamped_no_path(path, &obj, &load, &exec, 0, 0, &ftype)) return -1;
+  if (obj != osfile_IS_FILE) return -1;
+  if (ftype == osfile_TYPE_UNTYPED) return -1;
+
+  load &= 0xFF;
+  load -= 51;
+  if (exec < 1855548004U) load--;
+  exec -= 1855548004U;
+  return exec/100+42949672*load+(95*load)/100;
+}
diff --git a/RISCOS/README b/RISCOS/README
new file mode 100644
index 0000000000..8289880fe7
--- /dev/null
+++ b/RISCOS/README
@@ -0,0 +1,36 @@
+This directory contains files for the RISC OS port of Python.
+For more information about RISC OS see http://www.riscos.com/ .
+
+This port is currently being maintained by Dietmar Schwertberger,
+dietmar@schwertberger.de .
+
+On http://www.schwertberger.de you may find compiled versions and libraries
+as well as RISC OS specific documentation and extensions.
+
+
+==========================================================================
+Compiling:
+
+1. Extract Files from archive directory 'Python-...' to a directory named
+   '!Python'.
+2. Use a tool like Rename to change filenames from '*/[ch]' into '[ch].*'.
+3. Create missing directories with 'amu cdirs'.
+4. Build with 'amu'.
+
+I've only tested Acorn C/C++ 5.06 and amu.
+
+
+You will also need some additional libraries:
+
+  DLK
+    ftp://ftp.infc.ulst.ac.uk/pub/users/chris/
+  OSLib
+    http://www.mk-net.demon.co.uk/oslib
+  
+  zlib (optional)
+    ftp://ftp.freesoftware.com/pub/infozip/zlib/
+  sockets (optional)
+    http://www.mirror.ac.uk/sites/ftp.acorn.co.uk/pub/riscos/releases/networking/tcpip/sockets.arc
+  expat (optional)
+    http://sourceforge.net/projects/expat/
+    (makefile and config.h available from http://www.schwertberger.de/riscos_expat.zip
diff --git a/RISCOS/config.h b/RISCOS/config.h
new file mode 100644
index 0000000000..11a294c543
--- /dev/null
+++ b/RISCOS/config.h
@@ -0,0 +1,488 @@
+/* config.h.in.  Generated automatically from configure.in by autoheader.  */
+
+/* Define if on AIX 3.
+   System headers sometimes define this.
+   We just want to avoid a redefinition error message.  */
+#ifndef _ALL_SOURCE
+#undef _ALL_SOURCE
+#endif
+
+/* Define if type char is unsigned and you are not using gcc.  */
+#undef __CHAR_UNSIGNED__
+
+/* Define to empty if the keyword does not work.  */
+#undef const
+
+/* Define to `int' if <sys/types.h> doesn't define.  */
+#define gid_t int
+
+/* Define if your struct tm has tm_zone.  */
+#undef HAVE_TM_ZONE
+
+/* Define if you don't have tm_zone but do have the external array
+   tzname.  */
+#undef HAVE_TZNAME
+
+/* Define if on MINIX.  */
+#undef _MINIX
+
+/* Define to `int' if <sys/types.h> doesn't define.  */
+#define mode_t int
+
+/* Define to `long' if <sys/types.h> doesn't define.  */
+#define off_t long
+
+/* Define to `int' if <sys/types.h> doesn't define.  */
+#define pid_t int
+
+/* Define if the system does not provide POSIX.1 features except
+   with this defined.  */
+#undef _POSIX_1_SOURCE
+
+/* Define if you need to in order for stat and other things to work.  */
+#undef _POSIX_SOURCE
+
+/* Define as the return type of signal handlers (int or void).  */
+#define RETSIGTYPE void
+
+/* Define to `unsigned' if <sys/types.h> doesn't define.  */
+#undef size_t
+
+/* Define if you have the ANSI C header files.  */
+#define STDC_HEADERS 1
+
+/* Define if you can safely include both <sys/time.h> and <time.h>.  */
+#undef TIME_WITH_SYS_TIME
+
+/* Define if your <sys/time.h> declares struct tm.  */
+#define TM_IN_SYS_TIME 1
+
+/* Define to `int' if <sys/types.h> doesn't define.  */
+#define uid_t int
+
+/* Define if your <unistd.h> contains bad prototypes for exec*()
+   (as it does on SGI IRIX 4.x) */
+#undef BAD_EXEC_PROTOTYPES
+
+/* Define if your compiler botches static forward declarations
+   (as it does on SCI ODT 3.0) */
+#undef BAD_STATIC_FORWARD
+
+/* Define this if you have BeOS threads */
+#undef BEOS_THREADS
+
+/* Define if you have the Mach cthreads package */
+#undef C_THREADS
+
+/* Define to `long' if <time.h> doesn't define.  */
+#undef clock_t
+
+/* Used for BeOS configuration */
+#undef DL_EXPORT_HEADER
+#ifdef DL_EXPORT_HEADER
+#include DL_EXPORT_HEADER
+#endif
+
+/* Define if getpgrp() must be called as getpgrp(0). */
+#undef GETPGRP_HAVE_ARG
+
+/* Define if gettimeofday() does not have second (timezone) argument
+   This is the case on Motorola V4 (R40V4.2) */
+#undef GETTIMEOFDAY_NO_TZ
+
+/* Define this if your time.h defines altzone */
+#undef HAVE_ALTZONE
+
+/* Define this if you have some version of gethostbyname_r() */
+#undef HAVE_GETHOSTBYNAME_R
+
+/* Define this if you have the 3-arg version of gethostbyname_r() */
+#undef HAVE_GETHOSTBYNAME_R_3_ARG
+
+/* Define this if you have the 5-arg version of gethostbyname_r() */
+#undef HAVE_GETHOSTBYNAME_R_5_ARG
+
+/* Define this if you have the 6-arg version of gethostbyname_r() */
+#undef HAVE_GETHOSTBYNAME_R_6_ARG
+
+/* Define this if you have the type long long */
+#undef HAVE_LONG_LONG
+
+/* Define this if you have a K&R style C preprocessor */
+#undef HAVE_OLD_CPP
+
+/* Define if your compiler supports function prototypes */
+#define HAVE_PROTOTYPES 1
+
+/* Define if your compiler supports variable length function prototypes
+   (e.g. void fprintf(FILE *, char *, ...);) *and* <stdarg.h> */
+#define HAVE_STDARG_PROTOTYPES 1
+
+/* Define if malloc(0) returns a NULL pointer */
+#undef MALLOC_ZERO_RETURNS_NULL
+
+/* Define if you have POSIX threads */
+#undef _POSIX_THREADS
+
+/* Define to force use of thread-safe errno, h_errno, and other functions */
+#undef _REENTRANT
+
+/* Define if setpgrp() must be called as setpgrp(0, 0). */
+#undef SETPGRP_HAVE_ARG
+
+/* Define to empty if the keyword does not work.  */
+#undef signed
+
+/* Define if  you can safely include both <sys/select.h> and <sys/time.h>
+   (which you can't on SCO ODT 3.0). */
+#undef SYS_SELECT_WITH_SYS_TIME
+
+/* Define if a va_list is an array of some kind */
+#define VA_LIST_IS_ARRAY 1
+
+/* Define to empty if the keyword does not work.  */
+#undef volatile
+
+/* Define if you want SIGFPE handled (see Include/pyfpe.h). */
+#undef WANT_SIGFPE_HANDLER
+
+/* Define if you want to use SGI (IRIX 4) dynamic linking.
+   This requires the "dl" library by Jack Jansen,
+   ftp://ftp.cwi.nl/pub/dynload/dl-1.6.tar.Z.
+   Don't bother on IRIX 5, it already has dynamic linking using SunOS
+   style shared libraries */
+#undef WITH_SGI_DL
+
+/* Define if you want to emulate SGI (IRIX 4) dynamic linking.
+   This is rumoured to work on VAX (Ultrix), Sun3 (SunOS 3.4),
+   Sequent Symmetry (Dynix), and Atari ST.
+   This requires the "dl-dld" library,
+   ftp://ftp.cwi.nl/pub/dynload/dl-dld-1.1.tar.Z,
+   as well as the "GNU dld" library,
+   ftp://ftp.cwi.nl/pub/dynload/dld-3.2.3.tar.Z.
+   Don't bother on SunOS 4 or 5, they already have dynamic linking using
+   shared libraries */
+#undef WITH_DL_DLD
+
+/* Define if you want to use the new-style (Openstep, Rhapsody, MacOS)
+   dynamic linker (dyld) instead of the old-style (NextStep) dynamic
+   linker (rld). Dyld is necessary to support frameworks. */
+#undef WITH_DYLD
+
+/* Define if you want to compile in rudimentary thread support */
+#undef WITH_THREAD
+
+/* Define if you want to produce an OpenStep/Rhapsody framework
+   (shared library plus accessory files). */
+#undef WITH_NEXT_FRAMEWORK
+
+/* The number of bytes in an off_t. */
+#undef SIZEOF_OFF_T
+
+/* Defined to enable large file support when an off_t is bigger than a long
+   and long long is available and at least as big as an off_t. You may need
+   to add some flags for configuration and compilation to enable this mode.
+   E.g, for Solaris 2.7:
+   CFLAGS="-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64" OPT="-O2 $CFLAGS" \
+ configure
+*/
+#undef HAVE_LARGEFILE_SUPPORT
+
+/* The number of bytes in a time_t. */
+#define SIZEOF_TIME_T 4
+
+/* The number of bytes in a int.  */
+#define SIZEOF_INT 4
+
+/* The number of bytes in a long.  */
+#define SIZEOF_LONG 4
+
+/* The number of bytes in a long long.  */
+#undef SIZEOF_LONG_LONG
+
+/* The number of bytes in a void *.  */
+#define SIZEOF_VOID_P 4
+
+/* Define if you have the alarm function.  */
+#undef HAVE_ALARM
+
+/* Define if you have the chown function.  */
+#undef HAVE_CHOWN
+
+/* Define if you have the clock function.  */
+#define HAVE_CLOCK 1
+
+/* Define if you have the dlopen function.  */
+#undef HAVE_DLOPEN
+
+/* Define if you have the dup2 function.  */
+#undef HAVE_DUP2
+
+/* Define if you have the execv function.  */
+#undef HAVE_EXECV
+
+/* Define if you have the fdatasync function.  */
+#undef HAVE_FDATASYNC
+
+/* Define if you have the flock function.  */
+#undef HAVE_FLOCK
+
+/* Define if you have the fork function.  */
+#undef HAVE_FORK
+
+/* Define if you have the fseek64 function.  */
+#undef HAVE_FSEEK64
+
+/* Define if you have the fseeko function.  */
+#undef HAVE_FSEEKO
+
+/* Define if you have the fstatvfs function.  */
+#undef HAVE_FSTATVFS
+
+/* Define if you have the fsync function.  */
+#undef HAVE_FSYNC
+
+/* Define if you have the ftell64 function.  */
+#undef HAVE_FTELL64
+
+/* Define if you have the ftello function.  */
+#undef HAVE_FTELLO
+
+/* Define if you have the ftime function.  */
+#undef HAVE_FTIME
+
+/* Define if you have the ftruncate function.  */
+#undef HAVE_FTRUNCATE
+
+/* Define if you have the getcwd function.  */
+#undef HAVE_GETCWD
+
+/* Define if you have the getpeername function.  */
+#undef HAVE_GETPEERNAME
+
+/* Define if you have the getpgrp function.  */
+#undef HAVE_GETPGRP
+
+/* Define if you have the getpid function.  */
+#undef HAVE_GETPID
+
+/* Define if you have the getpwent function.  */
+#undef HAVE_GETPWENT
+
+/* Define if you have the gettimeofday function.  */
+#undef HAVE_GETTIMEOFDAY
+
+/* Define if you have the getwd function.  */
+#undef HAVE_GETWD
+
+/* Define if you have the hypot function.  */
+#undef HAVE_HYPOT
+
+/* Define if you have the kill function.  */
+#undef HAVE_KILL
+
+/* Define if you have the link function.  */
+#undef HAVE_LINK
+
+/* Define if you have the lstat function.  */
+#undef HAVE_LSTAT
+
+/* Define if you have the memmove function.  */
+#define HAVE_MEMMOVE 1
+
+/* Define if you have the mkfifo function.  */
+#undef HAVE_MKFIFO
+
+/* Define if you have the mktime function.  */
+#define HAVE_MKTIME 1
+
+/* Define if you have the nice function.  */
+#undef HAVE_NICE
+
+/* Define if you have the pause function.  */
+#undef HAVE_PAUSE
+
+/* Define if you have the plock function.  */
+#undef HAVE_PLOCK
+
+/* Define if you have the pthread_init function.  */
+#undef HAVE_PTHREAD_INIT
+
+/* Define if you have the putenv function.  */
+#undef HAVE_PUTENV
+
+/* Define if you have the readlink function.  */
+#undef HAVE_READLINK
+
+/* Define if you have the select function.  */
+#undef HAVE_SELECT
+
+/* Define if you have the setgid function.  */
+#undef HAVE_SETGID
+
+/* Define if you have the setlocale function.  */
+#undef HAVE_SETLOCALE
+
+/* Define if you have the setpgid function.  */
+#undef HAVE_SETPGID
+
+/* Define if you have the setpgrp function.  */
+#undef HAVE_SETPGRP
+
+/* Define if you have the setsid function.  */
+#undef HAVE_SETSID
+
+/* Define if you have the setuid function.  */
+#undef HAVE_SETUID
+
+/* Define if you have the setvbuf function.  */
+#undef HAVE_SETVBUF
+
+/* Define if you have the sigaction function.  */
+#undef HAVE_SIGACTION
+
+/* Define if you have the siginterrupt function.  */
+#undef HAVE_SIGINTERRUPT
+
+/* Define if you have the sigrelse function.  */
+#undef HAVE_SIGRELSE
+
+/* Define if you have the statvfs function.  */
+#undef HAVE_STATVFS
+
+/* Define if you have the strdup function.  */
+#undef HAVE_STRDUP
+
+/* Define if you have the strerror function.  */
+#define HAVE_STRERROR 1
+
+/* Define if you have the strftime function.  */
+#define HAVE_STRFTIME 1
+
+/* Define if you have the strptime function.  */
+#undef HAVE_STRPTIME
+
+/* Define if you have the symlink function.  */
+#undef HAVE_SYMLINK
+
+/* Define if you have the tcgetpgrp function.  */
+#undef HAVE_TCGETPGRP
+
+/* Define if you have the tcsetpgrp function.  */
+#undef HAVE_TCSETPGRP
+
+/* Define if you have the timegm function.  */
+#undef HAVE_TIMEGM
+
+/* Define if you have the times function.  */
+#undef HAVE_TIMES
+
+/* Define if you have the truncate function.  */
+#undef HAVE_TRUNCATE
+
+/* Define if you have the uname function.  */
+#undef HAVE_UNAME
+
+/* Define if you have the waitpid function.  */
+#undef HAVE_WAITPID
+
+/* Define if you have the <dirent.h> header file.  */
+#undef HAVE_DIRENT_H
+
+/* Define if you have the <dlfcn.h> header file.  */
+#undef HAVE_DLFCN_H
+
+/* Define if you have the <fcntl.h> header file.  */
+#undef HAVE_FCNTL_H
+
+/* Define if you have the <limits.h> header file.  */
+#define HAVE_LIMITS_H 1
+
+/* Define if you have the <locale.h> header file.  */
+#define HAVE_LOCALE_H 1
+
+/* Define if you have the <ncurses.h> header file.  */
+#undef HAVE_NCURSES_H
+
+/* Define if you have the <ndir.h> header file.  */
+#undef HAVE_NDIR_H
+
+/* Define if you have the <pthread.h> header file.  */
+#undef HAVE_PTHREAD_H
+
+/* Define if you have the <signal.h> header file.  */
+#define HAVE_SIGNAL_H 1
+
+/* Define if you have the <stdarg.h> header file.  */
+#define HAVE_STDARG_H 1
+
+/* Define if you have the <stddef.h> header file.  */
+#define HAVE_STDDEF_H 1
+
+/* Define if you have the <stdlib.h> header file.  */
+#define HAVE_STDLIB_H 1
+
+/* Define if you have the <sys/audioio.h> header file.  */
+#undef HAVE_SYS_AUDIOIO_H
+
+/* Define if you have the <sys/dir.h> header file.  */
+#undef HAVE_SYS_DIR_H
+
+/* Define if you have the <sys/file.h> header file.  */
+#undef HAVE_SYS_FILE_H
+
+/* Define if you have the <sys/lock.h> header file.  */
+#undef HAVE_SYS_LOCK_H
+
+/* Define if you have the <sys/ndir.h> header file.  */
+#undef HAVE_SYS_NDIR_H
+
+/* Define if you have the <sys/param.h> header file.  */
+#undef HAVE_SYS_PARAM_H
+
+/* Define if you have the <sys/select.h> header file.  */
+#undef HAVE_SYS_SELECT_H
+
+/* Define if you have the <sys/time.h> header file.  */
+#undef HAVE_SYS_TIME_H
+
+/* Define if you have the <sys/times.h> header file.  */
+#undef HAVE_SYS_TIMES_H
+
+/* Define if you have the <sys/un.h> header file.  */
+#undef HAVE_SYS_UN_H
+
+/* Define if you have the <sys/utsname.h> header file.  */
+#undef HAVE_SYS_UTSNAME_H
+
+/* Define if you have the <sys/wait.h> header file.  */
+#undef HAVE_SYS_WAIT_H
+
+/* Define if you have the <thread.h> header file.  */
+#undef HAVE_THREAD_H
+
+/* Define if you have the <unistd.h> header file.  */
+#undef HAVE_UNISTD_H
+
+/* Define if you have the <utime.h> header file.  */
+#undef HAVE_UTIME_H
+
+/* Define if you have the dl library (-ldl).  */
+#undef HAVE_LIBDL
+
+/* Define if you have the dld library (-ldld).  */
+#undef HAVE_LIBDLD
+
+/* Define if you have the ieee library (-lieee).  */
+#undef HAVE_LIBIEEE
+
+#define DONT_HAVE_SYS_TYPES_H 1
+
+#define DONT_HAVE_FSTAT 1
+#define DONT_HAVE_STAT  1
+#define DONT_HAVE_SYS_STAT_H  1
+
+#define PLATFORM "RISCOS"
+
+#define socklen_t int
+#define HAVE_DYNAMIC_LOADING
diff --git a/RISCOS/unixstuff.c b/RISCOS/unixstuff.c
new file mode 100644
index 0000000000..10648d264f
--- /dev/null
+++ b/RISCOS/unixstuff.c
@@ -0,0 +1,62 @@
+/* Fudge unix isatty and fileno for RISCOS */
+
+#include "h.unixstuff"
+#include <math.h>
+#include "h.osfile"
+
+int fileno(FILE *f)
+{ return (int)f;
+}
+
+int isatty(int fn)
+{ return (fn==fileno(stdin));
+}
+
+bits unixtime(bits ld,bits ex)
+{ ld&=0xFF;
+  ld-=51;
+  if(ex<1855548004U) ld--;
+  ex-=1855548004U;
+  return ex/100+42949672*ld+(95*ld)/100;
+}
+
+int unlink(char *fname)
+{ remove(fname);
+  return 0;
+}
+
+
+/*#define RET(k) {printf(" %d\n",k);return k;}*/
+#define RET(k) return k
+
+int isdir(char *fn)
+{ int ob;
+/*  printf("isdir %s",fn);*/
+  if(xosfile_read_stamped_no_path(fn,&ob,0,0,0,0,0)) RET(0);
+  switch (ob)
+  {   case osfile_IS_DIR:RET(1);
+    case osfile_IS_IMAGE:RET(1);
+  }
+  RET(0);
+}
+
+int isfile(char *fn)
+{ int ob;  /*printf("isfile %s",fn);*/
+  if(xosfile_read_stamped_no_path(fn,&ob,0,0,0,0,0)) RET(0);
+  switch (ob)
+  {  case osfile_IS_FILE:RET(1);
+    case osfile_IS_IMAGE:RET(1);
+  }
+  RET(0);
+}
+
+int exists(char *fn)
+{ int ob;  /*printf("exists %s",fn);*/
+  if(xosfile_read_stamped_no_path(fn,&ob,0,0,0,0,0)) RET(0);
+  switch (ob)
+  {  case osfile_IS_FILE:RET(1);
+      case osfile_IS_DIR:RET(1);
+    case osfile_IS_IMAGE:RET(1);
+  }
+  RET(0);
+}
diff --git a/RISCOS/unixstuff.h b/RISCOS/unixstuff.h
new file mode 100644
index 0000000000..75104c2983
--- /dev/null
+++ b/RISCOS/unixstuff.h
@@ -0,0 +1,13 @@
+/* Fudge unix isatty and fileno for RISCOS */
+
+#include <stdio.h>
+
+int fileno(FILE *f);
+int isatty(int fn);
+unsigned int unixtime(unsigned int ld,unsigned int ex);
+/*long PyOS_GetLastModificationTime(char *name);*/
+int unlink(char *fname);
+int isdir(char *fn);
+int isfile(char *fn);
+int exists(char *fn);
+