From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libjava/gnu/java/net/protocol/core/Connection.h | 64 ++++++++ libjava/gnu/java/net/protocol/core/Connection.java | 172 +++++++++++++++++++++ .../gnu/java/net/protocol/core/CoreInputStream.h | 60 +++++++ .../java/net/protocol/core/CoreInputStream.java | 90 +++++++++++ libjava/gnu/java/net/protocol/core/Handler.h | 49 ++++++ libjava/gnu/java/net/protocol/core/Handler.java | 28 ++++ .../java/net/protocol/core/natCoreInputStream.cc | 51 ++++++ 7 files changed, 514 insertions(+) create mode 100644 libjava/gnu/java/net/protocol/core/Connection.h create mode 100644 libjava/gnu/java/net/protocol/core/Connection.java create mode 100644 libjava/gnu/java/net/protocol/core/CoreInputStream.h create mode 100644 libjava/gnu/java/net/protocol/core/CoreInputStream.java create mode 100644 libjava/gnu/java/net/protocol/core/Handler.h create mode 100644 libjava/gnu/java/net/protocol/core/Handler.java create mode 100644 libjava/gnu/java/net/protocol/core/natCoreInputStream.cc (limited to 'libjava/gnu/java/net/protocol/core') diff --git a/libjava/gnu/java/net/protocol/core/Connection.h b/libjava/gnu/java/net/protocol/core/Connection.h new file mode 100644 index 000000000..d09908b4c --- /dev/null +++ b/libjava/gnu/java/net/protocol/core/Connection.h @@ -0,0 +1,64 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_net_protocol_core_Connection__ +#define __gnu_java_net_protocol_core_Connection__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace gcj + { + class Core; + } + namespace java + { + namespace net + { + namespace protocol + { + namespace core + { + class Connection; + } + } + } + } + } + namespace java + { + namespace net + { + class URL; + } + } +} + +class gnu::java::net::protocol::core::Connection : public ::java::net::URLConnection +{ + +public: + Connection(::java::net::URL *); + virtual void connect(); + virtual ::java::io::InputStream * getInputStream(); + virtual ::java::lang::String * getHeaderField(::java::lang::String *); + virtual ::java::util::Map * getHeaderFields(); + virtual ::java::lang::String * getHeaderField(jint); + virtual ::java::lang::String * getHeaderFieldKey(jint); +private: + ::java::lang::String * getKey(::java::lang::String *); + ::java::lang::String * getField(::java::lang::String *); + void getHeaders(); + ::java::util::Hashtable * __attribute__((aligned(__alignof__( ::java::net::URLConnection)))) hdrHash; + ::java::util::Vector * hdrVec; + jboolean gotHeaders; + ::gnu::gcj::Core * core; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_net_protocol_core_Connection__ diff --git a/libjava/gnu/java/net/protocol/core/Connection.java b/libjava/gnu/java/net/protocol/core/Connection.java new file mode 100644 index 000000000..2319c0be9 --- /dev/null +++ b/libjava/gnu/java/net/protocol/core/Connection.java @@ -0,0 +1,172 @@ +// Connection.java - Implementation of URLConnection for core protocol. + +/* Copyright (C) 2001, 2003 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.java.net.protocol.core; + +import gnu.gcj.Core; +import java.io.InputStream; +import java.io.IOException; +import java.net.ProtocolException; +import java.net.URL; +import java.net.URLConnection; +import java.util.Map; +import java.util.Vector; +import java.util.Hashtable; +import java.util.Enumeration; + +/** + * @author Anthony Green + * @date August 13, 2001 + */ + +class Connection extends URLConnection +{ + private Hashtable hdrHash = new Hashtable(); + private Vector hdrVec = new Vector(); + private boolean gotHeaders = false; + + private Core core; + + public Connection (URL url) + { + super(url); + } + + // Implementation of abstract method. + public void connect() throws IOException + { + // Call is ignored if already connected. + if (connected) + return; + + // If not connected, then file needs to be opened. + core = Core.create (url.getFile()); + connected = true; + } + + public InputStream getInputStream() throws IOException + { + if (!connected) + connect(); + + if (! doInput) + throw new ProtocolException("Can't open InputStream if doInput is false"); + return new CoreInputStream (core); + } + + // Override default method in URLConnection. + public String getHeaderField(String name) + { + try + { + getHeaders(); + } + catch (IOException x) + { + return null; + } + return (String) hdrHash.get(name.toLowerCase()); + } + + // Override default method in URLConnection. + public Map getHeaderFields() + { + try + { + getHeaders(); + } + catch (IOException x) + { + return null; + } + return hdrHash; + } + + // Override default method in URLConnection. + public String getHeaderField(int n) + { + try + { + getHeaders(); + } + catch (IOException x) + { + return null; + } + if (n < hdrVec.size()) + return getField ((String) hdrVec.elementAt(n)); + + return null; + } + + // Override default method in URLConnection. + public String getHeaderFieldKey(int n) + { + try + { + getHeaders(); + } + catch (IOException x) + { + return null; + } + if (n < hdrVec.size()) + return getKey ((String) hdrVec.elementAt(n)); + + return null; + } + + private String getKey(String str) + { + if (str == null) + return null; + int index = str.indexOf(':'); + if (index >= 0) + return str.substring(0, index); + else + return null; + } + + private String getField(String str) + { + if (str == null) + return null; + int index = str.indexOf(':'); + if (index >= 0) + return str.substring(index + 1).trim(); + else + return str; + } + + private void getHeaders() throws IOException + { + if (gotHeaders) + return; + gotHeaders = true; + + connect(); + + // Yes, it is overkill to use the hash table and vector here since + // we're only putting one header in the file, but in case we need + // to add others later and for consistency, we'll implement it this way. + + // Add the only header we know about right now: Content-length. + long len = core.length; + String line = "Content-length: " + len; + hdrVec.addElement(line); + + // The key will never be null in this scenario since we build up the + // headers ourselves. If we ever rely on getting a header from somewhere + // else, then we may have to check if the result of getKey() is null. + String key = getKey(line); + hdrHash.put(key.toLowerCase(), Long.toString(len)); + } +} + diff --git a/libjava/gnu/java/net/protocol/core/CoreInputStream.h b/libjava/gnu/java/net/protocol/core/CoreInputStream.h new file mode 100644 index 000000000..d6beb3965 --- /dev/null +++ b/libjava/gnu/java/net/protocol/core/CoreInputStream.h @@ -0,0 +1,60 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_net_protocol_core_CoreInputStream__ +#define __gnu_java_net_protocol_core_CoreInputStream__ + +#pragma interface + +#include +#include + +extern "Java" +{ + namespace gnu + { + namespace gcj + { + class Core; + class RawData; + } + namespace java + { + namespace net + { + namespace protocol + { + namespace core + { + class CoreInputStream; + } + } + } + } + } +} + +class gnu::java::net::protocol::core::CoreInputStream : public ::java::io::InputStream +{ + + jint unsafeGetByte(jlong); + jint copyIntoByteArray(JArray< jbyte > *, jint, jint); +public: + CoreInputStream(::gnu::gcj::Core *); + virtual jint available(); + virtual void mark(jint); + virtual jboolean markSupported(); + virtual jint read(); + virtual jint read(JArray< jbyte > *, jint, jint); + virtual void reset(); + virtual jlong skip(jlong); +public: // actually protected + ::gnu::gcj::RawData * __attribute__((aligned(__alignof__( ::java::io::InputStream)))) ptr; + jint pos; + jint mark__; + jint count; +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_net_protocol_core_CoreInputStream__ diff --git a/libjava/gnu/java/net/protocol/core/CoreInputStream.java b/libjava/gnu/java/net/protocol/core/CoreInputStream.java new file mode 100644 index 000000000..421bb1c47 --- /dev/null +++ b/libjava/gnu/java/net/protocol/core/CoreInputStream.java @@ -0,0 +1,90 @@ +// Handler.java - URLStreamHandler for core protocol. + +/* Copyright (C) 2001 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.java.net.protocol.core; + +import gnu.gcj.Core; +import gnu.gcj.RawData; +import java.io.InputStream; +import java.io.IOException; + +public class CoreInputStream extends InputStream +{ + /* A pointer to the object in memory. */ + protected RawData ptr; + + /* Position of the next byte in core to be read. */ + protected int pos; + + /* The currently marked position in the stream. */ + protected int mark; + + /* The index in core one greater than the last valid character. */ + protected int count; + + private native int unsafeGetByte (long offset); + private native int copyIntoByteArray (byte[] dest, int offset, int numBytes); + + public CoreInputStream (Core core) + { + ptr = core.ptr; + count = core.length; + } + + public synchronized int available() + { + return count - pos; + } + + public synchronized void mark(int readAheadLimit) + { + // readAheadLimit is ignored per Java Class Lib. book, p.220. + mark = pos; + } + + public boolean markSupported() + { + return true; + } + + public synchronized int read() + { + if (pos < count) + return ((int) unsafeGetByte(pos++)) & 0xFF; + return -1; + } + + public synchronized int read(byte[] b, int off, int len) + { + if (pos >= count) + return -1; + + int numBytes = Math.min(count - pos, len); + copyIntoByteArray (b, off, numBytes); + pos += numBytes; + return numBytes; + } + + public synchronized void reset() + { + pos = mark; + } + + public synchronized long skip(long n) + { + // Even though the var numBytes is a long, in reality it can never + // be larger than an int since the result of subtracting 2 positive + // ints will always fit in an int. Since we have to return a long + // anyway, numBytes might as well just be a long. + long numBytes = Math.min ((long) (count - pos), n < 0 ? 0L : n); + pos += numBytes; + return numBytes; + } +} diff --git a/libjava/gnu/java/net/protocol/core/Handler.h b/libjava/gnu/java/net/protocol/core/Handler.h new file mode 100644 index 000000000..364e21abb --- /dev/null +++ b/libjava/gnu/java/net/protocol/core/Handler.h @@ -0,0 +1,49 @@ + +// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*- + +#ifndef __gnu_java_net_protocol_core_Handler__ +#define __gnu_java_net_protocol_core_Handler__ + +#pragma interface + +#include +extern "Java" +{ + namespace gnu + { + namespace java + { + namespace net + { + namespace protocol + { + namespace core + { + class Handler; + } + } + } + } + } + namespace java + { + namespace net + { + class URL; + class URLConnection; + } + } +} + +class gnu::java::net::protocol::core::Handler : public ::java::net::URLStreamHandler +{ + +public: + Handler(); +public: // actually protected + virtual ::java::net::URLConnection * openConnection(::java::net::URL *); +public: + static ::java::lang::Class class$; +}; + +#endif // __gnu_java_net_protocol_core_Handler__ diff --git a/libjava/gnu/java/net/protocol/core/Handler.java b/libjava/gnu/java/net/protocol/core/Handler.java new file mode 100644 index 000000000..8726172d2 --- /dev/null +++ b/libjava/gnu/java/net/protocol/core/Handler.java @@ -0,0 +1,28 @@ +// Handler.java - URLStreamHandler for core protocol. + +/* Copyright (C) 2001 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +package gnu.java.net.protocol.core; + +import java.io.IOException; +import java.net.URL; +import java.net.URLConnection; +import java.net.URLStreamHandler; + +/** + * @author Anthony Green + * @date August 13, 2001. + */ +public class Handler extends URLStreamHandler +{ + protected URLConnection openConnection(URL url) throws IOException + { + return new Connection(url); + } +} diff --git a/libjava/gnu/java/net/protocol/core/natCoreInputStream.cc b/libjava/gnu/java/net/protocol/core/natCoreInputStream.cc new file mode 100644 index 000000000..4053efcd1 --- /dev/null +++ b/libjava/gnu/java/net/protocol/core/natCoreInputStream.cc @@ -0,0 +1,51 @@ +// natCoreInputStream.cc -- C++ side of CoreInputStream + +/* Copyright (C) 2001 Free Software Foundation + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +/* Author: Anthony Green . */ + +#include + +#include +#include +#include + +#include +#include +#include + +jint +gnu::java::net::protocol::core::CoreInputStream::unsafeGetByte (jlong offset) +{ + return ((char*) ptr) [offset]; +} + +jint +gnu::java::net::protocol::core::CoreInputStream::copyIntoByteArray (jbyteArray dest, + jint offset, + jint numBytes) +{ + if (!dest) + throw new ::java::lang::NullPointerException; + + jsize destSize = JvGetArrayLength (dest); + + if (offset < 0 || numBytes < 0 || offset + numBytes < 0 + || offset + numBytes > destSize + || pos + numBytes > count) + throw new ::java::lang::ArrayIndexOutOfBoundsException; + + void *pcore = (void *) &((char*) ptr) [pos]; + void *pdest = (void *) (elements (dest) + offset); + + memcpy (pdest, pcore, numBytes); + + return 0; +} + -- cgit v1.2.3