Do not reference System.out or System.err if possible

soywiz · soywiz · commit f245c2ffe15f · 2017-08-26T09:36:14.000+02:00
diff --git a/jtransc-rt-core/src/com/jtransc/compression/jzlib/Adler32.java b/jtransc-rt-core/src/com/jtransc/compression/jzlib/Adler32.java
@@ -135,7 +135,7 @@ public void reset(long init){
       adler.reset();
     }
     else{
-      System.err.println("unsupported operation");
+      JTranscConsole.error("unsupported operation");
     }
   }
   public long getValue(){
diff --git a/jtransc-rt/regexodus/src/regexodus/CharacterClass.java b/jtransc-rt/regexodus/src/regexodus/CharacterClass.java
@@ -30,6 +30,7 @@
 package regexodus;
 
 import com.jtransc.annotation.JTranscInvisible;
+import com.jtransc.io.JTranscConsole;
 import regexodus.ds.IntBitSet;
 
 import java.util.ArrayList;
@@ -886,9 +887,9 @@ public static void main(String[] args) {
 
 
     private static void printRealm(ArrayList<String> realm, String name) {
-        System.out.println(name + ":");
+		JTranscConsole.log(name + ":");
         for (String s : realm) {
-            System.out.println("  " + s);
+			JTranscConsole.log("  " + s);
         }
     }
 }
diff --git a/jtransc-rt/src/java/io/JTranscFileSystem.java b/jtransc-rt/src/java/io/JTranscFileSystem.java
@@ -164,8 +164,8 @@ public long getLastModifiedTime(File f) {
 	}
 
 	public long getLength(File f) {
-		//System.out.println(f.getPath());
-		//System.out.println(f.getAbsolutePath());
+		//JTranscConsole.log(f.getPath());
+		//JTranscConsole.log(f.getAbsolutePath());
 		return JTranscSyncIO.impl.getLength(normalize2(f));
 	}
 
diff --git a/jtransc-rt/src/java/io/RandomAccessFile.java b/jtransc-rt/src/java/io/RandomAccessFile.java
@@ -53,7 +53,7 @@ public RandomAccessFile(File file, String mode) throws FileNotFoundException {
 		fd = new FileDescriptor();
 		//fd.attach(this);
 		path = name;
-		//System.out.println("RandomAccessFile");
+		//JTranscConsole.log("RandomAccessFile");
 		jfd = JTranscSyncIO.impl.open(name, imode);
 	}
 
diff --git a/jtransc-rt/src/java/lang/Class.java b/jtransc-rt/src/java/lang/Class.java
@@ -371,11 +371,11 @@ public boolean desiredAssertionStatus() {
 	public T[] getEnumConstants() {
 		T[] values = getEnumConstantsShared();
 		if (values == null) {
-			System.out.println("Class " + this + " is not an enum (" + isEnum() + ")!");
+			JTranscConsole.log("Class " + this + " is not an enum (" + isEnum() + ")!");
 
 			try {
 				final Method valuesMethod = getMethod("values");
-				System.out.println("values method:" + valuesMethod);
+				JTranscConsole.log("values method:" + valuesMethod);
 			} catch (NoSuchMethodException e) {
 				throw new Error(e);
 			}
diff --git a/jtransc-rt/src/java/lang/Integer.java b/jtransc-rt/src/java/lang/Integer.java
@@ -111,7 +111,7 @@ public static int _parseInt(String input, int radix) {
 			}
 			result *= radix;
 			result += JTranscCType.decodeDigit(c);
-			//System.out.println(c + ": " + JTranscCType.decodeDigit(c));
+			//JTranscConsole.log(c + ": " + JTranscCType.decodeDigit(c));
 		}
 		return sign * result;
 	}
diff --git a/jtransc-rt/src/java/lang/Thread.java b/jtransc-rt/src/java/lang/Thread.java
@@ -22,6 +22,7 @@
 import com.jtransc.annotation.JTranscMethodBody;
 import com.jtransc.annotation.haxe.HaxeAddMembers;
 import com.jtransc.annotation.haxe.HaxeMethodBody;
+import com.jtransc.io.JTranscConsole;
 
 import java.util.Collection;
 import java.util.HashMap;
@@ -208,7 +209,7 @@ public synchronized void start() {
 		"});"
 	)
 	private void _start() {
-		System.err.println("WARNING: Threads not supported! Executing thread code in the parent's thread!");
+		JTranscConsole.error("WARNING: Threads not supported! Executing thread code in the parent's thread!");
 		runInternal();
 	}
 
@@ -294,7 +295,7 @@ public void destroy() {
 	}
 
 	public final boolean isAlive() {
-		//System.out.println("isAlive: " + _isAlive);
+		//JTranscConsole.log("isAlive: " + _isAlive);
 		return _isAlive;
 	}
 
@@ -426,8 +427,8 @@ public interface UncaughtExceptionHandler {
 	}
 
 	static public UncaughtExceptionHandler defaultUncaughtExceptionHandler = (t, e) -> {
-		System.out.println(t);
-		System.out.println(e);
+		JTranscConsole.log(t);
+		JTranscConsole.log(e);
 	};
 
 	public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
diff --git a/jtransc-rt/src/java/lang/ThreadGroup.java b/jtransc-rt/src/java/lang/ThreadGroup.java
@@ -16,6 +16,8 @@
 
 package java.lang;
 
+import com.jtransc.io.JTranscConsole;
+
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedHashSet;
@@ -175,7 +177,7 @@ synchronized public final void destroy() {
 	}
 
 	public void list() {
-		System.out.println("Unimplemented ThreadGroup.list()");
+		JTranscConsole.log("Unimplemented ThreadGroup.list()");
 	}
 
 	native public void uncaughtException(Thread t, Throwable e);
diff --git a/jtransc-rt/src/java/lang/reflect/_InternalUtils.java b/jtransc-rt/src/java/lang/reflect/_InternalUtils.java
@@ -43,8 +43,6 @@ static Type parseType(String str, Type owner) {
 
 	static Type parseType(MStringReader sr, Type owner) {
 		char c = sr.read();
-		//System.out.println("parseType:sr=" + sr.str + ":owner=" + owner.getTypeName());
-		//System.out.println("parseType:sr=" + sr.str);
 		switch (c) {
 			case '(':
 				Type[] args = parseTypes(sr, owner);
@@ -76,10 +74,8 @@ static Type parseType(MStringReader sr, Type owner) {
 				Type type = parseType(sr, owner);
 				int end = sr.offset;
 				if (type instanceof Class<?>) {
-					//System.out.println("AAAAAAAAAAAA");
 					return Class_forName0(sr.str.substring(start, end));
 				} else {
-					//System.out.println("BBBBBBBBBBBB");
 					return new ArrayType(type);
 				}
 			case 'L':
diff --git a/jtransc-rt/src/java/net/URI.java b/jtransc-rt/src/java/net/URI.java
@@ -22,110 +22,6 @@
 import java.net.internal.UrlUtils;
 import java.util.Locale;
 
-/**
- * A Uniform Resource Identifier that identifies an abstract or physical
- * resource, as specified by <a href="http://www.ietf.org/rfc/rfc2396.txt">RFC
- * 2396</a>.
- *
- * <h3>Parts of a URI</h3>
- * A URI is composed of many parts. This class can both parse URI strings into
- * parts and compose URI strings from parts. For example, consider the parts of
- * this URI:
- * {@code http://username:password@host:8080/directory/file?query#fragment}
- * <table>
- * <tr><th>Component                                            </th><th>Example value                                                      </th><th>Also known as</th></tr>
- * <tr><td>{@link #getScheme() Scheme}                          </td><td>{@code http}                                                       </td><td>protocol</td></tr>
- * <tr><td>{@link #getSchemeSpecificPart() Scheme-specific part}</td><td>{@code //username:password@host:8080/directory/file?query#fragment}</td><td></td></tr>
- * <tr><td>{@link #getAuthority() Authority}                    </td><td>{@code username:password@host:8080}                                </td><td></td></tr>
- * <tr><td>{@link #getUserInfo() User Info}                     </td><td>{@code username:password}                                          </td><td></td></tr>
- * <tr><td>{@link #getHost() Host}                              </td><td>{@code host}                                                       </td><td></td></tr>
- * <tr><td>{@link #getPort() Port}                              </td><td>{@code 8080}                                                       </td><td></td></tr>
- * <tr><td>{@link #getPath() Path}                              </td><td>{@code /directory/file}                                            </td><td></td></tr>
- * <tr><td>{@link #getQuery() Query}                            </td><td>{@code query}                                                      </td><td></td></tr>
- * <tr><td>{@link #getFragment() Fragment}                      </td><td>{@code fragment}                                                   </td><td>ref</td></tr>
- * </table>
- *
- * <h3>Absolute vs. Relative URIs</h3>
- * URIs are either {@link #isAbsolute() absolute or relative}.
- * <ul>
- *     <li><strong>Absolute:</strong> {@code http://android.com/robots.txt}
- *     <li><strong>Relative:</strong> {@code robots.txt}
- * </ul>
- *
- * <p>Absolute URIs always have a scheme. If its scheme is supported by {@link
- * URL}, you can use {@link #toURL} to convert an absolute URI to a URL.
- *
- * <p>Relative URIs do not have a scheme and cannot be converted to URLs. If you
- * have the absolute URI that a relative URI is relative to, you can use {@link
- * #resolve} to compute the referenced absolute URI. Symmetrically, you can use
- * {@link #relativize} to compute the relative URI from one URI to another.
- * <pre>   {@code
- *   URI absolute = new URI("http://android.com/");
- *   URI relative = new URI("robots.txt");
- *   URI resolved = new URI("http://android.com/robots.txt");
- *
- *   // print "http://android.com/robots.txt"
- *   System.out.println(absolute.resolve(relative));
- *
- *   // print "robots.txt"
- *   System.out.println(absolute.relativize(resolved));
- * }</pre>
- *
- * <h3>Opaque vs. Hierarchical URIs</h3>
- * Absolute URIs are either {@link #isOpaque() opaque or hierarchical}. Relative
- * URIs are always hierarchical.
- * <ul>
- *     <li><strong>Hierarchical:</strong> {@code http://android.com/robots.txt}
- *     <li><strong>Opaque:</strong> {@code mailto:robots@example.com}
- * </ul>
- *
- * <p>Opaque URIs have both a scheme and a scheme-specific part that does not
- * begin with the slash character: {@code /}. The contents of the
- * scheme-specific part of an opaque URI is not parsed so an opaque URI never
- * has an authority, user info, host, port, path or query. An opaque URIs may
- * have a fragment, however. A typical opaque URI is
- * {@code mailto:robots@example.com}.
- * <table>
- * <tr><th>Component           </th><th>Example value             </th></tr>
- * <tr><td>Scheme              </td><td>{@code mailto}            </td></tr>
- * <tr><td>Scheme-specific part</td><td>{@code robots@example.com}</td></tr>
- * <tr><td>Fragment            </td><td>                          </td></tr>
- * </table>
- * <p>Hierarchical URIs may have values for any URL component. They always
- * have a non-null path, though that path may be the empty string.
- *
- * <h3>Encoding and Decoding URI Components</h3>
- * Each component of a URI permits a limited set of legal characters. Other
- * characters must first be <i>encoded</i> before they can be embedded in a URI.
- * To recover the original characters from a URI, they may be <i>decoded</i>.
- * <strong>Contrary to what you might expect,</strong> this class uses the
- * term <i>raw</i> to refer to encoded strings. The non-<i>raw</i> accessors
- * return decoded strings. For example, consider how this URI is decoded:
- * {@code http://user:pa55w%3Frd@host:80/doc%7Csearch?q=green%20robots#over%206%22}
- * <table>
- * <tr><th>Component           </th><th>Legal Characters                                                    </th><th>Other Constraints                                  </th><th>Raw Value                                                      </th><th>Value</th></tr>
- * <tr><td>Scheme              </td><td>{@code 0-9}, {@code a-z}, {@code A-Z}, {@code +-.}                  </td><td>First character must be in {@code a-z}, {@code A-Z}</td><td>                                                               </td><td>{@code http}</td></tr>
- * <tr><td>Scheme-specific part</td><td>{@code 0-9}, {@code a-z}, {@code A-Z}, {@code _-!.~'()*,;:$&+=?/[]@}</td><td>Non-ASCII characters okay                          </td><td>{@code //user:pa55w%3Frd@host:80/doc%7Csearch?q=green%20robots}</td><td>{@code //user:pa55w?rd@host:80/doc|search?q=green robots}</td></tr>
- * <tr><td>Authority           </td><td>{@code 0-9}, {@code a-z}, {@code A-Z}, {@code _-!.~'()*,;:$&+=@[]}  </td><td>Non-ASCII characters okay                          </td><td>{@code user:pa55w%3Frd@host:80}                                </td><td>{@code user:pa55w?rd@host:80}</td></tr>
- * <tr><td>User Info           </td><td>{@code 0-9}, {@code a-z}, {@code A-Z}, {@code _-!.~'()*,;:$&+=}     </td><td>Non-ASCII characters okay                          </td><td>{@code user:pa55w%3Frd}                                        </td><td>{@code user:pa55w?rd}</td></tr>
- * <tr><td>Host                </td><td>{@code 0-9}, {@code a-z}, {@code A-Z}, {@code -.[]}                 </td><td>Domain name, IPv4 address or [IPv6 address]        </td><td>                                                               </td><td>host</td></tr>
- * <tr><td>Port                </td><td>{@code 0-9}                                                         </td><td>                                                   </td><td>                                                               </td><td>{@code 80}</td></tr>
- * <tr><td>Path                </td><td>{@code 0-9}, {@code a-z}, {@code A-Z}, {@code _-!.~'()*,;:$&+=/@}   </td><td>Non-ASCII characters okay                          </td><td>{@code /doc%7Csearch}                                          </td><td>{@code /doc|search}</td></tr>
- * <tr><td>Query               </td><td>{@code 0-9}, {@code a-z}, {@code A-Z}, {@code _-!.~'()*,;:$&+=?/[]@}</td><td>Non-ASCII characters okay                          </td><td>{@code q=green%20robots}                                       </td><td>{@code q=green robots}</td></tr>
- * <tr><td>Fragment            </td><td>{@code 0-9}, {@code a-z}, {@code A-Z}, {@code _-!.~'()*,;:$&+=?/[]@}</td><td>Non-ASCII characters okay                          </td><td>{@code over%206%22}                                            </td><td>{@code over 6"}</td></tr>
- * </table>
- * A URI's host, port and scheme are not eligible for encoding and must not
- * contain illegal characters.
- *
- * <p>To encode a URI, invoke any of the multiple-parameter constructors of this
- * class. These constructors accept your original strings and encode them into
- * their raw form.
- *
- * <p>To decode a URI, invoke the single-string constructor, and then use the
- * appropriate accessor methods to get the decoded components.
- *
- * <p>The {@link URL} class can be used to retrieve resources by their URI.
- */
 @SuppressWarnings("all")
 public final class URI implements Comparable<URI>, Serializable {
 
diff --git a/jtransc-rt/src/java/net/URLEncoder.java b/jtransc-rt/src/java/net/URLEncoder.java
@@ -28,7 +28,7 @@ public static String encode(String s) {
 	public static String encode(String s, String enc) throws UnsupportedEncodingException {
 		final StringBuilder sb = new StringBuilder(s.length());
 		byte[] data = s.getBytes(enc);
-		//for (byte c : data) System.out.printf("%02X\n", c & 0xFF);
+
 		for (byte c : data) {
 			if (c == (byte) ' ') {
 				sb.append('+');
diff --git a/jtransc-rt/src/java/text/NumberFormat.java b/jtransc-rt/src/java/text/NumberFormat.java
@@ -52,7 +52,7 @@ protected NumberFormat() {
 
 	private NumberFormat(Locale locale) {
 		this.locale = locale;
-		//System.out.println(locale.getLanguage());
+		//JTranscConsole.log(locale.getLanguage());
 
 		// https://docs.oracle.com/cd/E19455-01/806-0169/overview-9/index.html
 		intGroupDigits = JTranscLocale.getIntNumberOfDigits(locale);
diff --git a/jtransc-rt/src/java/util/GregorianCalendar.java b/jtransc-rt/src/java/util/GregorianCalendar.java
diff --git a/jtransc-rt/src/java/util/Properties.java b/jtransc-rt/src/java/util/Properties.java
diff --git a/jtransc-rt/src/java/util/Random.java b/jtransc-rt/src/java/util/Random.java
diff --git a/jtransc-rt/src/java/util/TreeMap.java b/jtransc-rt/src/java/util/TreeMap.java

Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ public void reset(long init){`
`135`	`135`	`adler.reset();`
`136`	`136`	`}`
`137`	`137`	`else{`
`138`		`- System.err.println("unsupported operation");`
	`138`	`+ JTranscConsole.error("unsupported operation");`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`	`public long getValue(){`
Original file line number	Diff line number	Diff line change
`@@ -30,6 +30,7 @@`
`30`	`30`	`package regexodus;`
`31`	`31`
`32`	`32`	`import com.jtransc.annotation.JTranscInvisible;`
	`33`	`+import com.jtransc.io.JTranscConsole;`
`33`	`34`	`import regexodus.ds.IntBitSet;`
`34`	`35`
`35`	`36`	`import java.util.ArrayList;`
`@@ -886,9 +887,9 @@ public static void main(String[] args) {`
`886`	`887`
`887`	`888`
`888`	`889`	`private static void printRealm(ArrayList<String> realm, String name) {`
`889`		`- System.out.println(name + ":");`
	`890`	`+ JTranscConsole.log(name + ":");`
`890`	`891`	`for (String s : realm) {`
`891`		`- System.out.println(" " + s);`
	`892`	`+ JTranscConsole.log(" " + s);`
`892`	`893`	`}`
`893`	`894`	`}`
`894`	`895`	`}`
Original file line number	Diff line number	Diff line change
`@@ -164,8 +164,8 @@ public long getLastModifiedTime(File f) {`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`public long getLength(File f) {`
`167`		`- //System.out.println(f.getPath());`
`168`		`- //System.out.println(f.getAbsolutePath());`
	`167`	`+ //JTranscConsole.log(f.getPath());`
	`168`	`+ //JTranscConsole.log(f.getAbsolutePath());`
`169`	`169`	`return JTranscSyncIO.impl.getLength(normalize2(f));`
`170`	`170`	`}`
`171`	`171`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public RandomAccessFile(File file, String mode) throws FileNotFoundException {`
`53`	`53`	`fd = new FileDescriptor();`
`54`	`54`	`//fd.attach(this);`
`55`	`55`	`path = name;`
`56`		`- //System.out.println("RandomAccessFile");`
	`56`	`+ //JTranscConsole.log("RandomAccessFile");`
`57`	`57`	`jfd = JTranscSyncIO.impl.open(name, imode);`
`58`	`58`	`}`
`59`	`59`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ public static int _parseInt(String input, int radix) {`
`111`	`111`	`}`
`112`	`112`	`result *= radix;`
`113`	`113`	`result += JTranscCType.decodeDigit(c);`
`114`		`- //System.out.println(c + ": " + JTranscCType.decodeDigit(c));`
	`114`	`+ //JTranscConsole.log(c + ": " + JTranscCType.decodeDigit(c));`
`115`	`115`	`}`
`116`	`116`	`return sign * result;`
`117`	`117`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@`
`22`	`22`	`import com.jtransc.annotation.JTranscMethodBody;`
`23`	`23`	`import com.jtransc.annotation.haxe.HaxeAddMembers;`
`24`	`24`	`import com.jtransc.annotation.haxe.HaxeMethodBody;`
	`25`	`+import com.jtransc.io.JTranscConsole;`
`25`	`26`
`26`	`27`	`import java.util.Collection;`
`27`	`28`	`import java.util.HashMap;`
`@@ -208,7 +209,7 @@ public synchronized void start() {`
`208`	`209`	`"});"`
`209`	`210`	`)`
`210`	`211`	`private void _start() {`
`211`		`- System.err.println("WARNING: Threads not supported! Executing thread code in the parent's thread!");`
	`212`	`+ JTranscConsole.error("WARNING: Threads not supported! Executing thread code in the parent's thread!");`
`212`	`213`	`runInternal();`
`213`	`214`	`}`
`214`	`215`
`@@ -294,7 +295,7 @@ public void destroy() {`
`294`	`295`	`}`
`295`	`296`
`296`	`297`	`public final boolean isAlive() {`
`297`		`- //System.out.println("isAlive: " + _isAlive);`
	`298`	`+ //JTranscConsole.log("isAlive: " + _isAlive);`
`298`	`299`	`return _isAlive;`
`299`	`300`	`}`
`300`	`301`
`@@ -426,8 +427,8 @@ public interface UncaughtExceptionHandler {`
`426`	`427`	`}`
`427`	`428`
`428`	`429`	`static public UncaughtExceptionHandler defaultUncaughtExceptionHandler = (t, e) -> {`
`429`		`- System.out.println(t);`
`430`		`- System.out.println(e);`
	`430`	`+ JTranscConsole.log(t);`
	`431`	`+ JTranscConsole.log(e);`
`431`	`432`	`};`
`432`	`433`
`433`	`434`	`public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,8 @@`
`16`	`16`
`17`	`17`	`package java.lang;`
`18`	`18`
	`19`	`+import com.jtransc.io.JTranscConsole;`
	`20`	`+`
`19`	`21`	`import java.util.ArrayList;`
`20`	`22`	`import java.util.Arrays;`
`21`	`23`	`import java.util.LinkedHashSet;`
`@@ -175,7 +177,7 @@ synchronized public final void destroy() {`
`175`	`177`	`}`
`176`	`178`
`177`	`179`	`public void list() {`
`178`		`- System.out.println("Unimplemented ThreadGroup.list()");`
	`180`	`+ JTranscConsole.log("Unimplemented ThreadGroup.list()");`
`179`	`181`	`}`
`180`	`182`
`181`	`183`	`native public void uncaughtException(Thread t, Throwable e);`