#!/usr/bin/env python

# blorbtool.py: A (semi-)multifunctional Blorb utility
# Created by Andrew Plotkin ([email protected])
# Last updated: June 12, 2017
# This script is in the public domain.

# When listing chunks, you'll see output that looks like:
#   'GLUL' (232192 bytes, start 60)
# "60" means that the IFF chunk starts at byte 60 in the blorb file. There's
# always an eight-byte header, so the actual Glulx data file starts at byte
# 68 (and is then 232192 bytes long).
#
# For AIFF chunks, you'll see:
#   'FORM'/'AIFF' (8536+8 bytes, start 324266)
# The AIFF data implicitly includes the eight-byte header, which is why the
# length says "+8". Start at byte 324266 and read 8544 bytes.

# We use the print() function for Python 2/3 compatibility
from __future__ import print_function

# We use the Py2 raw_input() function. In Py3 there is no such function,
# but we define a back-polyfill. (I'm lazy.)
try:
   raw_input
except NameError:
   raw_input = input

import sys
import os
import optparse
import re
import collections
import struct
import base64
import json

from chunk import Chunk
try:
   import readline
except:
   pass

try:
   # Python 3.3 and up
   os_replace = os.replace
except AttributeError:
   if (os.name != 'nt'):
       # Older Python (on Unix)
       os_replace = os.rename
   else:
       # On Windows, os.rename can't replace an existing file.
       def os_replace(src, dst):
           try:
               os.remove(dst)
           except:
               pass
           os.rename(src, dst)

popt = optparse.OptionParser(usage='blorbtool.py BLORBFILE [ command ]')

popt.add_option('-n', '--new',
               action='store_true', dest='newfile',
               help='create a new blorb file instead of loading one in')
popt.add_option('-o', '--output',
               action='store', dest='output', metavar='BLORBFILE',
               help='blorb file to write to (if requested)')
popt.add_option('-f', '--force',
               action='store_true', dest='force',
               help='overwrite files without confirming')
popt.add_option('-v', '--verbose',
               action='store_true', dest='verbose',
               help='verbose stack traces on error')
popt.add_option('-l', '--commands',
               action='store_true', dest='listcommands',
               help='list all commands (and exit)')

(opts, args) = popt.parse_args()

def dict_append(map, key, val):
   ls = map.get(key)
   if (not ls):
       ls = []
       map[key] = ls
   ls.append(val)

def confirm_input(prompt):
   ln = raw_input(prompt+' >')
   if (ln.lower().startswith('y')):
       return True

