corrade-vassal – Rev 1
?pathlinks?
//
// In order to convert some functionality to Visual C#, the Java Language Conversion Assistant
// creates "support classes" that duplicate the original functionality.
//
// Support classes replicate the functionality of the original code, but in some cases they are
// substantially different architecturally. Although every effort is made to preserve the
// original architecture of the application in the converted project, the user should be aware that
// the primary goal of these support classes is to replicate functionality, and that at times
// the architecture of the resulting solution may differ somewhat.
//
using System;
/// <summary>
/// This interface should be implemented by any class whose instances are intended
/// to be executed by a thread.
/// </summary>
public interface IThreadRunnable
{
/// <summary>
/// This method has to be implemented in order that starting of the thread causes the object's
/// run method to be called in that separately executing thread.
/// </summary>
void Run();
}
/// <summary>
/// Contains conversion support elements such as classes, interfaces and static methods.
/// </summary>
internal class SupportClass
{
/// <summary>
/// Converts an array of sbytes to an array of bytes
/// </summary>
/// <param name="sbyteArray">The array of sbytes to be converted</param>
/// <returns>The new array of bytes</returns>
public static byte[] ToByteArray(sbyte[] sbyteArray)
{
byte[] byteArray = null;
if (sbyteArray != null)
{
byteArray = new byte[sbyteArray.Length];
for(int index=0; index < sbyteArray.Length; index++)
byteArray[index] = (byte) sbyteArray[index];
}
return byteArray;
}
/// <summary>
/// Converts a string to an array of bytes
/// </summary>
/// <param name="sourceString">The string to be converted</param>
/// <returns>The new array of bytes</returns>
public static byte[] ToByteArray(System.String sourceString)
{
return System.Text.UTF8Encoding.UTF8.GetBytes(sourceString);
}
/// <summary>
/// Converts a array of object-type instances to a byte-type array.
/// </summary>
/// <param name="tempObjectArray">Array to convert.</param>
/// <returns>An array of byte type elements.</returns>
public static byte[] ToByteArray(System.Object[] tempObjectArray)
{
byte[] byteArray = null;
if (tempObjectArray != null)
{
byteArray = new byte[tempObjectArray.Length];
for (int index = 0; index < tempObjectArray.Length; index++)
byteArray[index] = (byte)tempObjectArray[index];
}
return byteArray;
}
/*******************************/
/// <summary>
/// Writes the exception stack trace to the received stream
/// </summary>
/// <param name="throwable">Exception to obtain information from</param>
/// <param name="stream">Output sream used to write to</param>
public static void WriteStackTrace(System.Exception throwable, System.IO.TextWriter stream)
{
stream.Write(throwable.StackTrace);
stream.Flush();
}
/*******************************/
/// <summary>
/// Receives a byte array and returns it transformed in an sbyte array
/// </summary>
/// <param name="byteArray">Byte array to process</param>
/// <returns>The transformed array</returns>
public static sbyte[] ToSByteArray(byte[] byteArray)
{
sbyte[] sbyteArray = null;
if (byteArray != null)
{
sbyteArray = new sbyte[byteArray.Length];
for(int index=0; index < byteArray.Length; index++)
sbyteArray[index] = (sbyte) byteArray[index];
}
return sbyteArray;
}
/*******************************/
/// <summary>
/// Converts an array of sbytes to an array of chars
/// </summary>
/// <param name="sByteArray">The array of sbytes to convert</param>
/// <returns>The new array of chars</returns>
public static char[] ToCharArray(sbyte[] sByteArray)
{
return System.Text.UTF8Encoding.UTF8.GetChars(ToByteArray(sByteArray));
}
/// <summary>
/// Converts an array of bytes to an array of chars
/// </summary>
/// <param name="byteArray">The array of bytes to convert</param>
/// <returns>The new array of chars</returns>
public static char[] ToCharArray(byte[] byteArray)
{
return System.Text.UTF8Encoding.UTF8.GetChars(byteArray);
}
/*******************************/
/// <summary>
/// This method returns the literal value received
/// </summary>
/// <param name="literal">The literal to return</param>
/// <returns>The received value</returns>
public static long Identity(long literal)
{
return literal;
}
/// <summary>
/// This method returns the literal value received
/// </summary>
/// <param name="literal">The literal to return</param>
/// <returns>The received value</returns>
public static ulong Identity(ulong literal)
{
return literal;
}
/// <summary>
/// This method returns the literal value received
/// </summary>
/// <param name="literal">The literal to return</param>
/// <returns>The received value</returns>
public static float Identity(float literal)
{
return literal;
}
/// <summary>
/// This method returns the literal value received
/// </summary>
/// <param name="literal">The literal to return</param>
/// <returns>The received value</returns>
public static double Identity(double literal)
{
return literal;
}
/*******************************/
/// <summary>
/// Provides support functions to create read-write random acces files and write functions
/// </summary>
public class RandomAccessFileSupport
{
/// <summary>
/// Creates a new random acces stream with read-write or read rights
/// </summary>
/// <param name="fileName">A relative or absolute path for the file to open</param>
/// <param name="mode">Mode to open the file in</param>
/// <returns>The new System.IO.FileStream</returns>
public static System.IO.FileStream CreateRandomAccessFile(System.String fileName, System.String mode)
{
System.IO.FileStream newFile = null;
if (mode.CompareTo("rw") == 0)
// newFile = new System.IO.FileStream(fileName, System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite);
//else if (mode.CompareTo("rw+") == 0)
newFile = new System.IO.FileStream(fileName, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.ReadWrite);
else if (mode.CompareTo("r") == 0)
newFile = new System.IO.FileStream(fileName, System.IO.FileMode.Open, System.IO.FileAccess.Read);
else
throw new System.ArgumentException();
return newFile;
}
/// <summary>
/// Creates a new random acces stream with read-write or read rights
/// </summary>
/// <param name="fileName">File infomation for the file to open</param>
/// <param name="mode">Mode to open the file in</param>
/// <returns>The new System.IO.FileStream</returns>
public static System.IO.FileStream CreateRandomAccessFile(System.IO.FileInfo fileName, System.String mode)
{
return CreateRandomAccessFile(fileName.FullName, mode);
}
/// <summary>
/// Writes the data to the specified file stream
/// </summary>
/// <param name="data">Data to write</param>
/// <param name="fileStream">File to write to</param>
public static void WriteBytes(System.String data,System.IO.FileStream fileStream)
{
int index = 0;
int length = data.Length;
while(index < length)
fileStream.WriteByte((byte)data[index++]);
}
/// <summary>
/// Writes the received string to the file stream
/// </summary>
/// <param name="data">String of information to write</param>
/// <param name="fileStream">File to write to</param>
public static void WriteChars(System.String data,System.IO.FileStream fileStream)
{
WriteBytes(data, fileStream);
}
/// <summary>
/// Writes the received data to the file stream
/// </summary>
/// <param name="sByteArray">Data to write</param>
/// <param name="fileStream">File to write to</param>
public static void WriteRandomFile(sbyte[] sByteArray,System.IO.FileStream fileStream)
{
byte[] byteArray = ToByteArray(sByteArray);
fileStream.Write(byteArray, 0, byteArray.Length);
}
}
/*******************************/
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static int URShift(int number, int bits)
{
if ( number >= 0)
return number >> bits;
else
return (number >> bits) + (2 << ~bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static int URShift(int number, long bits)
{
return URShift(number, (int)bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static long URShift(long number, int bits)
{
if (number >= 0)
return number >> bits;
else
return (number >> bits) + (2L << ~bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static long URShift(long number, long bits)
{
return URShift(number, (int)bits);
}
/*******************************/
/// <summary>Reads a number of characters from the current source Stream and writes the data to the target array at the specified index.</summary>
/// <param name="sourceStream">The source Stream to read from.</param>
/// <param name="target">Contains the array of characteres read from the source Stream.</param>
/// <param name="start">The starting index of the target array.</param>
/// <param name="count">The maximum number of characters to read from the source Stream.</param>
/// <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source Stream. Returns -1 if the end of the stream is reached.</returns>
public static System.Int32 ReadInput(System.IO.Stream sourceStream, sbyte[] target, int start, int count)
{
// Returns 0 bytes if not enough space in target
if (target.Length == 0)
return 0;
byte[] receiver = new byte[target.Length];
int bytesRead = sourceStream.Read(receiver, start, count);
// Returns -1 if EOF
if (bytesRead == 0)
return -1;
for(int i = start; i < start + bytesRead; i++)
target[i] = (sbyte)receiver[i];
return bytesRead;
}
/// <summary>Reads a number of characters from the current source TextReader and writes the data to the target array at the specified index.</summary>
/// <param name="sourceTextReader">The source TextReader to read from</param>
/// <param name="target">Contains the array of characteres read from the source TextReader.</param>
/// <param name="start">The starting index of the target array.</param>
/// <param name="count">The maximum number of characters to read from the source TextReader.</param>
/// <returns>The number of characters read. The number will be less than or equal to count depending on the data available in the source TextReader. Returns -1 if the end of the stream is reached.</returns>
public static System.Int32 ReadInput(System.IO.TextReader sourceTextReader, sbyte[] target, int start, int count)
{
// Returns 0 bytes if not enough space in target
if (target.Length == 0) return 0;
char[] charArray = new char[target.Length];
int bytesRead = sourceTextReader.Read(charArray, start, count);
// Returns -1 if EOF
if (bytesRead == 0) return -1;
for(int index=start; index<start+bytesRead; index++)
target[index] = (sbyte)charArray[index];
return bytesRead;
}
/*******************************/
/// <summary>
/// The class performs token processing in strings
/// </summary>
public class Tokenizer: System.Collections.IEnumerator
{
/// Position over the string
private long currentPos = 0;
/// Include demiliters in the results.
private bool includeDelims = false;
/// Char representation of the String to tokenize.
private char[] chars = null;
//The tokenizer uses the default delimiter set: the space character, the tab character, the newline character, and the carriage-return character and the form-feed character
private string delimiters = " \t\n\r\f";
/// <summary>
/// Initializes a new class instance with a specified string to process
/// </summary>
/// <param name="source">String to tokenize</param>
public Tokenizer(System.String source)
{
this.chars = source.ToCharArray();
}
/// <summary>
/// Initializes a new class instance with a specified string to process
/// and the specified token delimiters to use
/// </summary>
/// <param name="source">String to tokenize</param>
/// <param name="delimiters">String containing the delimiters</param>
public Tokenizer(System.String source, System.String delimiters):this(source)
{
this.delimiters = delimiters;
}
/// <summary>
/// Initializes a new class instance with a specified string to process, the specified token
/// delimiters to use, and whether the delimiters must be included in the results.
/// </summary>
/// <param name="source">String to tokenize</param>
/// <param name="delimiters">String containing the delimiters</param>
/// <param name="includeDelims">Determines if delimiters are included in the results.</param>
public Tokenizer(System.String source, System.String delimiters, bool includeDelims):this(source,delimiters)
{
this.includeDelims = includeDelims;
}
/// <summary>
/// Returns the next token from the token list
/// </summary>
/// <returns>The string value of the token</returns>
public System.String NextToken()
{
return NextToken(this.delimiters);
}
/// <summary>
/// Returns the next token from the source string, using the provided
/// token delimiters
/// </summary>
/// <param name="delimiters">String containing the delimiters to use</param>
/// <returns>The string value of the token</returns>
public System.String NextToken(System.String delimiters)
{
//According to documentation, the usage of the received delimiters should be temporary (only for this call).
//However, it seems it is not true, so the following line is necessary.
this.delimiters = delimiters;
//at the end
if (this.currentPos == this.chars.Length)
throw new System.ArgumentOutOfRangeException();
//if over a delimiter and delimiters must be returned
else if ( (System.Array.IndexOf(delimiters.ToCharArray(),chars[this.currentPos]) != -1)
&& this.includeDelims )
return "" + this.chars[this.currentPos++];
//need to get the token wo delimiters.
else
return nextToken(delimiters.ToCharArray());
}
//Returns the nextToken wo delimiters
private System.String nextToken(char[] delimiters)
{
string token="";
long pos = this.currentPos;
//skip possible delimiters
while (System.Array.IndexOf(delimiters,this.chars[currentPos]) != -1)
//The last one is a delimiter (i.e there is no more tokens)
if (++this.currentPos == this.chars.Length)
{
this.currentPos = pos;
throw new System.ArgumentOutOfRangeException();
}
//getting the token
while (System.Array.IndexOf(delimiters,this.chars[this.currentPos]) == -1)
{
token+=this.chars[this.currentPos];
//the last one is not a delimiter
if (++this.currentPos == this.chars.Length)
break;
}
return token;
}
/// <summary>
/// Determines if there are more tokens to return from the source string
/// </summary>
/// <returns>True or false, depending if there are more tokens</returns>
public bool HasMoreTokens()
{
//keeping the current pos
long pos = this.currentPos;
try
{
this.NextToken();
}
catch (System.ArgumentOutOfRangeException)
{
return false;
}
finally
{
this.currentPos = pos;
}
return true;
}
/// <summary>
/// Remaining tokens count
/// </summary>
public int Count
{
get
{
//keeping the current pos
long pos = this.currentPos;
int i = 0;
try
{
while (true)
{
this.NextToken();
i++;
}
}
catch (System.ArgumentOutOfRangeException)
{
this.currentPos = pos;
return i;
}
}
}
/// <summary>
/// Performs the same action as NextToken.
/// </summary>
public System.Object Current
{
get
{
return (Object) this.NextToken();
}
}
/// <summary>
// Performs the same action as HasMoreTokens.
/// </summary>
/// <returns>True or false, depending if there are more tokens</returns>
public bool MoveNext()
{
return this.HasMoreTokens();
}
/// <summary>
/// Does nothing.
/// </summary>
public void Reset()
{
;
}
}
/*******************************/
/// <summary>
/// This class provides auxiliar functionality to read and unread characters from a string into a buffer.
/// </summary>
private class BackStringReader : System.IO.StringReader
{
private char[] buffer;
private int position = 1;
/// <summary>
/// Constructor. Calls the base constructor.
/// </summary>
/// <param name="stringReader">The buffer from which chars will be read.</param>
/// <param name="size">The size of the Back buffer.</param>
public BackStringReader(String s) : base (s)
{
this.buffer = new char[position];
}
/// <summary>
/// Reads a character.
/// </summary>
/// <returns>The character read.</returns>
public override int Read()
{
if (this.position >= 0 && this.position < this.buffer.Length)
return (int) this.buffer[this.position++];
return base.Read();
}
/// <summary>
/// Reads an amount of characters from the buffer and copies the values to the array passed.
/// </summary>
/// <param name="array">Array where the characters will be stored.</param>
/// <param name="index">The beginning index to read.</param>
/// <param name="count">The number of characters to read.</param>
/// <returns>The number of characters read.</returns>
public override int Read(char[] array, int index, int count)
{
int readLimit = this.buffer.Length - this.position;
if (count <= 0)
return 0;
if (readLimit > 0)
{
if (count < readLimit)
readLimit = count;
System.Array.Copy(this.buffer, this.position, array, index, readLimit);
count -= readLimit;
index += readLimit;
this.position += readLimit;
}
if (count > 0)
{
count = base.Read(array, index, count);
if (count == -1)
{
if (readLimit == 0)
return -1;
return readLimit;
}
return readLimit + count;
}
return readLimit;
}
/// <summary>
/// Unreads a character.
/// </summary>
/// <param name="unReadChar">The character to be unread.</param>
public void UnRead(int unReadChar)
{
this.position--;
this.buffer[this.position] = (char) unReadChar;
}
/// <summary>
/// Unreads an amount of characters by moving these to the buffer.
/// </summary>
/// <param name="array">The character array to be unread.</param>
/// <param name="index">The beginning index to unread.</param>
/// <param name="count">The number of characters to unread.</param>
public void UnRead(char[] array, int index, int count)
{
this.Move(array, index, count);
}
/// <summary>
/// Unreads an amount of characters by moving these to the buffer.
/// </summary>
/// <param name="array">The character array to be unread.</param>
public void UnRead(char[] array)
{
this.Move(array, 0, array.Length - 1);
}
/// <summary>
/// Moves the array of characters to the buffer.
/// </summary>
/// <param name="array">Array of characters to move.</param>
/// <param name="index">Offset of the beginning.</param>
/// <param name="count">Amount of characters to move.</param>
private void Move(char[] array, int index, int count)
{
for (int arrayPosition = index + count; arrayPosition >= index; arrayPosition--)
this.UnRead(array[arrayPosition]);
}
}
/*******************************/
/// <summary>
/// The StreamTokenizerSupport class takes an input stream and parses it into "tokens".
/// The stream tokenizer can recognize identifiers, numbers, quoted strings, and various comment styles.
/// </summary>
public class StreamTokenizerSupport
{
/// <summary>
/// Internal constants and fields
/// </summary>
private const System.String TOKEN = "Token[";
private const System.String NOTHING = "NOTHING";
private const System.String NUMBER = "number=";
private const System.String EOF = "EOF";
private const System.String EOL = "EOL";
private const System.String QUOTED = "quoted string=";
private const System.String LINE = "], Line ";
private const System.String DASH = "-.";
private const System.String DOT = ".";
private const int TT_NOTHING = - 4;
private const sbyte ORDINARYCHAR = 0x00;
private const sbyte WORDCHAR = 0x01;
private const sbyte WHITESPACECHAR = 0x02;
private const sbyte COMMENTCHAR = 0x04;
private const sbyte QUOTECHAR = 0x08;
private const sbyte NUMBERCHAR = 0x10;
private const int STATE_NEUTRAL = 0;
private const int STATE_WORD = 1;
private const int STATE_NUMBER1 = 2;
private const int STATE_NUMBER2 = 3;
private const int STATE_NUMBER3 = 4;
private const int STATE_NUMBER4 = 5;
private const int STATE_STRING = 6;
private const int STATE_LINECOMMENT = 7;
private const int STATE_DONE_ON_EOL = 8;
private const int STATE_PROCEED_ON_EOL = 9;
private const int STATE_POSSIBLEC_COMMENT = 10;
private const int STATE_POSSIBLEC_COMMENT_END = 11;
private const int STATE_C_COMMENT = 12;
private const int STATE_STRING_ESCAPE_SEQ = 13;
private const int STATE_STRING_ESCAPE_SEQ_OCTAL = 14;
private const int STATE_DONE = 100;
private sbyte[] attribute = new sbyte[256];
private bool eolIsSignificant = false;
private bool slashStarComments = false;
private bool slashSlashComments = false;
private bool lowerCaseMode = false;
private bool pushedback = false;
private int lineno = 1;
private BackReader inReader;
private BackStringReader inStringReader;
private BackInputStream inStream;
private System.Text.StringBuilder buf;
/// <summary>
/// Indicates that the end of the stream has been read.
/// </summary>
public const int TT_EOF = - 1;
/// <summary>
/// Indicates that the end of the line has been read.
/// </summary>
public const int TT_EOL = '\n';
/// <summary>
/// Indicates that a number token has been read.
/// </summary>
public const int TT_NUMBER = - 2;
/// <summary>
/// Indicates that a word token has been read.
/// </summary>
public const int TT_WORD = - 3;
/// <summary>
/// If the current token is a number, this field contains the value of that number.
/// </summary>
public double nval;
/// <summary>
/// If the current token is a word token, this field contains a string giving the characters of the word
/// token.
/// </summary>
public System.String sval;
/// <summary>
/// After a call to the nextToken method, this field contains the type of the token just read.
/// </summary>
public int ttype;
/// <summary>
/// Internal methods
/// </summary>
private int read()
{
if (this.inReader != null)
return this.inReader.Read();
else if (this.inStream != null)
return this.inStream.Read();
else
return this.inStringReader.Read();
}
private void unread(int ch)
{
if (this.inReader != null)
this.inReader.UnRead(ch);
else if (this.inStream != null)
this.inStream.UnRead(ch);
else
this.inStringReader.UnRead(ch);
}
private void init()
{
this.buf = new System.Text.StringBuilder();
this.ttype = StreamTokenizerSupport.TT_NOTHING;
this.WordChars('A', 'Z');
this.WordChars('a', 'z');
this.WordChars(160, 255);
this.WhitespaceChars(0x00, 0x20);
this.CommentChar('/');
this.QuoteChar('\'');
this.QuoteChar('\"');
this.ParseNumbers();
}
private void setAttributes(int low, int hi, sbyte attrib)
{
int l = System.Math.Max(0, low);
int h = System.Math.Min(255, hi);
for (int i = l; i <= h; i++)
this.attribute[i] = attrib;
}
private bool isWordChar(int data)
{
char ch = (char) data;
return (data != - 1 && (ch > 255 || this.attribute[ch] == StreamTokenizerSupport.WORDCHAR || this.attribute[ch] == StreamTokenizerSupport.NUMBERCHAR));
}
/// <summary>
/// Creates a StreamToknizerSupport that parses the given string.
/// </summary>
/// <param name="reader">The System.IO.StringReader that contains the String to be parsed.</param>
public StreamTokenizerSupport(System.IO.StringReader reader)
{
string s = "";
for (int i = reader.Read(); i != -1 ; i = reader.Read())
{
s += (char) i;
}
reader.Close();
this.inStringReader = new BackStringReader(s);
this.init();
}
/// <summary>
/// Creates a StreamTokenizerSupport that parses the given stream.
/// </summary>
/// <param name="reader">Reader to be parsed.</param>
public StreamTokenizerSupport(System.IO.StreamReader reader)
{
this.inReader = new BackReader(new System.IO.StreamReader(reader.BaseStream, reader.CurrentEncoding).BaseStream, 2, reader.CurrentEncoding);
this.init();
}
/// <summary>
/// Creates a StreamTokenizerSupport that parses the given stream.
/// </summary>
/// <param name="stream">Stream to be parsed.</param>
public StreamTokenizerSupport(System.IO.Stream stream)
{
this.inStream = new BackInputStream(new System.IO.BufferedStream(stream), 2);
this.init();
}
/// <summary>
/// Specified that the character argument starts a single-line comment.
/// </summary>
/// <param name="ch">The character.</param>
public virtual void CommentChar(int ch)
{
if (ch >= 0 && ch <= 255)
this.attribute[ch] = StreamTokenizerSupport.COMMENTCHAR;
}
/// <summary>
/// Determines whether or not ends of line are treated as tokens.
/// </summary>
/// <param name="flag">True indicates that end-of-line characters are separate tokens; False indicates
/// that end-of-line characters are white space.</param>
public virtual void EOLIsSignificant(bool flag)
{
this.eolIsSignificant = flag;
}
/// <summary>
/// Return the current line number.
/// </summary>
/// <returns>Current line number</returns>
public virtual int Lineno()
{
return this.lineno;
}
/// <summary>
/// Determines whether or not word token are automatically lowercased.
/// </summary>
/// <param name="flag">True indicates that all word tokens should be lowercased.</param>
public virtual void LowerCaseMode(bool flag)
{
this.lowerCaseMode = flag;
}
/// <summary>
/// Parses the next token from the input stream of this tokenizer.
/// </summary>
/// <returns>The value of the ttype field.</returns>
public virtual int NextToken()
{
char prevChar = (char) (0);
char ch = (char) (0);
char qChar = (char) (0);
int octalNumber = 0;
int state;
if (this.pushedback)
{
this.pushedback = false;
return this.ttype;
}
this.ttype = StreamTokenizerSupport.TT_NOTHING;
state = StreamTokenizerSupport.STATE_NEUTRAL;
this.nval = 0.0;
this.sval = null;
this.buf.Length = 0;
do
{
int data = this.read();
prevChar = ch;
ch = (char) data;
switch (state)
{
case StreamTokenizerSupport.STATE_NEUTRAL:
{
if (data == - 1)
{
this.ttype = TT_EOF;
state = StreamTokenizerSupport.STATE_DONE;
}
else if (ch > 255)
{
this.buf.Append(ch);
this.ttype = StreamTokenizerSupport.TT_WORD;
state = StreamTokenizerSupport.STATE_WORD;
}
else if (this.attribute[ch] == StreamTokenizerSupport.COMMENTCHAR)
{
state = StreamTokenizerSupport.STATE_LINECOMMENT;
}
else if (this.attribute[ch] == StreamTokenizerSupport.WORDCHAR)
{
this.buf.Append(ch);
this.ttype = StreamTokenizerSupport.TT_WORD;
state = StreamTokenizerSupport.STATE_WORD;
}
else if (this.attribute[ch] == StreamTokenizerSupport.NUMBERCHAR)
{
this.ttype = StreamTokenizerSupport.TT_NUMBER;
this.buf.Append(ch);
if (ch == '-')
state = StreamTokenizerSupport.STATE_NUMBER1;
else if (ch == '.')
state = StreamTokenizerSupport.STATE_NUMBER3;
else
state = StreamTokenizerSupport.STATE_NUMBER2;
}
else if (this.attribute[ch] == StreamTokenizerSupport.QUOTECHAR)
{
qChar = ch;
this.ttype = ch;
state = StreamTokenizerSupport.STATE_STRING;
}
else if ((this.slashSlashComments || this.slashStarComments) && ch == '/')
state = StreamTokenizerSupport.STATE_POSSIBLEC_COMMENT;
else if (this.attribute[ch] == StreamTokenizerSupport.ORDINARYCHAR)
{
this.ttype = ch;
state = StreamTokenizerSupport.STATE_DONE;
}
else if (ch == '\n' || ch == '\r')
{
this.lineno++;
if (this.eolIsSignificant)
{
this.ttype = StreamTokenizerSupport.TT_EOL;
if (ch == '\n')
state = StreamTokenizerSupport.STATE_DONE;
else if (ch == '\r')
state = StreamTokenizerSupport.STATE_DONE_ON_EOL;
}
else if (ch == '\r')
state = StreamTokenizerSupport.STATE_PROCEED_ON_EOL;
}
break;
}
case StreamTokenizerSupport.STATE_WORD:
{
if (this.isWordChar(data))
this.buf.Append(ch);
else
{
if (data != - 1)
this.unread(ch);
this.sval = this.buf.ToString();
state = StreamTokenizerSupport.STATE_DONE;
}
break;
}
case StreamTokenizerSupport.STATE_NUMBER1:
{
if (data == - 1 || this.attribute[ch] != StreamTokenizerSupport.NUMBERCHAR || ch == '-')
{
if ( this.attribute[ch] == StreamTokenizerSupport.COMMENTCHAR && System.Char.IsNumber(ch) )
{
this.buf.Append(ch);
state = StreamTokenizerSupport.STATE_NUMBER2;
}
else
{
if (data != - 1)
this.unread(ch);
this.ttype = '-';
state = StreamTokenizerSupport.STATE_DONE;
}
}
else
{
this.buf.Append(ch);
if (ch == '.')
state = StreamTokenizerSupport.STATE_NUMBER3;
else
state = StreamTokenizerSupport.STATE_NUMBER2;
}
break;
}
case StreamTokenizerSupport.STATE_NUMBER2:
{
if (data == - 1 || this.attribute[ch] != StreamTokenizerSupport.NUMBERCHAR || ch == '-')
{
if (System.Char.IsNumber(ch) && this.attribute[ch] == StreamTokenizerSupport.WORDCHAR)
{
this.buf.Append(ch);
}
else if (ch == '.' && this.attribute[ch] == StreamTokenizerSupport.WHITESPACECHAR)
{
this.buf.Append(ch);
}
else if ( (data != -1) && (this.attribute[ch] == StreamTokenizerSupport.COMMENTCHAR && System.Char.IsNumber(ch) ))
{
this.buf.Append(ch);
}
else
{
if (data != - 1)
this.unread(ch);
try
{
this.nval = System.Double.Parse(this.buf.ToString());
}
catch (System.FormatException) {}
state = StreamTokenizerSupport.STATE_DONE;
}
}
else
{
this.buf.Append(ch);
if (ch == '.')
state = StreamTokenizerSupport.STATE_NUMBER3;
}
break;
}
case StreamTokenizerSupport.STATE_NUMBER3:
{
if (data == - 1 || this.attribute[ch] != StreamTokenizerSupport.NUMBERCHAR || ch == '-' || ch == '.')
{
if ( this.attribute[ch] == StreamTokenizerSupport.COMMENTCHAR && System.Char.IsNumber(ch))
{
this.buf.Append(ch);
}
else
{
if (data != - 1)
this.unread(ch);
System.String str = this.buf.ToString();
if (str.Equals(StreamTokenizerSupport.DASH))
{
this.unread('.');
this.ttype = '-';
}
else if (str.Equals(StreamTokenizerSupport.DOT) && !(StreamTokenizerSupport.WORDCHAR != this.attribute[prevChar]))
this.ttype = '.';
else
{
try
{
this.nval = System.Double.Parse(str);
}
catch (System.FormatException){}
}
state = StreamTokenizerSupport.STATE_DONE;
}
}
else
{
this.buf.Append(ch);
state = StreamTokenizerSupport.STATE_NUMBER4;
}
break;
}
case StreamTokenizerSupport.STATE_NUMBER4:
{
if (data == - 1 || this.attribute[ch] != StreamTokenizerSupport.NUMBERCHAR || ch == '-' || ch == '.')
{
if (data != - 1)
this.unread(ch);
try
{
this.nval = System.Double.Parse(this.buf.ToString());
}
catch (System.FormatException) {}
state = StreamTokenizerSupport.STATE_DONE;
}
else
this.buf.Append(ch);
break;
}
case StreamTokenizerSupport.STATE_LINECOMMENT:
{
if (data == - 1)
{
this.ttype = StreamTokenizerSupport.TT_EOF;
state = StreamTokenizerSupport.STATE_DONE;
}
else if (ch == '\n' || ch == '\r')
{
this.unread(ch);
state = StreamTokenizerSupport.STATE_NEUTRAL;
}
break;
}
case StreamTokenizerSupport.STATE_DONE_ON_EOL:
{
if (ch != '\n' && data != - 1)
this.unread(ch);
state = StreamTokenizerSupport.STATE_DONE;
break;
}
case StreamTokenizerSupport.STATE_PROCEED_ON_EOL:
{
if (ch != '\n' && data != - 1)
this.unread(ch);
state = StreamTokenizerSupport.STATE_NEUTRAL;
break;
}
case StreamTokenizerSupport.STATE_STRING:
{
if (data == - 1 || ch == qChar || ch == '\r' || ch == '\n')
{
this.sval = this.buf.ToString();
if (ch == '\r' || ch == '\n')
this.unread(ch);
state = StreamTokenizerSupport.STATE_DONE;
}
else if (ch == '\\')
state = StreamTokenizerSupport.STATE_STRING_ESCAPE_SEQ;
else
this.buf.Append(ch);
break;
}
case StreamTokenizerSupport.STATE_STRING_ESCAPE_SEQ:
{
if (data == - 1)
{
this.sval = this.buf.ToString();
state = StreamTokenizerSupport.STATE_DONE;
break;
}
state = StreamTokenizerSupport.STATE_STRING;
if (ch == 'a')
this.buf.Append(0x7);
else if (ch == 'b')
this.buf.Append('\b');
else if (ch == 'f')
this.buf.Append(0xC);
else if (ch == 'n')
this.buf.Append('\n');
else if (ch == 'r')
this.buf.Append('\r');
else if (ch == 't')
this.buf.Append('\t');
else if (ch == 'v')
this.buf.Append(0xB);
else if (ch >= '0' && ch <= '7')
{
octalNumber = ch - '0';
state = StreamTokenizerSupport.STATE_STRING_ESCAPE_SEQ_OCTAL;
}
else
this.buf.Append(ch);
break;
}
case StreamTokenizerSupport.STATE_STRING_ESCAPE_SEQ_OCTAL:
{
if (data == - 1 || ch < '0' || ch > '7')
{
this.buf.Append((char) octalNumber);
if (data == - 1)
{
this.sval = buf.ToString();
state = StreamTokenizerSupport.STATE_DONE;
}
else
{
this.unread(ch);
state = StreamTokenizerSupport.STATE_STRING;
}
}
else
{
int temp = octalNumber * 8 + (ch - '0');
if (temp < 256)
octalNumber = temp;
else
{
buf.Append((char) octalNumber);
buf.Append(ch);
state = StreamTokenizerSupport.STATE_STRING;
}
}
break;
}
case StreamTokenizerSupport.STATE_POSSIBLEC_COMMENT:
{
if (ch == '*')
state = StreamTokenizerSupport.STATE_C_COMMENT;
else if (ch == '/')
state = StreamTokenizerSupport.STATE_LINECOMMENT;
else
{
if (data != - 1)
this.unread(ch);
this.ttype = '/';
state = StreamTokenizerSupport.STATE_DONE;
}
break;
}
case StreamTokenizerSupport.STATE_C_COMMENT:
{
if (ch == '*')
state = StreamTokenizerSupport.STATE_POSSIBLEC_COMMENT_END;
if (ch == '\n')
this.lineno++;
else if (data == - 1)
{
this.ttype = StreamTokenizerSupport.TT_EOF;
state = StreamTokenizerSupport.STATE_DONE;
}
break;
}
case StreamTokenizerSupport.STATE_POSSIBLEC_COMMENT_END:
{
if (data == - 1)
{
this.ttype = StreamTokenizerSupport.TT_EOF;
state = StreamTokenizerSupport.STATE_DONE;
}
else if (ch == '/')
state = StreamTokenizerSupport.STATE_NEUTRAL;
else if (ch != '*')
state = StreamTokenizerSupport.STATE_C_COMMENT;
break;
}
}
}
while (state != StreamTokenizerSupport.STATE_DONE);
if (this.ttype == StreamTokenizerSupport.TT_WORD && this.lowerCaseMode)
this.sval = this.sval.ToLower();
return this.ttype;
}
/// <summary>
/// Specifies that the character argument is "ordinary" in this tokenizer.
/// </summary>
/// <param name="ch">The character.</param>
public virtual void OrdinaryChar(int ch)
{
if (ch >= 0 && ch <= 255)
this.attribute[ch] = StreamTokenizerSupport.ORDINARYCHAR;
}
/// <summary>
/// Specifies that all characters c in the range low less-equal c less-equal high are "ordinary" in this
/// tokenizer.
/// </summary>
/// <param name="low">Low end of the range.</param>
/// <param name="hi">High end of the range.</param>
public virtual void OrdinaryChars(int low, int hi)
{
this.setAttributes(low, hi, StreamTokenizerSupport.ORDINARYCHAR);
}
/// <summary>
/// Specifies that numbers should be parsed by this tokenizer.
/// </summary>
public virtual void ParseNumbers()
{
for (int i = '0'; i <= '9'; i++)
this.attribute[i] = StreamTokenizerSupport.NUMBERCHAR;
this.attribute['.'] = StreamTokenizerSupport.NUMBERCHAR;
this.attribute['-'] = StreamTokenizerSupport.NUMBERCHAR;
}
/// <summary>
/// Causes the next call to the nextToken method of this tokenizer to return the current value in the
/// ttype field, and not to modify the value in the nval or sval field.
/// </summary>
public virtual void PushBack()
{
if (this.ttype != StreamTokenizerSupport.TT_NOTHING)
this.pushedback = true;
}
/// <summary>
/// Specifies that matching pairs of this character delimit string constants in this tokenizer.
/// </summary>
/// <param name="ch">The character.</param>
public virtual void QuoteChar(int ch)
{
if (ch >= 0 && ch <= 255)
this.attribute[ch] = QUOTECHAR;
}
/// <summary>
/// Resets this tokenizer's syntax table so that all characters are "ordinary." See the ordinaryChar
/// method for more information on a character being ordinary.
/// </summary>
public virtual void ResetSyntax()
{
this.OrdinaryChars(0x00, 0xff);
}
/// <summary>
/// Determines whether or not the tokenizer recognizes C++-style comments.
/// </summary>
/// <param name="flag">True indicates to recognize and ignore C++-style comments.</param>
public virtual void SlashSlashComments(bool flag)
{
this.slashSlashComments = flag;
}
/// <summary>
/// Determines whether or not the tokenizer recognizes C-style comments.
/// </summary>
/// <param name="flag">True indicates to recognize and ignore C-style comments.</param>
public virtual void SlashStarComments(bool flag)
{
this.slashStarComments = flag;
}
/// <summary>
/// Returns the string representation of the current stream token.
/// </summary>
/// <returns>A String representation of the current stream token.</returns>
public override System.String ToString()
{
System.Text.StringBuilder buffer = new System.Text.StringBuilder(StreamTokenizerSupport.TOKEN);
switch (this.ttype)
{
case StreamTokenizerSupport.TT_NOTHING:
{
buffer.Append(StreamTokenizerSupport.NOTHING);
break;
}
case StreamTokenizerSupport.TT_WORD:
{
buffer.Append(this.sval);
break;
}
case StreamTokenizerSupport.TT_NUMBER:
{
buffer.Append(StreamTokenizerSupport.NUMBER);
buffer.Append(this.nval);
break;
}
case StreamTokenizerSupport.TT_EOF:
{
buffer.Append(StreamTokenizerSupport.EOF);
break;
}
case StreamTokenizerSupport.TT_EOL:
{
buffer.Append(StreamTokenizerSupport.EOL);
break;
}
}
if (this.ttype > 0)
{
if (this.attribute[this.ttype] == StreamTokenizerSupport.QUOTECHAR)
{
buffer.Append(StreamTokenizerSupport.QUOTED);
buffer.Append(this.sval);
}
else
{
buffer.Append('\'');
buffer.Append((char) this.ttype);
buffer.Append('\'');
}
}
buffer.Append(StreamTokenizerSupport.LINE);
buffer.Append(this.lineno);
return buffer.ToString();
}
/// <summary>
/// Specifies that all characters c in the range low less-equal c less-equal high are white space
/// characters.
/// </summary>
/// <param name="low">The low end of the range.</param>
/// <param name="hi">The high end of the range.</param>
public virtual void WhitespaceChars(int low, int hi)
{
this.setAttributes(low, hi, StreamTokenizerSupport.WHITESPACECHAR);
}
/// <summary>
/// Specifies that all characters c in the range low less-equal c less-equal high are word constituents.
/// </summary>
/// <param name="low">The low end of the range.</param>
/// <param name="hi">The high end of the range.</param>
public virtual void WordChars(int low, int hi)
{
this.setAttributes(low, hi, StreamTokenizerSupport.WORDCHAR);
}
}
/*******************************/
/// <summary>
/// This class provides functionality to reads and unread characters into a buffer.
/// </summary>
public class BackReader : System.IO.StreamReader
{
private char[] buffer;
private int position = 1;
//private int markedPosition;
/// <summary>
/// Constructor. Calls the base constructor.
/// </summary>
/// <param name="streamReader">The buffer from which chars will be read.</param>
/// <param name="size">The size of the Back buffer.</param>
public BackReader(System.IO.Stream streamReader, int size, System.Text.Encoding encoding) : base(streamReader,encoding)
{
this.buffer = new char[size];
this.position = size;
}
/// <summary>
/// Constructor. Calls the base constructor.
/// </summary>
/// <param name="streamReader">The buffer from which chars will be read.</param>
public BackReader(System.IO.Stream streamReader, System.Text.Encoding encoding) : base(streamReader, encoding)
{
this.buffer = new char[this.position];
}
/// <summary>
/// Checks if this stream support mark and reset methods.
/// </summary>
/// <remarks>
/// This method isn't supported.
/// </remarks>
/// <returns>Always false.</returns>
public bool MarkSupported()
{
return false;
}
/// <summary>
/// Marks the element at the corresponding position.
/// </summary>
/// <remarks>
/// This method isn't supported.
/// </remarks>
public void Mark(int position)
{
throw new System.IO.IOException("Mark operations are not allowed");
}
/// <summary>
/// Resets the current stream.
/// </summary>
/// <remarks>
/// This method isn't supported.
/// </remarks>
public void Reset()
{
throw new System.IO.IOException("Mark operations are not allowed");
}
/// <summary>
/// Reads a character.
/// </summary>
/// <returns>The character read.</returns>
public override int Read()
{
if (this.position >= 0 && this.position < this.buffer.Length)
return (int) this.buffer[this.position++];
return base.Read();
}
/// <summary>
/// Reads an amount of characters from the buffer and copies the values to the array passed.
/// </summary>
/// <param name="array">Array where the characters will be stored.</param>
/// <param name="index">The beginning index to read.</param>
/// <param name="count">The number of characters to read.</param>
/// <returns>The number of characters read.</returns>
public override int Read(char[] array, int index, int count)
{
int readLimit = this.buffer.Length - this.position;
if (count <= 0)
return 0;
if (readLimit > 0)
{
if (count < readLimit)
readLimit = count;
System.Array.Copy(this.buffer, this.position, array, index, readLimit);
count -= readLimit;
index += readLimit;
this.position += readLimit;
}
if (count > 0)
{
count = base.Read(array, index, count);
if (count == -1)
{
if (readLimit == 0)
return -1;
return readLimit;
}
return readLimit + count;
}
return readLimit;
}
/// <summary>
/// Checks if this buffer is ready to be read.
/// </summary>
/// <returns>True if the position is less than the length, otherwise false.</returns>
public bool IsReady()
{
return (this.position >= this.buffer.Length || this.BaseStream.Position >= this.BaseStream.Length);
}
/// <summary>
/// Unreads a character.
/// </summary>
/// <param name="unReadChar">The character to be unread.</param>
public void UnRead(int unReadChar)
{
this.position--;
this.buffer[this.position] = (char) unReadChar;
}
/// <summary>
/// Unreads an amount of characters by moving these to the buffer.
/// </summary>
/// <param name="array">The character array to be unread.</param>
/// <param name="index">The beginning index to unread.</param>
/// <param name="count">The number of characters to unread.</param>
public void UnRead(char[] array, int index, int count)
{
this.Move(array, index, count);
}
/// <summary>
/// Unreads an amount of characters by moving these to the buffer.
/// </summary>
/// <param name="array">The character array to be unread.</param>
public void UnRead(char[] array)
{
this.Move(array, 0, array.Length - 1);
}
/// <summary>
/// Moves the array of characters to the buffer.
/// </summary>
/// <param name="array">Array of characters to move.</param>
/// <param name="index">Offset of the beginning.</param>
/// <param name="count">Amount of characters to move.</param>
private void Move(char[] array, int index, int count)
{
for (int arrayPosition = index + count; arrayPosition >= index; arrayPosition--)
this.UnRead(array[arrayPosition]);
}
}
/*******************************/
/// <summary>
/// Provides functionality to read and unread from a Stream.
/// </summary>
public class BackInputStream : System.IO.BinaryReader
{
private byte[] buffer;
private int position = 1;
/// <summary>
/// Creates a BackInputStream with the specified stream and size for the buffer.
/// </summary>
/// <param name="streamReader">The stream to use.</param>
/// <param name="size">The specific size of the buffer.</param>
public BackInputStream(System.IO.Stream streamReader, System.Int32 size) : base(streamReader)
{
this.buffer = new byte[size];
this.position = size;
}
/// <summary>
/// Creates a BackInputStream with the specified stream.
/// </summary>
/// <param name="streamReader">The stream to use.</param>
public BackInputStream(System.IO.Stream streamReader) : base(streamReader)
{
this.buffer = new byte[this.position];
}
/// <summary>
/// Checks if this stream support mark and reset methods.
/// </summary>
/// <returns>Always false, these methods aren't supported.</returns>
public bool MarkSupported()
{
return false;
}
/// <summary>
/// Reads the next bytes in the stream.
/// </summary>
/// <returns>The next byte readed</returns>
public override int Read()
{
if (position >= 0 && position < buffer.Length)
return (int) this.buffer[position++];
return base.Read();
}
/// <summary>
/// Reads the amount of bytes specified from the stream.
/// </summary>
/// <param name="array">The buffer to read data into.</param>
/// <param name="index">The beginning point to read.</param>
/// <param name="count">The number of characters to read.</param>
/// <returns>The number of characters read into buffer.</returns>
public virtual int Read(sbyte[] array, int index, int count)
{
int byteCount = 0;
int readLimit = count + index;
byte[] aux = ToByteArray(array);
for (byteCount = 0; position < buffer.Length && index < readLimit; byteCount++)
aux[index++] = buffer[position++];
if (index < readLimit)
byteCount += base.Read(aux, index, readLimit - index);
for(int i = 0; i < aux.Length;i++)
array[i] = (sbyte)aux[i];
return byteCount;
}
/// <summary>
/// Unreads a byte from the stream.
/// </summary>
/// <param name="element">The value to be unread.</param>
public void UnRead(int element)
{
this.position--;
if (position >= 0)
this.buffer[this.position] = (byte) element;
}
/// <summary>
/// Unreads an amount of bytes from the stream.
/// </summary>
/// <param name="array">The byte array to be unread.</param>
/// <param name="index">The beginning index to unread.</param>
/// <param name="count">The number of bytes to be unread.</param>
public void UnRead(byte[] array, int index, int count)
{
this.Move(array, index, count);
}
/// <summary>
/// Unreads an array of bytes from the stream.
/// </summary>
/// <param name="array">The byte array to be unread.</param>
public void UnRead(byte[] array)
{
this.Move(array, 0, array.Length - 1);
}
/// <summary>
/// Skips the specified number of bytes from the underlying stream.
/// </summary>
/// <param name="numberOfBytes">The number of bytes to be skipped.</param>
/// <returns>The number of bytes actually skipped</returns>
public long Skip(long numberOfBytes)
{
return this.BaseStream.Seek(numberOfBytes, System.IO.SeekOrigin.Current) - this.BaseStream.Position;
}
/// <summary>
/// Moves data from the array to the buffer field.
/// </summary>
/// <param name="array">The array of bytes to be unread.</param>
/// <param name="index">The beginning index to unread.</param>
/// <param name="count">The amount of bytes to be unread.</param>
private void Move(byte[] array, int index, int count)
{
for (int arrayPosition = index + count; arrayPosition >= index; arrayPosition--)
this.UnRead(array[arrayPosition]);
}
}
/*******************************/
/// <summary>
/// Support class used to handle threads
/// </summary>
public class ThreadClass : IThreadRunnable
{
/// <summary>
/// The instance of System.Threading.Thread
/// </summary>
private System.Threading.Thread threadField;
/// <summary>
/// Initializes a new instance of the ThreadClass class
/// </summary>
public ThreadClass()
{
threadField = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
}
/// <summary>
/// Initializes a new instance of the Thread class.
/// </summary>
/// <param name="Name">The name of the thread</param>
public ThreadClass(System.String Name)
{
threadField = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
this.Name = Name;
}
/// <summary>
/// Initializes a new instance of the Thread class.
/// </summary>
/// <param name="Start">A ThreadStart delegate that references the methods to be invoked when this thread begins executing</param>
public ThreadClass(System.Threading.ThreadStart Start)
{
threadField = new System.Threading.Thread(Start);
}
/// <summary>
/// Initializes a new instance of the Thread class.
/// </summary>
/// <param name="Start">A ThreadStart delegate that references the methods to be invoked when this thread begins executing</param>
/// <param name="Name">The name of the thread</param>
public ThreadClass(System.Threading.ThreadStart Start, System.String Name)
{
threadField = new System.Threading.Thread(Start);
this.Name = Name;
}
/// <summary>
/// This method has no functionality unless the method is overridden
/// </summary>
public virtual void Run()
{
}
/// <summary>
/// Causes the operating system to change the state of the current thread instance to ThreadState.Running
/// </summary>
public virtual void Start()
{
threadField.Start();
}
/// <summary>
/// Interrupts a thread that is in the WaitSleepJoin thread state
/// </summary>
public virtual void Interrupt()
{
threadField.Interrupt();
}
/// <summary>
/// Gets the current thread instance
/// </summary>
public System.Threading.Thread Instance
{
get
{
return threadField;
}
set
{
threadField = value;
}
}
/// <summary>
/// Gets or sets the name of the thread
/// </summary>
public System.String Name
{
get
{
return threadField.Name;
}
set
{
if (threadField.Name == null)
threadField.Name = value;
}
}
/// <summary>
/// Gets or sets a value indicating the scheduling priority of a thread
/// </summary>
public System.Threading.ThreadPriority Priority
{
get
{
return threadField.Priority;
}
set
{
threadField.Priority = value;
}
}
/// <summary>
/// Gets a value indicating the execution status of the current thread
/// </summary>
public bool IsAlive
{
get
{
return threadField.IsAlive;
}
}
/// <summary>
/// Gets or sets a value indicating whether or not a thread is a background thread.
/// </summary>
public bool IsBackground
{
get
{
return threadField.IsBackground;
}
set
{
threadField.IsBackground = value;
}
}
/// <summary>
/// Blocks the calling thread until a thread terminates
/// </summary>
public void Join()
{
threadField.Join();
}
/// <summary>
/// Blocks the calling thread until a thread terminates or the specified time elapses
/// </summary>
/// <param name="MiliSeconds">Time of wait in milliseconds</param>
public void Join(long MiliSeconds)
{
lock(this)
{
threadField.Join(new System.TimeSpan(MiliSeconds * 10000));
}
}
/// <summary>
/// Blocks the calling thread until a thread terminates or the specified time elapses
/// </summary>
/// <param name="MiliSeconds">Time of wait in milliseconds</param>
/// <param name="NanoSeconds">Time of wait in nanoseconds</param>
public void Join(long MiliSeconds, int NanoSeconds)
{
lock(this)
{
threadField.Join(new System.TimeSpan(MiliSeconds * 10000 + NanoSeconds * 100));
}
}
/*
/// <summary>
/// Resumes a thread that has been suspended
/// </summary>
public void Resume()
{
threadField.Resume();
}
/// <summary>
/// Raises a ThreadAbortException in the thread on which it is invoked,
/// to begin the process of terminating the thread. Calling this method
/// usually terminates the thread
/// </summary>
public void Abort()
{
threadField.Abort();
}
/// <summary>
/// Raises a ThreadAbortException in the thread on which it is invoked,
/// to begin the process of terminating the thread while also providing
/// exception information about the thread termination.
/// Calling this method usually terminates the thread.
/// </summary>
/// <param name="stateInfo">An object that contains application-specific information, such as state, which can be used by the thread being aborted</param>
public void Abort(System.Object stateInfo)
{
lock(this)
{
threadField.Abort(stateInfo);
}
}
/// <summary>
/// Suspends the thread, if the thread is already suspended it has no effect
/// </summary>
public void Suspend()
{
threadField.Suspend();
}
*/
/// <summary>
/// Obtain a String that represents the current Object
/// </summary>
/// <returns>A String that represents the current Object</returns>
public override System.String ToString()
{
return "Thread[" + Name + "," + Priority.ToString() + "," + "" + "]";
}
/// <summary>
/// Gets the currently running thread
/// </summary>
/// <returns>The currently running thread</returns>
public static ThreadClass Current()
{
ThreadClass CurrentThread = new ThreadClass();
CurrentThread.Instance = System.Threading.Thread.CurrentThread;
return CurrentThread;
}
}
/*******************************/
/// <summary>
/// SupportClass for the Stack class.
/// </summary>
public class StackSupport
{
/// <summary>
/// Removes the element at the top of the stack and returns it.
/// </summary>
/// <param name="stack">The stack where the element at the top will be returned and removed.</param>
/// <returns>The element at the top of the stack.</returns>
public static System.Object Pop(System.Collections.ArrayList stack)
{
System.Object obj = stack[stack.Count - 1];
stack.RemoveAt(stack.Count - 1);
return obj;
}
}
}