using System;

using System.IO;

namespace SevenZip

{

using CommandLineParser;

public class CDoubleStream: Stream

{

public System.IO.Stream s1;

public System.IO.Stream s2;

public int fileIndex;

public long skipSize;

public override bool CanRead { get { return true; }}

public override bool CanWrite { get { return false; }}

public override bool CanSeek { get { return false; }}

public override long Length { get { return s1.Length + s2.Length - skipSize; } }

public override long Position

{

get { return 0; }

set { }

}

public override void Flush() { }

public override int Read(byte[] buffer, int offset, int count)

{

int numTotal = 0;

while (count > 0)

{

if (fileIndex == 0)

{

int num = s1.Read(buffer, offset, count);

offset += num;

count -= num;

numTotal += num;

if (num == 0)

fileIndex++;

}

if (fileIndex == 1)

{

numTotal += s2.Read(buffer, offset, count);

return numTotal;

}

}

return numTotal;

}

public override void Write(byte[] buffer, int offset, int count)

{

throw (new Exception("can't Write"));

}

public override long Seek(long offset, System.IO.SeekOrigin origin)

{

throw (new Exception("can't Seek"));

}

public override void SetLength(long value)

{

throw (new Exception("can't SetLength"));

}

}

class LzmaAlone

{

enum Key

{

Help1 = 0,

Help2,

Mode,

Dictionary,

FastBytes,

LitContext,

LitPos,

PosBits,

MatchFinder,

EOS,

StdIn,

StdOut,

Train

};

static void PrintHelp()

{

System.Console.WriteLine("\nUsage: LZMA <e|d> [<switches>...] inputFile outputFile\n" +

" e: encode file\n" +

" d: decode file\n" +

" b: Benchmark\n" +

"<Switches>\n" +

// " -a{N}: set compression mode - [0, 1], default: 1 (max)\n" +

" -d{N}: set dictionary - [0, 29], default: 23 (8MB)\n" +

" -fb{N}: set number of fast bytes - [5, 273], default: 128\n" +

" -lc{N}: set number of literal context bits - [0, 8], default: 3\n" +

" -lp{N}: set number of literal pos bits - [0, 4], default: 0\n" +

" -pb{N}: set number of pos bits - [0, 4], default: 2\n" +

" -mf{MF_ID}: set Match Finder: [bt2, bt4], default: bt4\n" +

" -eos: write End Of Stream marker\n"

// + " -si: read data from stdin\n"

// + " -so: write data to stdout\n"

);

}

static bool GetNumber(string s, out Int32 v)

{

v = 0;

for (int i = 0; i < s.Length; i++)

{

char c = s[i];

if (c < '0' || c > '9')

return false;

v *= 10;

v += (Int32)(c - '0');

}

return true;

}

static int IncorrectCommand()

{

throw (new Exception("Command line error"));

// System.Console.WriteLine("\nCommand line error\n");

// return 1;

}

static int Main2(string[] args)

{

System.Console.WriteLine("\nLZMA# 4.49 Copyright (c) 1999-2007 Igor Pavlov 2006-07-05\n");

if (args.Length == 0)

{

PrintHelp();

return 0;

}

SwitchForm[] kSwitchForms = new SwitchForm[13];

int sw = 0;

kSwitchForms[sw++] = new SwitchForm("?", SwitchType.Simple, false);

kSwitchForms[sw++] = new SwitchForm("H", SwitchType.Simple, false);

kSwitchForms[sw++] = new SwitchForm("A", SwitchType.UnLimitedPostString, false, 1);

kSwitchForms[sw++] = new SwitchForm("D", SwitchType.UnLimitedPostString, false, 1);

kSwitchForms[sw++] = new SwitchForm("FB", SwitchType.UnLimitedPostString, false, 1);

kSwitchForms[sw++] = new SwitchForm("LC", SwitchType.UnLimitedPostString, false, 1);

kSwitchForms[sw++] = new SwitchForm("LP", SwitchType.UnLimitedPostString, false, 1);

kSwitchForms[sw++] = new SwitchForm("PB", SwitchType.UnLimitedPostString, false, 1);

kSwitchForms[sw++] = new SwitchForm("MF", SwitchType.UnLimitedPostString, false, 1);

kSwitchForms[sw++] = new SwitchForm("EOS", SwitchType.Simple, false);

kSwitchForms[sw++] = new SwitchForm("SI", SwitchType.Simple, false);

kSwitchForms[sw++] = new SwitchForm("SO", SwitchType.Simple, false);

kSwitchForms[sw++] = new SwitchForm("T", SwitchType.UnLimitedPostString, false, 1);

Parser parser = new Parser(sw);

try

{

parser.ParseStrings(kSwitchForms, args);

}

catch

{

return IncorrectCommand();

}

if (parser[(int)Key.Help1].ThereIs || parser[(int)Key.Help2].ThereIs)

{

PrintHelp();

return 0;

}

System.Collections.ArrayList nonSwitchStrings = parser.NonSwitchStrings;

int paramIndex = 0;

if (paramIndex >= nonSwitchStrings.Count)

return IncorrectCommand();

string command = (string)nonSwitchStrings[paramIndex++];

command = command.ToLower();

bool dictionaryIsDefined = false;

Int32 dictionary = 1 << 21;

if (parser[(int)Key.Dictionary].ThereIs)

{

Int32 dicLog;

if (!GetNumber((string)parser[(int)Key.Dictionary].PostStrings[0], out dicLog))

IncorrectCommand();

dictionary = (Int32)1 << dicLog;

dictionaryIsDefined = true;

}

string mf = "bt4";

if (parser[(int)Key.MatchFinder].ThereIs)

mf = (string)parser[(int)Key.MatchFinder].PostStrings[0];

mf = mf.ToLower();

if (command == "b")

{

const Int32 kNumDefaultItereations = 10;

Int32 numIterations = kNumDefaultItereations;

if (paramIndex < nonSwitchStrings.Count)

if (!GetNumber((string)nonSwitchStrings[paramIndex++], out numIterations))

numIterations = kNumDefaultItereations;

return LzmaBench.LzmaBenchmark(numIterations, (UInt32)dictionary);

}

string train = "";

if (parser[(int)Key.Train].ThereIs)

train = (string)parser[(int)Key.Train].PostStrings[0];

bool encodeMode = false;

if (command == "e")

encodeMode = true;

else if (command == "d")

encodeMode = false;

else

IncorrectCommand();

bool stdInMode = parser[(int)Key.StdIn].ThereIs;

bool stdOutMode = parser[(int)Key.StdOut].ThereIs;

Stream inStream = null;

if (stdInMode)

{

throw (new Exception("Not implemeted"));

}

else

{

if (paramIndex >= nonSwitchStrings.Count)

IncorrectCommand();

string inputName = (string)nonSwitchStrings[paramIndex++];

inStream = new FileStream(inputName, FileMode.Open, FileAccess.Read);

}

FileStream outStream = null;

if (stdOutMode)

{

throw (new Exception("Not implemeted"));

}

else

{

if (paramIndex >= nonSwitchStrings.Count)

IncorrectCommand();

string outputName = (string)nonSwitchStrings[paramIndex++];

outStream = new FileStream(outputName, FileMode.Create, FileAccess.Write);

}

FileStream trainStream = null;

if (train.Length != 0)

trainStream = new FileStream(train, FileMode.Open, FileAccess.Read);

if (encodeMode)

{

if (!dictionaryIsDefined)

dictionary = 1 << 23;

Int32 posStateBits = 2;

Int32 litContextBits = 3; // for normal files

// UInt32 litContextBits = 0; // for 32-bit data

Int32 litPosBits = 0;

// UInt32 litPosBits = 2; // for 32-bit data

Int32 algorithm = 2;

Int32 numFastBytes = 128;

bool eos = parser[(int)Key.EOS].ThereIs || stdInMode;

if (parser[(int)Key.Mode].ThereIs)

if (!GetNumber((string)parser[(int)Key.Mode].PostStrings[0], out algorithm))

IncorrectCommand();

if (parser[(int)Key.FastBytes].ThereIs)

if (!GetNumber((string)parser[(int)Key.FastBytes].PostStrings[0], out numFastBytes))

IncorrectCommand();

if (parser[(int)Key.LitContext].ThereIs)

if (!GetNumber((string)parser[(int)Key.LitContext].PostStrings[0], out litContextBits))

IncorrectCommand();

if (parser[(int)Key.LitPos].ThereIs)

if (!GetNumber((string)parser[(int)Key.LitPos].PostStrings[0], out litPosBits))

IncorrectCommand();

if (parser[(int)Key.PosBits].ThereIs)

if (!GetNumber((string)parser[(int)Key.PosBits].PostStrings[0], out posStateBits))

IncorrectCommand();

CoderPropID[] propIDs =

{

CoderPropID.DictionarySize,

CoderPropID.PosStateBits,

CoderPropID.LitContextBits,

CoderPropID.LitPosBits,

CoderPropID.Algorithm,

CoderPropID.NumFastBytes,

CoderPropID.MatchFinder,

CoderPropID.EndMarker

};

object[] properties =

{

(Int32)(dictionary),

(Int32)(posStateBits),

(Int32)(litContextBits),

(Int32)(litPosBits),

(Int32)(algorithm),

(Int32)(numFastBytes),

mf,

eos

};

Compression.LZMA.Encoder encoder = new Compression.LZMA.Encoder();

encoder.SetCoderProperties(propIDs, properties);

encoder.WriteCoderProperties(outStream);

Int64 fileSize;

if (eos || stdInMode)

fileSize = -1;

else

fileSize = inStream.Length;

for (int i = 0; i < 8; i++)

outStream.WriteByte((Byte)(fileSize >> (8 * i)));

if (trainStream != null)

{

CDoubleStream doubleStream = new CDoubleStream();

doubleStream.s1 = trainStream;

doubleStream.s2 = inStream;

doubleStream.fileIndex = 0;

inStream = doubleStream;

long trainFileSize = trainStream.Length;

doubleStream.skipSize = 0;

if (trainFileSize > dictionary)

doubleStream.skipSize = trainFileSize - dictionary;

trainStream.Seek(doubleStream.skipSize, SeekOrigin.Begin);

encoder.SetTrainSize((uint)(trainFileSize - doubleStream.skipSize));

}

encoder.Code(inStream, outStream, -1, -1, null);

}

else if (command == "d")

{

byte[] properties = new byte[5];

if (inStream.Read(properties, 0, 5) != 5)

throw (new Exception("input .lzma is too short"));

Compression.LZMA.Decoder decoder = new Compression.LZMA.Decoder();

decoder.SetDecoderProperties(properties);

if (trainStream != null)

{

if (!decoder.Train(trainStream))

throw (new Exception("can't train"));

}

long outSize = 0;

for (int i = 0; i < 8; i++)

{

int v = inStream.ReadByte();

if (v < 0)

throw (new Exception("Can't Read 1"));

outSize |= ((long)(byte)v) << (8 * i);

}

long compressedSize = inStream.Length - inStream.Position;

decoder.Code(inStream, outStream, compressedSize, outSize, null);

}

else

throw (new Exception("Command Error"));

return 0;

}

[STAThread]

static int Main(string[] args)

{

try

{

return Main2(args);

}

catch (Exception e)

{

Console.WriteLine("{0} Caught exception #1.", e);

// throw e;

return 1;

}

}

}

}