class BlorbChunk:
   def __init__(self, blorbfile, typ, start, len, formtype=None):
       self.blorbfile = blorbfile
       self.type = typ
       self.start = start
       self.len = len
       self.formtype = formtype
       self.literaldata = None
       self.filedata = None
       self.filestart = None

   def __repr__(self):
       return '<BlorbChunk %s at %d, len %d>' % (typestring(self.type), self.start, self.len)

   def data(self, max=None):
       if (self.literaldata):
           if (max is not None):
               return self.literaldata[0:max]
           else:
               return self.literaldata
       if (self.filedata):
           fl = open(self.filedata, 'rb')
           if (self.filestart is not None):
               fl.seek(self.filestart)
           if (max is not None):
               dat = fl.read(max)
           else:
               dat = fl.read()
           fl.close()
           return dat
       self.blorbfile.formchunk.seek(self.start)
       toread = self.len
       if (max is not None):
           toread = min(self.len, max)
       return self.blorbfile.formchunk.read(toread)

   def describe(self):
       if (not self.formtype):
           return '%s (%d bytes, start %d)' % (typestring(self.type), self.len, self.start)
       else:
           return '%s/%s (%d+8 bytes, start %d)' % (typestring(self.type), typestring(self.formtype), self.len, self.start)

   def display(self):
       print('* %s' % (self.describe(),))
       if (self.type == b'RIdx'):
           # Index chunk
           dat = self.data()
           (subdat, dat) = (dat[:4], dat[4:])
           num = struct.unpack('>I', subdat)[0]
           print('%d resources:' % (num,))
           while (dat):
               (subdat, dat) = (dat[:12], dat[12:])
               subls = struct.unpack('>4c2I', subdat)
               usage = b''.join(subls[0:4])
               print('  %s %d: starts at %d' % (typestring(usage), subls[-2], subls[-1]))
       elif (self.type == b'IFmd'):
           # Metadata chunk
           dat = self.data()
           print(dat.decode('utf-8'))
       elif (self.type == b'Fspc'):
           # Frontispiece chunk
           dat = self.data()
           if (len(dat) != 4):
               print('Warning: invalid contents!')
           else:
               num = struct.unpack('>I', dat[0:4])[0]
               print('Frontispiece is pict number', num)
       elif (self.type == b'RDes'):
           # Resource description chunk
           dat = self.data()
           (subdat, dat) = (dat[:4], dat[4:])
           count = struct.unpack('>I', subdat)[0]
           print('%d entries:' % (count,))
           for ix in range(count):
               if (len(dat) < 12):
                   print('Warning: contents too short!')
                   break
               (subdat, dat) = (dat[:12], dat[12:])
               subls = struct.unpack('>4c2I', subdat)
               restype = b''.join(subls[0:4])
               strlen = subls[-1]
               num = subls[-2]
               if (len(dat) < strlen):
                   print('Warning: contents too short!')
                   break
               (subdat, dat) = (dat[:strlen], dat[strlen:])
               print('  %s resource %d: "%s"' % (typestring(restype), num, subdat.decode('utf-8')))
           if (len(dat) > 0):
               print('Warning: contents too long!')
       elif (self.type == b'APal'):
           # Adaptive palette
           dat = self.data()
           if (len(dat) % 4 != 0):
               print('Warning: invalid contents!')
           else:
               ls = []
               while (dat):
                   (subdat, dat) = (dat[:4], dat[4:])
                   num = struct.unpack('>I', subdat)[0]
                   ls.append(str(num))
               print('Picts using adaptive palette:', ' '.join(ls))
       elif (self.type == b'Loop'):
           # Looping
           dat = self.data()
           if (len(dat) % 8 != 0):
               print('Warning: invalid contents!')
           else:
               while (dat):
                   (subdat, dat) = (dat[:8], dat[8:])
                   (num, count) = struct.unpack('>II', subdat)
                   print('Sound %d repeats %d times' % (num, count))
       elif (self.type == b'RelN'):
           # Release number
           dat = self.data()
           if (len(dat) != 2):
               print('Warning: invalid contents!')
           else:
               num = struct.unpack('>H', dat)[0]
               print('Release number', num)
       elif (self.type == b'SNam'):
           # Story name (obsolete)
           dat = self.data()
           if (len(dat) % 2 != 0):
               print('Warning: invalid contents!')
           else:
               ls = []
               while (dat):
                   (subdat, dat) = (dat[:2], dat[2:])
                   num = struct.unpack('>H', subdat)[0]
                   ls.append(chr(num))
               print('Story name:', ''.join(ls))
       elif (self.type in (b'TEXT', b'ANNO', b'AUTH', b'(c) ')):
           dat = self.data()
           print(dat.decode())
       elif (self.type == b'Reso'):
           # Resolution chunk
           dat = self.data()
           if (len(dat)-24) % 28 != 0:
               print('Warning: invalid contents!')
           else:
               (subdat, dat) = (dat[:24], dat[24:])
               subls = struct.unpack('>6I', subdat)
               print('Standard window size %dx%d, min %dx%d, max %dx%d' % subls)
               while (dat):
                   (subdat, dat) = (dat[:28], dat[28:])
                   subls = struct.unpack('>7I', subdat)
                   print('Pict %d: standard ratio: %d/%d, min %d/%d, max %d/%d' % subls)
       else:
           dat = self.data(16)
           strdat = repr(dat)
           if (re.match('[a-z][\'\"]', strdat)):
               strdat = strdat[1:]
           if (len(dat) == self.len):
               print('contents: %s' % (strdat,))
           else:
               print('beginning: %s' % (strdat,))

