From: jjenista Date: Tue, 10 Feb 2009 00:59:40 +0000 (+0000) Subject: class library additions X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=1c22c0dd30a5c92655985c3376ae174e80217590;p=IRC.git class library additions --- diff --git a/Robust/src/ClassLibrary/Math.java b/Robust/src/ClassLibrary/Math.java index 8a500e46..63147285 100644 --- a/Robust/src/ClassLibrary/Math.java +++ b/Robust/src/ClassLibrary/Math.java @@ -72,6 +72,21 @@ public class Math { return r; } + public static double rint(double x) { + double y = ceil(x); + double d = y - x; + if( d == 0.5 ) { + if( ((int)y)%2 == 0 ) { + return y; + } else { + return y - 1.0; + } + } else if( d < 0.5 ) { + return y; + } + return y - 1.0; + } + public static native double sin(double a); public static native double cos(double a); public static native double asin(double a); @@ -83,6 +98,9 @@ public class Math { public static native double log(double a); public static native double pow(double a, double b); + public static native double ceil(double a); + public static native double floor(double a); + public static native float sinf(float a); public static native float cosf(float a); public static native float expf(float a); diff --git a/Robust/src/ClassLibrary/PushbackInputStream.java b/Robust/src/ClassLibrary/PushbackInputStream.java new file mode 100644 index 00000000..fb29b416 --- /dev/null +++ b/Robust/src/ClassLibrary/PushbackInputStream.java @@ -0,0 +1,74 @@ +public class PushbackInputStream { + // A pushback input stream lets you throw things + // back into the stream to be read again. Read + // characters from a normal input stream, but keep + // them in a ring buffer also. Then, when unread() + // is called, throw characters from the ring buffer + // onto a stack. During read() first take characters + // off the stack if they are present, otherwise get + // them from the normal input stream. + + private FileInputStream in; + + private int max; + + private int index; + private int[] ring; + + private int top; + private int bottom; + private int[] stack; + + + public PushbackInputStream(FileInputStream fis) { + in = fis; + max = 1000; + + index = 0; + ring = new int[max]; + + bottom = -1; + top = bottom; + stack = new int[max]; + } + + + public int read() { + int v; + + // get next value from stack or if empty + // then from the input stream + if( top > bottom ) { + v = stack[top]; + --top; + } else { + v = in.read(); + } + + // put whatever it is in the ring buffer + ring[index] = v; + + // keep ring buffer index + ++index; + if( index == max ) { + index = 0; + } + + // user gets what they want + return v; + } + + + public void unread(int v) { + ++top; + + // the unread stack can only get so high + if( top == max ) { + System.printString( "PushbackInputStream: max reached" ); + System.exit( -1 ); + } + + // put it on the unread stack + stack[top] = ring[index]; + } +} \ No newline at end of file diff --git a/Robust/src/ClassLibrary/String.java b/Robust/src/ClassLibrary/String.java index 56e9ff7c..a06028bf 100644 --- a/Robust/src/ClassLibrary/String.java +++ b/Robust/src/ClassLibrary/String.java @@ -306,6 +306,20 @@ public class String { return new String(chararray); } + public int compareTo( String s ) { + int lenDiff = this.length() - s.length(); + if( lenDiff != 0 ) { + return lenDiff; + } + for( int i = 0; i < this.length(); ++i ) { + int valDiff = this.charAt(i) - s.charAt(i); + if( valDiff != 0 ) { + return valDiff; + } + } + return 0; + } + public int hashCode() { if (cachedHashcode!=0) return cachedHashcode; diff --git a/Robust/src/ClassLibrary/Vector.java b/Robust/src/ClassLibrary/Vector.java index e944d4fb..fb916cfc 100644 --- a/Robust/src/ClassLibrary/Vector.java +++ b/Robust/src/ClassLibrary/Vector.java @@ -72,6 +72,19 @@ public class Vector { array[size++]=obj; } + public void insertElementAt(Object obj, int index) { + if (index<0||index>=size) + System.printString("Illegal insertElementAt"); + if (size==array.length) { + ensureCapacity(size+1); + } + size++; + for(int i=size-1; i>index; --i) { + array[i] = array[i-1]; + } + array[index] = obj; + } + public void removeElementAt(int index) { if (index<0||index>=size) System.printString("Illegal remove"); @@ -80,4 +93,11 @@ public class Vector { } size--; } + + public void removeAllElements() { + int s = size; + for(int i = 0; iYou may change the delimiter set on the fly by calling + * nextToken(String). But the semantic is quite difficult; it even + * depends on calling hasMoreTokens(). You should call + * hasMoreTokens() before, otherwise the old delimiters + * after the last token are candidates for being returned. + * + *

If you want to get the delimiters, you have to use the three argument + * constructor. The delimiters are returned as token consisting of a + * single character. + * + * @author Jochen Hoenicke + * @author Warren Levy (warrenl@cygnus.com) + * @see java.io.StreamTokenizer + * @status updated to 1.4 + */ +public class StringTokenizer //implements Enumeration +{ + // WARNING: StringTokenizer is a CORE class in the bootstrap cycle. See the + // comments in vm/reference/java/lang/Runtime for implications of this fact. + + /** + * The position in the str, where we currently are. + */ + private int pos; + + /** + * The string that should be split into tokens. + */ + private final String str; + + /** + * The length of the string. + */ + private final int len; + + /** + * The string containing the delimiter characters. + */ + private String delim; + + /** + * Tells, if we should return the delimiters. + */ + private final boolean retDelims; + + /** + * Creates a new StringTokenizer for the string str, + * that should split on the default delimiter set (space, tab, + * newline, return and formfeed), and which doesn't return the + * delimiters. + * + * @param str The string to split + * @throws NullPointerException if str is null + */ + public StringTokenizer(String str) + { + //this(str, " \t\n\r\f", false); + StringTokenizer(str, " \t\n\r\f", false); + } + + /** + * Create a new StringTokenizer, that splits the given string on + * the given delimiter characters. It doesn't return the delimiter + * characters. + * + * @param str the string to split + * @param delim a string containing all delimiter characters + * @throws NullPointerException if either argument is null + */ + public StringTokenizer(String str, String delim) + { + //this(str, delim, false); + StringTokenizer(str, delim, false); + } + + /** + * Create a new StringTokenizer, that splits the given string on + * the given delimiter characters. If you set + * returnDelims to true, the delimiter + * characters are returned as tokens of their own. The delimiter + * tokens always consist of a single character. + * + * @param str the string to split + * @param delim a string containing all delimiter characters + * @param returnDelims tells, if you want to get the delimiters + * @throws NullPointerException if str or delim is null + */ + public StringTokenizer(String str, String delim, boolean returnDelims) + { + len = str.length(); + this.str = str; + this.delim = delim; + this.retDelims = returnDelims; + this.pos = 0; + } + + /** + * Tells if there are more tokens. + * + * @return true if the next call of nextToken() will succeed + */ + public boolean hasMoreTokens() + { + if (! retDelims) + { + while (pos < len && delim.indexOf(str.charAt(pos)) >= 0) + pos++; + } + return pos < len; + } + + /** + * Returns the nextToken, changing the delimiter set to the given + * delim. The change of the delimiter set is + * permanent, ie. the next call of nextToken(), uses the same + * delimiter set. + * + * @param delim a string containing the new delimiter characters + * @return the next token with respect to the new delimiter characters + * @throws NoSuchElementException if there are no more tokens + * @throws NullPointerException if delim is null + */ + public String nextToken(String delim) //throws NoSuchElementException + { + this.delim = delim; + return nextToken(); + } + + /** + * Returns the nextToken of the string. + * + * @return the next token with respect to the current delimiter characters + * @throws NoSuchElementException if there are no more tokens + */ + public String nextToken() //throws NoSuchElementException + { + if (pos < len && delim.indexOf(str.charAt(pos)) >= 0) + { + if (retDelims) + return str.substring(pos, ++pos); + while (++pos < len && delim.indexOf(str.charAt(pos)) >= 0) + ; + } + if (pos < len) + { + int start = pos; + while (++pos < len && delim.indexOf(str.charAt(pos)) < 0) + ; + + return str.substring(start, pos); + } + + //throw new NoSuchElementException(); + System.printString("StringTokenizer: No such element"); + System.exit(-1); + } + + /** + * This does the same as hasMoreTokens. This is the + * Enumeration interface method. + * + * @return true, if the next call of nextElement() will succeed + * @see #hasMoreTokens() + */ + public boolean hasMoreElements() + { + return hasMoreTokens(); + } + + /** + * This does the same as nextTokens. This is the + * Enumeration interface method. + * + * @return the next token with respect to the current delimiter characters + * @throws NoSuchElementException if there are no more tokens + * @see #nextToken() + */ + public Object nextElement() //throws NoSuchElementException + { + return nextToken(); + } + + /** + * This counts the number of remaining tokens in the string, with + * respect to the current delimiter set. + * + * @return the number of times nextTokens() will succeed + * @see #nextToken() + */ + public int countTokens() + { + int count = 0; + int delimiterCount = 0; + boolean tokenFound = false; // Set when a non-delimiter is found + int tmpPos = pos; + + // Note for efficiency, we count up the delimiters rather than check + // retDelims every time we encounter one. That way, we can + // just do the conditional once at the end of the method + while (tmpPos < len) + { + if (delim.indexOf(str.charAt(tmpPos++)) >= 0) + { + if (tokenFound) + { + // Got to the end of a token + count++; + tokenFound = false; + } + delimiterCount++; // Increment for this delimiter + } + else + { + tokenFound = true; + // Get to the end of the token + while (tmpPos < len + && delim.indexOf(str.charAt(tmpPos)) < 0) + ++tmpPos; + } + } + + // Make sure to count the last token + if (tokenFound) + count++; + + // if counting delmiters add them into the token count + if( retDelims ) { + return count + delimiterCount; + } else { + return count; + } + } +} // class StringTokenizer diff --git a/Robust/src/Main/Main.java b/Robust/src/Main/Main.java index 5e66c45b..5bcfe435 100644 --- a/Robust/src/Main/Main.java +++ b/Robust/src/Main/Main.java @@ -191,6 +191,7 @@ public class Main { readSourceFile(state, ClassLibraryPrefix+"StringBuffer.java"); //if(!state.RAW) { readSourceFile(state, ClassLibraryPrefix+"FileInputStream.java"); + readSourceFile(state, ClassLibraryPrefix+"PushbackInputStream.java"); readSourceFile(state, ClassLibraryPrefix+"InputStream.java"); readSourceFile(state, ClassLibraryPrefix+"OutputStream.java"); readSourceFile(state, ClassLibraryPrefix+"FileOutputStream.java"); @@ -198,6 +199,7 @@ public class Main { readSourceFile(state, ClassLibraryPrefix+"InetAddress.java"); readSourceFile(state, ClassLibraryPrefix+"SocketInputStream.java"); readSourceFile(state, ClassLibraryPrefix+"SocketOutputStream.java"); + readSourceFile(state, ClassLibraryPrefix+"gnu/StringTokenizer.java"); //} readSourceFile(state, ClassLibraryPrefix+"Math.java"); readSourceFile(state, ClassLibraryPrefix+"gnu/Random.java"); diff --git a/Robust/src/Runtime/math.c b/Robust/src/Runtime/math.c index 6d5369ca..516cd1d4 100644 --- a/Robust/src/Runtime/math.c +++ b/Robust/src/Runtime/math.c @@ -42,6 +42,14 @@ double CALL22(___Math______pow____D_D, double ___a___, double ___b___, double __ return pow(___a___,___b___); } +double CALL11(___Math______ceil____D, double ___a___, double ___a___) { + return ceil(___a___); +} + +double CALL11(___Math______floor____D, double ___a___, double ___a___) { + return floor(___a___); +} + float CALL11(___Math______cosf____F, float ___a___, float ___a___) { return cosf(___a___); }