Import mymc 2.5 Python source code

Source: http://www.csclub.uwaterloo.ca:11068/mymc/mymc-pysrc-2.5.zip

README.txt

@@ -0,0 +1,178 @@
+README.txt
+
+By Ross Ridge
+Pubic Domain
+
+@(#) mymc README.txt 1.5 08/02/06 13:26:26
+
+
+This file describes mymc, a utility for manipulating PlayStation 2
+memory card images as used by the emulator PCSX2.  Its main purpose is
+to allow save games to be imported and exported to and from these
+images.  Both MAX Drive and EMS (.psu) save files are fully supported,
+however save files in the SharkPort/X-Port and Code Breaker formats
+can only be imported and not exported.  In addition to these basic
+functions, mymc can also perform a number of other operations, like
+creating new memory card images, viewing their contents, and adding
+and extracting individual files.
+
+A simple, hopefully easy to use, graphicial user interface (GUI) is
+provided, but it's limitted to only basic operations.  More advanced
+opterations require the use of a command line tool.  To install mymc,
+unpack the downloaded ZIP archive to a new directory on your machine.
+You can then run the GUI version of mymc by openning that newn
+directory with Windows Explorer and double clicking on the "mymc-gui"
+icon.  To make it easier to access, you can drag the "mymc-gui" icon
+to either your Desktop, Start Menu or Quick Launch toolbar.  Make sure
+if you do so, that you create a shortcut to "mymc-gui.exe".  If you
+copy the file instead, the program won't work.
+
+The command line utility can be invoked from the Windows Command
+Prompt by using the "mymc" command.  The executable "mymc.exe" and
+number of support files and these file must kept together in the same
+directory.  To run the command you need to either add the directory
+where you unpacked the distribution to your PATH or type the full
+pathname of the executable.  For example if you unpacked mymc to a
+directory named "c:\mymc" you need to enter "c:\mymc\mymc.exe" to run
+the program.
+
+The second important thing to note is that mymc is only "alpha"
+quality software.  This means that has is been released without
+extensive testing and may be unreliable.  While it works fine for me,
+the author, it might not work as well for you.  For that reason you
+should be careful how you use it, and prepared for the eventuality of
+it corrupting your save game images or producing garbage save files.
+If you're worried about this, one make things safer is to use two
+memory card images.  Use the first image to load and save your games
+with under PCSX2, and the second image to import and export saves
+games using mysc.  Then use the PS2 browser to copy files between two
+card images.
+
+
+GUI TUTORIAL
+============
+
+The GUI for mymc is should be easy to use.  After starting mymc, you
+can select the PS2 memory card image you want to work with by
+selecting the "Open" command by pressing the first button on the
+toolbar.  You can then import a save file clicking on the Import
+toolbar button.  To export a save files, first select it and then
+press the Export button.  You can delete a save file permanently from
+your memory card, by selecting the "Delete" command from the File
+menu.
+
+Do not try to use mymc to modify a memory card image while PCSX2 is
+running.  Doing so will corrupt your memory card.
+
+
+COMMAND LINE TUTORIAL
+=====================
+
+The basic usage template for mysc is "mymc memcard.ps2 command".  The
+first argument, "memcard.ps2" is the filename of the memory card image
+while "command" is the name of the command you wish to use on the
+image.  So for example, assuming you've installed mymc in "c:\mymc"
+and you've installed PCSX2 in "c:\pcsx2" you could enter the following
+command to see the contents of the memory card in the emulator's slot
+1:
+
+    c:\mymc\mymc c:\pcsx2\memcards\Mcd001.ps2 dir
+
+You would see output something like this:
+
+    BASLUS-20678USAGAS00             UNLIMITED SAGA
+     154KB Not Protected             SYSTEMDATA
+
+    BADATA-SYSTEM                    Your System
+       5KB Not Protected             Configuration
+
+    BASLUS-20488-0000D               SOTET<13>060:08
+     173KB Not Protected             Arias
+
+    7,800 KB Free
+
+This is the simple "user friendly" way to view the contents of a
+memory card.  It displays the same information you can see using the
+PlayStation 2 memory card browser.  On the right is name of each save,
+and on the left is the size and protection status of the save.  Also
+on the left is one bit of information you won't see in the browser,
+the directory name of the save file.  PlayStation 2 saves are actually
+a collection of different files all stored in a single directory on
+the memory card.  This is important information, because you need to
+know it to export save files.
+
+As mentioned above, if you know the directory name of a save, you can
+export it.  Exporting a save creates a save file in either the EMS
+(.psu) or MAX Drive (.max) format.  You can then transfer the save to
+real PS2 memory using the appropriate tools.  You can also send the
+saves to someone else to use or just keep them on your hard drive as a
+backup.  The following command demonstrates how to export a save in
+the EMS format using mymc:
+
+    c:\mymc\mymc c:\pcsx2\memcards\Mcd001.ps2 export BASLUS-20448-000D
+
+This will create a file called "BASLUS-20448-000D.psu" in the current
+directory.  To create a file in the MAX format instead, use the export
+command's -m option:
+
+    c:\mymc\mymc c:\pcsx2\memcards\Mcd001.ps2 export -m BASLUS-20448-000D
+
+This creates a file named "BASLUS-20448-000D.max".  Note the "-m"
+option that appears after the "export" command.
+
+Importing save files is similar.  The save file type is auto-detected,
+so you don't need use an "-m" option with MAX Drive saves.  Here's a
+couple of examples using each format:
+
+    c:\mymc\mymc c:\pcsx2\memcards\Mcd001.ps2 import BASLUS-20035.psu
+    c:\mymc\mymc c:\pcsx2\memcards\Mcd001.ps2 import 20062_3583_GTA3.max
+
+
+ADVANCED NOTES
+==============
+
+    - To get general help with the command line utility use the "-h"
+      global option (eg. "mymc -h").  To get help with a specific
+      command use the "-h" option with that command (eg. "mymc x
+      import -h").  In this later case, you need to specify a memory
+      card image file, but it's ignored and so doesn't need to exist.
+
+    - Both executables in the Windows version, "mymc.exe" and
+      "mymc-gui.exe" do the same thing and support the same options.
+      The difference is that "mymc" is console application, while
+      "mymc-gui" is a Windows appliction.  Currently, using "mymc"
+      to start the GUI will result in a fair amount debug messages
+      being printed that are normally not seen "mymc-gui" is used.
+
+    - It's possible to use mymc create images that are bigger (or
+      smaller) than standard PS2 memory cards.  Be very careful if you
+      do this, not all games may be compatible with such images.
+
+    - The bad block list on images is ignored.  Since memory card
+      images created with either PCSX2 or mymc won't have any bad
+      blocks, this shouldn't be a problem unless you've somehow
+      extracted a complete image from a real memory card and expect to
+      copy it back.
+
+    - The PS2 only uses at most 8,000 KB of a memory card, but there
+      is actually 8,135 KB of allocatable space on a standard
+      error-free memory card.  The extra 135 KB is reserved so that
+      memory card with bad blocks don't appear to have less space than
+      memory cards with fewer or no bad blocks.  Since there are no
+      bad blocks on memory card images, mymc uses the full capacity
+      provided by standard memory cards.
+
+
+PYTHON SOURCE DISTRIBUTION
+==========================
+
+The "source code" distribution of mymc is provided for users of Linux
+and other non-Windows operating systems.  It uses the same Python code
+that the Windows distribution is built with (using py2exe) and
+supports all the same functionality.  One big difference is that the
+Windows DLL "mymcsup.dll" is not included and as a result compressing
+and decompressing MAX Drive saves will be as much as 100 times slower.
+The GUI mode is hasn't been extensively tested on non-Windows systems,
+and the 3D display of save file icons requires the DLL.  The Python
+source version should support big-endian machines, but this hasn't
+been tested.

gui.py

@@ -0,0 +1,948 @@
+#
+# gui.py
+#
+# By Ross Ridge
+# Public Domain
+#
+
+"""Graphical user-interface for mymc."""
+
+_SCCS_ID = "@(#) mymc gui.py 1.3 08/02/06 13:15:41\n"
+
+import os
+import sys
+import struct
+import cStringIO
+import time
+
+# Work around a problem with mixing wx and py2exe
+if os.name == "nt" and hasattr(sys, "setdefaultencoding"):
+	sys.setdefaultencoding("mbcs")
+import wx
+
+import ps2mc
+import ps2save
+import guires
+
+try:
+	import ctypes
+	import mymcsup
+	D3DXVECTOR3 = mymcsup.D3DXVECTOR3
+	D3DXVECTOR4 = mymcsup.D3DXVECTOR4
+	D3DXVECTOR4_ARRAY3 = mymcsup.D3DXVECTOR4_ARRAY3
+
+	def mkvec4arr3(l):
+		return D3DXVECTOR4_ARRAY3(*[D3DXVECTOR4(*vec)
+					    for vec in l])
+except ImportError:
+	mymcsup = None
+
+lighting_none = {"lighting": False,
+		 "vertex_diffuse": False,
+		 "alt_lighting": False,
+		 "light_dirs": [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+		 "light_colours": [[0, 0, 0, 0], [0, 0, 0, 0],
+				   [0, 0, 0, 0]],
+		 "ambient": [0, 0, 0, 0]}
+
+lighting_diffuse = {"lighting": False,
+		    "vertex_diffuse": True,
+		    "alt_lighting": False,
+		    "light_dirs": [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+		    "light_colours": [[0, 0, 0, 0], [0, 0, 0, 0],
+				      [0, 0, 0, 0]],
+		    "ambient": [0, 0, 0, 0]}
+
+lighting_icon = {"lighting": True,
+		 "vertex_diffuse": True,
+		 "alt_lighting": False,
+		 "light_dirs": [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]],
+		 "light_colours": [[0, 0, 0, 0], [0, 0, 0, 0],
+				   [0, 0, 0, 0]],
+		 "ambient": [0, 0, 0, 0]}
+
+lighting_alternate = {"lighting": True,
+		      "vertex_diffuse": True,
+		      "alt_lighting": True,
+		      "light_dirs": [[1, -1, 2, 0],
+				     [-1, 1, -2, 0],
+				     [0, 1, 0, 0]],
+		      "light_colours": [[1, 1, 1, 1],
+					[1, 1, 1, 1],
+					[0.7, 0.7, 0.7, 1]],
+		      "ambient": [0.5, 0.5, 0.5, 1]}
+
+lighting_alternate2 = {"lighting": True,
+		       "vertex_diffuse": False,
+		       "alt_lighting": True,
+		       "light_dirs": [[1, -1, 2, 0],
+				      [-1, 1, -2, 0],
+				      [0, 4, 1, 0]],
+		       "light_colours": [[0.7, 0.7, 0.7, 1],
+					 [0.7, 0.7, 0.7, 1],
+					 [0.2, 0.2, 0.2, 1]],
+		       "ambient": [0.3, 0.3, 0.3, 1]}
+
+camera_default = [0, 4, -8]
+camera_high = [0, 7, -6]
+camera_near = [0, 3, -6]
+camera_flat = [0, 2, -7.5]
+
+def get_dialog_units(win):
+	return win.ConvertDialogPointToPixels((1, 1))[0]
+
+def single_title(title):
+	"""Convert the two parts of an icon.sys title into one string."""
+	
+	title = title[0] + " " + title[1]
+	return u" ".join(title.split())
+
+def _get_icon_resource_as_images(name):
+	ico = guires.resources[name]
+	images = []
+	f = cStringIO.StringIO(ico)
+	count = struct.unpack("<HHH", ico[0:6])[2]
+	# count = wx.Image_GetImageCount(f, wx.BITMAP_TYPE_ICO)
+	for i in range(count):
+		f.seek(0)
+		images.append(wx.ImageFromStream(f, wx.BITMAP_TYPE_ICO, i))
+	return images
+	
+def get_icon_resource(name):
+	"""Convert a Window ICO contained in a string to an IconBundle."""
+
+	bundle = wx.IconBundle()
+	for img in _get_icon_resource_as_images(name):
+		bmp = wx.BitmapFromImage(img)
+		icon = wx.IconFromBitmap(bmp)
+		bundle.AddIcon(icon)
+	return bundle
+
+def get_icon_resource_bmp(name, size):
+	"""Get an icon resource as a Bitmap.
+
+	Tries to find the closest matching size if no exact match exists."""
+	
+	best = None
+	best_size = (0, 0)
+	for img in _get_icon_resource_as_images(name):
+		sz = (img.GetWidth(), img.GetHeight())
+		if sz == size:
+			return wx.BitmapFromImage(img)
+		if sz[0] >= size[0] and sz[1] >= size[1]:
+			if ((best_size[0] < size[0] or best_size[1] < size[1])
+			    or sz[0] * sz[1] < best_size[0] * best_size[1]):
+				best = img
+				best_size = sz
+		elif sz[0] * sz[1] > best_size[0] * best_size[1]:
+			best = img
+			best_size = sz
+	img = best.Rescale(size[0], size[1], wx.IMAGE_QUALITY_HIGH)
+	return wx.BitmapFromImage(img)
+
+
+class dirlist_control(wx.ListCtrl):
+	"""Lists all the save files in a memory card image."""
+	
+	def __init__(self, parent, evt_focus, evt_select, config):
+		self.config = config
+		self.selected = set()
+		self.evt_select = evt_select
+		wx.ListCtrl.__init__(self, parent, wx.ID_ANY,
+				     style = wx.LC_REPORT)
+		wx.EVT_LIST_COL_CLICK(self, -1, self.evt_col_click)
+		wx.EVT_LIST_ITEM_FOCUSED(self, -1, evt_focus)
+		wx.EVT_LIST_ITEM_SELECTED(self, -1, self.evt_item_selected)
+		wx.EVT_LIST_ITEM_DESELECTED(self, -1, self.evt_item_deselected)
+
+	def _update_dirtable(self, mc, dir):
+		self.dirtable = table = []
+		enc = "unicode"
+		if self.config.get_ascii():
+			enc = "ascii"
+		for ent in dir:
+			if not ps2mc.mode_is_dir(ent[0]):
+				continue
+			dirname = "/" + ent[8]
+			s = mc.get_icon_sys(dirname)
+			if s == None:
+				continue
+			a = ps2save.unpack_icon_sys(s)
+			size = mc.dir_size(dirname)
+			title = ps2save.icon_sys_title(a, encoding = enc)
+			table.append((ent, s, size, title))
+		
+	def update_dirtable(self, mc):
+		self.dirtable = []
+		if mc == None:
+			return
+		dir = mc.dir_open("/")
+		try:
+			self._update_dirtable(mc, dir)
+		finally:
+			dir.close()
+			
+	def cmp_dir_name(self, i1, i2):
+		return self.dirtable[i1][0][8] > self.dirtable[i2][0][8]
+
+	def cmp_dir_title(self, i1, i2):
+		return self.dirtable[i1][3] > self.dirtable[i2][3]
+
+	def cmp_dir_size(self, i1, i2):
+		return self.dirtable[i1][2] > self.dirtable[i2][2]
+
+	def cmp_dir_modified(self, i1, i2):
+		m1 = list(self.dirtable[i1][0][6])
+		m2 = list(self.dirtable[i2][0][6])
+		m1.reverse()
+		m2.reverse()
+		return m1 > m2
+	
+	def evt_col_click(self, event):
+		col = event.m_col
+		if col == 0:
+			cmp = self.cmp_dir_name
+		elif col == 1:
+			cmp = self.cmp_dir_size
+		elif col == 2:
+			cmp = self.cmp_dir_modified
+		elif col == 3:
+			cmp = self.cmp_dir_title
+		self.SortItems(cmp)
+		return
+
+	def evt_item_selected(self, event):
+		self.selected.add(event.GetData())
+		self.evt_select(event)
+		
+	def evt_item_deselected(self, event):
+		self.selected.discard(event.GetData())
+		self.evt_select(event)
+		
+	def update(self, mc):
+		"""Update the ListCtrl according to the contents of the
+		   memory card image."""
+		
+		self.ClearAll()
+		self.selected = set()
+		self.InsertColumn(0, "Directory")
+		self.InsertColumn(1, "Size")
+		self.InsertColumn(2, "Modified")
+		self.InsertColumn(3, "Description")
+		li = self.GetColumn(1)
+		li.SetAlign(wx.LIST_FORMAT_RIGHT)
+		li.SetText("Size")
+		self.SetColumn(1, li)
+		
+		self.update_dirtable(mc)
+		
+		empty = len(self.dirtable) == 0
+		self.Enable(not empty)
+		if empty:
+			return
+		
+		for (i, a) in enumerate(self.dirtable):
+			(ent, icon_sys, size, title) = a
+			li = self.InsertStringItem(i, ent[8])
+			self.SetStringItem(li, 1, "%dK" % (size / 1024))
+			m = ent[6]
+			m = ("%04d-%02d-%02d %02d:%02d"
+			     % (m[5], m[4], m[3], m[2], m[1]))
+			self.SetStringItem(li, 2, m)
+			self.SetStringItem(li, 3, single_title(title))
+			self.SetItemData(li, i)
+
+		du = get_dialog_units(self)
+		for i in range(4):
+			self.SetColumnWidth(i, wx.LIST_AUTOSIZE)
+			self.SetColumnWidth(i, self.GetColumnWidth(i) + du)
+		self.SortItems(self.cmp_dir_name)
+
+
+class icon_window(wx.Window):
+	"""Displays a save file's 3D icon.  Windows only.
+	
+	The rendering of the 3D icon is handled by C++ code in the
+	mymcsup DLL which subclasses this window.  This class mainly
+	handles configuration options that affect how the 3D icon is
+	displayed.
+	"""
+	
+	ID_CMD_ANIMATE        = 201
+	ID_CMD_LIGHT_NONE     = 202
+	ID_CMD_LIGHT_ICON     = 203
+	ID_CMD_LIGHT_ALT1     = 204
+	ID_CMD_LIGHT_ALT2     = 205
+	ID_CMD_CAMERA_FLAT    = 206
+	ID_CMD_CAMERA_DEFAULT = 207
+	ID_CMD_CAMERA_NEAR    = 209
+	ID_CMD_CAMERA_HIGH    = 210
+
+	light_options = {ID_CMD_LIGHT_NONE: lighting_none,
+			 ID_CMD_LIGHT_ICON: lighting_icon,
+			 ID_CMD_LIGHT_ALT1: lighting_alternate,
+			 ID_CMD_LIGHT_ALT2: lighting_alternate2}
+
+	camera_options = {ID_CMD_CAMERA_FLAT: camera_flat,
+			  ID_CMD_CAMERA_DEFAULT: camera_default,
+			  ID_CMD_CAMERA_NEAR: camera_near,
+			  ID_CMD_CAMERA_HIGH: camera_high}
+
+	def append_menu_options(self, win, menu):
+		menu.AppendCheckItem(icon_window.ID_CMD_ANIMATE,
+				     "Animate Icons")
+		menu.AppendSeparator()
+		menu.AppendRadioItem(icon_window.ID_CMD_LIGHT_NONE,
+				     "Lighting Off")
+		menu.AppendRadioItem(icon_window.ID_CMD_LIGHT_ICON,
+				     "Icon Lighting")
+		menu.AppendRadioItem(icon_window.ID_CMD_LIGHT_ALT1,
+				     "Alternate Lighting")
+		menu.AppendRadioItem(icon_window.ID_CMD_LIGHT_ALT2,
+				     "Alternate Lighting 2")
+		menu.AppendSeparator()
+		menu.AppendRadioItem(icon_window.ID_CMD_CAMERA_FLAT,
+				     "Camera Flat")
+		menu.AppendRadioItem(icon_window.ID_CMD_CAMERA_DEFAULT,
+				     "Camera Default")
+		menu.AppendRadioItem(icon_window.ID_CMD_CAMERA_NEAR,
+				     "Camera Near")
+		menu.AppendRadioItem(icon_window.ID_CMD_CAMERA_HIGH,
+				     "Camera High")
+
+		wx.EVT_MENU(win, icon_window.ID_CMD_ANIMATE,
+			    self.evt_menu_animate)
+		wx.EVT_MENU(win, icon_window.ID_CMD_LIGHT_NONE,
+			    self.evt_menu_light)
+		wx.EVT_MENU(win, icon_window.ID_CMD_LIGHT_ICON,
+			    self.evt_menu_light)
+		wx.EVT_MENU(win, icon_window.ID_CMD_LIGHT_ALT1,
+			    self.evt_menu_light)
+		wx.EVT_MENU(win, icon_window.ID_CMD_LIGHT_ALT2,
+			    self.evt_menu_light)
+		
+		wx.EVT_MENU(win, icon_window.ID_CMD_CAMERA_FLAT,
+			    self.evt_menu_camera)
+		wx.EVT_MENU(win, icon_window.ID_CMD_CAMERA_DEFAULT,
+			    self.evt_menu_camera)
+		wx.EVT_MENU(win, icon_window.ID_CMD_CAMERA_NEAR,
+			    self.evt_menu_camera)
+		wx.EVT_MENU(win, icon_window.ID_CMD_CAMERA_HIGH,
+			    self.evt_menu_camera)
+		
+	def __init__(self, parent, focus):
+		self.failed = False
+		wx.Window.__init__(self, parent)
+		if mymcsup == None:
+			self.failed = True
+			return
+		r = mymcsup.init_icon_renderer(focus.GetHandle(),
+					       self.GetHandle())
+		if r == -1:
+			print "init_icon_renderer failed"
+			self.failed = True
+			return
+		
+		self.config = config = mymcsup.icon_config()
+		config.animate = True
+
+		self.menu = wx.Menu()
+		self.append_menu_options(self, self.menu)
+		self.set_lighting(self.ID_CMD_LIGHT_ALT2)
+		self.set_camera(self.ID_CMD_CAMERA_DEFAULT)
+		
+		wx.EVT_CONTEXT_MENU(self, self.evt_context_menu)
+
+	def __del__(self):
+		if mymcsup != None:
+			mymcsup.delete_icon_renderer()
+
+	def update_menu(self, menu):
+		"""Update the content menu according to the current config."""
+
+		menu.Check(icon_window.ID_CMD_ANIMATE, self.config.animate)
+		menu.Check(self.lighting_id, True)
+		menu.Check(self.camera_id, True)
+		
+	def load_icon(self, icon_sys, icon):
+		"""Pass the raw icon data to the support DLL for display."""
+
+		if self.failed:
+			return
+		
+		if icon_sys == None or icon == None:
+			r = mymcsup.load_icon(None, 0, None, 0)
+		else:
+			r = mymcsup.load_icon(icon_sys, len(icon_sys),
+					      icon, len(icon))
+		if r != 0:
+			print "load_icon", r
+			self.failed = True
+
+	def _set_lighting(self, lighting, vertex_diffuse, alt_lighting,
+			 light_dirs, light_colours, ambient):
+		if self.failed:
+			return
+		config = self.config
+		config.lighting = lighting
+		config.vertex_diffuse = vertex_diffuse
+		config.alt_lighting = alt_lighting
+		config.light_dirs = mkvec4arr3(light_dirs)
+		config.light_colours = mkvec4arr3(light_colours)
+		config.ambient = D3DXVECTOR4(*ambient)
+		if mymcsup.set_config(config) == -1:
+			self.failed = True
+
+	def set_lighting(self, id):
+		self.lighting_id = id
+		self._set_lighting(**self.light_options[id])
+		
+	def set_animate(self, animate):
+		if self.failed:
+			return
+		self.config.animate = animate
+		if mymcsup.set_config(self.config) == -1:
+			self.failed = True
+		
+	def _set_camera(self, camera):
+		if self.failed:
+			return
+		self.config.camera = mymcsup.D3DXVECTOR3(*camera)
+		if mymcsup.set_config(self.config) == -1:
+			self.failed = True
+
+	def set_camera(self, id):
+		self.camera_id = id
+		self._set_camera(self.camera_options[id])
+		
+	def evt_context_menu(self, event):
+		self.update_menu(self.menu)
+		self.PopupMenu(self.menu)
+
+	def evt_menu_animate(self, event):
+		self.set_animate(not self.config.animate)
+
+	def evt_menu_light(self, event):
+		self.set_lighting(event.GetId())
+
+	def evt_menu_camera(self, event):
+		self.set_camera(event.GetId())
+
+class gui_config(wx.Config):
+	"""A class for holding the persistant configuration state."""
+
+	memcard_dir = "Memory Card Directory"
+	savefile_dir = "Save File Directory"
+	ascii = "ASCII Descriptions"
+	
+	def __init__(self):
+		wx.Config.__init__(self, "mymc", "Ross Ridge",
+				   style = wx.CONFIG_USE_LOCAL_FILE)
+
+	def get_memcard_dir(self, default = None):
+		return self.Read(gui_config.memcard_dir, default)
+
+	def set_memcard_dir(self, value):
+		return self.Write(gui_config.memcard_dir, value)
+
+	def get_savefile_dir(self, default = None):
+		return self.Read(gui_config.savefile_dir, default)
+
+	def set_savefile_dir(self, value):
+		return self.Write(gui_config.savefile_dir, value)
+
+	def get_ascii(self, default = False):
+		return bool(self.ReadInt(gui_config.ascii, int(bool(default))))
+
+	def set_ascii(self, value):
+		return self.WriteInt(gui_config.ascii, int(bool(value)))
+
+def add_tool(toolbar, id, label, ico):
+	tbsize = toolbar.GetToolBitmapSize()
+	bmp = get_icon_resource_bmp(ico, tbsize)
+	return toolbar.AddLabelTool(id, label, bmp, shortHelp = label)
+
+class gui_frame(wx.Frame):
+	"""The main top level window."""
+	
+	ID_CMD_EXIT = wx.ID_EXIT
+	ID_CMD_OPEN = wx.ID_OPEN
+	ID_CMD_EXPORT = 103
+	ID_CMD_IMPORT = 104
+	ID_CMD_DELETE = wx.ID_DELETE
+	ID_CMD_ASCII = 106
+	
+	def message_box(self, message, caption = "mymc", style = wx.OK,
+			x = -1, y = -1):
+		return wx.MessageBox(message, caption, style, self, x, y)
+
+	def error_box(self, msg):
+		return self.message_box(msg, "Error", wx.OK | wx.ICON_ERROR)
+		
+	def mc_error(self, value, filename = None):
+		"""Display a message box for EnvironmentError exeception."""
+
+		if filename == None:
+			filename = self.mcname
+			if filename == None:
+				filename = "???"
+		filename = getattr(value, "filename", filename) 
+		strerror = getattr(value, "strerror", "unknown error")
+		return self.error_box(filename + ": " + strerror)
+
+	def __init__(self, parent, title, mcname = None):
+		self.f = None
+		self.mc = None
+		self.mcname = None
+		self.icon_win = None
+
+		size = (750, 350)
+		if mymcsup == None:
+			size = (500, 350)
+		wx.Frame.__init__(self, parent, wx.ID_ANY, title, size = size)
+
+		wx.EVT_CLOSE(self, self.evt_close)
+
+		self.config = gui_config()
+		self.title = title
+
+		self.SetIcons(get_icon_resource("mc4.ico"))
+				
+		wx.EVT_MENU(self, self.ID_CMD_EXIT, self.evt_cmd_exit)
+		wx.EVT_MENU(self, self.ID_CMD_OPEN, self.evt_cmd_open)
+		wx.EVT_MENU(self, self.ID_CMD_EXPORT, self.evt_cmd_export)
+		wx.EVT_MENU(self, self.ID_CMD_IMPORT, self.evt_cmd_import)
+		wx.EVT_MENU(self, self.ID_CMD_DELETE, self.evt_cmd_delete)
+		wx.EVT_MENU(self, self.ID_CMD_ASCII, self.evt_cmd_ascii)
+		
+		filemenu = wx.Menu()
+		filemenu.Append(self.ID_CMD_OPEN, "&Open...",
+				"Opens an existing PS2 memory card image.")
+		filemenu.AppendSeparator()
+		self.export_menu_item = filemenu.Append(
+			self.ID_CMD_EXPORT, "&Export...",
+			"Export a save file from this image.")
+		self.import_menu_item = filemenu.Append(
+			self.ID_CMD_IMPORT, "&Import...",
+			"Import a save file into this image.")
+		self.delete_menu_item = filemenu.Append(
+			self.ID_CMD_DELETE, "&Delete")
+		filemenu.AppendSeparator()
+		filemenu.Append(self.ID_CMD_EXIT, "E&xit")
+
+		optionmenu = wx.Menu()
+		self.ascii_menu_item = optionmenu.AppendCheckItem(
+			self.ID_CMD_ASCII, "&ASCII Descriptions",
+			"Show descriptions in ASCII instead of Shift-JIS")
+
+
+		wx.EVT_MENU_OPEN(self, self.evt_menu_open);
+
+		self.CreateToolBar(wx.TB_HORIZONTAL)
+		self.toolbar = toolbar = self.GetToolBar()
+		tbsize = (32, 32)
+		toolbar.SetToolBitmapSize(tbsize)
+		add_tool(toolbar, self.ID_CMD_OPEN, "Open", "mc2.ico")
+		toolbar.AddSeparator()
+		add_tool(toolbar, self.ID_CMD_IMPORT, "Import", "mc5b.ico")
+		add_tool(toolbar, self.ID_CMD_EXPORT, "Export", "mc6a.ico")
+		toolbar.Realize()
+
+		self.statusbar = self.CreateStatusBar(2,
+						      style = wx.ST_SIZEGRIP)
+		self.statusbar.SetStatusWidths([-2, -1])
+		
+		panel = wx.Panel(self, wx.ID_ANY, (0, 0))
+
+		self.dirlist = dirlist_control(panel,
+					       self.evt_dirlist_item_focused,
+					       self.evt_dirlist_select,
+					       self.config)
+		if mcname != None:
+			self.open_mc(mcname)
+		else:
+			self.refresh()
+
+		sizer = wx.BoxSizer(wx.HORIZONTAL)
+		sizer.Add(self.dirlist, 2, wx.EXPAND)
+		sizer.AddSpacer(5)
+
+		icon_win = None
+		if mymcsup != None:
+			icon_win = icon_window(panel, self)
+			if icon_win.failed:
+				icon_win.Destroy()
+				icon_win = None
+		self.icon_win = icon_win
+		
+		if icon_win == None:
+			self.info1 = None
+			self.info2 = None
+		else:
+			self.icon_menu = icon_menu = wx.Menu()
+			icon_win.append_menu_options(self, icon_menu)
+			optionmenu.AppendSubMenu(icon_menu, "Icon Window")
+			title_style =  wx.ALIGN_RIGHT | wx.ST_NO_AUTORESIZE
+			
+			self.info1 = wx.StaticText(panel, -1, "",
+						   style = title_style)
+			self.info2 = wx.StaticText(panel, -1, "",
+						   style = title_style)
+			# self.info3 = wx.StaticText(panel, -1, "")
+
+			info_sizer = wx.BoxSizer(wx.VERTICAL)
+			info_sizer.Add(self.info1, 0, wx.EXPAND)
+			info_sizer.Add(self.info2, 0, wx.EXPAND)
+			# info_sizer.Add(self.info3, 0, wx.EXPAND)
+			info_sizer.AddSpacer(5)
+			info_sizer.Add(icon_win, 1, wx.EXPAND)
+
+			sizer.Add(info_sizer, 1, wx.EXPAND | wx.ALL,
+				  border = 5)
+
+		menubar = wx.MenuBar()
+		menubar.Append(filemenu, "&File")
+		menubar.Append(optionmenu, "&Options")
+		self.SetMenuBar(menubar)
+
+		
+		panel.SetSizer(sizer)
+		panel.SetAutoLayout(True)
+		sizer.Fit(panel)
+
+		self.Show(True)
+
+		if self.mc == None:
+			self.evt_cmd_open()
+
+	def _close_mc(self):
+		if self.mc != None:
+			try:
+				self.mc.close()
+			except EnvironmentError, value:
+				self.mc_error(value)
+			self.mc = None
+		if self.f != None:
+			try:
+				self.f.close()
+			except EnvironmentError, value:
+				self.mc_error(value)
+			self.f = None
+		self.mcname = None
+		
+	def refresh(self):
+		try:
+			self.dirlist.update(self.mc)
+		except EnvironmentError, value:
+			self.mc_error(value)
+			self._close_mc()
+			self.dirlist.update(None)
+
+		mc = self.mc
+		
+		self.toolbar.EnableTool(self.ID_CMD_IMPORT, mc != None)
+		self.toolbar.EnableTool(self.ID_CMD_EXPORT, False)
+
+		if mc == None:
+			status = "No memory card image"
+		else:
+			free = mc.get_free_space() / 1024
+			limit = mc.get_allocatable_space() / 1024
+			status = "%dK of %dK free" % (free, limit)
+		self.statusbar.SetStatusText(status, 1)
+
+	def open_mc(self, filename):
+		self._close_mc()
+		self.statusbar.SetStatusText("", 1)
+		if self.icon_win != None:
+			self.icon_win.load_icon(None, None)
+		
+		f = None
+		try:
+			f = file(filename, "r+b")
+			mc = ps2mc.ps2mc(f)
+		except EnvironmentError, value:
+			if f != None:
+				f.close()
+			self.mc_error(value, filename)
+			self.SetTitle(self.title)
+			self.refresh()
+			return
+
+		self.f = f
+		self.mc = mc
+		self.mcname = filename
+		self.SetTitle(filename + " - " + self.title)
+		self.refresh()
+
+	def evt_menu_open(self, event):
+		self.import_menu_item.Enable(self.mc != None)
+		selected = self.mc != None and len(self.dirlist.selected) > 0
+		self.export_menu_item.Enable(selected)
+		self.delete_menu_item.Enable(selected)
+		self.ascii_menu_item.Check(self.config.get_ascii())
+		if self.icon_win != None:
+			self.icon_win.update_menu(self.icon_menu)
+
+	def evt_dirlist_item_focused(self, event):
+		if self.icon_win == None:
+			return
+		
+		mc = self.mc
+
+		i = event.GetData()
+		(ent, icon_sys, size, title) = self.dirlist.dirtable[i]
+		self.info1.SetLabel(title[0])
+		self.info2.SetLabel(title[1])
+
+		a = ps2save.unpack_icon_sys(icon_sys)
+		try:
+			mc.chdir("/" + ent[8])
+			f = mc.open(a[15], "rb")
+			try: 
+				icon = f.read()
+			finally:
+				f.close()
+		except EnvironmentError, value:
+			print "icon failed to load", value
+			self.icon_win.load_icon(None, None)
+			return
+
+		self.icon_win.load_icon(icon_sys, icon)
+
+	def evt_dirlist_select(self, event):
+		self.toolbar.EnableTool(self.ID_CMD_IMPORT, self.mc != None)
+		self.toolbar.EnableTool(self.ID_CMD_EXPORT,
+					len(self.dirlist.selected) > 0)
+
+	def evt_cmd_open(self, event = None):
+		fn = wx.FileSelector("Open Memory Card Image",
+				     self.config.get_memcard_dir(""),
+				     "Mcd001.ps2", "ps2", "*.ps2",
+				     wx.FD_FILE_MUST_EXIST | wx.FD_OPEN,
+				     self)
+		if fn == "":
+			return
+		self.open_mc(fn)
+		if self.mc != None:
+			dirname = os.path.dirname(fn)
+			if os.path.isabs(dirname):
+				self.config.set_memcard_dir(dirname)
+
+	def evt_cmd_export(self, event):
+		mc = self.mc
+		if mc == None:
+			return
+		
+		selected = self.dirlist.selected
+		dirtable = self.dirlist.dirtable
+		sfiles = []
+		for i in selected:
+			dirname = dirtable[i][0][8]
+			try:
+				sf = mc.export_save_file("/" + dirname)
+				longname = ps2save.make_longname(dirname, sf)
+				sfiles.append((dirname, sf, longname))
+			except EnvironmentError, value:
+				self.mc_error(value. dirname)
+
+		if len(sfiles) == 0:
+			return
+		
+		dir = self.config.get_savefile_dir("")
+		if len(selected) == 1:
+			(dirname, sf, longname) = sfiles[0]
+			fn = wx.FileSelector("Export " + dirname,
+					     dir, longname, "psu",
+					     "EMS save file (.psu)|*.psu"
+					     "|MAXDrive save file (.max)"
+					     "|*.max",
+					     (wx.FD_OVERWRITE_PROMPT
+					      | wx.FD_SAVE),
+					     self)
+			if fn == "":
+				return
+			try:
+				f = file(fn, "wb")
+				try:
+					if fn.endswith(".max"):
+						sf.save_max_drive(f)
+					else:
+						sf.save_ems(f)
+				finally:
+					f.close()
+			except EnvironmentError, value:
+				self.mc_error(value, fn)
+				return
+
+			dir = os.path.dirname(fn)
+			if os.path.isabs(dir):
+				self.config.set_savefile_dir(dir)
+
+			self.message_box("Exported " + fn + " successfully.")
+			return
+		
+		dir = wx.DirSelector("Export Save Files", dir, parent = self)
+		if dir == "":
+			return
+		count = 0
+		for (dirname, sf, longname) in sfiles:
+			fn = os.path.join(dir, longname) + ".psu"
+			try:
+				f = file(fn, "wb")
+				sf.save_ems(f)
+				f.close()
+				count += 1
+			except EnvironmentError, value:
+				self.mc_error(value, fn)
+		if count > 0:
+			if os.path.isabs(dir):
+				self.config.set_savefile_dir(dir)
+			self.message_box("Exported %d file(s) successfully."
+					 % count)
+			
+
+	def _do_import(self, fn):
+		sf = ps2save.ps2_save_file()
+		f = file(fn, "rb")
+		try:
+			ft = ps2save.detect_file_type(f)
+			f.seek(0)
+			if ft == "max":
+				sf.load_max_drive(f)
+			elif ft == "psu":
+				sf.load_ems(f)
+			elif ft == "cbs":
+				sf.load_codebreaker(f)
+			elif ft == "sps":
+				sf.load_sharkport(f)
+			elif ft == "npo":
+				self.error_box(fn + ": nPort saves"
+					       " are not supported.")
+				return
+			else:
+				self.error_box(fn + ": Save file format not"
+					       " recognized.")
+				return
+		finally:
+			f.close()
+
+		if not self.mc.import_save_file(sf, True):
+			self.error_box(fn + ": Save file already present.")
+		
+	def evt_cmd_import(self, event):
+		if self.mc == None:
+			return
+		
+		dir = self.config.get_savefile_dir("")
+		fd = wx.FileDialog(self, "Import Save File", dir,
+				   wildcard = ("PS2 save files"
+					       " (.cbs;.psu;.max;.sps;.xps)"
+					       "|*.cbs;*.psu;*.max;*.sps;*.xps"
+					       "|All files|*.*"),
+				   style = (wx.FD_OPEN | wx.FD_MULTIPLE
+					    | wx.FD_FILE_MUST_EXIST))
+		if fd == None:
+			return
+		r = fd.ShowModal()
+		if r == wx.ID_CANCEL:
+			return
+
+		success = None
+		for fn in fd.GetPaths():
+			try:
+				self._do_import(fn)
+				success = fn
+			except EnvironmentError, value:
+				self.mc_error(value, fn)
+
+		if success != None:
+			dir = os.path.dirname(success)
+			if os.path.isabs(dir):
+				self.config.set_savefile_dir(dir)
+		self.refresh()
+
+	def evt_cmd_delete(self, event):
+		mc = self.mc
+		if mc == None:
+			return
+		
+		selected = self.dirlist.selected
+		dirtable = self.dirlist.dirtable
+
+		dirnames = [dirtable[i][0][8]
+			    for i in selected]
+		if len(selected) == 1:
+			title = dirtable[list(selected)[0]][3]
+			s = dirnames[0] + " (" + single_title(title) + ")"
+		else:
+			s = ", ".join(dirnames)
+			if len(s) > 200:
+				s = s[:200] + "..."
+		r = self.message_box("Are you sure you want to delete "
+				     + s + "?",
+				     "Delete Save File Confirmation",
+				     wx.YES_NO)
+		if r != wx.YES:
+			return
+
+		for dn in dirnames:
+			try:
+				mc.rmdir("/" + dn)
+			except EnvironmentError, value:
+				self.mc_error(value, dn)
+
+		mc.check()
+		self.refresh()
+
+	def evt_cmd_ascii(self, event):
+		self.config.set_ascii(not self.config.get_ascii())
+		self.refresh()
+		
+	def evt_cmd_exit(self, event):
+		self.Close(True)
+
+	def evt_close(self, event):
+		self._close_mc()
+		self.Destroy()
+		
+def run(filename = None):
+	"""Display a GUI for working with memory card images."""
+
+	wx_app = wx.PySimpleApp()
+	frame = gui_frame(None, "mymc", filename)
+	return wx_app.MainLoop()
+	
+if __name__ == "__main__":
+	import gc
+	gc.set_debug(gc.DEBUG_LEAK)
+
+	run("test.ps2")
+
+ 	gc.collect()
+ 	for o in gc.garbage:
+ 		print 
+ 		print o
+ 		if type(o) == ps2mc.ps2mc_file:
+ 			for m in dir(o):
+ 				print m, getattr(o, m)
+
+
+# 	while True:
+# 		for o in gc.garbage:
+# 			if type(o) == ps2mc.ps2mc_file:
+# 				for m in dir(o):
+# 					if getattr(o, m) == None:
+# 						continue
+# 					if (m == "__del__"
+# 					    or m == "__class__"
+# 					    or m == "__dict__"
+# 					    or m == "__weakref__"):
+# 						continue
+# 					print m
+# 					setattr(o, m, None)
+# 					o = None
+# 					break
+# 				break
+# 		del gc.garbage[:]
+# 		gc.collect()

guires.py

@@ -0,0 +1,185 @@
+resources = {
+	"mc4.ico": (
+		"AAABAAIAICAQAAAAAADoAgAAJgAAADAwAAEAAAAAqA4AAA4DAAAoAAAAIAAAAEAAAAABAAQAAAAA\n"
+		"AIACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAgAAAAICAAIAAAACAAIAAgIAAAICAgADAwMAA\n"
+		"AAD/AAD/AAAA//8A/wAAAP8A/wD//wAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAcABwAAAAAAAAAAAAAAAABwAABwAAAAAAAAAAAAAAAHAAYAB3d3d3dwAAAAAAAAcABm\n"
+		"YAB3d3dwAAAAAAAABwAGZmYAB3d3AAAAAAAAAHAAZmZmYAB4iIiIiIiAAAcABmZmZgAAB/+P+q/4\n"
+		"gABwAGZmZmAAAABu7u7u6IAHAAZmZmYAAAAABu7u7u6AAABmZmZgBwcAAABu7u7ugAAGZmZmAHBw\n"
+		"AAAABu7u7oAAAGZmYAcHBwAAAABu7u6ABwAGZgBwcHBwAAAABu7ugAAAAGAABwcHAABAAADu7oAA\n"
+		"AAAAAHB3cAAEAAAG7u6AAAAAAAAAB3AAwAAAbu7ugAAABwAAAAAABAAABu7u7oAAAAhgAAAAAMAH\n"
+		"AG7u7u6AAAAI5gAAAAAAdwbu7u7ugAAACO5gAAxAAABu7u7u7oAAAAju5gAEzAAG7u7u7u6AAAAI\n"
+		"7u5gAAwAbu7u7u7ugAAACO7u5gAABu7u7u7u7oAAAAju7u5gAG7u7u7u7u6AAAAI7u7u5gbu7u7u\n"
+		"7u7ugAAACI7u7u7u7u7u7u7u6IAAAAiIiIiIiIiIiIiIiIiAAAAIiIiIiIiIiIiIiIiIgAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////g////wH///4AAH/8AAH/+AAD//AA\n"
+		"AAHgAAABwAAAAYAAAAGAAAABgAAAAYAAAAGAAAAB4AAAAfAAAAH4AAAB+AAAAfgAAAH4AAAB+AAA\n"
+		"AfgAAAH4AAAB+AAAAfgAAAH4AAAB+AAAAfgAAAH4AAAB//////////8oAAAAMAAAAGAAAAABAAgA\n"
+		"AAAAAIAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAgAAAAICAAIAAAACAAIAAgIAAAMDAwADA\n"
+		"3MAA8MqmAAAgQAAAIGAAACCAAAAgoAAAIMAAACDgAABAAAAAQCAAAEBAAABAYAAAQIAAAECgAABA\n"
+		"wAAAQOAAAGAAAABgIAAAYEAAAGBgAABggAAAYKAAAGDAAABg4AAAgAAAAIAgAACAQAAAgGAAAICA\n"
+		"AACAoAAAgMAAAIDgAACgAAAAoCAAAKBAAACgYAAAoIAAAKCgAACgwAAAoOAAAMAAAADAIAAAwEAA\n"
+		"AMBgAADAgAAAwKAAAMDAAADA4AAA4AAAAOAgAADgQAAA4GAAAOCAAADgoAAA4MAAAODgAEAAAABA\n"
+		"ACAAQABAAEAAYABAAIAAQACgAEAAwABAAOAAQCAAAEAgIABAIEAAQCBgAEAggABAIKAAQCDAAEAg\n"
+		"4ABAQAAAQEAgAEBAQABAQGAAQECAAEBAoABAQMAAQEDgAEBgAABAYCAAQGBAAEBgYABAYIAAQGCg\n"
+		"AEBgwABAYOAAQIAAAECAIABAgEAAQIBgAECAgABAgKAAQIDAAECA4ABAoAAAQKAgAECgQABAoGAA\n"
+		"QKCAAECgoABAoMAAQKDgAEDAAABAwCAAQMBAAEDAYABAwIAAQMCgAEDAwABAwOAAQOAAAEDgIABA\n"
+		"4EAAQOBgAEDggABA4KAAQODAAEDg4ACAAAAAgAAgAIAAQACAAGAAgACAAIAAoACAAMAAgADgAIAg\n"
+		"AACAICAAgCBAAIAgYACAIIAAgCCgAIAgwACAIOAAgEAAAIBAIACAQEAAgEBgAIBAgACAQKAAgEDA\n"
+		"AIBA4ACAYAAAgGAgAIBgQACAYGAAgGCAAIBgoACAYMAAgGDgAICAAACAgCAAgIBAAICAYACAgIAA\n"
+		"gICgAICAwACAgOAAgKAAAICgIACAoEAAgKBgAICggACAoKAAgKDAAICg4ACAwAAAgMAgAIDAQACA\n"
+		"wGAAgMCAAIDAoACAwMAAgMDgAIDgAACA4CAAgOBAAIDgYACA4IAAgOCgAIDgwACA4OAAwAAAAMAA\n"
+		"IADAAEAAwABgAMAAgADAAKAAwADAAMAA4ADAIAAAwCAgAMAgQADAIGAAwCCAAMAgoADAIMAAwCDg\n"
+		"AMBAAADAQCAAwEBAAMBAYADAQIAAwECgAMBAwADAQOAAwGAAAMBgIADAYEAAwGBgAMBggADAYKAA\n"
+		"wGDAAMBg4ADAgAAAwIAgAMCAQADAgGAAwICAAMCAoADAgMAAwIDgAMCgAADAoCAAwKBAAMCgYADA\n"
+		"oIAAwKCgAMCgwADAoOAAwMAAAMDAIADAwEAAwMBgAMDAgADAwKAA8Pv/AKSgoACAgIAAAAD/AAD/\n"
+		"AAAA//8A/wAAAP8A/wD//wAA////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAKQAAKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAApAAAAACkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACk\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKQAAAAAAAAApAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAApAAAAAAACQAAAACkpKSkpKSkpKSk\n"
+		"pKSkpAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkAAAAAAAJCQkAAACkpKSkpKSkpKSkpKQAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAKQAAAAAAAkJCQkJAAAAAKSkpKSkpKQAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAApAAAAAAACQkJCQkJCQAAAACkpKSkpKQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkAAAA\n"
+		"AAAJCQkJCQkJCQkAAAAApPf39/f39/f39/f39/f39/f39/cAAAAAAAAAAKQAAAAAAAkJCQkJCQkJ\n"
+		"CQkJAAAAAKQHBwf3BwcH9/f39wcHB/f39/cAAAAAAAAApAAAAAAACQkJCQkJCQkJCQkAAAAAAACk\n"
+		"9vb39vb29/r69/b29vf39/cAAAAAAACkAAAAAAAJCQkJCQkJCQkJCQAAAAAAAAAApPf39/f39/f3\n"
+		"9/f39/f39/cAAAAAAKQAAAAAAAkJCQkJCQkJCQkJAAAAAAAAAAAAAKT39/f39/f39/f39/f39/cA\n"
+		"AAAApAAAAAAACQkJCQkJCQkJCQkAAAAAAAAAAAAAAAD3/v7+/v7+/v7+/v739/cAAACkAAAAAAAJ\n"
+		"CQkJCQkJCQkJCQAApAAApAAAAAAAAAAAB/7+/v7+/v7+/v7+9/cAAAAAAAAAAAkJCQkJCQkJCQkJ\n"
+		"AACkAACkAAAAAAAAAAAAAAf+/v7+/v7+/v7+9/cAAAAAAAAACQkJCQkJCQkJCQkAAKQAAKQAAAAA\n"
+		"AAAAAAAAAAAH/v7+/v7+/v7+9/cAAACkAAAAAAkJCQkJCQkJCQAApAAApAAAAKQAAAAAAAAAAAAA\n"
+		"B/7+/v7+/v7+9/cAAAAApAAAAAAJCQkJCQkJAACkAACkAAAApACkAAAAAAAAAAAAAAf+/v7+/v7+\n"
+		"9/cAAAAAAACkAAAACQkJCQkAAKQAAKQAAACkAKQAAAAAAAAAAAAAAAAH/v7+/v7+9/cAAAAAAAAA\n"
+		"AAAAAAkJCQAAAAAApAAAAAAApAAAAAAAAADAAAAAAAAAB/7+/v7+9/cAAAAAAAAAAKQAAAAJAAAA\n"
+		"AACkAAAKpKQAAAAAAAAAAMAAAAAAAAAAAP7+/v7+9/cAAAAAAAAAAAAAAAAAAAAAAKQAAACkAKSk\n"
+		"AAAAAAAAwAAAAAAAAAAAB/7+/v7+9/cAAAAAAAAAAACkAAAAAAAAAAAAAACkpACkAAAAAADAAAAA\n"
+		"AAAAAAAH/v7+/v7+9/cAAAAAAAAAAAD3pAAAAAAAAAAAAAAApKQKAAAAAMDAAAAAAAAAAAf+/v7+\n"
+		"/v7+9/cAAAAAAAAAAAD39wcAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAAB/7+/v7+/v7+9/cAAAAA\n"
+		"AAAAAAD39/4HAAAAAAAAAAAAAAAAAADAAAAACqQAAAAH/v7+/v7+/v7+9/cAAAAAAAAAAAD39/7+\n"
+		"BwAAAAAAAAAAAAAAAMDAAAAKpAoAAAf+/v7+/v7+/v7+9/cAAAAAAAAAAAD39/7+/gcAAAAAAAAA\n"
+		"AAAAAAAAAAqkpAAAB/7+/v7+/v7+/v7+9/cAAAAAAAAAAAD39/7+/v4HAAAAAAAAAAAAAAAAAKQK\n"
+		"AAAH/v7+/v7+/v7+/v7+9/cAAAAAAAAAAAD39/7+/v7+BwAAAAAAwADAAAAAAAAAAAf+/v7+/v7+\n"
+		"/v7+/v7+9/cAAAAAAAAAAAD39/7+/v7+/gcAAAAAAMDAwAAAAAAAB/7+/v7+/v7+/v7+/v7+9/cA\n"
+		"AAAAAAAAAAD39/7+/v7+/v4HAAAAwAAAwAAAAAAH/v7+/v7+/v7+/v7+/v7+9/cAAAAAAAAAAAD3\n"
+		"9/7+/v7+/v7+BwAAAAAAwAAAAAf+/v7+/v7+/v7+/v7+/v7+9/cAAAAAAAAAAAD39/7+/v7+/v7+\n"
+		"/gcAAAAAAAAAB/7+/v7+/v7+/v7+/v7+/v7+9/cAAAAAAAAAAAD39/7+/v7+/v7+/v4HAAAAAAAH\n"
+		"/v7+/v7+/v7+/v7+/v7+/v7+9/cAAAAAAAAAAAD39/7+/v7+/v7+/v7+BwAAAAf+/v7+/v7+/v7+\n"
+		"/v7+/v7+/v7+9/cAAAAAAAAAAAD39/7+/v7+/v7+/v7+/gcAB/7+/v7+/v7+/v7+/v7+/v7+/v7+\n"
+		"9/cAAAAAAAAAAAD39/7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+9/cAAAAAAAAA\n"
+		"AAD39/f+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v7+/v739/cAAAAAAAAAAAD3+/v79/f3\n"
+		"9/f39/f39/f39/f39/f39/f39/f39/f39/f39/f39/cAAAAAAAAAAAD30NDQ9/f39/f39/f39/f3\n"
+		"9/f39/f39/f39/f39/f396SkpKSk9/cAAAAAAAAAAAD3+ff59/f39/f39/f39/f39/f39/f39/f3\n"
+		"9/f39/f39/f39/f39/cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///////wAA////\n"
+		"////AAD//h////8AAP/8D////wAA//gP////AAD/8Af///8AAP/gAAAP/wAA/8AAAD//AAD/gAAB\n"
+		"//8AAP8AAAH//wAA/gAAAAADAAD8AAAAAAMAAPgAAAAAAwAA8AAAAAADAADgAAAAAAMAAMAAAAAA\n"
+		"AwAAgAAAAAADAACAAAAAAAMAAIAAAAAAAwAAgAAAAAADAADAAAAAAAMAAPAAAAAAAwAA+AAAAAAD\n"
+		"AAD8AAAAAAMAAP4AAAAAAwAA/gAAAAADAAD+AAAAAAMAAP4AAAAAAwAA/gAAAAADAAD+AAAAAAMA\n"
+		"AP4AAAAAAwAA/gAAAAADAAD+AAAAAAMAAP4AAAAAAwAA/gAAAAADAAD+AAAAAAMAAP4AAAAAAwAA\n"
+		"/gAAAAADAAD+AAAAAAMAAP4AAAAAAwAA/gAAAAADAAD+AAAAAAMAAP4AAAAAAwAA/gAAAAADAAD+\n"
+		"AAAAAAMAAP///////wAA////////AAD///////8AAA==\n"
+	).decode("base64_codec"),
+	"mc5b.ico": (
+		"AAABAAEAICAQAAAAAADoAgAAFgAAACgAAAAgAAAAQAAAAAEABAAAAAAAgAIAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAgICAAMDAwAAAAP8AAP8AAAD//wD/AAAA\n"
+		"/wD/AP//AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcABwAAAAAAAAAAAAAAAABwAAAAAAAAAAAAAAAAAA\n"
+		"AHAAYAAAAAAAAAAAAAAAAAcABmYAAAAAAAAAAAAAAKBwAGZmYABwAAAAAAAAAACqAAZmZmYABwAA\n"
+		"AAAAAAAAqqBmZmZgAABwAAAAAAAAB6qqZmZmAAAABwAACqqqqqqiqqZmYAAAAABwAAqqqqqqoiqq\n"
+		"ZgBwcAAABwAKoiIiIiIiqqAHBwAAAABwCqIiIiIiIiqqcHBwAAAABwqiIiIiIiIqqgcHBwAAAAAK\n"
+		"oiIiIiIiqqBwcHAABAAACqqqqqqiKqoHB3cAAEAAAAqqqqqqoqqgAAB3AAwAAAcAAAAAAKqqAAAA\n"
+		"AABAAABwAAAAAACqpwAAAAAMAHAHAAAAAAAAqgBwAAAAAAdwcAAAAAAAAKAABwAAxAAABwAAAAAA\n"
+		"AAAAAABwAEzAAHAAAAAAAAAAAAAABwAAwAcAAAAAAAAAAAAAAABwAABwAAAAAAAAAAAAAAAABwAH\n"
+		"AAAAAAAAAAAAAAAAAABwcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAD///////////////////////8H///+B////AP///gB///QAH//wAA//8AAH/+A\n"
+		"AA+AAAAHgAAAA4AAAAGAAAAAgAAAAIAAAACAAAAAgAAAAP/AAAH/wAAD/8wAB//eAA///wAf//+A\n"
+		"P///wH///+D////x/////////////////w==\n"
+	).decode("base64_codec"),
+	"mc2.ico": (
+		"AAABAAEAMDAAAQAAAACoDgAAFgAAACgAAAAwAAAAYAAAAAEACAAAAAAAgAoAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAwMDAAMDcwADwyqYAACBAAAAgYAAAIIAA\n"
+		"ACCgAAAgwAAAIOAAAEAAAABAIAAAQEAAAEBgAABAgAAAQKAAAEDAAABA4AAAYAAAAGAgAABgQAAA\n"
+		"YGAAAGCAAABgoAAAYMAAAGDgAACAAAAAgCAAAIBAAACAYAAAgIAAAICgAACAwAAAgOAAAKAAAACg\n"
+		"IAAAoEAAAKBgAACggAAAoKAAAKDAAACg4AAAwAAAAMAgAADAQAAAwGAAAMCAAADAoAAAwMAAAMDg\n"
+		"AADgAAAA4CAAAOBAAADgYAAA4IAAAOCgAADgwAAA4OAAQAAAAEAAIABAAEAAQABgAEAAgABAAKAA\n"
+		"QADAAEAA4ABAIAAAQCAgAEAgQABAIGAAQCCAAEAgoABAIMAAQCDgAEBAAABAQCAAQEBAAEBAYABA\n"
+		"QIAAQECgAEBAwABAQOAAQGAAAEBgIABAYEAAQGBgAEBggABAYKAAQGDAAEBg4ABAgAAAQIAgAECA\n"
+		"QABAgGAAQICAAECAoABAgMAAQIDgAECgAABAoCAAQKBAAECgYABAoIAAQKCgAECgwABAoOAAQMAA\n"
+		"AEDAIABAwEAAQMBgAEDAgABAwKAAQMDAAEDA4ABA4AAAQOAgAEDgQABA4GAAQOCAAEDgoABA4MAA\n"
+		"QODgAIAAAACAACAAgABAAIAAYACAAIAAgACgAIAAwACAAOAAgCAAAIAgIACAIEAAgCBgAIAggACA\n"
+		"IKAAgCDAAIAg4ACAQAAAgEAgAIBAQACAQGAAgECAAIBAoACAQMAAgEDgAIBgAACAYCAAgGBAAIBg\n"
+		"YACAYIAAgGCgAIBgwACAYOAAgIAAAICAIACAgEAAgIBgAICAgACAgKAAgIDAAICA4ACAoAAAgKAg\n"
+		"AICgQACAoGAAgKCAAICgoACAoMAAgKDgAIDAAACAwCAAgMBAAIDAYACAwIAAgMCgAIDAwACAwOAA\n"
+		"gOAAAIDgIACA4EAAgOBgAIDggACA4KAAgODAAIDg4ADAAAAAwAAgAMAAQADAAGAAwACAAMAAoADA\n"
+		"AMAAwADgAMAgAADAICAAwCBAAMAgYADAIIAAwCCgAMAgwADAIOAAwEAAAMBAIADAQEAAwEBgAMBA\n"
+		"gADAQKAAwEDAAMBA4ADAYAAAwGAgAMBgQADAYGAAwGCAAMBgoADAYMAAwGDgAMCAAADAgCAAwIBA\n"
+		"AMCAYADAgIAAwICgAMCAwADAgOAAwKAAAMCgIADAoEAAwKBgAMCggADAoKAAwKDAAMCg4ADAwAAA\n"
+		"wMAgAMDAQADAwGAAwMCAAMDAoADw+/8ApKCgAICAgAAAAP8AAP8AAAD//wD/AAAA/wD/AP//AAD/\n"
+		"//8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKQAAKQAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACkpKSkpKSkpAAAAACkpKSkpKSkpKSkpKSkpKSkpKSkpKSk\n"
+		"pKQAAAAAAAAAAAAAAKSkpKSkpKQAAAAAAAAApKSkpKSkpKSkpKSkpKSkpKSkpKSkpKSkAAAAAAAA\n"
+		"AAAAAKSkpKSkpAcAAAAAAAAAB6SkpKSkpKSkpKSkpKSkpKSkpKSkpKSkAAAAAAAAAAAAAKSkpKSk\n"
+		"BwAAAAAACQAAAACkpKSkpKSkpKSkpKSkpKSkpKQAAACkAAAAAAAAAAAAAKSkpKQHAAAAAAAJCQkA\n"
+		"AAAHpKSkpKSkpKSkpKSkpKSkpKQAAACkAAAAAAAAAAAAAKSkpAcAAAAAAAkJCQkJAAAAAAekpKSk\n"
+		"pKSkpKSkpKSkpKQAAACkAAAAAAAAAAAAAKSkBwAAAAAACQkJCQkJCQAAAAAHpKSkpKSkpKSkpKSk\n"
+		"pKSkpKSkAAAAAAAAAAAAAKQAAAAAAAAJCQkJCQkJCQkAAAAAB6SkpKSkpKSkpKSkpKSkpKSkAAAA\n"
+		"AAAAAAAAAKQAAAAAAAkJCQkJCQkJCQkJAAAAAAekpKSkpKSkpKSkpKSkpKSkAAAAAAAAAAAApAAA\n"
+		"AAAACQkJCQkJCQkJCQkAAAAAAAAHpKSkpKSkpKSkpKSkpKSkAAAAAAAAAACkAAAAAAAJCQkJCQkJ\n"
+		"CQkJCQAAAAAAAAAAB6SkpKSkpKSkpKSkpKSkAAAAAAAAAKQAAAAAAAkJCQkJCQkJCQkJAAAAAAAA\n"
+		"AAAAAAekpKSkpKSkpKSkpKSkAAAAAAAApAAAAAAACQkJCQkJCQkJCQkAAAAAAAAAAAAAAAAHpKSk\n"
+		"pKSkpKSkpKSkAAAAAACkAAAAAAAJCQkJCQkJCQkJCQAApAAApAAAAAAAAAAAB6SkpKSkpKSkpKSk\n"
+		"AAAAAAAAAAAAAAkJCQkJCQkJCQkJAACkAACkAAAAAAAAAAAAAAekpKSkpKSkpKSkAAAAAAAAAAAA\n"
+		"CQkJCQkJCQkJCQkAAKQAAKQAAAAAAAAAAAAAAAAHpKSkpKSkpKSkAAAAAACkAAAAAAkJCQkJCQkJ\n"
+		"CQAApAAApAAAAKQAAAAAAAAAAAAAB6SkpKSkpKSkAAAAAAAApAAAAAAJCQkJCQkJAACkAACkAAAA\n"
+		"pACkAAAAAAAAAAAAAAekpKSkpKSkAAAAAAAAAACkAAAACQkJCQkAAKQAAKQAAACkAKQAAAAAAAAA\n"
+		"AAAAAAAHpKSkpKSkAAAAAAAAAAAAAAAAAAkJCQAAAAAApAAAAAAApAAAAAAAAADAAAAAAAAAB6Sk\n"
+		"pKSkAAAAAAAAAAAAAAAAAAAJAAAAAACkAAAKpKQAAAAAAAAAAMAAAAAAAAAAAKSkpKSkAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAKQAAACkAKSkAAAAAAAAwAAAAAAAAAAAB6SkpKSkAAAAAAAAAAAAAKQAAAAA\n"
+		"AAAAAAAAAACkpACkAAAAAADAAAAAAAAAAAAHpKSkpKSkAAAAAAAAAAAAAKSkBwAAAAAAAAAAAAAA\n"
+		"pKQKAAAAAMDAAAAAAAAAAAekpKSkpKSkAAAAAAAAAAAAAKSkpAcAAAAAAAAAAAAAAAAAAAAAwAAA\n"
+		"AAAAAAAAB6SkpKSkpKSkAAAAAAAAAAAAAKSkpKQHAAAAAAAAAAAAAAAAAADAAAAACqQAAAAHpKSk\n"
+		"pKSkpKSkAAAAAAAAAAAAAKSkpKSkBwAAAAAAAAAAAAAAAMDAAAAKpAoAAAekpKSkpKSkpKSkAAAA\n"
+		"AAAAAAAAAKSkpKSkpAcAAAAAAAAAAAAAAAAAAAqkpAAAB6SkpKSkpKSkpKSkAAAAAAAAAAAAAKSk\n"
+		"pKSkpKQHAAAAAAAAAAAAAAAAAKQKAAD3pKSkpKSkpKSkpKSkAAAAAAAAAAAAAKSkpKSkpKSk9wAA\n"
+		"AAAAwADAAAAAAAAAAPf39/f396SkpKSkpKSkAAAAAAAAAAAAAKSkpKSkpKSk9/cAAAAAAMDAwAAA\n"
+		"AAAAB6SkpPf396SkpKSkpKSkAAAAAAAAAAAAAKSkpKSkpKSk9/f3AAAAwAAAwAAAAACkpKSkpPf3\n"
+		"96SkpKSkpKSkAAAAAAAAAAAAAKSkpKSkpKSk9/f39wAAAAAAwAAAAPekpKSkpPf396SkpKSkpKSk\n"
+		"AAAAAAAAAAAAAKSkpKSkpKSk9/f39/cAAAAAAAAA9/ekpKSkpPf396SkpKSkpKSkAAAAAAAAAAAA\n"
+		"AKSkpKSkpKSk9/f39/f3AAAAAAD39/ekpKSkpPf396SkpKSkpKSkAAAAAAAAAAAAAKSkpKSkpKSk\n"
+		"9/f39/f39wAAAPf39/ekpKSkpPf396SkpKSkpKSkAAAAAAAAAAAAAKSkpKSkpKSk9/f39/f39/cA\n"
+		"9/f39/ekpKSkpPf396SkpKSkpKSkAAAAAAAAAAAAAKSkpKSkpKSk9/f39/f39/f39/f39/ekpKSk\n"
+		"pPf396SkpKSkpKSkAAAAAAAAAAAAAKSkpKSkpKSk9/f39/f39/f39/f39/ekpKSkpPf396SkpKSk\n"
+		"pKQAAAAAAAAAAAAAAKSkpKSkpKSk9/f39/f39/f39/f39/ekpKSkpPf396SkpKSkpAAA9gAAAAAA\n"
+		"AAAAAACkpKSkpKSk9/f39/f39/f39/f39/f39/f39/f396SkpKSkAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////AAD///////8AAP///////wAA////////\n"
+		"AAD//w////8AAP8AAAAADwAA/gAAAAAHAAD+AAAAAAcAAP4AAAAABwAA/gAAAAAHAAD+AAAAAAcA\n"
+		"AP4AAAAABwAA/gAAAAAHAAD+AAAAAAcAAPwAAAAABwAA+AAAAAAHAADwAAAAAAcAAOAAAAAABwAA\n"
+		"wAAAAAAHAADAAAAAAAcAAMAAAAAABwAAwAAAAAAHAADgAAAAAAcAAPgAAAAABwAA/AAAAAAHAAD+\n"
+		"AAAAAAcAAP4AAAAABwAA/gAAAAAHAAD+AAAAAAcAAP4AAAAABwAA/gAAAAAHAAD+AAAAAAcAAP4A\n"
+		"AAAABwAA/gAAAAAHAAD+AAAAAAcAAP4AAAAABwAA/gAAAAAHAAD+AAAAAAcAAP4AAAAABwAA/gAA\n"
+		"AAAHAAD+AAAAAAcAAP4AAAAABwAA/gAAAAAHAAD+AAAAAA8AAP4AAAAAGwAA/wAAAAA/AAD/////\n"
+		"//sAAP///////wAA\n"
+	).decode("base64_codec"),
+	"mc6a.ico": (
+		"AAABAAEAICAQAAAAAADoAgAAFgAAACgAAAAgAAAAQAAAAAEABAAAAAAAgAIAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAACAAACAAAAAgIAAgAAAAIAAgACAgAAAgICAAMDAwAAAAP8AAP8AAAD//wD/AAAA\n"
+		"/wD/AP//AAD///8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAABwAHAAAAAAAAAAAAAAAAAHAAAAAAAAAAAAAAAAAAAAcABg\n"
+		"AAAAAAAAAAAAAAAABwAGZgAAAAAAAAAAAAAAAHAAZmZgAHAAAACgAAAAAAcABmZmZgAHAAAAqgAA\n"
+		"AABwAGZmZmAAAHAAAKqgAAAHAAZmZmYAAAAHAACqqgAAcABmZmZgAAqqqqqqoqqgAAAGZmZmAHB6\n"
+		"qqqqqqIqqgAAZmZmYAcHCqIiIiIiIqqgAAZmZgBwcHqiIiIiIiIqqnAAZmAHBwcKoiIiIiIiKqoA\n"
+		"AAYAAHBweqIiIiIiIqqgAAAAAAcHdwqqqqqqoiqqAAAAAAAAAHcKqqqqqqKqoAAAAHAAAAAAAEAA\n"
+		"AHCqqgAAAAAHAAAAAAwAcAcAqqAAAAAAAHAAAAAAB3BwAKoAAAAAAAAHAADEAAAHAACgAAAAAAAA\n"
+		"AHAATMAAcAAAAAAAAAAAAAAHAADABwAAAAAAAAAAAAAAAHAAAHAAAAAAAAAAAAAAAAAHAAcAAAAA\n"
+		"AAAAAAAAAAAAAHBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
+		"AAAAAAAAAAAAAAD//////////////////////wf///4H///8A///+AH///AAf3/gAD8/wAAfH4AA\n"
+		"Dw8AAAAHAAAAAwAAAAEAAAAAAAAAAMAAAAHgAAAD8AAAB/AAAQ/4AAMf/AAHP/4AD3//AB///4A/\n"
+		"///Af///4P////H//////////////////w==\n"
+	).decode("base64_codec"),
+}

lzari.py

@@ -0,0 +1,787 @@
+#
+# lzari.py
+#
+# By Ross Ridge
+#
+
+"""
+Implementation of Haruhiko Okumura's LZARI data compression algorithm
+in Python.  Largely based on LZARI.C, one key difference is the use of
+a two level dicitionary look up during compression rather than
+LZARI.C's binary search tree.
+"""
+
+_SCCS_ID = "@(#) mysc lzari.py 1.5 08/02/05 16:00:34\n"
+
+import sys
+import array
+import binascii
+import string
+import time
+from bisect import bisect_right
+from math import log
+
+try:
+	import ctypes
+	import mymcsup
+except ImportError:
+	mymcsup = None
+
+hexlify = binascii.hexlify
+
+__ALL__ = ['lzari_codec', 'string_to_bit_array', 'bit_array_to_string']
+
+#
+# Fundamental constants of the LZARI compression alogorithm.
+#
+# Changing any of these values will create an incompatible implementation.
+#
+
+HIST_LEN = 4096
+MIN_MATCH_LEN = 3
+MAX_MATCH_LEN = 60
+
+ARITH_BITS = 15
+QUADRANT1 = 1 << ARITH_BITS
+QUADRANT2 = QUADRANT1 * 2
+QUADRANT3 = QUADRANT1 * 3
+QUADRANT4 = QUADRANT1 * 4
+MAX_CUM = QUADRANT1 - 1
+MAX_CHAR = (256 + MAX_MATCH_LEN - MIN_MATCH_LEN + 1)
+
+#
+# Other constants specific to this implementation
+#
+
+MAX_SUFFIX_CHAIN = 50	# limit on how many identical suffixes to try to match
+
+#def debug(value, msg):
+#	print "@@@ %s %04x" % (msg, value)
+debug = lambda value, msg: None
+
+_tr_16 = string.maketrans("0123456789abcdef",
+			  "\x00\x01\x02\x03"
+			  "\x10\x11\x12\x13"
+			  "\x20\x21\x22\x23"
+			  "\x30\x31\x32\x33")
+_tr_4 = string.maketrans("0123",
+			 "\x00\x01"
+			 "\x10\x11")
+_tr_2 = string.maketrans("01", "\x00\x01")
+
+def string_to_bit_array(s):
+	"""Convert a string to an array containing a sequence of bits."""
+	s = binascii.hexlify(s).translate(_tr_16)
+	s = binascii.hexlify(s).translate(_tr_4)
+	s = binascii.hexlify(s).translate(_tr_2)
+	a = array.array('B', s)
+	return a
+
+_tr_rev_2 = string.maketrans("\x00\x01", "01")
+_tr_rev_4 = string.maketrans("\x00\x01"
+			     "\x10\x11",
+			     "0123")
+_tr_rev_16 = string.maketrans("\x00\x01\x02\x03"
+			      "\x10\x11\x12\x13"
+			      "\x20\x21\x22\x23"
+			      "\x30\x31\x32\x33",
+			      "0123456789abcdef")
+def bit_array_to_string(a):
+	"""Convert an array containing a sequence of bits to a string."""
+	remainder = len(a) % 8
+	if remainder != 0:
+		a.fromlist([0] * (8 - remainder))
+	s = a.tostring()
+	s = binascii.unhexlify(s.translate(_tr_rev_2))
+	s = binascii.unhexlify(s.translate(_tr_rev_4))	
+	return binascii.unhexlify(s.translate(_tr_rev_16))
+
+def _match(src, pos, hpos, mlen, end):
+	mlen += 1
+	if not src.startswith(src[hpos : hpos + mlen], pos):
+		return None
+	for i in range(mlen, end):
+		if src[pos + i] != src[hpos + i]:
+			return i
+	return end
+
+def _rehash_table2(src, chars, head, next, next2, hist_invalid):
+	p = head
+	table2 = {}
+	l = []
+	while p > hist_invalid:
+		l.append(p)
+		p = next[p % HIST_LEN]
+	l.reverse()
+	for p in l:
+		p2 = p + MIN_MATCH_LEN
+		key2 = src[p2 : p2 + chars]
+		head2 = table2.get(key2, hist_invalid)
+		next2[p % HIST_LEN] = head2
+		table2[key2] = p
+	return table2
+
+class lzari_codec(object):
+	# despite the name this does not implement a codec compatible
+	# with Python's codec system
+	
+	def init(self, decode):
+		self.high = QUADRANT4
+		self.low = 0
+		if decode:
+			self.code = 0
+			# reverse the order of sym_cum so bisect_right() can
+			# be used for faster searching
+			self.sym_cum = range(0, MAX_CHAR + 1)
+		else:
+			self.shifts = 0
+			self.char_to_symbol = range(1, MAX_CHAR + 1)
+			self.sym_cum = range(MAX_CHAR, -1, -1)
+			self.next_table = [None] * HIST_LEN
+			self.next2_table = [None] * HIST_LEN
+			self.suffix_table = {}
+
+		self.symbol_to_char = [0] + range(MAX_CHAR)
+		self.sym_freq = [0] + [1] * MAX_CHAR
+		self.position_cum = [0] * (HIST_LEN + 1)
+		a = 0
+		for i in range(HIST_LEN, 0, -1):
+			a =  a + 10000 / (200 + i)
+			self.position_cum[i - 1] = a
+		
+	def search(self, table, x):
+		c = 1
+	        s = len(table) - 1
+		while True:
+			a = (s + c) / 2
+			if table[a] <= x:
+				s = a
+			else:
+				c = a + 1
+			if c >= s:
+				break
+		return c
+
+	def update_model_decode(self, symbol):
+		# A compatible implemention to the one used while compressing.
+		
+		sym_freq = self.sym_freq
+		sym_cum = self.sym_cum
+		
+		if self.sym_cum[MAX_CHAR] >= MAX_CUM:
+			c = 0
+			for i in range(MAX_CHAR, 0, -1):
+				self.sym_cum[MAX_CHAR - i] = c
+				a = (self.sym_freq[i] + 1) / 2
+				self.sym_freq[i] = a
+				c += a
+			self.sym_cum[MAX_CHAR] = c
+		freq = sym_freq[symbol]
+		new_symbol = symbol
+		while self.sym_freq[new_symbol - 1] == freq:
+		        new_symbol -= 1
+		# new_symbol = sym_freq.index(freq)
+		if new_symbol != symbol:
+			symbol_to_char = self.symbol_to_char
+		        swap_char = symbol_to_char[new_symbol]
+			char = symbol_to_char[symbol]
+			symbol_to_char[new_symbol] = char
+			symbol_to_char[symbol] = swap_char
+		sym_freq[new_symbol] = freq + 1
+		for i in range(MAX_CHAR - new_symbol + 1, MAX_CHAR + 1):
+			sym_cum[i] += 1
+			
+	def update_model_encode(self, symbol):
+		sym_freq = self.sym_freq
+		sym_cum = self.sym_cum
+		
+	        if sym_cum[0] >= MAX_CUM:
+			c = 0
+			for i in range(MAX_CHAR, 0, -1):
+				sym_cum[i] = c
+				a = (sym_freq[i] + 1) / 2
+				sym_freq[i] = a
+				c += a
+			sym_cum[0] = c
+		freq = sym_freq[symbol]
+		new_symbol = symbol
+		while sym_freq[new_symbol - 1] == freq:
+		        new_symbol -= 1
+		if new_symbol != symbol:
+			debug(new_symbol, "a")
+		        swap_char = self.symbol_to_char[new_symbol]
+			char = self.symbol_to_char[symbol]
+			self.symbol_to_char[new_symbol] = char
+			self.symbol_to_char[symbol] = swap_char
+			self.char_to_symbol[char] = new_symbol
+			self.char_to_symbol[swap_char] = symbol
+		sym_freq[new_symbol] += 1
+		for i in range(new_symbol):
+			sym_cum[i] += 1
+
+	def decode_char(self):
+		high = self.high
+		low = self.low
+		code = self.code
+		sym_cum = self.sym_cum
+		
+		_range = high - low
+		max_cum_freq = sym_cum[MAX_CHAR]
+		n = ((code - low + 1) * max_cum_freq - 1) / _range
+		i = bisect_right(sym_cum, n, 1)
+		high = low + sym_cum[i] * _range / max_cum_freq
+		low += sym_cum[i - 1] * _range / max_cum_freq
+		symbol = MAX_CHAR + 1 - i
+
+		while True:
+			if low < QUADRANT2:
+				if low < QUADRANT1 or high > QUADRANT3:
+					if high > QUADRANT2:
+						break
+				else:
+					low -= QUADRANT1
+					code -= QUADRANT1
+					high -= QUADRANT1
+			else:
+				low -= QUADRANT2
+				code -= QUADRANT2
+				high -= QUADRANT2
+			low *= 2
+			high *= 2
+			code = code * 2 + self.in_iter()
+
+		ret = self.symbol_to_char[symbol]
+		self.high = high
+		self.low = low
+		self.code = code
+		self.update_model_decode(symbol)
+		return ret
+	
+	def decode_position(self):
+		_range = self.high - self.low
+		max_cum = self.position_cum[0]
+		pos = self.search(self.position_cum,
+				  ((self.code - self.low + 1)
+				   * max_cum - 1) / _range) - 1
+		self.high = (self.low +
+			     self.position_cum[pos] * _range / max_cum)
+		self.low += self.position_cum[pos + 1] * _range / max_cum
+		while True:
+			if self.low < QUADRANT2:
+				if (self.low < QUADRANT1
+				    or self.high > QUADRANT3):
+					if self.high > QUADRANT2:
+						return pos
+ 				else:
+					self.low -= QUADRANT1
+					self.code -= QUADRANT1
+					self.high -= QUADRANT1
+			else:
+				self.low -= QUADRANT2
+				self.code -= QUADRANT2
+				self.high -= QUADRANT2
+			self.low *= 2
+			self.high *= 2
+			self.code = self.in_iter() + self.code * 2
+
+	def add_suffix_1(self, pos, find):
+		# naive implemention used for testing
+		
+		if not find:
+			return (None, 0)
+		src = self.src
+		mlen = min(1000, self.max_match, len(src) - pos)
+		hist_start = max(pos - HIST_LEN, 0)
+		while mlen >= MIN_MATCH_LEN:
+			i = src.rfind(src[pos : pos + mlen], hist_start, pos)
+			if i != -1:
+				assert (src[pos : pos + mlen]
+					== src[i: i + mlen])
+				return (i, mlen)
+			mlen -= 1
+		return (None, -1)
+			
+	def add_suffix_2(self, pos, find):
+		# a two level dictionary look up that leverages Python's
+		# built-in dicts to get something that's hopefully faster
+		# than implementing binary trees in completely in Python.
+		
+		src = self.src
+		suffix_table = self.suffix_table
+		max_match = min(self.max_match, len(src) - pos)
+
+		mlen = -1
+		mpos = None
+		
+		hist_invalid = pos - HIST_LEN - 1
+		modpos = pos % HIST_LEN
+		pos2 = pos + MIN_MATCH_LEN
+		
+		key = src[pos : pos2]
+		a = suffix_table.get(key)
+		if a != None:
+			next = self.next_table
+			next2 = self.next2_table
+			
+			[count, head, table2, chars] = a
+			
+			pos3 = pos2 + chars
+			key2 = src[pos2 : pos3]
+			min_match2 = MIN_MATCH_LEN + chars
+			if find:
+				p = table2.get(key2, hist_invalid)
+				maxmlen = max_match - min_match2
+				while p > hist_invalid and mlen != maxmlen:
+					p3 = p + min_match2
+					if mpos == None and p3 <= pos:
+						mpos = p
+						mlen = 0
+					if p3 >= pos:
+						p = next2[p % HIST_LEN]
+						continue
+					rlen = _match(src, pos3, p3, mlen,
+						      min(maxmlen, pos - p3))
+					if rlen != None:
+						mpos = p
+						mlen = rlen
+					p = next2[p % HIST_LEN]
+			if mpos != None:
+				mlen += min_match2
+			elif find:
+				p = head
+				maxmlen = min(chars, max_match - MIN_MATCH_LEN)
+				i = 0
+				while (p > hist_invalid and i < 50000
+				       and mlen < maxmlen):
+					assert i < count
+					i += 1
+					p2 = p + MIN_MATCH_LEN
+					l2 = pos - p2
+					if mpos == None and l2 >= 0:
+						mpos = p
+						mlen = 0
+					if l2 <= 0:
+						p = next[p % HIST_LEN]
+						continue
+					if l2 > maxmlen:
+						l2 = maxmlen
+					m = mlen + 1
+					if src.startswith(src[p2 : p2 + m],
+							  pos2):
+						mpos = p
+						for j in range(m, l2):
+							if (src[pos2 + j]
+							    != src[p2 + j]):
+								mlen = j
+								break
+						else:
+							mlen = l2
+					#rlen = _match(src, pos2, p2, mlen, l2)
+					#if rlen != None:
+					#	mpos = p
+					#	mlen = rlen
+					p = next[p % HIST_LEN]
+					
+				if mpos != None:
+					mlen += MIN_MATCH_LEN
+					
+			count += 1
+			new_chars = int(log(count, 2))
+			# new_chars = 50
+			new_chars = min(new_chars, max_match - MIN_MATCH_LEN)
+			if new_chars > chars:
+				chars = new_chars
+				table2 = _rehash_table2(src, chars, head,
+							next, next2,
+							hist_invalid)
+
+			next[modpos] = head
+			head = pos
+			
+			key2 = src[pos2 : pos2 + chars]
+			head2 = table2.get(key2, hist_invalid)
+			next2[modpos] = head2
+			table2[key2] = pos
+
+			a[0] = count
+			a[1] = head
+			a[2] = table2
+			a[3] = chars
+		else:
+			self.next_table[modpos] = hist_invalid
+			self.next2_table[modpos] = hist_invalid
+			key2 = ""
+			# key2 = src[pos2 : pos2 + 1]
+			suffix_table[key] = [1, pos, {key2: pos}, len(key2)]
+
+		p = pos - HIST_LEN
+		if p >= 0:
+			p2 = p + MIN_MATCH_LEN
+			key = src[p : p2]
+			a = suffix_table[key]
+			(count, head, table2, chars) = a
+			count -= 1
+			if count == 0:
+				assert head == p
+				del suffix_table[key]
+			else:
+				key2 = src[p2 : p2 + chars]
+				if table2[key2] == p:
+					del table2[key2]
+				a[0] = count
+		assert (mpos == None
+			or src[pos : pos + mlen] == src[mpos : mpos + mlen])
+		return (mpos, mlen)
+
+	def _add_suffix(self, pos, find):
+		r = self.add_suffix_2(pos, find)
+		start_pos = self.start_pos
+		if find and r[0] != None:
+			print ("%4d %02x %4d %2d"
+			       % (pos - start_pos, ord(self.src[pos]),
+				  r[0] - start_pos, r[1]))
+		else:
+			print ("%4d %02x"
+				       % (pos - start_pos, ord(self.src[pos])))
+		return r
+	
+	add_suffix = add_suffix_2
+	
+	def output_bit(self, bit):
+		self.append_bit(bit)
+		bit ^= 1
+		for i in range(self.shifts):
+			self.append_bit(bit)
+		self.shifts = 0
+		
+	def encode_char(self, char):
+		low = self.low
+		high = self.high
+		sym_cum = self.sym_cum
+		
+		symbol = self.char_to_symbol[char]
+		range = high - low
+	
+		high = low + range * sym_cum[symbol - 1] / sym_cum[0]
+		low += range * sym_cum[symbol] / sym_cum[0]
+		debug(high, "high");
+		debug(low, "low");
+		while True:
+			if high <= QUADRANT2:
+				self.output_bit(0)
+			elif low >= QUADRANT2:
+				self.output_bit(1)
+				low -= QUADRANT2
+				high -= QUADRANT2
+			elif low >= QUADRANT1 and high <= QUADRANT3:
+				self.shifts += 1
+				low -= QUADRANT1
+				high -= QUADRANT1
+			else:
+				break
+			low *= 2
+			high *= 2
+		self.low = low
+		self.high = high
+		self.update_model_encode(symbol)
+
+	def encode_position(self, position):
+		position_cum = self.position_cum
+		low = self.low
+		high = self.high
+
+		range = high - low
+		high = low + range * position_cum[position] / position_cum[0]
+		low += range * position_cum[position + 1] / position_cum[0]
+
+		debug(high, "high");
+		debug(low, "low");
+		while True:
+			if high <= QUADRANT2:
+				self.output_bit(0)
+			elif low >= QUADRANT2:
+				self.output_bit(1)
+				low -= QUADRANT2
+				high -= QUADRANT2
+			elif low >= QUADRANT1 and high <= QUADRANT3:
+				self.shifts += 1
+				low -= QUADRANT1
+				high -= QUADRANT1
+			else:
+				break
+			low *= 2
+			high *= 2
+			
+		self.low = low
+		self.high = high
+			
+	def encode(self, src, progress = None):
+		"""Compress a string."""
+		
+		length = len(src)
+		if length == 0:
+			return ""
+
+		out_array = array.array('B')
+		self.out_array = out_array
+		self.append_bit = out_array.append
+		
+		self.init(False)
+
+		max_match = min(MAX_MATCH_LEN, length)
+		self.max_match = max_match
+		self.src = src = "\x20" * max_match + src
+			
+		in_length = len(src)
+		
+		self.start_pos = max_match
+		
+		for in_pos in range(max_match):
+			self.add_suffix(in_pos, False)
+		in_pos += 1
+		last_percent = -1
+		while in_pos < in_length:
+			if progress:
+				percent = (in_pos - max_match) * 100 / length
+				if percent != last_percent:
+					sys.stderr.write("%s%3d%%\r"
+							 % (progress, percent))
+					last_percent = percent
+			debug(ord(src[in_pos]), "src")
+			(match_pos, match_len) = self.add_suffix(in_pos, True)
+			if match_len < MIN_MATCH_LEN:
+				self.encode_char(ord(src[in_pos]))
+			else:
+				debug(in_pos - match_pos - 1, "match_pos")
+				debug(match_len, "match_len")
+				self.encode_char(256 - MIN_MATCH_LEN
+						 + match_len)
+				self.encode_position(in_pos - match_pos - 1)
+				for i in range(match_len - 1):
+					in_pos += 1
+					self.add_suffix(in_pos, False)
+			in_pos += 1
+				
+		self.shifts += 1
+		if self.low < QUADRANT1:
+			self.output_bit(0)
+		else:
+			self.output_bit(1)
+
+		#for k, v in sorted(self.suffix_table.items()):
+		#	count, head, table2, chars = v
+		#	print hexlify(k), count, head, len(table2), chars
+			
+		if progress:
+			sys.stderr.write("%s100%%\n" % progress)
+		
+		return bit_array_to_string(out_array)
+		
+	def decode(self, src, out_length, progress = None):
+		"""Decompress a string."""
+		
+		a = string_to_bit_array(src)
+		a.fromlist([0] * 32)	 # add some extra bits 
+		self.in_iter = iter(a).next
+
+		out = array.array('B', "\0") * out_length
+		outpos = 0
+		
+		self.init(True)
+
+		self.code = 0
+		for i in range(ARITH_BITS + 2):
+			self.code += self.code + self.in_iter()
+
+		hist_pos = HIST_LEN - MAX_MATCH_LEN
+		history = [0x20] * hist_pos + [0] * MAX_MATCH_LEN
+
+		decode_char = self.decode_char
+		last_percent = -1
+		last_time = time.time()
+		while outpos < out_length:
+			if progress:
+				percent = outpos * 100 / out_length
+				if percent != last_percent:
+					now = time.time()
+					if now - last_time >= 1:
+						sys.stderr.write("%s%3d%%\r"
+							% (progress, percent))
+						last_percent = percent
+						last_time = now
+			char = decode_char()
+			if char >= 0x100:
+				pos = self.decode_position()
+				length = char - 0x100 + MIN_MATCH_LEN
+				base = (hist_pos - pos - 1) % HIST_LEN
+				for off in range(length):
+					a = history[(base + off) % HIST_LEN]
+					out[outpos] = a
+					outpos += 1
+					history[hist_pos] = a
+					hist_pos = (hist_pos + 1) % HIST_LEN
+			else:
+				out[outpos] = char
+				outpos += 1
+				history[hist_pos] = char
+				hist_pos = (hist_pos + 1) % HIST_LEN
+		
+		self.in_iter = None
+		if progress:
+			sys.stderr.write("%s100%%\n" % progress)
+		return out.tostring()
+
+if mymcsup == None:
+	def decode(src, out_length, progress = None):
+		return lzari_codec().decode(src, out_length, progress)
+	
+	def encode(src, progress = None):
+		return lzari_codec().encode(src, progress)
+else:
+	mylzari_decode = mymcsup.mylzari_decode
+	mylzari_encode = mymcsup.mylzari_encode
+	mylzari_free_encoded = mymcsup.mylzari_free_encoded
+	
+	def decode(src, out_length, progress = None):
+		out = ctypes.create_string_buffer(out_length)
+		if (mylzari_decode(src, len(src), out, out_length, progress)
+		    == -1):
+			raise ValueError, "compressed input is corrupt"
+		return ctypes.string_at(out, out_length)
+
+	def encode(src, progress = None):
+		(r, compressed, comp_len) = mylzari_encode(src, len(src),
+							   progress)
+		# print r, compressed.value, comp_len
+		if r == -1:
+			raise MemoryError, "out of memory during compression"
+		ret = ctypes.string_at(compressed.value, comp_len.value)
+		mylzari_free_encoded(compressed)
+		return ret;
+
+def main2(args):
+	import struct
+	import os
+	
+	src = file(args[2], "rb").read()
+	lzari = lzari_codec()
+	out = file(args[3], "wb")
+	start = os.times()
+	if args[1] == "c":
+		dest = lzari.encode(src)
+		now = os.times()
+		out.write(struct.pack("L", len(src)))
+	else:
+		dest = lzari.decode(src[4:],
+				    struct.unpack("L", src[:4])[0])
+		now = os.times()
+	out.write(dest)
+	out.close()
+	print "time:", now[0] - start[0], now[1] - start[1], now[4] - start[4]
+
+
+def _get_hotshot_lineinfo(filename):
+	import hotshot.log
+	log = hotshot.log.LogReader(filename)
+	timings = {}
+	for what, loc, tdelta in log:
+		if what == hotshot.log.LINE:
+			a = timings.get(loc)
+			if a == None:
+				timings[loc] = [1, tdelta]
+			else:
+				a[0] += 1
+				a[1] += tdelta
+	return timings.items()
+
+def _dump_hotshot_lineinfo(log):
+	a = sorted(_get_hotshot_lineinfo(log))
+	total_count = sum((time[0]
+			   for (loc, time) in a))
+	total_time = sum((time[1]
+			  for (loc, time) in a))
+	for (loc, [count, time]) in a:
+		print ("%8d %6.3f%%  %8d %6.3f%%"
+		       % (time, time * 100.0 / total_time,
+			  count, count * 100.0 / total_count)),
+		print "%s:%d(%s)" % loc
+
+def _dump_hotshot_lineinfo2(log):
+	cur = None
+	a = sorted(_get_hotshot_lineinfo(log))
+	total_count = sum((time[0]
+			   for (loc, time) in a))
+	total_time = sum((time[1]
+			  for (loc, time) in a))
+	for ((filename, lineno, fn), [count, time]) in a:
+		if cur != filename:
+			if cur != None and f != None:
+				for line in f:
+					print line[:-1]
+				f.close()
+			try:
+				f = file(filename, "r")
+			except OSError:
+				f = None
+			cur = filename
+			l = 0
+			print "#", filename
+		if f != None:
+			while l < lineno:
+				print f.readline()[:-1]
+				l += 1
+		print ("# %8d %6.3f%%  %8d %6.3f%%"
+		       % (time, time * 100.0 / total_time,
+			  count, count * 100.0 / total_count))
+	if cur != None and f != None:
+		for line in f:
+			print line[:-1]
+		f.close()
+	
+def main(args):
+	import os
+	
+	if args[1] == "pc":
+		import profile
+		pr = profile.Profile()
+		for i in range(5):
+			print pr.calibrate(100000)
+		return
+	elif args[1] == "p":
+		import profile
+		ret = 0
+		# profile.Profile.bias = 5.26e-6
+		profile.runctx("ret = main2(args[1:])",
+			       globals(), locals())
+		return ret
+	elif args[1].startswith("h"):
+		import hotshot, hotshot.stats
+		import warnings
+
+		warnings.filterwarnings("ignore")
+		tmp = os.tempnam()
+		try:
+			l = args[1].startswith("hl")
+			p = hotshot.Profile(tmp, l)
+			ret = p.runcall(main2, args[1:])
+			p.close()
+			p = None
+			if l:
+				if args[1] == "hl2":
+					_dump_hotshot_lineinfo2(tmp)
+				else:
+					_dump_hotshot_lineinfo(tmp)
+			else:
+				hotshot.stats.load(tmp).print_stats()
+		finally:
+			try:
+				os.remove(tmp)
+			except OSError:
+				pass
+		return ret
+			
+	return main2(args)
+
+if __name__ == '__main__':
+	sys.exit(main(sys.argv))
+	

mymc.py

@@ -0,0 +1,810 @@
+#
+# mymc.py
+#
+# By Ross Ridge
+# Public Domain
+#
+
+"""A utility for manipulating PS2 memory card images."""
+
+_SCCS_ID = "@(#) mysc mymc.py 1.11 08/08/11 14:12:26\n"[:-1]
+
+import sys
+import os
+import time
+import optparse
+import textwrap
+import binascii
+import string
+from errno import EEXIST, EIO
+
+import ps2mc
+import ps2save
+from ps2mc_dir import *
+from round import *
+import verbuild
+
+class subopt_error(Exception):
+	pass
+
+io_error = ps2mc.io_error
+
+if os.name == "nt":
+	import codecs
+
+	class file_wrap(object):
+		""" wrap a file-like object with a new encoding attribute. """
+		
+		def __init__(self, f, encoding):
+			object.__setattr__(self, "_f", f)
+			object.__setattr__(self, "encoding", encoding)
+
+		def __getattribute__(self, name):
+			if name == "encoding":
+				return object.__getattribute__(self, name)
+			return getattr(object.__getattribute__(self, "_f"),
+				       name)
+
+		def __setattr__(self, name, value):
+			if name == "encoding":
+				raise TypeError, "readonly attribute"
+			return setattr(object.__getattribute__(self, "_f"),
+				       name, value)
+
+	for name in ["stdin", "stdout", "stderr"]:
+		f = getattr(sys, name)
+		cur = getattr(f, "encoding", None)
+		if cur == "ascii" or cur == None:
+			f = file_wrap(f, "mbcs")
+		else:
+			try:
+				codecs.lookup(cur)
+			except LookupError:
+				f = file_wrap(f, "mbcs")
+		setattr(sys, name, f)
+
+
+if os.name in ["nt", "os2", "ce"]:
+	from glob import glob
+else:
+	# assume globing is done by the shell
+	glob = lambda pattern: [pattern]
+
+
+def glob_args(args, globfn):
+	ret = []
+	for arg in args:
+		match = globfn(arg)
+		if len(match) == 0:
+			ret.append(arg)
+		else:
+			ret += match
+	return ret
+	      
+def _copy(fout, fin):
+	"""copy the contents of one file to another"""
+	
+	while True:
+		s = fin.read(1024)
+		if s == "":
+			break
+		fout.write(s)
+	
+
+def do_ls(cmd, mc, opts, args, opterr):
+	mode_bits = "rwxpfdD81C+KPH4"
+
+	if len(args) == 0:
+		args = ["/"]
+
+	out = sys.stdout
+	args = glob_args(args, mc.glob)
+	for dirname in args:
+		dir = mc.dir_open(dirname)
+		try:
+			if len(args) > 1:
+				sys.stdout.write("\n" + dirname + ":\n")
+			for ent in dir:
+				mode = ent[0]
+				if (mode & DF_EXISTS) == 0:
+					continue
+				for bit in range(0, 15):
+					if mode & (1 << bit):
+						out.write(mode_bits[bit])
+					else:
+						out.write("-")
+				if opts.creation_time:
+					tod = ent[3]
+				else:
+					tod = ent[6]
+				tm = time.localtime(tod_to_time(tod))
+				out.write(" %7d %04d-%02d-%02d"
+					  " %02d:%02d:%02d %s\n"
+					  % (ent[2],
+					     tm.tm_year, tm.tm_mon, tm.tm_mday,
+					     tm.tm_hour, tm.tm_min, tm.tm_sec,
+					     ent[8]))
+		finally:
+			dir.close()
+			
+
+def do_add(cmd, mc, opts,  args, opterr):
+	if len(args) < 1:
+		opterr("Filename required.")
+	if opts.directory != None:
+		mc.chdir(opts.directory)
+	for src in glob_args(args, glob):
+		f = open(src, "rb")
+		dest = os.path.basename(src)
+		out = mc.open(dest, "wb")
+		_copy(out, f)
+		out.close()
+		f.close()
+		
+def do_extract(cmd, mc, opts, args, opterr):
+	if len(args) < 1:
+		opterr("Filename required.")
+
+	if opts.directory != None:
+		mc.chdir(opts.directory)
+
+	close_out = False
+	out = None
+	if opts.output != None:
+		if opts.use_stdout:
+			opterr("The -o and -p options are mutually exclusive.")
+		dont_close_out = True
+		out = file(opts.output, "wb")
+	elif opts.use_stdout:
+		out = sys.stdout
+
+	try:
+		for filename in glob_args(args, mc.glob):
+			f = mc.open(filename, "rb")
+			try:
+				if out != None:
+					_copy(out, f)
+					continue
+				a = filename.split("/")
+				o = file(a[-1], "wb")
+				try:
+					_copy(o, f)
+				finally:
+					o.close()
+			finally:
+				f.close()
+	finally:
+		if close_out:
+			out.close()
+
+def do_mkdir(cmd, mc, opts, args, opterr):
+	if len(args) < 1:
+		opterr("Directory required.")
+		
+	for filename in args:
+		mc.mkdir(filename)
+
+def do_remove(cmd, mc, opts, args, opterr):
+	if len(args) < 1:
+		opterr("Filename required.")
+		
+	for filename in args:
+		mc.remove(filename)
+
+def do_import(cmd, mc, opts, args, opterr):
+	if len(args) < 1:
+		opterr("Filename required.")
+
+	args = glob_args(args, glob)
+	if opts.directory != None and len(args) > 1:
+		opterr("The -d option can only be used with a"
+		       "single savefile.")
+		
+	for filename in args:
+		sf = ps2save.ps2_save_file()
+		f = file(filename, "rb")
+		try:
+			ftype = ps2save.detect_file_type(f)
+			f.seek(0)
+			if ftype == "max":
+				sf.load_max_drive(f)
+			elif ftype == "psu":
+				sf.load_ems(f)
+			elif ftype == "cbs":
+				sf.load_codebreaker(f)
+			elif ftype == "sps":
+				sf.load_sharkport(f)
+			elif ftype == "npo":
+				raise io_error, (EIO, "nPort saves"
+						 " are not supported.",
+						 filename)
+			else:
+				raise io_error, (EIO, "Save file format not"
+						 " recognized", filename)
+		finally:
+			f.close()
+		dirname = opts.directory
+		if dirname == None:
+			dirname = sf.get_directory()[8]
+		print "Importing", filename, "to", dirname
+		if not mc.import_save_file(sf, opts.ignore_existing,
+						opts.directory):
+			print (filename + ": already in memory card image,"
+			       " ignored.")
+
+#re_num = re.compile("[0-9]+")
+
+def do_export(cmd, mc, opts, args, opterr):
+	if len(args) < 1:
+		opterr("Directory name required")
+
+	if opts.overwrite_existing and opts.ignore_existing:
+		opterr("The -i and -f options are mutually exclusive.")
+		
+	args = glob_args(args, mc.glob)
+	if opts.output_file != None:
+		if len(args) > 1:
+			opterr("Only one directory can be exported"
+			       " when the -o option is used.")
+		if opts.longnames:
+			opterr("The -o and -l options are mutually exclusive.")
+
+	if opts.directory != None:
+		os.chdir(opts.directory)
+		
+	for dirname in args:
+		sf = mc.export_save_file(dirname)
+		filename = opts.output_file
+		if opts.longnames:
+			filename = (ps2save.make_longname(dirname, sf)
+				    + "." + opts.type)
+		if filename == None:
+			filename = dirname + "." + opts.type
+				
+		if not opts.overwrite_existing:
+			exists = True
+			try:
+				open(filename, "rb").close()
+			except EnvironmentError:
+				exists = False
+			if exists:
+				if opts.ignore_existing:
+					continue
+				raise io_error(EEXIST, "File exists", filename)
+			
+		f = file(filename, "wb")
+		try:
+			print "Exporing", dirname, "to", filename
+			
+			if opts.type == "max":
+				sf.save_max_drive(f)
+			else:
+				sf.save_ems(f)
+		finally:
+			f.close()
+
+def do_delete(cmd, mc, opts, args, opterr):
+	if len(args) < 1:
+		opterr("Directory required.")
+
+	for dirname in args:
+		mc.rmdir(dirname)
+	
+def do_setmode(cmd, mc, opts, args, opterr):
+	set_mask = 0
+	clear_mask = ~0
+	for (opt, bit) in [(opts.read, DF_READ),
+			   (opts.write, DF_WRITE),
+			   (opts.execute, DF_EXECUTE),
+			   (opts.protected, DF_PROTECTED),
+			   (opts.psx, DF_PSX),
+			   (opts.pocketstation, DF_POCKETSTN),
+			   (opts.hidden, DF_HIDDEN)]:
+		if opt != None:
+			if opt:
+				set_mask |= bit
+			else:
+				clear_mask ^= bit
+
+	value = opts.hex_value
+	if set_mask == 0 and clear_mask == ~0:
+		if value == None:
+			opterr("At least one option must be given.")
+		if value.startswith("0x") or value.startswith("0X"):
+			value = int(value[2:], 16)
+		else:
+			value = int(value, 16)
+	else:
+		if value != None:
+			opterr("The -X option can't be combined with"
+			       " other options.")
+
+	for arg in glob_args(args, mc.glob):
+		ent = mc.get_dirent(arg)
+		if value == None:
+			ent[0] = (ent[0] & clear_mask) | set_mask
+			print "new %04x" % ent[0]
+		else:
+			ent[0] = value
+		mc.set_dirent(arg, ent)
+
+def _get_ps2_title(mc, enc):
+	s = mc.get_icon_sys(".");
+	if s == None:
+		return None
+	a = ps2save.unpack_icon_sys(s)
+	return ps2save.icon_sys_title(a, enc)
+
+def _get_psx_title(mc, savename, enc):
+	mode = mc.get_mode(savename)
+	if mode == None or not mode_is_file(mode):
+		return None
+	f = mc.open(savename)
+	s = f.read(128)
+	if len(s) != 128:
+		return None
+	(magic, icon, blocks, title) = struct.unpack("<2sBB64s28x32x", s)
+	if magic != "SC":
+		return None
+	return [ps2save.shift_jis_conv(zero_terminate(title), enc), ""]
+
+def do_dir(cmd, mc, opts, args, opterr):
+	if len(args) != 0:
+		opterr("Incorrect number of arguments.")
+	f = None
+	dir = mc.dir_open("/")
+	try:
+		for ent in list(dir)[2:]:
+			dirmode = ent[0]
+			if not mode_is_dir(dirmode):
+				continue
+			dirname = "/" + ent[8]
+			mc.chdir(dirname)
+			length = mc.dir_size(".");
+			enc = getattr(sys.stdout, "encoding", None)
+			if dirmode & DF_PSX:
+				title = _get_psx_title(mc, ent[8], enc)
+			else:
+				title = _get_ps2_title(mc, enc)
+			if title == None:
+				title = ["Corrupt", ""]
+			protection = dirmode & (DF_PROTECTED | DF_WRITE)
+			if protection == 0:
+				protection = "Delete Protected"
+			elif protection == DF_WRITE:
+				protection = "Not Protected"
+			elif protection == DF_PROTECTED:
+				protection = "Copy & Delete Protected"
+			else:
+				protection = "Copy Protected"
+
+			type = None
+			if dirmode & DF_PSX:
+				type = "PlayStation"
+				if dirmode & DF_POCKETSTN:
+					type = "PocketStation"
+			if type != None:
+				protection = type
+				
+			print "%-32s %s" % (ent[8], title[0])
+			print ("%4dKB %-25s %s"
+			       % (length / 1024, protection, title[1]))
+			print
+	finally:
+		if f != None:
+			f.close()
+		dir.close()
+		
+	free = mc.get_free_space() / 1024
+	if free > 999999:
+		free = "%d,%03d,%03d" % (free / 1000000, free / 1000 % 1000,
+					 free % 1000)
+	elif free > 999:
+		free = "%d,%03d" % (free / 1000, free % 1000)
+	else:
+		free = "%d" % free
+
+	print free + " KB Free"
+
+def do_df(cmd, mc, opts, args, opterr):
+	if len(args) != 0:
+		opterr("Incorrect number of arguments.")
+	print mc.f.name + ":", mc.get_free_space(), "bytes free."
+
+def do_check(cmd, mc, opts, args, opterr):
+	if len(args) != 0:
+		opterr("Incorrect number of arguments.")
+	if mc.check():
+		print "No errors found."
+		return 0
+	return 1
+	
+def do_format(cmd, mcname, opts, args, opterr):
+	if len(args) != 0:
+		opterr("Incorrect number of arguments.")
+	pages_per_card = ps2mc.PS2MC_STANDARD_PAGES_PER_CARD
+	if opts.clusters != None:
+		pages_per_cluster = (ps2mc.PS2MC_CLUSTER_SIZE
+				     / ps2mc.PS2MC_STANDARD_PAGE_SIZE)
+		pages_per_card = opts.clusters * pages_per_cluster
+	params = (True,
+		  ps2mc.PS2MC_STANDARD_PAGE_SIZE,
+		  ps2mc.PS2MC_STANDARD_PAGES_PER_ERASE_BLOCK,
+		  pages_per_card)
+
+	if not opts.overwrite_existing:
+		exists = True
+		try:
+			file(mcname, "rb").close()
+		except EnvironmentError:
+			exists = False
+		if exists:
+			raise io_error, (EEXIST, "file exists", mcname)
+
+	f = file(mcname, "w+b")
+	try:
+		ps2mc.ps2mc(f, True, params).close()
+	finally:
+		f.close()
+
+def do_gui(cmd, mcname, opts, args, opterr):
+	if len(args) != 0:
+		opterr("Incorrect number of arguments.")
+
+	try:
+		import gui
+	except ImportError:
+		write_error(None, "GUI not available")
+		return 1
+
+	gui.run(mcname)
+	return 0
+
+def do_create_pad(cmd, mc, opts, args, opterr):
+	length = mc.clusters_per_card
+	if len(args) > 1:
+		length = int(args[1])
+	pad = "\0" * mc.cluster_size
+	f = mc.open(args[0], "wb")
+	try:
+		for i in xrange(length):
+			f.write(pad)
+	finally:
+		f.close()
+	
+		
+def do_frob(cmd, mc, opts, args, opterr):
+	mc.write_superblock()
+
+_trans = string.maketrans("".join(map(chr, range(32))), " " * 32)
+
+def _print_bin(base, s):
+	for off in range(0, len(s), 16):
+		print "%04X" % (base + off),
+		a = s[off : off + 16]
+		for b in a:
+			print "%02X" % ord(b),
+		print "", a.translate(_trans)
+	
+def _print_erase_block(mc, n):
+	ppb = mc.pages_per_erase_block
+	base = n * ppb
+	for i in range(ppb):
+		s = mc.read_page(base + i)
+		_print_bin(i * mc.page_size, s)
+		print
+		
+def do_print_good_blocks(cmd, mc, opts, args, opterr):
+	print "good_block2:"
+	_print_erase_block(mc, mc.good_block2)
+	print "good_block1:"
+	_print_erase_block(mc, mc.good_block1)
+
+def do_ecc_check(cmd, mc, opts, args, opterr):
+	for i in range(mc.clusters_per_card * mc.pages_per_cluster):
+		try:
+			mc.read_page(i)
+		except ps2mc.ecc_error:
+			print "bad: %05x" % i
+
+opt = optparse.make_option
+
+#
+# Each value in the dictionary is a tuple consisting of:
+#    - function implementing the command
+#    - mode to use to open the ps2 save file
+#    - help description of the command
+#    - list of options supported by the command
+#
+cmd_table = {
+	"ls": (do_ls, "rb",
+	       "[directory ...]",
+	       "List the contents of a directory.",
+	       [opt("-c", "--creation-time", action="store_true",
+		    help = "Display creation times.")]),
+	"extract": (do_extract, "rb",
+		    "filename ...",
+		    "Extract files from the memory card.",
+		    [opt("-o", "--output", metavar = "FILE",
+			 help = 'Extract file to "FILE".'),
+		     opt("-d", "--directory", 
+			 help = 'Extract files from "DIRECTORY".'),
+		     opt("-p", "--use-stdout", action="store_true",
+			 help = "Extract files to standard output.")]),
+	"add": (do_add, "r+b",
+		"filename ...",
+		"Add files to the memory card.",
+		[opt("-d", "--directory", 
+		     help = 'Add files to "directory".')]),
+	"mkdir": (do_mkdir, "r+b",
+		  "directory ...",
+		  "Make directories.",
+		  []),
+	"remove": (do_remove, "r+b",
+		   "filename ...",
+		   "Remove files and directories.",
+		   []),
+	"import": (do_import, "r+b",
+		   "savefile ...",
+		   "Import save files into the memory card.",
+		   [opt("-i", "--ignore-existing", action="store_true",
+			help = ("Ignore files that already exist"
+				"on the image.")),
+		    opt("-d", "--directory", metavar="DEST",
+			help = 'Import to "DEST".')]),
+	"export": (do_export, "rb",
+		   "directory ...",
+		   "Export save files from the memory card.",
+		   [opt("-f", "--overwrite-existing", action = "store_true",
+			help = "Overwrite any save files already exported."),
+		    opt("-i", "--ignore-existing", action = "store_true",
+			help = "Ingore any save files already exported."),
+		    opt("-o", "--output-file", metavar = "filename",
+			help = 'Use "filename" as the name of the save file.'),
+		    opt("-d", "--directory", metavar = "directory",
+			help = 'Export save files to "directory".'),
+		    opt("-l", "--longnames", action = "store_true",
+			help = ("Generate longer, more descriptive,"
+				" filenames.")),
+		    opt("-p", "--ems", action = "store_const",
+			dest = "type", const = "psu", default = "psu",
+			help = "Use the EMS .psu save file format. [default]"),
+		    opt("-m", "--max-drive", action = "store_const",
+			dest = "type", const = "max",
+			help = "Use the MAX Drive save file format.")]),
+	"delete": (do_delete, "r+b",
+		   "dirname ...",
+		   "Recursively delete a directory (save file).",
+		   []),
+	"set": (do_setmode, "r+b",
+		"filename ...",
+		"Set mode flags on files and directories",
+		[opt("-p", "--protected", action="store_true",
+		     help = "Set copy protected flag"),
+		 opt("-P", "--psx", action="store_true",
+		     help = "Set PSX flag"),
+		 opt("-K", "--pocketstation", action="store_true",
+		     help = "Set PocketStation flag"),
+		 opt("-H", "--hidden", action="store_true",
+		     help = "Set hidden flag"),
+		 opt("-r", "--read", action="store_true",
+		     help = "Set read allowed flag"),
+		 opt("-w", "--write", action="store_true",
+		     help = "Set write allowed flag"),
+		 opt("-x", "--execute", action="store_true",
+		     help = "Set executable flag"),
+		 opt("-X", "--hex-value", metavar="mode",
+		     help = 'Set mode to "mode".')]),
+	"clear": (do_setmode, "r+b",
+		"filename ...",
+		"Clear mode flags on files and directories",
+		[opt("-p", "--protected", action="store_false",
+		     help = "Clear copy protected flag"),
+		 opt("-P", "--psx", action="store_false",
+		     help = "Clear PSX flag"),
+		 opt("-K", "--pocketstation", action="store_false",
+		     help = "Clear PocketStation flag"),
+		 opt("-H", "--hidden", action="store_false",
+		     help = "Clear hidden flag"),
+		 opt("-r", "--read", action="store_false",
+		     help = "Clear read allowed flag"),
+		 opt("-w", "--write", action="store_false",
+		     help = "Clear write allowed flag"),
+		 opt("-x", "--execute", action="store_false",
+		     help = "Clear executable flag"),
+		 opt("-X", dest="hex_value", default=None,
+		     help = optparse.SUPPRESS_HELP)]),
+	"dir": (do_dir, "rb",
+		None,
+		"Display save file information.",
+		[]),
+	"df": (do_df, "rb",
+	       None,
+	       "Display the amount free space.",
+	       []),
+	"check": (do_check, "rb",
+		  "",
+		  "Check for file system errors.",
+		  []),
+	"format": (do_format, None,
+		   "",
+		   "Creates a new memory card image.",
+		   [opt("-c", "--clusters", type="int",
+			help = "Size in clusters of the memory card."),
+		    opt("-f", "--overwrite-existing", action="store_true",
+			help = "Overwrite any existing file")]),
+	"gui": (do_gui, None,
+		"",
+		"Starts the graphical user interface.",
+		[]),
+}
+
+#
+# secret commands for debugging purposes.
+# 
+debug_cmd_table = {
+	"frob": (do_frob, "r+b",
+		 "",
+		 None,
+		 []),
+	"print_good_blocks": (do_print_good_blocks, "rb",
+			      "",
+			      None,
+			      []),
+	"ecc_check": (do_ecc_check, "rb",
+		      "",
+		      None,
+		      []),
+	"create_pad": (do_create_pad, "r+b",
+		       "",
+		       None,
+		       [])
+}
+
+del opt		# clean up name space
+
+
+def write_error(filename, msg):
+	if filename == None:
+		sys.stderr.write(msg + "\n")
+	else:
+		sys.stderr.write(filename + ": " + msg + "\n")
+
+class suboption_parser(optparse.OptionParser):
+	def exit(self, status = 0, msg = None):
+		if msg:
+			sys.stderr.write(msg)
+		raise subopt_error, status
+
+class my_help_formatter(optparse.IndentedHelpFormatter):
+	"""A better formatter for optparser's help message"""
+	
+	def format_description(self, description):
+		if not description:
+			return ""
+		desc_width = self.width - self.current_indent
+		indent = " " * self.current_indent
+		lines = []
+		for line in description.split('\n'):
+			ii = indent
+			si = indent
+			if line.startswith("\t"):
+				line = line[1:]
+				ii = indent + " " * 4
+				si = ii + " " * line.find(":") + 2
+			line = textwrap.fill(line, desc_width,
+					     initial_indent = ii,
+					     subsequent_indent = si)
+			lines.append(line)
+		return "\n".join(lines) + "\n"
+
+def main():
+	prog = sys.argv[0].decode(sys.getdefaultencoding(), "replace")
+	usage = "usage: %prog [-ih] memcard.ps2 command [...]"
+	description = ("Manipulate PS2 memory card images.\n\n"
+		       "Supported commands: ")
+	for cmd in sorted(cmd_table.keys()):
+		description += "\n   " + cmd + ": " + cmd_table[cmd][3]
+		
+	version = ("mymc "
+		   + verbuild.MYMC_VERSION_MAJOR
+		   + "." + verbuild.MYMC_VERSION_BUILD
+		   + "   (" + _SCCS_ID + ")")
+
+	optparser = optparse.OptionParser(prog = prog, usage = usage,
+					  description = description,
+			 		  version = version,
+					  formatter = my_help_formatter())
+	optparser.add_option("-D", dest = "debug", action = "store_true",
+			     default = False, help = optparse.SUPPRESS_HELP)
+	optparser.add_option("-i", "--ignore-ecc", action = "store_true",
+			     help = "Ignore ECC errors while reading.")
+			     
+	optparser.disable_interspersed_args()
+	(opts, args) = optparser.parse_args()
+
+	if len(args) == 0:
+		try:
+			import gui
+		except ImportError:
+			gui = None
+		if gui != None:
+			gui.run()
+			sys.exit(0)
+
+	if len(args) < 2:
+		optparser.error("Incorrect number of arguments.")
+
+	if opts.debug:
+		cmd_table.update(debug_cmd_table)
+	cmd = args[1]
+	if cmd not in cmd_table:
+		optparser.error('Command "%s" not recognized.' % cmd)
+	(fn, mode, usage_args, description, optlist) = cmd_table[cmd]
+
+	usage = "%prog"
+	if len(optlist) > 0:
+		usage += " [options]"
+	if usage_args != None:
+		usage += " " + usage_args
+	subprog = prog + " memcard.ps2 " + cmd
+	subopt_parser = suboption_parser(prog = subprog, usage = usage,
+					 description = description,
+					 option_list = optlist)
+	subopt_parser.disable_interspersed_args()
+	
+	f = None
+	mc = None
+	ret = 0
+	mcname = args[0]
+
+	try:
+		(subopts, subargs) = subopt_parser.parse_args(args[2:])
+		try:
+			if mode == None:
+				ret = fn(cmd, mcname, subopts, subargs,
+					 subopt_parser.error)
+			else:
+				f = file(mcname, mode)
+				mc = ps2mc.ps2mc(f, opts.ignore_ecc)
+				ret = fn(cmd, mc, subopts, subargs,
+					 subopt_parser.error)
+		finally:
+			if mc != None:
+				mc.close()
+			if f != None:
+				# print "f.close()"
+				f.close()
+
+	except EnvironmentError, value:
+		if getattr(value, "filename", None) != None:
+			write_error(value.filename, value.strerror)
+			ret = 1
+		elif getattr(value, "strerror", None) != None:
+			write_error(mcname, value.strerror)
+			ret = 1
+		else:		
+			# something weird
+			raise
+		if opts.debug:
+			raise
+
+	except subopt_error, (ret,):
+		pass
+	
+	except (ps2mc.error, ps2save.error), value:
+		fn = getattr(value, "filename", None)
+		if fn == None:
+			fn = mcname
+		write_error(fn, str(value))
+		if opts.debug:
+			raise
+		ret = 1
+
+	if ret == None:
+		ret = 0
+
+	return ret
+
+sys.exit(main())
+

ps2mc_dir.py

@@ -0,0 +1,131 @@
+#
+# ps2mc_dir.py
+#
+# By Ross Ridge
+# Public Domain
+#
+
+"""Functions for working with PS2 memory card directory entries."""
+
+_SCCS_ID = "@(#) mysc ps2mc_dir.py 1.3 08/02/05 15:51:58\n"
+
+import struct
+import time
+import calendar
+
+PS2MC_DIRENT_LENGTH = 512
+
+DF_READ        = 0x0001
+DF_WRITE       = 0x0002
+DF_EXECUTE     = 0x0004
+DF_RWX         = DF_READ | DF_WRITE | DF_EXECUTE
+DF_PROTECTED   = 0x0008
+DF_FILE        = 0x0010
+DF_DIR         = 0x0020
+DF_O_DCREAT    = 0x0040
+DF_0080        = 0x0080
+DF_0100        = 0x0100
+DF_O_CREAT     = 0x0200
+DF_0400        = 0x0400
+DF_POCKETSTN   = 0x0800
+DF_PSX         = 0x1000
+DF_HIDDEN      = 0x2000
+DF_4000        = 0x4000
+DF_EXISTS      = 0x8000
+
+def zero_terminate(s):
+	"""Truncate a string at the first NUL ('\0') character, if any."""
+	
+	i = s.find('\0')
+	if i == -1:
+		return s
+	return s[:i]
+
+# mode, ???, length, created,
+# fat_cluster, parent_entry, modified, attr,
+# name
+_dirent_fmt = "<HHL8sLL8sL28x448s"
+
+# secs, mins, hours, mday, month, year
+_tod_fmt = "<xBBBBBH"
+
+#
+# Use the new Struct object if available
+# 
+if hasattr(struct, "Struct"):
+	_dirent_struct = struct.Struct(_dirent_fmt)
+	_tod_struct = struct.Struct(_tod_fmt)
+
+	def unpack_tod(s):
+		return _tod_struct.unpack(s)
+	
+	def pack_tod(tod):
+		return _tod_struct.pack(tod)
+	
+	def unpack_dirent(s):
+		ent = _dirent_struct.unpack(s)
+		ent = list(ent)
+		ent[3] = _tod_struct.unpack(ent[3])
+		ent[6] = _tod_struct.unpack(ent[6])
+		ent[8] = zero_terminate(ent[8])
+		return ent
+
+	def pack_dirent(ent):
+		ent = list(ent)
+		ent[3] = _tod_struct.pack(*ent[3])
+		ent[6] = _tod_struct.pack(*ent[6])
+		return _dirent_struct.pack(*ent)
+else:
+	def unpack_tod(s):
+		return struct.unpack(_tod_fmt, s)
+
+	def pack_tod(tod):
+		return struct.pack(_tod_fmt, tod)
+	
+	def unpack_dirent(s):
+		# mode, ???, length, created,
+		# fat_cluster, parent_entry, modified, attr,
+		# name
+		ent = struct.unpack(_dirent_fmt, s)
+		ent = list(ent)
+		ent[3] = struct.unpack(_tod_fmt, ent[3])
+		ent[6] = struct.unpack(_tod_fmt, ent[6])
+		ent[8] = zero_terminate(ent[8])
+		return ent
+
+	def pack_dirent(ent):
+		ent = list(ent)
+		ent[3] = struct.pack(_tod_fmt, *ent[3])
+		ent[6] = struct.pack(_tod_fmt, *ent[6])
+		return struct.pack(_dirent_fmt, *ent)
+
+def time_to_tod(when):
+	"""Convert a Python time value to a ToD tuple"""
+	
+	tm = time.gmtime(when + 9 * 3600)
+	return (tm.tm_sec, tm.tm_min, tm.tm_hour,
+		tm.tm_mday, tm.tm_mon, tm.tm_year)
+
+def tod_to_time(tod):
+	"""Convert a ToD tuple to a Python time value."""
+	
+	try:
+		month = tod[4]
+		if month == 0:
+			month = 1
+		return calendar.timegm((tod[5], month, tod[3],
+					tod[2], tod[1], tod[0],
+					None, None, 0)) - 9 * 3600
+	except ValueError:
+		return 0
+		
+def tod_now():
+	"""Get the current time as a ToD tuple."""
+	return time_to_tod(time.time())
+	
+def mode_is_file(mode):
+	return (mode & (DF_FILE | DF_DIR | DF_EXISTS)) == (DF_FILE | DF_EXISTS)
+
+def mode_is_dir(mode):
+	return (mode & (DF_FILE | DF_DIR | DF_EXISTS)) == (DF_DIR | DF_EXISTS)
+

ps2mc_ecc.py

@@ -0,0 +1,182 @@
+#
+# ps2mc_ecc.py
+#
+# By Ross Ridge
+# Public Domain
+#
+
+"""
+Routines for calculating the Hamming codes, a simple form of error
+correcting codes (ECC), as used on PS2 memory cards.  
+"""
+
+_SCCS_ID = "@(#) mysc ps2mc_ecc.py 1.4 07/12/17 02:34:04\n"
+
+import array
+
+from round import div_round_up
+
+try:
+	import ctypes
+	import mymcsup
+except ImportError:
+	mymcsup = None
+
+__ALL__ = ["ECC_CHECK_OK", "ECC_CHECK_CORRECTED", "ECC_CHECK_FAILED",
+	   "ecc_calculate", "ecc_check",
+	   "ecc_calculate_page", "ecc_check_page"]
+
+ECC_CHECK_OK = 0
+ECC_CHECK_CORRECTED = 1
+ECC_CHECK_FAILED = 2
+
+def _popcount(a):
+	count = 0
+	while a != 0:
+		a &= a - 1
+		count += 1
+	return count
+
+def _parityb(a):
+	a = (a ^ (a >> 1))
+	a = (a ^ (a >> 2))
+	a = (a ^ (a >> 4))
+	return a & 1
+
+def _make_ecc_tables():
+	parity_table = [_parityb(b)
+			for b in range(256)]
+	cpmasks = [0x55, 0x33, 0x0F, 0x00, 0xAA, 0xCC, 0xF0] 
+
+	column_parity_masks = [None] * 256
+	for b in range(256):
+		mask = 0
+		for i in range(len(cpmasks)):
+			mask |= parity_table[b & cpmasks[i]] << i
+			column_parity_masks[b] = mask
+
+	return parity_table, column_parity_masks
+
+_parity_table, _column_parity_masks = _make_ecc_tables()
+
+def _ecc_calculate(s):
+	"Calculate the Hamming code for a 128 byte long string or byte array."
+	
+	if not isinstance(s, array.array):
+		a = array.array('B')
+		a.fromstring(s)
+		s = a
+	column_parity = 0x77
+	line_parity_0 = 0x7F
+	line_parity_1 = 0x7F
+	for i in range(len(s)):
+		b = s[i]
+		column_parity ^= _column_parity_masks[b]
+		if _parity_table[b]:
+			line_parity_0 ^= ~i
+			line_parity_1 ^= i
+	return [column_parity, line_parity_0 & 0x7F, line_parity_1]
+
+def _ecc_check(s, ecc):
+	"""Detect and correct any single bit errors.
+	
+	The parameters "s" and "ecc", the data and expected Hamming code 
+	repectively, must be modifiable sequences of integers and are
+	updated with the corrected values if necessary."""
+
+	computed = ecc_calculate(s)
+	if computed == ecc:
+		return ECC_CHECK_OK
+
+	#print
+	#_print_bin(0, s.tostring())
+	#print "computed %02x %02x %02x" % tuple(computed)
+	#print "actual %02x %02x %02x" % tuple(ecc)
+	
+	# ECC mismatch
+		
+	cp_diff = (computed[0] ^ ecc[0]) & 0x77
+	lp0_diff = (computed[1] ^ ecc[1]) & 0x7F
+	lp1_diff = (computed[2] ^ ecc[2]) & 0x7F
+	lp_comp = lp0_diff ^ lp1_diff
+	cp_comp = (cp_diff >> 4) ^ (cp_diff & 0x07)
+
+	#print "%02x %02x %02x %02x %02x" % (cp_diff, lp0_diff, lp1_diff,
+	#				    lp_comp, cp_comp)
+
+	if lp_comp == 0x7F and cp_comp == 0x07:
+		print "corrected 1"
+		# correctable 1 bit error in data
+		s[lp1_diff] ^= 1 << (cp_diff >> 4)
+		return ECC_CHECK_CORRECTED
+	if ((cp_diff == 0 and lp0_diff == 0 and lp1_diff == 0)
+	      or _popcount(lp_comp) + _popcount(cp_comp) == 1):
+		print "corrected 2"
+		# correctable 1 bit error in ECC
+		# (and/or one of the unused bits was set)
+		ecc[0] = computed[0]
+		ecc[1] = computed[1]
+		ecc[2] = computed[2]
+		return ECC_CHECK_CORRECTED
+
+	# uncorrectable error
+	return ECC_CHECK_FAILED
+
+def ecc_calculate_page(page):
+	"""Return a list of the ECC codes for a PS2 memory card page."""
+	return [ecc_calculate(page[i * 128 : i * 128 + 128])
+		for i in range(div_round_up(len(page), 128))]
+
+def ecc_check_page(page, spare):
+	"Check and correct any single bit errors in a PS2 memory card page."
+	
+	failed = False
+	corrected = False
+
+	#chunks = [(array.array('B', page[i * 128 : i * 128 + 128]),
+	#	   map(ord, spare[i * 3 : i * 3 + 3]))
+	#	  for i in range(div_round_up(len(page), 128))]
+
+	chunks = []
+	for i in range(div_round_up(len(page), 128)):
+		a = array.array('B')
+		a.fromstring(page[i * 128 : i * 128 + 128])
+		chunks.append((a, map(ord, spare[i * 3 : i * 3 + 3])))
+	
+	r = [ecc_check(s, ecc)
+	     for (s, ecc) in chunks]
+	ret = ECC_CHECK_OK
+	if ECC_CHECK_CORRECTED in r:
+		# rebuild sector and spare from the corrected versions
+		page = "".join([a[0].tostring()
+				for a in chunks])
+		spare = "".join([chr(a[1][i])
+				 for a in chunks
+				 for i in range(3)])
+		ret = ECC_CHECK_CORRECTED
+	if ECC_CHECK_FAILED in r:
+		ret = ECC_CHECK_FAILED
+	return (ret, page, spare)
+
+if mymcsup == None:
+	ecc_calculate = _ecc_calculate
+	ecc_check = _ecc_check
+else:
+	# _c_ubyte_p = ctypes.POINTER(ctypes.c_ubyte)
+	def ecc_calculate(s):
+		aecc = array.array('B', "\0\0\0")
+		cecc = ctypes.c_ubyte.from_address(aecc.buffer_info()[0])
+		mymcsup.ecc_calculate(s, len(s), cecc)
+		return list(aecc)
+
+	def ecc_check(s, ecc):
+		cs = ctypes.c_ubyte.from_address(s.buffer_info()[0])
+		# print "%08X" % s.buffer_info()[0]
+		aecc = array.array('B', ecc)
+		cecc = ctypes.c_ubyte.from_address(aecc.buffer_info()[0])
+		ret = mymcsup.ecc_check(cs, len(s), cecc)
+		ecc[0] = aecc[0]
+		ecc[1] = aecc[1]
+		ecc[2] = aecc[2]
+		return ret
+		

ps2save.py

@@ -0,0 +1,625 @@
+#
+# ps2save.py
+#
+# By Ross Ridge
+# Public Domain
+# 
+# A simple interface for working with various PS2 save file formats.
+#
+
+_SCCS_ID = "@(#) mysc ps2save.py 1.6 08/08/11 14:11:54\n"
+
+import sys
+import os
+import string
+import struct
+import binascii
+import array
+import zlib
+
+from round import div_round_up, round_up
+from ps2mc_dir import *
+from sjistab import shift_jis_normalize_table
+
+try:
+	import lzari
+except ImportError:
+	lzari = None
+
+PS2SAVE_MAX_MAGIC = "Ps2PowerSave"
+PS2SAVE_SPS_MAGIC = "\x0d\0\0\0SharkPortSave"
+PS2SAVE_CBS_MAGIC = "CFU\0"
+PS2SAVE_NPO_MAGIC = "nPort"
+
+# This is the initial permutation state ("S") for the RC4 stream cipher
+# algorithm used to encrpyt and decrypt Codebreaker saves.
+PS2SAVE_CBS_RC4S = [0x5f, 0x1f, 0x85, 0x6f, 0x31, 0xaa, 0x3b, 0x18,
+		    0x21, 0xb9, 0xce, 0x1c, 0x07, 0x4c, 0x9c, 0xb4,
+		    0x81, 0xb8, 0xef, 0x98, 0x59, 0xae, 0xf9, 0x26,
+		    0xe3, 0x80, 0xa3, 0x29, 0x2d, 0x73, 0x51, 0x62,
+		    0x7c, 0x64, 0x46, 0xf4, 0x34, 0x1a, 0xf6, 0xe1,
+		    0xba, 0x3a, 0x0d, 0x82, 0x79, 0x0a, 0x5c, 0x16,
+		    0x71, 0x49, 0x8e, 0xac, 0x8c, 0x9f, 0x35, 0x19,
+		    0x45, 0x94, 0x3f, 0x56, 0x0c, 0x91, 0x00, 0x0b,
+		    0xd7, 0xb0, 0xdd, 0x39, 0x66, 0xa1, 0x76, 0x52,
+		    0x13, 0x57, 0xf3, 0xbb, 0x4e, 0xe5, 0xdc, 0xf0,
+		    0x65, 0x84, 0xb2, 0xd6, 0xdf, 0x15, 0x3c, 0x63,
+		    0x1d, 0x89, 0x14, 0xbd, 0xd2, 0x36, 0xfe, 0xb1,
+		    0xca, 0x8b, 0xa4, 0xc6, 0x9e, 0x67, 0x47, 0x37,
+		    0x42, 0x6d, 0x6a, 0x03, 0x92, 0x70, 0x05, 0x7d,
+		    0x96, 0x2f, 0x40, 0x90, 0xc4, 0xf1, 0x3e, 0x3d,
+		    0x01, 0xf7, 0x68, 0x1e, 0xc3, 0xfc, 0x72, 0xb5,
+		    0x54, 0xcf, 0xe7, 0x41, 0xe4, 0x4d, 0x83, 0x55,
+		    0x12, 0x22, 0x09, 0x78, 0xfa, 0xde, 0xa7, 0x06,
+		    0x08, 0x23, 0xbf, 0x0f, 0xcc, 0xc1, 0x97, 0x61,
+		    0xc5, 0x4a, 0xe6, 0xa0, 0x11, 0xc2, 0xea, 0x74,
+		    0x02, 0x87, 0xd5, 0xd1, 0x9d, 0xb7, 0x7e, 0x38,
+		    0x60, 0x53, 0x95, 0x8d, 0x25, 0x77, 0x10, 0x5e,
+		    0x9b, 0x7f, 0xd8, 0x6e, 0xda, 0xa2, 0x2e, 0x20,
+		    0x4f, 0xcd, 0x8f, 0xcb, 0xbe, 0x5a, 0xe0, 0xed,
+		    0x2c, 0x9a, 0xd4, 0xe2, 0xaf, 0xd0, 0xa9, 0xe8,
+		    0xad, 0x7a, 0xbc, 0xa8, 0xf2, 0xee, 0xeb, 0xf5,
+		    0xa6, 0x99, 0x28, 0x24, 0x6c, 0x2b, 0x75, 0x5d,
+		    0xf8, 0xd3, 0x86, 0x17, 0xfb, 0xc0, 0x7b, 0xb3,
+		    0x58, 0xdb, 0xc7, 0x4b, 0xff, 0x04, 0x50, 0xe9,
+		    0x88, 0x69, 0xc9, 0x2a, 0xab, 0xfd, 0x5b, 0x1b,
+		    0x8a, 0xd9, 0xec, 0x27, 0x44, 0x0e, 0x33, 0xc8,
+		    0x6b, 0x93, 0x32, 0x48, 0xb6, 0x30, 0x43, 0xa5]
+
+class error(Exception):
+	"""Base for all exceptions specific to this module."""
+	pass
+
+class corrupt(error):
+	"""Corrupt save file."""
+
+	def __init__(self, msg, f = None):
+		fn = None
+		if f != None:
+			fn = getattr(f, "name", None)
+		self.filename = fn
+		error.__init__(self, "Corrupt save file: " + msg)
+
+class eof(corrupt):
+	"""Save file is truncated."""
+
+	def __init__(self, f = None):
+		corrupt.__init__(self, "Unexpected EOF", f)
+
+class subdir(corrupt):
+	def __init__(self, f = None):
+		corrupt.__init__(self, "Non-file in save file.", f)
+
+#
+# Table of graphically similar ASCII characters that can be used
+# as substitutes for Unicode characters.
+#
+char_substs = {
+	u'\u00a2': u"c",
+	u'\u00b4': u"'",
+	u'\u00d7': u"x",
+	u'\u00f7': u"/",
+	u'\u2010': u"-",
+	u'\u2015': u"-",
+	u'\u2018': u"'",
+	u'\u2019': u"'",
+	u'\u201c': u'"',
+	u'\u201d': u'"',
+	u'\u2032': u"'",
+	u'\u2212': u"-",
+	u'\u226a': u"<<",
+	u'\u226b': u">>",
+	u'\u2500': u"-",
+	u'\u2501': u"-",
+	u'\u2502': u"|",
+	u'\u2503': u"|",
+	u'\u250c': u"+",
+	u'\u250f': u"+",
+	u'\u2510': u"+",
+	u'\u2513': u"+",
+	u'\u2514': u"+",
+	u'\u2517': u"+",
+	u'\u2518': u"+",
+	u'\u251b': u"+",
+	u'\u251c': u"+",
+	u'\u251d': u"+",
+	u'\u2520': u"+",
+	u'\u2523': u"+",
+	u'\u2524': u"+",
+	u'\u2525': u"+",
+	u'\u2528': u"+",
+	u'\u252b': u"+",
+	u'\u252c': u"+",
+	u'\u252f': u"+",
+	u'\u2530': u"+",
+	u'\u2533': u"+",
+	u'\u2537': u"+",
+	u'\u2538': u"+",
+	u'\u253b': u"+",
+	u'\u253c': u"+",
+	u'\u253f': u"+",
+	u'\u2542': u"+",
+	u'\u254b': u"+",
+	u'\u25a0': u"#",
+	u'\u25a1': u"#",
+	u'\u3001': u",",
+	u'\u3002': u".",
+	u'\u3003': u'"',
+	u'\u3007': u'0',
+	u'\u3008': u'<',
+	u'\u3009': u'>',
+	u'\u300a': u'<<',
+	u'\u300b': u'>>',
+	u'\u300a': u'<<',
+	u'\u300b': u'>>',
+	u'\u300c': u'[',
+	u'\u300d': u']',
+	u'\u300e': u'[',
+	u'\u300f': u']',
+	u'\u3010': u'[',
+	u'\u3011': u']',
+	u'\u3014': u'[',
+	u'\u3015': u']',
+	u'\u301c': u'~',
+	u'\u30fc': u'-',
+}
+
+def shift_jis_conv(src, encoding = None):
+	"""Convert Shift-JIS strings to a graphically similar representation.
+
+	If encoding is "unicode" then a Unicode string is returned,
+	otherwise a string in encoding specified is returned.  If necessary,
+	graphically similar characters are used to replace characters not
+	exactly representable in the desired encoding.
+	"""
+	
+	if encoding == None:
+		encoding = sys.getdefaultencoding()
+	if encoding == "shift_jis":
+		return src
+	u = src.decode("shift_jis", "replace")
+	if encoding == "unicode":
+		return u
+	a = []
+	for uc in u:
+		try:
+			uc.encode(encoding)
+			a.append(uc)
+		except UnicodeError:
+			for uc2 in shift_jis_normalize_table.get(uc, uc):
+				a.append(char_substs.get(uc2, uc2))
+	
+	return u"".join(a).encode(encoding, "replace")
+
+def rc4_crypt(s, t):
+	"""RC4 encrypt/decrypt the string t using the permutation s.
+
+	Returns a byte array."""
+	
+	s = array.array('B', s)
+	t = array.array('B', t)
+	j = 0
+	for ii in range(len(t)):
+		i = (ii + 1) % 256
+		j = (j + s[i]) % 256
+		(s[i], s[j]) = (s[j], s[i])
+		t[ii] ^= s[(s[i] + s[j]) % 256]
+	return t
+
+# def sps_check(s):
+# 	"""Calculate the checksum for a SharkPort save."""
+#
+# 	h = 0
+# 	for c in array.array('B', s):
+# 		h += c << (h % 24)
+# 		h &= 0xFFFFFFFF
+# 	return h
+
+def unpack_icon_sys(s):
+	"""Unpack an icon.sys file into a tuple."""
+	
+	# magic, title offset, ...
+	# [14] title, normal icon, copy icon, del icon
+	a = struct.unpack("<4s2xH4x"
+			  "L" "16s16s16s16s" "16s16s16s" "16s16s16s" "16s"
+			  "68s64s64s64s512x", s)
+	a = list(a)
+	for i in range(3, 7):
+		a[i] = struct.unpack("<4L", a[i])
+		a[i] = map(hex, a[i])
+	for i in range(7, 14):
+		a[i] = struct.unpack("<4f", a[i])
+	a[14] = zero_terminate(a[14])
+	a[15] = zero_terminate(a[15])
+	a[16] = zero_terminate(a[16])
+	a[17] = zero_terminate(a[17])
+	return a
+
+def icon_sys_title(icon_sys, encoding = None):
+	"""Extract the two lines of the title stored in an icon.sys tuple."""
+	
+	offset = icon_sys[1]
+	title = icon_sys[14]
+	title2 = shift_jis_conv(title[offset:], encoding)
+	title1 = shift_jis_conv(title[:offset], encoding)
+	return (title1, title2)
+
+def _read_fixed(f, n):
+	"""Read a string of a fixed length from a file."""
+	
+	s = f.read(n)
+	if len(s) != n:
+		raise eof, f
+	return s
+
+def _read_long_string(f):
+	"""Read a string prefixed with a 32-bit length from a file."""
+	
+	length = struct.unpack("<L", _read_fixed(f, 4))[0]
+	return _read_fixed(f, length) 
+
+class ps2_save_file(object):
+	"""The state of a PlayStation 2 save file."""
+	
+	def __init__(self):
+		self.file_ents = None
+		self.file_data = None
+		self.dirent = None
+		self._defer_load_max = False
+
+	def set_directory(self, ent, defer = False):
+		self._defer_load_max = defer
+		self._compressed = None
+		self.file_ents = [None] * ent[2]
+		self.file_data = [None] * ent[2]
+		self.dirent = ent
+
+	def set_file(self, i, ent, data):
+		self.file_ents[i] = ent
+		self.file_data[i] = data
+
+	def get_directory(self):
+		return self.dirent
+
+	def get_file(self, i):
+		if self._defer_load_max:
+			self._defer_load_max = False
+			self._load_max_drive_2()
+		return (self.file_ents[i], self.file_data[i])
+
+	def __len__(self):
+		return self.dirent[2]
+
+	def __getitem__(self, index):
+		return self.get_file(index)
+	
+	def get_icon_sys(self):
+		for i in range(self.dirent[2]):
+			(ent, data) = self.get_file(i)
+			if ent[8] == "icon.sys" and len(data) >= 964:
+				return unpack_icon_sys(data[:964])
+		return None
+
+	def load_ems(self, f):
+		"""Load EMS (.psu) save files."""
+		
+		cluster_size = 1024
+
+		dirent = unpack_dirent(_read_fixed(f, PS2MC_DIRENT_LENGTH))
+		dotent = unpack_dirent(_read_fixed(f, PS2MC_DIRENT_LENGTH))
+		dotdotent = unpack_dirent(_read_fixed(f, PS2MC_DIRENT_LENGTH))
+		if (not mode_is_dir(dirent[0])
+		    or not mode_is_dir(dotent[0])
+		    or not mode_is_dir(dotdotent[0])
+		    or dirent[2] < 2):
+			raise corrupt, ("Not a EMS (.psu) save file.", f)
+
+		dirent[2] -= 2
+		self.set_directory(dirent)
+
+		for i in range(dirent[2]):
+			ent = unpack_dirent(_read_fixed(f,
+							PS2MC_DIRENT_LENGTH))
+			if not mode_is_file(ent[0]):
+				raise subdir, f
+			flen = ent[2]
+			self.set_file(i, ent, _read_fixed(f, flen))
+			_read_fixed(f, round_up(flen, cluster_size) - flen)
+
+
+	def save_ems(self, f):
+		cluster_size = 1024
+
+		dirent = self.dirent[:]
+		dirent[2] += 2
+		f.write(pack_dirent(dirent))
+		f.write(pack_dirent((DF_RWX | DF_DIR | DF_0400 | DF_EXISTS,
+				     0, 0, dirent[3],
+				     0, 0, dirent[3], 0, ".")))
+		f.write(pack_dirent((DF_RWX | DF_DIR | DF_0400 | DF_EXISTS,
+				     0, 0, dirent[3],
+				     0, 0, dirent[3], 0, "..")))
+				     
+		for i in range(dirent[2] - 2):
+			(ent, data) = self.get_file(i)
+			f.write(pack_dirent(ent))
+			if not mode_is_file(ent[0]):
+				raise error, "Directory has a subdirectory."
+			f.write(data)
+			f.write("\0" * (round_up(len(data), cluster_size)
+					- len(data)))
+		f.flush()
+
+	def _load_max_drive_2(self):
+		(length, s) = self._compressed
+		self._compressed = None
+		
+		if lzari == None:
+			raise error, ("The lzari module is needed to "
+				      " decompress MAX Drive saves.")
+		s = lzari.decode(s, length,
+				 "decompressing " + self.dirent[8] + ": ")
+		dirlen = self.dirent[2]
+		now = tod_now()
+		off = 0
+		for i in range(dirlen):
+			if len(s) - off < 36:
+				raise eof, f
+			(l, name) = struct.unpack("<L32s", s[off : off + 36])
+			name = zero_terminate(name)
+			# print "%08x %08x %s" % (off, l, name)
+			off += 36
+			data = s[off : off + l]
+			if len(data) != l:
+				raise eof, f
+			self.set_file(i,
+				      (DF_RWX | DF_FILE | DF_0400, 0, l,
+				       now, 0, 0, now, 0, name),
+				      data)
+			off += l
+			off = round_up(off + 8, 16) - 8
+		
+	def load_max_drive(self, f):
+		s = f.read(0x5C)
+		magic = None
+		if len(s) == 0x5C:
+			(magic, crc, dirname, iconsysname, clen, dirlen,
+			 length) = struct.unpack("<12sL32s32sLLL", s)
+		if magic != PS2SAVE_MAX_MAGIC:
+			raise corrupt, ("Not a MAX Drive save file", f)
+		if clen == length:
+			# some saves have the uncompressed size here
+			# instead of the compressed size
+			s = f.read()
+		else:
+			s = _read_fixed(f, clen - 4)
+		dirname = zero_terminate(dirname)
+		now = tod_now()
+		self.set_directory((DF_RWX | DF_DIR | DF_0400, 0,
+				    dirlen, now, 0, 0, now, 0, dirname),
+				   True)
+		self._compressed = (length, s)
+		
+	def save_max_drive(self, f):
+		if lzari == None:
+			raise error, ("The lzari module is needed to "
+				      " decompress MAX Drive saves.")
+		iconsysname = ""
+		icon_sys = self.get_icon_sys()
+		if icon_sys != None:
+			title = icon_sys_title(icon_sys, "ascii")
+			if len(title[0]) > 0 and title[0][-1] != ' ':
+				iconsysname = title[0] + " " + title[1].strip()
+			else:
+				iconsysname = title[0] + title[1].rstrip()
+		s = ""
+		dirent = self.dirent
+		for i in range(dirent[2]):
+			(ent, data) = self.get_file(i)
+			if not mode_is_file(ent[0]):
+				raise error, "Non-file in save file."
+			s += struct.pack("<L32s", ent[2], ent[8])
+			s += data
+			s += "\0" * (round_up(len(s) + 8, 16) - 8 - len(s))
+		length = len(s)
+		progress =  "compressing " + dirent[8] + ": "
+		compressed = lzari.encode(s, progress)
+		hdr = struct.pack("<12sL32s32sLLL", PS2SAVE_MAX_MAGIC,
+				  0, dirent[8], iconsysname,
+				  len(compressed) + 4, dirent[2], length)
+		crc = binascii.crc32(hdr)
+		crc = binascii.crc32(compressed, crc)
+		f.write(struct.pack("<12sL32s32sLLL", PS2SAVE_MAX_MAGIC,
+				    crc & 0xFFFFFFFF, dirent[8], iconsysname,
+				    len(compressed) + 4, dirent[2], length))
+		f.write(compressed)
+		f.flush()
+
+	def load_codebreaker(self, f):
+		magic = f.read(4)
+		if magic != PS2SAVE_CBS_MAGIC:
+			raise corrupt, ("Not a Codebreaker save file.", f)
+		(d04, hlen) = struct.unpack("<LL", _read_fixed(f, 8))
+		if hlen < 92 + 32:
+			raise corrupt, ("Header lengh too short.", f)
+		(dlen, flen, dirname, created, modified, d44, d48, dirmode,
+		 d50, d54, d58, title) \
+		       = struct.unpack("<LL32s8s8sLLLLLL%ds" % (hlen - 92),
+				       _read_fixed(f, hlen - 12))
+		dirname = zero_terminate(dirname)
+		created = unpack_tod(created)
+		modified = unpack_tod(modified)
+		title = zero_terminate(title)
+
+		# These fields don't always seem to be set correctly.
+		if not mode_is_dir(dirmode):
+			dirmode = DF_RWX | DF_DIR | DF_0400
+		if tod_to_time(created) == 0:
+			created = tod_now()
+		if tod_to_time(modified) == 0:
+			modified = tod_now()
+
+		# flen can either be the total length of the file,
+		# or the length of compressed body of the file
+		body = f.read(flen)
+		clen = len(body)
+		if clen != flen and clen != flen - hlen:
+			raise eof, f
+		body = rc4_crypt(PS2SAVE_CBS_RC4S, body)
+		dcobj = zlib.decompressobj()
+		body = dcobj.decompress(body, dlen)
+
+		files = []
+		while body != "":
+			if len(body) < 64:
+				raise eof, f
+			header = struct.unpack("<8s8sLHHLL32s", body[:64])
+			size = header[2]
+			data = body[64 : 64 + size]
+			if len(data) != size:
+				raise eof, f
+			body = body[64 + size:]
+			files.append((header, data))
+			
+		self.set_directory((dirmode, 0, len(files), created, 0, 0,
+				    modified, 0, dirname))
+		for i in range(len(files)):
+			(header, data) = files[i]
+			(created, modified, size, mode, h06, h08, h0C, name) \
+				= header
+			name = zero_terminate(name)
+			created = unpack_tod(created)
+			modified = unpack_tod(modified)
+			if not mode_is_file(mode):
+				raise subdir, f
+			if tod_to_time(created) == 0:
+				created = tod_now()
+			if tod_to_time(modified) == 0:
+				modified = tod_now()
+			self.set_file(i, (mode, 0, size, created, 0, 0,
+					  modified, 0, name), data)
+
+	def load_sharkport(self, f):
+		magic = f.read(17)
+		if magic != PS2SAVE_SPS_MAGIC:
+			raise corrupt, ("Not a SharkPort/X-Port save file.", f)
+		(savetype,) = struct.unpack("<L", _read_fixed(f, 4))
+		dirname = _read_long_string(f)
+		datestamp = _read_long_string(f)
+		comment = _read_long_string(f)
+		
+		(flen,) = struct.unpack("<L", _read_fixed(f, 4))
+		
+		(hlen, dirname, dirlen, dirmode, created, modified) \
+			= struct.unpack("<H64sL8xH2x8s8s", _read_fixed(f, 98))
+		_read_fixed(f, hlen - 98)
+
+		dirname = zero_terminate(dirname)
+		created = unpack_tod(created)
+		modified = unpack_tod(modified)
+
+		# mode values are byte swapped
+		dirmode = dirmode / 256 % 256 + dirmode % 256 * 256
+		dirlen -= 2
+		if not mode_is_dir(dirmode) or dirlen < 0:
+			raise corrupt, ("Bad values in directory entry.", f)
+		self.set_directory((dirmode, 0, dirlen, created, 0, 0,
+				    modified, 0, dirname))
+
+		for i in range(dirlen):
+			(hlen, name, flen, mode, created, modified) \
+			       = struct.unpack("<H64sL8xH2x8s8s",
+					       _read_fixed(f, 98))
+			if hlen < 98:
+				raise corrupt, ("Header length too short.", f)
+			_read_fixed(f, hlen - 98)
+			name = zero_terminate(name)
+			created = unpack_tod(created)
+			modified = unpack_tod(modified)
+			mode = mode / 256 % 256 + mode % 256 * 256
+			if not mode_is_file(mode):
+				raise subdir, f
+			self.set_file(i, (mode, 0, flen, created, 0, 0,
+					  modified, 0, name),
+				      _read_fixed(f, flen))
+			
+		# ignore 4 byte checksum at the end
+		
+def detect_file_type(f):
+	"""Detect the type of PS2 save file.
+
+	The file-like object f should be positioned at the start of the file.
+	"""
+	
+	hdr = f.read(PS2MC_DIRENT_LENGTH * 3)
+	if hdr[:12] == PS2SAVE_MAX_MAGIC:
+		return "max"
+	if hdr[:17] == PS2SAVE_SPS_MAGIC:
+		return "sps"
+	if hdr[:4] == PS2SAVE_CBS_MAGIC:
+		return "cbs"
+	if hdr[:5] == PS2SAVE_NPO_MAGIC:
+		return "npo"
+	#
+	# EMS (.psu) save files don't have a magic number.  Check to
+	# see if it looks enough like one.
+	#
+	if len(hdr) != PS2MC_DIRENT_LENGTH * 3:
+		return None
+	dirent = unpack_dirent(hdr[:PS2MC_DIRENT_LENGTH])
+	dotent = unpack_dirent(hdr[PS2MC_DIRENT_LENGTH
+				   : PS2MC_DIRENT_LENGTH * 2])
+	dotdotent = unpack_dirent(hdr[PS2MC_DIRENT_LENGTH * 2:])
+	if (mode_is_dir(dirent[0]) and mode_is_dir(dotent[0])
+	    and mode_is_dir(dotdotent[0]) and dirent[2] >= 2
+	    and dotent[8] == "." and dotdotent[8] == ".."):
+		return "psu"
+	return None
+
+#
+# Set up tables of illegal and problematic characters in file names.
+#
+_bad_filename_chars = ("".join(map(chr, range(32)))
+		       + "".join(map(chr, range(127, 256))))
+_bad_filename_repl = "_" * len(_bad_filename_chars)
+
+if os.name in ["nt", "os2", "ce"]:
+	_bad_filename_chars += '<>:"/\\|'
+	_bad_filename_repl +=  "()_'___"
+	_bad_filename_chars2 = _bad_filename_chars + "?* "
+	_bad_filename_repl2 = _bad_filename_repl +   "___"
+else:
+	_bad_filename_chars += "/"
+	_bad_filename_repl += "_"
+	_bad_filename_chars2 = _bad_filename_chars + "?*'&|:[<>] \\\""
+	_bad_filename_repl2 = _bad_filename_repl +   "______(())___"
+
+_filename_trans = string.maketrans(_bad_filename_chars, _bad_filename_repl);
+_filename_trans2 = string.maketrans(_bad_filename_chars2, _bad_filename_repl2);
+
+def fix_filename(filename):
+	"""Replace illegal or problematic characters from a filename."""
+	return filename.translate(_filename_trans)
+
+def make_longname(dirname, sf):
+	"""Return a string containing a verbose filename for a save file."""
+
+	icon_sys = sf.get_icon_sys()
+	title = ""
+	if icon_sys != None:
+		title = icon_sys_title(icon_sys, "ascii")
+		title = title[0] + " " + title[1]
+		title = " ".join(title.split())
+	crc = binascii.crc32("")
+	for (ent, data) in sf:
+		crc = binascii.crc32(data, crc)
+ 	if len(dirname) >= 12 and (dirname[0:2] in ("BA", "BJ", "BE", "BK")):
+		if dirname[2:6] == "DATA":
+			title = ""
+		else:
+			#dirname = dirname[2:6] + dirname[7:12]
+			dirname = dirname[2:12]
+
+	return fix_filename("%s %s (%08X)"
+			    % (dirname, title, crc & 0xFFFFFFFF))
+

round.py

@@ -0,0 +1,21 @@
+#
+# round.py
+#
+# By Ross Ridge
+# Public Domain
+#
+# Simple rounding functions.
+#
+
+_SCCS_ID = "@(#) mysc round.py 1.3 07/04/17 02:10:27\n"
+
+def div_round_up(a, b):
+	return (a + b - 1) / b
+
+def round_up(a, b):
+	return (a + b - 1) / b * b
+
+def round_down(a, b):
+	return a / b * b
+
+

sjistab.py

@@ -0,0 +1,2 @@
+# automatically generated
+shift_jis_normalize_table = {u'\uff81': u'\u30c1', u'\u3000': u' ', u'\uff85': u'\u30ca', u'\uff06': u'&', u'\uff89': u'\u30ce', u'\uff0a': u'*', u'\uff8d': u'\u30d8', u'\uff0e': u'.', u'\uff91': u'\u30e0', u'\uff12': u'2', u'\uff95': u'\u30e6', u'\uff16': u'6', u'\uff99': u'\u30eb', u'\u309b': u' \u3099', u'\uff1a': u':', u'\uff9d': u'\u30f3', u'\uff03': u'#', u'\uff1e': u'>', u'\uff22': u'B', u'\uff26': u'F', u'\uff2a': u'J', u'\u222c': u'\u222b\u222b', u'\uff2e': u'N', u'\uff32': u'R', u'\uff36': u'V', u'\uff3a': u'Z', u'\uff3e': u'^', u'\uff42': u'b', u'\uff46': u'f', u'\uff4a': u'j', u'\uff4e': u'n', u'\uff52': u'r', u'\uff56': u'v', u'\uff5a': u'z', u'\uff62': u'\u300c', u'\uffe5': u'\xa5', u'\uff66': u'\u30f2', u'\uff6a': u'\u30a7', u'\uff6e': u'\u30e7', u'\uff72': u'\u30a4', u'\uff76': u'\u30ab', u'\uff7a': u'\u30b3', u'\uff7e': u'\u30bb', u'\uff01': u'!', u'\uff82': u'\u30c4', u'\uff05': u'%', u'\uff86': u'\u30cb', u'\uff09': u')', u'\uff8a': u'\u30cf', u'\uff8e': u'\u30db', u'\uff11': u'1', u'\uff92': u'\u30e1', u'\uff15': u'5', u'\uff96': u'\u30e8', u'\uff19': u'9', u'\uff9a': u'\u30ec', u'\uff1d': u'=', u'\u309c': u' \u309a', u'\uff9e': u'\u3099', u'\uff21': u'A', u'\uff25': u'E', u'\uff29': u'I', u'\xa8': u' \u0308', u'\uff2d': u'M', u'\uff31': u'Q', u'\u2033': u'\u2032\u2032', u'\uff35': u'U', u'\xb4': u' \u0301', u'\uff39': u'Y', u'\uff3d': u']', u'\uff41': u'a', u'\uff45': u'e', u'\uff49': u'i', u'\uff4d': u'm', u'\uff51': u'q', u'\uff55': u'u', u'\uff59': u'y', u'\uff5d': u'}', u'\uff61': u'\u3002', u'\uff65': u'\u30fb', u'\uff69': u'\u30a5', u'\uff6d': u'\u30e5', u'\uff71': u'\u30a2', u'\uff75': u'\u30aa', u'\uff79': u'\u30b1', u'\uff7d': u'\u30b9', u'\uff83': u'\u30c6', u'\uff04': u'$', u'\uff87': u'\u30cc', u'\uff08': u'(', u'\uff8b': u'\u30d2', u'\uff0c': u',', u'\uff8f': u'\u30de', u'\uff10': u'0', u'\uff93': u'\u30e2', u'\uff14': u'4', u'\uff97': u'\u30e9', u'\uff18': u'8', u'\uff9b': u'\u30ed', u'\uff1c': u'<', u'\uff9f': u'\u309a', u'\uff20': u'@', u'\uff24': u'D', u'\u2026': u'...', u'\uff28': u'H', u'\uff2c': u'L', u'\uff30': u'P', u'\uff34': u'T', u'\uff38': u'X', u'\uff3c': u'\\', u'\uff40': u'`', u'\uff44': u'd', u'\uff48': u'h', u'\uff4c': u'l', u'\uff50': u'p', u'\uff54': u't', u'\uff58': u'x', u'\uff5c': u'|', u'\uffe3': u' \u0304', u'\uff64': u'\u3001', u'\uff68': u'\u30a3', u'\uff6c': u'\u30e3', u'\uff70': u'\u30fc', u'\uff74': u'\u30a8', u'\uff78': u'\u30af', u'\uff7c': u'\u30b7', u'\uff80': u'\u30bf', u'\u2103': u'\xb0C', u'\uff84': u'\u30c8', u'\uff88': u'\u30cd', u'\uff0b': u'+', u'\uff8c': u'\u30d5', u'\uff0f': u'/', u'\uff90': u'\u30df', u'\uff13': u'3', u'\uff94': u'\u30e4', u'\uff17': u'7', u'\uff98': u'\u30ea', u'\uff1b': u';', u'\uff9c': u'\u30ef', u'\uff1f': u'?', u'\uff23': u'C', u'\u2025': u'..', u'\uff27': u'G', u'\u212b': u'\xc5', u'\uff2f': u'O', u'\uff33': u'S', u'\uff37': u'W', u'\uff3b': u'[', u'\uff3f': u'_', u'\uff43': u'c', u'\uff47': u'g', u'\uff4b': u'k', u'\uff4f': u'o', u'\uff53': u's', u'\uff57': u'w', u'\uff5b': u'{', u'\uff63': u'\u300d', u'\uff67': u'\u30a1', u'\uff6b': u'\u30a9', u'\uff6f': u'\u30c3', u'\uff73': u'\u30a6', u'\uff77': u'\u30ad', u'\uff7b': u'\u30b5', u'\uff2b': u'K', u'\uff7f': u'\u30bd'}

verbuild.py

@@ -0,0 +1,2 @@
+MYMC_VERSION_BUILD = r'''5'''
+MYMC_VERSION_MAJOR = r'''2'''