class BlorbFile:
   def __init__(self, filename, outfilename=None):
       self.chunks = []
       self.chunkmap = {}
       self.chunkatpos = {}
       self.usages = []
       self.usagemap = {}

       self.filename = filename
       self.outfilename = outfilename
       if (not self.outfilename):
           self.outfilename = self.filename

       if (not self.filename):
           # No loading; create an empty file.
           self.file = None
           self.formchunk = None
           self.changed = True
           chunk = BlorbChunk(self, b'RIdx', -1, 4)
           chunk.literaldata = struct.pack('>I', 0)
           self.add_chunk(chunk, None, None, 0)
           return

       self.changed = False

       self.file = open(filename, 'rb')
       formchunk = Chunk(self.file)
       self.formchunk = formchunk

       if (formchunk.getname() != b'FORM'):
           raise Exception('This does not appear to be a Blorb file.')
       formtype = formchunk.read(4)
       if (formtype != b'IFRS'):
           raise Exception('This does not appear to be a Blorb file.')
       formlen = formchunk.getsize()
       while formchunk.tell() < formlen:
           chunk = Chunk(formchunk)
           start = formchunk.tell()
           size = chunk.getsize()
           formtype = None
           if chunk.getname() == b'FORM':
               formtype = chunk.read(4)
           subchunk = BlorbChunk(self, chunk.getname(), start, size, formtype)
           self.chunks.append(subchunk)
           chunk.skip()
           chunk.close()

       for chunk in self.chunks:
           self.chunkatpos[chunk.start] = chunk
           dict_append(self.chunkmap, chunk.type, chunk)

       # Sanity checks. Also get the usage list.

       ls = self.chunkmap.get(b'RIdx')
       if (not ls):
           raise Exception('No resource index chunk!')
       elif (len(ls) != 1):
           print('Warning: too many resource index chunks!')
       else:
           chunk = ls[0]
           if (self.chunks[0] is not chunk):
               print('Warning: resource index chunk is not first!')
           dat = chunk.data()
           numres = struct.unpack('>I', dat[0:4])[0]
           if (numres*12+4 != chunk.len):
               print('Warning: resource index chunk has wrong size!')
           for ix in range(numres):
               subdat = dat[4+ix*12 : 16+ix*12]
               typ = struct.unpack('>4c', subdat[0:4])
               typ = b''.join(typ)
               num = struct.unpack('>I', subdat[4:8])[0]
               start = struct.unpack('>I', subdat[8:12])[0]
               subchunk = self.chunkatpos.get(start)
               if (not subchunk):
                   print('Warning: resource (%s, %d) refers to a nonexistent chunk!' % (typestring(typ), num))
               self.usages.append( (typ, num, subchunk) )
               self.usagemap[(typ, num)] = subchunk

   def close(self):
       if (self.formchunk):
           self.formchunk.close()
           self.formchunk = None
       if (self.file):
           self.file.close()
           self.file = None

   def sanity_check(self):
       if (len(self.usages) != len(self.usagemap)):
           print('Warning: internal mismatch (usages)!')
       if (len(self.chunks) != len(self.chunkatpos)):
           print('Warning: internal mismatch (chunks)!')

   def chunk_position(self, chunk):
       try:
           return self.chunks.index(chunk)
       except:
           return None

   def save_if_needed(self):
       if self.changed:
           try:
               self.save()
           except CommandError as ex:
               print(str(ex))

   def canonicalize(self):
       self.sanity_check()
       try:
           indexchunk = self.chunkmap[b'RIdx'][0]
       except:
           raise CommandError('There is no index chunk, so this cannot be a legal blorb file.')
       indexchunk.len = 4 + 12*len(self.usages)
       pos = 12
       for chunk in self.chunks:
           chunk.savestart = pos
           pos = pos + 8 + chunk.len
           if (pos % 2):
               pos = pos+1
       self.usages.sort(key=lambda tup:tup[2].savestart)
       ls = []
       ls.append(struct.pack('>I', len(self.usages)))
       for (typ, num, chunk) in self.usages:
           ls.append(typ)
           ls.append(struct.pack('>II', num, chunk.savestart))
       dat = b''.join(ls)
       if (len(dat) != indexchunk.len):
           print('Warning: index chunk length does not match!')
       indexchunk.literaldata = dat

   def save(self, outfilename=None):
       if (outfilename):
           self.outfilename = outfilename
       if (not self.changed and (self.outfilename == self.filename)):
           raise CommandError('No changes need saving.')
       if (not self.outfilename):
           raise CommandError('No pathname supplied for saving.')
       if (os.path.exists(self.outfilename) and not opts.force):
           if (not confirm_input('File %s exists. Rewrite?' % (self.outfilename,))):
               print('Cancelled.')
               return
       self.canonicalize()
       tmpfilename = self.outfilename + '~TEMP'
       fl = open(tmpfilename, 'wb')
       fl.write(b'FORM----IFRS')
       pos = 12
       for chunk in self.chunks:
           fl.write(chunk.type)
           fl.write(struct.pack('>I', chunk.len))
           pos = pos+8
           dat = chunk.data()
           fl.write(dat)
           pos = pos+len(dat)
           if (pos % 2):
               fl.write(b'\0')
               pos = pos+1
       fl.seek(4)
       fl.write(struct.pack('>I', pos-8))
       fl.close()
       os_replace(tmpfilename, self.outfilename)
       print('Wrote file:', self.outfilename)
       return self.outfilename

   def delete_chunk(self, delchunk):
       self.chunks = [ chunk for chunk in self.chunks if (chunk is not delchunk) ]
       ls = self.chunkmap[delchunk.type]
       ls = [ chunk for chunk in ls if (chunk is not delchunk) ]
       if (ls):
           self.chunkmap[delchunk.type] = ls
       else:
           self.chunkmap.pop(delchunk.type)
       self.chunkatpos.pop(delchunk.start)
       self.usages = [ tup for tup in self.usages if (tup[2] is not delchunk) ]
       ls = [ key for (key,val) in self.usagemap.items() if (val is delchunk) ]
       for key in ls:
           self.usagemap.pop(key)
       self.changed = True

   def add_chunk(self, chunk, use=None, num=None, pos=None):
       if (pos is None):
           self.chunks.append(chunk)
       else:
           self.chunks.insert(pos, chunk)
       self.chunkatpos[chunk.start] = chunk
       dict_append(self.chunkmap, chunk.type, chunk)
       if (use is not None):
           self.usages.append( (use, num, chunk) )
           self.usagemap[(use,num)] = chunk
       self.changed = True

