March 3, 2008
\n\nThe Google Web Toolkit software and sample code developed by Google\nis licensed under the Apache License, v. 2.0. Other software included\nin this distribution is provided under other licenses, as listed in the\nIncluded Software and Licenses section at the bottom of this page.\nSource code for software included in this distribution is available\nfrom the\nGoogle Web Toolkit\nproject or as otherwise indicated at the bottom of this page.\n
\n\nPlease note that the executable version of the Google Web Toolkit\ndistributed by Google will communicate with Google's servers to check\nfor available updates. If updates are available, you will receive the\noption to install them.\n
\n\n\nApache License
\nVersion 2.0, January 2004
\nhttp://www.apache.org/licenses/\n\n
\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n
\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n
\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n
\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n
\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n
\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n
\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n
\n\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n
\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n
\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n
\n2. Grant of Copyright License.\nSubject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n
\n3. Grant of Patent License.\nSubject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n
\n4. Redistribution.\nYou may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n
5. Submission of Contributions.\nUnless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n
\n6. Trademarks.\nThis License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n
\n7. Disclaimer of Warranty.\nUnless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n
\n8. Limitation of Liability.\nIn no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n
\n9. Accepting Warranty or Additional Liability.\nWhile redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n
\n\n\nThe following third party software is distributed with Google Web\nToolkit and is provided under other licenses and/or has source available\nfrom other locations. Where \"gwt-dev.jar\" is listed, substitute in the\nname of the jar corresponding to your platform, e.g. \"gwt-dev-linux.jar\".\n
\n\n| Package | \nLicense | \nSource Code Availability | \n
|---|---|---|
| Apache Tomcat | \nApache License v. 2.0 (above) | \ntomcat.apache.org; modifications are at org/apache/tomcat/ within gwt-dev.jar | \n
| Apache Tapestry | \nApache License v. 2.0 (above) | \ntapestry.apache.org | \n
| ASM 3.1 | \n(custom) | \ncom/google/gwt/dev/asm/ within gwt-dev.jar | \n
| Eclipse Java Development Tools (JDT) | \nEclipse Public License v. 1.0 | \neclipse.org | \n
| Eclipse Standard Widget Toolkit (SWT) | \nEclipse Public License v. 1.0 | \n\n Linux,\n Windows, and\n Mac;\n modifications are at org/eclipse/swt/ within gwt-dev.jar\n | \n
| Jetty 6.1.11 | \nApache License v. 2.0 (above) | \nmortbay.org/jetty | \n
| Mozilla Rhino | \nMozilla Public License v. 1.1 | \ncom/google/gwt/dev/js/rhino/ within gwt-dev.jar | \n
| Mozilla 1.7.12 (Linux only) | \nMozilla Public License v. 1.1 | \nmozilla.org | \n
| Protobuf | \nNew BSD License | \n\n code.google.com/p/protobuf;\n binary modifications consist of package-rebasing. The rebased classes are rooted at com/google/gwt/dev/protobuf/ within gwt-dev.jar\n | \n
| Google Web Toolkit | \n
| Version 2.8.3 (Git revision 0d0b5d352) | \n
\n Release notes can be found on the GWT project hosting website.\n
\n \n\n" }, { "path": "gwt/gwt-2.8.3/webAppCreator", "content": "#!/bin/sh\nHOMEDIR=`dirname $0`;\njava -cp $HOMEDIR/gwt-user.jar:$HOMEDIR/gwt-dev.jar com.google.gwt.user.tools.WebAppCreator \"$@\";\n" }, { "path": "gwt/gwt-2.8.3/webAppCreator.cmd", "content": "@java -cp \"%~dp0\\gwt-user.jar;%~dp0\\gwt-dev.jar\" com.google.gwt.user.tools.WebAppCreator %*\n" }, { "path": "reproducible-test.sh", "content": "#!/bin/bash\n\nant dist\nhash1=`sha256sum Peergos.jar`\nant dist\nhash2=`sha256sum Peergos.jar`\nif [[ $hash1 == $hash2 ]];\nthen\n exit 0\nelse\n exit -1\nfi\n" }, { "path": "scripts/ensure-compile.sh", "content": "#!/bin/bash\n\n##\n## To set this as the pre-commit hook do:\n##\n## ln -s $(git rev-parse --show-toplevel)/scripts/ensure-compile.sh $(git rev-parse --show-toplevel)/.git/hooks/pre-commit\n##\n\necho \"********************************\"\necho \" Checking if project compiles..\"\necho \"********************************\"\n\nif ! ant compile;\nthen \n echo \"Project failed to compile\"\n exit 1\nfi\n\n" }, { "path": "src/peergos/Peergos.gwt.xml", "content": "\r\n * This class is used to encode and decode data in Base64 format as described in RFC 1521.\r\n *\r\n *
\r\n * Project home page: www.source-code.biz/base64coder/java \n * The default pushback buffer size one byte, but this can be overridden\n * by the creator of the stream.\n * \n *\n * @author Aaron M. Renn (arenn@urbanophile.com)\n * @author Warren Levy (warrenl@cygnus.com)\n */\npublic class PushbackInputStream extends FilterInputStream\n{\n /**\n * This is the default buffer size\n */\n private static final int DEFAULT_BUFFER_SIZE = 1;\n\n /**\n * This is the buffer that is used to store the pushed back data\n */\n protected byte[] buf;\n\n /**\n * This is the position in the buffer from which the next byte will be\n * read. Bytes are stored in reverse order in the buffer, starting from\n * \n * This method will return the number of bytes available from the\n * pushback buffer plus the number of bytes available from the\n * underlying stream.\n *\n * @return The number of bytes that can be read before blocking could occur\n *\n * @exception IOException If an error occurs\n */\n public int available() throws IOException\n {\n try\n {\n return (buf.length - pos) + super.available();\n }\n catch (NullPointerException npe)\n {\n throw new IOException (\"Stream closed\");\n }\n }\n\n /**\n * This method closes the stream and releases any associated resources.\n *\n * @exception IOException If an error occurs.\n */\n public synchronized void close() throws IOException\n {\n buf = null;\n super.close();\n }\n\n /**\n * This method returns \n * This method will block until the byte can be read.\n *\n * @return The byte read or -1 if end of stream\n *\n * @exception IOException If an error occurs\n */\n public synchronized int read() throws IOException\n {\n if (pos < buf.length)\n return ((int) buf[pos++]) & 0xFF;\n\n return super.read();\n }\n\n /**\n * This method read bytes from a stream and stores them into a\n * caller supplied buffer. It starts storing the data at index\n * \n * This method will block until some data can be read.\n * \n * This method first reads bytes from the pushback buffer in order to\n * satisfy the read request. If the pushback buffer cannot provide all\n * of the bytes requested, the remaining bytes are read from the\n * underlying stream.\n *\n * @param b The array into which the bytes read should be stored\n * @param off The offset into the array to start storing bytes\n * @param len The requested number of bytes to read\n *\n * @return The actual number of bytes read, or -1 if end of stream.\n *\n * @exception IOException If an error occurs.\n */\n public synchronized int read(byte[] b, int off, int len) throws IOException\n {\n int numBytes = Math.min(buf.length - pos, len);\n\n if (numBytes > 0)\n {\n System.arraycopy (buf, pos, b, off, numBytes);\n pos += numBytes;\n len -= numBytes;\n off += numBytes;\n }\n\n if (len > 0)\n {\n len = super.read(b, off, len);\n if (len == -1) //EOF\n return numBytes > 0 ? numBytes : -1;\n numBytes += len;\n }\n return numBytes;\n }\n\n /**\n * This method pushes a single byte of data into the pushback buffer.\n * The byte pushed back is the one that will be returned as the first byte\n * of the next read.\n * \n * If the pushback buffer is full, this method throws an exception.\n * \n * The argument to this method is an \n * If the pushback buffer cannot hold all of the requested bytes, an\n * exception is thrown.\n *\n * @param b The byte array to be pushed back\n *\n * @exception IOException If the pushback buffer is full\n */\n public synchronized void unread(byte[] b) throws IOException\n {\n unread(b, 0, b.length);\n }\n\n /**\n * This method pushed back bytes from the passed in array into the\n * pushback buffer. The bytes from \n * If the pushback buffer cannot hold all of the requested bytes, an\n * exception is thrown.\n *\n * @param b The byte array to be pushed back\n * @param off The index into the array where the bytes to be push start\n * @param len The number of bytes to be pushed.\n *\n * @exception IOException If the pushback buffer is full\n */\n public synchronized void unread(byte[] b, int off, int len)\n throws IOException\n {\n if (pos < len)\n throw new IOException(\"Insufficient space in pushback buffer\");\n\n // Note the order that these bytes are being added is the opposite\n // of what would be done if they were added to the buffer one at a time.\n // See the Java Class Libraries book p. 1390.\n System.arraycopy(b, off, buf, pos - len, len);\n\n // Don't put this into the arraycopy above, an exception might be thrown\n // and in that case we don't want to modify pos.\n pos -= len;\n }\n\n /**\n * This method skips the specified number of bytes in the stream. It\n * returns the actual number of bytes skipped, which may be less than the\n * requested amount.\n * \n * This method first discards bytes from the buffer, then calls the\n * \n * This abstract class does not provide a fully working implementation, so it needs to be subclassed, and at least the\n * {@link #write(char[], int, int)}, {@link #close()} and {@link #flush()} methods needs to be overridden. Overriding some of the\n * non-abstract methods is also often advised, since it might result in higher efficiency.\n * \n * Many specialized readers for purposes like reading from a file already exist in this package.\n * \n * @see Reader */\npublic abstract class Writer implements Appendable, Closeable, Flushable {\n\n\tstatic final String TOKEN_NULL = \"null\"; //$NON-NLS-1$\n\n\t/*** The object used to synchronize access to the writer. */\n\tprotected Object lock;\n\n\t/*** Constructs a new {@code Writer} with {@code this} as the object used to synchronize critical sections. */\n\tprotected Writer () {\n\t\tsuper();\n\t\tlock = this;\n\t}\n\n\t/*** Constructs a new {@code Writer} with {@code lock} used to synchronize critical sections.\n\t * \n\t * @param lock the {@code Object} used to synchronize critical sections.\n\t * @throws NullPointerException if {@code lock} is {@code null}. */\n\tprotected Writer (Object lock) {\n\t\tif (lock == null) {\n\t\t\tthrow new NullPointerException();\n\t\t}\n\t\tthis.lock = lock;\n\t}\n\n\t/*** Closes this writer. Implementations of this method should free any resources associated with the writer.\n\t * \n\t * @throws IOException if an error occurs while closing this writer. */\n\tpublic abstract void close () throws IOException;\n\n\t/*** Flushes this writer. Implementations of this method should ensure that all buffered characters are written to the target.\n\t * \n\t * @throws IOException if an error occurs while flushing this writer. */\n\tpublic abstract void flush () throws IOException;\n\n\t/*** Writes the entire character buffer {@code buf} to the target.\n\t * \n\t * @param buf the non-null array containing characters to write.\n\t * @throws IOException if this writer is closed or another I/O error occurs. */\n\tpublic void write (char buf[]) throws IOException {\n\t\twrite(buf, 0, buf.length);\n\t}\n\n\t/*** Writes {@code count} characters starting at {@code offset} in {@code buf} to the target.\n\t * \n\t * @param buf the non-null character array to write.\n\t * @param offset the index of the first character in {@code buf} to write.\n\t * @param count the maximum number of characters to write.\n\t * @throws IndexOutOfBoundsException if {@code offset < 0} or {@code count < 0}, or if {@code offset + count} is greater than\n\t * the size of {@code buf}.\n\t * @throws IOException if this writer is closed or another I/O error occurs. */\n\tpublic abstract void write (char buf[], int offset, int count) throws IOException;\n\n\t/*** Writes one character to the target. Only the two least significant bytes of the integer {@code oneChar} are written.\n\t * \n\t * @param oneChar the character to write to the target.\n\t * @throws IOException if this writer is closed or another I/O error occurs. */\n\tpublic void write (int oneChar) throws IOException {\n\t\tsynchronized (lock) {\n\t\t\tchar oneCharArray[] = new char[1];\n\t\t\toneCharArray[0] = (char)oneChar;\n\t\t\twrite(oneCharArray);\n\t\t}\n\t}\n\n\t/*** Writes the characters from the specified string to the target.\n\t * \n\t * @param str the non-null string containing the characters to write.\n\t * @throws IOException if this writer is closed or another I/O error occurs. */\n\tpublic void write (String str) throws IOException {\n\t\twrite(str, 0, str.length());\n\t}\n\n\t/*** Writes {@code count} characters from {@code str} starting at {@code offset} to the target.\n\t * \n\t * @param str the non-null string containing the characters to write.\n\t * @param offset the index of the first character in {@code str} to write.\n\t * @param count the number of characters from {@code str} to write.\n\t * @throws IOException if this writer is closed or another I/O error occurs.\n\t * @throws IndexOutOfBoundsException if {@code offset < 0} or {@code count < 0}, or if {@code offset + count} is greater than\n\t * the length of {@code str}. */\n\tpublic void write (String str, int offset, int count) throws IOException {\n\t\tif (count < 0) { // other cases tested by getChars()\n\t\t\tthrow new StringIndexOutOfBoundsException();\n\t\t}\n\t\tchar buf[] = new char[count];\n\t\tstr.getChars(offset, offset + count, buf, 0);\n\n\t\tsynchronized (lock) {\n\t\t\twrite(buf, 0, buf.length);\n\t\t}\n\t}\n\n\t/*** Appends the character {@code c} to the target. This method works the same way as {@link #write(int)}.\n\t * \n\t * @param c the character to append to the target stream.\n\t * @return this writer.\n\t * @throws IOException if this writer is closed or another I/O error occurs. */\n\tpublic Writer append (char c) throws IOException {\n\t\twrite(c);\n\t\treturn this;\n\t}\n\n\t/*** Appends the character sequence {@code csq} to the target. This method works the same way as\n\t * {@code Writer.write(csq.toString())}. If {@code csq} is {@code null}, then the string \"null\" is written to the target\n\t * stream.\n\t * \n\t * @param csq the character sequence appended to the target.\n\t * @return this writer.\n\t * @throws IOException if this writer is closed or another I/O error occurs. */\n\tpublic Writer append (CharSequence csq) throws IOException {\n\t\tif (null == csq) {\n\t\t\twrite(TOKEN_NULL);\n\t\t} else {\n\t\t\twrite(csq.toString());\n\t\t}\n\t\treturn this;\n\t}\n\n\t/*** Appends a subsequence of the character sequence {@code csq} to the target. This method works the same way as\n\t * {@code Writer.writer(csq.subsequence(start, end).toString())}. If {@code csq} is {@code null}, then the specified\n\t * subsequence of the string \"null\" will be written to the target.\n\t * \n\t * @param csq the character sequence appended to the target.\n\t * @param start the index of the first char in the character sequence appended to the target.\n\t * @param end the index of the character following the last character of the subsequence appended to the target.\n\t * @return this writer.\n\t * @throws IOException if this writer is closed or another I/O error occurs.\n\t * @throws IndexOutOfBoundsException if {@code start > end}, {@code start < 0}, {@code end < 0} or either {@code start} or\n\t * {@code end} are greater or equal than the length of {@code csq}. */\n\tpublic Writer append (CharSequence csq, int start, int end) throws IOException {\n\t\tif (null == csq) {\n\t\t\twrite(TOKEN_NULL.substring(start, end));\n\t\t} else {\n\t\t\twrite(csq.subSequence(start, end).toString());\n\t\t}\n\t\treturn this;\n\t}\n\n\t/*** Returns true if this writer has encountered and suppressed an error. Used by PrintWriters as an alternative to checked\n\t * exceptions. */\n\tboolean checkError () {\n\t\treturn false;\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/lang/AutoCloseable.java",
"content": "package java.lang;\n\npublic interface AutoCloseable {\n\tvoid close() throws Exception;\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/lang/ClassLoader.java",
"content": "package java.lang;\n\nimport java.io.InputStream;\nimport java.net.URL;\n\npublic class ClassLoader {\n\n\tpublic static ClassLoader getSystemClassLoader() {\n\t\treturn null;\n\t}\n\t\n\tpublic InputStream getResourceAsStream(String name) {\n\t\treturn null;\n\t}\n\t\n\tpublic URL getResource(String name) {\n\t\treturn null;\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/lang/ClassNotFoundException.java",
"content": "/*\r\n * @(#)ClassNotFoundException.java\t1.20 04/02/19\r\n *\r\n * Copyright 2004 Sun Microsystems, Inc. All rights reserved.\r\n * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.\r\n */\r\n\r\npackage java.lang;\r\n\r\n/** Thrown when an application tries to load in a class through its string name using:\r\n * \r\n * but no definition for the class with the specified name could be found.\r\n * \r\n * \r\n * As of release 1.4, this exception has been retrofitted to conform to the general purpose exception-chaining mechanism. The\r\n * \"optional exception that was raised while loading the class\" that may be provided at construction time and accessed via the\r\n * {@link #getException()} method is now known as the cause, and may be accessed via the {@link Throwable#getCause()}\r\n * method, as well as the aforementioned \"legacy method.\"\r\n * \r\n * @author unascribed\r\n * @version 1.20, 02/19/04\r\n * @see java.lang.Class#forName(java.lang.String)\r\n * @see java.lang.ClassLoader#findSystemClass(java.lang.String)\r\n * @see java.lang.ClassLoader#loadClass(java.lang.String, boolean)\r\n * @since JDK1.0 */\r\npublic class ClassNotFoundException extends Exception {\r\n\t/** use serialVersionUID from JDK 1.1.X for interoperability */\r\n\tprivate static final long serialVersionUID = 9176873029745254542L;\r\n\r\n\t/** This field holds the exception ex if the ClassNotFoundException(String s, Throwable ex) constructor was used to instantiate\r\n\t * the object\r\n\t * @serial\r\n\t * @since 1.2 */\r\n\tprivate Throwable ex;\r\n\r\n\t/** Constructs a \r\n\t * This method predates the general-purpose exception chaining facility. The {@link Throwable#getCause()} method is now the\r\n\t * preferred means of obtaining this information.\r\n\t * \r\n\t * @return the \n * All characters except letters ('a'..'z', 'A'..'Z') and numbers ('0'..'9')\n * and characters '.', '-', '*', '_' are converted into their hexadecimal\n * value prepended by '%'. For example: '#' -> %23. In addition, spaces are\n * substituted by '+'\n *\n * @param s\n * the string to be encoded.\n * @return the encoded string.\n * @deprecated use {@link #encode(String, String)} instead.\n */\n @Deprecated\n public static String encode(String s) {\n // Guess a bit bigger for encoded form\n StringBuilder buf = new StringBuilder(s.length() + 16);\n for (int i = 0; i < s.length(); i++) {\n char ch = s.charAt(i);\n if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')\n || (ch >= '0' && ch <= '9') || \".-*_\".indexOf(ch) > -1) {\n buf.append(ch);\n } else if (ch == ' ') {\n buf.append('+');\n } else {\n byte[] bytes = new String(new char[] { ch }).getBytes();\n for (int j = 0; j < bytes.length; j++) {\n buf.append('%');\n buf.append(digits.charAt((bytes[j] & 0xf0) >> 4));\n buf.append(digits.charAt(bytes[j] & 0xf));\n }\n }\n }\n return buf.toString();\n }\n\n /**\n * Encodes the given string {@code s} in a x-www-form-urlencoded string\n * using the specified encoding scheme {@code enc}.\n * \n * All characters except letters ('a'..'z', 'A'..'Z') and numbers ('0'..'9')\n * and characters '.', '-', '*', '_' are converted into their hexadecimal\n * value prepended by '%'. For example: '#' -> %23. In addition, spaces are\n * substituted by '+'\n *\n * @param s\n * the string to be encoded.\n * @param enc\n * the encoding scheme to be used.\n * @return the encoded string.\n * @throws UnsupportedEncodingException\n * if the specified encoding scheme is invalid.\n */\n public static String encode(String s, String enc) throws UnsupportedEncodingException {\n if (s == null || enc == null) {\n throw new NullPointerException();\n }\n // check for UnsupportedEncodingException\n \"\".getBytes(enc);\n\n // Guess a bit bigger for encoded form\n StringBuilder buf = new StringBuilder(s.length() + 16);\n int start = -1;\n for (int i = 0; i < s.length(); i++) {\n char ch = s.charAt(i);\n if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')\n || (ch >= '0' && ch <= '9') || \" .-*_\".indexOf(ch) > -1) {\n if (start >= 0) {\n convert(s.substring(start, i), buf, enc);\n start = -1;\n }\n if (ch != ' ') {\n buf.append(ch);\n } else {\n buf.append('+');\n }\n } else {\n if (start < 0) {\n start = i;\n }\n }\n }\n if (start >= 0) {\n convert(s.substring(start, s.length()), buf, enc);\n }\n return buf.toString();\n }\n\n private static void convert(String s, StringBuilder buf, String enc)\n throws UnsupportedEncodingException {\n byte[] bytes = s.getBytes(enc);\n for (int j = 0; j < bytes.length; j++) {\n buf.append('%');\n buf.append(digits.charAt((bytes[j] & 0xf0) >> 4));\n buf.append(digits.charAt(bytes[j] & 0xf));\n }\n }\n}"
},
{
"path": "src/peergos/gwt/emu/java/net/UnknownHostException.java",
"content": "package java.net;\n\nimport java.io.IOException;\n\npublic class UnknownHostException extends IOException{\n\n public UnknownHostException() {\n }\n\n public UnknownHostException(String msg) {\n super(msg);\n }\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/nio/Buffer.java",
"content": "/* Licensed to the Apache Software Foundation (ASF) under one or more\n * contributor license agreements. See the NOTICE file distributed with\n * this work for additional information regarding copyright ownership.\n * The ASF licenses this file to You under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n * \n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage java.nio;\n\n/** A buffer is a list of elements of a specific primitive type.\n * \n * A buffer can be described by the following properties:\n * \n * Buffers are not thread-safe. If concurrent access to a buffer instance is required, then the callers are responsible to take\n * care of the synchronization issues.\n * \n\t * While the content of this buffer is not changed, the following internal changes take place: the current position is reset\n\t * back to the start of the buffer, the value of the buffer limit is made equal to the capacity and mark is cleared.\n\t * \n\t * The limit is set to the current position, then the position is set to zero, and the mark is cleared.\n\t * \n\t * The content of this buffer is not changed.\n\t * \n\t * If the current position in the buffer is in excess of \n\t * If the mark is set and it is greater than the new position, then it is cleared.\n\t * \n\t * The position is set to zero, and the mark is cleared. The content of this buffer is not changed.\n\t * \n * A char buffer can be created in either one of the following ways:\n * \n\t * Calling this method has the same effect as {@code put(src, 0, src.length)}.\n\t * \n * The specification for Adler32 may be found in RFC 1950.\n * (ZLIB Compressed Data Format Specification version 3.3)\n * \n * \n * From that document:\n * \n * \"ADLER32 (Adler-32 checksum)\n * This contains a checksum value of the uncompressed data\n * (excluding any dictionary data) computed according to Adler-32\n * algorithm. This algorithm is a 32-bit extension and improvement\n * of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073\n * standard. \n * \n * Adler-32 is composed of two sums accumulated per byte: s1 is\n * the sum of all bytes, s2 is the sum of all s1 values. Both sums\n * are done modulo 65521. s1 is initialized to 1, s2 to zero. The\n * Adler-32 checksum is stored as s2*65536 + s1 in most-\n * significant-byte first (network) order.\"\n * \n * \"8.2. The Adler-32 algorithm\n * \n * The Adler-32 algorithm is much faster than the CRC32 algorithm yet\n * still provides an extremely low probability of undetected errors.\n * \n * The modulo on unsigned long accumulators can be delayed for 5552\n * bytes, so the modulo operation time is negligible. If the bytes\n * are a, b, c, the second sum is 3a + 2b + c + 3, and so is position\n * and order sensitive, unlike the first sum, which is just a\n * checksum. That 65521 is prime is important to avoid a possible\n * large class of two-byte errors that leave the check unchanged.\n * (The Fletcher checksum uses 255, which is not prime and which also\n * makes the Fletcher check insensitive to single byte changes 0 <->\n * 255.)\n * \n * The sum s1 is initialized to 1 instead of zero to make the length\n * of the sequence part of s2, so that the length does not have to be\n * checked separately. (Any sequence of zeroes has a Fletcher\n * checksum of zero.)\"\n *\n * @author John Leuner, Per Bothner\n * @since JDK 1.1\n *\n * @see InflaterInputStream\n * @see DeflaterOutputStream\n */\n public class Adler32 implements Checksum\n {\n \n /** largest prime smaller than 65536 */\n private static final int BASE = 65521;\n \n private int checksum; //we do all in int.\n \n //Note that java doesn't have unsigned integers,\n //so we have to be careful with what arithmetic\n //we do. We return the checksum as a long to\n //avoid sign confusion.\n \n /**\n * Creates a new instance of the
\r\n * Author: Christian d'Heureuse, Inventec Informatik AG, Zurich, Switzerland
\r\n * Multi-licensed: EPL / LGPL / GPL / AL / BSD.\r\n *\r\n * @author Christian d'Heureuse\r\n * @author vaxquis\r\n */\r\n\r\npackage com.badlogic.gdx.utils;\r\n\r\npublic class Base64Coder {\r\n\tpublic static class CharMap {\r\n\t\tprotected final char[] encodingMap = new char[64];\r\n\t\tprotected final byte[] decodingMap = new byte[128];\r\n\r\n\t\tpublic CharMap (char char63, char char64) {\r\n\t\t\tint i = 0;\r\n\t\t\tfor (char c = 'A'; c <= 'Z'; c++) {\r\n\t\t\t\tencodingMap[i++] = c;\r\n\t\t\t}\r\n\t\t\tfor (char c = 'a'; c <= 'z'; c++) {\r\n\t\t\t\tencodingMap[i++] = c;\r\n\t\t\t}\r\n\t\t\tfor (char c = '0'; c <= '9'; c++) {\r\n\t\t\t\tencodingMap[i++] = c;\r\n\t\t\t}\r\n\t\t\tencodingMap[i++] = char63;\r\n\t\t\tencodingMap[i++] = char64;\r\n\t\t\tfor (i = 0; i < decodingMap.length; i++) {\r\n\t\t\t\tdecodingMap[i] = -1;\r\n\t\t\t}\r\n\t\t\tfor (i = 0; i < 64; i++) {\r\n\t\t\t\tdecodingMap[encodingMap[i]] = (byte)i;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tpublic byte[] getDecodingMap () {\r\n\t\t\treturn decodingMap;\r\n\t\t}\r\n\r\n\t\tpublic char[] getEncodingMap () {\r\n\t\t\treturn encodingMap;\r\n\t\t}\r\n\t}\r\n\r\n\t// The line separator string of the operating system.\r\n\tprivate static final String systemLineSeparator = \"\\n\";\r\n\r\n\tpublic static final CharMap regularMap = new CharMap('+', '/'), urlsafeMap = new CharMap('-', '_');\r\n\r\n\t/** Encodes a string into Base64 format. No blanks or line breaks are inserted.\r\n\t * @param s A String to be encoded.\r\n\t * @return A String containing the Base64 encoded data. */\r\n\tpublic static String encodeString (String s) {\r\n\t\treturn encodeString(s, false);\r\n\t}\r\n\r\n\tpublic static String encodeString (String s, boolean useUrlsafeEncoding) {\r\n\t\treturn new String(encode(s.getBytes(), useUrlsafeEncoding ? urlsafeMap.encodingMap : regularMap.encodingMap));\r\n\t}\r\n\r\n\t/** Encodes a byte array into Base 64 format and breaks the output into lines of 76 characters. This method is compatible with\r\n\t * sun.misc.BASE64Encoder.encodeBuffer(byte[]).\r\n\t * @param in An array containing the data bytes to be encoded.\r\n\t * @return A String containing the Base64 encoded data, broken into lines. */\r\n\tpublic static String encodeLines (byte[] in) {\r\n\t\treturn encodeLines(in, 0, in.length, 76, systemLineSeparator, regularMap.encodingMap);\r\n\t}\r\n\r\n\tpublic static String encodeLines (byte[] in, int iOff, int iLen, int lineLen, String lineSeparator, CharMap charMap) {\r\n\t\treturn encodeLines(in, iOff, iLen, lineLen, lineSeparator, charMap.encodingMap);\r\n\t}\r\n\r\n\t/** Encodes a byte array into Base 64 format and breaks the output into lines.\r\n\t * @param in An array containing the data bytes to be encoded.\r\n\t * @param iOff Offset of the first byte in in to be processed.\r\n\t * @param iLen Number of bytes to be processed in in, starting at iOff.\r\n\t * @param lineLen Line length for the output data. Should be a multiple of 4.\r\n\t * @param lineSeparator The line separator to be used to separate the output lines.\r\n\t * @param charMap char map to use\r\n\t * @return A String containing the Base64 encoded data, broken into lines. */\r\n\tpublic static String encodeLines (byte[] in, int iOff, int iLen, int lineLen, String lineSeparator, char[] charMap) {\r\n\t\tint blockLen = (lineLen * 3) / 4;\r\n\t\tif (blockLen <= 0) {\r\n\t\t\tthrow new IllegalArgumentException();\r\n\t\t}\r\n\t\tint lines = (iLen + blockLen - 1) / blockLen;\r\n\t\tint bufLen = ((iLen + 2) / 3) * 4 + lines * lineSeparator.length();\r\n\t\tStringBuilder buf = new StringBuilder(bufLen);\r\n\t\tint ip = 0;\r\n\t\twhile (ip < iLen) {\r\n\t\t\tint l = Math.min(iLen - ip, blockLen);\r\n\t\t\tbuf.append(encode(in, iOff + ip, l, charMap));\r\n\t\t\tbuf.append(lineSeparator);\r\n\t\t\tip += l;\r\n\t\t}\r\n\t\treturn buf.toString();\r\n\t}\r\n\r\n\t/** Encodes a byte array into Base64 format. No blanks or line breaks are inserted in the output.\r\n\t * @param in An array containing the data bytes to be encoded.\r\n\t * @return A character array containing the Base64 encoded data. */\r\n\tpublic static char[] encode (byte[] in) {\r\n\t\treturn encode(in, regularMap.encodingMap);\r\n\t}\r\n\r\n\tpublic static char[] encode (byte[] in, CharMap charMap) {\r\n\t\treturn encode(in, 0, in.length, charMap);\r\n\t}\r\n\r\n public static char[] encode (byte[] in, char[] charMap) {\r\n\t\treturn encode(in, 0, in.length, charMap);\r\n\t}\r\n\r\n\t/** Encodes a byte array into Base64 format. No blanks or line breaks are inserted in the output.\r\n\t * @param in An array containing the data bytes to be encoded.\r\n\t * @param iLen Number of bytes to process in in.\r\n\t * @return A character array containing the Base64 encoded data. */\r\n\tpublic static char[] encode (byte[] in, int iLen) {\r\n\t\treturn encode(in, 0, iLen, regularMap.encodingMap);\r\n\t}\r\n\r\n\tpublic static char[] encode (byte[] in, int iOff, int iLen, CharMap charMap) {\r\n\t\treturn encode(in, iOff, iLen, charMap.encodingMap);\r\n\t}\r\n\r\n\t/** Encodes a byte array into Base64 format. No blanks or line breaks are inserted in the output.\r\n\t * @param in An array containing the data bytes to be encoded.\r\n\t * @param iOff Offset of the first byte in in to be processed.\r\n\t * @param iLen Number of bytes to process in in, starting at iOff.\r\n\t * @param charMap char map to use\r\n\t * @return A character array containing the Base64 encoded data. */\r\n\tpublic static char[] encode (byte[] in, int iOff, int iLen, char[] charMap) {\r\n\t\tint oDataLen = (iLen * 4 + 2) / 3; // output length without padding\r\n\t\tint oLen = ((iLen + 2) / 3) * 4; // output length including padding\r\n\t\tchar[] out = new char[oLen];\r\n\t\tint ip = iOff;\r\n\t\tint iEnd = iOff + iLen;\r\n\t\tint op = 0;\r\n\t\twhile (ip < iEnd) {\r\n\t\t\tint i0 = in[ip++] & 0xff;\r\n\t\t\tint i1 = ip < iEnd ? in[ip++] & 0xff : 0;\r\n\t\t\tint i2 = ip < iEnd ? in[ip++] & 0xff : 0;\r\n\t\t\tint o0 = i0 >>> 2;\r\n\t\t\tint o1 = ((i0 & 3) << 4) | (i1 >>> 4);\r\n\t\t\tint o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);\r\n\t\t\tint o3 = i2 & 0x3F;\r\n\t\t\tout[op++] = charMap[o0];\r\n\t\t\tout[op++] = charMap[o1];\r\n\t\t\tout[op] = op < oDataLen ? charMap[o2] : '=';\r\n\t\t\top++;\r\n\t\t\tout[op] = op < oDataLen ? charMap[o3] : '=';\r\n\t\t\top++;\r\n\t\t}\r\n\t\treturn out;\r\n\t}\r\n\r\n\t/** Decodes a string from Base64 format. No blanks or line breaks are allowed within the Base64 encoded input data.\r\n\t * @param s A Base64 String to be decoded.\r\n\t * @return A String containing the decoded data.\r\n\t * @throws IllegalArgumentException If the input is not valid Base64 encoded data. */\r\n\tpublic static String decodeString (String s) {\r\n\t\treturn decodeString(s, false);\r\n\t}\r\n\r\n\tpublic static String decodeString (String s, boolean useUrlSafeEncoding) {\r\n\t\treturn new String(decode(s.toCharArray(), useUrlSafeEncoding ? urlsafeMap.decodingMap : regularMap.decodingMap));\r\n\t}\r\n\r\n public static byte[] decodeLines (String s) {\r\n return decodeLines(s, regularMap.decodingMap);\r\n }\r\n\r\n public static byte[] decodeLines (String s, CharMap inverseCharMap) {\r\n return decodeLines(s, inverseCharMap.decodingMap);\r\n }\r\n\r\n\t/** Decodes a byte array from Base64 format and ignores line separators, tabs and blanks. CR, LF, Tab and Space characters are\r\n\t * ignored in the input data. This method is compatible with sun.misc.BASE64Decoder.decodeBuffer(String).\r\n\t * @param s A Base64 String to be decoded.\r\n * @param inverseCharMap\r\n\t * @return An array containing the decoded data bytes.\r\n\t * @throws IllegalArgumentException If the input is not valid Base64 encoded data. */\r\n\tpublic static byte[] decodeLines (String s, byte[] inverseCharMap) {\r\n\t\tchar[] buf = new char[s.length()];\r\n\t\tint p = 0;\r\n\t\tfor (int ip = 0; ip < s.length(); ip++) {\r\n\t\t\tchar c = s.charAt(ip);\r\n\t\t\tif (c != ' ' && c != '\\r' && c != '\\n' && c != '\\t') {\r\n\t\t\t\tbuf[p++] = c;\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn decode(buf, 0, p, inverseCharMap);\r\n\t}\r\n\t\r\n\t/** Decodes a byte array from Base64 format. No blanks or line breaks are allowed within the Base64 encoded input data.\r\n\t * @param s A Base64 String to be decoded.\r\n\t * @return An array containing the decoded data bytes.\r\n\t * @throws IllegalArgumentException If the input is not valid Base64 encoded data. */\r\n\tpublic static byte[] decode (String s) {\r\n\t\treturn decode(s.toCharArray());\r\n\t}\r\n\r\n\t/** Decodes a byte array from Base64 format. No blanks or line breaks are allowed within the Base64 encoded input data.\r\n\t * @param s A Base64 String to be decoded.\r\n\t * @param inverseCharMap\r\n\t * @return An array containing the decoded data bytes.\r\n\t * @throws IllegalArgumentException If the input is not valid Base64 encoded data. */\r\n\tpublic static byte[] decode (String s, CharMap inverseCharMap) {\r\n\t\treturn decode(s.toCharArray(), inverseCharMap);\r\n\t}\r\n\r\n public static byte[] decode (char[] in, byte[] inverseCharMap) {\r\n\t\treturn decode(in, 0, in.length, inverseCharMap);\r\n\t}\r\n\r\n\tpublic static byte[] decode (char[] in, CharMap inverseCharMap) {\r\n\t\treturn decode(in, 0, in.length, inverseCharMap);\r\n\t}\r\n\r\n\t/** Decodes a byte array from Base64 format. No blanks or line breaks are allowed within the Base64 encoded input data.\r\n\t * @param in A character array containing the Base64 encoded data.\r\n\t * @return An array containing the decoded data bytes.\r\n\t * @throws IllegalArgumentException If the input is not valid Base64 encoded data. */\r\n\tpublic static byte[] decode (char[] in) {\r\n\t\treturn decode(in, 0, in.length, regularMap.decodingMap);\r\n\t}\r\n\r\n\tpublic static byte[] decode (char[] in, int iOff, int iLen, CharMap inverseCharMap) {\r\n\t\treturn decode(in, iOff, iLen, inverseCharMap.decodingMap);\r\n\t}\r\n\r\n\t/** Decodes a byte array from Base64 format. No blanks or line breaks are allowed within the Base64 encoded input data.\r\n\t * @param in A character array containing the Base64 encoded data.\r\n\t * @param iOff Offset of the first character in in to be processed.\r\n\t * @param iLen Number of characters to process in in, starting at iOff.\r\n\t * @param inverseCharMap charMap to use\r\n\t * @return An array containing the decoded data bytes.\r\n\t * @throws IllegalArgumentException If the input is not valid Base64 encoded data. */\r\n\tpublic static byte[] decode (char[] in, int iOff, int iLen, byte[] inverseCharMap) {\r\n\t\tif (iLen % 4 != 0) {\r\n\t\t\tthrow new IllegalArgumentException(\"Length of Base64 encoded input string is not a multiple of 4.\");\r\n\t\t}\r\n\t\twhile (iLen > 0 && in[iOff + iLen - 1] == '=') {\r\n\t\t\tiLen--;\r\n\t\t}\r\n\t\tint oLen = (iLen * 3) / 4;\r\n\t\tbyte[] out = new byte[oLen];\r\n\t\tint ip = iOff;\r\n\t\tint iEnd = iOff + iLen;\r\n\t\tint op = 0;\r\n\t\twhile (ip < iEnd) {\r\n\t\t\tint i0 = in[ip++];\r\n\t\t\tint i1 = in[ip++];\r\n\t\t\tint i2 = ip < iEnd ? in[ip++] : 'A';\r\n\t\t\tint i3 = ip < iEnd ? in[ip++] : 'A';\r\n\t\t\tif (i0 > 127 || i1 > 127 || i2 > 127 || i3 > 127) {\r\n\t\t\t\tthrow new IllegalArgumentException(\"Illegal character in Base64 encoded data.\");\r\n\t\t\t}\r\n\t\t\tint b0 = inverseCharMap[i0];\r\n\t\t\tint b1 = inverseCharMap[i1];\r\n\t\t\tint b2 = inverseCharMap[i2];\r\n\t\t\tint b3 = inverseCharMap[i3];\r\n\t\t\tif (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0) {\r\n\t\t\t\tthrow new IllegalArgumentException(\"Illegal character in Base64 encoded data.\");\r\n\t\t\t}\r\n\t\t\tint o0 = (b0 << 2) | (b1 >>> 4);\r\n\t\t\tint o1 = ((b1 & 0xf) << 4) | (b2 >>> 2);\r\n\t\t\tint o2 = ((b2 & 3) << 6) | b3;\r\n\t\t\tout[op++] = (byte)o0;\r\n\t\t\tif (op < oLen) {\r\n\t\t\t\tout[op++] = (byte)o1;\r\n\t\t\t}\r\n\t\t\tif (op < oLen) {\r\n\t\t\t\tout[op++] = (byte)o2;\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn out;\r\n\t}\r\n\r\n\t// Dummy constructor.\r\n\tprivate Base64Coder () {\r\n\t}\r\n}\r\n"
},
{
"path": "src/peergos/gwt/emu/com/badlogic/gdx/utils/Utf8Decoder.java",
"content": "/*******************************************************************************\n * Copyright 2015 See AUTHORS file.\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n * \n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n ******************************************************************************/\n\n/*******************************************************************************\n * Copyright (c) 2008-2009 Bjoern Hoehrmann FilterInputStream provides the ability to\n * unread data from a stream. It maintains an internal buffer of unread\n * data that is supplied to the next read operation. This is conceptually\n * similar to mark/reset functionality, except that in this case the\n * position to reset the stream to does not need to be known in advance.\n * buf[buf.length - 1] to buf[0]. Thus when\n * pos is 0 the buffer is full and buf.length when\n * it is empty\n */\n protected int pos;\n\n /**\n * This method initializes a PushbackInputStream to\n * read from the specified subordinate InputStream\n * with a default pushback buffer size of 1.\n *\n * @param in The subordinate stream to read from\n */\n public PushbackInputStream(InputStream in)\n {\n this(in, DEFAULT_BUFFER_SIZE);\n }\n\n /**\n * This method initializes a PushbackInputStream to\n * read from the specified subordinate InputStream with\n * the specified buffer size\n *\n * @param in The subordinate InputStream to read from\n * @param size The pushback buffer size to use\n */\n public PushbackInputStream(InputStream in, int size)\n {\n super(in);\n if (size < 0)\n throw new IllegalArgumentException();\n buf = new byte[size];\n pos = buf.length;\n }\n\n /**\n * This method returns the number of bytes that can be read from this\n * stream before a read can block. A return of 0 indicates that blocking\n * might (or might not) occur on the very next read attempt.\n * false to indicate that it does\n * not support mark/reset functionality.\n *\n * @return This method returns false to indicate that\n * this class does not support mark/reset functionality\n */\n public boolean markSupported()\n {\n return false;\n }\n\n /**\n * This method always throws an IOException in this class because\n * mark/reset functionality is not supported.\n *\n * @exception IOException Always thrown for this class\n */\n public void reset() throws IOException\n {\n throw new IOException(\"Mark not supported in this class\");\n }\n\n /**\n * This method reads an unsigned byte from the input stream and returns it\n * as an int in the range of 0-255. This method also will return -1 if\n * the end of the stream has been reached. The byte returned will be read\n * from the pushback buffer, unless the buffer is empty, in which case\n * the byte will be read from the underlying stream.\n * offset into the buffer and attempts to read\n * len bytes. This method can return before reading the\n * number of bytes requested. The actual number of bytes read is\n * returned as an int. A -1 is returned to indicate the end of the\n * stream.\n * int. Only the low\n * eight bits of this value are pushed back.\n *\n * @param b The byte to be pushed back, passed as an int\n *\n * @exception IOException If the pushback buffer is full.\n */\n public synchronized void unread(int b) throws IOException\n {\n if (pos <= 0)\n throw new IOException(\"Insufficient space in pushback buffer\");\n\n buf[--pos] = (byte) b;\n }\n\n /**\n * This method pushes all of the bytes in the passed byte array into\n * the pushback bfer. These bytes are pushed in reverse order so that\n * the next byte read from the stream after this operation will be\n * b[0] followed by b[1], etc.\n * b[offset] to\n * b[offset + len] are pushed in reverse order so that\n * the next byte read from the stream after this operation will be\n * b[offset] followed by b[offset + 1],\n * etc.\n * skip method on the underlying InputStream to\n * skip additional bytes if necessary.\n *\n * @param n The requested number of bytes to skip\n *\n * @return The actual number of bytes skipped.\n *\n * @exception IOException If an error occurs\n *\n * @since 1.2\n */\n public synchronized long skip(long n) throws IOException\n {\n final long origN = n;\n\n if (n > 0L)\n {\n int numread = (int) Math.min((long) (buf.length - pos), n);\n pos += numread;\n n -= numread;\n if (n > 0)\n n -= super.skip(n);\n }\n\n return origN - n;\n }\n}"
},
{
"path": "src/peergos/gwt/emu/java/io/RandomAccessFile.java",
"content": "/*\n * Copyright 2010 Google Inc.\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n * \n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\npackage java.io;\n\n/** Saves binary data to the local storage; currently using hex encoding. The string is prefixed with \"hex:\"\n * @author haustein */\npublic class RandomAccessFile implements Closeable/* implements DataOutput, DataInput, Closeable */{\n\t\n\tpublic RandomAccessFile (File file, String mode) throws FileNotFoundException {\n\t\tthrow new Error(\"Not implemented\");\n\t}\n\n\t@Override\n\tpublic void close() throws IOException {\n\t}\n\n\tpublic long length () throws IOException {\n\t\treturn -1;\n\t}\n\t\n\tpublic int read () throws IOException {\n\t\treturn -1;\n\t}\n\t\n\tpublic int read (byte b[]) throws IOException {\n\t\treturn -1;\n\t}\n\n\tpublic int read (byte b[], int offset, int len) throws IOException {\n\t\treturn -1;\n\t}\n\n\tpublic void seek (long pos) throws IOException {\n\t}\n\t\n\tpublic void setLength (long newLength) throws IOException {\n\t}\n\t\n\tpublic void write (byte b[]) throws IOException {\n\t}\n\n}"
},
{
"path": "src/peergos/gwt/emu/java/io/Reader.java",
"content": "/*\n * Copyright 2018 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\npackage java.io;\n\n/**\n * Reads a stream of characters.\n */\npublic abstract class Reader {\n /**\n * The maximum buffer size to incrementally read in {@link #skip}.\n */\n private static final int MAX_SKIP_BUFFER_SIZE = 1024;\n\n /**\n * Closes the reader, and releases any associated resources.\n */\n public abstract void close() throws IOException;\n\n /**\n * Marks the present position in the stream. Until {@code readAheadLimit} more\n * characters have been read, the current point in the stream will be stored\n * as the mark. Calls to {@link #reset} will reposition the point in the\n * stream to the mark.\n *\n * @throws IOException If the stream does not support mark().\n */\n public void mark(int readAheadLimit) throws IOException {\n throw new IOException(\"Not supported\");\n }\n\n /**\n * Returns whether {@link #mark} is implemented.\n */\n public boolean markSupported() {\n return false;\n }\n\n /**\n * Reads a single character, or -1 if we are at the end of the stream.\n */\n public int read() throws IOException {\n char chr[] = new char[1];\n return (read(chr) == -1) ? -1 : chr[0];\n }\n\n /**\n * Attempts to fill {@code buf} with characters up to the size of the array.\n */\n public int read(char[] buf) throws IOException {\n return read(buf, 0, buf.length);\n }\n\n /**\n * Attempts to fill {@code buf} with up to {@code len} characters. Characters\n * will be stored in {@code buf} starting at index {@code off}.\n */\n public abstract int read(char[] buf, int off, int len) throws IOException;\n\n /**\n * Returns whether the stream is ready for reading characters.\n */\n public boolean ready() throws IOException {\n return false;\n }\n\n /**\n * Attempts to reset the stream to the previous mark.\n */\n public void reset() throws IOException {\n throw new IOException(\"Not supported\");\n }\n\n /**\n * Skips {@code n} characters, returning the number of characters that were actually skipped.\n */\n public long skip(long n) throws IOException {\n long remaining = n;\n int bufferSize = Math.min((int) n, MAX_SKIP_BUFFER_SIZE);\n char[] skipBuffer = new char[bufferSize];\n while (remaining > 0) {\n long numRead = read(skipBuffer, 0, (int) remaining);\n if (numRead < 0) {\n break;\n }\n remaining -= numRead;\n }\n return n - remaining;\n }\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/io/UTFDataFormatException.java",
"content": "/*\n * Copyright 2010 Google Inc.\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n * \n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\npackage java.io;\n\npublic class UTFDataFormatException extends IOException {\n\n\tpublic UTFDataFormatException (String msg) {\n\t\tsuper(msg);\n\t}\n\n\tpublic UTFDataFormatException () {\n\t\tsuper();\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/io/UnsupportedEncodingException.java",
"content": "/*\n * Copyright 2010 Google Inc.\n * \n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n * \n * http://www.apache.org/licenses/LICENSE-2.0\n * \n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\n\npackage java.io;\n\npublic class UnsupportedEncodingException extends IOException {\n\tpublic UnsupportedEncodingException () {\n\t\tsuper();\n\t}\n\n\tpublic UnsupportedEncodingException (String s) {\n\t\tsuper(s);\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/io/Writer.java",
"content": "/**\n * Licensed to the Apache Software Foundation (ASF) under one or more\n * contributor license agreements. See the NOTICE file distributed with\n * this work for additional information regarding copyright ownership.\n * The ASF licenses this file to You under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage java.io;\n\n/*** The base class for all writers. A writer is a means of writing data to a target in a character-wise manner. Most output streams\n * expect the {@link #flush()} method to be called before closing the stream, to ensure all data is actually written out.\n * \r\n *
\r\n * forName method in class Class.\r\n * findSystemClass method in class ClassLoader .\r\n * loadClass method in class ClassLoader.\r\n * ClassNotFoundException with no detail message. */\r\n\tpublic ClassNotFoundException () {\r\n\t\tsuper((Throwable)null); // Disallow initCause\r\n\t}\r\n\r\n\t/** Constructs a ClassNotFoundException with the specified detail message.\r\n\t * \r\n\t * @param s the detail message. */\r\n\tpublic ClassNotFoundException (String s) {\r\n\t\tsuper(s, null); // Disallow initCause\r\n\t}\r\n\r\n\t/** Constructs a ClassNotFoundException with the specified detail message and optional exception that was raised\r\n\t * while loading the class.\r\n\t * \r\n\t * @param s the detail message\r\n\t * @param ex the exception that was raised while loading the class\r\n\t * @since 1.2 */\r\n\tpublic ClassNotFoundException (String s, Throwable ex) {\r\n\t\tsuper(s, null); // Disallow initCause\r\n\t\tthis.ex = ex;\r\n\t}\r\n\r\n\t/** Returns the exception that was raised if an error occurred while attempting to load the class. Otherwise, returns\r\n\t * null.\r\n\t * \r\n\t * Exception that was raised while loading a class\r\n\t * @since 1.2 */\r\n\tpublic Throwable getException () {\r\n\t\treturn ex;\r\n\t}\r\n\r\n\t/** Returns the cause of this exception (the exception that was raised if an error occurred while attempting to load the class;\r\n\t * otherwise null).\r\n\t * \r\n\t * @return the cause of this exception.\r\n\t * @since 1.4 */\r\n\tpublic Throwable getCause () {\r\n\t\treturn ex;\r\n\t}\r\n}\r\n"
},
{
"path": "src/peergos/gwt/emu/java/lang/Exception.java",
"content": "/*\n * Copyright 2007 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\npackage java.lang;\n\n/**\n * See InternalError with no detail message.\n */\n public InternalError() {\n super();\n }\n \n /**\n * Constructs an InternalError with the specified\n * detail message.\n *\n * @param s the detail message.\n */\n public InternalError(String s) {\n super(s);\n }\n}"
},
{
"path": "src/peergos/gwt/emu/java/lang/InterruptedException.java",
"content": "/* Copyright (c) 2008, Avian Contributors\r\n\r\n Permission to use, copy, modify, and/or distribute this software\r\n for any purpose with or without fee is hereby granted, provided\r\n that the above copyright notice and this permission notice appear\r\n in all copies.\r\n\r\n There is NO WARRANTY for this software. See license.txt for\r\n details. */\r\n\r\npackage java.lang;\r\n\r\npublic class InterruptedException extends Exception {\r\n\tpublic InterruptedException (String message, Throwable cause) {\r\n\t\tsuper(message, cause);\r\n\t}\r\n\r\n\tpublic InterruptedException (String message) {\r\n\t\tthis(message, null);\r\n\t}\r\n\r\n\tpublic InterruptedException (Throwable cause) {\r\n\t\tthis(null, cause);\r\n\t}\r\n\r\n\tpublic InterruptedException () {\r\n\t\tthis(null, null);\r\n\t}\r\n}\r\n"
},
{
"path": "src/peergos/gwt/emu/java/lang/OutOfMemoryError.java",
"content": "package java.lang;\n\npublic class OutOfMemoryError extends Error {\n\n\tpublic OutOfMemoryError() {}\n\n\tpublic OutOfMemoryError(String msg) {\n\t\tsuper(msg);\n\t}\n\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/lang/Readable.java",
"content": "/*******************************************************************************\r\n * Copyright 2011 See AUTHORS file.\r\n * \r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n * \r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n * \r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n ******************************************************************************/\r\n\r\npackage java.lang;\r\n\r\nimport java.io.IOException;\r\nimport java.nio.CharBuffer;\r\n\r\npublic interface Readable {\r\n\tint read (CharBuffer cb) throws IOException;\r\n}\r\n"
},
{
"path": "src/peergos/gwt/emu/java/lang/Runnable.java",
"content": "package java.lang;\n\nimport jsinterop.annotations.*;\n\n@FunctionalInterface\npublic interface Runnable {\n\n @JsMethod\n void run();\n}"
},
{
"path": "src/peergos/gwt/emu/java/lang/RuntimeException.java",
"content": "/*\n * Copyright 2007 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n * use this file except in compliance with the License. You may obtain a copy of\n * the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */\npackage java.lang;\n\n/**\n * See \n *
\n * limit - 1. Accessing elements out of the scope will cause an exception. Limit may not be negative and not greater\n * than capacity.ReadOnlyBufferException, while changing the position, limit and mark of a read-only buffer is OK.UNSET_MARK means the mark has not been set. */\n\tfinal static int UNSET_MARK = -1;\n\n\t/** The capacity of this buffer, which never change. */\n\tfinal int capacity;\n\n\t/** limit - 1 is the last element that can be read or written. Limit must be no less than zero and no greater than\n\t * capacity. */\n\tint limit;\n\n\t/** Mark is where position will be set when reset() is called. Mark is not set by default. Mark is always no less\n\t * than zero and no greater than position. */\n\tint mark = UNSET_MARK;\n\n\t/** The current position of this buffer. Position is always no less than zero and no greater than limit. */\n\tint position = 0;\n\n\t/** Construct a buffer with the specified capacity.\n\t * \n\t * @param capacity the capacity of this buffer. */\n\tBuffer (int capacity) {\n\t\tsuper();\n\t\tif (capacity < 0) {\n\t\t\tthrow new IllegalArgumentException();\n\t\t}\n\t\tthis.capacity = this.limit = capacity;\n\t}\n\n\t/** Returns the capacity of this buffer.\n\t * \n\t * @return the number of elements that are contained in this buffer.\n\t * @since Android 1.0 */\n\tpublic final int capacity () {\n\t\treturn capacity;\n\t}\n\n\t/** Clears this buffer.\n\t * newLimit then, on returning from this call, it will have\n\t * been adjusted to be equivalent to newLimit. If the mark is set and is greater than the new limit, then it is\n\t * cleared.\n\t * newLimit is invalid.\n\t * @since Android 1.0 */\n\tpublic final Buffer limit (int newLimit) {\n\t\tif (newLimit < 0 || newLimit > capacity) {\n\t\t\tthrow new IllegalArgumentException();\n\t\t}\n\n\t\tlimit = newLimit;\n\t\tif (position > newLimit) {\n\t\t\tposition = newLimit;\n\t\t}\n\t\tif ((mark != UNSET_MARK) && (mark > newLimit)) {\n\t\t\tmark = UNSET_MARK;\n\t\t}\n\t\treturn this;\n\t}\n\n\t/** Marks the current position, so that the position may return to this point later by calling reset().\n\t * \n\t * @return this buffer.\n\t * @since Android 1.0 */\n\tpublic final Buffer mark () {\n\t\tmark = position;\n\t\treturn this;\n\t}\n\n\t/** Returns the position of this buffer.\n\t * \n\t * @return the value of this buffer's current position.\n\t * @since Android 1.0 */\n\tpublic final int position () {\n\t\treturn position;\n\t}\n\n\t/** Sets the position of this buffer.\n\t * newPosition is invalid.\n\t * @since Android 1.0 */\n\tpublic final Buffer position (int newPosition) {\n\t\tif (newPosition < 0 || newPosition > limit) {\n\t\t\tthrow new IllegalArgumentException();\n\t\t}\n\n\t\tposition = newPosition;\n\t\tif ((mark != UNSET_MARK) && (mark > position)) {\n\t\t\tmark = UNSET_MARK;\n\t\t}\n\t\treturn this;\n\t}\n\n\t/** Returns the number of remaining elements in this buffer, that is {@code limit - position}.\n\t * \n\t * @return the number of remaining elements in this buffer.\n\t * @since Android 1.0 */\n\tpublic final int remaining () {\n\t\treturn limit - position;\n\t}\n\n\t/** Resets the position of this buffer to the mark.\n\t * \n\t * @return this buffer.\n\t * @exception InvalidMarkException if the mark is not set.\n\t * @since Android 1.0 */\n\tpublic final Buffer reset () {\n\t\tif (mark == UNSET_MARK) {\n\t\t\tthrow new InvalidMarkException();\n\t\t}\n\t\tposition = mark;\n\t\treturn this;\n\t}\n\n\t/** Rewinds this buffer.\n\t * BufferOverflowException is thrown when elements are written to a buffer but there is not enough remaining space\n * in the buffer.\n * \n * @since Android 1.0 */\npublic class BufferOverflowException extends RuntimeException {\n\n\tprivate static final long serialVersionUID = -5484897634319144535L;\n\n\t/** Constructs a BufferOverflowException.\n\t * \n\t * @since Android 1.0 */\n\tpublic BufferOverflowException () {\n\t\tsuper();\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/nio/CharBuffer.java",
"content": "/*\n * Licensed to the Apache Software Foundation (ASF) under one or more\n * contributor license agreements. See the NOTICE file distributed with\n * this work for additional information regarding copyright ownership.\n * The ASF licenses this file to You under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance with\n * the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage java.nio;\n\n/** A buffer of chars.\n * \n *
\n * \n * @since Android 1.0 */\npublic abstract class CharBuffer extends Buffer implements ComparableAdler32 class.\n * The checksum starts off with a value of 1.\n */\n public Adler32 ()\n {\n reset();\n }\n \n /**\n * Resets the Adler32 checksum to the initial value.\n */\n public void reset ()\n {\n checksum = 1; //Initialize to 1\n }\n \n /**\n * Updates the checksum with the byte b.\n *\n * @param bval the data value to add. The high byte of the int is ignored.\n */\n public void update (int bval)\n {\n //We could make a length 1 byte array and call update again, but I\n //would rather not have that overhead\n int s1 = checksum & 0xffff;\n int s2 = checksum >>> 16;\n \n s1 = (s1 + (bval & 0xFF)) % BASE;\n s2 = (s1 + s2) % BASE;\n \n checksum = (s2 << 16) + s1;\n }\n \n /**\n * Updates the checksum with the bytes taken from the array.\n *\n * @param buffer an array of bytes\n */\n public void update (byte[] buffer)\n {\n update(buffer, 0, buffer.length);\n }\n \n /**\n * Updates the checksum with the bytes taken from the array.\n *\n * @param buf an array of bytes\n * @param off the start of the data used for this update\n * @param len the number of bytes to use for this update\n */\n public void update (byte[] buf, int off, int len)\n {\n //(By Per Bothner)\n int s1 = checksum & 0xffff;\n int s2 = checksum >>> 16;\n \n while (len > 0)\n {\n // We can defer the modulo operation:\n // s1 maximally grows from 65521 to 65521 + 255 * 3800\n // s2 maximally grows by 3800 * median(s1) = 2090079800 < 2^31\n int n = 3800;\n if (n > len)\n n = len;\n len -= n;\n while (--n >= 0)\n {\n s1 = s1 + (buf[off++] & 0xFF);\n s2 = s2 + s1;\n }\n s1 %= BASE;\n s2 %= BASE;\n }\n \n /*Old implementation, borrowed from somewhere:\n int n;\n \n while (len-- > 0) {\n \n s1 = (s1 + (bs[offset++] & 0xff)) % BASE; \n s2 = (s2 + s1) % BASE;\n }*/\n \n checksum = (s2 << 16) | s1;\n }\n \n /**\n * Returns the Adler32 data checksum computed so far.\n */\n public long getValue()\n {\n return (long) checksum & 0xffffffffL;\n }\n }"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/CRC32.java",
"content": " /* CRC32.java - Computes CRC32 data checksum of a data stream\n Copyright (C) 1999. 2000, 2001 Free Software Foundation, Inc.\n \n This file is part of GNU Classpath.\n \n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n \n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n \n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n \n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n \n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n \n package java.util.zip;\n \n /*\n * Written using on-line Java Platform 1.2 API Specification, as well\n * as \"The Java Class Libraries\", 2nd edition (Addison-Wesley, 1998).\n * The actual CRC32 algorithm is taken from RFC 1952.\n * Status: Believed complete and correct.\n */\n \n /**\n * Computes CRC32 data checksum of a data stream.\n * The actual CRC32 algorithm is described in RFC 1952\n * (GZIP file format specification version 4.3).\n * Can be used to get the CRC32 over a stream if used with checked input/output\n * streams.\n *\n * @see InflaterInputStream\n * @see DeflaterOutputStream\n *\n * @author Per Bothner\n * @date April 1, 1999.\n */\n public class CRC32 implements Checksum\n {\n /** The crc data checksum so far. */\n private int crc = 0;\n \n /** The fast CRC table. Computed once when the CRC32 class is loaded. */\n private static int[] crc_table = make_crc_table();\n \n /** Make the table for a fast CRC. */\n private static int[] make_crc_table ()\n {\n int[] crc_table = new int[256];\n for (int n = 0; n < 256; n++)\n {\n int c = n;\n for (int k = 8; --k >= 0; )\n {\n if ((c & 1) != 0)\n c = 0xedb88320 ^ (c >>> 1);\n else\n c = c >>> 1;\n }\n crc_table[n] = c;\n }\n return crc_table;\n }\n \n /**\n * Returns the CRC32 data checksum computed so far.\n */\n public long getValue ()\n {\n return (long) crc & 0xffffffffL;\n }\n \n /**\n * Resets the CRC32 data checksum as if no update was ever called.\n */\n public void reset () { crc = 0; }\n \n /**\n * Updates the checksum with the int bval.\n *\n * @param bval (the byte is taken as the lower 8 bits of bval)\n */\n \n public void update (int bval)\n {\n int c = ~crc;\n c = crc_table[(c ^ bval) & 0xff] ^ (c >>> 8);\n crc = ~c;\n }\n \n /**\n * Adds the byte array to the data checksum.\n *\n * @param buf the buffer which contains the data\n * @param off the offset in the buffer where the data starts\n * @param len the length of the data\n */\n public void update (byte[] buf, int off, int len)\n {\n int c = ~crc;\n while (--len >= 0)\n c = crc_table[(c ^ buf[off++]) & 0xff] ^ (c >>> 8);\n crc = ~c;\n }\n \n /**\n * Adds the complete byte array to the data checksum.\n */\n public void update (byte[] buf) { update(buf, 0, buf.length); }\n }"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/Checksum.java",
"content": " /* Checksum.java - Interface to compute a data checksum\n Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.\n \n This file is part of GNU Classpath.\n \n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n \n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n \n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n \n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n \n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n \n package java.util.zip;\n \n /*\n * Written using on-line Java Platform 1.2 API Specification, as well\n * as \"The Java Class Libraries\", 2nd edition (Addison-Wesley, 1998).\n * St Believed complete and correct.\n */\n \n /**\n * Interface to compute a data checksum used by checked input/output streams.\n * A data checksum can be updated by one byte or with a byte array. After each\n * update the value of the current checksum can be returned by calling\n * getValue. The complete checksum object can also be reset\n * so it can be used again with new data.\n *\n * @see CheckedInputStream\n * @see CheckedOutputStream\n *\n * @author Per Bothner\n * @author Jochen Hoenicke\n */\n public interface Checksum\n {\n /**\n * Returns the data checksum computed so far.\n */\n long getValue();\n \n /**\n * Resets the data checksum as if no update was ever called.\n */\n void reset();\n \n /**\n * Adds one byte to the data checksum.\n *\n * @param bval the data value to add. The high byte of the int is ignored.\n */\n void update (int bval);\n \n /**\n * Adds the byte array to the data checksum.\n *\n * @param buf the buffer which contains the data\n * @param off the offset in the buffer where the data starts\n * @param len the length of the data\n */\n void update (byte[] buf, int off, int len);\n }"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/Deflater.java",
"content": " /* Deflater.java - Compress a data stream\n Copyright (C) 1999, 2000, 2001, 2004, 2005 Free Software Foundation, Inc.\n\n This file is part of GNU Classpath.\n\n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n\n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n\n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n\n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n\n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n\n package java.util.zip;\n\n /**\n * This is the Deflater class. The deflater class compresses input\n * with the deflate algorithm described in RFC 1951. It has several\n * compression levels and three different strategies described below.\n *\n * This class is not thread safe. This is inherent in the API, due\n * to the split of deflate and setInput.\n *\n * @author Jochen Hoenicke\n * @author Tom Tromey\n */\n public class Deflater\n {\n /**\n * The best and slowest compression level. This tries to find very\n * long and distant string repetitions.\n */\n public static final int BEST_COMPRESSION = 9;\n /**\n * The worst but fastest compression level.\n */\n public static final int BEST_SPEED = 1;\n /**\n * The default compression level.\n */\n public static final int DEFAULT_COMPRESSION = -1;\n /**\n * This level won't compress at all but output uncompressed blocks.\n */\n public static final int NO_COMPRESSION = 0;\n\n /**\n * The default strategy.\n */\n public static final int DEFAULT_STRATEGY = 0;\n /**\n * This strategy will only allow longer string repetitions. It is\n * useful for random data with a small character set.\n */\n public static final int FILTERED = 1;\n\n /**\n * This strategy will not look for string repetitions at all. It\n * only encodes with Huffman trees (which means, that more common\n * characters get a smaller encoding.\n */\n public static final int HUFFMAN_ONLY = 2;\n\n /**\n * The compression method. This is the only method supported so far.\n * There is no need to use this constant at all.\n */\n public static final int DEFLATED = 8;\n\n /*\n * The Deflater can do the following state transitions:\n *\n * (1) -> INIT_STATE ----> INIT_FINISHING_STATE ---.\n * / | (2) (5) |\n * / v (5) |\n * (3)| SETDICT_STATE ---> SETDICT_FINISHING_STATE |(3)\n * \\ | (3) | ,-------'\n * | | | (3) /\n * v v (5) v v\n * (1) -> BUSY_STATE ----> FINISHING_STATE\n * | (6)\n * v\n * FINISHED_STATE\n * \\_____________________________________/\n * | (7)\n * v\n * CLOSED_STATE\n *\n * (1) If we should produce a header we start in INIT_STATE, otherwise\n * we start in BUSY_STATE.\n * (2) A dictionary may be set only when we are in INIT_STATE, then\n * we change the state as indicated.\n * (3) Whether a dictionary is set or not, on the first call of deflate\n * we change to BUSY_STATE.\n * (4) -- intentionally left blank -- :)\n * (5) FINISHING_STATE is entered, when flush() is called to indicate that\n * there is no more INPUT. There are also states indicating, that\n * the header wasn't written yet.\n * (6) FINISHED_STATE is entered, when everything has been flushed to the\n * internal pending output buffer.\n * (7) At any time (7)\n *\n */\n\n private static final int IS_SETDICT = 0x01;\n private static final int IS_FLUSHING = 0x04;\n private static final int IS_FINISHING = 0x08;\n\n private static final int INIT_STATE = 0x00;\n private static final int SETDICT_STATE = 0x01;\n private static final int INIT_FINISHING_STATE = 0x08;\n private static final int SETDICT_FINISHING_STATE = 0x09;\n private static final int BUSY_STATE = 0x10;\n private static final int FLUSHING_STATE = 0x14;\n private static final int FINISHING_STATE = 0x1c;\n private static final int FINISHED_STATE = 0x1e;\n private static final int CLOSED_STATE = 0x7f;\n\n /** Compression level. */\n private int level;\n\n /** should we include a header. */\n private boolean noHeader;\n\n /** The current state. */\n private int state;\n\n /** The total bytes of output written. */\n private long totalOut;\n\n /** The pending output. */\n private DeflaterPending pending;\n\n /** The deflater engine. */\n private DeflaterEngine engine;\n\n /**\n * Creates a new deflater with default compression level.\n */\n public Deflater()\n {\n this(DEFAULT_COMPRESSION, false);\n }\n\n /**\n * Creates a new deflater with given compression level.\n * @param lvl the compression level, a value between NO_COMPRESSION\n * and BEST_COMPRESSION, or DEFAULT_COMPRESSION.\n * @exception IllegalArgumentException if lvl is out of range.\n */\n public Deflater(int lvl)\n {\n this(lvl, false);\n }\n\n /**\n * Creates a new deflater with given compression level.\n * @param lvl the compression level, a value between NO_COMPRESSION\n * and BEST_COMPRESSION.\n * @param nowrap true, iff we should suppress the deflate header at the\n * beginning and the adler checksum at the end of the output. This is\n * useful for the GZIP format.\n * @exception IllegalArgumentException if lvl is out of range.\n */\n public Deflater(int lvl, boolean nowrap)\n {\n if (lvl == DEFAULT_COMPRESSION)\n lvl = 6;\n else if (lvl < NO_COMPRESSION || lvl > BEST_COMPRESSION)\n throw new IllegalArgumentException();\n\n pending = new DeflaterPending();\n engine = new DeflaterEngine(pending);\n this.noHeader = nowrap;\n setStrategy(DEFAULT_STRATEGY);\n setLevel(lvl);\n reset();\n }\n\n /**\n * Resets the deflater. The deflater acts afterwards as if it was\n * just created with the same compression level and strategy as it\n * had before.\n */\n public void reset()\n {\n state = (noHeader ? BUSY_STATE : INIT_STATE);\n totalOut = 0;\n pending.reset();\n engine.reset();\n }\n\n /**\n * Frees all objects allocated by the compressor. There's no\n * reason to call this, since you can just rely on garbage\n * collection. Exists only for compatibility against Sun's JDK,\n * where the compressor allocates native memory.\n * If you call any method (even reset) afterwards the behaviour is\n * undefined.\n */\n public void end()\n {\n engine = null;\n pending = null;\n state = CLOSED_STATE;\n }\n\n /**\n * Gets the current adler checksum of the data that was processed so\n * far.\n */\n public int getAdler()\n {\n return engine.getAdler();\n }\n\n /**\n * Gets the number of input bytes processed so far.\n */\n @Deprecated\n public int getTotalIn()\n {\n return (int) engine.getTotalIn();\n }\n\n /**\n * Gets the number of input bytes processed so far.\n * @since 1.5\n */\n public long getBytesRead()\n {\n return engine.getTotalIn();\n }\n\n /**\n * Gets the number of output bytes so far.\n */\n @Deprecated\n public int getTotalOut()\n {\n return (int) totalOut;\n }\n\n /**\n * Gets the number of output bytes so far.\n * @since 1.5\n */\n public long getBytesWritten()\n {\n return totalOut;\n }\n\n /**\n * Finalizes this object.\n */\n protected void finalize()\n {\n /* Exists solely for compatibility. We don't have any native state. */\n }\n\n /**\n * Flushes the current input block. Further calls to deflate() will\n * produce enough output to inflate everything in the current input\n * block. This is not part of Sun's JDK so I have made it package\n * private. It is used by DeflaterOutputStream to implement\n * flush().\n */\n void flush() {\n state |= IS_FLUSHING;\n }\n\n /**\n * Finishes the deflater with the current input block. It is an error\n * to give more input after this method was called. This method must\n * be called to force all bytes to be flushed.\n */\n public void finish() {\n state |= IS_FLUSHING | IS_FINISHING;\n }\n\n /**\n * Returns true iff the stream was finished and no more output bytes\n * are available.\n */\n public boolean finished()\n {\n return state == FINISHED_STATE && pending.isFlushed();\n }\n\n /**\n * Returns true, if the input buffer is empty.\n * You should then call setInput().
\n *\n * NOTE: This method can also return true when the stream\n * was finished.\n */\n public boolean needsInput()\n {\n return engine.needsInput();\n }\n\n /**\n * Sets the data which should be compressed next. This should be only\n * called when needsInput indicates that more input is needed.\n * If you call setInput when needsInput() returns false, the\n * previous input that is still pending will be thrown away.\n * The given byte array should not be changed, before needsInput() returns\n * true again.\n * This call is equivalent to setInput(input, 0, input.length).\n * @param input the buffer containing the input data.\n * @exception IllegalStateException if the buffer was finished() or ended().\n */\n public void setInput(byte[] input)\n {\n setInput(input, 0, input.length);\n }\n\n /**\n * Sets the data which should be compressed next. This should be\n * only called when needsInput indicates that more input is needed.\n * The given byte array should not be changed, before needsInput() returns\n * true again.\n * @param input the buffer containing the input data.\n * @param off the start of the data.\n * @param len the length of the data.\n * @exception IllegalStateException if the buffer was finished() or ended()\n * or if previous input is still pending.\n */\n public void setInput(byte[] input, int off, int len)\n {\n if ((state & IS_FINISHING) != 0)\n throw new IllegalStateException(\"finish()/end() already called\");\n engine.setInput(input, off, len);\n }\n\n /**\n * Sets the compression level. There is no guarantee of the exact\n * position of the change, but if you call this when needsInput is\n * true the change of compression level will occur somewhere near\n * before the end of the so far given input.\n * @param lvl the new compression level.\n */\n public void setLevel(int lvl)\n {\n if (lvl == DEFAULT_COMPRESSION)\n lvl = 6;\n else if (lvl < NO_COMPRESSION || lvl > BEST_COMPRESSION)\n throw new IllegalArgumentException();\n\n\n if (level != lvl)\n {\n level = lvl;\n engine.setLevel(lvl);\n }\n }\n\n /**\n * Sets the compression strategy. Strategy is one of\n * DEFAULT_STRATEGY, HUFFMAN_ONLY and FILTERED. For the exact\n * position where the strategy is changed, the same as for\n * setLevel() applies.\n * @param stgy the new compression strategy.\n */\n public void setStrategy(int stgy)\n {\n if (stgy != DEFAULT_STRATEGY && stgy != FILTERED\n && stgy != HUFFMAN_ONLY)\n throw new IllegalArgumentException();\n engine.setStrategy(stgy);\n }\n\n /**\n * Deflates the current input block to the given array. It returns\n * the number of bytes compressed, or 0 if either\n * needsInput() or finished() returns true or length is zero.\n * @param output the buffer where to write the compressed data.\n */\n public int deflate(byte[] output)\n {\n return deflate(output, 0, output.length);\n }\n\n /**\n * Deflates the current input block to the given array. It returns\n * the number of bytes compressed, or 0 if either\n * needsInput() or finished() returns true or length is zero.\n * @param output the buffer where to write the compressed data.\n * @param offset the offset into the output array.\n * @param length the maximum number of bytes that may be written.\n * @exception IllegalStateException if end() was called.\n * @exception IndexOutOfBoundsException if offset and/or length\n * don't match the array length.\n */\n public int deflate(byte[] output, int offset, int length)\n {\n int origLength = length;\n\n if (state == CLOSED_STATE)\n throw new IllegalStateException(\"Deflater closed\");\n\n if (state < BUSY_STATE)\n {\n /* output header */\n int header = (DEFLATED +\n ((DeflaterConstants.MAX_WBITS - 8) << 4)) << 8;\n int level_flags = (level - 1) >> 1;\n if (level_flags < 0 || level_flags > 3)\n level_flags = 3;\n header |= level_flags << 6;\n if ((state & IS_SETDICT) != 0)\n /* Dictionary was set */\n header |= DeflaterConstants.PRESET_DICT;\n header += 31 - (header % 31);\n\n pending.writeShortMSB(header);\n if ((state & IS_SETDICT) != 0)\n {\n int chksum = engine.getAdler();\n engine.resetAdler();\n pending.writeShortMSB(chksum >> 16);\n pending.writeShortMSB(chksum & 0xffff);\n }\n\n state = BUSY_STATE | (state & (IS_FLUSHING | IS_FINISHING));\n }\n\n for (;;)\n {\n int count = pending.flush(output, offset, length);\n offset += count;\n totalOut += count;\n length -= count;\n if (length == 0 || state == FINISHED_STATE)\n break;\n\n if (!engine.deflate((state & IS_FLUSHING) != 0,\n (state & IS_FINISHING) != 0))\n {\n if (state == BUSY_STATE)\n /* We need more input now */\n return origLength - length;\n else if (state == FLUSHING_STATE)\n {\n if (level != NO_COMPRESSION)\n {\n /* We have to supply some lookahead. 8 bit lookahead\n * are needed by the zlib inflater, and we must fill\n * the next byte, so that all bits are flushed.\n */\n int neededbits = 8 + ((-pending.getBitCount()) & 7);\n while (neededbits > 0)\n {\n /* write a static tree block consisting solely of\n * an EOF:\n */\n pending.writeBits(2, 10);\n neededbits -= 10;\n }\n }\n state = BUSY_STATE;\n }\n else if (state == FINISHING_STATE)\n {\n pending.alignToByte();\n /* We have completed the stream */\n if (!noHeader)\n {\n int adler = engine.getAdler();\n pending.writeShortMSB(adler >> 16);\n pending.writeShortMSB(adler & 0xffff);\n }\n state = FINISHED_STATE;\n }\n }\n }\n\n return origLength - length;\n }\n\n /**\n * Sets the dictionary which should be used in the deflate process.\n * This call is equivalent to setDictionary(dict, 0,\n * dict.length).\n * @param dict the dictionary.\n * @exception IllegalStateException if setInput () or deflate ()\n * were already called or another dictionary was already set.\n */\n public void setDictionary(byte[] dict)\n {\n setDictionary(dict, 0, dict.length);\n }\n\n /**\n * Sets the dictionary which should be used in the deflate process.\n * The dictionary should be a byte array containing strings that are\n * likely to occur in the data which should be compressed. The\n * dictionary is not stored in the compressed output, only a\n * checksum. To decompress the output you need to supply the same\n * dictionary again.\n * @param dict the dictionary.\n * @param offset an offset into the dictionary.\n * @param length the length of the dictionary.\n * @exception IllegalStateException if setInput () or deflate () were\n * already called or another dictionary was already set.\n */\n public void setDictionary(byte[] dict, int offset, int length)\n {\n if (state != INIT_STATE)\n throw new IllegalStateException();\n\n state = SETDICT_STATE;\n engine.setDictionary(dict, offset, length);\n }\n }"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/DeflaterConstants.java",
"content": " /* java.util.zip.DeflaterConstants\n Copyright (C) 2001 Free Software Foundation, Inc.\n \n This file is part of GNU Classpath.\n \n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n \n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n \n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n \n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n \n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n\npackage java.util.zip;\n \ninterface DeflaterConstants\n{\n boolean DEBUGGING = false;\n \n int STORED_BLOCK = 0;\n int STATIC_TREES = 1;\n int DYN_TREES = 2;\n int PRESET_DICT = 0x20;\n \n int DEFAULT_MEM_LEVEL = 8;\n \n int MAX_MATCH = 258;\n int MIN_MATCH = 3;\n \n int MAX_WBITS = 15;\n int WSIZE = 1 << MAX_WBITS;\n int WMASK = WSIZE - 1;\n \n int HASH_BITS = DEFAULT_MEM_LEVEL + 7;\n int HASH_SIZE = 1 << HASH_BITS;\n int HASH_MASK = HASH_SIZE - 1;\n int HASH_SHIFT = (HASH_BITS + MIN_MATCH - 1) / MIN_MATCH;\n \n int MIN_LOOKAHEAD = MAX_MATCH + MIN_MATCH + 1;\n int MAX_DIST = WSIZE - MIN_LOOKAHEAD;\n \n int PENDING_BUF_SIZE = 1 << (DEFAULT_MEM_LEVEL + 8);\n int MAX_BLOCK_SIZE = Math.min(65535, PENDING_BUF_SIZE-5);\n \n int DEFLATE_STORED = 0;\n int DEFLATE_FAST = 1;\n int DEFLATE_SLOW = 2;\n \n int GOOD_LENGTH[] = { 0,4, 4, 4, 4, 8, 8, 8, 32, 32 };\n int MAX_LAZY[] = { 0,4, 5, 6, 4,16, 16, 32, 128, 258 };\n int NICE_LENGTH[] = { 0,8,16,32,16,32,128,128, 258, 258 };\n int MAX_CHAIN[] = { 0,4, 8,32,16,32,128,256,1024,4096 };\n int COMPR_FUNC[] = { 0,1, 1, 1, 1, 2, 2, 2, 2, 2 };\n}"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/DeflaterEngine.java",
"content": " /* DeflaterEngine.java --\n Copyright (C) 2001, 2004 Free Software Foundation, Inc.\n \n This file is part of GNU Classpath.\n \n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n \n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n \n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n \n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n \n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n\npackage java.util.zip;\n \nclass DeflaterEngine implements DeflaterConstants\n{\n private static final int TOO_FAR = 4096;\n \n private int ins_h;\n \n /**\n * Hashtable, hashing three characters to an index for window, so\n * that window[index]..window[index+2] have this hash code.\n * Note that the array should really be unsigned short, so you need\n * to and the values with 0xffff.\n */\n private short[] head;\n \n /**\n * prev[index & WMASK] points to the previous index that has the\n * same hash code as the string starting at index. This way\n * entries with the same hash code are in a linked list.\n * Note that the array should really be unsigned short, so you need\n * to and the values with 0xffff.\n */\n private short[] prev;\n \n private int matchStart, matchLen;\n private boolean prevAvailable;\n private int blockStart;\n \n /**\n * strstart points to the current character in window.\n */\n private int strstart;\n \n /**\n * lookahead is the number of characters starting at strstart in\n * window that are valid.\n * So window[strstart] until window[strstart+lookahead-1] are valid\n * characters.\n */\n private int lookahead;\n \n /**\n * This array contains the part of the uncompressed stream that\n * is of relevance. The current character is indexed by strstart.\n */\n private byte[] window;\n \n private int strategy, max_chain, max_lazy, niceLength, goodLength;\n \n /** The current compression function. */\n private int comprFunc;\n \n /** The input data for compression. */\n private byte[] inputBuf;\n \n /** The total bytes of input read. */\n private int totalIn;\n \n /** The offset into inputBuf, where input data starts. */\n private int inputOff;\n \n /** The end offset of the input data. */\n private int inputEnd;\n \n private DeflaterPending pending;\n private DeflaterHuffman huffman;\n \n /** The adler checksum */\n private Adler32 adler;\n \n /* DEFLATE ALGORITHM:\n *\n * The uncompressed stream is inserted into the window array. When\n * the window array is full the first half is thrown away and the\n * second half is copied to the beginning.\n *\n * The head array is a hash table. Three characters build a hash value\n * and they the value points to the corresponding index in window of \n * the last string with this hash. The prev array implements a\n * linked list of matches with the same hash: prev[index & WMASK] points\n * to the previous index with the same hash.\n * \n * \n */\n \n \n DeflaterEngine(DeflaterPending pending) {\n this.pending = pending;\n huffman = new DeflaterHuffman(pending);\n adler = new Adler32();\n \n window = new byte[2*WSIZE];\n head = new short[HASH_SIZE];\n prev = new short[WSIZE];\n \n /* We start at index 1, to avoid a implementation deficiency, that\n * we cannot build a repeat pattern at index 0.\n */\n blockStart = strstart = 1;\n }\n \n public void reset()\n {\n huffman.reset();\n adler.reset();\n blockStart = strstart = 1;\n lookahead = 0;\n totalIn = 0;\n prevAvailable = false;\n matchLen = MIN_MATCH - 1;\n for (int i = 0; i < HASH_SIZE; i++)\n head[i] = 0;\n for (int i = 0; i < WSIZE; i++)\n prev[i] = 0;\n }\n \n public final void resetAdler()\n {\n adler.reset();\n }\n \n public final int getAdler()\n {\n int chksum = (int) adler.getValue();\n return chksum;\n }\n \n public final int getTotalIn()\n {\n return totalIn;\n }\n \n public final void setStrategy(int strat)\n {\n strategy = strat;\n }\n \n public void setLevel(int lvl)\n {\n goodLength = DeflaterConstants.GOOD_LENGTH[lvl];\n max_lazy = DeflaterConstants.MAX_LAZY[lvl];\n niceLength = DeflaterConstants.NICE_LENGTH[lvl];\n max_chain = DeflaterConstants.MAX_CHAIN[lvl];\n \n if (DeflaterConstants.COMPR_FUNC[lvl] != comprFunc)\n {\n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"Change from \"+comprFunc +\" to \"\n + DeflaterConstants.COMPR_FUNC[lvl]);\n switch (comprFunc)\n {\n case DEFLATE_STORED:\n if (strstart > blockStart)\n {\n huffman.flushStoredBlock(window, blockStart,\n strstart - blockStart, false);\n blockStart = strstart;\n }\n updateHash();\n break;\n case DEFLATE_FAST:\n if (strstart > blockStart)\n {\n huffman.flushBlock(window, blockStart, strstart - blockStart,\n false);\n blockStart = strstart;\n }\n break;\n case DEFLATE_SLOW:\n if (prevAvailable)\n huffman.tallyLit(window[strstart-1] & 0xff);\n if (strstart > blockStart)\n {\n huffman.flushBlock(window, blockStart, strstart - blockStart,\n false);\n blockStart = strstart;\n }\n prevAvailable = false;\n matchLen = MIN_MATCH - 1;\n break;\n }\n comprFunc = COMPR_FUNC[lvl];\n }\n }\n \n private void updateHash() {\n if (DEBUGGING)\n System.err.println(\"updateHash: \"+strstart);\n ins_h = (window[strstart] << HASH_SHIFT) ^ window[strstart + 1];\n }\n \n /**\n * Inserts the current string in the head hash and returns the previous\n * value for this hash.\n */\n private int insertString() {\n short match;\n int hash = ((ins_h << HASH_SHIFT) ^ window[strstart + (MIN_MATCH -1)])\n & HASH_MASK;\n \n if (DEBUGGING)\n {\n if (hash != (((window[strstart] << (2*HASH_SHIFT))\n ^ (window[strstart + 1] << HASH_SHIFT)\n ^ (window[strstart + 2])) & HASH_MASK))\n throw new InternalError(\"hash inconsistent: \"+hash+\"/\"\n +window[strstart]+\",\"\n +window[strstart+1]+\",\"\n +window[strstart+2]+\",\"+HASH_SHIFT);\n }\n \n prev[strstart & WMASK] = match = head[hash];\n head[hash] = (short) strstart;\n ins_h = hash;\n return match & 0xffff;\n }\n \n private void slideWindow()\n {\n System.arraycopy(window, WSIZE, window, 0, WSIZE);\n matchStart -= WSIZE;\n strstart -= WSIZE;\n blockStart -= WSIZE;\n \n /* Slide the hash table (could be avoided with 32 bit values\n * at the expense of memory usage).\n */\n for (int i = 0; i < HASH_SIZE; i++)\n {\n int m = head[i] & 0xffff;\n head[i] = m >= WSIZE ? (short) (m - WSIZE) : 0;\n }\n \n /* Slide the prev table.\n */\n for (int i = 0; i < WSIZE; i++)\n {\n int m = prev[i] & 0xffff;\n prev[i] = m >= WSIZE ? (short) (m - WSIZE) : 0;\n }\n }\n \n /**\n * Fill the window when the lookahead becomes insufficient.\n * Updates strstart and lookahead.\n *\n * OUT assertions: strstart + lookahead <= 2*WSIZE\n * lookahead >= MIN_LOOKAHEAD or inputOff == inputEnd\n */\n private void fillWindow()\n {\n /* If the window is almost full and there is insufficient lookahead,\n * move the upper half to the lower one to make room in the upper half.\n */\n if (strstart >= WSIZE + MAX_DIST)\n slideWindow();\n \n /* If there is not enough lookahead, but still some input left,\n * read in the input\n */\n while (lookahead < DeflaterConstants.MIN_LOOKAHEAD && inputOff < inputEnd)\n {\n int more = 2*WSIZE - lookahead - strstart;\n \t\n if (more > inputEnd - inputOff)\n more = inputEnd - inputOff;\n \n System.arraycopy(inputBuf, inputOff,\n window, strstart + lookahead, more);\n adler.update(inputBuf, inputOff, more);\n inputOff += more;\n totalIn += more;\n lookahead += more;\n }\n \n if (lookahead >= MIN_MATCH)\n updateHash();\n }\n \n /**\n * Find the best (longest) string in the window matching the\n * string starting at strstart.\n *\n * Preconditions:\n * strstart + MAX_MATCH <= window.length.\n *\n *\n * @param curMatch\n */\n private boolean findLongestMatch(int curMatch) {\n int chainLength = this.max_chain;\n int niceLength = this.niceLength;\n short[] prev = this.prev;\n int scan = this.strstart;\n int match;\n int best_end = this.strstart + matchLen;\n int best_len = Math.max(matchLen, MIN_MATCH - 1);\n \n int limit = Math.max(strstart - MAX_DIST, 0);\n \n int strend = scan + MAX_MATCH - 1;\n byte scan_end1 = window[best_end - 1];\n byte scan_end = window[best_end];\n \n /* Do not waste too much time if we already have a good match: */\n if (best_len >= this.goodLength)\n chainLength >>= 2;\n \n /* Do not look for matches beyond the end of the input. This is necessary\n * to make deflate deterministic.\n */\n if (niceLength > lookahead)\n niceLength = lookahead;\n \n if (DeflaterConstants.DEBUGGING\n && strstart > 2*WSIZE - MIN_LOOKAHEAD)\n throw new InternalError(\"need lookahead\");\n \n do {\n if (DeflaterConstants.DEBUGGING && curMatch >= strstart)\n throw new InternalError(\"future match\");\n if (window[curMatch + best_len] != scan_end\n || window[curMatch + best_len - 1] != scan_end1\n || window[curMatch] != window[scan]\n || window[curMatch+1] != window[scan + 1])\n continue;\n \n match = curMatch + 2;\n scan += 2;\n \n /* We check for insufficient lookahead only every 8th comparison;\n * the 256th check will be made at strstart+258.\n */\n while (window[++scan] == window[++match]\n && window[++scan] == window[++match]\n && window[++scan] == window[++match]\n && window[++scan] == window[++match]\n && window[++scan] == window[++match]\n && window[++scan] == window[++match]\n && window[++scan] == window[++match]\n && window[++scan] == window[++match]\n && scan < strend);\n \n if (scan > best_end) {\n // \tif (DeflaterConstants.DEBUGGING && ins_h == 0)\n // \t System.err.println(\"Found match: \"+curMatch+\"-\"+(scan-strstart));\n matchStart = curMatch;\n best_end = scan;\n best_len = scan - strstart;\n if (best_len >= niceLength)\n break;\n \n scan_end1 = window[best_end-1];\n scan_end = window[best_end];\n }\n scan = strstart;\n } while ((curMatch = (prev[curMatch & WMASK] & 0xffff)) > limit\n && --chainLength != 0);\n \n matchLen = Math.min(best_len, lookahead);\n return matchLen >= MIN_MATCH;\n }\n \n void setDictionary(byte[] buffer, int offset, int length) {\n if (DeflaterConstants.DEBUGGING && strstart != 1)\n throw new IllegalStateException(\"strstart not 1\");\n adler.update(buffer, offset, length);\n if (length < MIN_MATCH)\n return;\n if (length > MAX_DIST) {\n offset += length - MAX_DIST;\n length = MAX_DIST;\n }\n \n System.arraycopy(buffer, offset, window, strstart, length);\n \n updateHash();\n length--;\n while (--length > 0)\n {\n insertString();\n strstart++;\n }\n strstart += 2;\n blockStart = strstart;\n }\n \n private boolean deflateStored(boolean flush, boolean finish)\n {\n if (!flush && lookahead == 0)\n return false;\n \n strstart += lookahead;\n lookahead = 0;\n \n int storedLen = strstart - blockStart;\n \n if ((storedLen >= DeflaterConstants.MAX_BLOCK_SIZE)\n /* Block is full */\n || (blockStart < WSIZE && storedLen >= MAX_DIST)\n /* Block may move out of window */\n || flush)\n {\n boolean lastBlock = finish;\n if (storedLen > DeflaterConstants.MAX_BLOCK_SIZE)\n {\n storedLen = DeflaterConstants.MAX_BLOCK_SIZE;\n lastBlock = false;\n }\n \n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"storedBlock[\"+storedLen+\",\"+lastBlock+\"]\");\n \n huffman.flushStoredBlock(window, blockStart, storedLen, lastBlock);\n blockStart += storedLen;\n return !lastBlock;\n }\n return true;\n }\n \n private boolean deflateFast(boolean flush, boolean finish)\n {\n if (lookahead < MIN_LOOKAHEAD && !flush)\n return false;\n \n while (lookahead >= MIN_LOOKAHEAD || flush)\n {\n if (lookahead == 0)\n {\n /* We are flushing everything */\n huffman.flushBlock(window, blockStart, strstart - blockStart,\n finish);\n blockStart = strstart;\n return false;\n }\n \n if (strstart > 2 * WSIZE - MIN_LOOKAHEAD)\n {\n /* slide window, as findLongestMatch need this.\n \t * This should only happen when flushing and the window\n \t * is almost full.\n \t */\n slideWindow();\n }\n \n int hashHead;\n if (lookahead >= MIN_MATCH\n && (hashHead = insertString()) != 0\n && strategy != Deflater.HUFFMAN_ONLY\n && strstart - hashHead <= MAX_DIST\n && findLongestMatch(hashHead))\n {\n /* longestMatch sets matchStart and matchLen */\n if (DeflaterConstants.DEBUGGING)\n {\n for (int i = 0 ; i < matchLen; i++)\n {\n if (window[strstart+i] != window[matchStart + i])\n throw new InternalError();\n }\n }\n boolean full = huffman.tallyDist(strstart - matchStart, matchLen);\n \t \n lookahead -= matchLen;\n if (matchLen <= max_lazy && lookahead >= MIN_MATCH)\n {\n while (--matchLen > 0)\n {\n strstart++;\n insertString();\n }\n strstart++;\n }\n else\n {\n strstart += matchLen;\n if (lookahead >= MIN_MATCH - 1)\n updateHash();\n }\n matchLen = MIN_MATCH - 1;\n if (!full)\n continue;\n }\n else\n {\n /* No match found */\n huffman.tallyLit(window[strstart] & 0xff);\n strstart++;\n lookahead--;\n }\n \n if (huffman.isFull())\n {\n boolean lastBlock = finish && lookahead == 0;\n huffman.flushBlock(window, blockStart, strstart - blockStart,\n lastBlock);\n blockStart = strstart;\n return !lastBlock;\n }\n }\n return true;\n }\n \n private boolean deflateSlow(boolean flush, boolean finish)\n {\n if (lookahead < MIN_LOOKAHEAD && !flush)\n return false;\n \n while (lookahead >= MIN_LOOKAHEAD || flush)\n {\n if (lookahead == 0)\n {\n if (prevAvailable)\n huffman.tallyLit(window[strstart-1] & 0xff);\n prevAvailable = false;\n \n /* We are flushing everything */\n if (DeflaterConstants.DEBUGGING && !flush)\n throw new InternalError(\"Not flushing, but no lookahead\");\n huffman.flushBlock(window, blockStart, strstart - blockStart,\n finish);\n blockStart = strstart;\n return false;\n }\n \n if (strstart >= 2 * WSIZE - MIN_LOOKAHEAD)\n {\n /* slide window, as findLongestMatch need this.\n \t * This should only happen when flushing and the window\n \t * is almost full.\n \t */\n slideWindow();\n }\n \n int prevMatch = matchStart;\n int prevLen = matchLen;\n if (lookahead >= MIN_MATCH)\n {\n int hashHead = insertString();\n if (strategy != Deflater.HUFFMAN_ONLY\n && hashHead != 0 && strstart - hashHead <= MAX_DIST\n && findLongestMatch(hashHead))\n {\n /* longestMatch sets matchStart and matchLen */\n \t\t\n /* Discard match if too small and too far away */\n if (matchLen <= 5\n && (strategy == Deflater.FILTERED\n || (matchLen == MIN_MATCH\n && strstart - matchStart > TOO_FAR))) {\n matchLen = MIN_MATCH - 1;\n }\n }\n }\n \t\n /* previous match was better */\n if (prevLen >= MIN_MATCH && matchLen <= prevLen)\n {\n if (DeflaterConstants.DEBUGGING)\n {\n for (int i = 0 ; i < matchLen; i++)\n {\n if (window[strstart-1+i] != window[prevMatch + i])\n throw new InternalError();\n }\n }\n huffman.tallyDist(strstart - 1 - prevMatch, prevLen);\n prevLen -= 2;\n do\n {\n strstart++;\n lookahead--;\n if (lookahead >= MIN_MATCH)\n insertString();\n }\n while (--prevLen > 0);\n strstart ++;\n lookahead--;\n prevAvailable = false;\n matchLen = MIN_MATCH - 1;\n }\n else\n {\n if (prevAvailable)\n huffman.tallyLit(window[strstart-1] & 0xff);\n prevAvailable = true;\n strstart++;\n lookahead--;\n }\n \n if (huffman.isFull())\n {\n int len = strstart - blockStart;\n if (prevAvailable)\n len--;\n boolean lastBlock = (finish && lookahead == 0 && !prevAvailable);\n huffman.flushBlock(window, blockStart, len, lastBlock);\n blockStart += len;\n return !lastBlock;\n }\n }\n return true;\n }\n \n public boolean deflate(boolean flush, boolean finish)\n {\n boolean progress;\n do\n {\n fillWindow();\n boolean canFlush = flush && inputOff == inputEnd;\n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"window: [\"+blockStart+\",\"+strstart+\",\"\n +lookahead+\"], \"+comprFunc+\",\"+canFlush);\n switch (comprFunc)\n {\n case DEFLATE_STORED:\n progress = deflateStored(canFlush, finish);\n break;\n case DEFLATE_FAST:\n progress = deflateFast(canFlush, finish);\n break;\n case DEFLATE_SLOW:\n progress = deflateSlow(canFlush, finish);\n break;\n default:\n throw new InternalError();\n }\n }\n while (pending.isFlushed() /* repeat while we have no pending output */\n && progress); /* and progress was made */\n \n return progress;\n }\n \n public void setInput(byte[] buf, int off, int len)\n {\n if (inputOff < inputEnd)\n throw new IllegalStateException\n (\"Old input was not completely processed\");\n \n int end = off + len;\n \n /* We want to throw an ArrayIndexOutOfBoundsException early. The\n * check is very tricky: it also handles integer wrap around. \n */\n if (0 > off || off > end || end > buf.length)\n throw new ArrayIndexOutOfBoundsException();\n \n inputBuf = buf;\n inputOff = off;\n inputEnd = end;\n }\n \n public final boolean needsInput()\n {\n return inputEnd == inputOff;\n }\n}"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/DeflaterHuffman.java",
"content": "/* DeflaterHuffman.java --\n Copyright (C) 2001, 2004, 2005 Free Software Foundation, Inc.\n \n This file is part of GNU Classpath.\n \n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n \n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n \n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n \n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n \n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n \npackage java.util.zip;\n \n/**\n * This is the DeflaterHuffman class.\n *\n * This class is not thread safe. This is inherent in the API, due\n * to the split of deflate and setInput.\n *\n * @author Jochen Hoenicke\n * @date Jan 6, 2000\n */\nclass DeflaterHuffman\n{\n private static final int BUFSIZE = 1 << (DeflaterConstants.DEFAULT_MEM_LEVEL + 6);\n private static final int LITERAL_NUM = 286;\n private static final int DIST_NUM = 30;\n private static final int BITLEN_NUM = 19;\n private static final int REP_3_6 = 16;\n private static final int REP_3_10 = 17;\n private static final int REP_11_138 = 18;\n private static final int EOF_SYMBOL = 256;\n private static final int[] BL_ORDER =\n { 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 };\n \n private static final String bit4Reverse =\n \"\\000\\010\\004\\014\\002\\012\\006\\016\\001\\011\\005\\015\\003\\013\\007\\017\";\n \n class Tree {\n short[] freqs;\n short[] codes;\n byte[] length;\n int[] bl_counts;\n int minNumCodes, numCodes;\n int maxLength;\n \n Tree(int elems, int minCodes, int maxLength) {\n this.minNumCodes = minCodes;\n this.maxLength = maxLength;\n freqs = new short[elems];\n bl_counts = new int[maxLength];\n }\n \n void reset() {\n for (int i = 0; i < freqs.length; i++)\n freqs[i] = 0;\n codes = null;\n length = null;\n }\n \n final void writeSymbol(int code)\n {\n if (DeflaterConstants.DEBUGGING)\n {\n freqs[code]--;\n // \t System.err.print(\"writeSymbol(\"+freqs.length+\",\"+code+\"): \");\n }\n pending.writeBits(codes[code] & 0xffff, length[code]);\n }\n \n final void checkEmpty()\n {\n boolean empty = true;\n for (int i = 0; i < freqs.length; i++)\n if (freqs[i] != 0)\n {\n System.err.println(\"freqs[\"+i+\"] == \"+freqs[i]);\n empty = false;\n }\n if (!empty)\n throw new InternalError();\n System.err.println(\"checkEmpty suceeded!\");\n }\n \n void setStaticCodes(short[] stCodes, byte[] stLength)\n {\n codes = stCodes;\n length = stLength;\n }\n \n public void buildCodes() {\n int[] nextCode = new int[maxLength];\n int code = 0;\n codes = new short[freqs.length];\n \n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"buildCodes: \"+freqs.length);\n for (int bits = 0; bits < maxLength; bits++)\n {\n nextCode[bits] = code;\n code += bl_counts[bits] << (15 - bits);\n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"bits: \"+(bits+1)+\" count: \"+bl_counts[bits]\n +\" nextCode: \"+Integer.toHexString(code));\n }\n if (DeflaterConstants.DEBUGGING && code != 65536)\n throw new RuntimeException(\"Inconsistent bl_counts!\");\n \n for (int i=0; i < numCodes; i++)\n {\n int bits = length[i];\n if (bits > 0)\n {\n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"codes[\"+i+\"] = rev(\"\n +Integer.toHexString(nextCode[bits-1])+\"),\"\n +bits);\n codes[i] = bitReverse(nextCode[bits-1]);\n nextCode[bits-1] += 1 << (16 - bits);\n }\n }\n }\n \n private void buildLength(int childs[])\n {\n this.length = new byte [freqs.length];\n int numNodes = childs.length / 2;\n int numLeafs = (numNodes + 1) / 2;\n int overflow = 0;\n \n for (int i = 0; i < maxLength; i++)\n bl_counts[i] = 0;\n \n /* First calculate optimal bit lengths */\n int lengths[] = new int[numNodes];\n lengths[numNodes-1] = 0;\n for (int i = numNodes - 1; i >= 0; i--)\n {\n if (childs[2*i+1] != -1)\n {\n int bitLength = lengths[i] + 1;\n if (bitLength > maxLength)\n {\n bitLength = maxLength;\n overflow++;\n }\n lengths[childs[2*i]] = lengths[childs[2*i+1]] = bitLength;\n }\n else\n {\n /* A leaf node */\n int bitLength = lengths[i];\n bl_counts[bitLength - 1]++;\n this.length[childs[2*i]] = (byte) lengths[i];\n }\n }\n \n if (DeflaterConstants.DEBUGGING)\n {\n System.err.println(\"Tree \"+freqs.length+\" lengths:\");\n for (int i=0; i < numLeafs; i++)\n System.err.println(\"Node \"+childs[2*i]+\" freq: \"+freqs[childs[2*i]]\n + \" len: \"+length[childs[2*i]]);\n }\n \n if (overflow == 0)\n return;\n \n int incrBitLen = maxLength - 1;\n do\n {\n /* Find the first bit length which could increase: */\n while (bl_counts[--incrBitLen] == 0)\n ;\n \t \n /* Move this node one down and remove a corresponding\n \t * amount of overflow nodes.\n \t */\n do\n {\n bl_counts[incrBitLen]--;\n bl_counts[++incrBitLen]++;\n overflow -= 1 << (maxLength - 1 - incrBitLen);\n }\n while (overflow > 0 && incrBitLen < maxLength - 1);\n }\n while (overflow > 0);\n \n /* We may have overshot above. Move some nodes from maxLength to\n * maxLength-1 in that case.\n */\n bl_counts[maxLength-1] += overflow;\n bl_counts[maxLength-2] -= overflow;\n \n /* Now recompute all bit lengths, scanning in increasing\n * frequency. It is simpler to reconstruct all lengths instead of\n * fixing only the wrong ones. This idea is taken from 'ar'\n * written by Haruhiko Okumura.\n *\n * The nodes were inserted with decreasing frequency into the childs\n * array.\n */\n int nodePtr = 2 * numLeafs;\n for (int bits = maxLength; bits != 0; bits--)\n {\n int n = bl_counts[bits-1];\n while (n > 0)\n {\n int childPtr = 2*childs[nodePtr++];\n if (childs[childPtr + 1] == -1)\n {\n /* We found another leaf */\n length[childs[childPtr]] = (byte) bits;\n n--;\n }\n }\n }\n if (DeflaterConstants.DEBUGGING)\n {\n System.err.println(\"*** After overflow elimination. ***\");\n for (int i=0; i < numLeafs; i++)\n System.err.println(\"Node \"+childs[2*i]+\" freq: \"+freqs[childs[2*i]]\n + \" len: \"+length[childs[2*i]]);\n }\n }\n \n void buildTree()\n {\n int numSymbols = freqs.length;\n \n /* heap is a priority queue, sorted by frequency, least frequent\n * nodes first. The heap is a binary tree, with the property, that\n * the parent node is smaller than both child nodes. This assures\n * that the smallest node is the first parent.\n *\n * The binary tree is encoded in an array: 0 is root node and\n * the nodes 2*n+1, 2*n+2 are the child nodes of node n.\n */\n int[] heap = new int[numSymbols];\n int heapLen = 0;\n int maxCode = 0;\n for (int n = 0; n < numSymbols; n++)\n {\n int freq = freqs[n];\n if (freq != 0)\n {\n /* Insert n into heap */\n int pos = heapLen++;\n int ppos;\n while (pos > 0 &&\n freqs[heap[ppos = (pos - 1) / 2]] > freq) {\n heap[pos] = heap[ppos];\n pos = ppos;\n }\n heap[pos] = n;\n maxCode = n;\n }\n }\n \n /* We could encode a single literal with 0 bits but then we\n * don't see the literals. Therefore we force at least two\n * literals to avoid this case. We don't care about order in\n * this case, both literals get a 1 bit code. \n */\n while (heapLen < 2)\n {\n int node = maxCode < 2 ? ++maxCode : 0;\n heap[heapLen++] = node;\n }\n \n numCodes = Math.max(maxCode + 1, minNumCodes);\n \n int numLeafs = heapLen;\n int[] childs = new int[4*heapLen - 2];\n int[] values = new int[2*heapLen - 1];\n int numNodes = numLeafs;\n for (int i = 0; i < heapLen; i++)\n {\n int node = heap[i];\n childs[2*i] = node;\n childs[2*i+1] = -1;\n values[i] = freqs[node] << 8;\n heap[i] = i;\n }\n \n /* Construct the Huffman tree by repeatedly combining the least two\n * frequent nodes.\n */\n do\n {\n int first = heap[0];\n int last = heap[--heapLen];\n \t \n /* Propagate the hole to the leafs of the heap */\n int ppos = 0;\n int path = 1;\n while (path < heapLen)\n {\n if (path + 1 < heapLen\n && values[heap[path]] > values[heap[path+1]])\n path++;\n \t \n heap[ppos] = heap[path];\n ppos = path;\n path = path * 2 + 1;\n }\n \t \n /* Now propagate the last element down along path. Normally\n \t * it shouldn't go too deep.\n \t */\n int lastVal = values[last];\n while ((path = ppos) > 0\n && values[heap[ppos = (path - 1)/2]] > lastVal)\n heap[path] = heap[ppos];\n heap[path] = last;\n \t \n \t \n int second = heap[0];\n \t \n /* Create a new node father of first and second */\n last = numNodes++;\n childs[2*last] = first;\n childs[2*last+1] = second;\n int mindepth = Math.min(values[first] & 0xff, values[second] & 0xff);\n values[last] = lastVal = values[first] + values[second] - mindepth + 1;\n \t \n /* Again, propagate the hole to the leafs */\n ppos = 0;\n path = 1;\n while (path < heapLen)\n {\n if (path + 1 < heapLen\n && values[heap[path]] > values[heap[path+1]])\n path++;\n \t \n heap[ppos] = heap[path];\n ppos = path;\n path = ppos * 2 + 1;\n }\n \t \n /* Now propagate the new element down along path */\n while ((path = ppos) > 0\n && values[heap[ppos = (path - 1)/2]] > lastVal)\n heap[path] = heap[ppos];\n heap[path] = last;\n }\n while (heapLen > 1);\n \n if (heap[0] != childs.length / 2 - 1)\n throw new RuntimeException(\"Weird!\");\n \n buildLength(childs);\n }\n \n int getEncodedLength()\n {\n int len = 0;\n for (int i = 0; i < freqs.length; i++)\n len += freqs[i] * length[i];\n return len;\n }\n \n void calcBLFreq(Tree blTree) {\n int max_count; /* max repeat count */\n int min_count; /* min repeat count */\n int count; /* repeat count of the current code */\n int curlen = -1; /* length of current code */\n \n int i = 0;\n while (i < numCodes)\n {\n count = 1;\n int nextlen = length[i];\n if (nextlen == 0)\n {\n max_count = 138;\n min_count = 3;\n }\n else\n {\n max_count = 6;\n min_count = 3;\n if (curlen != nextlen)\n {\n blTree.freqs[nextlen]++;\n count = 0;\n }\n }\n curlen = nextlen;\n i++;\n \n while (i < numCodes && curlen == length[i])\n {\n i++;\n if (++count >= max_count)\n break;\n }\n \n if (count < min_count)\n blTree.freqs[curlen] += count;\n else if (curlen != 0)\n blTree.freqs[REP_3_6]++;\n else if (count <= 10)\n blTree.freqs[REP_3_10]++;\n else\n blTree.freqs[REP_11_138]++;\n }\n }\n \n void writeTree(Tree blTree)\n {\n int max_count; /* max repeat count */\n int min_count; /* min repeat count */\n int count; /* repeat count of the current code */\n int curlen = -1; /* length of current code */\n \n int i = 0;\n while (i < numCodes)\n {\n count = 1;\n int nextlen = length[i];\n if (nextlen == 0)\n {\n max_count = 138;\n min_count = 3;\n }\n else\n {\n max_count = 6;\n min_count = 3;\n if (curlen != nextlen)\n {\n blTree.writeSymbol(nextlen);\n count = 0;\n }\n }\n curlen = nextlen;\n i++;\n \n while (i < numCodes && curlen == length[i])\n {\n i++;\n if (++count >= max_count)\n break;\n }\n \n if (count < min_count)\n {\n while (count-- > 0)\n blTree.writeSymbol(curlen);\n }\n else if (curlen != 0)\n {\n blTree.writeSymbol(REP_3_6);\n pending.writeBits(count - 3, 2);\n }\n else if (count <= 10)\n {\n blTree.writeSymbol(REP_3_10);\n pending.writeBits(count - 3, 3);\n }\n else\n {\n blTree.writeSymbol(REP_11_138);\n pending.writeBits(count - 11, 7);\n }\n }\n }\n }\n \n \n \n DeflaterPending pending;\n private Tree literalTree, distTree, blTree;\n \n private short d_buf[];\n private byte l_buf[];\n private int last_lit;\n private int extra_bits;\n \n private static short staticLCodes[];\n private static byte staticLLength[];\n private static short staticDCodes[];\n private static byte staticDLength[];\n \n /**\n * Reverse the bits of a 16 bit value.\n */\n static short bitReverse(int value) {\n return (short) (bit4Reverse.charAt(value & 0xf) << 12\n | bit4Reverse.charAt((value >> 4) & 0xf) << 8\n | bit4Reverse.charAt((value >> 8) & 0xf) << 4\n | bit4Reverse.charAt(value >> 12));\n }\n \n static {\n /* See RFC 1951 3.2.6 */\n /* Literal codes */\n staticLCodes = new short[LITERAL_NUM];\n staticLLength = new byte[LITERAL_NUM];\n int i = 0;\n while (i < 144) {\n staticLCodes[i] = bitReverse((0x030 + i) << 8);\n staticLLength[i++] = 8;\n }\n while (i < 256) {\n staticLCodes[i] = bitReverse((0x190 - 144 + i) << 7);\n staticLLength[i++] = 9;\n }\n while (i < 280) {\n staticLCodes[i] = bitReverse((0x000 - 256 + i) << 9);\n staticLLength[i++] = 7;\n }\n while (i < LITERAL_NUM) {\n staticLCodes[i] = bitReverse((0x0c0 - 280 + i) << 8);\n staticLLength[i++] = 8;\n }\n \n /* Distant codes */\n staticDCodes = new short[DIST_NUM];\n staticDLength = new byte[DIST_NUM];\n for (i = 0; i < DIST_NUM; i++) {\n staticDCodes[i] = bitReverse(i << 11);\n staticDLength[i] = 5;\n }\n }\n \n public DeflaterHuffman(DeflaterPending pending)\n {\n this.pending = pending;\n \n literalTree = new Tree(LITERAL_NUM, 257, 15);\n distTree = new Tree(DIST_NUM, 1, 15);\n blTree = new Tree(BITLEN_NUM, 4, 7);\n \n d_buf = new short[BUFSIZE];\n l_buf = new byte [BUFSIZE];\n }\n \n public final void reset() {\n last_lit = 0;\n extra_bits = 0;\n literalTree.reset();\n distTree.reset();\n blTree.reset();\n }\n \n private int l_code(int len) {\n if (len == 255)\n return 285;\n \n int code = 257;\n while (len >= 8)\n {\n code += 4;\n len >>= 1;\n }\n return code + len;\n }\n \n private int d_code(int distance) {\n int code = 0;\n while (distance >= 4)\n {\n code += 2;\n distance >>= 1;\n }\n return code + distance;\n }\n \n public void sendAllTrees(int blTreeCodes) {\n blTree.buildCodes();\n literalTree.buildCodes();\n distTree.buildCodes();\n pending.writeBits(literalTree.numCodes - 257, 5);\n pending.writeBits(distTree.numCodes - 1, 5);\n pending.writeBits(blTreeCodes - 4, 4);\n for (int rank = 0; rank < blTreeCodes; rank++)\n pending.writeBits(blTree.length[BL_ORDER[rank]], 3);\n literalTree.writeTree(blTree);\n distTree.writeTree(blTree);\n if (DeflaterConstants.DEBUGGING)\n blTree.checkEmpty();\n }\n \n public void compressBlock() {\n for (int i = 0; i < last_lit; i++)\n {\n int litlen = l_buf[i] & 0xff;\n int dist = d_buf[i];\n if (dist-- != 0)\n {\n if (DeflaterConstants.DEBUGGING)\n System.err.print(\"[\"+(dist+1)+\",\"+(litlen+3)+\"]: \");\n \n int lc = l_code(litlen);\n literalTree.writeSymbol(lc);\n \n int bits = (lc - 261) / 4;\n if (bits > 0 && bits <= 5)\n pending.writeBits(litlen & ((1 << bits) - 1), bits);\n \n int dc = d_code(dist);\n distTree.writeSymbol(dc);\n \n bits = dc / 2 - 1;\n if (bits > 0)\n pending.writeBits(dist & ((1 << bits) - 1), bits);\n }\n else\n {\n if (DeflaterConstants.DEBUGGING)\n {\n if (litlen > 32 && litlen < 127)\n System.err.print(\"(\"+(char)litlen+\"): \");\n else\n System.err.print(\"{\"+litlen+\"}: \");\n }\n literalTree.writeSymbol(litlen);\n }\n }\n if (DeflaterConstants.DEBUGGING)\n System.err.print(\"EOF: \");\n literalTree.writeSymbol(EOF_SYMBOL);\n if (DeflaterConstants.DEBUGGING)\n {\n literalTree.checkEmpty();\n distTree.checkEmpty();\n }\n }\n \n public void flushStoredBlock(byte[] stored,\n int stored_offset, int stored_len,\n boolean lastBlock) {\n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"Flushing stored block \"+ stored_len);\n pending.writeBits((DeflaterConstants.STORED_BLOCK << 1)\n + (lastBlock ? 1 : 0), 3);\n pending.alignToByte();\n pending.writeShort(stored_len);\n pending.writeShort(~stored_len);\n pending.writeBlock(stored, stored_offset, stored_len);\n reset();\n }\n \n public void flushBlock(byte[] stored, int stored_offset, int stored_len,\n boolean lastBlock) {\n literalTree.freqs[EOF_SYMBOL]++;\n \n /* Build trees */\n literalTree.buildTree();\n distTree.buildTree();\n \n /* Calculate bitlen frequency */\n literalTree.calcBLFreq(blTree);\n distTree.calcBLFreq(blTree);\n \n /* Build bitlen tree */\n blTree.buildTree();\n \n int blTreeCodes = 4;\n for (int i = 18; i > blTreeCodes; i--)\n {\n if (blTree.length[BL_ORDER[i]] > 0)\n blTreeCodes = i+1;\n }\n int opt_len = 14 + blTreeCodes * 3 + blTree.getEncodedLength()\n + literalTree.getEncodedLength() + distTree.getEncodedLength()\n + extra_bits;\n \n int static_len = extra_bits;\n for (int i = 0; i < LITERAL_NUM; i++)\n static_len += literalTree.freqs[i] * staticLLength[i];\n for (int i = 0; i < DIST_NUM; i++)\n static_len += distTree.freqs[i] * staticDLength[i];\n if (opt_len >= static_len)\n {\n /* Force static trees */\n opt_len = static_len;\n }\n \n if (stored_offset >= 0 && stored_len+4 < opt_len >> 3)\n {\n /* Store Block */\n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"Storing, since \" + stored_len + \" < \" + opt_len\n + \" <= \" + static_len);\n flushStoredBlock(stored, stored_offset, stored_len, lastBlock);\n }\n else if (opt_len == static_len)\n {\n /* Encode with static tree */\n pending.writeBits((DeflaterConstants.STATIC_TREES << 1)\n + (lastBlock ? 1 : 0), 3);\n literalTree.setStaticCodes(staticLCodes, staticLLength);\n distTree.setStaticCodes(staticDCodes, staticDLength);\n compressBlock();\n reset();\n }\n else\n {\n /* Encode with dynamic tree */\n pending.writeBits((DeflaterConstants.DYN_TREES << 1)\n + (lastBlock ? 1 : 0), 3);\n sendAllTrees(blTreeCodes);\n compressBlock();\n reset();\n }\n }\n \n public final boolean isFull()\n {\n return last_lit == BUFSIZE;\n }\n \n public final boolean tallyLit(int lit)\n {\n if (DeflaterConstants.DEBUGGING)\n {\n if (lit > 32 && lit < 127)\n System.err.println(\"(\"+(char)lit+\")\");\n else\n System.err.println(\"{\"+lit+\"}\");\n }\n d_buf[last_lit] = 0;\n l_buf[last_lit++] = (byte) lit;\n literalTree.freqs[lit]++;\n return last_lit == BUFSIZE;\n }\n \n public final boolean tallyDist(int dist, int len)\n {\n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"[\"+dist+\",\"+len+\"]\");\n \n d_buf[last_lit] = (short) dist;\n l_buf[last_lit++] = (byte) (len - 3);\n \n int lc = l_code(len-3);\n literalTree.freqs[lc]++;\n if (lc >= 265 && lc < 285)\n extra_bits += (lc - 261) / 4;\n \n int dc = d_code(dist-1);\n distTree.freqs[dc]++;\n if (dc >= 4)\n extra_bits += dc / 2 - 1;\n return last_lit == BUFSIZE;\n }\n}"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/DeflaterOutputStream.java",
"content": " /* DeflaterOutputStream.java - Output filter for compressing.\n Copyright (C) 1999, 2000, 2001, 2004, 2005 Free Software Foundation, Inc.\n \n This file is part of GNU Classpath.\n \n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n \n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n \n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n \n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n \n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n \n \n package java.util.zip;\n \n import java.io.FilterOutputStream;\n import java.io.IOException;\n import java.io.OutputStream;\n \n /* Written using on-line Java Platform 1.2 API Specification\n * and JCL book.\n * Believed complete and correct.\n */\n \n /**\n * This is a special FilterOutputStream deflating the bytes that are\n * written through it. It uses the Deflater for deflating.\n *\n * A special thing to be noted is that flush() doesn't flush\n * everything in Sun's JDK, but it does so in jazzlib. This is because\n * Sun's Deflater doesn't have a way to flush() everything, without\n * finishing the stream.\n *\n * @author Tom Tromey, Jochen Hoenicke\n * @date Jan 11, 2001 \n */\n public class DeflaterOutputStream extends FilterOutputStream\n {\n /**\n * This buffer is used temporarily to retrieve the bytes from the\n * deflater and write them to the underlying output stream.\n */\n protected byte[] buf;\n \n /**\n * The deflater which is used to deflate the stream.\n */\n protected Deflater def;\n \n /**\n * Deflates everything in the def's input buffers. This will call\n * def.deflate() until all bytes from the input buffers\n * are processed.\n */\n protected void deflate() throws IOException\n {\n while (! def.needsInput())\n {\n int len = def.deflate(buf, 0, buf.length);\n \n // System.err.println(\"DOS deflated \" + len + \" out of \" + buf.length);\n if (len <= 0)\n break;\n out.write(buf, 0, len);\n }\n \n if (! def.needsInput())\n throw new InternalError(\"Can't deflate all input?\");\n }\n \n /**\n * Creates a new DeflaterOutputStream with a default Deflater and\n * default buffer size.\n * @param out the output stream where deflated output should be written.\n */\n public DeflaterOutputStream(OutputStream out)\n {\n this(out, new Deflater(), 4096);\n }\n \n /**\n * Creates a new DeflaterOutputStream with the given Deflater and\n * default buffer size.\n * @param out the output stream where deflated output should be written.\n * @param defl the underlying deflater.\n */\n public DeflaterOutputStream(OutputStream out, Deflater defl)\n {\n this(out, defl, 4096);\n }\n \n /**\n * Creates a new DeflaterOutputStream with the given Deflater and\n * buffer size.\n * @param out the output stream where deflated output should be written.\n * @param defl the underlying deflater.\n * @param bufsize the buffer size.\n * @exception IllegalArgumentException if bufsize isn't positive.\n */\n public DeflaterOutputStream(OutputStream out, Deflater defl, int bufsize)\n {\n super(out);\n if (bufsize <= 0)\n throw new IllegalArgumentException(\"bufsize <= 0\");\n buf = new byte[bufsize];\n def = defl;\n }\n \n /**\n * Flushes the stream by calling flush() on the deflater and then\n * on the underlying stream. This ensures that all bytes are\n * flushed. This function doesn't work in Sun's JDK, but only in\n * jazzlib.\n */\n public void flush() throws IOException\n {\n def.flush();\n deflate();\n out.flush();\n }\n \n /**\n * Finishes the stream by calling finish() on the deflater. This\n * was the only way to ensure that all bytes are flushed in Sun's\n * JDK.\n */\n public void finish() throws IOException\n {\n def.finish();\n while (! def.finished())\n {\n int len = def.deflate(buf, 0, buf.length);\n if (len <= 0)\n break;\n out.write(buf, 0, len);\n }\n if (! def.finished())\n throw new InternalError(\"Can't deflate all input?\");\n out.flush();\n }\n \n /**\n * Calls finish() and closes the stream.\n */\n public void close() throws IOException\n {\n finish();\n out.close();\n }\n \n /**\n * Writes a single byte to the compressed output stream.\n * @param bval the byte value.\n */\n public void write(int bval) throws IOException\n {\n byte[] b = new byte[1];\n b[0] = (byte) bval;\n write(b, 0, 1);\n }\n \n /**\n * Writes a len bytes from an array to the compressed stream.\n * @param buf the byte array.\n * @param off the offset into the byte array where to start.\n * @param len the number of bytes to write.\n */\n public void write(byte[] buf, int off, int len) throws IOException\n {\n def.setInput(buf, off, len);\n deflate();\n }\n }"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/DeflaterPending.java",
"content": "/* java.util.zip.DeflaterPending\n Copyright (C) 2001 Free Software Foundation, Inc.\n \n This file is part of GNU Classpath.\n \n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n \n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n \n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n \n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n \n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n\npackage java.util.zip;\n \n/**\n * This class stores the pending output of the Deflater.\n *\n * @author Jochen Hoenicke\n * @date Jan 5, 2000\n */\n \nclass DeflaterPending extends PendingBuffer\n{\n public DeflaterPending()\n {\n super(DeflaterConstants.PENDING_BUF_SIZE);\n }\n}"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/GZIPInputStream.java",
"content": "/*******************************************************************************\r\n * Copyright 2011 See AUTHORS file.\r\n * \r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n * \r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n * \r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n ******************************************************************************/\n\n\npackage java.util.zip;\n\nimport java.io.IOException;\r\nimport java.io.InputStream;\n\n/** Dummy emulation. Throws a GdxRuntimeException on first read.\n * @author hneuer */\npublic class GZIPInputStream extends InflaterInputStream {\n\tpublic GZIPInputStream (InputStream in, int size) {\n\t\tsuper(in);\n\t}\r\n\tpublic GZIPInputStream(InputStream in) throws IOException {\r\n\t\tsuper(in);\r\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/InflaterInputStream.java",
"content": "/*******************************************************************************\r\n * Copyright 2011 See AUTHORS file.\r\n * \r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n * \r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n * \r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n ******************************************************************************/\n\n\npackage java.util.zip;\n\nimport java.io.IOException;\nimport java.io.InputStream;\n\n/** Dummy emulation. Throws a GdxRuntimeException on first read.\n * @author hneuer */\npublic class InflaterInputStream extends InputStream {\n\tprivate InputStream in;\n\n\tpublic InflaterInputStream (InputStream in) {\n\t\tthis.in = in;\n\t}\n\n\t@Override\n\tpublic int read () throws IOException {\n\t\tthrow new IOException(\"InflaterInputStream not supported in GWT\");\n\t}\n\n\t@Override\n\tpublic void close () throws IOException {\n\t\tsuper.close();\n\t\t//StreamUtils.closeQuietly(in);\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/java/util/zip/PendingBuffer.java",
"content": "/* java.util.zip.PendingBuffer\n Copyright (C) 2001 Free Software Foundation, Inc.\n \n This file is part of GNU Classpath.\n \n GNU Classpath is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n \n GNU Classpath is distributed in the hope that it will be useful, but\n WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n General Public License for more details.\n \n You should have received a copy of the GNU General Public License\n along with GNU Classpath; see the file COPYING. If not, write to the\n Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301 USA.\n \n Linking this library statically or dynamically with other modules is\n making a combined work based on this library. Thus, the terms and\n conditions of the GNU General Public License cover the whole\n combination.\n \n As a special exception, the copyright holders of this library give you\n permission to link this library with independent modules to produce an\n executable, regardless of the license terms of these independent\n modules, and to copy and distribute the resulting executable under\n terms of your choice, provided that you also meet, for each linked\n independent module, the terms and conditions of the license of that\n module. An independent module is a module which is not derived from\n or based on this library. If you modify this library, you may extend\n this exception to your version of the library, but you are not\n obligated to do so. If you do not wish to do so, delete this\n exception statement from your version. */\n \npackage java.util.zip;\n \n/**\n * This class is general purpose class for writing data to a buffer.\n *\n * It allows you to write bits as well as bytes\n *\n * Based on DeflaterPending.java\n *\n * @author Jochen Hoenicke\n * @date Jan 5, 2000\n */\n \nclass PendingBuffer\n{\n protected byte[] buf;\n int start;\n int end;\n \n int bits;\n int bitCount;\n \n public PendingBuffer()\n {\n this( 4096 );\n }\n \n public PendingBuffer(int bufsize)\n {\n buf = new byte[bufsize];\n }\n \n public final void reset() {\n start = end = bitCount = 0;\n }\n \n public final void writeByte(int b)\n {\n if (DeflaterConstants.DEBUGGING && start != 0)\n throw new IllegalStateException();\n buf[end++] = (byte) b;\n }\n \n public final void writeShort(int s)\n {\n if (DeflaterConstants.DEBUGGING && start != 0)\n throw new IllegalStateException();\n buf[end++] = (byte) s;\n buf[end++] = (byte) (s >> 8);\n }\n \n public final void writeInt(int s)\n {\n if (DeflaterConstants.DEBUGGING && start != 0)\n throw new IllegalStateException();\n buf[end++] = (byte) s;\n buf[end++] = (byte) (s >> 8);\n buf[end++] = (byte) (s >> 16);\n buf[end++] = (byte) (s >> 24);\n }\n \n public final void writeBlock(byte[] block, int offset, int len)\n {\n if (DeflaterConstants.DEBUGGING && start != 0)\n throw new IllegalStateException();\n System.arraycopy(block, offset, buf, end, len);\n end += len;\n }\n \n public final int getBitCount() {\n return bitCount;\n }\n \n public final void alignToByte() {\n if (DeflaterConstants.DEBUGGING && start != 0)\n throw new IllegalStateException();\n if (bitCount > 0)\n {\n buf[end++] = (byte) bits;\n if (bitCount > 8)\n buf[end++] = (byte) (bits >>> 8);\n }\n bits = 0;\n bitCount = 0;\n }\n \n public final void writeBits(int b, int count)\n {\n if (DeflaterConstants.DEBUGGING && start != 0)\n throw new IllegalStateException();\n if (DeflaterConstants.DEBUGGING)\n System.err.println(\"writeBits(\"+Integer.toHexString(b)+\",\"+count+\")\");\n bits |= b << bitCount;\n bitCount += count;\n if (bitCount >= 16) {\n buf[end++] = (byte) bits;\n buf[end++] = (byte) (bits >>> 8);\n bits >>>= 16;\n bitCount -= 16;\n }\n }\n \n public final void writeShortMSB(int s) {\n if (DeflaterConstants.DEBUGGING && start != 0)\n throw new IllegalStateException();\n buf[end++] = (byte) (s >> 8);\n buf[end++] = (byte) s;\n }\n \n public final boolean isFlushed() {\n return end == 0;\n }\n \n /**\n * Flushes the pending buffer into the given output array. If the\n * output array is to small, only a partial flush is done.\n *\n * @param output the output array;\n * @param offset the offset into output array;\n * @param length the maximum number of bytes to store;\n * @exception IndexOutOfBoundsException if offset or length are\n * invalid.\n */\n public final int flush(byte[] output, int offset, int length) {\n if (bitCount >= 8)\n {\n buf[end++] = (byte) bits;\n bits >>>= 8;\n bitCount -= 8;\n }\n if (length > end - start)\n {\n length = end - start;\n System.arraycopy(buf, start, output, offset, length);\n start = 0;\n end = 0;\n }\n else\n {\n System.arraycopy(buf, start, output, offset, length);\n start += length;\n }\n return length;\n }\n \n /**\n * Flushes the pending buffer and returns that data in a new array\n *\n * @return the output stream\n */\n \n public final byte[] toByteArray()\n {\n byte[] ret = new byte[ end - start ];\n System.arraycopy(buf, start, ret, 0, ret.length);\n start = 0;\n end = 0;\n return ret;\n }\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/application/Platform.java",
"content": "package javafx.application;\n\npublic final class Platform {\n\n public static void runLater(Runnable runnable) {};\n\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/embed/swing/JFXPanel.java",
"content": "package javafx.embed.swing;\n\npublic final class JFXPanel {\n public JFXPanel(){\n\n }\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/embed/swing/SwingFXUtils.java",
"content": "package javafx.embed.swing;\n\nimport java.awt.image.BufferedImage;\nimport javafx.scene.image.Image;\n\npublic final class SwingFXUtils {\n public static BufferedImage fromFXImage(Image img, BufferedImage bimg) {\n return null;\n }\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/scene/SnapshotParameters.java",
"content": "package javafx.scene;\n\npublic final class SnapshotParameters {\n\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/scene/image/Image.java",
"content": "package javafx.scene.image;\n\npublic class Image{\n\n public Image() {\n\n }\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/scene/image/WritableImage.java",
"content": "package javafx.scene.image;\n\npublic final class WritableImage extends Image {\n public WritableImage(int width, int height) {\n super();\n }\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/scene/media/Media.java",
"content": "package javafx.scene.media;\n\nimport javafx.util.Duration;\n\npublic final class Media {\n public Media(String source){\n\n }\n public final Duration getDuration() {\n return null;\n }\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/scene/media/MediaPlayer.java",
"content": "package javafx.scene.media;\nimport javafx.util.Duration;\n\npublic final class MediaPlayer{\n public MediaPlayer(Media media){\n\n }\n public void seek(Duration seekTime) {\n\n }\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/scene/media/MediaView.java",
"content": "package javafx.scene.media;\nimport javafx.scene.image.WritableImage;\nimport javafx.scene.SnapshotParameters;\n\npublic final class MediaView{\n public MediaView() {\n\n }\n public void setFitWidth(int width){\n\n }\n public void setFitHeight(int height) {\n\n }\n public void setMediaPlayer(MediaPlayer mediaPlayer){\n\n }\n public void setPreserveRatio(boolean preserverRatio) {\n\n }\n public WritableImage snapshot(SnapshotParameters params, WritableImage image){\n return null;\n }\n}"
},
{
"path": "src/peergos/gwt/emu/javafx/util/Duration.java",
"content": "package javafx.util;\n\npublic final class Duration {\n\n public static Duration seconds(double s) {\n return null;\n }\n\n public boolean isUnknown() {\n return false;\n }\n public double toSeconds() {\n return 0;\n }\n}\n"
},
{
"path": "src/peergos/gwt/emu/javax/crypto/Mac.java",
"content": "package javax.crypto;\n\nimport javax.crypto.spec.SecretKeySpec;\n\npublic class Mac {\n\n\tpublic static Mac getInstance(String algo)\n\t{\n\t\treturn null;\n\t}\n\t\n\tpublic void init(SecretKeySpec spec)\n\t{\n\t\t\n\t}\n\t\n\tpublic int getMacLength()\n\t{\n\t\treturn -1;\n\t}\n\t\n\tpublic void update(byte[] b)\n\t{\n\t\t\n\t}\n\t\n\tpublic void doFinal(byte[] a, int i)\n\t{\n\t\t\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/javax/crypto/spec/SecretKeySpec.java",
"content": "package javax.crypto.spec;\n\npublic class SecretKeySpec {\n\n\tprivate final byte[] key;\n\tprivate final String algorithm;\n\tpublic SecretKeySpec(byte[] key, String algorithm)\n\t{\n\t\tthis.key = key;\n\t\tthis.algorithm = algorithm;\n\t}\n\n\tpublic byte[] getEncoded() {\n\t\treturn this.key;\n\t}\n}\n"
},
{
"path": "src/peergos/gwt/emu/javax/imageio/ImageIO.java",
"content": "package javax.imageio;\n\nimport java.awt.image.BufferedImage;\nimport java.awt.image.RenderedImage;\nimport java.io.InputStream;\nimport java.io.OutputStream;\nimport java.io.IOException;\n\n/*\n* Dummy implementation - does nothing\n* */\npublic class ImageIO {\n\n public static BufferedImage read(InputStream input) throws IOException {\n return null;\n }\n\n public static boolean write(RenderedImage im,\n String formatName,\n OutputStream output) throws IOException {\n return false;\n }\n}\n"
},
{
"path": "src/peergos/server/AggregatedMetrics.java",
"content": "package peergos.server;\n\nimport io.prometheus.client.Counter;\nimport io.prometheus.client.Histogram;\nimport io.prometheus.client.exporter.HTTPServer;\nimport peergos.server.util.*;\n\nimport java.io.IOException;\nimport java.util.*;\n\n/**\n * A wrapper around the prometheus metrics and HTTP exporter.\n */\npublic class AggregatedMetrics {\n private static Counter build(String name, String help) {\n return Counter.build()\n .name(name).help(help).register();\n }\n\n public static final Counter FOLLOW_REQUEST_COUNTER = build(\"send_follow_request_total\",\"Total follow requests.\");\n public static final Counter GET_FOLLOW_REQUEST_COUNTER = build(\"get_follow_request_counter\", \"Total get follow request calls.\");\n public static final Counter REMOVE_FOLLOW_REQUEST_COUNTER = build(\"remove_follow_request_counter\", \"Total remove follow request calls.\");\n\n public static final Counter PUBLIC_FILE_COUNTER = build(\"public_file_counter\", \"Total public files.\");\n\n public static final Counter STORAGE_ID = build(\"storage_id\", \"Total id calls.\");\n public static final Counter STORAGE_IDS = build(\"storage_ids\", \"Total ids calls.\");\n public static final Counter STORAGE_BLOCK_PUT = build(\"storage_block_put\", \"Total DHT block puts.\");\n public static final Counter STORAGE_BLOCK_PUT_BULK = build(\"storage_block_put_bulk\", \"Total bulk block puts.\");\n public static final Counter STORAGE_BLOCK_GET = build(\"storage_block_get\", \"Total DHT block gets.\");\n public static final Counter STORAGE_BLOCK_STAT = build(\"storage_block_stat\", \"Total DHT block stats.\");\n public static final Counter STORAGE_BLOCK_REFS = build(\"storage_block_refs\", \"Total DHT block refs.\");\n public static final Counter STORAGE_TRANSACTION_START = build(\"storage_transaction_start\", \"Total DHT transaction starts.\");\n public static final Counter STORAGE_TRANSACTION_CLOSE = build(\"storage_transaction_close\", \"Total DHT transaction closes.\");\n public static final Counter STORAGE_CHAMP_GET = build(\"storage_champ_get\", \"Total champ gets\");\n public static final Counter STORAGE_LINK_GET = build(\"storage_link_get\", \"Total link gets\");\n public static final Counter STORAGE_LINK_COUNTS = build(\"storage_link_counts\", \"Total link counts\");\n public static final Counter STORAGE_IPNS_GET = build(\"storage_ipns_get\", \"Total ipns gets\");\n public static final Histogram STORAGE_CHAMP_GET_DURATION = Histogram.build()\n .labelNames(\"duration\")\n .name(\"champ_get_duration\")\n .help(\"Time to respond to a champ.get call\")\n .exponentialBuckets(0.01, 2, 16)\n .register();\n\n public static final Histogram STORAGE_LINK_GET_DURATION = Histogram.build()\n .labelNames(\"duration\")\n .name(\"link_get_duration\")\n .help(\"Time to respond to a link.get call\")\n .exponentialBuckets(0.01, 2, 16)\n .register();\n\n public static final Counter MUTABLE_POINTERS_SET = build(\"mutable_pointers_set\", \"Total mutable-pointers set calls.\");\n public static final Counter MUTABLE_POINTERS_GET = build(\"mutable_pointers_get\", \"Total mutable-pointers get calls.\");\n\n public static final Counter LOGIN_SET = build(\"login_set\", \"Total login set calls.\");\n public static final Counter LOGIN_GET = build(\"login_get\", \"Total successful login get calls.\");\n public static final Counter LOGIN_GET_FAILURE_PASSWORD = build(\"login_get_failure_password\", \"Total login get calls with incorrect signature.\");\n public static final Counter LOGIN_GET_FAILURE_EXTERNAL = build(\"login_get_failure_external\", \"Total failed login get calls for external users.\");\n public static final Counter LOGIN_GET_MFA = build(\"login_get_mfa\", \"Total get mfa calls.\");\n public static final Counter LOGIN_ADD_TOTP = build(\"login_add_totp\", \"Total add totp calls.\");\n public static final Counter LOGIN_ENABLE_TOTP = build(\"login_enable_totp\", \"Total enable totp calls.\");\n public static final Counter LOGIN_WEBAUTHN_START = build(\"login_webauthn_start\", \"Total webauthn start calls.\");\n public static final Counter LOGIN_WEBAUTHN_COMPLETE = build(\"login_webauthn_complete\", \"Total webauthn complete calls.\");\n public static final Counter LOGIN_DELETE_MFA = build(\"login_delete_mfa\", \"Total delete mfa calls.\");\n\n public static final Counter BAT_ADD = build(\"bat_add\", \"Total addBat calls.\");\n public static final Counter BATS_GET = build(\"bats_get\", \"Total getBats calls.\");\n\n public static final Counter GET_ALL_USERNAMES = build(\"core_node_get_all_usernames\", \"Total get-all-usernames calls.\");\n public static final Counter GET_USERNAME = build(\"core_node_get_username\", \"Total get-username calls.\");\n public static final Counter GET_PUBLIC_KEY = build(\"core_node_get_public_key\", \"Total get-public-key calls.\");\n public static final Counter GET_PUBLIC_KEY_CHAIN = build(\"core_node_get_chain\", \"Total get-public-key-chain calls.\");\n public static final Counter UPDATE_PUBLIC_KEY_CHAIN = build(\"core_node_update_chain\", \"Total getupdate-public-key-chain calls.\");\n public static final Counter PKI_RATE_LIMITED = build(\"pki_rate_limited\", \"Total number of pki updates rate limited.\");\n public static final Counter SIGNUP = build(\"core_node_signup\", \"Total signup calls.\");\n public static final Counter PAID_SIGNUP_START = build(\"core_node_signup_paid_start\", \"Total start paid signup calls.\");\n public static final Counter PAID_SIGNUP_COMPLETE = build(\"core_node_signup_paid_complete\", \"Total complete paid signup calls.\");\n public static final Counter PAID_SIGNUP_SUCCESS = build(\"core_node_signup_paid_success\", \"Total successful paid signup calls.\");\n public static final Counter MIRROR = build(\"core_node_mirror\", \"Total mirror calls.\");\n public static final Counter PAID_MIRROR_START = build(\"core_node_mirror_paid_start\", \"Total start paid mirror calls.\");\n public static final Counter PAID_MIRROR_COMPLETE = build(\"core_node_mirror_paid_complete\", \"Total complete paid mirror calls.\");\n public static final Counter GET_USER_SNAPSHOTS = build(\"core_node_get_user_snapshots\", \"Total get user snapshots calls.\");\n public static final Counter PAID_MIRROR_SUCCESS = build(\"core_node_mirror_paid_success\", \"Total successful paid mirror calls.\");\n public static final Counter MIGRATE_USER = build(\"core_node_migrate_user\", \"Total migrate-user calls.\");\n\n private static Set