Cleanup and webapp testing.
This commit is contained in:
dev
@ -8,7 +8,6 @@
|
||||
<pathelement path="${java.class.path}" />
|
||||
<pathelement location="${i2plib}/i2p.jar" />
|
||||
<pathelement location="${i2plib}/i2ptunnel.jar" />
|
||||
<pathelement location="${i2plib}/i2psnark.jar" />
|
||||
<pathelement location="${jettylib}/ant.jar"/>
|
||||
<pathelement location="${jettylib}/org.mortbay.jetty.jar"/>
|
||||
<pathelement location="${jettylib}/jasper-compiler.jar" />
|
||||
@ -32,7 +31,7 @@
|
||||
srcdir="./java"
|
||||
debug="true" deprecation="on" source="1.5" target="1.5"
|
||||
destdir="./build/obj"
|
||||
classpath="${i2plib}/i2p.jar:${i2plib}/i2ptunnel.jar:${i2plib}/i2psnark.jar:${i2plib}/systray.jar:${i2plib}/org.mortbay.jetty.jar" >
|
||||
classpath="${i2plib}/i2p.jar:${jettylib}/javax.servlet.jar" >
|
||||
<compilerarg line="${javac.compilerargs}" />
|
||||
</javac>
|
||||
</target>
|
||||
|
||||
@ -19,8 +19,10 @@ package net.i2p.i2pcontrol;
|
||||
import java.io.File;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.util.Calendar;
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
import java.util.Date;
|
||||
|
||||
import net.i2p.I2PAppContext;
|
||||
import net.i2p.data.Base32;
|
||||
@ -30,11 +32,7 @@ import net.i2p.data.PrivateKeyFile;
|
||||
import net.i2p.util.FileUtil;
|
||||
import net.i2p.util.I2PAppThread;
|
||||
import net.i2p.util.Log;
|
||||
import net.i2p.i2ptunnel.TunnelController;
|
||||
import net.i2p.apps.systray.UrlLauncher;
|
||||
|
||||
import org.mortbay.http.HttpContext;
|
||||
import org.mortbay.jetty.Server;
|
||||
|
||||
/**
|
||||
* This handles the starting and stopping of an eepsite tunnel and jetty
|
||||
@ -49,9 +47,6 @@ import org.mortbay.jetty.Server;
|
||||
*/
|
||||
public class I2PControlController {
|
||||
private static final Log _log = I2PAppContext.getGlobalContext().logManager().getLog(I2PControlController.class);
|
||||
private static Server _server;
|
||||
private static TunnelController _tunnel;
|
||||
private static ZzzOT _zzzot;
|
||||
private static Object _lock = new Object();
|
||||
|
||||
public static void main(String args[]) {
|
||||
@ -64,169 +59,25 @@ public class I2PControlController {
|
||||
else
|
||||
throw new IllegalArgumentException("Usage: PluginController -d $PLUGIN [start|stop]");
|
||||
}
|
||||
|
||||
public static Torrents getTorrents() {
|
||||
synchronized(_lock) {
|
||||
if (_zzzot == null)
|
||||
_zzzot = new ZzzOT();
|
||||
}
|
||||
return _zzzot.getTorrents();
|
||||
|
||||
public static String getTestString(){
|
||||
Calendar cal = Calendar.getInstance();
|
||||
int hour = cal.get(Calendar.HOUR_OF_DAY);
|
||||
int minute = cal.get(Calendar.MINUTE);
|
||||
int second = cal.get(Calendar.SECOND);
|
||||
int ms = cal.get(Calendar.MILLISECOND);
|
||||
return hour+":"+minute+":"+second+":"+ms;
|
||||
}
|
||||
|
||||
|
||||
private static void start(String args[]) {
|
||||
File pluginDir = new File(args[1]);
|
||||
if (!pluginDir.exists())
|
||||
throw new IllegalArgumentException("Plugin directory " + pluginDir.getAbsolutePath() + " does not exist");
|
||||
|
||||
// We create the private key file in advance, so that we can
|
||||
// create the help.html file from the templates
|
||||
// without waiting for i2ptunnel to create it AND build the tunnels before returning.
|
||||
_log.error("NOTICE: I2PControl started");
|
||||
/*
|
||||
Destination dest = null;
|
||||
File key = new File(pluginDir, "eepPriv.dat");
|
||||
if (!key.exists()) {
|
||||
PrivateKeyFile pkf = new PrivateKeyFile(new File(pluginDir, "eepPriv.dat"));
|
||||
try {
|
||||
dest = pkf.createIfAbsent();
|
||||
} catch (Exception e) {
|
||||
_log.error("Unable to create " + key.getAbsolutePath() + ' ' + e);
|
||||
throw new IllegalArgumentException("Unable to create " + key.getAbsolutePath() + ' ' + e);
|
||||
}
|
||||
_log.error("NOTICE: ZzzOT: New eepsite keys created in " + key.getAbsolutePath());
|
||||
_log.error("NOTICE: ZzzOT: You should back up this file!");
|
||||
String b32 = Base32.encode(dest.calculateHash().getData()) + ".b32.i2p";
|
||||
String b64 = dest.toBase64();
|
||||
_log.error("NOTICE: ZzzOT: Your base 32 address is " + b32);
|
||||
_log.error("NOTICE: ZzzOT: Your base 64 address is " + b64);
|
||||
}
|
||||
*/
|
||||
// Don't startJetty(pluginDir, dest);
|
||||
// Don't startI2PTunnel(pluginDir, dest);
|
||||
}
|
||||
|
||||
|
||||
private static void startI2PTunnel(File pluginDir, Destination dest) {
|
||||
File i2ptunnelConfig = new File(pluginDir, "i2ptunnel.config");
|
||||
Properties i2ptunnelProps = new Properties();
|
||||
try {
|
||||
DataHelper.loadProps(i2ptunnelProps, i2ptunnelConfig);
|
||||
} catch (IOException ioe) {
|
||||
_log.error("Cannot open " + i2ptunnelConfig.getAbsolutePath() + ' ' + ioe);
|
||||
throw new IllegalArgumentException("Cannot open " + i2ptunnelConfig.getAbsolutePath() + ' ' + ioe);
|
||||
}
|
||||
TunnelController tun = new TunnelController(i2ptunnelProps, "tunnel.0.");
|
||||
// start in foreground so we can get the destination
|
||||
//tun.startTunnelBackground();
|
||||
tun.startTunnel();
|
||||
if (dest != null) {
|
||||
List msgs = tun.clearMessages();
|
||||
for (Object s : msgs) {
|
||||
_log.error("NOTICE: ZzzOT Tunnel message: " + s);
|
||||
}
|
||||
}
|
||||
_tunnel = tun;
|
||||
}
|
||||
|
||||
private static void startJetty(File pluginDir, Destination dest) {
|
||||
if (_server != null)
|
||||
throw new IllegalArgumentException("Jetty already running!");
|
||||
migrateJettyXML(pluginDir);
|
||||
I2PAppContext context = I2PAppContext.getGlobalContext();
|
||||
File tmpdir = new File(context.getTempDir().getAbsolutePath(), "/zzzot-work");
|
||||
tmpdir.mkdir();
|
||||
File jettyXml = new File(pluginDir, "jetty.xml");
|
||||
try {
|
||||
Server serv = new Server(jettyXml.getAbsolutePath());
|
||||
HttpContext[] hcs = serv.getContexts();
|
||||
for (int i = 0; i < hcs.length; i++)
|
||||
hcs[i].setTempDirectory(tmpdir);
|
||||
serv.start();
|
||||
_server = serv;
|
||||
} catch (Throwable t) {
|
||||
_log.error("ZzzOT jetty start failed", t);
|
||||
throw new IllegalArgumentException("Jetty start failed " + t);
|
||||
}
|
||||
if (dest != null)
|
||||
launchHelp(pluginDir, dest);
|
||||
}
|
||||
|
||||
private static void stop() {
|
||||
stopI2PTunnel();
|
||||
stopJetty();
|
||||
if (_zzzot != null)
|
||||
_zzzot.stop();
|
||||
}
|
||||
|
||||
private static void stopI2PTunnel() {
|
||||
if (_tunnel == null)
|
||||
return;
|
||||
try {
|
||||
_tunnel.stopTunnel();
|
||||
} catch (Throwable t) {
|
||||
_log.error("ZzzOT tunnel stop failed", t);
|
||||
throw new IllegalArgumentException("Tunnel stop failed " + t);
|
||||
}
|
||||
_tunnel = null;
|
||||
}
|
||||
|
||||
private static void stopJetty() {
|
||||
if (_server == null)
|
||||
return;
|
||||
try {
|
||||
_server.stop();
|
||||
} catch (Throwable t) {
|
||||
_log.error("ZzzOT jetty stop failed", t);
|
||||
throw new IllegalArgumentException("Jetty stop failed " + t);
|
||||
}
|
||||
_server = null;
|
||||
}
|
||||
|
||||
/** put the directory in the jetty.xml file */
|
||||
private static void migrateJettyXML(File pluginDir) {
|
||||
File outFile = new File(pluginDir, "jetty.xml");
|
||||
if (outFile.exists())
|
||||
return;
|
||||
File fileTmpl = new File(pluginDir, "templates/jetty.xml");
|
||||
try {
|
||||
String props = FileUtil.readTextFile(fileTmpl.getAbsolutePath(), 250, true);
|
||||
if (props == null)
|
||||
throw new IOException(fileTmpl.getAbsolutePath() + " open failed");
|
||||
props = props.replace("$PLUGIN", pluginDir.getAbsolutePath());
|
||||
FileOutputStream os = new FileOutputStream(outFile);
|
||||
os.write(props.getBytes("UTF-8"));
|
||||
os.close();
|
||||
} catch (IOException ioe) {
|
||||
_log.error("jetty.xml migrate failed", ioe);
|
||||
}
|
||||
}
|
||||
|
||||
/** put the directory, base32, and base64 info in the help.html file and launch a browser window to display it */
|
||||
private static void launchHelp(File pluginDir, Destination dest) {
|
||||
File fileTmpl = new File(pluginDir, "templates/help.html");
|
||||
File outFile = new File(pluginDir, "eepsite/docroot/help.html");
|
||||
String b32 = Base32.encode(dest.calculateHash().getData()) + ".b32.i2p";
|
||||
String b64 = dest.toBase64();
|
||||
try {
|
||||
String html = FileUtil.readTextFile(fileTmpl.getAbsolutePath(), 100, true);
|
||||
if (html == null)
|
||||
throw new IOException(fileTmpl.getAbsolutePath() + " open failed");
|
||||
html = html.replace("$PLUGIN", pluginDir.getAbsolutePath());
|
||||
html = html.replace("$B32", b32);
|
||||
html = html.replace("$B64", b64);
|
||||
FileOutputStream os = new FileOutputStream(outFile);
|
||||
os.write(html.getBytes("UTF-8"));
|
||||
os.close();
|
||||
Thread t = new I2PAppThread(new Launcher(), "ZzzOTHelp", true);
|
||||
t.start();
|
||||
} catch (IOException ioe) {
|
||||
_log.error("ZzzOT help launch failed", ioe);
|
||||
}
|
||||
}
|
||||
|
||||
private static class Launcher implements Runnable {
|
||||
public void run() {
|
||||
UrlLauncher.main(new String[] { "http://127.0.0.1:7662/help.html" } );
|
||||
}
|
||||
// Maybe do things. Perhaps.
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,37 +0,0 @@
|
||||
package net.i2p.i2pcontrol;
|
||||
/*
|
||||
* Copyright 2010 zzz (zzz@mail.i2p)
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import java.io.UnsupportedEncodingException;
|
||||
|
||||
import net.i2p.data.ByteArray;
|
||||
|
||||
/**
|
||||
* A 20-byte SHA1 info hash
|
||||
*/
|
||||
public class InfoHash extends ByteArray {
|
||||
|
||||
public InfoHash(String data) throws UnsupportedEncodingException {
|
||||
this(data.getBytes("ISO-8859-1"));
|
||||
}
|
||||
|
||||
public InfoHash(byte[] data) {
|
||||
super(data);
|
||||
if (data.length != 20)
|
||||
throw new IllegalArgumentException("Bad infohash length: " + data.length);
|
||||
}
|
||||
}
|
||||
@ -1,37 +0,0 @@
|
||||
package net.i2p.i2pcontrol;
|
||||
/*
|
||||
* Copyright 2010 zzz (zzz@mail.i2p)
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import java.io.UnsupportedEncodingException;
|
||||
|
||||
import net.i2p.data.ByteArray;
|
||||
|
||||
/**
|
||||
* A 20-byte peer ID
|
||||
*/
|
||||
public class PID extends ByteArray {
|
||||
|
||||
public PID(String data) throws UnsupportedEncodingException {
|
||||
this(data.getBytes("ISO-8859-1"));
|
||||
}
|
||||
|
||||
public PID(byte[] data) {
|
||||
super(data);
|
||||
if (data.length != 20)
|
||||
throw new IllegalArgumentException("Bad peer ID length: " + data.length);
|
||||
}
|
||||
}
|
||||
@ -1,92 +0,0 @@
|
||||
package net.i2p.i2pcontrol;
|
||||
/*
|
||||
* Copyright 2010 zzz (zzz@mail.i2p)
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.util.HashMap;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import net.i2p.crypto.SHA256Generator;
|
||||
import net.i2p.data.Base64;
|
||||
import net.i2p.data.Destination;
|
||||
import net.i2p.data.Hash;
|
||||
import net.i2p.util.SimpleScheduler;
|
||||
import net.i2p.util.SimpleTimer;
|
||||
|
||||
/*
|
||||
* A single peer for a single torrent.
|
||||
* Save a couple stats, and implements
|
||||
* a Map so we can BEncode it
|
||||
* So it's like PeerID but in reverse - we make a Map from the
|
||||
* data. PeerID makes the data from a Map.
|
||||
*/
|
||||
public class Peer extends HashMap<String, Object> {
|
||||
|
||||
private long lastSeen;
|
||||
private long bytesLeft;
|
||||
private static final ConcurrentHashMap<String, String> destCache = new ConcurrentHashMap();
|
||||
private static final Integer PORT = Integer.valueOf(6881);
|
||||
private static final long CLEAN_TIME = 3*60*60*1000;
|
||||
|
||||
static {
|
||||
SimpleScheduler.getInstance().addPeriodicEvent(new Cleaner(), CLEAN_TIME);
|
||||
}
|
||||
|
||||
public Peer(byte[] id, Destination address) {
|
||||
super(3);
|
||||
if (id.length != 20)
|
||||
throw new IllegalArgumentException("Bad peer ID length: " + id.length);
|
||||
put("peer id", id);
|
||||
put("port", PORT);
|
||||
// cache the 520-byte address strings
|
||||
String dest = address.toBase64() + ".i2p";
|
||||
String oldDest = destCache.putIfAbsent(dest, dest);
|
||||
if (oldDest != null)
|
||||
dest = oldDest;
|
||||
put("ip", dest);
|
||||
}
|
||||
|
||||
public void setLeft(long l) {
|
||||
bytesLeft = l;
|
||||
lastSeen = System.currentTimeMillis();
|
||||
}
|
||||
|
||||
public boolean isSeed() {
|
||||
return bytesLeft <= 0;
|
||||
}
|
||||
|
||||
public long lastSeen() {
|
||||
return lastSeen;
|
||||
}
|
||||
|
||||
/** convert b64.i2p to a Hash, then to a binary string */
|
||||
/* or should we just store it in the constructor? cache it? */
|
||||
public String getHash() {
|
||||
String ip = (String) get("ip");
|
||||
byte[] b = Base64.decode(ip.substring(0, ip.length() - 4));
|
||||
Hash h = SHA256Generator.getInstance().calculateHash(b);
|
||||
try {
|
||||
return new String(h.getData(), "ISO-8859-1");
|
||||
} catch (UnsupportedEncodingException uee) { return null; }
|
||||
}
|
||||
|
||||
private static class Cleaner implements SimpleTimer.TimedEvent {
|
||||
public void timeReached() {
|
||||
destCache.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,42 +0,0 @@
|
||||
package net.i2p.i2pcontrol;
|
||||
/*
|
||||
* Copyright 2010 zzz (zzz@mail.i2p)
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
/**
|
||||
* All the peers for a single torrent
|
||||
*/
|
||||
public class Peers extends ConcurrentHashMap<PID, Peer> {
|
||||
|
||||
public Peers() {
|
||||
super();
|
||||
}
|
||||
|
||||
public int countSeeds() {
|
||||
int rv = 0;
|
||||
for (Peer p : values()) {
|
||||
if (p.isSeed())
|
||||
rv++;
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
|
||||
public int countLeeches() {
|
||||
return size() - countSeeds();
|
||||
}
|
||||
}
|
||||
@ -1,158 +0,0 @@
|
||||
// ========================================================================
|
||||
// $Id: ForwardHandler.java,v 1.16 2005/08/13 00:01:26 gregwilkins Exp $
|
||||
// Copyright 199-2004 Mort Bay Consulting Pty. Ltd.
|
||||
// ------------------------------------------------------------------------
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
// ========================================================================
|
||||
|
||||
package net.i2p.i2pcontrol;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Map;
|
||||
|
||||
import org.mortbay.http.HttpException;
|
||||
import org.mortbay.http.HttpMessage;
|
||||
import org.mortbay.http.HttpRequest;
|
||||
import org.mortbay.http.HttpResponse;
|
||||
import org.mortbay.http.PathMap;
|
||||
import org.mortbay.http.handler.AbstractHttpHandler;
|
||||
import org.mortbay.util.URI;
|
||||
import org.mortbay.util.UrlEncoded;
|
||||
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/** Forward Request Handler.
|
||||
* Forwards a request to a new URI. Experimental - use with caution.
|
||||
* @version $Revision: 1.16 $
|
||||
* @author Greg Wilkins (gregw)
|
||||
*
|
||||
* Just like ForwardHandler but forwards query parameters too
|
||||
* And took out the dependency on apache logging
|
||||
* @author zzz
|
||||
*/
|
||||
public class QForwardHandler extends AbstractHttpHandler
|
||||
{
|
||||
PathMap _forward = new PathMap();
|
||||
String _root;
|
||||
boolean _handleQueries = false;
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/** Constructor.
|
||||
*/
|
||||
public QForwardHandler()
|
||||
{}
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/** Constructor.
|
||||
* @param rootForward
|
||||
*/
|
||||
public QForwardHandler(String rootForward)
|
||||
{
|
||||
_root=rootForward;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/** Add a forward mapping.
|
||||
* @param pathSpecInContext The path to forward from
|
||||
* @param newPath The path to forward to.
|
||||
*/
|
||||
public void addForward(String pathSpecInContext,
|
||||
String newPath)
|
||||
{
|
||||
_forward.put(pathSpecInContext,newPath);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/** Add a forward mapping for root path.
|
||||
* This allows a forward for exactly / which is the default
|
||||
* path in a pathSpec.
|
||||
* @param newPath The path to forward to.
|
||||
*/
|
||||
public void setRootForward(String newPath)
|
||||
{
|
||||
_root=newPath;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/** Set the Handler up to cope with forwards to paths that contain query
|
||||
* elements (e.g. "/blah"->"/foo?a=b").
|
||||
* AND (I2P) pass params through (e.g. "/blah?c=d? -> "/foo?c=d? ).
|
||||
* @param b
|
||||
*/
|
||||
public void setHandleQueries(boolean b)
|
||||
{
|
||||
_handleQueries = b;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
public void handle(String pathInContext,
|
||||
String pathParams,
|
||||
HttpRequest request,
|
||||
HttpResponse response)
|
||||
throws HttpException, IOException
|
||||
{
|
||||
String newPath=null;
|
||||
String query=null;
|
||||
if (_root!=null && ("/".equals(pathInContext) || pathInContext.startsWith("/;")))
|
||||
newPath=_root;
|
||||
else
|
||||
{
|
||||
Map.Entry entry = _forward.getMatch(pathInContext);
|
||||
if (entry!=null)
|
||||
{
|
||||
String match = (String)entry.getValue();
|
||||
if (_handleQueries)
|
||||
{
|
||||
int hook = match.indexOf('?');
|
||||
if (hook != -1){
|
||||
query = match.substring(hook+1);
|
||||
match = match.substring(0, hook);
|
||||
}
|
||||
}
|
||||
String info=PathMap.pathInfo((String)entry.getKey(),pathInContext);
|
||||
newPath=info==null?match:(URI.addPaths(match,info));
|
||||
}
|
||||
}
|
||||
|
||||
if (newPath!=null)
|
||||
{
|
||||
// this is the new part for i2p
|
||||
// setPath() changes the request URI and loses the parameters
|
||||
// so save them and add them back
|
||||
Map saved = null;
|
||||
if (_handleQueries){
|
||||
request.setCharacterEncoding("ISO-8859-1", false);
|
||||
saved = request.getParameters();
|
||||
}
|
||||
|
||||
int last=request.setState(HttpMessage.__MSG_EDITABLE);
|
||||
String context=getHttpContext().getContextPath();
|
||||
if (context.length()==1)
|
||||
request.setPath(newPath);
|
||||
else
|
||||
request.setPath(URI.addPaths(context,newPath));
|
||||
if (_handleQueries && query != null){
|
||||
// add forwarded to query string to parameters
|
||||
UrlEncoded.decodeTo(query, request.getParameters());
|
||||
}
|
||||
|
||||
// this is the new part for i2p
|
||||
if (_handleQueries){
|
||||
// add them back
|
||||
request.getParameters().putAll(saved);
|
||||
}
|
||||
|
||||
request.setState(last);
|
||||
getHttpContext().getHttpServer().service(request,response);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,37 +0,0 @@
|
||||
package net.i2p.i2pcontrol;
|
||||
/*
|
||||
* Copyright 2010 zzz (zzz@mail.i2p)
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
/**
|
||||
* All the torrents
|
||||
*/
|
||||
public class Torrents extends ConcurrentHashMap<InfoHash, Peers> {
|
||||
|
||||
public Torrents() {
|
||||
super();
|
||||
}
|
||||
|
||||
public int countPeers() {
|
||||
int rv = 0;
|
||||
for (Peers p : values()) {
|
||||
rv += p.size();
|
||||
}
|
||||
return rv;
|
||||
}
|
||||
}
|
||||
@ -1,66 +0,0 @@
|
||||
package net.i2p.i2pcontrol;
|
||||
/*
|
||||
* Copyright 2010 zzz (zzz@mail.i2p)
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
import java.util.Iterator;
|
||||
|
||||
import net.i2p.util.SimpleScheduler;
|
||||
import net.i2p.util.SimpleTimer;
|
||||
|
||||
/**
|
||||
* Instantiate this to fire it up
|
||||
*/
|
||||
class ZzzOT {
|
||||
|
||||
private Torrents _torrents;
|
||||
private static final long CLEAN_TIME = 4*60*1000;
|
||||
private static final long EXPIRE_TIME = 60*60*1000;
|
||||
|
||||
ZzzOT() {
|
||||
_torrents = new Torrents();
|
||||
SimpleScheduler.getInstance().addPeriodicEvent(new Cleaner(), CLEAN_TIME);
|
||||
}
|
||||
|
||||
Torrents getTorrents() {
|
||||
return _torrents;
|
||||
}
|
||||
|
||||
void stop() {
|
||||
_torrents.clear();
|
||||
// no way to stop the cleaner
|
||||
}
|
||||
|
||||
private class Cleaner implements SimpleTimer.TimedEvent {
|
||||
|
||||
public void timeReached() {
|
||||
long now = System.currentTimeMillis();
|
||||
for (Iterator<Peers> iter = _torrents.values().iterator(); iter.hasNext(); ) {
|
||||
Peers p = iter.next();
|
||||
int recent = 0;
|
||||
for (Iterator<Peer> iterp = p.values().iterator(); iterp.hasNext(); ) {
|
||||
Peer peer = iterp.next();
|
||||
if (peer.lastSeen() < now - EXPIRE_TIME)
|
||||
iterp.remove();
|
||||
else
|
||||
recent++;
|
||||
}
|
||||
if (recent <= 0)
|
||||
iter.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
147
src/java/org/json/simple/ItemList.java
Normal file
147
src/java/org/json/simple/ItemList.java
Normal file
@ -0,0 +1,147 @@
|
||||
/*
|
||||
* $Id: ItemList.java,v 1.1 2006/04/15 14:10:48 platform Exp $
|
||||
* Created on 2006-3-24
|
||||
*/
|
||||
package org.json.simple;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.StringTokenizer;
|
||||
|
||||
/**
|
||||
* |a:b:c| => |a|,|b|,|c|
|
||||
* |:| => ||,||
|
||||
* |a:| => |a|,||
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public class ItemList {
|
||||
private String sp=",";
|
||||
List items=new ArrayList();
|
||||
|
||||
|
||||
public ItemList(){}
|
||||
|
||||
|
||||
public ItemList(String s){
|
||||
this.split(s,sp,items);
|
||||
}
|
||||
|
||||
public ItemList(String s,String sp){
|
||||
this.sp=s;
|
||||
this.split(s,sp,items);
|
||||
}
|
||||
|
||||
public ItemList(String s,String sp,boolean isMultiToken){
|
||||
split(s,sp,items,isMultiToken);
|
||||
}
|
||||
|
||||
public List getItems(){
|
||||
return this.items;
|
||||
}
|
||||
|
||||
public String[] getArray(){
|
||||
return (String[])this.items.toArray();
|
||||
}
|
||||
|
||||
public void split(String s,String sp,List append,boolean isMultiToken){
|
||||
if(s==null || sp==null)
|
||||
return;
|
||||
if(isMultiToken){
|
||||
StringTokenizer tokens=new StringTokenizer(s,sp);
|
||||
while(tokens.hasMoreTokens()){
|
||||
append.add(tokens.nextToken().trim());
|
||||
}
|
||||
}
|
||||
else{
|
||||
this.split(s,sp,append);
|
||||
}
|
||||
}
|
||||
|
||||
public void split(String s,String sp,List append){
|
||||
if(s==null || sp==null)
|
||||
return;
|
||||
int pos=0;
|
||||
int prevPos=0;
|
||||
do{
|
||||
prevPos=pos;
|
||||
pos=s.indexOf(sp,pos);
|
||||
if(pos==-1)
|
||||
break;
|
||||
append.add(s.substring(prevPos,pos).trim());
|
||||
pos+=sp.length();
|
||||
}while(pos!=-1);
|
||||
append.add(s.substring(prevPos).trim());
|
||||
}
|
||||
|
||||
public void setSP(String sp){
|
||||
this.sp=sp;
|
||||
}
|
||||
|
||||
public void add(int i,String item){
|
||||
if(item==null)
|
||||
return;
|
||||
items.add(i,item.trim());
|
||||
}
|
||||
|
||||
public void add(String item){
|
||||
if(item==null)
|
||||
return;
|
||||
items.add(item.trim());
|
||||
}
|
||||
|
||||
public void addAll(ItemList list){
|
||||
items.addAll(list.items);
|
||||
}
|
||||
|
||||
public void addAll(String s){
|
||||
this.split(s,sp,items);
|
||||
}
|
||||
|
||||
public void addAll(String s,String sp){
|
||||
this.split(s,sp,items);
|
||||
}
|
||||
|
||||
public void addAll(String s,String sp,boolean isMultiToken){
|
||||
this.split(s,sp,items,isMultiToken);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param i 0-based
|
||||
* @return
|
||||
*/
|
||||
public String get(int i){
|
||||
return (String)items.get(i);
|
||||
}
|
||||
|
||||
public int size(){
|
||||
return items.size();
|
||||
}
|
||||
|
||||
public String toString(){
|
||||
return toString(sp);
|
||||
}
|
||||
|
||||
public String toString(String sp){
|
||||
StringBuffer sb=new StringBuffer();
|
||||
|
||||
for(int i=0;i<items.size();i++){
|
||||
if(i==0)
|
||||
sb.append(items.get(i));
|
||||
else{
|
||||
sb.append(sp);
|
||||
sb.append(items.get(i));
|
||||
}
|
||||
}
|
||||
return sb.toString();
|
||||
|
||||
}
|
||||
|
||||
public void clear(){
|
||||
items.clear();
|
||||
}
|
||||
|
||||
public void reset(){
|
||||
sp=",";
|
||||
items.clear();
|
||||
}
|
||||
}
|
||||
107
src/java/org/json/simple/JSONArray.java
Normal file
107
src/java/org/json/simple/JSONArray.java
Normal file
@ -0,0 +1,107 @@
|
||||
/*
|
||||
* $Id: JSONArray.java,v 1.1 2006/04/15 14:10:48 platform Exp $
|
||||
* Created on 2006-4-10
|
||||
*/
|
||||
package org.json.simple;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.Writer;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
|
||||
/**
|
||||
* A JSON array. JSONObject supports java.util.List interface.
|
||||
*
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public class JSONArray extends ArrayList implements List, JSONAware, JSONStreamAware {
|
||||
private static final long serialVersionUID = 3957988303675231981L;
|
||||
|
||||
/**
|
||||
* Encode a list into JSON text and write it to out.
|
||||
* If this list is also a JSONStreamAware or a JSONAware, JSONStreamAware and JSONAware specific behaviours will be ignored at this top level.
|
||||
*
|
||||
* @see org.json.simple.JSONValue#writeJSONString(Object, Writer)
|
||||
*
|
||||
* @param list
|
||||
* @param out
|
||||
*/
|
||||
public static void writeJSONString(List list, Writer out) throws IOException{
|
||||
if(list == null){
|
||||
out.write("null");
|
||||
return;
|
||||
}
|
||||
|
||||
boolean first = true;
|
||||
Iterator iter=list.iterator();
|
||||
|
||||
out.write('[');
|
||||
while(iter.hasNext()){
|
||||
if(first)
|
||||
first = false;
|
||||
else
|
||||
out.write(',');
|
||||
|
||||
Object value=iter.next();
|
||||
if(value == null){
|
||||
out.write("null");
|
||||
continue;
|
||||
}
|
||||
|
||||
JSONValue.writeJSONString(value, out);
|
||||
}
|
||||
out.write(']');
|
||||
}
|
||||
|
||||
public void writeJSONString(Writer out) throws IOException{
|
||||
writeJSONString(this, out);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a list to JSON text. The result is a JSON array.
|
||||
* If this list is also a JSONAware, JSONAware specific behaviours will be omitted at this top level.
|
||||
*
|
||||
* @see org.json.simple.JSONValue#toJSONString(Object)
|
||||
*
|
||||
* @param list
|
||||
* @return JSON text, or "null" if list is null.
|
||||
*/
|
||||
public static String toJSONString(List list){
|
||||
if(list == null)
|
||||
return "null";
|
||||
|
||||
boolean first = true;
|
||||
StringBuffer sb = new StringBuffer();
|
||||
Iterator iter=list.iterator();
|
||||
|
||||
sb.append('[');
|
||||
while(iter.hasNext()){
|
||||
if(first)
|
||||
first = false;
|
||||
else
|
||||
sb.append(',');
|
||||
|
||||
Object value=iter.next();
|
||||
if(value == null){
|
||||
sb.append("null");
|
||||
continue;
|
||||
}
|
||||
sb.append(JSONValue.toJSONString(value));
|
||||
}
|
||||
sb.append(']');
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
public String toJSONString(){
|
||||
return toJSONString(this);
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return toJSONString();
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
12
src/java/org/json/simple/JSONAware.java
Normal file
12
src/java/org/json/simple/JSONAware.java
Normal file
@ -0,0 +1,12 @@
|
||||
package org.json.simple;
|
||||
|
||||
/**
|
||||
* Beans that support customized output of JSON text shall implement this interface.
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public interface JSONAware {
|
||||
/**
|
||||
* @return JSON text
|
||||
*/
|
||||
String toJSONString();
|
||||
}
|
||||
129
src/java/org/json/simple/JSONObject.java
Normal file
129
src/java/org/json/simple/JSONObject.java
Normal file
@ -0,0 +1,129 @@
|
||||
/*
|
||||
* $Id: JSONObject.java,v 1.1 2006/04/15 14:10:48 platform Exp $
|
||||
* Created on 2006-4-10
|
||||
*/
|
||||
package org.json.simple;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.Writer;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* A JSON object. Key value pairs are unordered. JSONObject supports java.util.Map interface.
|
||||
*
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public class JSONObject extends HashMap implements Map, JSONAware, JSONStreamAware{
|
||||
private static final long serialVersionUID = -503443796854799292L;
|
||||
|
||||
/**
|
||||
* Encode a map into JSON text and write it to out.
|
||||
* If this map is also a JSONAware or JSONStreamAware, JSONAware or JSONStreamAware specific behaviours will be ignored at this top level.
|
||||
*
|
||||
* @see org.json.simple.JSONValue#writeJSONString(Object, Writer)
|
||||
*
|
||||
* @param map
|
||||
* @param out
|
||||
*/
|
||||
public static void writeJSONString(Map map, Writer out) throws IOException {
|
||||
if(map == null){
|
||||
out.write("null");
|
||||
return;
|
||||
}
|
||||
|
||||
boolean first = true;
|
||||
Iterator iter=map.entrySet().iterator();
|
||||
|
||||
out.write('{');
|
||||
while(iter.hasNext()){
|
||||
if(first)
|
||||
first = false;
|
||||
else
|
||||
out.write(',');
|
||||
Map.Entry entry=(Map.Entry)iter.next();
|
||||
out.write('\"');
|
||||
out.write(escape(String.valueOf(entry.getKey())));
|
||||
out.write('\"');
|
||||
out.write(':');
|
||||
JSONValue.writeJSONString(entry.getValue(), out);
|
||||
}
|
||||
out.write('}');
|
||||
}
|
||||
|
||||
public void writeJSONString(Writer out) throws IOException{
|
||||
writeJSONString(this, out);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a map to JSON text. The result is a JSON object.
|
||||
* If this map is also a JSONAware, JSONAware specific behaviours will be omitted at this top level.
|
||||
*
|
||||
* @see org.json.simple.JSONValue#toJSONString(Object)
|
||||
*
|
||||
* @param map
|
||||
* @return JSON text, or "null" if map is null.
|
||||
*/
|
||||
public static String toJSONString(Map map){
|
||||
if(map == null)
|
||||
return "null";
|
||||
|
||||
StringBuffer sb = new StringBuffer();
|
||||
boolean first = true;
|
||||
Iterator iter=map.entrySet().iterator();
|
||||
|
||||
sb.append('{');
|
||||
while(iter.hasNext()){
|
||||
if(first)
|
||||
first = false;
|
||||
else
|
||||
sb.append(',');
|
||||
|
||||
Map.Entry entry=(Map.Entry)iter.next();
|
||||
toJSONString(String.valueOf(entry.getKey()),entry.getValue(), sb);
|
||||
}
|
||||
sb.append('}');
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
public String toJSONString(){
|
||||
return toJSONString(this);
|
||||
}
|
||||
|
||||
private static String toJSONString(String key,Object value, StringBuffer sb){
|
||||
sb.append('\"');
|
||||
if(key == null)
|
||||
sb.append("null");
|
||||
else
|
||||
JSONValue.escape(key, sb);
|
||||
sb.append('\"').append(':');
|
||||
|
||||
sb.append(JSONValue.toJSONString(value));
|
||||
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
public String toString(){
|
||||
return toJSONString();
|
||||
}
|
||||
|
||||
public static String toString(String key,Object value){
|
||||
StringBuffer sb = new StringBuffer();
|
||||
toJSONString(key, value, sb);
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters (U+0000 through U+001F).
|
||||
* It's the same as JSONValue.escape() only for compatibility here.
|
||||
*
|
||||
* @see org.json.simple.JSONValue#escape(String)
|
||||
*
|
||||
* @param s
|
||||
* @return
|
||||
*/
|
||||
public static String escape(String s){
|
||||
return JSONValue.escape(s);
|
||||
}
|
||||
}
|
||||
15
src/java/org/json/simple/JSONStreamAware.java
Normal file
15
src/java/org/json/simple/JSONStreamAware.java
Normal file
@ -0,0 +1,15 @@
|
||||
package org.json.simple;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.Writer;
|
||||
|
||||
/**
|
||||
* Beans that support customized output of JSON text to a writer shall implement this interface.
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public interface JSONStreamAware {
|
||||
/**
|
||||
* write JSON string to out.
|
||||
*/
|
||||
void writeJSONString(Writer out) throws IOException;
|
||||
}
|
||||
272
src/java/org/json/simple/JSONValue.java
Normal file
272
src/java/org/json/simple/JSONValue.java
Normal file
@ -0,0 +1,272 @@
|
||||
/*
|
||||
* $Id: JSONValue.java,v 1.1 2006/04/15 14:37:04 platform Exp $
|
||||
* Created on 2006-4-15
|
||||
*/
|
||||
package org.json.simple;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.Reader;
|
||||
import java.io.StringReader;
|
||||
import java.io.Writer;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.json.simple.parser.JSONParser;
|
||||
import org.json.simple.parser.ParseException;
|
||||
|
||||
|
||||
/**
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public class JSONValue {
|
||||
/**
|
||||
* Parse JSON text into java object from the input source.
|
||||
* Please use parseWithException() if you don't want to ignore the exception.
|
||||
*
|
||||
* @see org.json.simple.parser.JSONParser#parse(Reader)
|
||||
* @see #parseWithException(Reader)
|
||||
*
|
||||
* @param in
|
||||
* @return Instance of the following:
|
||||
* org.json.simple.JSONObject,
|
||||
* org.json.simple.JSONArray,
|
||||
* java.lang.String,
|
||||
* java.lang.Number,
|
||||
* java.lang.Boolean,
|
||||
* null
|
||||
*
|
||||
*/
|
||||
public static Object parse(Reader in){
|
||||
try{
|
||||
JSONParser parser=new JSONParser();
|
||||
return parser.parse(in);
|
||||
}
|
||||
catch(Exception e){
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public static Object parse(String s){
|
||||
StringReader in=new StringReader(s);
|
||||
return parse(in);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse JSON text into java object from the input source.
|
||||
*
|
||||
* @see org.json.simple.parser.JSONParser
|
||||
*
|
||||
* @param in
|
||||
* @return Instance of the following:
|
||||
* org.json.simple.JSONObject,
|
||||
* org.json.simple.JSONArray,
|
||||
* java.lang.String,
|
||||
* java.lang.Number,
|
||||
* java.lang.Boolean,
|
||||
* null
|
||||
*
|
||||
* @throws IOException
|
||||
* @throws ParseException
|
||||
*/
|
||||
public static Object parseWithException(Reader in) throws IOException, ParseException{
|
||||
JSONParser parser=new JSONParser();
|
||||
return parser.parse(in);
|
||||
}
|
||||
|
||||
public static Object parseWithException(String s) throws ParseException{
|
||||
JSONParser parser=new JSONParser();
|
||||
return parser.parse(s);
|
||||
}
|
||||
|
||||
/**
|
||||
* Encode an object into JSON text and write it to out.
|
||||
* <p>
|
||||
* If this object is a Map or a List, and it's also a JSONStreamAware or a JSONAware, JSONStreamAware or JSONAware will be considered firstly.
|
||||
* <p>
|
||||
* DO NOT call this method from writeJSONString(Writer) of a class that implements both JSONStreamAware and (Map or List) with
|
||||
* "this" as the first parameter, use JSONObject.writeJSONString(Map, Writer) or JSONArray.writeJSONString(List, Writer) instead.
|
||||
*
|
||||
* @see org.json.simple.JSONObject#writeJSONString(Map, Writer)
|
||||
* @see org.json.simple.JSONArray#writeJSONString(List, Writer)
|
||||
*
|
||||
* @param value
|
||||
* @param writer
|
||||
*/
|
||||
public static void writeJSONString(Object value, Writer out) throws IOException {
|
||||
if(value == null){
|
||||
out.write("null");
|
||||
return;
|
||||
}
|
||||
|
||||
if(value instanceof String){
|
||||
out.write('\"');
|
||||
out.write(escape((String)value));
|
||||
out.write('\"');
|
||||
return;
|
||||
}
|
||||
|
||||
if(value instanceof Double){
|
||||
if(((Double)value).isInfinite() || ((Double)value).isNaN())
|
||||
out.write("null");
|
||||
else
|
||||
out.write(value.toString());
|
||||
return;
|
||||
}
|
||||
|
||||
if(value instanceof Float){
|
||||
if(((Float)value).isInfinite() || ((Float)value).isNaN())
|
||||
out.write("null");
|
||||
else
|
||||
out.write(value.toString());
|
||||
return;
|
||||
}
|
||||
|
||||
if(value instanceof Number){
|
||||
out.write(value.toString());
|
||||
return;
|
||||
}
|
||||
|
||||
if(value instanceof Boolean){
|
||||
out.write(value.toString());
|
||||
return;
|
||||
}
|
||||
|
||||
if((value instanceof JSONStreamAware)){
|
||||
((JSONStreamAware)value).writeJSONString(out);
|
||||
return;
|
||||
}
|
||||
|
||||
if((value instanceof JSONAware)){
|
||||
out.write(((JSONAware)value).toJSONString());
|
||||
return;
|
||||
}
|
||||
|
||||
if(value instanceof Map){
|
||||
JSONObject.writeJSONString((Map)value, out);
|
||||
return;
|
||||
}
|
||||
|
||||
if(value instanceof List){
|
||||
JSONArray.writeJSONString((List)value, out);
|
||||
return;
|
||||
}
|
||||
|
||||
out.write(value.toString());
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert an object to JSON text.
|
||||
* <p>
|
||||
* If this object is a Map or a List, and it's also a JSONAware, JSONAware will be considered firstly.
|
||||
* <p>
|
||||
* DO NOT call this method from toJSONString() of a class that implements both JSONAware and Map or List with
|
||||
* "this" as the parameter, use JSONObject.toJSONString(Map) or JSONArray.toJSONString(List) instead.
|
||||
*
|
||||
* @see org.json.simple.JSONObject#toJSONString(Map)
|
||||
* @see org.json.simple.JSONArray#toJSONString(List)
|
||||
*
|
||||
* @param value
|
||||
* @return JSON text, or "null" if value is null or it's an NaN or an INF number.
|
||||
*/
|
||||
public static String toJSONString(Object value){
|
||||
if(value == null)
|
||||
return "null";
|
||||
|
||||
if(value instanceof String)
|
||||
return "\""+escape((String)value)+"\"";
|
||||
|
||||
if(value instanceof Double){
|
||||
if(((Double)value).isInfinite() || ((Double)value).isNaN())
|
||||
return "null";
|
||||
else
|
||||
return value.toString();
|
||||
}
|
||||
|
||||
if(value instanceof Float){
|
||||
if(((Float)value).isInfinite() || ((Float)value).isNaN())
|
||||
return "null";
|
||||
else
|
||||
return value.toString();
|
||||
}
|
||||
|
||||
if(value instanceof Number)
|
||||
return value.toString();
|
||||
|
||||
if(value instanceof Boolean)
|
||||
return value.toString();
|
||||
|
||||
if((value instanceof JSONAware))
|
||||
return ((JSONAware)value).toJSONString();
|
||||
|
||||
if(value instanceof Map)
|
||||
return JSONObject.toJSONString((Map)value);
|
||||
|
||||
if(value instanceof List)
|
||||
return JSONArray.toJSONString((List)value);
|
||||
|
||||
return value.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Escape quotes, \, /, \r, \n, \b, \f, \t and other control characters (U+0000 through U+001F).
|
||||
* @param s
|
||||
* @return
|
||||
*/
|
||||
public static String escape(String s){
|
||||
if(s==null)
|
||||
return null;
|
||||
StringBuffer sb = new StringBuffer();
|
||||
escape(s, sb);
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param s - Must not be null.
|
||||
* @param sb
|
||||
*/
|
||||
static void escape(String s, StringBuffer sb) {
|
||||
for(int i=0;i<s.length();i++){
|
||||
char ch=s.charAt(i);
|
||||
switch(ch){
|
||||
case '"':
|
||||
sb.append("\\\"");
|
||||
break;
|
||||
case '\\':
|
||||
sb.append("\\\\");
|
||||
break;
|
||||
case '\b':
|
||||
sb.append("\\b");
|
||||
break;
|
||||
case '\f':
|
||||
sb.append("\\f");
|
||||
break;
|
||||
case '\n':
|
||||
sb.append("\\n");
|
||||
break;
|
||||
case '\r':
|
||||
sb.append("\\r");
|
||||
break;
|
||||
case '\t':
|
||||
sb.append("\\t");
|
||||
break;
|
||||
case '/':
|
||||
sb.append("\\/");
|
||||
break;
|
||||
default:
|
||||
//Reference: http://www.unicode.org/versions/Unicode5.1.0/
|
||||
if((ch>='\u0000' && ch<='\u001F') || (ch>='\u007F' && ch<='\u009F') || (ch>='\u2000' && ch<='\u20FF')){
|
||||
String ss=Integer.toHexString(ch);
|
||||
sb.append("\\u");
|
||||
for(int k=0;k<4-ss.length();k++){
|
||||
sb.append('0');
|
||||
}
|
||||
sb.append(ss.toUpperCase());
|
||||
}
|
||||
else{
|
||||
sb.append(ch);
|
||||
}
|
||||
}
|
||||
}//for
|
||||
}
|
||||
|
||||
}
|
||||
202
src/java/org/json/simple/LICENSE.txt
Normal file
202
src/java/org/json/simple/LICENSE.txt
Normal file
@ -0,0 +1,202 @@
|
||||
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
23
src/java/org/json/simple/parser/ContainerFactory.java
Normal file
23
src/java/org/json/simple/parser/ContainerFactory.java
Normal file
@ -0,0 +1,23 @@
|
||||
package org.json.simple.parser;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Container factory for creating containers for JSON object and JSON array.
|
||||
*
|
||||
* @see org.json.simple.parser.JSONParser#parse(java.io.Reader, ContainerFactory)
|
||||
*
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public interface ContainerFactory {
|
||||
/**
|
||||
* @return A Map instance to store JSON object, or null if you want to use org.json.simple.JSONObject.
|
||||
*/
|
||||
Map createObjectContainer();
|
||||
|
||||
/**
|
||||
* @return A List instance to store JSON array, or null if you want to use org.json.simple.JSONArray.
|
||||
*/
|
||||
List creatArrayContainer();
|
||||
}
|
||||
110
src/java/org/json/simple/parser/ContentHandler.java
Normal file
110
src/java/org/json/simple/parser/ContentHandler.java
Normal file
@ -0,0 +1,110 @@
|
||||
package org.json.simple.parser;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* A simplified and stoppable SAX-like content handler for stream processing of JSON text.
|
||||
*
|
||||
* @see org.xml.sax.ContentHandler
|
||||
* @see org.json.simple.parser.JSONParser#parse(java.io.Reader, ContentHandler, boolean)
|
||||
*
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public interface ContentHandler {
|
||||
/**
|
||||
* Receive notification of the beginning of JSON processing.
|
||||
* The parser will invoke this method only once.
|
||||
*
|
||||
* @throws ParseException
|
||||
* - JSONParser will stop and throw the same exception to the caller when receiving this exception.
|
||||
*/
|
||||
void startJSON() throws ParseException, IOException;
|
||||
|
||||
/**
|
||||
* Receive notification of the end of JSON processing.
|
||||
*
|
||||
* @throws ParseException
|
||||
*/
|
||||
void endJSON() throws ParseException, IOException;
|
||||
|
||||
/**
|
||||
* Receive notification of the beginning of a JSON object.
|
||||
*
|
||||
* @return false if the handler wants to stop parsing after return.
|
||||
* @throws ParseException
|
||||
* - JSONParser will stop and throw the same exception to the caller when receiving this exception.
|
||||
* @see #endJSON
|
||||
*/
|
||||
boolean startObject() throws ParseException, IOException;
|
||||
|
||||
/**
|
||||
* Receive notification of the end of a JSON object.
|
||||
*
|
||||
* @return false if the handler wants to stop parsing after return.
|
||||
* @throws ParseException
|
||||
*
|
||||
* @see #startObject
|
||||
*/
|
||||
boolean endObject() throws ParseException, IOException;
|
||||
|
||||
/**
|
||||
* Receive notification of the beginning of a JSON object entry.
|
||||
*
|
||||
* @param key - Key of a JSON object entry.
|
||||
*
|
||||
* @return false if the handler wants to stop parsing after return.
|
||||
* @throws ParseException
|
||||
*
|
||||
* @see #endObjectEntry
|
||||
*/
|
||||
boolean startObjectEntry(String key) throws ParseException, IOException;
|
||||
|
||||
/**
|
||||
* Receive notification of the end of the value of previous object entry.
|
||||
*
|
||||
* @return false if the handler wants to stop parsing after return.
|
||||
* @throws ParseException
|
||||
*
|
||||
* @see #startObjectEntry
|
||||
*/
|
||||
boolean endObjectEntry() throws ParseException, IOException;
|
||||
|
||||
/**
|
||||
* Receive notification of the beginning of a JSON array.
|
||||
*
|
||||
* @return false if the handler wants to stop parsing after return.
|
||||
* @throws ParseException
|
||||
*
|
||||
* @see #endArray
|
||||
*/
|
||||
boolean startArray() throws ParseException, IOException;
|
||||
|
||||
/**
|
||||
* Receive notification of the end of a JSON array.
|
||||
*
|
||||
* @return false if the handler wants to stop parsing after return.
|
||||
* @throws ParseException
|
||||
*
|
||||
* @see #startArray
|
||||
*/
|
||||
boolean endArray() throws ParseException, IOException;
|
||||
|
||||
/**
|
||||
* Receive notification of the JSON primitive values:
|
||||
* java.lang.String,
|
||||
* java.lang.Number,
|
||||
* java.lang.Boolean
|
||||
* null
|
||||
*
|
||||
* @param value - Instance of the following:
|
||||
* java.lang.String,
|
||||
* java.lang.Number,
|
||||
* java.lang.Boolean
|
||||
* null
|
||||
*
|
||||
* @return false if the handler wants to stop parsing after return.
|
||||
* @throws ParseException
|
||||
*/
|
||||
boolean primitive(Object value) throws ParseException, IOException;
|
||||
|
||||
}
|
||||
533
src/java/org/json/simple/parser/JSONParser.java
Normal file
533
src/java/org/json/simple/parser/JSONParser.java
Normal file
@ -0,0 +1,533 @@
|
||||
/*
|
||||
* $Id: JSONParser.java,v 1.1 2006/04/15 14:10:48 platform Exp $
|
||||
* Created on 2006-4-15
|
||||
*/
|
||||
package org.json.simple.parser;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.Reader;
|
||||
import java.io.StringReader;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.json.simple.JSONArray;
|
||||
import org.json.simple.JSONObject;
|
||||
|
||||
|
||||
/**
|
||||
* Parser for JSON text. Please note that JSONParser is NOT thread-safe.
|
||||
*
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public class JSONParser {
|
||||
public static final int S_INIT=0;
|
||||
public static final int S_IN_FINISHED_VALUE=1;//string,number,boolean,null,object,array
|
||||
public static final int S_IN_OBJECT=2;
|
||||
public static final int S_IN_ARRAY=3;
|
||||
public static final int S_PASSED_PAIR_KEY=4;
|
||||
public static final int S_IN_PAIR_VALUE=5;
|
||||
public static final int S_END=6;
|
||||
public static final int S_IN_ERROR=-1;
|
||||
|
||||
private LinkedList handlerStatusStack;
|
||||
private Yylex lexer = new Yylex((Reader)null);
|
||||
private Yytoken token = null;
|
||||
private int status = S_INIT;
|
||||
|
||||
private int peekStatus(LinkedList statusStack){
|
||||
if(statusStack.size()==0)
|
||||
return -1;
|
||||
Integer status=(Integer)statusStack.getFirst();
|
||||
return status.intValue();
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset the parser to the initial state without resetting the underlying reader.
|
||||
*
|
||||
*/
|
||||
public void reset(){
|
||||
token = null;
|
||||
status = S_INIT;
|
||||
handlerStatusStack = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset the parser to the initial state with a new character reader.
|
||||
*
|
||||
* @param in - The new character reader.
|
||||
* @throws IOException
|
||||
* @throws ParseException
|
||||
*/
|
||||
public void reset(Reader in){
|
||||
lexer.yyreset(in);
|
||||
reset();
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The position of the beginning of the current token.
|
||||
*/
|
||||
public int getPosition(){
|
||||
return lexer.getPosition();
|
||||
}
|
||||
|
||||
public Object parse(String s) throws ParseException{
|
||||
return parse(s, (ContainerFactory)null);
|
||||
}
|
||||
|
||||
public Object parse(String s, ContainerFactory containerFactory) throws ParseException{
|
||||
StringReader in=new StringReader(s);
|
||||
try{
|
||||
return parse(in, containerFactory);
|
||||
}
|
||||
catch(IOException ie){
|
||||
/*
|
||||
* Actually it will never happen.
|
||||
*/
|
||||
throw new ParseException(-1, ParseException.ERROR_UNEXPECTED_EXCEPTION, ie);
|
||||
}
|
||||
}
|
||||
|
||||
public Object parse(Reader in) throws IOException, ParseException{
|
||||
return parse(in, (ContainerFactory)null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse JSON text into java object from the input source.
|
||||
*
|
||||
* @param in
|
||||
* @param containerFactory - Use this factory to createyour own JSON object and JSON array containers.
|
||||
* @return Instance of the following:
|
||||
* org.json.simple.JSONObject,
|
||||
* org.json.simple.JSONArray,
|
||||
* java.lang.String,
|
||||
* java.lang.Number,
|
||||
* java.lang.Boolean,
|
||||
* null
|
||||
*
|
||||
* @throws IOException
|
||||
* @throws ParseException
|
||||
*/
|
||||
public Object parse(Reader in, ContainerFactory containerFactory) throws IOException, ParseException{
|
||||
reset(in);
|
||||
LinkedList statusStack = new LinkedList();
|
||||
LinkedList valueStack = new LinkedList();
|
||||
|
||||
try{
|
||||
do{
|
||||
nextToken();
|
||||
switch(status){
|
||||
case S_INIT:
|
||||
switch(token.type){
|
||||
case Yytoken.TYPE_VALUE:
|
||||
status=S_IN_FINISHED_VALUE;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
valueStack.addFirst(token.value);
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_BRACE:
|
||||
status=S_IN_OBJECT;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
valueStack.addFirst(createObjectContainer(containerFactory));
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_SQUARE:
|
||||
status=S_IN_ARRAY;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
valueStack.addFirst(createArrayContainer(containerFactory));
|
||||
break;
|
||||
default:
|
||||
status=S_IN_ERROR;
|
||||
}//inner switch
|
||||
break;
|
||||
|
||||
case S_IN_FINISHED_VALUE:
|
||||
if(token.type==Yytoken.TYPE_EOF)
|
||||
return valueStack.removeFirst();
|
||||
else
|
||||
throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
|
||||
|
||||
case S_IN_OBJECT:
|
||||
switch(token.type){
|
||||
case Yytoken.TYPE_COMMA:
|
||||
break;
|
||||
case Yytoken.TYPE_VALUE:
|
||||
if(token.value instanceof String){
|
||||
String key=(String)token.value;
|
||||
valueStack.addFirst(key);
|
||||
status=S_PASSED_PAIR_KEY;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
}
|
||||
else{
|
||||
status=S_IN_ERROR;
|
||||
}
|
||||
break;
|
||||
case Yytoken.TYPE_RIGHT_BRACE:
|
||||
if(valueStack.size()>1){
|
||||
statusStack.removeFirst();
|
||||
valueStack.removeFirst();
|
||||
status=peekStatus(statusStack);
|
||||
}
|
||||
else{
|
||||
status=S_IN_FINISHED_VALUE;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
status=S_IN_ERROR;
|
||||
break;
|
||||
}//inner switch
|
||||
break;
|
||||
|
||||
case S_PASSED_PAIR_KEY:
|
||||
switch(token.type){
|
||||
case Yytoken.TYPE_COLON:
|
||||
break;
|
||||
case Yytoken.TYPE_VALUE:
|
||||
statusStack.removeFirst();
|
||||
String key=(String)valueStack.removeFirst();
|
||||
Map parent=(Map)valueStack.getFirst();
|
||||
parent.put(key,token.value);
|
||||
status=peekStatus(statusStack);
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_SQUARE:
|
||||
statusStack.removeFirst();
|
||||
key=(String)valueStack.removeFirst();
|
||||
parent=(Map)valueStack.getFirst();
|
||||
List newArray=createArrayContainer(containerFactory);
|
||||
parent.put(key,newArray);
|
||||
status=S_IN_ARRAY;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
valueStack.addFirst(newArray);
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_BRACE:
|
||||
statusStack.removeFirst();
|
||||
key=(String)valueStack.removeFirst();
|
||||
parent=(Map)valueStack.getFirst();
|
||||
Map newObject=createObjectContainer(containerFactory);
|
||||
parent.put(key,newObject);
|
||||
status=S_IN_OBJECT;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
valueStack.addFirst(newObject);
|
||||
break;
|
||||
default:
|
||||
status=S_IN_ERROR;
|
||||
}
|
||||
break;
|
||||
|
||||
case S_IN_ARRAY:
|
||||
switch(token.type){
|
||||
case Yytoken.TYPE_COMMA:
|
||||
break;
|
||||
case Yytoken.TYPE_VALUE:
|
||||
List val=(List)valueStack.getFirst();
|
||||
val.add(token.value);
|
||||
break;
|
||||
case Yytoken.TYPE_RIGHT_SQUARE:
|
||||
if(valueStack.size()>1){
|
||||
statusStack.removeFirst();
|
||||
valueStack.removeFirst();
|
||||
status=peekStatus(statusStack);
|
||||
}
|
||||
else{
|
||||
status=S_IN_FINISHED_VALUE;
|
||||
}
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_BRACE:
|
||||
val=(List)valueStack.getFirst();
|
||||
Map newObject=createObjectContainer(containerFactory);
|
||||
val.add(newObject);
|
||||
status=S_IN_OBJECT;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
valueStack.addFirst(newObject);
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_SQUARE:
|
||||
val=(List)valueStack.getFirst();
|
||||
List newArray=createArrayContainer(containerFactory);
|
||||
val.add(newArray);
|
||||
status=S_IN_ARRAY;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
valueStack.addFirst(newArray);
|
||||
break;
|
||||
default:
|
||||
status=S_IN_ERROR;
|
||||
}//inner switch
|
||||
break;
|
||||
case S_IN_ERROR:
|
||||
throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
|
||||
}//switch
|
||||
if(status==S_IN_ERROR){
|
||||
throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
|
||||
}
|
||||
}while(token.type!=Yytoken.TYPE_EOF);
|
||||
}
|
||||
catch(IOException ie){
|
||||
throw ie;
|
||||
}
|
||||
|
||||
throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
|
||||
}
|
||||
|
||||
private void nextToken() throws ParseException, IOException{
|
||||
token = lexer.yylex();
|
||||
if(token == null)
|
||||
token = new Yytoken(Yytoken.TYPE_EOF, null);
|
||||
}
|
||||
|
||||
private Map createObjectContainer(ContainerFactory containerFactory){
|
||||
if(containerFactory == null)
|
||||
return new JSONObject();
|
||||
Map m = containerFactory.createObjectContainer();
|
||||
|
||||
if(m == null)
|
||||
return new JSONObject();
|
||||
return m;
|
||||
}
|
||||
|
||||
private List createArrayContainer(ContainerFactory containerFactory){
|
||||
if(containerFactory == null)
|
||||
return new JSONArray();
|
||||
List l = containerFactory.creatArrayContainer();
|
||||
|
||||
if(l == null)
|
||||
return new JSONArray();
|
||||
return l;
|
||||
}
|
||||
|
||||
public void parse(String s, ContentHandler contentHandler) throws ParseException{
|
||||
parse(s, contentHandler, false);
|
||||
}
|
||||
|
||||
public void parse(String s, ContentHandler contentHandler, boolean isResume) throws ParseException{
|
||||
StringReader in=new StringReader(s);
|
||||
try{
|
||||
parse(in, contentHandler, isResume);
|
||||
}
|
||||
catch(IOException ie){
|
||||
/*
|
||||
* Actually it will never happen.
|
||||
*/
|
||||
throw new ParseException(-1, ParseException.ERROR_UNEXPECTED_EXCEPTION, ie);
|
||||
}
|
||||
}
|
||||
|
||||
public void parse(Reader in, ContentHandler contentHandler) throws IOException, ParseException{
|
||||
parse(in, contentHandler, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Stream processing of JSON text.
|
||||
*
|
||||
* @see ContentHandler
|
||||
*
|
||||
* @param in
|
||||
* @param contentHandler
|
||||
* @param isResume - Indicates if it continues previous parsing operation.
|
||||
* If set to true, resume parsing the old stream, and parameter 'in' will be ignored.
|
||||
* If this method is called for the first time in this instance, isResume will be ignored.
|
||||
*
|
||||
* @throws IOException
|
||||
* @throws ParseException
|
||||
*/
|
||||
public void parse(Reader in, ContentHandler contentHandler, boolean isResume) throws IOException, ParseException{
|
||||
if(!isResume){
|
||||
reset(in);
|
||||
handlerStatusStack = new LinkedList();
|
||||
}
|
||||
else{
|
||||
if(handlerStatusStack == null){
|
||||
isResume = false;
|
||||
reset(in);
|
||||
handlerStatusStack = new LinkedList();
|
||||
}
|
||||
}
|
||||
|
||||
LinkedList statusStack = handlerStatusStack;
|
||||
|
||||
try{
|
||||
do{
|
||||
switch(status){
|
||||
case S_INIT:
|
||||
contentHandler.startJSON();
|
||||
nextToken();
|
||||
switch(token.type){
|
||||
case Yytoken.TYPE_VALUE:
|
||||
status=S_IN_FINISHED_VALUE;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
if(!contentHandler.primitive(token.value))
|
||||
return;
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_BRACE:
|
||||
status=S_IN_OBJECT;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
if(!contentHandler.startObject())
|
||||
return;
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_SQUARE:
|
||||
status=S_IN_ARRAY;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
if(!contentHandler.startArray())
|
||||
return;
|
||||
break;
|
||||
default:
|
||||
status=S_IN_ERROR;
|
||||
}//inner switch
|
||||
break;
|
||||
|
||||
case S_IN_FINISHED_VALUE:
|
||||
nextToken();
|
||||
if(token.type==Yytoken.TYPE_EOF){
|
||||
contentHandler.endJSON();
|
||||
status = S_END;
|
||||
return;
|
||||
}
|
||||
else{
|
||||
status = S_IN_ERROR;
|
||||
throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
|
||||
}
|
||||
|
||||
case S_IN_OBJECT:
|
||||
nextToken();
|
||||
switch(token.type){
|
||||
case Yytoken.TYPE_COMMA:
|
||||
break;
|
||||
case Yytoken.TYPE_VALUE:
|
||||
if(token.value instanceof String){
|
||||
String key=(String)token.value;
|
||||
status=S_PASSED_PAIR_KEY;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
if(!contentHandler.startObjectEntry(key))
|
||||
return;
|
||||
}
|
||||
else{
|
||||
status=S_IN_ERROR;
|
||||
}
|
||||
break;
|
||||
case Yytoken.TYPE_RIGHT_BRACE:
|
||||
if(statusStack.size()>1){
|
||||
statusStack.removeFirst();
|
||||
status=peekStatus(statusStack);
|
||||
}
|
||||
else{
|
||||
status=S_IN_FINISHED_VALUE;
|
||||
}
|
||||
if(!contentHandler.endObject())
|
||||
return;
|
||||
break;
|
||||
default:
|
||||
status=S_IN_ERROR;
|
||||
break;
|
||||
}//inner switch
|
||||
break;
|
||||
|
||||
case S_PASSED_PAIR_KEY:
|
||||
nextToken();
|
||||
switch(token.type){
|
||||
case Yytoken.TYPE_COLON:
|
||||
break;
|
||||
case Yytoken.TYPE_VALUE:
|
||||
statusStack.removeFirst();
|
||||
status=peekStatus(statusStack);
|
||||
if(!contentHandler.primitive(token.value))
|
||||
return;
|
||||
if(!contentHandler.endObjectEntry())
|
||||
return;
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_SQUARE:
|
||||
statusStack.removeFirst();
|
||||
statusStack.addFirst(new Integer(S_IN_PAIR_VALUE));
|
||||
status=S_IN_ARRAY;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
if(!contentHandler.startArray())
|
||||
return;
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_BRACE:
|
||||
statusStack.removeFirst();
|
||||
statusStack.addFirst(new Integer(S_IN_PAIR_VALUE));
|
||||
status=S_IN_OBJECT;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
if(!contentHandler.startObject())
|
||||
return;
|
||||
break;
|
||||
default:
|
||||
status=S_IN_ERROR;
|
||||
}
|
||||
break;
|
||||
|
||||
case S_IN_PAIR_VALUE:
|
||||
/*
|
||||
* S_IN_PAIR_VALUE is just a marker to indicate the end of an object entry, it doesn't proccess any token,
|
||||
* therefore delay consuming token until next round.
|
||||
*/
|
||||
statusStack.removeFirst();
|
||||
status = peekStatus(statusStack);
|
||||
if(!contentHandler.endObjectEntry())
|
||||
return;
|
||||
break;
|
||||
|
||||
case S_IN_ARRAY:
|
||||
nextToken();
|
||||
switch(token.type){
|
||||
case Yytoken.TYPE_COMMA:
|
||||
break;
|
||||
case Yytoken.TYPE_VALUE:
|
||||
if(!contentHandler.primitive(token.value))
|
||||
return;
|
||||
break;
|
||||
case Yytoken.TYPE_RIGHT_SQUARE:
|
||||
if(statusStack.size()>1){
|
||||
statusStack.removeFirst();
|
||||
status=peekStatus(statusStack);
|
||||
}
|
||||
else{
|
||||
status=S_IN_FINISHED_VALUE;
|
||||
}
|
||||
if(!contentHandler.endArray())
|
||||
return;
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_BRACE:
|
||||
status=S_IN_OBJECT;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
if(!contentHandler.startObject())
|
||||
return;
|
||||
break;
|
||||
case Yytoken.TYPE_LEFT_SQUARE:
|
||||
status=S_IN_ARRAY;
|
||||
statusStack.addFirst(new Integer(status));
|
||||
if(!contentHandler.startArray())
|
||||
return;
|
||||
break;
|
||||
default:
|
||||
status=S_IN_ERROR;
|
||||
}//inner switch
|
||||
break;
|
||||
|
||||
case S_END:
|
||||
return;
|
||||
|
||||
case S_IN_ERROR:
|
||||
throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
|
||||
}//switch
|
||||
if(status==S_IN_ERROR){
|
||||
throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
|
||||
}
|
||||
}while(token.type!=Yytoken.TYPE_EOF);
|
||||
}
|
||||
catch(IOException ie){
|
||||
status = S_IN_ERROR;
|
||||
throw ie;
|
||||
}
|
||||
catch(ParseException pe){
|
||||
status = S_IN_ERROR;
|
||||
throw pe;
|
||||
}
|
||||
catch(RuntimeException re){
|
||||
status = S_IN_ERROR;
|
||||
throw re;
|
||||
}
|
||||
catch(Error e){
|
||||
status = S_IN_ERROR;
|
||||
throw e;
|
||||
}
|
||||
|
||||
status = S_IN_ERROR;
|
||||
throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
|
||||
}
|
||||
}
|
||||
90
src/java/org/json/simple/parser/ParseException.java
Normal file
90
src/java/org/json/simple/parser/ParseException.java
Normal file
@ -0,0 +1,90 @@
|
||||
package org.json.simple.parser;
|
||||
|
||||
/**
|
||||
* ParseException explains why and where the error occurs in source JSON text.
|
||||
*
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*
|
||||
*/
|
||||
public class ParseException extends Exception {
|
||||
private static final long serialVersionUID = -7880698968187728548L;
|
||||
|
||||
public static final int ERROR_UNEXPECTED_CHAR = 0;
|
||||
public static final int ERROR_UNEXPECTED_TOKEN = 1;
|
||||
public static final int ERROR_UNEXPECTED_EXCEPTION = 2;
|
||||
|
||||
private int errorType;
|
||||
private Object unexpectedObject;
|
||||
private int position;
|
||||
|
||||
public ParseException(int errorType){
|
||||
this(-1, errorType, null);
|
||||
}
|
||||
|
||||
public ParseException(int errorType, Object unexpectedObject){
|
||||
this(-1, errorType, unexpectedObject);
|
||||
}
|
||||
|
||||
public ParseException(int position, int errorType, Object unexpectedObject){
|
||||
this.position = position;
|
||||
this.errorType = errorType;
|
||||
this.unexpectedObject = unexpectedObject;
|
||||
}
|
||||
|
||||
public int getErrorType() {
|
||||
return errorType;
|
||||
}
|
||||
|
||||
public void setErrorType(int errorType) {
|
||||
this.errorType = errorType;
|
||||
}
|
||||
|
||||
/**
|
||||
* @see org.json.simple.parser.JSONParser#getPosition()
|
||||
*
|
||||
* @return The character position (starting with 0) of the input where the error occurs.
|
||||
*/
|
||||
public int getPosition() {
|
||||
return position;
|
||||
}
|
||||
|
||||
public void setPosition(int position) {
|
||||
this.position = position;
|
||||
}
|
||||
|
||||
/**
|
||||
* @see org.json.simple.parser.Yytoken
|
||||
*
|
||||
* @return One of the following base on the value of errorType:
|
||||
* ERROR_UNEXPECTED_CHAR java.lang.Character
|
||||
* ERROR_UNEXPECTED_TOKEN org.json.simple.parser.Yytoken
|
||||
* ERROR_UNEXPECTED_EXCEPTION java.lang.Exception
|
||||
*/
|
||||
public Object getUnexpectedObject() {
|
||||
return unexpectedObject;
|
||||
}
|
||||
|
||||
public void setUnexpectedObject(Object unexpectedObject) {
|
||||
this.unexpectedObject = unexpectedObject;
|
||||
}
|
||||
|
||||
public String toString(){
|
||||
StringBuffer sb = new StringBuffer();
|
||||
|
||||
switch(errorType){
|
||||
case ERROR_UNEXPECTED_CHAR:
|
||||
sb.append("Unexpected character (").append(unexpectedObject).append(") at position ").append(position).append(".");
|
||||
break;
|
||||
case ERROR_UNEXPECTED_TOKEN:
|
||||
sb.append("Unexpected token ").append(unexpectedObject).append(" at position ").append(position).append(".");
|
||||
break;
|
||||
case ERROR_UNEXPECTED_EXCEPTION:
|
||||
sb.append("Unexpected exception at position ").append(position).append(": ").append(unexpectedObject);
|
||||
break;
|
||||
default:
|
||||
sb.append("Unkown error at position ").append(position).append(".");
|
||||
break;
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
688
src/java/org/json/simple/parser/Yylex.java
Normal file
688
src/java/org/json/simple/parser/Yylex.java
Normal file
@ -0,0 +1,688 @@
|
||||
/* The following code was generated by JFlex 1.4.2 */
|
||||
|
||||
package org.json.simple.parser;
|
||||
|
||||
class Yylex {
|
||||
|
||||
/** This character denotes the end of file */
|
||||
public static final int YYEOF = -1;
|
||||
|
||||
/** initial size of the lookahead buffer */
|
||||
private static final int ZZ_BUFFERSIZE = 16384;
|
||||
|
||||
/** lexical states */
|
||||
public static final int YYINITIAL = 0;
|
||||
public static final int STRING_BEGIN = 2;
|
||||
|
||||
/**
|
||||
* ZZ_LEXSTATE[l] is the state in the DFA for the lexical state l
|
||||
* ZZ_LEXSTATE[l+1] is the state in the DFA for the lexical state l
|
||||
* at the beginning of a line
|
||||
* l is of the form l = 2*k, k a non negative integer
|
||||
*/
|
||||
private static final int ZZ_LEXSTATE[] = {
|
||||
0, 0, 1, 1
|
||||
};
|
||||
|
||||
/**
|
||||
* Translates characters to character classes
|
||||
*/
|
||||
private static final String ZZ_CMAP_PACKED =
|
||||
"\11\0\1\7\1\7\2\0\1\7\22\0\1\7\1\0\1\11\10\0"+
|
||||
"\1\6\1\31\1\2\1\4\1\12\12\3\1\32\6\0\4\1\1\5"+
|
||||
"\1\1\24\0\1\27\1\10\1\30\3\0\1\22\1\13\2\1\1\21"+
|
||||
"\1\14\5\0\1\23\1\0\1\15\3\0\1\16\1\24\1\17\1\20"+
|
||||
"\5\0\1\25\1\0\1\26\uff82\0";
|
||||
|
||||
/**
|
||||
* Translates characters to character classes
|
||||
*/
|
||||
private static final char [] ZZ_CMAP = zzUnpackCMap(ZZ_CMAP_PACKED);
|
||||
|
||||
/**
|
||||
* Translates DFA states to action switch labels.
|
||||
*/
|
||||
private static final int [] ZZ_ACTION = zzUnpackAction();
|
||||
|
||||
private static final String ZZ_ACTION_PACKED_0 =
|
||||
"\2\0\2\1\1\2\1\3\1\4\3\1\1\5\1\6"+
|
||||
"\1\7\1\10\1\11\1\12\1\13\1\14\1\15\5\0"+
|
||||
"\1\14\1\16\1\17\1\20\1\21\1\22\1\23\1\24"+
|
||||
"\1\0\1\25\1\0\1\25\4\0\1\26\1\27\2\0"+
|
||||
"\1\30";
|
||||
|
||||
private static int [] zzUnpackAction() {
|
||||
int [] result = new int[45];
|
||||
int offset = 0;
|
||||
offset = zzUnpackAction(ZZ_ACTION_PACKED_0, offset, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
private static int zzUnpackAction(String packed, int offset, int [] result) {
|
||||
int i = 0; /* index in packed string */
|
||||
int j = offset; /* index in unpacked array */
|
||||
int l = packed.length();
|
||||
while (i < l) {
|
||||
int count = packed.charAt(i++);
|
||||
int value = packed.charAt(i++);
|
||||
do result[j++] = value; while (--count > 0);
|
||||
}
|
||||
return j;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Translates a state to a row index in the transition table
|
||||
*/
|
||||
private static final int [] ZZ_ROWMAP = zzUnpackRowMap();
|
||||
|
||||
private static final String ZZ_ROWMAP_PACKED_0 =
|
||||
"\0\0\0\33\0\66\0\121\0\154\0\207\0\66\0\242"+
|
||||
"\0\275\0\330\0\66\0\66\0\66\0\66\0\66\0\66"+
|
||||
"\0\363\0\u010e\0\66\0\u0129\0\u0144\0\u015f\0\u017a\0\u0195"+
|
||||
"\0\66\0\66\0\66\0\66\0\66\0\66\0\66\0\66"+
|
||||
"\0\u01b0\0\u01cb\0\u01e6\0\u01e6\0\u0201\0\u021c\0\u0237\0\u0252"+
|
||||
"\0\66\0\66\0\u026d\0\u0288\0\66";
|
||||
|
||||
private static int [] zzUnpackRowMap() {
|
||||
int [] result = new int[45];
|
||||
int offset = 0;
|
||||
offset = zzUnpackRowMap(ZZ_ROWMAP_PACKED_0, offset, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
private static int zzUnpackRowMap(String packed, int offset, int [] result) {
|
||||
int i = 0; /* index in packed string */
|
||||
int j = offset; /* index in unpacked array */
|
||||
int l = packed.length();
|
||||
while (i < l) {
|
||||
int high = packed.charAt(i++) << 16;
|
||||
result[j++] = high | packed.charAt(i++);
|
||||
}
|
||||
return j;
|
||||
}
|
||||
|
||||
/**
|
||||
* The transition table of the DFA
|
||||
*/
|
||||
private static final int ZZ_TRANS [] = {
|
||||
2, 2, 3, 4, 2, 2, 2, 5, 2, 6,
|
||||
2, 2, 7, 8, 2, 9, 2, 2, 2, 2,
|
||||
2, 10, 11, 12, 13, 14, 15, 16, 16, 16,
|
||||
16, 16, 16, 16, 16, 17, 18, 16, 16, 16,
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
||||
16, 16, 16, 16, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, 4, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, 4, 19, 20, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 20, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, 5, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
21, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 22, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
23, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, 16, 16, 16, 16, 16, 16, 16,
|
||||
16, -1, -1, 16, 16, 16, 16, 16, 16, 16,
|
||||
16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, 24, 25,
|
||||
26, 27, 28, 29, 30, 31, 32, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, 34, 35, -1, -1,
|
||||
34, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
36, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, 37, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, 38, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, 39, -1, 39, -1, 39, -1, -1,
|
||||
-1, -1, -1, 39, 39, -1, -1, -1, -1, 39,
|
||||
39, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, 33, -1, 20, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, 20, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, 35,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, 38, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, 40,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, 41, -1, -1, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1, 42, -1, 42, -1, 42,
|
||||
-1, -1, -1, -1, -1, 42, 42, -1, -1, -1,
|
||||
-1, 42, 42, -1, -1, -1, -1, -1, -1, -1,
|
||||
-1, -1, 43, -1, 43, -1, 43, -1, -1, -1,
|
||||
-1, -1, 43, 43, -1, -1, -1, -1, 43, 43,
|
||||
-1, -1, -1, -1, -1, -1, -1, -1, -1, 44,
|
||||
-1, 44, -1, 44, -1, -1, -1, -1, -1, 44,
|
||||
44, -1, -1, -1, -1, 44, 44, -1, -1, -1,
|
||||
-1, -1, -1, -1, -1,
|
||||
};
|
||||
|
||||
/* error codes */
|
||||
private static final int ZZ_UNKNOWN_ERROR = 0;
|
||||
private static final int ZZ_NO_MATCH = 1;
|
||||
private static final int ZZ_PUSHBACK_2BIG = 2;
|
||||
|
||||
/* error messages for the codes above */
|
||||
private static final String ZZ_ERROR_MSG[] = {
|
||||
"Unkown internal scanner error",
|
||||
"Error: could not match input",
|
||||
"Error: pushback value was too large"
|
||||
};
|
||||
|
||||
/**
|
||||
* ZZ_ATTRIBUTE[aState] contains the attributes of state <code>aState</code>
|
||||
*/
|
||||
private static final int [] ZZ_ATTRIBUTE = zzUnpackAttribute();
|
||||
|
||||
private static final String ZZ_ATTRIBUTE_PACKED_0 =
|
||||
"\2\0\1\11\3\1\1\11\3\1\6\11\2\1\1\11"+
|
||||
"\5\0\10\11\1\0\1\1\1\0\1\1\4\0\2\11"+
|
||||
"\2\0\1\11";
|
||||
|
||||
private static int [] zzUnpackAttribute() {
|
||||
int [] result = new int[45];
|
||||
int offset = 0;
|
||||
offset = zzUnpackAttribute(ZZ_ATTRIBUTE_PACKED_0, offset, result);
|
||||
return result;
|
||||
}
|
||||
|
||||
private static int zzUnpackAttribute(String packed, int offset, int [] result) {
|
||||
int i = 0; /* index in packed string */
|
||||
int j = offset; /* index in unpacked array */
|
||||
int l = packed.length();
|
||||
while (i < l) {
|
||||
int count = packed.charAt(i++);
|
||||
int value = packed.charAt(i++);
|
||||
do result[j++] = value; while (--count > 0);
|
||||
}
|
||||
return j;
|
||||
}
|
||||
|
||||
/** the input device */
|
||||
private java.io.Reader zzReader;
|
||||
|
||||
/** the current state of the DFA */
|
||||
private int zzState;
|
||||
|
||||
/** the current lexical state */
|
||||
private int zzLexicalState = YYINITIAL;
|
||||
|
||||
/** this buffer contains the current text to be matched and is
|
||||
the source of the yytext() string */
|
||||
private char zzBuffer[] = new char[ZZ_BUFFERSIZE];
|
||||
|
||||
/** the textposition at the last accepting state */
|
||||
private int zzMarkedPos;
|
||||
|
||||
/** the current text position in the buffer */
|
||||
private int zzCurrentPos;
|
||||
|
||||
/** startRead marks the beginning of the yytext() string in the buffer */
|
||||
private int zzStartRead;
|
||||
|
||||
/** endRead marks the last character in the buffer, that has been read
|
||||
from input */
|
||||
private int zzEndRead;
|
||||
|
||||
/** number of newlines encountered up to the start of the matched text */
|
||||
private int yyline;
|
||||
|
||||
/** the number of characters up to the start of the matched text */
|
||||
private int yychar;
|
||||
|
||||
/**
|
||||
* the number of characters from the last newline up to the start of the
|
||||
* matched text
|
||||
*/
|
||||
private int yycolumn;
|
||||
|
||||
/**
|
||||
* zzAtBOL == true <=> the scanner is currently at the beginning of a line
|
||||
*/
|
||||
private boolean zzAtBOL = true;
|
||||
|
||||
/** zzAtEOF == true <=> the scanner is at the EOF */
|
||||
private boolean zzAtEOF;
|
||||
|
||||
/* user code: */
|
||||
private StringBuffer sb=new StringBuffer();
|
||||
|
||||
int getPosition(){
|
||||
return yychar;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Creates a new scanner
|
||||
* There is also a java.io.InputStream version of this constructor.
|
||||
*
|
||||
* @param in the java.io.Reader to read input from.
|
||||
*/
|
||||
Yylex(java.io.Reader in) {
|
||||
this.zzReader = in;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new scanner.
|
||||
* There is also java.io.Reader version of this constructor.
|
||||
*
|
||||
* @param in the java.io.Inputstream to read input from.
|
||||
*/
|
||||
Yylex(java.io.InputStream in) {
|
||||
this(new java.io.InputStreamReader(in));
|
||||
}
|
||||
|
||||
/**
|
||||
* Unpacks the compressed character translation table.
|
||||
*
|
||||
* @param packed the packed character translation table
|
||||
* @return the unpacked character translation table
|
||||
*/
|
||||
private static char [] zzUnpackCMap(String packed) {
|
||||
char [] map = new char[0x10000];
|
||||
int i = 0; /* index in packed string */
|
||||
int j = 0; /* index in unpacked array */
|
||||
while (i < 90) {
|
||||
int count = packed.charAt(i++);
|
||||
char value = packed.charAt(i++);
|
||||
do map[j++] = value; while (--count > 0);
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Refills the input buffer.
|
||||
*
|
||||
* @return <code>false</code>, iff there was new input.
|
||||
*
|
||||
* @exception java.io.IOException if any I/O-Error occurs
|
||||
*/
|
||||
private boolean zzRefill() throws java.io.IOException {
|
||||
|
||||
/* first: make room (if you can) */
|
||||
if (zzStartRead > 0) {
|
||||
System.arraycopy(zzBuffer, zzStartRead,
|
||||
zzBuffer, 0,
|
||||
zzEndRead-zzStartRead);
|
||||
|
||||
/* translate stored positions */
|
||||
zzEndRead-= zzStartRead;
|
||||
zzCurrentPos-= zzStartRead;
|
||||
zzMarkedPos-= zzStartRead;
|
||||
zzStartRead = 0;
|
||||
}
|
||||
|
||||
/* is the buffer big enough? */
|
||||
if (zzCurrentPos >= zzBuffer.length) {
|
||||
/* if not: blow it up */
|
||||
char newBuffer[] = new char[zzCurrentPos*2];
|
||||
System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
|
||||
zzBuffer = newBuffer;
|
||||
}
|
||||
|
||||
/* finally: fill the buffer with new input */
|
||||
int numRead = zzReader.read(zzBuffer, zzEndRead,
|
||||
zzBuffer.length-zzEndRead);
|
||||
|
||||
if (numRead > 0) {
|
||||
zzEndRead+= numRead;
|
||||
return false;
|
||||
}
|
||||
// unlikely but not impossible: read 0 characters, but not at end of stream
|
||||
if (numRead == 0) {
|
||||
int c = zzReader.read();
|
||||
if (c == -1) {
|
||||
return true;
|
||||
} else {
|
||||
zzBuffer[zzEndRead++] = (char) c;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// numRead < 0
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Closes the input stream.
|
||||
*/
|
||||
public final void yyclose() throws java.io.IOException {
|
||||
zzAtEOF = true; /* indicate end of file */
|
||||
zzEndRead = zzStartRead; /* invalidate buffer */
|
||||
|
||||
if (zzReader != null)
|
||||
zzReader.close();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Resets the scanner to read from a new input stream.
|
||||
* Does not close the old reader.
|
||||
*
|
||||
* All internal variables are reset, the old input stream
|
||||
* <b>cannot</b> be reused (internal buffer is discarded and lost).
|
||||
* Lexical state is set to <tt>ZZ_INITIAL</tt>.
|
||||
*
|
||||
* @param reader the new input stream
|
||||
*/
|
||||
public final void yyreset(java.io.Reader reader) {
|
||||
zzReader = reader;
|
||||
zzAtBOL = true;
|
||||
zzAtEOF = false;
|
||||
zzEndRead = zzStartRead = 0;
|
||||
zzCurrentPos = zzMarkedPos = 0;
|
||||
yyline = yychar = yycolumn = 0;
|
||||
zzLexicalState = YYINITIAL;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the current lexical state.
|
||||
*/
|
||||
public final int yystate() {
|
||||
return zzLexicalState;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Enters a new lexical state
|
||||
*
|
||||
* @param newState the new lexical state
|
||||
*/
|
||||
public final void yybegin(int newState) {
|
||||
zzLexicalState = newState;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the text matched by the current regular expression.
|
||||
*/
|
||||
public final String yytext() {
|
||||
return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead );
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the character at position <tt>pos</tt> from the
|
||||
* matched text.
|
||||
*
|
||||
* It is equivalent to yytext().charAt(pos), but faster
|
||||
*
|
||||
* @param pos the position of the character to fetch.
|
||||
* A value from 0 to yylength()-1.
|
||||
*
|
||||
* @return the character at position pos
|
||||
*/
|
||||
public final char yycharat(int pos) {
|
||||
return zzBuffer[zzStartRead+pos];
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the length of the matched text region.
|
||||
*/
|
||||
public final int yylength() {
|
||||
return zzMarkedPos-zzStartRead;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Reports an error that occured while scanning.
|
||||
*
|
||||
* In a wellformed scanner (no or only correct usage of
|
||||
* yypushback(int) and a match-all fallback rule) this method
|
||||
* will only be called with things that "Can't Possibly Happen".
|
||||
* If this method is called, something is seriously wrong
|
||||
* (e.g. a JFlex bug producing a faulty scanner etc.).
|
||||
*
|
||||
* Usual syntax/scanner level error handling should be done
|
||||
* in error fallback rules.
|
||||
*
|
||||
* @param errorCode the code of the errormessage to display
|
||||
*/
|
||||
private void zzScanError(int errorCode) {
|
||||
String message;
|
||||
try {
|
||||
message = ZZ_ERROR_MSG[errorCode];
|
||||
}
|
||||
catch (ArrayIndexOutOfBoundsException e) {
|
||||
message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
|
||||
}
|
||||
|
||||
throw new Error(message);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Pushes the specified amount of characters back into the input stream.
|
||||
*
|
||||
* They will be read again by then next call of the scanning method
|
||||
*
|
||||
* @param number the number of characters to be read again.
|
||||
* This number must not be greater than yylength()!
|
||||
*/
|
||||
public void yypushback(int number) {
|
||||
if ( number > yylength() )
|
||||
zzScanError(ZZ_PUSHBACK_2BIG);
|
||||
|
||||
zzMarkedPos -= number;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Resumes scanning until the next regular expression is matched,
|
||||
* the end of input is encountered or an I/O-Error occurs.
|
||||
*
|
||||
* @return the next token
|
||||
* @exception java.io.IOException if any I/O-Error occurs
|
||||
*/
|
||||
public Yytoken yylex() throws java.io.IOException, ParseException {
|
||||
int zzInput;
|
||||
int zzAction;
|
||||
|
||||
// cached fields:
|
||||
int zzCurrentPosL;
|
||||
int zzMarkedPosL;
|
||||
int zzEndReadL = zzEndRead;
|
||||
char [] zzBufferL = zzBuffer;
|
||||
char [] zzCMapL = ZZ_CMAP;
|
||||
|
||||
int [] zzTransL = ZZ_TRANS;
|
||||
int [] zzRowMapL = ZZ_ROWMAP;
|
||||
int [] zzAttrL = ZZ_ATTRIBUTE;
|
||||
|
||||
while (true) {
|
||||
zzMarkedPosL = zzMarkedPos;
|
||||
|
||||
yychar+= zzMarkedPosL-zzStartRead;
|
||||
|
||||
zzAction = -1;
|
||||
|
||||
zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
|
||||
|
||||
zzState = ZZ_LEXSTATE[zzLexicalState];
|
||||
|
||||
|
||||
zzForAction: {
|
||||
while (true) {
|
||||
|
||||
if (zzCurrentPosL < zzEndReadL)
|
||||
zzInput = zzBufferL[zzCurrentPosL++];
|
||||
else if (zzAtEOF) {
|
||||
zzInput = YYEOF;
|
||||
break zzForAction;
|
||||
}
|
||||
else {
|
||||
// store back cached positions
|
||||
zzCurrentPos = zzCurrentPosL;
|
||||
zzMarkedPos = zzMarkedPosL;
|
||||
boolean eof = zzRefill();
|
||||
// get translated positions and possibly new buffer
|
||||
zzCurrentPosL = zzCurrentPos;
|
||||
zzMarkedPosL = zzMarkedPos;
|
||||
zzBufferL = zzBuffer;
|
||||
zzEndReadL = zzEndRead;
|
||||
if (eof) {
|
||||
zzInput = YYEOF;
|
||||
break zzForAction;
|
||||
}
|
||||
else {
|
||||
zzInput = zzBufferL[zzCurrentPosL++];
|
||||
}
|
||||
}
|
||||
int zzNext = zzTransL[ zzRowMapL[zzState] + zzCMapL[zzInput] ];
|
||||
if (zzNext == -1) break zzForAction;
|
||||
zzState = zzNext;
|
||||
|
||||
int zzAttributes = zzAttrL[zzState];
|
||||
if ( (zzAttributes & 1) == 1 ) {
|
||||
zzAction = zzState;
|
||||
zzMarkedPosL = zzCurrentPosL;
|
||||
if ( (zzAttributes & 8) == 8 ) break zzForAction;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// store back cached position
|
||||
zzMarkedPos = zzMarkedPosL;
|
||||
|
||||
switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction]) {
|
||||
case 11:
|
||||
{ sb.append(yytext());
|
||||
}
|
||||
case 25: break;
|
||||
case 4:
|
||||
{ sb.delete(0, sb.length());yybegin(STRING_BEGIN);
|
||||
}
|
||||
case 26: break;
|
||||
case 16:
|
||||
{ sb.append('\b');
|
||||
}
|
||||
case 27: break;
|
||||
case 6:
|
||||
{ return new Yytoken(Yytoken.TYPE_RIGHT_BRACE,null);
|
||||
}
|
||||
case 28: break;
|
||||
case 23:
|
||||
{ Boolean val=Boolean.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
|
||||
}
|
||||
case 29: break;
|
||||
case 22:
|
||||
{ return new Yytoken(Yytoken.TYPE_VALUE, null);
|
||||
}
|
||||
case 30: break;
|
||||
case 13:
|
||||
{ yybegin(YYINITIAL);return new Yytoken(Yytoken.TYPE_VALUE, sb.toString());
|
||||
}
|
||||
case 31: break;
|
||||
case 12:
|
||||
{ sb.append('\\');
|
||||
}
|
||||
case 32: break;
|
||||
case 21:
|
||||
{ Double val=Double.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
|
||||
}
|
||||
case 33: break;
|
||||
case 1:
|
||||
{ throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_CHAR, new Character(yycharat(0)));
|
||||
}
|
||||
case 34: break;
|
||||
case 8:
|
||||
{ return new Yytoken(Yytoken.TYPE_RIGHT_SQUARE,null);
|
||||
}
|
||||
case 35: break;
|
||||
case 19:
|
||||
{ sb.append('\r');
|
||||
}
|
||||
case 36: break;
|
||||
case 15:
|
||||
{ sb.append('/');
|
||||
}
|
||||
case 37: break;
|
||||
case 10:
|
||||
{ return new Yytoken(Yytoken.TYPE_COLON,null);
|
||||
}
|
||||
case 38: break;
|
||||
case 14:
|
||||
{ sb.append('"');
|
||||
}
|
||||
case 39: break;
|
||||
case 5:
|
||||
{ return new Yytoken(Yytoken.TYPE_LEFT_BRACE,null);
|
||||
}
|
||||
case 40: break;
|
||||
case 17:
|
||||
{ sb.append('\f');
|
||||
}
|
||||
case 41: break;
|
||||
case 24:
|
||||
{ try{
|
||||
int ch=Integer.parseInt(yytext().substring(2),16);
|
||||
sb.append((char)ch);
|
||||
}
|
||||
catch(Exception e){
|
||||
throw new ParseException(yychar, ParseException.ERROR_UNEXPECTED_EXCEPTION, e);
|
||||
}
|
||||
}
|
||||
case 42: break;
|
||||
case 20:
|
||||
{ sb.append('\t');
|
||||
}
|
||||
case 43: break;
|
||||
case 7:
|
||||
{ return new Yytoken(Yytoken.TYPE_LEFT_SQUARE,null);
|
||||
}
|
||||
case 44: break;
|
||||
case 2:
|
||||
{ Long val=Long.valueOf(yytext()); return new Yytoken(Yytoken.TYPE_VALUE, val);
|
||||
}
|
||||
case 45: break;
|
||||
case 18:
|
||||
{ sb.append('\n');
|
||||
}
|
||||
case 46: break;
|
||||
case 9:
|
||||
{ return new Yytoken(Yytoken.TYPE_COMMA,null);
|
||||
}
|
||||
case 47: break;
|
||||
case 3:
|
||||
{
|
||||
}
|
||||
case 48: break;
|
||||
default:
|
||||
if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
|
||||
zzAtEOF = true;
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
zzScanError(ZZ_NO_MATCH);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
58
src/java/org/json/simple/parser/Yytoken.java
Normal file
58
src/java/org/json/simple/parser/Yytoken.java
Normal file
@ -0,0 +1,58 @@
|
||||
/*
|
||||
* $Id: Yytoken.java,v 1.1 2006/04/15 14:10:48 platform Exp $
|
||||
* Created on 2006-4-15
|
||||
*/
|
||||
package org.json.simple.parser;
|
||||
|
||||
/**
|
||||
* @author FangYidong<fangyidong@yahoo.com.cn>
|
||||
*/
|
||||
public class Yytoken {
|
||||
public static final int TYPE_VALUE=0;//JSON primitive value: string,number,boolean,null
|
||||
public static final int TYPE_LEFT_BRACE=1;
|
||||
public static final int TYPE_RIGHT_BRACE=2;
|
||||
public static final int TYPE_LEFT_SQUARE=3;
|
||||
public static final int TYPE_RIGHT_SQUARE=4;
|
||||
public static final int TYPE_COMMA=5;
|
||||
public static final int TYPE_COLON=6;
|
||||
public static final int TYPE_EOF=-1;//end of file
|
||||
|
||||
public int type=0;
|
||||
public Object value=null;
|
||||
|
||||
public Yytoken(int type,Object value){
|
||||
this.type=type;
|
||||
this.value=value;
|
||||
}
|
||||
|
||||
public String toString(){
|
||||
StringBuffer sb = new StringBuffer();
|
||||
switch(type){
|
||||
case TYPE_VALUE:
|
||||
sb.append("VALUE(").append(value).append(")");
|
||||
break;
|
||||
case TYPE_LEFT_BRACE:
|
||||
sb.append("LEFT BRACE({)");
|
||||
break;
|
||||
case TYPE_RIGHT_BRACE:
|
||||
sb.append("RIGHT BRACE(})");
|
||||
break;
|
||||
case TYPE_LEFT_SQUARE:
|
||||
sb.append("LEFT SQUARE([)");
|
||||
break;
|
||||
case TYPE_RIGHT_SQUARE:
|
||||
sb.append("RIGHT SQUARE(])");
|
||||
break;
|
||||
case TYPE_COMMA:
|
||||
sb.append("COMMA(,)");
|
||||
break;
|
||||
case TYPE_COLON:
|
||||
sb.append("COLON(:)");
|
||||
break;
|
||||
case TYPE_EOF:
|
||||
sb.append("END OF FILE");
|
||||
break;
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
}
|
||||
@ -7,8 +7,8 @@
|
||||
I2PControl
|
||||
</h1>
|
||||
<table cellspacing="8">
|
||||
<tr><td>Torrents:<td align="right"><%=I2PControlController.getTorrents().size()%>
|
||||
<tr><td>Peers:<td align="right"><%=I2PControlController.getTorrents().countPeers()%>
|
||||
<tr><td>Status:<td align="right"><%=I2PControlController.getTestString()%>
|
||||
<tr><td>Status again:<td align="right"><%=I2PControlController.getTestString()%>
|
||||
</table>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
Reference in New Issue
Block a user