class CommandError(Exception):
   pass

class BlorbTool:
   def show_commands():
       print('blorbtool commands:')
       print()
       print('list -- list all chunks')
       print('index -- list all resources in the index chunk')
       print('display -- display contents of all chunks')
       print('display TYPE -- contents of chunk(s) of that type')
       print('display USE NUM -- contents of chunk by use and number (e.g., "display Exec 0")')
       print('export TYPE FILENAME -- export the chunk of that type to a file')
       print('export USE NUM FILENAME -- export a chunk by use and number')
       print('import TYPE FILENAME -- import a file as a chunk of that type')
       print('import USE NUM TYPE FILENAME -- import a file as a resource of that use, number, and type')
       print('delete TYPE -- delete chunk(s) of that type')
       print('delete USE NUM -- delete chunk by use and number')
       print('giload DIRECTORY -- export the Exec and Pict chunks for use with Quixe')
       print('save -- write out changes')
       print('reload -- discard changes and reload existing blorb file')

   show_commands = staticmethod(show_commands)

   def __init__(self):
       self.is_interactive = False
       self.has_quit = False

   def set_interactive(self, val):
       self.is_interactive = val

   def quit_yet(self):
       return self.has_quit

   def handle(self, args=None):
       try:
           if (self.is_interactive):
               args = raw_input('>').split()
           if (not args):
               return
           argname = args.pop(0)
           if (argname in self.aliasmap):
               argname = self.aliasmap[argname]
           cmd = getattr(self, 'cmd_'+argname, None)
           if (not cmd):
               raise CommandError('Unknown command: ' + argname)
               return
           cmd(args)
       except KeyboardInterrupt:
           # EOF or interrupt. Pass it on.
           raise
       except EOFError:
           # EOF or interrupt. Pass it on.
           raise
       except CommandError as ex:
           print(str(ex))
       except Exception as ex:
           # Unexpected exception: print it.
           print(ex.__class__.__name__+':', str(ex))
           if (opts.verbose):
               raise

   def parse_int(self, val, label=''):
       if (label):
           label = label+': '
       try:
           return int(val)
       except:
           raise CommandError(label+'integer required')

   def parse_chunk_type(self, val, label=''):
       if (label):
           label = label+': '
       if len(val) > 4:
           raise CommandError(label+'chunk type must be 1-4 characters')
       return val.ljust(4).encode()

   aliasmap = { '?':'help', 'q':'quit', 'write':'save', 'restart':'reload', 'restore':'reload' }

   def cmd_quit(self, args):
       if (args):
           raise CommandError('usage: quit')
       self.has_quit = True

   def cmd_help(self, args):
       if (args):
           raise CommandError('usage: help')
       self.show_commands()

   def cmd_list(self, args):
       if (args):
           raise CommandError('usage: list')
       print(len(blorbfile.chunks), 'chunks:')
       for chunk in blorbfile.chunks:
           print('  %s' % (chunk.describe(),))

   def cmd_index(self, args):
       if (args):
           raise CommandError('usage: index')
       print(len(blorbfile.usages), 'resources:')
       for (use, num, chunk) in blorbfile.usages:
           print('  %s %d: %s' % (typestring(use), num, chunk.describe()))

   def cmd_display(self, args):
       if (not args):
           ls = blorbfile.chunks
       elif (len(args) == 1):
           typ = self.parse_chunk_type(args[0], 'display')
           ls = [ chunk for chunk in blorbfile.chunks if chunk.type == typ ]
           if (not ls):
               raise CommandError('No chunks of type %s' % (typestring(typ),))
       elif (len(args) == 2):
           use = self.parse_chunk_type(args[0], 'display')
           num = self.parse_int(args[1], 'display (second argument)')
           chunk = blorbfile.usagemap.get( (use, num) )
           if (not chunk):
               raise CommandError('No resource with usage %s, number %d' % (typestring(use), num))
           ls = [ chunk ]
       else:
           raise CommandError('usage: display | display TYPE | display USE NUM')
       for chunk in ls:
           chunk.display()

   def cmd_export(self, args):
       if (len(args) == 2):
           typ = self.parse_chunk_type(args[0], 'export')
           ls = [ chunk for chunk in blorbfile.chunks if chunk.type == typ ]
           if (not ls):
               raise CommandError('No chunks of type %s' % (typestring(typ),))
           if (len(ls) != 1):
               raise CommandError('%d chunks of type %s' % (len(ls), typestring(typ),))
           chunk = ls[0]
       elif (len(args) == 3):
           use = self.parse_chunk_type(args[0], 'export')
           num = self.parse_int(args[1], 'export (second argument)')
           chunk = blorbfile.usagemap.get( (use, num) )
           if (not chunk):
               raise CommandError('No resource with usage %s, number %d' % (typestring(use), num))
       else:
           raise CommandError('usage: export TYPE FILENAME | export USE NUM FILENAME')
       outfilename = args[-1]
       if (outfilename == blorbfile.filename):
           raise CommandError('You can\'t export a chunk over the original blorb file!')
       if (os.path.exists(outfilename) and not opts.force):
           if (not confirm_input('File %s exists. Overwrite?' % (outfilename,))):
               print('Cancelled.')
               return
       outfl = open(outfilename, 'wb')
       if (chunk.formtype and chunk.formtype != b'FORM'):
           # For an AIFF file, we must include the FORM/length header.
           # (Unless it's an overly nested AIFF.)
           outfl.write(b'FORM')
           outfl.write(struct.pack('>I', chunk.len))
       outfl.write(chunk.data())
       finallen = outfl.tell()
       outfl.close()
       print('Wrote %d bytes to %s.' % (finallen, outfilename))

   def cmd_import(self, args):
       origchunk = None
       if (len(args) == 2):
           typ = self.parse_chunk_type(args[0], 'import')
           use = None
           num = None
           ls = [ chunk for chunk in blorbfile.chunks if chunk.type == typ ]
           if (ls):
               origchunk = ls[0]
       elif (len(args) == 4):
           use = self.parse_chunk_type(args[0], 'import')
           num = self.parse_int(args[1], 'import (second argument)')
           typ = self.parse_chunk_type(args[2], 'import (third argument)')
           origchunk = blorbfile.usagemap.get( (use, num) )
       else:
           raise CommandError('usage: import TYPE FILENAME | import USE NUM TYPE FILENAME')
       infilename = args[-1]
       if (infilename == blorbfile.filename):
           raise CommandError('You can\'t import the original blorb file as a chunk!')
       fl = open(infilename, 'rb')
       filestart = None
       formtype = None
       dat = fl.read(5)
       if (dat[0:4] == b'FORM' and ord(dat[4]) < 0x20):
           # This is an AIFF file, and must be embedded
           filestart = 8
           fl.seek(8, 0)
           formtype = fl.read(4)
           if (typ != b'FORM'):
               # We accept the formtype as a synonym here, if the user
               # got it right.
               if (typ != formtype):
                   raise CommandError('This IFF file has form type \'%s\', not \'%s\'.' % (formtype, typ))
               typ = b'FORM'
       fl.seek(0, 2)
       filelen = fl.tell()
       fl.close()
       if (filestart):
           filelen = filelen - 8
       fakestart = min(list(blorbfile.chunkatpos.keys()) + [0]) - 1
       if origchunk:
           # Replace existing chunk
           pos = blorbfile.chunk_position(origchunk)
           blorbfile.delete_chunk(origchunk)
       else:
           pos = None
       chunk = BlorbChunk(blorbfile, typ, fakestart, filelen)
       chunk.filedata = infilename
       if (filestart):
           chunk.filestart = filestart
           chunk.formtype = formtype
       blorbfile.add_chunk(chunk, use, num, pos)
       if pos is None:
           print('Added chunk, length %d' % (filelen,))
       else:
           print('Replaced chunk, new length %d' % (filelen,))

   def cmd_giload(self, args):
       prefix = ''
       if (len(args) == 1):
           outdirname = args[0]
       elif (len(args) == 2):
           outdirname = args[0]
           prefix = args[1]
       else:
           raise CommandError('usage: giload DIRECTORY | giload DIRECTORY PREFIX')
       if (not (os.path.exists(outdirname) and os.path.isdir(outdirname))):
           raise CommandError('Not a directory: %s' % (outdirname))

       chunk = blorbfile.usagemap.get( (b'Exec', 0) )
       if (not chunk):
           raise CommandError('No resource with usage %s, number %d' % (typestring(use), num))
       chunkdat = chunk.data()
       if (chunk.formtype and chunk.formtype != b'FORM'):
           chunkdat = b'FORM' + struct.pack('>I', chunk.len) + chunkdat
       outfl = open(os.path.join(outdirname, 'game.ulx.js'), 'w')
       chunkdatenc = base64.b64encode(chunkdat).decode()
       outfl.write('$(document).ready(function() {\n')
       outfl.write("  GiLoad.load_run(null, '%s', 'base64');\n" % (chunkdatenc,))
       outfl.write('});\n')
       outfl.close()

       alttexts = {}
       ls = blorbfile.chunkmap.get(b'RDes')
       if (ls):
           chunk = ls[0]
           alttexts = analyze_resourcedescs(chunk)

       outfl = open(os.path.join(outdirname, 'resourcemap.js'), 'w')
       outfl.write('/* resourcemap.js generated by blorbtool.py */\n')
       outfl.write('StaticImageInfo = {\n')
       usages = [ (num, chunk) for (use, num, chunk) in blorbfile.usages if (use == b'Pict') ]
       usages.sort()   # on num
       first = True
       wholemap = collections.OrderedDict()
       for (num, chunk) in usages:
           try:
               (suffix, size) = analyze_pict(chunk)
           except Exception as ex:
               print('Error on Pict chunk %d: %s' % (num, ex))
               continue
           picfilename = 'pict-%d.%s' % (num, suffix)
           map = collections.OrderedDict()
           map['image'] = num
           map['url'] = os.path.join(prefix, picfilename)
           if (b'Pict', num) in alttexts:
               map['alttext'] = alttexts.get( (b'Pict',num) ).decode('utf-8')
           map['width'] = size[0]
           map['height'] = size[1]
           wholemap['pict-%d' % (num,)] = map
           indexdat = json.dumps(map, indent=2)
           if (first):
               first = False
           else:
               outfl.write(',\n')
           outfl.write('%d: %s\n' % (num, indexdat))
           outfl2 = open(os.path.join(outdirname, picfilename), 'wb')
           if (chunk.formtype and chunk.formtype != b'FORM'):
               outfl2.write(b'FORM')
               outfl2.write(struct.pack('>I', chunk.len))
           outfl2.write(chunk.data())
           outfl2.close()
       outfl.write('};\n')
       outfl.close()

       outfl = open(os.path.join(outdirname, 'resourcemap.json'), 'w')
       json.dump(wholemap, outfl, indent=2)
       outfl.write('\n')
       outfl.close()

       print('Wrote Quixe-compatible data to directory "%s".' % (outdirname,))

   def cmd_delete(self, args):
       if (len(args) == 1):
           typ = self.parse_chunk_type(args[0], 'delete')
           ls = [ chunk for chunk in blorbfile.chunks if chunk.type == typ ]
           if (not ls):
               raise CommandError('No chunks of type %s' % (typestring(typ),))
       elif (len(args) == 2):
           use = self.parse_chunk_type(args[0], 'delete')
           num = self.parse_int(args[1], 'delete (second argument)')
           chunk = blorbfile.usagemap.get( (use, num) )
           if (not chunk):
               raise CommandError('No resource with usage %s, number %d' % (typestring(use), num))
           ls = [ chunk ]
       else:
           raise CommandError('usage: delete TYPE | delete USE NUM')
       for chunk in ls:
           blorbfile.delete_chunk(chunk)
       print('Deleted %d chunk%s' % (len(ls), ('' if len(ls)==1 else 's')))

   def cmd_reload(self, args):
       global blorbfile
       if (args):
           raise CommandError('usage: reload')
       filename = blorbfile.filename
       blorbfile.close()
       blorbfile = BlorbFile(filename)
       print('Reloaded %s.' % (filename,))

   def cmd_save(self, args):
       global blorbfile
       if (len(args) == 0):
           outfilename = None
       elif (len(args) == 1):
           outfilename = args[0]
       else:
           raise CommandError('usage: save | save FILENAME')
       filename = blorbfile.save(outfilename)
       if (filename):
           # Reload, so that the blorbfile's Chunk (and its chunks)
           # refer to the new file. (The reloaded blorbfile will have
           # changed == False, too.)
           blorbfile.close()
           blorbfile = BlorbFile(filename)

   def cmd_dump(self, args):
       print('### chunks:', blorbfile.chunks)
       print('### chunkmap:', blorbfile.chunkmap)
       print('### chunkatpos:', blorbfile.chunkatpos)
       print('### usages:', blorbfile.usages)
       print('### usagemap:', blorbfile.usagemap)

