package com.tapina.robe.swi;
   
   import com.tapina.robe.module.Module;
   import com.tapina.robe.module.ModuleUtils;
   import com.tapina.robe.runtime.*;
   import com.tapina.robe.runtime.instruction.SWI;
   import com.tapina.robe.swi.os.*;
   
   import java.awt.*;
  import java.awt.image.BufferedImage;
  import java.io.*;
  import java.lang.reflect.Method;
  import java.text.CharacterIterator;
  import java.util.*;
  import java.util.logging.Logger;
  
  /***
   * Created by IntelliJ IDEA.
   * User: gareth
   * Date: Aug 21, 2003
   * Time: 6:12:53 PM
   */
  public final class OS extends SWIHandler {
      private static OS instance = null;
  
      private OS() {
      }
  
      public synchronized static OS getInstance() {
          if (instance == null) {
              instance = new OS();
          }
          return instance;
      }
  
      public static int getBase() {
          return 0;
      }
  
      public String getName() {
          return "UtilityModule";
      }
  
      private static final String[] methodNames = new String[]{
          "WriteC", "", "Write0", "NewLine", "ReadC", "CLI", "Byte", "", // 0x00
          "File", "Args", "", "", "GBPB", "Find", "", "", // 0x08
          "GetEnv", "Exit", "", "IntOn", "IntOff", "", "EnterOS", "", // 0x10
          "", "", "", "", "", "", "Module", "", // 0x18
          "", "ReadUnsigned", "", "ReadVarVal", "SetVarVal", "", "", "GSTrans", // 0x20
          "", "FSControl", "ChangeDynamicArea", "GenerateError", "", "", "SpriteOp", "", // 0x28
          "", "ReadVduVariables", "", "", "", "ReadModeVariable", "", "", // 0x30
          "", "", "", "", "", "", "", "" // 0x38
      };
  
      public static Method getMethod(Integer offset) throws NoSuchMethodException {
          return getMethod(methodNames[offset.intValue()]);
      }
  
      private static final Method getMethod(String name) throws NoSuchMethodException {
          return OS.class.getMethod(name, METHOD_PARAMETERS);
      }
  
      public final void WriteC(Environment env) {
          char charIso88591 = (char) (env.getCpu().R[0] & 0xff);
          writeC(charIso88591);
      }
  
      public final void writeC(char c) {
          System.out.print(c);
      }
  
      public final void NewLine(Environment env) {
          newLine();
      }
  
      public final void newLine() {
          System.out.print("\r\n");
      }
  
      public final void ReadC(Environment env) {
          char charIso88591 = readC();
          env.getCpu().clearC();
          env.getCpu().R[0] = charIso88591 & 0xff;
      }
  
      public final char readC() {
          try {
              return (char) System.in.read();
          } catch (IOException e) {
              throw new SWIError(0, e);
          }
      }
  
      public final void Write0(Environment env) {
          final int[] R = env.getCpu().R;
          final String s = env.getMemoryMap().getString0(R[0]);
          write0(s);
          R[0] += s.length() + 1;
      }
 
     public final void write0(String s) {
         System.out.print(s);
     }
 
     public final void CLI(Environment env) {
         String command = env.getMemoryMap().getString0_10_13(env.getCpu().R[0]);
         cli(command);
     }
 
     public final void cli(String command) {
         StringTokenizer tokenizer = new StringTokenizer(command);
         String id = tokenizer.nextToken();
         if (id.equalsIgnoreCase("copy")) {
             final String fromFile = tokenizer.nextToken();
             final String toFile = tokenizer.nextToken();
             boolean preserveAccess = true, confirmCopy = true, deleteSource = false, forceOverwrite = false,
                     lookFirst = false, newerOnly = false, promptDiscChange = false, quick = false, recurse = false,
                     restamp = false, structureOnly = false, verbose = true;
             if (tokenizer.hasMoreTokens()) {
                 final String options = tokenizer.nextToken().toUpperCase();
                 if (options.indexOf("~A") != -1) preserveAccess = false;
                 if (options.indexOf("~C") != -1) confirmCopy = false;
                 if (options.indexOf("D") != -1) deleteSource = true;
                 if (options.indexOf("F") != -1) forceOverwrite = true;
                 if (options.indexOf("L") != -1) lookFirst = true;
                 if (options.indexOf("N") != -1) newerOnly = true;
                 if (options.indexOf("P") != -1) promptDiscChange = true;
                 if (options.indexOf("Q") != -1) quick = true;
                 if (options.indexOf("R") != -1) recurse = true;
                 if (options.indexOf("S") != -1) restamp = true;
                 if (options.indexOf("T") != -1) structureOnly = true;
                 if (options.indexOf("~V") != -1) verbose = false;
                 File in = new File(FilenameUtils.acornToNative(fromFile));
                 File out = new File(FilenameUtils.acornToNative(toFile));
                 BufferedInputStream inputStream = null;
                 BufferedOutputStream outputStream = null;
                 try {
                     inputStream = new BufferedInputStream(new FileInputStream(in));
                     outputStream = new BufferedOutputStream(new FileOutputStream(out));
                     int c;
                     while ((c = inputStream.read()) != -1) {
                         outputStream.write(c);
                     }
                 } catch (IOException e) {
                     throw new SWIError(0, e);
                 } finally {
                     try {
                         if (inputStream != null) {
                             inputStream.close();
                         }
                         if (outputStream != null) {
                             outputStream.close();
                         }
                     } catch (IOException e) {
                         // Ignore
                     }
                 }
                 if (deleteSource) {
                     in.delete();
                 }
             }
         } else {
             log.warning("We do not handle * command: *" + command);
         }
     }
 
     public final void Byte(Environment env) {
         final int[] R = env.getCpu().R;
         int[] result = osByte(R[0], R[1], R[2]);
         System.arraycopy(result, 0, R, 1, result.length);
     }
 
     private final static byte[] CMOS = new byte[240];
 
     static {
         CMOS[140] = 0; // NewLook flags
     }
 
     public final int[] osByte(int reasonCode, int r1, int r2) {
         switch (reasonCode) {
             case 0: // Get OS version
                 switch (r1) {
                     case 0: // Throw version as error
                         throw new SWIError(0, "ROBE 0.10");
                     case 1: // Return version code
                         return new int[]{6};
                     default:
                         throw new SWIError(0, "Unknown OS.Byte 0," + r1);
                 }
             case 161: // Read CMOS value
                 return new int[]{r1, CMOS[r1]};
             case 240: // Read country number
                 if (r1 != 0 || r2 != 255) {
                     log.warning("We do not support writing country number with OSByte 240");
                 }
                 return new int[]{Territory.getInstance().getDefaultTerritoryNumber(), 0};
             default:
                 throw new SWIError(0, "Unknown OS.Byte " + reasonCode);
         }
     }
 
     public final void File(Environment env) {
         final int[] R = env.getCpu().R;
         final String filename = env.getMemoryMap().getString0(R[1]);
         switch (R[0]) {
             case 1:
                 file1(filename, R[2], R[3], R[5]);
                 break;
             case 8:
                 file8(filename);
                 break;
             case 10:
                 ByteArray data = env.getMemoryMap().getByteArray(R[4], R[5] - R[4] + 1, false);
                 file10(filename, R[2], data);
                 break;
             case 16:
                 if ((R[3] & 0xff) != 0) {
                     throw new SWIError(0, "Cannot load files at their own load address");
                 }
                 if ((R[3] & 1<<31) != 0) {
                     log.warning("We do not correctly synchronise on code load");
                 }
                 final DirectoryEntry entry16 = file5(filename, null);
                 ByteArray buffer = env.getMemoryMap().getByteArray(R[2], entry16.getLength(), true);
                 file16(filename, buffer);
                 break;
             case 17:
                 DirectoryEntry entry = file5(filename, null);
                 if (entry != null) {
                     R[0] = entry.getObjectType();
                     R[2] = entry.getLoadAddress();
                     R[3] = entry.getExecAddress();
                     R[4] = entry.getLength();
                     R[5] = entry.getAttributes();
                 } else {
                     R[0] = 0; // Not found.
                 }
                 break;
             default:
                 throw new SWIError(0, "Unknown OS.File " + R[0]);
         }
     }
 
     /***
      * This SWI is used to load a named file. An error will be generated if not found, is directory, no read access,
      * or a bad load address.
      * @param filename
      * @param buffer
      */
     private void file16(String filename, ByteArray buffer) {
         final File file = new File(FilenameUtils.acornToNative(filename));
         if (file.isDirectory()) {
             throw new SWIError(0, "Filename specified is a directory");
         }
         FileInputStream inputStream = null;
         try {
             inputStream = new FileInputStream(file);
             inputStream.read(buffer.getArray(), buffer.getOffset(), buffer.getLength());
             inputStream.close();
         } catch (IOException e) {
             throw new SWIError(0, e);
         } finally {
             if (inputStream != null) {
                 try {
                     inputStream.close();
                 } catch (IOException e) { // Ignore
                 }
             }
         }
     }
 
     /***
      * This SWI is used to read catalogue information for a named object.
      *
      * @param filename
      * @param path
      */
     public final DirectoryEntry file5(String filename, String path) {
         if (path != null) {
             log.warning("OS_File path ignored when reading directory entry");
         }
         File file = new File(FilenameUtils.acornToNative(filename));
         return fileDirectoryEntry(file);
     }
 
     public void file1(String filename, int loadAddress, int execAddress, int attributes) {
         DirectoryEntry directoryEntry = new DirectoryEntry(filename, loadAddress, execAddress, attributes);
         File file = new File(filename);
         file.setLastModified(directoryEntry.getTimestamp().getTime());
     }
 
     public final void file8(String filename) {
         final File dir = new File(FilenameUtils.acornToNative(filename));
         boolean success = dir.isDirectory() || dir.mkdir();
         if (!success) {
             throw new SWIError(0, "Unable to create directory and it does not already exist");
         }
     }
 
     public final void file10(String filename, int filetype, ByteArray data) {
         final File file = new File(FilenameUtils.acornToNative(filename));
         FileOutputStream outputStream = null;
         try {
             outputStream = new FileOutputStream(file);
             outputStream.write(data.getArray(), data.getOffset(), data.getLength());
         } catch (IOException e) {
             throw new SWIError(0, e);
         } finally {
             if (outputStream != null) {
                 try {
                     outputStream.close();
                 } catch (IOException e) { // Ignore
                 }
             }
         }
     }
 
     public final void Args(Environment env) {
         final int[] R = env.getCpu().R;
         int result = args(R[0], R[1] & 0xff, R[2]);
         R[2] = result;
     }
 
     public final int args(int reasonCode, int handle, int attribute) {
         try {
             switch (reasonCode) {
                 case 2: // Read extent
                     RandomAccessFile randomAccessFile = getOpenFile(handle);
                     return (int) randomAccessFile.length();
                 default:
                     throw new SWIError(0, "Unknown OS.Args " + reasonCode);
             }
         } catch (IOException e) {
             throw new SWIError(0, e);
         }
     }
 
     public final void GBPB(Environment env) {
         final CPU cpu = env.getCpu();
         final int[] R = cpu.R;
         final MemoryMap memoryMap = env.getMemoryMap();
         switch (R[0]) {
             case 4:
                 final int count = R[3];
                 final byte[] buffer = new byte[count];
                 int unreadCount = gbpb4(R[0], R[1], buffer, 0, count);
                 final int readCount = count - unreadCount;
                 memoryMap.storeBytes(R[2], buffer, 0, readCount);
                 R[2] += readCount;
                 R[3] = unreadCount;
                 if (unreadCount == 0) {
                     cpu.clearC();
                 } else {
                     cpu.setC();
                 }
                 log.warning("New file pointer not returned in R4");
                 break;
             case 11:
                 final String dirname = memoryMap.getString0(R[1]);
                 final String match = R[6] == 0 ? null : memoryMap.getString0(R[6]);
                 final DirectoryEntry[] entries = gbpb11(R[0], dirname, R[4], R[3], match);
                 // Store the entries in the buffer
                 int entryBase = R[2];
                 R[3] = 0;
                 for (int i = 0; i < entries.length; i++, R[3]++) {
                     DirectoryEntry entry = entries[i];
                     int entrySize = 29 + entry.getName().length() + 1;
                     if (entryBase + entrySize > R[2] + R[5]) {
                         break;
                     }
                     long fiveByteTime = convertTo5ByteTime(entry.getTimestamp());
                     memoryMap.storeWords(entryBase, new int[]{entry.getLoadAddress(), entry.getExecAddress(),
                                                               entry.getLength(), entry.getAttributes(),
                                                               entry.getObjectType(), entry.getInternalName(),
                                                               (int) (fiveByteTime & 0xffffffffL)});
                     memoryMap.storeByte(entryBase + 28, (byte) (fiveByteTime >> 32));
                     memoryMap.storeString0(entryBase + 29, entry.getName());
                     entryBase += (entrySize + 3) & (~3); // Word-aligned
                 }
                 R[4] = (entries.length == 0) ? -1 : R[4] + entries.length;
                 if (R[3] == 0) {
                     cpu.clearC();
                 } else {
                     cpu.setC();
                 }
                 break;
             default:
                 throw new SWIError(0, "Unknown OS.GBPB " + R[0]);
         }
     }
 
     public final int gbpb4(int reasonCode, int fileHandle, byte[] buffer, int offset, int count) {
         try {
             switch (reasonCode) {
                 case 4: // Read bytes from current file pointer
                     RandomAccessFile randomAccessFile = getOpenFile(fileHandle);
                     int readCount = randomAccessFile.read(buffer, offset, count);
                     if (readCount != -1) {
                         return count - readCount;
                     } else {
                         return count;
                     }
                 default:
                     throw new SWIError(0, "Unknown OS.GBPB " + reasonCode);
             }
         } catch (IOException e) {
             throw new SWIError(0, e);
         }
     }
 
     private final Map directoryEntryMap = new HashMap(10);
 
     public final DirectoryEntry[] gbpb11(int reasonCode, String dirName, int offset, int count, String match) {
         switch (reasonCode) {
             case 11:
                 final String key = dirName + ':' + match;
                 DirectoryEntry[] entries = (DirectoryEntry[]) directoryEntryMap.get(key);
                 if (entries == null) {
                     File f = new File(FilenameUtils.acornToNative(dirName));
                     if (match != null && !match.equals("*")) {
                         log.warning("Filename match string ignored");
                     }
                     File[] fs = f.listFiles();
                     entries = new DirectoryEntry[fs == null ? 0 : fs.length];
                     for (int i = 0; i < entries.length; i++) {
                         File file = fs[i];
                         entries[i] = fileDirectoryEntry(file);
                     }
                     directoryEntryMap.put(key, entries);
                 }
                 if (entries.length - offset < count) {
                     count = entries.length - offset;
                 }
                 DirectoryEntry[] result = new DirectoryEntry[count];
                 System.arraycopy(entries, offset, result, 0, count);
                 return result;
             default:
                 throw new SWIError(0, "Unknown OS.GBPB " + reasonCode);
         }
     }
 
     /***
      * Return a DirectoryEntry for a given File.
      * DirectoryEntry is a representation of the information RISC OS programs expect to be able to find out about
      * a file from its directory entry. File is a Java representation of an abstract point in the filesystem.
      *
      * @param file filesystem entry to obtain DirectoryEntry for. It need not exist.
      * @return DirectoryEntry for given file. It will indicate the file's type.
      */
     DirectoryEntry fileDirectoryEntry(File file) {
         long timestamp = file.lastModified();
         long length = file.length();
         int attributes = 0;
         if (file.canRead()) {
             attributes |= DirectoryEntry.ATTRIBUTE_OWNER_READ + DirectoryEntry.ATTRIBUTE_OTHERS_READ;
         }
         if (file.canWrite()) {
             attributes |= DirectoryEntry.ATTRIBUTE_OWNER_WRITE + DirectoryEntry.ATTRIBUTE_OTHERS_WRITE;
         }
         if (file.isHidden()) {
             attributes |= DirectoryEntry.ATTRIBUTE_HIDDEN + DirectoryEntry.ATTRIBUTE_LOCKED;
         }
         final int type = file.exists() ? (file.isDirectory() ? DirectoryEntry.TYPE_DIRECTORY : DirectoryEntry.TYPE_FILE) :
                 DirectoryEntry.TYPE_NOT_FOUND;
         return new DirectoryEntry(FilenameUtils.nativeToAcorn(file.getName()),
                 new Date(timestamp), length, attributes, type);
     }
 
     public final void Find(Environment env) {
         final int[] R = env.getCpu().R;
         final int action = R[0] & 0xc0;
         final int pathType = R[0] & 0x03;
         boolean dirError = (R[0] & 0x04) != 0;
         boolean missingError = (R[0] & 0x08) != 0;
         if (action != 0) {
             final String filename = env.getMemoryMap().getString0(R[1]);
             final String path;
             switch (pathType) {
                 case 0:
                     path = readVarVal("File$Path");
                     break;
                 case 1:
                     path = env.getMemoryMap().getString0(R[2]);
                     break;
                 case 2:
                     path = readVarVal(env.getMemoryMap().getString0(R[2]));
                     break;
                 default:
                     path = null;
             }
             R[0] = find(action, filename, path, dirError, missingError);
         } else {
             find(action, R[1]);
         }
     }
 
     private static int fileHandleSeq = 100;
     private final Map randomAccessFileMap = new HashMap(10);
 
     public final int find(int action, String filename, String path, boolean dirError, boolean missingError) {
         if (path != null) {
             log.warning("We do not support paths in OS.Find");
         }
         filename = FilenameUtils.acornToNative(filename);
         RandomAccessFile randomAccessFile;
         try {
             switch (action) {
                 case 0x40:
                     // Open existing file with read-only access
                     randomAccessFile = new RandomAccessFile(filename, "r");
                     break;
                 case 0x80:
                     // Create empty file with read/write access
                     randomAccessFile = new RandomAccessFile(filename, "rw");
                     randomAccessFile.setLength(0); // Truncate the file to 0
                     break;
                 case 0xc0:
                     // Open existing file with read/write access
                     randomAccessFile = new RandomAccessFile(filename, "rw");
                     break;
                 default:
                     throw new SWIError(0, "Unknown OS.Find &" + Integer.toHexString(action));
             }
             synchronized (OS.class) {
                 final int fileHandle = fileHandleSeq++;
                 randomAccessFileMap.put(new Integer(fileHandle), randomAccessFile);
                 return fileHandle;
             }
         } catch (IOException e) {
             throw new SWIError(0, e);
         }
     }
 
     public final int find(int action, int handle) {
         if (action == 0) {
             // Close the file with the handle, or close all files if handle = 0
             RandomAccessFile randomAccessFile = getOpenFile(handle);
             if (randomAccessFile != null) {
                 try {
                     randomAccessFile.close();
                 } catch (IOException e) {
                     throw new SWIError(0, e);
                 }
             }
         }
         return handle;
     }
 
     private RandomAccessFile getOpenFile(int handle) {
         final RandomAccessFile randomAccessFile = (RandomAccessFile) randomAccessFileMap.get(new Integer(handle));
         if (randomAccessFile == null) {
             throw new SWIError(0, "Invalid file handle");
         }
         return randomAccessFile;
     }
 
     static final int DEFAULT_RAM_LIMIT = 1024 * 1024;
     static final AppEnvironment DEFAULT_APP_ENVIRONMENT = new AppEnvironment("ROBE", DEFAULT_RAM_LIMIT, new Date());
     private RawDataBlock envStartTime = null;
     private RawDataBlock envCommandLine = null;
 
     public final void GetEnv(Environment env) {
         final int[] R = env.getCpu().R;
         final MemoryMap memoryMap = env.getMemoryMap();
 
         AppEnvironment appEnvironment = getEnv();
         if (envCommandLine == null) {
             envCommandLine = memoryMap.createSystemDataBlock(appEnvironment.getCommandLine().length() + 1);
         }
         ByteArrayUtils.putString0(envCommandLine.getBytes(), 0, appEnvironment.getCommandLine());
         R[0] = envCommandLine.getAddress();
 
         log.warning("We do not support getting RAM limit correctly, returning size of &" +
                 Integer.toHexString(appEnvironment.getRamLimit()));
         R[1] = appEnvironment.getRamLimit();
 
         if (envStartTime == null) {
             envStartTime = memoryMap.createSystemDataBlock(5);
         }
         ByteArrayUtils.put5ByteValue(envStartTime.getBytes(), 0, convertTo5ByteTime(appEnvironment.getStartTime()));
         R[2] = envStartTime.getAddress();
     }
 
     private final static long EPOCH_BASE = new GregorianCalendar(1900, 0, 1, 0, 0, 0).getTimeInMillis();
 
     public final static long convertTo5ByteTime(Date date) {
         long timeMillis = date.getTime(); // milliseconds since January 1, 1970, 00:00:00 GMT
         long timeCentis = (timeMillis - EPOCH_BASE) / 10; // centiseconds since January 1, 1900, 00:00:00 GMT
         return timeCentis & 0xffffffffffL;
     }
 
     public final static Date convertToDate(long fiveByteTime) {
         long timeMillis = (fiveByteTime * 10) + EPOCH_BASE;
         return new Date(timeMillis);
     }
 
     public final AppEnvironment getEnv() {
         return DEFAULT_APP_ENVIRONMENT;
     }
 
     public final void Exit(Environment env) {
         final int[] R = env.getCpu().R;
         if (R[1] == 0x58454241) { // "ABEX" magic number
             exit(R[2]);
         } else {
             exit(0);
         }
     }
 
     public final void exit(int rc) {
         final long executionTime = (System.currentTimeMillis() - OS.DEFAULT_APP_ENVIRONMENT.getStartTime().getTime());
         log.info("Executed " + Instruction.count + " instructions in " + executionTime + "ms");
         log.info(" = " + ((double) Instruction.count * 1000 / ((double) executionTime)) + "/s");
         System.exit(rc);
     }
 
     public final void IntOn(Environment env) {
         env.getCpu().setI();
     }
 
     public final void IntOff(Environment env) {
         env.getCpu().clearI();
     }
 
     public final void EnterOS(Environment env) {
         log.warning("OS.EnterOS ignored");
     }
 
     public final void Module(Environment env) {
         final int[] R = env.getCpu().R;
         switch (R[0]) {
             case 6: // Claim
                 R[2] = env.getMemoryMap().claimRmaBlock(R[3]).getAddress();
                 break;
             case 7: // Free
                 env.getMemoryMap().releaseRmaBlock(R[2]);
                 break;
             case 18: // Lookup module name
                 final String name = env.getMemoryMap().getString0(R[1]);
                 if (name.indexOf('%') > -1) {
                     log.warning("We do not handle modules with multiple instantiations correctly");
                 }
                 final Module module = ModuleUtils.getModule(name);
                 if (module != null) {
                     R[1] = ModuleUtils.getModuleNumber(module);
                     R[2] = 0;
                     R[3] = module.getAddress();
                     R[4] = 0x98765432; // Private word - use silly value so that we can spot if it's used later
                     R[5] = 0; // Postfix string
                 } else {
                     log.severe("Module not found: " + name);
                     throw new SWIError(0, "Module not found: " + name);
                 }
                 break;
             default:
                 throw new SWIError(0, "Unknown OS.Module " + R[0]);
         }
     }
 
     public final void ReadUnsigned(Environment env) {
         final int[] R = env.getCpu().R;
         int base = R[0] & 0xff;
         if (base < 2 || base > 36) {
             base = 10;
         }
         if ((R[0] & 0x80000000) != 0) {
             log.warning("we do not support restriction on terminator in OS.ReadUnsigned - ignoring");
         }
         final String s = env.getMemoryMap().getStringN(R[1], 34);
         final int result = readUnsigned(base, s);
         if (((R[0] & 0x40000000) != 0 && result > 255)
                 || ((R[0] & 0x2000000) != 0 && result > R[2])) {
             throw new SWIError(0, "Number out of range");
         }
         log.warning("Terminator character pointer is incorrect");
         R[2] = result;
     }
 
     /***
      * Convert a String to an integer.
      * If the String starts with &, base 16 is assumed. If the String starts with <var>base</var>_, this base
      * is used. If no base is given or the base is invalid, the base in defaultInputBase is used.
      * The terminating character in the string is the first character that is inconsistent with the base
      * being used.
      *
      * @param defaultInputBase base to use if none is specified in the string
      * @param input            String to convert
      * @return
      */
     public final int readUnsigned(int defaultInputBase, String input) {
         int base = defaultInputBase;
         int underscoreIndex = input.indexOf('_');
 
         if (input.startsWith("&")) {
             base = 16;
             input = input.substring(1);
         } else if (underscoreIndex > 0) {
             final String s = input.substring(0, underscoreIndex);
             try {
                 base = Integer.parseInt(s);
             } catch (NumberFormatException e) {
                 log.warning("Invalid base " + s + " in OS.readUnsigned");
             }
             input = input.substring(underscoreIndex + 1);
         }
 
         if (base < 2 || base > 36) {
             base = defaultInputBase;
         }
 
         // Find the end of the string
         for (int i = 0; i < input.length(); i++) {
             final char c = input.charAt(i);
             final int decimalDigit = c - '0';
             final int alphaDigit = Character.toUpperCase(c) - 'A' + 10;
             if ((decimalDigit < 0 || decimalDigit > 9) &&
                     (alphaDigit < 10 || alphaDigit >= base)) {
                 // This character is out of range
                 input = input.substring(0, i);
                 break;
             }
         }
         try {
             return (int) (Long.parseLong(input, base) & 0xffffffffL);
         } catch (NumberFormatException e) {
             throw new SWIError(0, e);
         }
     }
 
     /***
      * This SWI returns type and value of a variable.
      * To check if it exists or find its length, call with R2 &lt; 0. If the variable does not exist R2 will be 0.
      * Otherwise the length is given by NOT(R2), although for anything other than a string variable (type 0) this is the
      * unexpanded length. For either case an error will be returned.
      *
      * @param env IN: R0 = pointer to wildcarded name
      *            R1 = pointer to buffer
      *            R2 = length of buffer, or -ve to check existence/read length
      *            R3 = name pointer, or 0 for 1st call
      *            R4 = 3 to expand macros and numbers to strings.
      *            OUT: if R2 was -ve (read length)
      *            R0 corrupt (pointer to error)
      *            R2 = NOT (length), or 0 if variable does not exist.
      *            if R2 was +ve (read value)
      *            R0 preserved
      *            R2 = bytes read
      *            In both cases:
      *            R3 = new name pointer
      *            R4 = Variable type
      */
     public final void ReadVarVal(Environment env) {
         final int[] R = env.getCpu().R;
         final MemoryMap memoryMap = env.getMemoryMap();
         String value = readVarVal(memoryMap.getString0(R[0]));
         final int bufferLength = R[2];
         if (bufferLength < 0) {
             R[0] = 0;
             R[2] = value == null ? 0 : ~(value.length());
         } else {
             if (bufferLength == 0 || value == null) {
                 value = "";
             } else if (value.length() >= bufferLength) {
                 value = value.substring(0, bufferLength - 1);
             }
             memoryMap.storeString0(R[1], value);
             R[2] = value.length();
         }
         R[3] = 0; // todo: new name pointer not returned
         R[4] = 0; // todo: variable type always fixed
     }
 
     private final static Properties ENVIRONMENT_VARIABLES = new Properties();
 
     public final String readVarVal(String varName) {
         return ENVIRONMENT_VARIABLES.getProperty(varName);
     }
 
     /***
      * This SWI sets a variable's value to that specified, or deletes the variable. The name may be wildcarded for
      * deletion and update (using '*' and '#'). Code variables will not be deleted unless R4 = 16. Literal strings
      * do not need to be null terminated, as R2 is used for the length.
      *
      * @param env IN: R0 = pointer to name
      *            R1 = pointer to value to set to
      *            R2 = length, or -1 to delete
      *            R3 = name pointer (0 for 1st call)
      *            R4 = variable type (0 = string, 1 = integer, 2 = macro, 3 = expression, 4 = literal string, +16 code)
      *            OUT: R3 = new name pointer
      *            R4 = variable type
      */
     public final void SetVarVal(Environment env) {
         final int[] R = env.getCpu().R;
         final MemoryMap memoryMap = env.getMemoryMap();
         if (R[2] != -1) {
             setVarVal(memoryMap.getString0(R[0]), memoryMap.getStringN(R[1], R[2]), R[4]);
         } else {
             deleteVarVal(memoryMap.getString0(R[0]));
         }
     }
 
     public void setVarVal(String name, String value, int valueType) {
         if (valueType != 0 && valueType != 4) {
             log.warning("setVarVal always stores variables as strings <" + name + "> = \"" + value + "\"");
         }
         ENVIRONMENT_VARIABLES.setProperty(name, value);
     }
 
     public void deleteVarVal(String name) {
         log.warning("setVarVal(deleteVarVal) unimplemented, no value removed for <" + name + ">");
     }
 
     /***
      * This SWI is equivalent to a call to OS_GSInit, followed by repeated calls    
      * to OS_GSRead . It reads and translates a whole string.
      * <pre><![CDATA[
      * Translates a string as follows:
      * From  To
      * |"    "
      * |<    <
      * |!    forces top bit of next char to be set.
      * |char CTRL( ASCII(uppercase(char) - 64 )
      * "str" str
      * <num> CTRL(num)
      * <str> system variable str
      * ]]>
      * </pre>
      *
      * @param env
      */
     public final void GSTrans(Environment env) {
         final int[] R = env.getCpu().R;
         String in = env.getMemoryMap().getString0_10_13(R[0]);
         final boolean spaceTerminates = (R[2] & 0x20000000) != 0;
         final boolean convertControlCodes = (R[2] & 0x40000000) == 0;
         final boolean stripQuotes = (R[2] & 0x80000000) == 0;
         log.warning("convert control codes and strip quotes flags ignored");
         GSTranslator translator = new GSTranslator(in, spaceTerminates, this);
         String out = gsTrans(translator, new StringBuffer(in.length()));
         int bufferLength = R[2] & 0x1fffffff;
         if (out.length() > bufferLength - 1) {
             out = out.substring(0, bufferLength - 1);
             env.getCpu().setC();
         }
 
         R[0] += translator.getIndex() + 1;
         env.getMemoryMap().storeString0(R[1], out);
         R[2] = out.length();
     }
 
     public final String gsTrans(String in, boolean spaceTerminates, boolean convertControlCodes, boolean stripQuotes) {
         StringBuffer out = new StringBuffer(in.length());
         GSTranslator translator = new GSTranslator(in, spaceTerminates, this);
 
         return gsTrans(translator, out);
     }
 
     private String gsTrans(GSTranslator translator, StringBuffer out) {
         do {
             char c = translator.nextCharacter();
             if (c == CharacterIterator.DONE) {
                 break;
             } else {
                 out.append(c);
             }
         } while (true);
         return out.toString();
     }
 
     public final void FSControl(Environment env) {
         final int[] R = env.getCpu().R;
         final MemoryMap memoryMap = env.getMemoryMap();
         String pathname = memoryMap.getString0(R[1]);
         final String path;
         if (R[3] != 0) {
             path = readVarVal(memoryMap.getString0(R[3]));
         } else if (R[4] != 0) {
             path = memoryMap.getString0(R[4]);
         } else {
             path = null;
         }
         pathname = fsControl(R[0], pathname, path);
         final int bufferLength = R[5];
         if (pathname.length() > bufferLength) {
             pathname = pathname.substring(0, bufferLength);
         }
         memoryMap.storeString0(R[2], pathname);
         R[5] -= pathname.length();
     }
 
     public final String fsControl(int reasonCode, String pathname, String path) {
         if (path != null) {
             log.warning("Path ignored in OS.FSControl");
         }
         try {
             switch (reasonCode) {
                 case 37:
                     File f = new File(FilenameUtils.acornToNative(pathname));
                     return FilenameUtils.nativeToAcorn(f.getCanonicalPath());
                 default:
                     throw new SWIError(0, "Unknown OS.FSControl " + reasonCode);
             }
         } catch (IOException e) {
             throw new SWIError(0, e);
         }
     }
 
     public final void ChangeDynamicArea(final Environment env) {
         final int[] R = env.getCpu().R;
         if (R[0] < 256) {
             log.warning("We do not support changing non-user areas.");
         }
         final DynamicArea dynamicArea = env.getMemoryMap().findDynamicArea(R[0]);
         final int changeRequest = R[1];
         if (changeRequest > 0) {
             dynamicArea.extendForwards(changeRequest);
         } else {
             // Ignore shrinkage for now
             log.info("ChangeDynamicArea will never reduce memory usage!");
             R[1] = 0;
         }
     }
 
     public final void GenerateError(Environment env) {
         final int[] R = env.getCpu().R;
         throw new SWIError(env, R[0]);
     }
 
     public final void generateError(int errorNumber, String errorMessage) throws SWIError {
         throw new SWIError(errorNumber, errorMessage);
     }
 
     private static final SpriteArea SYSTEM_SPRITE_AREA = new SpriteArea(0x100000);
 
     public final void SpriteOp(Environment env) {
         final int[] R = env.getCpu().R;
         final SpriteArea spriteArea;
         final MemoryMap memoryMap = env.getMemoryMap();
         final String spriteName = memoryMap.getString0(R[2]);
         if ((R[0] & 0x300) != 0) {
             final DataBlock dataBlock = memoryMap.getDataBlock(R[1]);
             if (!(dataBlock instanceof SpriteArea)) {
                 spriteArea = new SpriteArea(dataBlock);
                 memoryMap.replaceDataBlock(dataBlock, spriteArea); // Turn this block into a sprite area.
             } else {
                 spriteArea = (SpriteArea) dataBlock;
             }
             if ((R[0] & 0x200) != 0) {
                 log.warning("we do not support sprite pointer arguments to OS.SpriteOp - ignoring");
                 return;
             }
         } else {
             spriteArea = SYSTEM_SPRITE_AREA;
         }
         SpriteOp(R, spriteArea, spriteName);
     }
 
     void SpriteOp(final int[] R, final SpriteArea spriteArea, final String spriteName) {
         final int operation = R[0] & 0xff;
         switch (operation) {
             case 40: // Read sprite info
                 final BufferedImage image = spriteOp40(spriteArea, spriteName);
                 R[3] = image.getWidth();
                 R[4] = image.getHeight();
                 log.warning("All sprites return as 24bpp with 90x90 dpi since we use TYPE_INT_ARGB native images");
                 R[5] = image.getColorModel().hasAlpha()? 1 : 0;
                 R[6] = (6 << 27) | 1 | (90 << 1) | (90 << 14); // 24bpp, 90dpi always
                 break;
             default:
                 spriteOp(operation, spriteArea, spriteName);
         }
     }
 
     public final BufferedImage spriteOp40(SpriteArea spriteArea, String spriteName) {
         return spriteArea.getSprite(spriteName).getImage();
     }
 
     public final void spriteOp(int operation, SpriteArea spriteArea, String spriteName) {
         switch (operation) {
             case 10: // Load sprites
                 // spriteName is the filename in this case
                 synchronized (spriteArea) {
                     spriteArea.load(new File(FilenameUtils.acornToNative(spriteName)));
                 }
                 break;
             case 11: // Merge sprites
                 // spriteName is the filename in this case
                 synchronized (spriteArea) {
                     spriteArea.merge(new File(FilenameUtils.acornToNative(spriteName)));
                 }
                 break;
             default:
                 spriteOp(operation, spriteArea, spriteArea.getSprite(spriteName));
         }
     }
 
     public final void spriteOp(int operation, SpriteArea spriteArea, Sprite sprite) {
         log.warning("spriteOp on Sprite unimplemented");
     }
 
     /***
      * Entry:
      * => R0 = pointer to input block
      * R1 = pointer to output block (can be same as R0)
      * The input block is a list of variable numbers (words) terminated by -1.
      * Each variable is read, and its value is written as a word into the output block.
      * Note: You can also read the mode variables with this call.
      *
      * @param env
      */
     public final void ReadVduVariables(Environment env) {
         final int[] R = env.getCpu().R;
         final MemoryMap memoryMap = env.getMemoryMap();
         for (int inAddress = R[0], outAddress = R[1]; ; inAddress += 4, outAddress += 4) {
             final int number = memoryMap.getWord(inAddress);
             if (number == -1) {
                 break;
             }
             final int value = readVduVariable(number);
             memoryMap.storeWord(outAddress, value);
         }
     }
 
     public final int readVduVariable(int number) {
         final DisplayMode displayMode = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDisplayMode();
         final int bitDepth = displayMode.getBitDepth();
         switch (number) {
             case 3:
                 if (bitDepth == 24) {
                     return -1;
                 } else {
                     return (1 << bitDepth) - 1;
                 }
             case 4: // XEigFactor (screenx = osx >> xeig) always returns 1 to make the mode work like VGA
                 return 1;
             case 5: // YEigFactor (screeny = osy >> xeig) always returns 1 to make the mode work like VGA
                 return 1;
             case 9: // Log2BPP
                 if (bitDepth == -1) {
                     return 5;
                 } else {
                     return log2(bitDepth);
                 }
             case 11: // XWindLimit (x pixels - 1)
                 return displayMode.getWidth() - 1;
             case 12: // YWindLimit (y pixels - 1)
                 return displayMode.getHeight() - 1;
             default:
                 log.warning("Cannot read VDU variable " + number);
                 return 0;
         }
     }
 
     public void ReadModeVariable(Environment env) {
         final int[] R = env.getCpu().R;
         if (R[0] != -1) {
             log.warning("Cannot read mode variable for a different mode: reading for current mode");
         }
 
         if (R[1] < 128) {
             R[2] = readVduVariable(R[1]);
         } else {
             log.info("Attempt to read mode variable " + R[1] + " - failed");
             env.getCpu().setC();
         }
     }
 
     private int log2(int v) {
         for (int log = 0, mask = 1; log < 32; log++, mask <<= 1) {
             if ((v & mask) != 0) { // If the bit is set
                 if ((v & ~(mask - 1)) == mask) { // If no higher bits are set
                     if ((v & ~mask) == mask) { // If no lower bits are set
                         return log;
                     } else {
                         return log + 1;
                     }
                 }
             }
         }
         throw new IllegalArgumentException("Could not resolve log2(" + v + ")");
     }
 
     public static void main(String[] args) throws UnknownSWIException {
         Logger log = Logger.getLogger(OS.class.getName());
         Environment environment = new Environment(0x8000, new byte[0]);
         final int[] R = environment.getCpu().R;
         Instruction swiCall;
 
         log.info("SWI OS_WriteC");
         R[0] = 65;
         log.fine("R[0] = " + R[0]);
         swiCall = new SWI(Condition.AL, 0x0);
         swiCall.checkAndExecute(environment);
 
         R[0] = 0;
         R[1] = 0;
         log.fine("R[0] = " + R[0]);
         log.fine("R[1] = " + R[1]);
         log.info("SWI XOS_Byte");
         swiCall = new SWI(Condition.AL, 0x800006);
         swiCall.checkAndExecute(environment);
         log.fine("=> R[0] = " + R[0]);
 
         R[0] = 0;
         R[1] = 1;
         log.fine("R[0] = " + R[0]);
         log.fine("R[1] = " + R[1]);
         log.info("SWI OS_Byte");
         swiCall.checkAndExecute(environment);
         log.fine("=> R[1] = " + R[1]);
     }
 }