home *** CD-ROM | disk | FTP | other *** search
/ Total Destruction / Total_Destruction.iso / util / q2source.exe / utils3 / Unpack / Unpack.class (.txt) next >
Encoding:
Java Class File  |  1997-12-11  |  3.9 KB  |  129 lines
  1. import java.io.DataInputStream;
  2. import java.io.DataOutputStream;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.FilterInputStream;
  7. import java.io.FilterOutputStream;
  8. import java.io.IOException;
  9. import java.io.RandomAccessFile;
  10.  
  11. class Unpack {
  12.    static final int IDPAKHEADER = 1262698832;
  13.  
  14.    static void usage() {
  15.       System.out.println("Usage: unpack <packfile> <match> <basedir>");
  16.       System.out.println("   or: unpack -list <packfile>");
  17.       System.out.println("<match> may contain a single * wildcard");
  18.       System.exit(1);
  19.    }
  20.  
  21.    static int intSwap(int i) {
  22.       int a = i & 255;
  23.       int b = i >> 8 & 255;
  24.       int c = i >> 16 & 255;
  25.       int d = i >> 24 & 255;
  26.       return (a << 24) + (b << 16) + (c << 8) + d;
  27.    }
  28.  
  29.    static boolean patternMatch(String pattern, String s) {
  30.       if (pattern.equals(s)) {
  31.          return true;
  32.       } else {
  33.          int index = pattern.indexOf(42);
  34.          if (index == -1) {
  35.             return false;
  36.          } else if (!pattern.regionMatches(0, s, 0, index)) {
  37.             return false;
  38.          } else {
  39.             ++index;
  40.             int remaining = pattern.length() - index;
  41.             if (s.length() < remaining) {
  42.                return false;
  43.             } else {
  44.                return pattern.regionMatches(index, s, s.length() - remaining, remaining);
  45.             }
  46.          }
  47.       }
  48.    }
  49.  
  50.    public static void main(String[] args) {
  51.       byte[] name = new byte[56];
  52.       String pakName;
  53.       String pattern;
  54.       if (args.length == 2) {
  55.          if (!args[0].equals("-list")) {
  56.             usage();
  57.          }
  58.  
  59.          pakName = args[1];
  60.          pattern = null;
  61.       } else if (args.length == 3) {
  62.          pakName = args[0];
  63.          pattern = args[1];
  64.       } else {
  65.          pakName = null;
  66.          pattern = null;
  67.          usage();
  68.       }
  69.  
  70.       try {
  71.          DataInputStream directory = new DataInputStream(new FileInputStream(pakName));
  72.          RandomAccessFile readLump = new RandomAccessFile(pakName, "r");
  73.          int ident = intSwap(directory.readInt());
  74.          int dirofs = intSwap(directory.readInt());
  75.          int dirlen = intSwap(directory.readInt());
  76.          if (ident != 1262698832) {
  77.             System.out.println(pakName + " is not a pakfile.");
  78.             System.exit(1);
  79.          }
  80.  
  81.          directory.skipBytes(dirofs - 12);
  82.          int numLumps = dirlen / 64;
  83.          System.out.println(numLumps + " lumps in " + pakName);
  84.  
  85.          for(int i = 0; i < numLumps; ++i) {
  86.             directory.readFully(name);
  87.             int filepos = intSwap(directory.readInt());
  88.             int filelen = intSwap(directory.readInt());
  89.             String nameString = new String(name, 0);
  90.             nameString = nameString.substring(0, nameString.indexOf(0));
  91.             if (pattern == null) {
  92.                System.out.println(nameString + " : " + filelen + "bytes");
  93.             } else if (patternMatch(pattern, nameString)) {
  94.                byte[] buffer = new byte[filelen];
  95.                System.out.println("Unpaking " + nameString + " " + filelen + " bytes");
  96.                readLump.seek((long)filepos);
  97.                readLump.readFully(buffer);
  98.                StringBuffer fixedString = new StringBuffer(args[2] + File.separator + nameString);
  99.  
  100.                for(int index = 0; index < fixedString.length(); ++index) {
  101.                   if (fixedString.charAt(index) == '/') {
  102.                      fixedString.setCharAt(index, File.separatorChar);
  103.                   }
  104.                }
  105.  
  106.                String finalName = fixedString.toString();
  107.                int var25 = finalName.lastIndexOf(File.separatorChar);
  108.                if (var25 != -1) {
  109.                   String finalPath = finalName.substring(0, var25);
  110.                   File writePath = new File(finalPath);
  111.                   writePath.mkdirs();
  112.                }
  113.  
  114.                File writeFile = new File(finalName);
  115.                DataOutputStream writeLump = new DataOutputStream(new FileOutputStream(writeFile));
  116.                ((FilterOutputStream)writeLump).write(buffer);
  117.                ((FilterOutputStream)writeLump).close();
  118.             }
  119.          }
  120.  
  121.          readLump.close();
  122.          ((FilterInputStream)directory).close();
  123.       } catch (IOException var23) {
  124.          System.out.println(((Throwable)var23).toString());
  125.       }
  126.  
  127.    }
  128. }
  129.