# Some utility functions.

def typestring(dat):
   return "'" + dat.decode() + "'"

def bytes_to_intarray(dat):
   if (bytes is str):
       # Python 2
       return [ ord(val) for val in dat ]
   else:
       # Python 3
       return [ val for val in dat ]

def intarray_to_bytes(arr):
   if (bytes is str):
       # Python 2
       return b''.join([ chr(val) for val in arr ])
   else:
       # Python 3
       return bytes(arr)

def analyze_resourcedescs(chunk):
   res = {}
   dat = chunk.data()
   (subdat, dat) = (dat[:4], dat[4:])
   count = struct.unpack('>I', subdat)[0]
   for ix in range(count):
       if (len(dat) < 12):
           break
       (subdat, dat) = (dat[:12], dat[12:])
       subls = struct.unpack('>4c2I', subdat)
       usage = b''.join(subls[0:4])
       strlen = subls[-1]
       num = subls[-2]
       if (len(dat) < strlen):
           break
       (subdat, dat) = (dat[:strlen], dat[strlen:])
       res[(usage, num)] = subdat
   return res

def analyze_pict(chunk):
   if (chunk.type == b'JPEG'):
       size = parse_jpeg(chunk.data())
       return ('jpeg', size)
   if (chunk.type == b'PNG '):
       size = parse_png(chunk.data())
       return ('png', size)
   raise Exception('Unrecognized Pict type: %s' % (chunk.type,))

def parse_png(dat):
   dat = bytes_to_intarray(dat)
   pos = 0
   sig = dat[pos:pos+8]
   pos += 8
   if sig != [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]:
       raise Exception('PNG signature does not match')
   while pos < len(dat):
       clen = (dat[pos] << 24) | (dat[pos+1] << 16) | (dat[pos+2] << 8) | dat[pos+3]
       pos += 4
       ctyp = intarray_to_bytes(dat[pos:pos+4])
       pos += 4
       #print('Chunk:', ctyp, 'len', clen)
       if ctyp == b'IHDR':
           width  = (dat[pos] << 24) | (dat[pos+1] << 16) | (dat[pos+2] << 8) | dat[pos+3]
           pos += 4
           height = (dat[pos] << 24) | (dat[pos+1] << 16) | (dat[pos+2] << 8) | dat[pos+3]
           pos += 4
           return (width, height)
       pos += clen
       pos += 4
   raise Exception('No PNG header block found')

def parse_jpeg(dat):
   dat = bytes_to_intarray(dat)
   #print('Length:', len(dat))
   pos = 0
   while pos < len(dat):
       if dat[pos] != 0xFF:
           raise Exception('marker is not FF')
       while dat[pos] == 0xFF:
           pos += 1
       marker = dat[pos]
       pos += 1
       if marker == 0x01 or (marker >= 0xD0 and marker <= 0xD9):
           #print('FF%02X*' % (marker,))
           continue
       clen = (dat[pos] << 8) | dat[pos+1]
       #print('FF%02X, len %d' % (marker, clen))
       if (marker >= 0xC0 and marker <= 0xCF and marker != 0xC8):
           if clen <= 7:
               raise Exception('SOF block is too small')
           bits = dat[pos+2]
           height = (dat[pos+3] << 8) | dat[pos+4]
           width  = (dat[pos+5] << 8) | dat[pos+6]
           return (width, height)
       pos += clen
   raise Exception('SOF block not found')

# Actual work begins here.

if (opts.listcommands):
   BlorbTool.show_commands()
   sys.exit(-1)

if (not args and not opts.newfile):
   popt.print_help()
   sys.exit(-1)

filename = None
if (args):
   filename = args.pop(0)
   if (opts.newfile and not opts.output):
       opts.output = filename
       filename = None

try:
   blorbfile = BlorbFile(filename, opts.output)
except Exception as ex:
   print(ex.__class__.__name__+':', str(ex))
   if (opts.verbose):
       raise
   sys.exit(-1)

# If args exist, execute them as a command. If not, loop grabbing and
# executing commands until we discover that the user has executed Quit.
# (The handler catches all exceptions except KeyboardInterrupt.)
try:
   tool = BlorbTool()
   if (args):
       tool.set_interactive(False)
       tool.handle(args)
       blorbfile.sanity_check()
       blorbfile.save_if_needed()
   else:
       tool.set_interactive(True)
       while (not tool.quit_yet()):
           tool.handle()
           blorbfile.sanity_check()
       blorbfile.save_if_needed()
       print('<exiting>')
except KeyboardInterrupt:
   print('<interrupted>')
except EOFError:
   print('<eof>')

blorbfile.close()

You are viewing proxied material from gopher.661.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.