diff options
Diffstat (limited to 'test/scanners/java/jruby.in.java')
| -rw-r--r-- | test/scanners/java/jruby.in.java | 51193 |
1 files changed, 0 insertions, 51193 deletions
diff --git a/test/scanners/java/jruby.in.java b/test/scanners/java/jruby.in.java deleted file mode 100644 index 538abfa..0000000 --- a/test/scanners/java/jruby.in.java +++ /dev/null @@ -1,51193 +0,0 @@ -package org.jruby; - -public enum CompatVersion { - - RUBY1_8, RUBY1_9, BOTH; - - public static CompatVersion getVersionFromString(String compatString) { - if (compatString.equalsIgnoreCase("RUBY1_8")) { - return CompatVersion.RUBY1_8; - } else if (compatString.equalsIgnoreCase("RUBY1_9")) { - return CompatVersion.RUBY1_9; - } else { - return null; - } - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Damian Steer <pldms@mac.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -/** - * An almost entirely useless interface for those objects that we _really_ want - * to finalise. - * - * @author pldms - * - */ -public interface Finalizable { - public void finalize(); -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002 Jan Arne Petersen <jpetersen@uni-bonn.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; -/** - * Error numbers. - * @fixme - * this interface is a big hack defining a bunch of arbitrary valor as system call error numbers - * this is actually because I need them but will probably need to be changed to something smarter - * sooner or later. - * The purpose of this class it to help implement the Errno module which in turn in needed by rubicon. - * @author Benoit Cerrina - **/ -public interface IErrno -{ - int EPERM = 1; - int ENOENT = 2; - int ESRCH = 3; - int EINTR = 4; - int EIO = 5; - int ENXIO = 6; - int E2BIG = 7; - int ENOEXEC = 8; - int EBADF = 9; - int ECHILD = 10; - int EDEADLK = 11; - int ENOMEM = 12; - int EACCES = 13; - int EFAULT = 14; - int ENOTBLK = 15; - int EBUSY = 16; - int EEXIST = 17; - int EXDEV = 18; - int ENODEV = 19; - int ENOTDIR = 20; - int EISDIR = 21; - int EINVAL = 22; - int ENFILE = 23; - int EMFILE = 24; - int ENOTTY = 25; - int ETXTBSY = 26; - int EFBIG = 27; - int ENOSPC = 28; - int ESPIPE = 29; - int EROFS = 30; - int EMLINK = 31; - int EPIPE = 32; - int EDOM = 33; - int ERANGE = 34; - int EWOULDBLOCK = 35; - int EAGAIN = 35; - int EINPROGRESS = 36; - int EALREADY = 37; - int ENOTSOCK = 38; - int EDESTADDRREQ = 39; - int EMSGSIZE = 40; - int EPROTOTYPE = 41; - int ENOPROTOOPT = 42; - int EPROTONOSUPPORT = 43; - int ESOCKTNOSUPPORT = 44; - int EOPNOTSUPP = 45; - int EPFNOSUPPORT = 46; - int EAFNOSUPPORT = 47; - int EADDRINUSE = 48; - int EADDRNOTAVAIL = 49; - int ENETDOWN = 50; - int ENETUNREACH = 51; - int ENETRESET = 52; - int ECONNABORTED = 53; - int ECONNRESET = 54; - int ENOBUFS = 55; - int EISCONN = 56; - int ENOTCONN = 57; - int ESHUTDOWN = 58; - int ETOOMANYREFS = 59; - int ETIMEDOUT = 60; - int ECONNREFUSED = 61; - int ELOOP = 62; - int ENAMETOOLONG = 63; - int EHOSTDOWN = 64; - int EHOSTUNREACH = 65; - int ENOTEMPTY = 66; - int EUSERS = 68; - int EDQUOT = 69; - int ESTALE = 70; - int EREMOTE = 71; - int ENOLCK = 77; - int ENOSYS = 78; - int EOVERFLOW = 84; - int EIDRM = 90; - int ENOMSG = 91; - int EILSEQ = 92; - int EBADMSG = 94; - int EMULTIHOP = 95; - int ENODATA = 96; - int ENOLINK = 97; - int ENOSR = 98; - int ENOSTR = 99; - int EPROTO = 100; - int ETIME = 101; - int EOPNOTSUPP_DARWIN = 102; -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2007 William N Dortch <bill.dortch@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.util.List; -import java.util.Map; - -import org.jruby.internal.runtime.methods.DynamicMethod; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.builtin.Variable; - -/** - * This class is used to provide an intermediate superclass for modules and classes that include - * other modules. It inserts itself as the immediate superClass of the includer, but defers all - * module methods to the actual superclass. Multiple of these intermediate superclasses can be - * added for multiple included modules. - * - * This allows the normal superclass-based searches (searchMethod, getConstant, etc) to traverse - * the superclass ancestors as normal while the included modules do not actually show up in - * direct inheritance traversal. - * - * @see org.jruby.RubyModule - */ -public final class IncludedModuleWrapper extends RubyClass { - private final RubyModule delegate; - - public IncludedModuleWrapper(Ruby runtime, RubyClass superClass, RubyModule delegate) { - super(runtime, superClass, false); - this.delegate = delegate; - this.metaClass = delegate.metaClass; - } - - /** - * Overridden newIncludeClass implementation to allow attaching future includes to the correct module - * (i.e. the one to which this is attached) - * - * @see org.jruby.RubyModule#newIncludeClass(RubyClass) - */ - @Override - public IncludedModuleWrapper newIncludeClass(RubyClass superClass) { - IncludedModuleWrapper includedModule = new IncludedModuleWrapper(getRuntime(), superClass, getNonIncludedClass()); - - // include its parent (and in turn that module's parents) - if (getSuperClass() != null) { - includedModule.includeModule(getSuperClass()); - } - - return includedModule; - } - - @Override - public boolean isModule() { - return false; - } - - @Override - public boolean isClass() { - return false; - } - - @Override - public boolean isIncluded() { - return true; - } - - @Override - public boolean isImmediate() { - return true; - } - - @Override - public void setMetaClass(RubyClass newRubyClass) { - throw new UnsupportedOperationException("An included class is only a wrapper for a module"); - } - - @Override - public Map<String, DynamicMethod> getMethods() { - return delegate.getMethods(); - } - - @Override - public void addMethod(String name, DynamicMethod method) { - throw new UnsupportedOperationException("An included class is only a wrapper for a module"); - } - - public void setMethods(Map newMethods) { - throw new UnsupportedOperationException("An included class is only a wrapper for a module"); - } - - @Override - public String getName() { - return delegate.getName(); - } - - @Override - public RubyModule getNonIncludedClass() { - return delegate; - } - - @Override - public RubyClass getRealClass() { - return getSuperClass().getRealClass(); - } - - @Override - protected boolean isSame(RubyModule module) { - return delegate.isSame(module); - } - - /** - * We don't want to reveal ourselves to Ruby code, so delegate this - * operation. - */ - @Override - public IRubyObject id() { - return delegate.id(); - } - - // - // VARIABLE TABLE METHODS - pass to delegate - // - - @Override - protected boolean variableTableContains(String name) { - return delegate.variableTableContains(name); - } - - @Override - protected boolean variableTableFastContains(String internedName) { - return delegate.variableTableFastContains(internedName); - } - - @Override - protected IRubyObject variableTableFetch(String name) { - return delegate.variableTableFetch(name); - } - - @Override - protected IRubyObject variableTableFastFetch(String internedName) { - return delegate.variableTableFastFetch(internedName); - } - - @Override - protected IRubyObject variableTableStore(String name, IRubyObject value) { - return delegate.variableTableStore(name, value); - } - - @Override - protected IRubyObject variableTableFastStore(String internedName, IRubyObject value) { - return delegate.variableTableFastStore(internedName, value); - } - - @Override - protected IRubyObject variableTableRemove(String name) { - return delegate.variableTableRemove(name); - } - - @Override - protected VariableTableEntry[] variableTableGetTable() { - return delegate.variableTableGetTable(); - } - - @Override - protected int variableTableGetSize() { - return delegate.variableTableGetSize(); - } - - @Override - protected void variableTableSync(List<Variable<IRubyObject>> vars) { - delegate.variableTableSync(vars); - } - - @Override - protected IRubyObject variableTableReadLocked(VariableTableEntry entry) { - return delegate.variableTableReadLocked(entry); - } - - /** - * Method to help ease transition to new variables implementation. - * Will likely be deprecated in the near future. - */ - @SuppressWarnings("unchecked") - @Override - @Deprecated // born deprecated - protected Map variableTableGetMap() { - return delegate.variableTableGetMap(); - } - - /** - * Method to help ease transition to new variables implementation. - * Will likely be deprecated in the near future. - */ - @SuppressWarnings("unchecked") - @Override - @Deprecated // born deprecated - protected Map variableTableGetMap(Map map) { - return delegate.variableTableGetMap(map); - } - - // - // CONSTANT TABLE METHODS - pass to delegate - // - - @Override - protected boolean constantTableContains(String name) { - return delegate.constantTableContains(name); - } - - @Override - protected boolean constantTableFastContains(String internedName) { - return delegate.constantTableFastContains(internedName); - } - - @Override - protected IRubyObject constantTableFetch(String name) { - return delegate.constantTableFetch(name); - } - - @Override - protected IRubyObject constantTableFastFetch(String internedName) { - return delegate.constantTableFastFetch(internedName); - } - - @Override - protected IRubyObject constantTableStore(String name, IRubyObject value) { - // FIXME: legal here? may want UnsupportedOperationException - return delegate.constantTableStore(name, value); - } - - @Override - protected IRubyObject constantTableFastStore(String internedName, IRubyObject value) { - // FIXME: legal here? may want UnsupportedOperationException - return delegate.constantTableFastStore(internedName, value); - } - - @Override - protected IRubyObject constantTableRemove(String name) { - // this _is_ legal (when removing an undef) - return delegate.constantTableRemove(name); - } - - @Override - protected ConstantTableEntry[] constantTableGetTable() { - return delegate.constantTableGetTable(); - } - - @Override - protected int constantTableGetSize() { - return delegate.constantTableGetSize(); - } - - @Override - protected void constantTableSync(List<Variable<IRubyObject>> vars) { - // FIXME: legal here? may want UnsupportedOperationException - delegate.constantTableSync(vars); - } - - /** - * Method to help ease transition to new variables implementation. - * Will likely be deprecated in the near future. - */ - @SuppressWarnings("unchecked") - @Override - @Deprecated // born deprecated - protected Map constantTableGetMap() { - return delegate.constantTableGetMap(); - } - - /** - * Method to help ease transition to new variables implementation. - * Will likely be deprecated in the near future. - */ - @SuppressWarnings("unchecked") - @Override - @Deprecated // born deprecated - protected Map constantTableGetMap(Map map) { - return delegate.constantTableGetMap(map); - } - -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Charles Nutter <charles.o.nutter@sun.com> - * Copyright (C) 2008 MenTaLguY <mental@rydia.net> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.applet.Applet; -import java.awt.BorderLayout; -import java.awt.Color; -import java.awt.Container; -import java.awt.EventQueue; -import java.awt.Font; -import java.awt.Insets; -import java.awt.Graphics; -import java.awt.GraphicsConfiguration; -import java.awt.GraphicsEnvironment; -import java.awt.image.VolatileImage; -import java.io.IOException; -import java.io.InputStream; -import java.io.PrintStream; -import java.net.URL; -import java.util.Arrays; - -import java.lang.reflect.InvocationTargetException; - -import org.jruby.anno.JRubyMethod; -import org.jruby.demo.TextAreaReadline; -import org.jruby.javasupport.JavaUtil; -import org.jruby.runtime.Block; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -import javax.swing.JScrollPane; -import javax.swing.JTextPane; - -/** - * @author <a href="mailto:mental@rydia.net">MenTaLguY</a> - * - * The JRubyApplet class provides a simple way to write Java applets using - * JRuby without needing to create a custom Java applet class. At applet - * initialization time, JRubyApplet starts up a JRuby runtime, then evaluates - * the scriptlet given as the "eval" applet parameter. - * - * The Java applet instance is available to the Ruby script as - * JRUBY_APPLET; the script can define callbacks for applet start, stop, - * and destroy by passing blocks to JRUBY_APPLET.on_start, - * JRUBY_APPLET.on_stop, and JRUBY_APPLET.on_destroy, respectively. - * - * Ruby code can install a custom paint callback using JRUBY_APPLET.on_paint - * (the Graphics2D object is passed as an argument to the callback). By - * default, JRubyApplet painting is double-buffered, but you can select - * single-buffered painting via JRUBY_APPLET.double_buffered = false. - * - * The applet's background color can be set via JRUBY_APPLET.background_color=. - * You may want to set it to nil if you're not using double-buffering, so that - * no background color will be drawn (your own paint code is then responsible - * for filling the area). - * - * Beyond these things, you should be able to use JRuby's Java integration - * to do whatever you would do in Java with the applet instance. - * - */ -public class JRubyApplet extends Applet { - private Ruby runtime; - private boolean doubleBuffered = true; - private Color backgroundColor = Color.WHITE; - private RubyProc startProc; - private RubyProc stopProc; - private RubyProc destroyProc; - private RubyProc paintProc; - private Graphics priorGraphics; - private IRubyObject wrappedGraphics; - private VolatileImage backBuffer; - private Graphics backBufferGraphics; - private Facade facade; - - private interface Facade { - public InputStream getInputStream(); - public PrintStream getOutputStream(); - public PrintStream getErrorStream(); - public void attach(Ruby runtime, Applet applet); - public void destroy(); - } - - private static RubyProc blockToProc(Ruby runtime, Block block) { - if (block.isGiven()) { - RubyProc proc = block.getProcObject(); - if (proc == null) { - proc = RubyProc.newProc(runtime, block, block.type); - } - return proc; - } else { - return null; - } - } - - private boolean getBooleanParameter(String name, boolean defaultValue) { - String value = getParameter(name); - if ( value != null ) { - return value.equals("true"); - } else { - return defaultValue; - } - } - - private InputStream getCodeResourceAsStream(String name) { - if (name == null) { - return null; - } - try { - final URL directURL = new URL(getCodeBase(), name); - return directURL.openStream(); - } catch (IOException e) { - } - return JRubyApplet.class.getClassLoader().getResourceAsStream(name); - } - - private static void safeInvokeAndWait(Runnable runnable) throws InvocationTargetException, InterruptedException { - if (EventQueue.isDispatchThread()) { - try { - runnable.run(); - } catch (Exception e) { - throw new InvocationTargetException(e); - } - } else { - EventQueue.invokeAndWait(runnable); - } - } - - public static class RubyMethods { - @JRubyMethod - public static IRubyObject on_start(IRubyObject recv, Block block) { - JRubyApplet applet = (JRubyApplet)recv.dataGetStruct(); - synchronized (applet) { - applet.startProc = blockToProc(applet.runtime, block); - } - return recv; - } - - @JRubyMethod - public static IRubyObject on_stop(IRubyObject recv, Block block) { - JRubyApplet applet = (JRubyApplet)recv.dataGetStruct(); - synchronized (applet) { - applet.stopProc = blockToProc(applet.runtime, block); - } - return recv; - } - - @JRubyMethod - public static IRubyObject on_destroy(IRubyObject recv, Block block) { - JRubyApplet applet = (JRubyApplet)recv.dataGetStruct(); - synchronized (applet) { - applet.destroyProc = blockToProc(applet.runtime, block); - } - return recv; - } - - @JRubyMethod - public static IRubyObject on_paint(IRubyObject recv, Block block) { - JRubyApplet applet = (JRubyApplet)recv.dataGetStruct(); - synchronized (applet) { - applet.paintProc = blockToProc(applet.runtime, block); - applet.repaint(); - } - return recv; - } - } - - @Override - public void init() { - super.init(); - - if (getBooleanParameter("jruby.console", false)) { - facade = new ConsoleFacade(getParameter("jruby.banner")); - } else { - facade = new TrivialFacade(); - } - - synchronized (this) { - if (runtime != null) { - return; - } - - final RubyInstanceConfig config = new RubyInstanceConfig() {{ - setInput(facade.getInputStream()); - setOutput(facade.getOutputStream()); - setError(facade.getErrorStream()); - setObjectSpaceEnabled(getBooleanParameter("jruby.objectspace", false)); - }}; - Ruby.setSecurityRestricted(true); - runtime = Ruby.newInstance(config); - } - - final String scriptName = getParameter("jruby.script"); - final InputStream scriptStream = getCodeResourceAsStream(scriptName); - final String evalString = getParameter("jruby.eval"); - - try { - final JRubyApplet applet = this; - safeInvokeAndWait(new Runnable() { - public void run() { - applet.setLayout(new BorderLayout()); - applet.facade.attach(applet.runtime, applet); - if (scriptStream != null) { - applet.runtime.runFromMain(scriptStream, scriptName); - } - if (evalString != null) { - applet.runtime.evalScriptlet(evalString); - } - } - }); - } catch (InterruptedException e) { - } catch (InvocationTargetException e) { - throw new RuntimeException("Error running script", e.getCause()); - } - } - - private void invokeCallback(final RubyProc proc, final IRubyObject[] args) { - if (proc == null) { - return; - } - final Ruby runtime = this.runtime; - try { - safeInvokeAndWait(new Runnable() { - public void run() { - ThreadContext context = runtime.getCurrentContext(); - proc.call(context, args); - } - }); - } catch (InterruptedException e) { - } catch (InvocationTargetException e) { - throw new RuntimeException("Ruby callback failed", e.getCause()); - } - } - - public synchronized void setBackgroundColor(Color color) { - backgroundColor = color; - repaint(); - } - - public synchronized Color getBackgroundColor() { - return backgroundColor; - } - - public synchronized boolean isDoubleBuffered() { - return doubleBuffered; - } - - public synchronized void setDoubleBuffered(boolean shouldBuffer) { - doubleBuffered = shouldBuffer; - repaint(); - } - - @Override - public synchronized void start() { - super.start(); - invokeCallback(startProc, new IRubyObject[] {}); - } - - @Override - public synchronized void stop() { - invokeCallback(stopProc, new IRubyObject[] {}); - super.stop(); - } - - @Override - public synchronized void destroy() { - try { - invokeCallback(destroyProc, new IRubyObject[] {}); - } finally { - facade.destroy(); - final Ruby runtime = this.runtime; - this.runtime = null; - startProc = null; - stopProc = null; - destroyProc = null; - paintProc = null; - priorGraphics = null; - wrappedGraphics = null; - runtime.tearDown(); - super.destroy(); - } - } - - @Override - public void update(Graphics g) { - paint(g); - } - - @Override - public synchronized void paint(Graphics g) { - if (doubleBuffered) { - paintBuffered(g); - } else { - paintUnbuffered(g); - } - } - - private synchronized void paintBuffered(Graphics g) { - do { - GraphicsConfiguration config = getGraphicsConfiguration(); - int width = getWidth(); - int height = getHeight(); - if (backBuffer == null || width != backBuffer.getWidth() || height != backBuffer.getHeight() || backBuffer.validate(config) == VolatileImage.IMAGE_INCOMPATIBLE) { - if (backBuffer != null) { - backBufferGraphics.dispose(); - backBufferGraphics = null; - backBuffer.flush(); - backBuffer = null; - } - backBuffer = config.createCompatibleVolatileImage(width, height); - backBufferGraphics = backBuffer.createGraphics(); - } - backBufferGraphics.setClip(g.getClip()); - paintUnbuffered(backBufferGraphics); - g.drawImage(backBuffer, 0, 0, this); - } while (backBuffer.contentsLost()); - } - - private synchronized void paintUnbuffered(Graphics g) { - if (backgroundColor != null) { - g.setColor(backgroundColor); - g.fillRect(0, 0, getWidth(), getHeight()); - } - if (paintProc != null) { - if (priorGraphics != g) { - wrappedGraphics = JavaUtil.convertJavaToUsableRubyObject(runtime, g); - priorGraphics = g; - } - ThreadContext context = runtime.getCurrentContext(); - paintProc.call(context, new IRubyObject[] {wrappedGraphics}); - } - super.paint(g); - } - - private static class TrivialFacade implements Facade { - public TrivialFacade() {} - public InputStream getInputStream() { return System.in; } - public PrintStream getOutputStream() { return System.out; } - public PrintStream getErrorStream() { return System.err; } - public void attach(Ruby runtime, Applet applet) { - final IRubyObject wrappedApplet = JavaUtil.convertJavaToUsableRubyObject(runtime, applet); - wrappedApplet.dataWrapStruct(applet); - runtime.defineGlobalConstant("JRUBY_APPLET", wrappedApplet); - wrappedApplet.getMetaClass().defineAnnotatedMethods(RubyMethods.class); - } - public void destroy() {} - } - - private static class ConsoleFacade implements Facade { - private JTextPane textPane; - private JScrollPane scrollPane; - private TextAreaReadline adaptor; - private InputStream inputStream; - private PrintStream outputStream; - private PrintStream errorStream; - - public ConsoleFacade(String bannerText) { - textPane = new JTextPane(); - textPane.setMargin(new Insets(4, 4, 0, 4)); - textPane.setCaretColor(new Color(0xa4, 0x00, 0x00)); - textPane.setBackground(new Color(0xf2, 0xf2, 0xf2)); - textPane.setForeground(new Color(0xa4, 0x00, 0x00)); - - Font font = findFont("Monospaced", Font.PLAIN, 14, - new String[] {"Monaco", "Andale Mono"}); - - textPane.setFont(font); - - scrollPane = new JScrollPane(textPane); - scrollPane.setDoubleBuffered(true); - if ( bannerText != null ) { - bannerText = " " + bannerText + " \n\n"; - } - adaptor = new TextAreaReadline(textPane, bannerText); - inputStream = adaptor.getInputStream(); - outputStream = new PrintStream(adaptor.getOutputStream()); - errorStream = new PrintStream(adaptor.getOutputStream()); - } - - public InputStream getInputStream() { return inputStream; } - public PrintStream getOutputStream() { return outputStream; } - public PrintStream getErrorStream() { return errorStream; } - - public void attach(Ruby runtime, Applet applet) { - adaptor.hookIntoRuntime(runtime); - applet.add(scrollPane); - applet.validate(); - } - - public void destroy() { - Container parent = scrollPane.getParent(); - adaptor.shutdown(); - if (parent != null) { - parent.remove(scrollPane); - } - } - - private Font findFont(String otherwise, int style, int size, String[] families) { - String[] fonts = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames(); - Arrays.sort(fonts); - for (int i = 0; i < families.length; i++) { - if (Arrays.binarySearch(fonts, families[i]) >= 0) { - return new Font(families[i], style, size); - } - } - return new Font(otherwise, style, size); - } - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.BufferedWriter; -import java.io.OutputStreamWriter; - -import java.net.InetAddress; -import java.net.Socket; - -/** - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -public class JRubyClient extends JRubyService { - public JRubyClient(String[] args) throws Exception { - Configuration conf = new Configuration(args[0]); - if(conf.isDebug()) { - System.err.println("Starting client with port " + conf.getPort() + ", key " + conf.getKey() + " and command " + conf.getCommand()); - } - Socket socket = new Socket(InetAddress.getLocalHost(), conf.getPort()); - BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); - if(conf.terminate()) { - writer.write(CMD_TERM + " " + conf.getKey() + "\n"); - } else if(conf.noMore()) { - writer.write(CMD_NO_MORE + " " + conf.getKey() + "\n"); - } else { - writer.write(CMD_START + " " + conf.getKey() + " " + conf.getCommand() + "\n"); - } - writer.flush(); - writer.close(); - socket.close(); - } - - public static void main(String[] args) throws Exception { - new JRubyClient(args); - } -}// JRubyClient -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.BufferedReader; -import java.io.InputStreamReader; - -import java.net.InetAddress; -import java.net.InetSocketAddress; -import java.net.ServerSocket; -import java.net.Socket; - -import java.util.List; -import java.util.ArrayList; - -/** - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -public class JRubyServer extends JRubyService { - private Configuration conf; - - private boolean stillStarting = true; - - private JRubyServer(String[] args) throws Exception { - conf = new Configuration(args[0]); - if(conf.isDebug()) { - System.err.println("Starting server with port " + conf.getPort() + " and key " + conf.getKey()); - } - ServerSocket server = new ServerSocket(); - server.bind(new InetSocketAddress(InetAddress.getLocalHost(),conf.getPort())); - while(true) { - Thread t1 = new Thread(new Handler(server.accept())); - t1.setDaemon(true); - t1.start(); - } - } - - private class Handler implements Runnable { - private Socket socket; - - public Handler(Socket socket) { - this.socket = socket; - } - - public void run() { - try { - BufferedReader rr = new BufferedReader(new InputStreamReader(this.socket.getInputStream())); - String command = rr.readLine(); - rr.close(); - this.socket.close(); - this.socket = null; - if(conf.isDebug()) { - System.err.println("Got command: " + command); - } - String[] cmds = command.split(" ", 3); - if(cmds[1].equals(conf.getKey())) { - if(cmds[0].equals(CMD_TERM)) { - if(conf.isDebug()) { - System.err.println("Terminating hard"); - } - System.exit(0); - } else if(cmds[0].equals(CMD_NO_MORE)) { - if(conf.isDebug()) { - System.err.println("Accepting no more START"); - } - stillStarting = false; - } else if(cmds[0].equals(CMD_START)) { - if(stillStarting) { - if(conf.isDebug()) { - System.err.println("Doing START on command " + cmds[2]); - } - new Main().run(intoCommandArguments(cmds[2].trim())); - } else { - if(conf.isDebug()) { - System.err.println("Not doing START anymore, invalid command"); - } - } - } else { - if(conf.isDebug()) { - System.err.println("Unrecognized command"); - } - } - } else { - if(conf.isDebug()) { - System.err.println("Invalid key"); - } - } - } catch(Exception e) {} - } - } - - protected static String[] intoCommandArguments(String str) { - List<String> args = new ArrayList<String>(); - boolean inSingle = false; - int contentStart = -1; - - for(int i=0,j=str.length();i<j;i++) { - if(str.charAt(i) == ' ' && !inSingle && contentStart != -1) { - args.add(str.substring(contentStart,i)); - contentStart = -1; - continue; - } - if(str.charAt(i) == ' ') { - continue; - } - if(str.charAt(i) == '\'' && !inSingle) { - inSingle = true; - contentStart = i+1; - continue; - } - if(str.charAt(i) == '\'') { - inSingle = false; - args.add(str.substring(contentStart,i)); - contentStart = -1; - continue; - } - if(contentStart == -1) { - contentStart = i; - } - } - if(contentStart != -1) { - args.add(str.substring(contentStart)); - } - return (String[])args.toArray(new String[0]); - } - - public static void main(String[] args) throws Exception { - new JRubyServer(args); - } -}// JRubyServer -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -/** - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -public abstract class JRubyService { - protected static class Configuration { - private final static int DEFAULT_PORT = 19222; - - private String key; - private int port = DEFAULT_PORT; - private boolean terminate; - private boolean noMore; - private boolean debug; - private String command; - - public Configuration(String args) { - int i=0; - int stop; - loop: for(int j=args.length();i<j;i++) { - if(args.charAt(i) == '-' && i+1 < j) { - switch(args.charAt(++i)) { - case 'k': - stop = args.indexOf(" ", (++i) + 1); - if(stop == -1) { - stop = args.length(); - } - key = args.substring(i, stop).trim(); - i = stop; - break; - case 'p': - stop = args.indexOf(" ", (++i) + 1); - if(stop == -1) { - stop = args.length(); - } - port = Integer.parseInt(args.substring(i, stop).trim()); - i = stop; - break; - case 't': - terminate = true; - i++; - break; - case 'n': - noMore = true; - i++; - break; - case 'd': - debug = true; - i++; - break; - case '-': // handle everything after -- as arguments to the jruby process - i++; - break loop; - default: - i--; - break loop; - } - } else if(args.charAt(i) != ' ') { - break loop; - } - } - if(i<args.length()) { - command = args.substring(i).trim(); - } - } - - public String getKey() { - return key; - } - - public int getPort() { - return port; - } - - public boolean terminate() { - return terminate; - } - - public boolean noMore() { - return noMore; - } - - public boolean isDebug() { - return debug; - } - - public String getCommand() { - return command; - } - } - - public static final String CMD_START = "START"; - public static final String CMD_NO_MORE = "NO_MORE"; - public static final String CMD_TERM = "TERM"; -}// JRubyService -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2006 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Kiel Hodges <jruby-devel@selfsosoft.com> - * Copyright (C) 2005 Jason Voegele <jason@jvoegele.com> - * Copyright (C) 2005 Tim Azzopardi <tim@tigerfive.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.InputStream; -import java.io.PrintStream; - -import org.jruby.exceptions.MainExitException; -import org.jruby.exceptions.RaiseException; -import org.jruby.exceptions.ThreadKill; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.SafePropertyAccessor; -import org.jruby.util.SimpleSampler; - -/** - * Class used to launch the interpreter. - * This is the main class as defined in the jruby.mf manifest. - * It is very basic and does not support yet the same array of switches - * as the C interpreter. - * Usage: java -jar jruby.jar [switches] [rubyfile.rb] [arguments] - * -e 'command' one line of script. Several -e's allowed. Omit [programfile] - * @author jpetersen - */ -public class Main { - private boolean hasPrintedUsage = false; - private final RubyInstanceConfig config; - - public Main(RubyInstanceConfig config) { - this.config = config; - } - - public Main(final InputStream in, final PrintStream out, final PrintStream err) { - this(new RubyInstanceConfig(){{ - setInput(in); - setOutput(out); - setError(err); - }}); - } - - public Main() { - this(new RubyInstanceConfig()); - } - - public static void main(String[] args) { - Main main = new Main(); - - try { - int status = main.run(args); - if (status != 0) { - System.exit(status); - } - } catch (RaiseException re) { - throw re; - } catch (Throwable t) { - // print out as a nice Ruby backtrace - System.err.println(ThreadContext.createRawBacktraceStringFromThrowable(t)); - System.exit(1); - } - } - - public int run(String[] args) { - try { - config.processArguments(args); - return run(); - } catch (MainExitException mee) { - if (!mee.isAborted()) { - config.getOutput().println(mee.getMessage()); - if (mee.isUsageError()) { - printUsage(); - } - } - return mee.getStatus(); - } catch (OutOfMemoryError oome) { - // produce a nicer error since Rubyists aren't used to seeing this - System.gc(); - - String memoryMax = SafePropertyAccessor.getProperty("jruby.memory.max"); - String message = ""; - if (memoryMax != null) { - message = " of " + memoryMax; - } - System.err.println("Error: Your application used more memory than the safety cap" + message + "."); - System.err.println("Specify -J-Xmx####m to increase it (#### = cap size in MB)."); - - if (config.getVerbose()) { - System.err.println("Exception trace follows:"); - oome.printStackTrace(); - } else { - System.err.println("Specify -w for full OutOfMemoryError stack trace"); - } - return 1; - } catch (StackOverflowError soe) { - // produce a nicer error since Rubyists aren't used to seeing this - System.gc(); - - String stackMax = SafePropertyAccessor.getProperty("jruby.stack.max"); - String message = ""; - if (stackMax != null) { - message = " of " + stackMax; - } - System.err.println("Error: Your application used more stack memory than the safety cap" + message + "."); - System.err.println("Specify -J-Xss####k to increase it (#### = cap size in KB)."); - - if (config.getVerbose()) { - System.err.println("Exception trace follows:"); - soe.printStackTrace(); - } else { - System.err.println("Specify -w for full StackOverflowError stack trace"); - } - return 1; - } catch (UnsupportedClassVersionError ucve) { - System.err.println("Error: Some library (perhaps JRuby) was built with a later JVM version."); - System.err.println("Please use libraries built with the version you intend to use or an earlier one."); - - if (config.getVerbose()) { - System.err.println("Exception trace follows:"); - ucve.printStackTrace(); - } else { - System.err.println("Specify -w for full UnsupportedClassVersionError stack trace"); - } - return 1; - } catch (ThreadKill kill) { - return 0; - } - } - - public int run() { - if (config.isShowVersion()) { - showVersion(); - } - - if (config.isShowCopyright()) { - showCopyright(); - } - - if (!config.shouldRunInterpreter() ) { - if (config.shouldPrintUsage()) { - printUsage(); - } - if (config.shouldPrintProperties()) { - printProperties(); - } - return 0; - } - - InputStream in = config.getScriptSource(); - String filename = config.displayedFileName(); - Ruby runtime = Ruby.newInstance(config); - - // set thread context JRuby classloader here, for the main thread - try { - Thread.currentThread().setContextClassLoader(runtime.getJRubyClassLoader()); - } catch (SecurityException se) { - // can't set TC classloader - if (runtime.getInstanceConfig().isVerbose()) { - System.err.println("WARNING: Security restrictions disallowed setting context classloader for main thread."); - } - } - - if (in == null) { - // no script to run, return success below - } else if (config.isShouldCheckSyntax()) { - runtime.parseFromMain(in, filename); - config.getOutput().println("Syntax OK"); - } else { - long now = -1; - - try { - if (config.isBenchmarking()) { - now = System.currentTimeMillis(); - } - - if (config.isSamplingEnabled()) { - SimpleSampler.startSampleThread(); - } - - try { - runtime.runFromMain(in, filename); - } finally { - runtime.tearDown(); - - if (config.isBenchmarking()) { - config.getOutput().println("Runtime: " + (System.currentTimeMillis() - now) + " ms"); - } - - if (config.isSamplingEnabled()) { - org.jruby.util.SimpleSampler.report(); - } - } - } catch (RaiseException rj) { - RubyException raisedException = rj.getException(); - if (runtime.getSystemExit().isInstance(raisedException)) { - IRubyObject status = raisedException.callMethod(runtime.getCurrentContext(), "status"); - - if (status != null && !status.isNil()) { - return RubyNumeric.fix2int(status); - } - } else { - runtime.printError(raisedException); - return 1; - } - } - } - return 0; - } - - private void showVersion() { - config.getOutput().print(config.getVersionString()); - } - - private void showCopyright() { - config.getOutput().print(config.getCopyrightString()); - } - - public void printUsage() { - if (!hasPrintedUsage) { - config.getOutput().print(config.getBasicUsageHelp()); - hasPrintedUsage = true; - } - } - - public void printProperties() { - config.getOutput().print(config.getPropertyHelp()); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.lang.ref.SoftReference; - -import org.jruby.runtime.builtin.IRubyObject; - -public final class MetaClass extends RubyClass { - - private SoftReference<IRubyObject> attached = new SoftReference<IRubyObject>(null); - - /** NEWOBJ (in RubyObject#getSingletonClassClone()) - * - */ - public MetaClass(Ruby runtime) { - super(runtime, null, false); - } - - /** rb_class_boot (for MetaClasses) (in makeMetaClass(RubyClass)) - * - */ - public MetaClass(Ruby runtime, RubyClass superClass) { - super(runtime, superClass, false); - index = superClass.index; // use same ClassIndex as metaclass, since we're technically still of that type - } - - public boolean isSingleton() { - return true; - } - - /** - * If an object uses an anonymous class 'class << obj', then this grabs the original - * metaclass and not the one that get injected as a result of 'class << obj'. - */ - public RubyClass getRealClass() { - return superClass.getRealClass(); - } - - public final IRubyObject allocate(){ - throw getRuntime().newTypeError("can't create instance of virtual class"); - } - - public IRubyObject getAttached() { - return attached.get(); - } - - public void setAttached(IRubyObject attached) { - this.attached = new SoftReference<IRubyObject>(attached); - } - -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2005 David Corbin <dcorbin@users.sourceforge.net> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.PrintStream; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.javasupport.Java; -import org.jruby.javasupport.JavaObject; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.builtin.IRubyObject; - -@JRubyClass(name = "NativeException", parent = "RuntimeError") -public class NativeException extends RubyException { - - private final Throwable cause; - public static final String CLASS_NAME = "NativeException"; - private final Ruby runtime; - - public NativeException(Ruby runtime, RubyClass rubyClass, Throwable cause) { - super(runtime, rubyClass, cause.getClass().getName() + ": " + cause.getMessage()); - this.runtime = runtime; - this.cause = cause; - } - - public static RubyClass createClass(Ruby runtime, RubyClass baseClass) { - // FIXME: If NativeException is expected to be used from Ruby code, it should provide - // a real allocator to be used. Otherwise Class.new will fail, as will marshalling. JRUBY-415 - RubyClass exceptionClass = runtime.defineClass(CLASS_NAME, baseClass, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - - exceptionClass.defineAnnotatedMethods(NativeException.class); - - return exceptionClass; - } - - @JRubyMethod(frame = true) - public IRubyObject cause(Block unusedBlock) { - return Java.wrap(getRuntime(), JavaObject.wrap(getRuntime(), cause)); - } - - public IRubyObject backtrace() { - IRubyObject rubyTrace = super.backtrace(); - if (rubyTrace.isNil()) { - return rubyTrace; - } - RubyArray array = (RubyArray) rubyTrace.dup(); - StackTraceElement[] stackTrace = cause.getStackTrace(); - for (int i = stackTrace.length - 1; i >= 0; i--) { - StackTraceElement element = stackTrace[i]; - String className = element.getClassName(); - String line = null; - if (element.getFileName() == null) { - line = className + ":" + element.getLineNumber() + ":in `" + element.getMethodName() + "'"; - } else { - int index = className.lastIndexOf("."); - String packageName = null; - if (index == -1) { - packageName = ""; - } else { - packageName = className.substring(0, index) + "/"; - } - line = packageName.replace(".", "/") + element.getFileName() + ":" + element.getLineNumber() + ":in `" + element.getMethodName() + "'"; - } - RubyString string = runtime.newString(line); - array.unshift(string); - } - return array; - } - - public void printBacktrace(PrintStream errorStream) { - super.printBacktrace(errorStream); - errorStream.println("Complete Java stackTrace"); - cause.printStackTrace(errorStream); - } - - public Throwable getCause() { - return cause; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -/** - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -public interface Profile { - Profile ALL = new Profile() { - public boolean allowBuiltin(String name) { return true; } - public boolean allowClass(String name) { return true; } - public boolean allowModule(String name) { return true; } - public boolean allowLoad(String name) { return true; } - public boolean allowRequire(String name) { return true; } - }; - Profile DEBUG_ALLOW = new Profile() { - public boolean allowBuiltin(String name) { System.err.println("allowBuiltin("+name+")"); return true; } - public boolean allowClass(String name) { System.err.println("allowClass("+name+")"); return true; } - public boolean allowModule(String name) { System.err.println("allowModule("+name+")"); return true; } - public boolean allowLoad(String name) { System.err.println("allowLoad("+name+")"); return true; } - public boolean allowRequire(String name) { System.err.println("allowRequire("+name+")"); return true; } - }; - Profile NO_FILE_CLASS = new Profile() { - public boolean allowBuiltin(String name) { return true; } - public boolean allowClass(String name) { return !name.equals("File"); } - public boolean allowModule(String name) { return true; } - public boolean allowLoad(String name) { return true; } - public boolean allowRequire(String name) { return true; } - }; - Profile ANY = ALL; - Profile DEFAULT = ALL; - - boolean allowBuiltin(String name); - boolean allowClass(String name); - boolean allowModule(String name); - boolean allowLoad(String name); - boolean allowRequire(String name); -}// Profile -/* - **** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2006 Michael Studman <codehaus@michaelstudman.com> - * Copyright (C) 2006 Ola Bini <ola@ologix.com> - * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.ByteArrayInputStream; -import java.io.File; -import java.io.FileDescriptor; -import java.io.IOException; -import java.io.InputStream; -import java.io.PrintStream; -import java.io.UnsupportedEncodingException; -import java.lang.ref.WeakReference; -import java.lang.reflect.Field; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.Hashtable; -import java.util.IdentityHashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Random; -import java.util.Set; -import java.util.Stack; -import java.util.Vector; -import java.util.WeakHashMap; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.SynchronousQueue; -import java.util.concurrent.ThreadFactory; -import java.util.concurrent.ThreadPoolExecutor; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicInteger; - -import org.joda.time.DateTimeZone; -import org.jruby.ast.Node; -import org.jruby.ast.executable.RubiniusRunner; -import org.jruby.ast.executable.Script; -import org.jruby.ast.executable.YARVCompiledRunner; -import org.jruby.common.RubyWarnings; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.compiler.ASTCompiler; -import org.jruby.compiler.ASTInspector; -import org.jruby.compiler.JITCompiler; -import org.jruby.compiler.NotCompilableException; -import org.jruby.compiler.impl.StandardASMCompiler; -import org.jruby.compiler.yarv.StandardYARVCompiler; -import org.jruby.exceptions.JumpException; -import org.jruby.exceptions.RaiseException; -import org.jruby.ext.JRubyPOSIXHandler; -import org.jruby.ext.LateLoadingLibrary; -import org.jruby.ext.posix.POSIX; -import org.jruby.ext.posix.POSIXFactory; -import org.jruby.internal.runtime.GlobalVariables; -import org.jruby.internal.runtime.ThreadService; -import org.jruby.internal.runtime.ValueAccessor; -import org.jruby.javasupport.JavaSupport; -import org.jruby.management.BeanManager; -import org.jruby.management.ClassCache; -import org.jruby.management.Config; -import org.jruby.parser.Parser; -import org.jruby.parser.ParserConfiguration; -import org.jruby.runtime.Binding; -import org.jruby.runtime.Block; -import org.jruby.runtime.CacheMap; -import org.jruby.runtime.CallSite; -import org.jruby.runtime.CallbackFactory; -import org.jruby.runtime.DynamicScope; -import org.jruby.runtime.EventHook; -import org.jruby.runtime.GlobalVariable; -import org.jruby.runtime.IAccessor; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ObjectSpace; -import org.jruby.runtime.RubyEvent; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.load.Library; -import org.jruby.runtime.load.LoadService; -import org.jruby.util.BuiltinScript; -import org.jruby.util.ByteList; -import org.jruby.util.IOInputStream; -import org.jruby.util.IOOutputStream; -import org.jruby.util.JRubyClassLoader; -import org.jruby.util.JavaNameMangler; -import org.jruby.util.KCode; -import org.jruby.util.SafePropertyAccessor; -import org.jruby.util.collections.WeakHashSet; -import org.jruby.util.io.ChannelDescriptor; - -/** - * The Ruby object represents the top-level of a JRuby "instance" in a given VM. - * JRuby supports spawning multiple instances in the same JVM. Generally, objects - * created under these instances are tied to a given runtime, for such details - * as identity and type, because multiple Ruby instances means there are - * multiple instances of each class. This means that in multi-runtime mode - * (or really, multi-VM mode, where each JRuby instance is a ruby "VM"), objects - * generally can't be transported across runtimes without marshaling. - * - * This class roots everything that makes the JRuby runtime function, and - * provides a number of utility methods for constructing global types and - * accessing global runtime structures. - */ -public final class Ruby { - /** - * Returns a new instance of the JRuby runtime configured with defaults. - * - * @return the JRuby runtime - * @see org.jruby.RubyInstanceConfig - */ - public static Ruby newInstance() { - return newInstance(new RubyInstanceConfig()); - } - - /** - * Returns a new instance of the JRuby runtime configured as specified. - * - * @param config The instance configuration - * @return The JRuby runtime - * @see org.jruby.RubyInstanceConfig - */ - public static Ruby newInstance(RubyInstanceConfig config) { - Ruby ruby = new Ruby(config); - ruby.init(); - return ruby; - } - - /** - * Returns a new instance of the JRuby runtime configured with the given - * input, output and error streams and otherwise default configuration - * (except where specified system properties alter defaults). - * - * @param in the custom input stream - * @param out the custom output stream - * @param err the custom error stream - * @return the JRuby runtime - * @see org.jruby.RubyInstanceConfig - */ - public static Ruby newInstance(InputStream in, PrintStream out, PrintStream err) { - RubyInstanceConfig config = new RubyInstanceConfig(); - config.setInput(in); - config.setOutput(out); - config.setError(err); - return newInstance(config); - } - - /** - * Create and initialize a new JRuby runtime. The properties of the - * specified RubyInstanceConfig will be used to determine various JRuby - * runtime characteristics. - * - * @param config The configuration to use for the new instance - * @see org.jruby.RubyInstanceConfig - */ - private Ruby(RubyInstanceConfig config) { - this.config = config; - this.threadService = new ThreadService(this); - if(config.isSamplingEnabled()) { - org.jruby.util.SimpleSampler.registerThreadContext(threadService.getCurrentContext()); - } - - this.in = config.getInput(); - this.out = config.getOutput(); - this.err = config.getError(); - this.objectSpaceEnabled = config.isObjectSpaceEnabled(); - this.profile = config.getProfile(); - this.currentDirectory = config.getCurrentDirectory(); - this.kcode = config.getKCode(); - this.beanManager = new BeanManager(this, config.isManagementEnabled()); - this.jitCompiler = new JITCompiler(this); - - this.beanManager.register(new Config(this)); - this.beanManager.register(new ClassCache(this)); - - this.cacheMap = new CacheMap(this); - } - - /** - * Evaluates a script under the current scope (perhaps the top-level - * scope) and returns the result (generally the last value calculated). - * This version goes straight into the interpreter, bypassing compilation - * and runtime preparation typical to normal script runs. - * - * @param script The scriptlet to run - * @returns The result of the eval - */ - public IRubyObject evalScriptlet(String script) { - ThreadContext context = getCurrentContext(); - Node node = parseEval(script, "<script>", context.getCurrentScope(), 0); - - try { - return node.interpret(this, context, context.getFrameSelf(), Block.NULL_BLOCK); - } catch (JumpException.ReturnJump rj) { - throw newLocalJumpError("return", (IRubyObject)rj.getValue(), "unexpected return"); - } catch (JumpException.BreakJump bj) { - throw newLocalJumpError("break", (IRubyObject)bj.getValue(), "unexpected break"); - } catch (JumpException.RedoJump rj) { - throw newLocalJumpError("redo", (IRubyObject)rj.getValue(), "unexpected redo"); - } - } - - /** - * Parse and execute the specified script - * This differs from the other methods in that it accepts a string-based script and - * parses and runs it as though it were loaded at a command-line. This is the preferred - * way to start up a new script when calling directly into the Ruby object (which is - * generally *dis*couraged. - * - * @param script The contents of the script to run as a normal, root script - * @return The last value of the script - */ - public IRubyObject executeScript(String script, String filename) { - byte[] bytes; - - try { - bytes = script.getBytes(KCode.NONE.getKCode()); - } catch (UnsupportedEncodingException e) { - bytes = script.getBytes(); - } - - Node node = parseInline(new ByteArrayInputStream(bytes), filename, null); - ThreadContext context = getCurrentContext(); - - String oldFile = context.getFile(); - int oldLine = context.getLine(); - try { - context.setFile(node.getPosition().getFile()); - context.setLine(node.getPosition().getStartLine()); - return runNormally(node, false); - } finally { - context.setFile(oldFile); - context.setLine(oldLine); - } - } - - /** - * Run the script contained in the specified input stream, using the - * specified filename as the name of the script being executed. The stream - * will be read fully before being parsed and executed. The given filename - * will be used for the ruby $PROGRAM_NAME and $0 global variables in this - * runtime. - * - * This method is intended to be called once per runtime, generally from - * Main or from main-like top-level entry points. - * - * As part of executing the script loaded from the input stream, various - * RubyInstanceConfig properties will be used to determine whether to - * compile the script before execution or run with various wrappers (for - * looping, printing, and so on, see jruby -help). - * - * @param inputStream The InputStream from which to read the script contents - * @param filename The filename to use when parsing, and for $PROGRAM_NAME - * and $0 ruby global variables. - */ - public void runFromMain(InputStream inputStream, String filename) { - IAccessor d = new ValueAccessor(newString(filename)); - getGlobalVariables().define("$PROGRAM_NAME", d); - getGlobalVariables().define("$0", d); - - for (Iterator i = config.getOptionGlobals().entrySet().iterator(); i.hasNext();) { - Map.Entry entry = (Map.Entry) i.next(); - Object value = entry.getValue(); - IRubyObject varvalue; - if (value != null) { - varvalue = newString(value.toString()); - } else { - varvalue = getTrue(); - } - getGlobalVariables().set("$" + entry.getKey().toString(), varvalue); - } - - - if(config.isYARVEnabled()) { - if (config.isShowBytecode()) System.err.print("error: bytecode printing only works with JVM bytecode"); - new YARVCompiledRunner(this, inputStream, filename).run(); - } else if(config.isRubiniusEnabled()) { - if (config.isShowBytecode()) System.err.print("error: bytecode printing only works with JVM bytecode"); - new RubiniusRunner(this, inputStream, filename).run(); - } else { - Node scriptNode = parseFromMain(inputStream, filename); - ThreadContext context = getCurrentContext(); - - String oldFile = context.getFile(); - int oldLine = context.getLine(); - try { - context.setFile(scriptNode.getPosition().getFile()); - context.setLine(scriptNode.getPosition().getStartLine()); - - if (config.isAssumePrinting() || config.isAssumeLoop()) { - runWithGetsLoop(scriptNode, config.isAssumePrinting(), config.isProcessLineEnds(), - config.isSplit(), config.isYARVCompileEnabled()); - } else { - runNormally(scriptNode, config.isYARVCompileEnabled()); - } - } finally { - context.setFile(oldFile); - context.setLine(oldLine); - } - } - } - - /** - * Parse the script contained in the given input stream, using the given - * filename as the name of the script, and return the root Node. This - * is used to verify that the script syntax is valid, for jruby -c. The - * current scope (generally the top-level scope) is used as the parent - * scope for parsing. - * - * @param inputStream The input stream from which to read the script - * @param filename The filename to use for parsing - * @returns The root node of the parsed script - */ - public Node parseFromMain(InputStream inputStream, String filename) { - if (config.isInlineScript()) { - return parseInline(inputStream, filename, getCurrentContext().getCurrentScope()); - } else { - return parseFile(inputStream, filename, getCurrentContext().getCurrentScope()); - } - } - - /** - * Run the given script with a "while gets; end" loop wrapped around it. - * This is primarily used for the -n command-line flag, to allow writing - * a short script that processes input lines using the specified code. - * - * @param scriptNode The root node of the script to execute - * @param printing Whether $_ should be printed after each loop (as in the - * -p command-line flag) - * @param processLineEnds Whether line endings should be processed by - * setting $\ to $/ and <code>chop!</code>ing every line read - * @param split Whether to split each line read using <code>String#split</code> - * @param yarvCompile Whether to compile the target script to YARV (Ruby 1.9) - * bytecode before executing. - * @return The result of executing the specified script - */ - public IRubyObject runWithGetsLoop(Node scriptNode, boolean printing, boolean processLineEnds, boolean split, boolean yarvCompile) { - ThreadContext context = getCurrentContext(); - - Script script = null; - YARVCompiledRunner runner = null; - boolean compile = getInstanceConfig().getCompileMode().shouldPrecompileCLI(); - if (compile || !yarvCompile) { - script = tryCompile(scriptNode); - if (compile && script == null) { - // terminate; tryCompile will have printed out an error and we're done - return getNil(); - } - } else if (yarvCompile) { - runner = tryCompileYarv(scriptNode); - } - - if (processLineEnds) { - getGlobalVariables().set("$\\", getGlobalVariables().get("$/")); - } - - while (RubyKernel.gets(context, getTopSelf(), IRubyObject.NULL_ARRAY).isTrue()) { - loop: while (true) { // Used for the 'redo' command - try { - if (processLineEnds) { - getGlobalVariables().get("$_").callMethod(context, "chop!"); - } - - if (split) { - getGlobalVariables().set("$F", getGlobalVariables().get("$_").callMethod(context, "split")); - } - - if (script != null) { - runScript(script); - } else if (runner != null) { - runYarv(runner); - } else { - runInterpreter(scriptNode); - } - - if (printing) RubyKernel.print(context, getKernel(), new IRubyObject[] {getGlobalVariables().get("$_")}); - break loop; - } catch (JumpException.RedoJump rj) { - // do nothing, this iteration restarts - } catch (JumpException.NextJump nj) { - // recheck condition - break loop; - } catch (JumpException.BreakJump bj) { - // end loop - return (IRubyObject) bj.getValue(); - } - } - } - - return getNil(); - } - - /** - * Run the specified script without any of the loop-processing wrapper - * code. - * - * @param scriptNode The root node of the script to be executed - * @param yarvCompile Whether to compile the script to YARV (Ruby 1.9) - * bytecode before execution - * @return The result of executing the script - */ - public IRubyObject runNormally(Node scriptNode, boolean yarvCompile) { - Script script = null; - YARVCompiledRunner runner = null; - boolean compile = getInstanceConfig().getCompileMode().shouldPrecompileCLI(); - boolean forceCompile = getInstanceConfig().getCompileMode().shouldPrecompileAll(); - if (yarvCompile) { - runner = tryCompileYarv(scriptNode); - } else if (compile) { - script = tryCompile(scriptNode); - if (forceCompile && script == null) { - System.err.println("Error, could not compile; pass -J-Djruby.jit.logging.verbose=true for more details"); - return getNil(); - } - } - - if (script != null) { - if (config.isShowBytecode()) { - return nilObject; - } else { - return runScript(script); - } - } else if (runner != null) { - return runYarv(runner); - } else { - if (config.isShowBytecode()) System.err.print("error: bytecode printing only works with JVM bytecode"); - return runInterpreter(scriptNode); - } - } - - private Script tryCompile(Node node) { - return tryCompile(node, new JRubyClassLoader(getJRubyClassLoader())); - } - - private Script tryCompile(Node node, JRubyClassLoader classLoader) { - Script script = null; - try { - String filename = node.getPosition().getFile(); - String classname = JavaNameMangler.mangledFilenameForStartupClasspath(filename); - - ASTInspector inspector = new ASTInspector(); - inspector.inspect(node); - - StandardASMCompiler asmCompiler = new StandardASMCompiler(classname, filename); - ASTCompiler compiler = new ASTCompiler(); - if (config.isShowBytecode()) { - compiler.compileRoot(node, asmCompiler, inspector, false, false); - asmCompiler.dumpClass(System.out); - } else { - compiler.compileRoot(node, asmCompiler, inspector, true, false); - } - script = (Script)asmCompiler.loadClass(classLoader).newInstance(); - - if (config.isJitLogging()) { - System.err.println("compiled: " + node.getPosition().getFile()); - } - } catch (NotCompilableException nce) { - if (config.isJitLoggingVerbose()) { - System.err.println("Error -- Not compileable: " + nce.getMessage()); - nce.printStackTrace(); - } - } catch (ClassNotFoundException e) { - if (config.isJitLoggingVerbose()) { - System.err.println("Error -- Not compileable: " + e.getMessage()); - e.printStackTrace(); - } - } catch (InstantiationException e) { - if (config.isJitLoggingVerbose()) { - System.err.println("Error -- Not compileable: " + e.getMessage()); - e.printStackTrace(); - } - } catch (IllegalAccessException e) { - if (config.isJitLoggingVerbose()) { - System.err.println("Error -- Not compileable: " + e.getMessage()); - e.printStackTrace(); - } - } catch (Throwable t) { - if (config.isJitLoggingVerbose()) { - System.err.println("could not compile: " + node.getPosition().getFile() + " because of: \"" + t.getMessage() + "\""); - t.printStackTrace(); - } - } - - return script; - } - - private YARVCompiledRunner tryCompileYarv(Node node) { - try { - StandardYARVCompiler compiler = new StandardYARVCompiler(this); - ASTCompiler.getYARVCompiler().compile(node, compiler); - org.jruby.lexer.yacc.ISourcePosition p = node.getPosition(); - if(p == null && node instanceof org.jruby.ast.RootNode) { - p = ((org.jruby.ast.RootNode)node).getBodyNode().getPosition(); - } - return new YARVCompiledRunner(this,compiler.getInstructionSequence("<main>",p.getFile(),"toplevel")); - } catch (NotCompilableException nce) { - System.err.println("Error -- Not compileable: " + nce.getMessage()); - return null; - } catch (JumpException.ReturnJump rj) { - return null; - } - } - - private IRubyObject runScript(Script script) { - ThreadContext context = getCurrentContext(); - - try { - return script.load(context, context.getFrameSelf(), IRubyObject.NULL_ARRAY, Block.NULL_BLOCK); - } catch (JumpException.ReturnJump rj) { - return (IRubyObject) rj.getValue(); - } - } - - private IRubyObject runYarv(YARVCompiledRunner runner) { - try { - return runner.run(); - } catch (JumpException.ReturnJump rj) { - return (IRubyObject) rj.getValue(); - } - } - - private IRubyObject runInterpreter(Node scriptNode) { - ThreadContext context = getCurrentContext(); - - assert scriptNode != null : "scriptNode is not null"; - - try { - return scriptNode.interpret(this, context, getTopSelf(), Block.NULL_BLOCK); - } catch (JumpException.ReturnJump rj) { - return (IRubyObject) rj.getValue(); - } - } - - public BeanManager getBeanManager() { - return beanManager; - } - - public JITCompiler getJITCompiler() { - return jitCompiler; - } - - /** - * @deprecated use #newInstance() - */ - public static Ruby getDefaultInstance() { - return newInstance(); - } - - @Deprecated - public static Ruby getCurrentInstance() { - return null; - } - - @Deprecated - public static void setCurrentInstance(Ruby runtime) { - } - - public int allocSymbolId() { - return symbolLastId.incrementAndGet(); - } - public int allocModuleId() { - return moduleLastId.incrementAndGet(); - } - - /** - * Retrieve the module with the given name from the Object namespace. - * - * @param name The name of the module - * @return The module or null if not found - */ - public RubyModule getModule(String name) { - return (RubyModule) objectClass.getConstantAt(name); - } - - /** - * Retrieve the module with the given name from the Object namespace. The - * module name must be an interned string, but this method will be faster - * than the non-interned version. - * - * @param internedName The name of the module; <em>must</em> be an interned String - * @return The module or null if not found - */ - public RubyModule fastGetModule(String internedName) { - return (RubyModule) objectClass.fastGetConstantAt(internedName); - } - - /** - * Retrieve the class with the given name from the Object namespace. - * - * @param name The name of the class - * @return The class - */ - public RubyClass getClass(String name) { - return objectClass.getClass(name); - } - - /** - * Retrieve the class with the given name from the Object namespace. The - * module name must be an interned string, but this method will be faster - * than the non-interned version. - * - * @param internedName the name of the class; <em>must</em> be an interned String! - * @return - */ - public RubyClass fastGetClass(String internedName) { - return objectClass.fastGetClass(internedName); - } - - /** - * Define a new class under the Object namespace. Roughly equivalent to - * rb_define_class in MRI. - * - * @param name The name for the new class - * @param superClass The super class for the new class - * @param allocator An ObjectAllocator instance that can construct - * instances of the new class. - * @return The new class - */ - public RubyClass defineClass(String name, RubyClass superClass, ObjectAllocator allocator) { - return defineClassUnder(name, superClass, allocator, objectClass); - } - - /** - * A variation of defineClass that allows passing in an array of subplementary - * call sites for improving dynamic invocation performance. - * - * @param name The name for the new class - * @param superClass The super class for the new class - * @param allocator An ObjectAllocator instance that can construct - * instances of the new class. - * @return The new class - */ - public RubyClass defineClass(String name, RubyClass superClass, ObjectAllocator allocator, CallSite[] callSites) { - return defineClassUnder(name, superClass, allocator, objectClass, callSites); - } - - /** - * Define a new class with the given name under the given module or class - * namespace. Roughly equivalent to rb_define_class_under in MRI. - * - * If the name specified is already bound, its value will be returned if: - * * It is a class - * * No new superclass is being defined - * - * @param name The name for the new class - * @param superClass The super class for the new class - * @param allocator An ObjectAllocator instance that can construct - * instances of the new class. - * @param parent The namespace under which to define the new class - * @return The new class - */ - public RubyClass defineClassUnder(String name, RubyClass superClass, ObjectAllocator allocator, RubyModule parent) { - return defineClassUnder(name, superClass, allocator, parent, null); - } - - /** - * A variation of defineClassUnder that allows passing in an array of - * supplementary call sites to improve dynamic invocation. - * - * @param name The name for the new class - * @param superClass The super class for the new class - * @param allocator An ObjectAllocator instance that can construct - * instances of the new class. - * @param parent The namespace under which to define the new class - * @param callSites The array of call sites to add - * @return The new class - */ - public RubyClass defineClassUnder(String name, RubyClass superClass, ObjectAllocator allocator, RubyModule parent, CallSite[] callSites) { - IRubyObject classObj = parent.getConstantAt(name); - - if (classObj != null) { - if (!(classObj instanceof RubyClass)) throw newTypeError(name + " is not a class"); - RubyClass klazz = (RubyClass)classObj; - if (klazz.getSuperClass().getRealClass() != superClass) { - throw newNameError(name + " is already defined", name); - } - // If we define a class in Ruby, but later want to allow it to be defined in Java, - // the allocator needs to be updated - if (klazz.getAllocator() != allocator) { - klazz.setAllocator(allocator); - } - return klazz; - } - - boolean parentIsObject = parent == objectClass; - - if (superClass == null) { - String className = parentIsObject ? name : parent.getName() + "::" + name; - warnings.warn(ID.NO_SUPER_CLASS, "no super class for `" + className + "', Object assumed", className); - - superClass = objectClass; - } - - return RubyClass.newClass(this, superClass, name, allocator, parent, !parentIsObject, callSites); - } - - /** - * Define a new module under the Object namespace. Roughly equivalent to - * rb_define_module in MRI. - * - * @param name The name of the new module - * @returns The new module - */ - public RubyModule defineModule(String name) { - return defineModuleUnder(name, objectClass); - } - - /** - * Define a new module with the given name under the given module or - * class namespace. Roughly equivalent to rb_define_module_under in MRI. - * - * @param name The name of the new module - * @param parent The class or module namespace under which to define the - * module - * @returns The new module - */ - public RubyModule defineModuleUnder(String name, RubyModule parent) { - IRubyObject moduleObj = parent.getConstantAt(name); - - boolean parentIsObject = parent == objectClass; - - if (moduleObj != null ) { - if (moduleObj.isModule()) return (RubyModule)moduleObj; - - if (parentIsObject) { - throw newTypeError(moduleObj.getMetaClass().getName() + " is not a module"); - } else { - throw newTypeError(parent.getName() + "::" + moduleObj.getMetaClass().getName() + " is not a module"); - } - } - - return RubyModule.newModule(this, name, parent, !parentIsObject); - } - - /** - * From Object, retrieve the named module. If it doesn't exist a - * new module is created. - * - * @param name The name of the module - * @returns The existing or new module - */ - public RubyModule getOrCreateModule(String name) { - IRubyObject module = objectClass.getConstantAt(name); - if (module == null) { - module = defineModule(name); - } else if (getSafeLevel() >= 4) { - throw newSecurityError("Extending module prohibited."); - } else if (!module.isModule()) { - throw newTypeError(name + " is not a Module"); - } - - return (RubyModule) module; - } - - - /** - * Retrieve the current safe level. - * - * @see org.jruby.Ruby#setSaveLevel - */ - public int getSafeLevel() { - return this.safeLevel; - } - - - /** - * Set the current safe level: - * - * 0 - strings from streams/environment/ARGV are tainted (default) - * 1 - no dangerous operation by tainted value - * 2 - process/file operations prohibited - * 3 - all generated objects are tainted - * 4 - no global (non-tainted) variable modification/no direct output - * - * The safe level is set using $SAFE in Ruby code. It is not particularly - * well supported in JRuby. - */ - public void setSafeLevel(int safeLevel) { - this.safeLevel = safeLevel; - } - - public KCode getKCode() { - return kcode; - } - - public void setKCode(KCode kcode) { - this.kcode = kcode; - } - - public void secure(int level) { - if (level <= safeLevel) { - throw newSecurityError("Insecure operation '" + getCurrentContext().getFrameName() + "' at level " + safeLevel); - } - } - - // FIXME moved this here to get what's obviously a utility method out of IRubyObject. - // perhaps security methods should find their own centralized home at some point. - public void checkSafeString(IRubyObject object) { - if (getSafeLevel() > 0 && object.isTaint()) { - ThreadContext tc = getCurrentContext(); - if (tc.getFrameName() != null) { - throw newSecurityError("Insecure operation - " + tc.getFrameName()); - } - throw newSecurityError("Insecure operation: -r"); - } - secure(4); - if (!(object instanceof RubyString)) { - throw newTypeError( - "wrong argument type " + object.getMetaClass().getName() + " (expected String)"); - } - } - - /** rb_define_global_const - * - */ - public void defineGlobalConstant(String name, IRubyObject value) { - objectClass.defineConstant(name, value); - } - - public boolean isClassDefined(String name) { - return getModule(name) != null; - } - - /** - * A ThreadFactory for when we're using pooled threads; we want to create - * the threads with daemon = true so they don't keep us from shutting down. - */ - public static class DaemonThreadFactory implements ThreadFactory { - public Thread newThread(Runnable runnable) { - Thread thread = new Thread(runnable); - thread.setDaemon(true); - - return thread; - } - } - - /** - * This method is called immediately after constructing the Ruby instance. - * The main thread is prepared for execution, all core classes and libraries - * are initialized, and any libraries required on the command line are - * loaded. - */ - private void init() { - // Get the main threadcontext (gets constructed for us) - ThreadContext tc = getCurrentContext(); - - safeLevel = config.getSafeLevel(); - - // Construct key services - loadService = config.createLoadService(this); - posix = POSIXFactory.getPOSIX(new JRubyPOSIXHandler(this), RubyInstanceConfig.nativeEnabled); - javaSupport = new JavaSupport(this); - - if (RubyInstanceConfig.POOLING_ENABLED) { - Executors.newCachedThreadPool(); - executor = new ThreadPoolExecutor( - RubyInstanceConfig.POOL_MIN, - RubyInstanceConfig.POOL_MAX, - RubyInstanceConfig.POOL_TTL, - TimeUnit.SECONDS, - new SynchronousQueue<Runnable>(), - new DaemonThreadFactory()); - } - - // initialize the root of the class hierarchy completely - initRoot(tc); - - // Construct the top-level execution frame and scope for the main thread - tc.prepareTopLevel(objectClass, topSelf); - - // Initialize all the core classes - bootstrap(); - - // Create global constants and variables - RubyGlobal.createGlobals(tc, this); - - // Prepare LoadService and load path - getLoadService().init(config.loadPaths()); - - // initialize builtin libraries - initBuiltins(); - - // Require in all libraries specified on command line - for (String scriptName : config.requiredLibraries()) { - RubyKernel.require(getTopSelf(), newString(scriptName), Block.NULL_BLOCK); - } - } - - private void bootstrap() { - initCore(); - initExceptions(); - } - - private void initRoot(ThreadContext context) { - // Bootstrap the top of the hierarchy - objectClass = RubyClass.createBootstrapClass(this, "Object", null, RubyObject.OBJECT_ALLOCATOR); - moduleClass = RubyClass.createBootstrapClass(this, "Module", objectClass, RubyModule.MODULE_ALLOCATOR); - classClass = RubyClass.createBootstrapClass(this, "Class", moduleClass, RubyClass.CLASS_ALLOCATOR); - - objectClass.setMetaClass(classClass); - moduleClass.setMetaClass(classClass); - classClass.setMetaClass(classClass); - - RubyClass metaClass; - metaClass = objectClass.makeMetaClass(classClass); - metaClass = moduleClass.makeMetaClass(metaClass); - metaClass = classClass.makeMetaClass(metaClass); - - RubyObject.createObjectClass(this, objectClass); - RubyModule.createModuleClass(this, moduleClass); - RubyClass.createClassClass(this, classClass); - - // set constants now that they're initialized - objectClass.setConstant("Object", objectClass); - objectClass.setConstant("Class", classClass); - objectClass.setConstant("Module", moduleClass); - - // Initialize Kernel and include into Object - RubyKernel.createKernelModule(this); - objectClass.includeModule(kernelModule); - - // Initialize the "dummy" class used as a marker - dummyClass = new RubyClass(this); - dummyClass.freeze(context); - - // Object is ready, create top self - topSelf = TopSelfFactory.createTopSelf(this); - } - - private void initCore() { - // Pre-create all the core classes potentially referenced during startup - RubyNil.createNilClass(this); - RubyBoolean.createFalseClass(this); - RubyBoolean.createTrueClass(this); - - nilObject = new RubyNil(this); - falseObject = new RubyBoolean(this, false); - trueObject = new RubyBoolean(this, true); - - RubyComparable.createComparable(this); - RubyEnumerable.createEnumerableModule(this); - RubyString.createStringClass(this); - RubySymbol.createSymbolClass(this); - - if (profile.allowClass("ThreadGroup")) { - RubyThreadGroup.createThreadGroupClass(this); - } - if (profile.allowClass("Thread")) { - RubyThread.createThreadClass(this); - } - if (profile.allowClass("Exception")) { - RubyException.createExceptionClass(this); - } - if (profile.allowModule("Precision")) { - RubyPrecision.createPrecisionModule(this); - } - if (profile.allowClass("Numeric")) { - RubyNumeric.createNumericClass(this); - } - if (profile.allowClass("Integer")) { - RubyInteger.createIntegerClass(this); - } - if (profile.allowClass("Fixnum")) { - RubyFixnum.createFixnumClass(this); - } - - if (config.getCompatVersion() == CompatVersion.RUBY1_9) { - if (profile.allowClass("Complex")) { - RubyComplex.createComplexClass(this); - } - if (profile.allowClass("Rational")) { - RubyRational.createRationalClass(this); - } - } - - if (profile.allowClass("Hash")) { - RubyHash.createHashClass(this); - } - if (profile.allowClass("Array")) { - RubyArray.createArrayClass(this); - } - if (profile.allowClass("Float")) { - RubyFloat.createFloatClass(this); - } - if (profile.allowClass("Bignum")) { - RubyBignum.createBignumClass(this); - } - ioClass = RubyIO.createIOClass(this); - - if (profile.allowClass("Struct")) { - RubyStruct.createStructClass(this); - } - if (profile.allowClass("Tms")) { - tmsStruct = RubyStruct.newInstance(structClass, new IRubyObject[]{newString("Tms"), newSymbol("utime"), newSymbol("stime"), newSymbol("cutime"), newSymbol("cstime")}, Block.NULL_BLOCK); - } - - if (profile.allowClass("Binding")) { - RubyBinding.createBindingClass(this); - } - // Math depends on all numeric types - if (profile.allowModule("Math")) { - RubyMath.createMathModule(this); - } - if (profile.allowClass("Regexp")) { - RubyRegexp.createRegexpClass(this); - } - if (profile.allowClass("Range")) { - RubyRange.createRangeClass(this); - } - if (profile.allowModule("ObjectSpace")) { - RubyObjectSpace.createObjectSpaceModule(this); - } - if (profile.allowModule("GC")) { - RubyGC.createGCModule(this); - } - if (profile.allowClass("Proc")) { - RubyProc.createProcClass(this); - } - if (profile.allowClass("Method")) { - RubyMethod.createMethodClass(this); - } - if (profile.allowClass("MatchData")) { - RubyMatchData.createMatchDataClass(this); - } - if (profile.allowModule("Marshal")) { - RubyMarshal.createMarshalModule(this); - } - if (profile.allowClass("Dir")) { - RubyDir.createDirClass(this); - } - if (profile.allowModule("FileTest")) { - RubyFileTest.createFileTestModule(this); - } - // depends on IO, FileTest - if (profile.allowClass("File")) { - RubyFile.createFileClass(this); - } - if (profile.allowClass("File::Stat")) { - RubyFileStat.createFileStatClass(this); - } - if (profile.allowModule("Process")) { - RubyProcess.createProcessModule(this); - } - if (profile.allowClass("Time")) { - RubyTime.createTimeClass(this); - } - if (profile.allowClass("UnboundMethod")) { - RubyUnboundMethod.defineUnboundMethodClass(this); - } - if (profile.allowClass("Data")) { - defineClass("Data", objectClass, objectClass.getAllocator()); - } - if (!isSecurityRestricted()) { - // Signal uses sun.misc.* classes, this is not allowed - // in the security-sensitive environments - if (profile.allowModule("Signal")) { - RubySignal.createSignal(this); - } - } - if (profile.allowClass("Continuation")) { - RubyContinuation.createContinuation(this); - } - } - - private void initExceptions() { - standardError = defineClassIfAllowed("StandardError", exceptionClass); - runtimeError = defineClassIfAllowed("RuntimeError", standardError); - ioError = defineClassIfAllowed("IOError", standardError); - scriptError = defineClassIfAllowed("ScriptError", exceptionClass); - rangeError = defineClassIfAllowed("RangeError", standardError); - signalException = defineClassIfAllowed("SignalException", exceptionClass); - - if (profile.allowClass("NameError")) { - nameError = RubyNameError.createNameErrorClass(this, standardError); - nameErrorMessage = RubyNameError.createNameErrorMessageClass(this, nameError); - } - if (profile.allowClass("NoMethodError")) { - noMethodError = RubyNoMethodError.createNoMethodErrorClass(this, nameError); - } - if (profile.allowClass("SystemExit")) { - systemExit = RubySystemExit.createSystemExitClass(this, exceptionClass); - } - if (profile.allowClass("LocalJumpError")) { - localJumpError = RubyLocalJumpError.createLocalJumpErrorClass(this, standardError); - } - if (profile.allowClass("NativeException")) { - nativeException = NativeException.createClass(this, runtimeError); - } - if (profile.allowClass("SystemCallError")) { - systemCallError = RubySystemCallError.createSystemCallErrorClass(this, standardError); - } - - fatal = defineClassIfAllowed("Fatal", exceptionClass); - interrupt = defineClassIfAllowed("Interrupt", signalException); - typeError = defineClassIfAllowed("TypeError", standardError); - argumentError = defineClassIfAllowed("ArgumentError", standardError); - indexError = defineClassIfAllowed("IndexError", standardError); - syntaxError = defineClassIfAllowed("SyntaxError", scriptError); - loadError = defineClassIfAllowed("LoadError", scriptError); - notImplementedError = defineClassIfAllowed("NotImplementedError", scriptError); - securityError = defineClassIfAllowed("SecurityError", standardError); - noMemoryError = defineClassIfAllowed("NoMemoryError", exceptionClass); - regexpError = defineClassIfAllowed("RegexpError", standardError); - eofError = defineClassIfAllowed("EOFError", ioError); - threadError = defineClassIfAllowed("ThreadError", standardError); - concurrencyError = defineClassIfAllowed("ConcurrencyError", threadError); - systemStackError = defineClassIfAllowed("SystemStackError", standardError); - zeroDivisionError = defineClassIfAllowed("ZeroDivisionError", standardError); - floatDomainError = defineClassIfAllowed("FloatDomainError", rangeError); - - initErrno(); - } - - private RubyClass defineClassIfAllowed(String name, RubyClass superClass) { - // TODO: should probably apply the null object pattern for a - // non-allowed class, rather than null - if (superClass != null && profile.allowClass(name)) { - return defineClass(name, superClass, superClass.getAllocator()); - } - return null; - } - - private Map<Integer, RubyClass> errnos = new HashMap<Integer, RubyClass>(); - - public RubyClass getErrno(int n) { - return errnos.get(n); - } - - /** - * Create module Errno's Variables. We have this method since Errno does not have it's - * own java class. - */ - private void initErrno() { - if (profile.allowModule("Errno")) { - errnoModule = defineModule("Errno"); - - Field[] fields = IErrno.class.getFields(); - - for (int i = 0; i < fields.length; i++) { - try { - createSysErr(fields[i].getInt(IErrno.class), fields[i].getName()); - } catch (IllegalAccessException e) { - throw new RuntimeException("Someone defined a non-public constant in IErrno.java", e); - } - } - } - } - - /** - * Creates a system error. - * @param i the error code (will probably use a java exception instead) - * @param name of the error to define. - **/ - private void createSysErr(int i, String name) { - if(profile.allowClass(name)) { - RubyClass errno = getErrno().defineClassUnder(name, systemCallError, systemCallError.getAllocator()); - errnos.put(i, errno); - errno.defineConstant("Errno", newFixnum(i)); - } - } - - private void initBuiltins() { - addLazyBuiltin("java.rb", "java", "org.jruby.javasupport.Java"); - addLazyBuiltin("jruby.rb", "jruby", "org.jruby.libraries.JRubyLibrary"); - - addLazyBuiltin("minijava.rb", "minijava", "org.jruby.java.MiniJava"); - - addLazyBuiltin("jruby/ext.rb", "jruby/ext", "org.jruby.RubyJRuby$ExtLibrary"); - addLazyBuiltin("jruby/type.rb", "jruby/type", "org.jruby.RubyJRuby$TypeLibrary"); - addLazyBuiltin("iconv.so", "iconv", "org.jruby.libraries.IConvLibrary"); - addLazyBuiltin("nkf.so", "nkf", "org.jruby.libraries.NKFLibrary"); - addLazyBuiltin("stringio.so", "stringio", "org.jruby.libraries.StringIOLibrary"); - addLazyBuiltin("strscan.so", "strscan", "org.jruby.libraries.StringScannerLibrary"); - addLazyBuiltin("zlib.so", "zlib", "org.jruby.libraries.ZlibLibrary"); - addLazyBuiltin("yaml_internal.rb", "yaml_internal", "org.jruby.libraries.YamlLibrary"); - addLazyBuiltin("enumerator.so", "enumerator", "org.jruby.libraries.EnumeratorLibrary"); - addLazyBuiltin("generator_internal.rb", "generator_internal", "org.jruby.ext.Generator$Service"); - addLazyBuiltin("readline.so", "readline", "org.jruby.ext.Readline$Service"); - addLazyBuiltin("thread.so", "thread", "org.jruby.libraries.ThreadLibrary"); - addLazyBuiltin("digest.so", "digest", "org.jruby.libraries.DigestLibrary"); - addLazyBuiltin("digest.rb", "digest", "org.jruby.libraries.DigestLibrary"); - addLazyBuiltin("digest/md5.so", "digest/md5", "org.jruby.libraries.DigestLibrary$MD5"); - addLazyBuiltin("digest/rmd160.so", "digest/rmd160", "org.jruby.libraries.DigestLibrary$RMD160"); - addLazyBuiltin("digest/sha1.so", "digest/sha1", "org.jruby.libraries.DigestLibrary$SHA1"); - addLazyBuiltin("digest/sha2.so", "digest/sha2", "org.jruby.libraries.DigestLibrary$SHA2"); - addLazyBuiltin("bigdecimal.so", "bigdecimal", "org.jruby.libraries.BigDecimalLibrary"); - addLazyBuiltin("io/wait.so", "io/wait", "org.jruby.libraries.IOWaitLibrary"); - addLazyBuiltin("etc.so", "etc", "org.jruby.libraries.EtcLibrary"); - addLazyBuiltin("weakref.rb", "weakref", "org.jruby.ext.WeakRef$WeakRefLibrary"); - addLazyBuiltin("socket.so", "socket", "org.jruby.ext.socket.RubySocket$Service"); - addLazyBuiltin("rbconfig.rb", "rbconfig", "org.jruby.libraries.RbConfigLibrary"); - addLazyBuiltin("jruby/serialization.rb", "serialization", "org.jruby.libraries.JRubySerializationLibrary"); - addLazyBuiltin("ffi.so", "ffi", "org.jruby.ext.ffi.Factory$Service"); - if(RubyInstanceConfig.NATIVE_NET_PROTOCOL) { - addLazyBuiltin("net/protocol.rb", "net/protocol", "org.jruby.libraries.NetProtocolBufferedIOLibrary"); - } - - if (config.getCompatVersion() == CompatVersion.RUBY1_9) { - addLazyBuiltin("fiber.so", "fiber", "org.jruby.libraries.FiberLibrary"); - } - - addBuiltinIfAllowed("openssl.so", new Library() { - public void load(Ruby runtime, boolean wrap) throws IOException { - runtime.getLoadService().require("jruby/openssl/stub"); - } - }); - - String[] builtins = {"fcntl", "yaml", "yaml/syck", "jsignal" }; - for (String library : builtins) { - addBuiltinIfAllowed(library + ".rb", new BuiltinScript(library)); - } - - getLoadService().require("builtin/core_ext/symbol"); - - RubyKernel.autoload(topSelf, newSymbol("Java"), newString("java")); - - getLoadService().require("enumerator"); - } - - private void addLazyBuiltin(String name, String shortName, String className) { - addBuiltinIfAllowed(name, new LateLoadingLibrary(shortName, className, getJRubyClassLoader())); - } - - private void addBuiltinIfAllowed(String name, Library lib) { - if(profile.allowBuiltin(name)) { - loadService.addBuiltinLibrary(name,lib); - } - } - - Object getRespondToMethod() { - return respondToMethod; - } - - void setRespondToMethod(Object rtm) { - this.respondToMethod = rtm; - } - - public Object getObjectToYamlMethod() { - return objectToYamlMethod; - } - - void setObjectToYamlMethod(Object otym) { - this.objectToYamlMethod = otym; - } - - /** - * Retrieve mappings of cached methods to where they have been cached. When a cached - * method needs to be invalidated this map can be used to remove all places it has been - * cached. - * - * @return the mappings of where cached methods have been stored - */ - public CacheMap getCacheMap() { - return cacheMap; - } - - /** Getter for property rubyTopSelf. - * @return Value of property rubyTopSelf. - */ - public IRubyObject getTopSelf() { - return topSelf; - } - - public void setCurrentDirectory(String dir) { - currentDirectory = dir; - } - - public String getCurrentDirectory() { - return currentDirectory; - } - - public RubyModule getEtc() { - return etcModule; - } - - public void setEtc(RubyModule etcModule) { - this.etcModule = etcModule; - } - - public RubyClass getObject() { - return objectClass; - } - - public RubyClass getModule() { - return moduleClass; - } - - public RubyClass getClassClass() { - return classClass; - } - - public RubyModule getKernel() { - return kernelModule; - } - void setKernel(RubyModule kernelModule) { - this.kernelModule = kernelModule; - } - - public RubyClass getDummy() { - return dummyClass; - } - - public RubyModule getComparable() { - return comparableModule; - } - void setComparable(RubyModule comparableModule) { - this.comparableModule = comparableModule; - } - - public RubyClass getNumeric() { - return numericClass; - } - void setNumeric(RubyClass numericClass) { - this.numericClass = numericClass; - } - - public RubyClass getFloat() { - return floatClass; - } - void setFloat(RubyClass floatClass) { - this.floatClass = floatClass; - } - - public RubyClass getInteger() { - return integerClass; - } - void setInteger(RubyClass integerClass) { - this.integerClass = integerClass; - } - - public RubyClass getFixnum() { - return fixnumClass; - } - void setFixnum(RubyClass fixnumClass) { - this.fixnumClass = fixnumClass; - } - - public RubyClass getComplex() { - return complexClass; - } - void setComplex(RubyClass complexClass) { - this.complexClass = complexClass; - } - - public RubyClass getRational() { - return rationalClass; - } - void setRational(RubyClass rationalClass) { - this.rationalClass = rationalClass; - } - - public RubyModule getEnumerable() { - return enumerableModule; - } - void setEnumerable(RubyModule enumerableModule) { - this.enumerableModule = enumerableModule; - } - - public RubyModule getEnumerator() { - return enumeratorClass; - } - void setEnumerator(RubyClass enumeratorClass) { - this.enumeratorClass = enumeratorClass; - } - - public RubyClass getString() { - return stringClass; - } - void setString(RubyClass stringClass) { - this.stringClass = stringClass; - } - - public RubyClass getSymbol() { - return symbolClass; - } - void setSymbol(RubyClass symbolClass) { - this.symbolClass = symbolClass; - } - - public RubyClass getArray() { - return arrayClass; - } - void setArray(RubyClass arrayClass) { - this.arrayClass = arrayClass; - } - - public RubyClass getHash() { - return hashClass; - } - void setHash(RubyClass hashClass) { - this.hashClass = hashClass; - } - - public RubyClass getRange() { - return rangeClass; - } - void setRange(RubyClass rangeClass) { - this.rangeClass = rangeClass; - } - - /** Returns the "true" instance from the instance pool. - * @return The "true" instance. - */ - public RubyBoolean getTrue() { - return trueObject; - } - - /** Returns the "false" instance from the instance pool. - * @return The "false" instance. - */ - public RubyBoolean getFalse() { - return falseObject; - } - - /** Returns the "nil" singleton instance. - * @return "nil" - */ - public IRubyObject getNil() { - return nilObject; - } - - public RubyClass getNilClass() { - return nilClass; - } - void setNilClass(RubyClass nilClass) { - this.nilClass = nilClass; - } - - public RubyClass getTrueClass() { - return trueClass; - } - void setTrueClass(RubyClass trueClass) { - this.trueClass = trueClass; - } - - public RubyClass getFalseClass() { - return falseClass; - } - void setFalseClass(RubyClass falseClass) { - this.falseClass = falseClass; - } - - public RubyClass getProc() { - return procClass; - } - void setProc(RubyClass procClass) { - this.procClass = procClass; - } - - public RubyClass getBinding() { - return bindingClass; - } - void setBinding(RubyClass bindingClass) { - this.bindingClass = bindingClass; - } - - public RubyClass getMethod() { - return methodClass; - } - void setMethod(RubyClass methodClass) { - this.methodClass = methodClass; - } - - public RubyClass getUnboundMethod() { - return unboundMethodClass; - } - void setUnboundMethod(RubyClass unboundMethodClass) { - this.unboundMethodClass = unboundMethodClass; - } - - public RubyClass getMatchData() { - return matchDataClass; - } - void setMatchData(RubyClass matchDataClass) { - this.matchDataClass = matchDataClass; - } - - public RubyClass getRegexp() { - return regexpClass; - } - void setRegexp(RubyClass regexpClass) { - this.regexpClass = regexpClass; - } - - public RubyClass getTime() { - return timeClass; - } - void setTime(RubyClass timeClass) { - this.timeClass = timeClass; - } - - public RubyModule getMath() { - return mathModule; - } - void setMath(RubyModule mathModule) { - this.mathModule = mathModule; - } - - public RubyModule getMarshal() { - return marshalModule; - } - void setMarshal(RubyModule marshalModule) { - this.marshalModule = marshalModule; - } - - public RubyClass getBignum() { - return bignumClass; - } - void setBignum(RubyClass bignumClass) { - this.bignumClass = bignumClass; - } - - public RubyClass getDir() { - return dirClass; - } - void setDir(RubyClass dirClass) { - this.dirClass = dirClass; - } - - public RubyClass getFile() { - return fileClass; - } - void setFile(RubyClass fileClass) { - this.fileClass = fileClass; - } - - public RubyClass getFileStat() { - return fileStatClass; - } - void setFileStat(RubyClass fileStatClass) { - this.fileStatClass = fileStatClass; - } - - public RubyModule getFileTest() { - return fileTestModule; - } - void setFileTest(RubyModule fileTestModule) { - this.fileTestModule = fileTestModule; - } - - public RubyClass getIO() { - return ioClass; - } - void setIO(RubyClass ioClass) { - this.ioClass = ioClass; - } - - public RubyClass getThread() { - return threadClass; - } - void setThread(RubyClass threadClass) { - this.threadClass = threadClass; - } - - public RubyClass getThreadGroup() { - return threadGroupClass; - } - void setThreadGroup(RubyClass threadGroupClass) { - this.threadGroupClass = threadGroupClass; - } - - public RubyThreadGroup getDefaultThreadGroup() { - return defaultThreadGroup; - } - void setDefaultThreadGroup(RubyThreadGroup defaultThreadGroup) { - this.defaultThreadGroup = defaultThreadGroup; - } - - public RubyClass getContinuation() { - return continuationClass; - } - void setContinuation(RubyClass continuationClass) { - this.continuationClass = continuationClass; - } - - public RubyClass getStructClass() { - return structClass; - } - void setStructClass(RubyClass structClass) { - this.structClass = structClass; - } - - public IRubyObject getTmsStruct() { - return tmsStruct; - } - void setTmsStruct(RubyClass tmsStruct) { - this.tmsStruct = tmsStruct; - } - - public IRubyObject getPasswdStruct() { - return passwdStruct; - } - void setPasswdStruct(RubyClass passwdStruct) { - this.passwdStruct = passwdStruct; - } - - public IRubyObject getGroupStruct() { - return groupStruct; - } - void setGroupStruct(RubyClass groupStruct) { - this.groupStruct = groupStruct; - } - - public RubyModule getGC() { - return gcModule; - } - void setGC(RubyModule gcModule) { - this.gcModule = gcModule; - } - - public RubyModule getObjectSpaceModule() { - return objectSpaceModule; - } - void setObjectSpaceModule(RubyModule objectSpaceModule) { - this.objectSpaceModule = objectSpaceModule; - } - - public RubyModule getProcess() { - return processModule; - } - void setProcess(RubyModule processModule) { - this.processModule = processModule; - } - - public RubyClass getProcStatus() { - return procStatusClass; - } - void setProcStatus(RubyClass procStatusClass) { - this.procStatusClass = procStatusClass; - } - - public RubyModule getProcUID() { - return procUIDModule; - } - void setProcUID(RubyModule procUIDModule) { - this.procUIDModule = procUIDModule; - } - - public RubyModule getProcGID() { - return procGIDModule; - } - void setProcGID(RubyModule procGIDModule) { - this.procGIDModule = procGIDModule; - } - - public RubyModule getProcSysModule() { - return procSysModule; - } - void setProcSys(RubyModule procSysModule) { - this.procSysModule = procSysModule; - } - - public RubyModule getPrecision() { - return precisionModule; - } - void setPrecision(RubyModule precisionModule) { - this.precisionModule = precisionModule; - } - - public RubyModule getErrno() { - return errnoModule; - } - - public RubyClass getException() { - return exceptionClass; - } - void setException(RubyClass exceptionClass) { - this.exceptionClass = exceptionClass; - } - - public RubyClass getNameError() { - return nameError; - } - - public RubyClass getNameErrorMessage() { - return nameErrorMessage; - } - - public RubyClass getNoMethodError() { - return noMethodError; - } - - public RubyClass getSignalException() { - return signalException; - } - - public RubyClass getRangeError() { - return rangeError; - } - - public RubyClass getSystemExit() { - return systemExit; - } - - public RubyClass getLocalJumpError() { - return localJumpError; - } - - public RubyClass getNativeException() { - return nativeException; - } - - public RubyClass getSystemCallError() { - return systemCallError; - } - - public RubyClass getFatal() { - return fatal; - } - - public RubyClass getInterrupt() { - return interrupt; - } - - public RubyClass getTypeError() { - return typeError; - } - - public RubyClass getArgumentError() { - return argumentError; - } - - public RubyClass getIndexError() { - return indexError; - } - - public RubyClass getSyntaxError() { - return syntaxError; - } - - public RubyClass getStandardError() { - return standardError; - } - - public RubyClass getRuntimeError() { - return runtimeError; - } - - public RubyClass getIOError() { - return ioError; - } - - public RubyClass getLoadError() { - return loadError; - } - - public RubyClass getNotImplementedError() { - return notImplementedError; - } - - public RubyClass getSecurityError() { - return securityError; - } - - public RubyClass getNoMemoryError() { - return noMemoryError; - } - - public RubyClass getRegexpError() { - return regexpError; - } - - public RubyClass getEOFError() { - return eofError; - } - - public RubyClass getThreadError() { - return threadError; - } - - public RubyClass getConcurrencyError() { - return concurrencyError; - } - - public RubyClass getSystemStackError() { - return systemStackError; - } - - public RubyClass getZeroDivisionError() { - return zeroDivisionError; - } - - public RubyClass getFloatDomainError() { - return floatDomainError; - } - - private RubyHash charsetMap; - public RubyHash getCharsetMap() { - if (charsetMap == null) charsetMap = new RubyHash(this); - return charsetMap; - } - - /** Getter for property isVerbose. - * @return Value of property isVerbose. - */ - public IRubyObject getVerbose() { - return verbose; - } - - /** Setter for property isVerbose. - * @param verbose New value of property isVerbose. - */ - public void setVerbose(IRubyObject verbose) { - this.verbose = verbose; - } - - /** Getter for property isDebug. - * @return Value of property isDebug. - */ - public IRubyObject getDebug() { - return debug; - } - - /** Setter for property isDebug. - * @param debug New value of property isDebug. - */ - public void setDebug(IRubyObject debug) { - this.debug = debug; - } - - public JavaSupport getJavaSupport() { - return javaSupport; - } - - public static ClassLoader getClassLoader() { - // we try to get the classloader that loaded JRuby, falling back on System - ClassLoader loader = Ruby.class.getClassLoader(); - if (loader == null) { - loader = ClassLoader.getSystemClassLoader(); - } - - return loader; - } - - public synchronized JRubyClassLoader getJRubyClassLoader() { - // FIXME: Get rid of laziness and handle restricted access elsewhere - if (!Ruby.isSecurityRestricted() && jrubyClassLoader == null) { - jrubyClassLoader = new JRubyClassLoader(config.getLoader()); - } - - return jrubyClassLoader; - } - - /** Defines a global variable - */ - public void defineVariable(final GlobalVariable variable) { - globalVariables.define(variable.name(), new IAccessor() { - public IRubyObject getValue() { - return variable.get(); - } - - public IRubyObject setValue(IRubyObject newValue) { - return variable.set(newValue); - } - }); - } - - /** defines a readonly global variable - * - */ - public void defineReadonlyVariable(String name, IRubyObject value) { - globalVariables.defineReadonly(name, new ValueAccessor(value)); - } - - public Node parseFile(InputStream in, String file, DynamicScope scope) { - return parser.parse(file, in, scope, new ParserConfiguration(0, false, false, true)); - } - - public Node parseInline(InputStream in, String file, DynamicScope scope) { - return parser.parse(file, in, scope, new ParserConfiguration(0, false, true)); - } - - public Node parseEval(String content, String file, DynamicScope scope, int lineNumber) { - byte[] bytes; - - try { - bytes = content.getBytes(KCode.NONE.getKCode()); - } catch (UnsupportedEncodingException e) { - bytes = content.getBytes(); - } - - return parser.parse(file, new ByteArrayInputStream(bytes), scope, - new ParserConfiguration(lineNumber, false)); - } - - public Node parse(String content, String file, DynamicScope scope, int lineNumber, - boolean extraPositionInformation) { - byte[] bytes; - - try { - bytes = content.getBytes(KCode.NONE.getKCode()); - } catch (UnsupportedEncodingException e) { - bytes = content.getBytes(); - } - - return parser.parse(file, new ByteArrayInputStream(bytes), scope, - new ParserConfiguration(lineNumber, extraPositionInformation, false)); - } - - public Node parseEval(ByteList content, String file, DynamicScope scope, int lineNumber) { - return parser.parse(file, content, scope, new ParserConfiguration(lineNumber, false)); - } - - public Node parse(ByteList content, String file, DynamicScope scope, int lineNumber, - boolean extraPositionInformation) { - return parser.parse(file, content, scope, - new ParserConfiguration(lineNumber, extraPositionInformation, false)); - } - - - public ThreadService getThreadService() { - return threadService; - } - - public ThreadContext getCurrentContext() { - return threadService.getCurrentContext(); - } - - /** - * Returns the loadService. - * @return ILoadService - */ - public LoadService getLoadService() { - return loadService; - } - - public RubyWarnings getWarnings() { - return warnings; - } - - public PrintStream getErrorStream() { - // FIXME: We can't guarantee this will always be a RubyIO...so the old code here is not safe - /*java.io.OutputStream os = ((RubyIO) getGlobalVariables().get("$stderr")).getOutStream(); - if(null != os) { - return new PrintStream(os); - } else { - return new PrintStream(new org.jruby.util.SwallowingOutputStream()); - }*/ - return new PrintStream(new IOOutputStream(getGlobalVariables().get("$stderr"))); - } - - public InputStream getInputStream() { - return new IOInputStream(getGlobalVariables().get("$stdin")); - } - - public PrintStream getOutputStream() { - return new PrintStream(new IOOutputStream(getGlobalVariables().get("$stdout"))); - } - - public RubyModule getClassFromPath(String path) { - RubyModule c = getObject(); - if (path.length() == 0 || path.charAt(0) == '#') { - throw newTypeError("can't retrieve anonymous class " + path); - } - int pbeg = 0, p = 0; - for(int l=path.length(); p<l; ) { - while(p<l && path.charAt(p) != ':') { - p++; - } - String str = path.substring(pbeg, p); - - if(p<l && path.charAt(p) == ':') { - if(p+1 < l && path.charAt(p+1) != ':') { - throw newTypeError("undefined class/module " + path.substring(pbeg,p)); - } - p += 2; - pbeg = p; - } - - IRubyObject cc = c.getConstant(str); - if(!(cc instanceof RubyModule)) { - throw newTypeError("" + path + " does not refer to class/module"); - } - c = (RubyModule)cc; - } - return c; - } - - /** Prints an error with backtrace to the error stream. - * - * MRI: eval.c - error_print() - * - */ - public void printError(RubyException excp) { - if (excp == null || excp.isNil()) { - return; - } - - ThreadContext context = getCurrentContext(); - IRubyObject backtrace = excp.callMethod(context, "backtrace"); - - PrintStream errorStream = getErrorStream(); - if (backtrace.isNil() || !(backtrace instanceof RubyArray)) { - if (context.getFile() != null) { - errorStream.print(context.getFile() + ":" + context.getLine()); - } else { - errorStream.print(context.getLine()); - } - } else if (((RubyArray) backtrace).getLength() == 0) { - printErrorPos(context, errorStream); - } else { - IRubyObject mesg = ((RubyArray) backtrace).first(); - - if (mesg.isNil()) { - printErrorPos(context, errorStream); - } else { - errorStream.print(mesg); - } - } - - RubyClass type = excp.getMetaClass(); - String info = excp.toString(); - - if (type == getRuntimeError() && (info == null || info.length() == 0)) { - errorStream.print(": unhandled exception\n"); - } else { - String path = type.getName(); - - if (info.length() == 0) { - errorStream.print(": " + path + '\n'); - } else { - if (path.startsWith("#")) { - path = null; - } - - String tail = null; - if (info.indexOf("\n") != -1) { - tail = info.substring(info.indexOf("\n") + 1); - info = info.substring(0, info.indexOf("\n")); - } - - errorStream.print(": " + info); - - if (path != null) { - errorStream.print(" (" + path + ")\n"); - } - - if (tail != null) { - errorStream.print(tail + '\n'); - } - } - } - - excp.printBacktrace(errorStream); - } - - private void printErrorPos(ThreadContext context, PrintStream errorStream) { - if (context.getFile() != null) { - if (context.getFrameName() != null) { - errorStream.print(context.getFile() + ":" + context.getLine()); - errorStream.print(":in '" + context.getFrameName() + '\''); - } else if (context.getLine() != 0) { - errorStream.print(context.getFile() + ":" + context.getLine()); - } else { - errorStream.print(context.getFile()); - } - } - } - - public void loadFile(String scriptName, InputStream in, boolean wrap) { - IRubyObject self = wrap ? TopSelfFactory.createTopSelf(this) : getTopSelf(); - ThreadContext context = getCurrentContext(); - String file = context.getFile(); - - try { - secure(4); /* should alter global state */ - - context.setFile(scriptName); - context.preNodeEval(objectClass, self, scriptName); - - parseFile(in, scriptName, null).interpret(this, context, self, Block.NULL_BLOCK); - } catch (JumpException.ReturnJump rj) { - return; - } finally { - context.postNodeEval(); - context.setFile(file); - } - } - - public void compileAndLoadFile(String filename, InputStream in, boolean wrap) { - IRubyObject self = wrap ? TopSelfFactory.createTopSelf(this) : getTopSelf(); - ThreadContext context = getCurrentContext(); - String file = context.getFile(); - - try { - secure(4); /* should alter global state */ - - context.setFile(filename); - context.preNodeEval(objectClass, self, filename); - - Node scriptNode = parseFile(in, filename, null); - - Script script = tryCompile(scriptNode, new JRubyClassLoader(jrubyClassLoader)); - if (script == null) { - System.err.println("Error, could not compile; pass -J-Djruby.jit.logging.verbose=true for more details"); - } - - runScript(script); - } catch (JumpException.ReturnJump rj) { - return; - } finally { - context.postNodeEval(); - context.setFile(file); - } - } - - public void loadScript(Script script) { - IRubyObject self = getTopSelf(); - ThreadContext context = getCurrentContext(); - - try { - secure(4); /* should alter global state */ - - context.preNodeEval(objectClass, self); - - script.load(context, self, IRubyObject.NULL_ARRAY, Block.NULL_BLOCK); - } catch (JumpException.ReturnJump rj) { - return; - } finally { - context.postNodeEval(); - } - } - - public class CallTraceFuncHook extends EventHook { - private RubyProc traceFunc; - - public void setTraceFunc(RubyProc traceFunc) { - this.traceFunc = traceFunc; - } - - public void eventHandler(ThreadContext context, String eventName, String file, int line, String name, IRubyObject type) { - if (!context.isWithinTrace()) { - if (file == null) file = "(ruby)"; - if (type == null) type = getFalse(); - - RubyBinding binding = RubyBinding.newBinding(Ruby.this); - - context.preTrace(); - try { - traceFunc.call(context, new IRubyObject[] { - newString(eventName), // event name - newString(file), // filename - newFixnum(line), // line numbers should be 1-based - name != null ? newSymbol(name) : getNil(), - binding, - type - }); - } finally { - context.postTrace(); - } - } - } - - public boolean isInterestedInEvent(RubyEvent event) { - return true; - } - }; - - private final CallTraceFuncHook callTraceFuncHook = new CallTraceFuncHook(); - - public void addEventHook(EventHook hook) { - eventHooks.add(hook); - hasEventHooks = true; - } - - public void removeEventHook(EventHook hook) { - eventHooks.remove(hook); - hasEventHooks = !eventHooks.isEmpty(); - } - - public void setTraceFunction(RubyProc traceFunction) { - removeEventHook(callTraceFuncHook); - - if (traceFunction == null) { - return; - } - - callTraceFuncHook.setTraceFunc(traceFunction); - addEventHook(callTraceFuncHook); - } - - public void callEventHooks(ThreadContext context, RubyEvent event, String file, int line, String name, IRubyObject type) { - for (EventHook eventHook : eventHooks) { - if (eventHook.isInterestedInEvent(event)) { - eventHook.event(context, event, file, line, name, type); - } - } - } - - public boolean hasEventHooks() { - return hasEventHooks; - } - - public GlobalVariables getGlobalVariables() { - return globalVariables; - } - - // For JSR 223 support: see http://scripting.java.net/ - public void setGlobalVariables(GlobalVariables globalVariables) { - this.globalVariables = globalVariables; - } - - public CallbackFactory callbackFactory(Class<?> type) { - return CallbackFactory.createFactory(this, type); - } - - /** - * Push block onto exit stack. When runtime environment exits - * these blocks will be evaluated. - * - * @return the element that was pushed onto stack - */ - public IRubyObject pushExitBlock(RubyProc proc) { - atExitBlocks.push(proc); - return proc; - } - - // use this for JRuby-internal finalizers - public void addInternalFinalizer(Finalizable finalizer) { - synchronized (internalFinalizersMutex) { - if (internalFinalizers == null) { - internalFinalizers = new WeakHashMap<Finalizable, Object>(); - } - internalFinalizers.put(finalizer, null); - } - } - - // this method is for finalizers registered via ObjectSpace - public void addFinalizer(Finalizable finalizer) { - synchronized (finalizersMutex) { - if (finalizers == null) { - finalizers = new WeakHashMap<Finalizable, Object>(); - } - finalizers.put(finalizer, null); - } - } - - public void removeInternalFinalizer(Finalizable finalizer) { - synchronized (internalFinalizersMutex) { - if (internalFinalizers != null) { - internalFinalizers.remove(finalizer); - } - } - } - - public void removeFinalizer(Finalizable finalizer) { - synchronized (finalizersMutex) { - if (finalizers != null) { - finalizers.remove(finalizer); - } - } - } - - /** - * Make sure Kernel#at_exit procs get invoked on runtime shutdown. - * This method needs to be explicitly called to work properly. - * I thought about using finalize(), but that did not work and I - * am not sure the runtime will be at a state to run procs by the - * time Ruby is going away. This method can contain any other - * things that need to be cleaned up at shutdown. - */ - public void tearDown() { - int status = 0; - - while (!atExitBlocks.empty()) { - RubyProc proc = atExitBlocks.pop(); - try { - proc.call(getCurrentContext(), IRubyObject.NULL_ARRAY); - } catch (RaiseException rj) { - RubyException raisedException = rj.getException(); - if (!getSystemExit().isInstance(raisedException)) { - status = 1; - printError(raisedException); - } else { - IRubyObject statusObj = raisedException.callMethod( - getCurrentContext(), "status"); - if (statusObj != null && !statusObj.isNil()) { - status = RubyNumeric.fix2int(statusObj); - } - } - } - } - - if (finalizers != null) { - synchronized (finalizers) { - for (Iterator<Finalizable> finalIter = new ArrayList<Finalizable>(finalizers.keySet()).iterator(); finalIter.hasNext();) { - finalIter.next().finalize(); - finalIter.remove(); - } - } - } - - synchronized (internalFinalizersMutex) { - if (internalFinalizers != null) { - for (Iterator<Finalizable> finalIter = new ArrayList<Finalizable>( - internalFinalizers.keySet()).iterator(); finalIter.hasNext();) { - finalIter.next().finalize(); - finalIter.remove(); - } - } - } - - getThreadService().disposeCurrentThread(); - - getBeanManager().unregisterCompiler(); - getBeanManager().unregisterConfig(); - getBeanManager().unregisterClassCache(); - getBeanManager().unregisterMethodCache(); - - if (status != 0) { - throw newSystemExit(status); - } - } - - // new factory methods ------------------------------------------------------------------------ - - public RubyArray newEmptyArray() { - return RubyArray.newEmptyArray(this); - } - - public RubyArray newArray() { - return RubyArray.newArray(this); - } - - public RubyArray newArrayLight() { - return RubyArray.newArrayLight(this); - } - - public RubyArray newArray(IRubyObject object) { - return RubyArray.newArray(this, object); - } - - public RubyArray newArray(IRubyObject car, IRubyObject cdr) { - return RubyArray.newArray(this, car, cdr); - } - - public RubyArray newArray(IRubyObject[] objects) { - return RubyArray.newArray(this, objects); - } - - public RubyArray newArrayNoCopy(IRubyObject[] objects) { - return RubyArray.newArrayNoCopy(this, objects); - } - - public RubyArray newArrayNoCopyLight(IRubyObject[] objects) { - return RubyArray.newArrayNoCopyLight(this, objects); - } - - public RubyArray newArray(List<IRubyObject> list) { - return RubyArray.newArray(this, list); - } - - public RubyArray newArray(int size) { - return RubyArray.newArray(this, size); - } - - public RubyBoolean newBoolean(boolean value) { - return RubyBoolean.newBoolean(this, value); - } - - public RubyFileStat newFileStat(String filename, boolean lstat) { - return RubyFileStat.newFileStat(this, filename, lstat); - } - - public RubyFileStat newFileStat(FileDescriptor descriptor) { - return RubyFileStat.newFileStat(this, descriptor); - } - - public RubyFixnum newFixnum(long value) { - return RubyFixnum.newFixnum(this, value); - } - - public RubyFixnum newFixnum(int value) { - return RubyFixnum.newFixnum(this, value); - } - - public RubyFloat newFloat(double value) { - return RubyFloat.newFloat(this, value); - } - - public RubyNumeric newNumeric() { - return RubyNumeric.newNumeric(this); - } - - public RubyProc newProc(Block.Type type, Block block) { - if (type != Block.Type.LAMBDA && block.getProcObject() != null) return block.getProcObject(); - - RubyProc proc = RubyProc.newProc(this, type); - - proc.callInit(IRubyObject.NULL_ARRAY, block); - - return proc; - } - - public RubyProc newBlockPassProc(Block.Type type, Block block) { - if (type != Block.Type.LAMBDA && block.getProcObject() != null) return block.getProcObject(); - - RubyProc proc = RubyProc.newProc(this, type); - proc.initialize(getCurrentContext(), block); - - return proc; - } - - public RubyBinding newBinding() { - return RubyBinding.newBinding(this); - } - - public RubyBinding newBinding(Binding binding) { - return RubyBinding.newBinding(this, binding); - } - - public RubyString newString() { - return RubyString.newString(this, new ByteList()); - } - - public RubyString newString(String string) { - return RubyString.newString(this, string); - } - - public RubyString newString(ByteList byteList) { - return RubyString.newString(this, byteList); - } - - @Deprecated - public RubyString newStringShared(ByteList byteList) { - return RubyString.newStringShared(this, byteList); - } - - public RubySymbol newSymbol(String name) { - return symbolTable.getSymbol(name); - } - - /** - * Faster than {@link #newSymbol(String)} if you already have an interned - * name String. Don't intern your string just to call this version - the - * overhead of interning will more than wipe out any benefit from the faster - * lookup. - * - * @param internedName the symbol name, <em>must</em> be interned! if in - * doubt, call {@link #newSymbol(String)} instead. - * @return the symbol for name - */ - public RubySymbol fastNewSymbol(String internedName) { - assert internedName == internedName.intern() : internedName + " is not interned"; - - return symbolTable.fastGetSymbol(internedName); - } - - public RubyTime newTime(long milliseconds) { - return RubyTime.newTime(this, milliseconds); - } - - public RaiseException newRuntimeError(String message) { - return newRaiseException(getRuntimeError(), message); - } - - public RaiseException newArgumentError(String message) { - return newRaiseException(getArgumentError(), message); - } - - public RaiseException newArgumentError(int got, int expected) { - return newRaiseException(getArgumentError(), "wrong # of arguments(" + got + " for " + expected + ")"); - } - - public RaiseException newErrnoEBADFError() { - return newRaiseException(getErrno().fastGetClass("EBADF"), "Bad file descriptor"); - } - - public RaiseException newErrnoENOPROTOOPTError() { - return newRaiseException(getErrno().fastGetClass("ENOPROTOOPT"), "Protocol not available"); - } - - public RaiseException newErrnoEPIPEError() { - return newRaiseException(getErrno().fastGetClass("EPIPE"), "Broken pipe"); - } - - public RaiseException newErrnoECONNREFUSEDError() { - return newRaiseException(getErrno().fastGetClass("ECONNREFUSED"), "Connection refused"); - } - - public RaiseException newErrnoECONNRESETError() { - return newRaiseException(getErrno().fastGetClass("ECONNRESET"), "Connection reset by peer"); - } - - public RaiseException newErrnoEADDRINUSEError() { - return newRaiseException(getErrno().fastGetClass("EADDRINUSE"), "Address in use"); - } - - public RaiseException newErrnoEINVALError() { - return newRaiseException(getErrno().fastGetClass("EINVAL"), "Invalid file"); - } - - public RaiseException newErrnoENOENTError() { - return newRaiseException(getErrno().fastGetClass("ENOENT"), "File not found"); - } - - public RaiseException newErrnoEACCESError(String message) { - return newRaiseException(getErrno().fastGetClass("EACCES"), message); - } - - public RaiseException newErrnoEAGAINError(String message) { - return newRaiseException(getErrno().fastGetClass("EAGAIN"), message); - } - - public RaiseException newErrnoEISDirError() { - return newRaiseException(getErrno().fastGetClass("EISDIR"), "Is a directory"); - } - - public RaiseException newErrnoESPIPEError() { - return newRaiseException(getErrno().fastGetClass("ESPIPE"), "Illegal seek"); - } - - public RaiseException newErrnoEBADFError(String message) { - return newRaiseException(getErrno().fastGetClass("EBADF"), message); - } - - public RaiseException newErrnoEINVALError(String message) { - return newRaiseException(getErrno().fastGetClass("EINVAL"), message); - } - - public RaiseException newErrnoENOTDIRError(String message) { - return newRaiseException(getErrno().fastGetClass("ENOTDIR"), message); - } - - public RaiseException newErrnoENOTSOCKError(String message) { - return newRaiseException(getErrno().fastGetClass("ENOTSOCK"), message); - } - - public RaiseException newErrnoENOENTError(String message) { - return newRaiseException(getErrno().fastGetClass("ENOENT"), message); - } - - public RaiseException newErrnoESPIPEError(String message) { - return newRaiseException(getErrno().fastGetClass("ESPIPE"), message); - } - - public RaiseException newErrnoEEXISTError(String message) { - return newRaiseException(getErrno().fastGetClass("EEXIST"), message); - } - - public RaiseException newErrnoEDOMError(String message) { - return newRaiseException(getErrno().fastGetClass("EDOM"), "Domain error - " + message); - } - - public RaiseException newErrnoECHILDError() { - return newRaiseException(getErrno().fastGetClass("ECHILD"), "No child processes"); - } - - public RaiseException newIndexError(String message) { - return newRaiseException(getIndexError(), message); - } - - public RaiseException newSecurityError(String message) { - return newRaiseException(getSecurityError(), message); - } - - public RaiseException newSystemCallError(String message) { - return newRaiseException(getSystemCallError(), message); - } - - public RaiseException newTypeError(String message) { - return newRaiseException(getTypeError(), message); - } - - public RaiseException newThreadError(String message) { - return newRaiseException(getThreadError(), message); - } - - public RaiseException newConcurrencyError(String message) { - return newRaiseException(getConcurrencyError(), message); - } - - public RaiseException newSyntaxError(String message) { - return newRaiseException(getSyntaxError(), message); - } - - public RaiseException newRegexpError(String message) { - return newRaiseException(getRegexpError(), message); - } - - public RaiseException newRangeError(String message) { - return newRaiseException(getRangeError(), message); - } - - public RaiseException newNotImplementedError(String message) { - return newRaiseException(getNotImplementedError(), message); - } - - public RaiseException newInvalidEncoding(String message) { - return newRaiseException(fastGetClass("Iconv").fastGetClass("InvalidEncoding"), message); - } - - public RaiseException newNoMethodError(String message, String name, IRubyObject args) { - return new RaiseException(new RubyNoMethodError(this, getNoMethodError(), message, name, args), true); - } - - public RaiseException newNameError(String message, String name) { - return newNameError(message, name, null); - } - - public RaiseException newNameError(String message, String name, Throwable origException) { - return newNameError(message, name, origException, true); - } - - public RaiseException newNameError(String message, String name, Throwable origException, boolean printWhenVerbose) { - if (printWhenVerbose && origException != null && this.getVerbose().isTrue()) { - origException.printStackTrace(getErrorStream()); - } - return new RaiseException(new RubyNameError( - this, getNameError(), message, name), true); - } - - public RaiseException newLocalJumpError(String reason, IRubyObject exitValue, String message) { - return new RaiseException(new RubyLocalJumpError(this, getLocalJumpError(), message, reason, exitValue), true); - } - - public RaiseException newRedoLocalJumpError() { - return new RaiseException(new RubyLocalJumpError(this, getLocalJumpError(), "unexpected redo", "redo", getNil()), true); - } - - public RaiseException newLoadError(String message) { - return newRaiseException(getLoadError(), message); - } - - public RaiseException newFrozenError(String objectType) { - // TODO: Should frozen error have its own distinct class? If not should more share? - return newRaiseException(getTypeError(), "can't modify frozen " + objectType); - } - - public RaiseException newSystemStackError(String message) { - return newRaiseException(getSystemStackError(), message); - } - - public RaiseException newSystemExit(int status) { - return new RaiseException(RubySystemExit.newInstance(this, status)); - } - - public RaiseException newIOError(String message) { - return newRaiseException(getIOError(), message); - } - - public RaiseException newStandardError(String message) { - return newRaiseException(getStandardError(), message); - } - - public RaiseException newIOErrorFromException(IOException ioe) { - // TODO: this is kinda gross - if(ioe.getMessage() != null) { - if (ioe.getMessage().equals("Broken pipe")) { - throw newErrnoEPIPEError(); - } else if (ioe.getMessage().equals("Connection reset by peer")) { - throw newErrnoECONNRESETError(); - } - return newRaiseException(getIOError(), ioe.getMessage()); - } else { - return newRaiseException(getIOError(), "IO Error"); - } - } - - public RaiseException newTypeError(IRubyObject receivedObject, RubyClass expectedType) { - return newRaiseException(getTypeError(), "wrong argument type " + - receivedObject.getMetaClass().getRealClass() + " (expected " + expectedType + ")"); - } - - public RaiseException newEOFError() { - return newRaiseException(getEOFError(), "End of file reached"); - } - - public RaiseException newEOFError(String message) { - return newRaiseException(getEOFError(), message); - } - - public RaiseException newZeroDivisionError() { - return newRaiseException(getZeroDivisionError(), "divided by 0"); - } - - public RaiseException newFloatDomainError(String message){ - return newRaiseException(getFloatDomainError(), message); - } - - /** - * @param exceptionClass - * @param message - * @return - */ - private RaiseException newRaiseException(RubyClass exceptionClass, String message) { - RaiseException re = new RaiseException(this, exceptionClass, message, true); - return re; - } - - - public RubySymbol.SymbolTable getSymbolTable() { - return symbolTable; - } - - public void setStackTraces(int stackTraces) { - this.stackTraces = stackTraces; - } - - public int getStackTraces() { - return stackTraces; - } - - public void setRandomSeed(long randomSeed) { - this.randomSeed = randomSeed; - } - - public long getRandomSeed() { - return randomSeed; - } - - public Random getRandom() { - return random; - } - - public ObjectSpace getObjectSpace() { - return objectSpace; - } - - public Map<Integer, WeakReference<ChannelDescriptor>> getDescriptors() { - return descriptors; - } - - public long incrementRandomSeedSequence() { - return randomSeedSequence++; - } - - public InputStream getIn() { - return in; - } - - public PrintStream getOut() { - return out; - } - - public PrintStream getErr() { - return err; - } - - public boolean isGlobalAbortOnExceptionEnabled() { - return globalAbortOnExceptionEnabled; - } - - public void setGlobalAbortOnExceptionEnabled(boolean enable) { - globalAbortOnExceptionEnabled = enable; - } - - public boolean isDoNotReverseLookupEnabled() { - return doNotReverseLookupEnabled; - } - - public void setDoNotReverseLookupEnabled(boolean b) { - doNotReverseLookupEnabled = b; - } - - private ThreadLocal<Map<Object, Object>> inspect = new ThreadLocal<Map<Object, Object>>(); - public void registerInspecting(Object obj) { - Map<Object, Object> val = inspect.get(); - if (val == null) inspect.set(val = new IdentityHashMap<Object, Object>()); - val.put(obj, null); - } - - public boolean isInspecting(Object obj) { - Map<Object, Object> val = inspect.get(); - return val == null ? false : val.containsKey(obj); - } - - public void unregisterInspecting(Object obj) { - Map<Object, Object> val = inspect.get(); - if (val != null ) val.remove(obj); - } - - public boolean isObjectSpaceEnabled() { - return objectSpaceEnabled; - } - - // The method is intentionally not public, since it typically should - // not be used outside of the core. - /* package-private */ void setObjectSpaceEnabled(boolean objectSpaceEnabled) { - this.objectSpaceEnabled = objectSpaceEnabled; - } - - public long getStartTime() { - return startTime; - } - - public Profile getProfile() { - return profile; - } - - public String getJRubyHome() { - return config.getJRubyHome(); - } - - public void setJRubyHome(String home) { - config.setJRubyHome(home); - } - - public RubyInstanceConfig getInstanceConfig() { - return config; - } - - /** GET_VM_STATE_VERSION */ - public long getGlobalState() { - synchronized(this) { - return globalState; - } - } - - /** INC_VM_STATE_VERSION */ - public void incGlobalState() { - synchronized(this) { - globalState = (globalState+1) & 0x8fffffff; - } - } - - public static boolean isSecurityRestricted() { - return securityRestricted; - } - - public static void setSecurityRestricted(boolean restricted) { - securityRestricted = restricted; - } - - public POSIX getPosix() { - return posix; - } - - public void setRecordSeparatorVar(GlobalVariable recordSeparatorVar) { - this.recordSeparatorVar = recordSeparatorVar; - } - - public GlobalVariable getRecordSeparatorVar() { - return recordSeparatorVar; - } - - public Set<Script> getJittedMethods() { - return jittedMethods; - } - - public ExecutorService getExecutor() { - return executor; - } - - public Map<String, DateTimeZone> getLocalTimezoneCache() { - return localTimeZoneCache; - } - - private final CacheMap cacheMap; - private final ThreadService threadService; - private Hashtable<Object, Object> runtimeInformation; - - private POSIX posix; - - private int stackTraces = 0; - - private ObjectSpace objectSpace = new ObjectSpace(); - - private final RubySymbol.SymbolTable symbolTable = new RubySymbol.SymbolTable(this); - private Map<Integer, WeakReference<ChannelDescriptor>> descriptors = new ConcurrentHashMap<Integer, WeakReference<ChannelDescriptor>>(); - private long randomSeed = 0; - private long randomSeedSequence = 0; - private Random random = new Random(); - - private List<EventHook> eventHooks = new Vector<EventHook>(); - private boolean hasEventHooks; - private boolean globalAbortOnExceptionEnabled = false; - private boolean doNotReverseLookupEnabled = false; - private volatile boolean objectSpaceEnabled; - - private final Set<Script> jittedMethods = Collections.synchronizedSet(new WeakHashSet<Script>()); - - private static ThreadLocal<Ruby> currentRuntime = new ThreadLocal<Ruby>(); - - private long globalState = 1; - - private int safeLevel = -1; - - // Default objects - private IRubyObject topSelf; - private RubyNil nilObject; - private RubyBoolean trueObject; - private RubyBoolean falseObject; - public final RubyFixnum[] fixnumCache = new RubyFixnum[256]; - - private IRubyObject verbose; - private IRubyObject debug; - - private RubyThreadGroup defaultThreadGroup; - - /** - * All the core classes we keep hard references to. These are here largely - * so that if someone redefines String or Array we won't start blowing up - * creating strings and arrays internally. They also provide much faster - * access than going through normal hash lookup on the Object class. - */ - private RubyClass - objectClass, moduleClass, classClass, nilClass, trueClass, - falseClass, numericClass, floatClass, integerClass, fixnumClass, - complexClass, rationalClass, enumeratorClass, - arrayClass, hashClass, rangeClass, stringClass, symbolClass, - procClass, bindingClass, methodClass, unboundMethodClass, - matchDataClass, regexpClass, timeClass, bignumClass, dirClass, - fileClass, fileStatClass, ioClass, threadClass, threadGroupClass, - continuationClass, structClass, tmsStruct, passwdStruct, - groupStruct, procStatusClass, exceptionClass, runtimeError, ioError, - scriptError, nameError, nameErrorMessage, noMethodError, signalException, - rangeError, dummyClass, systemExit, localJumpError, nativeException, - systemCallError, fatal, interrupt, typeError, argumentError, indexError, - syntaxError, standardError, loadError, notImplementedError, securityError, noMemoryError, - regexpError, eofError, threadError, concurrencyError, systemStackError, zeroDivisionError, floatDomainError; - - /** - * All the core modules we keep direct references to, for quick access and - * to ensure they remain available. - */ - private RubyModule - kernelModule, comparableModule, enumerableModule, mathModule, - marshalModule, etcModule, fileTestModule, gcModule, - objectSpaceModule, processModule, procUIDModule, procGIDModule, - procSysModule, precisionModule, errnoModule; - - // record separator var, to speed up io ops that use it - private GlobalVariable recordSeparatorVar; - - // former java.lang.System concepts now internalized for MVM - private String currentDirectory; - - private long startTime = System.currentTimeMillis(); - - private RubyInstanceConfig config; - - private InputStream in; - private PrintStream out; - private PrintStream err; - - // Java support - private JavaSupport javaSupport; - private JRubyClassLoader jrubyClassLoader; - - // Management/monitoring - private BeanManager beanManager; - - // Compilation - private final JITCompiler jitCompiler; - - // Note: this field and the following static initializer - // must be located be in this order! - private volatile static boolean securityRestricted = false; - static { - if (SafePropertyAccessor.isSecurityProtected("jruby.reflection")) { - // can't read non-standard properties - securityRestricted = true; - } else { - SecurityManager sm = System.getSecurityManager(); - if (sm != null) { - try { - sm.checkCreateClassLoader(); - } catch (SecurityException se) { - // can't create custom classloaders - securityRestricted = true; - } - } - } - } - - private Parser parser = new Parser(this); - - private LoadService loadService; - private GlobalVariables globalVariables = new GlobalVariables(this); - private RubyWarnings warnings = new RubyWarnings(this); - - // Contains a list of all blocks (as Procs) that should be called when - // the runtime environment exits. - private Stack<RubyProc> atExitBlocks = new Stack<RubyProc>(); - - private Profile profile; - - private KCode kcode = KCode.NONE; - - // Atomic integers for symbol and method IDs - private AtomicInteger symbolLastId = new AtomicInteger(128); - private AtomicInteger moduleLastId = new AtomicInteger(0); - - private Object respondToMethod; - private Object objectToYamlMethod; - - private Map<String, DateTimeZone> localTimeZoneCache = new HashMap<String,DateTimeZone>(); - /** - * A list of "external" finalizers (the ones, registered via ObjectSpace), - * weakly referenced, to be executed on tearDown. - */ - private Map<Finalizable, Object> finalizers; - - /** - * A list of JRuby-internal finalizers, weakly referenced, - * to be executed on tearDown. - */ - private Map<Finalizable, Object> internalFinalizers; - - // mutex that controls modifications of user-defined finalizers - private final Object finalizersMutex = new Object(); - - // mutex that controls modifications of internal finalizers - private final Object internalFinalizersMutex = new Object(); - - // A thread pool to use for executing this runtime's Ruby threads - private ExecutorService executor; -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2007 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.FrameField; -import org.jruby.anno.JRubyMethod; -import org.jruby.runtime.Block; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; - -public class RubyArgsFile { - private static final class ArgsFileData { - private final Ruby runtime; - public ArgsFileData(Ruby runtime) { - this.runtime = runtime; - } - - public IRubyObject currentFile; - public int currentLineNumber; - public boolean startedProcessing = false; - public boolean finishedProcessing = false; - - public boolean nextArgsFile(ThreadContext context) { - if (finishedProcessing) { - return false; - } - - RubyArray args = (RubyArray)runtime.getGlobalVariables().get("$*"); - if (args.getLength() == 0) { - if (!startedProcessing) { - currentFile = runtime.getGlobalVariables().get("$stdin"); - ((RubyString) runtime.getGlobalVariables().get("$FILENAME")).setValue(new ByteList(new byte[]{'-'})); - currentLineNumber = 0; - startedProcessing = true; - return true; - } else { - finishedProcessing = true; - return false; - } - } - - IRubyObject arg = args.shift(); - RubyString filename = (RubyString)((RubyObject)arg).to_s(); - ByteList filenameBytes = filename.getByteList(); - ((RubyString) runtime.getGlobalVariables().get("$FILENAME")).setValue(filenameBytes); - - if (filenameBytes.length() == 1 && filenameBytes.get(0) == '-') { - currentFile = runtime.getGlobalVariables().get("$stdin"); - } else { - currentFile = RubyFile.open(context, runtime.getFile(), - new IRubyObject[] {filename.strDup(context.getRuntime())}, Block.NULL_BLOCK); - } - - startedProcessing = true; - return true; - } - - public static ArgsFileData getDataFrom(IRubyObject recv) { - ArgsFileData data = (ArgsFileData)recv.dataGetStruct(); - if(data == null) { - data = new ArgsFileData(recv.getRuntime()); - recv.dataWrapStruct(data); - } - return data; - } - } - - public static void setCurrentLineNumber(IRubyObject recv, int newLineNumber) { - ArgsFileData.getDataFrom(recv).currentLineNumber = newLineNumber; - } - - public static void initArgsFile(Ruby runtime) { - RubyObject argsFile = new RubyObject(runtime, runtime.getObject()); - - runtime.getEnumerable().extend_object(argsFile); - - runtime.defineReadonlyVariable("$<", argsFile); - runtime.defineGlobalConstant("ARGF", argsFile); - - RubyClass argfClass = argsFile.getMetaClass(); - argfClass.defineAnnotatedMethods(RubyArgsFile.class); - runtime.defineReadonlyVariable("$FILENAME", runtime.newString("-")); - } - - @JRubyMethod(name = {"fileno", "to_i"}) - public static IRubyObject fileno(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - - if (data.currentFile == null && !data.nextArgsFile(context)) { - throw context.getRuntime().newArgumentError("no stream"); - } - return ((RubyIO) data.currentFile).fileno(context); - } - - @JRubyMethod(name = "to_io") - public static IRubyObject to_io(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - - if (data.currentFile == null && !data.nextArgsFile(context)) { - throw context.getRuntime().newArgumentError("no stream"); - } - return data.currentFile; - } - - public static IRubyObject internalGets(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - - if(data.currentFile == null && !data.nextArgsFile(context)) { - return context.getRuntime().getNil(); - } - - IRubyObject line = data.currentFile.callMethod(context, "gets", args); - - while (line instanceof RubyNil) { - data.currentFile.callMethod(context, "close"); - if (!data.nextArgsFile(context)) { - data.currentFile = null; - return line; - } - line = data.currentFile.callMethod(context, "gets", args); - } - - data.currentLineNumber++; - context.getRuntime().getGlobalVariables().set("$.", context.getRuntime().newFixnum(data.currentLineNumber)); - - return line; - } - - // ARGF methods - - /** Read a line. - * - */ - @JRubyMethod(name = "gets", optional = 1, frame = true, writes = FrameField.LASTLINE) - public static IRubyObject gets(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - IRubyObject result = internalGets(context, recv, args); - - if (!result.isNil()) { - context.getCurrentFrame().setLastLine(result); - } - - return result; - } - - /** Read a line. - * - */ - @JRubyMethod(name = "readline", optional = 1, frame = true, writes = FrameField.LASTLINE) - public static IRubyObject readline(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - IRubyObject line = gets(context, recv, args); - - if (line.isNil()) { - throw context.getRuntime().newEOFError(); - } - - return line; - } - - @JRubyMethod(name = "readlines", optional = 1, frame = true) - public static RubyArray readlines(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - IRubyObject[] separatorArgument; - if (args.length > 0) { - if (!context.getRuntime().getNilClass().isInstance(args[0]) && - !context.getRuntime().getString().isInstance(args[0])) { - throw context.getRuntime().newTypeError(args[0], context.getRuntime().getString()); - } - separatorArgument = new IRubyObject[] { args[0] }; - } else { - separatorArgument = IRubyObject.NULL_ARRAY; - } - - RubyArray result = context.getRuntime().newArray(); - IRubyObject line; - while (! (line = internalGets(context, recv, separatorArgument)).isNil()) { - result.append(line); - } - return result; - } - - @JRubyMethod(name = "each_byte", frame = true) - public static IRubyObject each_byte(ThreadContext context, IRubyObject recv, Block block) { - IRubyObject bt; - - while(!(bt = getc(context, recv)).isNil()) { - block.yield(context, bt); - } - - return recv; - } - - /** Invoke a block for each line. - * - */ - @JRubyMethod(name = "each_line", alias = {"each"}, optional = 1, frame = true) - public static IRubyObject each_line(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - IRubyObject nextLine = internalGets(context, recv, args); - - while (!nextLine.isNil()) { - block.yield(context, nextLine); - nextLine = internalGets(context, recv, args); - } - - return recv; - } - - @JRubyMethod(name = "file") - public static IRubyObject file(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - - if(data.currentFile == null && !data.nextArgsFile(context)) { - return context.getRuntime().getNil(); - } - return data.currentFile; - } - - @JRubyMethod(name = "skip") - public static IRubyObject skip(IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - data.currentFile = null; - return recv; - } - - @JRubyMethod(name = "close") - public static IRubyObject close(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - if(data.currentFile == null && !data.nextArgsFile(context)) { - return recv; - } - data.currentFile = null; - data.currentLineNumber = 0; - return recv; - } - - @JRubyMethod(name = "closed?") - public static IRubyObject closed_p(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - if(data.currentFile == null && !data.nextArgsFile(context)) { - return recv; - } - return ((RubyIO)data.currentFile).closed_p(context); - } - - @JRubyMethod(name = "binmode") - public static IRubyObject binmode(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - if(data.currentFile == null && !data.nextArgsFile(context)) { - throw context.getRuntime().newArgumentError("no stream"); - } - - return ((RubyIO)data.currentFile).binmode(); - } - - @JRubyMethod(name = "lineno") - public static IRubyObject lineno(ThreadContext context, IRubyObject recv) { - return context.getRuntime().newFixnum(ArgsFileData.getDataFrom(recv).currentLineNumber); - } - - @JRubyMethod(name = "tell", alias = {"pos"}) - public static IRubyObject tell(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - if(data.currentFile == null && !data.nextArgsFile(context)) { - throw context.getRuntime().newArgumentError("no stream to tell"); - } - return ((RubyIO)data.currentFile).pos(context); - } - - @JRubyMethod(name = "rewind") - public static IRubyObject rewind(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - if(data.currentFile == null && !data.nextArgsFile(context)) { - throw context.getRuntime().newArgumentError("no stream to rewind"); - } - return ((RubyIO)data.currentFile).rewind(context); - } - - @JRubyMethod(name = {"eof", "eof?"}) - public static IRubyObject eof(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - if (data.currentFile == null && !data.nextArgsFile(context)) { - return context.getRuntime().getTrue(); - } - - return ((RubyIO) data.currentFile).eof_p(context); - } - - @JRubyMethod(name = "pos=", required = 1) - public static IRubyObject set_pos(ThreadContext context, IRubyObject recv, IRubyObject offset) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - if(data.currentFile == null && !data.nextArgsFile(context)) { - throw context.getRuntime().newArgumentError("no stream to set position"); - } - return ((RubyIO)data.currentFile).pos_set(context, offset); - } - - @JRubyMethod(name = "seek", required = 1, optional = 1) - public static IRubyObject seek(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - if(data.currentFile == null && !data.nextArgsFile(context)) { - throw context.getRuntime().newArgumentError("no stream to seek"); - } - return ((RubyIO)data.currentFile).seek(context, args); - } - - @JRubyMethod(name = "lineno=", required = 1) - public static IRubyObject set_lineno(ThreadContext context, IRubyObject recv, IRubyObject line) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - data.currentLineNumber = RubyNumeric.fix2int(line); - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "readchar") - public static IRubyObject readchar(ThreadContext context, IRubyObject recv) { - IRubyObject c = getc(context, recv); - - if(c.isNil()) throw context.getRuntime().newEOFError(); - - return c; - } - - @JRubyMethod(name = "getc") - public static IRubyObject getc(ThreadContext context, IRubyObject recv) { - ArgsFileData data = ArgsFileData.getDataFrom(recv); - IRubyObject bt; - while(true) { - if(data.currentFile == null && !data.nextArgsFile(context)) { - return context.getRuntime().getNil(); - } - if(!(data.currentFile instanceof RubyFile)) { - bt = data.currentFile.callMethod(context,"getc"); - } else { - bt = ((RubyIO)data.currentFile).getc(); - } - if(bt.isNil()) { - data.currentFile = null; - continue; - } - return bt; - } - } - - @JRubyMethod(name = "read", optional = 2) - public static IRubyObject read(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - ArgsFileData data = ArgsFileData.getDataFrom(recv); - IRubyObject tmp, str, length; - long len = 0; - if(args.length > 0) { - length = args[0]; - if(args.length > 1) { - str = args[1]; - } else { - str = runtime.getNil(); - } - } else { - length = str = runtime.getNil(); - } - - if(!length.isNil()) { - len = RubyNumeric.num2long(length); - } - if(!str.isNil()) { - str = str.convertToString(); - ((RubyString)str).modify(); - ((RubyString)str).getByteList().length(0); - args[1] = runtime.getNil(); - } - while(true) { - if(data.currentFile == null && !data.nextArgsFile(context)) { - return str; - } - if(!(data.currentFile instanceof RubyIO)) { - tmp = data.currentFile.callMethod(context, "read", args); - } else { - tmp = ((RubyIO)data.currentFile).read(args); - } - if(str.isNil()) { - str = tmp; - } else if(!tmp.isNil()) { - ((RubyString)str).append(tmp); - } - if(tmp.isNil() || length.isNil()) { - data.currentFile = null; - continue; - } else if(args.length >= 1) { - if(((RubyString)str).getByteList().length() < len) { - len -= ((RubyString)str).getByteList().length(); - args[0] = runtime.newFixnum(len); - continue; - } - } - return str; - } - } - - @JRubyMethod(name = "filename", alias = {"path"}) - public static RubyString filename(ThreadContext context, IRubyObject recv) { - return (RubyString) context.getRuntime().getGlobalVariables().get("$FILENAME"); - } - - @JRubyMethod(name = "to_s") - public static IRubyObject to_s(IRubyObject recv) { - return recv.getRuntime().newString("ARGF"); - } -} -/* - **** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2005 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Ola Bini <Ola.Bini@ki.se> - * Copyright (C) 2006 Daniel Steer <damian.steer@hp.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.lang.reflect.Array; -import java.io.IOException; -import java.util.Arrays; -import java.util.Collection; -import java.util.Comparator; -import java.util.Iterator; -import java.util.List; -import java.util.ListIterator; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.javasupport.JavaUtil; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.ByteList; -import org.jruby.util.Pack; - -/** - * The implementation of the built-in class Array in Ruby. - * - * Concurrency: no synchronization is required among readers, but - * all users must synchronize externally with writers. - * - */ -@JRubyClass(name="Array") -public class RubyArray extends RubyObject implements List { - - public static RubyClass createArrayClass(Ruby runtime) { - RubyClass arrayc = runtime.defineClass("Array", runtime.getObject(), ARRAY_ALLOCATOR); - runtime.setArray(arrayc); - arrayc.index = ClassIndex.ARRAY; - arrayc.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyArray; - } - }; - - arrayc.includeModule(runtime.getEnumerable()); - arrayc.defineAnnotatedMethods(RubyArray.class); - - return arrayc; - } - - private static ObjectAllocator ARRAY_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyArray(runtime, klass); - } - }; - - @Override - public int getNativeTypeIndex() { - return ClassIndex.ARRAY; - } - - private final void concurrentModification() { - throw getRuntime().newConcurrencyError("Detected invalid array contents due to unsynchronized modifications with concurrent users"); - } - - /** rb_ary_s_create - * - */ - @JRubyMethod(name = "[]", rest = true, frame = true, meta = true) - public static IRubyObject create(IRubyObject klass, IRubyObject[] args, Block block) { - RubyArray arr = (RubyArray) ((RubyClass) klass).allocate(); - arr.callInit(IRubyObject.NULL_ARRAY, block); - - if (args.length > 0) { - arr.alloc(args.length); - System.arraycopy(args, 0, arr.values, 0, args.length); - arr.realLength = args.length; - } - return arr; - } - - /** rb_ary_new2 - * - */ - public static final RubyArray newArray(final Ruby runtime, final long len) { - return new RubyArray(runtime, len); - } - public static final RubyArray newArrayLight(final Ruby runtime, final long len) { - return new RubyArray(runtime, len, false); - } - - /** rb_ary_new - * - */ - public static final RubyArray newArray(final Ruby runtime) { - return new RubyArray(runtime, ARRAY_DEFAULT_SIZE); - } - - /** rb_ary_new - * - */ - public static final RubyArray newArrayLight(final Ruby runtime) { - /* Ruby arrays default to holding 16 elements, so we create an - * ArrayList of the same size if we're not told otherwise - */ - RubyArray arr = new RubyArray(runtime, false); - arr.alloc(ARRAY_DEFAULT_SIZE); - return arr; - } - - public static RubyArray newArray(Ruby runtime, IRubyObject obj) { - return new RubyArray(runtime, new IRubyObject[] { obj }); - } - - public static RubyArray newArrayLight(Ruby runtime, IRubyObject obj) { - return new RubyArray(runtime, new IRubyObject[] { obj }, false); - } - - /** rb_assoc_new - * - */ - public static RubyArray newArray(Ruby runtime, IRubyObject car, IRubyObject cdr) { - return new RubyArray(runtime, new IRubyObject[] { car, cdr }); - } - - public static RubyArray newEmptyArray(Ruby runtime) { - return new RubyArray(runtime, NULL_ARRAY); - } - - /** rb_ary_new4, rb_ary_new3 - * - */ - public static RubyArray newArray(Ruby runtime, IRubyObject[] args) { - RubyArray arr = new RubyArray(runtime, args.length); - System.arraycopy(args, 0, arr.values, 0, args.length); - arr.realLength = args.length; - return arr; - } - - public static RubyArray newArrayNoCopy(Ruby runtime, IRubyObject[] args) { - return new RubyArray(runtime, args); - } - - public static RubyArray newArrayNoCopy(Ruby runtime, IRubyObject[] args, int begin) { - return new RubyArray(runtime, args, begin); - } - - public static RubyArray newArrayNoCopyLight(Ruby runtime, IRubyObject[] args) { - RubyArray arr = new RubyArray(runtime, false); - arr.values = args; - arr.realLength = args.length; - return arr; - } - - public static RubyArray newArray(Ruby runtime, Collection collection) { - RubyArray arr = new RubyArray(runtime, collection.size()); - collection.toArray(arr.values); - arr.realLength = arr.values.length; - return arr; - } - - public static final int ARRAY_DEFAULT_SIZE = 16; - - // volatile to ensure that initial nil-fill is visible to other threads - private volatile IRubyObject[] values; - - private static final int TMPLOCK_ARR_F = 1 << 9; - private static final int TMPLOCK_OR_FROZEN_ARR_F = TMPLOCK_ARR_F | FROZEN_F; - - private volatile boolean isShared = false; - private int begin = 0; - private int realLength = 0; - - /* - * plain internal array assignment - */ - private RubyArray(Ruby runtime, IRubyObject[] vals) { - super(runtime, runtime.getArray()); - values = vals; - realLength = vals.length; - } - - /* - * plain internal array assignment - */ - private RubyArray(Ruby runtime, IRubyObject[] vals, boolean objectSpace) { - super(runtime, runtime.getArray(), objectSpace); - values = vals; - realLength = vals.length; - } - - /* - * plain internal array assignment - */ - private RubyArray(Ruby runtime, IRubyObject[] vals, int begin) { - super(runtime, runtime.getArray()); - this.values = vals; - this.begin = begin; - this.realLength = vals.length - begin; - this.isShared = true; - } - - /* rb_ary_new2 - * just allocates the internal array - */ - private RubyArray(Ruby runtime, long length) { - super(runtime, runtime.getArray()); - checkLength(length); - alloc((int) length); - } - - private RubyArray(Ruby runtime, long length, boolean objectspace) { - super(runtime, runtime.getArray(), objectspace); - checkLength(length); - alloc((int)length); - } - - /* rb_ary_new3, rb_ary_new4 - * allocates the internal array of size length and copies the 'length' elements - */ - public RubyArray(Ruby runtime, long length, IRubyObject[] vals) { - super(runtime, runtime.getArray()); - checkLength(length); - int ilength = (int) length; - alloc(ilength); - if (ilength > 0 && vals.length > 0) System.arraycopy(vals, 0, values, 0, ilength); - - realLength = ilength; - } - - /* NEWOBJ and OBJSETUP equivalent - * fastest one, for shared arrays, optional objectspace - */ - private RubyArray(Ruby runtime, boolean objectSpace) { - super(runtime, runtime.getArray(), objectSpace); - } - - private RubyArray(Ruby runtime) { - super(runtime, runtime.getArray()); - alloc(ARRAY_DEFAULT_SIZE); - } - - public RubyArray(Ruby runtime, RubyClass klass) { - super(runtime, klass); - alloc(ARRAY_DEFAULT_SIZE); - } - - /* Array constructors taking the MetaClass to fulfil MRI Array subclass behaviour - * - */ - private RubyArray(Ruby runtime, RubyClass klass, int length) { - super(runtime, klass); - alloc(length); - } - - private RubyArray(Ruby runtime, RubyClass klass, long length) { - super(runtime, klass); - checkLength(length); - alloc((int)length); - } - - private RubyArray(Ruby runtime, RubyClass klass, long length, boolean objectspace) { - super(runtime, klass, objectspace); - checkLength(length); - alloc((int)length); - } - - private RubyArray(Ruby runtime, RubyClass klass, boolean objectSpace) { - super(runtime, klass, objectSpace); - } - - private RubyArray(Ruby runtime, RubyClass klass, RubyArray original) { - super(runtime, klass); - realLength = original.realLength; - alloc(realLength); - try { - System.arraycopy(original.values, original.begin, values, 0, realLength); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - } - - private final IRubyObject[] reserve(int length) { - final IRubyObject[] arr = new IRubyObject[length]; - Arrays.fill(arr, getRuntime().getNil()); - return arr; - } - - private final void alloc(int length) { - final IRubyObject[] newValues = new IRubyObject[length]; - Arrays.fill(newValues, getRuntime().getNil()); - values = newValues; - } - - private final void realloc(int newLength) { - IRubyObject[] reallocated = new IRubyObject[newLength]; - Arrays.fill(reallocated, getRuntime().getNil()); - try { - System.arraycopy(values, 0, reallocated, 0, newLength > realLength ? realLength : newLength); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - values = reallocated; - } - - private final void checkLength(long length) { - if (length < 0) { - throw getRuntime().newArgumentError("negative array size (or size too big)"); - } - - if (length >= Integer.MAX_VALUE) { - throw getRuntime().newArgumentError("array size too big"); - } - } - - /** Getter for property list. - * @return Value of property list. - */ - public List getList() { - return Arrays.asList(toJavaArray()); - } - - public int getLength() { - return realLength; - } - - public IRubyObject[] toJavaArray() { - IRubyObject[] copy = reserve(realLength); - try { - System.arraycopy(values, begin, copy, 0, realLength); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - return copy; - } - - public IRubyObject[] toJavaArrayUnsafe() { - return !isShared ? values : toJavaArray(); - } - - public IRubyObject[] toJavaArrayMaybeUnsafe() { - return (!isShared && begin == 0 && values.length == realLength) ? values : toJavaArray(); - } - - /** rb_ary_make_shared - * - */ - private final RubyArray makeShared(int beg, int len, RubyClass klass) { - return makeShared(beg, len, klass, klass.getRuntime().isObjectSpaceEnabled()); - } - - /** rb_ary_make_shared - * - */ - private final RubyArray makeShared(int beg, int len, RubyClass klass, boolean objectSpace) { - RubyArray sharedArray = new RubyArray(getRuntime(), klass, objectSpace); - isShared = true; - sharedArray.values = values; - sharedArray.isShared = true; - sharedArray.begin = beg; - sharedArray.realLength = len; - return sharedArray; - } - - /** rb_ary_modify_check - * - */ - private final void modifyCheck() { - if ((flags & TMPLOCK_OR_FROZEN_ARR_F) != 0) { - if ((flags & FROZEN_F) != 0) throw getRuntime().newFrozenError("array"); - if ((flags & TMPLOCK_ARR_F) != 0) throw getRuntime().newTypeError("can't modify array during iteration"); - } - if (!isTaint() && getRuntime().getSafeLevel() >= 4) { - throw getRuntime().newSecurityError("Insecure: can't modify array"); - } - } - - /** rb_ary_modify - * - */ - private final void modify() { - modifyCheck(); - if (isShared) { - IRubyObject[] vals = reserve(realLength); - isShared = false; - try { - System.arraycopy(values, begin, vals, 0, realLength); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - begin = 0; - values = vals; - } - } - - /* ================ - * Instance Methods - * ================ - */ - - /** rb_ary_initialize - * - */ - @JRubyMethod(name = "initialize", required = 0, optional = 2, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(ThreadContext context, IRubyObject[] args, Block block) { - int argc = args.length; - Ruby runtime = getRuntime(); - - if (argc == 0) { - modifyCheck(); - realLength = 0; - if (block.isGiven()) runtime.getWarnings().warn(ID.BLOCK_UNUSED, "given block not used"); - - return this; - } - - if (argc == 1 && !(args[0] instanceof RubyFixnum)) { - IRubyObject val = args[0].checkArrayType(); - if (!val.isNil()) { - replace(val); - return this; - } - } - - long len = RubyNumeric.num2long(args[0]); - - if (len < 0) throw runtime.newArgumentError("negative array size"); - - if (len >= Integer.MAX_VALUE) throw runtime.newArgumentError("array size too big"); - - int ilen = (int) len; - - modify(); - - if (ilen > values.length) values = reserve(ilen); - - if (block.isGiven()) { - if (argc == 2) { - runtime.getWarnings().warn(ID.BLOCK_BEATS_DEFAULT_VALUE, "block supersedes default value argument"); - } - - for (int i = 0; i < ilen; i++) { - store(i, block.yield(context, new RubyFixnum(runtime, i))); - realLength = i + 1; - } - } else { - try { - Arrays.fill(values, 0, ilen, (argc == 2) ? args[1] : runtime.getNil()); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - realLength = ilen; - } - return this; - } - - /** rb_ary_initialize_copy - * - */ - @JRubyMethod(name = {"initialize_copy"}, required = 1, visibility=Visibility.PRIVATE) - @Override - public IRubyObject initialize_copy(IRubyObject orig) { - return this.replace(orig); - } - - /** rb_ary_replace - * - */ - @JRubyMethod(name = {"replace"}, required = 1) - public IRubyObject replace(IRubyObject orig) { - modifyCheck(); - - RubyArray origArr = orig.convertToArray(); - - if (this == orig) return this; - - origArr.isShared = true; - isShared = true; - values = origArr.values; - realLength = origArr.realLength; - begin = origArr.begin; - - - return this; - } - - /** rb_ary_to_s - * - */ - @JRubyMethod(name = "to_s") - @Override - public IRubyObject to_s() { - if (realLength == 0) return RubyString.newEmptyString(getRuntime()); - - return join(getRuntime().getCurrentContext(), getRuntime().getGlobalVariables().get("$,")); - } - - - public boolean includes(ThreadContext context, IRubyObject item) { - int begin = this.begin; - - for (int i = begin; i < begin + realLength; i++) { - final IRubyObject value; - try { - value = values[i]; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - continue; - } - if (equalInternal(context, value, item)) return true; - } - - return false; - } - - /** rb_ary_hash - * - */ - @JRubyMethod(name = "hash") - public RubyFixnum hash(ThreadContext context) { - int h = realLength; - - Ruby runtime = getRuntime(); - int begin = this.begin; - for (int i = begin; i < begin + realLength; i++) { - h = (h << 1) | (h < 0 ? 1 : 0); - final IRubyObject value; - try { - value = values[i]; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - continue; - } - h ^= RubyNumeric.num2long(value.callMethod(context, MethodIndex.HASH, "hash")); - } - - return runtime.newFixnum(h); - } - - /** rb_ary_store - * - */ - public final IRubyObject store(long index, IRubyObject value) { - if (index < 0) { - index += realLength; - if (index < 0) { - throw getRuntime().newIndexError("index " + (index - realLength) + " out of array"); - } - } - - modify(); - - if (index >= realLength) { - if (index >= values.length) { - long newLength = values.length >> 1; - - if (newLength < ARRAY_DEFAULT_SIZE) newLength = ARRAY_DEFAULT_SIZE; - - newLength += index; - if (index >= Integer.MAX_VALUE || newLength >= Integer.MAX_VALUE) { - throw getRuntime().newArgumentError("index too big"); - } - realloc((int) newLength); - } - - realLength = (int) index + 1; - } - - try { - values[(int) index] = value; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - return value; - } - - /** rb_ary_elt - * - */ - private final IRubyObject elt(long offset) { - if (offset < 0 || offset >= realLength) { - return getRuntime().getNil(); - } - try { - return values[begin + (int)offset]; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - return getRuntime().getNil(); - } - } - - /** rb_ary_entry - * - */ - public final IRubyObject entry(long offset) { - return (offset < 0 ) ? elt(offset + realLength) : elt(offset); - } - - - /** rb_ary_entry - * - */ - public final IRubyObject entry(int offset) { - return (offset < 0 ) ? elt(offset + realLength) : elt(offset); - } - - public final IRubyObject eltInternal(int offset) { - return values[begin + offset]; - } - - public final IRubyObject eltInternalSet(int offset, IRubyObject item) { - return values[begin + offset] = item; - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public IRubyObject fetch(ThreadContext context, IRubyObject[] args, Block block) { - switch (args.length) { - case 1: - return fetch(context, args[0], block); - case 2: - return fetch(context, args[0], args[1], block); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_ary_fetch - * - */ - @JRubyMethod(name = "fetch", frame = true) - public IRubyObject fetch(ThreadContext context, IRubyObject arg0, Block block) { - long index = RubyNumeric.num2long(arg0); - - if (index < 0) index += realLength; - if (index < 0 || index >= realLength) { - if (block.isGiven()) return block.yield(context, arg0); - throw getRuntime().newIndexError("index " + index + " out of array"); - } - - try { - return values[begin + (int) index]; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - return getRuntime().getNil(); - } - } - - /** rb_ary_fetch - * - */ - @JRubyMethod(name = "fetch", frame = true) - public IRubyObject fetch(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - if (block.isGiven()) getRuntime().getWarnings().warn(ID.BLOCK_BEATS_DEFAULT_VALUE, "block supersedes default value argument"); - - long index = RubyNumeric.num2long(arg0); - - if (index < 0) index += realLength; - if (index < 0 || index >= realLength) { - if (block.isGiven()) return block.yield(context, arg0); - return arg1; - } - - try { - return values[begin + (int) index]; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - return getRuntime().getNil(); - } - } - - /** rb_ary_to_ary - * - */ - private static RubyArray aryToAry(IRubyObject obj) { - if (obj instanceof RubyArray) return (RubyArray) obj; - - if (obj.respondsTo("to_ary")) return obj.convertToArray(); - - RubyArray arr = new RubyArray(obj.getRuntime(), false); // possibly should not in object space - arr.alloc(1); - arr.values[0] = obj; - arr.realLength = 1; - return arr; - } - - /** rb_ary_splice - * - */ - private final void splice(long beg, long len, IRubyObject rpl) { - if (len < 0) throw getRuntime().newIndexError("negative length (" + len + ")"); - - if (beg < 0) { - beg += realLength; - if (beg < 0) { - beg -= realLength; - throw getRuntime().newIndexError("index " + beg + " out of array"); - } - } - - final RubyArray rplArr; - final int rlen; - - if (rpl == null || rpl.isNil()) { - rplArr = null; - rlen = 0; - } else { - rplArr = aryToAry(rpl); - rlen = rplArr.realLength; - } - - modify(); - - if (beg >= realLength) { - len = beg + rlen; - - if (len >= values.length) { - int tryNewLength = values.length + (values.length >> 1); - realloc(len > tryNewLength ? (int)len : tryNewLength); - } - - realLength = (int) len; - } else { - if (beg + len > realLength) len = realLength - beg; - - long alen = realLength + rlen - len; - if (alen >= values.length) { - int tryNewLength = values.length + (values.length >> 1); - realloc(alen > tryNewLength ? (int)alen : tryNewLength); - } - - if (len != rlen) { - try { - System.arraycopy(values, (int) (beg + len), values, (int) beg + rlen, realLength - (int) (beg + len)); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - realLength = (int) alen; - } - } - - if (rlen > 0) { - try { - System.arraycopy(rplArr.values, rplArr.begin, values, (int) beg, rlen); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - } - } - - /** rb_ary_splice - * - */ - private final void spliceOne(long beg, long len, IRubyObject rpl) { - if (len < 0) throw getRuntime().newIndexError("negative length (" + len + ")"); - - if (beg < 0) { - beg += realLength; - if (beg < 0) { - beg -= realLength; - throw getRuntime().newIndexError("index " + beg + " out of array"); - } - } - - modify(); - - if (beg >= realLength) { - len = beg + 1; - - if (len >= values.length) { - int tryNewLength = values.length + (values.length >> 1); - realloc(len > tryNewLength ? (int)len : tryNewLength); - } - - realLength = (int) len; - } else { - if (beg + len > realLength) len = realLength - beg; - - int alen = realLength + 1 - (int)len; - if (alen >= values.length) { - int tryNewLength = values.length + (values.length >> 1); - realloc(alen > tryNewLength ? alen : tryNewLength); - } - - if (len != 1) { - try { - System.arraycopy(values, (int) (beg + len), values, (int) beg + 1, realLength - (int) (beg + len)); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - realLength = alen; - } - } - - try { - values[(int)beg] = rpl; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - } - - @JRubyMethod - public IRubyObject insert() { - throw getRuntime().newArgumentError(0, 1); - } - - /** rb_ary_insert - * - */ - @JRubyMethod - public IRubyObject insert(IRubyObject arg) { - return this; - } - - /** rb_ary_insert - * - */ - @JRubyMethod - public IRubyObject insert(IRubyObject arg1, IRubyObject arg2) { - long pos = RubyNumeric.num2long(arg1); - - if (pos == -1) pos = realLength; - if (pos < 0) pos++; - - spliceOne(pos, 0, arg2); // rb_ary_new4 - - return this; - } - - /** rb_ary_insert - * - */ - @JRubyMethod(name = "insert", required = 1, rest = true) - public IRubyObject insert(IRubyObject[] args) { - if (args.length == 1) return this; - - long pos = RubyNumeric.num2long(args[0]); - - if (pos == -1) pos = realLength; - if (pos < 0) pos++; - - RubyArray inserted = new RubyArray(getRuntime(), false); - inserted.values = args; - inserted.begin = 1; - inserted.realLength = args.length - 1; - - splice(pos, 0, inserted); // rb_ary_new4 - - return this; - } - - /** rb_ary_dup - * - */ - public final RubyArray aryDup() { - RubyArray dup = new RubyArray(getRuntime(), getMetaClass(), this); - dup.flags |= flags & TAINTED_F; // from DUP_SETUP - // rb_copy_generic_ivar from DUP_SETUP here ...unlikely.. - return dup; - } - - /** rb_ary_transpose - * - */ - @JRubyMethod(name = "transpose") - public RubyArray transpose() { - RubyArray tmp, result = null; - - int alen = realLength; - if (alen == 0) return aryDup(); - - Ruby runtime = getRuntime(); - int elen = -1; - int end = begin + alen; - for (int i = begin; i < end; i++) { - tmp = elt(i).convertToArray(); - if (elen < 0) { - elen = tmp.realLength; - result = new RubyArray(runtime, elen); - for (int j = 0; j < elen; j++) { - result.store(j, new RubyArray(runtime, alen)); - } - } else if (elen != tmp.realLength) { - throw runtime.newIndexError("element size differs (" + tmp.realLength - + " should be " + elen + ")"); - } - for (int j = 0; j < elen; j++) { - ((RubyArray) result.elt(j)).store(i - begin, tmp.elt(j)); - } - } - return result; - } - - /** rb_values_at (internal) - * - */ - private final IRubyObject values_at(long olen, IRubyObject[] args) { - RubyArray result = new RubyArray(getRuntime(), args.length); - - for (int i = 0; i < args.length; i++) { - if (args[i] instanceof RubyFixnum) { - result.append(entry(((RubyFixnum)args[i]).getLongValue())); - continue; - } - - long beglen[]; - if (!(args[i] instanceof RubyRange)) { - } else if ((beglen = ((RubyRange) args[i]).begLen(olen, 0)) == null) { - continue; - } else { - int beg = (int) beglen[0]; - int len = (int) beglen[1]; - int end = begin + len; - for (int j = begin; j < end; j++) { - result.append(entry(j + beg)); - } - continue; - } - result.append(entry(RubyNumeric.num2long(args[i]))); - } - - return result; - } - - /** rb_values_at - * - */ - @JRubyMethod(name = "values_at", rest = true) - public IRubyObject values_at(IRubyObject[] args) { - return values_at(realLength, args); - } - - /** rb_ary_subseq - * - */ - public IRubyObject subseq(long beg, long len) { - if (beg > realLength || beg < 0 || len < 0) return getRuntime().getNil(); - - if (beg + len > realLength) { - len = realLength - beg; - - if (len < 0) len = 0; - } - - if (len == 0) return new RubyArray(getRuntime(), getMetaClass(), 0); - - return makeShared(begin + (int) beg, (int) len, getMetaClass()); - } - - /** rb_ary_subseq - * - */ - public IRubyObject subseqLight(long beg, long len) { - if (beg > realLength || beg < 0 || len < 0) return getRuntime().getNil(); - - if (beg + len > realLength) { - len = realLength - beg; - - if (len < 0) len = 0; - } - - if (len == 0) return new RubyArray(getRuntime(), getMetaClass(), 0, false); - - return makeShared(begin + (int) beg, (int) len, getMetaClass(), false); - } - - /** rb_ary_length - * - */ - @JRubyMethod(name = "length", alias = "size") - public RubyFixnum length() { - return getRuntime().newFixnum(realLength); - } - - /** rb_ary_push - specialized rb_ary_store - * - */ - @JRubyMethod(name = "<<", required = 1) - public RubyArray append(IRubyObject item) { - modify(); - - if (realLength == values.length) { - if (realLength == Integer.MAX_VALUE) throw getRuntime().newArgumentError("index too big"); - - long newLength = values.length + (values.length >> 1); - if ( newLength > Integer.MAX_VALUE ) { - newLength = Integer.MAX_VALUE; - }else if ( newLength < ARRAY_DEFAULT_SIZE ) { - newLength = ARRAY_DEFAULT_SIZE; - } - - realloc((int) newLength); - } - - try { - values[realLength++] = item; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - return this; - } - - /** rb_ary_push_m - * FIXME: Whis is this named "push_m"? - */ - @JRubyMethod(name = "push", rest = true) - public RubyArray push_m(IRubyObject[] items) { - for (int i = 0; i < items.length; i++) { - append(items[i]); - } - - return this; - } - - /** rb_ary_pop - * - */ - @JRubyMethod(name = "pop") - public IRubyObject pop() { - modifyCheck(); - - if (realLength == 0) return getRuntime().getNil(); - - if (isShared) { - try { - return values[begin + --realLength]; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - return getRuntime().getNil(); - } - } else { - int index = begin + --realLength; - try { - final IRubyObject obj = values[index]; - values[index] = getRuntime().getNil(); - return obj; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - return getRuntime().getNil(); - } - } - } - - /** rb_ary_shift - * - */ - @JRubyMethod(name = "shift") - public IRubyObject shift() { - modify(); - - if (realLength == 0) return getRuntime().getNil(); - - final IRubyObject obj; - try { - obj = values[begin]; - values[begin] = getRuntime().getNil(); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - return getRuntime().getNil(); - } - - isShared = true; - - begin++; - realLength--; - - return obj; - } - - /** rb_ary_unshift - * - */ - public RubyArray unshift(IRubyObject item) { - modify(); - - if (realLength == values.length) { - int newLength = values.length >> 1; - if (newLength < ARRAY_DEFAULT_SIZE) newLength = ARRAY_DEFAULT_SIZE; - - newLength += values.length; - realloc(newLength); - } - try { - System.arraycopy(values, 0, values, 1, realLength); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - - realLength++; - values[0] = item; - - return this; - } - - /** rb_ary_unshift_m - * - */ - @JRubyMethod(name = "unshift", rest = true) - public RubyArray unshift_m(IRubyObject[] items) { - long len = realLength; - - if (items.length == 0) return this; - - store(len + items.length - 1, getRuntime().getNil()); - - try { - // it's safe to use zeroes here since modified by store() - System.arraycopy(values, 0, values, items.length, (int) len); - System.arraycopy(items, 0, values, 0, items.length); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - - return this; - } - - /** rb_ary_includes - * - */ - @JRubyMethod(name = "include?", required = 1) - public RubyBoolean include_p(ThreadContext context, IRubyObject item) { - return context.getRuntime().newBoolean(includes(context, item)); - } - - /** rb_ary_frozen_p - * - */ - @JRubyMethod(name = "frozen?") - @Override - public RubyBoolean frozen_p(ThreadContext context) { - return context.getRuntime().newBoolean(isFrozen() || (flags & TMPLOCK_ARR_F) != 0); - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public IRubyObject aref(IRubyObject[] args) { - switch (args.length) { - case 1: - return aref(args[0]); - case 2: - return aref(args[0], args[1]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_ary_aref - */ - @JRubyMethod(name = {"[]", "slice"}) - public IRubyObject aref(IRubyObject arg0) { - if (arg0 instanceof RubyFixnum) return entry(((RubyFixnum)arg0).getLongValue()); - if (arg0 instanceof RubySymbol) throw getRuntime().newTypeError("Symbol as array index"); - - long[] beglen; - if (!(arg0 instanceof RubyRange)) { - } else if ((beglen = ((RubyRange) arg0).begLen(realLength, 0)) == null) { - return getRuntime().getNil(); - } else { - return subseq(beglen[0], beglen[1]); - } - return entry(RubyNumeric.num2long(arg0)); - } - - /** rb_ary_aref - */ - @JRubyMethod(name = {"[]", "slice"}) - public IRubyObject aref(IRubyObject arg0, IRubyObject arg1) { - if (arg0 instanceof RubySymbol) throw getRuntime().newTypeError("Symbol as array index"); - - long beg = RubyNumeric.num2long(arg0); - if (beg < 0) beg += realLength; - - return subseq(beg, RubyNumeric.num2long(arg1)); - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public IRubyObject aset(IRubyObject[] args) { - switch (args.length) { - case 2: - return aset(args[0], args[1]); - case 3: - return aset(args[0], args[1], args[2]); - default: - throw getRuntime().newArgumentError("wrong number of arguments (" + args.length + " for 2)"); - } - } - - /** rb_ary_aset - * - */ - @JRubyMethod(name = "[]=") - public IRubyObject aset(IRubyObject arg0, IRubyObject arg1) { - if (arg0 instanceof RubyFixnum) { - store(((RubyFixnum)arg0).getLongValue(), arg1); - return arg1; - } - if (arg0 instanceof RubyRange) { - long[] beglen = ((RubyRange) arg0).begLen(realLength, 1); - splice(beglen[0], beglen[1], arg1); - return arg1; - } - if (arg0 instanceof RubySymbol) throw getRuntime().newTypeError("Symbol as array index"); - - store(RubyNumeric.num2long(arg0), arg1); - return arg1; - } - - /** rb_ary_aset - * - */ - @JRubyMethod(name = "[]=") - public IRubyObject aset(IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) { - if (arg0 instanceof RubySymbol) throw getRuntime().newTypeError("Symbol as array index"); - if (arg1 instanceof RubySymbol) throw getRuntime().newTypeError("Symbol as subarray length"); - splice(RubyNumeric.num2long(arg0), RubyNumeric.num2long(arg1), arg2); - return arg2; - } - - /** rb_ary_at - * - */ - @JRubyMethod(name = "at", required = 1) - public IRubyObject at(IRubyObject pos) { - return entry(RubyNumeric.num2long(pos)); - } - - /** rb_ary_concat - * - */ - @JRubyMethod(name = "concat", required = 1) - public RubyArray concat(IRubyObject obj) { - RubyArray ary = obj.convertToArray(); - - if (ary.realLength > 0) splice(realLength, 0, ary); - - return this; - } - - /** inspect_ary - * - */ - private IRubyObject inspectAry(ThreadContext context) { - ByteList buffer = new ByteList(); - buffer.append('['); - boolean tainted = isTaint(); - - for (int i = 0; i < realLength; i++) { - if (i > 0) buffer.append(',').append(' '); - - RubyString str = inspect(context, values[begin + i]); - if (str.isTaint()) tainted = true; - buffer.append(str.getByteList()); - } - buffer.append(']'); - - RubyString str = getRuntime().newString(buffer); - if (tainted) str.setTaint(true); - - return str; - } - - /** rb_ary_inspect - * - */ - @JRubyMethod(name = "inspect") - @Override - public IRubyObject inspect() { - if (realLength == 0) return getRuntime().newString("[]"); - if (getRuntime().isInspecting(this)) return getRuntime().newString("[...]"); - - try { - getRuntime().registerInspecting(this); - return inspectAry(getRuntime().getCurrentContext()); - } finally { - getRuntime().unregisterInspecting(this); - } - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public IRubyObject first(IRubyObject[] args) { - switch (args.length) { - case 0: - return first(); - case 1: - return first(args[0]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 0, 1); - return null; // not reached - } - } - - /** rb_ary_first - * - */ - @JRubyMethod(name = "first") - public IRubyObject first() { - if (realLength == 0) return getRuntime().getNil(); - return values[begin]; - } - - /** rb_ary_first - * - */ - @JRubyMethod(name = "first") - public IRubyObject first(IRubyObject arg0) { - long n = RubyNumeric.num2long(arg0); - if (n > realLength) { - n = realLength; - } else if (n < 0) { - throw getRuntime().newArgumentError("negative array size (or size too big)"); - } - - return makeShared(begin, (int) n, getRuntime().getArray()); - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public IRubyObject last(IRubyObject[] args) { - switch (args.length) { - case 0: - return last(); - case 1: - return last(args[0]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 0, 1); - return null; // not reached - } - } - - /** rb_ary_last - * - */ - @JRubyMethod(name = "last") - public IRubyObject last() { - if (realLength == 0) return getRuntime().getNil(); - return values[begin + realLength - 1]; - } - - /** rb_ary_last - * - */ - @JRubyMethod(name = "last") - public IRubyObject last(IRubyObject arg0) { - long n = RubyNumeric.num2long(arg0); - if (n > realLength) { - n = realLength; - } else if (n < 0) { - throw getRuntime().newArgumentError("negative array size (or size too big)"); - } - - return makeShared(begin + realLength - (int) n, (int) n, getRuntime().getArray()); - } - - /** rb_ary_each - * - */ - @JRubyMethod(name = "each", frame = true) - public IRubyObject each(ThreadContext context, Block block) { - for (int i = 0; i < realLength; i++) { - block.yield(context, values[begin + i]); - } - return this; - } - - /** rb_ary_each_index - * - */ - @JRubyMethod(name = "each_index", frame = true) - public IRubyObject each_index(ThreadContext context, Block block) { - Ruby runtime = getRuntime(); - for (int i = 0; i < realLength; i++) { - block.yield(context, runtime.newFixnum(i)); - } - return this; - } - - /** rb_ary_reverse_each - * - */ - @JRubyMethod(name = "reverse_each", frame = true) - public IRubyObject reverse_each(ThreadContext context, Block block) { - int len = realLength; - - while(len-- > 0) { - block.yield(context, values[begin + len]); - - if (realLength < len) len = realLength; - } - - return this; - } - - private IRubyObject inspectJoin(ThreadContext context, RubyArray tmp, IRubyObject sep) { - Ruby runtime = getRuntime(); - - // If already inspecting, there is no need to register/unregister again. - if (runtime.isInspecting(this)) { - return tmp.join(context, sep); - } - - try { - runtime.registerInspecting(this); - return tmp.join(context, sep); - } finally { - runtime.unregisterInspecting(this); - } - } - - /** rb_ary_join - * - */ - public RubyString join(ThreadContext context, IRubyObject sep) { - final Ruby runtime = getRuntime(); - - if (realLength == 0) return RubyString.newEmptyString(getRuntime()); - - boolean taint = isTaint() || sep.isTaint(); - - long len = 1; - for (int i = begin; i < begin + realLength; i++) { - IRubyObject value; - try { - value = values[i]; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - return runtime.newString(""); - } - IRubyObject tmp = value.checkStringType(); - len += tmp.isNil() ? 10 : ((RubyString) tmp).getByteList().length(); - } - - RubyString strSep = null; - if (!sep.isNil()) { - sep = strSep = sep.convertToString(); - len += strSep.getByteList().length() * (realLength - 1); - } - - ByteList buf = new ByteList((int)len); - for (int i = begin; i < begin + realLength; i++) { - IRubyObject tmp; - try { - tmp = values[i]; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - return runtime.newString(""); - } - if (tmp instanceof RubyString) { - // do nothing - } else if (tmp instanceof RubyArray) { - if (runtime.isInspecting(tmp)) { - tmp = runtime.newString("[...]"); - } else { - tmp = inspectJoin(context, (RubyArray)tmp, sep); - } - } else { - tmp = RubyString.objAsString(context, tmp); - } - - if (i > begin && !sep.isNil()) buf.append(strSep.getByteList()); - - buf.append(tmp.asString().getByteList()); - if (tmp.isTaint()) taint = true; - } - - RubyString result = runtime.newString(buf); - - if (taint) result.setTaint(true); - - return result; - } - - /** rb_ary_join_m - * - */ - @JRubyMethod(name = "join", optional = 1) - public RubyString join_m(ThreadContext context, IRubyObject[] args) { - int argc = args.length; - IRubyObject sep = (argc == 1) ? args[0] : getRuntime().getGlobalVariables().get("$,"); - - return join(context, sep); - } - - /** rb_ary_to_a - * - */ - @JRubyMethod(name = "to_a") - @Override - public RubyArray to_a() { - if(getMetaClass() != getRuntime().getArray()) { - RubyArray dup = new RubyArray(getRuntime(), getRuntime().isObjectSpaceEnabled()); - - isShared = true; - dup.isShared = true; - dup.values = values; - dup.realLength = realLength; - dup.begin = begin; - - return dup; - } - return this; - } - - @JRubyMethod(name = "to_ary") - public IRubyObject to_ary() { - return this; - } - - @Override - public RubyArray convertToArray() { - return this; - } - - @Override - public IRubyObject checkArrayType(){ - return this; - } - - /** rb_ary_equal - * - */ - @JRubyMethod(name = "==", required = 1) - @Override - public IRubyObject op_equal(ThreadContext context, IRubyObject obj) { - if (this == obj) return getRuntime().getTrue(); - - if (!(obj instanceof RubyArray)) { - if (!obj.respondsTo("to_ary")) { - return getRuntime().getFalse(); - } else { - if (equalInternal(context, obj.callMethod(context, "to_ary"), this)) return getRuntime().getTrue(); - return getRuntime().getFalse(); - } - } - - RubyArray ary = (RubyArray) obj; - if (realLength != ary.realLength) return getRuntime().getFalse(); - - Ruby runtime = getRuntime(); - for (long i = 0; i < realLength; i++) { - if (!equalInternal(context, elt(i), ary.elt(i))) return runtime.getFalse(); - } - return runtime.getTrue(); - } - - /** rb_ary_eql - * - */ - @JRubyMethod(name = "eql?", required = 1) - public RubyBoolean eql_p(ThreadContext context, IRubyObject obj) { - if (this == obj) return getRuntime().getTrue(); - if (!(obj instanceof RubyArray)) return getRuntime().getFalse(); - - RubyArray ary = (RubyArray) obj; - - if (realLength != ary.realLength) return getRuntime().getFalse(); - - Ruby runtime = getRuntime(); - for (int i = 0; i < realLength; i++) { - if (!eqlInternal(context, elt(i), ary.elt(i))) return runtime.getFalse(); - } - return runtime.getTrue(); - } - - /** rb_ary_compact_bang - * - */ - @JRubyMethod(name = "compact!") - public IRubyObject compact_bang() { - modify(); - - int p = 0; - int t = 0; - int end = p + realLength; - - while (t < end) { - if (values[t].isNil()) { - t++; - } else { - values[p++] = values[t++]; - } - } - - if (realLength == p) return getRuntime().getNil(); - - realloc(p); - realLength = p; - return this; - } - - /** rb_ary_compact - * - */ - @JRubyMethod(name = "compact") - public IRubyObject compact() { - RubyArray ary = aryDup(); - ary.compact_bang(); - return ary; - } - - /** rb_ary_empty_p - * - */ - @JRubyMethod(name = "empty?") - public IRubyObject empty_p() { - return realLength == 0 ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - /** rb_ary_clear - * - */ - @JRubyMethod(name = "clear") - public IRubyObject rb_clear() { - modifyCheck(); - - if(isShared) { - alloc(ARRAY_DEFAULT_SIZE); - isShared = true; - } else if (values.length > ARRAY_DEFAULT_SIZE << 1){ - alloc(ARRAY_DEFAULT_SIZE << 1); - } else { - final int begin = this.begin; - try { - Arrays.fill(values, begin, begin + realLength, getRuntime().getNil()); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - } - - begin = 0; - realLength = 0; - return this; - } - - /** rb_ary_fill - * - */ - @JRubyMethod(name = "fill", optional = 3, frame = true) - public IRubyObject fill(ThreadContext context, IRubyObject[] args, Block block) { - IRubyObject item = null; - IRubyObject begObj = null; - IRubyObject lenObj = null; - int argc = args.length; - - if (block.isGiven()) { - Arity.checkArgumentCount(getRuntime(), args, 0, 2); - item = null; - begObj = argc > 0 ? args[0] : null; - lenObj = argc > 1 ? args[1] : null; - argc++; - } else { - Arity.checkArgumentCount(getRuntime(), args, 1, 3); - item = args[0]; - begObj = argc > 1 ? args[1] : null; - lenObj = argc > 2 ? args[2] : null; - } - - int beg = 0, end = 0, len = 0; - switch (argc) { - case 1: - beg = 0; - len = realLength; - break; - case 2: - if (begObj instanceof RubyRange) { - long[] beglen = ((RubyRange) begObj).begLen(realLength, 1); - beg = (int) beglen[0]; - len = (int) beglen[1]; - break; - } - /* fall through */ - case 3: - beg = begObj.isNil() ? 0 : RubyNumeric.num2int(begObj); - if (beg < 0) { - beg = realLength + beg; - if (beg < 0) beg = 0; - } - len = (lenObj == null || lenObj.isNil()) ? realLength - beg : RubyNumeric.num2int(lenObj); - // TODO: In MRI 1.9, an explicit check for negative length is - // added here. IndexError is raised when length is negative. - // See [ruby-core:12953] for more details. - // - // New note: This is actually under re-evaluation, - // see [ruby-core:17483]. - break; - } - - modify(); - - // See [ruby-core:17483] - if (len < 0) { - return this; - } - - if (len > Integer.MAX_VALUE - beg) { - throw getRuntime().newArgumentError("argument too big"); - } - - end = beg + len; - if (end > realLength) { - if (end >= values.length) realloc(end); - - realLength = end; - } - - if (block.isGiven()) { - Ruby runtime = getRuntime(); - for (int i = beg; i < end; i++) { - IRubyObject v = block.yield(context, runtime.newFixnum(i)); - if (i >= realLength) break; - try { - values[i] = v; - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - } - } else { - if (len > 0) { - try { - Arrays.fill(values, beg, beg + len, item); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - } - } - - return this; - } - - /** rb_ary_index - * - */ - @JRubyMethod(name = "index", required = 1) - public IRubyObject index(ThreadContext context, IRubyObject obj) { - Ruby runtime = getRuntime(); - for (int i = begin; i < begin + realLength; i++) { - if (equalInternal(context, values[i], obj)) return runtime.newFixnum(i - begin); - } - - return runtime.getNil(); - } - - /** rb_ary_rindex - * - */ - @JRubyMethod(name = "rindex", required = 1) - public IRubyObject rindex(ThreadContext context, IRubyObject obj) { - Ruby runtime = getRuntime(); - int i = realLength; - - while (i-- > 0) { - if (i > realLength) { - i = realLength; - continue; - } - if (equalInternal(context, values[begin + i], obj)) return getRuntime().newFixnum(i); - } - - return runtime.getNil(); - } - - /** rb_ary_indexes - * - */ - @JRubyMethod(name = {"indexes", "indices"}, required = 1, rest = true) - public IRubyObject indexes(IRubyObject[] args) { - getRuntime().getWarnings().warn(ID.DEPRECATED_METHOD, "Array#indexes is deprecated; use Array#values_at", "Array#indexes", "Array#values_at"); - - RubyArray ary = new RubyArray(getRuntime(), args.length); - - IRubyObject[] arefArgs = new IRubyObject[1]; - for (int i = 0; i < args.length; i++) { - arefArgs[0] = args[i]; - ary.append(aref(arefArgs)); - } - - return ary; - } - - /** rb_ary_reverse_bang - * - */ - @JRubyMethod(name = "reverse!") - public IRubyObject reverse_bang() { - modify(); - - final int realLength = this.realLength; - final IRubyObject[] values = this.values; - try { - if (realLength > 1) { - int p1 = 0; - int p2 = p1 + realLength - 1; - - while (p1 < p2) { - final IRubyObject tmp = values[p1]; - values[p1++] = values[p2]; - values[p2--] = tmp; - } - } - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - return this; - } - - /** rb_ary_reverse_m - * - */ - @JRubyMethod(name = "reverse") - public IRubyObject reverse() { - return aryDup().reverse_bang(); - } - - /** rb_ary_collect - * - */ - @JRubyMethod(name = {"collect", "map"}, frame = true) - public RubyArray collect(ThreadContext context, Block block) { - Ruby runtime = getRuntime(); - - if (!block.isGiven()) return new RubyArray(getRuntime(), runtime.getArray(), this); - - RubyArray collect = new RubyArray(runtime, realLength); - - for (int i = begin; i < begin + realLength; i++) { - collect.append(block.yield(context, values[i])); - } - - return collect; - } - - /** rb_ary_collect_bang - * - */ - @JRubyMethod(name = {"collect!", "map!"}, frame = true) - public RubyArray collect_bang(ThreadContext context, Block block) { - modify(); - for (int i = 0, len = realLength; i < len; i++) { - store(i, block.yield(context, values[begin + i])); - } - return this; - } - - /** rb_ary_select - * - */ - @JRubyMethod(name = "select", frame = true) - public RubyArray select(ThreadContext context, Block block) { - Ruby runtime = getRuntime(); - RubyArray result = new RubyArray(runtime, realLength); - - if (isShared) { - for (int i = begin; i < begin + realLength; i++) { - if (block.yield(context, values[i]).isTrue()) result.append(elt(i - begin)); - } - } else { - for (int i = 0; i < realLength; i++) { - if (block.yield(context, values[i]).isTrue()) result.append(elt(i)); - } - } - return result; - } - - /** rb_ary_delete - * - */ - @JRubyMethod(name = "delete", required = 1, frame = true) - public IRubyObject delete(ThreadContext context, IRubyObject item, Block block) { - int i2 = 0; - - Ruby runtime = getRuntime(); - for (int i1 = 0; i1 < realLength; i1++) { - IRubyObject e = values[begin + i1]; - if (equalInternal(context, e, item)) continue; - if (i1 != i2) store(i2, e); - i2++; - } - - if (realLength == i2) { - if (block.isGiven()) return block.yield(context, item); - - return runtime.getNil(); - } - - modify(); - - final int realLength = this.realLength; - final int begin = this.begin; - final IRubyObject[] values = this.values; - if (realLength > i2) { - try { - Arrays.fill(values, begin + i2, begin + realLength, getRuntime().getNil()); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - this.realLength = i2; - if (i2 << 1 < values.length && values.length > ARRAY_DEFAULT_SIZE) realloc(i2 << 1); - } - - return item; - } - - /** rb_ary_delete_at - * - */ - private final IRubyObject delete_at(int pos) { - int len = realLength; - - if (pos >= len) return getRuntime().getNil(); - - if (pos < 0) pos += len; - - if (pos < 0) return getRuntime().getNil(); - - modify(); - - IRubyObject obj = values[pos]; - try { - System.arraycopy(values, pos + 1, values, pos, len - (pos + 1)); - values[realLength-1] = getRuntime().getNil(); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - realLength--; - - return obj; - } - - /** rb_ary_delete_at_m - * - */ - @JRubyMethod(name = "delete_at", required = 1) - public IRubyObject delete_at(IRubyObject obj) { - return delete_at((int) RubyNumeric.num2long(obj)); - } - - /** rb_ary_reject_bang - * - */ - @JRubyMethod(name = "reject", frame = true) - public IRubyObject reject(ThreadContext context, Block block) { - RubyArray ary = aryDup(); - ary.reject_bang(context, block); - return ary; - } - - /** rb_ary_reject_bang - * - */ - @JRubyMethod(name = "reject!", frame = true) - public IRubyObject reject_bang(ThreadContext context, Block block) { - int i2 = 0; - modify(); - - for (int i1 = 0; i1 < realLength; i1++) { - IRubyObject v = values[i1]; - if (block.yield(context, v).isTrue()) continue; - - if (i1 != i2) store(i2, v); - i2++; - } - if (realLength == i2) return getRuntime().getNil(); - - if (i2 < realLength) { - try { - Arrays.fill(values, i2, realLength, getRuntime().getNil()); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - realLength = i2; - } - - return this; - } - - /** rb_ary_delete_if - * - */ - @JRubyMethod(name = "delete_if", frame = true) - public IRubyObject delete_if(ThreadContext context, Block block) { - reject_bang(context, block); - return this; - } - - /** rb_ary_zip - * - */ - @JRubyMethod(name = "zip", optional = 1, rest = true, frame = true) - public IRubyObject zip(ThreadContext context, IRubyObject[] args, Block block) { - for (int i = 0; i < args.length; i++) { - args[i] = args[i].convertToArray(); - } - - Ruby runtime = getRuntime(); - if (block.isGiven()) { - for (int i = 0; i < realLength; i++) { - RubyArray tmp = new RubyArray(runtime, args.length + 1); - tmp.append(elt(i)); - for (int j = 0; j < args.length; j++) { - tmp.append(((RubyArray) args[j]).elt(i)); - } - block.yield(context, tmp); - } - return runtime.getNil(); - } - - int len = realLength; - RubyArray result = new RubyArray(runtime, len); - for (int i = 0; i < len; i++) { - RubyArray tmp = new RubyArray(runtime, args.length + 1); - tmp.append(elt(i)); - for (int j = 0; j < args.length; j++) { - tmp.append(((RubyArray) args[j]).elt(i)); - } - result.append(tmp); - } - return result; - } - - /** rb_ary_cmp - * - */ - @JRubyMethod(name = "<=>", required = 1) - public IRubyObject op_cmp(ThreadContext context, IRubyObject obj) { - RubyArray ary2 = obj.convertToArray(); - - int len = realLength; - - if (len > ary2.realLength) len = ary2.realLength; - - Ruby runtime = getRuntime(); - for (int i = 0; i < len; i++) { - IRubyObject v = elt(i).callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", ary2.elt(i)); - if (!(v instanceof RubyFixnum) || ((RubyFixnum) v).getLongValue() != 0) return v; - } - len = realLength - ary2.realLength; - - if (len == 0) return RubyFixnum.zero(runtime); - if (len > 0) return RubyFixnum.one(runtime); - - return RubyFixnum.minus_one(runtime); - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public IRubyObject slice_bang(IRubyObject[] args) { - switch (args.length) { - case 1: - return slice_bang(args[0]); - case 2: - return slice_bang(args[0], args[1]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_ary_slice_bang - * - */ - @JRubyMethod(name = "slice!") - public IRubyObject slice_bang(IRubyObject arg0) { - if (arg0 instanceof RubyRange) { - long[] beglen = ((RubyRange) arg0).begLen(realLength, 1); - long pos = beglen[0]; - long len = beglen[1]; - - if (pos < 0) pos = realLength + pos; - - arg0 = subseq(pos, len); - splice(pos, len, null); - return arg0; - } - return delete_at((int) RubyNumeric.num2long(arg0)); - } - - /** rb_ary_slice_bang - * - */ - @JRubyMethod(name = "slice!") - public IRubyObject slice_bang(IRubyObject arg0, IRubyObject arg1) { - long pos = RubyNumeric.num2long(arg0); - long len = RubyNumeric.num2long(arg1); - - if (pos < 0) pos = realLength + pos; - - arg1 = subseq(pos, len); - splice(pos, len, null); - - return arg1; - } - - /** rb_ary_assoc - * - */ - @JRubyMethod(name = "assoc", required = 1) - public IRubyObject assoc(ThreadContext context, IRubyObject key) { - Ruby runtime = getRuntime(); - - for (int i = begin; i < begin + realLength; i++) { - IRubyObject v = values[i]; - if (v instanceof RubyArray) { - RubyArray arr = (RubyArray)v; - if (arr.realLength > 0 && equalInternal(context, arr.values[arr.begin], key)) return arr; - } - } - - return runtime.getNil(); - } - - /** rb_ary_rassoc - * - */ - @JRubyMethod(name = "rassoc", required = 1) - public IRubyObject rassoc(ThreadContext context, IRubyObject value) { - Ruby runtime = getRuntime(); - - for (int i = begin; i < begin + realLength; i++) { - IRubyObject v = values[i]; - if (v instanceof RubyArray) { - RubyArray arr = (RubyArray)v; - if (arr.realLength > 1 && equalInternal(context, arr.values[arr.begin + 1], value)) return arr; - } - } - - return runtime.getNil(); - } - - /** flatten - * - */ - private final int flatten(ThreadContext context, int index, RubyArray ary2, RubyArray memo) { - int i = index; - int n; - int lim = index + ary2.realLength; - - IRubyObject id = ary2.id(); - - if (memo.includes(context, id)) throw getRuntime().newArgumentError("tried to flatten recursive array"); - - memo.append(id); - splice(index, 1, ary2); - while (i < lim) { - IRubyObject tmp = elt(i).checkArrayType(); - if (!tmp.isNil()) { - n = flatten(context, i, (RubyArray) tmp, memo); - i += n; - lim += n; - } - i++; - } - memo.pop(); - return lim - index - 1; /* returns number of increased items */ - } - - /** rb_ary_flatten_bang - * - */ - @JRubyMethod(name = "flatten!") - public IRubyObject flatten_bang(ThreadContext context) { - int i = 0; - RubyArray memo = null; - - while (i < realLength) { - IRubyObject ary2 = values[begin + i]; - IRubyObject tmp = ary2.checkArrayType(); - if (!tmp.isNil()) { - if (memo == null) { - memo = new RubyArray(getRuntime(), false); - memo.values = reserve(ARRAY_DEFAULT_SIZE); - } - - i += flatten(context, i, (RubyArray) tmp, memo); - } - i++; - } - if (memo == null) return getRuntime().getNil(); - - return this; - } - - /** rb_ary_flatten - * - */ - @JRubyMethod(name = "flatten") - public IRubyObject flatten(ThreadContext context) { - RubyArray ary = aryDup(); - ary.flatten_bang(context); - return ary; - } - - /** rb_ary_nitems - * - */ - @JRubyMethod(name = "nitems") - public IRubyObject nitems() { - int n = 0; - - for (int i = begin; i < begin + realLength; i++) { - if (!values[i].isNil()) n++; - } - - return getRuntime().newFixnum(n); - } - - /** rb_ary_plus - * - */ - @JRubyMethod(name = "+", required = 1) - public IRubyObject op_plus(IRubyObject obj) { - RubyArray y = obj.convertToArray(); - int len = realLength + y.realLength; - RubyArray z = new RubyArray(getRuntime(), len); - try { - System.arraycopy(values, begin, z.values, 0, realLength); - System.arraycopy(y.values, y.begin, z.values, realLength, y.realLength); - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - z.realLength = len; - return z; - } - - /** rb_ary_times - * - */ - @JRubyMethod(name = "*", required = 1) - public IRubyObject op_times(ThreadContext context, IRubyObject times) { - IRubyObject tmp = times.checkStringType(); - - if (!tmp.isNil()) return join(context, tmp); - - long len = RubyNumeric.num2long(times); - if (len == 0) return new RubyArray(getRuntime(), getMetaClass(), 0); - if (len < 0) throw getRuntime().newArgumentError("negative argument"); - - if (Long.MAX_VALUE / len < realLength) { - throw getRuntime().newArgumentError("argument too big"); - } - - len *= realLength; - - RubyArray ary2 = new RubyArray(getRuntime(), getMetaClass(), len); - ary2.realLength = (int) len; - - try { - for (int i = 0; i < len; i += realLength) { - System.arraycopy(values, begin, ary2.values, i, realLength); - } - } catch (ArrayIndexOutOfBoundsException e) { - concurrentModification(); - } - - ary2.infectBy(this); - - return ary2; - } - - /** ary_make_hash - * - */ - private final RubyHash makeHash(RubyArray ary2) { - RubyHash hash = new RubyHash(getRuntime(), false); - int begin = this.begin; - for (int i = begin; i < begin + realLength; i++) { - hash.fastASet(values[i], NEVER); - } - - if (ary2 != null) { - begin = ary2.begin; - for (int i = begin; i < begin + ary2.realLength; i++) { - hash.fastASet(ary2.values[i], NEVER); - } - } - return hash; - } - - /** rb_ary_uniq_bang - * - */ - @JRubyMethod(name = "uniq!") - public IRubyObject uniq_bang() { - RubyHash hash = makeHash(null); - - if (realLength == hash.size()) return getRuntime().getNil(); - - int j = 0; - for (int i = 0; i < realLength; i++) { - IRubyObject v = elt(i); - if (hash.fastDelete(v)) store(j++, v); - } - realLength = j; - return this; - } - - /** rb_ary_uniq - * - */ - @JRubyMethod(name = "uniq") - public IRubyObject uniq() { - RubyArray ary = aryDup(); - ary.uniq_bang(); - return ary; - } - - /** rb_ary_diff - * - */ - @JRubyMethod(name = "-", required = 1) - public IRubyObject op_diff(IRubyObject other) { - RubyHash hash = other.convertToArray().makeHash(null); - RubyArray ary3 = new RubyArray(getRuntime()); - - int begin = this.begin; - for (int i = begin; i < begin + realLength; i++) { - if (hash.fastARef(values[i]) != null) continue; - ary3.append(elt(i - begin)); - } - - return ary3; - } - - /** rb_ary_and - * - */ - @JRubyMethod(name = "&", required = 1) - public IRubyObject op_and(IRubyObject other) { - RubyArray ary2 = other.convertToArray(); - RubyHash hash = ary2.makeHash(null); - RubyArray ary3 = new RubyArray(getRuntime(), - realLength < ary2.realLength ? realLength : ary2.realLength); - - for (int i = 0; i < realLength; i++) { - IRubyObject v = elt(i); - if (hash.fastDelete(v)) ary3.append(v); - } - - return ary3; - } - - /** rb_ary_or - * - */ - @JRubyMethod(name = "|", required = 1) - public IRubyObject op_or(IRubyObject other) { - RubyArray ary2 = other.convertToArray(); - RubyHash set = makeHash(ary2); - - RubyArray ary3 = new RubyArray(getRuntime(), realLength + ary2.realLength); - - for (int i = 0; i < realLength; i++) { - IRubyObject v = elt(i); - if (set.fastDelete(v)) ary3.append(v); - } - for (int i = 0; i < ary2.realLength; i++) { - IRubyObject v = ary2.elt(i); - if (set.fastDelete(v)) ary3.append(v); - } - return ary3; - } - - /** rb_ary_sort - * - */ - @JRubyMethod(name = "sort", frame = true) - public RubyArray sort(Block block) { - RubyArray ary = aryDup(); - ary.sort_bang(block); - return ary; - } - - /** rb_ary_sort_bang - * - */ - @JRubyMethod(name = "sort!", frame = true) - public RubyArray sort_bang(Block block) { - modify(); - if (realLength > 1) { - flags |= TMPLOCK_ARR_F; - try { - if (block.isGiven()) { - Arrays.sort(values, 0, realLength, new BlockComparator(block)); - } else { - Arrays.sort(values, 0, realLength, new DefaultComparator()); - } - } finally { - flags &= ~TMPLOCK_ARR_F; - } - } - return this; - } - - final class BlockComparator implements Comparator { - private Block block; - - public BlockComparator(Block block) { - this.block = block; - } - - public int compare(Object o1, Object o2) { - ThreadContext context = getRuntime().getCurrentContext(); - IRubyObject obj1 = (IRubyObject) o1; - IRubyObject obj2 = (IRubyObject) o2; - IRubyObject ret = block.yield(context, getRuntime().newArray(obj1, obj2), null, null, true); - int n = RubyComparable.cmpint(context, ret, obj1, obj2); - //TODO: ary_sort_check should be done here - return n; - } - } - - static final class DefaultComparator implements Comparator { - public int compare(Object o1, Object o2) { - if (o1 instanceof RubyFixnum && o2 instanceof RubyFixnum) { - return compareFixnums(o1, o2); - } - if (o1 instanceof RubyString && o2 instanceof RubyString) { - return ((RubyString) o1).op_cmp((RubyString) o2); - } - //TODO: ary_sort_check should be done here - return compareOthers((IRubyObject)o1, (IRubyObject)o2); - } - - private int compareFixnums(Object o1, Object o2) { - long a = ((RubyFixnum) o1).getLongValue(); - long b = ((RubyFixnum) o2).getLongValue(); - if (a > b) { - return 1; - } - if (a < b) { - return -1; - } - return 0; - } - - private int compareOthers(IRubyObject o1, IRubyObject o2) { - ThreadContext context = o1.getRuntime().getCurrentContext(); - IRubyObject ret = o1.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", o2); - int n = RubyComparable.cmpint(context, ret, o1, o2); - //TODO: ary_sort_check should be done here - return n; - } - } - - public static void marshalTo(RubyArray array, MarshalStream output) throws IOException { - output.registerLinkTarget(array); - output.writeInt(array.getList().size()); - for (Iterator iter = array.getList().iterator(); iter.hasNext();) { - output.dumpObject((IRubyObject) iter.next()); - } - } - - public static RubyArray unmarshalFrom(UnmarshalStream input) throws IOException { - RubyArray result = input.getRuntime().newArray(); - input.registerLinkTarget(result); - int size = input.unmarshalInt(); - for (int i = 0; i < size; i++) { - result.append(input.unmarshalObject()); - } - return result; - } - - /** - * @see org.jruby.util.Pack#pack - */ - @JRubyMethod(name = "pack", required = 1) - public RubyString pack(ThreadContext context, IRubyObject obj) { - RubyString iFmt = RubyString.objAsString(context, obj); - return Pack.pack(getRuntime(), this, iFmt.getByteList()); - } - - @Override - public Class getJavaClass() { - return List.class; - } - - // Satisfy java.util.List interface (for Java integration) - public int size() { - return realLength; - } - - public boolean isEmpty() { - return realLength == 0; - } - - public boolean contains(Object element) { - return indexOf(element) != -1; - } - - public Object[] toArray() { - Object[] array = new Object[realLength]; - for (int i = begin; i < realLength; i++) { - array[i - begin] = JavaUtil.convertRubyToJava(values[i]); - } - return array; - } - - public Object[] toArray(final Object[] arg) { - Object[] array = arg; - if (array.length < realLength) { - Class type = array.getClass().getComponentType(); - array = (Object[]) Array.newInstance(type, realLength); - } - int length = realLength - begin; - - for (int i = 0; i < length; i++) { - array[i] = JavaUtil.convertRubyToJava(values[i + begin]); - } - return array; - } - - public boolean add(Object element) { - append(JavaUtil.convertJavaToRuby(getRuntime(), element)); - return true; - } - - public boolean remove(Object element) { - IRubyObject deleted = delete(getRuntime().getCurrentContext(), JavaUtil.convertJavaToRuby(getRuntime(), element), Block.NULL_BLOCK); - return deleted.isNil() ? false : true; // TODO: is this correct ? - } - - public boolean containsAll(Collection c) { - for (Iterator iter = c.iterator(); iter.hasNext();) { - if (indexOf(iter.next()) == -1) { - return false; - } - } - - return true; - } - - public boolean addAll(Collection c) { - for (Iterator iter = c.iterator(); iter.hasNext();) { - add(iter.next()); - } - return !c.isEmpty(); - } - - public boolean addAll(int index, Collection c) { - Iterator iter = c.iterator(); - for (int i = index; iter.hasNext(); i++) { - add(i, iter.next()); - } - return !c.isEmpty(); - } - - public boolean removeAll(Collection c) { - boolean listChanged = false; - for (Iterator iter = c.iterator(); iter.hasNext();) { - if (remove(iter.next())) { - listChanged = true; - } - } - return listChanged; - } - - public boolean retainAll(Collection c) { - boolean listChanged = false; - - for (Iterator iter = iterator(); iter.hasNext();) { - Object element = iter.next(); - if (!c.contains(element)) { - remove(element); - listChanged = true; - } - } - return listChanged; - } - - public Object get(int index) { - return JavaUtil.convertRubyToJava((IRubyObject) elt(index), Object.class); - } - - public Object set(int index, Object element) { - return store(index, JavaUtil.convertJavaToRuby(getRuntime(), element)); - } - - // TODO: make more efficient by not creating IRubyArray[] - public void add(int index, Object element) { - insert(new IRubyObject[]{RubyFixnum.newFixnum(getRuntime(), index), JavaUtil.convertJavaToRuby(getRuntime(), element)}); - } - - public Object remove(int index) { - return JavaUtil.convertRubyToJava(delete_at(index), Object.class); - } - - public int indexOf(Object element) { - int begin = this.begin; - - if (element != null) { - IRubyObject convertedElement = JavaUtil.convertJavaToRuby(getRuntime(), element); - - for (int i = begin; i < begin + realLength; i++) { - if (convertedElement.equals(values[i])) { - return i; - } - } - } - return -1; - } - - public int lastIndexOf(Object element) { - int begin = this.begin; - - if (element != null) { - IRubyObject convertedElement = JavaUtil.convertJavaToRuby(getRuntime(), element); - - for (int i = begin + realLength - 1; i >= begin; i--) { - if (convertedElement.equals(values[i])) { - return i; - } - } - } - - return -1; - } - - public class RubyArrayConversionIterator implements Iterator { - protected int index = 0; - protected int last = -1; - - public boolean hasNext() { - return index < realLength; - } - - public Object next() { - IRubyObject element = elt(index); - last = index++; - return JavaUtil.convertRubyToJava(element, Object.class); - } - - public void remove() { - if (last == -1) throw new IllegalStateException(); - - delete_at(last); - if (last < index) index--; - - last = -1; - - } - } - - public Iterator iterator() { - return new RubyArrayConversionIterator(); - } - - final class RubyArrayConversionListIterator extends RubyArrayConversionIterator implements ListIterator { - public RubyArrayConversionListIterator() { - } - - public RubyArrayConversionListIterator(int index) { - this.index = index; - } - - public boolean hasPrevious() { - return index >= 0; - } - - public Object previous() { - return JavaUtil.convertRubyToJava((IRubyObject) elt(last = --index), Object.class); - } - - public int nextIndex() { - return index; - } - - public int previousIndex() { - return index - 1; - } - - public void set(Object obj) { - if (last == -1) throw new IllegalStateException(); - - store(last, JavaUtil.convertJavaToRuby(getRuntime(), obj)); - } - - public void add(Object obj) { - insert(new IRubyObject[] { RubyFixnum.newFixnum(getRuntime(), index++), JavaUtil.convertJavaToRuby(getRuntime(), obj) }); - last = -1; - } - } - - public ListIterator listIterator() { - return new RubyArrayConversionListIterator(); - } - - public ListIterator listIterator(int index) { - return new RubyArrayConversionListIterator(index); - } - - // TODO: list.subList(from, to).clear() is supposed to clear the sublist from the list. - // How can we support this operation? - public List subList(int fromIndex, int toIndex) { - if (fromIndex < 0 || toIndex > size() || fromIndex > toIndex) { - throw new IndexOutOfBoundsException(); - } - - IRubyObject subList = subseq(fromIndex, toIndex - fromIndex + 1); - - return subList.isNil() ? null : (List) subList; - } - - public void clear() { - rb_clear(); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.math.BigDecimal; -import java.math.BigInteger; -import java.math.MathContext; -import java.math.RoundingMode; -import java.util.ArrayList; -import java.util.List; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyConstant; -import org.jruby.anno.JRubyMethod; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallbackFactory; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -@JRubyClass(name="BigDecimal", parent="Numeric") -public class RubyBigDecimal extends RubyNumeric { - private static final ObjectAllocator BIGDECIMAL_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyBigDecimal(runtime, klass); - } - }; - - @JRubyConstant - public final static int ROUND_DOWN = BigDecimal.ROUND_DOWN; - @JRubyConstant - public final static int ROUND_CEILING = BigDecimal.ROUND_CEILING; - @JRubyConstant - public final static int ROUND_UP = BigDecimal.ROUND_UP; - @JRubyConstant - public final static int ROUND_HALF_DOWN = BigDecimal.ROUND_HALF_DOWN; - @JRubyConstant - public final static int ROUND_HALF_EVEN = BigDecimal.ROUND_HALF_EVEN; - @JRubyConstant - public final static int ROUND_HALF_UP = BigDecimal.ROUND_HALF_UP; - @JRubyConstant - public final static int ROUND_FLOOR = BigDecimal.ROUND_FLOOR; - - @JRubyConstant - public final static int SIGN_POSITIVE_INFINITE=3; - @JRubyConstant - public final static int EXCEPTION_OVERFLOW=1; - @JRubyConstant - public final static int SIGN_POSITIVE_ZERO=1; - @JRubyConstant - public final static int EXCEPTION_ALL=255; - @JRubyConstant - public final static int SIGN_NEGATIVE_FINITE=-2; - @JRubyConstant - public final static int EXCEPTION_UNDERFLOW=4; - @JRubyConstant - public final static int SIGN_NaN=0; - @JRubyConstant - public final static int BASE=10000; - @JRubyConstant - public final static int ROUND_MODE=256; - @JRubyConstant - public final static int SIGN_POSITIVE_FINITE=2; - @JRubyConstant - public final static int EXCEPTION_INFINITY=1; - @JRubyConstant - public final static int SIGN_NEGATIVE_INFINITE=-3; - @JRubyConstant - public final static int EXCEPTION_ZERODIVIDE=1; - @JRubyConstant - public final static int SIGN_NEGATIVE_ZERO=-1; - @JRubyConstant - public final static int EXCEPTION_NaN=2; - - // Static constants - private static final BigDecimal TWO = new BigDecimal(2); - private static final double SQRT_10 = 3.162277660168379332; - - public static RubyClass createBigDecimal(Ruby runtime) { - RubyClass result = runtime.defineClass("BigDecimal",runtime.getNumeric(), BIGDECIMAL_ALLOCATOR); - - CallbackFactory callbackFactory = runtime.callbackFactory(RubyBigDecimal.class); - - runtime.getKernel().defineAnnotatedMethods(BigDecimalKernelMethods.class); - - result.setInternalModuleVariable("vpPrecLimit", RubyFixnum.zero(runtime)); - result.setInternalModuleVariable("vpExceptionMode", RubyFixnum.zero(runtime)); - result.setInternalModuleVariable("vpRoundingMode", runtime.newFixnum(ROUND_HALF_UP)); - - result.defineAnnotatedMethods(RubyBigDecimal.class); - result.defineAnnotatedConstants(RubyBigDecimal.class); - - return result; - } - - private boolean isNaN = false; - private int infinitySign = 0; - private int zeroSign = 0; - private BigDecimal value; - - public BigDecimal getValue() { - return value; - } - - public RubyBigDecimal(Ruby runtime, RubyClass klass) { - super(runtime, klass); - } - - public RubyBigDecimal(Ruby runtime, BigDecimal value) { - super(runtime, runtime.fastGetClass("BigDecimal")); - this.value = value; - } - - public static class BigDecimalKernelMethods { - @JRubyMethod(name = "BigDecimal", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject newBigDecimal(IRubyObject recv, IRubyObject[] args) { - return RubyBigDecimal.newBigDecimal(recv, args, Block.NULL_BLOCK); - } - } - - public static RubyBigDecimal newBigDecimal(IRubyObject recv, IRubyObject[] args, Block unusedBlock) { - return newInstance(recv.getRuntime().fastGetClass("BigDecimal"), args); - } - - @JRubyMethod(name = "ver", meta = true) - public static IRubyObject ver(IRubyObject recv) { - return recv.getRuntime().newString("1.0.1"); - } - - @JRubyMethod(name = "_dump", optional = 1, frame = true) - public IRubyObject dump(IRubyObject[] args, Block unusedBlock) { - RubyString precision = RubyString.newUnicodeString(args[0].getRuntime(), "0:"); - RubyString str = this.asString(); - return precision.append(str); - } - - @JRubyMethod(name = "_load", required = 1, frame = true, meta = true) - public static RubyBigDecimal load(IRubyObject recv, IRubyObject from, Block block) { - RubyBigDecimal rubyBigDecimal = (RubyBigDecimal) (((RubyClass)recv).allocate()); - String precisionAndValue = from.convertToString().asJavaString(); - String value = precisionAndValue.substring(precisionAndValue.indexOf(":")+1); - rubyBigDecimal.value = new BigDecimal(value); - return rubyBigDecimal; - } - - @JRubyMethod(name = "double_fig", meta = true) - public static IRubyObject double_fig(IRubyObject recv) { - return recv.getRuntime().newFixnum(20); - } - - @JRubyMethod(name = "limit", optional = 1, meta = true) - public static IRubyObject limit(IRubyObject recv, IRubyObject[] args) { - Ruby runtime = recv.getRuntime(); - RubyModule c = (RubyModule)recv; - IRubyObject nCur = c.searchInternalModuleVariable("vpPrecLimit"); - - if (args.length > 0) { - IRubyObject arg = args[0]; - if (!arg.isNil()) { - if (!(arg instanceof RubyFixnum)) { - throw runtime.newTypeError(arg, runtime.getFixnum()); - } - if (0 > ((RubyFixnum)arg).getLongValue()) { - throw runtime.newArgumentError("argument must be positive"); - } - c.setInternalModuleVariable("vpPrecLimit", arg); - } - } - - return nCur; - } - - @JRubyMethod(name = "mode", required = 1, optional = 1, meta = true) - public static IRubyObject mode(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - // FIXME: I doubt any of the constants referenced in this method - // are ever redefined -- should compare to the known values, rather - // than do an expensive constant lookup. - Ruby runtime = recv.getRuntime(); - RubyClass clazz = runtime.fastGetClass("BigDecimal"); - RubyModule c = (RubyModule)recv; - - args = Arity.scanArgs(runtime, args, 1, 1); - - IRubyObject mode = args[0]; - IRubyObject value = args[1]; - - if (!(mode instanceof RubyFixnum)) { - throw runtime.newTypeError("wrong argument type " + mode.getMetaClass() + " (expected Fixnum)"); - } - - long longMode = ((RubyFixnum)mode).getLongValue(); - long EXCEPTION_ALL = ((RubyFixnum)clazz.fastGetConstant("EXCEPTION_ALL")).getLongValue(); - if ((longMode & EXCEPTION_ALL) != 0) { - if (value.isNil()) { - return c.searchInternalModuleVariable("vpExceptionMode"); - } - if (!(value.isNil()) && !(value instanceof RubyBoolean)) { - throw runtime.newTypeError("second argument must be true or false"); - } - - RubyFixnum currentExceptionMode = (RubyFixnum)c.searchInternalModuleVariable("vpExceptionMode"); - RubyFixnum newExceptionMode = new RubyFixnum(runtime, currentExceptionMode.getLongValue()); - - RubyFixnum EXCEPTION_INFINITY = (RubyFixnum)clazz.fastGetConstant("EXCEPTION_INFINITY"); - if ((longMode & EXCEPTION_INFINITY.getLongValue()) != 0) { - newExceptionMode = (value.isTrue()) ? (RubyFixnum)currentExceptionMode.callCoerced(context, "|", EXCEPTION_INFINITY) - : (RubyFixnum)currentExceptionMode.callCoerced(context, "&", new RubyFixnum(runtime, ~(EXCEPTION_INFINITY).getLongValue())); - } - - RubyFixnum EXCEPTION_NaN = (RubyFixnum)clazz.fastGetConstant("EXCEPTION_NaN"); - if ((longMode & EXCEPTION_NaN.getLongValue()) != 0) { - newExceptionMode = (value.isTrue()) ? (RubyFixnum)currentExceptionMode.callCoerced(context, "|", EXCEPTION_NaN) - : (RubyFixnum)currentExceptionMode.callCoerced(context, "&", new RubyFixnum(runtime, ~(EXCEPTION_NaN).getLongValue())); - } - c.setInternalModuleVariable("vpExceptionMode", newExceptionMode); - return newExceptionMode; - } - - long ROUND_MODE = ((RubyFixnum)clazz.fastGetConstant("ROUND_MODE")).getLongValue(); - if (longMode == ROUND_MODE) { - if (value.isNil()) { - return c.searchInternalModuleVariable("vpRoundingMode"); - } - if (!(value instanceof RubyFixnum)) { - throw runtime.newTypeError("wrong argument type " + mode.getMetaClass() + " (expected Fixnum)"); - } - - RubyFixnum roundingMode = (RubyFixnum)value; - if (roundingMode == clazz.fastGetConstant("ROUND_UP") || - roundingMode == clazz.fastGetConstant("ROUND_DOWN") || - roundingMode == clazz.fastGetConstant("ROUND_FLOOR") || - roundingMode == clazz.fastGetConstant("ROUND_CEILING") || - roundingMode == clazz.fastGetConstant("ROUND_HALF_UP") || - roundingMode == clazz.fastGetConstant("ROUND_HALF_DOWN") || - roundingMode == clazz.fastGetConstant("ROUND_HALF_EVEN")) { - c.setInternalModuleVariable("vpRoundingMode", roundingMode); - } else { - throw runtime.newTypeError("invalid rounding mode"); - } - return c.searchInternalModuleVariable("vpRoundingMode"); - } - throw runtime.newTypeError("first argument for BigDecimal#mode invalid"); - } - - private RoundingMode getRoundingMode(Ruby runtime) { - RubyFixnum roundingMode = (RubyFixnum)runtime.fastGetClass("BigDecimal") - .searchInternalModuleVariable("vpRoundingMode"); - return RoundingMode.valueOf((int)roundingMode.getLongValue()); - } - - private RubyBigDecimal getVpValue(IRubyObject v, boolean must) { - if(v instanceof RubyBigDecimal) { - return (RubyBigDecimal)v; - } else if(v instanceof RubyFixnum || v instanceof RubyBignum) { - String s = v.toString(); - return newInstance(getRuntime().fastGetClass("BigDecimal"),new IRubyObject[]{getRuntime().newString(s)}); - } - if(must) { - String err; - if (isImmediate()) { - ThreadContext context = getRuntime().getCurrentContext(); - err = inspect(context, this).toString(); - } else { - err = getMetaClass().getBaseName(); - } - throw getRuntime().newTypeError(err + " can't be coerced into BigDecimal"); - } - return null; - } - - private final static Pattern INFINITY_PATTERN = Pattern.compile("^([+-])?Infinity$"); - private final static Pattern NUMBER_PATTERN - = Pattern.compile("^([+-]?\\d*\\.?\\d*([eE][+-]?)?\\d*).*"); - - @JRubyMethod(name = "new", required = 1, optional = 1, meta = true) - public static RubyBigDecimal newInstance(IRubyObject recv, IRubyObject[] args) { - BigDecimal decimal; - if (args.length == 0) { - decimal = new BigDecimal(0); - } else { - String strValue = args[0].convertToString().toString(); - strValue = strValue.trim(); - if ("NaN".equals(strValue)) { - return newNaN(recv.getRuntime()); - } - - Matcher m = INFINITY_PATTERN.matcher(strValue); - if (m.matches()) { - int sign = 1; - String signGroup = m.group(1); - if ("-".equals(signGroup)) { - sign = -1; - } - return newInfinity(recv.getRuntime(), sign); - } - - // Clean-up string representation so that it could be understood - // by Java's BigDecimal. Not terribly efficient for now. - // 1. MRI allows d and D as exponent separators - strValue = strValue.replaceFirst("[dD]", "E"); - // 2. MRI allows underscores anywhere - strValue = strValue.replaceAll("_", ""); - // 3. MRI ignores the trailing junk - strValue = NUMBER_PATTERN.matcher(strValue).replaceFirst("$1"); - - try { - decimal = new BigDecimal(strValue); - } catch(NumberFormatException e) { - decimal = new BigDecimal(0); - } - if (decimal.signum() == 0) { - // MRI behavior: -0 and +0 are two different things - if (strValue.matches("^\\s*-.*")) { - return newZero(recv.getRuntime(), -1); - } else { - return newZero(recv.getRuntime(), 1); - } - } - } - return new RubyBigDecimal(recv.getRuntime(), decimal); - } - - private static RubyBigDecimal newZero(Ruby runtime, int sign) { - RubyBigDecimal rbd = new RubyBigDecimal(runtime, BigDecimal.ZERO); - if (sign < 0) { - rbd.zeroSign = -1; - } else { - rbd.zeroSign = 1; - } - return rbd; - } - - private static RubyBigDecimal newNaN(Ruby runtime) { - RubyBigDecimal rbd = new RubyBigDecimal(runtime, BigDecimal.ZERO); - rbd.isNaN = true; - return rbd; - } - - private static RubyBigDecimal newInfinity(Ruby runtime, int sign) { - RubyBigDecimal rbd = new RubyBigDecimal(runtime, BigDecimal.ZERO); - if (sign < 0) { - rbd.infinitySign = -1; - } else { - rbd.infinitySign = 1; - } - return rbd; - } - - private RubyBigDecimal setResult() { - return setResult(0); - } - - private RubyBigDecimal setResult(int scale) { - int prec = RubyFixnum.fix2int(getRuntime().fastGetClass("BigDecimal").searchInternalModuleVariable("vpPrecLimit")); - int prec2 = Math.max(scale,prec); - if(prec2 > 0 && this.value.scale() > (prec2-getExponent())) { - this.value = this.value.setScale(prec2-getExponent(),BigDecimal.ROUND_HALF_UP); - } - return this; - } - - @JRubyMethod(name = "hash") - public RubyFixnum hash() { - return getRuntime().newFixnum(value.hashCode()); - } - - @JRubyMethod(name = {"%", "modulo"}, required = 1) - public IRubyObject op_mod(ThreadContext context, IRubyObject arg) { - // TODO: full-precision remainder is 1000x slower than MRI! - Ruby runtime = context.getRuntime(); - if (isInfinity() || isNaN()) { - return newNaN(runtime); - } - RubyBigDecimal val = getVpValue(arg, false); - if (val == null) { - return callCoerced(context, "%", arg, true); - } - if (val.isInfinity() || val.isNaN() || val.isZero()) { - return newNaN(runtime); - } - - // Java and MRI definitions of modulo are different. - BigDecimal modulo = value.remainder(val.value); - if (modulo.signum() * val.value.signum() < 0) { - modulo = modulo.add(val.value); - } - - return new RubyBigDecimal(runtime, modulo).setResult(); - } - - @JRubyMethod(name = "remainder", required = 1) - public IRubyObject remainder(ThreadContext context, IRubyObject arg) { - // TODO: full-precision remainder is 1000x slower than MRI! - Ruby runtime = context.getRuntime(); - if (isInfinity() || isNaN()) { - return newNaN(runtime); - } - RubyBigDecimal val = getVpValue(arg,false); - if (val == null) { - return callCoerced(context, "remainder", arg, true); - } - if (val.isInfinity() || val.isNaN() || val.isZero()) { - return newNaN(runtime); - } - - // Java and MRI definitions of remainder are the same. - return new RubyBigDecimal(runtime, value.remainder(val.value)).setResult(); - } - - @JRubyMethod(name = "*", required = 1) - public IRubyObject op_mul(ThreadContext context, IRubyObject arg) { - return mult2(context, arg, RubyFixnum.zero(context.getRuntime())); - } - - @JRubyMethod(name = "mult", required = 2) - public IRubyObject mult2(ThreadContext context, IRubyObject b, IRubyObject n) { - Ruby runtime = context.getRuntime(); - - RubyBigDecimal val = getVpValue(b,false); - if(val == null) { - // TODO: what about n arg? - return callCoerced(context, "*", b); - } - - int digits = RubyNumeric.fix2int(n); - - if (isNaN() || val.isNaN()) { - return newNaN(runtime); - } - - if ((isInfinity() && val.isZero()) || (isZero() && val.isInfinity())) { - return newNaN(runtime); - } - - if (isZero() || val.isZero()) { - int sign1 = isZero()? zeroSign : value.signum(); - int sign2 = val.isZero() ? val.zeroSign : val.value.signum(); - return newZero(runtime, sign1 * sign2); - } - - if (isInfinity() || val.isInfinity()) { - int sign1 = isInfinity() ? infinitySign : value.signum(); - int sign2 = val.isInfinity() ? val.infinitySign : val.value.signum(); - return newInfinity(runtime, sign1 * sign2); - } - - BigDecimal res = value.multiply(val.value); - if (res.precision() > digits) { - // TODO: rounding mode should not be hard-coded. See #mode. - res = res.round(new MathContext(digits, RoundingMode.HALF_UP)); - } - return new RubyBigDecimal(runtime, res).setResult(); - } - - @JRubyMethod(name = {"**", "power"}, required = 1) - public IRubyObject op_pow(IRubyObject arg) { - if (!(arg instanceof RubyFixnum)) { - throw getRuntime().newTypeError("wrong argument type " + arg.getMetaClass() + " (expected Fixnum)"); - } - - if (isNaN() || isInfinity()) { - return newNaN(getRuntime()); - } - - int times = RubyNumeric.fix2int(arg.convertToInteger()); - - if (times < 0) { - if (isZero()) { - return newInfinity(getRuntime(), value.signum()); - } - - // Note: MRI has a very non-trivial way of calculating the precision, - // so we use very simple approximation here: - int precision = (-times + 4) * (getAllDigits().length() + 4); - - return new RubyBigDecimal(getRuntime(), - value.pow(times, new MathContext(precision, RoundingMode.HALF_UP))); - } else { - return new RubyBigDecimal(getRuntime(), value.pow(times)); - } - } - - @JRubyMethod(name = "+", required = 1, frame=true) - public IRubyObject op_plus(ThreadContext context, IRubyObject b) { - return addInternal(context, b, "add", RubyFixnum.zero(context.getRuntime())); - } - - @JRubyMethod(name = "add", required = 2, frame=true) - public IRubyObject add2(ThreadContext context, IRubyObject b, IRubyObject digits) { - return addInternal(context, b, "add", digits); - } - - private IRubyObject addInternal(ThreadContext context, IRubyObject b, String op, IRubyObject digits) { - Ruby runtime = context.getRuntime(); - int prec = getPositiveInt(context, digits); - - RubyBigDecimal val = getVpValue(b, false); - if (val == null) { - // TODO: - // MRI behavior: Call "+" or "add", depending on the call. - // But this leads to exceptions when Floats are added. See: - // http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/17374 - // return callCoerced(context, op, b, true); -- this is MRI behavior. - // We'll use ours for now, thus providing an ability to add Floats. - return callCoerced(context, "+", b, true); - } - - IRubyObject res = handleAddSpecialValues(val); - if (res != null) { - return res; - } - RoundingMode roundMode = getRoundingMode(runtime); - return new RubyBigDecimal(runtime, value.add( - val.value, new MathContext(prec, roundMode))); // TODO: why this: .setResult(); - } - - private int getPositiveInt(ThreadContext context, IRubyObject arg) { - Ruby runtime = context.getRuntime(); - - if (arg instanceof RubyFixnum) { - int value = RubyNumeric.fix2int(arg); - if (value < 0) { - throw runtime.newArgumentError("argument must be positive"); - } - return value; - } else { - throw runtime.newTypeError(arg, runtime.getFixnum()); - } - } - - private IRubyObject handleAddSpecialValues(RubyBigDecimal val) { - if (isNaN() || val.isNaN) { - return newNaN(getRuntime()); - } - // TODO: don't calculate the same value 3 times - if (infinitySign * val.infinitySign > 0) { - return isInfinity() ? this : val; - } - if (infinitySign * val.infinitySign < 0) { - return newNaN(getRuntime()); - } - if (infinitySign * val.infinitySign == 0) { - int sign = infinitySign + val.infinitySign; - if (sign != 0) { - return newInfinity(getRuntime(), sign); - } - } - return null; - } - - @JRubyMethod(name = "+@") - public IRubyObject op_uplus() { - return this; - } - - @JRubyMethod(name = "-", required = 1) - public IRubyObject op_minus(ThreadContext context, IRubyObject arg) { - RubyBigDecimal val = getVpValue(arg, false); - if(val == null) { - return callCoerced(context, "-", arg); - } - RubyBigDecimal res = handleMinusSpecialValues(val); - if (res != null) { - return res; - } - return new RubyBigDecimal(getRuntime(),value.subtract(val.value)).setResult(); - } - - @JRubyMethod(name = "sub", required = 2) - public IRubyObject sub2(ThreadContext context, IRubyObject b, IRubyObject n) { - RubyBigDecimal val = getVpValue(b, false); - if(val == null) { - return callCoerced(context, "-", b); - } - RubyBigDecimal res = handleMinusSpecialValues(val); - if (res != null) { - return res; - } - - return new RubyBigDecimal(getRuntime(),value.subtract(val.value)).setResult(); - } - - private RubyBigDecimal handleMinusSpecialValues(RubyBigDecimal val) { - if (isNaN() || val.isNaN()) { - return newNaN(getRuntime()); - } - - // TODO: 3 times calculate the same value below - if (infinitySign * val.infinitySign > 0) { - return newNaN(getRuntime()); - } - if (infinitySign * val.infinitySign < 0) { - return this; - } - if (infinitySign * val.infinitySign == 0) { - if (isInfinity()) { - return this; - } - if (val.isInfinity()) { - return newInfinity(getRuntime(), val.infinitySign * -1); - } - int sign = infinitySign + val.infinitySign; - if (sign != 0) { - return newInfinity(getRuntime(), sign); - } - } - return null; - } - - @JRubyMethod(name = "-@") - public IRubyObject op_uminus() { - Ruby runtime = getRuntime(); - if (isNaN()) { - return newNaN(runtime); - } - if (isInfinity()) { - return newInfinity(runtime, -infinitySign); - } - if (isZero()) { - return newZero(runtime, -zeroSign); - } - return new RubyBigDecimal(getRuntime(), value.negate()); - } - - @JRubyMethod(name = {"/", "quo"}) - public IRubyObject op_quo(ThreadContext context, IRubyObject other) { - // regular division with some default precision - // TODO: proper algorithm to set the precision - return op_div(context, other, getRuntime().newFixnum(200)); - } - - @JRubyMethod(name = "div") - public IRubyObject op_div(ThreadContext context, IRubyObject other) { - // integer division - RubyBigDecimal val = getVpValue(other, false); - if (val == null) { - return callCoerced(context, "div", other); - } - - if (isNaN() || val.isZero() || val.isNaN()) { - return newNaN(getRuntime()); - } - - if (isInfinity() || val.isInfinity()) { - return newNaN(getRuntime()); - } - - return new RubyBigDecimal(getRuntime(), - this.value.divideToIntegralValue(val.value)).setResult(); - } - - @JRubyMethod(name = "div") - public IRubyObject op_div(ThreadContext context, IRubyObject other, IRubyObject digits) { - // TODO: take BigDecimal.mode into account. - - int scale = RubyNumeric.fix2int(digits); - - RubyBigDecimal val = getVpValue(other, false); - if (val == null) { - return callCoerced(context, "/", other); - } - - if (isNaN() || (isZero() && val.isZero()) || val.isNaN()) { - return newNaN(getRuntime()); - } - - if (val.isZero()) { - int sign1 = isInfinity() ? infinitySign : value.signum(); - return newInfinity(getRuntime(), sign1 * val.zeroSign); - } - - if (isInfinity() && !val.isInfinity()) { - return newInfinity(getRuntime(), infinitySign * val.value.signum()); - } - - if (!isInfinity() && val.isInfinity()) { - return newZero(getRuntime(), value.signum() * val.infinitySign); - } - - if (isInfinity() && val.isInfinity()) { - return newNaN(getRuntime()); - } - - if (scale == 0) { - // MRI behavior: "If digits is 0, the result is the same as the / operator." - return op_quo(context, other); - } else { - // TODO: better algorithm to set precision needed - int prec = Math.max(200, scale); - return new RubyBigDecimal(getRuntime(), - value.divide(val.value, new MathContext(prec, RoundingMode.HALF_UP))).setResult(scale); - } - } - - private IRubyObject cmp(ThreadContext context, IRubyObject r, char op) { - int e = 0; - RubyBigDecimal rb = getVpValue(r,false); - if(rb == null) { - IRubyObject ee = callCoerced(context, "<=>",r); - if(ee.isNil()) { - return getRuntime().getNil(); - } - e = RubyNumeric.fix2int(ee); - } else { - if (isNaN() | rb.isNaN()) { - return getRuntime().getNil(); - } - if (infinitySign != 0 || rb.infinitySign != 0) { - e = infinitySign - rb.infinitySign; - } else { - e = value.compareTo(rb.value); - } - } - switch(op) { - case '*': return getRuntime().newFixnum(e); - case '=': return (e==0)?getRuntime().getTrue():getRuntime().getFalse(); - case '!': return (e!=0)?getRuntime().getTrue():getRuntime().getFalse(); - case 'G': return (e>=0)?getRuntime().getTrue():getRuntime().getFalse(); - case '>': return (e> 0)?getRuntime().getTrue():getRuntime().getFalse(); - case 'L': return (e<=0)?getRuntime().getTrue():getRuntime().getFalse(); - case '<': return (e< 0)?getRuntime().getTrue():getRuntime().getFalse(); - } - return getRuntime().getNil(); - } - - @JRubyMethod(name = "<=>", required = 1) - public IRubyObject op_cmp(ThreadContext context, IRubyObject arg) { - return cmp(context, arg,'*'); - } - - @JRubyMethod(name = {"eql?", "==", "==="}, required = 1) - public IRubyObject eql_p(ThreadContext context, IRubyObject arg) { - return cmp(context, arg,'='); - } - - @JRubyMethod(name = "<", required = 1) - public IRubyObject op_lt(ThreadContext context, IRubyObject arg) { - return cmp(context, arg,'<'); - } - - @JRubyMethod(name = "<=", required = 1) - public IRubyObject op_le(ThreadContext context, IRubyObject arg) { - return cmp(context, arg,'L'); - } - - @JRubyMethod(name = ">", required = 1) - public IRubyObject op_gt(ThreadContext context, IRubyObject arg) { - return cmp(context, arg,'>'); - } - - @JRubyMethod(name = ">=", required = 1) - public IRubyObject op_ge(ThreadContext context, IRubyObject arg) { - return cmp(context, arg,'G'); - } - - @JRubyMethod(name = "abs") - public IRubyObject abs() { - Ruby runtime = getRuntime(); - if (isNaN) { - return newNaN(runtime); - } - if (isInfinity()) { - return newInfinity(runtime, 1); - } - return new RubyBigDecimal(getRuntime(), value.abs()).setResult(); - } - - @JRubyMethod(name = "ceil", optional = 1) - public IRubyObject ceil(IRubyObject[] args) { - if (isNaN) { - return newNaN(getRuntime()); - } - if (isInfinity()) { - return newInfinity(getRuntime(), infinitySign); - } - - int n = 0; - if (args.length > 0) { - n = RubyNumeric.fix2int(args[0]); - } - - if (value.scale() > n) { // rounding neccessary - return new RubyBigDecimal(getRuntime(), - value.setScale(n, RoundingMode.CEILING)); - } else { - return this; - } - } - - @JRubyMethod(name = "coerce", required = 1) - public IRubyObject coerce(IRubyObject other) { - IRubyObject obj; - if(other instanceof RubyFloat) { - obj = getRuntime().newArray(other,to_f()); - } else { - obj = getRuntime().newArray(getVpValue(other, true),this); - } - return obj; - } - - public double getDoubleValue() { return value.doubleValue(); } - public long getLongValue() { return value.longValue(); } - - public RubyNumeric multiplyWith(ThreadContext context, RubyInteger value) { - return (RubyNumeric)op_mul(context, value); - } - - public RubyNumeric multiplyWith(ThreadContext context, RubyFloat value) { - return (RubyNumeric)op_mul(context, value); - } - - public RubyNumeric multiplyWith(ThreadContext context, RubyBignum value) { - return (RubyNumeric)op_mul(context, value); - } - - @JRubyMethod(name = "divmod", required = 1) - public IRubyObject divmod(ThreadContext context, IRubyObject other) { - // TODO: full-precision divmod is 1000x slower than MRI! - Ruby runtime = context.getRuntime(); - if (isInfinity() || isNaN()) { - return RubyArray.newArray(runtime, newNaN(runtime), newNaN(runtime)); - } - RubyBigDecimal val = getVpValue(other, false); - if (val == null) { - return callCoerced(context, "divmod", other, true); - } - if (val.isInfinity() || val.isNaN() || val.isZero()) { - return RubyArray.newArray(runtime, newNaN(runtime), newNaN(runtime)); - } - - // Java and MRI definitions of divmod are different. - BigDecimal[] divmod = value.divideAndRemainder(val.value); - - BigDecimal div = divmod[0]; - BigDecimal mod = divmod[1]; - - if (mod.signum() * val.value.signum() < 0) { - div = div.subtract(BigDecimal.ONE); - mod = mod.add(val.value); - } - - return RubyArray.newArray(runtime, - new RubyBigDecimal(runtime, div), - new RubyBigDecimal(runtime, mod)); - } - - @JRubyMethod(name = "exponent") - public IRubyObject exponent() { - return getRuntime().newFixnum(getExponent()); - } - - @JRubyMethod(name = "finite?") - public IRubyObject finite_p() { - if (isNaN()) { - return getRuntime().getFalse(); - } - return getRuntime().newBoolean(!isInfinity()); - } - - @JRubyMethod(name = "floor", optional = 1) - public IRubyObject floor(IRubyObject[]args) { - if (isNaN) { - return newNaN(getRuntime()); - } - if (isInfinity()) { - return newInfinity(getRuntime(), infinitySign); - } - - int n = 0; - if (args.length > 0) { - n = RubyNumeric.fix2int(args[0]); - } - - if (value.scale() > n) { // rounding neccessary - return new RubyBigDecimal(getRuntime(), - value.setScale(n, RoundingMode.FLOOR)); - } else { - return this; - } - } - - @JRubyMethod(name = "frac") - public IRubyObject frac() { - if (isNaN) { - return newNaN(getRuntime()); - } - if (isInfinity()) { - return newInfinity(getRuntime(), infinitySign); - } - if (value.scale() > 0 && value.precision() < value.scale()) { - return new RubyBigDecimal(getRuntime(), value); - } - - BigDecimal val = value.subtract(((RubyBigDecimal)fix()).value); - return new RubyBigDecimal(getRuntime(), val); - } - - @JRubyMethod(name = "infinite?") - public IRubyObject infinite_p() { - if (infinitySign == 0) { - return getRuntime().getNil(); - } - return getRuntime().newFixnum(infinitySign); - } - - @JRubyMethod(name = "inspect") - public IRubyObject inspect(ThreadContext context) { - StringBuilder val = new StringBuilder("#<BigDecimal:").append(Integer.toHexString(System.identityHashCode(this))).append(","); - val.append("'").append(this.callMethod(context, MethodIndex.TO_S, "to_s")).append("'").append(","); - - val.append(getSignificantDigits().length()).append("("); - - int len = getAllDigits().length(); - int pow = len / 4; - val.append((pow + 1) * 4).append(")").append(">"); - - return getRuntime().newString(val.toString()); - } - - @JRubyMethod(name = "nan?") - public IRubyObject nan_p() { - return getRuntime().newBoolean(isNaN); - } - - @JRubyMethod(name = "nonzero?") - public IRubyObject nonzero_p() { - return isZero() ? getRuntime().getNil() : this; - } - - @JRubyMethod(name = "precs") - public IRubyObject precs() { - final Ruby runtime = getRuntime(); - final IRubyObject[] array = new IRubyObject[2]; - - array[0] = runtime.newFixnum(getSignificantDigits().length()); - - int len = getAllDigits().length(); - int pow = len / 4; - array[1] = runtime.newFixnum((pow + 1) * 4); - - return RubyArray.newArray(runtime, array); - } - - @JRubyMethod(name = "round", optional = 2) - public IRubyObject round(IRubyObject[] args) { - int scale = args.length > 0 ? num2int(args[0]) : 0; - int mode = (args.length > 1) ? javaRoundingModeFromRubyRoundingMode(args[1]) : BigDecimal.ROUND_HALF_UP; - // JRUBY-914: Java 1.4 BigDecimal does not allow a negative scale, so we have to simulate it - if (scale < 0) { - // shift the decimal point just to the right of the digit to be rounded to (divide by 10**(abs(scale))) - // -1 -> 10's digit, -2 -> 100's digit, etc. - BigDecimal normalized = value.movePointRight(scale); - // ...round to that digit - BigDecimal rounded = normalized.setScale(0,mode); - // ...and shift the result back to the left (multiply by 10**(abs(scale))) - return new RubyBigDecimal(getRuntime(), rounded.movePointLeft(scale)); - } else { - return new RubyBigDecimal(getRuntime(), value.setScale(scale, mode)); - } - } - - //this relies on the Ruby rounding enumerations == Java ones, which they (currently) all are - private int javaRoundingModeFromRubyRoundingMode(IRubyObject arg) { - return num2int(arg); - } - - @JRubyMethod(name = "sign") - public IRubyObject sign() { - if (isNaN()) { - return getMetaClass().fastGetConstant("SIGN_NaN"); - } - - if (isInfinity()) { - if (infinitySign < 0) { - return getMetaClass().fastGetConstant("SIGN_NEGATIVE_INFINITE"); - } else { - return getMetaClass().fastGetConstant("SIGN_POSITIVE_INFINITE"); - } - } - - if (isZero()) { - if (zeroSign < 0) { - return getMetaClass().fastGetConstant("SIGN_NEGATIVE_ZERO"); - } else { - return getMetaClass().fastGetConstant("SIGN_POSITIVE_ZERO"); - } - } - - if (value.signum() < 0) { - return getMetaClass().fastGetConstant("SIGN_NEGATIVE_FINITE"); - } else { - return getMetaClass().fastGetConstant("SIGN_POSITIVE_FINITE"); - } - } - - @JRubyMethod(name = "split") - public RubyArray split() { - final Ruby runtime = getRuntime(); - final IRubyObject[] array = new IRubyObject[4]; - - // sign - final RubyFixnum sign; - if (isNaN) { - sign = RubyFixnum.zero(runtime); - } else if (isInfinity()) { - sign = runtime.newFixnum(infinitySign); - } else if (isZero()){ - sign = runtime.newFixnum(zeroSign); - } else { - sign = runtime.newFixnum(value.signum()); - } - array[0] = sign; - - // significant digits and exponent - final RubyString digits; - final RubyFixnum exp; - if (isNaN()) { - digits = runtime.newString("NaN"); - exp = RubyFixnum.zero(runtime); - } else if (isInfinity()) { - digits = runtime.newString("Infinity"); - exp = RubyFixnum.zero(runtime); - } else if (isZero()){ - digits = runtime.newString("0"); - exp = RubyFixnum.zero(runtime); - } else { - // normalize the value - digits = runtime.newString(getSignificantDigits()); - exp = runtime.newFixnum(getExponent()); - } - array[1] = digits; - array[3] = exp; - - // base - array[2] = runtime.newFixnum(10); - - return RubyArray.newArray(runtime, array); - } - - // it doesn't handle special cases - private String getSignificantDigits() { - // TODO: no need to calculate every time. - BigDecimal val = value.abs().stripTrailingZeros(); - return val.unscaledValue().toString(); - } - - private String getAllDigits() { - // TODO: no need to calculate every time. - BigDecimal val = value.abs(); - return val.unscaledValue().toString(); - } - - // it doesn't handle special cases - private int getExponent() { - // TODO: no need to calculate every time. - if (isZero()) { - return 0; - } - BigDecimal val = value.abs().stripTrailingZeros(); - return val.precision() - val.scale(); - } - - @JRubyMethod(name = "sqrt", required = 1) - public IRubyObject sqrt(IRubyObject arg) { - Ruby runtime = getRuntime(); - if (isNaN()) { - throw runtime.newFloatDomainError("(VpSqrt) SQRT(NaN value)"); - } - if ((isInfinity() && infinitySign < 0) || value.signum() < 0) { - throw runtime.newFloatDomainError("(VpSqrt) SQRT(negative value)"); - } - if (isInfinity() && infinitySign > 0) { - return newInfinity(runtime, 1); - } - - // NOTE: MRI's sqrt precision is limited by 100, - // but we allow values more than 100. - int n = RubyNumeric.fix2int(arg); - if (n < 0) { - throw runtime.newArgumentError("argument must be positive"); - } - - n += 4; // just in case, add a bit of extra precision - - return new RubyBigDecimal(getRuntime(), - bigSqrt(this.value, new MathContext(n, RoundingMode.HALF_UP))).setResult(); - } - - @JRubyMethod(name = "to_f") - public IRubyObject to_f() { - if (isNaN()) { - return RubyFloat.newFloat(getRuntime(), Double.NaN); - } - if (isInfinity()) { - return RubyFloat.newFloat(getRuntime(), - infinitySign < 0 ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY); - } - if (isZero()) { - return RubyFloat.newFloat(getRuntime(), - zeroSign < 0 ? -0.0 : 0.0); - } - return RubyFloat.newFloat(getRuntime(), value.doubleValue()); - } - - @JRubyMethod(name = {"to_i", "to_int"}) - public IRubyObject to_int() { - if (isNaN() || infinitySign != 0) { - return getRuntime().getNil(); - } - try { - return RubyNumeric.int2fix(getRuntime(), value.longValueExact()); - } catch (ArithmeticException ae) { - return RubyBignum.bignorm(getRuntime(), value.toBigInteger()); - } - } - - private String removeTrailingZeroes(String in) { - while(in.length() > 0 && in.charAt(in.length()-1)=='0') { - in = in.substring(0,in.length()-1); - } - return in; - } - - public static boolean formatHasLeadingPlus(String format) { - return format.startsWith("+"); - } - - public static boolean formatHasLeadingSpace(String format) { - return format.startsWith(" "); - } - - public static boolean formatHasFloatingPointNotation(String format) { - return format.endsWith("F"); - } - - public static int formatFractionalDigitGroups(String format) { - int groups = 0; - Pattern p = Pattern.compile("(\\+| )?(\\d+)(E|F)?"); - Matcher m = p.matcher(format); - if (m.matches()) { - groups = Integer.parseInt(m.group(2)); - } - return groups; - } - - private boolean hasArg(IRubyObject[] args) { - return args.length != 0 && !args[0].isNil(); - } - - private String format(IRubyObject[] args) { - return args[0].toString(); - } - - private String firstArgument(IRubyObject[] args) { - if (hasArg(args)) { - return format(args); - } - return null; - } - - private boolean posSpace(String arg) { - if (null != arg) { - return formatHasLeadingSpace(arg); - } - return false; - } - - private boolean posSign(String arg) { - if (null != arg) { - return formatHasLeadingPlus(arg) || posSpace(arg); - } - return false; - } - - private boolean asEngineering(String arg) { - if (null != arg) { - return !formatHasFloatingPointNotation(arg); - } - return true; - } - - private int groups(String arg) { - if (null != arg) { - return formatFractionalDigitGroups(arg); - } - return 0; - } - - private boolean isZero() { - return !isNaN() && !isInfinity() && (value.signum() == 0); - } - - private boolean isNaN() { - return isNaN; - } - - private boolean isInfinity() { - return infinitySign != 0; - } - - private String unscaledValue() { - return value.abs().unscaledValue().toString(); - } - - private IRubyObject engineeringValue(String arg) { - int exponent = getExponent(); - int signum = value.signum(); - StringBuilder build = new StringBuilder(); - build.append(signum == -1 ? "-" : (signum == 1 ? (posSign(arg) ? (posSpace(arg) ? " " : "+") : "") : "")); - build.append("0."); - if (0 == groups(arg)) { - String s = removeTrailingZeroes(unscaledValue()); - if ("".equals(s)) { - build.append("0"); - } else { - build.append(s); - } - } else { - int index = 0; - String sep = ""; - while (index < unscaledValue().length()) { - int next = index + groups(arg); - if (next > unscaledValue().length()) { - next = unscaledValue().length(); - } - build.append(sep).append(unscaledValue().substring(index, next)); - sep = " "; - index += groups(arg); - } - } - build.append("E").append(exponent); - return getRuntime().newString(build.toString()); - } - - private IRubyObject floatingPointValue(String arg) { - String values[] = value.abs().stripTrailingZeros().toPlainString().split("\\."); - String whole = "0"; - if (values.length > 0) { - whole = values[0]; - } - String after = "0"; - if (values.length > 1) { - after = values[1]; - } - int signum = value.signum(); - StringBuilder build = new StringBuilder(); - build.append(signum == -1 ? "-" : (signum == 1 ? (posSign(arg) ? (posSpace(arg) ? " " : "+") : "") : "")); - if (groups(arg) == 0) { - build.append(whole); - if (null != after) { - build.append(".").append(after); - } - } else { - int index = 0; - String sep = ""; - while (index < whole.length()) { - int next = index + groups(arg); - if (next > whole.length()) { - next = whole.length(); - } - build.append(sep).append(whole.substring(index, next)); - sep = " "; - index += groups(arg); - } - if (null != after) { - build.append("."); - index = 0; - sep = ""; - while (index < after.length()) { - int next = index + groups(arg); - if (next > after.length()) { - next = after.length(); - } - build.append(sep).append(after.substring(index, next)); - sep = " "; - index += groups(arg); - } - } - } - return getRuntime().newString(build.toString()); - } - - @JRubyMethod(name = "to_s", optional = 1) - public IRubyObject to_s(IRubyObject[] args) { - String arg = firstArgument(args); - if (isNaN()) { - return getRuntime().newString("NaN"); - } - if (infinitySign != 0) { - if (infinitySign == -1) { - return getRuntime().newString("-Infinity"); - } else { - return getRuntime().newString("Infinity"); - } - } - if (isZero()) { - String zero = "0.0"; - if (zeroSign < 0) { - zero = "-" + zero; - } - return getRuntime().newString(zero); - } - if(asEngineering(arg)) { - return engineeringValue(arg); - } else { - return floatingPointValue(arg); - } - } - - // Note: #fix has only no-arg form, but truncate allows optional parameter. - - @JRubyMethod - public IRubyObject fix() { - return truncate(RubyFixnum.zero(getRuntime())); - } - - @JRubyMethod - public IRubyObject truncate() { - return truncate(RubyFixnum.zero(getRuntime())); - } - - @JRubyMethod - public IRubyObject truncate(IRubyObject arg) { - if (isNaN) { - return newNaN(getRuntime()); - } - if (isInfinity()) { - return newInfinity(getRuntime(), infinitySign); - } - - int n = RubyNumeric.fix2int(arg); - - int precision = value.precision() - value.scale() + n; - - if (precision > 0) { - return new RubyBigDecimal(getRuntime(), - value.round(new MathContext(precision, RoundingMode.DOWN))); - } else { - // TODO: proper sign - return new RubyBigDecimal(getRuntime(), BigDecimal.ZERO); - } - } - - @JRubyMethod(name = "zero?") - public IRubyObject zero_p() { - return getRuntime().newBoolean(isZero()); - } - - /** - * Returns the correctly rounded square root of a positive - * BigDecimal. This method performs the fast <i>Square Root by - * Coupled Newton Iteration</i> algorithm by Timm Ahrendt, from - * the book "Pi, unleashed" by Jörg Arndt in a neat loop. - * <p> - * The code is based on Frans Lelieveld's code , used here with - * permission. - * - * @param squarD The number to get the root from. - * @param rootMC Precision and rounding mode. - * @return the root of the argument number - * @throws ArithmeticException - * if the argument number is negative - * @throws IllegalArgumentException - * if rootMC has precision 0 - */ - public static BigDecimal bigSqrt(BigDecimal squarD, MathContext rootMC) { - // General number and precision checking - int sign = squarD.signum(); - if (sign == -1) { - throw new ArithmeticException("Square root of a negative number: " + squarD); - } else if(sign == 0) { - return squarD.round(rootMC); - } - - int prec = rootMC.getPrecision(); // the requested precision - if (prec == 0) { - throw new IllegalArgumentException("Most roots won't have infinite precision = 0"); - } - - // Initial precision is that of double numbers 2^63/2 ~ 4E18 - int BITS = 62; // 63-1 an even number of number bits - int nInit = 16; // precision seems 16 to 18 digits - MathContext nMC = new MathContext(18, RoundingMode.HALF_DOWN); - - // Iteration variables, for the square root x and the reciprocal v - BigDecimal x = null, e = null; // initial x: x0 ~ sqrt() - BigDecimal v = null, g = null; // initial v: v0 = 1/(2*x) - - // Estimate the square root with the foremost 62 bits of squarD - BigInteger bi = squarD.unscaledValue(); // bi and scale are a tandem - int biLen = bi.bitLength(); - int shift = Math.max(0, biLen - BITS + (biLen%2 == 0 ? 0 : 1)); // even shift.. - bi = bi.shiftRight(shift); // ..floors to 62 or 63 bit BigInteger - - double root = Math.sqrt(bi.doubleValue()); - BigDecimal halfBack = new BigDecimal(BigInteger.ONE.shiftLeft(shift/2)); - - int scale = squarD.scale(); - if (scale % 2 == 1) { - root *= SQRT_10; // 5 -> 2, -5 -> -3 need half a scale more.. - } - scale = (int) Math.floor(scale/2.); // ..where 100 -> 10 shifts the scale - - // Initial x - use double root - multiply by halfBack to unshift - set new scale - x = new BigDecimal(root, nMC); - x = x.multiply(halfBack, nMC); // x0 ~ sqrt() - if (scale != 0) { - x = x.movePointLeft(scale); - } - - if (prec < nInit) { // for prec 15 root x0 must surely be OK - return x.round(rootMC); // return small prec roots without iterations - } - - // Initial v - the reciprocal - v = BigDecimal.ONE.divide(TWO.multiply(x), nMC); // v0 = 1/(2*x) - - // Collect iteration precisions beforehand - List<Integer> nPrecs = new ArrayList<Integer>(); - - assert nInit > 3 : "Never ending loop!"; // assume nInit = 16 <= prec - - // Let m be the exact digits precision in an earlier! loop - for (int m = prec + 1; m > nInit; m = m/2 + (m > 100 ? 1 : 2)) { - nPrecs.add(m); - } - - // The loop of "Square Root by Coupled Newton Iteration" - for (int i = nPrecs.size() - 1; i > -1; i--) { - // Increase precision - next iteration supplies n exact digits - nMC = new MathContext(nPrecs.get(i), (i%2 == 1) ? RoundingMode.HALF_UP : - RoundingMode.HALF_DOWN); - - // Next x // e = d - x^2 - e = squarD.subtract(x.multiply(x, nMC), nMC); - if (i != 0) { - x = x.add(e.multiply(v, nMC)); // x += e*v ~ sqrt() - } else { - x = x.add(e.multiply(v, rootMC), rootMC); // root x is ready! - break; - } - - // Next v // g = 1 - 2*x*v - g = BigDecimal.ONE.subtract(TWO.multiply(x).multiply(v, nMC)); - - v = v.add(g.multiply(v, nMC)); // v += g*v ~ 1/2/sqrt() - } - - return x; // return sqrt(squarD) with precision of rootMC - } -}// RubyBigdecimal -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; -import java.math.BigDecimal; -import java.math.BigInteger; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; - -/** - * - * @author jpetersen - */ -@JRubyClass(name="Bignum", parent="Integer") -public class RubyBignum extends RubyInteger { - public static RubyClass createBignumClass(Ruby runtime) { - RubyClass bignum = runtime.defineClass("Bignum", runtime.getInteger(), - ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setBignum(bignum); - bignum.index = ClassIndex.BIGNUM; - - bignum.defineAnnotatedMethods(RubyBignum.class); - - return bignum; - } - - private static final int BIT_SIZE = 64; - private static final long MAX = (1L << (BIT_SIZE - 1)) - 1; - private static final BigInteger LONG_MAX = BigInteger.valueOf(MAX); - private static final BigInteger LONG_MIN = BigInteger.valueOf(-MAX - 1); - - private final BigInteger value; - - public RubyBignum(Ruby runtime, BigInteger value) { - super(runtime, runtime.getBignum()); - this.value = value; - } - - public int getNativeTypeIndex() { - return ClassIndex.BIGNUM; - } - - public Class<?> getJavaClass() { - return BigInteger.class; - } - - public static RubyBignum newBignum(Ruby runtime, long value) { - return newBignum(runtime, BigInteger.valueOf(value)); - } - - public static RubyBignum newBignum(Ruby runtime, double value) { - return newBignum(runtime, new BigDecimal(value).toBigInteger()); - } - - public static RubyBignum newBignum(Ruby runtime, BigInteger value) { - return new RubyBignum(runtime, value); - } - - public static RubyBignum newBignum(Ruby runtime, String value) { - return new RubyBignum(runtime, new BigInteger(value)); - } - - public double getDoubleValue() { - return big2dbl(this); - } - - public long getLongValue() { - return big2long(this); - } - - /** Getter for property value. - * @return Value of property value. - */ - public BigInteger getValue() { - return value; - } - - /* ================ - * Utility Methods - * ================ - */ - - /* If the value will fit in a Fixnum, return one of those. */ - /** rb_big_norm - * - */ - public static RubyInteger bignorm(Ruby runtime, BigInteger bi) { - if (bi.compareTo(LONG_MIN) < 0 || bi.compareTo(LONG_MAX) > 0) { - return newBignum(runtime, bi); - } - return runtime.newFixnum(bi.longValue()); - } - - /** rb_big2long - * - */ - public static long big2long(RubyBignum value) { - BigInteger big = value.getValue(); - - if (big.compareTo(LONG_MIN) < 0 || big.compareTo(LONG_MAX) > 0) { - throw value.getRuntime().newRangeError("bignum too big to convert into `long'"); - } - return big.longValue(); - } - - /** rb_big2dbl - * - */ - public static double big2dbl(RubyBignum value) { - BigInteger big = value.getValue(); - double dbl = convertToDouble(big); - if (dbl == Double.NEGATIVE_INFINITY || dbl == Double.POSITIVE_INFINITY) { - value.getRuntime().getWarnings().warn(ID.BIGNUM_FROM_FLOAT_RANGE, "Bignum out of Float range"); - } - return dbl; - } - - private IRubyObject checkShiftDown(RubyBignum other) { - if (other.value.signum() == 0) return RubyFixnum.zero(getRuntime()); - if (value.compareTo(LONG_MIN) < 0 || value.compareTo(LONG_MAX) > 0) { - return other.value.signum() >= 0 ? RubyFixnum.zero(getRuntime()) : RubyFixnum.minus_one(getRuntime()); - } - return getRuntime().getNil(); - } - - /** - * BigInteger#doubleValue is _really_ slow currently. - * This is faster, and mostly correct (?) - */ - static double convertToDouble(BigInteger bigint) { - byte[] arr = bigint.toByteArray(); - double res = 0; - double acc = 1; - for (int i = arr.length - 1; i > 0 ; i--) - { - res += (double) (arr[i] & 0xff) * acc; - acc *= 256; - } - res += (double) arr[0] * acc; // final byte sign is significant - return res; - } - - /** rb_int2big - * - */ - public static BigInteger fix2big(RubyFixnum arg) { - return BigInteger.valueOf(arg.getLongValue()); - } - - /* ================ - * Instance Methods - * ================ - */ - - /** rb_big_to_s - * - */ - @JRubyMethod(name = "to_s", optional = 1) - public IRubyObject to_s(IRubyObject[] args) { - int base = args.length == 0 ? 10 : num2int(args[0]); - if (base < 2 || base > 36) { - throw getRuntime().newArgumentError("illegal radix " + base); - } - return getRuntime().newString(getValue().toString(base)); - } - - /** rb_big_coerce - * - */ - @JRubyMethod(name = "coerce", required = 1) - public IRubyObject coerce(IRubyObject other) { - if (other instanceof RubyFixnum) { - return getRuntime().newArray(newBignum(getRuntime(), ((RubyFixnum) other).getLongValue()), this); - } else if (other instanceof RubyBignum) { - return getRuntime().newArray(newBignum(getRuntime(), ((RubyBignum) other).getValue()), this); - } - - throw getRuntime().newTypeError("Can't coerce " + other.getMetaClass().getName() + " to Bignum"); - } - - /** rb_big_uminus - * - */ - @JRubyMethod(name = "-@") - public IRubyObject op_uminus() { - return bignorm(getRuntime(), value.negate()); - } - - /** rb_big_plus - * - */ - @JRubyMethod(name = "+", required = 1) - public IRubyObject op_plus(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return addFixnum((RubyFixnum)other); - } else if (other instanceof RubyBignum) { - return addBignum((RubyBignum)other); - } else if (other instanceof RubyFloat) { - return addFloat((RubyFloat)other); - } - return addOther(context, other); - } - - private IRubyObject addFixnum(RubyFixnum other) { - return bignorm(getRuntime(), value.add(fix2big(other))); - } - - private IRubyObject addBignum(RubyBignum other) { - return bignorm(getRuntime(), value.add(other.value)); - } - - private IRubyObject addFloat(RubyFloat other) { - return RubyFloat.newFloat(getRuntime(), big2dbl(this) + other.getDoubleValue()); - } - - private IRubyObject addOther(ThreadContext context, IRubyObject other) { - return coerceBin(context, "+", other); - } - - /** rb_big_minus - * - */ - @JRubyMethod(name = "-", required = 1) - public IRubyObject op_minus(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return subtractFixnum((RubyFixnum)other); - } else if (other instanceof RubyBignum) { - return subtractBignum((RubyBignum)other); - } else if (other instanceof RubyFloat) { - return subtractFloat((RubyFloat)other); - } - return subtractOther(context, other); - } - - private IRubyObject subtractFixnum(RubyFixnum other) { - return bignorm(getRuntime(), value.subtract(fix2big(((RubyFixnum) other)))); - } - - private IRubyObject subtractBignum(RubyBignum other) { - return bignorm(getRuntime(), value.subtract(((RubyBignum) other).value)); - } - - private IRubyObject subtractFloat(RubyFloat other) { - return RubyFloat.newFloat(getRuntime(), big2dbl(this) - ((RubyFloat) other).getDoubleValue()); - } - - private IRubyObject subtractOther(ThreadContext context, IRubyObject other) { - return coerceBin(context, "-", other); - } - - /** rb_big_mul - * - */ - @JRubyMethod(name = "*", required = 1) - public IRubyObject op_mul(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return bignorm(getRuntime(), value.multiply(fix2big(((RubyFixnum) other)))); - } - if (other instanceof RubyBignum) { - return bignorm(getRuntime(), value.multiply(((RubyBignum) other).value)); - } else if (other instanceof RubyFloat) { - return RubyFloat.newFloat(getRuntime(), big2dbl(this) * ((RubyFloat) other).getDoubleValue()); - } - return coerceBin(context, "*", other); - } - - /** - * rb_big_divide. Shared part for both "/" and "div" operations. - */ - private IRubyObject op_divide(ThreadContext context, IRubyObject other, String op) { - assert ("/".equals(op) || "div".equals(op)); - - final BigInteger otherValue; - if (other instanceof RubyFixnum) { - otherValue = fix2big((RubyFixnum) other); - } else if (other instanceof RubyBignum) { - otherValue = ((RubyBignum) other).value; - } else if (other instanceof RubyFloat) { - double div = big2dbl(this) / ((RubyFloat) other).getDoubleValue(); - if ("/".equals(op)) { - return RubyFloat.newFloat(getRuntime(), - big2dbl(this) / ((RubyFloat) other).getDoubleValue()); - } else { - return RubyNumeric.dbl2num(getRuntime(), div); - } - } else { - return coerceBin(context, op, other); - } - - if (otherValue.equals(BigInteger.ZERO)) { - throw getRuntime().newZeroDivisionError(); - } - - BigInteger[] results = value.divideAndRemainder(otherValue); - - if ((value.signum() * otherValue.signum()) == -1 && results[1].signum() != 0) { - return bignorm(getRuntime(), results[0].subtract(BigInteger.ONE)); - } - return bignorm(getRuntime(), results[0]); - } - - /** rb_big_div - * - */ - @JRubyMethod(name = {"/"}, required = 1) - public IRubyObject op_div(ThreadContext context, IRubyObject other) { - return op_divide(context, other, "/"); - } - - /** rb_big_idiv - * - */ - @JRubyMethod(name = {"div"}, required = 1) - public IRubyObject op_idiv(ThreadContext context, IRubyObject other) { - return op_divide(context, other, "div"); - } - - /** rb_big_divmod - * - */ - @JRubyMethod(name = "divmod", required = 1) - public IRubyObject divmod(ThreadContext context, IRubyObject other) { - final BigInteger otherValue; - if (other instanceof RubyFixnum) { - otherValue = fix2big((RubyFixnum) other); - } else if (other instanceof RubyBignum) { - otherValue = ((RubyBignum) other).value; - } else { - return coerceBin(context, "divmod", other); - } - - if (otherValue.equals(BigInteger.ZERO)) { - throw getRuntime().newZeroDivisionError(); - } - - BigInteger[] results = value.divideAndRemainder(otherValue); - - if ((value.signum() * otherValue.signum()) == -1 && results[1].signum() != 0) { - results[0] = results[0].subtract(BigInteger.ONE); - results[1] = otherValue.add(results[1]); - } - final Ruby runtime = getRuntime(); - return RubyArray.newArray(getRuntime(), bignorm(runtime, results[0]), bignorm(runtime, results[1])); - } - - /** rb_big_modulo - * - */ - @JRubyMethod(name = {"%", "modulo"}, required = 1) - public IRubyObject op_mod(ThreadContext context, IRubyObject other) { - final BigInteger otherValue; - if (other instanceof RubyFixnum) { - otherValue = fix2big((RubyFixnum) other); - } else if (other instanceof RubyBignum) { - otherValue = ((RubyBignum) other).value; - } else { - return coerceBin(context, "%", other); - } - if (otherValue.equals(BigInteger.ZERO)) { - throw getRuntime().newZeroDivisionError(); - } - BigInteger result = value.mod(otherValue.abs()); - if (otherValue.signum() == -1 && result.signum() != 0) { - result = otherValue.add(result); - } - return bignorm(getRuntime(), result); - - } - - /** rb_big_remainder - * - */ - @JRubyMethod(name = "remainder", required = 1) - public IRubyObject remainder(ThreadContext context, IRubyObject other) { - final BigInteger otherValue; - if (other instanceof RubyFixnum) { - otherValue = fix2big(((RubyFixnum) other)); - } else if (other instanceof RubyBignum) { - otherValue = ((RubyBignum) other).value; - } else { - return coerceBin(context, "remainder", other); - } - if (otherValue.equals(BigInteger.ZERO)) { - throw getRuntime().newZeroDivisionError(); - } - return bignorm(getRuntime(), value.remainder(otherValue)); - } - - /** rb_big_quo - - * - */ - @JRubyMethod(name = "quo", required = 1) - public IRubyObject quo(ThreadContext context, IRubyObject other) { - if (other instanceof RubyNumeric) { - return RubyFloat.newFloat(getRuntime(), big2dbl(this) / ((RubyNumeric) other).getDoubleValue()); - } else { - return coerceBin(context, "quo", other); - } - } - - /** rb_big_pow - * - */ - @JRubyMethod(name = {"**", "power"}, required = 1) - public IRubyObject op_pow(ThreadContext context, IRubyObject other) { - double d; - if (other instanceof RubyFixnum) { - RubyFixnum fix = (RubyFixnum) other; - long fixValue = fix.getLongValue(); - // MRI issuses warning here on (RBIGNUM(x)->len * SIZEOF_BDIGITS * yy > 1024*1024) - if (((value.bitLength() + 7) / 8) * 4 * Math.abs(fixValue) > 1024 * 1024) { - getRuntime().getWarnings().warn(ID.MAY_BE_TOO_BIG, "in a**b, b may be too big", fixValue); - } - if (fixValue >= 0) { - return bignorm(getRuntime(), value.pow((int) fixValue)); // num2int is also implemented - } else { - return RubyFloat.newFloat(getRuntime(), Math.pow(big2dbl(this), (double)fixValue)); - } - } else if (other instanceof RubyBignum) { - d = ((RubyBignum) other).getDoubleValue(); - getRuntime().getWarnings().warn(ID.MAY_BE_TOO_BIG, "in a**b, b may be too big", d); - } else if (other instanceof RubyFloat) { - d = ((RubyFloat) other).getDoubleValue(); - } else { - return coerceBin(context, "**", other); - - } - return RubyFloat.newFloat(getRuntime(), Math.pow(big2dbl(this), d)); - } - - /** rb_big_pow - * - */ - @JRubyMethod(name = {"**", "power"}, required = 1, compat = CompatVersion.RUBY1_9) - public IRubyObject op_pow_19(ThreadContext context, IRubyObject other) { - Ruby runtime = context.getRuntime(); - if (other == RubyFixnum.zero(runtime)) return RubyFixnum.one(runtime); - double d; - if (other instanceof RubyFixnum) { - RubyFixnum fix = (RubyFixnum) other; - long fixValue = fix.getLongValue(); - - if (fixValue < 0) { - return RubyRational.newRationalRaw(runtime, this).callMethod(context, "**", other); - } - // MRI issuses warning here on (RBIGNUM(x)->len * SIZEOF_BDIGITS * yy > 1024*1024) - if (((value.bitLength() + 7) / 8) * 4 * Math.abs(fixValue) > 1024 * 1024) { - getRuntime().getWarnings().warn(ID.MAY_BE_TOO_BIG, "in a**b, b may be too big", fixValue); - } - if (fixValue >= 0) { - return bignorm(runtime, value.pow((int) fixValue)); // num2int is also implemented - } else { - return RubyFloat.newFloat(runtime, Math.pow(big2dbl(this), (double)fixValue)); - } - } else if (other instanceof RubyBignum) { - if (other.callMethod(context, "<", RubyFixnum.zero(runtime)).isTrue()) { - return RubyRational.newRationalRaw(runtime, this).callMethod(context, "**", other); - } - d = ((RubyBignum) other).getDoubleValue(); - getRuntime().getWarnings().warn(ID.MAY_BE_TOO_BIG, "in a**b, b may be too big", d); - } else if (other instanceof RubyFloat) { - d = ((RubyFloat) other).getDoubleValue(); - } else { - return coerceBin(context, "**", other); - - } - return RubyNumeric.dbl2num(runtime, Math.pow(big2dbl(this), d)); - } - - /** rb_big_and - * - */ - @JRubyMethod(name = "&", required = 1) - public IRubyObject op_and(ThreadContext context, IRubyObject other) { - other = other.convertToInteger(); - if (other instanceof RubyBignum) { - return bignorm(getRuntime(), value.and(((RubyBignum) other).value)); - } else if(other instanceof RubyFixnum) { - return bignorm(getRuntime(), value.and(fix2big((RubyFixnum)other))); - } - return coerceBin(context, "&", other); - } - - /** rb_big_or - * - */ - @JRubyMethod(name = "|", required = 1) - public IRubyObject op_or(ThreadContext context, IRubyObject other) { - other = other.convertToInteger(); - if (other instanceof RubyBignum) { - return bignorm(getRuntime(), value.or(((RubyBignum) other).value)); - } - if (other instanceof RubyFixnum) { // no bignorm here needed - return bignorm(getRuntime(), value.or(fix2big((RubyFixnum)other))); - } - return coerceBin(context, "|", other); - } - - /** rb_big_xor - * - */ - @JRubyMethod(name = "^", required = 1) - public IRubyObject op_xor(ThreadContext context, IRubyObject other) { - other = other.convertToInteger(); - if (other instanceof RubyBignum) { - return bignorm(getRuntime(), value.xor(((RubyBignum) other).value)); - } - if (other instanceof RubyFixnum) { - return bignorm(getRuntime(), value.xor(BigInteger.valueOf(((RubyFixnum) other).getLongValue()))); - } - return coerceBin(context, "^", other); - } - - /** rb_big_neg - * - */ - @JRubyMethod(name = "~") - public IRubyObject op_neg() { - return RubyBignum.newBignum(getRuntime(), value.not()); - } - - /** rb_big_lshift - * - */ - @JRubyMethod(name = "<<", required = 1) - public IRubyObject op_lshift(IRubyObject other) { - long shift; - boolean neg = false; - - for (;;) { - if (other instanceof RubyFixnum) { - shift = ((RubyFixnum)other).getLongValue(); - if (shift < 0) { - neg = true; - shift = -shift; - } - break; - } else if (other instanceof RubyBignum) { - RubyBignum otherBignum = (RubyBignum)other; - if (otherBignum.value.signum() < 0) { - IRubyObject tmp = otherBignum.checkShiftDown(this); - if (!tmp.isNil()) return tmp; - neg = true; - } - shift = big2long(otherBignum); - break; - } - other = other.convertToInteger(); - } - - return bignorm(getRuntime(), neg ? value.shiftRight((int)shift) : value.shiftLeft((int)shift)); - } - - /** rb_big_rshift - * - */ - @JRubyMethod(name = ">>", required = 1) - public IRubyObject op_rshift(IRubyObject other) { - long shift; - boolean neg = false; - - for (;;) { - if (other instanceof RubyFixnum) { - shift = ((RubyFixnum)other).getLongValue(); - if (shift < 0) { - neg = true; - shift = -shift; - } - break; - } else if (other instanceof RubyBignum) { - RubyBignum otherBignum = (RubyBignum)other; - if (otherBignum.value.signum() >= 0) { - IRubyObject tmp = otherBignum.checkShiftDown(this); - if (!tmp.isNil()) return tmp; - } else { - neg = true; - } - shift = big2long(otherBignum); - break; - } - other = other.convertToInteger(); - } - return bignorm(getRuntime(), neg ? value.shiftLeft((int)shift) : value.shiftRight((int)shift)); - } - - /** rb_big_aref - * - */ - @JRubyMethod(name = "[]", required = 1) - public RubyFixnum op_aref(IRubyObject other) { - if (other instanceof RubyBignum) { - if (((RubyBignum) other).value.signum() >= 0 || value.signum() == -1) { - return RubyFixnum.zero(getRuntime()); - } - return RubyFixnum.one(getRuntime()); - } - long position = num2long(other); - if (position < 0 || position > Integer.MAX_VALUE) { - return RubyFixnum.zero(getRuntime()); - } - - return value.testBit((int)position) ? RubyFixnum.one(getRuntime()) : RubyFixnum.zero(getRuntime()); - } - - /** rb_big_cmp - * - */ - @JRubyMethod(name = "<=>", required = 1) - public IRubyObject op_cmp(ThreadContext context, IRubyObject other) { - final BigInteger otherValue; - if (other instanceof RubyFixnum) { - otherValue = fix2big((RubyFixnum) other); - } else if (other instanceof RubyBignum) { - otherValue = ((RubyBignum) other).value; - } else if (other instanceof RubyFloat) { - return dbl_cmp(getRuntime(), big2dbl(this), ((RubyFloat) other).getDoubleValue()); - } else { - return coerceCmp(context, "<=>", other); - } - - // wow, the only time we can use the java protocol ;) - return RubyFixnum.newFixnum(getRuntime(), value.compareTo(otherValue)); - } - - /** rb_big_eq - * - */ - @JRubyMethod(name = "==", required = 1) - public IRubyObject op_equal(IRubyObject other) { - final BigInteger otherValue; - if (other instanceof RubyFixnum) { - otherValue = fix2big((RubyFixnum) other); - } else if (other instanceof RubyBignum) { - otherValue = ((RubyBignum) other).value; - } else if (other instanceof RubyFloat) { - double a = ((RubyFloat) other).getDoubleValue(); - if (Double.isNaN(a)) { - return getRuntime().getFalse(); - } - return RubyBoolean.newBoolean(getRuntime(), a == big2dbl(this)); - } else { - return other.op_eqq(getRuntime().getCurrentContext(), this); - } - return RubyBoolean.newBoolean(getRuntime(), value.compareTo(otherValue) == 0); - } - - /** rb_big_eql - * - */ - @JRubyMethod(name = {"eql?", "==="}, required = 1) - public IRubyObject eql_p(IRubyObject other) { - if (other instanceof RubyBignum) { - return value.compareTo(((RubyBignum)other).value) == 0 ? getRuntime().getTrue() : getRuntime().getFalse(); - } - return getRuntime().getFalse(); - } - - /** rb_big_hash - * - */ - @JRubyMethod(name = "hash") - public RubyFixnum hash() { - return getRuntime().newFixnum(value.hashCode()); - } - - /** rb_big_to_f - * - */ - @JRubyMethod(name = "to_f") - public IRubyObject to_f() { - return RubyFloat.newFloat(getRuntime(), getDoubleValue()); - } - - /** rb_big_abs - * - */ - @JRubyMethod(name = "abs") - public IRubyObject abs() { - return RubyBignum.newBignum(getRuntime(), value.abs()); - } - - /** rb_big_size - * - */ - @JRubyMethod(name = "size") - public IRubyObject size() { - return getRuntime().newFixnum((value.bitLength() + 7) / 8); - } - - public static void marshalTo(RubyBignum bignum, MarshalStream output) throws IOException { - output.registerLinkTarget(bignum); - - output.write(bignum.value.signum() >= 0 ? '+' : '-'); - - BigInteger absValue = bignum.value.abs(); - - byte[] digits = absValue.toByteArray(); - - boolean oddLengthNonzeroStart = (digits.length % 2 != 0 && digits[0] != 0); - int shortLength = digits.length / 2; - if (oddLengthNonzeroStart) { - shortLength++; - } - output.writeInt(shortLength); - - for (int i = 1; i <= shortLength * 2 && i <= digits.length; i++) { - output.write(digits[digits.length - i]); - } - - if (oddLengthNonzeroStart) { - // Pad with a 0 - output.write(0); - } - } - - public static RubyNumeric unmarshalFrom(UnmarshalStream input) throws IOException { - boolean positive = input.readUnsignedByte() == '+'; - int shortLength = input.unmarshalInt(); - - // BigInteger required a sign byte in incoming array - byte[] digits = new byte[shortLength * 2 + 1]; - - for (int i = digits.length - 1; i >= 1; i--) { - digits[i] = input.readSignedByte(); - } - - BigInteger value = new BigInteger(digits); - if (!positive) { - value = value.negate(); - } - - RubyNumeric result = bignorm(input.getRuntime(), value); - input.registerLinkTarget(result); - return result; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2005 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Charles O Nutter <headius@headius.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.runtime.Binding; -import org.jruby.runtime.Frame; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * @author jpetersen - */ -@JRubyClass(name="Binding") -public class RubyBinding extends RubyObject { - private Binding binding; - - public RubyBinding(Ruby runtime, RubyClass rubyClass, Binding binding) { - super(runtime, rubyClass); - - this.binding = binding; - } - - private RubyBinding(Ruby runtime, RubyClass rubyClass) { - super(runtime, rubyClass); - } - - private static ObjectAllocator BINDING_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - RubyBinding instance = new RubyBinding(runtime, klass); - - return instance; - } - }; - - public static RubyClass createBindingClass(Ruby runtime) { - RubyClass bindingClass = runtime.defineClass("Binding", runtime.getObject(), BINDING_ALLOCATOR); - runtime.setBinding(bindingClass); - - bindingClass.defineAnnotatedMethods(RubyBinding.class); - - return bindingClass; - } - - public Binding getBinding() { - return binding; - } - - // Proc class - - public static RubyBinding newBinding(Ruby runtime, Binding binding) { - return new RubyBinding(runtime, runtime.getBinding(), binding); - } - - public static RubyBinding newBinding(Ruby runtime) { - ThreadContext context = runtime.getCurrentContext(); - - // FIXME: We should be cloning, not reusing: frame, scope, dynvars, and potentially iter/block info - Frame frame = context.getCurrentFrame(); - Binding binding = new Binding(frame, context.getBindingRubyClass(), context.getCurrentScope()); - - return new RubyBinding(runtime, runtime.getBinding(), binding); - } - - /** - * Create a binding appropriate for a bare "eval", by using the previous (caller's) frame and current - * scope. - */ - public static RubyBinding newBindingForEval(ThreadContext context) { - // This requires some explaining. We use Frame values when executing blocks to fill in - // various values in ThreadContext and EvalState.eval like rubyClass, cref, and self. - // Largely, for an eval that is using the logical binding at a place where the eval is - // called we mostly want to use the current frames value for this. Most importantly, - // we need that self (JRUBY-858) at this point. We also need to make sure that returns - // jump to the right place (which happens to be the previous frame). Lastly, we do not - // want the current frames klazz since that will be the klazz represented of self. We - // want the class right before the eval (well we could use cref class for this too I think). - // Once we end up having Frames created earlier I think the logic of stuff like this will - // be better since we won't be worried about setting Frame to setup other variables/stacks - // but just making sure Frame itself is correct... - - Frame previousFrame = context.getPreviousFrame(); - Frame currentFrame = context.getCurrentFrame(); - currentFrame.setKlazz(previousFrame.getKlazz()); - - // Set jump target to whatever the previousTarget thinks is good. -// currentFrame.setJumpTarget(previousFrame.getJumpTarget() != null ? previousFrame.getJumpTarget() : previousFrame); - - Binding binding = new Binding(previousFrame, context.getBindingRubyClass(), context.getCurrentScope()); - Ruby runtime = context.getRuntime(); - - return new RubyBinding(runtime, runtime.getBinding(), binding); - } - - @JRubyMethod(name = "initialize", visibility = Visibility.PRIVATE) - public IRubyObject initialize(ThreadContext context) { - // FIXME: We should be cloning, not reusing: frame, scope, dynvars, and potentially iter/block info - Frame frame = context.getCurrentFrame(); - binding = new Binding(frame, context.getBindingRubyClass(), context.getCurrentScope()); - - return this; - } - - @JRubyMethod(name = "initialize_copy", required = 1, visibility = Visibility.PRIVATE) - @Override - public IRubyObject initialize_copy(IRubyObject other) { - RubyBinding otherBinding = (RubyBinding)other; - - binding = otherBinding.binding; - - return this; - } -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; - -/** - * - * @author jpetersen - */ -@JRubyClass(name={"TrueClass", "FalseClass"}) -public class RubyBoolean extends RubyObject { - - public RubyBoolean(Ruby runtime, boolean value) { - super(runtime, (value ? runtime.getTrueClass() : runtime.getFalseClass()), // Don't initialize with class - false); // Don't put in object space - - if (!value) flags = FALSE_F; - } - - @Override - public int getNativeTypeIndex() { - return (flags & FALSE_F) == 0 ? ClassIndex.TRUE : ClassIndex.FALSE; - } - - @Override - public boolean isImmediate() { - return true; - } - - @Override - public RubyClass getSingletonClass() { - return metaClass; - } - - @Override - public Class<?> getJavaClass() { - return boolean.class; - } - - public static RubyClass createFalseClass(Ruby runtime) { - RubyClass falseClass = runtime.defineClass("FalseClass", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setFalseClass(falseClass); - falseClass.index = ClassIndex.FALSE; - - falseClass.defineAnnotatedMethods(False.class); - - falseClass.getMetaClass().undefineMethod("new"); - - return falseClass; - } - - public static RubyClass createTrueClass(Ruby runtime) { - RubyClass trueClass = runtime.defineClass("TrueClass", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setTrueClass(trueClass); - trueClass.index = ClassIndex.TRUE; - - trueClass.defineAnnotatedMethods(True.class); - - trueClass.getMetaClass().undefineMethod("new"); - - return trueClass; - } - - public static RubyBoolean newBoolean(Ruby runtime, boolean value) { - return value ? runtime.getTrue() : runtime.getFalse(); - } - - public static class False { - @JRubyMethod(name = "&") - public static IRubyObject false_and(IRubyObject f, IRubyObject oth) { - return f; - } - - @JRubyMethod(name = "|") - public static IRubyObject false_or(IRubyObject f, IRubyObject oth) { - return oth.isTrue() ? f.getRuntime().getTrue() : f; - } - - @JRubyMethod(name = "^") - public static IRubyObject false_xor(IRubyObject f, IRubyObject oth) { - return oth.isTrue() ? f.getRuntime().getTrue() : f; - } - - @JRubyMethod(name = "to_s") - public static IRubyObject false_to_s(IRubyObject f) { - return f.getRuntime().newString("false"); - } - } - - public static class True { - @JRubyMethod(name = "&") - public static IRubyObject true_and(IRubyObject t, IRubyObject oth) { - return oth.isTrue() ? t : t.getRuntime().getFalse(); - } - - @JRubyMethod(name = "|") - public static IRubyObject true_or(IRubyObject t, IRubyObject oth) { - return t; - } - - @JRubyMethod(name = "^") - public static IRubyObject true_xor(IRubyObject t, IRubyObject oth) { - return oth.isTrue() ? t.getRuntime().getFalse() : t; - } - - @JRubyMethod(name = "to_s") - public static IRubyObject true_to_s(IRubyObject t) { - return t.getRuntime().newString("true"); - } - } - - @Override - public RubyFixnum id() { - if ((flags & FALSE_F) == 0) { - return RubyFixnum.newFixnum(getRuntime(), 2); - } else { - return RubyFixnum.zero(getRuntime()); - } - } - - @Override - public IRubyObject taint(ThreadContext context) { - return this; - } - - @Override - public IRubyObject freeze(ThreadContext context) { - return this; - } - - public void marshalTo(MarshalStream output) throws java.io.IOException { - output.write(isTrue() ? 'T' : 'F'); - } -} - -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004-2005 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Set; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; - -import org.jruby.internal.runtime.methods.DynamicMethod; -import org.jruby.internal.runtime.methods.JavaMethod; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallSite; -import org.jruby.runtime.CallSite.InlineCachingCallSite; -import org.jruby.runtime.CallType; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ObjectMarshal; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.collections.WeakHashSet; - -/** - * - * @author jpetersen - */ -@JRubyClass(name="Class", parent="Module") -public class RubyClass extends RubyModule { - public static final int CS_IDX_INITIALIZE = 0; - public static final String[] CS_NAMES = { - "initialize" - }; - private final CallSite[] baseCallSites = new CallSite[CS_NAMES.length]; - { - for(int i = 0; i < CS_NAMES.length; i++) { - baseCallSites[i] = new InlineCachingCallSite(CS_NAMES[i], CallType.FUNCTIONAL); - } - } - - private CallSite[] extraCallSites; - - public static void createClassClass(Ruby runtime, RubyClass classClass) { - classClass.index = ClassIndex.CLASS; - classClass.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyClass; - } - }; - - classClass.undefineMethod("module_function"); - classClass.undefineMethod("append_features"); - classClass.undefineMethod("extend_object"); - - classClass.defineAnnotatedMethods(RubyClass.class); - - classClass.addMethod("new", new SpecificArityNew(classClass, Visibility.PUBLIC)); - - // This is a non-standard method; have we decided to start extending Ruby? - //classClass.defineFastMethod("subclasses", callbackFactory.getFastOptMethod("subclasses")); - - // FIXME: for some reason this dispatcher causes a VerifyError... - //classClass.dispatcher = callbackFactory.createDispatcher(classClass); - } - - public static final ObjectAllocator CLASS_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - RubyClass clazz = new RubyClass(runtime); - clazz.allocator = ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR; // Class.allocate object is not allocatable before it is initialized - return clazz; - } - }; - - public ObjectAllocator getAllocator() { - return allocator; - } - - public void setAllocator(ObjectAllocator allocator) { - this.allocator = allocator; - } - - @JRubyMethod(name = "allocate") - public IRubyObject allocate() { - if (superClass == null) throw runtime.newTypeError("can't instantiate uninitialized class"); - IRubyObject obj = allocator.allocate(runtime, this); - if (obj.getMetaClass().getRealClass() != getRealClass()) throw runtime.newTypeError("wrong instance allocation"); - return obj; - } - - public CallSite[] getBaseCallSites() { - return baseCallSites; - } - - public CallSite[] getExtraCallSites() { - return extraCallSites; - } - - @Override - public int getNativeTypeIndex() { - return ClassIndex.CLASS; - } - - @Override - public boolean isModule() { - return false; - } - - @Override - public boolean isClass() { - return true; - } - - @Override - public boolean isSingleton() { - return false; - } - - /** boot_defclass - * Create an initial Object meta class before Module and Kernel dependencies have - * squirreled themselves together. - * - * @param runtime we need it - * @return a half-baked meta class for object - */ - public static RubyClass createBootstrapClass(Ruby runtime, String name, RubyClass superClass, ObjectAllocator allocator) { - RubyClass obj; - - if (superClass == null ) { // boot the Object class - obj = new RubyClass(runtime); - obj.marshal = DEFAULT_OBJECT_MARSHAL; - } else { // boot the Module and Class classes - obj = new RubyClass(runtime, superClass); - } - obj.setAllocator(allocator); - obj.setBaseName(name); - return obj; - } - - private final Ruby runtime; - private ObjectAllocator allocator; // the default allocator - protected ObjectMarshal marshal; - private Set<RubyClass> subclasses; - - /** separate path for MetaClass and IncludedModuleWrapper construction - * (rb_class_boot version for MetaClasses) - * no marshal, allocator initialization and addSubclass(this) here! - */ - protected RubyClass(Ruby runtime, RubyClass superClass, boolean objectSpace) { - super(runtime, runtime.getClassClass(), objectSpace); - this.runtime = runtime; - this.superClass = superClass; // this is the only case it might be null here (in MetaClass construction) - } - - /** used by CLASS_ALLOCATOR (any Class' class will be a Class!) - * also used to bootstrap Object class - */ - protected RubyClass(Ruby runtime) { - super(runtime, runtime.getClassClass()); - this.runtime = runtime; - index = ClassIndex.CLASS; - } - - /** rb_class_boot (for plain Classes) - * also used to bootstrap Module and Class classes - */ - protected RubyClass(Ruby runtime, RubyClass superClazz) { - this(runtime); - superClass = superClazz; - marshal = superClazz.marshal; // use parent's marshal - superClazz.addSubclass(this); - - infectBy(superClass); - } - - /** - * A constructor which allows passing in an array of supplementary call sites. - */ - protected RubyClass(Ruby runtime, RubyClass superClazz, CallSite[] extraCallSites) { - this(runtime); - this.superClass = superClazz; - this.marshal = superClazz.marshal; // use parent's marshal - superClazz.addSubclass(this); - - this.extraCallSites = extraCallSites; - - infectBy(superClass); - } - - /** - * Construct a new class with the given name scoped under Object (global) - * and with Object as its immediate superclass. - * Corresponds to rb_class_new in MRI. - */ - public static RubyClass newClass(Ruby runtime, RubyClass superClass) { - if (superClass == runtime.getClassClass()) throw runtime.newTypeError("can't make subclass of Class"); - if (superClass.isSingleton()) throw runtime.newTypeError("can't make subclass of virtual class"); - return new RubyClass(runtime, superClass); - } - - /** - * A variation on newClass that allow passing in an array of supplementary - * call sites to improve dynamic invocation. - */ - public static RubyClass newClass(Ruby runtime, RubyClass superClass, CallSite[] extraCallSites) { - if (superClass == runtime.getClassClass()) throw runtime.newTypeError("can't make subclass of Class"); - if (superClass.isSingleton()) throw runtime.newTypeError("can't make subclass of virtual class"); - return new RubyClass(runtime, superClass, extraCallSites); - } - - /** - * Construct a new class with the given name, allocator, parent class, - * and containing class. If setParent is true, the class's parent will be - * explicitly set to the provided parent (rather than the new class just - * being assigned to a constant in that parent). - * Corresponds to rb_class_new/rb_define_class_id/rb_name_class/rb_set_class_path - * in MRI. - */ - public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent) { - RubyClass clazz = newClass(runtime, superClass); - clazz.setBaseName(name); - clazz.setAllocator(allocator); - clazz.makeMetaClass(superClass.getMetaClass()); - if (setParent) clazz.setParent(parent); - parent.setConstant(name, clazz); - clazz.inherit(superClass); - return clazz; - } - - /** - * A variation on newClass that allows passing in an array of supplementary - * call sites to improve dynamic invocation performance. - */ - public static RubyClass newClass(Ruby runtime, RubyClass superClass, String name, ObjectAllocator allocator, RubyModule parent, boolean setParent, CallSite[] extraCallSites) { - RubyClass clazz = newClass(runtime, superClass, extraCallSites); - clazz.setBaseName(name); - clazz.setAllocator(allocator); - clazz.makeMetaClass(superClass.getMetaClass()); - if (setParent) clazz.setParent(parent); - parent.setConstant(name, clazz); - clazz.inherit(superClass); - return clazz; - } - - /** rb_make_metaclass - * - */ - @Override - public RubyClass makeMetaClass(RubyClass superClass) { - if (isSingleton()) { // could be pulled down to RubyClass in future - MetaClass klass = new MetaClass(getRuntime(), superClass); // rb_class_boot - setMetaClass(klass); - - klass.setAttached(this); - klass.setMetaClass(klass); - klass.setSuperClass(getSuperClass().getRealClass().getMetaClass()); - - return klass; - } else { - return super.makeMetaClass(superClass); - } - } - - @Deprecated - public IRubyObject invoke(ThreadContext context, IRubyObject self, int methodIndex, String name, IRubyObject[] args, CallType callType, Block block) { - return invoke(context, self, name, args, callType, block); - } - - public boolean notVisibleAndNotMethodMissing(DynamicMethod method, String name, IRubyObject caller, CallType callType) { - return !method.isCallableFrom(caller, callType) && !name.equals("method_missing"); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - CallType callType, Block block) { - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, caller, callType, block); - } - return method.call(context, self, this, name, block); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, Block block) { - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, context.getFrameSelf(), CallType.FUNCTIONAL, block); - } - return method.call(context, self, this, name, block); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - IRubyObject[] args, CallType callType, Block block) { - assert args != null; - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, args, caller, callType, block); - } - return method.call(context, self, this, name, args, block); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, - IRubyObject[] args, Block block) { - assert args != null; - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, args, context.getFrameSelf(), CallType.FUNCTIONAL, block); - } - return method.call(context, self, this, name, args, block); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg, CallType callType, Block block) { - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg, caller, callType, block); - } - return method.call(context, self, this, name, arg, block); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg, Block block) { - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg, context.getFrameSelf(), CallType.FUNCTIONAL, block); - } - return method.call(context, self, this, name, arg, block); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg0, IRubyObject arg1, CallType callType, Block block) { - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg0, arg1, caller, callType, block); - } - return method.call(context, self, this, name, arg0, arg1, block); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg0, IRubyObject arg1, Block block) { - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg0, arg1, context.getFrameSelf(), CallType.FUNCTIONAL, block); - } - return method.call(context, self, this, name, arg0, arg1, block); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, CallType callType, Block block) { - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg0, arg1, arg2, caller, callType, block); - } - return method.call(context, self, this, name, arg0, arg1, arg2, block); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) { - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg0, arg1, arg2, context.getFrameSelf(), CallType.FUNCTIONAL, block); - } - return method.call(context, self, this, name, arg0, arg1, arg2, block); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - CallType callType) { - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, caller, callType, Block.NULL_BLOCK); - } - return method.call(context, self, this, name); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name) { - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, context.getFrameSelf(), CallType.FUNCTIONAL, Block.NULL_BLOCK); - } - return method.call(context, self, this, name); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - IRubyObject[] args, CallType callType) { - assert args != null; - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, args, caller, callType, Block.NULL_BLOCK); - } - return method.call(context, self, this, name, args); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, - IRubyObject[] args) { - assert args != null; - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, args, context.getFrameSelf(), CallType.FUNCTIONAL, Block.NULL_BLOCK); - } - return method.call(context, self, this, name, args); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg, CallType callType) { - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg, caller, callType, Block.NULL_BLOCK); - } - return method.call(context, self, this, name, arg); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg) { - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg, context.getFrameSelf(), CallType.FUNCTIONAL, Block.NULL_BLOCK); - } - return method.call(context, self, this, name, arg); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg0, IRubyObject arg1, CallType callType) { - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg0, arg1, caller, callType, Block.NULL_BLOCK); - } - return method.call(context, self, this, name, arg0, arg1); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg0, IRubyObject arg1) { - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg0, arg1, context.getFrameSelf(), CallType.FUNCTIONAL, Block.NULL_BLOCK); - } - return method.call(context, self, this, name, arg0, arg1); - } - - public IRubyObject invoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, CallType callType) { - DynamicMethod method = searchMethod(name); - IRubyObject caller = context.getFrameSelf(); - if (shouldCallMethodMissing(method, name, caller, callType)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg0, arg1, arg2, caller, callType, Block.NULL_BLOCK); - } - return method.call(context, self, this, name, arg0, arg1, arg2); - } - - public IRubyObject finvoke(ThreadContext context, IRubyObject self, String name, - IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) { - DynamicMethod method = searchMethod(name); - if (shouldCallMethodMissing(method)) { - return RuntimeHelpers.callMethodMissing(context, self, method, name, arg0, arg1, arg2, context.getFrameSelf(), CallType.FUNCTIONAL, Block.NULL_BLOCK); - } - return method.call(context, self, this, name, arg0, arg1, arg2); - } - - private boolean shouldCallMethodMissing(DynamicMethod method) { - return method.isUndefined(); - } - private boolean shouldCallMethodMissing(DynamicMethod method, String name, IRubyObject caller, CallType callType) { - return method.isUndefined() || notVisibleAndNotMethodMissing(method, name, caller, callType); - } - - public IRubyObject invokeInherited(ThreadContext context, IRubyObject self, IRubyObject subclass) { - DynamicMethod method = getMetaClass().searchMethod("inherited"); - - if (method.isUndefined()) { - return RuntimeHelpers.callMethodMissing(context, self, method, "inherited", subclass, context.getFrameSelf(), CallType.FUNCTIONAL, Block.NULL_BLOCK); - } - - return method.call(context, self, getMetaClass(), "inherited", subclass, Block.NULL_BLOCK); - } - - /** rb_class_new_instance - * - */ - public IRubyObject newInstance(ThreadContext context, IRubyObject[] args, Block block) { - IRubyObject obj = allocate(); - baseCallSites[CS_IDX_INITIALIZE].call(context, obj, args, block); - return obj; - } - - // TODO: replace this with a smarter generated invoker that can handle 0-N args - public static class SpecificArityNew extends JavaMethod { - public SpecificArityNew(RubyModule implClass, Visibility visibility) { - super(implClass, visibility); - } - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) { - RubyClass cls = (RubyClass)self; - IRubyObject obj = cls.allocate(); - cls.baseCallSites[CS_IDX_INITIALIZE].call(context, obj, args, block); - return obj; - } - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, Block block) { - RubyClass cls = (RubyClass)self; - IRubyObject obj = cls.allocate(); - cls.baseCallSites[CS_IDX_INITIALIZE].call(context, obj, block); - return obj; - } - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg0, Block block) { - RubyClass cls = (RubyClass)self; - IRubyObject obj = cls.allocate(); - cls.baseCallSites[CS_IDX_INITIALIZE].call(context, obj, arg0, block); - return obj; - } - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg0, IRubyObject arg1, Block block) { - RubyClass cls = (RubyClass)self; - IRubyObject obj = cls.allocate(); - cls.baseCallSites[CS_IDX_INITIALIZE].call(context, obj, arg0, arg1, block); - return obj; - } - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) { - RubyClass cls = (RubyClass)self; - IRubyObject obj = cls.allocate(); - cls.baseCallSites[CS_IDX_INITIALIZE].call(context, obj, arg0, arg1, arg2, block); - return obj; - } - } - - /** rb_class_initialize - * - */ - @JRubyMethod(name = "initialize", optional = 1, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, Block block) { - if (superClass != null) { - throw getRuntime().newTypeError("already initialized class"); - } - - IRubyObject superObject; - if (args.length == 0) { - superObject = getRuntime().getObject(); - } else { - superObject = args[0]; - checkInheritable(superObject); - } - - RubyClass superClazz = (RubyClass) superObject; - - superClass = superClazz; - allocator = superClazz.allocator; - makeMetaClass(superClazz.getMetaClass()); - - marshal = superClazz.marshal; - - superClazz.addSubclass(this); - - super.initialize(block); - - inherit(superClazz); - - return this; - } - - /** rb_class_init_copy - * - */ - @JRubyMethod(name = "initialize_copy", required = 1) - @Override - public IRubyObject initialize_copy(IRubyObject original){ - if (superClass != null) throw runtime.newTypeError("already initialized class"); - if (original instanceof MetaClass) throw getRuntime().newTypeError("can't copy singleton class"); - - super.initialize_copy(original); - allocator = ((RubyClass)original).allocator; - return this; - } - - // TODO: Someday, enable. - // @JRubyMethod(name = "subclasses", optional = 1) - public IRubyObject subclasses(ThreadContext context, IRubyObject[] args) { - boolean recursive = false; - if (args.length == 1) { - if (args[0] instanceof RubyBoolean) { - recursive = args[0].isTrue(); - } else { - context.getRuntime().newTypeError(args[0], context.getRuntime().fastGetClass("Boolean")); - } - } - - return RubyArray.newArray(context.getRuntime(), subclasses(recursive)).freeze(context); - } - - public Collection subclasses(boolean includeDescendants) { - if (subclasses != null) { - Collection<RubyClass> mine = new ArrayList<RubyClass>(subclasses); - if (includeDescendants) { - for (RubyClass i: subclasses) { - mine.addAll(i.subclasses(includeDescendants)); - } - } - - return mine; - } else { - return Collections.EMPTY_LIST; - } - } - - public synchronized void addSubclass(RubyClass subclass) { - if (subclasses == null) subclasses = new WeakHashSet<RubyClass>(); - subclasses.add(subclass); - } - - public Ruby getClassRuntime() { - return runtime; - } - - public RubyClass getRealClass() { - return this; - } - - @JRubyMethod(name = "inherited", required = 1) - public IRubyObject inherited(ThreadContext context, IRubyObject arg) { - return context.getRuntime().getNil(); - } - - /** rb_class_inherited (reversed semantics!) - * - */ - public void inherit(RubyClass superClazz) { - if (superClazz == null) superClazz = getRuntime().getObject(); - - superClazz.invokeInherited(getRuntime().getCurrentContext(), superClazz, this); - } - - /** Return the real super class of this class. - * - * rb_class_superclass - * - */ - @JRubyMethod(name = "superclass") - public IRubyObject superclass(ThreadContext context) { - RubyClass superClazz = superClass; - - if (superClazz == null) throw context.getRuntime().newTypeError("uninitialized class"); - - if (isSingleton()) superClazz = metaClass; - while (superClazz != null && superClazz.isIncluded()) superClazz = superClazz.superClass; - - return superClazz != null ? superClazz : context.getRuntime().getNil(); - } - - /** rb_check_inheritable - * - */ - public static void checkInheritable(IRubyObject superClass) { - if (!(superClass instanceof RubyClass)) { - throw superClass.getRuntime().newTypeError("superclass must be a Class (" + superClass.getMetaClass() + " given)"); - } - if (((RubyClass)superClass).isSingleton()) { - throw superClass.getRuntime().newTypeError("can't make subclass of virtual class"); - } - } - - public final ObjectMarshal getMarshal() { - return marshal; - } - - public final void setMarshal(ObjectMarshal marshal) { - this.marshal = marshal; - } - - public final void marshal(Object obj, MarshalStream marshalStream) throws IOException { - getMarshal().marshalTo(getRuntime(), obj, this, marshalStream); - } - - public final Object unmarshal(UnmarshalStream unmarshalStream) throws IOException { - return getMarshal().unmarshalFrom(getRuntime(), this, unmarshalStream); - } - - public static void marshalTo(RubyClass clazz, MarshalStream output) throws java.io.IOException { - output.registerLinkTarget(clazz); - output.writeString(MarshalStream.getPathFromClass(clazz)); - } - - public static RubyClass unmarshalFrom(UnmarshalStream input) throws java.io.IOException { - String name = RubyString.byteListToString(input.unmarshalString()); - RubyClass result = UnmarshalStream.getClassFromPath(input.getRuntime(), name); - input.registerLinkTarget(result); - return result; - } - - protected static final ObjectMarshal DEFAULT_OBJECT_MARSHAL = new ObjectMarshal() { - public void marshalTo(Ruby runtime, Object obj, RubyClass type, - MarshalStream marshalStream) throws IOException { - IRubyObject object = (IRubyObject)obj; - - marshalStream.registerLinkTarget(object); - marshalStream.dumpVariables(object.getVariableList()); - } - - public Object unmarshalFrom(Ruby runtime, RubyClass type, - UnmarshalStream unmarshalStream) throws IOException { - IRubyObject result = type.allocate(); - - unmarshalStream.registerLinkTarget(result); - - unmarshalStream.defaultVariablesUnmarshal(result); - - return result; - } - }; -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.File; -import java.net.MalformedURLException; -import java.net.URL; -import org.jruby.anno.JRubyMethod; - -import org.jruby.runtime.Block; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -public class RubyClassPathVariable extends RubyObject { - public static void createClassPathVariable(Ruby runtime) { - RubyClassPathVariable self = new RubyClassPathVariable(runtime); - runtime.getEnumerable().extend_object(self); - runtime.defineReadonlyVariable("$CLASSPATH", self); - - self.getMetaClass().defineAnnotatedMethods(RubyClassPathVariable.class); - } - - private RubyClassPathVariable(Ruby runtime) { - super(runtime, runtime.getObject()); - } - - @JRubyMethod(name = {"append", "<<"}, required = 1) - public IRubyObject append(IRubyObject obj) throws Exception { - String ss = obj.convertToString().toString(); - URL url = getURL(ss); - getRuntime().getJRubyClassLoader().addURL(url); - return this; - } - - private URL getURL(String target) throws MalformedURLException { - if(target.indexOf("://") == -1) { - return new File(target).toURI().toURL(); - } else { - return new URL(target); - } - } - - @JRubyMethod(name = {"size", "length"}) - public IRubyObject size() { - return getRuntime().newFixnum(getRuntime().getJRubyClassLoader().getURLs().length); - } - - @JRubyMethod(name = "each", frame = true) - public IRubyObject each(Block block) { - URL[] urls = getRuntime().getJRubyClassLoader().getURLs(); - ThreadContext ctx = getRuntime().getCurrentContext(); - for(int i=0,j=urls.length;i<j;i++) { - block.yield(ctx, getRuntime().newString(urls[i].toString())); - } - return getRuntime().getNil(); - } - - @JRubyMethod(name = "to_s") - public IRubyObject to_s() { - return callMethod(getRuntime().getCurrentContext(), "to_a").callMethod(getRuntime().getCurrentContext(), "to_s"); - } - - @JRubyMethod(name = "inspect") - public IRubyObject inspect() { - return callMethod(getRuntime().getCurrentContext(), "to_a").callMethod(getRuntime().getCurrentContext(), "inspect"); - } -}// RubyClassPathVariable -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2006 Thomas E Enebo <enebo@acm.org> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.exceptions.RaiseException; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -/** Implementation of the Comparable module. - * - */ -@JRubyModule(name="Comparable") -public class RubyComparable { - public static RubyModule createComparable(Ruby runtime) { - RubyModule comparableModule = runtime.defineModule("Comparable"); - runtime.setComparable(comparableModule); - - comparableModule.defineAnnotatedMethods(RubyComparable.class); - - return comparableModule; - } - - /* ================ - * Utility Methods - * ================ - */ - - /** rb_cmpint - * - */ - public static int cmpint(ThreadContext context, IRubyObject val, IRubyObject a, IRubyObject b) { - if (val.isNil()) cmperr(a, b); - if (val instanceof RubyFixnum) return RubyNumeric.fix2int((RubyFixnum) val); - if (val instanceof RubyBignum) return ((RubyBignum) val).getValue().signum() == -1 ? 1 : -1; - - RubyFixnum zero = RubyFixnum.zero(context.getRuntime()); - - if (val.callMethod(context, MethodIndex.OP_GT, ">", zero).isTrue()) return 1; - if (val.callMethod(context, MethodIndex.OP_LT, "<", zero).isTrue()) return -1; - - return 0; - } - - /** rb_cmperr - * - */ - public static IRubyObject cmperr(IRubyObject recv, IRubyObject other) { - IRubyObject target; - if (other.isImmediate() || !(other.isNil() || other.isTrue() || other == recv.getRuntime().getFalse())) { - target = other.inspect(); - } else { - target = other.getType(); - } - - throw recv.getRuntime().newArgumentError("comparison of " + recv.getType() + " with " + target + " failed"); - } - - /* ================ - * Module Methods - * ================ - */ - - /** cmp_equal (cmp_eq inlined here) - * - */ - @JRubyMethod(name = "==", required = 1) - public static IRubyObject op_equal(ThreadContext context, IRubyObject recv, IRubyObject other) { - Ruby runtime = context.getRuntime(); - - if (recv == other) return runtime.getTrue(); - - try { - IRubyObject result = recv.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", other); - - return RubyBoolean.newBoolean(runtime, cmpint(context, result, recv, other) == 0); - } catch (RaiseException e) { - if (e.getException().kind_of_p(context, runtime.getStandardError()).isTrue()) { - return runtime.getNil(); - } else { - throw e; - } - } - } - - /** cmp_gt - * - */ - // <=> may return nil in many circumstances, e.g. 3 <=> NaN - @JRubyMethod(name = ">", required = 1) - public static RubyBoolean op_gt(ThreadContext context, IRubyObject recv, IRubyObject other) { - IRubyObject result = recv.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", other); - - if (result.isNil()) cmperr(recv, other); - - return RubyBoolean.newBoolean(context.getRuntime(), cmpint(context, result, recv, other) > 0); - } - - /** cmp_ge - * - */ - @JRubyMethod(name = ">=", required = 1) - public static RubyBoolean op_ge(ThreadContext context, IRubyObject recv, IRubyObject other) { - IRubyObject result = recv.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", other); - - if (result.isNil()) cmperr(recv, other); - - return RubyBoolean.newBoolean(context.getRuntime(), cmpint(context, result, recv, other) >= 0); - } - - /** cmp_lt - * - */ - @JRubyMethod(name = "<", required = 1) - public static RubyBoolean op_lt(ThreadContext context, IRubyObject recv, IRubyObject other) { - IRubyObject result = recv.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", other); - - if (result.isNil()) cmperr(recv, other); - - return RubyBoolean.newBoolean(context.getRuntime(), cmpint(context, result, recv, other) < 0); - } - - /** cmp_le - * - */ - @JRubyMethod(name = "<=", required = 1) - public static RubyBoolean op_le(ThreadContext context, IRubyObject recv, IRubyObject other) { - IRubyObject result = recv.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", other); - - if (result.isNil()) cmperr(recv, other); - - return RubyBoolean.newBoolean(context.getRuntime(), cmpint(context, result, recv, other) <= 0); - } - - /** cmp_between - * - */ - @JRubyMethod(name = "between?", required = 2) - public static RubyBoolean between_p(ThreadContext context, IRubyObject recv, IRubyObject first, IRubyObject second) { - return context.getRuntime().newBoolean(op_lt(context, recv, first).isFalse() && op_gt(context, recv, second).isFalse()); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import static org.jruby.util.Numeric.f_abs; -import static org.jruby.util.Numeric.f_abs2; -import static org.jruby.util.Numeric.f_add; -import static org.jruby.util.Numeric.f_arg; -import static org.jruby.util.Numeric.f_conjugate; -import static org.jruby.util.Numeric.f_denominator; -import static org.jruby.util.Numeric.f_div; -import static org.jruby.util.Numeric.f_divmod; -import static org.jruby.util.Numeric.f_equal_p; -import static org.jruby.util.Numeric.f_exact_p; -import static org.jruby.util.Numeric.f_expt; -import static org.jruby.util.Numeric.f_gt_p; -import static org.jruby.util.Numeric.f_inspect; -import static org.jruby.util.Numeric.f_lcm; -import static org.jruby.util.Numeric.f_mul; -import static org.jruby.util.Numeric.f_negate; -import static org.jruby.util.Numeric.f_negative_p; -import static org.jruby.util.Numeric.f_numerator; -import static org.jruby.util.Numeric.f_one_p; -import static org.jruby.util.Numeric.f_polar; -import static org.jruby.util.Numeric.f_quo; -import static org.jruby.util.Numeric.f_scalar_p; -import static org.jruby.util.Numeric.f_sub; -import static org.jruby.util.Numeric.f_to_f; -import static org.jruby.util.Numeric.f_to_i; -import static org.jruby.util.Numeric.f_to_r; -import static org.jruby.util.Numeric.f_to_s; -import static org.jruby.util.Numeric.f_xor; -import static org.jruby.util.Numeric.f_zero_p; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.runtime.Arity; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.Frame; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.Numeric; - -/** - * 1.9 complex.c as of revision: 18876 - */ - -@JRubyClass(name = "Complex", parent = "Numeric") -public class RubyComplex extends RubyNumeric { - - public static RubyClass createComplexClass(Ruby runtime) { - RubyClass complexc = runtime.defineClass("Complex", runtime.getNumeric(), COMPLEX_ALLOCATOR); // because one can Complex.send(:allocate) - runtime.setComplex(complexc); - - complexc.index = ClassIndex.COMPLEX; - complexc.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyComplex; - } - }; - - ThreadContext context = runtime.getCurrentContext(); - complexc.callMethod(context, "private_class_method", runtime.newSymbol("allocate")); - - complexc.defineAnnotatedMethods(RubyComplex.class); - - String[]undefined = {"<", "<=", "<=>", ">", ">=", "between?", "divmod", - "floor", "ceil", "modulo", "round", "step", "truncate"}; - - for (String undef : undefined) { - complexc.undefineMethod(undef); - } - - complexc.defineConstant("I", RubyComplex.newComplexConvert(context, RubyFixnum.zero(runtime), RubyFixnum.one(runtime))); - - return complexc; - } - - private static ObjectAllocator COMPLEX_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyComplex(runtime, klass, RubyFixnum.zero(runtime), RubyFixnum.zero(runtime)); - } - }; - - /** internal - * - */ - private RubyComplex(Ruby runtime, IRubyObject clazz, IRubyObject real, IRubyObject image) { - super(runtime, (RubyClass)clazz); - this.real = real; - this.image = image; - } - - /** rb_complex_raw - * - */ - static RubyComplex newComplexRaw(Ruby runtime, IRubyObject x, RubyObject y) { - return new RubyComplex(runtime, runtime.getComplex(), x, y); - } - - /** rb_complex_raw1 - * - */ - static RubyComplex newComplexRaw(Ruby runtime, IRubyObject x) { - return new RubyComplex(runtime, runtime.getComplex(), x, RubyFixnum.zero(runtime)); - } - - /** rb_complex_new1 - * - */ - public static IRubyObject newComplexCanonicalize(ThreadContext context, IRubyObject x) { - return newComplexCanonicalize(context, x, RubyFixnum.zero(context.getRuntime())); - } - - /** rb_complex_new - * - */ - public static IRubyObject newComplexCanonicalize(ThreadContext context, IRubyObject x, IRubyObject y) { - return canonicalizeInternal(context, context.getRuntime().getComplex(), x, y); - } - - /** rb_complex_polar - * - */ - static IRubyObject newComplexPolar(ThreadContext context, IRubyObject x, IRubyObject y) { - return polar(context, context.getRuntime().getComplex(), x, y); - } - - /** f_complex_new1 - * - */ - static IRubyObject newComplex(ThreadContext context, IRubyObject clazz, IRubyObject x) { - return newComplex(context, clazz, x, RubyFixnum.zero(context.getRuntime())); - } - - /** f_complex_new2 - * - */ - static IRubyObject newComplex(ThreadContext context, IRubyObject clazz, IRubyObject x, IRubyObject y) { - assert !(x instanceof RubyComplex); - return canonicalizeInternal(context, clazz, x, y); - } - - /** f_complex_new_bang2 - * - */ - static RubyComplex newComplexBang(ThreadContext context, IRubyObject clazz, IRubyObject x, IRubyObject y) { - assert x instanceof RubyComplex && y instanceof RubyComplex; - return new RubyComplex(context.getRuntime(), clazz, x, y); - } - - /** f_complex_new_bang1 - * - */ - public static RubyComplex newComplexBang(ThreadContext context, IRubyObject clazz, IRubyObject x) { - assert x instanceof RubyComplex; - return newComplexBang(context, clazz, x, RubyFixnum.zero(context.getRuntime())); - } - - private IRubyObject real; - private IRubyObject image; - - IRubyObject getImage() { - return image; - } - - IRubyObject getReal() { - return real; - } - - /** m_cos - * - */ - private static IRubyObject m_cos(ThreadContext context, IRubyObject x) { - if (f_scalar_p(context, x).isTrue()) return RubyMath.cos(x, x); - RubyComplex complex = (RubyComplex)x; - return newComplex(context, context.getRuntime().getComplex(), - f_mul(context, RubyMath.cos(x, complex.real), RubyMath.cosh(x, complex.image)), - f_mul(context, f_negate(context, RubyMath.sin(x, complex.real)), RubyMath.sinh(x, complex.image))); - } - - /** m_sin - * - */ - private static IRubyObject m_sin(ThreadContext context, IRubyObject x) { - if (f_scalar_p(context, x).isTrue()) return RubyMath.sin(x, x); - RubyComplex complex = (RubyComplex)x; - return newComplex(context, context.getRuntime().getComplex(), - f_mul(context, RubyMath.sin(x, complex.real), RubyMath.cosh(x, complex.image)), - f_mul(context, RubyMath.cos(x, complex.real), RubyMath.sinh(x, complex.image))); - } - - /** m_sqrt - * - */ - private static IRubyObject m_sqrt(ThreadContext context, IRubyObject x) { - if (f_scalar_p(context, x).isTrue()) { - if (!f_negative_p(context, x)) return RubyMath.sqrt(x, x); - return newComplex(context, context.getRuntime().getComplex(), - RubyFixnum.zero(context.getRuntime()), - RubyMath.sqrt(x, f_negate(context, x))); - } else { - RubyComplex complex = (RubyComplex)x; - if (f_negative_p(context, complex.image)) { - return f_conjugate(context, m_sqrt(context, f_conjugate(context, x))); - } else { - IRubyObject a = f_abs(context, x); - IRubyObject two = RubyFixnum.two(context.getRuntime()); - return newComplex(context, context.getRuntime().getComplex(), - RubyMath.sqrt(x, f_div(context, f_add(context, a, complex.real), two)), - RubyMath.sqrt(x, f_div(context, f_sub(context, a, complex.real), two))); - } - } - } - - /** nucomp_s_new_bang - * - */ - @Deprecated - public static IRubyObject newInstanceBang(ThreadContext context, IRubyObject recv, IRubyObject[]args) { - switch (args.length) { - case 1: return newInstanceBang(context, recv, args[0]); - case 2: return newInstanceBang(context, recv, args[0], args[1]); - } - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 1); - return null; - } - - @JRubyMethod(name = "new!", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject newInstanceBang(ThreadContext context, IRubyObject recv, IRubyObject real) { - if (!(real instanceof RubyNumeric)) real = f_to_i(context, real); - return new RubyComplex(context.getRuntime(), recv, real, RubyFixnum.zero(context.getRuntime())); - } - - @JRubyMethod(name = "new!", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject newInstanceBang(ThreadContext context, IRubyObject recv, IRubyObject real, IRubyObject image) { - if (!(real instanceof RubyNumeric)) real = f_to_i(context, real); - if (!(image instanceof RubyNumeric)) image = f_to_i(context, image); - return new RubyComplex(context.getRuntime(), recv, real, image); - } - - /** nucomp_real_check (might go to bimorphic) - * - */ - private static void realCheck(ThreadContext context, IRubyObject num) { - switch (num.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - case ClassIndex.RATIONAL: - break; - default: - if (!(num instanceof RubyNumeric ) || !f_scalar_p(context, num).isTrue()) { - throw context.getRuntime().newArgumentError("not a real"); - } - } - } - - /** nucomp_s_canonicalize_internal - * - */ - private static final boolean CL_CANNON = true; - private static IRubyObject canonicalizeInternal(ThreadContext context, IRubyObject clazz, IRubyObject real, IRubyObject image) { - if (f_zero_p(context, image) && - ((RubyModule)clazz).fastHasConstant("Unify") && - (!CL_CANNON || - (!(real instanceof RubyFloat) && - !(image instanceof RubyFloat)))) { - return real; - } else if (f_scalar_p(context, real).isTrue() && - f_scalar_p(context, image).isTrue()) { - return new RubyComplex(context.getRuntime(), clazz, real, image); - } else if (f_scalar_p(context, real).isTrue()) { - RubyComplex complex = (RubyComplex)image; - return new RubyComplex(context.getRuntime(), clazz, - f_sub(context, real, complex.image), - f_add(context, RubyFixnum.zero(context.getRuntime()), complex.real)); - } else if (f_scalar_p(context, image).isTrue()) { - RubyComplex complex = (RubyComplex)real; - return new RubyComplex(context.getRuntime(), clazz, - complex.real, - f_add(context, complex.image, image)); - } else { - RubyComplex complex1 = (RubyComplex)real; - RubyComplex complex2 = (RubyComplex)image; - return new RubyComplex(context.getRuntime(), clazz, - f_sub(context, complex1.real, complex2.image), - f_add(context, complex1.image, complex2.real)); - } - } - - /** nucomp_s_new - * - */ - @Deprecated - public static IRubyObject newInstance(ThreadContext context, IRubyObject recv, IRubyObject[]args) { - switch (args.length) { - case 1: return newInstance(context, recv, args[0]); - case 2: return newInstance(context, recv, args[0], args[1]); - } - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 1); - return null; - } - - @JRubyMethod(name = {"new", "rect", "rectangular"}, meta = true) - public static IRubyObject newInstance(ThreadContext context, IRubyObject recv, IRubyObject real) { - realCheck(context, real); - return canonicalizeInternal(context, recv, real, RubyFixnum.zero(context.getRuntime())); - } - - @JRubyMethod(name = {"new", "rect", "rectangular"}, meta = true) - public static IRubyObject newInstance(ThreadContext context, IRubyObject recv, IRubyObject real, IRubyObject image) { - realCheck(context, real); - realCheck(context, image); - return canonicalizeInternal(context, recv, real, image); - } - - /** f_complex_polar - * - */ - private static IRubyObject f_complex_polar(ThreadContext context, IRubyObject clazz, IRubyObject x, IRubyObject y) { - assert !(x instanceof RubyComplex) && !(y instanceof RubyComplex); - return canonicalizeInternal(context, clazz, - f_mul(context, x, m_cos(context, y)), - f_mul(context, x, m_sin(context, y))); - } - - /** nucomp_s_polar - * - */ - @JRubyMethod(name = "polar", meta = true) - public static IRubyObject polar(ThreadContext context, IRubyObject clazz, IRubyObject abs, IRubyObject arg) { - return f_complex_polar(context, clazz, abs, arg); - } - - /** rb_Complex1 - * - */ - public static IRubyObject newComplexConvert(ThreadContext context, IRubyObject x) { - return newComplexConvert(context, x, RubyFixnum.zero(context.getRuntime())); - } - - /** rb_Complex/rb_Complex2 - * - */ - public static IRubyObject newComplexConvert(ThreadContext context, IRubyObject x, IRubyObject y) { - return convert(context, context.getRuntime().getComplex(), x, y); - } - - @Deprecated - public static IRubyObject convert(ThreadContext context, IRubyObject clazz, IRubyObject[]args) { - switch (args.length) { - case 0: return convert(context, clazz); - case 1: return convert(context, clazz, args[0]); - case 2: return convert(context, clazz, args[0], args[1]); - } - Arity.raiseArgumentError(context.getRuntime(), args.length, 0, 2); - return null; - } - - /** nucomp_s_convert - * - */ - @JRubyMethod(name = "convert", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject convert(ThreadContext context, IRubyObject recv) { - IRubyObject nil = context.getRuntime().getNil(); - return convertCommon(context, recv, nil, nil); - } - - /** nucomp_s_convert - * - */ - @JRubyMethod(name = "convert", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject convert(ThreadContext context, IRubyObject recv, IRubyObject a1) { - return convertCommon(context, recv, a1, context.getRuntime().getNil()); - } - - /** nucomp_s_convert - * - */ - @JRubyMethod(name = "convert", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject convert(ThreadContext context, IRubyObject recv, IRubyObject a1, IRubyObject a2) { - return convertCommon(context, recv, a1, a2); - } - - private static IRubyObject convertCommon(ThreadContext context, IRubyObject recv, IRubyObject a1, IRubyObject a2) { - Frame frame = context.getCurrentFrame(); - IRubyObject backref = frame.getBackRef(); - if (backref != null && backref instanceof RubyMatchData) ((RubyMatchData)backref).use(); - - if (a1 instanceof RubyString) a1 = str_to_c_strict(context, a1); - if (a2 instanceof RubyString) a2 = str_to_c_strict(context, a2); - - frame.setBackRef(backref); - - if (a1 instanceof RubyComplex) { - RubyComplex a1Complex = (RubyComplex)a1; - if (!(a1Complex.image instanceof RubyFloat) && f_zero_p(context, a1Complex.image)) { - a1 = a1Complex.real; - } - } - - if (a2 instanceof RubyComplex) { - RubyComplex a2Complex = (RubyComplex)a2; - if (!(a2Complex.image instanceof RubyFloat) && f_zero_p(context, a2Complex.image)) { - a2 = a2Complex.real; - } - } - - if (a1 instanceof RubyComplex) { - if (a2.isNil() || f_zero_p(context, a2)) return a1; - } - return a2.isNil() ? newInstance(context, recv, a1) : newInstance(context, recv, a1, a2); - } - - /** nucomp_real - * - */ - @JRubyMethod(name = "real") - public IRubyObject real() { - return real; - } - - /** nucomp_image - * - */ - @JRubyMethod(name = {"image", "imag"}) - public IRubyObject image() { - return image; - } - - /** nucomp_add - * - */ - @JRubyMethod(name = "+") - public IRubyObject op_add(ThreadContext context, IRubyObject other) { - if (other instanceof RubyComplex) { - RubyComplex otherComplex = (RubyComplex)other; - return newComplex(context, getMetaClass(), - f_add(context, real, otherComplex.real), - f_add(context, image, otherComplex.image)); - } else if (other instanceof RubyNumeric && f_scalar_p(context, other).isTrue()) { - return newComplex(context, getMetaClass(), f_add(context, real, other), image); - } - return coerceBin(context, "+", other); - } - - /** nucomp_sub - * - */ - @JRubyMethod(name = "-") - public IRubyObject op_sub(ThreadContext context, IRubyObject other) { - if (other instanceof RubyComplex) { - RubyComplex otherComplex = (RubyComplex)other; - return newComplex(context, getMetaClass(), - f_sub(context, real, otherComplex.real), - f_sub(context, image, otherComplex.image)); - } else if (other instanceof RubyNumeric && f_scalar_p(context, other).isTrue()) { - return newComplex(context, getMetaClass(), f_sub(context, real, other), image); - } - return coerceBin(context, "-", other); - } - - /** nucomp_mul - * - */ - @JRubyMethod(name = "*") - public IRubyObject op_mul(ThreadContext context, IRubyObject other) { - if (other instanceof RubyComplex) { - RubyComplex otherComplex = (RubyComplex)other; - IRubyObject realp = f_sub(context, - f_mul(context, real, otherComplex.real), - f_mul(context, image, otherComplex.image)); - IRubyObject imagep = f_add(context, - f_mul(context, real, otherComplex.image), - f_mul(context, image, otherComplex.real)); - - return newComplex(context, getMetaClass(), realp, imagep); - } else if (other instanceof RubyNumeric && f_scalar_p(context, other).isTrue()) { - return newComplex(context, getMetaClass(), - f_mul(context, real, other), - f_mul(context, image, other)); - } - return coerceBin(context, "*", other); - } - - /** nucomp_div - * - */ - @JRubyMethod(name = "/") - public IRubyObject op_div(ThreadContext context, IRubyObject other) { - if (other instanceof RubyComplex) { - RubyComplex otherComplex = (RubyComplex)other; - if (real instanceof RubyFloat || image instanceof RubyFloat || - otherComplex.real instanceof RubyFloat || otherComplex.image instanceof RubyFloat) { - IRubyObject magn = RubyMath.hypot(this, otherComplex.real, otherComplex.image); - IRubyObject tmp = newComplexBang(context, getMetaClass(), - f_quo(context, otherComplex.real, magn), - f_quo(context, otherComplex.image, magn)); - return f_quo(context, f_mul(context, this, f_conjugate(context, tmp)), magn); - } - return f_quo(context, f_mul(context, this, f_conjugate(context, other)), f_abs2(context, other)); - } else if (other instanceof RubyNumeric && f_scalar_p(context, other).isTrue()) { - return newComplex(context, getMetaClass(), - f_quo(context, real, other), - f_quo(context, image, other)); - } - return coerceBin(context, "/", other); - } - - /** nucomp_fdiv / nucomp_quo - * - */ - @JRubyMethod(name = {"fdiv", "quo"}) - public IRubyObject fdiv(ThreadContext context, IRubyObject other) { - IRubyObject complex = newComplex(context, getMetaClass(), - f_to_f(context, real), - f_to_f(context, image)); - - return f_div(context, complex, other); - } - - /** nucomp_expt - * - */ - @JRubyMethod(name = "**") - public IRubyObject op_expt(ThreadContext context, IRubyObject other) { - if (f_zero_p(context, other)) { - return newComplexBang(context, getMetaClass(), RubyFixnum.one(context.getRuntime())); - } else if (other instanceof RubyRational && f_one_p(context, f_denominator(context, other))) { - other = f_numerator(context, other); - } - - if (other instanceof RubyComplex) { - RubyArray a = f_polar(context, this).convertToArray(); - IRubyObject r = a.eltInternal(0); - IRubyObject theta = a.eltInternal(1); - RubyComplex otherComplex = (RubyComplex)other; - IRubyObject nr = RubyMath.exp(this, f_sub(context, - f_mul(context, otherComplex.real, RubyMath.log(this, r)), - f_mul(context, otherComplex.image, theta))); - IRubyObject ntheta = f_add(context, - f_mul(context, theta, otherComplex.real), - f_mul(context, otherComplex.image, RubyMath.log(this, r))); - return polar(context, getMetaClass(), nr, ntheta); - } else if (other instanceof RubyInteger) { - IRubyObject one = RubyFixnum.one(context.getRuntime()); - if (f_gt_p(context, other, RubyFixnum.zero(context.getRuntime())).isTrue()) { - IRubyObject x = this; - IRubyObject z = x; - IRubyObject n = f_sub(context, other, one); - - IRubyObject two = RubyFixnum.two(context.getRuntime()); - - while (!f_zero_p(context, n)) { - - RubyArray a = f_divmod(context, n, two).convertToArray(); - - while (f_zero_p(context, a.eltInternal(1))) { - RubyComplex xComplex = (RubyComplex)x; - x = newComplex(context, getMetaClass(), - f_sub(context, f_mul(context, xComplex.real, xComplex.real), - f_mul(context, xComplex.image, xComplex.image)), - f_mul(context, f_mul(context, two, xComplex.real), xComplex.image)); - - n = a.eltInternal(0); - a = f_divmod(context, n, two).convertToArray(); - } - z = f_mul(context, z, x); - n = f_sub(context, n, one); - } - return z; - } - return f_expt(context, f_div(context, f_to_r(context, one), this), f_negate(context, other)); - } else if (other instanceof RubyNumeric && f_scalar_p(context, other).isTrue()) { - RubyArray a = f_polar(context, this).convertToArray(); - IRubyObject r = a.eltInternal(0); - IRubyObject theta = a.eltInternal(1); - return f_complex_polar(context, getMetaClass(), f_expt(context, r, other), f_mul(context, theta, other)); - } - return coerceBin(context, "**", other); - } - - /** nucomp_equal_p - * - */ - @JRubyMethod(name = "==") - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - if (other instanceof RubyComplex) { - RubyComplex otherComplex = (RubyComplex)other; - if (f_equal_p(context, real, otherComplex.real) && f_equal_p(context, image, otherComplex.image)) return context.getRuntime().getTrue(); - return context.getRuntime().getFalse(); - } else if (other instanceof RubyNumeric && f_scalar_p(context, other).isTrue()) { - if (f_equal_p(context, real, other) && f_zero_p(context, image)) return context.getRuntime().getTrue(); - return context.getRuntime().getFalse(); - } - return f_equal_p(context, other, this) ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - /** nucomp_coerce - * - */ - @JRubyMethod(name = "coerce") - public IRubyObject coerce(ThreadContext context, IRubyObject other) { - if (other instanceof RubyNumeric && f_scalar_p(context, other).isTrue()) { - return context.getRuntime().newArray(newComplexBang(context, getMetaClass(), other), this); - } - throw context.getRuntime().newTypeError(other.getMetaClass().getName() + " can't be coerced into " + getMetaClass().getName()); - } - - /** nucomp_abs - * - */ - @JRubyMethod(name = {"abs", "magnitude"}) - public IRubyObject abs(ThreadContext context) { - return RubyMath.hypot(this, real, image); - } - - /** nucomp_abs2 - * - */ - @JRubyMethod(name = "abs2") - public IRubyObject abs2(ThreadContext context) { - return f_add(context, - f_mul(context, real, real), - f_mul(context, image, image)); - } - - /** nucomp_arg - * - */ - @JRubyMethod(name = {"arg", "angle"}) - public IRubyObject arg(ThreadContext context) { - return RubyMath.atan2(this, image, real); - } - - /** nucomp_polar - * - */ - @JRubyMethod(name = "polar") - public IRubyObject polar(ThreadContext context) { - return context.getRuntime().newArray(f_abs(context, this), f_arg(context, this)); - } - - /** nucomp_conjugate - * - */ - @JRubyMethod(name = {"conjugate", "conj", "~"}) - public IRubyObject conjugate(ThreadContext context) { - return newComplex(context, getMetaClass(), real, f_negate(context, image)); - } - - /** nucomp_real_p - * - */ - //@JRubyMethod(name = "real?") - public IRubyObject real_p(ThreadContext context) { - return context.getRuntime().getFalse(); - } - - /** nucomp_complex_p - * - */ - // @JRubyMethod(name = "complex?") - public IRubyObject complex_p(ThreadContext context) { - return context.getRuntime().getTrue(); - } - - /** nucomp_exact_p - * - */ - // @JRubyMethod(name = "exact?") - public IRubyObject exact_p(ThreadContext context) { - return (f_exact_p(context, real).isTrue() && f_exact_p(context, image).isTrue()) ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - /** nucomp_exact_p - * - */ - // @JRubyMethod(name = "inexact?") - public IRubyObject inexact_p(ThreadContext context) { - return exact_p(context).isTrue() ? context.getRuntime().getFalse() : context.getRuntime().getTrue(); - } - - /** nucomp_denominator - * - */ - @JRubyMethod(name = "denominator") - public IRubyObject demoninator(ThreadContext context) { - return f_lcm(context, f_denominator(context, real), f_denominator(context, image)); - } - - /** nucomp_numerator - * - */ - @JRubyMethod(name = "numerator") - public IRubyObject numerator(ThreadContext context) { - IRubyObject cd = callMethod(context, "denominator"); - return newComplex(context, getMetaClass(), - f_mul(context, - f_numerator(context, real), - f_div(context, cd, f_denominator(context, real))), - f_mul(context, - f_numerator(context, image), - f_div(context, cd, f_denominator(context, image)))); - } - - /** nucomp_hash - * - */ - @JRubyMethod(name = "hash") - public IRubyObject hash(ThreadContext context) { - return f_xor(context, real, image); - } - - /** f_signbit - * - */ - private static boolean signbit(ThreadContext context, IRubyObject x) { - if (x instanceof RubyFloat) { - return Double.doubleToLongBits(((RubyFloat)x).getDoubleValue()) < 0; - } - return f_negative_p(context, x); - } - - /** f_tpositive_p - * - */ - private static boolean tpositive_p(ThreadContext context, IRubyObject x) { - return !signbit(context, x); - } - - /** nucomp_to_s - * - */ - @JRubyMethod(name = "to_s") - public IRubyObject to_s(ThreadContext context) { - boolean impos = tpositive_p(context, image); - - RubyString str = f_to_s(context, real).convertToString(); - str.cat(impos ? (byte)'+' : (byte)'-'); - str.cat(f_to_s(context, f_abs(context, image)).convertToString().getByteList()); - str.cat((byte)'i'); - return str; - } - - /** nucomp_inspect - * - */ - @JRubyMethod(name = "inspect") - public IRubyObject inspect(ThreadContext context) { - boolean impos = tpositive_p(context, image); - RubyString str = context.getRuntime().newString(); - str.cat((byte)'('); - str.cat(f_inspect(context, real).convertToString().getByteList()); - str.cat(impos ? (byte)'+' : (byte)'-'); - str.cat(f_inspect(context, f_abs(context, image)).convertToString().getByteList()); - str.cat((byte)'i'); - str.cat((byte)')'); - return str; - } - - /** nucomp_marshal_dump - * - */ - @JRubyMethod(name = "marshal_dump") - public IRubyObject marshal_dump(ThreadContext context) { - return context.getRuntime().newArray(real, image); - } - - /** nucomp_marshal_load - * - */ - @JRubyMethod(name = "marshal_load") - public IRubyObject marshal_load(ThreadContext context, IRubyObject arg) { - RubyArray a = arg.convertToArray(); - real = a.size() > 0 ? a.eltInternal(0) : context.getRuntime().getNil(); - image = a.size() > 1 ? a.eltInternal(1) : context.getRuntime().getNil(); - return this; - } - - /** nucomp_scalar_p - * - */ - @JRubyMethod(name = "scalar?") - public IRubyObject scalar_p(ThreadContext context) { - return context.getRuntime().getFalse(); - } - - /** nucomp_to_i - * - */ - @JRubyMethod(name = "to_i") - public IRubyObject to_i(ThreadContext context) { - if (image instanceof RubyFloat || !f_zero_p(context, image)) { - throw context.getRuntime().newRangeError("can't convert " + f_to_s(context, this).convertToString() + " into Integer"); - } - return f_to_i(context, real); - } - - /** nucomp_to_f - * - */ - @JRubyMethod(name = "to_f") - public IRubyObject to_f(ThreadContext context) { - if (image instanceof RubyFloat || !f_zero_p(context, image)) { - throw context.getRuntime().newRangeError("can't convert " + f_to_s(context, this).convertToString() + " into Float"); - } - return f_to_f(context, real); - } - - /** nucomp_to_f - * - */ - @JRubyMethod(name = "to_r") - public IRubyObject to_r(ThreadContext context) { - if (image instanceof RubyFloat || !f_zero_p(context, image)) { - throw context.getRuntime().newRangeError("can't convert " + f_to_s(context, this).convertToString() + " into Rational"); - } - return f_to_r(context, real); - } - - static RubyArray str_to_c_internal(ThreadContext context, IRubyObject recv) { - RubyString s = recv.callMethod(context, "strip").convertToString(); - ByteList bytes = s.getByteList(); - - Ruby runtime = context.getRuntime(); - if (bytes.realSize == 0) return runtime.newArray(runtime.getNil(), recv); - - IRubyObject sr, si, re; - sr = si = re = runtime.getNil(); - boolean po = false; - IRubyObject m = RubyRegexp.newRegexp(runtime, Numeric.ComplexPatterns.comp_pat0).callMethod(context, "match", s); - - if (!m.isNil()) { - sr = m.callMethod(context, "[]", RubyFixnum.one(runtime)); - si = m.callMethod(context, "[]", RubyFixnum.two(runtime)); - re = m.callMethod(context, "post_match"); - po = true; - } - - if (m.isNil()) { - m = RubyRegexp.newRegexp(runtime, Numeric.ComplexPatterns.comp_pat1).callMethod(context, "match", s); - - if (!m.isNil()) { - sr = runtime.getNil(); - si = m.callMethod(context, "[]", RubyFixnum.one(runtime)); - if (si.isNil()) si = runtime.newString(); - IRubyObject t = m.callMethod(context, "[]", RubyFixnum.two(runtime)); - if (t.isNil()) t = runtime.newString(new ByteList(new byte[]{'1'})); - si.convertToString().cat(t.convertToString().getByteList()); - re = m.callMethod(context, "post_match"); - po = false; - } - } - - if (m.isNil()) { - m = RubyRegexp.newRegexp(runtime, Numeric.ComplexPatterns.comp_pat2).callMethod(context, "match", s); - if (m.isNil()) return runtime.newArray(runtime.getNil(), recv); - sr = m.callMethod(context, "[]", RubyFixnum.one(runtime)); - if (m.callMethod(context, "[]", RubyFixnum.two(runtime)).isNil()) { - si = runtime.getNil(); - } else { - si = m.callMethod(context, "[]", RubyFixnum.three(runtime)); - IRubyObject t = m.callMethod(context, "[]", RubyFixnum.four(runtime)); - if (t.isNil()) t = runtime.newString(new ByteList(new byte[]{'1'})); - si.convertToString().cat(t.convertToString().getByteList()); - } - re = m.callMethod(context, "post_match"); - po = false; - } - - IRubyObject r = RubyFixnum.zero(runtime); - IRubyObject i = r; - - if (!sr.isNil()) { - if (sr.callMethod(context, "include?", runtime.newString(new ByteList(new byte[]{'/'}))).isTrue()) { - r = f_to_r(context, sr); - } else if (f_gt_p(context, sr.callMethod(context, "count", runtime.newString(".eE")), RubyFixnum.zero(runtime)).isTrue()) { - r = f_to_f(context, sr); - } else { - r = f_to_i(context, sr); - } - } - - if (!si.isNil()) { - if (si.callMethod(context, "include?", runtime.newString(new ByteList(new byte[]{'/'}))).isTrue()) { - i = f_to_r(context, si); - } else if (f_gt_p(context, si.callMethod(context, "count", runtime.newString(".eE")), RubyFixnum.zero(runtime)).isTrue()) { - i = f_to_f(context, si); - } else { - i = f_to_i(context, si); - } - } - return runtime.newArray(po ? newComplexPolar(context, r, i) : newComplexCanonicalize(context, r, i), re); - } - - private static IRubyObject str_to_c_strict(ThreadContext context, IRubyObject recv) { - RubyArray a = str_to_c_internal(context, recv); - if (a.eltInternal(0).isNil() || a.eltInternal(1).convertToString().getByteList().length() > 0) { - IRubyObject s = recv.callMethod(context, "inspect"); - throw context.getRuntime().newArgumentError("invalid value for Complex: " + s.convertToString()); - } - return a.eltInternal(0); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.Block; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * Placeholder until/if we can support this - * - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -@JRubyClass(name="Continuation") -public class RubyContinuation { - public static void createContinuation(Ruby runtime) { - RubyClass cContinuation = runtime.defineClass("Continuation",runtime.getObject(),runtime.getObject().getAllocator()); - cContinuation.defineAnnotatedMethods(RubyContinuation.class); - runtime.setContinuation(cContinuation); - } - - @JRubyMethod(name = {"call", "[]"}, rest = true, frame = true) - public static IRubyObject call(IRubyObject recv, IRubyObject[] args, Block unusedBlock) { - throw recv.getRuntime().newNotImplementedError("Continuations are not implemented in JRuby and will not work"); - } -}// RubyContinuation -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006, 2007 Ola Bini <ola@ologix.com> - * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com> - * Copyright (C) 2008 Vladimir Sizikov <vsizikov@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.security.Provider; -import java.security.MessageDigest; -import java.security.NoSuchAlgorithmException; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.anno.JRubyClass; - -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.callback.Callback; -import org.jruby.util.ByteList; - -/** - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -@JRubyModule(name="Digest") -public class RubyDigest { - private static Provider provider = null; - - public static void createDigest(Ruby runtime) { - try { - provider = (Provider) Class.forName("org.bouncycastle.jce.provider.BouncyCastleProvider").newInstance(); - } catch(Exception e) { - // provider is not available - } - - RubyModule mDigest = runtime.defineModule("Digest"); - RubyClass cDigestBase = mDigest.defineClassUnder("Base",runtime.getObject(), Base.BASE_ALLOCATOR); - - cDigestBase.defineAnnotatedMethods(Base.class); - } - - private static MessageDigest createMessageDigest(Ruby runtime, String providerName) throws NoSuchAlgorithmException { - if(provider != null) { - try { - return MessageDigest.getInstance(providerName, provider); - } catch(NoSuchAlgorithmException e) { - // bouncy castle doesn't support algorithm - } - } - // fall back to system JCA providers - return MessageDigest.getInstance(providerName); - } - - @JRubyClass(name="Digest::MD5", parent="Digest::Base") - public static class MD5 {} - @JRubyClass(name="Digest::RMD160", parent="Digest::Base") - public static class RMD160 {} - @JRubyClass(name="Digest::SHA1", parent="Digest::Base") - public static class SHA1 {} - @JRubyClass(name="Digest::SHA256", parent="Digest::Base") - public static class SHA256 {} - @JRubyClass(name="Digest::SHA384", parent="Digest::Base") - public static class SHA384 {} - @JRubyClass(name="Digest::SHA512", parent="Digest::Base") - public static class SHA512 {} - - public static void createDigestMD5(Ruby runtime) { - runtime.getLoadService().require("digest.so"); - RubyModule mDigest = runtime.fastGetModule("Digest"); - RubyClass cDigestBase = mDigest.fastGetClass("Base"); - RubyClass cDigest_MD5 = mDigest.defineClassUnder("MD5",cDigestBase,cDigestBase.getAllocator()); - cDigest_MD5.defineFastMethod("block_length", new Callback() { - public Arity getArity() { - return Arity.NO_ARGUMENTS; - } - public IRubyObject execute(IRubyObject recv, IRubyObject[] args, Block block) { - return RubyFixnum.newFixnum(recv.getRuntime(), 64); - } - }); - cDigest_MD5.setInternalModuleVariable("metadata",runtime.newString("MD5")); - } - - public static void createDigestRMD160(Ruby runtime) { - runtime.getLoadService().require("digest.so"); - if(provider == null) { - throw runtime.newLoadError("RMD160 not supported without BouncyCastle"); - } - - RubyModule mDigest = runtime.fastGetModule("Digest"); - RubyClass cDigestBase = mDigest.fastGetClass("Base"); - RubyClass cDigest_RMD160 = mDigest.defineClassUnder("RMD160",cDigestBase,cDigestBase.getAllocator()); - cDigest_RMD160.setInternalModuleVariable("metadata",runtime.newString("RIPEMD160")); - } - - public static void createDigestSHA1(Ruby runtime) { - runtime.getLoadService().require("digest.so"); - RubyModule mDigest = runtime.fastGetModule("Digest"); - RubyClass cDigestBase = mDigest.fastGetClass("Base"); - RubyClass cDigest_SHA1 = mDigest.defineClassUnder("SHA1",cDigestBase,cDigestBase.getAllocator()); - cDigest_SHA1.setInternalModuleVariable("metadata",runtime.newString("SHA1")); - } - - public static void createDigestSHA2(Ruby runtime) { - runtime.getLoadService().require("digest.so"); - try { - createMessageDigest(runtime, "SHA-256"); - } catch(NoSuchAlgorithmException e) { - throw runtime.newLoadError("SHA2 not supported"); - } - - RubyModule mDigest = runtime.fastGetModule("Digest"); - RubyClass cDigestBase = mDigest.fastGetClass("Base"); - RubyClass cDigest_SHA2_256 = mDigest.defineClassUnder("SHA256",cDigestBase,cDigestBase.getAllocator()); - cDigest_SHA2_256.setInternalModuleVariable("metadata",runtime.newString("SHA-256")); - RubyClass cDigest_SHA2_384 = mDigest.defineClassUnder("SHA384",cDigestBase,cDigestBase.getAllocator()); - cDigest_SHA2_384.setInternalModuleVariable("metadata",runtime.newString("SHA-384")); - RubyClass cDigest_SHA2_512 = mDigest.defineClassUnder("SHA512",cDigestBase,cDigestBase.getAllocator()); - cDigest_SHA2_512.setInternalModuleVariable("metadata",runtime.newString("SHA-512")); - } - - @JRubyClass(name="Digest::Base") - public static class Base extends RubyObject { - protected static final ObjectAllocator BASE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new Base(runtime, klass); - } - }; - - @JRubyMethod(name = "digest", required = 1, meta = true) - public static IRubyObject s_digest(IRubyObject recv, IRubyObject str) { - Ruby runtime = recv.getRuntime(); - String name = ((RubyClass)recv).searchInternalModuleVariable("metadata").toString(); - try { - MessageDigest md = createMessageDigest(runtime, name); - return RubyString.newString(runtime, md.digest(str.convertToString().getBytes())); - } catch(NoSuchAlgorithmException e) { - throw recv.getRuntime().newNotImplementedError("Unsupported digest algorithm (" + name + ")"); - } - } - - @JRubyMethod(name = "hexdigest", required = 1, meta = true) - public static IRubyObject s_hexdigest(IRubyObject recv, IRubyObject str) { - Ruby runtime = recv.getRuntime(); - String name = ((RubyClass)recv).searchInternalModuleVariable("metadata").toString(); - try { - MessageDigest md = createMessageDigest(runtime, name); - return RubyString.newString(runtime, ByteList.plain(toHex(md.digest(str.convertToString().getBytes())))); - } catch(NoSuchAlgorithmException e) { - throw recv.getRuntime().newNotImplementedError("Unsupported digest algorithm (" + name + ")"); - } - } - - private MessageDigest algo; - private StringBuffer data; - - public Base(Ruby runtime, RubyClass type) { - super(runtime,type); - data = new StringBuffer(); - - if(type == runtime.fastGetModule("Digest").fastGetClass("Base")) { - throw runtime.newNotImplementedError("Digest::Base is an abstract class"); - } - if(!type.hasInternalModuleVariable("metadata")) { - throw runtime.newNotImplementedError("the " + type + "() function is unimplemented on this machine"); - } - try { - setAlgorithm(type.searchInternalModuleVariable("metadata")); - } catch(NoSuchAlgorithmException e) { - throw runtime.newNotImplementedError("the " + type + "() function is unimplemented on this machine"); - } - - } - - @JRubyMethod(name = "initialize", optional = 1, frame = true) - public IRubyObject initialize(IRubyObject[] args, Block unusedBlock) { - if(args.length > 0 && !args[0].isNil()) { - update(args[0]); - } - return this; - } - - @JRubyMethod(name = "initialize_copy", required = 1) - public IRubyObject initialize_copy(IRubyObject obj) { - if(this == obj) { - return this; - } - ((RubyObject)obj).checkFrozen(); - - data = new StringBuffer(((Base)obj).data.toString()); - String name = ((Base)obj).algo.getAlgorithm(); - try { - algo = createMessageDigest(getRuntime(), name); - } catch(NoSuchAlgorithmException e) { - throw getRuntime().newNotImplementedError("Unsupported digest algorithm (" + name + ")"); - } - return this; - } - - @JRubyMethod(name = {"update", "<<"}, required = 1) - public IRubyObject update(IRubyObject obj) { - data.append(obj); - return this; - } - - @JRubyMethod(name = "digest", optional = 1) - public IRubyObject digest(IRubyObject[] args) { - if (args.length == 1) { - reset(); - data.append(args[0]); - } - - IRubyObject digest = getDigest(); - - if (args.length == 1) { - reset(); - } - return digest; - } - - private IRubyObject getDigest() { - algo.reset(); - return RubyString.newString(getRuntime(), algo.digest(ByteList.plain(data))); - } - - @JRubyMethod(name = "digest!") - public IRubyObject digest_bang() { - algo.reset(); - byte[] digest = algo.digest(ByteList.plain(data)); - reset(); - return RubyString.newString(getRuntime(), digest); - } - - @JRubyMethod(name = {"hexdigest"}, optional = 1) - public IRubyObject hexdigest(IRubyObject[] args) { - algo.reset(); - if (args.length == 1) { - reset(); - data.append(args[0]); - } - - byte[] digest = ByteList.plain(toHex(algo.digest(ByteList.plain(data)))); - - if (args.length == 1) { - reset(); - } - return RubyString.newString(getRuntime(), digest); - } - - @JRubyMethod(name = {"to_s"}) - public IRubyObject to_s() { - algo.reset(); - return RubyString.newString(getRuntime(), ByteList.plain(toHex(algo.digest(ByteList.plain(data))))); - } - - @JRubyMethod(name = {"hexdigest!"}) - public IRubyObject hexdigest_bang() { - algo.reset(); - byte[] digest = ByteList.plain(toHex(algo.digest(ByteList.plain(data)))); - reset(); - return RubyString.newString(getRuntime(), digest); - } - - @JRubyMethod(name = "inspect") - public IRubyObject inspect() { - algo.reset(); - return RubyString.newString(getRuntime(), ByteList.plain("#<" + getMetaClass().getRealClass().getName() + ": " + toHex(algo.digest(ByteList.plain(data))) + ">")); - } - - @JRubyMethod(name = "==", required = 1) - public IRubyObject op_equal(IRubyObject oth) { - boolean ret = this == oth; - if(!ret) { - if (oth instanceof Base) { - Base b = (Base)oth; - ret = this.algo.getAlgorithm().equals(b.algo.getAlgorithm()) && - this.getDigest().equals(b.getDigest()); - } else { - IRubyObject str = oth.convertToString(); - ret = this.to_s().equals(str); - } - } - - return ret ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = {"length", "size", "digest_length"}) - public IRubyObject length() { - return RubyFixnum.newFixnum(getRuntime(), algo.getDigestLength()); - } - - @JRubyMethod(name = {"block_length"}) - public IRubyObject block_length() { - throw getRuntime().newRuntimeError( - this.getMetaClass() + " doesn't implement block_length()"); - } - - @JRubyMethod(name = {"reset"}) - public IRubyObject reset() { - algo.reset(); - data = new StringBuffer(); - return getRuntime().getNil(); - } - - private void setAlgorithm(IRubyObject algo) throws NoSuchAlgorithmException { - this.algo = createMessageDigest(getRuntime(), algo.toString()); - } - - private static String toHex(byte[] val) { - StringBuilder out = new StringBuilder(); - for(int i=0,j=val.length;i<j;i++) { - String ve = Integer.toString((((int)((char)val[i])) & 0xFF),16); - if(ve.length() == 1) { - ve = "0" + ve; - } - out.append(ve); - } - return out.toString(); - } - } -}// RubyDigest -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.util.ArrayList; -import java.util.List; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.ext.posix.util.Platform; - -import org.jruby.javasupport.JavaUtil; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.Dir; -import org.jruby.util.JRubyFile; -import org.jruby.util.ByteList; - -/** - * .The Ruby built-in class Dir. - * - * @author jvoegele - */ -@JRubyClass(name="Dir", include="Enumerable") -public class RubyDir extends RubyObject { - // What we passed to the constructor for method 'path' - private RubyString path; - protected JRubyFile dir; - private String[] snapshot; // snapshot of contents of directory - private int pos; // current position in directory - private boolean isOpen = true; - - public RubyDir(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - private static final ObjectAllocator DIR_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyDir(runtime, klass); - } - }; - - public static RubyClass createDirClass(Ruby runtime) { - RubyClass dirClass = runtime.defineClass("Dir", runtime.getObject(), DIR_ALLOCATOR); - runtime.setDir(dirClass); - - dirClass.includeModule(runtime.getEnumerable()); - - dirClass.defineAnnotatedMethods(RubyDir.class); - - return dirClass; - } - - private final void checkDir() { - if (!isTaint() && getRuntime().getSafeLevel() >= 4) throw getRuntime().newSecurityError("Insecure: operation on untainted Dir"); - - testFrozen(""); - - if (!isOpen) throw getRuntime().newIOError("closed directory"); - } - - /** - * Creates a new <code>Dir</code>. This method takes a snapshot of the - * contents of the directory at creation time, so changes to the contents - * of the directory will not be reflected during the lifetime of the - * <code>Dir</code> object returned, so a new <code>Dir</code> instance - * must be created to reflect changes to the underlying file system. - */ - @JRubyMethod(name = "initialize", required = 1, frame = true) - public IRubyObject initialize(IRubyObject _newPath, Block unusedBlock) { - RubyString newPath = _newPath.convertToString(); - getRuntime().checkSafeString(newPath); - - String adjustedPath = RubyFile.adjustRootPathOnWindows(getRuntime(), newPath.toString(), null); - checkDirIsTwoSlashesOnWindows(getRuntime(), adjustedPath); - - dir = JRubyFile.create(getRuntime().getCurrentDirectory(), adjustedPath); - if (!dir.isDirectory()) { - dir = null; - throw getRuntime().newErrnoENOENTError(newPath.toString() + " is not a directory"); - } - path = newPath; - List<String> snapshotList = new ArrayList<String>(); - snapshotList.add("."); - snapshotList.add(".."); - snapshotList.addAll(getContents(dir)); - snapshot = (String[]) snapshotList.toArray(new String[snapshotList.size()]); - pos = 0; - - return this; - } - -// ----- Ruby Class Methods ---------------------------------------------------- - - private static List<ByteList> dirGlobs(String cwd, IRubyObject[] args, int flags) { - List<ByteList> dirs = new ArrayList<ByteList>(); - - for (int i = 0; i < args.length; i++) { - ByteList globPattern = args[i].convertToString().getByteList(); - dirs.addAll(Dir.push_glob(cwd, globPattern, flags)); - } - - return dirs; - } - - private static IRubyObject asRubyStringList(Ruby runtime, List<ByteList> dirs) { - List<RubyString> allFiles = new ArrayList<RubyString>(); - - for (ByteList dir: dirs) { - allFiles.add(RubyString.newString(runtime, dir)); - } - - IRubyObject[] tempFileList = new IRubyObject[allFiles.size()]; - allFiles.toArray(tempFileList); - - return runtime.newArrayNoCopy(tempFileList); - } - - private static String getCWD(Ruby runtime) { - try { - return new org.jruby.util.NormalizedFile(runtime.getCurrentDirectory()).getCanonicalPath(); - } catch(Exception e) { - return runtime.getCurrentDirectory(); - } - } - - @JRubyMethod(name = "[]", required = 1, rest=true, meta = true) - public static IRubyObject aref(IRubyObject recv, IRubyObject[] args) { - List<ByteList> dirs; - if (args.length == 1) { - ByteList globPattern = args[0].convertToString().getByteList(); - dirs = Dir.push_glob(getCWD(recv.getRuntime()), globPattern, 0); - } else { - dirs = dirGlobs(getCWD(recv.getRuntime()), args, 0); - } - - return asRubyStringList(recv.getRuntime(), dirs); - } - - /** - * Returns an array of filenames matching the specified wildcard pattern - * <code>pat</code>. If a block is given, the array is iterated internally - * with each filename is passed to the block in turn. In this case, Nil is - * returned. - */ - @JRubyMethod(name = "glob", required = 1, optional = 1, frame = true, meta = true) - public static IRubyObject glob(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = recv.getRuntime(); - int flags = args.length == 2 ? RubyNumeric.num2int(args[1]) : 0; - - List<ByteList> dirs; - IRubyObject tmp = args[0].checkArrayType(); - if (tmp.isNil()) { - ByteList globPattern = args[0].convertToString().getByteList(); - dirs = Dir.push_glob(recv.getRuntime().getCurrentDirectory(), globPattern, flags); - } else { - dirs = dirGlobs(getCWD(runtime), ((RubyArray) tmp).toJavaArray(), flags); - } - - if (block.isGiven()) { - for (int i = 0; i < dirs.size(); i++) { - block.yield(context, RubyString.newString(runtime, dirs.get(i))); - } - - return recv.getRuntime().getNil(); - } - - return asRubyStringList(recv.getRuntime(), dirs); - } - - /** - * @return all entries for this Dir - */ - @JRubyMethod(name = "entries") - public RubyArray entries() { - return getRuntime().newArrayNoCopy(JavaUtil.convertJavaArrayToRuby(getRuntime(), snapshot)); - } - - /** - * Returns an array containing all of the filenames in the given directory. - */ - @JRubyMethod(name = "entries", required = 1, meta = true) - public static RubyArray entries(IRubyObject recv, IRubyObject path) { - Ruby runtime = recv.getRuntime(); - - String adjustedPath = RubyFile.adjustRootPathOnWindows( - runtime, path.convertToString().toString(), null); - checkDirIsTwoSlashesOnWindows(runtime, adjustedPath); - - final JRubyFile directory = JRubyFile.create( - recv.getRuntime().getCurrentDirectory(), adjustedPath); - - if (!directory.isDirectory()) { - throw recv.getRuntime().newErrnoENOENTError("No such directory"); - } - List<String> fileList = getContents(directory); - fileList.add(0, "."); - fileList.add(1, ".."); - Object[] files = fileList.toArray(); - return recv.getRuntime().newArrayNoCopy(JavaUtil.convertJavaArrayToRuby(recv.getRuntime(), files)); - } - - // MRI behavior: just plain '//' or '\\\\' are considered illegal on Windows. - private static void checkDirIsTwoSlashesOnWindows(Ruby runtime, String path) { - if (Platform.IS_WINDOWS && ("//".equals(path) || "\\\\".equals(path))) { - throw runtime.newErrnoEINVALError("Invalid argument - " + path); - } - } - - /** Changes the current directory to <code>path</code> */ - @JRubyMethod(name = "chdir", optional = 1, frame = true, meta = true) - public static IRubyObject chdir(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - RubyString path = args.length == 1 ? - (RubyString) args[0].convertToString() : getHomeDirectoryPath(context); - String adjustedPath = RubyFile.adjustRootPathOnWindows( - recv.getRuntime(), path.toString(), null); - checkDirIsTwoSlashesOnWindows(recv.getRuntime(), adjustedPath); - JRubyFile dir = getDir(recv.getRuntime(), adjustedPath, true); - String realPath = null; - String oldCwd = recv.getRuntime().getCurrentDirectory(); - - // We get canonical path to try and flatten the path out. - // a dir '/subdir/..' should return as '/' - // cnutter: Do we want to flatten path out? - try { - realPath = dir.getCanonicalPath(); - } catch (IOException e) { - realPath = dir.getAbsolutePath(); - } - - IRubyObject result = null; - if (block.isGiven()) { - // FIXME: Don't allow multiple threads to do this at once - recv.getRuntime().setCurrentDirectory(realPath); - try { - result = block.yield(context, path); - } finally { - dir = getDir(recv.getRuntime(), oldCwd, true); - recv.getRuntime().setCurrentDirectory(oldCwd); - } - } else { - recv.getRuntime().setCurrentDirectory(realPath); - result = recv.getRuntime().newFixnum(0); - } - - return result; - } - - /** - * Changes the root directory (only allowed by super user). Not available - * on all platforms. - */ - @JRubyMethod(name = "chroot", required = 1, meta = true) - public static IRubyObject chroot(IRubyObject recv, IRubyObject path) { - throw recv.getRuntime().newNotImplementedError("chroot not implemented: chroot is non-portable and is not supported."); - } - - /** - * Deletes the directory specified by <code>path</code>. The directory must - * be empty. - */ - @JRubyMethod(name = {"rmdir", "unlink", "delete"}, required = 1, meta = true) - public static IRubyObject rmdir(IRubyObject recv, IRubyObject path) { - JRubyFile directory = getDir(recv.getRuntime(), path.convertToString().toString(), true); - - if (!directory.delete()) { - throw recv.getRuntime().newSystemCallError("No such directory"); - } - - return recv.getRuntime().newFixnum(0); - } - - /** - * Executes the block once for each file in the directory specified by - * <code>path</code>. - */ - @JRubyMethod(name = "foreach", required = 1, frame = true, meta = true) - public static IRubyObject foreach(ThreadContext context, IRubyObject recv, IRubyObject _path, Block block) { - RubyString path = _path.convertToString(); - recv.getRuntime().checkSafeString(path); - - RubyClass dirClass = recv.getRuntime().getDir(); - RubyDir dir = (RubyDir) dirClass.newInstance(context, new IRubyObject[] { path }, block); - - dir.each(context, block); - return recv.getRuntime().getNil(); - } - - /** Returns the current directory. */ - @JRubyMethod(name = {"getwd", "pwd"}, meta = true) - public static RubyString getwd(IRubyObject recv) { - Ruby ruby = recv.getRuntime(); - - return RubyString.newUnicodeString(ruby, ruby.getCurrentDirectory()); - } - - /** - * Creates the directory specified by <code>path</code>. Note that the - * <code>mode</code> parameter is provided only to support existing Ruby - * code, and is ignored. - */ - @JRubyMethod(name = "mkdir", required = 1, optional = 1, meta = true) - public static IRubyObject mkdir(IRubyObject recv, IRubyObject[] args) { - Ruby runtime = recv.getRuntime(); - runtime.checkSafeString(args[0]); - String path = args[0].toString(); - - File newDir = getDir(runtime, path, false); - if (File.separatorChar == '\\') { - newDir = new File(newDir.getPath()); - } - - int mode = args.length == 2 ? ((int) args[1].convertToInteger().getLongValue()) : 0777; - - if (runtime.getPosix().mkdir(newDir.getAbsolutePath(), mode) < 0) { - // FIXME: This is a system error based on errno - throw recv.getRuntime().newSystemCallError("mkdir failed"); - } - - return RubyFixnum.zero(recv.getRuntime()); - } - - /** - * Returns a new directory object for <code>path</code>. If a block is - * provided, a new directory object is passed to the block, which closes the - * directory object before terminating. - */ - @JRubyMethod(name = "open", required = 1, frame = true, meta = true) - public static IRubyObject open(ThreadContext context, IRubyObject recv, IRubyObject path, Block block) { - RubyDir directory = - (RubyDir) recv.getRuntime().getDir().newInstance(context, - new IRubyObject[] { path }, Block.NULL_BLOCK); - - if (!block.isGiven()) return directory; - - try { - return block.yield(context, directory); - } finally { - directory.close(); - } - } - -// ----- Ruby Instance Methods ------------------------------------------------- - - /** - * Closes the directory stream. - */ - @JRubyMethod(name = "close") - public IRubyObject close() { - // Make sure any read()s after close fail. - checkDir(); - - isOpen = false; - - return getRuntime().getNil(); - } - - /** - * Executes the block once for each entry in the directory. - */ - @JRubyMethod(name = "each", frame = true) - public IRubyObject each(ThreadContext context, Block block) { - checkDir(); - - String[] contents = snapshot; - for (int i=0; i<contents.length; i++) { - block.yield(context, getRuntime().newString(contents[i])); - } - return this; - } - - /** - * Returns the current position in the directory. - */ - @JRubyMethod(name = {"tell", "pos"}) - public RubyInteger tell() { - checkDir(); - return getRuntime().newFixnum(pos); - } - - /** - * Moves to a position <code>d</code>. <code>pos</code> must be a value - * returned by <code>tell</code> or 0. - */ - @JRubyMethod(name = "seek", required = 1) - public IRubyObject seek(IRubyObject newPos) { - checkDir(); - - set_pos(newPos); - return this; - } - - @JRubyMethod(name = "pos=", required = 1) - public IRubyObject set_pos(IRubyObject newPos) { - this.pos = RubyNumeric.fix2int(newPos); - return newPos; - } - - @JRubyMethod(name = "path") - public IRubyObject path(ThreadContext context) { - checkDir(); - - return path.strDup(context.getRuntime()); - } - - /** Returns the next entry from this directory. */ - @JRubyMethod(name = "read") - public IRubyObject read() { - checkDir(); - - if (pos >= snapshot.length) { - return getRuntime().getNil(); - } - RubyString result = getRuntime().newString(snapshot[pos]); - pos++; - return result; - } - - /** Moves position in this directory to the first entry. */ - @JRubyMethod(name = "rewind") - public IRubyObject rewind() { - if (!isTaint() && getRuntime().getSafeLevel() >= 4) throw getRuntime().newSecurityError("Insecure: can't close"); - checkDir(); - - pos = 0; - return this; - } - -// ----- Helper Methods -------------------------------------------------------- - - /** Returns a Java <code>File</code> object for the specified path. If - * <code>path</code> is not a directory, throws <code>IOError</code>. - * - * @param path path for which to return the <code>File</code> object. - * @param mustExist is true the directory must exist. If false it must not. - * @throws IOError if <code>path</code> is not a directory. - */ - protected static JRubyFile getDir(final Ruby runtime, final String path, final boolean mustExist) { - JRubyFile result = JRubyFile.create(runtime.getCurrentDirectory(),path); - if (mustExist && !result.exists()) { - throw runtime.newErrnoENOENTError("No such file or directory - " + path); - } - boolean isDirectory = result.isDirectory(); - - if (mustExist && !isDirectory) { - throw runtime.newErrnoENOTDIRError(path + " is not a directory"); - } else if (!mustExist && isDirectory) { - throw runtime.newErrnoEEXISTError("File exists - " + path); - } - - return result; - } - - /** - * Returns the contents of the specified <code>directory</code> as an - * <code>ArrayList</code> containing the names of the files as Java Strings. - */ - protected static List<String> getContents(File directory) { - String[] contents = directory.list(); - List<String> result = new ArrayList<String>(); - - // If an IO exception occurs (something odd, but possible) - // A directory may return null. - if (contents != null) { - for (int i=0; i<contents.length; i++) { - result.add(contents[i]); - } - } - return result; - } - - /** - * Returns the contents of the specified <code>directory</code> as an - * <code>ArrayList</code> containing the names of the files as Ruby Strings. - */ - protected static List<RubyString> getContents(File directory, Ruby runtime) { - List<RubyString> result = new ArrayList<RubyString>(); - String[] contents = directory.list(); - - for (int i = 0; i < contents.length; i++) { - result.add(runtime.newString(contents[i])); - } - return result; - } - - /** - * Returns the home directory of the specified <code>user</code> on the - * system. If the home directory of the specified user cannot be found, - * an <code>ArgumentError it thrown</code>. - */ - public static IRubyObject getHomeDirectoryPath(ThreadContext context, String user) { - /* - * TODO: This version is better than the hackish previous one. Windows - * behavior needs to be defined though. I suppose this version - * could be improved more too. - * TODO: /etc/passwd is also inadequate for MacOSX since it does not - * use /etc/passwd for regular user accounts - */ - - String passwd = null; - try { - FileInputStream stream = new FileInputStream("/etc/passwd"); - int totalBytes = stream.available(); - byte[] bytes = new byte[totalBytes]; - stream.read(bytes); - stream.close(); - passwd = new String(bytes); - } catch (IOException e) { - return context.getRuntime().getNil(); - } - - String[] rows = passwd.split("\n"); - int rowCount = rows.length; - for (int i = 0; i < rowCount; i++) { - String[] fields = rows[i].split(":"); - if (fields[0].equals(user)) { - return context.getRuntime().newString(fields[5]); - } - } - - throw context.getRuntime().newArgumentError("user " + user + " doesn't exist"); - } - - public static RubyString getHomeDirectoryPath(ThreadContext context) { - Ruby runtime = context.getRuntime(); - RubyHash systemHash = (RubyHash) runtime.getObject().fastGetConstant("ENV_JAVA"); - RubyHash envHash = (RubyHash) runtime.getObject().fastGetConstant("ENV"); - IRubyObject home = envHash.op_aref(context, runtime.newString("HOME")); - - if (home == null || home.isNil()) { - home = systemHash.op_aref(context, runtime.newString("user.home")); - } - - if (home == null || home.isNil()) { - home = envHash.op_aref(context, runtime.newString("LOGDIR")); - } - - if (home == null || home.isNil()) { - throw runtime.newArgumentError("user.home/LOGDIR not set"); - } - - return (RubyString) home; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.util.Comparator; -import java.util.Arrays; -import java.util.concurrent.atomic.AtomicInteger; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; - -import org.jruby.exceptions.JumpException; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallBlock; -import org.jruby.runtime.BlockCallback; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.TypeConverter; - -/** - * The implementation of Ruby's Enumerable module. - */ - -@JRubyModule(name="Enumerable") -public class RubyEnumerable { - - public static RubyModule createEnumerableModule(Ruby runtime) { - RubyModule enumModule = runtime.defineModule("Enumerable"); - runtime.setEnumerable(enumModule); - - enumModule.defineAnnotatedMethods(RubyEnumerable.class); - - return enumModule; - } - - public static IRubyObject callEach(Ruby runtime, ThreadContext context, IRubyObject self, - BlockCallback callback) { - return RuntimeHelpers.invoke(context, self, "each", CallBlock.newCallClosure(self, runtime.getEnumerable(), - Arity.noArguments(), callback, context)); - } - - private static class ExitIteration extends RuntimeException { - public Throwable fillInStackTrace() { - return this; - } - } - - @JRubyMethod(name = "first") - public static IRubyObject first_0(ThreadContext context, IRubyObject self) { - Ruby runtime = self.getRuntime(); - final ThreadContext localContext = context; - - final IRubyObject[] holder = new IRubyObject[]{runtime.getNil()}; - - try { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw ctx.getRuntime().newThreadError("Enumerable#first cannot be parallelized"); - } - holder[0] = largs[0]; - throw new ExitIteration(); - } - }); - } catch(ExitIteration ei) {} - - return holder[0]; - } - - @JRubyMethod(name = "first") - public static IRubyObject first_1(ThreadContext context, IRubyObject self, final IRubyObject num) { - final Ruby runtime = self.getRuntime(); - final RubyArray result = runtime.newArray(); - final ThreadContext localContext = context; - - if(RubyNumeric.fix2int(num) < 0) { - throw runtime.newArgumentError("negative index"); - } - - try { - callEach(runtime, context, self, new BlockCallback() { - private int iter = RubyNumeric.fix2int(num); - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#first cannot be parallelized"); - } - if(iter-- == 0) { - throw new ExitIteration(); - } - result.append(largs[0]); - return runtime.getNil(); - } - }); - } catch(ExitIteration ei) {} - - return result; - } - - @JRubyMethod(name = {"to_a", "entries"}) - public static IRubyObject to_a(ThreadContext context, IRubyObject self) { - Ruby runtime = self.getRuntime(); - RubyArray result = runtime.newArray(); - - callEach(runtime, context, self, new AppendBlockCallback(runtime, result)); - - return result; - } - - @JRubyMethod(name = "sort", frame = true) - public static IRubyObject sort(ThreadContext context, IRubyObject self, final Block block) { - Ruby runtime = self.getRuntime(); - RubyArray result = runtime.newArray(); - - callEach(runtime, context, self, new AppendBlockCallback(runtime, result)); - result.sort_bang(block); - - return result; - } - - @JRubyMethod(name = "sort_by", frame = true) - public static IRubyObject sort_by(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final ThreadContext localContext = context; // MUST NOT be used across threads - - if (self instanceof RubyArray) { - RubyArray selfArray = (RubyArray) self; - final IRubyObject[][] valuesAndCriteria = new IRubyObject[selfArray.size()][2]; - - callEach(runtime, context, self, new BlockCallback() { - AtomicInteger i = new AtomicInteger(0); - - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - IRubyObject[] myVandC = valuesAndCriteria[i.getAndIncrement()]; - myVandC[0] = largs[0]; - myVandC[1] = block.yield(ctx, largs[0]); - return runtime.getNil(); - } - }); - - Arrays.sort(valuesAndCriteria, new Comparator<IRubyObject[]>() { - public int compare(IRubyObject[] o1, IRubyObject[] o2) { - return RubyFixnum.fix2int(o1[1].callMethod(localContext, MethodIndex.OP_SPACESHIP, "<=>", o2[1])); - } - }); - - IRubyObject dstArray[] = new IRubyObject[selfArray.size()]; - for (int i = 0; i < dstArray.length; i++) { - dstArray[i] = valuesAndCriteria[i][0]; - } - - return runtime.newArrayNoCopy(dstArray); - } else { - final RubyArray result = runtime.newArray(); - callEach(runtime, context, self, new AppendBlockCallback(runtime, result)); - - final IRubyObject[][] valuesAndCriteria = new IRubyObject[result.size()][2]; - for (int i = 0; i < valuesAndCriteria.length; i++) { - IRubyObject val = result.eltInternal(i); - valuesAndCriteria[i][0] = val; - valuesAndCriteria[i][1] = block.yield(context, val); - } - - Arrays.sort(valuesAndCriteria, new Comparator<IRubyObject[]>() { - public int compare(IRubyObject[] o1, IRubyObject[] o2) { - return RubyFixnum.fix2int(o1[1].callMethod(localContext, MethodIndex.OP_SPACESHIP, "<=>", o2[1])); - } - }); - - for (int i = 0; i < valuesAndCriteria.length; i++) { - result.eltInternalSet(i, valuesAndCriteria[i][0]); - } - - return result; - } - } - - @JRubyMethod(name = "grep", required = 1, frame = true) - public static IRubyObject grep(ThreadContext context, IRubyObject self, final IRubyObject pattern, final Block block) { - final Ruby runtime = self.getRuntime(); - final RubyArray result = runtime.newArray(); - - if (block.isGiven()) { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - ctx.setRubyFrameDelta(ctx.getRubyFrameDelta()+2); - if (pattern.callMethod(ctx, MethodIndex.OP_EQQ, "===", largs[0]).isTrue()) { - IRubyObject value = block.yield(ctx, largs[0]); - synchronized (result) { - result.append(value); - } - } - ctx.setRubyFrameDelta(ctx.getRubyFrameDelta()-2); - return runtime.getNil(); - } - }); - } else { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (pattern.callMethod(ctx, MethodIndex.OP_EQQ, "===", largs[0]).isTrue()) { - synchronized (result) { - result.append(largs[0]); - } - } - return runtime.getNil(); - } - }); - } - - return result; - } - - @JRubyMethod(name = {"detect", "find"}, optional = 1, frame = true) - public static IRubyObject detect(ThreadContext context, IRubyObject self, IRubyObject[] args, final Block block) { - final Ruby runtime = self.getRuntime(); - final IRubyObject result[] = new IRubyObject[] { null }; - final ThreadContext localContext = context; - IRubyObject ifnone = null; - - if (args.length == 1) ifnone = args[0]; - - try { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#detect/find cannot be parallelized"); - } - if (block.yield(ctx, largs[0]).isTrue()) { - result[0] = largs[0]; - throw JumpException.SPECIAL_JUMP; - } - return runtime.getNil(); - } - }); - } catch (JumpException.SpecialJump sj) { - return result[0]; - } - - return ifnone != null ? ifnone.callMethod(context, "call") : runtime.getNil(); - } - - @JRubyMethod(name = {"select", "find_all"}, frame = true) - public static IRubyObject select(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final RubyArray result = runtime.newArray(); - - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (block.yield(ctx, largs[0]).isTrue()) { - synchronized (result) { - result.append(largs[0]); - } - } - return runtime.getNil(); - } - }); - - return result; - } - - @JRubyMethod(name = "reject", frame = true) - public static IRubyObject reject(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final RubyArray result = runtime.newArray(); - - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (!block.yield(ctx, largs[0]).isTrue()) { - synchronized (result) { - result.append(largs[0]); - } - } - return runtime.getNil(); - } - }); - - return result; - } - - @JRubyMethod(name = {"collect", "map"}, frame = true) - public static IRubyObject collect(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final RubyArray result = runtime.newArray(); - - if (block.isGiven()) { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - IRubyObject value = block.yield(ctx, largs[0]); - synchronized (result) { - result.append(value); - } - return runtime.getNil(); - } - }); - } else { - callEach(runtime, context, self, new AppendBlockCallback(runtime, result)); - } - return result; - } - - @JRubyMethod(name = "inject", optional = 1, frame = true) - public static IRubyObject inject(ThreadContext context, IRubyObject self, IRubyObject[] args, final Block block) { - final Ruby runtime = self.getRuntime(); - final IRubyObject result[] = new IRubyObject[] { null }; - final ThreadContext localContext = context; - - if (args.length == 1) result[0] = args[0]; - - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#inject cannot be parallelized"); - } - result[0] = result[0] == null ? - largs[0] : block.yield(ctx, runtime.newArray(result[0], largs[0]), null, null, true); - - return runtime.getNil(); - } - }); - - return result[0] == null ? runtime.getNil() : result[0]; - } - - @JRubyMethod(name = "partition", frame = true) - public static IRubyObject partition(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final RubyArray arr_true = runtime.newArray(); - final RubyArray arr_false = runtime.newArray(); - - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (block.yield(ctx, largs[0]).isTrue()) { - synchronized (arr_true) { - arr_true.append(largs[0]); - } - } else { - synchronized (arr_false) { - arr_false.append(largs[0]); - } - } - - return runtime.getNil(); - } - }); - - return runtime.newArray(arr_true, arr_false); - } - - private static class EachWithIndex implements BlockCallback { - private int index = 0; - private final Block block; - private final Ruby runtime; - - public EachWithIndex(ThreadContext ctx, Block block) { - this.block = block; - this.runtime = ctx.getRuntime(); - } - - public IRubyObject call(ThreadContext context, IRubyObject[] iargs, Block block) { - this.block.call(context, new IRubyObject[] { runtime.newArray(iargs[0], runtime.newFixnum(index++)) }); - return runtime.getNil(); - } - } - - @JRubyMethod(name = "each_with_index", frame = true) - public static IRubyObject each_with_index(ThreadContext context, IRubyObject self, Block block) { - RuntimeHelpers.invoke(context, self, "each", CallBlock.newCallClosure(self, self.getRuntime().getEnumerable(), - Arity.noArguments(), new EachWithIndex(context, block), context)); - - return self; - } - - @JRubyMethod(name = {"include?", "member?"}, required = 1, frame = true) - public static IRubyObject include_p(ThreadContext context, IRubyObject self, final IRubyObject arg) { - final Ruby runtime = context.getRuntime(); - final ThreadContext localContext = context; - - try { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#include?/member? cannot be parallelized"); - } - if (RubyObject.equalInternal(ctx, largs[0], arg)) { - throw JumpException.SPECIAL_JUMP; - } - return runtime.getNil(); - } - }); - } catch (JumpException.SpecialJump sj) { - return runtime.getTrue(); - } - - return runtime.getFalse(); - } - - @JRubyMethod(name = "max", frame = true) - public static IRubyObject max(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final IRubyObject result[] = new IRubyObject[] { null }; - final ThreadContext localContext = context; - - if (block.isGiven()) { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#max{} cannot be parallelized"); - } - if (result[0] == null || RubyComparable.cmpint(ctx, block.yield(ctx, - runtime.newArray(largs[0], result[0])), largs[0], result[0]) > 0) { - result[0] = largs[0]; - } - return runtime.getNil(); - } - }); - } else { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - synchronized (result) { - if (result[0] == null || RubyComparable.cmpint(ctx, largs[0].callMethod(ctx, - MethodIndex.OP_SPACESHIP, "<=>", result[0]), largs[0], result[0]) > 0) { - result[0] = largs[0]; - } - } - return runtime.getNil(); - } - }); - } - - return result[0] == null ? runtime.getNil() : result[0]; - } - - @JRubyMethod(name = "min", frame = true) - public static IRubyObject min(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final IRubyObject result[] = new IRubyObject[] { null }; - final ThreadContext localContext = context; - - if (block.isGiven()) { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#min{} cannot be parallelized"); - } - if (result[0] == null || RubyComparable.cmpint(ctx, block.yield(ctx, - runtime.newArray(largs[0], result[0])), largs[0], result[0]) < 0) { - result[0] = largs[0]; - } - return runtime.getNil(); - } - }); - } else { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - synchronized (result) { - if (result[0] == null || RubyComparable.cmpint(ctx, largs[0].callMethod(ctx, - MethodIndex.OP_SPACESHIP, "<=>", result[0]), largs[0], result[0]) < 0) { - result[0] = largs[0]; - } - } - return runtime.getNil(); - } - }); - } - - return result[0] == null ? runtime.getNil() : result[0]; - } - - @JRubyMethod(name = "all?", frame = true) - public static IRubyObject all_p(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final ThreadContext localContext = context; - - try { - if (block.isGiven()) { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#all? cannot be parallelized"); - } - if (!block.yield(ctx, largs[0]).isTrue()) { - throw JumpException.SPECIAL_JUMP; - } - return runtime.getNil(); - } - }); - } else { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#all? cannot be parallelized"); - } - if (!largs[0].isTrue()) { - throw JumpException.SPECIAL_JUMP; - } - return runtime.getNil(); - } - }); - } - } catch (JumpException.SpecialJump sj) { - return runtime.getFalse(); - } - - return runtime.getTrue(); - } - - @JRubyMethod(name = "any?", frame = true) - public static IRubyObject any_p(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final ThreadContext localContext = context; - - try { - if (block.isGiven()) { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#any? cannot be parallelized"); - } - if (block.yield(ctx, largs[0]).isTrue()) { - throw JumpException.SPECIAL_JUMP; - } - return runtime.getNil(); - } - }); - } else { - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (localContext != ctx) { - throw runtime.newThreadError("Enumerable#any? cannot be parallelized"); - } - if (largs[0].isTrue()) { - throw JumpException.SPECIAL_JUMP; - } - return runtime.getNil(); - } - }); - } - } catch (JumpException.SpecialJump sj) { - return runtime.getTrue(); - } - - return runtime.getFalse(); - } - - @JRubyMethod(name = "zip", rest = true, frame = true) - public static IRubyObject zip(ThreadContext context, IRubyObject self, final IRubyObject[] args, final Block block) { - final Ruby runtime = self.getRuntime(); - - for (int i = 0; i < args.length; i++) { - args[i] = TypeConverter.convertToType(args[i], runtime.getArray(), MethodIndex.TO_A, "to_a"); - } - - final int aLen = args.length + 1; - - if (block.isGiven()) { - callEach(runtime, context, self, new BlockCallback() { - AtomicInteger ix = new AtomicInteger(0); - - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - RubyArray array = runtime.newArray(aLen); - int myIx = ix.getAndIncrement(); - array.append(largs[0]); - for (int i = 0, j = args.length; i < j; i++) { - array.append(((RubyArray) args[i]).entry(myIx)); - } - block.yield(ctx, array); - return runtime.getNil(); - } - }); - return runtime.getNil(); - } else { - final RubyArray zip = runtime.newArray(); - callEach(runtime, context, self, new BlockCallback() { - AtomicInteger ix = new AtomicInteger(0); - - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - RubyArray array = runtime.newArray(aLen); - array.append(largs[0]); - int myIx = ix.getAndIncrement(); - for (int i = 0, j = args.length; i < j; i++) { - array.append(((RubyArray) args[i]).entry(myIx)); - } - synchronized (zip) { - zip.append(array); - } - return runtime.getNil(); - } - }); - return zip; - } - } - - @JRubyMethod(name = "group_by", frame = true) - public static IRubyObject group_by(ThreadContext context, IRubyObject self, final Block block) { - final Ruby runtime = self.getRuntime(); - final RubyHash result = new RubyHash(runtime); - - callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - IRubyObject key = block.yield(ctx, largs[0]); - synchronized (result) { - IRubyObject curr = result.fastARef(key); - - if (curr == null) { - curr = runtime.newArray(); - result.fastASet(key, curr); - } - curr.callMethod(ctx, MethodIndex.OP_LSHIFT, "<<", largs[0]); - } - return runtime.getNil(); - } - }); - - return result; - } - - public static final class AppendBlockCallback implements BlockCallback { - private Ruby runtime; - private RubyArray result; - - public AppendBlockCallback(Ruby runtime, RubyArray result) { - this.runtime = runtime; - this.result = result; - } - - public IRubyObject call(ThreadContext context, IRubyObject[] largs, Block blk) { - result.append(largs[0]); - - return runtime.getNil(); - } - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006 Michael Studman <me@michaelstudman.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Block; -import org.jruby.runtime.BlockCallback; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * Implementation of Ruby's Enumerator module. - */ -@JRubyModule(name="Enumerable::Enumerator", include="Enumerable") -public class RubyEnumerator extends RubyObject { - /** target for each operation */ - private IRubyObject object; - - /** method to invoke for each operation */ - private IRubyObject method; - - /** args to each method */ - private IRubyObject[] methodArgs; - - private static ObjectAllocator ENUMERATOR_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyEnumerator(runtime, klass); - } - }; - - public static void defineEnumerator(Ruby runtime) { - RubyModule kernel = runtime.getKernel(); - kernel.defineAnnotatedMethod(RubyEnumerator.class, "obj_to_enum"); - - RubyModule enm = runtime.getClassFromPath("Enumerable"); - enm.defineAnnotatedMethod(RubyEnumerator.class, "each_with_index"); - enm.defineAnnotatedMethod(RubyEnumerator.class, "each_slice"); - enm.defineAnnotatedMethod(RubyEnumerator.class, "enum_slice"); - enm.defineAnnotatedMethod(RubyEnumerator.class, "each_cons"); - enm.defineAnnotatedMethod(RubyEnumerator.class, "enum_cons"); - - RubyClass enmr = enm.defineClassUnder("Enumerator", runtime.getObject(), ENUMERATOR_ALLOCATOR); - - enmr.includeModule(enm); - - enmr.defineAnnotatedMethod(RubyEnumerator.class, "initialize"); - enmr.defineAnnotatedMethod(RubyEnumerator.class, "each"); - - runtime.setEnumerator(enmr); - } - - @JRubyMethod(name = {"to_enum", "enum_for"}, optional = 1, rest = true, frame = true) - public static IRubyObject obj_to_enum(ThreadContext context, IRubyObject self, IRubyObject[] args, Block block) { - IRubyObject[] newArgs = new IRubyObject[args.length + 1]; - newArgs[0] = self; - System.arraycopy(args, 0, newArgs, 1, args.length); - - return self.getRuntime().getEnumerator().callMethod(context, "new", newArgs); - } - - private RubyEnumerator(Ruby runtime, RubyClass type) { - super(runtime, type); - object = method = runtime.getNil(); - } - - @JRubyMethod(name = "initialize", required = 1, rest = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args) { - object = args[0]; - method = args.length > 1 ? args[1] : getRuntime().fastNewSymbol("each"); - if (args.length > 2) { - methodArgs = new IRubyObject[Math.max(0, args.length - 2)]; - System.arraycopy(args, 2, methodArgs, 0, args.length - 2); - } else { - methodArgs = new IRubyObject[0]; - } - return this; - } - - /** - * Send current block and supplied args to method on target. According to MRI - * Block may not be given and "each" should just ignore it and call on through to - * underlying method. - */ - @JRubyMethod(name = "each", frame = true) - public IRubyObject each(ThreadContext context, Block block) { - return object.callMethod(context, method.asJavaString(), methodArgs, block); - } - - @JRubyMethod(name = "enum_with_index") - public static IRubyObject each_with_index(ThreadContext context, IRubyObject self) { - IRubyObject enumerator = self.getRuntime().getEnumerator(); - return RuntimeHelpers.invoke(context, enumerator, "new", self, self.getRuntime().fastNewSymbol("each_with_index")); - } - - @JRubyMethod(name = "each_slice", required = 1, frame = true) - public static IRubyObject each_slice(ThreadContext context, IRubyObject self, IRubyObject arg, final Block block) { - final int size = (int)RubyNumeric.num2long(arg); - - if (size <= 0) throw self.getRuntime().newArgumentError("invalid slice size"); - - final Ruby runtime = self.getRuntime(); - final RubyArray result[] = new RubyArray[]{runtime.newArray(size)}; - - RubyEnumerable.callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - result[0].append(largs[0]); - if (result[0].size() == size) { - block.yield(ctx, result[0]); - result[0] = runtime.newArray(size); - } - return runtime.getNil(); - } - }); - - if (result[0].size() > 0) block.yield(context, result[0]); - return self.getRuntime().getNil(); - } - - @JRubyMethod(name = "each_cons", required = 1, frame = true) - public static IRubyObject each_cons(ThreadContext context, IRubyObject self, IRubyObject arg, final Block block) { - final int size = (int)RubyNumeric.num2long(arg); - - if (size <= 0) throw self.getRuntime().newArgumentError("invalid size"); - - final Ruby runtime = self.getRuntime(); - final RubyArray result = runtime.newArray(size); - - RubyEnumerable.callEach(runtime, context, self, new BlockCallback() { - public IRubyObject call(ThreadContext ctx, IRubyObject[] largs, Block blk) { - if (result.size() == size) result.shift(); - result.append(largs[0]); - if (result.size() == size) block.yield(ctx, result.aryDup()); - return runtime.getNil(); - } - }); - - return runtime.getNil(); - } - - @JRubyMethod(name = "enum_slice", required = 1) - public static IRubyObject enum_slice(ThreadContext context, IRubyObject self, IRubyObject arg) { - IRubyObject enumerator = self.getRuntime().getEnumerator(); - return RuntimeHelpers.invoke(context, enumerator, "new", self, self.getRuntime().fastNewSymbol("each_slice"), arg); - } - - @JRubyMethod(name = "enum_cons", required = 1) - public static IRubyObject enum_cons(ThreadContext context, IRubyObject self, IRubyObject arg) { - IRubyObject enumerator = self.getRuntime().getEnumerator(); - return RuntimeHelpers.invoke(context, enumerator, "new", self, self.getRuntime().fastNewSymbol("each_cons"), arg); - } -} -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.ext.posix.Passwd; -import org.jruby.ext.posix.Group; -import org.jruby.ext.posix.POSIX; -import org.jruby.ext.posix.util.Platform; -import org.jruby.runtime.Block; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -@JRubyModule(name="Etc") -public class RubyEtc { - public static RubyModule createEtcModule(Ruby runtime) { - RubyModule etcModule = runtime.defineModule("Etc"); - - runtime.setEtc(etcModule); - - etcModule.defineAnnotatedMethods(RubyEtc.class); - - definePasswdStruct(runtime); - defineGroupStruct(runtime); - - return etcModule; - } - - private static void definePasswdStruct(Ruby runtime) { - IRubyObject[] args = new IRubyObject[] { - runtime.newString("Passwd"), - runtime.newSymbol("name"), - runtime.newSymbol("passwd"), - runtime.newSymbol("uid"), - runtime.newSymbol("gid"), - runtime.newSymbol("gecos"), - runtime.newSymbol("dir"), - runtime.newSymbol("shell"), - runtime.newSymbol("change"), - runtime.newSymbol("uclass"), - runtime.newSymbol("expire") - }; - - runtime.setPasswdStruct(RubyStruct.newInstance(runtime.getStructClass(), args, Block.NULL_BLOCK)); - } - - private static void defineGroupStruct(Ruby runtime) { - IRubyObject[] args = new IRubyObject[] { - runtime.newString("Group"), - runtime.newSymbol("name"), - runtime.newSymbol("passwd"), - runtime.newSymbol("gid"), - runtime.newSymbol("mem") - }; - - runtime.setGroupStruct(RubyStruct.newInstance(runtime.getStructClass(), args, Block.NULL_BLOCK)); - } - - private static IRubyObject setupPasswd(Ruby runtime, Passwd passwd) { - IRubyObject[] args = new IRubyObject[] { - runtime.newString(passwd.getLoginName()), - runtime.newString(passwd.getPassword()), - runtime.newFixnum(passwd.getUID()), - runtime.newFixnum(passwd.getGID()), - runtime.newString(passwd.getGECOS()), - runtime.newString(passwd.getHome()), - runtime.newString(passwd.getShell()), - runtime.newFixnum(passwd.getPasswdChangeTime()), - runtime.newString(passwd.getAccessClass()), - runtime.newFixnum(passwd.getExpire()) - - }; - - return RubyStruct.newStruct(runtime.getPasswdStruct(), args, Block.NULL_BLOCK); - } - - - private static IRubyObject setupGroup(Ruby runtime, Group group) { - IRubyObject[] args = new IRubyObject[] { - runtime.newString(group.getName()), - runtime.newString(group.getPassword()), - runtime.newFixnum(group.getGID()), - intoStringArray(runtime, group.getMembers()) - }; - - return RubyStruct.newStruct(runtime.getGroupStruct(), args, Block.NULL_BLOCK); - } - - private static IRubyObject intoStringArray(Ruby runtime, String[] members) { - IRubyObject[] arr = new IRubyObject[members.length]; - for(int i = 0; i<arr.length; i++) { - arr[i] = runtime.newString(members[i]); - } - return runtime.newArrayNoCopy(arr); - } - - - @JRubyMethod(name = "getpwuid", optional=1, module = true) - public static IRubyObject getpwuid(IRubyObject recv, IRubyObject[] args) { - Ruby runtime = recv.getRuntime(); - POSIX posix = runtime.getPosix(); - int uid = args.length == 0 ? posix.getuid() : RubyNumeric.fix2int(args[0]); - Passwd pwd = posix.getpwuid(uid); - if(pwd == null) { - if (Platform.IS_WINDOWS) { // MRI behavior - return recv.getRuntime().getNil(); - } - throw runtime.newArgumentError("can't find user for " + uid); - } - return setupPasswd(runtime, pwd); - } - - @JRubyMethod(name = "getpwnam", required=1, module = true) - public static IRubyObject getpwnam(IRubyObject recv, IRubyObject name) { - String nam = name.convertToString().toString(); - Passwd pwd = recv.getRuntime().getPosix().getpwnam(nam); - if(pwd == null) { - if (Platform.IS_WINDOWS) { // MRI behavior - return recv.getRuntime().getNil(); - } - throw recv.getRuntime().newArgumentError("can't find user for " + nam); - } - return setupPasswd(recv.getRuntime(), pwd); - } - - @JRubyMethod(name = "passwd", module = true, frame=true) - public static IRubyObject passwd(IRubyObject recv, Block block) { - Ruby runtime = recv.getRuntime(); - POSIX posix = runtime.getPosix(); - if(block.isGiven()) { - ThreadContext context = runtime.getCurrentContext(); - posix.setpwent(); - Passwd pw; - while((pw = posix.getpwent()) != null) { - block.yield(context, setupPasswd(runtime, pw)); - } - posix.endpwent(); - } - - Passwd pw = posix.getpwent(); - if (pw != null) { - return setupPasswd(runtime, pw); - } else { - return runtime.getNil(); - } - } - - @JRubyMethod(name = "getlogin", module = true) - public static IRubyObject getlogin(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - - String login = runtime.getPosix().getlogin(); - - if (login != null) { - return runtime.newString(login); - } else { - return runtime.getNil(); - } - } - - @JRubyMethod(name = "endpwent", module = true) - public static IRubyObject endpwent(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - runtime.getPosix().endpwent(); - return runtime.getNil(); - } - - @JRubyMethod(name = "setpwent", module = true) - public static IRubyObject setpwent(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - runtime.getPosix().setpwent(); - return runtime.getNil(); - } - - @JRubyMethod(name = "getpwent", module = true) - public static IRubyObject getpwent(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - Passwd passwd = runtime.getPosix().getpwent(); - if (passwd != null) { - return setupPasswd(recv.getRuntime(), passwd); - } else { - return runtime.getNil(); - } - } - - @JRubyMethod(name = "getgrnam", required=1, module = true) - public static IRubyObject getgrnam(IRubyObject recv, IRubyObject name) { - String nam = name.convertToString().toString(); - Group grp = recv.getRuntime().getPosix().getgrnam(nam); - if(grp == null) { - if (Platform.IS_WINDOWS) { // MRI behavior - return recv.getRuntime().getNil(); - } - throw recv.getRuntime().newArgumentError("can't find group for " + nam); - } - return setupGroup(recv.getRuntime(), grp); - } - - @JRubyMethod(name = "getgrgid", optional=1, module = true) - public static IRubyObject getgrgid(IRubyObject recv, IRubyObject[] args) { - Ruby runtime = recv.getRuntime(); - POSIX posix = runtime.getPosix(); - int gid = args.length == 0 ? posix.getgid() : RubyNumeric.fix2int(args[0]); - Group gr = posix.getgrgid(gid); - if(gr == null) { - if (Platform.IS_WINDOWS) { // MRI behavior - return runtime.getNil(); - } - throw runtime.newArgumentError("can't find group for " + gid); - } - return setupGroup(runtime, gr); - } - - @JRubyMethod(name = "endgrent", module = true) - public static IRubyObject endgrent(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - runtime.getPosix().endgrent(); - return runtime.getNil(); - } - - @JRubyMethod(name = "setgrent", module = true) - public static IRubyObject setgrent(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - runtime.getPosix().setgrent(); - return runtime.getNil(); - } - - @JRubyMethod(name = "group", module = true, frame=true) - public static IRubyObject group(IRubyObject recv, Block block) { - Ruby runtime = recv.getRuntime(); - POSIX posix = runtime.getPosix(); - if(block.isGiven()) { - ThreadContext context = runtime.getCurrentContext(); - posix.setgrent(); - Group gr; - while((gr = posix.getgrent()) != null) { - block.yield(context, setupGroup(runtime, gr)); - } - posix.endgrent(); - } - - Group gr = posix.getgrent(); - if (gr != null) { - return setupGroup(runtime, gr); - } else { - return runtime.getNil(); - } - } - - @JRubyMethod(name = "getgrent", module = true) - public static IRubyObject getgrent(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - Group gr = runtime.getPosix().getgrent(); - if (gr != null) { - return setupGroup(recv.getRuntime(), gr); - } else { - return runtime.getNil(); - } - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Joey Gibson <joey@joeygibson.com> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 David Corbin <dcorbin@users.sf.net> - * Copyright (C) 2006 Michael Studman <codehaus@michaelstudman.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; -import java.io.PrintStream; -import java.util.List; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; - -import org.jruby.runtime.Block; -import org.jruby.runtime.Frame; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ObjectMarshal; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.builtin.Variable; -import org.jruby.runtime.component.VariableEntry; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.SafePropertyAccessor; - -/** - * - * @author jpetersen - */ -@JRubyClass(name="Exception") -public class RubyException extends RubyObject { - private StackTraceElement[] backtraceFrames; - private StackTraceElement[] javaStackTrace; - private IRubyObject backtrace; - public IRubyObject message; - public static final int TRACE_HEAD = 8; - public static final int TRACE_TAIL = 4; - public static final int TRACE_MAX = TRACE_HEAD + TRACE_TAIL + 6; - - protected RubyException(Ruby runtime, RubyClass rubyClass) { - this(runtime, rubyClass, null); - } - - public RubyException(Ruby runtime, RubyClass rubyClass, String message) { - super(runtime, rubyClass); - - this.message = message == null ? runtime.getNil() : runtime.newString(message); - } - - private static ObjectAllocator EXCEPTION_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - RubyException instance = new RubyException(runtime, klass); - - // for future compatibility as constructors move toward not accepting metaclass? - instance.setMetaClass(klass); - - return instance; - } - }; - - private static final ObjectMarshal EXCEPTION_MARSHAL = new ObjectMarshal() { - public void marshalTo(Ruby runtime, Object obj, RubyClass type, - MarshalStream marshalStream) throws IOException { - RubyException exc = (RubyException)obj; - - marshalStream.registerLinkTarget(exc); - List<Variable<IRubyObject>> attrs = exc.getVariableList(); - attrs.add(new VariableEntry<IRubyObject>( - "mesg", exc.message == null ? runtime.getNil() : exc.message)); - attrs.add(new VariableEntry<IRubyObject>("bt", exc.getBacktrace())); - marshalStream.dumpVariables(attrs); - } - - public Object unmarshalFrom(Ruby runtime, RubyClass type, - UnmarshalStream unmarshalStream) throws IOException { - RubyException exc = (RubyException)type.allocate(); - - unmarshalStream.registerLinkTarget(exc); - unmarshalStream.defaultVariablesUnmarshal(exc); - - exc.message = exc.removeInternalVariable("mesg"); - exc.set_backtrace(exc.removeInternalVariable("bt")); - - return exc; - } - }; - - public static RubyClass createExceptionClass(Ruby runtime) { - RubyClass exceptionClass = runtime.defineClass("Exception", runtime.getObject(), EXCEPTION_ALLOCATOR); - runtime.setException(exceptionClass); - - exceptionClass.setMarshal(EXCEPTION_MARSHAL); - exceptionClass.defineAnnotatedMethods(RubyException.class); - - return exceptionClass; - } - - public static RubyException newException(Ruby runtime, RubyClass excptnClass, String msg) { - return new RubyException(runtime, excptnClass, msg); - } - - public void setBacktraceFrames(StackTraceElement[] backtraceFrames) { - this.backtraceFrames = backtraceFrames; - if (TRACE_TYPE == RAW || - TRACE_TYPE == RAW_FILTERED || - TRACE_TYPE == RUBY_COMPILED || - TRACE_TYPE == RUBY_HYBRID) { - javaStackTrace = Thread.currentThread().getStackTrace(); - } - } - - public static final int RAW = 0; - public static final int RAW_FILTERED = 1; - public static final int RUBY_FRAMED = 2; - public static final int RUBY_COMPILED = 3; - public static final int RUBY_HYBRID = 4; - - public static final int TRACE_TYPE; - - static { - String style = SafePropertyAccessor.getProperty("jruby.backtrace.style", "ruby_framed").toLowerCase(); - - if (style.equals("raw")) TRACE_TYPE = RAW; - else if (style.equals("raw_filtered")) TRACE_TYPE = RAW_FILTERED; - else if (style.equals("ruby_framed")) TRACE_TYPE = RUBY_FRAMED; - else if (style.equals("ruby_compiled")) TRACE_TYPE = RUBY_COMPILED; - else if (style.equals("ruby_hybrid")) TRACE_TYPE = RUBY_HYBRID; - else TRACE_TYPE = RUBY_FRAMED; - } - - public IRubyObject getBacktrace() { - if (backtrace == null) { - initBacktrace(); - } - return backtrace; - } - - public void initBacktrace() { - switch (TRACE_TYPE) { - case RAW: - backtrace = ThreadContext.createRawBacktrace(getRuntime(), javaStackTrace, false); - break; - case RAW_FILTERED: - backtrace = ThreadContext.createRawBacktrace(getRuntime(), javaStackTrace, true); - break; - case RUBY_FRAMED: - backtrace = backtraceFrames == null ? getRuntime().getNil() : ThreadContext.createBacktraceFromFrames(getRuntime(), backtraceFrames); - break; - case RUBY_COMPILED: - backtrace = ThreadContext.createRubyCompiledBacktrace(getRuntime(), javaStackTrace); - break; - case RUBY_HYBRID: - backtrace = ThreadContext.createRubyHybridBacktrace(getRuntime(), backtraceFrames, javaStackTrace, getRuntime().getDebug().isTrue()); - break; - } - } - - @JRubyMethod(optional = 2, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, Block block) { - if (args.length == 1) message = args[0]; - return this; - } - - @JRubyMethod - public IRubyObject backtrace() { - return getBacktrace(); - } - - @JRubyMethod(required = 1) - public IRubyObject set_backtrace(IRubyObject obj) { - if (obj.isNil()) { - backtrace = null; - } else if (!isArrayOfStrings(obj)) { - throw getRuntime().newTypeError("backtrace must be Array of String"); - } else { - backtrace = (RubyArray) obj; - } - return backtrace(); - } - - @JRubyMethod(name = "exception", optional = 1, rest = true, meta = true) - public static IRubyObject exception(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - return ((RubyClass) recv).newInstance(context, args, block); - } - - @JRubyMethod(optional = 1) - public RubyException exception(IRubyObject[] args) { - switch (args.length) { - case 0 : - return this; - case 1 : - if(args[0] == this) { - return this; - } - RubyException ret = (RubyException)rbClone(); - ret.initialize(args, Block.NULL_BLOCK); // This looks wrong, but it's the way MRI does it. - return ret; - default : - throw getRuntime().newArgumentError("Wrong argument count"); - } - } - - @JRubyMethod - public IRubyObject to_s() { - if (message.isNil()) return getRuntime().newString(getMetaClass().getName()); - message.setTaint(isTaint()); - return message; - } - - @JRubyMethod(name = {"to_str", "message"}) - public IRubyObject to_str(ThreadContext context) { - return callMethod(context, MethodIndex.TO_S, "to_s"); - } - - /** inspects an object and return a kind of debug information - * - *@return A RubyString containing the debug information. - */ - @JRubyMethod - public IRubyObject inspect(ThreadContext context) { - RubyModule rubyClass = getMetaClass(); - RubyString exception = RubyString.objAsString(context, this); - - if (exception.getByteList().realSize == 0) return getRuntime().newString(rubyClass.getName()); - StringBuilder sb = new StringBuilder("#<"); - sb.append(rubyClass.getName()).append(": ").append(exception.getByteList()).append(">"); - return getRuntime().newString(sb.toString()); - } - - public void printBacktrace(PrintStream errorStream) { - IRubyObject backtrace = callMethod(getRuntime().getCurrentContext(), "backtrace"); - boolean debug = getRuntime().getDebug().isTrue(); - if (!backtrace.isNil() && backtrace instanceof RubyArray) { - IRubyObject[] elements = backtrace.convertToArray().toJavaArray(); - - for (int i = 1; i < elements.length; i++) { - IRubyObject stackTraceLine = elements[i]; - if (stackTraceLine instanceof RubyString) { - printStackTraceLine(errorStream, stackTraceLine); - } - - if (!debug && i == RubyException.TRACE_HEAD && elements.length > RubyException.TRACE_MAX) { - int hiddenLevels = elements.length - RubyException.TRACE_HEAD - RubyException.TRACE_TAIL; - errorStream.print("\t ... " + hiddenLevels + " levels...\n"); - i = elements.length - RubyException.TRACE_TAIL; - } - } - } - } - - private void printStackTraceLine(PrintStream errorStream, IRubyObject stackTraceLine) { - errorStream.print("\tfrom " + stackTraceLine + '\n'); - } - - private boolean isArrayOfStrings(IRubyObject backtrace) { - if (!(backtrace instanceof RubyArray)) return false; - - IRubyObject[] elements = ((RubyArray) backtrace).toJavaArray(); - - for (int i = 0 ; i < elements.length ; i++) { - if (!(elements[i] instanceof RubyString)) return false; - } - - return true; - } -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2003 Joey Gibson <joey@joeygibson.com> - * Copyright (C) 2004-2007 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2007 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.util.io.OpenFile; -import org.jruby.util.io.ChannelDescriptor; -import java.io.File; -import java.io.FileDescriptor; -import java.io.FileNotFoundException; -import java.io.IOException; -import java.io.InputStream; -import java.io.Reader; -import java.nio.channels.Channels; -import java.nio.channels.FileChannel; -import java.nio.channels.FileLock; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.ext.posix.util.Platform; -import org.jruby.runtime.Block; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.io.DirectoryAsFileException; -import org.jruby.util.io.Stream; -import org.jruby.util.io.ChannelStream; -import org.jruby.util.io.ModeFlags; -import org.jruby.util.JRubyFile; -import org.jruby.util.TypeConverter; -import org.jruby.util.io.BadDescriptorException; -import org.jruby.util.io.FileExistsException; -import org.jruby.util.io.InvalidValueException; -import org.jruby.util.io.PipeException; - -/** - * Ruby File class equivalent in java. - **/ -@JRubyClass(name="File", parent="IO", include="FileTest") -public class RubyFile extends RubyIO { - private static final long serialVersionUID = 1L; - - public static final int LOCK_SH = 1; - public static final int LOCK_EX = 2; - public static final int LOCK_NB = 4; - public static final int LOCK_UN = 8; - - private static final int FNM_NOESCAPE = 1; - private static final int FNM_PATHNAME = 2; - private static final int FNM_DOTMATCH = 4; - private static final int FNM_CASEFOLD = 8; - private static final int FNM_SYSCASE; - - static { - if (Platform.IS_WINDOWS) { - FNM_SYSCASE = FNM_CASEFOLD; - } else { - FNM_SYSCASE = 0; - } - } - - private static boolean startsWithDriveLetterOnWindows(String path) { - return (path != null) - && Platform.IS_WINDOWS && - ((path.length()>1 && path.charAt(0) == '/') ? - (path.length() > 2 - && isWindowsDriveLetter(path.charAt(1)) - && path.charAt(2) == ':') : - (path.length() > 1 - && isWindowsDriveLetter(path.charAt(0)) - && path.charAt(1) == ':')); - } - // adjusts paths started with '/' or '\\', on windows. - static String adjustRootPathOnWindows(Ruby runtime, String path, String dir) { - if (path == null) return path; - if (Platform.IS_WINDOWS) { - // MRI behavior on Windows: it treats '/' as a root of - // a current drive (but only if SINGLE slash is present!): - // E.g., if current work directory is - // 'D:/home/directory', then '/' means 'D:/'. - // - // Basically, '/path' is treated as a *RELATIVE* path, - // relative to the current drive. '//path' is treated - // as absolute one. - if ((path.startsWith("/") && !(path.length()>2 && path.charAt(2) == ':')) || path.startsWith("\\")) { - if (path.length() > 1 && (path.charAt(1) == '/' || path.charAt(1) == '\\')) { - return path; - } - - // First try to use drive letter from supplied dir value, - // then try current work dir. - if (!startsWithDriveLetterOnWindows(dir)) { - dir = runtime.getCurrentDirectory(); - } - if (dir.length() >= 2) { - path = dir.substring(0, 2) + path; - } - } else if (startsWithDriveLetterOnWindows(path) && path.length() == 2) { - // compensate for missing slash after drive letter on windows - path += "/"; - } - } - return path; - } - - protected String path; - private FileLock currentLock; - - public RubyFile(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - // XXX This constructor is a hack to implement the __END__ syntax. - // Converting a reader back into an InputStream doesn't generally work. - public RubyFile(Ruby runtime, String path, final Reader reader) { - this(runtime, path, new InputStream() { - public int read() throws IOException { - return reader.read(); - } - }); - } - - public RubyFile(Ruby runtime, String path, InputStream in) { - super(runtime, runtime.getFile()); - this.path = path; - try { - this.openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(Channels.newChannel(in), getNewFileno(), new FileDescriptor()))); - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } - this.openFile.setMode(openFile.getMainStream().getModes().getOpenFileFlags()); - registerDescriptor(openFile.getMainStream().getDescriptor()); - } - - private static ObjectAllocator FILE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - RubyFile instance = new RubyFile(runtime, klass); - - instance.setMetaClass(klass); - - return instance; - } - }; - - @JRubyModule(name="File::Constants") - public static class Constants {} - - public static RubyClass createFileClass(Ruby runtime) { - RubyClass fileClass = runtime.defineClass("File", runtime.getIO(), FILE_ALLOCATOR); - runtime.setFile(fileClass); - RubyString separator = runtime.newString("/"); - ThreadContext context = runtime.getCurrentContext(); - - fileClass.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyFile; - } - }; - - separator.freeze(context); - fileClass.defineConstant("SEPARATOR", separator); - fileClass.defineConstant("Separator", separator); - - if (File.separatorChar == '\\') { - RubyString altSeparator = runtime.newString("\\"); - altSeparator.freeze(context); - fileClass.defineConstant("ALT_SEPARATOR", altSeparator); - } else { - fileClass.defineConstant("ALT_SEPARATOR", runtime.getNil()); - } - - RubyString pathSeparator = runtime.newString(File.pathSeparator); - pathSeparator.freeze(context); - fileClass.defineConstant("PATH_SEPARATOR", pathSeparator); - - // TODO: why are we duplicating the constants here, and then in - // File::Constants below? File::Constants is included in IO. - - // TODO: These were missing, so we're not handling them elsewhere? - // FIXME: The old value, 32786, didn't match what IOModes expected, so I reference - // the constant here. THIS MAY NOT BE THE CORRECT VALUE. - fileClass.fastSetConstant("BINARY", runtime.newFixnum(ModeFlags.BINARY)); - fileClass.fastSetConstant("FNM_NOESCAPE", runtime.newFixnum(FNM_NOESCAPE)); - fileClass.fastSetConstant("FNM_CASEFOLD", runtime.newFixnum(FNM_CASEFOLD)); - fileClass.fastSetConstant("FNM_SYSCASE", runtime.newFixnum(FNM_SYSCASE)); - fileClass.fastSetConstant("FNM_DOTMATCH", runtime.newFixnum(FNM_DOTMATCH)); - fileClass.fastSetConstant("FNM_PATHNAME", runtime.newFixnum(FNM_PATHNAME)); - - // Create constants for open flags - fileClass.fastSetConstant("RDONLY", runtime.newFixnum(ModeFlags.RDONLY)); - fileClass.fastSetConstant("WRONLY", runtime.newFixnum(ModeFlags.WRONLY)); - fileClass.fastSetConstant("RDWR", runtime.newFixnum(ModeFlags.RDWR)); - fileClass.fastSetConstant("CREAT", runtime.newFixnum(ModeFlags.CREAT)); - fileClass.fastSetConstant("EXCL", runtime.newFixnum(ModeFlags.EXCL)); - fileClass.fastSetConstant("NOCTTY", runtime.newFixnum(ModeFlags.NOCTTY)); - fileClass.fastSetConstant("TRUNC", runtime.newFixnum(ModeFlags.TRUNC)); - fileClass.fastSetConstant("APPEND", runtime.newFixnum(ModeFlags.APPEND)); - fileClass.fastSetConstant("NONBLOCK", runtime.newFixnum(ModeFlags.NONBLOCK)); - - // Create constants for flock - fileClass.fastSetConstant("LOCK_SH", runtime.newFixnum(RubyFile.LOCK_SH)); - fileClass.fastSetConstant("LOCK_EX", runtime.newFixnum(RubyFile.LOCK_EX)); - fileClass.fastSetConstant("LOCK_NB", runtime.newFixnum(RubyFile.LOCK_NB)); - fileClass.fastSetConstant("LOCK_UN", runtime.newFixnum(RubyFile.LOCK_UN)); - - // Create Constants class - RubyModule constants = fileClass.defineModuleUnder("Constants"); - - // TODO: These were missing, so we're not handling them elsewhere? - constants.fastSetConstant("BINARY", runtime.newFixnum(ModeFlags.BINARY)); - constants.fastSetConstant("SYNC", runtime.newFixnum(0x1000)); - constants.fastSetConstant("FNM_NOESCAPE", runtime.newFixnum(FNM_NOESCAPE)); - constants.fastSetConstant("FNM_CASEFOLD", runtime.newFixnum(FNM_CASEFOLD)); - constants.fastSetConstant("FNM_SYSCASE", runtime.newFixnum(FNM_SYSCASE)); - constants.fastSetConstant("FNM_DOTMATCH", runtime.newFixnum(FNM_DOTMATCH)); - constants.fastSetConstant("FNM_PATHNAME", runtime.newFixnum(FNM_PATHNAME)); - - // Create constants for open flags - constants.fastSetConstant("RDONLY", runtime.newFixnum(ModeFlags.RDONLY)); - constants.fastSetConstant("WRONLY", runtime.newFixnum(ModeFlags.WRONLY)); - constants.fastSetConstant("RDWR", runtime.newFixnum(ModeFlags.RDWR)); - constants.fastSetConstant("CREAT", runtime.newFixnum(ModeFlags.CREAT)); - constants.fastSetConstant("EXCL", runtime.newFixnum(ModeFlags.EXCL)); - constants.fastSetConstant("NOCTTY", runtime.newFixnum(ModeFlags.NOCTTY)); - constants.fastSetConstant("TRUNC", runtime.newFixnum(ModeFlags.TRUNC)); - constants.fastSetConstant("APPEND", runtime.newFixnum(ModeFlags.APPEND)); - constants.fastSetConstant("NONBLOCK", runtime.newFixnum(ModeFlags.NONBLOCK)); - - // Create constants for flock - constants.fastSetConstant("LOCK_SH", runtime.newFixnum(RubyFile.LOCK_SH)); - constants.fastSetConstant("LOCK_EX", runtime.newFixnum(RubyFile.LOCK_EX)); - constants.fastSetConstant("LOCK_NB", runtime.newFixnum(RubyFile.LOCK_NB)); - constants.fastSetConstant("LOCK_UN", runtime.newFixnum(RubyFile.LOCK_UN)); - - // File::Constants module is included in IO. - runtime.getIO().includeModule(constants); - - runtime.getFileTest().extend_object(fileClass); - - fileClass.defineAnnotatedMethods(RubyFile.class); - - return fileClass; - } - - @JRubyMethod - @Override - public IRubyObject close() { - // Make sure any existing lock is released before we try and close the file - if (currentLock != null) { - try { - currentLock.release(); - } catch (IOException e) { - throw getRuntime().newIOError(e.getMessage()); - } - } - return super.close(); - } - - @JRubyMethod(required = 1) - public IRubyObject flock(ThreadContext context, IRubyObject lockingConstant) { - // TODO: port exact behavior from MRI, and move most locking logic into ChannelDescriptor - // TODO: for all LOCK_NB cases, return false if they would block - ChannelDescriptor descriptor = openFile.getMainStream().getDescriptor(); - - // null channel always succeeds for all locking operations - if (descriptor.isNull()) return RubyFixnum.zero(context.getRuntime()); - - FileChannel fileChannel = (FileChannel)descriptor.getChannel(); - int lockMode = RubyNumeric.num2int(lockingConstant); - - // Exclusive locks in Java require the channel to be writable, otherwise - // an exception is thrown (terminating JRuby execution). - // But flock behavior of MRI is that it allows - // exclusive locks even on non-writable file. So we convert exclusive - // lock to shared lock if the channel is not writable, to better match - // the MRI behavior. - if (!openFile.isWritable() && (lockMode & LOCK_EX) > 0) { - lockMode = (lockMode ^ LOCK_EX) | LOCK_SH; - } - - try { - switch (lockMode) { - case LOCK_UN: - case LOCK_UN | LOCK_NB: - if (currentLock != null) { - currentLock.release(); - currentLock = null; - - return RubyFixnum.zero(context.getRuntime()); - } - break; - case LOCK_EX: - if (currentLock != null) { - currentLock.release(); - currentLock = null; - } - currentLock = fileChannel.lock(); - if (currentLock != null) { - return RubyFixnum.zero(context.getRuntime()); - } - - break; - case LOCK_EX | LOCK_NB: - if (currentLock != null) { - currentLock.release(); - currentLock = null; - } - currentLock = fileChannel.tryLock(); - if (currentLock != null) { - return RubyFixnum.zero(context.getRuntime()); - } - - break; - case LOCK_SH: - if (currentLock != null) { - currentLock.release(); - currentLock = null; - } - - currentLock = fileChannel.lock(0L, Long.MAX_VALUE, true); - if (currentLock != null) { - return RubyFixnum.zero(context.getRuntime()); - } - - break; - case LOCK_SH | LOCK_NB: - if (currentLock != null) { - currentLock.release(); - currentLock = null; - } - - currentLock = fileChannel.tryLock(0L, Long.MAX_VALUE, true); - if (currentLock != null) { - return RubyFixnum.zero(context.getRuntime()); - } - - break; - default: - } - } catch (IOException ioe) { - if (context.getRuntime().getDebug().isTrue()) { - ioe.printStackTrace(System.err); - } - // Return false here - } catch (java.nio.channels.OverlappingFileLockException ioe) { - if (context.getRuntime().getDebug().isTrue()) { - ioe.printStackTrace(System.err); - } - // Return false here - } - - return context.getRuntime().getFalse(); - } - - @JRubyMethod(required = 1, optional = 2, frame = true, visibility = Visibility.PRIVATE) - @Override - public IRubyObject initialize(IRubyObject[] args, Block block) { - if (openFile == null) { - throw getRuntime().newRuntimeError("reinitializing File"); - } - - if (args.length > 0 && args.length < 3) { - IRubyObject fd = TypeConverter.convertToTypeWithCheck(args[0], getRuntime().getFixnum(), MethodIndex.TO_INT, "to_int"); - if (!fd.isNil()) { - args[0] = fd; - return super.initialize(args, block); - } - } - - return openFile(args); - } - - private IRubyObject openFile(IRubyObject args[]) { - IRubyObject filename = args[0].convertToString(); - getRuntime().checkSafeString(filename); - - path = filename.convertToString().getUnicodeValue(); - - String modeString; - ModeFlags modes; - int perm; - - try { - if ((args.length > 1 && args[1] instanceof RubyFixnum) || (args.length > 2 && !args[2].isNil())) { - if (args[1] instanceof RubyFixnum) { - modes = new ModeFlags(RubyNumeric.num2int(args[1])); - } else { - modeString = args[1].convertToString().toString(); - modes = getIOModes(getRuntime(), modeString); - } - if (args.length > 2 && !args[2].isNil()) { - perm = RubyNumeric.num2int(args[2]); - } else { - perm = 438; // 0666 - } - - sysopenInternal(path, modes, perm); - } else { - modeString = "r"; - if (args.length > 1) { - if (!args[1].isNil()) { - modeString = args[1].convertToString().toString(); - } - } - openInternal(path, modeString); - } - } catch (InvalidValueException ex) { - throw getRuntime().newErrnoEINVALError(); - } finally {} - - return this; - } - - private void sysopenInternal(String path, ModeFlags modes, int perm) throws InvalidValueException { - openFile = new OpenFile(); - - openFile.setPath(path); - openFile.setMode(modes.getOpenFileFlags()); - - ChannelDescriptor descriptor = sysopen(path, modes, perm); - openFile.setMainStream(fdopen(descriptor, modes)); - - registerDescriptor(descriptor); - } - - private void openInternal(String path, String modeString) throws InvalidValueException { - openFile = new OpenFile(); - - openFile.setMode(getIOModes(getRuntime(), modeString).getOpenFileFlags()); - openFile.setPath(path); - openFile.setMainStream(fopen(path, modeString)); - - registerDescriptor(openFile.getMainStream().getDescriptor()); - } - - private ChannelDescriptor sysopen(String path, ModeFlags modes, int perm) throws InvalidValueException { - try { - ChannelDescriptor descriptor = ChannelDescriptor.open( - getRuntime().getCurrentDirectory(), - path, - modes, - perm, - getRuntime().getPosix()); - - // TODO: check if too many open files, GC and try again - - return descriptor; - } catch (FileNotFoundException fnfe) { - throw getRuntime().newErrnoENOENTError(); - } catch (DirectoryAsFileException dafe) { - throw getRuntime().newErrnoEISDirError(); - } catch (FileExistsException fee) { - throw getRuntime().newErrnoEEXISTError("file exists: " + path); - } catch (IOException ioe) { - throw getRuntime().newIOErrorFromException(ioe); - } - } - - private Stream fopen(String path, String modeString) { - try { - Stream stream = ChannelStream.fopen( - getRuntime(), - path, - getIOModes(getRuntime(), modeString)); - - if (stream == null) { - // TODO - // if (errno == EMFILE || errno == ENFILE) { - // rb_gc(); - // file = fopen(fname, mode); - // } - // if (!file) { - // rb_sys_fail(fname); - // } - } - - // Do we need to be in SETVBUF mode for buffering to make sense? This comes up elsewhere. - // #ifdef USE_SETVBUF - // if (setvbuf(file, NULL, _IOFBF, 0) != 0) - // rb_warn("setvbuf() can't be honoured for %s", fname); - // #endif - // #ifdef __human68k__ - // fmode(file, _IOTEXT); - // #endif - return stream; - } catch (BadDescriptorException e) { - throw getRuntime().newErrnoEBADFError(); - } catch (FileNotFoundException ex) { - // FNFException can be thrown in both cases, when the file - // is not found, or when permission is denied. - if (Ruby.isSecurityRestricted() || new File(path).exists()) { - throw getRuntime().newErrnoEACCESError( - "Permission denied - " + path); - } - throw getRuntime().newErrnoENOENTError( - "File not found - " + path); - } catch (DirectoryAsFileException ex) { - throw getRuntime().newErrnoEISDirError(); - } catch (FileExistsException ex) { - throw getRuntime().newErrnoEEXISTError(path); - } catch (IOException ex) { - throw getRuntime().newIOErrorFromException(ex); - } catch (InvalidValueException ex) { - throw getRuntime().newErrnoEINVALError(); - } catch (PipeException ex) { - throw getRuntime().newErrnoEPIPEError(); - } - } - - @JRubyMethod(required = 1) - public IRubyObject chmod(ThreadContext context, IRubyObject arg) { - int mode = (int) arg.convertToInteger().getLongValue(); - - if (!new File(path).exists()) { - throw context.getRuntime().newErrnoENOENTError("No such file or directory - " + path); - } - - return context.getRuntime().newFixnum(context.getRuntime().getPosix().chmod(path, mode)); - } - - @JRubyMethod(required = 2) - public IRubyObject chown(ThreadContext context, IRubyObject arg1, IRubyObject arg2) { - int owner = -1; - if (!arg1.isNil()) { - owner = RubyNumeric.num2int(arg1); - } - - int group = -1; - if (!arg2.isNil()) { - group = RubyNumeric.num2int(arg2); - } - - if (!new File(path).exists()) { - throw context.getRuntime().newErrnoENOENTError("No such file or directory - " + path); - } - - return context.getRuntime().newFixnum(context.getRuntime().getPosix().chown(path, owner, group)); - } - - @JRubyMethod - public IRubyObject atime(ThreadContext context) { - return context.getRuntime().newFileStat(path, false).atime(); - } - - @JRubyMethod - public IRubyObject ctime(ThreadContext context) { - return context.getRuntime().newFileStat(path, false).ctime(); - } - - @JRubyMethod(required = 1) - public IRubyObject lchmod(ThreadContext context, IRubyObject arg) { - int mode = (int) arg.convertToInteger().getLongValue(); - - if (!new File(path).exists()) { - throw context.getRuntime().newErrnoENOENTError("No such file or directory - " + path); - } - - return context.getRuntime().newFixnum(context.getRuntime().getPosix().lchmod(path, mode)); - } - - // TODO: this method is not present in MRI! - @JRubyMethod(required = 2) - public IRubyObject lchown(ThreadContext context, IRubyObject arg1, IRubyObject arg2) { - int owner = -1; - if (!arg1.isNil()) { - owner = RubyNumeric.num2int(arg1); - } - - int group = -1; - if (!arg2.isNil()) { - group = RubyNumeric.num2int(arg2); - } - - if (!new File(path).exists()) { - throw context.getRuntime().newErrnoENOENTError("No such file or directory - " + path); - } - - return context.getRuntime().newFixnum(context.getRuntime().getPosix().lchown(path, owner, group)); - } - - @JRubyMethod - public IRubyObject lstat(ThreadContext context) { - return context.getRuntime().newFileStat(path, true); - } - - @JRubyMethod - public IRubyObject mtime(ThreadContext context) { - return getLastModified(context.getRuntime(), path); - } - - @JRubyMethod - public RubyString path(ThreadContext context) { - return context.getRuntime().newString(path); - } - - @JRubyMethod - @Override - public IRubyObject stat(ThreadContext context) { - openFile.checkClosed(context.getRuntime()); - return context.getRuntime().newFileStat(path, false); - } - - @JRubyMethod(required = 1) - public IRubyObject truncate(ThreadContext context, IRubyObject arg) { - RubyInteger newLength = arg.convertToInteger(); - if (newLength.getLongValue() < 0) { - throw context.getRuntime().newErrnoEINVALError("invalid argument: " + path); - } - try { - openFile.checkWritable(context.getRuntime()); - openFile.getMainStream().ftruncate(newLength.getLongValue()); - } catch (BadDescriptorException e) { - throw context.getRuntime().newErrnoEBADFError(); - } catch (PipeException e) { - throw context.getRuntime().newErrnoESPIPEError(); - } catch (InvalidValueException ex) { - throw context.getRuntime().newErrnoEINVALError(); - } catch (IOException e) { - // Should we do anything? - } - - return RubyFixnum.zero(context.getRuntime()); - } - - @Override - public String toString() { - return "RubyFile(" + path + ", " + openFile.getMode() + ", " + openFile.getMainStream().getDescriptor().getFileno() + ")"; - } - - // TODO: This is also defined in the MetaClass too...Consolidate somewhere. - private static ModeFlags getModes(Ruby runtime, IRubyObject object) throws InvalidValueException { - if (object instanceof RubyString) { - return getIOModes(runtime, ((RubyString) object).toString()); - } else if (object instanceof RubyFixnum) { - return new ModeFlags(((RubyFixnum) object).getLongValue()); - } - - throw runtime.newTypeError("Invalid type for modes"); - } - - @JRubyMethod - @Override - public IRubyObject inspect() { - StringBuilder val = new StringBuilder(); - val.append("#<File:").append(path); - if(!openFile.isOpen()) { - val.append(" (closed)"); - } - val.append(">"); - return getRuntime().newString(val.toString()); - } - - /* File class methods */ - - @JRubyMethod(required = 1, optional = 1, meta = true) - public static IRubyObject basename(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - String name = RubyString.stringValue(args[0]).toString(); - - // MRI-compatible basename handling for windows drive letter paths - if (Platform.IS_WINDOWS) { - if (name.length() > 1 && name.charAt(1) == ':' && Character.isLetter(name.charAt(0))) { - switch (name.length()) { - case 2: - return RubyString.newEmptyString(context.getRuntime()).infectBy(args[0]); - case 3: - return context.getRuntime().newString(name.substring(2)).infectBy(args[0]); - default: - switch (name.charAt(2)) { - case '/': - case '\\': - break; - default: - // strip c: away from relative-pathed name - name = name.substring(2); - break; - } - break; - } - } - } - - while (name.length() > 1 && name.charAt(name.length() - 1) == '/') { - name = name.substring(0, name.length() - 1); - } - - // Paths which end in "/" or "\\" must be stripped off. - int slashCount = 0; - int length = name.length(); - for (int i = length - 1; i >= 0; i--) { - char c = name.charAt(i); - if (c != '/' && c != '\\') { - break; - } - slashCount++; - } - if (slashCount > 0 && length > 1) { - name = name.substring(0, name.length() - slashCount); - } - - int index = name.lastIndexOf('/'); - if (index == -1) { - // XXX actually only on windows... - index = name.lastIndexOf('\\'); - } - - if (!name.equals("/") && index != -1) { - name = name.substring(index + 1); - } - - if (args.length == 2) { - String ext = RubyString.stringValue(args[1]).toString(); - if (".*".equals(ext)) { - index = name.lastIndexOf('.'); - if (index > 0) { // -1 no match; 0 it is dot file not extension - name = name.substring(0, index); - } - } else if (name.endsWith(ext)) { - name = name.substring(0, name.length() - ext.length()); - } - } - return context.getRuntime().newString(name).infectBy(args[0]); - } - - @JRubyMethod(required = 2, rest = true, meta = true) - public static IRubyObject chmod(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - int count = 0; - RubyInteger mode = args[0].convertToInteger(); - for (int i = 1; i < args.length; i++) { - IRubyObject filename = args[i]; - - if (!RubyFileTest.exist_p(filename, filename.convertToString()).isTrue()) { - throw runtime.newErrnoENOENTError("No such file or directory - " + filename); - } - - boolean result = 0 == runtime.getPosix().chmod(filename.toString(), (int)mode.getLongValue()); - if (result) { - count++; - } - } - - return runtime.newFixnum(count); - } - - @JRubyMethod(required = 3, rest = true, meta = true) - public static IRubyObject chown(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - int count = 0; - int owner = -1; - if (!args[0].isNil()) { - owner = RubyNumeric.num2int(args[0]); - } - - int group = -1; - if (!args[1].isNil()) { - group = RubyNumeric.num2int(args[1]); - } - for (int i = 2; i < args.length; i++) { - IRubyObject filename = args[i]; - - if (!RubyFileTest.exist_p(filename, filename.convertToString()).isTrue()) { - throw runtime.newErrnoENOENTError("No such file or directory - " + filename); - } - - boolean result = 0 == runtime.getPosix().chown(filename.toString(), owner, group); - if (result) { - count++; - } - } - - return runtime.newFixnum(count); - } - - @JRubyMethod(required = 1, meta = true) - public static IRubyObject dirname(ThreadContext context, IRubyObject recv, IRubyObject arg) { - RubyString filename = RubyString.stringValue(arg); - String jfilename = filename.toString(); - String name = jfilename.replace('\\', '/'); - int minPathLength = 1; - boolean trimmedSlashes = false; - - boolean startsWithDriveLetterOnWindows = startsWithDriveLetterOnWindows(name); - - if (startsWithDriveLetterOnWindows) { - minPathLength = 3; - } - - while (name.length() > minPathLength && name.charAt(name.length() - 1) == '/') { - trimmedSlashes = true; - name = name.substring(0, name.length() - 1); - } - - String result; - if (startsWithDriveLetterOnWindows && name.length() == 2) { - if (trimmedSlashes) { - // C:\ is returned unchanged - result = jfilename.substring(0, 3); - } else { - result = jfilename.substring(0, 2) + '.'; - } - } else { - //TODO deal with UNC names - int index = name.lastIndexOf('/'); - if (index == -1) { - if (startsWithDriveLetterOnWindows) { - return context.getRuntime().newString(jfilename.substring(0, 2) + "."); - } else { - return context.getRuntime().newString("."); - } - } - if (index == 0) return context.getRuntime().newString("/"); - - if (startsWithDriveLetterOnWindows && index == 2) { - // Include additional path separator - // (so that dirname of "C:\file.txt" is "C:\", not "C:") - index++; - } - - result = jfilename.substring(0, index); - } - - char endChar; - // trim trailing slashes - while (result.length() > minPathLength) { - endChar = result.charAt(result.length() - 1); - if (endChar == '/' || endChar == '\\') { - result = result.substring(0, result.length() - 1); - } else { - break; - } - } - - return context.getRuntime().newString(result).infectBy(filename); - } - - private static boolean isWindowsDriveLetter(char c) { - return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); - } - - - /** - * Returns the extension name of the file. An empty string is returned if - * the filename (not the entire path) starts or ends with a dot. - * @param recv - * @param arg Path to get extension name of - * @return Extension, including the dot, or an empty string - */ - @JRubyMethod(required = 1, meta = true) - public static IRubyObject extname(ThreadContext context, IRubyObject recv, IRubyObject arg) { - IRubyObject baseFilename = basename(context, recv, new IRubyObject[]{arg}); - String filename = RubyString.stringValue(baseFilename).toString(); - String result = ""; - - int dotIndex = filename.lastIndexOf("."); - if (dotIndex > 0 && dotIndex != (filename.length() - 1)) { - // Dot is not at beginning and not at end of filename. - result = filename.substring(dotIndex); - } - - return context.getRuntime().newString(result); - } - - /** - * Converts a pathname to an absolute pathname. Relative paths are - * referenced from the current working directory of the process unless - * a second argument is given, in which case it will be used as the - * starting point. If the second argument is also relative, it will - * first be converted to an absolute pathname. - * @param recv - * @param args - * @return Resulting absolute path as a String - */ - @JRubyMethod(required = 1, optional = 1, meta = true) - public static IRubyObject expand_path(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - String relativePath = RubyString.stringValue(args[0]).toString(); - - boolean isAbsoluteWithFilePrefix = relativePath.startsWith("file:"); - - String cwd = null; - - // Handle ~user paths - relativePath = expandUserPath(context, relativePath); - - // If there's a second argument, it's the path to which the first - // argument is relative. - if (args.length == 2 && !args[1].isNil()) { - - String cwdArg = RubyString.stringValue(args[1]).toString(); - - // Handle ~user paths. - cwd = expandUserPath(context, cwdArg); - - cwd = adjustRootPathOnWindows(runtime, cwd, null); - - boolean startsWithSlashNotOnWindows = (cwd != null) - && !Platform.IS_WINDOWS && cwd.length() > 0 - && cwd.charAt(0) == '/'; - - // TODO: better detection when path is absolute or not. - // If the path isn't absolute, then prepend the current working - // directory to the path. - if (!startsWithSlashNotOnWindows && !startsWithDriveLetterOnWindows(cwd)) { - cwd = new File(runtime.getCurrentDirectory(), cwd).getAbsolutePath(); - } - } else { - // If there's no second argument, simply use the working directory - // of the runtime. - cwd = runtime.getCurrentDirectory(); - } - - // Something wrong we don't know the cwd... - // TODO: Is this behavior really desirable? /mov - if (cwd == null) return runtime.getNil(); - - /* The counting of slashes that follows is simply a way to adhere to - * Ruby's UNC (or something) compatibility. When Ruby's expand_path is - * called with "//foo//bar" it will return "//foo/bar". JRuby uses - * java.io.File, and hence returns "/foo/bar". In order to retain - * java.io.File in the lower layers and provide full Ruby - * compatibility, the number of extra slashes must be counted and - * prepended to the result. - */ - - // TODO: special handling on windows for some corner cases -// if (IS_WINDOWS) { -// if (relativePath.startsWith("//")) { -// if (relativePath.length() > 2 && relativePath.charAt(2) != '/') { -// int nextSlash = relativePath.indexOf('/', 3); -// if (nextSlash != -1) { -// return runtime.newString( -// relativePath.substring(0, nextSlash) -// + canonicalize(relativePath.substring(nextSlash))); -// } else { -// return runtime.newString(relativePath); -// } -// } -// } -// } - - // Find out which string to check. - String padSlashes = ""; - if (!Platform.IS_WINDOWS) { - if (relativePath.length() > 0 && relativePath.charAt(0) == '/') { - padSlashes = countSlashes(relativePath); - } else if (cwd.length() > 0 && cwd.charAt(0) == '/') { - padSlashes = countSlashes(cwd); - } - } - - JRubyFile path; - - if (relativePath.length() == 0) { - path = JRubyFile.create(relativePath, cwd); - } else { - relativePath = adjustRootPathOnWindows(runtime, relativePath, cwd); - path = JRubyFile.create(cwd, relativePath); - } - - String tempResult = padSlashes + canonicalize(path.getAbsolutePath()); - - if(isAbsoluteWithFilePrefix) { - tempResult = tempResult.substring(tempResult.indexOf("file:")); - } - - return runtime.newString(tempResult); - } - - /** - * This method checks a path, and if it starts with ~, then it expands - * the path to the absolute path of the user's home directory. If the - * string does not begin with ~, then the string is simply returned. - * unaltered. - * @param recv - * @param path Path to check - * @return Expanded path - */ - public static String expandUserPath(ThreadContext context, String path) { - - int pathLength = path.length(); - - if (pathLength >= 1 && path.charAt(0) == '~') { - // Enebo : Should ~frogger\\foo work (it doesnt in linux ruby)? - int userEnd = path.indexOf('/'); - - if (userEnd == -1) { - if (pathLength == 1) { - // Single '~' as whole path to expand - path = RubyDir.getHomeDirectoryPath(context).toString(); - } else { - // No directory delimeter. Rest of string is username - userEnd = pathLength; - } - } - - if (userEnd == 1) { - // '~/...' as path to expand - path = RubyDir.getHomeDirectoryPath(context).toString() + - path.substring(1); - } else if (userEnd > 1){ - // '~user/...' as path to expand - String user = path.substring(1, userEnd); - IRubyObject dir = RubyDir.getHomeDirectoryPath(context, user); - - if (dir.isNil()) { - throw context.getRuntime().newArgumentError("user " + user + " does not exist"); - } - - path = "" + dir + (pathLength == userEnd ? "" : path.substring(userEnd)); - } - } - return path; - } - - /** - * Returns a string consisting of <code>n-1</code> slashes, where - * <code>n</code> is the number of slashes at the beginning of the input - * string. - * @param stringToCheck - * @return - */ - private static String countSlashes( String stringToCheck ) { - - // Count number of extra slashes in the beginning of the string. - int slashCount = 0; - for (int i = 0; i < stringToCheck.length(); i++) { - if (stringToCheck.charAt(i) == '/') { - slashCount++; - } else { - break; - } - } - - // If there are N slashes, then we want N-1. - if (slashCount > 0) { - slashCount--; - } - - // Prepare a string with the same number of redundant slashes so that - // we easily can prepend it to the result. - byte[] slashes = new byte[slashCount]; - for (int i = 0; i < slashCount; i++) { - slashes[i] = '/'; - } - return new String(slashes); - - } - - private static String canonicalize(String path) { - return canonicalize(null, path); - } - - private static String canonicalize(String canonicalPath, String remaining) { - if (remaining == null) { - if ("".equals(canonicalPath)) { - return "/"; - } else { - // compensate for missing slash after drive letter on windows - if (startsWithDriveLetterOnWindows(canonicalPath) - && canonicalPath.length() == 2) { - canonicalPath += "/"; - } - } - return canonicalPath; - } - - String child; - int slash = remaining.indexOf('/'); - if (slash == -1) { - child = remaining; - remaining = null; - } else { - child = remaining.substring(0, slash); - remaining = remaining.substring(slash + 1); - } - - if (child.equals(".")) { - // skip it - if (canonicalPath != null && canonicalPath.length() == 0 ) canonicalPath += "/"; - } else if (child.equals("..")) { - if (canonicalPath == null) throw new IllegalArgumentException("Cannot have .. at the start of an absolute path"); - int lastDir = canonicalPath.lastIndexOf('/'); - if (lastDir == -1) { - if (startsWithDriveLetterOnWindows(canonicalPath)) { - // do nothing, we should not delete the drive letter - } else { - canonicalPath = ""; - } - } else { - canonicalPath = canonicalPath.substring(0, lastDir); - } - } else if (canonicalPath == null) { - canonicalPath = child; - } else { - canonicalPath += "/" + child; - } - - return canonicalize(canonicalPath, remaining); - } - - /** - * Returns true if path matches against pattern The pattern is not a regular expression; - * instead it follows rules similar to shell filename globbing. It may contain the following - * metacharacters: - * *: Glob - match any sequence chars (re: .*). If like begins with '.' then it doesn't. - * ?: Matches a single char (re: .). - * [set]: Matches a single char in a set (re: [...]). - * - */ - @JRubyMethod(name = {"fnmatch", "fnmatch?"}, required = 2, optional = 1, meta = true) - public static IRubyObject fnmatch(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - int flags = args.length == 3 ? RubyNumeric.num2int(args[2]) : 0; - - ByteList pattern = args[0].convertToString().getByteList(); - ByteList path = args[1].convertToString().getByteList(); - - if (org.jruby.util.Dir.fnmatch(pattern.bytes, pattern.begin, pattern.begin+pattern.realSize, - path.bytes, path.begin, path.begin+path.realSize, flags) == 0) { - return context.getRuntime().getTrue(); - } - return context.getRuntime().getFalse(); - } - - @JRubyMethod(name = "ftype", required = 1, meta = true) - public static IRubyObject ftype(ThreadContext context, IRubyObject recv, IRubyObject filename) { - return context.getRuntime().newFileStat(filename.convertToString().toString(), true).ftype(); - } - - private static String inspectJoin(ThreadContext context, IRubyObject recv, RubyArray parent, RubyArray array) { - Ruby runtime = context.getRuntime(); - - // If already inspecting, there is no need to register/unregister again. - if (runtime.isInspecting(parent)) return join(context, recv, array).toString(); - - try { - runtime.registerInspecting(parent); - return join(context, recv, array).toString(); - } finally { - runtime.unregisterInspecting(parent); - } - } - - private static RubyString join(ThreadContext context, IRubyObject recv, RubyArray ary) { - IRubyObject[] args = ary.toJavaArray(); - boolean isTainted = false; - StringBuilder buffer = new StringBuilder(); - Ruby runtime = context.getRuntime(); - - for (int i = 0; i < args.length; i++) { - if (args[i].isTaint()) { - isTainted = true; - } - String element; - if (args[i] instanceof RubyString) { - element = args[i].toString(); - } else if (args[i] instanceof RubyArray) { - if (runtime.isInspecting(args[i])) { - element = "[...]"; - } else { - element = inspectJoin(context, recv, ary, ((RubyArray)args[i])); - } - } else { - element = args[i].convertToString().toString(); - } - - chomp(buffer); - if (i > 0 && !element.startsWith("/") && !element.startsWith("\\")) { - buffer.append("/"); - } - buffer.append(element); - } - - RubyString fixedStr = RubyString.newString(runtime, buffer.toString()); - fixedStr.setTaint(isTainted); - return fixedStr; - } - - /* - * Fixme: This does not have exact same semantics as RubyArray.join, but they - * probably could be consolidated (perhaps as join(args[], sep, doChomp)). - */ - @JRubyMethod(rest = true, meta = true) - public static RubyString join(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - return join(context, recv, RubyArray.newArrayNoCopyLight(context.getRuntime(), args)); - } - - private static void chomp(StringBuilder buffer) { - int lastIndex = buffer.length() - 1; - - while (lastIndex >= 0 && (buffer.lastIndexOf("/") == lastIndex || buffer.lastIndexOf("\\") == lastIndex)) { - buffer.setLength(lastIndex); - lastIndex--; - } - } - - @JRubyMethod(name = "lstat", required = 1, meta = true) - public static IRubyObject lstat(ThreadContext context, IRubyObject recv, IRubyObject filename) { - String f = filename.convertToString().toString(); - if(f.startsWith("file:") && f.indexOf('!') != -1) { - f = f.substring(5, f.indexOf("!")); - } - return context.getRuntime().newFileStat(f, true); - } - - @JRubyMethod(name = "stat", required = 1, meta = true) - public static IRubyObject stat(ThreadContext context, IRubyObject recv, IRubyObject filename) { - String f = filename.convertToString().toString(); - if(f.startsWith("file:") && f.indexOf('!') != -1) { - f = f.substring(5, f.indexOf("!")); - } - return context.getRuntime().newFileStat(f, false); - } - - @JRubyMethod(name = "atime", required = 1, meta = true) - public static IRubyObject atime(ThreadContext context, IRubyObject recv, IRubyObject filename) { - String f = filename.convertToString().toString(); - if(f.startsWith("file:") && f.indexOf('!') != -1) { - f = f.substring(5, f.indexOf("!")); - } - return context.getRuntime().newFileStat(f, false).atime(); - } - - @JRubyMethod(name = "ctime", required = 1, meta = true) - public static IRubyObject ctime(ThreadContext context, IRubyObject recv, IRubyObject filename) { - String f = filename.convertToString().toString(); - if(f.startsWith("file:") && f.indexOf('!') != -1) { - f = f.substring(5, f.indexOf("!")); - } - return context.getRuntime().newFileStat(f, false).ctime(); - } - - @JRubyMethod(required = 2, rest = true, meta = true) - public static IRubyObject lchmod(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - int count = 0; - RubyInteger mode = args[0].convertToInteger(); - for (int i = 1; i < args.length; i++) { - IRubyObject filename = args[i]; - - if (!RubyFileTest.exist_p(filename, filename.convertToString()).isTrue()) { - throw runtime.newErrnoENOENTError("No such file or directory - " + filename); - } - - boolean result = 0 == runtime.getPosix().lchmod(filename.toString(), (int)mode.getLongValue()); - if (result) { - count++; - } - } - - return runtime.newFixnum(count); - } - - @JRubyMethod(required = 3, rest = true, meta = true) - public static IRubyObject lchown(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - int owner = !args[0].isNil() ? RubyNumeric.num2int(args[0]) : -1; - int group = !args[1].isNil() ? RubyNumeric.num2int(args[1]) : -1; - int count = 0; - - for (int i = 2; i < args.length; i++) { - IRubyObject filename = args[i]; - - if (!RubyFileTest.exist_p(filename, filename.convertToString()).isTrue()) { - throw runtime.newErrnoENOENTError("No such file or directory - " + filename); - } - - boolean result = 0 == runtime.getPosix().lchown(filename.toString(), owner, group); - if (result) { - count++; - } - } - - return runtime.newFixnum(count); - } - - @JRubyMethod(required = 2, meta = true) - public static IRubyObject link(ThreadContext context, IRubyObject recv, IRubyObject from, IRubyObject to) { - Ruby runtime = context.getRuntime(); - RubyString fromStr = RubyString.stringValue(from); - RubyString toStr = RubyString.stringValue(to); - try { - if (runtime.getPosix().link( - fromStr.toString(),toStr.toString()) == -1) { - // FIXME: When we get JNA3 we need to properly write this to errno. - throw runtime.newErrnoEEXISTError("File exists - " - + fromStr + " or " + toStr); - } - } catch (java.lang.UnsatisfiedLinkError ule) { - throw runtime.newNotImplementedError("link() function is unimplemented on this machine"); - } - - return runtime.newFixnum(0); - } - - @JRubyMethod(name = "mtime", required = 1, meta = true) - public static IRubyObject mtime(ThreadContext context, IRubyObject recv, IRubyObject filename) { - return getLastModified(context.getRuntime(), filename.convertToString().toString()); - } - - @JRubyMethod(required = 2, meta = true) - public static IRubyObject rename(ThreadContext context, IRubyObject recv, IRubyObject oldName, IRubyObject newName) { - Ruby runtime = context.getRuntime(); - RubyString oldNameString = RubyString.stringValue(oldName); - RubyString newNameString = RubyString.stringValue(newName); - runtime.checkSafeString(oldNameString); - runtime.checkSafeString(newNameString); - JRubyFile oldFile = JRubyFile.create(runtime.getCurrentDirectory(), oldNameString.toString()); - JRubyFile newFile = JRubyFile.create(runtime.getCurrentDirectory(), newNameString.toString()); - - if (!oldFile.exists() || !newFile.getParentFile().exists()) { - throw runtime.newErrnoENOENTError("No such file or directory - " + oldNameString + - " or " + newNameString); - } - - JRubyFile dest = JRubyFile.create(runtime.getCurrentDirectory(), newNameString.toString()); - - if (oldFile.renameTo(dest)) { // rename is successful - return RubyFixnum.zero(runtime); - } - - // rename via Java API call wasn't successful, let's try some tricks, similar to MRI - - if (newFile.exists()) { - runtime.getPosix().chmod(newNameString.toString(), 0666); - newFile.delete(); - } - - if (oldFile.renameTo(dest)) { // try to rename one more time - return RubyFixnum.zero(runtime); - } - - throw runtime.newErrnoEACCESError("Permission denied - " + oldNameString + " or " + - newNameString); - } - - @JRubyMethod(required = 1, meta = true) - public static RubyArray split(ThreadContext context, IRubyObject recv, IRubyObject arg) { - RubyString filename = RubyString.stringValue(arg); - - return context.getRuntime().newArray(dirname(context, recv, filename), - basename(context, recv, new IRubyObject[] { filename })); - } - - @JRubyMethod(required = 2, meta = true) - public static IRubyObject symlink(ThreadContext context, IRubyObject recv, IRubyObject from, IRubyObject to) { - Ruby runtime = context.getRuntime(); - RubyString fromStr = RubyString.stringValue(from); - RubyString toStr = RubyString.stringValue(to); - try { - if (runtime.getPosix().symlink( - fromStr.toString(), toStr.toString()) == -1) { - // FIXME: When we get JNA3 we need to properly write this to errno. - throw runtime.newErrnoEEXISTError("File exists - " - + fromStr + " or " + toStr); - } - } catch (java.lang.UnsatisfiedLinkError ule) { - throw runtime.newNotImplementedError("symlink() function is unimplemented on this machine"); - } - - return runtime.newFixnum(0); - } - - @JRubyMethod(required = 1, meta = true) - public static IRubyObject readlink(ThreadContext context, IRubyObject recv, IRubyObject path) { - Ruby runtime = context.getRuntime(); - - try { - String realPath = runtime.getPosix().readlink(path.toString()); - - if (!RubyFileTest.exist_p(recv, path).isTrue()) { - throw runtime.newErrnoENOENTError("No such file or directory - " + path); - } - - if (!RubyFileTest.symlink_p(recv, path).isTrue()) { - throw runtime.newErrnoEINVALError("invalid argument - " + path); - } - - if (realPath == null) { - //FIXME: When we get JNA3 we need to properly write this to errno. - } - - return runtime.newString(realPath); - } catch (IOException e) { - throw runtime.newIOError(e.getMessage()); - } - } - - // Can we produce IOError which bypasses a close? - @JRubyMethod(required = 2, meta = true) - public static IRubyObject truncate(ThreadContext context, IRubyObject recv, IRubyObject arg1, IRubyObject arg2) { - Ruby runtime = context.getRuntime(); - RubyString filename = arg1.convertToString(); // TODO: SafeStringValue here - RubyInteger newLength = arg2.convertToInteger(); - - if (!new File(runtime.getCurrentDirectory(), filename.getByteList().toString()).exists()) { - throw runtime.newErrnoENOENTError( - "No such file or directory - " + filename.getByteList().toString()); - } - - if (newLength.getLongValue() < 0) { - throw runtime.newErrnoEINVALError("invalid argument: " + filename); - } - - IRubyObject[] args = new IRubyObject[] { filename, runtime.newString("r+") }; - RubyFile file = (RubyFile) open(context, recv, args, Block.NULL_BLOCK); - file.truncate(context, newLength); - file.close(); - - return RubyFixnum.zero(runtime); - } - - @JRubyMethod(meta = true, optional = 1) - public static IRubyObject umask(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - int oldMask = 0; - if (args.length == 0) { - oldMask = runtime.getPosix().umask(0); - runtime.getPosix().umask(oldMask); - } else if (args.length == 1) { - oldMask = runtime.getPosix().umask((int) args[0].convertToInteger().getLongValue()); - } else { - runtime.newArgumentError("wrong number of arguments"); - } - - return runtime.newFixnum(oldMask); - } - - /** - * This method does NOT set atime, only mtime, since Java doesn't support anything else. - */ - @JRubyMethod(required = 2, rest = true, meta = true) - public static IRubyObject utime(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - // Ignore access_time argument since Java does not support it. - - long mtime; - if (args[1] instanceof RubyTime) { - mtime = ((RubyTime) args[1]).getJavaDate().getTime(); - } else if (args[1] instanceof RubyNumeric) { - mtime = RubyNumeric.num2long(args[1]); - } else if (args[1] == runtime.getNil()) { - mtime = System.currentTimeMillis(); - } else { - RubyTime time = (RubyTime) TypeConverter.convertToType(args[1], runtime.getTime(), MethodIndex.NO_INDEX,"to_time", true); - mtime = time.getJavaDate().getTime(); - } - - for (int i = 2, j = args.length; i < j; i++) { - RubyString filename = RubyString.stringValue(args[i]); - runtime.checkSafeString(filename); - JRubyFile fileToTouch = JRubyFile.create(runtime.getCurrentDirectory(),filename.toString()); - - if (!fileToTouch.exists()) { - throw runtime.newErrnoENOENTError(" No such file or directory - \"" + filename + "\""); - } - - fileToTouch.setLastModified(mtime); - } - - return runtime.newFixnum(args.length - 2); - } - - @JRubyMethod(name = {"unlink", "delete"}, rest = true, meta = true) - public static IRubyObject unlink(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - for (int i = 0; i < args.length; i++) { - RubyString filename = RubyString.stringValue(args[i]); - runtime.checkSafeString(filename); - JRubyFile lToDelete = JRubyFile.create(runtime.getCurrentDirectory(),filename.toString()); - - boolean isSymlink = RubyFileTest.symlink_p(recv, filename).isTrue(); - // Broken symlinks considered by exists() as non-existing, - // so we need to check for symlinks explicitly. - if (!lToDelete.exists() && !isSymlink) { - throw runtime.newErrnoENOENTError(" No such file or directory - \"" + filename + "\""); - } - - if (!lToDelete.delete()) { - throw runtime.newErrnoEACCESError("Permission denied - \"" + filename + "\""); - } - } - - return runtime.newFixnum(args.length); - } - - // Fast path since JNA stat is about 10x slower than this - private static IRubyObject getLastModified(Ruby runtime, String path) { - JRubyFile file = JRubyFile.create(runtime.getCurrentDirectory(), path); - - if (!file.exists()) { - throw runtime.newErrnoENOENTError("No such file or directory - " + path); - } - - return runtime.newTime(file.lastModified()); - } -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Joey Gibson <joey@joeygibson.com> - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.FileDescriptor; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.ext.posix.FileStat; -import org.jruby.ext.posix.util.Platform; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.JRubyFile; - -/** - * Implements File::Stat - */ -@JRubyClass(name="File::Stat", include="Comparable") -public class RubyFileStat extends RubyObject { - private static final long serialVersionUID = 1L; - - private JRubyFile file; - private FileStat stat; - - private static ObjectAllocator ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyFileStat(runtime, klass); - } - }; - - public static RubyClass createFileStatClass(Ruby runtime) { - // TODO: NOT_ALLOCATABLE_ALLOCATOR is probably ok here. Confirm. JRUBY-415 - final RubyClass fileStatClass = runtime.getFile().defineClassUnder("Stat",runtime.getObject(), ALLOCATOR); - runtime.setFileStat(fileStatClass); - - fileStatClass.includeModule(runtime.fastGetModule("Comparable")); - fileStatClass.defineAnnotatedMethods(RubyFileStat.class); - - return fileStatClass; - } - - protected RubyFileStat(Ruby runtime, RubyClass clazz) { - super(runtime, clazz); - - } - - public static RubyFileStat newFileStat(Ruby runtime, String filename, boolean lstat) { - RubyFileStat stat = new RubyFileStat(runtime, runtime.getFileStat()); - - stat.setup(filename, lstat); - - return stat; - } - - public static RubyFileStat newFileStat(Ruby runtime, FileDescriptor descriptor) { - RubyFileStat stat = new RubyFileStat(runtime, runtime.getFileStat()); - - stat.setup(descriptor); - - return stat; - } - - private void setup(FileDescriptor descriptor) { - stat = getRuntime().getPosix().fstat(descriptor); - } - - private void setup(String filename, boolean lstat) { - if (Platform.IS_WINDOWS && filename.length() == 2 - && filename.charAt(1) == ':' && Character.isLetter(filename.charAt(0))) { - filename += "/"; - } - - file = JRubyFile.create(getRuntime().getCurrentDirectory(), filename); - - if (lstat) { - stat = getRuntime().getPosix().lstat(file.getAbsolutePath()); - } else { - stat = getRuntime().getPosix().stat(file.getAbsolutePath()); - } - } - - @JRubyMethod(name = "initialize", required = 1, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject fname, Block unusedBlock) { - setup(fname.convertToString().toString(), false); - - return this; - } - - @JRubyMethod(name = "atime") - public IRubyObject atime() { - return getRuntime().newTime(stat.atime() * 1000); - } - - @JRubyMethod(name = "blksize") - public RubyFixnum blksize() { - return getRuntime().newFixnum(stat.blockSize()); - } - - @JRubyMethod(name = "blockdev?") - public IRubyObject blockdev_p() { - return getRuntime().newBoolean(stat.isBlockDev()); - } - - @JRubyMethod(name = "blocks") - public IRubyObject blocks() { - return getRuntime().newFixnum(stat.blocks()); - } - - @JRubyMethod(name = "chardev?") - public IRubyObject chardev_p() { - return getRuntime().newBoolean(stat.isCharDev()); - } - - @JRubyMethod(name = "<=>", required = 1) - public IRubyObject cmp(IRubyObject other) { - if (!(other instanceof RubyFileStat)) getRuntime().getNil(); - - long time1 = stat.mtime(); - long time2 = ((RubyFileStat) other).stat.mtime(); - - if (time1 == time2) { - return getRuntime().newFixnum(0); - } else if (time1 < time2) { - return getRuntime().newFixnum(-1); - } - - return getRuntime().newFixnum(1); - } - - @JRubyMethod(name = "ctime") - public IRubyObject ctime() { - return getRuntime().newTime(stat.ctime() * 1000); - } - - @JRubyMethod(name = "dev") - public IRubyObject dev() { - return getRuntime().newFixnum(stat.dev()); - } - - @JRubyMethod(name = "dev_major") - public IRubyObject devMajor() { - return getRuntime().newFixnum(stat.major(stat.dev())); - } - - @JRubyMethod(name = "dev_minor") - public IRubyObject devMinor() { - return getRuntime().newFixnum(stat.minor(stat.dev())); - } - - @JRubyMethod(name = "directory?") - public RubyBoolean directory_p() { - return getRuntime().newBoolean(stat.isDirectory()); - } - - @JRubyMethod(name = "executable?") - public IRubyObject executable_p() { - return getRuntime().newBoolean(stat.isExecutable()); - } - - @JRubyMethod(name = "executable_real?") - public IRubyObject executableReal_p() { - return getRuntime().newBoolean(stat.isExecutableReal()); - } - - @JRubyMethod(name = "file?") - public RubyBoolean file_p() { - return getRuntime().newBoolean(stat.isFile()); - } - - @JRubyMethod(name = "ftype") - public RubyString ftype() { - return getRuntime().newString(stat.ftype()); - } - - @JRubyMethod(name = "gid") - public IRubyObject gid() { - return getRuntime().newFixnum(stat.gid()); - } - - @JRubyMethod(name = "grpowned?") - public IRubyObject group_owned_p() { - return getRuntime().newBoolean(stat.isGroupOwned()); - } - - @JRubyMethod(name = "initialize_copy", required = 1) - public IRubyObject initialize_copy(IRubyObject original) { - if (!(original instanceof RubyFileStat)) { - throw getRuntime().newTypeError("wrong argument class"); - } - - RubyFileStat originalFileStat = (RubyFileStat) original; - - file = originalFileStat.file; - stat = originalFileStat.stat; - - return this; - } - - @JRubyMethod(name = "ino") - public IRubyObject ino() { - return getRuntime().newFixnum(stat.ino()); - } - - @JRubyMethod(name = "inspect") - public IRubyObject inspect() { - StringBuilder buf = new StringBuilder("#<"); - buf.append(getMetaClass().getRealClass().getName()); - buf.append(" "); - // FIXME: Obvious issue that not all platforms can display all attributes. Ugly hacks. - // Using generic posix library makes pushing inspect behavior into specific system impls - // rather painful. - try { buf.append("dev=0x").append(Long.toHexString(stat.dev())).append(", "); } catch (Exception e) {} - try { buf.append("ino=").append(stat.ino()).append(", "); } catch (Exception e) {} - buf.append("mode=0").append(Integer.toOctalString(stat.mode())).append(", "); - try { buf.append("nlink=").append(stat.nlink()).append(", "); } catch (Exception e) {} - try { buf.append("uid=").append(stat.uid()).append(", "); } catch (Exception e) {} - try { buf.append("gid=").append(stat.gid()).append(", "); } catch (Exception e) {} - try { buf.append("rdev=0x").append(Long.toHexString(stat.rdev())).append(", "); } catch (Exception e) {} - buf.append("size=").append(stat.st_size()).append(", "); - try { buf.append("blksize=").append(stat.blockSize()).append(", "); } catch (Exception e) {} - try { buf.append("blocks=").append(stat.blocks()).append(", "); } catch (Exception e) {} - - buf.append("atime=").append(atime()).append(", "); - buf.append("mtime=").append(mtime()).append(", "); - buf.append("ctime=").append(ctime()); - buf.append(">"); - - return getRuntime().newString(buf.toString()); - } - - @JRubyMethod(name = "uid") - public IRubyObject uid() { - return getRuntime().newFixnum(stat.uid()); - } - - @JRubyMethod(name = "mode") - public IRubyObject mode() { - return getRuntime().newFixnum(stat.mode()); - } - - @JRubyMethod(name = "mtime") - public IRubyObject mtime() { - return getRuntime().newTime(stat.mtime() * 1000); - } - - public IRubyObject mtimeEquals(IRubyObject other) { - return getRuntime().newBoolean(stat.mtime() == newFileStat(getRuntime(), other.convertToString().toString(), false).stat.mtime()); - } - - public IRubyObject mtimeGreaterThan(IRubyObject other) { - return getRuntime().newBoolean(stat.mtime() > newFileStat(getRuntime(), other.convertToString().toString(), false).stat.mtime()); - } - - public IRubyObject mtimeLessThan(IRubyObject other) { - return getRuntime().newBoolean(stat.mtime() < newFileStat(getRuntime(), other.convertToString().toString(), false).stat.mtime()); - } - - @JRubyMethod(name = "nlink") - public IRubyObject nlink() { - return getRuntime().newFixnum(stat.nlink()); - } - - @JRubyMethod(name = "owned?") - public IRubyObject owned_p() { - return getRuntime().newBoolean(stat.isOwned()); - } - - @JRubyMethod(name = "pipe?") - public IRubyObject pipe_p() { - return getRuntime().newBoolean(stat.isNamedPipe()); - } - - @JRubyMethod(name = "rdev") - public IRubyObject rdev() { - return getRuntime().newFixnum(stat.rdev()); - } - - @JRubyMethod(name = "rdev_major") - public IRubyObject rdevMajor() { - return getRuntime().newFixnum(stat.major(stat.rdev())); - } - - @JRubyMethod(name = "rdev_minor") - public IRubyObject rdevMinor() { - return getRuntime().newFixnum(stat.minor(stat.rdev())); - } - - @JRubyMethod(name = "readable?") - public IRubyObject readable_p() { - return getRuntime().newBoolean(stat.isReadable()); - } - - @JRubyMethod(name = "readable_real?") - public IRubyObject readableReal_p() { - return getRuntime().newBoolean(stat.isReadableReal()); - } - - @JRubyMethod(name = "setgid?") - public IRubyObject setgid_p() { - return getRuntime().newBoolean(stat.isSetgid()); - } - - @JRubyMethod(name = "setuid?") - public IRubyObject setuid_p() { - return getRuntime().newBoolean(stat.isSetuid()); - } - - @JRubyMethod(name = "size") - public IRubyObject size() { - return getRuntime().newFixnum(stat.st_size()); - } - - @JRubyMethod(name = "size?") - public IRubyObject size_p() { - long size = stat.st_size(); - - if (size == 0) return getRuntime().getNil(); - - return getRuntime().newFixnum(size); - } - - @JRubyMethod(name = "socket?") - public IRubyObject socket_p() { - return getRuntime().newBoolean(stat.isSocket()); - } - - @JRubyMethod(name = "sticky?") - public IRubyObject sticky_p() { - return getRuntime().newBoolean(stat.isSticky()); - } - - @JRubyMethod(name = "symlink?") - public IRubyObject symlink_p() { - return getRuntime().newBoolean(stat.isSymlink()); - } - - @JRubyMethod(name = "writable?") - public IRubyObject writable_p() { - return getRuntime().newBoolean(stat.isWritable()); - } - - @JRubyMethod(name = "writable_real?") - public IRubyObject writableReal_p() { - return getRuntime().newBoolean(stat.isWritableReal()); - } - - @JRubyMethod(name = "zero?") - public IRubyObject zero_p() { - return getRuntime().newBoolean(stat.isEmpty()); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.exceptions.RaiseException; - -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.JRubyFile; - -@JRubyModule(name="FileTest") -public class RubyFileTest { - public static RubyModule createFileTestModule(Ruby runtime) { - RubyModule fileTestModule = runtime.defineModule("FileTest"); - runtime.setFileTest(fileTestModule); - - fileTestModule.defineAnnotatedMethods(RubyFileTest.class); - - return fileTestModule; - } - - @JRubyMethod(name = "blockdev?", required = 1, module = true) - public static IRubyObject blockdev_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isBlockDev()); - } - - @JRubyMethod(name = "chardev?", required = 1, module = true) - public static IRubyObject chardev_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isCharDev()); - } - - @JRubyMethod(name = "directory?", required = 1, module = true) - public static IRubyObject directory_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isDirectory()); - } - - @JRubyMethod(name = "executable?", required = 1, module = true) - public static IRubyObject executable_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isExecutable()); - } - - @JRubyMethod(name = "executable_real?", required = 1, module = true) - public static IRubyObject executable_real_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isExecutableReal()); - } - - @JRubyMethod(name = {"exist?", "exists?"}, required = 1, module = true) - public static IRubyObject exist_p(IRubyObject recv, IRubyObject filename) { - if (Ruby.isSecurityRestricted()) { - return recv.getRuntime().getFalse(); - } - - if(filename.convertToString().toString().startsWith("file:")) { - String file = filename.convertToString().toString().substring(5); - int bang = file.indexOf('!'); - if (bang == -1 || bang == file.length() - 1) { - return recv.getRuntime().getFalse(); - } - String jar = file.substring(0, bang); - String after = file.substring(bang + 2); - try { - java.util.jar.JarFile jf = new java.util.jar.JarFile(jar); - if(jf.getJarEntry(after) != null) { - return recv.getRuntime().getTrue(); - } else { - return recv.getRuntime().getFalse(); - } - } catch(Exception e) { - return recv.getRuntime().getFalse(); - } - } - - return recv.getRuntime().newBoolean(file(filename).exists()); - } - - @JRubyMethod(name = "file?", required = 1, module = true) - public static RubyBoolean file_p(IRubyObject recv, IRubyObject filename) { - JRubyFile file = file(filename); - - return filename.getRuntime().newBoolean(file.exists() && file.isFile()); - } - - @JRubyMethod(name = "grpowned?", required = 1, module = true) - public static IRubyObject grpowned_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isGroupOwned()); - } - - @JRubyMethod(name = "identical?", required = 2, module = true) - public static IRubyObject identical_p(IRubyObject recv, IRubyObject filename1, IRubyObject filename2) { - Ruby runtime = recv.getRuntime(); - JRubyFile file1 = file(filename1); - JRubyFile file2 = file(filename2); - - return runtime.newBoolean(file1.exists() && file2.exists() && - runtime.getPosix().stat(file1.getAbsolutePath()).isIdentical(runtime.getPosix().stat(file2.getAbsolutePath()))); - } - - @JRubyMethod(name = "owned?", required = 1, module = true) - public static IRubyObject owned_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isOwned()); - } - - @JRubyMethod(name = "pipe?", required = 1, module = true) - public static IRubyObject pipe_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isNamedPipe()); - } - - // We use file test since it is faster than a stat; also euid == uid in Java always - @JRubyMethod(name = {"readable?", "readable_real?"}, required = 1, module = true) - public static IRubyObject readable_p(IRubyObject recv, IRubyObject filename) { - JRubyFile file = file(filename); - - return recv.getRuntime().newBoolean(file.exists() && file.canRead()); - } - - // Not exposed by filetest, but so similiar in nature that it is stored here - public static IRubyObject rowned_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isROwned()); - } - - @JRubyMethod(name = "setgid?", required = 1, module = true) - public static IRubyObject setgid_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isSetgid()); - } - - @JRubyMethod(name = "setuid?", required = 1, module = true) - public static IRubyObject setuid_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isSetuid()); - } - - @JRubyMethod(name = "size", required = 1, module = true) - public static IRubyObject size(IRubyObject recv, IRubyObject filename) { - JRubyFile file = file(filename); - - if (!file.exists()) noFileError(filename); - - return recv.getRuntime().newFixnum(file.length()); - } - - @JRubyMethod(name = "size?", required = 1, module = true) - public static IRubyObject size_p(IRubyObject recv, IRubyObject filename) { - JRubyFile file = file(filename); - - if (!file.exists()) { - return recv.getRuntime().getNil(); - } - - long length = file.length(); - if (length > 0) { - return recv.getRuntime().newFixnum(length); - } else { - return recv.getRuntime().getNil(); - } - } - - @JRubyMethod(name = "socket?", required = 1, module = true) - public static IRubyObject socket_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isSocket()); - } - - @JRubyMethod(name = "sticky?", required = 1, module = true) - public static IRubyObject sticky_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - return runtime.newBoolean(file.exists() && runtime.getPosix().stat(file.getAbsolutePath()).isSticky()); - } - - @JRubyMethod(name = "symlink?", required = 1, module = true) - public static RubyBoolean symlink_p(IRubyObject recv, IRubyObject filename) { - Ruby runtime = recv.getRuntime(); - JRubyFile file = file(filename); - - try { - // Note: We can't use file.exists() to check whether the symlink - // exists or not, because that method returns false for existing - // but broken symlink. So, we try without the existence check, - // but in the try-catch block. - // MRI behavior: symlink? on broken symlink should return true. - return runtime.newBoolean(runtime.getPosix().lstat(file.getAbsolutePath()).isSymlink()); - } catch (RaiseException re) { - return runtime.getFalse(); - } - } - - // We do both writable and writable_real through the same method because - // in our java process effective and real userid will always be the same. - @JRubyMethod(name = {"writable?", "writable_real?"}, required = 1, module = true) - public static RubyBoolean writable_p(IRubyObject recv, IRubyObject filename) { - return filename.getRuntime().newBoolean(file(filename).canWrite()); - } - - @JRubyMethod(name = "zero?", required = 1, module = true) - public static RubyBoolean zero_p(IRubyObject recv, IRubyObject filename) { - JRubyFile file = file(filename); - - return filename.getRuntime().newBoolean(file.exists() && file.length() == 0L); - } - - private static JRubyFile file(IRubyObject path) { - String filename = path.convertToString().toString(); - - return JRubyFile.create(path.getRuntime().getCurrentDirectory(), filename); - } - - private static void noFileError(IRubyObject filename) { - throw filename.getRuntime().newErrnoENOENTError("No such file or directory - " + - filename.convertToString()); - } -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 David Corbin <dcorbin@users.sourceforge.net> - * Copyright (C) 2006 Antti Karanta <antti.karanta@napa.fi> - * Copyright (C) 2007 Miguel Covarrubias <mlcovarrubias@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.math.BigInteger; -import java.util.HashMap; -import java.util.Map; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.java.MiniJava; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.Convert; -import org.jruby.util.Numeric; -import org.jruby.util.TypeCoercer; - -/** - * Implementation of the Fixnum class. - */ -@JRubyClass(name="Fixnum", parent="Integer", include="Precision") -public class RubyFixnum extends RubyInteger { - - public static RubyClass createFixnumClass(Ruby runtime) { - RubyClass fixnum = runtime.defineClass("Fixnum", runtime.getInteger(), - ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setFixnum(fixnum); - fixnum.index = ClassIndex.FIXNUM; - fixnum.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyFixnum; - } - }; - - fixnum.includeModule(runtime.getPrecision()); - - fixnum.defineAnnotatedMethods(RubyFixnum.class); - - for (int i = 0; i < runtime.fixnumCache.length; i++) { - runtime.fixnumCache[i] = new RubyFixnum(runtime, fixnum, i - 128); - } - - return fixnum; - } - - private final long value; - private static final int BIT_SIZE = 64; - public static final long SIGN_BIT = (1L << (BIT_SIZE - 1)); - public static final long MAX = (1L<<(BIT_SIZE - 1)) - 1; - public static final long MIN = -1 * MAX - 1; - public static final long MAX_MARSHAL_FIXNUM = (1L << 30) - 1; // 0x3fff_ffff - public static final long MIN_MARSHAL_FIXNUM = - (1L << 30); // -0x4000_0000 - - private static IRubyObject fixCoerce(IRubyObject x) { - do { - x = x.convertToInteger(); - } while (!(x instanceof RubyFixnum) && !(x instanceof RubyBignum)); - return x; - } - - public RubyFixnum(Ruby runtime) { - this(runtime, 0); - } - - public RubyFixnum(Ruby runtime, long value) { - super(runtime, runtime.getFixnum(), false); - this.value = value; - } - - private RubyFixnum(Ruby runtime, RubyClass klazz, long value) { - super(runtime, klazz, false); - this.value = value; - } - - @Override - public int getNativeTypeIndex() { - return ClassIndex.FIXNUM; - } - - /** - * short circuit for Fixnum key comparison - */ - @Override - public final boolean eql(IRubyObject other) { - return other instanceof RubyFixnum && value == ((RubyFixnum)other).value; - } - - @Override - public boolean isImmediate() { - return true; - } - - @Override - public RubyClass getSingletonClass() { - throw getRuntime().newTypeError("can't define singleton"); - } - - @Override - public Class<?> getJavaClass() { - // this precision-guessing needs to be thought out more, since in the - // case of coercing to Object we generally want to get the same type - // always -// if (value >= Byte.MIN_VALUE && value <= Byte.MAX_VALUE) { -// return byte.class; -// } else if (value >= Short.MIN_VALUE && value <= Short.MAX_VALUE) { -// return short.class; -// } else if (value >= Character.MIN_VALUE && value <= Character.MAX_VALUE) { -// return char.class; -// } else if (value >= Integer.MIN_VALUE && value <= Integer.MAX_VALUE) { -// return int.class; -// } - return long.class; - } - - @Override - public double getDoubleValue() { - return value; - } - - @Override - public long getLongValue() { - return value; - } - - private static final int CACHE_OFFSET = 128; - - public static RubyFixnum newFixnum(Ruby runtime, long value) { - if (isInCacheRange(value)) { - return runtime.fixnumCache[(int) value + CACHE_OFFSET]; - } - return new RubyFixnum(runtime, value); - } - - private static boolean isInCacheRange(long value) { - return value <= 127 && value >= -128; - } - - public RubyFixnum newFixnum(long newValue) { - return newFixnum(getRuntime(), newValue); - } - - public static RubyFixnum zero(Ruby runtime) { - return runtime.fixnumCache[CACHE_OFFSET]; - } - - public static RubyFixnum one(Ruby runtime) { - return runtime.fixnumCache[CACHE_OFFSET + 1]; - } - - public static RubyFixnum two(Ruby runtime) { - return runtime.fixnumCache[CACHE_OFFSET + 2]; - } - - public static RubyFixnum three(Ruby runtime) { - return runtime.fixnumCache[CACHE_OFFSET + 3]; - } - - public static RubyFixnum four(Ruby runtime) { - return runtime.fixnumCache[CACHE_OFFSET + 4]; - } - - public static RubyFixnum five(Ruby runtime) { - return runtime.fixnumCache[CACHE_OFFSET + 5]; - } - - public static RubyFixnum minus_one(Ruby runtime) { - return runtime.fixnumCache[CACHE_OFFSET - 1]; - } - - @Override - public RubyFixnum hash() { - return newFixnum(hashCode()); - } - - @Override - public final int hashCode() { - return (int)(value ^ value >>> 32); - } - - @Override - public boolean equals(Object other) { - if (other == this) { - return true; - } - - if (other instanceof RubyFixnum) { - RubyFixnum num = (RubyFixnum)other; - - if (num.value == value) { - return true; - } - } - - return false; - } - - /* ================ - * Instance Methods - * ================ - */ - - /** fix_to_s - * - */ - public RubyString to_s(IRubyObject[] args) { - switch (args.length) { - case 0: return to_s(); - case 1: return to_s(args[0]); - default: throw getRuntime().newArgumentError(args.length, 1); - } - } - - @JRubyMethod - @Override - public RubyString to_s() { - int base = 10; - return getRuntime().newString(Convert.longToByteList(value, base)); - } - - @JRubyMethod - public RubyString to_s(IRubyObject arg0) { - int base = num2int(arg0); - if (base < 2 || base > 36) { - throw getRuntime().newArgumentError("illegal radix " + base); - } - return getRuntime().newString(Convert.longToByteList(value, base)); - } - - /** fix_id2name - * - */ - @JRubyMethod - public IRubyObject id2name() { - RubySymbol symbol = RubySymbol.getSymbolLong(getRuntime(), value); - - if (symbol != null) return getRuntime().newString(symbol.asJavaString()); - - return getRuntime().getNil(); - } - - /** fix_to_sym - * - */ - @JRubyMethod - public IRubyObject to_sym() { - RubySymbol symbol = RubySymbol.getSymbolLong(getRuntime(), value); - - return symbol != null ? symbol : getRuntime().getNil(); - } - - /** fix_uminus - * - */ - @JRubyMethod(name = "-@") - public IRubyObject op_uminus() { - if (value == MIN) { // a gotcha - return RubyBignum.newBignum(getRuntime(), BigInteger.valueOf(value).negate()); - } - return RubyFixnum.newFixnum(getRuntime(), -value); - } - - /** fix_plus - * - */ - @JRubyMethod(name = "+") - public IRubyObject op_plus(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return addFixnum(context, (RubyFixnum)other); - } - return addOther(context, other); - } - - private IRubyObject addFixnum(ThreadContext context, RubyFixnum other) { - long otherValue = other.value; - long result = value + otherValue; - if (additionOverflowed(value, otherValue, result)) { - return addAsBignum(context, other); - } - return newFixnum(context.getRuntime(), result); - } - - private static boolean additionOverflowed(long original, long other, long result) { - return (~(original ^ other) & (original ^ result) & SIGN_BIT) != 0; - } - - private static boolean subtractionOverflowed(long original, long other, long result) { - return (~(original ^ ~other) & (original ^ result) & SIGN_BIT) != 0; - } - - private IRubyObject addAsBignum(ThreadContext context, RubyFixnum other) { - return RubyBignum.newBignum(context.getRuntime(), value).op_plus(context, other); - } - - private IRubyObject addOther(ThreadContext context, IRubyObject other) { - if (other instanceof RubyBignum) { - return ((RubyBignum) other).op_plus(context, this); - } - if (other instanceof RubyFloat) { - return context.getRuntime().newFloat((double) value + ((RubyFloat) other).getDoubleValue()); - } - return coerceBin(context, "+", other); - } - - /** fix_minus - * - */ - @JRubyMethod(name = "-") - public IRubyObject op_minus(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return subtractFixnum(context, (RubyFixnum)other); - } - return subtractOther(context, other); - } - - private IRubyObject subtractFixnum(ThreadContext context, RubyFixnum other) { - long otherValue = other.value; - long result = value - otherValue; - if (subtractionOverflowed(value, otherValue, result)) { - return subtractAsBignum(context, other); - } - return newFixnum(context.getRuntime(), result); - } - - private IRubyObject subtractAsBignum(ThreadContext context, RubyFixnum other) { - return RubyBignum.newBignum(context.getRuntime(), value).op_minus(context, other); - } - - private IRubyObject subtractOther(ThreadContext context, IRubyObject other) { - if (other instanceof RubyBignum) { - return RubyBignum.newBignum(context.getRuntime(), value).op_minus(context, other); - } else if (other instanceof RubyFloat) { - return context.getRuntime().newFloat((double) value - ((RubyFloat) other).getDoubleValue()); - } - return coerceBin(context, "-", other); - } - - /** fix_mul - * - */ - @JRubyMethod(name = "*") - public IRubyObject op_mul(ThreadContext context, IRubyObject other) { - Ruby runtime = context.getRuntime(); - if (other instanceof RubyFixnum) { - long otherValue = ((RubyFixnum) other).value; - if (value == 0) { - return RubyFixnum.zero(runtime); - } - long result = value * otherValue; - if (result / value != otherValue) { - return RubyBignum.newBignum(runtime, value).op_mul(context, other); - } - return newFixnum(runtime, result); - } else if (other instanceof RubyBignum) { - return ((RubyBignum) other).op_mul(context, this); - } else if (other instanceof RubyFloat) { - return runtime.newFloat((double) value * ((RubyFloat) other).getDoubleValue()); - } - return coerceBin(context, "*", other); - } - - /** fix_div - * here is terrible MRI gotcha: - * 1.div 3.0 -> 0 - * 1 / 3.0 -> 0.3333333333333333 - * - * MRI is also able to do it in one place by looking at current frame in rb_num_coerce_bin: - * rb_funcall(x, ruby_frame->orig_func, 1, y); - * - * also note that RubyFloat doesn't override Numeric.div - */ - @JRubyMethod(name = "div") - public IRubyObject div_div(ThreadContext context, IRubyObject other) { - return idiv(context, other, "div"); - } - - @JRubyMethod(name = "/") - public IRubyObject op_div(ThreadContext context, IRubyObject other) { - return idiv(context, other, "/"); - } - - @JRubyMethod(name = {"odd?"}) - public RubyBoolean odd_p() { - if(value%2 != 0) { - return getRuntime().getTrue(); - } - return getRuntime().getFalse(); - } - - @JRubyMethod(name = {"even?"}) - public RubyBoolean even_p() { - if(value%2 == 0) { - return getRuntime().getTrue(); - } - return getRuntime().getFalse(); - } - - @JRubyMethod - public IRubyObject pred() { - return getRuntime().newFixnum(value-1); - } - - public IRubyObject idiv(ThreadContext context, IRubyObject other, String method) { - if (other instanceof RubyFixnum) { - long x = value; - long y = ((RubyFixnum) other).value; - - if (y == 0) { - throw context.getRuntime().newZeroDivisionError(); - } - - long div = x / y; - long mod = x % y; - - if (mod < 0 && y > 0 || mod > 0 && y < 0) { - div -= 1; - } - - return context.getRuntime().newFixnum(div); - } - return coerceBin(context, method, other); - } - - /** fix_mod - * - */ - @JRubyMethod(name = {"%", "modulo"}) - public IRubyObject op_mod(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - // Java / and % are not the same as ruby - long x = value; - long y = ((RubyFixnum) other).value; - - if (y == 0) { - throw context.getRuntime().newZeroDivisionError(); - } - - long mod = x % y; - - if (mod < 0 && y > 0 || mod > 0 && y < 0) { - mod += y; - } - - return context.getRuntime().newFixnum(mod); - } - return coerceBin(context, "%", other); - } - - /** fix_divmod - * - */ - @JRubyMethod - @Override - public IRubyObject divmod(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - long x = value; - long y = ((RubyFixnum) other).value; - final Ruby runtime = context.getRuntime(); - - if (y == 0) { - throw runtime.newZeroDivisionError(); - } - - long div = x / y; - long mod = x % y; - - if (mod < 0 && y > 0 || mod > 0 && y < 0) { - div -= 1; - mod += y; - } - - IRubyObject fixDiv = RubyFixnum.newFixnum(runtime, div); - IRubyObject fixMod = RubyFixnum.newFixnum(runtime, mod); - - return RubyArray.newArray(runtime, fixDiv, fixMod); - - } - return coerceBin(context, "divmod", other); - } - - /** fix_quo - * - */ - @JRubyMethod(name = "quo", compat = CompatVersion.RUBY1_8) - public IRubyObject quo(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return RubyFloat.newFloat(context.getRuntime(), (double) value / (double) ((RubyFixnum) other).value); - } - return coerceBin(context, "quo", other); - } - - /** fix_pow - * - */ - @JRubyMethod(name = "**") - public IRubyObject op_pow(ThreadContext context, IRubyObject other) { - if(other instanceof RubyFixnum) { - long b = ((RubyFixnum) other).value; - - if (b == 0) { - return RubyFixnum.one(context.getRuntime()); - } - if (b == 1) { - return this; - } - if (b > 0) { - return RubyBignum.newBignum(context.getRuntime(), value).op_pow(context, other); - } - return RubyFloat.newFloat(context.getRuntime(), Math.pow(value, b)); - } else if (other instanceof RubyFloat) { - return RubyFloat.newFloat(context.getRuntime(), Math.pow(value, ((RubyFloat) other) - .getDoubleValue())); - } - return coerceBin(context, "**", other); - } - - /** fix_pow - * - */ - @JRubyMethod(name = "**", compat = CompatVersion.RUBY1_9) - public IRubyObject op_pow_19(ThreadContext context, IRubyObject other) { - Ruby runtime = context.getRuntime(); - long a = value; - if (other instanceof RubyFixnum) { - long b = ((RubyFixnum) other).value; - - if (b < 0) { - return RubyRational.newRationalRaw(context.getRuntime(), this).callMethod(context, "**", other); - } - - if (b == 0) return RubyFixnum.one(runtime); - if (b == 1) return this; - - if (a == 0) { - return b > 0 ? RubyFixnum.zero(runtime) : RubyNumeric.dbl2num(runtime, 1.0 / 0.0); - } - if (a == 1) return RubyFixnum.one(runtime); - if (a == -1) { - return b % 2 == 0 ? RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime); - } - return Numeric.int_pow(context, a, b); - } else if (other instanceof RubyBignum) { - if (other.callMethod(context, "<", RubyFixnum.zero(runtime)).isTrue()) { - return RubyRational.newRationalRaw(runtime, this).callMethod(context, "**", other); - } - if (a == 0) return RubyFixnum.zero(runtime); - if (a == 1) return RubyFixnum.one(runtime); - if (a == -1) { - return RubyInteger.even_p(context, other).isTrue() ? RubyFixnum.one(runtime) : RubyFixnum.minus_one(runtime); - } - RubyBignum.newBignum(runtime, RubyBignum.fix2big(this)).op_pow(context, other); - } else if (other instanceof RubyFloat) { - return RubyFloat.newFloat(context.getRuntime(), Math.pow(a, ((RubyFloat) other).getDoubleValue())); - } - return coerceBin(context, "**", other); - } - - - /** fix_abs - * - */ - @JRubyMethod - public IRubyObject abs() { - if (value < 0) { - // A gotcha for Long.MIN_VALUE: value = -value - if (value == Long.MIN_VALUE) { - return RubyBignum.newBignum( - getRuntime(), BigInteger.valueOf(value).negate()); - } - return RubyFixnum.newFixnum(getRuntime(), -value); - } - return this; - } - - /** fix_equal - * - */ - @JRubyMethod(name = "==") - @Override - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return RubyBoolean.newBoolean(context.getRuntime(), value == ((RubyFixnum) other).value); - } - return super.op_num_equal(context, other); - } - - /** fix_cmp - * - */ - @JRubyMethod(name = "<=>") - public IRubyObject op_cmp(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return compareFixnum(context, (RubyFixnum)other); - } - return coerceCmp(context, "<=>", other); - } - - private IRubyObject compareFixnum(ThreadContext context, RubyFixnum other) { - long otherValue = ((RubyFixnum) other).value; - if (value == otherValue) { - return RubyFixnum.zero(context.getRuntime()); - } - if (value > otherValue) { - return RubyFixnum.one(context.getRuntime()); - } - return RubyFixnum.minus_one(context.getRuntime()); - } - - /** fix_gt - * - */ - @JRubyMethod(name = ">") - public IRubyObject op_gt(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return RubyBoolean.newBoolean(context.getRuntime(), value > ((RubyFixnum) other).value); - } - return coerceRelOp(context, ">", other); - } - - /** fix_ge - * - */ - @JRubyMethod(name = ">=") - public IRubyObject op_ge(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return RubyBoolean.newBoolean(context.getRuntime(), value >= ((RubyFixnum) other).value); - } - return coerceRelOp(context, ">=", other); - } - - /** fix_lt - * - */ - @JRubyMethod(name = "<") - public IRubyObject op_lt(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return RubyBoolean.newBoolean(context.getRuntime(), value < ((RubyFixnum) other).value); - } - - return coerceRelOp(context, "<", other); - } - - /** fix_le - * - */ - @JRubyMethod(name = "<=") - public IRubyObject op_le(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum) { - return RubyBoolean.newBoolean(context.getRuntime(), value <= ((RubyFixnum) other).value); - } - - return coerceRelOp(context, "<=", other); - } - - /** fix_rev - * - */ - @JRubyMethod(name = "~") - public IRubyObject op_neg() { - return newFixnum(~value); - } - - /** fix_and - * - */ - @JRubyMethod(name = "&") - public IRubyObject op_and(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum || (other = fixCoerce(other)) instanceof RubyFixnum) { - return newFixnum(context.getRuntime(), value & ((RubyFixnum) other).value); - } - return ((RubyBignum) other).op_and(context, this); - } - - /** fix_or - * - */ - @JRubyMethod(name = "|") - public IRubyObject op_or(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum || (other = fixCoerce(other)) instanceof RubyFixnum) { - return newFixnum(context.getRuntime(), value | ((RubyFixnum) other).value); - } - return ((RubyBignum) other).op_or(context, this); - } - - /** fix_xor - * - */ - @JRubyMethod(name = "^") - public IRubyObject op_xor(ThreadContext context, IRubyObject other) { - if (other instanceof RubyFixnum || (other = fixCoerce(other)) instanceof RubyFixnum) { - return newFixnum(context.getRuntime(), value ^ ((RubyFixnum) other).value); - } - return ((RubyBignum) other).op_xor(context, this); - } - - /** fix_aref - * - */ - @JRubyMethod(name = "[]") - public IRubyObject op_aref(IRubyObject other) { - if(!(other instanceof RubyFixnum) && !((other = fixCoerce(other)) instanceof RubyFixnum)) { - RubyBignum big = (RubyBignum) other; - RubyObject tryFix = RubyBignum.bignorm(getRuntime(), big.getValue()); - if (!(tryFix instanceof RubyFixnum)) { - return big.getValue().signum() == 0 || value >= 0 ? RubyFixnum.zero(getRuntime()) : RubyFixnum.one(getRuntime()); - } - } - - long otherValue = fix2long(other); - - if (otherValue < 0) return RubyFixnum.zero(getRuntime()); - - if (BIT_SIZE - 1 < otherValue) { - return value < 0 ? RubyFixnum.one(getRuntime()) : RubyFixnum.zero(getRuntime()); - } - - return (value & (1L << otherValue)) == 0 ? RubyFixnum.zero(getRuntime()) : RubyFixnum.one(getRuntime()); - } - - /** fix_lshift - * - */ - @JRubyMethod(name = "<<") - public IRubyObject op_lshift(IRubyObject other) { - if (!(other instanceof RubyFixnum)) return RubyBignum.newBignum(getRuntime(), value).op_lshift(other); - - long width = ((RubyFixnum)other).getLongValue(); - - return width < 0 ? rshift(-width) : lshift(width); - } - - private IRubyObject lshift(long width) { - if (width > BIT_SIZE - 1 || ((~0L << BIT_SIZE - width - 1) & value) != 0) { - return RubyBignum.newBignum(getRuntime(), value).op_lshift(RubyFixnum.newFixnum(getRuntime(), width)); - } - return RubyFixnum.newFixnum(getRuntime(), value << width); - } - - /** fix_rshift - * - */ - @JRubyMethod(name = ">>") - public IRubyObject op_rshift(IRubyObject other) { - if (!(other instanceof RubyFixnum)) return RubyBignum.newBignum(getRuntime(), value).op_rshift(other); - - long width = ((RubyFixnum)other).getLongValue(); - - if (width == 0) return this; - - return width < 0 ? lshift(-width) : rshift(width); - } - - private IRubyObject rshift(long width) { - if (width >= BIT_SIZE - 1) { - return value < 0 ? RubyFixnum.minus_one(getRuntime()) : RubyFixnum.zero(getRuntime()); - } - return RubyFixnum.newFixnum(getRuntime(), value >> width); - } - - /** fix_to_f - * - */ - @JRubyMethod - public IRubyObject to_f() { - return RubyFloat.newFloat(getRuntime(), (double) value); - } - - /** fix_size - * - */ - @JRubyMethod - public IRubyObject size() { - return newFixnum((long) ((BIT_SIZE + 7) / 8)); - } - - /** fix_zero_p - * - */ - @JRubyMethod(name = "zero?") - public IRubyObject zero_p() { - return RubyBoolean.newBoolean(getRuntime(), value == 0); - } - - @JRubyMethod - @Override - public IRubyObject id() { - if (value <= Long.MAX_VALUE / 2 && value >= Long.MIN_VALUE / 2) { - return newFixnum(2 * value + 1); - } - - return super.id(); - } - - @Override - public IRubyObject taint(ThreadContext context) { - return this; - } - - @Override - public IRubyObject freeze(ThreadContext context) { - return this; - } - - // Piece of mri rb_to_id - @Override - public String asJavaString() { - getRuntime().getWarnings().warn(ID.FIXNUMS_NOT_SYMBOLS, "do not use Fixnums as Symbols"); - - // FIXME: I think this chunk is equivalent to MRI id2name (and not our public method - // id2name). Make into method if used more than once. - RubySymbol symbol = RubySymbol.getSymbolLong(getRuntime(), value); - - if (symbol == null) { - throw getRuntime().newArgumentError("" + value + " is not a symbol"); - } - - return symbol.asJavaString(); - } - - public static RubyFixnum unmarshalFrom(UnmarshalStream input) throws java.io.IOException { - return input.getRuntime().newFixnum(input.unmarshalInt()); - } - - /* ================ - * Singleton Methods - * ================ - */ - - /** rb_fix_induced_from - * - */ - @JRubyMethod(meta = true) - public static IRubyObject induced_from(IRubyObject recv, IRubyObject other) { - return RubyNumeric.num2fix(other); - } - - @Override - public IRubyObject to_java() { - return MiniJava.javaToRuby(getRuntime(), Long.valueOf(value)); - } - - @Override - public IRubyObject as(Class javaClass) { - return MiniJava.javaToRuby(getRuntime(), coerceToJavaType(getRuntime(), this, javaClass)); - } - - private static Object coerceToJavaType(Ruby ruby, RubyFixnum self, Class javaClass) { - if (!Number.class.isAssignableFrom(javaClass)) { - throw ruby.newTypeError(javaClass.getCanonicalName() + " is not a numeric type"); - } - - TypeCoercer coercer = JAVA_COERCERS.get(javaClass); - - if (coercer == null) { - throw ruby.newTypeError("Cannot coerce Fixnum to " + javaClass.getCanonicalName()); - } - - return coercer.coerce(self); - } - - private static final Map<Class, TypeCoercer> JAVA_COERCERS = new HashMap<Class, TypeCoercer>(); - - static { - TypeCoercer intCoercer = new TypeCoercer() { - public Object coerce(IRubyObject self) { - RubyFixnum fixnum = (RubyFixnum)self; - - if (fixnum.value > Integer.MAX_VALUE) { - throw self.getRuntime().newRangeError("Fixnum " + fixnum.value + " is too large for Java int"); - } - - return Integer.valueOf((int)fixnum.value); - } - }; - JAVA_COERCERS.put(int.class, intCoercer); - JAVA_COERCERS.put(Integer.class, intCoercer); - } -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Don Schwartz <schwardo@users.sourceforge.net> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import static org.jruby.util.Numeric.f_expt; -import static org.jruby.util.Numeric.f_mul; -import static org.jruby.util.Numeric.f_to_i; -import static org.jruby.util.Numeric.frexp; -import static org.jruby.util.Numeric.ldexp; - -import java.text.DecimalFormat; -import java.text.DecimalFormatSymbols; -import java.util.Locale; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; - -/** - * A representation of a float object - */ -@JRubyClass(name="Float", parent="Numeric", include="Precision") -public class RubyFloat extends RubyNumeric { - - public static RubyClass createFloatClass(Ruby runtime) { - RubyClass floatc = runtime.defineClass("Float", runtime.getNumeric(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setFloat(floatc); - floatc.index = ClassIndex.FLOAT; - floatc.kindOf = new RubyModule.KindOf() { - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyFloat; - } - }; - - floatc.getSingletonClass().undefineMethod("new"); - floatc.includeModule(runtime.getPrecision()); - - // Java Doubles are 64 bit long: - floatc.defineConstant("ROUNDS", RubyFixnum.newFixnum(runtime, 1)); - floatc.defineConstant("RADIX", RubyFixnum.newFixnum(runtime, 2)); - floatc.defineConstant("MANT_DIG", RubyFixnum.newFixnum(runtime, 53)); - floatc.defineConstant("DIG", RubyFixnum.newFixnum(runtime, 15)); - // Double.MAX_EXPONENT since Java 1.6 - floatc.defineConstant("MIN_EXP", RubyFixnum.newFixnum(runtime, -1021)); - // Double.MAX_EXPONENT since Java 1.6 - floatc.defineConstant("MAX_EXP", RubyFixnum.newFixnum(runtime, 1024)); - floatc.defineConstant("MIN_10_EXP", RubyFixnum.newFixnum(runtime, -307)); - floatc.defineConstant("MAX_10_EXP", RubyFixnum.newFixnum(runtime, 308)); - floatc.defineConstant("MIN", RubyFloat.newFloat(runtime, Double.MIN_VALUE)); - floatc.defineConstant("MAX", RubyFloat.newFloat(runtime, Double.MAX_VALUE)); - floatc.defineConstant("EPSILON", RubyFloat.newFloat(runtime, 2.2204460492503131e-16)); - - floatc.defineAnnotatedMethods(RubyFloat.class); - - return floatc; - } - - private final double value; - - public int getNativeTypeIndex() { - return ClassIndex.FLOAT; - } - - public RubyFloat(Ruby runtime) { - this(runtime, 0.0); - } - - public RubyFloat(Ruby runtime, double value) { - super(runtime, runtime.getFloat()); - this.value = value; - } - - public Class<?> getJavaClass() { - // this needs to be thought out more along with the changes in RubyFixnum - // since "to Object" coercion will generally want to produce the same - // type every time -// if (value >= Float.MIN_VALUE && value <= Float.MAX_VALUE) { -// return float.class; -// } - return double.class; - } - - /** Getter for property value. - * @return Value of property value. - */ - public double getValue() { - return this.value; - } - - public double getDoubleValue() { - return value; - } - - public long getLongValue() { - return (long) value; - } - - public RubyFloat convertToFloat() { - return this; - } - - protected int compareValue(RubyNumeric other) { - double otherVal = other.getDoubleValue(); - return getValue() > otherVal ? 1 : getValue() < otherVal ? -1 : 0; - } - - public static RubyFloat newFloat(Ruby runtime, double value) { - return new RubyFloat(runtime, value); - } - - /* ================ - * Instance Methods - * ================ - */ - - /** rb_flo_induced_from - * - */ - @JRubyMethod(required = 1, meta = true) - public static IRubyObject induced_from(ThreadContext context, IRubyObject recv, IRubyObject number) { - if (number instanceof RubyFixnum || number instanceof RubyBignum || number instanceof RubyRational) { - return number.callMethod(context, MethodIndex.TO_F, "to_f"); - } else if (number instanceof RubyFloat) { - return number; - } - throw recv.getRuntime().newTypeError( - "failed to convert " + number.getMetaClass() + " into Float"); - } - - private final static DecimalFormat FORMAT = new DecimalFormat("##############0.0##############", - new DecimalFormatSymbols(Locale.ENGLISH)); - - /** flo_to_s - * - */ - @JRubyMethod(name = "to_s") - public IRubyObject to_s() { - if (Double.isInfinite(value)) { - return RubyString.newString(getRuntime(), value < 0 ? "-Infinity" : "Infinity"); - } - - if (Double.isNaN(value)) { - return RubyString.newString(getRuntime(), "NaN"); - } - - String val = ""+value; - - if(val.indexOf('E') != -1) { - String v2 = FORMAT.format(value); - int ix = v2.length()-1; - while(v2.charAt(ix) == '0' && v2.charAt(ix-1) != '.') { - ix--; - } - if(ix > 15 || "0.0".equals(v2.substring(0,ix+1))) { - val = val.replaceFirst("E(\\d)","e+$1").replaceFirst("E-","e-"); - } else { - val = v2.substring(0,ix+1); - } - } - - return RubyString.newString(getRuntime(), val); - } - - /** flo_coerce - * - */ - @JRubyMethod(name = "coerce", required = 1) - public IRubyObject coerce(IRubyObject other) { - return getRuntime().newArray(RubyKernel.new_float(this, other), this); - } - - /** flo_uminus - * - */ - @JRubyMethod(name = "-@") - public IRubyObject op_uminus() { - return RubyFloat.newFloat(getRuntime(), -value); - } - - /** flo_plus - * - */ - @JRubyMethod(name = "+", required = 1) - public IRubyObject op_plus(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - return RubyFloat.newFloat(getRuntime(), value + ((RubyNumeric) other).getDoubleValue()); - default: - return coerceBin(context, "+", other); - } - } - - /** flo_minus - * - */ - @JRubyMethod(name = "-", required = 1) - public IRubyObject op_minus(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - return RubyFloat.newFloat(getRuntime(), value - ((RubyNumeric) other).getDoubleValue()); - default: - return coerceBin(context, "-", other); - } - } - - /** flo_mul - * - */ - @JRubyMethod(name = "*", required = 1) - public IRubyObject op_mul(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - return RubyFloat.newFloat( - getRuntime(), value * ((RubyNumeric) other).getDoubleValue()); - default: - return coerceBin(context, "*", other); - } - } - - /** flo_div - * - */ - @JRubyMethod(name = "/", required = 1) - public IRubyObject op_fdiv(ThreadContext context, IRubyObject other) { // don't override Numeric#div ! - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - return RubyFloat.newFloat(getRuntime(), value / ((RubyNumeric) other).getDoubleValue()); - default: - return coerceBin(context, "/", other); - } - } - - /** flo_mod - * - */ - @JRubyMethod(name = {"%", "modulo"}, required = 1) - public IRubyObject op_mod(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - double y = ((RubyNumeric) other).getDoubleValue(); - // Modelled after c ruby implementation (java /,% not same as ruby) - double x = value; - - double mod = Math.IEEEremainder(x, y); - if (y * mod < 0) { - mod += y; - } - - return RubyFloat.newFloat(getRuntime(), mod); - default: - return coerceBin(context, "%", other); - } - } - - /** flo_divmod - * - */ - @JRubyMethod(name = "divmod", required = 1) - public IRubyObject divmod(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - double y = ((RubyNumeric) other).getDoubleValue(); - double x = value; - - double mod = Math.IEEEremainder(x, y); - // MRI behavior: - if (Double.isNaN(mod)) { - throw getRuntime().newFloatDomainError("NaN"); - } - double div = Math.floor(x / y); - - if (y * mod < 0) { - mod += y; - } - final Ruby runtime = getRuntime(); - IRubyObject car = dbl2num(runtime, div); - RubyFloat cdr = RubyFloat.newFloat(runtime, mod); - return RubyArray.newArray(runtime, car, cdr); - default: - return coerceBin(context, "divmod", other); - } - } - - /** flo_pow - * - */ - @JRubyMethod(name = "**", required = 1) - public IRubyObject op_pow(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - return RubyFloat.newFloat(getRuntime(), Math.pow(value, ((RubyNumeric) other) - .getDoubleValue())); - default: - return coerceBin(context, "**", other); - } - } - - /** flo_eq - * - */ - @JRubyMethod(name = "==", required = 1) - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - if (Double.isNaN(value)) { - return getRuntime().getFalse(); - } - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - return RubyBoolean.newBoolean(getRuntime(), value == ((RubyNumeric) other) - .getDoubleValue()); - default: - // Numeric.equal - return super.op_num_equal(context, other); - } - } - - /** flo_cmp - * - */ - @JRubyMethod(name = "<=>", required = 1) - public IRubyObject op_cmp(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - double b = ((RubyNumeric) other).getDoubleValue(); - return dbl_cmp(getRuntime(), value, b); - default: - return coerceCmp(context, "<=>", other); - } - } - - /** flo_gt - * - */ - @JRubyMethod(name = ">", required = 1) - public IRubyObject op_gt(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - double b = ((RubyNumeric) other).getDoubleValue(); - return RubyBoolean.newBoolean(getRuntime(), !Double.isNaN(b) && value > b); - default: - return coerceRelOp(context, ">", other); - } - } - - /** flo_ge - * - */ - @JRubyMethod(name = ">=", required = 1) - public IRubyObject op_ge(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - double b = ((RubyNumeric) other).getDoubleValue(); - return RubyBoolean.newBoolean(getRuntime(), !Double.isNaN(b) && value >= b); - default: - return coerceRelOp(context, ">=", other); - } - } - - /** flo_lt - * - */ - @JRubyMethod(name = "<", required = 1) - public IRubyObject op_lt(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - double b = ((RubyNumeric) other).getDoubleValue(); - return RubyBoolean.newBoolean(getRuntime(), !Double.isNaN(b) && value < b); - default: - return coerceRelOp(context, "<", other); - } - } - - /** flo_le - * - */ - @JRubyMethod(name = "<=", required = 1) - public IRubyObject op_le(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - case ClassIndex.FLOAT: - double b = ((RubyNumeric) other).getDoubleValue(); - return RubyBoolean.newBoolean(getRuntime(), !Double.isNaN(b) && value <= b); - default: - return coerceRelOp(context, "<=", other); - } - } - - /** flo_eql - * - */ - @JRubyMethod(name = "eql?", required = 1) - public IRubyObject eql_p(IRubyObject other) { - if (other instanceof RubyFloat) { - double b = ((RubyFloat) other).value; - if (Double.isNaN(value) || Double.isNaN(b)) { - return getRuntime().getFalse(); - } - if (value == b) { - return getRuntime().getTrue(); - } - } - return getRuntime().getFalse(); - } - - /** flo_hash - * - */ - @JRubyMethod(name = "hash") - public RubyFixnum hash() { - return getRuntime().newFixnum(hashCode()); - } - - public final int hashCode() { - long l = Double.doubleToLongBits(value); - return (int)(l ^ l >>> 32); - } - - /** flo_fo - * - */ - @JRubyMethod(name = "to_f") - public IRubyObject to_f() { - return this; - } - - /** flo_abs - * - */ - @JRubyMethod(name = "abs") - public IRubyObject abs() { - if (Double.doubleToLongBits(value) < 0) { - return RubyFloat.newFloat(getRuntime(), Math.abs(value)); - } - return this; - } - - /** flo_zero_p - * - */ - @JRubyMethod(name = "zero?") - public IRubyObject zero_p() { - return RubyBoolean.newBoolean(getRuntime(), value == 0.0); - } - - /** flo_truncate - * - */ - @JRubyMethod(name = {"truncate", "to_i", "to_int"}) - public IRubyObject truncate() { - double f = value; - if (f > 0.0) f = Math.floor(f); - if (f < 0.0) f = Math.ceil(f); - - return dbl2num(getRuntime(), f); - } - - /** float_to_r, float_decode - * - */ - static final int DBL_MANT_DIG = 53; - static final int FLT_RADIX = 2; - @JRubyMethod(name = "to_r", compat = CompatVersion.RUBY1_9) - public IRubyObject to_r(ThreadContext context) { - long[]exp = new long[1]; - double f = frexp(value, exp); - f = ldexp(f, DBL_MANT_DIG); - long n = exp[0] - DBL_MANT_DIG; - Ruby runtime = context.getRuntime(); - IRubyObject x = f_mul(context, f_to_i(context, runtime.newFloat(f)), - f_expt(context, - RubyFixnum.newFixnum(context.getRuntime(), FLT_RADIX), - RubyFixnum.newFixnum(runtime, n))); - return x; - } - - /** floor - * - */ - @JRubyMethod(name = "floor") - public IRubyObject floor() { - return dbl2num(getRuntime(), Math.floor(value)); - } - - /** flo_ceil - * - */ - @JRubyMethod(name = "ceil") - public IRubyObject ceil() { - return dbl2num(getRuntime(), Math.ceil(value)); - } - - /** flo_round - * - */ - @JRubyMethod(name = "round") - public IRubyObject round() { - double f = value; - if (f > 0.0) { - f = Math.floor(f + 0.5); - } - if (f < 0.0) { - f = Math.ceil(f - 0.5); - } - return dbl2num(getRuntime(), f); - } - - /** flo_is_nan_p - * - */ - @JRubyMethod(name = "nan?") - public IRubyObject nan_p() { - return RubyBoolean.newBoolean(getRuntime(), Double.isNaN(value)); - } - - /** flo_is_infinite_p - * - */ - @JRubyMethod(name = "infinite?") - public IRubyObject infinite_p() { - if (Double.isInfinite(value)) { - return RubyFixnum.newFixnum(getRuntime(), value < 0 ? -1 : 1); - } - return getRuntime().getNil(); - } - - /** flo_is_finite_p - * - */ - @JRubyMethod(name = "finite?") - public IRubyObject finite_p() { - if (Double.isInfinite(value) || Double.isNaN(value)) { - return getRuntime().getFalse(); - } - return getRuntime().getTrue(); - } - - public static void marshalTo(RubyFloat aFloat, MarshalStream output) throws java.io.IOException { - output.registerLinkTarget(aFloat); - - String strValue = aFloat.toString(); - - if (Double.isInfinite(aFloat.value)) { - strValue = aFloat.value < 0 ? "-inf" : "inf"; - } else if (Double.isNaN(aFloat.value)) { - strValue = "nan"; - } - output.writeString(strValue); - } - - public static RubyFloat unmarshalFrom(UnmarshalStream input) throws java.io.IOException { - RubyFloat result = RubyFloat.newFloat(input.getRuntime(), org.jruby.util.Convert.byteListToDouble(input.unmarshalString(),false)); - input.registerLinkTarget(result); - return result; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * GC (Garbage Collection) Module - * - * Note: Since we rely on Java's memory model we can't provide the - * kind of control over garbage collection that MRI provides. - * - * @author Anders - */ -@JRubyModule(name="GC") -public class RubyGC { - public static RubyModule createGCModule(Ruby runtime) { - RubyModule result = runtime.defineModule("GC"); - runtime.setGC(result); - - result.defineAnnotatedMethods(RubyGC.class); - - return result; - } - - @JRubyMethod(module = true, visibility = Visibility.PRIVATE) - public static IRubyObject start(IRubyObject recv) { - System.gc(); - return recv.getRuntime().getNil(); - } - - @JRubyMethod - public static IRubyObject garbage_collect(IRubyObject recv) { - System.gc(); - return recv.getRuntime().getNil(); - } - - @JRubyMethod(module = true, visibility = Visibility.PRIVATE) - public static IRubyObject enable(IRubyObject recv) { - recv.getRuntime().getWarnings().warn(ID.EMPTY_IMPLEMENTATION, "GC.enable will not work on JRuby", "GC.enable"); - return recv.getRuntime().getNil(); - } - - @JRubyMethod(module = true, visibility = Visibility.PRIVATE) - public static IRubyObject disable(IRubyObject recv) { - recv.getRuntime().getWarnings().warn(ID.EMPTY_IMPLEMENTATION, "GC.disable will not work on JRuby", "GC.disable"); - return recv.getRuntime().getNil(); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Tim Azzopardi <tim@tigerfive.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2006 Michael Studman <codehaus@michaelstudman.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.util.io.STDIO; -import java.util.HashMap; -import java.util.Map; - -import org.jruby.anno.JRubyMethod; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.environment.OSEnvironmentReaderExcepton; -import org.jruby.environment.OSEnvironment; -import org.jruby.internal.runtime.ValueAccessor; -import org.jruby.javasupport.JavaUtil; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Constants; -import org.jruby.runtime.GlobalVariable; -import org.jruby.runtime.IAccessor; -import org.jruby.runtime.ReadonlyGlobalVariable; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.KCode; - -/** This class initializes global variables and constants. - * - * @author jpetersen - */ -public class RubyGlobal { - - /** - * Obligate string-keyed and string-valued hash, used for ENV and ENV_JAVA - * - */ - public static class StringOnlyRubyHash extends RubyHash { - - public StringOnlyRubyHash(Ruby runtime, Map valueMap, IRubyObject defaultValue) { - super(runtime, valueMap, defaultValue); - } - - @Override - public RubyHash to_hash() { - Ruby runtime = getRuntime(); - RubyHash hash = RubyHash.newHash(runtime); - hash.replace(runtime.getCurrentContext(), this); - return hash; - } - - @Override - public IRubyObject op_aref(ThreadContext context, IRubyObject key) { - return super.op_aref(context, key.convertToString()); - } - - @Override - public IRubyObject op_aset(ThreadContext context, IRubyObject key, IRubyObject value) { - if (!key.respondsTo("to_str")) { - throw getRuntime().newTypeError("can't convert " + key.getMetaClass() + " into String"); - } - if (!value.respondsTo("to_str") && !value.isNil()) { - throw getRuntime().newTypeError("can't convert " + value.getMetaClass() + " into String"); - } - - if (value.isNil()) { - return super.delete(context, key, org.jruby.runtime.Block.NULL_BLOCK); - } - - //return super.aset(getRuntime().newString("sadfasdF"), getRuntime().newString("sadfasdF")); - return super.op_aset(context, RuntimeHelpers.invoke(context, key, "to_str"), - value.isNil() ? getRuntime().getNil() : RuntimeHelpers.invoke(context, value, "to_str")); - } - - @JRubyMethod - @Override - public IRubyObject to_s(){ - return getRuntime().newString("ENV"); - } - } - - public static void createGlobals(ThreadContext context, Ruby runtime) { - runtime.defineGlobalConstant("TOPLEVEL_BINDING", runtime.newBinding()); - - runtime.defineGlobalConstant("TRUE", runtime.getTrue()); - runtime.defineGlobalConstant("FALSE", runtime.getFalse()); - runtime.defineGlobalConstant("NIL", runtime.getNil()); - - // define ARGV and $* for this runtime - RubyArray argvArray = runtime.newArray(); - String[] argv = runtime.getInstanceConfig().getArgv(); - for (int i = 0; i < argv.length; i++) { - argvArray.append(RubyString.newString(runtime, argv[i].getBytes())); - } - runtime.defineGlobalConstant("ARGV", argvArray); - runtime.getGlobalVariables().defineReadonly("$*", new ValueAccessor(argvArray)); - - IAccessor d = new ValueAccessor(runtime.newString( - runtime.getInstanceConfig().displayedFileName())); - runtime.getGlobalVariables().define("$PROGRAM_NAME", d); - runtime.getGlobalVariables().define("$0", d); - - // Version information: - IRubyObject version = runtime.newString(Constants.RUBY_VERSION).freeze(context); - IRubyObject release = runtime.newString(Constants.COMPILE_DATE).freeze(context); - IRubyObject platform = runtime.newString(Constants.PLATFORM).freeze(context); - IRubyObject engine = runtime.newString(Constants.ENGINE).freeze(context); - - runtime.defineGlobalConstant("RUBY_VERSION", version); - runtime.defineGlobalConstant("RUBY_PATCHLEVEL", runtime.newString(Constants.RUBY_PATCHLEVEL).freeze(context)); - runtime.defineGlobalConstant("RUBY_RELEASE_DATE", release); - runtime.defineGlobalConstant("RUBY_PLATFORM", platform); - runtime.defineGlobalConstant("RUBY_ENGINE", engine); - - runtime.defineGlobalConstant("VERSION", version); - runtime.defineGlobalConstant("RELEASE_DATE", release); - runtime.defineGlobalConstant("PLATFORM", platform); - - IRubyObject jrubyVersion = runtime.newString(Constants.VERSION).freeze(context); - runtime.defineGlobalConstant("JRUBY_VERSION", jrubyVersion); - - GlobalVariable kcodeGV = new KCodeGlobalVariable(runtime, "$KCODE", runtime.newString("NONE")); - runtime.defineVariable(kcodeGV); - runtime.defineVariable(new GlobalVariable.Copy(runtime, "$-K", kcodeGV)); - IRubyObject defaultRS = runtime.newString(runtime.getInstanceConfig().getRecordSeparator()).freeze(context); - GlobalVariable rs = new StringGlobalVariable(runtime, "$/", defaultRS); - runtime.defineVariable(rs); - runtime.setRecordSeparatorVar(rs); - runtime.getGlobalVariables().setDefaultSeparator(defaultRS); - runtime.defineVariable(new StringGlobalVariable(runtime, "$\\", runtime.getNil())); - runtime.defineVariable(new StringGlobalVariable(runtime, "$,", runtime.getNil())); - - runtime.defineVariable(new LineNumberGlobalVariable(runtime, "$.", RubyFixnum.one(runtime))); - runtime.defineVariable(new LastlineGlobalVariable(runtime, "$_")); - runtime.defineVariable(new LastExitStatusVariable(runtime, "$?")); - - runtime.defineVariable(new ErrorInfoGlobalVariable(runtime, "$!", runtime.getNil())); - runtime.defineVariable(new NonEffectiveGlobalVariable(runtime, "$=", runtime.getFalse())); - - if(runtime.getInstanceConfig().getInputFieldSeparator() == null) { - runtime.defineVariable(new GlobalVariable(runtime, "$;", runtime.getNil())); - } else { - runtime.defineVariable(new GlobalVariable(runtime, "$;", RubyRegexp.newRegexp(runtime, runtime.getInstanceConfig().getInputFieldSeparator(), 0))); - } - - Boolean verbose = runtime.getInstanceConfig().getVerbose(); - IRubyObject verboseValue = null; - if (verbose == null) { - verboseValue = runtime.getNil(); - } else if(verbose == Boolean.TRUE) { - verboseValue = runtime.getTrue(); - } else { - verboseValue = runtime.getFalse(); - } - runtime.defineVariable(new VerboseGlobalVariable(runtime, "$VERBOSE", verboseValue)); - - IRubyObject debug = runtime.newBoolean(runtime.getInstanceConfig().isDebug()); - runtime.defineVariable(new DebugGlobalVariable(runtime, "$DEBUG", debug)); - runtime.defineVariable(new DebugGlobalVariable(runtime, "$-d", debug)); - - runtime.defineVariable(new SafeGlobalVariable(runtime, "$SAFE")); - - runtime.defineVariable(new BacktraceGlobalVariable(runtime, "$@")); - - IRubyObject stdin = new RubyIO(runtime, STDIO.IN); - IRubyObject stdout = new RubyIO(runtime, STDIO.OUT); - IRubyObject stderr = new RubyIO(runtime, STDIO.ERR); - - runtime.defineVariable(new InputGlobalVariable(runtime, "$stdin", stdin)); - - runtime.defineVariable(new OutputGlobalVariable(runtime, "$stdout", stdout)); - runtime.getGlobalVariables().alias("$>", "$stdout"); - runtime.getGlobalVariables().alias("$defout", "$stdout"); - - runtime.defineVariable(new OutputGlobalVariable(runtime, "$stderr", stderr)); - runtime.getGlobalVariables().alias("$deferr", "$stderr"); - - runtime.defineGlobalConstant("STDIN", stdin); - runtime.defineGlobalConstant("STDOUT", stdout); - runtime.defineGlobalConstant("STDERR", stderr); - - runtime.defineVariable(new LoadedFeatures(runtime, "$\"")); - runtime.defineVariable(new LoadedFeatures(runtime, "$LOADED_FEATURES")); - - runtime.defineVariable(new LoadPath(runtime, "$:")); - runtime.defineVariable(new LoadPath(runtime, "$-I")); - runtime.defineVariable(new LoadPath(runtime, "$LOAD_PATH")); - - runtime.defineVariable(new MatchMatchGlobalVariable(runtime, "$&")); - runtime.defineVariable(new PreMatchGlobalVariable(runtime, "$`")); - runtime.defineVariable(new PostMatchGlobalVariable(runtime, "$'")); - runtime.defineVariable(new LastMatchGlobalVariable(runtime, "$+")); - runtime.defineVariable(new BackRefGlobalVariable(runtime, "$~")); - - // On platforms without a c-library accessable through JNA, getpid will return hashCode - // as $$ used to. Using $$ to kill processes could take down many runtimes, but by basing - // $$ on getpid() where available, we have the same semantics as MRI. - runtime.getGlobalVariables().defineReadonly("$$", new ValueAccessor(runtime.newFixnum(runtime.getPosix().getpid()))); - - // after defn of $stderr as the call may produce warnings - defineGlobalEnvConstants(runtime); - - // Fixme: Do we need the check or does Main.java not call this...they should consolidate - if (runtime.getGlobalVariables().get("$*").isNil()) { - runtime.getGlobalVariables().defineReadonly("$*", new ValueAccessor(runtime.newArray())); - } - - runtime.getGlobalVariables().defineReadonly("$-p", - new ValueAccessor(runtime.getInstanceConfig().isAssumePrinting() ? runtime.getTrue() : runtime.getNil())); - runtime.getGlobalVariables().defineReadonly("$-n", - new ValueAccessor(runtime.getInstanceConfig().isAssumeLoop() ? runtime.getTrue() : runtime.getNil())); - runtime.getGlobalVariables().defineReadonly("$-a", - new ValueAccessor(runtime.getInstanceConfig().isSplit() ? runtime.getTrue() : runtime.getNil())); - runtime.getGlobalVariables().defineReadonly("$-l", - new ValueAccessor(runtime.getInstanceConfig().isProcessLineEnds() ? runtime.getTrue() : runtime.getNil())); - - // ARGF, $< object - RubyArgsFile.initArgsFile(runtime); - } - - private static void defineGlobalEnvConstants(Ruby runtime) { - - Map environmentVariableMap = null; - OSEnvironment environment = new OSEnvironment(); - try { - environmentVariableMap = environment.getEnvironmentVariableMap(runtime); - } catch (OSEnvironmentReaderExcepton e) { - // If the environment variables are not accessible shouldn't terminate - runtime.getWarnings().warn(ID.MISCELLANEOUS, e.getMessage()); - } - - if (environmentVariableMap == null) { - // if the environment variables can't be obtained, define an empty ENV - environmentVariableMap = new HashMap(); - } - - StringOnlyRubyHash h1 = new StringOnlyRubyHash(runtime, - environmentVariableMap, runtime.getNil()); - h1.getSingletonClass().defineAnnotatedMethods(StringOnlyRubyHash.class); - runtime.defineGlobalConstant("ENV", h1); - - // Define System.getProperties() in ENV_JAVA - Map systemProps = environment.getSystemPropertiesMap(runtime); - runtime.defineGlobalConstant("ENV_JAVA", new StringOnlyRubyHash( - runtime, systemProps, runtime.getNil())); - - } - - private static class NonEffectiveGlobalVariable extends GlobalVariable { - public NonEffectiveGlobalVariable(Ruby runtime, String name, IRubyObject value) { - super(runtime, name, value); - } - - @Override - public IRubyObject set(IRubyObject value) { - runtime.getWarnings().warn(ID.INEFFECTIVE_GLOBAL, "warning: variable " + name + " is no longer effective; ignored", name); - return value; - } - - @Override - public IRubyObject get() { - runtime.getWarnings().warn(ID.INEFFECTIVE_GLOBAL, "warning: variable " + name + " is no longer effective", name); - return runtime.getFalse(); - } - } - - private static class LastExitStatusVariable extends GlobalVariable { - public LastExitStatusVariable(Ruby runtime, String name) { - super(runtime, name, runtime.getNil()); - } - - @Override - public IRubyObject get() { - IRubyObject lastExitStatus = runtime.getCurrentContext().getLastExitStatus(); - return lastExitStatus == null ? runtime.getNil() : lastExitStatus; - } - - @Override - public IRubyObject set(IRubyObject lastExitStatus) { - runtime.getCurrentContext().setLastExitStatus(lastExitStatus); - - return lastExitStatus; - } - } - - private static class MatchMatchGlobalVariable extends GlobalVariable { - public MatchMatchGlobalVariable(Ruby runtime, String name) { - super(runtime, name, runtime.getNil()); - } - - @Override - public IRubyObject get() { - return RubyRegexp.last_match(runtime.getCurrentContext().getCurrentFrame().getBackRef()); - } - } - - private static class PreMatchGlobalVariable extends GlobalVariable { - public PreMatchGlobalVariable(Ruby runtime, String name) { - super(runtime, name, runtime.getNil()); - } - - @Override - public IRubyObject get() { - return RubyRegexp.match_pre(runtime.getCurrentContext().getCurrentFrame().getBackRef()); - } - } - - private static class PostMatchGlobalVariable extends GlobalVariable { - public PostMatchGlobalVariable(Ruby runtime, String name) { - super(runtime, name, runtime.getNil()); - } - - @Override - public IRubyObject get() { - return RubyRegexp.match_post(runtime.getCurrentContext().getCurrentFrame().getBackRef()); - } - } - - private static class LastMatchGlobalVariable extends GlobalVariable { - public LastMatchGlobalVariable(Ruby runtime, String name) { - super(runtime, name, runtime.getNil()); - } - - @Override - public IRubyObject get() { - return RubyRegexp.match_last(runtime.getCurrentContext().getCurrentFrame().getBackRef()); - } - } - - private static class BackRefGlobalVariable extends GlobalVariable { - public BackRefGlobalVariable(Ruby runtime, String name) { - super(runtime, name, runtime.getNil()); - } - - @Override - public IRubyObject get() { - return RuntimeHelpers.getBackref(runtime, runtime.getCurrentContext()); - } - - @Override - public IRubyObject set(IRubyObject value) { - RuntimeHelpers.setBackref(runtime, runtime.getCurrentContext(), value); - return value; - } - } - - // Accessor methods. - - private static class LineNumberGlobalVariable extends GlobalVariable { - public LineNumberGlobalVariable(Ruby runtime, String name, RubyFixnum value) { - super(runtime, name, value); - } - - @Override - public IRubyObject set(IRubyObject value) { - RubyArgsFile.setCurrentLineNumber(runtime.getGlobalVariables().get("$<"),RubyNumeric.fix2int(value)); - return super.set(value); - } - } - - private static class ErrorInfoGlobalVariable extends GlobalVariable { - public ErrorInfoGlobalVariable(Ruby runtime, String name, IRubyObject value) { - super(runtime, name, null); - set(value); - } - - @Override - public IRubyObject set(IRubyObject value) { - if (!value.isNil() && - !runtime.getException().isInstance(value) && - !(JavaUtil.isJavaObject(value) && JavaUtil.unwrapJavaObject(value) instanceof Exception)) { - throw runtime.newTypeError("assigning non-exception to $!"); - } - - return runtime.getCurrentContext().setErrorInfo(value); - } - - @Override - public IRubyObject get() { - return runtime.getCurrentContext().getErrorInfo(); - } - } - - // FIXME: move out of this class! - public static class StringGlobalVariable extends GlobalVariable { - public StringGlobalVariable(Ruby runtime, String name, IRubyObject value) { - super(runtime, name, value); - } - - @Override - public IRubyObject set(IRubyObject value) { - if (!value.isNil() && ! (value instanceof RubyString)) { - throw runtime.newTypeError("value of " + name() + " must be a String"); - } - return super.set(value); - } - } - - public static class KCodeGlobalVariable extends GlobalVariable { - public KCodeGlobalVariable(Ruby runtime, String name, IRubyObject value) { - super(runtime, name, value); - } - - @Override - public IRubyObject get() { - return runtime.getKCode().kcode(runtime); - } - - @Override - public IRubyObject set(IRubyObject value) { - runtime.setKCode(KCode.create(runtime, value.convertToString().toString())); - return value; - } - } - - private static class SafeGlobalVariable extends GlobalVariable { - public SafeGlobalVariable(Ruby runtime, String name) { - super(runtime, name, null); - } - - @Override - public IRubyObject get() { - return runtime.newFixnum(runtime.getSafeLevel()); - } - - @Override - public IRubyObject set(IRubyObject value) { -// int level = RubyNumeric.fix2int(value); -// if (level < runtime.getSafeLevel()) { -// throw runtime.newSecurityError("tried to downgrade safe level from " + -// runtime.getSafeLevel() + " to " + level); -// } -// runtime.setSafeLevel(level); - // thread.setSafeLevel(level); - runtime.getWarnings().warn(ID.SAFE_NOT_SUPPORTED, "SAFE levels are not supported in JRuby"); - return RubyFixnum.newFixnum(runtime, runtime.getSafeLevel()); - } - } - - private static class VerboseGlobalVariable extends GlobalVariable { - public VerboseGlobalVariable(Ruby runtime, String name, IRubyObject initialValue) { - super(runtime, name, initialValue); - set(initialValue); - } - - @Override - public IRubyObject get() { - return runtime.getVerbose(); - } - - @Override - public IRubyObject set(IRubyObject newValue) { - if (newValue.isNil()) { - runtime.setVerbose(newValue); - } else { - runtime.setVerbose(runtime.newBoolean(newValue.isTrue())); - } - - return newValue; - } - } - - private static class DebugGlobalVariable extends GlobalVariable { - public DebugGlobalVariable(Ruby runtime, String name, IRubyObject initialValue) { - super(runtime, name, initialValue); - set(initialValue); - } - - @Override - public IRubyObject get() { - return runtime.getDebug(); - } - - @Override - public IRubyObject set(IRubyObject newValue) { - if (newValue.isNil()) { - runtime.setDebug(newValue); - } else { - runtime.setDebug(runtime.newBoolean(newValue.isTrue())); - } - - return newValue; - } - } - - private static class BacktraceGlobalVariable extends GlobalVariable { - public BacktraceGlobalVariable(Ruby runtime, String name) { - super(runtime, name, null); - } - - @Override - public IRubyObject get() { - IRubyObject errorInfo = runtime.getGlobalVariables().get("$!"); - IRubyObject backtrace = errorInfo.isNil() ? runtime.getNil() : errorInfo.callMethod(errorInfo.getRuntime().getCurrentContext(), "backtrace"); - //$@ returns nil if $!.backtrace is not an array - if (!(backtrace instanceof RubyArray)) { - backtrace = runtime.getNil(); - } - return backtrace; - } - - @Override - public IRubyObject set(IRubyObject value) { - if (runtime.getGlobalVariables().get("$!").isNil()) { - throw runtime.newArgumentError("$! not set."); - } - runtime.getGlobalVariables().get("$!").callMethod(value.getRuntime().getCurrentContext(), "set_backtrace", value); - return value; - } - } - - private static class LastlineGlobalVariable extends GlobalVariable { - public LastlineGlobalVariable(Ruby runtime, String name) { - super(runtime, name, null); - } - - @Override - public IRubyObject get() { - return RuntimeHelpers.getLastLine(runtime, runtime.getCurrentContext()); - } - - @Override - public IRubyObject set(IRubyObject value) { - RuntimeHelpers.setLastLine(runtime, runtime.getCurrentContext(), value); - return value; - } - } - - private static class InputGlobalVariable extends GlobalVariable { - public InputGlobalVariable(Ruby runtime, String name, IRubyObject value) { - super(runtime, name, value); - } - - @Override - public IRubyObject set(IRubyObject value) { - if (value == get()) { - return value; - } - - return super.set(value); - } - } - - private static class OutputGlobalVariable extends GlobalVariable { - public OutputGlobalVariable(Ruby runtime, String name, IRubyObject value) { - super(runtime, name, value); - } - - @Override - public IRubyObject set(IRubyObject value) { - if (value == get()) { - return value; - } - if (value instanceof RubyIO) { - RubyIO io = (RubyIO)value; - - // HACK: in order to have stdout/err act like ttys and flush always, - // we set anything assigned to stdout/stderr to sync - io.getHandler().setSync(true); - } - - if (!value.respondsTo("write")) { - throw runtime.newTypeError(name() + " must have write method, " + - value.getType().getName() + " given"); - } - - return super.set(value); - } - } - - private static class LoadPath extends ReadonlyGlobalVariable { - public LoadPath(Ruby runtime, String name) { - super(runtime, name, null); - } - - /** - * @see org.jruby.runtime.GlobalVariable#get() - */ - @Override - public IRubyObject get() { - return runtime.getLoadService().getLoadPath(); - } - } - - private static class LoadedFeatures extends ReadonlyGlobalVariable { - public LoadedFeatures(Ruby runtime, String name) { - super(runtime, name, null); - } - - /** - * @see org.jruby.runtime.GlobalVariable#get() - */ - @Override - public IRubyObject get() { - return runtime.getLoadService().getLoadedFeatures(); - } - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2006 Ola Bini <Ola.Bini@ki.se> - * Copyright (C) 2006 Tim Azzopardi <tim@tigerfive.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2007 MenTaLguY <mental@rydia.net> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; -import java.util.AbstractCollection; -import java.util.AbstractSet; -import java.util.Collection; -import java.util.Iterator; -import java.util.Map; -import java.util.NoSuchElementException; -import java.util.Set; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.javasupport.JavaUtil; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.ByteList; -import org.jruby.util.TypeConverter; - -// Design overview: -// -// RubyHash is implemented as hash table with a singly-linked list of -// RubyHash.RubyHashEntry objects for each bucket. RubyHashEntry objects -// are also kept in a doubly-linked list which reflects their insertion -// order and is used for iteration. For simplicity, this latter list is -// circular; a dummy RubyHashEntry, RubyHash.head, is used to mark the -// ends of the list. -// -// When an entry is removed from the table, it is also removed from the -// doubly-linked list. However, while the reference to the previous -// RubyHashEntry is cleared (to mark the entry as dead), the reference -// to the next RubyHashEntry is preserved so that iterators are not -// invalidated: any iterator with a reference to a dead entry can climb -// back up into the list of live entries by chasing next references until -// it finds a live entry (or head). -// -// Ordinarily, this scheme would require O(N) time to clear a hash (since -// each RubyHashEntry would need to be visited and unlinked from the -// iteration list), but RubyHash also maintains a generation count. Every -// time the hash is cleared, the doubly-linked list is simply discarded and -// the generation count incremented. Iterators check to see whether the -// generation count has changed; if it has, they reset themselves back to -// the new start of the list. -// -// This design means that iterators are never invalidated by changes to the -// hashtable, and they do not need to modify the structure during their -// lifecycle. -// - -/** Implementation of the Hash class. - * - * Concurrency: no synchronization is required among readers, but - * all users must synchronize externally with writers. - * - */ -@JRubyClass(name = "Hash", include="Enumerable") -public class RubyHash extends RubyObject implements Map { - - public static RubyClass createHashClass(Ruby runtime) { - RubyClass hashc = runtime.defineClass("Hash", runtime.getObject(), HASH_ALLOCATOR); - runtime.setHash(hashc); - hashc.index = ClassIndex.HASH; - hashc.kindOf = new RubyModule.KindOf() { - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyHash; - } - }; - - hashc.includeModule(runtime.getEnumerable()); - - hashc.defineAnnotatedMethods(RubyHash.class); - - return hashc; - } - - private final static ObjectAllocator HASH_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyHash(runtime, klass); - } - }; - - public int getNativeTypeIndex() { - return ClassIndex.HASH; - } - - /** rb_hash_s_create - * - */ - @JRubyMethod(name = "[]", rest = true, frame = true, meta = true) - public static IRubyObject create(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - RubyClass klass = (RubyClass) recv; - Ruby runtime = context.getRuntime(); - RubyHash hash; - - if (args.length == 1) { - IRubyObject tmp = TypeConverter.convertToTypeWithCheck( - args[0], runtime.getHash(), MethodIndex.TO_HASH, "to_hash"); - - if (!tmp.isNil()) { - RubyHash otherHash = (RubyHash) tmp; - return new RubyHash(runtime, klass, otherHash); - } - } - - if ((args.length & 1) != 0) { - throw runtime.newArgumentError("odd number of args for Hash"); - } - - hash = (RubyHash)klass.allocate(); - for (int i=0; i < args.length; i+=2) hash.op_aset(context, args[i], args[i+1]); - - return hash; - } - - /** rb_hash_new - * - */ - public static final RubyHash newHash(Ruby runtime) { - return new RubyHash(runtime); - } - - /** rb_hash_new - * - */ - public static final RubyHash newHash(Ruby runtime, Map valueMap, IRubyObject defaultValue) { - assert defaultValue != null; - - return new RubyHash(runtime, valueMap, defaultValue); - } - - private RubyHashEntry[] table; - private int size = 0; - private int threshold; - - private static final int PROCDEFAULT_HASH_F = 1 << 10; - - private IRubyObject ifNone; - - private RubyHash(Ruby runtime, RubyClass klass, RubyHash other) { - super(runtime, klass); - this.ifNone = runtime.getNil(); - threshold = INITIAL_THRESHOLD; - table = other.internalCopyTable(head); - size = other.size; - } - - public RubyHash(Ruby runtime, RubyClass klass) { - super(runtime, klass); - this.ifNone = runtime.getNil(); - alloc(); - } - - public RubyHash(Ruby runtime) { - this(runtime, runtime.getNil()); - } - - public RubyHash(Ruby runtime, IRubyObject defaultValue) { - super(runtime, runtime.getHash()); - this.ifNone = defaultValue; - alloc(); - } - - /* - * Constructor for internal usage (mainly for Array#|, Array#&, Array#- and Array#uniq) - * it doesn't initialize ifNone field - */ - RubyHash(Ruby runtime, boolean objectSpace) { - super(runtime, runtime.getHash(), objectSpace); - alloc(); - } - - // TODO should this be deprecated ? (to be efficient, internals should deal with RubyHash directly) - public RubyHash(Ruby runtime, Map valueMap, IRubyObject defaultValue) { - super(runtime, runtime.getHash()); - this.ifNone = defaultValue; - alloc(); - - for (Iterator iter = valueMap.entrySet().iterator();iter.hasNext();) { - Map.Entry e = (Map.Entry)iter.next(); - internalPut((IRubyObject)e.getKey(), (IRubyObject)e.getValue()); - } - } - - private final void alloc() { - threshold = INITIAL_THRESHOLD; - generation++; - head.nextAdded = head.prevAdded = head; - table = new RubyHashEntry[MRI_HASH_RESIZE ? MRI_INITIAL_CAPACITY : JAVASOFT_INITIAL_CAPACITY]; - } - - /* ============================ - * Here are hash internals - * (This could be extracted to a separate class but it's not too large though) - * ============================ - */ - - private static final int MRI_PRIMES[] = { - 8 + 3, 16 + 3, 32 + 5, 64 + 3, 128 + 3, 256 + 27, 512 + 9, 1024 + 9, 2048 + 5, 4096 + 3, - 8192 + 27, 16384 + 43, 32768 + 3, 65536 + 45, 131072 + 29, 262144 + 3, 524288 + 21, 1048576 + 7, - 2097152 + 17, 4194304 + 15, 8388608 + 9, 16777216 + 43, 33554432 + 35, 67108864 + 15, - 134217728 + 29, 268435456 + 3, 536870912 + 11, 1073741824 + 85, 0 - }; - - private static final int JAVASOFT_INITIAL_CAPACITY = 8; // 16 ? - private static final int MRI_INITIAL_CAPACITY = MRI_PRIMES[0]; - - private static final int INITIAL_THRESHOLD = JAVASOFT_INITIAL_CAPACITY - (JAVASOFT_INITIAL_CAPACITY >> 2); - private static final int MAXIMUM_CAPACITY = 1 << 30; - - private static final RubyHashEntry NO_ENTRY = new RubyHashEntry(); - private int generation = 0; // generation count for O(1) clears - private final RubyHashEntry head = new RubyHashEntry(); - { head.prevAdded = head.nextAdded = head; } - - static final class RubyHashEntry implements Map.Entry { - private IRubyObject key; - private IRubyObject value; - private RubyHashEntry next; - private RubyHashEntry prevAdded; - private RubyHashEntry nextAdded; - private int hash; - - RubyHashEntry() { - key = NEVER; - } - - RubyHashEntry(int h, IRubyObject k, IRubyObject v, RubyHashEntry e, RubyHashEntry head) { - key = k; value = v; next = e; hash = h; - prevAdded = head.prevAdded; - nextAdded = head; - nextAdded.prevAdded = this; - prevAdded.nextAdded = this; - } - - public void detach() { - if (prevAdded != null) { - prevAdded.nextAdded = nextAdded; - nextAdded.prevAdded = prevAdded; - prevAdded = null; - } - } - - public boolean isLive() { - return prevAdded != null; - } - - public Object getKey() { - return key; - } - public Object getJavaifiedKey(){ - return JavaUtil.convertRubyToJava(key); - } - - public Object getValue() { - return value; - } - public Object getJavaifiedValue() { - return JavaUtil.convertRubyToJava(value); - } - - public Object setValue(Object value) { - IRubyObject oldValue = this.value; - if (value instanceof IRubyObject) { - this.value = (IRubyObject)value; - } else { - throw new UnsupportedOperationException("directEntrySet() doesn't support setValue for non IRubyObject instance entries, convert them manually or use entrySet() instead"); - } - return oldValue; - } - - public boolean equals(Object other){ - if(!(other instanceof RubyHashEntry)) return false; - RubyHashEntry otherEntry = (RubyHashEntry)other; - if(key == otherEntry.key || key.eql(otherEntry.key)){ - if(value == otherEntry.value || value.equals(otherEntry.value)) return true; - } - return false; - } - - public int hashCode(){ - return key.hashCode() ^ value.hashCode(); - } - } - - private static int JavaSoftHashValue(int h) { - h ^= (h >>> 20) ^ (h >>> 12); - return h ^ (h >>> 7) ^ (h >>> 4); - } - - private static int JavaSoftBucketIndex(final int h, final int length) { - return h & (length - 1); - } - - private static int MRIHashValue(int h) { - return h & HASH_SIGN_BIT_MASK; - } - - private static final int HASH_SIGN_BIT_MASK = ~(1 << 31); - private static int MRIBucketIndex(final int h, final int length) { - return (h % length); - } - - private final void resize(int newCapacity) { - final RubyHashEntry[] oldTable = table; - final RubyHashEntry[] newTable = new RubyHashEntry[newCapacity]; - for (int j = 0; j < oldTable.length; j++) { - RubyHashEntry entry = oldTable[j]; - oldTable[j] = null; - while (entry != null) { - RubyHashEntry next = entry.next; - int i = bucketIndex(entry.hash, newCapacity); - entry.next = newTable[i]; - newTable[i] = entry; - entry = next; - } - } - table = newTable; - } - - private final void JavaSoftCheckResize() { - if (size > threshold) { - int oldCapacity = table.length; - if (oldCapacity == MAXIMUM_CAPACITY) { - threshold = Integer.MAX_VALUE; - return; - } - int newCapacity = table.length << 1; - resize(newCapacity); - threshold = newCapacity - (newCapacity >> 2); - } - } - - private static final int MIN_CAPA = 8; - private static final int ST_DEFAULT_MAX_DENSITY = 5; - private final void MRICheckResize() { - if (size / table.length > ST_DEFAULT_MAX_DENSITY) { - int forSize = table.length + 1; // size + 1; - for (int i=0, newCapacity = MIN_CAPA; i < MRI_PRIMES.length; i++, newCapacity <<= 1) { - if (newCapacity > forSize) { - resize(MRI_PRIMES[i]); - return; - } - } - return; // suboptimal for large hashes (> 1073741824 + 85 entries) not very likely to happen - } - } - // ------------------------------ - private static boolean MRI_HASH = true; - private static boolean MRI_HASH_RESIZE = true; - - private static int hashValue(final int h) { - return MRI_HASH ? MRIHashValue(h) : JavaSoftHashValue(h); - } - - private static int bucketIndex(final int h, final int length) { - return MRI_HASH ? MRIBucketIndex(h, length) : JavaSoftBucketIndex(h, length); - } - - private void checkResize() { - if (MRI_HASH_RESIZE) MRICheckResize(); else JavaSoftCheckResize(); - } - // ------------------------------ - public static long collisions = 0; - - // put implementation - - private final void internalPut(final IRubyObject key, final IRubyObject value) { - internalPut(key, value, true); - } - - private final void internalPut(final IRubyObject key, final IRubyObject value, final boolean checkForExisting) { - checkResize(); - final int hash = hashValue(key.hashCode()); - final int i = bucketIndex(hash, table.length); - - // if (table[i] != null) collisions++; - - if (checkForExisting) { - for (RubyHashEntry entry = table[i]; entry != null; entry = entry.next) { - IRubyObject k; - if (entry.hash == hash && ((k = entry.key) == key || key.eql(k))) { - entry.value = value; - return; - } - } - } - - table[i] = new RubyHashEntry(hash, key, value, table[i], head); - size++; - } - - // get implementation - - private final IRubyObject internalGet(IRubyObject key) { // specialized for value - return internalGetEntry(key).value; - } - - private final RubyHashEntry internalGetEntry(IRubyObject key) { - final int hash = hashValue(key.hashCode()); - for (RubyHashEntry entry = table[bucketIndex(hash, table.length)]; entry != null; entry = entry.next) { - IRubyObject k; - if (entry.hash == hash && ((k = entry.key) == key || key.eql(k))) return entry; - } - return NO_ENTRY; - } - - // delete implementation - - - private final RubyHashEntry internalDelete(final IRubyObject key) { - return internalDelete(hashValue(key.hashCode()), MATCH_KEY, key); - } - - private final RubyHashEntry internalDeleteEntry(final RubyHashEntry entry) { - // n.b. we need to recompute the hash in case the key object was modified - return internalDelete(hashValue(entry.key.hashCode()), MATCH_ENTRY, entry); - } - - private final RubyHashEntry internalDelete(final int hash, final EntryMatchType matchType, final Object obj) { - final int i = bucketIndex(hash, table.length); - - RubyHashEntry entry = table[i]; - if (entry != null) { - RubyHashEntry prior = null; - for (; entry != null; prior = entry, entry = entry.next) { - if (entry.hash == hash && matchType.matches(entry, obj)) { - if (prior != null) { - prior.next = entry.next; - } else { - table[i] = entry.next; - } - entry.detach(); - size--; - return entry; - } - } - } - - return NO_ENTRY; - } - - private static abstract class EntryMatchType { - public abstract boolean matches(final RubyHashEntry entry, final Object obj); - } - - private static final EntryMatchType MATCH_KEY = new EntryMatchType() { - public boolean matches(final RubyHashEntry entry, final Object obj) { - final IRubyObject key = entry.key; - return obj == key || (((IRubyObject)obj).eql(key)); - } - }; - - private static final EntryMatchType MATCH_ENTRY = new EntryMatchType() { - public boolean matches(final RubyHashEntry entry, final Object obj) { - return entry.equals(obj); - } - }; - - private final RubyHashEntry[] internalCopyTable(RubyHashEntry destHead) { - RubyHashEntry[]newTable = new RubyHashEntry[table.length]; - - for (RubyHashEntry entry = head.nextAdded; entry != head; entry = entry.nextAdded) { - int i = bucketIndex(entry.hash, table.length); - newTable[i] = new RubyHashEntry(entry.hash, entry.key, entry.value, newTable[i], destHead); - } - return newTable; - } - - public static abstract class Visitor { - public abstract void visit(IRubyObject key, IRubyObject value); - } - - public void visitAll(Visitor visitor) { - int startGeneration = generation; - for (RubyHashEntry entry = head.nextAdded; entry != head; entry = entry.nextAdded) { - if (startGeneration != generation) { - startGeneration = generation; - entry = head.nextAdded; - if (entry == head) break; - } - if (entry.isLive()) visitor.visit(entry.key, entry.value); - } - } - - /* ============================ - * End of hash internals - * ============================ - */ - - /* ================ - * Instance Methods - * ================ - */ - - /** rb_hash_initialize - * - */ - @JRubyMethod(name = "initialize", optional = 1, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, final Block block) { - modify(); - - if (block.isGiven()) { - if (args.length > 0) throw getRuntime().newArgumentError("wrong number of arguments"); - ifNone = getRuntime().newProc(Block.Type.PROC, block); - flags |= PROCDEFAULT_HASH_F; - } else { - Arity.checkArgumentCount(getRuntime(), args, 0, 1); - if (args.length == 1) ifNone = args[0]; - } - return this; - } - - /** rb_hash_default - * - */ - @Deprecated - public IRubyObject default_value_get(ThreadContext context, IRubyObject[] args) { - switch (args.length) { - case 0: return default_value_get(context); - case 1: return default_value_get(context, args[0]); - default: throw context.getRuntime().newArgumentError(args.length, 1); - } - } - @JRubyMethod(name = "default", frame = true) - public IRubyObject default_value_get(ThreadContext context) { - if ((flags & PROCDEFAULT_HASH_F) != 0) { - return getRuntime().getNil(); - } - return ifNone; - } - @JRubyMethod(name = "default", frame = true) - public IRubyObject default_value_get(ThreadContext context, IRubyObject arg) { - if ((flags & PROCDEFAULT_HASH_F) != 0) { - return RuntimeHelpers.invoke(context, ifNone, "call", this, arg); - } - return ifNone; - } - - /** rb_hash_set_default - * - */ - @JRubyMethod(name = "default=", required = 1) - public IRubyObject default_value_set(final IRubyObject defaultValue) { - modify(); - - ifNone = defaultValue; - flags &= ~PROCDEFAULT_HASH_F; - - return ifNone; - } - - /** rb_hash_default_proc - * - */ - @JRubyMethod(name = "default_proc", frame = true) - public IRubyObject default_proc() { - return (flags & PROCDEFAULT_HASH_F) != 0 ? ifNone : getRuntime().getNil(); - } - - /** rb_hash_modify - * - */ - public void modify() { - testFrozen("hash"); - if (isTaint() && getRuntime().getSafeLevel() >= 4) { - throw getRuntime().newSecurityError("Insecure: can't modify hash"); - } - } - - /** inspect_hash - * - */ - private IRubyObject inspectHash(final ThreadContext context) { - final ByteList buffer = new ByteList(); - buffer.append('{'); - final boolean[] firstEntry = new boolean[1]; - - firstEntry[0] = true; - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - if (!firstEntry[0]) buffer.append(',').append(' '); - - buffer.append(inspect(context, key).getByteList()); - buffer.append('=').append('>'); - buffer.append(inspect(context, value).getByteList()); - firstEntry[0] = false; - } - }); - buffer.append('}'); - return getRuntime().newString(buffer); - } - - /** rb_hash_inspect - * - */ - @JRubyMethod(name = "inspect") - public IRubyObject inspect(ThreadContext context) { - if (size == 0) return getRuntime().newString("{}"); - if (getRuntime().isInspecting(this)) return getRuntime().newString("{...}"); - - try { - getRuntime().registerInspecting(this); - return inspectHash(context); - } finally { - getRuntime().unregisterInspecting(this); - } - } - - /** rb_hash_size - * - */ - @JRubyMethod(name = {"size", "length"}) - public RubyFixnum rb_size() { - return getRuntime().newFixnum(size); - } - - /** rb_hash_empty_p - * - */ - @JRubyMethod(name = "empty?") - public RubyBoolean empty_p() { - return size == 0 ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - /** rb_hash_to_a - * - */ - @JRubyMethod(name = "to_a") - public RubyArray to_a() { - final Ruby runtime = getRuntime(); - final RubyArray result = RubyArray.newArray(runtime, size); - - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - result.append(RubyArray.newArray(runtime, key, value)); - } - }); - - result.setTaint(isTaint()); - return result; - } - - /** rb_hash_to_s & to_s_hash - * - */ - @JRubyMethod(name = "to_s") - public IRubyObject to_s() { - if (getRuntime().isInspecting(this)) return getRuntime().newString("{...}"); - try { - getRuntime().registerInspecting(this); - return to_a().to_s(); - } finally { - getRuntime().unregisterInspecting(this); - } - } - - /** rb_hash_rehash - * - */ - @JRubyMethod(name = "rehash") - public RubyHash rehash() { - modify(); - final RubyHashEntry[] oldTable = table; - final RubyHashEntry[] newTable = new RubyHashEntry[oldTable.length]; - for (int j = 0; j < oldTable.length; j++) { - RubyHashEntry entry = oldTable[j]; - oldTable[j] = null; - while (entry != null) { - RubyHashEntry next = entry.next; - entry.hash = entry.key.hashCode(); // update the hash value - int i = bucketIndex(entry.hash, newTable.length); - entry.next = newTable[i]; - newTable[i] = entry; - entry = next; - } - } - table = newTable; - return this; - } - - /** rb_hash_to_hash - * - */ - @JRubyMethod(name = "to_hash") - public RubyHash to_hash() { - return this; - } - - public RubyHash convertToHash() { - return this; - } - - public final void fastASet(IRubyObject key, IRubyObject value) { - internalPut(key, value); - } - - @Deprecated - public IRubyObject op_aset(IRubyObject key, IRubyObject value) { - return op_aset(getRuntime().getCurrentContext(), key, value); - } - - /** rb_hash_aset - * - */ - @JRubyMethod(name = {"[]=", "store"}, required = 2) - public IRubyObject op_aset(ThreadContext context, IRubyObject key, IRubyObject value) { - modify(); - - if (!(key instanceof RubyString)) { - internalPut(key, value); - } else { - final RubyHashEntry entry = internalGetEntry(key); - if (entry != NO_ENTRY) { - entry.value = value; - } else { - RubyString realKey = (RubyString)key; - - if (!realKey.isFrozen()) { - realKey = realKey.strDup(context.getRuntime(), realKey.getMetaClass().getRealClass());; - realKey.setFrozen(true); - } - - internalPut(realKey, value, false); - } - } - - return value; - } - - /** - * Note: this is included as a compatibility measure for AR-JDBC - * @deprecated use RubyHash.op_aset instead - */ - public IRubyObject aset(IRubyObject key, IRubyObject value) { - return op_aset(getRuntime().getCurrentContext(), key, value); - } - - /** - * Note: this is included as a compatibility measure for Mongrel+JRuby - * @deprecated use RubyHash.op_aref instead - */ - public IRubyObject aref(IRubyObject key) { - return op_aref(getRuntime().getCurrentContext(), key); - } - - public final IRubyObject fastARef(IRubyObject key) { // retuns null when not found to avoid unnecessary getRuntime().getNil() call - return internalGet(key); - } - - /** rb_hash_aref - * - */ - @JRubyMethod(name = "[]", required = 1) - public IRubyObject op_aref(ThreadContext context, IRubyObject key) { - IRubyObject value; - return ((value = internalGet(key)) == null) ? callMethod(context, MethodIndex.DEFAULT, "default", key) : value; - } - - /** rb_hash_fetch - * - */ - @JRubyMethod(name = "fetch", required = 1, optional = 1, frame = true) - public IRubyObject fetch(ThreadContext context, IRubyObject[] args, Block block) { - if (args.length == 2 && block.isGiven()) { - getRuntime().getWarnings().warn(ID.BLOCK_BEATS_DEFAULT_VALUE, "block supersedes default value argument"); - } - - IRubyObject value; - if ((value = internalGet(args[0])) == null) { - if (block.isGiven()) return block.yield(context, args[0]); - if (args.length == 1) throw getRuntime().newIndexError("key not found"); - return args[1]; - } - return value; - } - - /** rb_hash_has_key - * - */ - @JRubyMethod(name = {"has_key?", "key?", "include?", "member?"}, required = 1) - public RubyBoolean has_key_p(IRubyObject key) { - return internalGetEntry(key) == NO_ENTRY ? getRuntime().getFalse() : getRuntime().getTrue(); - } - - private class Found extends RuntimeException {} - - private boolean hasValue(final ThreadContext context, final IRubyObject expected) { - try { - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - if (equalInternal(context, value, expected)) { - throw new Found(); - } - } - }); - return false; - } catch (Found found) { - return true; - } - } - - /** rb_hash_has_value - * - */ - @JRubyMethod(name = {"has_value?", "value?"}, required = 1) - public RubyBoolean has_value_p(ThreadContext context, IRubyObject expected) { - return getRuntime().newBoolean(hasValue(context, expected)); - } - - /** rb_hash_each - * - */ - @JRubyMethod(name = "each", frame = true) - public RubyHash each(final ThreadContext context, final Block block) { - final Ruby runtime = getRuntime(); - - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - // rb_assoc_new equivalent - block.yield(context, RubyArray.newArray(runtime, key, value), null, null, false); - } - }); - - return this; - } - - /** rb_hash_each_pair - * - */ - @JRubyMethod(name = "each_pair", frame = true) - public RubyHash each_pair(final ThreadContext context, final Block block) { - final Ruby runtime = getRuntime(); - - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - // rb_yield_values(2,...) equivalent - block.yield(context, RubyArray.newArray(runtime, key, value), null, null, true); - } - }); - - return this; - } - - /** rb_hash_each_value - * - */ - @JRubyMethod(name = "each_value", frame = true) - public RubyHash each_value(final ThreadContext context, final Block block) { - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - block.yield(context, value); - } - }); - - return this; - } - - /** rb_hash_each_key - * - */ - @JRubyMethod(name = "each_key", frame = true) - public RubyHash each_key(final ThreadContext context, final Block block) { - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - block.yield(context, key); - } - }); - - return this; - } - - /** rb_hash_sort - * - */ - @JRubyMethod(name = "sort", frame = true) - public RubyArray sort(Block block) { - return to_a().sort_bang(block); - } - - private static class FoundKey extends RuntimeException { - public IRubyObject key; - FoundKey(IRubyObject key) { - super(); - this.key = key; - } - } - - /** rb_hash_index - * - */ - @JRubyMethod(name = "index", required = 1) - public IRubyObject index(ThreadContext context, IRubyObject expected) { - IRubyObject key = internalIndex(context, expected); - if (key != null) { - return key; - } else { - return getRuntime().getNil(); - } - } - - private IRubyObject internalIndex(final ThreadContext context, final IRubyObject expected) { - try { - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - if (equalInternal(context, value, expected)) { - throw new FoundKey(key); - } - } - }); - return null; - } catch (FoundKey found) { - return found.key; - } - } - - /** rb_hash_indexes - * - */ - @JRubyMethod(name = {"indexes", "indices"}, rest = true) - public RubyArray indices(ThreadContext context, IRubyObject[] indices) { - return values_at(context, indices); - } - - /** rb_hash_keys - * - */ - @JRubyMethod(name = "keys") - public RubyArray keys() { - final Ruby runtime = getRuntime(); - final RubyArray keys = RubyArray.newArray(runtime, size); - - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - keys.append(key); - } - }); - - return keys; - } - - /** rb_hash_values - * - */ - @JRubyMethod(name = "values") - public RubyArray rb_values() { - final RubyArray values = RubyArray.newArray(getRuntime(), size); - - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - values.append(value); - } - }); - - return values; - } - - /** rb_hash_equal - * - */ - - private static final boolean EQUAL_CHECK_DEFAULT_VALUE = false; - - private static class Mismatch extends RuntimeException {} - - @Override - @JRubyMethod(name = "==", required = 1) - public IRubyObject op_equal(final ThreadContext context, final IRubyObject other) { - if (this == other) return getRuntime().getTrue(); - if (!(other instanceof RubyHash)) { - if (other.respondsTo("to_hash") && equalInternal(context, other, this)) return getRuntime().getTrue(); - return getRuntime().getFalse(); - } - - final RubyHash otherHash = (RubyHash)other; - if (size != otherHash.size) return getRuntime().getFalse(); - - final Ruby runtime = getRuntime(); - - if (EQUAL_CHECK_DEFAULT_VALUE) { - if (!equalInternal(context, ifNone, otherHash.ifNone) && - (flags & PROCDEFAULT_HASH_F) != (otherHash.flags & PROCDEFAULT_HASH_F)) return runtime.getFalse(); - } - - try { - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - IRubyObject otherValue = otherHash.internalGet(key); - if (otherValue == null || !equalInternal(context, value, otherValue)) throw new Mismatch(); - } - }); - return runtime.getTrue(); - } catch (Mismatch e) { - return runtime.getFalse(); - } - } - - /** rb_hash_shift - * - */ - @JRubyMethod(name = "shift") - public IRubyObject shift(ThreadContext context) { - modify(); - - RubyHashEntry entry = head.nextAdded; - if (entry != head) { - RubyArray result = RubyArray.newArray(getRuntime(), entry.key, entry.value); - internalDeleteEntry(entry); - return result; - } - - if ((flags & PROCDEFAULT_HASH_F) != 0) { - return RuntimeHelpers.invoke(context, ifNone, "call", this, getRuntime().getNil()); - } else { - return ifNone; - } - } - - public final boolean fastDelete(IRubyObject key) { - return internalDelete(key) != NO_ENTRY; - } - - /** rb_hash_delete - * - */ - @JRubyMethod(name = "delete", required = 1, frame = true) - public IRubyObject delete(ThreadContext context, IRubyObject key, Block block) { - modify(); - - final RubyHashEntry entry = internalDelete(key); - if (entry != NO_ENTRY) return entry.value; - - if (block.isGiven()) return block.yield(context, key); - return getRuntime().getNil(); - } - - /** rb_hash_select - * - */ - @JRubyMethod(name = "select", frame = true) - public IRubyObject select(final ThreadContext context, final Block block) { - final RubyArray result = getRuntime().newArray(); - final Ruby runtime = getRuntime(); - - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - if (block.yield(context, runtime.newArray(key, value), null, null, true).isTrue()) { - result.append(runtime.newArray(key, value)); - } - } - }); - - return result; - } - - /** rb_hash_delete_if - * - */ - @JRubyMethod(name = "delete_if", frame = true) - public RubyHash delete_if(final ThreadContext context, final Block block) { - modify(); - - final Ruby runtime = getRuntime(); - final RubyHash self = this; - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - if (block.yield(context, RubyArray.newArray(runtime, key, value), null, null, true).isTrue()) { - self.delete(context, key, block); - } - } - }); - - return this; - } - - /** rb_hash_reject - * - */ - @JRubyMethod(name = "reject", frame = true) - public RubyHash reject(ThreadContext context, Block block) { - return ((RubyHash)dup()).delete_if(context, block); - } - - /** rb_hash_reject_bang - * - */ - @JRubyMethod(name = "reject!", frame = true) - public IRubyObject reject_bang(ThreadContext context, Block block) { - int n = size; - delete_if(context, block); - if (n == size) return getRuntime().getNil(); - return this; - } - - /** rb_hash_clear - * - */ - @JRubyMethod(name = "clear") - public RubyHash rb_clear() { - modify(); - - if (size > 0) { - alloc(); - size = 0; - } - - return this; - } - - /** rb_hash_invert - * - */ - @JRubyMethod(name = "invert") - public RubyHash invert(final ThreadContext context) { - final RubyHash result = newHash(getRuntime()); - - visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - result.op_aset(context, value, key); - } - }); - - return result; - } - - /** rb_hash_update - * - */ - @JRubyMethod(name = {"merge!", "update"}, required = 1, frame = true) - public RubyHash merge_bang(final ThreadContext context, final IRubyObject other, final Block block) { - modify(); - - final Ruby runtime = getRuntime(); - final RubyHash otherHash = other.convertToHash(); - final RubyHash self = this; - otherHash.visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - if (block.isGiven()) { - IRubyObject existing = self.internalGet(key); - if (existing != null) - value = block.yield(context, RubyArray.newArrayNoCopy(runtime, new IRubyObject[]{key, existing, value})); - } - self.op_aset(context, key, value); - } - }); - - return this; - } - - /** rb_hash_merge - * - */ - @JRubyMethod(name = "merge", required = 1, frame = true) - public RubyHash merge(ThreadContext context, IRubyObject other, Block block) { - return ((RubyHash)dup()).merge_bang(context, other, block); - } - - /** rb_hash_replace - * - */ - @JRubyMethod(name = "initialize_copy", required = 1, visibility = Visibility.PRIVATE) - public RubyHash initialize_copy(ThreadContext context, IRubyObject other) { - return replace(context, other); - } - - /** rb_hash_replace - * - */ - @JRubyMethod(name = "replace", required = 1) - public RubyHash replace(final ThreadContext context, IRubyObject other) { - final RubyHash otherHash = other.convertToHash(); - - if (this == otherHash) return this; - - rb_clear(); - - final RubyHash self = this; - otherHash.visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - self.op_aset(context, key, value); - } - }); - - ifNone = otherHash.ifNone; - - if ((otherHash.flags & PROCDEFAULT_HASH_F) != 0) { - flags |= PROCDEFAULT_HASH_F; - } else { - flags &= ~PROCDEFAULT_HASH_F; - } - - return this; - } - - /** rb_hash_values_at - * - */ - @JRubyMethod(name = "values_at", rest = true) - public RubyArray values_at(ThreadContext context, IRubyObject[] args) { - RubyArray result = RubyArray.newArray(getRuntime(), args.length); - for (int i = 0; i < args.length; i++) { - result.append(op_aref(context, args[i])); - } - return result; - } - - public boolean hasDefaultProc() { - return (flags & PROCDEFAULT_HASH_F) != 0; - } - - public IRubyObject getIfNone(){ - return ifNone; - } - - private static class VisitorIOException extends RuntimeException { - VisitorIOException(Throwable cause) { - super(cause); - } - } - - // FIXME: Total hack to get flash in Rails marshalling/unmarshalling in session ok...We need - // to totally change marshalling to work with overridden core classes. - public static void marshalTo(final RubyHash hash, final MarshalStream output) throws IOException { - output.registerLinkTarget(hash); - output.writeInt(hash.size); - try { - hash.visitAll(new Visitor() { - public void visit(IRubyObject key, IRubyObject value) { - try { - output.dumpObject(key); - output.dumpObject(value); - } catch (IOException e) { - throw new VisitorIOException(e); - } - } - }); - } catch (VisitorIOException e) { - throw (IOException)e.getCause(); - } - - if (!hash.ifNone.isNil()) output.dumpObject(hash.ifNone); - } - - public static RubyHash unmarshalFrom(UnmarshalStream input, boolean defaultValue) throws IOException { - RubyHash result = newHash(input.getRuntime()); - input.registerLinkTarget(result); - int size = input.unmarshalInt(); - ThreadContext context = input.getRuntime().getCurrentContext(); - for (int i = 0; i < size; i++) { - result.op_aset(context, input.unmarshalObject(), input.unmarshalObject()); - } - if (defaultValue) result.default_value_set(input.unmarshalObject()); - return result; - } - - public Class getJavaClass() { - return Map.class; - } - - // Satisfy java.util.Set interface (for Java integration) - - public int size() { - return size; - } - - public boolean isEmpty() { - return size == 0; - } - - public boolean containsKey(Object key) { - return internalGet(JavaUtil.convertJavaToRuby(getRuntime(), key)) != null; - } - - public boolean containsValue(Object value) { - return hasValue(getRuntime().getCurrentContext(), JavaUtil.convertJavaToRuby(getRuntime(), value)); - } - - public Object get(Object key) { - return JavaUtil.convertRubyToJava(internalGet(JavaUtil.convertJavaToRuby(getRuntime(), key))); - } - - public Object put(Object key, Object value) { - internalPut(JavaUtil.convertJavaToRuby(getRuntime(), key), JavaUtil.convertJavaToRuby(getRuntime(), value)); - return value; - } - - public Object remove(Object key) { - IRubyObject rubyKey = JavaUtil.convertJavaToRuby(getRuntime(), key); - return internalDelete(rubyKey).value; - } - - public void putAll(Map map) { - Ruby runtime = getRuntime(); - for (Iterator iter = map.keySet().iterator(); iter.hasNext();) { - Object key = iter.next(); - internalPut(JavaUtil.convertJavaToRuby(runtime, key), JavaUtil.convertJavaToRuby(runtime, map.get(key))); - } - } - - public void clear() { - rb_clear(); - } - - public boolean equals(Object other) { - if (!(other instanceof RubyHash)) return false; - if (this == other) return true; - return op_equal(getRuntime().getCurrentContext(), (RubyHash)other).isTrue() ? true : false; - } - - public Set keySet() { - return new BaseSet(KEY_VIEW); - } - - public Set directKeySet() { - return new BaseSet(DIRECT_KEY_VIEW); - } - - public Collection values() { - return new BaseCollection(VALUE_VIEW); - } - - public Collection directValues() { - return new BaseCollection(DIRECT_VALUE_VIEW); - } - - public Set entrySet() { - return new BaseSet(ENTRY_VIEW); - } - - public Set directEntrySet() { - return new BaseSet(DIRECT_ENTRY_VIEW); - } - - private class BaseSet extends AbstractSet { - final EntryView view; - - public BaseSet(EntryView view) { - this.view = view; - } - - public Iterator iterator() { - return new BaseIterator(view); - } - - public boolean contains(Object o) { - return view.contains(RubyHash.this, o); - } - - public void clear() { - RubyHash.this.clear(); - } - - public int size() { - return RubyHash.this.size; - } - - public boolean remove(Object o) { - return view.remove(RubyHash.this, o); - } - } - - private class BaseCollection extends AbstractCollection { - final EntryView view; - - public BaseCollection(EntryView view) { - this.view = view; - } - - public Iterator iterator() { - return new BaseIterator(view); - } - - public boolean contains(Object o) { - return view.contains(RubyHash.this, o); - } - - public void clear() { - RubyHash.this.clear(); - } - - public int size() { - return RubyHash.this.size; - } - - public boolean remove(Object o) { - return view.remove(RubyHash.this, o); - } - } - - private class BaseIterator implements Iterator { - final private EntryView view; - private RubyHashEntry entry; - private boolean peeking; - private int startGeneration; - - public BaseIterator(EntryView view) { - this.view = view; - this.entry = head; - this.startGeneration = generation; - } - - private void advance(boolean consume) { - if (!peeking) { - do { - if (startGeneration != generation) { - startGeneration = generation; - entry = head; - } - entry = entry.nextAdded; - } while (entry != head && !entry.isLive()); - } - peeking = !consume; - } - - public Object next() { - advance(true); - if (entry == head) { - peeking = true; // remain where we are - throw new NoSuchElementException(); - } - return view.convertEntry(getRuntime(), entry); - } - - // once hasNext has been called, we commit to next() returning - // the entry it found, even if it were subsequently deleted - public boolean hasNext() { - advance(false); - return entry != head; - } - - public void remove() { - if (entry == head) { - throw new IllegalStateException("Iterator out of range"); - } - internalDeleteEntry(entry); - } - } - - private static abstract class EntryView { - public abstract Object convertEntry(Ruby runtime, RubyHashEntry value); - public abstract boolean contains(RubyHash hash, Object o); - public abstract boolean remove(RubyHash hash, Object o); - } - - private static final EntryView DIRECT_KEY_VIEW = new EntryView() { - public Object convertEntry(Ruby runtime, RubyHashEntry entry) { - return entry.key; - } - public boolean contains(RubyHash hash, Object o) { - if (!(o instanceof IRubyObject)) return false; - return hash.internalGet((IRubyObject)o) != null; - } - public boolean remove(RubyHash hash, Object o) { - if (!(o instanceof IRubyObject)) return false; - return hash.internalDelete((IRubyObject)o) != NO_ENTRY; - } - }; - - private static final EntryView KEY_VIEW = new EntryView() { - public Object convertEntry(Ruby runtime, RubyHashEntry entry) { - return JavaUtil.convertRubyToJava(entry.key, Object.class); - } - public boolean contains(RubyHash hash, Object o) { - return hash.containsKey(o); - } - public boolean remove(RubyHash hash, Object o) { - return hash.remove(o) != null; - } - }; - - private static final EntryView DIRECT_VALUE_VIEW = new EntryView() { - public Object convertEntry(Ruby runtime, RubyHashEntry entry) { - return entry.value; - } - public boolean contains(RubyHash hash, Object o) { - if (!(o instanceof IRubyObject)) return false; - IRubyObject obj = (IRubyObject)o; - return hash.hasValue(obj.getRuntime().getCurrentContext(), obj); - } - public boolean remove(RubyHash hash, Object o) { - if (!(o instanceof IRubyObject)) return false; - IRubyObject obj = (IRubyObject) o; - IRubyObject key = hash.internalIndex(obj.getRuntime().getCurrentContext(), obj); - if (key == null) return false; - return hash.internalDelete(key) != NO_ENTRY; - } - }; - - private final EntryView VALUE_VIEW = new EntryView() { - public Object convertEntry(Ruby runtime, RubyHashEntry entry) { - return JavaUtil.convertRubyToJava(entry.value, Object.class); - } - public boolean contains(RubyHash hash, Object o) { - return hash.containsValue(o); - } - public boolean remove(RubyHash hash, Object o) { - IRubyObject value = JavaUtil.convertJavaToRuby(hash.getRuntime(), o); - IRubyObject key = hash.internalIndex(hash.getRuntime().getCurrentContext(), value); - if (key == null) return false; - return hash.internalDelete(key) != NO_ENTRY; - } - }; - - private final EntryView DIRECT_ENTRY_VIEW = new EntryView() { - public Object convertEntry(Ruby runtime, RubyHashEntry entry) { - return entry; - } - public boolean contains(RubyHash hash, Object o) { - if (!(o instanceof RubyHashEntry)) return false; - RubyHashEntry entry = (RubyHashEntry)o; - RubyHashEntry candidate = internalGetEntry(entry.key); - return candidate != NO_ENTRY && entry.equals(candidate); - } - public boolean remove(RubyHash hash, Object o) { - if (!(o instanceof RubyHashEntry)) return false; - return hash.internalDeleteEntry((RubyHashEntry)o) != NO_ENTRY; - } - }; - - private final EntryView ENTRY_VIEW = new EntryView() { - public Object convertEntry(Ruby runtime, RubyHashEntry entry) { - return new ConvertingEntry(runtime, entry); - } - public boolean contains(RubyHash hash, Object o) { - if (!(o instanceof ConvertingEntry)) return false; - ConvertingEntry entry = (ConvertingEntry)o; - RubyHashEntry candidate = hash.internalGetEntry(entry.entry.key); - return candidate != NO_ENTRY && entry.entry.equals(candidate); - } - public boolean remove(RubyHash hash, Object o) { - if (!(o instanceof ConvertingEntry)) return false; - ConvertingEntry entry = (ConvertingEntry)o; - return hash.internalDeleteEntry(entry.entry) != NO_ENTRY; - } - }; - - private static class ConvertingEntry implements Map.Entry { - private final RubyHashEntry entry; - private final Ruby runtime; - - public ConvertingEntry(Ruby runtime, RubyHashEntry entry) { - this.entry = entry; - this.runtime = runtime; - } - - public Object getKey() { - return JavaUtil.convertRubyToJava(entry.key, Object.class); - } - public Object getValue() { - return JavaUtil.convertRubyToJava(entry.value, Object.class); - } - public Object setValue(Object o) { - return entry.setValue(JavaUtil.convertJavaToRuby(runtime, o)); - } - - public boolean equals(Object o) { - if (!(o instanceof ConvertingEntry)) { - return false; - } - ConvertingEntry other = (ConvertingEntry)o; - return entry.equals(other.entry); - } - public int hashCode() { - return entry.hashCode(); - } - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2007 Koichiro Ohba <koichiro@meadowy.org> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.nio.ByteBuffer; -import java.nio.CharBuffer; -import java.nio.charset.CharacterCodingException; -import java.nio.charset.Charset; -import java.nio.charset.CharsetDecoder; -import java.nio.charset.CharsetEncoder; -import java.nio.charset.CodingErrorAction; -import java.nio.charset.IllegalCharsetNameException; -import java.nio.charset.MalformedInputException; -import java.nio.charset.UnmappableCharacterException; -import java.nio.charset.UnsupportedCharsetException; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.Arity; - -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -import org.jruby.util.ByteList; - -@JRubyClass(name="Iconv") -public class RubyIconv extends RubyObject { - //static private final String TRANSLIT = "//translit"; - static private final String IGNORE = "//ignore"; - - private CharsetDecoder fromEncoding; - private CharsetEncoder toEncoding; - - public RubyIconv(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - private static final ObjectAllocator ICONV_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyIconv(runtime, klass); - } - }; - - @JRubyModule(name="Iconv::Failure") - public static class Failure {} - @JRubyClass(name="Iconv::IllegalSequence", parent="ArgumentError", include="Iconv::Failure") - public static class IllegalSequence {} - @JRubyClass(name="Iconv::InvalidCharacter", parent="ArgumentError", include="Iconv::Failure") - public static class InvalidCharacter {} - @JRubyClass(name="Iconv::InvalidEncoding", parent="ArgumentError", include="Iconv::Failure") - public static class InvalidEncoding {} - @JRubyClass(name="Iconv::OutOfRange", parent="ArgumentError", include="Iconv::Failure") - public static class OutOfRange {} - @JRubyClass(name="Iconv::BrokenLibrary", parent="ArgumentError", include="Iconv::Failure") - public static class BrokenLibrary {} - - public static void createIconv(Ruby runtime) { - RubyClass iconvClass = runtime.defineClass("Iconv", runtime.getObject(), ICONV_ALLOCATOR); - - iconvClass.defineAnnotatedMethods(RubyIconv.class); - - RubyModule failure = iconvClass.defineModuleUnder("Failure"); - RubyClass argumentError = runtime.getArgumentError(); - - String[] iconvErrors = {"IllegalSequence", "InvalidCharacter", "InvalidEncoding", - "OutOfRange", "BrokenLibrary"}; - - for (int i = 0; i < iconvErrors.length; i++) { - RubyClass subClass = iconvClass.defineClassUnder(iconvErrors[i], argumentError, RubyFailure.ICONV_FAILURE_ALLOCATOR); - subClass.defineAnnotatedMethods(RubyFailure.class); - subClass.includeModule(failure); - } - } - - public static class RubyFailure extends RubyException { - private IRubyObject success; - private IRubyObject failed; - - public static RubyFailure newInstance(Ruby runtime, RubyClass excptnClass, String msg) { - return new RubyFailure(runtime, excptnClass, msg); - } - - protected static final ObjectAllocator ICONV_FAILURE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyFailure(runtime, klass); - } - }; - - protected RubyFailure(Ruby runtime, RubyClass rubyClass) { - this(runtime, rubyClass, null); - } - - public RubyFailure(Ruby runtime, RubyClass rubyClass, String message) { - super(runtime, rubyClass, message); - } - - @JRubyMethod(name = "initialize", required = 1, optional = 2, frame = true) - public IRubyObject initialize(IRubyObject[] args, Block block) { - super.initialize(args, block); - success = args.length >= 2 ? args[1] : getRuntime().getNil(); - failed = args.length == 3 ? args[2] : getRuntime().getNil(); - - return this; - } - - @JRubyMethod(name = "success") - public IRubyObject success() { - return success; - } - - @JRubyMethod(name = "failed") - public IRubyObject failed() { - return failed; - } - - @JRubyMethod(name = "inspect") - public IRubyObject inspect() { - RubyModule rubyClass = getMetaClass(); - StringBuilder buffer = new StringBuilder("#<"); - buffer.append(rubyClass.getName()).append(": ").append(success.inspect().toString()); - buffer.append(", ").append(failed.inspect().toString()).append(">"); - - return getRuntime().newString(buffer.toString()); - } - } - - private static String getCharset(String encoding) { - int index = encoding.indexOf("//"); - if (index == -1) return encoding; - return encoding.substring(0, index); - } - - /* Currently dead code, but useful when we figure out how to actually perform translit. - private static boolean isTranslit(String encoding) { - return encoding.toLowerCase().indexOf(TRANSLIT) != -1 ? true : false; - }*/ - - private static boolean isIgnore(String encoding) { - return encoding.toLowerCase().indexOf(IGNORE) != -1 ? true : false; - } - - @JRubyMethod(name = "open", required = 2, frame = true, meta = true) - public static IRubyObject open(ThreadContext context, IRubyObject recv, IRubyObject to, IRubyObject from, Block block) { - Ruby runtime = context.getRuntime(); - - RubyIconv iconv = newIconv(context, recv, to, from); - - if (!block.isGiven()) return iconv; - - IRubyObject result = runtime.getNil(); - try { - result = block.yield(context, iconv); - } finally { - iconv.close(); - } - - return result; - } - - private static RubyIconv newIconv(ThreadContext context, IRubyObject recv, - IRubyObject to, IRubyObject from) { - RubyClass klazz = (RubyClass)recv; - - return (RubyIconv) klazz.newInstance( - context, new IRubyObject[] {to, from}, Block.NULL_BLOCK); - } - - @JRubyMethod(name = "initialize", required = 2, frame = true) - public IRubyObject initialize(IRubyObject arg1, IRubyObject arg2, Block unusedBlock) { - Ruby runtime = getRuntime(); - if (!arg1.respondsTo("to_str")) { - throw runtime.newTypeError("can't convert " + arg1.getMetaClass() + " into String"); - } - if (!arg2.respondsTo("to_str")) { - throw runtime.newTypeError("can't convert " + arg2.getMetaClass() + " into String"); - } - - String to = arg1.convertToString().toString(); - String from = arg2.convertToString().toString(); - - try { - - fromEncoding = Charset.forName(getCharset(from)).newDecoder(); - toEncoding = Charset.forName(getCharset(to)).newEncoder(); - - if (!isIgnore(from)) fromEncoding.onUnmappableCharacter(CodingErrorAction.REPORT); - if (!isIgnore(to)) toEncoding.onUnmappableCharacter(CodingErrorAction.REPORT); - } catch (IllegalCharsetNameException e) { - throw runtime.newInvalidEncoding("invalid encoding"); - } catch (UnsupportedCharsetException e) { - throw runtime.newInvalidEncoding("invalid encoding"); - } catch (Exception e) { - throw runtime.newSystemCallError(e.toString()); - } - - return this; - } - - @JRubyMethod(name = "close") - public IRubyObject close() { - toEncoding = null; - fromEncoding = null; - return RubyString.newEmptyString(getRuntime()); - } - - @JRubyMethod - public IRubyObject iconv(IRubyObject str) { - return iconv(str, 0, -1); - } - - @JRubyMethod - public IRubyObject iconv(IRubyObject str, IRubyObject startArg) { - int start = 0; - if (!startArg.isNil()) start = RubyNumeric.fix2int(startArg); - return iconv(str, start, -1); - } - - @JRubyMethod - public IRubyObject iconv(IRubyObject str, IRubyObject startArg, IRubyObject endArg) { - int start = 0; - int end = -1; - - if (!startArg.isNil()) start = RubyNumeric.fix2int(startArg); - if (!endArg.isNil()) end = RubyNumeric.fix2int(endArg); - - return iconv(str, start, end); - } - - private IRubyObject iconv(IRubyObject str, int start, int end) { - if (str.isNil()) { - fromEncoding.reset(); - toEncoding.reset(); - return RubyString.newEmptyString(getRuntime()); - } - - return _iconv(str.convertToString(), start, end); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with one, two or three arguments. - */ - public IRubyObject iconv(IRubyObject[] args) { - switch (args.length) { - case 1: - return iconv(args[0]); - case 2: - return iconv(args[0], args[1]); - case 3: - return iconv(args[0], args[1], args[2]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - // FIXME: We are assuming that original string will be raw bytes. If -Ku is provided - // this will not be true, but that is ok for now. Deal with that when someone needs it. - private IRubyObject _iconv(RubyString str, int start, int end) { - if (fromEncoding == null) { - throw getRuntime().newArgumentError("closed iconv"); - } - - ByteList bytes = str.getByteList(); - - // treat start and end as start...end for end >= 0, start..end for end < 0 - if (start < 0) { - start += bytes.length(); - } - - if (end < 0) { - end += 1 + bytes.length(); - } else if (end > bytes.length()) { - end = bytes.length(); - } - - if (start < 0 || end < start) { // invalid ranges result in an empty string - return RubyString.newEmptyString(getRuntime()); - } - - ByteBuffer buf = ByteBuffer.wrap(bytes.unsafeBytes(), bytes.begin() + start, end - start); - - try { - CharBuffer cbuf = fromEncoding.decode(buf); - buf = toEncoding.encode(cbuf); - } catch (MalformedInputException e) { - } catch (UnmappableCharacterException e) { - } catch (CharacterCodingException e) { - throw getRuntime().newInvalidEncoding("invalid sequence"); - } catch (IllegalStateException e) { - } - byte[] arr = buf.array(); - - return getRuntime().newString(new ByteList(arr, 0, buf.limit())); - } - - @JRubyMethod(name = "iconv", required = 2, rest = true, meta = true) - public static IRubyObject iconv(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock) { - return convertWithArgs(context, recv, args, "iconv"); - } - - @JRubyMethod(name = "conv", required = 3, rest = true, meta = true) - public static IRubyObject conv(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock) { - return convertWithArgs(context, recv, args, "conv").join(context, RubyString.newEmptyString(recv.getRuntime())); - } - - @JRubyMethod(name = "charset_map", meta= true) - public static IRubyObject charset_map_get(IRubyObject recv) { - return recv.getRuntime().getCharsetMap(); - } - - private static String mapCharset(ThreadContext context, IRubyObject val) { - RubyHash charset = val.getRuntime().getCharsetMap(); - if (charset.size() > 0) { - RubyString key = val.callMethod(context, "downcase").convertToString(); - IRubyObject tryVal = charset.fastARef(key); - if (tryVal != null) val = tryVal; - } - - return val.convertToString().toString(); - } - - public static RubyArray convertWithArgs(ThreadContext context, IRubyObject recv, IRubyObject[] args, String function) { - assert args.length >= 2; - - RubyArray array = context.getRuntime().newArray(args.length - 2); - RubyIconv iconv = newIconv(context, recv, args[0], args[1]); - - try { - for (int i = 2; i < args.length; i++) { - array.append(iconv.iconv(args[i])); - } - } finally { - iconv.close(); - } - - return array; - } - - /* - private static IRubyObject convert(String fromEncoding, String toEncoding, RubyString original) - throws UnsupportedEncodingException { - // Get all bytes from PLAIN string pretend they are not encoded in any way. - byte[] string = original.getBytes(); - // Now create a string pretending it is from fromEncoding - string = new String(string, fromEncoding).getBytes(toEncoding); - // Finally recode back to PLAIN - return RubyString.newString(original.getRuntime(), string); - } - */ -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.BufferedInputStream; -import java.io.ByteArrayInputStream; -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.PrintStream; -import java.io.UnsupportedEncodingException; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; - -import java.util.Set; -import java.util.StringTokenizer; -import org.jruby.ast.executable.Script; -import org.jruby.exceptions.MainExitException; -import org.jruby.runtime.Constants; -import org.jruby.runtime.load.LoadService; -import org.jruby.util.ClassCache; -import org.jruby.util.JRubyFile; -import org.jruby.util.KCode; -import org.jruby.util.NormalizedFile; -import org.jruby.util.SafePropertyAccessor; -import org.objectweb.asm.Opcodes; - -public class RubyInstanceConfig { - - /** - * The max count of active methods eligible for JIT-compilation. - */ - private static final int JIT_MAX_METHODS_LIMIT = 4096; - - /** - * The max size of JIT-compiled methods (full class size) allowed. - */ - private static final int JIT_MAX_SIZE_LIMIT = Integer.MAX_VALUE; - - /** - * The JIT threshold to the specified method invocation count. - */ - private static final int JIT_THRESHOLD = 50; - - /** The version to use for generated classes. Set to current JVM version by default */ - public static final int JAVA_VERSION; - - /** - * Default size for chained compilation. - */ - private static final int CHAINED_COMPILE_LINE_COUNT_DEFAULT = 500; - - /** - * The number of lines at which a method, class, or block body is split into - * chained methods (to dodge 64k method-size limit in JVM). - */ - public static final int CHAINED_COMPILE_LINE_COUNT - = SafePropertyAccessor.getInt("jruby.compile.chainsize", CHAINED_COMPILE_LINE_COUNT_DEFAULT); - - public enum CompileMode { - JIT, FORCE, OFF; - - public boolean shouldPrecompileCLI() { - switch (this) { - case JIT: case FORCE: - return true; - } - return false; - } - - public boolean shouldJIT() { - switch (this) { - case JIT: case FORCE: - return true; - } - return false; - } - - public boolean shouldPrecompileAll() { - return this == FORCE; - } - } - private InputStream input = System.in; - private PrintStream output = System.out; - private PrintStream error = System.err; - private Profile profile = Profile.DEFAULT; - private boolean objectSpaceEnabled - = SafePropertyAccessor.getBoolean("jruby.objectspace.enabled", false); - - private CompileMode compileMode = CompileMode.JIT; - private boolean runRubyInProcess = true; - private String currentDirectory; - private Map environment; - private String[] argv = {}; - - private final boolean jitLogging; - private final boolean jitLoggingVerbose; - private final int jitLogEvery; - private final int jitThreshold; - private final int jitMax; - private final int jitMaxSize; - private final boolean samplingEnabled; - private CompatVersion compatVersion; - - private ClassLoader contextLoader = Thread.currentThread().getContextClassLoader(); - private ClassLoader loader = contextLoader == null ? RubyInstanceConfig.class.getClassLoader() : contextLoader; - - private ClassCache<Script> classCache; - - // from CommandlineParser - private List<String> loadPaths = new ArrayList<String>(); - private Set<String> excludedMethods = new HashSet<String>(); - private StringBuffer inlineScript = new StringBuffer(); - private boolean hasInlineScript = false; - private String scriptFileName = null; - private List<String> requiredLibraries = new ArrayList<String>(); - private boolean benchmarking = false; - private boolean argvGlobalsOn = false; - private boolean assumeLoop = false; - private boolean assumePrinting = false; - private Map optionGlobals = new HashMap(); - private boolean processLineEnds = false; - private boolean split = false; - // This property is a Boolean, to allow three values, so it can match MRI's nil, false and true - private Boolean verbose = Boolean.FALSE; - private boolean debug = false; - private boolean showVersion = false; - private boolean showBytecode = false; - private boolean showCopyright = false; - private boolean endOfArguments = false; - private boolean shouldRunInterpreter = true; - private boolean shouldPrintUsage = false; - private boolean shouldPrintProperties=false; - private boolean yarv = false; - private boolean rubinius = false; - private boolean yarvCompile = false; - private KCode kcode = KCode.NONE; - private String recordSeparator = "\n"; - private boolean shouldCheckSyntax = false; - private String inputFieldSeparator = null; - private boolean managementEnabled = true; - - private int safeLevel = 0; - - private String jrubyHome; - - public static final boolean FASTEST_COMPILE_ENABLED - = SafePropertyAccessor.getBoolean("jruby.compile.fastest"); - public static final boolean BOXED_COMPILE_ENABLED - = FASTEST_COMPILE_ENABLED - || SafePropertyAccessor.getBoolean("jruby.compile.boxed"); - public static final boolean FASTOPS_COMPILE_ENABLED - = FASTEST_COMPILE_ENABLED - || SafePropertyAccessor.getBoolean("jruby.compile.fastops"); - public static final boolean FRAMELESS_COMPILE_ENABLED - = FASTEST_COMPILE_ENABLED - || SafePropertyAccessor.getBoolean("jruby.compile.frameless"); - public static final boolean POSITIONLESS_COMPILE_ENABLED - = FASTEST_COMPILE_ENABLED - || SafePropertyAccessor.getBoolean("jruby.compile.positionless"); - public static final boolean THREADLESS_COMPILE_ENABLED - = FASTEST_COMPILE_ENABLED - || SafePropertyAccessor.getBoolean("jruby.compile.threadless"); - public static final boolean LAZYHANDLES_COMPILE = SafePropertyAccessor.getBoolean("jruby.compile.lazyHandles", false); - public static final boolean FORK_ENABLED - = SafePropertyAccessor.getBoolean("jruby.fork.enabled"); - public static final boolean POOLING_ENABLED - = SafePropertyAccessor.getBoolean("jruby.thread.pool.enabled"); - public static final int POOL_MAX - = SafePropertyAccessor.getInt("jruby.thread.pool.max", Integer.MAX_VALUE); - public static final int POOL_MIN - = SafePropertyAccessor.getInt("jruby.thread.pool.min", 0); - public static final int POOL_TTL - = SafePropertyAccessor.getInt("jruby.thread.pool.ttl", 60); - - public static final boolean NATIVE_NET_PROTOCOL - = SafePropertyAccessor.getBoolean("jruby.native.net.protocol", false); - - public static boolean FULL_TRACE_ENABLED - = SafePropertyAccessor.getBoolean("jruby.debug.fullTrace", false); - - public static final String COMPILE_EXCLUDE - = SafePropertyAccessor.getProperty("jruby.jit.exclude"); - public static boolean nativeEnabled = true; - - - public static interface LoadServiceCreator { - LoadService create(Ruby runtime); - - LoadServiceCreator DEFAULT = new LoadServiceCreator() { - public LoadService create(Ruby runtime) { - return new LoadService(runtime); - } - }; - } - - private LoadServiceCreator creator = LoadServiceCreator.DEFAULT; - - - static { - String specVersion = null; - try { - specVersion = System.getProperty("jruby.bytecode.version"); - if (specVersion == null) { - specVersion = System.getProperty("java.specification.version"); - } - if (System.getProperty("jruby.native.enabled") != null) { - nativeEnabled = Boolean.getBoolean("jruby.native.enabled"); - } - } catch (SecurityException se) { - nativeEnabled = false; - specVersion = "1.5"; - } - - if (specVersion.equals("1.5")) { - JAVA_VERSION = Opcodes.V1_5; - } else { - JAVA_VERSION = Opcodes.V1_6; - } - } - - public int characterIndex = 0; - - public RubyInstanceConfig() { - if (Ruby.isSecurityRestricted()) - currentDirectory = "/"; - else { - currentDirectory = JRubyFile.getFileProperty("user.dir"); - } - - samplingEnabled = SafePropertyAccessor.getBoolean("jruby.sampling.enabled", false); - String compatString = SafePropertyAccessor.getProperty("jruby.compat.version", "RUBY1_8"); - if (compatString.equalsIgnoreCase("RUBY1_8")) { - compatVersion = CompatVersion.RUBY1_8; - } else if (compatString.equalsIgnoreCase("RUBY1_9")) { - compatVersion = CompatVersion.RUBY1_9; - } else { - System.err.println("Compatibility version `" + compatString + "' invalid; use RUBY1_8 or RUBY1_9. Using RUBY1_8."); - compatVersion = CompatVersion.RUBY1_8; - } - - if (Ruby.isSecurityRestricted()) { - compileMode = CompileMode.OFF; - jitLogging = false; - jitLoggingVerbose = false; - jitLogEvery = 0; - jitThreshold = -1; - jitMax = 0; - jitMaxSize = -1; - managementEnabled = false; - } else { - String threshold = SafePropertyAccessor.getProperty("jruby.jit.threshold"); - String max = SafePropertyAccessor.getProperty("jruby.jit.max"); - String maxSize = SafePropertyAccessor.getProperty("jruby.jit.maxsize"); - - if (COMPILE_EXCLUDE != null) { - String[] elements = COMPILE_EXCLUDE.split(","); - for (String element : elements) excludedMethods.add(element); - } - - managementEnabled = SafePropertyAccessor.getBoolean("jruby.management.enabled", true); - runRubyInProcess = SafePropertyAccessor.getBoolean("jruby.launch.inproc", true); - boolean jitProperty = SafePropertyAccessor.getProperty("jruby.jit.enabled") != null; - if (jitProperty) { - error.print("jruby.jit.enabled property is deprecated; use jruby.compile.mode=(OFF|JIT|FORCE) for -C, default, and +C flags"); - compileMode = SafePropertyAccessor.getBoolean("jruby.jit.enabled") ? CompileMode.JIT : CompileMode.OFF; - } else { - String jitModeProperty = SafePropertyAccessor.getProperty("jruby.compile.mode", "JIT"); - - if (jitModeProperty.equals("OFF")) { - compileMode = CompileMode.OFF; - } else if (jitModeProperty.equals("JIT")) { - compileMode = CompileMode.JIT; - } else if (jitModeProperty.equals("FORCE")) { - compileMode = CompileMode.FORCE; - } else { - error.print("jruby.compile.mode property must be OFF, JIT, FORCE, or unset; defaulting to JIT"); - compileMode = CompileMode.JIT; - } - } - jitLogging = SafePropertyAccessor.getBoolean("jruby.jit.logging"); - jitLoggingVerbose = SafePropertyAccessor.getBoolean("jruby.jit.logging.verbose"); - String logEvery = SafePropertyAccessor.getProperty("jruby.jit.logEvery"); - jitLogEvery = logEvery == null ? 0 : Integer.parseInt(logEvery); - jitThreshold = threshold == null ? - JIT_THRESHOLD : Integer.parseInt(threshold); - jitMax = max == null ? - JIT_MAX_METHODS_LIMIT : Integer.parseInt(max); - jitMaxSize = maxSize == null ? - JIT_MAX_SIZE_LIMIT : Integer.parseInt(maxSize); - } - - // default ClassCache using jitMax as a soft upper bound - classCache = new ClassCache<Script>(loader, jitMax); - - if (FORK_ENABLED) { - error.print("WARNING: fork is highly unlikely to be safe or stable on the JVM. Have fun!\n"); - } - } - - public LoadServiceCreator getLoadServiceCreator() { - return creator; - } - - public void setLoadServiceCreator(LoadServiceCreator creator) { - this.creator = creator; - } - - public LoadService createLoadService(Ruby runtime) { - return this.creator.create(runtime); - } - - public String getBasicUsageHelp() { - StringBuilder sb = new StringBuilder(); - sb - .append("Usage: jruby [switches] [--] [programfile] [arguments]\n") - .append(" -0[octal] specify record separator (\0, if no argument)\n") - .append(" -a autosplit mode with -n or -p (splits $_ into $F)\n") - .append(" -b benchmark mode, times the script execution\n") - .append(" -c check syntax only\n") - .append(" -Cdirectory cd to directory, before executing your script\n") - .append(" -d set debugging flags (set $DEBUG to true)\n") - .append(" -e 'command' one line of script. Several -e's allowed. Omit [programfile]\n") - .append(" -Fpattern split() pattern for autosplit (-a)\n") - //.append(" -i[extension] edit ARGV files in place (make backup if extension supplied)\n") - .append(" -Idirectory specify $LOAD_PATH directory (may be used more than once)\n") - .append(" -J[java option] pass an option on to the JVM (e.g. -J-Xmx512m)\n") - .append(" use --properties to list JRuby properties\n") - .append(" run 'java -help' for a list of other Java options\n") - .append(" -Kkcode specifies code-set (e.g. -Ku for Unicode\n") - .append(" -l enable line ending processing\n") - .append(" -n assume 'while gets(); ... end' loop around your script\n") - .append(" -p assume loop like -n but print line also like sed\n") - .append(" -rlibrary require the library, before executing your script\n") - .append(" -s enable some switch parsing for switches after script name\n") - .append(" -S look for the script in bin or using PATH environment variable\n") - .append(" -T[level] turn on tainting checks\n") - .append(" -v print version number, then turn on verbose mode\n") - .append(" -w turn warnings on for your script\n") - .append(" -W[level] set warning level; 0=silence, 1=medium, 2=verbose (default)\n") - //.append(" -x[directory] strip off text before #!ruby line and perhaps cd to directory\n") - .append(" -X[option] enable extended option (omit option to list)\n") - .append(" --copyright print the copyright\n") - .append(" --debug sets the execution mode most suitable for debugger functionality\n") - .append(" --jdb runs JRuby process under JDB\n") - .append(" --properties List all configuration Java properties (pass -J-Dproperty=value)\n") - .append(" --sample run with profiling using the JVM's sampling profiler\n") - .append(" --client use the non-optimizing \"client\" JVM (improves startup; default)\n") - .append(" --server use the optimizing \"server\" JVM (improves perf)\n") - .append(" --manage enable remote JMX management and monitoring of the VM and JRuby\n") - .append(" --1.8 specify Ruby 1.8.x compatibility (default)\n") - .append(" --1.9 specify Ruby 1.9.x compatibility\n") - .append(" --bytecode show the JVM bytecode produced by compiling specified code\n") - .append(" --version print the version\n"); - - return sb.toString(); - } - - public String getExtendedHelp() { - StringBuilder sb = new StringBuilder(); - sb - .append("These flags are for extended JRuby options.\n") - .append("Specify them by passing -X<option>\n") - .append(" -O run with ObjectSpace disabled (default; improves performance)\n") - .append(" +O run with ObjectSpace enabled (reduces performance)\n") - .append(" -C disable all compilation\n") - .append(" +C force compilation of all scripts before they are run (except eval)\n") - .append(" -y read a YARV-compiled Ruby script and run that (EXPERIMENTAL)\n") - .append(" -Y compile a Ruby script into YARV bytecodes and run this (EXPERIMENTAL)\n") - .append(" -R read a Rubinius-compiled Ruby script and run that (EXPERIMENTAL)\n"); - - return sb.toString(); - } - - public String getPropertyHelp() { - StringBuilder sb = new StringBuilder(); - sb - .append("These properties can be used to alter runtime behavior for perf or compatibility.\n") - .append("Specify them by passing -J-D<property>=<value>\n") - .append("\nCOMPILER SETTINGS:\n") - .append(" jruby.compile.mode=JIT|FORCE|OFF\n") - .append(" Set compilation mode. JIT is default; FORCE compiles all, OFF disables\n") - .append(" jruby.compile.fastest=true|false\n") - .append(" (EXPERIMENTAL) Turn on all experimental compiler optimizations\n") - .append(" jruby.compile.boxed=true|false\n") - .append(" (EXPERIMENTAL) Use boxed variables; this can speed up some methods. Default is false\n") - .append(" jruby.compile.frameless=true|false\n") - .append(" (EXPERIMENTAL) Turn on frameless compilation where possible\n") - .append(" jruby.compile.positionless=true|false\n") - .append(" (EXPERIMENTAL) Turn on compilation that avoids updating Ruby position info. Default is false\n") - .append(" jruby.compile.threadless=true|false\n") - .append(" (EXPERIMENTAL) Turn on compilation without polling for \"unsafe\" thread events. Default is false\n") - .append(" jruby.compile.fastops=true|false\n") - .append(" (EXPERIMENTAL) Turn on fast operators for Fixnum. Default is false\n") - .append(" jruby.compile.chainsize=<line count>\n") - .append(" Set the number of lines at which compiled bodies are \"chained\". Default is " + CHAINED_COMPILE_LINE_COUNT_DEFAULT + "\n") - .append(" jruby.compile.lazyHandles=true|false\n") - .append(" Generate method bindings (handles) for compiled methods lazily. Default is false.") - .append("\nJIT SETTINGS:\n") - .append(" jruby.jit.threshold=<invocation count>\n") - .append(" Set the JIT threshold to the specified method invocation count. Default is " + JIT_THRESHOLD + ".\n") - .append(" jruby.jit.max=<method count>\n") - .append(" Set the max count of active methods eligible for JIT-compilation.\n") - .append(" Default is " + JIT_MAX_METHODS_LIMIT + " per runtime. A value of 0 disables JIT, -1 disables max.\n") - .append(" jruby.jit.maxsize=<jitted method size (full .class)>\n") - .append(" Set the maximum full-class byte size allowed for jitted methods. Default is Integer.MAX_VALUE\n") - .append(" jruby.jit.logging=true|false\n") - .append(" Enable JIT logging (reports successful compilation). Default is false\n") - .append(" jruby.jit.logging.verbose=true|false\n") - .append(" Enable verbose JIT logging (reports failed compilation). Default is false\n") - .append(" jruby.jit.logEvery=<method count>\n") - .append(" Log a message every n methods JIT compiled. Default is 0 (off).\n") - .append(" jruby.jit.exclude=<ClsOrMod,ClsOrMod::method_name,-::method_name>\n") - .append(" Exclude methods from JIT by class/module short name, c/m::method_name,\n") - .append(" or -::method_name for anon/singleton classes/modules. Comma-delimited.\n") - .append("\nNATIVE SUPPORT:\n") - .append(" jruby.native.enabled=true|false\n") - .append(" Enable/disable native extensions (like JNA for non-Java APIs; Default is true\n") - .append(" (This affects all JRuby instances in a given JVM)\n") - .append(" jruby.native.verbose=true|false\n") - .append(" Enable verbose logging of native extension loading. Default is false.\n") - .append(" jruby.fork.enabled=true|false\n") - .append(" (EXPERIMENTAL, maybe dangerous) Enable fork(2) on platforms that support it.\n") - .append("\nTHREAD POOLING:\n") - .append(" jruby.thread.pool.enabled=true|false\n") - .append(" Enable reuse of native backing threads via a thread pool. Default is false.\n") - .append(" jruby.thread.pool.min=<min thread count>\n") - .append(" The minimum number of threads to keep alive in the pool. Default is 0.\n") - .append(" jruby.thread.pool.max=<max thread count>\n") - .append(" The maximum number of threads to allow in the pool. Default is unlimited.\n") - .append(" jruby.thread.pool.ttl=<time to live, in seconds>\n") - .append(" The maximum number of seconds to keep alive an idle thread. Default is 60.\n") - .append("\nMISCELLANY:\n") - .append(" jruby.compat.version=RUBY1_8|RUBY1_9\n") - .append(" Specify the major Ruby version to be compatible with; Default is RUBY1_8\n") - .append(" jruby.objectspace.enabled=true|false\n") - .append(" Enable or disable ObjectSpace.each_object (default is disabled)\n") - .append(" jruby.launch.inproc=true|false\n") - .append(" Set in-process launching of e.g. system('ruby ...'). Default is true\n") - .append(" jruby.bytecode.version=1.5|1.6\n") - .append(" Set bytecode version for JRuby to generate. Default is current JVM version.\n") - .append(" jruby.management.enabled=true|false\n") - .append(" Set whether JMX management is enabled. Default is true.\n") - .append(" jruby.debug.fullTrace=true|false\n") - .append(" Set whether full traces are enabled (c-call/c-return). Default is false.\n"); - - return sb.toString(); - } - - public String getVersionString() { - String ver = Constants.RUBY_VERSION; - switch (compatVersion) { - case RUBY1_8: - ver = Constants.RUBY_VERSION; - break; - case RUBY1_9: - ver = Constants.RUBY1_9_VERSION; - break; - } - - String fullVersion = String.format( - "jruby %s (ruby %s patchlevel %s) (%s rev %s) [%s-java]\n", - Constants.VERSION, ver, Constants.RUBY_PATCHLEVEL, - Constants.COMPILE_DATE, Constants.REVISION, - SafePropertyAccessor.getProperty("os.arch", "unknown") - ); - - return fullVersion; - } - - public String getCopyrightString() { - return "JRuby - Copyright (C) 2001-2008 The JRuby Community (and contribs)\n"; - } - - public void processArguments(String[] arguments) { - new ArgumentProcessor(arguments).processArguments(); - } - - public CompileMode getCompileMode() { - return compileMode; - } - - public void setCompileMode(CompileMode compileMode) { - this.compileMode = compileMode; - } - - public boolean isJitLogging() { - return jitLogging; - } - - public boolean isJitLoggingVerbose() { - return jitLoggingVerbose; - } - - public int getJitLogEvery() { - return jitLogEvery; - } - - public boolean isSamplingEnabled() { - return samplingEnabled; - } - - public int getJitThreshold() { - return jitThreshold; - } - - public int getJitMax() { - return jitMax; - } - - public int getJitMaxSize() { - return jitMaxSize; - } - - public boolean isRunRubyInProcess() { - return runRubyInProcess; - } - - public void setRunRubyInProcess(boolean flag) { - this.runRubyInProcess = flag; - } - - public void setInput(InputStream newInput) { - input = newInput; - } - - public InputStream getInput() { - return input; - } - - public CompatVersion getCompatVersion() { - return compatVersion; - } - - public void setOutput(PrintStream newOutput) { - output = newOutput; - } - - public PrintStream getOutput() { - return output; - } - - public void setError(PrintStream newError) { - error = newError; - } - - public PrintStream getError() { - return error; - } - - public void setCurrentDirectory(String newCurrentDirectory) { - currentDirectory = newCurrentDirectory; - } - - public String getCurrentDirectory() { - return currentDirectory; - } - - public void setProfile(Profile newProfile) { - profile = newProfile; - } - - public Profile getProfile() { - return profile; - } - - public void setObjectSpaceEnabled(boolean newObjectSpaceEnabled) { - objectSpaceEnabled = newObjectSpaceEnabled; - } - - public boolean isObjectSpaceEnabled() { - return objectSpaceEnabled; - } - - public void setEnvironment(Map newEnvironment) { - environment = newEnvironment; - } - - public Map getEnvironment() { - return environment; - } - - public ClassLoader getLoader() { - return loader; - } - - public void setLoader(ClassLoader loader) { - // Setting the loader needs to reset the class cache - if(this.loader != loader) { - this.classCache = new ClassCache<Script>(loader, this.classCache.getMax()); - } - this.loader = loader; - } - - public String[] getArgv() { - return argv; - } - - public void setArgv(String[] argv) { - this.argv = argv; - } - - public String getJRubyHome() { - if (jrubyHome == null) { - if (Ruby.isSecurityRestricted()) { - return "SECURITY RESTRICTED"; - } - jrubyHome = verifyHome(SafePropertyAccessor.getProperty("jruby.home", - SafePropertyAccessor.getProperty("user.home") + "/.jruby")); - - try { - // This comment also in rbConfigLibrary - // Our shell scripts pass in non-canonicalized paths, but even if we didn't - // anyone who did would become unhappy because Ruby apps expect no relative - // operators in the pathname (rubygems, for example). - jrubyHome = new NormalizedFile(jrubyHome).getCanonicalPath(); - } catch (IOException e) { } - - jrubyHome = new NormalizedFile(jrubyHome).getAbsolutePath(); - } - return jrubyHome; - } - - public void setJRubyHome(String home) { - jrubyHome = verifyHome(home); - } - - // We require the home directory to be absolute - private String verifyHome(String home) { - if (home.equals(".")) { - home = System.getProperty("user.dir"); - } - if (!home.startsWith("file:")) { - NormalizedFile f = new NormalizedFile(home); - if (!f.isAbsolute()) { - home = f.getAbsolutePath(); - } - f.mkdirs(); - } - return home; - } - - private class ArgumentProcessor { - private String[] arguments; - private int argumentIndex = 0; - - public ArgumentProcessor(String[] arguments) { - this.arguments = arguments; - } - - public void processArguments() { - while (argumentIndex < arguments.length && isInterpreterArgument(arguments[argumentIndex])) { - processArgument(); - argumentIndex++; - } - - if (!hasInlineScript && scriptFileName == null) { - if (argumentIndex < arguments.length) { - setScriptFileName(arguments[argumentIndex]); //consume the file name - argumentIndex++; - } - } - - processArgv(); - } - - private void processArgv() { - List<String> arglist = new ArrayList<String>(); - for (; argumentIndex < arguments.length; argumentIndex++) { - String arg = arguments[argumentIndex]; - if (argvGlobalsOn && arg.startsWith("-")) { - arg = arg.substring(1); - if (arg.indexOf('=') > 0) { - String[] keyvalue = arg.split("=", 2); - optionGlobals.put(keyvalue[0], keyvalue[1]); - } else { - optionGlobals.put(arg, null); - } - } else { - argvGlobalsOn = false; - arglist.add(arg); - } - } - - // Remaining arguments are for the script itself - argv = arglist.toArray(new String[arglist.size()]); - } - - private boolean isInterpreterArgument(String argument) { - return (argument.charAt(0) == '-' || argument.charAt(0) == '+') && !endOfArguments; - } - - private String getArgumentError(String additionalError) { - return "jruby: invalid argument\n" + additionalError + "\n"; - } - - private void processArgument() { - String argument = arguments[argumentIndex]; - FOR : for (characterIndex = 1; characterIndex < argument.length(); characterIndex++) { - switch (argument.charAt(characterIndex)) { - case '0': { - String temp = grabOptionalValue(); - if (null == temp) { - recordSeparator = "\u0000"; - } else if (temp.equals("0")) { - recordSeparator = "\n\n"; - } else if (temp.equals("777")) { - recordSeparator = "\uFFFF"; // Specify something that can't separate - } else { - try { - int val = Integer.parseInt(temp, 8); - recordSeparator = "" + (char) val; - } catch (Exception e) { - MainExitException mee = new MainExitException(1, getArgumentError(" -0 must be followed by either 0, 777, or a valid octal value")); - mee.setUsageError(true); - throw mee; - } - } - break FOR; - } - case 'a': - split = true; - break; - case 'b': - benchmarking = true; - break; - case 'c': - shouldCheckSyntax = true; - break; - case 'C': - try { - String saved = grabValue(getArgumentError(" -C must be followed by a directory expression")); - File base = new File(currentDirectory); - File newDir = new File(saved); - if (newDir.isAbsolute()) { - currentDirectory = newDir.getCanonicalPath(); - } else { - currentDirectory = new File(base, newDir.getPath()).getCanonicalPath(); - } - if (!(new File(currentDirectory).isDirectory())) { - MainExitException mee = new MainExitException(1, "jruby: Can't chdir to " + saved + " (fatal)"); - mee.setUsageError(true); - throw mee; - } - } catch (IOException e) { - MainExitException mee = new MainExitException(1, getArgumentError(" -C must be followed by a valid directory")); - mee.setUsageError(true); - throw mee; - } - break; - case 'd': - debug = true; - verbose = Boolean.TRUE; - break; - case 'e': - inlineScript.append(grabValue(getArgumentError(" -e must be followed by an expression to evaluate"))); - inlineScript.append('\n'); - hasInlineScript = true; - break FOR; - case 'F': - inputFieldSeparator = grabValue(getArgumentError(" -F must be followed by a pattern for input field separation")); - break; - case 'h': - shouldPrintUsage = true; - shouldRunInterpreter = false; - break; - // FIXME: -i flag not supported -// case 'i' : -// break; - case 'I': - String s = grabValue(getArgumentError("-I must be followed by a directory name to add to lib path")); - String[] ls = s.split(java.io.File.pathSeparator); - for (int i = 0; i < ls.length; i++) { - loadPaths.add(ls[i]); - } - break FOR; - case 'K': - // FIXME: No argument seems to work for -K in MRI plus this should not - // siphon off additional args 'jruby -K ~/scripts/foo'. Also better error - // processing. - String eArg = grabValue(getArgumentError("provide a value for -K")); - kcode = KCode.create(null, eArg); - break; - case 'l': - processLineEnds = true; - break; - case 'n': - assumeLoop = true; - break; - case 'p': - assumePrinting = true; - assumeLoop = true; - break; - case 'r': - requiredLibraries.add(grabValue(getArgumentError("-r must be followed by a package to require"))); - break FOR; - case 's' : - argvGlobalsOn = true; - break; - case 'S': - runBinScript(); - break FOR; - case 'T' :{ - String temp = grabOptionalValue(); - int value = 1; - - if(temp!=null) { - try { - value = Integer.parseInt(temp, 8); - } catch(Exception e) { - value = 1; - } - } - - safeLevel = value; - - break FOR; - } - case 'v': - verbose = Boolean.TRUE; - setShowVersion(true); - break; - case 'w': - verbose = Boolean.TRUE; - break; - case 'W': { - String temp = grabOptionalValue(); - int value = 2; - if (null != temp) { - if (temp.equals("2")) { - value = 2; - } else if (temp.equals("1")) { - value = 1; - } else if (temp.equals("0")) { - value = 0; - } else { - MainExitException mee = new MainExitException(1, getArgumentError(" -W must be followed by either 0, 1, 2 or nothing")); - mee.setUsageError(true); - throw mee; - } - } - switch (value) { - case 0: - verbose = null; - break; - case 1: - verbose = Boolean.FALSE; - break; - case 2: - verbose = Boolean.TRUE; - break; - } - - - break FOR; - } - // FIXME: -x flag not supported -// case 'x' : -// break; - case 'X': - String extendedOption = grabOptionalValue(); - - if (extendedOption == null) { - throw new MainExitException(0, "jruby: missing extended option, listing available options\n" + getExtendedHelp()); - } else if (extendedOption.equals("-O")) { - objectSpaceEnabled = false; - } else if (extendedOption.equals("+O")) { - objectSpaceEnabled = true; - } else if (extendedOption.equals("-C")) { - compileMode = CompileMode.OFF; - } else if (extendedOption.equals("+C")) { - compileMode = CompileMode.FORCE; - } else if (extendedOption.equals("-y")) { - yarv = true; - } else if (extendedOption.equals("-Y")) { - yarvCompile = true; - } else if (extendedOption.equals("-R")) { - rubinius = true; - } else { - MainExitException mee = - new MainExitException(1, "jruby: invalid extended option " + extendedOption + " (-X will list valid options)\n"); - mee.setUsageError(true); - - throw mee; - } - break FOR; - case '-': - if (argument.equals("--command") || argument.equals("--bin")) { - characterIndex = argument.length(); - runBinScript(); - break; - } else if (argument.equals("--compat")) { - characterIndex = argument.length(); - compatVersion = CompatVersion.getVersionFromString(grabValue(getArgumentError("--compat must be RUBY1_8 or RUBY1_9"))); - if (compatVersion == null) { - compatVersion = CompatVersion.RUBY1_8; - } - break FOR; - } else if (argument.equals("--copyright")) { - setShowCopyright(true); - shouldRunInterpreter = false; - break FOR; - } else if (argument.equals("--debug")) { - compileMode = CompileMode.OFF; - FULL_TRACE_ENABLED = true; - System.setProperty("jruby.reflection", "true"); - break FOR; - } else if (argument.equals("--jdb")) { - debug = true; - verbose = Boolean.TRUE; - break; - } else if (argument.equals("--help")) { - shouldPrintUsage = true; - shouldRunInterpreter = false; - break; - } else if (argument.equals("--properties")) { - shouldPrintProperties = true; - shouldRunInterpreter = false; - break; - } else if (argument.equals("--version")) { - setShowVersion(true); - break FOR; - } else if (argument.equals("--bytecode")) { - setShowBytecode(true); - break FOR; - } else { - if (argument.equals("--")) { - // ruby interpreter compatibilty - // Usage: ruby [switches] [--] [programfile] [arguments]) - endOfArguments = true; - break; - } - } - default: - throw new MainExitException(1, "jruby: unknown option " + argument); - } - } - } - - private void runBinScript() { - String scriptName = grabValue("jruby: provide a bin script to execute"); - if (scriptName.equals("irb")) { - scriptName = "jirb"; - } - - scriptFileName = scriptName; - - if (!new File(scriptFileName).exists()) { - try { - String jrubyHome = JRubyFile.create(System.getProperty("user.dir"), JRubyFile.getFileProperty("jruby.home")).getCanonicalPath(); - scriptFileName = JRubyFile.create(jrubyHome + JRubyFile.separator + "bin", scriptName).getCanonicalPath(); - } catch (IOException io) { - MainExitException mee = new MainExitException(1, "jruby: Can't determine script filename"); - mee.setUsageError(true); - throw mee; - } - } - - // route 'gem' through ruby code in case we're running out of the complete jar - if (scriptName.equals("gem") || !new File(scriptFileName).exists()) { - requiredLibraries.add("jruby/commands"); - inlineScript.append("JRuby::Commands." + scriptName); - inlineScript.append("\n"); - hasInlineScript = true; - } - endOfArguments = true; - } - - private String grabValue(String errorMessage) { - characterIndex++; - if (characterIndex < arguments[argumentIndex].length()) { - return arguments[argumentIndex].substring(characterIndex); - } - argumentIndex++; - if (argumentIndex < arguments.length) { - return arguments[argumentIndex]; - } - - MainExitException mee = new MainExitException(1, errorMessage); - mee.setUsageError(true); - - throw mee; - } - - private String grabOptionalValue() { - characterIndex++; - if (characterIndex < arguments[argumentIndex].length()) { - return arguments[argumentIndex].substring(characterIndex); - } - return null; - } - } - - public byte[] inlineScript() { - return inlineScript.toString().getBytes(); - } - - public List<String> requiredLibraries() { - return requiredLibraries; - } - - public List<String> loadPaths() { - return loadPaths; - } - - public boolean shouldRunInterpreter() { - if(isShowVersion() && (hasInlineScript || scriptFileName != null)) { - return true; - } - return isShouldRunInterpreter(); - } - - public boolean shouldPrintUsage() { - return shouldPrintUsage; - } - - public boolean shouldPrintProperties() { - return shouldPrintProperties; - } - - private boolean isSourceFromStdin() { - return getScriptFileName() == null; - } - - public boolean isInlineScript() { - return hasInlineScript; - } - - public InputStream getScriptSource() { - try { - // KCode.NONE is used because KCODE does not affect parse in Ruby 1.8 - // if Ruby 2.0 encoding pragmas are implemented, this will need to change - if (hasInlineScript) { - return new ByteArrayInputStream(inlineScript()); - } else if (isSourceFromStdin()) { - // can't use -v and stdin - if (isShowVersion()) { - return null; - } - return getInput(); - } else { - File file = JRubyFile.create(getCurrentDirectory(), getScriptFileName()); - return new BufferedInputStream(new FileInputStream(file)); - } - } catch (IOException e) { - throw new MainExitException(1, "Error opening script file: " + e.getMessage()); - } - } - - public String displayedFileName() { - if (hasInlineScript) { - if (scriptFileName != null) { - return scriptFileName; - } else { - return "-e"; - } - } else if (isSourceFromStdin()) { - return "-"; - } else { - return getScriptFileName(); - } - } - - private void setScriptFileName(String scriptFileName) { - this.scriptFileName = scriptFileName; - } - - public String getScriptFileName() { - return scriptFileName; - } - - public boolean isBenchmarking() { - return benchmarking; - } - - public boolean isAssumeLoop() { - return assumeLoop; - } - - public boolean isAssumePrinting() { - return assumePrinting; - } - - public boolean isProcessLineEnds() { - return processLineEnds; - } - - public boolean isSplit() { - return split; - } - - public boolean isVerbose() { - return verbose == Boolean.TRUE; - } - - public Boolean getVerbose() { - return verbose; - } - - public boolean isDebug() { - return debug; - } - - public boolean isShowVersion() { - return showVersion; - } - - public boolean isShowBytecode() { - return showBytecode; - } - - public boolean isShowCopyright() { - return showCopyright; - } - - protected void setShowVersion(boolean showVersion) { - this.showVersion = showVersion; - } - - protected void setShowBytecode(boolean showBytecode) { - this.showBytecode = showBytecode; - } - - protected void setShowCopyright(boolean showCopyright) { - this.showCopyright = showCopyright; - } - - public boolean isShouldRunInterpreter() { - return shouldRunInterpreter; - } - - public boolean isShouldCheckSyntax() { - return shouldCheckSyntax; - } - - public boolean isYARVEnabled() { - return yarv; - } - - public String getInputFieldSeparator() { - return inputFieldSeparator; - } - - public boolean isRubiniusEnabled() { - return rubinius; - } - - public boolean isYARVCompileEnabled() { - return yarvCompile; - } - - public KCode getKCode() { - return kcode; - } - - public String getRecordSeparator() { - return recordSeparator; - } - - public int getSafeLevel() { - return safeLevel; - } - - public void setRecordSeparator(String recordSeparator) { - this.recordSeparator = recordSeparator; - } - - public ClassCache getClassCache() { - return classCache; - } - - public void setClassCache(ClassCache classCache) { - this.classCache = classCache; - } - - public Map getOptionGlobals() { - return optionGlobals; - } - - public boolean isManagementEnabled() { - return managementEnabled; - } - - public Set getExcludedMethods() { - return excludedMethods; - } - -} -/* - **** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Charles O Nutter <headius@headius.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.Block; -import org.jruby.runtime.BlockBody; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; - -/** Implementation of the Integer class. - * - * @author jpetersen - */ -@JRubyClass(name="Integer", parent="Numeric", include="Precision") -public abstract class RubyInteger extends RubyNumeric { - - public static RubyClass createIntegerClass(Ruby runtime) { - RubyClass integer = runtime.defineClass("Integer", runtime.getNumeric(), - ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setInteger(integer); - integer.kindOf = new RubyModule.KindOf() { - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyInteger; - } - }; - - integer.getSingletonClass().undefineMethod("new"); - - integer.includeModule(runtime.getPrecision()); - - integer.defineAnnotatedMethods(RubyInteger.class); - - return integer; - } - - public RubyInteger(Ruby runtime, RubyClass rubyClass) { - super(runtime, rubyClass); - } - - public RubyInteger(Ruby runtime, RubyClass rubyClass, boolean useObjectSpace) { - super(runtime, rubyClass, useObjectSpace); - } - - public RubyInteger convertToInteger() { - return this; - } - - // conversion - protected RubyFloat toFloat() { - return RubyFloat.newFloat(getRuntime(), getDoubleValue()); - } - - /* ================ - * Instance Methods - * ================ - */ - - /** int_int_p - * - */ - @JRubyMethod(name = "integer?") - public IRubyObject integer_p() { - return getRuntime().getTrue(); - } - - /** int_upto - * - */ - @JRubyMethod(name = "upto", frame = true) - public IRubyObject upto(ThreadContext context, IRubyObject to, Block block) { - final Ruby runtime = getRuntime(); - - if (this instanceof RubyFixnum && to instanceof RubyFixnum) { - RubyFixnum toFixnum = (RubyFixnum) to; - final long toValue = toFixnum.getLongValue(); - final long fromValue = getLongValue(); - - if (block.getBody().getArgumentType() == BlockBody.ZERO_ARGS) { - final IRubyObject nil = runtime.getNil(); - for (long i = fromValue; i <= toValue; i++) { - block.yield(context, nil); - } - } else { - for (long i = fromValue; i <= toValue; i++) { - block.yield(context, RubyFixnum.newFixnum(runtime, i)); - } - } - } else { - RubyNumeric i = this; - - while (true) { - if (i.callMethod(context, MethodIndex.OP_GT, ">", to).isTrue()) { - break; - } - block.yield(context, i); - i = (RubyNumeric) i.callMethod(context, MethodIndex.OP_PLUS, "+", RubyFixnum.one(runtime)); - } - } - return this; - } - - /** int_downto - * - */ - // TODO: Make callCoerced work in block context...then fix downto, step, and upto. - @JRubyMethod(name = "downto", frame = true) - public IRubyObject downto(ThreadContext context, IRubyObject to, Block block) { - final Ruby runtime = getRuntime(); - - if (this instanceof RubyFixnum && to instanceof RubyFixnum) { - RubyFixnum toFixnum = (RubyFixnum) to; - final long toValue = toFixnum.getLongValue(); - if (block.getBody().getArgumentType() == BlockBody.ZERO_ARGS) { - final IRubyObject nil = runtime.getNil(); - for (long i = getLongValue(); i >= toValue; i--) { - block.yield(context, nil); - } - } else { - for (long i = getLongValue(); i >= toValue; i--) { - block.yield(context, RubyFixnum.newFixnum(getRuntime(), i)); - } - } - } else { - RubyNumeric i = this; - - while (true) { - if (i.callMethod(context, MethodIndex.OP_LT, "<", to).isTrue()) { - break; - } - block.yield(context, i); - i = (RubyNumeric) i.callMethod(context, MethodIndex.OP_MINUS, "-", RubyFixnum.one(getRuntime())); - } - } - return this; - } - - @JRubyMethod(name = "times", frame = true) - public IRubyObject times(ThreadContext context, Block block) { - final Ruby runtime = context.getRuntime(); - - if (this instanceof RubyFixnum) { - final long value = getLongValue(); - if (block.getBody().getArgumentType() == BlockBody.ZERO_ARGS) { - final IRubyObject nil = runtime.getNil(); - for (long i = 0; i < value; i++) { - block.yield(context, nil); - } - } else { - for (long i = 0; i < value; i++) { - block.yield(context, RubyFixnum.newFixnum(runtime, i)); - } - } - } else { - RubyNumeric i = RubyFixnum.zero(runtime); - while (true) { - if (!i.callMethod(context, MethodIndex.OP_LT, "<", this).isTrue()) { - break; - } - block.yield(context, i); - i = (RubyNumeric) i.callMethod(context, MethodIndex.OP_PLUS, "+", RubyFixnum.one(runtime)); - } - } - - return this; - } - - /** int_succ - * - */ - @JRubyMethod(name = {"succ", "next"}) - public IRubyObject succ(ThreadContext context) { - if (this instanceof RubyFixnum) { - return RubyFixnum.newFixnum(getRuntime(), getLongValue() + 1L); - } else { - return callMethod(context, MethodIndex.OP_PLUS, "+", RubyFixnum.one(getRuntime())); - } - } - - /** int_chr - * - */ - @JRubyMethod(name = "chr") - public RubyString chr() { - if (getLongValue() < 0 || getLongValue() > 0xff) { - throw getRuntime().newRangeError(this.toString() + " out of char range"); - } - return RubyString.newString(getRuntime(), new ByteList(new byte[]{(byte)getLongValue()}, false)); - } - - /** int_to_i - * - */ - @JRubyMethod(name = {"to_i", "to_int", "floor", "ceil", "round", "truncate"}) - public RubyInteger to_i() { - return this; - } - - /** integer_to_r - * - */ - @JRubyMethod(name = "to_r", compat = CompatVersion.RUBY1_9) - public IRubyObject to_r(ThreadContext context) { - return RubyRational.newRationalCanonicalize(context, this); - } - - - @JRubyMethod(name = {"odd?"}) - public static RubyBoolean odd_p(ThreadContext context, IRubyObject recv) { - if(recv.callMethod(context, "%", recv.getRuntime().newFixnum(2)) != RubyFixnum.zero(recv.getRuntime())) { - return recv.getRuntime().getTrue(); - } - return recv.getRuntime().getFalse(); - } - - @JRubyMethod(name = {"even?"}) - public static RubyBoolean even_p(ThreadContext context, IRubyObject recv) { - if(recv.callMethod(context, "%", recv.getRuntime().newFixnum(2)) == RubyFixnum.zero(recv.getRuntime())) { - return recv.getRuntime().getTrue(); - } - return recv.getRuntime().getFalse(); - } - - @JRubyMethod - public static IRubyObject pred(ThreadContext context, IRubyObject recv) { - return recv.callMethod(context, "-", recv.getRuntime().newFixnum(1)); - } - - - /* ================ - * Singleton Methods - * ================ - */ - - /** rb_int_induced_from - * - */ - @JRubyMethod(name = "induced_from", meta = true) - public static IRubyObject induced_from(ThreadContext context, IRubyObject recv, IRubyObject other) { - if (other instanceof RubyFixnum || other instanceof RubyBignum) { - return other; - } else if (other instanceof RubyFloat || other instanceof RubyRational) { - return other.callMethod(context, MethodIndex.TO_I, "to_i"); - } else { - throw recv.getRuntime().newTypeError( - "failed to convert " + other.getMetaClass().getName() + " into Integer"); - } - } -} -/* - **** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2006 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Evan Buswell <ebuswell@gmail.com> - * Copyright (C) 2007 Miguel Covarrubias <mlcovarrubias@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.EOFException; -import java.io.FileDescriptor; -import java.io.FilterInputStream; -import java.io.FilterOutputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.lang.ref.Reference; -import java.lang.ref.WeakReference; -import java.nio.channels.Channel; -import java.nio.channels.Channels; -import java.nio.channels.FileChannel; -import java.nio.channels.Pipe; -import java.nio.channels.SelectableChannel; -import java.nio.channels.SelectionKey; -import java.nio.channels.Selector; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.Iterator; -import java.util.List; -import java.util.Set; - -import java.util.concurrent.atomic.AtomicInteger; -import org.jruby.anno.FrameField; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.exceptions.RaiseException; -import org.jruby.ext.posix.util.FieldAccess; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallType; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.io.Stream; -import org.jruby.util.io.ModeFlags; -import org.jruby.util.ShellLauncher; -import org.jruby.util.TypeConverter; -import org.jruby.util.io.BadDescriptorException; -import org.jruby.util.io.ChannelStream; -import org.jruby.util.io.InvalidValueException; -import org.jruby.util.io.PipeException; -import org.jruby.util.io.FileExistsException; -import org.jruby.util.io.STDIO; -import org.jruby.util.io.OpenFile; -import org.jruby.util.io.ChannelDescriptor; - -import static org.jruby.CompatVersion.*; - -/** - * - * @author jpetersen - */ -@JRubyClass(name="IO", include="Enumerable") -public class RubyIO extends RubyObject { - protected OpenFile openFile; - protected List<RubyThread> blockingThreads; - - public void registerDescriptor(ChannelDescriptor descriptor) { - getRuntime().getDescriptors().put(new Integer(descriptor.getFileno()), new WeakReference<ChannelDescriptor>(descriptor)); - } - - public void unregisterDescriptor(int aFileno) { - getRuntime().getDescriptors().remove(new Integer(aFileno)); - } - - public ChannelDescriptor getDescriptorByFileno(int aFileno) { - Reference<ChannelDescriptor> reference = getRuntime().getDescriptors().get(new Integer(aFileno)); - if (reference == null) { - return null; - } - return reference.get(); - } - - // FIXME can't use static; would interfere with other runtimes in the same JVM - protected static AtomicInteger filenoIndex = new AtomicInteger(2); - - public static int getNewFileno() { - return filenoIndex.incrementAndGet(); - } - - // This should only be called by this and RubyFile. - // It allows this object to be created without a IOHandler. - public RubyIO(Ruby runtime, RubyClass type) { - super(runtime, type); - - openFile = new OpenFile(); - } - - public RubyIO(Ruby runtime, OutputStream outputStream) { - super(runtime, runtime.getIO()); - - // We only want IO objects with valid streams (better to error now). - if (outputStream == null) { - throw runtime.newIOError("Opening invalid stream"); - } - - openFile = new OpenFile(); - - try { - openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(Channels.newChannel(outputStream), getNewFileno(), new FileDescriptor()))); - } catch (InvalidValueException e) { - throw getRuntime().newErrnoEINVALError(); - } - - openFile.setMode(OpenFile.WRITABLE | OpenFile.APPEND); - - registerDescriptor(openFile.getMainStream().getDescriptor()); - } - - public RubyIO(Ruby runtime, InputStream inputStream) { - super(runtime, runtime.getIO()); - - if (inputStream == null) { - throw runtime.newIOError("Opening invalid stream"); - } - - openFile = new OpenFile(); - - try { - openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(Channels.newChannel(inputStream), getNewFileno(), new FileDescriptor()))); - } catch (InvalidValueException e) { - throw getRuntime().newErrnoEINVALError(); - } - - openFile.setMode(OpenFile.READABLE); - - registerDescriptor(openFile.getMainStream().getDescriptor()); - } - - public RubyIO(Ruby runtime, Channel channel) { - super(runtime, runtime.getIO()); - - // We only want IO objects with valid streams (better to error now). - if (channel == null) { - throw runtime.newIOError("Opening invalid stream"); - } - - openFile = new OpenFile(); - - try { - openFile.setMainStream(new ChannelStream(runtime, new ChannelDescriptor(channel, getNewFileno(), new FileDescriptor()))); - } catch (InvalidValueException e) { - throw getRuntime().newErrnoEINVALError(); - } - - openFile.setMode(openFile.getMainStream().getModes().getOpenFileFlags()); - - registerDescriptor(openFile.getMainStream().getDescriptor()); - } - - public RubyIO(Ruby runtime, ShellLauncher.POpenProcess process, ModeFlags modes) { - super(runtime, runtime.getIO()); - - openFile = new OpenFile(); - - openFile.setMode(modes.getOpenFileFlags() | OpenFile.SYNC); - openFile.setProcess(process); - - try { - if (openFile.isReadable()) { - Channel inChannel; - if (process.getInput() != null) { - // NIO-based - inChannel = process.getInput(); - } else { - // Stream-based - inChannel = Channels.newChannel(process.getInputStream()); - } - - ChannelDescriptor main = new ChannelDescriptor( - inChannel, - getNewFileno(), - new FileDescriptor()); - main.setCanBeSeekable(false); - - openFile.setMainStream(new ChannelStream(getRuntime(), main)); - registerDescriptor(main); - } - - if (openFile.isWritable()) { - Channel outChannel; - if (process.getOutput() != null) { - // NIO-based - outChannel = process.getOutput(); - } else { - outChannel = Channels.newChannel(process.getOutputStream()); - } - - ChannelDescriptor pipe = new ChannelDescriptor( - outChannel, - getNewFileno(), - new FileDescriptor()); - pipe.setCanBeSeekable(false); - - if (openFile.getMainStream() != null) { - openFile.setPipeStream(new ChannelStream(getRuntime(), pipe)); - } else { - openFile.setMainStream(new ChannelStream(getRuntime(), pipe)); - } - - registerDescriptor(pipe); - } - } catch (InvalidValueException e) { - throw getRuntime().newErrnoEINVALError(); - } - } - - public RubyIO(Ruby runtime, STDIO stdio) { - super(runtime, runtime.getIO()); - - openFile = new OpenFile(); - - try { - switch (stdio) { - case IN: - openFile.setMainStream( - new ChannelStream( - runtime, - // special constructor that accepts stream, not channel - new ChannelDescriptor(runtime.getIn(), 0, new ModeFlags(ModeFlags.RDONLY), FileDescriptor.in), - FileDescriptor.in)); - break; - case OUT: - openFile.setMainStream( - new ChannelStream( - runtime, - new ChannelDescriptor(Channels.newChannel(runtime.getOut()), 1, new ModeFlags(ModeFlags.WRONLY | ModeFlags.APPEND), FileDescriptor.out), - FileDescriptor.out)); - openFile.getMainStream().setSync(true); - break; - case ERR: - openFile.setMainStream( - new ChannelStream( - runtime, - new ChannelDescriptor(Channels.newChannel(runtime.getErr()), 2, new ModeFlags(ModeFlags.WRONLY | ModeFlags.APPEND), FileDescriptor.err), - FileDescriptor.err)); - openFile.getMainStream().setSync(true); - break; - } - } catch (InvalidValueException ex) { - throw getRuntime().newErrnoEINVALError(); - } - - openFile.setMode(openFile.getMainStream().getModes().getOpenFileFlags()); - - registerDescriptor(openFile.getMainStream().getDescriptor()); - } - - public static RubyIO newIO(Ruby runtime, Channel channel) { - return new RubyIO(runtime, channel); - } - - public OpenFile getOpenFile() { - return openFile; - } - - protected OpenFile getOpenFileChecked() { - openFile.checkClosed(getRuntime()); - return openFile; - } - - private static ObjectAllocator IO_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyIO(runtime, klass); - } - }; - - public static RubyClass createIOClass(Ruby runtime) { - RubyClass ioClass = runtime.defineClass("IO", runtime.getObject(), IO_ALLOCATOR); - ioClass.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyIO; - } - }; - - ioClass.includeModule(runtime.getEnumerable()); - - // TODO: Implement tty? and isatty. We have no real capability to - // determine this from java, but if we could set tty status, then - // we could invoke jruby differently to allow stdin to return true - // on this. This would allow things like cgi.rb to work properly. - - ioClass.defineAnnotatedMethods(RubyIO.class); - - // Constants for seek - ioClass.fastSetConstant("SEEK_SET", runtime.newFixnum(Stream.SEEK_SET)); - ioClass.fastSetConstant("SEEK_CUR", runtime.newFixnum(Stream.SEEK_CUR)); - ioClass.fastSetConstant("SEEK_END", runtime.newFixnum(Stream.SEEK_END)); - - return ioClass; - } - - public OutputStream getOutStream() { - return getOpenFileChecked().getMainStream().newOutputStream(); - } - - public InputStream getInStream() { - return getOpenFileChecked().getMainStream().newInputStream(); - } - - public Channel getChannel() { - if (getOpenFileChecked().getMainStream() instanceof ChannelStream) { - return ((ChannelStream) openFile.getMainStream()).getDescriptor().getChannel(); - } else { - return null; - } - } - - public Stream getHandler() { - return getOpenFileChecked().getMainStream(); - } - - @JRubyMethod(name = "reopen", required = 1, optional = 1) - public IRubyObject reopen(ThreadContext context, IRubyObject[] args) throws InvalidValueException { - Ruby runtime = context.getRuntime(); - - if (args.length < 1) { - throw runtime.newArgumentError("wrong number of arguments"); - } - - IRubyObject tmp = TypeConverter.convertToTypeWithCheck(args[0], runtime.getIO(), - MethodIndex.getIndex("to_io"), "to_io"); - - if (!tmp.isNil()) { - try { - RubyIO ios = (RubyIO) tmp; - - if (ios.openFile == this.openFile) { - return this; - } - - OpenFile originalFile = ios.getOpenFileChecked(); - OpenFile selfFile = getOpenFileChecked(); - - long pos = 0; - if (originalFile.isReadable()) { - pos = originalFile.getMainStream().fgetpos(); - } - - if (originalFile.getPipeStream() != null) { - originalFile.getPipeStream().fflush(); - } else if (originalFile.isWritable()) { - originalFile.getMainStream().fflush(); - } - - if (selfFile.isWritable()) { - selfFile.getWriteStream().fflush(); - } - - selfFile.setMode(originalFile.getMode()); - selfFile.setProcess(originalFile.getProcess()); - selfFile.setLineNumber(originalFile.getLineNumber()); - selfFile.setPath(originalFile.getPath()); - selfFile.setFinalizer(originalFile.getFinalizer()); - - ChannelDescriptor selfDescriptor = selfFile.getMainStream().getDescriptor(); - ChannelDescriptor originalDescriptor = originalFile.getMainStream().getDescriptor(); - - // confirm we're not reopening self's channel - if (selfDescriptor.getChannel() != originalDescriptor.getChannel()) { - // check if we're a stdio IO, and ensure we're not badly mutilated - if (selfDescriptor.getFileno() >=0 && selfDescriptor.getFileno() <= 2) { - selfFile.getMainStream().clearerr(); - - // dup2 new fd into self to preserve fileno and references to it - originalDescriptor.dup2Into(selfDescriptor); - - // re-register, since fileno points at something new now - registerDescriptor(selfDescriptor); - } else { - Stream pipeFile = selfFile.getPipeStream(); - int mode = selfFile.getMode(); - selfFile.getMainStream().fclose(); - selfFile.setPipeStream(null); - - // TODO: turn off readable? am I reading this right? - // This only seems to be used while duping below, since modes gets - // reset to actual modes afterward - //fptr->mode &= (m & FMODE_READABLE) ? ~FMODE_READABLE : ~FMODE_WRITABLE; - - if (pipeFile != null) { - selfFile.setMainStream(ChannelStream.fdopen(runtime, originalDescriptor, new ModeFlags())); - selfFile.setPipeStream(pipeFile); - } else { - selfFile.setMainStream( - new ChannelStream( - runtime, - originalDescriptor.dup2(selfDescriptor.getFileno()))); - - // re-register the descriptor - registerDescriptor(selfFile.getMainStream().getDescriptor()); - - // since we're not actually duping the incoming channel into our handler, we need to - // copy the original sync behavior from the other handler - selfFile.getMainStream().setSync(selfFile.getMainStream().isSync()); - } - selfFile.setMode(mode); - } - - // TODO: anything threads attached to original fd are notified of the close... - // see rb_thread_fd_close - - if (originalFile.isReadable() && pos >= 0) { - selfFile.seek(pos, Stream.SEEK_SET); - originalFile.seek(pos, Stream.SEEK_SET); - } - } - - if (selfFile.getPipeStream() != null && selfDescriptor.getFileno() != selfFile.getPipeStream().getDescriptor().getFileno()) { - int fd = selfFile.getPipeStream().getDescriptor().getFileno(); - - if (originalFile.getPipeStream() == null) { - selfFile.getPipeStream().fclose(); - selfFile.setPipeStream(null); - } else if (fd != originalFile.getPipeStream().getDescriptor().getFileno()) { - selfFile.getPipeStream().fclose(); - ChannelDescriptor newFD2 = originalFile.getPipeStream().getDescriptor().dup2(fd); - selfFile.setPipeStream(ChannelStream.fdopen(runtime, newFD2, getIOModes(runtime, "w"))); - - // re-register, since fileno points at something new now - registerDescriptor(newFD2); - } - } - - // TODO: restore binary mode - // if (fptr->mode & FMODE_BINMODE) { - // rb_io_binmode(io); - // } - - // TODO: set our metaclass to target's class (i.e. scary!) - - } catch (IOException ex) { // TODO: better error handling - throw runtime.newIOError("could not reopen: " + ex.getMessage()); - } catch (BadDescriptorException ex) { - throw runtime.newIOError("could not reopen: " + ex.getMessage()); - } catch (PipeException ex) { - throw runtime.newIOError("could not reopen: " + ex.getMessage()); - } - } else { - IRubyObject pathString = args[0].convertToString(); - - // TODO: check safe, taint on incoming string - - if (openFile == null) { - openFile = new OpenFile(); - } - - try { - ModeFlags modes; - if (args.length > 1) { - IRubyObject modeString = args[1].convertToString(); - modes = getIOModes(runtime, modeString.toString()); - - openFile.setMode(modes.getOpenFileFlags()); - } else { - modes = getIOModes(runtime, "r"); - } - - String path = pathString.toString(); - - // Ruby code frequently uses a platform check to choose "NUL:" on windows - // but since that check doesn't work well on JRuby, we help it out - - openFile.setPath(path); - - if (openFile.getMainStream() == null) { - try { - openFile.setMainStream(ChannelStream.fopen(runtime, path, modes)); - } catch (FileExistsException fee) { - throw runtime.newErrnoEEXISTError(path); - } - - registerDescriptor(openFile.getMainStream().getDescriptor()); - if (openFile.getPipeStream() != null) { - openFile.getPipeStream().fclose(); - unregisterDescriptor(openFile.getPipeStream().getDescriptor().getFileno()); - openFile.setPipeStream(null); - } - return this; - } else { - // TODO: This is an freopen in MRI, this is close, but not quite the same - openFile.getMainStream().freopen(path, getIOModes(runtime, openFile.getModeAsString(runtime))); - - // re-register - registerDescriptor(openFile.getMainStream().getDescriptor()); - - if (openFile.getPipeStream() != null) { - // TODO: pipe handler to be reopened with path and "w" mode - } - } - } catch (PipeException pe) { - throw runtime.newErrnoEPIPEError(); - } catch (IOException ex) { - throw runtime.newIOErrorFromException(ex); - } catch (BadDescriptorException ex) { - throw runtime.newErrnoEBADFError(); - } catch (InvalidValueException e) { - throw runtime.newErrnoEINVALError(); - } - } - - // A potentially previously close IO is being 'reopened'. - return this; - } - - public static ModeFlags getIOModes(Ruby runtime, String modesString) throws InvalidValueException { - return new ModeFlags(getIOModesIntFromString(runtime, modesString)); - } - - public static int getIOModesIntFromString(Ruby runtime, String modesString) { - int modes = 0; - int length = modesString.length(); - - if (length == 0) { - throw runtime.newArgumentError("illegal access mode"); - } - - switch (modesString.charAt(0)) { - case 'r' : - modes |= ModeFlags.RDONLY; - break; - case 'a' : - modes |= ModeFlags.APPEND | ModeFlags.WRONLY | ModeFlags.CREAT; - break; - case 'w' : - modes |= ModeFlags.WRONLY | ModeFlags.TRUNC | ModeFlags.CREAT; - break; - default : - throw runtime.newArgumentError("illegal access mode " + modes); - } - - for (int n = 1; n < length; n++) { - switch (modesString.charAt(n)) { - case 'b': - modes |= ModeFlags.BINARY; - break; - case '+': - modes = (modes & ~ModeFlags.ACCMODE) | ModeFlags.RDWR; - break; - default: - throw runtime.newArgumentError("illegal access mode " + modes); - } - } - - return modes; - } - - private static ByteList getSeparatorFromArgs(Ruby runtime, IRubyObject[] args, int idx) { - IRubyObject sepVal; - - if (args.length > idx) { - sepVal = args[idx]; - } else { - sepVal = runtime.getRecordSeparatorVar().get(); - } - - ByteList separator = sepVal.isNil() ? null : sepVal.convertToString().getByteList(); - - if (separator != null && separator.realSize == 0) { - separator = Stream.PARAGRAPH_DELIMETER; - } - - return separator; - } - - private ByteList getSeparatorForGets(Ruby runtime, IRubyObject[] args) { - return getSeparatorFromArgs(runtime, args, 0); - } - - public IRubyObject getline(Ruby runtime, ByteList separator) { - try { - OpenFile myOpenFile = getOpenFileChecked(); - - myOpenFile.checkReadable(runtime); - myOpenFile.setReadBuffered(); - - boolean isParagraph = separator == Stream.PARAGRAPH_DELIMETER; - separator = (separator == Stream.PARAGRAPH_DELIMETER) ? - Stream.PARAGRAPH_SEPARATOR : separator; - - if (isParagraph) { - swallow('\n'); - } - - if (separator == null) { - IRubyObject str = readAll(null); - if (((RubyString)str).getByteList().length() == 0) { - return runtime.getNil(); - } - incrementLineno(runtime, myOpenFile); - return str; - } else if (separator.length() == 1) { - return getlineFast(runtime, separator.get(0)); - } else { - Stream readStream = myOpenFile.getMainStream(); - int c = -1; - int n = -1; - int newline = separator.get(separator.length() - 1) & 0xFF; - - ByteList buf = new ByteList(0); - boolean update = false; - - while (true) { - do { - readCheck(readStream); - readStream.clearerr(); - - try { - n = readStream.getline(buf, (byte) newline); - c = buf.length() > 0 ? buf.get(buf.length() - 1) & 0xff : -1; - } catch (EOFException e) { - n = -1; - } - - if (n == -1) { - if (!readStream.isBlocking() && (readStream instanceof ChannelStream)) { - if(!(waitReadable(((ChannelStream)readStream).getDescriptor()))) { - throw runtime.newIOError("bad file descriptor: " + openFile.getPath()); - } - - continue; - } else { - break; - } - } - - update = true; - } while (c != newline); // loop until we see the nth separator char - - // if we hit EOF, we're done - if (n == -1) { - break; - } - - // if we've found the last char of the separator, - // and we've found at least as many characters as separator length, - // and the last n characters of our buffer match the separator, we're done - if (c == newline && buf.length() >= separator.length() && - 0 == ByteList.memcmp(buf.unsafeBytes(), buf.begin + buf.realSize - separator.length(), separator.unsafeBytes(), separator.begin, separator.realSize)) { - break; - } - } - - if (isParagraph) { - if (c != -1) { - swallow('\n'); - } - } - - if (!update) { - return runtime.getNil(); - } else { - incrementLineno(runtime, myOpenFile); - RubyString str = RubyString.newString(runtime, buf); - str.setTaint(true); - - return str; - } - } - } catch (PipeException ex) { - throw runtime.newErrnoEPIPEError(); - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } catch (EOFException e) { - return runtime.getNil(); - } catch (BadDescriptorException e) { - throw runtime.newErrnoEBADFError(); - } catch (IOException e) { - throw runtime.newIOError(e.getMessage()); - } - } - - private void incrementLineno(Ruby runtime, OpenFile myOpenFile) { - int lineno = myOpenFile.getLineNumber() + 1; - myOpenFile.setLineNumber(lineno); - runtime.getGlobalVariables().set("$.", runtime.newFixnum(lineno)); - // this is for a range check, near as I can tell - RubyNumeric.int2fix(runtime, myOpenFile.getLineNumber()); - } - - protected boolean swallow(int term) throws IOException, BadDescriptorException { - Stream readStream = openFile.getMainStream(); - int c; - - do { - readCheck(readStream); - - try { - c = readStream.fgetc(); - } catch (EOFException e) { - c = -1; - } - - if (c != term) { - readStream.ungetc(c); - return true; - } - } while (c != -1); - - return false; - } - - public IRubyObject getlineFast(Ruby runtime, int delim) throws IOException, BadDescriptorException { - Stream readStream = openFile.getMainStream(); - int c = -1; - - ByteList buf = new ByteList(0); - boolean update = false; - do { - readCheck(readStream); - readStream.clearerr(); - int n; - try { - n = readStream.getline(buf, (byte) delim); - c = buf.length() > 0 ? buf.get(buf.length() - 1) & 0xff : -1; - } catch (EOFException e) { - n = -1; - } - - if (n == -1) { - if (!readStream.isBlocking() && (readStream instanceof ChannelStream)) { - if(!(waitReadable(((ChannelStream)readStream).getDescriptor()))) { - throw runtime.newIOError("bad file descriptor: " + openFile.getPath()); - } - continue; - } else { - break; - } - } - - update = true; - } while (c != delim); - - if (!update) { - return runtime.getNil(); - } else { - incrementLineno(runtime, openFile); - RubyString str = RubyString.newString(runtime, buf); - str.setTaint(true); - return str; - } - } - // IO class methods. - - @JRubyMethod(name = {"new", "for_fd"}, rest = true, frame = true, meta = true) - public static IRubyObject newInstance(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - RubyClass klass = (RubyClass)recv; - - if (block.isGiven()) { - String className = klass.getName(); - context.getRuntime().getWarnings().warn( - ID.BLOCK_NOT_ACCEPTED, - className + "::new() does not take block; use " + className + "::open() instead", - className + "::open()"); - } - - return klass.newInstance(context, args, block); - } - - @JRubyMethod(name = "initialize", required = 1, optional = 1, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, Block unusedBlock) { - int argCount = args.length; - ModeFlags modes; - - int fileno = RubyNumeric.fix2int(args[0]); - - try { - ChannelDescriptor descriptor = getDescriptorByFileno(fileno); - - if (descriptor == null) { - throw getRuntime().newErrnoEBADFError(); - } - - descriptor.checkOpen(); - - if (argCount == 2) { - if (args[1] instanceof RubyFixnum) { - modes = new ModeFlags(RubyFixnum.fix2long(args[1])); - } else { - modes = getIOModes(getRuntime(), args[1].convertToString().toString()); - } - } else { - // use original modes - modes = descriptor.getOriginalModes(); - } - - openFile.setMode(modes.getOpenFileFlags()); - - openFile.setMainStream(fdopen(descriptor, modes)); - } catch (BadDescriptorException ex) { - throw getRuntime().newErrnoEBADFError(); - } catch (InvalidValueException ive) { - throw getRuntime().newErrnoEINVALError(); - } - - return this; - } - - protected Stream fdopen(ChannelDescriptor existingDescriptor, ModeFlags modes) throws InvalidValueException { - // See if we already have this descriptor open. - // If so then we can mostly share the handler (keep open - // file, but possibly change the mode). - - if (existingDescriptor == null) { - // redundant, done above as well - - // this seems unlikely to happen unless it's a totally bogus fileno - // ...so do we even need to bother trying to create one? - - // IN FACT, we should probably raise an error, yes? - throw getRuntime().newErrnoEBADFError(); - -// if (mode == null) { -// mode = "r"; -// } -// -// try { -// openFile.setMainStream(streamForFileno(getRuntime(), fileno)); -// } catch (BadDescriptorException e) { -// throw getRuntime().newErrnoEBADFError(); -// } catch (IOException e) { -// throw getRuntime().newErrnoEBADFError(); -// } -// //modes = new IOModes(getRuntime(), mode); -// -// registerStream(openFile.getMainStream()); - } else { - // We are creating a new IO object that shares the same - // IOHandler (and fileno). - return ChannelStream.fdopen(getRuntime(), existingDescriptor, modes); - } - } - - @JRubyMethod(name = "open", required = 1, optional = 2, frame = true, meta = true) - public static IRubyObject open(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = context.getRuntime(); - RubyClass klass = (RubyClass)recv; - - RubyIO io = (RubyIO)klass.newInstance(context, args, block); - - if (block.isGiven()) { - try { - return block.yield(context, io); - } finally { - try { - io.getMetaClass().invoke(context, io, "close", IRubyObject.NULL_ARRAY, CallType.FUNCTIONAL, Block.NULL_BLOCK); - } catch (RaiseException re) { - RubyException rubyEx = re.getException(); - if (rubyEx.kind_of_p(context, runtime.getStandardError()).isTrue()) { - // MRI behavior: swallow StandardErorrs - } else { - throw re; - } - } - } - } - - return io; - } - - // This appears to be some windows-only mode. On a java platform this is a no-op - @JRubyMethod(name = "binmode") - public IRubyObject binmode() { - return this; - } - - /** @deprecated will be removed in 1.2 */ - protected void checkInitialized() { - if (openFile == null) { - throw getRuntime().newIOError("uninitialized stream"); - } - } - - /** @deprecated will be removed in 1.2 */ - protected void checkClosed() { - if (openFile.getMainStream() == null && openFile.getPipeStream() == null) { - throw getRuntime().newIOError("closed stream"); - } - } - - @JRubyMethod(name = "syswrite", required = 1) - public IRubyObject syswrite(ThreadContext context, IRubyObject obj) { - Ruby runtime = context.getRuntime(); - - try { - RubyString string = obj.asString(); - OpenFile myOpenFile = getOpenFileChecked(); - - myOpenFile.checkWritable(runtime); - - Stream writeStream = myOpenFile.getWriteStream(); - - if (myOpenFile.isWriteBuffered()) { - runtime.getWarnings().warn(ID.SYSWRITE_BUFFERED_IO, "syswrite for buffered IO"); - } - - if (!writeStream.getDescriptor().isWritable()) { - myOpenFile.checkClosed(runtime); - } - - int read = writeStream.getDescriptor().write(string.getByteList()); - - if (read == -1) { - // TODO? I think this ends up propagating from normal Java exceptions - // sys_fail(openFile.getPath()) - } - - return runtime.newFixnum(read); - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } catch (PipeException ex) { - throw runtime.newErrnoEPIPEError(); - } catch (BadDescriptorException e) { - throw runtime.newErrnoEBADFError(); - } catch (IOException e) { - throw runtime.newSystemCallError(e.getMessage()); - } - } - - @JRubyMethod(name = "write_nonblock", required = 1) - public IRubyObject write_nonblock(ThreadContext context, IRubyObject obj) { - // MRI behavior: always check whether the file is writable - // or not, even if we are to write 0 bytes. - OpenFile myOpenFile = getOpenFileChecked(); - try { - myOpenFile.checkWritable(context.getRuntime()); - } catch (IOException ex) { - throw context.getRuntime().newIOErrorFromException(ex); - } catch (BadDescriptorException ex) { - throw context.getRuntime().newErrnoEBADFError(); - } catch (InvalidValueException ex) { - throw context.getRuntime().newErrnoEINVALError(); - } catch (PipeException ex) { - throw context.getRuntime().newErrnoEPIPEError(); - } - - // TODO: Obviously, we're not doing a non-blocking write here - return write(context, obj); - } - - /** io_write - * - */ - @JRubyMethod(name = "write", required = 1) - public IRubyObject write(ThreadContext context, IRubyObject obj) { - Ruby runtime = context.getRuntime(); - - runtime.secure(4); - - RubyString str = obj.asString(); - - // TODO: Ruby reuses this logic for other "write" behavior by checking if it's an IO and calling write again - - if (str.getByteList().length() == 0) { - return runtime.newFixnum(0); - } - - try { - OpenFile myOpenFile = getOpenFileChecked(); - - myOpenFile.checkWritable(runtime); - - int written = fwrite(str.getByteList()); - - if (written == -1) { - // TODO: sys fail - } - - // if not sync, we switch to write buffered mode - if (!myOpenFile.isSync()) { - myOpenFile.setWriteBuffered(); - } - - return runtime.newFixnum(written); - } catch (IOException ex) { - throw runtime.newIOErrorFromException(ex); - } catch (BadDescriptorException ex) { - throw runtime.newErrnoEBADFError(); - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } catch (PipeException ex) { - throw runtime.newErrnoEPIPEError(); - } - } - - protected boolean waitWritable(ChannelDescriptor descriptor) throws IOException { - Channel channel = descriptor.getChannel(); - if (channel == null || !(channel instanceof SelectableChannel)) { - return false; - } - - Selector selector = Selector.open(); - - ((SelectableChannel) channel).configureBlocking(false); - int real_ops = ((SelectableChannel) channel).validOps() & SelectionKey.OP_WRITE; - SelectionKey key = ((SelectableChannel) channel).keyFor(selector); - - if (key == null) { - ((SelectableChannel) channel).register(selector, real_ops, descriptor); - } else { - key.interestOps(key.interestOps()|real_ops); - } - - while(selector.select() == 0); - - for (Iterator i = selector.selectedKeys().iterator(); i.hasNext(); ) { - SelectionKey skey = (SelectionKey) i.next(); - if ((skey.interestOps() & skey.readyOps() & (SelectionKey.OP_WRITE)) != 0) { - if(skey.attachment() == descriptor) { - return true; - } - } - } - return false; - } - - protected boolean waitReadable(ChannelDescriptor descriptor) throws IOException { - Channel channel = descriptor.getChannel(); - if (channel == null || !(channel instanceof SelectableChannel)) { - return false; - } - - Selector selector = Selector.open(); - - ((SelectableChannel) channel).configureBlocking(false); - int real_ops = ((SelectableChannel) channel).validOps() & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT); - SelectionKey key = ((SelectableChannel) channel).keyFor(selector); - - if (key == null) { - ((SelectableChannel) channel).register(selector, real_ops, descriptor); - } else { - key.interestOps(key.interestOps()|real_ops); - } - - while(selector.select() == 0); - - for (Iterator i = selector.selectedKeys().iterator(); i.hasNext(); ) { - SelectionKey skey = (SelectionKey) i.next(); - if ((skey.interestOps() & skey.readyOps() & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0) { - if(skey.attachment() == descriptor) { - return true; - } - } - } - return false; - } - - protected int fwrite(ByteList buffer) { - int n, r, l, offset = 0; - boolean eagain = false; - Stream writeStream = openFile.getWriteStream(); - - int len = buffer.length(); - - if ((n = len) <= 0) return n; - - try { - if (openFile.isSync()) { - openFile.fflush(writeStream); - - // TODO: why is this guarded? - // if (!rb_thread_fd_writable(fileno(f))) { - // rb_io_check_closed(fptr); - // } - - while(offset<len) { - l = n; - - // TODO: Something about pipe buffer length here - - r = writeStream.getDescriptor().write(buffer,offset,l); - - if(r == len) { - return len; //Everything written - } - - if (0 <= r) { - offset += r; - n -= r; - eagain = true; - } - - if(eagain && waitWritable(writeStream.getDescriptor())) { - openFile.checkClosed(getRuntime()); - if(offset >= buffer.length()) { - return -1; - } - eagain = false; - } else { - return -1; - } - } - - - // TODO: all this stuff...some pipe logic, some async thread stuff - // retry: - // l = n; - // if (PIPE_BUF < l && - // !rb_thread_critical && - // !rb_thread_alone() && - // wsplit_p(fptr)) { - // l = PIPE_BUF; - // } - // TRAP_BEG; - // r = write(fileno(f), RSTRING(str)->ptr+offset, l); - // TRAP_END; - // if (r == n) return len; - // if (0 <= r) { - // offset += r; - // n -= r; - // errno = EAGAIN; - // } - // if (rb_io_wait_writable(fileno(f))) { - // rb_io_check_closed(fptr); - // if (offset < RSTRING(str)->len) - // goto retry; - // } - // return -1L; - } - - // TODO: handle errors in buffered write by retrying until finished or file is closed - return writeStream.fwrite(buffer); - // while (errno = 0, offset += (r = fwrite(RSTRING(str)->ptr+offset, 1, n, f)), (n -= r) > 0) { - // if (ferror(f) - // ) { - // if (rb_io_wait_writable(fileno(f))) { - // rb_io_check_closed(fptr); - // clearerr(f); - // if (offset < RSTRING(str)->len) - // continue; - // } - // return -1L; - // } - // } - -// return len - n; - } catch (IOException ex) { - throw getRuntime().newIOErrorFromException(ex); - } catch (BadDescriptorException ex) { - throw getRuntime().newErrnoEBADFError(); - } - } - - /** rb_io_addstr - * - */ - @JRubyMethod(name = "<<", required = 1) - public IRubyObject op_append(ThreadContext context, IRubyObject anObject) { - // Claims conversion is done via 'to_s' in docs. - callMethod(context, "write", anObject); - - return this; - } - - @JRubyMethod(name = "fileno", alias = "to_i") - public RubyFixnum fileno(ThreadContext context) { - return context.getRuntime().newFixnum(getOpenFileChecked().getMainStream().getDescriptor().getFileno()); - } - - /** Returns the current line number. - * - * @return the current line number. - */ - @JRubyMethod(name = "lineno") - public RubyFixnum lineno(ThreadContext context) { - return context.getRuntime().newFixnum(getOpenFileChecked().getLineNumber()); - } - - /** Sets the current line number. - * - * @param newLineNumber The new line number. - */ - @JRubyMethod(name = "lineno=", required = 1) - public RubyFixnum lineno_set(ThreadContext context, IRubyObject newLineNumber) { - getOpenFileChecked().setLineNumber(RubyNumeric.fix2int(newLineNumber)); - - return context.getRuntime().newFixnum(getOpenFileChecked().getLineNumber()); - } - - /** Returns the current sync mode. - * - * @return the current sync mode. - */ - @JRubyMethod(name = "sync") - public RubyBoolean sync(ThreadContext context) { - return context.getRuntime().newBoolean(getOpenFileChecked().getMainStream().isSync()); - } - - /** - * <p>Return the process id (pid) of the process this IO object - * spawned. If no process exists (popen was not called), then - * nil is returned. This is not how it appears to be defined - * but ruby 1.8 works this way.</p> - * - * @return the pid or nil - */ - @JRubyMethod(name = "pid") - public IRubyObject pid(ThreadContext context) { - OpenFile myOpenFile = getOpenFileChecked(); - - if (myOpenFile.getProcess() == null) { - return context.getRuntime().getNil(); - } - - // Of course this isn't particularly useful. - int pid = myOpenFile.getProcess().hashCode(); - - return context.getRuntime().newFixnum(pid); - } - - /** - * @deprecated - * @return - */ - public boolean writeDataBuffered() { - return openFile.getMainStream().writeDataBuffered(); - } - - @JRubyMethod(name = {"pos", "tell"}) - public RubyFixnum pos(ThreadContext context) { - try { - return context.getRuntime().newFixnum(getOpenFileChecked().getMainStream().fgetpos()); - } catch (InvalidValueException ex) { - throw context.getRuntime().newErrnoEINVALError(); - } catch (BadDescriptorException bde) { - throw context.getRuntime().newErrnoEBADFError(); - } catch (PipeException e) { - throw context.getRuntime().newErrnoESPIPEError(); - } catch (IOException e) { - throw context.getRuntime().newIOError(e.getMessage()); - } - } - - @JRubyMethod(name = "pos=", required = 1) - public RubyFixnum pos_set(ThreadContext context, IRubyObject newPosition) { - long offset = RubyNumeric.num2long(newPosition); - - if (offset < 0) { - throw context.getRuntime().newSystemCallError("Negative seek offset"); - } - - OpenFile myOpenFile = getOpenFileChecked(); - - try { - myOpenFile.getMainStream().lseek(offset, Stream.SEEK_SET); - } catch (BadDescriptorException e) { - throw context.getRuntime().newErrnoEBADFError(); - } catch (InvalidValueException e) { - throw context.getRuntime().newErrnoEINVALError(); - } catch (PipeException e) { - throw context.getRuntime().newErrnoESPIPEError(); - } catch (IOException e) { - throw context.getRuntime().newIOError(e.getMessage()); - } - - myOpenFile.getMainStream().clearerr(); - - return context.getRuntime().newFixnum(offset); - } - - /** Print some objects to the stream. - * - */ - @JRubyMethod(name = "print", rest = true, reads = FrameField.LASTLINE) - public IRubyObject print(ThreadContext context, IRubyObject[] args) { - if (args.length == 0) { - args = new IRubyObject[] { context.getCurrentFrame().getLastLine() }; - } - - Ruby runtime = context.getRuntime(); - IRubyObject fs = runtime.getGlobalVariables().get("$,"); - IRubyObject rs = runtime.getGlobalVariables().get("$\\"); - - for (int i = 0; i < args.length; i++) { - if (i > 0 && !fs.isNil()) { - callMethod(context, "write", fs); - } - if (args[i].isNil()) { - callMethod(context, "write", runtime.newString("nil")); - } else { - callMethod(context, "write", args[i]); - } - } - if (!rs.isNil()) { - callMethod(context, "write", rs); - } - - return runtime.getNil(); - } - - @JRubyMethod(name = "printf", required = 1, rest = true) - public IRubyObject printf(ThreadContext context, IRubyObject[] args) { - callMethod(context, "write", RubyKernel.sprintf(context, this, args)); - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "putc", required = 1, backtrace = true) - public IRubyObject putc(ThreadContext context, IRubyObject object) { - int c = RubyNumeric.num2chr(object); - - try { - getOpenFileChecked().getMainStream().fputc(c); - } catch (BadDescriptorException e) { - return RubyFixnum.zero(context.getRuntime()); - } catch (IOException e) { - return RubyFixnum.zero(context.getRuntime()); - } - - return object; - } - - public RubyFixnum seek(ThreadContext context, IRubyObject[] args) { - long offset = RubyNumeric.num2long(args[0]); - int whence = Stream.SEEK_SET; - - if (args.length > 1) { - whence = RubyNumeric.fix2int(args[1].convertToInteger()); - } - - return doSeek(context, offset, whence); - } - - @JRubyMethod(name = "seek") - public RubyFixnum seek(ThreadContext context, IRubyObject arg0) { - long offset = RubyNumeric.num2long(arg0); - int whence = Stream.SEEK_SET; - - return doSeek(context, offset, whence); - } - - @JRubyMethod(name = "seek") - public RubyFixnum seek(ThreadContext context, IRubyObject arg0, IRubyObject arg1) { - long offset = RubyNumeric.num2long(arg0); - int whence = RubyNumeric.fix2int(arg1.convertToInteger()); - - return doSeek(context, offset, whence); - } - - private RubyFixnum doSeek(ThreadContext context, long offset, int whence) { - OpenFile myOpenFile = getOpenFileChecked(); - - try { - myOpenFile.seek(offset, whence); - } catch (BadDescriptorException ex) { - throw context.getRuntime().newErrnoEBADFError(); - } catch (InvalidValueException e) { - throw context.getRuntime().newErrnoEINVALError(); - } catch (PipeException e) { - throw context.getRuntime().newErrnoESPIPEError(); - } catch (IOException e) { - throw context.getRuntime().newIOError(e.getMessage()); - } - - myOpenFile.getMainStream().clearerr(); - - return RubyFixnum.zero(context.getRuntime()); - } - - // This was a getOpt with one mandatory arg, but it did not work - // so I am parsing it for now. - @JRubyMethod(name = "sysseek", required = 1, optional = 1) - public RubyFixnum sysseek(ThreadContext context, IRubyObject[] args) { - long offset = RubyNumeric.num2long(args[0]); - long pos; - int whence = Stream.SEEK_SET; - - if (args.length > 1) { - whence = RubyNumeric.fix2int(args[1].convertToInteger()); - } - - OpenFile myOpenFile = getOpenFileChecked(); - - try { - - if (myOpenFile.isReadable() && myOpenFile.isReadBuffered()) { - throw context.getRuntime().newIOError("sysseek for buffered IO"); - } - if (myOpenFile.isWritable() && myOpenFile.isWriteBuffered()) { - context.getRuntime().getWarnings().warn(ID.SYSSEEK_BUFFERED_IO, "sysseek for buffered IO"); - } - - pos = myOpenFile.getMainStream().getDescriptor().lseek(offset, whence); - } catch (BadDescriptorException ex) { - throw context.getRuntime().newErrnoEBADFError(); - } catch (InvalidValueException e) { - throw context.getRuntime().newErrnoEINVALError(); - } catch (PipeException e) { - throw context.getRuntime().newErrnoESPIPEError(); - } catch (IOException e) { - throw context.getRuntime().newIOError(e.getMessage()); - } - - myOpenFile.getMainStream().clearerr(); - - return context.getRuntime().newFixnum(pos); - } - - @JRubyMethod(name = "rewind") - public RubyFixnum rewind(ThreadContext context) { - OpenFile myOpenfile = getOpenFileChecked(); - - try { - myOpenfile.getMainStream().lseek(0L, Stream.SEEK_SET); - myOpenfile.getMainStream().clearerr(); - - // TODO: This is some goofy global file value from MRI..what to do? -// if (io == current_file) { -// gets_lineno -= fptr->lineno; -// } - } catch (BadDescriptorException e) { - throw context.getRuntime().newErrnoEBADFError(); - } catch (InvalidValueException e) { - throw context.getRuntime().newErrnoEINVALError(); - } catch (PipeException e) { - throw context.getRuntime().newErrnoESPIPEError(); - } catch (IOException e) { - throw context.getRuntime().newIOError(e.getMessage()); - } - - // Must be back on first line on rewind. - myOpenfile.setLineNumber(0); - - return RubyFixnum.zero(context.getRuntime()); - } - - @JRubyMethod(name = "fsync") - public RubyFixnum fsync(ThreadContext context) { - Ruby runtime = context.getRuntime(); - - try { - OpenFile myOpenFile = getOpenFileChecked(); - - myOpenFile.checkWritable(runtime); - - myOpenFile.getWriteStream().sync(); - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } catch (PipeException ex) { - throw runtime.newErrnoEPIPEError(); - } catch (IOException e) { - throw runtime.newIOError(e.getMessage()); - } catch (BadDescriptorException e) { - throw runtime.newErrnoEBADFError(); - } - - return RubyFixnum.zero(runtime); - } - - /** Sets the current sync mode. - * - * @param newSync The new sync mode. - */ - @JRubyMethod(name = "sync=", required = 1) - public IRubyObject sync_set(IRubyObject newSync) { - getOpenFileChecked().setSync(newSync.isTrue()); - getOpenFileChecked().getMainStream().setSync(newSync.isTrue()); - - return this; - } - - @JRubyMethod(name = {"eof?", "eof"}) - public RubyBoolean eof_p(ThreadContext context) { - Ruby runtime = context.getRuntime(); - - try { - OpenFile myOpenFile = getOpenFileChecked(); - - myOpenFile.checkReadable(runtime); - myOpenFile.setReadBuffered(); - - if (myOpenFile.getMainStream().feof()) { - return runtime.getTrue(); - } - - if (myOpenFile.getMainStream().readDataBuffered()) { - return runtime.getFalse(); - } - - readCheck(myOpenFile.getMainStream()); - - myOpenFile.getMainStream().clearerr(); - - int c = myOpenFile.getMainStream().fgetc(); - - if (c != -1) { - myOpenFile.getMainStream().ungetc(c); - return runtime.getFalse(); - } - - myOpenFile.checkClosed(runtime); - - myOpenFile.getMainStream().clearerr(); - - return runtime.getTrue(); - } catch (PipeException ex) { - throw runtime.newErrnoEPIPEError(); - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } catch (BadDescriptorException e) { - throw runtime.newErrnoEBADFError(); - } catch (IOException e) { - throw runtime.newIOError(e.getMessage()); - } - } - - @JRubyMethod(name = {"tty?", "isatty"}) - public RubyBoolean tty_p(ThreadContext context) { - return context.getRuntime().newBoolean(context.getRuntime().getPosix().isatty(getOpenFileChecked().getMainStream().getDescriptor().getFileDescriptor())); - } - - @JRubyMethod(name = "initialize_copy", required = 1) - @Override - public IRubyObject initialize_copy(IRubyObject original){ - Ruby runtime = getRuntime(); - - if (this == original) return this; - - RubyIO originalIO = (RubyIO) TypeConverter.convertToTypeWithCheck(original, runtime.getIO(), MethodIndex.TO_IO, "to_io"); - - OpenFile originalFile = originalIO.getOpenFileChecked(); - OpenFile newFile = openFile; - - try { - // TODO: I didn't see where MRI has this check, but it seems to be the right place - originalFile.checkClosed(runtime); - - if (originalFile.getPipeStream() != null) { - originalFile.getPipeStream().fflush(); - originalFile.getMainStream().lseek(0, Stream.SEEK_CUR); - } else if (originalFile.isWritable()) { - originalFile.getMainStream().fflush(); - } else { - originalFile.getMainStream().lseek(0, Stream.SEEK_CUR); - } - - newFile.setMode(originalFile.getMode()); - newFile.setProcess(originalFile.getProcess()); - newFile.setLineNumber(originalFile.getLineNumber()); - newFile.setPath(originalFile.getPath()); - newFile.setFinalizer(originalFile.getFinalizer()); - - ModeFlags modes; - if (newFile.isReadable()) { - if (newFile.isWritable()) { - if (newFile.getPipeStream() != null) { - modes = new ModeFlags(ModeFlags.RDONLY); - } else { - modes = new ModeFlags(ModeFlags.RDWR); - } - } else { - modes = new ModeFlags(ModeFlags.RDONLY); - } - } else { - if (newFile.isWritable()) { - modes = new ModeFlags(ModeFlags.WRONLY); - } else { - modes = originalFile.getMainStream().getModes(); - } - } - - ChannelDescriptor descriptor = originalFile.getMainStream().getDescriptor().dup(); - - newFile.setMainStream(ChannelStream.fdopen(runtime, descriptor, modes)); - - // TODO: the rest of this...seeking to same position is unnecessary since we share a channel - // but some of this may be needed? - -// fseeko(fptr->f, ftello(orig->f), SEEK_SET); -// if (orig->f2) { -// if (fileno(orig->f) != fileno(orig->f2)) { -// fd = ruby_dup(fileno(orig->f2)); -// } -// fptr->f2 = rb_fdopen(fd, "w"); -// fseeko(fptr->f2, ftello(orig->f2), SEEK_SET); -// } -// if (fptr->mode & FMODE_BINMODE) { -// rb_io_binmode(dest); -// } - - // Register the new descriptor - registerDescriptor(newFile.getMainStream().getDescriptor()); - } catch (IOException ex) { - throw runtime.newIOError("could not init copy: " + ex); - } catch (BadDescriptorException ex) { - throw runtime.newIOError("could not init copy: " + ex); - } catch (PipeException ex) { - throw runtime.newIOError("could not init copy: " + ex); - } catch (InvalidValueException ex) { - throw runtime.newIOError("could not init copy: " + ex); - } - - return this; - } - - /** Closes the IO. - * - * @return The IO. - */ - @JRubyMethod(name = "closed?") - public RubyBoolean closed_p(ThreadContext context) { - return context.getRuntime().newBoolean(openFile.getMainStream() == null && openFile.getPipeStream() == null); - } - - /** - * <p>Closes all open resources for the IO. It also removes - * it from our magical all open file descriptor pool.</p> - * - * @return The IO. - */ - @JRubyMethod(name = "close") - public IRubyObject close() { - Ruby runtime = getRuntime(); - - if (runtime.getSafeLevel() >= 4 && isTaint()) { - throw runtime.newSecurityError("Insecure: can't close"); - } - - openFile.checkClosed(runtime); - return close2(runtime); - } - - protected IRubyObject close2(Ruby runtime) { - if (openFile == null) return runtime.getNil(); - - // These would be used when we notify threads...if we notify threads - interruptBlockingThreads(); - - ChannelDescriptor main, pipe; - if (openFile.getPipeStream() != null) { - pipe = openFile.getPipeStream().getDescriptor(); - } else { - if (openFile.getMainStream() == null) { - return runtime.getNil(); - } - pipe = null; - } - - main = openFile.getMainStream().getDescriptor(); - - // cleanup, raising errors if any - openFile.cleanup(runtime, true); - - // TODO: notify threads waiting on descriptors/IO? probably not... - - if (openFile.getProcess() != null) { - try { - IRubyObject processResult = RubyProcess.RubyStatus.newProcessStatus(runtime, openFile.getProcess().waitFor()); - runtime.getGlobalVariables().set("$?", processResult); - } catch (InterruptedException ie) { - // TODO: do something here? - } - } - - return runtime.getNil(); - } - - @JRubyMethod(name = "close_write") - public IRubyObject close_write(ThreadContext context) throws BadDescriptorException { - try { - if (context.getRuntime().getSafeLevel() >= 4 && isTaint()) { - throw context.getRuntime().newSecurityError("Insecure: can't close"); - } - - OpenFile myOpenFile = getOpenFileChecked(); - - if (myOpenFile.getPipeStream() == null && myOpenFile.isReadable()) { - throw context.getRuntime().newIOError("closing non-duplex IO for writing"); - } - - if (myOpenFile.getPipeStream() == null) { - close(); - } else{ - myOpenFile.getPipeStream().fclose(); - myOpenFile.setPipeStream(null); - myOpenFile.setMode(myOpenFile.getMode() & ~OpenFile.WRITABLE); - // TODO - // n is result of fclose; but perhaps having a SysError below is enough? - // if (n != 0) rb_sys_fail(fptr->path); - } - } catch (IOException ioe) { - // hmmmm - } - return this; - } - - @JRubyMethod(name = "close_read") - public IRubyObject close_read(ThreadContext context) throws BadDescriptorException { - Ruby runtime = context.getRuntime(); - - try { - if (runtime.getSafeLevel() >= 4 && isTaint()) { - throw runtime.newSecurityError("Insecure: can't close"); - } - - OpenFile myOpenFile = getOpenFileChecked(); - - if (myOpenFile.getPipeStream() == null && myOpenFile.isWritable()) { - throw runtime.newIOError("closing non-duplex IO for reading"); - } - - if (myOpenFile.getPipeStream() == null) { - close(); - } else{ - myOpenFile.getMainStream().fclose(); - myOpenFile.setMode(myOpenFile.getMode() & ~OpenFile.READABLE); - myOpenFile.setMainStream(myOpenFile.getPipeStream()); - myOpenFile.setPipeStream(null); - // TODO - // n is result of fclose; but perhaps having a SysError below is enough? - // if (n != 0) rb_sys_fail(fptr->path); - } - } catch (IOException ioe) { - // I believe Ruby bails out with a "bug" if closing fails - throw runtime.newIOErrorFromException(ioe); - } - return this; - } - - /** Flushes the IO output stream. - * - * @return The IO. - */ - @JRubyMethod(name = "flush") - public RubyIO flush() { - try { - getOpenFileChecked().getWriteStream().fflush(); - } catch (BadDescriptorException e) { - throw getRuntime().newErrnoEBADFError(); - } catch (IOException e) { - throw getRuntime().newIOError(e.getMessage()); - } - - return this; - } - - /** Read a line. - * - */ - @JRubyMethod(name = "gets", optional = 1, writes = FrameField.LASTLINE) - public IRubyObject gets(ThreadContext context, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - ByteList separator = getSeparatorForGets(runtime, args); - - IRubyObject result = getline(runtime, separator); - - if (!result.isNil()) context.getCurrentFrame().setLastLine(result); - - return result; - } - - public boolean getBlocking() { - return ((ChannelStream) openFile.getMainStream()).isBlocking(); - } - - @JRubyMethod(name = "fcntl", required = 2) - public IRubyObject fcntl(ThreadContext context, IRubyObject cmd, IRubyObject arg) { - // TODO: This version differs from ioctl by checking whether fcntl exists - // and raising notimplemented if it doesn't; perhaps no difference for us? - return ctl(context.getRuntime(), cmd, arg); - } - - @JRubyMethod(name = "ioctl", required = 1, optional = 1) - public IRubyObject ioctl(ThreadContext context, IRubyObject[] args) { - IRubyObject cmd = args[0]; - IRubyObject arg; - - if (args.length == 2) { - arg = args[1]; - } else { - arg = context.getRuntime().getNil(); - } - - return ctl(context.getRuntime(), cmd, arg); - } - - public IRubyObject ctl(Ruby runtime, IRubyObject cmd, IRubyObject arg) { - long realCmd = cmd.convertToInteger().getLongValue(); - long nArg = 0; - - // FIXME: Arg may also be true, false, and nil and still be valid. Strangely enough, - // protocol conversion is not happening in Ruby on this arg? - if (arg.isNil() || arg == runtime.getFalse()) { - nArg = 0; - } else if (arg instanceof RubyFixnum) { - nArg = RubyFixnum.fix2long(arg); - } else if (arg == runtime.getTrue()) { - nArg = 1; - } else { - throw runtime.newNotImplementedError("JRuby does not support string for second fcntl/ioctl argument yet"); - } - - OpenFile myOpenFile = getOpenFileChecked(); - - // Fixme: Only F_SETFL is current supported - if (realCmd == 1L) { // cmd is F_SETFL - boolean block = true; - - if ((nArg & ModeFlags.NONBLOCK) == ModeFlags.NONBLOCK) { - block = false; - } - - try { - myOpenFile.getMainStream().setBlocking(block); - } catch (IOException e) { - throw runtime.newIOError(e.getMessage()); - } - } else { - throw runtime.newNotImplementedError("JRuby only supports F_SETFL for fcntl/ioctl currently"); - } - - return runtime.newFixnum(0); - } - - private static final ByteList NIL_BYTELIST = ByteList.create("nil"); - private static final ByteList RECURSIVE_BYTELIST = ByteList.create("[...]"); - - @JRubyMethod(name = "puts", rest = true) - public IRubyObject puts(ThreadContext context, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - assert runtime.getGlobalVariables().getDefaultSeparator() instanceof RubyString; - RubyString separator = (RubyString) runtime.getGlobalVariables().getDefaultSeparator(); - - if (args.length == 0) { - write(context, separator.getByteList()); - return runtime.getNil(); - } - - for (int i = 0; i < args.length; i++) { - ByteList line; - - if (args[i].isNil()) { - line = NIL_BYTELIST; - } else if (runtime.isInspecting(args[i])) { - line = RECURSIVE_BYTELIST; - } else if (args[i] instanceof RubyArray) { - inspectPuts(context, (RubyArray) args[i]); - continue; - } else { - line = args[i].asString().getByteList(); - } - - write(context, line); - - if (line.length() == 0 || !line.endsWith(separator.getByteList())) { - write(context, separator.getByteList()); - } - } - return runtime.getNil(); - } - - protected void write(ThreadContext context, ByteList byteList) { - callMethod(context, "write", RubyString.newStringShared(context.getRuntime(), byteList)); - } - - private IRubyObject inspectPuts(ThreadContext context, RubyArray array) { - try { - context.getRuntime().registerInspecting(array); - return puts(context, array.toJavaArray()); - } finally { - context.getRuntime().unregisterInspecting(array); - } - } - - /** Read a line. - * - */ - @JRubyMethod(name = "readline", optional = 1, writes = FrameField.LASTLINE) - public IRubyObject readline(ThreadContext context, IRubyObject[] args) { - IRubyObject line = gets(context, args); - - if (line.isNil()) throw context.getRuntime().newEOFError(); - - return line; - } - - /** Read a byte. On EOF returns nil. - * - */ - @JRubyMethod(name = "getc") - public IRubyObject getc() { - try { - OpenFile myOpenFile = getOpenFileChecked(); - - myOpenFile.checkReadable(getRuntime()); - myOpenFile.setReadBuffered(); - - Stream stream = myOpenFile.getMainStream(); - - readCheck(stream); - stream.clearerr(); - - int c = myOpenFile.getMainStream().fgetc(); - - if (c == -1) { - // TODO: check for ferror, clear it, and try once more up above readCheck -// if (ferror(f)) { -// clearerr(f); -// if (!rb_io_wait_readable(fileno(f))) -// rb_sys_fail(fptr->path); -// goto retry; -// } - return getRuntime().getNil(); - } - - return getRuntime().newFixnum(c); - } catch (PipeException ex) { - throw getRuntime().newErrnoEPIPEError(); - } catch (InvalidValueException ex) { - throw getRuntime().newErrnoEINVALError(); - } catch (BadDescriptorException e) { - throw getRuntime().newErrnoEBADFError(); - } catch (EOFException e) { - throw getRuntime().newEOFError(); - } catch (IOException e) { - throw getRuntime().newIOError(e.getMessage()); - } - } - - private void readCheck(Stream stream) { - if (!stream.readDataBuffered()) { - openFile.checkClosed(getRuntime()); - } - } - - /** - * <p>Pushes char represented by int back onto IOS.</p> - * - * @param number to push back - */ - @JRubyMethod(name = "ungetc", required = 1) - public IRubyObject ungetc(IRubyObject number) { - int ch = RubyNumeric.fix2int(number); - - OpenFile myOpenFile = getOpenFileChecked(); - - if (!myOpenFile.isReadBuffered()) { - throw getRuntime().newIOError("unread stream"); - } - - try { - myOpenFile.checkReadable(getRuntime()); - myOpenFile.setReadBuffered(); - - if (myOpenFile.getMainStream().ungetc(ch) == -1 && ch != -1) { - throw getRuntime().newIOError("ungetc failed"); - } - } catch (PipeException ex) { - throw getRuntime().newErrnoEPIPEError(); - } catch (InvalidValueException ex) { - throw getRuntime().newErrnoEINVALError(); - } catch (BadDescriptorException e) { - throw getRuntime().newErrnoEBADFError(); - } catch (EOFException e) { - throw getRuntime().newEOFError(); - } catch (IOException e) { - throw getRuntime().newIOError(e.getMessage()); - } - - return getRuntime().getNil(); - } - - @JRubyMethod(name = "read_nonblock", required = 1, optional = 1) - public IRubyObject read_nonblock(ThreadContext context, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - openFile.checkClosed(runtime); - - if(!(openFile.getMainStream() instanceof ChannelStream)) { - // cryptic for the uninitiated... - throw runtime.newNotImplementedError("read_nonblock only works with Nio based handlers"); - } - try { - int maxLength = RubyNumeric.fix2int(args[0]); - if (maxLength < 0) { - throw runtime.newArgumentError("negative length " + maxLength + " given"); - } - ByteList buf = ((ChannelStream)openFile.getMainStream()).readnonblock(RubyNumeric.fix2int(args[0])); - IRubyObject strbuf = RubyString.newString(runtime, buf == null ? new ByteList(ByteList.NULL_ARRAY) : buf); - if(args.length > 1) { - args[1].callMethod(context, MethodIndex.OP_LSHIFT, "<<", strbuf); - return args[1]; - } - - return strbuf; - } catch (BadDescriptorException e) { - throw runtime.newErrnoEBADFError(); - } catch (EOFException e) { - return runtime.getNil(); - } catch (IOException e) { - throw runtime.newIOError(e.getMessage()); - } - } - - @JRubyMethod(name = "readpartial", required = 1, optional = 1) - public IRubyObject readpartial(ThreadContext context, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - openFile.checkClosed(runtime); - - if(!(openFile.getMainStream() instanceof ChannelStream)) { - // cryptic for the uninitiated... - throw runtime.newNotImplementedError("readpartial only works with Nio based handlers"); - } - try { - int maxLength = RubyNumeric.fix2int(args[0]); - if (maxLength < 0) { - throw runtime.newArgumentError("negative length " + maxLength + " given"); - } - ByteList buf = ((ChannelStream)openFile.getMainStream()).readpartial(RubyNumeric.fix2int(args[0])); - IRubyObject strbuf = RubyString.newString(runtime, buf == null ? new ByteList(ByteList.NULL_ARRAY) : buf); - if(args.length > 1) { - args[1].callMethod(context, MethodIndex.OP_LSHIFT, "<<", strbuf); - return args[1]; - } - - return strbuf; - } catch (BadDescriptorException e) { - throw runtime.newErrnoEBADFError(); - } catch (EOFException e) { - return runtime.getNil(); - } catch (IOException e) { - throw runtime.newIOError(e.getMessage()); - } - } - - @JRubyMethod(name = "sysread", required = 1, optional = 1) - public IRubyObject sysread(ThreadContext context, IRubyObject[] args) { - int len = (int)RubyNumeric.num2long(args[0]); - if (len < 0) throw getRuntime().newArgumentError("Negative size"); - - try { - RubyString str; - ByteList buffer; - if (args.length == 1 || args[1].isNil()) { - if (len == 0) { - return RubyString.newStringShared(getRuntime(), ByteList.EMPTY_BYTELIST); - } - - buffer = new ByteList(len); - str = RubyString.newString(getRuntime(), buffer); - } else { - str = args[1].convertToString(); - str.modify(len); - - if (len == 0) { - return str; - } - - buffer = str.getByteList(); - } - - OpenFile myOpenFile = getOpenFileChecked(); - - myOpenFile.checkReadable(getRuntime()); - - if (myOpenFile.getMainStream().readDataBuffered()) { - throw getRuntime().newIOError("sysread for buffered IO"); - } - - // TODO: Ruby locks the string here - - context.getThread().beforeBlockingCall(); - myOpenFile.checkClosed(getRuntime()); - - // TODO: Ruby re-checks that the buffer string hasn't been modified - - int bytesRead = myOpenFile.getMainStream().getDescriptor().read(len, str.getByteList()); - - // TODO: Ruby unlocks the string here - - // TODO: Ruby truncates string to specific size here, but our bytelist should handle this already? - - if (bytesRead == -1 || (bytesRead == 0 && len > 0)) { - throw getRuntime().newEOFError(); - } - - str.setTaint(true); - - return str; - } catch (BadDescriptorException e) { - throw getRuntime().newErrnoEBADFError(); - } catch (InvalidValueException e) { - throw getRuntime().newErrnoEINVALError(); - } catch (PipeException e) { - throw getRuntime().newErrnoEPIPEError(); - } catch (EOFException e) { - throw getRuntime().newEOFError(); - } catch (IOException e) { - // All errors to sysread should be SystemCallErrors, but on a closed stream - // Ruby returns an IOError. Java throws same exception for all errors so - // we resort to this hack... - if ("File not open".equals(e.getMessage())) { - throw getRuntime().newIOError(e.getMessage()); - } - throw getRuntime().newSystemCallError(e.getMessage()); - } finally { - context.getThread().afterBlockingCall(); - } - } - - public IRubyObject read(IRubyObject[] args) { - ThreadContext context = getRuntime().getCurrentContext(); - - switch (args.length) { - case 0: return read(context); - case 1: return read(context, args[0]); - case 2: return read(context, args[0], args[1]); - default: throw getRuntime().newArgumentError(args.length, 2); - } - } - - @JRubyMethod(name = "read") - public IRubyObject read(ThreadContext context) { - Ruby runtime = context.getRuntime(); - OpenFile myOpenFile = getOpenFileChecked(); - - try { - myOpenFile.checkReadable(runtime); - myOpenFile.setReadBuffered(); - - return readAll(getRuntime().getNil()); - } catch (PipeException ex) { - throw getRuntime().newErrnoEPIPEError(); - } catch (InvalidValueException ex) { - throw getRuntime().newErrnoEINVALError(); - } catch (EOFException ex) { - throw getRuntime().newEOFError(); - } catch (IOException ex) { - throw getRuntime().newIOErrorFromException(ex); - } catch (BadDescriptorException ex) { - throw getRuntime().newErrnoEBADFError(); - } - } - - @JRubyMethod(name = "read") - public IRubyObject read(ThreadContext context, IRubyObject arg0) { - if (arg0.isNil()) { - return read(context); - } - - OpenFile myOpenFile = getOpenFileChecked(); - - int length = RubyNumeric.num2int(arg0); - - if (length < 0) { - throw getRuntime().newArgumentError("negative length " + length + " given"); - } - - RubyString str = null; - - return readNotAll(context, myOpenFile, length, str); - } - - @JRubyMethod(name = "read") - public IRubyObject read(ThreadContext context, IRubyObject arg0, IRubyObject arg1) { - OpenFile myOpenFile = getOpenFileChecked(); - - if (arg0.isNil()) { - try { - myOpenFile.checkReadable(getRuntime()); - myOpenFile.setReadBuffered(); - - return readAll(arg1); - } catch (PipeException ex) { - throw getRuntime().newErrnoEPIPEError(); - } catch (InvalidValueException ex) { - throw getRuntime().newErrnoEINVALError(); - } catch (EOFException ex) { - throw getRuntime().newEOFError(); - } catch (IOException ex) { - throw getRuntime().newIOErrorFromException(ex); - } catch (BadDescriptorException ex) { - throw getRuntime().newErrnoEBADFError(); - } - } - - int length = RubyNumeric.num2int(arg0); - - if (length < 0) { - throw getRuntime().newArgumentError("negative length " + length + " given"); - } - - RubyString str = null; -// ByteList buffer = null; - if (arg1.isNil()) { -// buffer = new ByteList(length); -// str = RubyString.newString(getRuntime(), buffer); - } else { - str = arg1.convertToString(); - str.modify(length); - - if (length == 0) { - return str; - } - -// buffer = str.getByteList(); - } - - return readNotAll(context, myOpenFile, length, str); - } - - private IRubyObject readNotAll(ThreadContext context, OpenFile myOpenFile, int length, RubyString str) { - Ruby runtime = context.getRuntime(); - - try { - myOpenFile.checkReadable(runtime); - myOpenFile.setReadBuffered(); - - if (myOpenFile.getMainStream().feof()) { - return runtime.getNil(); - } - - // TODO: Ruby locks the string here - - // READ_CHECK from MRI io.c - readCheck(myOpenFile.getMainStream()); - - // TODO: check buffer length again? - // if (RSTRING(str)->len != len) { - // rb_raise(rb_eRuntimeError, "buffer string modified"); - // } - - // TODO: read into buffer using all the fread logic - // int read = openFile.getMainStream().fread(buffer); - ByteList newBuffer = myOpenFile.getMainStream().fread(length); - - // TODO: Ruby unlocks the string here - - // TODO: change this to check number read into buffer once that's working - // if (read == 0) { - - if (newBuffer == null || newBuffer.length() == 0) { - if (myOpenFile.getMainStream() == null) { - return runtime.getNil(); - } - - if (myOpenFile.getMainStream().feof()) { - // truncate buffer string to zero, if provided - if (str != null) { - str.setValue(ByteList.EMPTY_BYTELIST.dup()); - } - - return runtime.getNil(); - } - - // Removed while working on JRUBY-2386, since fixes for that - // modified EOF logic such that this check is not really valid. - // We expect that an EOFException will be thrown now in EOF - // cases. -// if (length > 0) { -// // I think this is only partly correct; sys fail based on errno in Ruby -// throw getRuntime().newEOFError(); -// } - } - - - // TODO: Ruby truncates string to specific size here, but our bytelist should handle this already? - - // FIXME: I don't like the null checks here - if (str == null) { - if (newBuffer == null) { - str = RubyString.newEmptyString(runtime); - } else { - str = RubyString.newString(runtime, newBuffer); - } - } else { - if (newBuffer == null) { - str.empty(); - } else { - str.setValue(newBuffer); - } - } - str.setTaint(true); - - return str; - } catch (EOFException ex) { - throw runtime.newEOFError(); - } catch (PipeException ex) { - throw runtime.newErrnoEPIPEError(); - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } catch (IOException ex) { - throw runtime.newIOErrorFromException(ex); - } catch (BadDescriptorException ex) { - throw runtime.newErrnoEBADFError(); - } - } - - protected IRubyObject readAll(IRubyObject buffer) throws BadDescriptorException, EOFException, IOException { - Ruby runtime = getRuntime(); - // TODO: handle writing into original buffer better - - RubyString str = null; - if (buffer instanceof RubyString) { - str = (RubyString)buffer; - } - - // TODO: ruby locks the string here - - // READ_CHECK from MRI io.c - if (openFile.getMainStream().readDataBuffered()) { - openFile.checkClosed(runtime); - } - - ByteList newBuffer = openFile.getMainStream().readall(); - - // TODO same zero-length checks as file above - - if (str == null) { - if (newBuffer == null) { - str = RubyString.newEmptyString(runtime); - } else { - str = RubyString.newString(runtime, newBuffer); - } - } else { - if (newBuffer == null) { - str.empty(); - } else { - str.setValue(newBuffer); - } - } - - str.taint(runtime.getCurrentContext()); - - return str; -// long bytes = 0; -// long n; -// -// if (siz == 0) siz = BUFSIZ; -// if (NIL_P(str)) { -// str = rb_str_new(0, siz); -// } -// else { -// rb_str_resize(str, siz); -// } -// for (;;) { -// rb_str_locktmp(str); -// READ_CHECK(fptr->f); -// n = io_fread(RSTRING(str)->ptr+bytes, siz-bytes, fptr); -// rb_str_unlocktmp(str); -// if (n == 0 && bytes == 0) { -// if (!fptr->f) break; -// if (feof(fptr->f)) break; -// if (!ferror(fptr->f)) break; -// rb_sys_fail(fptr->path); -// } -// bytes += n; -// if (bytes < siz) break; -// siz += BUFSIZ; -// rb_str_resize(str, siz); -// } -// if (bytes != siz) rb_str_resize(str, bytes); -// OBJ_TAINT(str); -// -// return str; - } - - // TODO: There's a lot of complexity here due to error handling and - // nonblocking IO; much of this goes away, but for now I'm just - // having read call ChannelStream.fread directly. -// protected int fread(int len, ByteList buffer) { -// long n = len; -// int c; -// int saved_errno; -// -// while (n > 0) { -// c = read_buffered_data(ptr, n, fptr->f); -// if (c < 0) goto eof; -// if (c > 0) { -// ptr += c; -// if ((n -= c) <= 0) break; -// } -// rb_thread_wait_fd(fileno(fptr->f)); -// rb_io_check_closed(fptr); -// clearerr(fptr->f); -// TRAP_BEG; -// c = getc(fptr->f); -// TRAP_END; -// if (c == EOF) { -// eof: -// if (ferror(fptr->f)) { -// switch (errno) { -// case EINTR: -// #if defined(ERESTART) -// case ERESTART: -// #endif -// clearerr(fptr->f); -// continue; -// case EAGAIN: -// #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN -// case EWOULDBLOCK: -// #endif -// if (len > n) { -// clearerr(fptr->f); -// } -// saved_errno = errno; -// rb_warning("nonblocking IO#read is obsolete; use IO#readpartial or IO#sysread"); -// errno = saved_errno; -// } -// if (len == n) return 0; -// } -// break; -// } -// *ptr++ = c; -// n--; -// } -// return len - n; -// -// } - - /** Read a byte. On EOF throw EOFError. - * - */ - @JRubyMethod(name = "readchar") - public IRubyObject readchar() { - IRubyObject c = getc(); - - if (c.isNil()) throw getRuntime().newEOFError(); - - return c; - } - - @JRubyMethod - public IRubyObject stat(ThreadContext context) { - openFile.checkClosed(context.getRuntime()); - return context.getRuntime().newFileStat(getOpenFileChecked().getMainStream().getDescriptor().getFileDescriptor()); - } - - /** - * <p>Invoke a block for each byte.</p> - */ - @JRubyMethod(name = "each_byte", frame = true) - public IRubyObject each_byte(ThreadContext context, Block block) { - Ruby runtime = context.getRuntime(); - - try { - OpenFile myOpenFile = getOpenFileChecked(); - - while (true) { - myOpenFile.checkReadable(runtime); - myOpenFile.setReadBuffered(); - - // TODO: READ_CHECK from MRI - - int c = myOpenFile.getMainStream().fgetc(); - - if (c == -1) { - // TODO: check for error, clear it, and wait until readable before trying once more -// if (ferror(f)) { -// clearerr(f); -// if (!rb_io_wait_readable(fileno(f))) -// rb_sys_fail(fptr->path); -// continue; -// } - break; - } - - assert c < 256; - block.yield(context, getRuntime().newFixnum(c)); - } - - // TODO: one more check for error -// if (ferror(f)) rb_sys_fail(fptr->path); - return this; - } catch (PipeException ex) { - throw runtime.newErrnoEPIPEError(); - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } catch (BadDescriptorException e) { - throw runtime.newErrnoEBADFError(); - } catch (EOFException e) { - return runtime.getNil(); - } catch (IOException e) { - throw runtime.newIOError(e.getMessage()); - } - } - - /** - * <p>Invoke a block for each line.</p> - */ - @JRubyMethod(name = {"each_line", "each"}, optional = 1, frame = true) - public RubyIO each_line(ThreadContext context, IRubyObject[] args, Block block) { - Ruby runtime = context.getRuntime(); - ByteList separator = getSeparatorForGets(runtime, args); - - for (IRubyObject line = getline(runtime, separator); !line.isNil(); - line = getline(runtime, separator)) { - block.yield(context, line); - } - - return this; - } - - - @JRubyMethod(name = "readlines", optional = 1) - public RubyArray readlines(ThreadContext context, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - IRubyObject[] separatorArgs = args.length > 0 ? new IRubyObject[] { args[0] } : IRubyObject.NULL_ARRAY; - ByteList separator = getSeparatorForGets(runtime, separatorArgs); - RubyArray result = runtime.newArray(); - IRubyObject line; - - while (! (line = getline(runtime, separator)).isNil()) { - result.append(line); - } - return result; - } - - @JRubyMethod(name = "to_io") - public RubyIO to_io() { - return this; - } - - @Override - public String toString() { - return "RubyIO(" + openFile.getMode() + ", " + openFile.getMainStream().getDescriptor().getFileno() + ")"; - } - - /* class methods for IO */ - - /** rb_io_s_foreach - * - */ - @JRubyMethod(name = "foreach", required = 1, optional = 1, frame = true, meta = true) - public static IRubyObject foreach(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = context.getRuntime(); - int count = args.length; - IRubyObject filename = args[0].convertToString(); - runtime.checkSafeString(filename); - - ByteList separator = getSeparatorFromArgs(runtime, args, 1); - - RubyIO io = (RubyIO)RubyFile.open(context, runtime.getFile(), new IRubyObject[] { filename }, Block.NULL_BLOCK); - - if (!io.isNil()) { - try { - IRubyObject str = io.getline(runtime, separator); - while (!str.isNil()) { - block.yield(context, str); - str = io.getline(runtime, separator); - } - } finally { - io.close(); - } - } - - return runtime.getNil(); - } - - private static RubyIO convertToIO(ThreadContext context, IRubyObject obj) { - return (RubyIO)TypeConverter.convertToType(obj, context.getRuntime().getIO(), MethodIndex.TO_IO, "to_io"); - } - - private static boolean registerSelect(ThreadContext context, Selector selector, IRubyObject obj, RubyIO ioObj, int ops) throws IOException { - Channel channel = ioObj.getChannel(); - if (channel == null || !(channel instanceof SelectableChannel)) { - return false; - } - - ((SelectableChannel) channel).configureBlocking(false); - int real_ops = ((SelectableChannel) channel).validOps() & ops; - SelectionKey key = ((SelectableChannel) channel).keyFor(selector); - - if (key == null) { - ((SelectableChannel) channel).register(selector, real_ops, obj); - } else { - key.interestOps(key.interestOps()|real_ops); - } - - return true; - } - - @JRubyMethod(name = "select", required = 1, optional = 3, meta = true) - public static IRubyObject select(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - return select_static(context, context.getRuntime(), args); - } - - private static void checkArrayType(Ruby runtime, IRubyObject obj) { - if (!(obj instanceof RubyArray)) { - throw runtime.newTypeError("wrong argument type " - + obj.getMetaClass().getName() + " (expected Array)"); - } - } - - public static IRubyObject select_static(ThreadContext context, Ruby runtime, IRubyObject[] args) { - try { - Set pending = new HashSet(); - Set unselectable_reads = new HashSet(); - Set unselectable_writes = new HashSet(); - Selector selector = Selector.open(); - if (!args[0].isNil()) { - // read - checkArrayType(runtime, args[0]); - for (Iterator i = ((RubyArray) args[0]).getList().iterator(); i.hasNext(); ) { - IRubyObject obj = (IRubyObject) i.next(); - RubyIO ioObj = convertToIO(context, obj); - if (registerSelect(context, selector, obj, ioObj, SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) { - if (ioObj.writeDataBuffered()) { - pending.add(obj); - } - } else { - if (( ioObj.openFile.getMode() & OpenFile.READABLE ) != 0) { - unselectable_reads.add(obj); - } - } - } - } - - if (args.length > 1 && !args[1].isNil()) { - // write - checkArrayType(runtime, args[1]); - for (Iterator i = ((RubyArray) args[1]).getList().iterator(); i.hasNext(); ) { - IRubyObject obj = (IRubyObject) i.next(); - RubyIO ioObj = convertToIO(context, obj); - if (!registerSelect(context, selector, obj, ioObj, SelectionKey.OP_WRITE)) { - if (( ioObj.openFile.getMode() & OpenFile.WRITABLE ) != 0) { - unselectable_writes.add(obj); - } - } - } - } - - if (args.length > 2 && !args[2].isNil()) { - checkArrayType(runtime, args[2]); - // Java's select doesn't do anything about this, so we leave it be. - } - - final boolean has_timeout = ( args.length > 3 && !args[3].isNil() ); - long timeout = 0; - if(has_timeout) { - IRubyObject timeArg = args[3]; - if (timeArg instanceof RubyFloat) { - timeout = Math.round(((RubyFloat) timeArg).getDoubleValue() * 1000); - } else if (timeArg instanceof RubyFixnum) { - timeout = Math.round(((RubyFixnum) timeArg).getDoubleValue() * 1000); - } else { // TODO: MRI also can hadle Bignum here - throw runtime.newTypeError("can't convert " - + timeArg.getMetaClass().getName() + " into time interval"); - } - - if (timeout < 0) { - throw runtime.newArgumentError("negative timeout given"); - } - } - - if (pending.isEmpty() && unselectable_reads.isEmpty() && unselectable_writes.isEmpty()) { - if (has_timeout) { - if (timeout==0) { - selector.selectNow(); - } else { - selector.select(timeout); - } - } else { - selector.select(); - } - } else { - selector.selectNow(); - } - - List r = new ArrayList(); - List w = new ArrayList(); - List e = new ArrayList(); - for (Iterator i = selector.selectedKeys().iterator(); i.hasNext(); ) { - SelectionKey key = (SelectionKey) i.next(); - if ((key.interestOps() & key.readyOps() - & (SelectionKey.OP_READ|SelectionKey.OP_ACCEPT|SelectionKey.OP_CONNECT)) != 0) { - r.add(key.attachment()); - pending.remove(key.attachment()); - } - if ((key.interestOps() & key.readyOps() & (SelectionKey.OP_WRITE)) != 0) { - w.add(key.attachment()); - } - } - r.addAll(pending); - r.addAll(unselectable_reads); - w.addAll(unselectable_writes); - - // make all sockets blocking as configured again - for (Iterator i = selector.keys().iterator(); i.hasNext(); ) { - SelectionKey key = (SelectionKey) i.next(); - SelectableChannel channel = key.channel(); - synchronized(channel.blockingLock()) { - RubyIO originalIO = (RubyIO) TypeConverter.convertToType( - (IRubyObject) key.attachment(), runtime.getIO(), - MethodIndex.TO_IO, "to_io"); - boolean blocking = originalIO.getBlocking(); - key.cancel(); - channel.configureBlocking(blocking); - } - } - selector.close(); - - if (r.size() == 0 && w.size() == 0 && e.size() == 0) { - return runtime.getNil(); - } - - List ret = new ArrayList(); - - ret.add(RubyArray.newArray(runtime, r)); - ret.add(RubyArray.newArray(runtime, w)); - ret.add(RubyArray.newArray(runtime, e)); - - return RubyArray.newArray(runtime, ret); - } catch(IOException e) { - throw runtime.newIOError(e.getMessage()); - } - } - - public static IRubyObject read(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - switch (args.length) { - case 0: throw context.getRuntime().newArgumentError(0, 1); - case 1: return read(context, recv, args[0], block); - case 2: return read(context, recv, args[0], args[1], block); - case 3: return read(context, recv, args[0], args[1], args[2], block); - default: throw context.getRuntime().newArgumentError(args.length, 3); - } - } - - @JRubyMethod(name = "read", meta = true) - public static IRubyObject read(ThreadContext context, IRubyObject recv, IRubyObject arg0, Block block) { - IRubyObject[] fileArguments = new IRubyObject[] {arg0}; - RubyIO file = (RubyIO) RubyKernel.open(context, recv, fileArguments, block); - - try { - return file.read(context); - } finally { - file.close(); - } - } - - @JRubyMethod(name = "read", meta = true) - public static IRubyObject read(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1, Block block) { - IRubyObject[] fileArguments = new IRubyObject[] {arg0}; - RubyIO file = (RubyIO) RubyKernel.open(context, recv, fileArguments, block); - - try { - if (!arg1.isNil()) { - return file.read(context, arg1); - } else { - return file.read(context); - } - } finally { - file.close(); - } - } - - @JRubyMethod(name = "read", meta = true) - public static IRubyObject read(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) { - IRubyObject[] fileArguments = new IRubyObject[]{arg0}; - RubyIO file = (RubyIO) RubyKernel.open(context, recv, fileArguments, block); - - if (!arg2.isNil()) { - file.seek(context, arg2); - } - - try { - if (!arg1.isNil()) { - return file.read(context, arg1); - } else { - return file.read(context); - } - } finally { - file.close(); - } - } - - @JRubyMethod(name = "readlines", required = 1, optional = 1, meta = true) - public static RubyArray readlines(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - int count = args.length; - - IRubyObject[] fileArguments = new IRubyObject[]{ args[0].convertToString() }; - IRubyObject[] separatorArguments = count >= 2 ? new IRubyObject[]{args[1]} : IRubyObject.NULL_ARRAY; - RubyIO file = (RubyIO) RubyKernel.open(context, recv, fileArguments, block); - try { - return file.readlines(context, separatorArguments); - } finally { - file.close(); - } - } - - @JRubyMethod(name = "popen", required = 1, optional = 1, meta = true) - public static IRubyObject popen(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = context.getRuntime(); - int mode; - - IRubyObject cmdObj = args[0].convertToString(); - runtime.checkSafeString(cmdObj); - - if ("-".equals(cmdObj.toString())) { - throw runtime.newNotImplementedError("popen(\"-\") is unimplemented"); - } - - try { - if (args.length == 1) { - mode = ModeFlags.RDONLY; - } else if (args[1] instanceof RubyFixnum) { - mode = RubyFixnum.num2int(args[1]); - } else { - mode = getIOModesIntFromString(runtime, args[1].convertToString().toString()); - } - - ModeFlags modes = new ModeFlags(mode); - - ShellLauncher.POpenProcess process = ShellLauncher.popen(runtime, cmdObj, modes); - RubyIO io = new RubyIO(runtime, process, modes); - - if (block.isGiven()) { - try { - return block.yield(context, io); - } finally { - if (io.openFile.isOpen()) { - io.close(); - } - runtime.getGlobalVariables().set("$?", RubyProcess.RubyStatus.newProcessStatus(runtime, (process.waitFor() * 256))); - } - } - return io; - } catch (InvalidValueException ex) { - throw runtime.newErrnoEINVALError(); - } catch (IOException e) { - throw runtime.newIOErrorFromException(e); - } catch (InterruptedException e) { - throw runtime.newThreadError("unexpected interrupt"); - } - } - - // NIO based pipe - @JRubyMethod(name = "pipe", meta = true) - public static IRubyObject pipe(ThreadContext context, IRubyObject recv) throws Exception { - // TODO: This isn't an exact port of MRI's pipe behavior, so revisit - Ruby runtime = context.getRuntime(); - Pipe pipe = Pipe.open(); - - RubyIO source = new RubyIO(runtime, pipe.source()); - RubyIO sink = new RubyIO(runtime, pipe.sink()); - - sink.openFile.getMainStream().setSync(true); - return runtime.newArrayNoCopy(new IRubyObject[] { source, sink }); - } - - @JRubyMethod(name = "copy_stream", meta = true, compat = RUBY1_9) - public static IRubyObject copy_stream(ThreadContext context, IRubyObject recv, - IRubyObject stream1, IRubyObject stream2) throws IOException { - RubyIO io1 = (RubyIO)stream1; - RubyIO io2 = (RubyIO)stream2; - - ChannelDescriptor d1 = io1.openFile.getMainStream().getDescriptor(); - if (!d1.isSeekable()) { - throw context.getRuntime().newTypeError("only supports file-to-file copy"); - } - ChannelDescriptor d2 = io2.openFile.getMainStream().getDescriptor(); - if (!d2.isSeekable()) { - throw context.getRuntime().newTypeError("only supports file-to-file copy"); - } - - FileChannel f1 = (FileChannel)d1.getChannel(); - FileChannel f2 = (FileChannel)d2.getChannel(); - - long size = f1.size(); - - f1.transferTo(f2.position(), size, f2); - - return context.getRuntime().newFixnum(size); - } - - /** - * Add a thread to the list of blocking threads for this IO. - * - * @param thread A thread blocking on this IO - */ - public synchronized void addBlockingThread(RubyThread thread) { - if (blockingThreads == null) { - blockingThreads = new ArrayList<RubyThread>(1); - } - blockingThreads.add(thread); - } - - /** - * Remove a thread from the list of blocking threads for this IO. - * - * @param thread A thread blocking on this IO - */ - public synchronized void removeBlockingThread(RubyThread thread) { - if (blockingThreads == null) { - return; - } - for (int i = 0; i < blockingThreads.size(); i++) { - if (blockingThreads.get(i) == thread) { - // not using remove(Object) here to avoid the equals() call - blockingThreads.remove(i); - } - } - } - - /** - * Fire an IOError in all threads blocking on this IO object - */ - protected synchronized void interruptBlockingThreads() { - if (blockingThreads == null) { - return; - } - for (int i = 0; i < blockingThreads.size(); i++) { - RubyThread thread = blockingThreads.get(i); - - // raise will also wake the thread from selection - thread.raise(new IRubyObject[] {getRuntime().newIOError("stream closed").getException()}, Block.NULL_BLOCK); - } - } -} -/* - **** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2005 Thomas E Enebo <enebo@acm.org> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; -import java.io.PrintWriter; -import java.io.StringWriter; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.anno.JRubyClass; - -import org.jruby.ast.ArgsNode; -import org.jruby.ast.ArgumentNode; -import org.jruby.ast.ListNode; -import org.jruby.ast.LocalAsgnNode; -import org.jruby.javasupport.Java; -import org.jruby.javasupport.JavaObject; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.load.Library; -import org.jruby.internal.runtime.methods.DynamicMethod; - -import org.jruby.ast.Node; -import org.jruby.compiler.ASTInspector; -import org.jruby.compiler.ASTCompiler; -import org.jruby.compiler.impl.StandardASMCompiler; -import org.jruby.internal.runtime.methods.MethodArgs; -import org.jruby.javasupport.JavaUtil; -import org.jruby.runtime.InterpretedBlock; -import org.jruby.runtime.ThreadContext; -import org.jruby.util.TypeConverter; -import org.objectweb.asm.ClassReader; -import org.objectweb.asm.util.TraceClassVisitor; - -/** - * Module which defines JRuby-specific methods for use. - */ -@JRubyModule(name="JRuby") -public class RubyJRuby { - public static RubyModule createJRuby(Ruby runtime) { - ThreadContext context = runtime.getCurrentContext(); - runtime.getKernel().callMethod(context, "require", runtime.newString("java")); - RubyModule jrubyModule = runtime.defineModule("JRuby"); - - jrubyModule.defineAnnotatedMethods(RubyJRuby.class); - - RubyClass compiledScriptClass = jrubyModule.defineClassUnder("CompiledScript",runtime.getObject(), runtime.getObject().getAllocator()); - - compiledScriptClass.attr_accessor(context, new IRubyObject[]{runtime.newSymbol("name"), runtime.newSymbol("class_name"), runtime.newSymbol("original_script"), runtime.newSymbol("code")}); - compiledScriptClass.defineAnnotatedMethods(JRubyCompiledScript.class); - - return jrubyModule; - } - - public static RubyModule createJRubyExt(Ruby runtime) { - runtime.getKernel().callMethod(runtime.getCurrentContext(),"require", runtime.newString("java")); - RubyModule mJRubyExt = runtime.getOrCreateModule("JRuby").defineModuleUnder("Extensions"); - - mJRubyExt.defineAnnotatedMethods(JRubyExtensions.class); - - runtime.getObject().includeModule(mJRubyExt); - - return mJRubyExt; - } - - public static class ExtLibrary implements Library { - public void load(Ruby runtime, boolean wrap) throws IOException { - RubyJRuby.createJRubyExt(runtime); - - runtime.getMethod().defineAnnotatedMethods(MethodExtensions.class); - } - } - - public static class TypeLibrary implements Library { - public void load(Ruby runtime, boolean wrap) throws IOException { - RubyModule jrubyType = runtime.defineModule("Type"); - jrubyType.defineAnnotatedMethods(TypeLibrary.class); - } - - @JRubyMethod(module = true) - public static IRubyObject coerce_to(ThreadContext context, IRubyObject self, IRubyObject object, IRubyObject clazz, IRubyObject method) { - Ruby ruby = object.getRuntime(); - - if (!(clazz instanceof RubyClass)) { - throw ruby.newTypeError(clazz, ruby.getClassClass()); - } - if (!(method instanceof RubySymbol)) { - throw ruby.newTypeError(method, ruby.getSymbol()); - } - - RubyClass rubyClass = (RubyClass)clazz; - RubySymbol methodSym = (RubySymbol)method; - - return TypeConverter.convertToTypeOrRaise(object, rubyClass, methodSym.asJavaString()); - } - } - - @JRubyMethod(name = "runtime", frame = true, module = true) - public static IRubyObject runtime(IRubyObject recv, Block unusedBlock) { - return Java.java_to_ruby(recv, JavaObject.wrap(recv.getRuntime(), recv.getRuntime()), Block.NULL_BLOCK); - } - - @JRubyMethod(name = "objectspace", frame = true, module = true) - public static IRubyObject getObjectSpaceEnabled(IRubyObject recv, Block b) { - Ruby runtime = recv.getRuntime(); - return RubyBoolean.newBoolean( - runtime, runtime.isObjectSpaceEnabled()); - } - - @JRubyMethod(name = "objectspace=", required = 1, frame = true, module = true) - public static IRubyObject setObjectSpaceEnabled( - IRubyObject recv, IRubyObject arg, Block b) { - Ruby runtime = recv.getRuntime(); - runtime.setObjectSpaceEnabled(arg.isTrue()); - return runtime.getNil(); - } - - @JRubyMethod(name = {"parse", "ast_for"}, optional = 3, frame = true, module = true) - public static IRubyObject parse(IRubyObject recv, IRubyObject[] args, Block block) { - if(block.isGiven()) { - if(block.getBody() instanceof org.jruby.runtime.CompiledBlock) { - throw new RuntimeException("Cannot compile an already compiled block. Use -J-Djruby.jit.enabled=false to avoid this problem."); - } - Arity.checkArgumentCount(recv.getRuntime(),args,0,0); - return Java.java_to_ruby(recv, JavaObject.wrap(recv.getRuntime(), ((InterpretedBlock)block.getBody()).getIterNode().getBodyNode()), Block.NULL_BLOCK); - } else { - Arity.checkArgumentCount(recv.getRuntime(),args,1,3); - String filename = "-"; - boolean extraPositionInformation = false; - RubyString content = args[0].convertToString(); - if(args.length>1) { - filename = args[1].convertToString().toString(); - if(args.length>2) { - extraPositionInformation = args[2].isTrue(); - } - } - return Java.java_to_ruby(recv, JavaObject.wrap(recv.getRuntime(), - recv.getRuntime().parse(content.getByteList(), filename, null, 0, extraPositionInformation)), Block.NULL_BLOCK); - } - } - - @JRubyMethod(name = "compile", optional = 3, frame = true, module = true) - public static IRubyObject compile(IRubyObject recv, IRubyObject[] args, Block block) { - Node node; - String filename; - RubyString content; - if(block.isGiven()) { - Arity.checkArgumentCount(recv.getRuntime(),args,0,0); - if(block.getBody() instanceof org.jruby.runtime.CompiledBlock) { - throw new RuntimeException("Cannot compile an already compiled block. Use -J-Djruby.jit.enabled=false to avoid this problem."); - } - content = RubyString.newEmptyString(recv.getRuntime()); - Node bnode = ((InterpretedBlock)block.getBody()).getIterNode().getBodyNode(); - node = new org.jruby.ast.RootNode(bnode.getPosition(), block.getBinding().getDynamicScope(), bnode); - filename = "__block_" + node.getPosition().getFile(); - } else { - Arity.checkArgumentCount(recv.getRuntime(),args,1,3); - filename = "-"; - boolean extraPositionInformation = false; - content = args[0].convertToString(); - if(args.length>1) { - filename = args[1].convertToString().toString(); - if(args.length>2) { - extraPositionInformation = args[2].isTrue(); - } - } - - node = recv.getRuntime().parse(content.getByteList(), filename, null, 0, extraPositionInformation); - } - - String classname; - if (filename.equals("-e")) { - classname = "__dash_e__"; - } else { - classname = filename.replace('\\', '/').replaceAll(".rb", "").replaceAll("-","_dash_"); - } - - ASTInspector inspector = new ASTInspector(); - inspector.inspect(node); - - StandardASMCompiler asmCompiler = new StandardASMCompiler(classname, filename); - ASTCompiler compiler = new ASTCompiler(); - compiler.compileRoot(node, asmCompiler, inspector); - byte[] bts = asmCompiler.getClassByteArray(); - - IRubyObject compiledScript = ((RubyModule)recv).fastGetConstant("CompiledScript").callMethod(recv.getRuntime().getCurrentContext(),"new"); - compiledScript.callMethod(recv.getRuntime().getCurrentContext(), "name=", recv.getRuntime().newString(filename)); - compiledScript.callMethod(recv.getRuntime().getCurrentContext(), "class_name=", recv.getRuntime().newString(classname)); - compiledScript.callMethod(recv.getRuntime().getCurrentContext(), "original_script=", content); - compiledScript.callMethod(recv.getRuntime().getCurrentContext(), "code=", Java.java_to_ruby(recv, JavaObject.wrap(recv.getRuntime(), bts), Block.NULL_BLOCK)); - - return compiledScript; - } - - @JRubyMethod(name = "reference", required = 1, module = true) - public static IRubyObject reference(IRubyObject recv, IRubyObject obj) { - return Java.wrap(recv.getRuntime().getJavaSupport().getJavaUtilitiesModule(), - JavaObject.wrap(recv.getRuntime(), obj)); - } - - @JRubyMethod(name = "dereference", required = 1, module = true) - public static IRubyObject dereference(ThreadContext context, IRubyObject recv, IRubyObject obj) { - if (!(obj.dataGetStruct() instanceof JavaObject)) { - throw context.getRuntime().newTypeError("got " + obj + ", expected wrapped Java object"); - } - - Object unwrapped = JavaUtil.unwrapJavaObject(obj); - - if (!(unwrapped instanceof IRubyObject)) { - throw context.getRuntime().newTypeError("got " + obj + ", expected Java-wrapped Ruby object"); - } - - return (IRubyObject)unwrapped; - } - - @JRubyClass(name="JRuby::CompiledScript") - public static class JRubyCompiledScript { - @JRubyMethod(name = "to_s") - public static IRubyObject compiled_script_to_s(IRubyObject recv) { - return recv.getInstanceVariables().fastGetInstanceVariable("@original_script"); - } - - @JRubyMethod(name = "inspect") - public static IRubyObject compiled_script_inspect(IRubyObject recv) { - return recv.getRuntime().newString("#<JRuby::CompiledScript " + recv.getInstanceVariables().fastGetInstanceVariable("@name") + ">"); - } - - @JRubyMethod(name = "inspect_bytecode") - public static IRubyObject compiled_script_inspect_bytecode(IRubyObject recv) { - StringWriter sw = new StringWriter(); - ClassReader cr = new ClassReader((byte[])org.jruby.javasupport.JavaUtil.convertRubyToJava(recv.getInstanceVariables().fastGetInstanceVariable("@code"),byte[].class)); - TraceClassVisitor cv = new TraceClassVisitor(new PrintWriter(sw)); - cr.accept(cv, ClassReader.SKIP_DEBUG); - return recv.getRuntime().newString(sw.toString()); - } - } - - @JRubyModule(name="JRubyExtensions") - public static class JRubyExtensions { - @JRubyMethod(name = "steal_method", required = 2, module = true) - public static IRubyObject steal_method(IRubyObject recv, IRubyObject type, IRubyObject methodName) { - RubyModule to_add = null; - if(recv instanceof RubyModule) { - to_add = (RubyModule)recv; - } else { - to_add = recv.getSingletonClass(); - } - String name = methodName.toString(); - if(!(type instanceof RubyModule)) { - throw recv.getRuntime().newArgumentError("First argument must be a module/class"); - } - - DynamicMethod method = ((RubyModule)type).searchMethod(name); - if(method == null || method.isUndefined()) { - throw recv.getRuntime().newArgumentError("No such method " + name + " on " + type); - } - - to_add.addMethod(name, method); - return recv.getRuntime().getNil(); - } - - @JRubyMethod(name = "steal_methods", required = 1, rest = true, module = true) - public static IRubyObject steal_methods(IRubyObject recv, IRubyObject[] args) { - IRubyObject type = args[0]; - for(int i=1;i<args.length;i++) { - steal_method(recv, type, args[i]); - } - return recv.getRuntime().getNil(); - } - } - - public static class MethodExtensions { - @JRubyMethod(name = "args") - public static IRubyObject methodArgs(IRubyObject recv) { - Ruby ruby = recv.getRuntime(); - RubyMethod rubyMethod = (RubyMethod)recv; - - DynamicMethod method = rubyMethod.method; - - if (method instanceof MethodArgs) { - MethodArgs interpMethod = (MethodArgs)method; - ArgsNode args = interpMethod.getArgsNode(); - RubyArray argsArray = RubyArray.newArray(ruby); - - RubyArray reqArray = RubyArray.newArray(ruby); - ListNode requiredArgs = args.getArgs(); - for (int i = 0; requiredArgs != null && i < requiredArgs.size(); i++) { - ArgumentNode arg = (ArgumentNode)requiredArgs.get(i); - reqArray.append(RubySymbol.newSymbol(ruby, arg.getName())); - } - argsArray.append(reqArray); - - RubyArray optArray = RubyArray.newArray(ruby); - ListNode optArgs = args.getOptArgs(); - for (int i = 0; optArgs != null && i < optArgs.size(); i++) { - LocalAsgnNode arg = (LocalAsgnNode)optArgs.get(i); - optArray.append(RubySymbol.newSymbol(ruby, arg.getName())); - } - argsArray.append(optArray); - - if (args.getRestArgNode() != null) { - argsArray.append(RubySymbol.newSymbol(ruby, args.getRestArgNode().getName())); - } else { - argsArray.append(ruby.getNil()); - } - - if (args.getBlockArgNode() != null) { - argsArray.append(RubySymbol.newSymbol(ruby, args.getBlockArgNode().getName())); - } else { - argsArray.append(ruby.getNil()); - } - - return argsArray; - } - - throw ruby.newTypeError("Method args are only available for standard interpreted or jitted methods"); - } - } -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Kiel Hodges <jruby-devel@selfsosoft.com> - * Copyright (C) 2006 Evan Buswell <evan@heron.sytes.net> - * Copyright (C) 2006 Ola Bini <ola@ologix.com> - * Copyright (C) 2006 Michael Studman <codehaus@michaelstudman.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.ByteArrayOutputStream; -import java.math.BigInteger; -import java.util.ArrayList; -import static org.jruby.anno.FrameField.*; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; - -import org.jruby.ast.util.ArgsUtil; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.evaluator.ASTInterpreter; -import org.jruby.exceptions.JumpException; -import org.jruby.exceptions.MainExitException; -import org.jruby.exceptions.RaiseException; -import org.jruby.internal.runtime.JumpTarget; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallType; -import org.jruby.runtime.Frame; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import static org.jruby.runtime.Visibility.*; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.load.IAutoloadMethod; -import org.jruby.runtime.load.LoadService; -import org.jruby.util.IdUtil; -import org.jruby.util.ShellLauncher; -import org.jruby.util.TypeConverter; - -/** - * Note: For CVS history, see KernelModule.java. - */ -@JRubyModule(name="Kernel") -public class RubyKernel { - public final static Class<?> IRUBY_OBJECT = IRubyObject.class; - - public static RubyModule createKernelModule(Ruby runtime) { - RubyModule module = runtime.defineModule("Kernel"); - runtime.setKernel(module); - - module.defineAnnotatedMethods(RubyKernel.class); - module.defineAnnotatedMethods(RubyObject.class); - - runtime.setRespondToMethod(module.searchMethod("respond_to?")); - - module.setFlag(RubyObject.USER7_F, false); //Kernel is the only Module that doesn't need an implementor - - return module; - } - - @JRubyMethod(name = "at_exit", frame = true, module = true, visibility = PRIVATE) - public static IRubyObject at_exit(ThreadContext context, IRubyObject recv, Block block) { - return context.getRuntime().pushExitBlock(context.getRuntime().newProc(Block.Type.PROC, block)); - } - - @JRubyMethod(name = "autoload?", required = 1, module = true, visibility = PRIVATE) - public static IRubyObject autoload_p(ThreadContext context, final IRubyObject recv, IRubyObject symbol) { - Ruby runtime = context.getRuntime(); - RubyModule module = recv instanceof RubyModule ? (RubyModule) recv : runtime.getObject(); - String name = module.getName() + "::" + symbol.asJavaString(); - - IAutoloadMethod autoloadMethod = runtime.getLoadService().autoloadFor(name); - if (autoloadMethod == null) return runtime.getNil(); - - return runtime.newString(autoloadMethod.file()); - } - - @JRubyMethod(name = "autoload", required = 2, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject autoload(final IRubyObject recv, IRubyObject symbol, final IRubyObject file) { - Ruby runtime = recv.getRuntime(); - final LoadService loadService = runtime.getLoadService(); - String nonInternedName = symbol.asJavaString(); - - if (!IdUtil.isValidConstantName(nonInternedName)) { - throw runtime.newNameError("autoload must be constant name", nonInternedName); - } - - RubyString fileString = file.convertToString(); - - if (fileString.isEmpty()) { - throw runtime.newArgumentError("empty file name"); - } - - final String baseName = symbol.asJavaString().intern(); // interned, OK for "fast" methods - final RubyModule module = recv instanceof RubyModule ? (RubyModule) recv : runtime.getObject(); - String nm = module.getName() + "::" + baseName; - - IRubyObject existingValue = module.fastFetchConstant(baseName); - if (existingValue != null && existingValue != RubyObject.UNDEF) return runtime.getNil(); - - module.fastStoreConstant(baseName, RubyObject.UNDEF); - - loadService.addAutoload(nm, new IAutoloadMethod() { - public String file() { - return file.toString(); - } - /** - * @see org.jruby.runtime.load.IAutoloadMethod#load(Ruby, String) - */ - public IRubyObject load(Ruby runtime, String name) { - boolean required = loadService.require(file()); - - // File to be loaded by autoload has already been or is being loaded. - if (!required) return null; - - return module.fastGetConstant(baseName); - } - }); - return runtime.getNil(); - } - - @JRubyMethod(name = "method_missing", rest = true, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject method_missing(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = context.getRuntime(); - - if (args.length == 0 || !(args[0] instanceof RubySymbol)) throw runtime.newArgumentError("no id given"); - - Visibility lastVis = context.getLastVisibility(); - CallType lastCallType = context.getLastCallType(); - - // create a lightweight thunk - IRubyObject msg = new RubyNameError.RubyNameErrorMessage(runtime, - recv, - args[0], - lastVis, - lastCallType); - final IRubyObject[]exArgs; - final RubyClass exc; - if (lastCallType != CallType.VARIABLE) { - exc = runtime.getNoMethodError(); - exArgs = new IRubyObject[]{msg, args[0], RubyArray.newArrayNoCopy(runtime, args, 1)}; - } else { - exc = runtime.getNameError(); - exArgs = new IRubyObject[]{msg, args[0]}; - } - - throw new RaiseException((RubyException)exc.newInstance(context, exArgs, Block.NULL_BLOCK)); - } - - @JRubyMethod(name = "open", required = 1, optional = 2, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject open(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - String arg = args[0].convertToString().toString(); - Ruby runtime = context.getRuntime(); - - if (arg.startsWith("|")) { - String command = arg.substring(1); - // exec process, create IO with process - return RubyIO.popen(context, runtime.getIO(), new IRubyObject[] {runtime.newString(command)}, block); - } - - return RubyFile.open(context, runtime.getFile(), args, block); - } - - @JRubyMethod(name = "getc", module = true, visibility = PRIVATE) - public static IRubyObject getc(ThreadContext context, IRubyObject recv) { - context.getRuntime().getWarnings().warn(ID.DEPRECATED_METHOD, "getc is obsolete; use STDIN.getc instead", "getc", "STDIN.getc"); - IRubyObject defin = context.getRuntime().getGlobalVariables().get("$stdin"); - return defin.callMethod(context, "getc"); - } - - @JRubyMethod(name = "gets", optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject gets(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - return RubyArgsFile.gets(context, context.getRuntime().getGlobalVariables().get("$<"), args); - } - - @JRubyMethod(name = "abort", optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject abort(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - if(args.length == 1) { - context.getRuntime().getGlobalVariables().get("$stderr").callMethod(context,"puts",args[0]); - } - throw new MainExitException(1,true); - } - - @JRubyMethod(name = "Array", required = 1, module = true, visibility = PRIVATE) - public static IRubyObject new_array(ThreadContext context, IRubyObject recv, IRubyObject object) { - IRubyObject value = object.checkArrayType(); - - if (value.isNil()) { - if (object.getMetaClass().searchMethod("to_a").getImplementationClass() != context.getRuntime().getKernel()) { - value = object.callMethod(context, MethodIndex.TO_A, "to_a"); - if (!(value instanceof RubyArray)) throw context.getRuntime().newTypeError("`to_a' did not return Array"); - return value; - } else { - return context.getRuntime().newArray(object); - } - } - return value; - } - - @JRubyMethod(name = "Complex", module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_9) - public static IRubyObject new_complex(ThreadContext context, IRubyObject recv) { - return RuntimeHelpers.invoke(context, context.getRuntime().getComplex(), "convert"); - } - @JRubyMethod(name = "Complex", module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_9) - public static IRubyObject new_complex(ThreadContext context, IRubyObject recv, IRubyObject arg) { - return RuntimeHelpers.invoke(context, context.getRuntime().getComplex(), "convert", arg); - } - @JRubyMethod(name = "Complex", module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_9) - public static IRubyObject new_complex(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1) { - return RuntimeHelpers.invoke(context, context.getRuntime().getComplex(), "convert", arg0, arg1); - } - - @JRubyMethod(name = "Rational", module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_9) - public static IRubyObject new_rational(ThreadContext context, IRubyObject recv) { - return RuntimeHelpers.invoke(context, context.getRuntime().getRational(), "convert"); - } - @JRubyMethod(name = "Rational", module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_9) - public static IRubyObject new_rational(ThreadContext context, IRubyObject recv, IRubyObject arg) { - return RuntimeHelpers.invoke(context, context.getRuntime().getRational(), "convert", arg); - } - @JRubyMethod(name = "Rational", module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_9) - public static IRubyObject new_rational(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1) { - return RuntimeHelpers.invoke(context, context.getRuntime().getRational(), "convert", arg0, arg1); - } - - @JRubyMethod(name = "Float", module = true, visibility = PRIVATE) - public static IRubyObject new_float(IRubyObject recv, IRubyObject object) { - if(object instanceof RubyFixnum){ - return RubyFloat.newFloat(object.getRuntime(), ((RubyFixnum)object).getDoubleValue()); - }else if(object instanceof RubyFloat){ - return object; - }else if(object instanceof RubyBignum){ - return RubyFloat.newFloat(object.getRuntime(), RubyBignum.big2dbl((RubyBignum)object)); - }else if(object instanceof RubyString){ - if(((RubyString)object).getByteList().realSize == 0){ // rb_cstr_to_dbl case - throw recv.getRuntime().newArgumentError("invalid value for Float(): " + object.inspect()); - } - return RubyNumeric.str2fnum(recv.getRuntime(),(RubyString)object,true); - }else if(object.isNil()){ - throw recv.getRuntime().newTypeError("can't convert nil into Float"); - } else { - RubyFloat rFloat = (RubyFloat)TypeConverter.convertToType(object, recv.getRuntime().getFloat(), MethodIndex.TO_F, "to_f"); - if (Double.isNaN(rFloat.getDoubleValue())) throw recv.getRuntime().newArgumentError("invalid value for Float()"); - return rFloat; - } - } - - @JRubyMethod(name = "Integer", required = 1, module = true, visibility = PRIVATE) - public static IRubyObject new_integer(ThreadContext context, IRubyObject recv, IRubyObject object) { - if (object instanceof RubyFloat) { - double val = ((RubyFloat)object).getDoubleValue(); - if (val > (double) RubyFixnum.MAX && val < (double) RubyFixnum.MIN) { - return RubyNumeric.dbl2num(context.getRuntime(),((RubyFloat)object).getDoubleValue()); - } - } else if (object instanceof RubyFixnum || object instanceof RubyBignum) { - return object; - } else if (object instanceof RubyString) { - return RubyNumeric.str2inum(context.getRuntime(),(RubyString)object,0,true); - } - - IRubyObject tmp = TypeConverter.convertToType(object, context.getRuntime().getInteger(), MethodIndex.TO_INT, "to_int", false); - if (tmp.isNil()) return object.convertToInteger(MethodIndex.TO_I, "to_i"); - return tmp; - } - - @JRubyMethod(name = "String", required = 1, module = true, visibility = PRIVATE) - public static IRubyObject new_string(ThreadContext context, IRubyObject recv, IRubyObject object) { - return TypeConverter.convertToType(object, context.getRuntime().getString(), MethodIndex.TO_S, "to_s"); - } - - @JRubyMethod(name = "p", rest = true, module = true, visibility = PRIVATE) - public static IRubyObject p(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - IRubyObject defout = runtime.getGlobalVariables().get("$>"); - - for (int i = 0; i < args.length; i++) { - if (args[i] != null) { - defout.callMethod(context, "write", RubyObject.inspect(context, args[i])); - defout.callMethod(context, "write", runtime.newString("\n")); - } - } - - if (defout instanceof RubyFile) { - ((RubyFile)defout).flush(); - } - - return context.getRuntime().getNil(); - } - - /** rb_f_putc - */ - @JRubyMethod(name = "putc", required = 1, module = true, visibility = PRIVATE) - public static IRubyObject putc(ThreadContext context, IRubyObject recv, IRubyObject ch) { - IRubyObject defout = context.getRuntime().getGlobalVariables().get("$>"); - return defout.callMethod(context, "putc", ch); - } - - @JRubyMethod(name = "puts", rest = true, module = true, visibility = PRIVATE) - public static IRubyObject puts(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - IRubyObject defout = context.getRuntime().getGlobalVariables().get("$>"); - - defout.callMethod(context, "puts", args); - - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "print", rest = true, module = true, visibility = PRIVATE) - public static IRubyObject print(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - IRubyObject defout = context.getRuntime().getGlobalVariables().get("$>"); - - defout.callMethod(context, "print", args); - - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "printf", rest = true, module = true, visibility = PRIVATE) - public static IRubyObject printf(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - if (args.length != 0) { - IRubyObject defout = context.getRuntime().getGlobalVariables().get("$>"); - - if (!(args[0] instanceof RubyString)) { - defout = args[0]; - args = ArgsUtil.popArray(args); - } - - defout.callMethod(context, "write", RubyKernel.sprintf(recv, args)); - } - - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "readline", optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject readline(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - IRubyObject line = gets(context, recv, args); - - if (line.isNil()) throw context.getRuntime().newEOFError(); - - return line; - } - - @JRubyMethod(name = "readlines", optional = 1, module = true, visibility = PRIVATE) - public static RubyArray readlines(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - return RubyArgsFile.readlines(context, context.getRuntime().getGlobalVariables().get("$<"), args); - } - - /** Returns value of $_. - * - * @throws TypeError if $_ is not a String or nil. - * @return value of $_ as String. - */ - private static RubyString getLastlineString(ThreadContext context, Ruby runtime) { - IRubyObject line = context.getPreviousFrame().getLastLine(); - - if (line.isNil()) { - throw runtime.newTypeError("$_ value need to be String (nil given)."); - } else if (!(line instanceof RubyString)) { - throw runtime.newTypeError("$_ value need to be String (" + line.getMetaClass().getName() + " given)."); - } else { - return (RubyString) line; - } - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the one or two-arg versions. - */ - public static IRubyObject sub_bang(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - return getLastlineString(context, context.getRuntime()).sub_bang(context, args, block); - } - - @JRubyMethod(name = "sub!", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE) - public static IRubyObject sub_bang(ThreadContext context, IRubyObject recv, IRubyObject arg0, Block block) { - return getLastlineString(context, context.getRuntime()).sub_bang(context, arg0, block); - } - - @JRubyMethod(name = "sub!", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE) - public static IRubyObject sub_bang(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1, Block block) { - return getLastlineString(context, context.getRuntime()).sub_bang(context, arg0, arg1, block); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the one or two-arg versions. - */ - public static IRubyObject sub(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - RubyString str = (RubyString) getLastlineString(context, context.getRuntime()).dup(); - - if (!str.sub_bang(context, args, block).isNil()) { - context.getPreviousFrame().setLastLine(str); - } - - return str; - } - - @JRubyMethod(name = "sub", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject sub(ThreadContext context, IRubyObject recv, IRubyObject arg0, Block block) { - RubyString str = (RubyString) getLastlineString(context, context.getRuntime()).dup(); - - if (!str.sub_bang(context, arg0, block).isNil()) { - context.getPreviousFrame().setLastLine(str); - } - - return str; - } - - @JRubyMethod(name = "sub", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject sub(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1, Block block) { - RubyString str = (RubyString) getLastlineString(context, context.getRuntime()).dup(); - - if (!str.sub_bang(context, arg0, arg1, block).isNil()) { - context.getPreviousFrame().setLastLine(str); - } - - return str; - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the one or two-arg versions. - */ - public static IRubyObject gsub_bang(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - return getLastlineString(context, context.getRuntime()).gsub_bang(context, args, block); - } - - @JRubyMethod(name = "gsub!", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject gsub_bang(ThreadContext context, IRubyObject recv, IRubyObject arg0, Block block) { - return getLastlineString(context, context.getRuntime()).gsub_bang(context, arg0, block); - } - - @JRubyMethod(name = "gsub!", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject gsub_bang(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1, Block block) { - return getLastlineString(context, context.getRuntime()).gsub_bang(context, arg0, arg1, block); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the one or two-arg versions. - */ - public static IRubyObject gsub(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - RubyString str = (RubyString) getLastlineString(context, context.getRuntime()).dup(); - - if (!str.gsub_bang(context, args, block).isNil()) { - context.getPreviousFrame().setLastLine(str); - } - - return str; - } - - @JRubyMethod(name = "gsub", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject gsub(ThreadContext context, IRubyObject recv, IRubyObject arg0, Block block) { - RubyString str = (RubyString) getLastlineString(context, context.getRuntime()).dup(); - - if (!str.gsub_bang(context, arg0, block).isNil()) { - context.getPreviousFrame().setLastLine(str); - } - - return str; - } - - @JRubyMethod(name = "gsub", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject gsub(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1, Block block) { - RubyString str = (RubyString) getLastlineString(context, context.getRuntime()).dup(); - - if (!str.gsub_bang(context, arg0, arg1, block).isNil()) { - context.getPreviousFrame().setLastLine(str); - } - - return str; - } - - @JRubyMethod(name = "chop!", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject chop_bang(ThreadContext context, IRubyObject recv, Block block) { - return getLastlineString(context, context.getRuntime()).chop_bang(); - } - - @JRubyMethod(name = "chop", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject chop(ThreadContext context, IRubyObject recv, Block block) { - RubyString str = getLastlineString(context, context.getRuntime()); - - if (str.getByteList().realSize > 0) { - str = (RubyString) str.dup(); - str.chop_bang(); - context.getPreviousFrame().setLastLine(str); - } - - return str; - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the zero or one-arg versions. - */ - public static IRubyObject chomp_bang(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - return getLastlineString(context, context.getRuntime()).chomp_bang(args); - } - - @JRubyMethod(name = "chomp!", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject chomp_bang(ThreadContext context, IRubyObject recv) { - return getLastlineString(context, context.getRuntime()).chomp_bang(); - } - - @JRubyMethod(name = "chomp!", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject chomp_bang(ThreadContext context, IRubyObject recv, IRubyObject arg0) { - return getLastlineString(context, context.getRuntime()).chomp_bang(arg0); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the zero or one-arg versions. - */ - public static IRubyObject chomp(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - RubyString str = getLastlineString(context, context.getRuntime()); - RubyString dup = (RubyString) str.dup(); - - if (dup.chomp_bang(args).isNil()) { - return str; - } - - context.getPreviousFrame().setLastLine(dup); - return dup; - } - - @JRubyMethod(name = "chomp", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject chomp(ThreadContext context, IRubyObject recv) { - RubyString str = getLastlineString(context, context.getRuntime()); - RubyString dup = (RubyString) str.dup(); - - if (dup.chomp_bang().isNil()) { - return str; - } - - context.getPreviousFrame().setLastLine(dup); - return dup; - } - - @JRubyMethod(name = "chomp", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = LASTLINE) - public static IRubyObject chomp(ThreadContext context, IRubyObject recv, IRubyObject arg0) { - RubyString str = getLastlineString(context, context.getRuntime()); - RubyString dup = (RubyString) str.dup(); - - if (dup.chomp_bang(arg0).isNil()) { - return str; - } - - context.getPreviousFrame().setLastLine(dup); - return dup; - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * - * @param context The thread context for the current thread - * @param recv The receiver of the method (usually a class that has included Kernel) - * @return - * @deprecated Use the versions with zero, one, or two args. - */ - public static IRubyObject split(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - return getLastlineString(context, context.getRuntime()).split(context, args); - } - - @JRubyMethod(name = "split", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = {LASTLINE, BACKREF}) - public static IRubyObject split(ThreadContext context, IRubyObject recv) { - return getLastlineString(context, context.getRuntime()).split(context); - } - - @JRubyMethod(name = "split", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = {LASTLINE, BACKREF}) - public static IRubyObject split(ThreadContext context, IRubyObject recv, IRubyObject arg0) { - return getLastlineString(context, context.getRuntime()).split(context, arg0); - } - - @JRubyMethod(name = "split", frame = true, module = true, visibility = PRIVATE, reads = LASTLINE, writes = {LASTLINE, BACKREF}) - public static IRubyObject split(ThreadContext context, IRubyObject recv, IRubyObject arg0, IRubyObject arg1) { - return getLastlineString(context, context.getRuntime()).split(context, arg0, arg1); - } - - @JRubyMethod(name = "scan", required = 1, frame = true, module = true, visibility = PRIVATE, reads = {LASTLINE, BACKREF}, writes = {LASTLINE, BACKREF}) - public static IRubyObject scan(ThreadContext context, IRubyObject recv, IRubyObject pattern, Block block) { - return getLastlineString(context, context.getRuntime()).scan(context, pattern, block); - } - - @JRubyMethod(name = "select", required = 1, optional = 3, module = true, visibility = PRIVATE) - public static IRubyObject select(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - return RubyIO.select_static(context, context.getRuntime(), args); - } - - @JRubyMethod(name = "sleep", optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject sleep(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - long milliseconds; - - if (args.length == 0) { - // Zero sleeps forever - milliseconds = 0; - } else { - if (!(args[0] instanceof RubyNumeric)) { - throw context.getRuntime().newTypeError("can't convert " + args[0].getMetaClass().getName() + "into time interval"); - } - milliseconds = (long) (args[0].convertToFloat().getDoubleValue() * 1000); - if (milliseconds < 0) { - throw context.getRuntime().newArgumentError("time interval must be positive"); - } else if (milliseconds == 0) { - // Explicit zero in MRI returns immediately - return context.getRuntime().newFixnum(0); - } - } - long startTime = System.currentTimeMillis(); - - RubyThread rubyThread = context.getThread(); - - do { - long loopStartTime = System.currentTimeMillis(); - try { - rubyThread.sleep(milliseconds); - } catch (InterruptedException iExcptn) { - } - milliseconds -= (System.currentTimeMillis() - loopStartTime); - } while (milliseconds > 0); - - return context.getRuntime().newFixnum(Math.round((System.currentTimeMillis() - startTime) / 1000.0)); - } - - // FIXME: Add at_exit and finalizers to exit, then make exit_bang not call those. - @JRubyMethod(name = "exit", optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject exit(IRubyObject recv, IRubyObject[] args) { - exit(recv.getRuntime(), args, false); - return recv.getRuntime().getNil(); // not reached - } - - @JRubyMethod(name = "exit!", optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject exit_bang(IRubyObject recv, IRubyObject[] args) { - exit(recv.getRuntime(), args, true); - return recv.getRuntime().getNil(); // not reached - } - - private static void exit(Ruby runtime, IRubyObject[] args, boolean hard) { - runtime.secure(4); - - int status = 1; - if (args.length > 0) { - RubyObject argument = (RubyObject)args[0]; - if (argument instanceof RubyFixnum) { - status = RubyNumeric.fix2int(argument); - } else { - status = argument.isFalse() ? 1 : 0; - } - } - - if (hard) { - throw new MainExitException(status, true); - } else { - throw runtime.newSystemExit(status); - } - } - - - /** Returns an Array with the names of all global variables. - * - */ - @JRubyMethod(name = "global_variables", module = true, visibility = PRIVATE) - public static RubyArray global_variables(ThreadContext context, IRubyObject recv) { - Ruby runtime = context.getRuntime(); - RubyArray globalVariables = runtime.newArray(); - - for (String globalVariableName : runtime.getGlobalVariables().getNames()) { - globalVariables.append(runtime.newString(globalVariableName)); - } - - return globalVariables; - } - - /** Returns an Array with the names of all local variables. - * - */ - @JRubyMethod(name = "local_variables", module = true, visibility = PRIVATE) - public static RubyArray local_variables(ThreadContext context, IRubyObject recv) { - final Ruby runtime = context.getRuntime(); - RubyArray localVariables = runtime.newArray(); - - for (String name: context.getCurrentScope().getAllNamesInScope()) { - if (IdUtil.isLocal(name)) localVariables.append(runtime.newString(name)); - } - - return localVariables; - } - - @JRubyMethod(name = "binding", frame = true, module = true, visibility = PRIVATE) - public static RubyBinding binding(ThreadContext context, IRubyObject recv, Block block) { - return RubyBinding.newBinding(context.getRuntime()); - } - - @JRubyMethod(name = {"block_given?", "iterator?"}, frame = true, module = true, visibility = PRIVATE) - public static RubyBoolean block_given_p(ThreadContext context, IRubyObject recv, Block block) { - return context.getRuntime().newBoolean(context.getPreviousFrame().getBlock().isGiven()); - } - - - @Deprecated - public static IRubyObject sprintf(IRubyObject recv, IRubyObject[] args) { - return sprintf(recv.getRuntime().getCurrentContext(), recv, args); - } - - @JRubyMethod(name = {"sprintf", "format"}, required = 1, rest = true, module = true, visibility = PRIVATE) - public static IRubyObject sprintf(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - if (args.length == 0) { - throw context.getRuntime().newArgumentError("sprintf must have at least one argument"); - } - - RubyString str = RubyString.stringValue(args[0]); - - RubyArray newArgs = context.getRuntime().newArrayNoCopy(args); - newArgs.shift(); - - return str.op_format(context, newArgs); - } - - @JRubyMethod(name = {"raise", "fail"}, optional = 3, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject raise(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - // FIXME: Pass block down? - Ruby runtime = context.getRuntime(); - - if (args.length == 0) { - IRubyObject lastException = runtime.getGlobalVariables().get("$!"); - if (lastException.isNil()) { - throw new RaiseException(runtime, runtime.getRuntimeError(), "", false); - } - throw new RaiseException((RubyException) lastException); - } - - IRubyObject exception; - - if (args.length == 1) { - if (args[0] instanceof RubyString) { - throw new RaiseException((RubyException)runtime.getRuntimeError().newInstance(context, args, block)); - } - - if (!args[0].respondsTo("exception")) { - throw runtime.newTypeError("exception class/object expected"); - } - exception = args[0].callMethod(context, "exception"); - } else { - if (!args[0].respondsTo("exception")) { - throw runtime.newTypeError("exception class/object expected"); - } - - exception = args[0].callMethod(context, "exception", args[1]); - } - - if (!runtime.fastGetClass("Exception").isInstance(exception)) { - throw runtime.newTypeError("exception object expected"); - } - - if (args.length == 3) { - ((RubyException) exception).set_backtrace(args[2]); - } - - if (runtime.getDebug().isTrue()) { - printExceptionSummary(context, runtime, (RubyException) exception); - } - - throw new RaiseException((RubyException) exception); - } - - private static void printExceptionSummary(ThreadContext context, Ruby runtime, RubyException rEx) { - Frame currentFrame = context.getCurrentFrame(); - - String msg = String.format("Exception `%s' at %s:%s - %s\n", - rEx.getMetaClass(), - currentFrame.getFile(), currentFrame.getLine() + 1, - rEx.to_s()); - - IRubyObject errorStream = runtime.getGlobalVariables().get("$stderr"); - errorStream.callMethod(context, "write", runtime.newString(msg)); - } - - /** - * Require. - * MRI allows to require ever .rb files or ruby extension dll (.so or .dll depending on system). - * we allow requiring either .rb files or jars. - * @param recv ruby object used to call require (any object will do and it won't be used anyway). - * @param name the name of the file to require - **/ - @JRubyMethod(name = "require", required = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject require(IRubyObject recv, IRubyObject name, Block block) { - Ruby runtime = recv.getRuntime(); - - if (runtime.getLoadService().require(name.convertToString().toString())) { - return runtime.getTrue(); - } - return runtime.getFalse(); - } - - @JRubyMethod(name = "load", required = 1, optional = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject load(IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = recv.getRuntime(); - RubyString file = args[0].convertToString(); - boolean wrap = args.length == 2 ? args[1].isTrue() : false; - - runtime.getLoadService().load(file.getByteList().toString(), wrap); - - return runtime.getTrue(); - } - - @JRubyMethod(name = "eval", required = 1, optional = 3, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject eval(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = context.getRuntime(); - - // string to eval - RubyString src = args[0].convertToString(); - runtime.checkSafeString(src); - - IRubyObject scope = args.length > 1 && !args[1].isNil() ? args[1] : null; - String file; - if (args.length > 2) { - file = args[2].convertToString().toString(); - } else if (scope == null) { - file = "(eval)"; - } else { - file = null; - } - int line; - if (args.length > 3) { - line = (int) args[3].convertToInteger().getLongValue(); - } else if (scope == null) { - line = 0; - } else { - line = -1; - } - if (scope == null) scope = RubyBinding.newBindingForEval(context); - - return ASTInterpreter.evalWithBinding(context, src, scope, file, line); - } - - @JRubyMethod(name = "callcc", frame = true, module = true, visibility = PRIVATE) - public static IRubyObject callcc(ThreadContext context, IRubyObject recv, Block block) { - Ruby runtime = context.getRuntime(); - runtime.getWarnings().warn(ID.EMPTY_IMPLEMENTATION, "Kernel#callcc: Continuations are not implemented in JRuby and will not work", "Kernel#callcc"); - IRubyObject cc = runtime.getContinuation().callMethod(context, "new"); - cc.dataWrapStruct(block); - return block.yield(context, cc); - } - - @JRubyMethod(name = "caller", optional = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject caller(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - int level = args.length > 0 ? RubyNumeric.fix2int(args[0]) : 1; - - if (level < 0) { - throw context.getRuntime().newArgumentError("negative level(" + level + ')'); - } - - return context.createCallerBacktrace(context.getRuntime(), level); - } - - @JRubyMethod(name = "catch", required = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject rbCatch(ThreadContext context, IRubyObject recv, IRubyObject tag, Block block) { - CatchTarget target = new CatchTarget(tag.asJavaString()); - try { - context.pushCatch(target); - return block.yield(context, tag); - } catch (JumpException.ThrowJump tj) { - if (tj.getTarget() == target) return (IRubyObject) tj.getValue(); - - throw tj; - } finally { - context.popCatch(); - } - } - - public static class CatchTarget implements JumpTarget { - private final String tag; - public CatchTarget(String tag) { this.tag = tag; } - public String getTag() { return tag; } - } - - @JRubyMethod(name = "throw", required = 1, frame = true, optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject rbThrow(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = context.getRuntime(); - - String tag = args[0].asJavaString(); - CatchTarget[] catches = context.getActiveCatches(); - - String message = "uncaught throw `" + tag + "'"; - - // Ordering of array traversal not important, just intuitive - for (int i = catches.length - 1 ; i >= 0 ; i--) { - if (tag.equals(catches[i].getTag())) { - //Catch active, throw for catch to handle - throw new JumpException.ThrowJump(catches[i], args.length > 1 ? args[1] : runtime.getNil()); - } - } - - // No catch active for this throw - RubyThread currentThread = context.getThread(); - if (currentThread == runtime.getThreadService().getMainThread()) { - throw runtime.newNameError(message, tag); - } else { - throw runtime.newThreadError(message + " in thread 0x" + Integer.toHexString(RubyInteger.fix2int(currentThread.id()))); - } - } - - @JRubyMethod(name = "trap", required = 1, frame = true, optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject trap(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - context.getRuntime().getLoadService().require("jsignal"); - return RuntimeHelpers.invoke(context, recv, "__jtrap", args, block); - } - - @JRubyMethod(name = "warn", required = 1, module = true, visibility = PRIVATE) - public static IRubyObject warn(ThreadContext context, IRubyObject recv, IRubyObject message) { - Ruby runtime = context.getRuntime(); - - if (!runtime.getVerbose().isNil()) { - IRubyObject out = runtime.getGlobalVariables().get("$stderr"); - RuntimeHelpers.invoke(context, out, "puts", message); - } - return runtime.getNil(); - } - - @JRubyMethod(name = "set_trace_func", required = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject set_trace_func(ThreadContext context, IRubyObject recv, IRubyObject trace_func, Block block) { - if (trace_func.isNil()) { - context.getRuntime().setTraceFunction(null); - } else if (!(trace_func instanceof RubyProc)) { - throw context.getRuntime().newTypeError("trace_func needs to be Proc."); - } else { - context.getRuntime().setTraceFunction((RubyProc) trace_func); - } - return trace_func; - } - - @JRubyMethod(name = "trace_var", required = 1, optional = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject trace_var(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - if (args.length == 0) throw context.getRuntime().newArgumentError(0, 1); - RubyProc proc = null; - String var = args.length > 1 ? args[0].toString() : null; - // ignore if it's not a global var - if (var.charAt(0) != '$') return context.getRuntime().getNil(); - if (args.length == 1) proc = RubyProc.newProc(context.getRuntime(), block, Block.Type.PROC); - if (args.length == 2) { - proc = (RubyProc)TypeConverter.convertToType(args[1], context.getRuntime().getProc(), 0, "to_proc", true); - } - - context.getRuntime().getGlobalVariables().setTraceVar(var, proc); - - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "untrace_var", required = 1, optional = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject untrace_var(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - if (args.length == 0) throw context.getRuntime().newArgumentError(0, 1); - String var = args.length >= 1 ? args[0].toString() : null; - - // ignore if it's not a global var - if (var.charAt(0) != '$') return context.getRuntime().getNil(); - - if (args.length > 1) { - ArrayList<IRubyObject> success = new ArrayList<IRubyObject>(); - for (int i = 1; i < args.length; i++) { - if (context.getRuntime().getGlobalVariables().untraceVar(var, args[i])) { - success.add(args[i]); - } - } - return RubyArray.newArray(context.getRuntime(), success); - } else { - context.getRuntime().getGlobalVariables().untraceVar(var); - } - - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "singleton_method_added", required = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject singleton_method_added(ThreadContext context, IRubyObject recv, IRubyObject symbolId, Block block) { - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "singleton_method_removed", required = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject singleton_method_removed(ThreadContext context, IRubyObject recv, IRubyObject symbolId, Block block) { - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "singleton_method_undefined", required = 1, frame = true, module = true, visibility = PRIVATE) - public static IRubyObject singleton_method_undefined(ThreadContext context, IRubyObject recv, IRubyObject symbolId, Block block) { - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = {"proc", "lambda"}, frame = true, module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_8) - public static RubyProc proc(ThreadContext context, IRubyObject recv, Block block) { - return context.getRuntime().newProc(Block.Type.LAMBDA, block); - } - - @Deprecated - public static RubyProc proc(IRubyObject recv, Block block) { - return recv.getRuntime().newProc(Block.Type.LAMBDA, block); - } - - @JRubyMethod(name = {"lambda"}, frame = true, module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_9) - public static RubyProc lambda(ThreadContext context, IRubyObject recv, Block block) { - return context.getRuntime().newProc(Block.Type.LAMBDA, block); - } - - @JRubyMethod(name = {"proc"}, frame = true, module = true, visibility = PRIVATE, compat = CompatVersion.RUBY1_9) - public static RubyProc proc_1_9(ThreadContext context, IRubyObject recv, Block block) { - return context.getRuntime().newProc(Block.Type.PROC, block); - } - - @JRubyMethod(name = "loop", frame = true, module = true, visibility = PRIVATE) - public static IRubyObject loop(ThreadContext context, IRubyObject recv, Block block) { - while (true) { - block.yield(context, context.getRuntime().getNil()); - - context.pollThreadEvents(); - } - } - - @JRubyMethod(name = "test", required = 2, optional = 1, module = true, visibility = PRIVATE) - public static IRubyObject test(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - if (args.length == 0) throw context.getRuntime().newArgumentError("wrong number of arguments"); - - int cmd; - if (args[0] instanceof RubyFixnum) { - cmd = (int)((RubyFixnum) args[0]).getLongValue(); - } else if (args[0] instanceof RubyString && - ((RubyString) args[0]).getByteList().length() > 0) { - // MRI behavior: use first byte of string value if len > 0 - cmd = ((RubyString) args[0]).getByteList().charAt(0); - } else { - cmd = (int) args[0].convertToInteger().getLongValue(); - } - - // MRI behavior: raise ArgumentError for 'unknown command' before - // checking number of args. - switch(cmd) { - case 'A': case 'b': case 'c': case 'C': case 'd': case 'e': case 'f': case 'g': case 'G': - case 'k': case 'M': case 'l': case 'o': case 'O': case 'p': case 'r': case 'R': case 's': - case 'S': case 'u': case 'w': case 'W': case 'x': case 'X': case 'z': case '=': case '<': - case '>': case '-': - break; - default: - throw context.getRuntime().newArgumentError("unknown command ?" + (char) cmd); - } - - // MRI behavior: now check arg count - - switch(cmd) { - case '-': case '=': case '<': case '>': - if (args.length != 3) throw context.getRuntime().newArgumentError(args.length, 3); - break; - default: - if (args.length != 2) throw context.getRuntime().newArgumentError(args.length, 2); - break; - } - - switch (cmd) { - case 'A': // ?A | Time | Last access time for file1 - return context.getRuntime().newFileStat(args[1].convertToString().toString(), false).atime(); - case 'b': // ?b | boolean | True if file1 is a block device - return RubyFileTest.blockdev_p(recv, args[1]); - case 'c': // ?c | boolean | True if file1 is a character device - return RubyFileTest.chardev_p(recv, args[1]); - case 'C': // ?C | Time | Last change time for file1 - return context.getRuntime().newFileStat(args[1].convertToString().toString(), false).ctime(); - case 'd': // ?d | boolean | True if file1 exists and is a directory - return RubyFileTest.directory_p(recv, args[1]); - case 'e': // ?e | boolean | True if file1 exists - return RubyFileTest.exist_p(recv, args[1]); - case 'f': // ?f | boolean | True if file1 exists and is a regular file - return RubyFileTest.file_p(recv, args[1]); - case 'g': // ?g | boolean | True if file1 has the \CF{setgid} bit - return RubyFileTest.setgid_p(recv, args[1]); - case 'G': // ?G | boolean | True if file1 exists and has a group ownership equal to the caller's group - return RubyFileTest.grpowned_p(recv, args[1]); - case 'k': // ?k | boolean | True if file1 exists and has the sticky bit set - return RubyFileTest.sticky_p(recv, args[1]); - case 'M': // ?M | Time | Last modification time for file1 - return context.getRuntime().newFileStat(args[1].convertToString().toString(), false).mtime(); - case 'l': // ?l | boolean | True if file1 exists and is a symbolic link - return RubyFileTest.symlink_p(recv, args[1]); - case 'o': // ?o | boolean | True if file1 exists and is owned by the caller's effective uid - return RubyFileTest.owned_p(recv, args[1]); - case 'O': // ?O | boolean | True if file1 exists and is owned by the caller's real uid - return RubyFileTest.rowned_p(recv, args[1]); - case 'p': // ?p | boolean | True if file1 exists and is a fifo - return RubyFileTest.pipe_p(recv, args[1]); - case 'r': // ?r | boolean | True if file1 is readable by the effective uid/gid of the caller - return RubyFileTest.readable_p(recv, args[1]); - case 'R': // ?R | boolean | True if file is readable by the real uid/gid of the caller - // FIXME: Need to implement an readable_real_p in FileTest - return RubyFileTest.readable_p(recv, args[1]); - case 's': // ?s | int/nil | If file1 has nonzero size, return the size, otherwise nil - return RubyFileTest.size_p(recv, args[1]); - case 'S': // ?S | boolean | True if file1 exists and is a socket - return RubyFileTest.socket_p(recv, args[1]); - case 'u': // ?u | boolean | True if file1 has the setuid bit set - return RubyFileTest.setuid_p(recv, args[1]); - case 'w': // ?w | boolean | True if file1 exists and is writable by effective uid/gid - return RubyFileTest.writable_p(recv, args[1]); - case 'W': // ?W | boolean | True if file1 exists and is writable by the real uid/gid - // FIXME: Need to implement an writable_real_p in FileTest - return RubyFileTest.writable_p(recv, args[1]); - case 'x': // ?x | boolean | True if file1 exists and is executable by the effective uid/gid - return RubyFileTest.executable_p(recv, args[1]); - case 'X': // ?X | boolean | True if file1 exists and is executable by the real uid/gid - return RubyFileTest.executable_real_p(recv, args[1]); - case 'z': // ?z | boolean | True if file1 exists and has a zero length - return RubyFileTest.zero_p(recv, args[1]); - case '=': // ?= | boolean | True if the modification times of file1 and file2 are equal - return context.getRuntime().newFileStat(args[1].convertToString().toString(), false).mtimeEquals(args[2]); - case '<': // ?< | boolean | True if the modification time of file1 is prior to that of file2 - return context.getRuntime().newFileStat(args[1].convertToString().toString(), false).mtimeLessThan(args[2]); - case '>': // ?> | boolean | True if the modification time of file1 is after that of file2 - return context.getRuntime().newFileStat(args[1].convertToString().toString(), false).mtimeGreaterThan(args[2]); - case '-': // ?- | boolean | True if file1 and file2 are identical - return RubyFileTest.identical_p(recv, args[1], args[2]); - default: - throw new InternalError("unreachable code reached!"); - } - } - - @JRubyMethod(name = "`", required = 1, module = true, visibility = PRIVATE) - public static IRubyObject backquote(ThreadContext context, IRubyObject recv, IRubyObject aString) { - Ruby runtime = context.getRuntime(); - ByteArrayOutputStream output = new ByteArrayOutputStream(); - - RubyString string = aString.convertToString(); - int resultCode = ShellLauncher.runAndWait(runtime, new IRubyObject[] {string}, output); - - runtime.getGlobalVariables().set("$?", RubyProcess.RubyStatus.newProcessStatus(runtime, resultCode)); - - return RubyString.newString(runtime, output.toByteArray()); - } - - @JRubyMethod(name = "srand", optional = 1, module = true, visibility = PRIVATE) - public static RubyInteger srand(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - long oldRandomSeed = runtime.getRandomSeed(); - - if (args.length > 0) { - RubyInteger integerSeed = args[0].convertToInteger(MethodIndex.TO_INT, "to_int"); - runtime.setRandomSeed(integerSeed.getLongValue()); - } else { - // Not sure how well this works, but it works much better than - // just currentTimeMillis by itself. - runtime.setRandomSeed(System.currentTimeMillis() ^ - recv.hashCode() ^ runtime.incrementRandomSeedSequence() ^ - runtime.getRandom().nextInt(Math.max(1, Math.abs((int)runtime.getRandomSeed())))); - } - runtime.getRandom().setSeed(runtime.getRandomSeed()); - return runtime.newFixnum(oldRandomSeed); - } - - @JRubyMethod(name = "rand", optional = 1, module = true, visibility = PRIVATE) - public static RubyNumeric rand(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - long ceil; - if (args.length == 0) { - ceil = 0; - } else if (args.length == 1) { - if (args[0] instanceof RubyBignum) { - byte[] bigCeilBytes = ((RubyBignum) args[0]).getValue().toByteArray(); - BigInteger bigCeil = new BigInteger(bigCeilBytes).abs(); - - byte[] randBytes = new byte[bigCeilBytes.length]; - runtime.getRandom().nextBytes(randBytes); - - BigInteger result = new BigInteger(randBytes).abs().mod(bigCeil); - - return new RubyBignum(runtime, result); - } - - RubyInteger integerCeil = (RubyInteger)RubyKernel.new_integer(context, recv, args[0]); - ceil = Math.abs(integerCeil.getLongValue()); - } else { - throw runtime.newArgumentError("wrong # of arguments(" + args.length + " for 1)"); - } - - if (ceil == 0) { - return RubyFloat.newFloat(runtime, runtime.getRandom().nextDouble()); - } - if (ceil > Integer.MAX_VALUE) { - return runtime.newFixnum(Math.abs(runtime.getRandom().nextLong()) % ceil); - } - - return runtime.newFixnum(runtime.getRandom().nextInt((int) ceil)); - } - - @JRubyMethod(name = "syscall", required = 1, optional = 9, module = true, visibility = PRIVATE) - public static IRubyObject syscall(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - throw context.getRuntime().newNotImplementedError("Kernel#syscall is not implemented in JRuby"); - } - - @JRubyMethod(name = {"system"}, required = 1, rest = true, module = true, visibility = PRIVATE) - public static RubyBoolean system(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - int resultCode; - try { - resultCode = ShellLauncher.runAndWait(runtime, args); - } catch (Exception e) { - resultCode = 127; - } - runtime.getGlobalVariables().set("$?", RubyProcess.RubyStatus.newProcessStatus(runtime, resultCode)); - return runtime.newBoolean(resultCode == 0); - } - - @JRubyMethod(name = {"exec"}, required = 1, rest = true, module = true, visibility = PRIVATE) - public static IRubyObject exec(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - int resultCode; - try { - // TODO: exec should replace the current process. - // This could be possible with JNA. - resultCode = ShellLauncher.execAndWait(runtime, args); - } catch (Exception e) { - throw runtime.newErrnoENOENTError("cannot execute"); - } - - return exit(recv, new IRubyObject[] {runtime.newFixnum(resultCode)}); - } - - @JRubyMethod(name = "fork", module = true, visibility = PRIVATE) - public static IRubyObject fork(ThreadContext context, IRubyObject recv, Block block) { - Ruby runtime = context.getRuntime(); - - if (!RubyInstanceConfig.FORK_ENABLED) { - throw runtime.newNotImplementedError("fork is unsafe and disabled by default on JRuby"); - } - - if (block.isGiven()) { - int pid = runtime.getPosix().fork(); - - if (pid == 0) { - try { - block.yield(context, runtime.getNil()); - } catch (RaiseException re) { - if (re.getException() instanceof RubySystemExit) { - throw re; - } - return exit_bang(recv, new IRubyObject[] {RubyFixnum.minus_one(runtime)}); - } catch (Throwable t) { - return exit_bang(recv, new IRubyObject[] {RubyFixnum.minus_one(runtime)}); - } - return exit_bang(recv, new IRubyObject[] {RubyFixnum.zero(runtime)}); - } else { - return runtime.newFixnum(pid); - } - } else { - int result = runtime.getPosix().fork(); - - if (result == -1) { - return runtime.getNil(); - } - - return runtime.newFixnum(result); - } - } - - @JRubyMethod(frame = true, module = true) - public static IRubyObject tap(ThreadContext context, IRubyObject recv, Block block) { - block.yield(context, recv); - return recv; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Charles O Nutter <headius@headius.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ - -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.builtin.IRubyObject; - -@JRubyClass(name="LocalJumpError",parent="StandardError") -public class RubyLocalJumpError extends RubyException { - private static ObjectAllocator LOCALJUMPERROR_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyLocalJumpError(runtime, klass); - } - }; - - public static RubyClass createLocalJumpErrorClass(Ruby runtime, RubyClass standardErrorClass) { - RubyClass nameErrorClass = runtime.defineClass("LocalJumpError", standardErrorClass, LOCALJUMPERROR_ALLOCATOR); - - nameErrorClass.defineAnnotatedMethods(RubyLocalJumpError.class); - - return nameErrorClass; - } - - private RubyLocalJumpError(Ruby runtime, RubyClass exceptionClass) { - super(runtime, exceptionClass); - } - - public RubyLocalJumpError(Ruby runtime, RubyClass exceptionClass, String message, String reason, IRubyObject exitValue) { - super(runtime, exceptionClass, message); - fastSetInternalVariable("reason", runtime.newSymbol(reason)); - fastSetInternalVariable("exit_value", exitValue); - } - - @JRubyMethod(name = "reason") - public IRubyObject reason() { - return fastGetInternalVariable("reason"); - } - - @JRubyMethod(name = "exit_value") - public IRubyObject exit_value() { - return fastGetInternalVariable("exit_value"); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2007 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2003 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.EOFException; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; - -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Block; -import org.jruby.runtime.Constants; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; - -import org.jruby.util.ByteList; -import org.jruby.util.IOInputStream; -import org.jruby.util.IOOutputStream; - -/** - * Marshal module - * - * @author Anders - */ -@JRubyModule(name="Marshal") -public class RubyMarshal { - - public static RubyModule createMarshalModule(Ruby runtime) { - RubyModule module = runtime.defineModule("Marshal"); - runtime.setMarshal(module); - - module.defineAnnotatedMethods(RubyMarshal.class); - module.defineConstant("MAJOR_VERSION", runtime.newFixnum(Constants.MARSHAL_MAJOR)); - module.defineConstant("MINOR_VERSION", runtime.newFixnum(Constants.MARSHAL_MINOR)); - - return module; - } - - @JRubyMethod(name = "dump", required = 1, optional = 2, frame = true, module = true) - public static IRubyObject dump(IRubyObject recv, IRubyObject[] args, Block unusedBlock) { - if (args.length < 1) { - throw recv.getRuntime().newArgumentError("wrong # of arguments(at least 1)"); - } - IRubyObject objectToDump = args[0]; - - IRubyObject io = null; - int depthLimit = -1; - - if (args.length >= 2) { - if (args[1].respondsTo("write")) { - io = args[1]; - } else if (args[1] instanceof RubyFixnum) { - depthLimit = (int) ((RubyFixnum) args[1]).getLongValue(); - } else { - throw recv.getRuntime().newTypeError("Instance of IO needed"); - } - if (args.length == 3) { - depthLimit = (int) ((RubyFixnum) args[2]).getLongValue(); - } - } - - try { - if (io != null) { - dumpToStream(objectToDump, outputStream(io), depthLimit); - return io; - } - ByteArrayOutputStream stringOutput = new ByteArrayOutputStream(); - dumpToStream(objectToDump, stringOutput, depthLimit); - - return RubyString.newString(recv.getRuntime(), new ByteList(stringOutput.toByteArray(),false)); - - } catch (IOException ioe) { - throw recv.getRuntime().newIOErrorFromException(ioe); - } - - } - - private static OutputStream outputStream(IRubyObject out) { - setBinmodeIfPossible(out); - if (out instanceof RubyIO) { - return ((RubyIO) out).getOutStream(); - } - return new IOOutputStream(out); - } - - private static void setBinmodeIfPossible(IRubyObject io) { - if (io.respondsTo("binmode")) { - io.callMethod(io.getRuntime().getCurrentContext(), "binmode"); - } - } - - @JRubyMethod(name = {"load", "restore"}, required = 1, optional = 1, frame = true, module = true) - public static IRubyObject load(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block unusedBlock) { - try { - if (args.length < 1) { - throw recv.getRuntime().newArgumentError("wrong number of arguments (0 for 1)"); - } - - if (args.length > 2) { - throw recv.getRuntime().newArgumentError("wrong number of arguments (" + args.length + " for 2)"); - } - - IRubyObject in = null; - IRubyObject proc = null; - - switch (args.length) { - case 2: - proc = args[1]; - case 1: - in = args[0]; - } - - InputStream rawInput; - if (in != null && in.respondsTo("read")) { - rawInput = inputStream(in); - } else if (in != null && in.respondsTo("to_str")) { - RubyString inString = (RubyString) RuntimeHelpers.invoke(context, in, "to_str"); - ByteList bytes = inString.getByteList(); - rawInput = new ByteArrayInputStream(bytes.unsafeBytes(), bytes.begin(), bytes.length()); - } else { - throw recv.getRuntime().newTypeError("instance of IO needed"); - } - - UnmarshalStream input = new UnmarshalStream(recv.getRuntime(), rawInput, proc); - - return input.unmarshalObject(); - - } catch (EOFException ee) { - throw recv.getRuntime().newEOFError(); - } catch (IOException ioe) { - throw recv.getRuntime().newIOErrorFromException(ioe); - } - } - - private static InputStream inputStream(IRubyObject in) { - setBinmodeIfPossible(in); - if (in instanceof RubyIO) { - return ((RubyIO) in).getInStream(); - } - return new IOInputStream(in); - } - - private static void dumpToStream(IRubyObject object, OutputStream rawOutput, int depthLimit) - throws IOException - { - MarshalStream output = new MarshalStream(object.getRuntime(), rawOutput, depthLimit); - output.dumpObject(object); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.util.Iterator; - -import org.joni.NameEntry; -import org.joni.Regex; -import org.joni.Region; -import org.joni.exception.JOniException; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; - -/** - * @author olabini - */ -@JRubyClass(name="MatchData") -public class RubyMatchData extends RubyObject { - Region regs; // captures - int begin; // begin and end are used when not groups defined - int end; - RubyString str; - Regex pattern; - - public static RubyClass createMatchDataClass(Ruby runtime) { - // TODO: Is NOT_ALLOCATABLE_ALLOCATOR ok here, since you can't actually instantiate MatchData directly? - RubyClass matchDataClass = runtime.defineClass("MatchData", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setMatchData(matchDataClass); - runtime.defineGlobalConstant("MatchingData", matchDataClass); - matchDataClass.kindOf = new RubyModule.KindOf() { - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyMatchData; - } - }; - - matchDataClass.getMetaClass().undefineMethod("new"); - - matchDataClass.defineAnnotatedMethods(RubyMatchData.class); - - return matchDataClass; - } - - public RubyMatchData(Ruby runtime) { - super(runtime, runtime.getMatchData()); - } - - public final static int MATCH_BUSY = USER2_F; - - // rb_match_busy - public final void use() { - flags |= MATCH_BUSY; - } - - public final boolean used() { - return (flags & MATCH_BUSY) != 0; - } - - private RubyArray match_array(Ruby runtime, int start) { - if (regs == null) { - if (start != 0) return runtime.newEmptyArray(); - if (begin == -1) { - return getRuntime().newArray(runtime.getNil()); - } else { - RubyString ss = str.makeShared(runtime, begin, end - begin); - if (isTaint()) ss.setTaint(true); - return getRuntime().newArray(ss); - } - } else { - RubyArray arr = getRuntime().newArray(regs.numRegs - start); - for (int i=start; i<regs.numRegs; i++) { - if (regs.beg[i] == -1) { - arr.append(getRuntime().getNil()); - } else { - RubyString ss = str.makeShared(runtime, regs.beg[i], regs.end[i] - regs.beg[i]); - if (isTaint()) ss.setTaint(true); - arr.append(ss); - } - } - return arr; - } - - } - - public IRubyObject group(long n) { - return RubyRegexp.nth_match((int)n, this); - } - - public IRubyObject group(int n) { - return RubyRegexp.nth_match(n, this); - } - - @JRubyMethod(name = "inspect") - public IRubyObject inspect() { - if (pattern == null) return anyToString(); - - RubyString result = getRuntime().newString(); - result.cat((byte)'#').cat((byte)'<'); - result.append(getMetaClass().getRealClass().to_s()); - - NameEntry[]names = new NameEntry[regs == null ? 1 : regs.numRegs]; - - if (pattern.numberOfNames() > 0) { - for (Iterator<NameEntry> i = pattern.namedBackrefIterator(); i.hasNext();) { - NameEntry e = i.next(); - for (int num : e.getBackRefs()) names[num] = e; - } - } - - for (int i=0; i<names.length; i++) { - result.cat((byte)' '); - if (i > 0) { - NameEntry e = names[i]; - if (e != null) { - result.cat(e.name, e.nameP, e.nameEnd - e.nameP); - } else { - result.cat((byte)('0' + i)); - } - result.cat((byte)':'); - } - IRubyObject v = RubyRegexp.nth_match(i, this); - if (v.isNil()) { - result.cat("nil".getBytes()); - } else { - result.append(v.inspect()); - } - } - - return result.cat((byte)'>'); - } - - /** match_to_a - * - */ - @JRubyMethod(name = "to_a") - @Override - public RubyArray to_a() { - return match_array(getRuntime(), 0); - } - - @JRubyMethod(name = "values_at", required = 1, rest = true) - public IRubyObject values_at(IRubyObject[] args) { - return to_a().values_at(args); - } - - @JRubyMethod(name = "select", frame = true) - public IRubyObject select(ThreadContext context, Block block) { - return block.yield(context, to_a()); - } - - /** match_captures - * - */ - @JRubyMethod(name = "captures") - public IRubyObject captures(ThreadContext context) { - return match_array(context.getRuntime(), 1); - } - - private int nameToBackrefNumber(RubyString str) { - ByteList value = str.getByteList(); - try { - return pattern.nameToBackrefNumber(value.bytes, value.begin, value.begin + value.realSize, regs); - } catch (JOniException je) { - throw getRuntime().newIndexError(je.getMessage()); - } - } - - final int backrefNumber(IRubyObject obj) { - if (obj instanceof RubySymbol) { - return nameToBackrefNumber((RubyString)((RubySymbol)obj).id2name()); - } else if (obj instanceof RubyString) { - return nameToBackrefNumber((RubyString)obj); - } else { - return RubyNumeric.num2int(obj); - } - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public IRubyObject op_aref(IRubyObject[] args) { - switch (args.length) { - case 1: - return op_aref(args[0]); - case 2: - return op_aref(args[0], args[1]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** match_aref - * - */ - @JRubyMethod(name = "[]") - public IRubyObject op_aref(IRubyObject idx) { - IRubyObject result = op_arefCommon(idx); - return result == null ? ((RubyArray)to_a()).aref(idx) : result; - } - - /** match_aref - * - */ - @JRubyMethod(name = "[]") - public IRubyObject op_aref(IRubyObject idx, IRubyObject rest) { - IRubyObject result; - return !rest.isNil() || (result = op_arefCommon(idx)) == null ? ((RubyArray)to_a()).aref(idx, rest) : result; - } - - private IRubyObject op_arefCommon(IRubyObject idx) { - if (idx instanceof RubyFixnum) { - int num = RubyNumeric.fix2int(idx); - if (num >= 0) return RubyRegexp.nth_match(num, this); - } else { - if (idx instanceof RubySymbol) { - return RubyRegexp.nth_match(nameToBackrefNumber((RubyString)((RubySymbol)idx).id2name()), this); - } else if (idx instanceof RubyString) { - return RubyRegexp.nth_match(nameToBackrefNumber((RubyString)idx), this); - } - } - return null; - } - - /** match_size - * - */ - @JRubyMethod(name = {"size", "length"}) - public IRubyObject size() { - return regs == null ? RubyFixnum.one(getRuntime()) : RubyFixnum.newFixnum(getRuntime(), regs.numRegs); - } - - /** match_begin - * - */ - @JRubyMethod(name = "begin", required = 1) - public IRubyObject begin(IRubyObject index) { - int i = backrefNumber(index); - - if (regs == null) { - if (i != 0) throw getRuntime().newIndexError("index " + i + " out of matches"); - if (begin < 0) return getRuntime().getNil(); - return RubyFixnum.newFixnum(getRuntime(), begin); - } else { - if (i < 0 || regs.numRegs <= i) throw getRuntime().newIndexError("index " + i + " out of matches"); - if (regs.beg[i] < 0) return getRuntime().getNil(); - return RubyFixnum.newFixnum(getRuntime(), regs.beg[i]); - } - } - - /** match_end - * - */ - @JRubyMethod(name = "end", required = 1) - public IRubyObject end(IRubyObject index) { - int i = backrefNumber(index); - - if (regs == null) { - if (i != 0) throw getRuntime().newIndexError("index " + i + " out of matches"); - if (end < 0) return getRuntime().getNil(); - return RubyFixnum.newFixnum(getRuntime(), end); - } else { - if (i < 0 || regs.numRegs <= i) throw getRuntime().newIndexError("index " + i + " out of matches"); - if (regs.end[i] < 0) return getRuntime().getNil(); - return RubyFixnum.newFixnum(getRuntime(), regs.end[i]); - } - } - - /** match_offset - * - */ - @JRubyMethod(name = "offset", required = 1) - public IRubyObject offset(IRubyObject index) { - int i = backrefNumber(index); - Ruby runtime = getRuntime(); - - if (regs == null) { - if (i != 0) throw getRuntime().newIndexError("index " + i + " out of matches"); - if (begin < 0) return runtime.newArray(runtime.getNil(), runtime.getNil()); - return runtime.newArray(RubyFixnum.newFixnum(runtime, begin),RubyFixnum.newFixnum(runtime, end)); - } else { - if (i < 0 || regs.numRegs <= i) throw runtime.newIndexError("index " + i + " out of matches"); - if (regs.beg[i] < 0) return runtime.newArray(runtime.getNil(), runtime.getNil()); - return runtime.newArray(RubyFixnum.newFixnum(runtime, regs.beg[i]),RubyFixnum.newFixnum(runtime, regs.end[i])); - } - } - - /** match_pre_match - * - */ - @JRubyMethod(name = "pre_match") - public IRubyObject pre_match(ThreadContext context) { - RubyString ss; - - if (regs == null) { - if(begin == -1) return context.getRuntime().getNil(); - ss = str.makeShared(context.getRuntime(), 0, begin); - } else { - if(regs.beg[0] == -1) return context.getRuntime().getNil(); - ss = str.makeShared(context.getRuntime(), 0, regs.beg[0]); - } - - if (isTaint()) ss.setTaint(true); - return ss; - } - - /** match_post_match - * - */ - @JRubyMethod(name = "post_match") - public IRubyObject post_match(ThreadContext context) { - RubyString ss; - - if (regs == null) { - if (begin == -1) return context.getRuntime().getNil(); - ss = str.makeShared(context.getRuntime(), end, str.getByteList().length() - end); - } else { - if (regs.beg[0] == -1) return context.getRuntime().getNil(); - ss = str.makeShared(context.getRuntime(), regs.end[0], str.getByteList().length() - regs.end[0]); - } - - if(isTaint()) ss.setTaint(true); - return ss; - } - - /** match_to_s - * - */ - @JRubyMethod(name = "to_s") - public IRubyObject to_s() { - IRubyObject ss = RubyRegexp.last_match(this); - if (ss.isNil()) ss = RubyString.newEmptyString(getRuntime()); - if (isTaint()) ss.setTaint(true); - return ss; - } - - /** match_string - * - */ - @JRubyMethod(name = "string") - public IRubyObject string() { - return str; //str is frozen - } - - @JRubyMethod(name = "initialize_copy", required = 1) - public IRubyObject initialize_copy(IRubyObject original) { - if (this == original) return this; - - if (!(getMetaClass() == original.getMetaClass())){ // MRI also does a pointer comparison here - throw getRuntime().newTypeError("wrong argument class"); - } - - RubyMatchData origMatchData = (RubyMatchData)original; - str = origMatchData.str; - regs = origMatchData.regs; - - return this; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001-2002 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -@JRubyModule(name="Math") -public class RubyMath { - /** Create the Math module and add it to the Ruby runtime. - * - */ - public static RubyModule createMathModule(Ruby runtime) { - RubyModule result = runtime.defineModule("Math"); - runtime.setMath(result); - - result.defineConstant("E", RubyFloat.newFloat(runtime, Math.E)); - result.defineConstant("PI", RubyFloat.newFloat(runtime, Math.PI)); - - result.defineAnnotatedMethods(RubyMath.class); - - return result; - } - - - private static void domainCheck(IRubyObject recv, double value, String msg) { - if (Double.isNaN(value)) { - throw recv.getRuntime().newErrnoEDOMError(msg); - } - } - - private static double chebylevSerie(double x, double coef[]) { - double b0, b1, b2, twox; - int i; - b1 = 0.0; - b0 = 0.0; - b2 = 0.0; - twox = 2.0 * x; - for (i = coef.length-1; i >= 0; i--) { - b2 = b1; - b1 = b0; - b0 = twox * b1 - b2 + coef[i]; - } - return 0.5*(b0 - b2); - } - - private static double sign(double x, double y) { - double abs = ((x < 0) ? -x : x); - return (y < 0.0) ? -abs : abs; - } - - @JRubyMethod(name = "atan2", required = 2, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat atan2(IRubyObject recv, IRubyObject x, IRubyObject y) { - double valuea = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double valueb = ((RubyFloat)RubyKernel.new_float(recv,y)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(), Math.atan2(valuea, valueb)); - } - - @JRubyMethod(name = "cos", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat cos(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(),Math.cos(value)); - } - - @JRubyMethod(name = "sin", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat sin(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(),Math.sin(value)); - } - - @JRubyMethod(name = "tan", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat tan(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(),Math.tan(value)); - } - - @JRubyMethod(name = "asin", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat asin(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double result = Math.asin(value); - domainCheck(recv, result, "asin"); - return RubyFloat.newFloat(recv.getRuntime(),result); - } - - @JRubyMethod(name = "acos", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat acos(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double result = Math.acos(value); - domainCheck(recv, result, "acos"); - return RubyFloat.newFloat(recv.getRuntime(), result); - } - - @JRubyMethod(name = "atan", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat atan(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(),Math.atan(value)); - } - - @JRubyMethod(name = "cosh", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat cosh(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(),(Math.exp(value) + Math.exp(-value)) / 2.0); - } - - @JRubyMethod(name = "sinh", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat sinh(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(),(Math.exp(value) - Math.exp(-value)) / 2.0); - } - - @JRubyMethod(name = "tanh", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat tanh(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(), Math.tanh(value)); - } - - @JRubyMethod(name = "acosh", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat acosh(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double result; - if (Double.isNaN(value) || value < 1) { - result = Double.NaN; - } else if (value < 94906265.62) { - result = Math.log(value + Math.sqrt(value * value - 1.0)); - } else{ - result = 0.69314718055994530941723212145818 + Math.log(value); - } - - domainCheck(recv, result, "acosh"); - - return RubyFloat.newFloat(recv.getRuntime(),result); - } - - private static final double ASINH_COEF[] = { - -.12820039911738186343372127359268e+0, - -.58811761189951767565211757138362e-1, - .47274654322124815640725249756029e-2, - -.49383631626536172101360174790273e-3, - .58506207058557412287494835259321e-4, - -.74669983289313681354755069217188e-5, - .10011693583558199265966192015812e-5, - -.13903543858708333608616472258886e-6, - .19823169483172793547317360237148e-7, - -.28847468417848843612747272800317e-8, - .42672965467159937953457514995907e-9, - -.63976084654366357868752632309681e-10, - .96991686089064704147878293131179e-11, - -.14844276972043770830246658365696e-11, - .22903737939027447988040184378983e-12, - -.35588395132732645159978942651310e-13, - .55639694080056789953374539088554e-14, - -.87462509599624678045666593520162e-15, - .13815248844526692155868802298129e-15, - -.21916688282900363984955142264149e-16, - .34904658524827565638313923706880e-17 - }; - - @JRubyMethod(name = "asinh", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat asinh(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double y = Math.abs(value); - double result; - - if (Double.isNaN(value)) { - result = Double.NaN; - } else if (y <= 1.05367e-08) { - result = value; - } else if (y <= 1.0) { - result = value * (1.0 + chebylevSerie(2.0 * value * value - 1.0, ASINH_COEF)); - } else if (y < 94906265.62) { - result = Math.log(value + Math.sqrt(value * value + 1.0)); - } else { - result = 0.69314718055994530941723212145818 + Math.log(y); - if (value < 0) result *= -1; - } - - return RubyFloat.newFloat(recv.getRuntime(),result); - } - - private static final double ATANH_COEF[] = { - .9439510239319549230842892218633e-1, - .4919843705578615947200034576668e-1, - .2102593522455432763479327331752e-2, - .1073554449776116584640731045276e-3, - .5978267249293031478642787517872e-5, - .3505062030889134845966834886200e-6, - .2126374343765340350896219314431e-7, - .1321694535715527192129801723055e-8, - .8365875501178070364623604052959e-10, - .5370503749311002163881434587772e-11, - .3486659470157107922971245784290e-12, - .2284549509603433015524024119722e-13, - .1508407105944793044874229067558e-14, - .1002418816804109126136995722837e-15, - .6698674738165069539715526882986e-17, - .4497954546494931083083327624533e-18 - }; - - @JRubyMethod(name = "atanh", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat atanh(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double y = Math.abs(value); - double result; - - if (Double.isNaN(value)) { - result = Double.NaN; - } else if (y < 1.82501e-08) { - result = value; - } else if (y <= 0.5) { - result = value * (1.0 + chebylevSerie(8.0 * value * value - 1.0, ATANH_COEF)); - } else if (y < 1.0) { - result = 0.5 * Math.log((1.0 + value) / (1.0 - value)); - } else if (y == 1.0) { - result = value * Double.POSITIVE_INFINITY; - } else { - result = Double.NaN; - } - - domainCheck(recv, result, "atanh"); - return RubyFloat.newFloat(recv.getRuntime(),result); - } - - @JRubyMethod(name = "exp", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat exp(IRubyObject recv, IRubyObject exponent) { - double value = ((RubyFloat)RubyKernel.new_float(recv,exponent)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(),Math.exp(value)); - } - - /** Returns the natural logarithm of x. - * - */ - @JRubyMethod(name = "log", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat log(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double result = Math.log(value); - domainCheck(recv, result, "log"); - return RubyFloat.newFloat(recv.getRuntime(),result); - } - - /** Returns the base 10 logarithm of x. - * - */ - @JRubyMethod(name = "log10", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat log10(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double result = Math.log(value) / Math.log(10); - domainCheck(recv, result, "log10"); - return RubyFloat.newFloat(recv.getRuntime(),result); - } - - @JRubyMethod(name = "sqrt", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat sqrt(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double result; - - if (value < 0) { - result = Double.NaN; - } else{ - result = Math.sqrt(value); - } - - domainCheck(recv, result, "sqrt"); - return RubyFloat.newFloat(recv.getRuntime(), result); - } - - @JRubyMethod(name = "hypot", required = 2, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat hypot(IRubyObject recv, IRubyObject x, IRubyObject y) { - double valuea = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double valueb = ((RubyFloat)RubyKernel.new_float(recv,y)).getDoubleValue(); - double result; - - if (Math.abs(valuea) > Math.abs(valueb)) { - result = valueb / valuea; - result = Math.abs(valuea) * Math.sqrt(1 + result * result); - } else if (valueb != 0) { - result = valuea / valueb; - result = Math.abs(valueb) * Math.sqrt(1 + result * result); - } else { - result = 0; - } - return RubyFloat.newFloat(recv.getRuntime(),result); - } - - - /* - * x = mantissa * 2 ** exponent - * - * Where mantissa is in the range of [.5, 1) - * - */ - @JRubyMethod(name = "frexp", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyArray frexp(IRubyObject recv, IRubyObject other) { - double mantissa = ((RubyFloat)RubyKernel.new_float(recv,other)).getDoubleValue(); - short sign = 1; - long exponent = 0; - - if (mantissa != 0.0) { - // Make mantissa same sign so we only have one code path. - if (mantissa < 0) { - mantissa = -mantissa; - sign = -1; - } - - // Increase value to hit lower range. - for (; mantissa < 0.5; mantissa *= 2.0, exponent -=1) { } - - // Decrease value to hit upper range. - for (; mantissa >= 1.0; mantissa *= 0.5, exponent +=1) { } - } - - return RubyArray.newArray(recv.getRuntime(), - RubyFloat.newFloat(recv.getRuntime(), sign * mantissa), - RubyNumeric.int2fix(recv.getRuntime(), exponent)); - } - - /* - * r = x * 2 ** y - */ - @JRubyMethod(name = "ldexp", required = 2, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat ldexp(IRubyObject recv, IRubyObject mantissa, IRubyObject exponent) { - double mantissaValue = ((RubyFloat)RubyKernel.new_float(recv, mantissa)).getDoubleValue(); - return RubyFloat.newFloat(recv.getRuntime(),mantissaValue * Math.pow(2.0, RubyNumeric.num2int(exponent))); - } - - private static final double ERFC_COEF[] = { - -.490461212346918080399845440334e-1, - -.142261205103713642378247418996e0, - .100355821875997955757546767129e-1, - -.576876469976748476508270255092e-3, - .274199312521960610344221607915e-4, - -.110431755073445076041353812959e-5, - .384887554203450369499613114982e-7, - -.118085825338754669696317518016e-8, - .323342158260509096464029309534e-10, - -.799101594700454875816073747086e-12, - .179907251139614556119672454866e-13, - -.371863548781869263823168282095e-15, - .710359900371425297116899083947e-17, - -.126124551191552258324954248533e-18 - }; - - @JRubyMethod(name = "erf", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat erf(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - - double result; - double y = Math.abs(value); - - if (y <= 1.49012e-08) { - result = 2 * value / 1.77245385090551602729816748334; - } else if (y <= 1) { - result = value * (1 + chebylevSerie(2 * value * value - 1, ERFC_COEF)); - } else if (y < 6.013687357) { - result = sign(1 - erfc(recv, RubyFloat.newFloat(recv.getRuntime(),y)).getDoubleValue(), value); - } else { - result = sign(1, value); - } - return RubyFloat.newFloat(recv.getRuntime(),result); - } - - private static final double ERFC2_COEF[] = { - -.69601346602309501127391508262e-1, - -.411013393626208934898221208467e-1, - .391449586668962688156114370524e-2, - -.490639565054897916128093545077e-3, - .715747900137703638076089414183e-4, - -.115307163413123283380823284791e-4, - .199467059020199763505231486771e-5, - -.364266647159922287393611843071e-6, - .694437261000501258993127721463e-7, - -.137122090210436601953460514121e-7, - .278838966100713713196386034809e-8, - -.581416472433116155186479105032e-9, - .123892049175275318118016881795e-9, - -.269063914530674343239042493789e-10, - .594261435084791098244470968384e-11, - -.133238673575811957928775442057e-11, - .30280468061771320171736972433e-12, - -.696664881494103258879586758895e-13, - .162085454105392296981289322763e-13, - -.380993446525049199987691305773e-14, - .904048781597883114936897101298e-15, - -.2164006195089607347809812047e-15, - .522210223399585498460798024417e-16, - -.126972960236455533637241552778e-16, - .310914550427619758383622741295e-17, - -.766376292032038552400956671481e-18, - .190081925136274520253692973329e-18 - }; - - private static final double ERFCC_COEF[] = { - .715179310202924774503697709496e-1, - -.265324343376067157558893386681e-1, - .171115397792085588332699194606e-2, - -.163751663458517884163746404749e-3, - .198712935005520364995974806758e-4, - -.284371241276655508750175183152e-5, - .460616130896313036969379968464e-6, - -.822775302587920842057766536366e-7, - .159214187277090112989358340826e-7, - -.329507136225284321486631665072e-8, - .72234397604005554658126115389e-9, - -.166485581339872959344695966886e-9, - .401039258823766482077671768814e-10, - -.100481621442573113272170176283e-10, - .260827591330033380859341009439e-11, - -.699111056040402486557697812476e-12, - .192949233326170708624205749803e-12, - -.547013118875433106490125085271e-13, - .158966330976269744839084032762e-13, - -.47268939801975548392036958429e-14, - .14358733767849847867287399784e-14, - -.444951056181735839417250062829e-15, - .140481088476823343737305537466e-15, - -.451381838776421089625963281623e-16, - .147452154104513307787018713262e-16, - -.489262140694577615436841552532e-17, - .164761214141064673895301522827e-17, - -.562681717632940809299928521323e-18, - .194744338223207851429197867821e-18 - }; - - @JRubyMethod(name = "erfc", required = 1, module = true, visibility = Visibility.PRIVATE) - public static RubyFloat erfc(IRubyObject recv, IRubyObject x) { - double value = ((RubyFloat)RubyKernel.new_float(recv,x)).getDoubleValue(); - double result; - double y = Math.abs(value); - - if (value <= -6.013687357) { - result = 2; - } else if (y < 1.49012e-08) { - result = 1 - 2 * value / 1.77245385090551602729816748334; - } else { - double ysq = y*y; - if (y < 1) { - result = 1 - value * (1 + chebylevSerie(2 * ysq - 1, ERFC_COEF)); - } else if (y <= 4.0) { - result = Math.exp(-ysq)/y*(0.5+chebylevSerie((8.0 / ysq - 5.0) / 3.0, ERFC2_COEF)); - if (value < 0) result = 2.0 - result; - if (value < 0) result = 2.0 - result; - if (value < 0) result = 2.0 - result; - } else { - result = Math.exp(-ysq) / y * (0.5 + chebylevSerie(8.0 / ysq - 1, ERFCC_COEF)); - if (value < 0) result = 2.0 - result; - } - } - return RubyFloat.newFloat(recv.getRuntime(),result); - } - -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.exceptions.JumpException; -import org.jruby.internal.runtime.methods.DynamicMethod; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallbackFactory; -import org.jruby.runtime.MethodBlock; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * The RubyMethod class represents a RubyMethod object. - * - * You can get such a method by calling the "method" method of an object. - * - * Note: This was renamed from Method.java - * - * @author jpetersen - * @since 0.2.3 - */ -@JRubyClass(name="Method") -public class RubyMethod extends RubyObject { - protected RubyModule implementationModule; - protected String methodName; - protected RubyModule originModule; - protected String originName; - protected DynamicMethod method; - protected IRubyObject receiver; - - protected RubyMethod(Ruby runtime, RubyClass rubyClass) { - super(runtime, rubyClass); - } - - /** Create the RubyMethod class and add it to the Ruby runtime. - * - */ - public static RubyClass createMethodClass(Ruby runtime) { - // TODO: NOT_ALLOCATABLE_ALLOCATOR is probably ok here. Confirm. JRUBY-415 - RubyClass methodClass = runtime.defineClass("Method", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setMethod(methodClass); - - methodClass.defineAnnotatedMethods(RubyMethod.class); - - return methodClass; - } - - public static RubyMethod newMethod( - RubyModule implementationModule, - String methodName, - RubyModule originModule, - String originName, - DynamicMethod method, - IRubyObject receiver) { - Ruby runtime = implementationModule.getRuntime(); - RubyMethod newMethod = new RubyMethod(runtime, runtime.getMethod()); - - newMethod.implementationModule = implementationModule; - newMethod.methodName = methodName; - newMethod.originModule = originModule; - newMethod.originName = originName; - newMethod.method = method.getRealMethod(); - newMethod.receiver = receiver; - - return newMethod; - } - - /** Call the method. - * - */ - @JRubyMethod(name = {"call", "[]"}) - public IRubyObject call(ThreadContext context, Block block) { - return method.call(context, receiver, implementationModule, methodName, block); - } - @JRubyMethod(name = {"call", "[]"}) - public IRubyObject call(ThreadContext context, IRubyObject arg, Block block) { - return method.call(context, receiver, implementationModule, methodName, arg, block); - } - @JRubyMethod(name = {"call", "[]"}) - public IRubyObject call(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - return method.call(context, receiver, implementationModule, methodName, arg0, arg1, block); - } - @JRubyMethod(name = {"call", "[]"}) - public IRubyObject call(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) { - return method.call(context, receiver, implementationModule, methodName, arg0, arg1, arg2, block); - } - @JRubyMethod(name = {"call", "[]"}, rest = true) - public IRubyObject call(ThreadContext context, IRubyObject[] args, Block block) { - return method.call(context, receiver, implementationModule, methodName, args, block); - } - - /** Returns the number of arguments a method accepted. - * - * @return the number of arguments of a method. - */ - @JRubyMethod(name = "arity") - public RubyFixnum arity() { - return getRuntime().newFixnum(method.getArity().getValue()); - } - - @JRubyMethod(name = "==", required = 1) - @Override - public RubyBoolean op_equal(ThreadContext context, IRubyObject other) { - if (!(other instanceof RubyMethod)) return context.getRuntime().getFalse(); - RubyMethod otherMethod = (RubyMethod)other; - return context.getRuntime().newBoolean(implementationModule == otherMethod.implementationModule && - originModule == otherMethod.originModule && - receiver == otherMethod.receiver && - method.getRealMethod() == otherMethod.method.getRealMethod()); - } - - @JRubyMethod(name = "clone") - @Override - public RubyMethod rbClone() { - return newMethod(implementationModule, methodName, originModule, originName, method, receiver); - } - - /** Create a Proc object. - * - */ - @JRubyMethod(name = "to_proc", frame = true) - public IRubyObject to_proc(ThreadContext context, Block unusedBlock) { - Ruby runtime = context.getRuntime(); - CallbackFactory f = runtime.callbackFactory(RubyMethod.class); - Block block = MethodBlock.createMethodBlock(context, context.getCurrentScope(), - f.getBlockMethod("bmcall"), this, runtime.getTopSelf()); - - while (true) { - try { - // FIXME: We should not be regenerating this over and over - return mproc(context, block); - } catch (JumpException.BreakJump bj) { - return (IRubyObject) bj.getValue(); - } catch (JumpException.ReturnJump rj) { - return (IRubyObject) rj.getValue(); - } catch (JumpException.RetryJump rj) { - // Execute iterateMethod again. - } - } - } - - /** Create a Proc object which is called like a ruby method. - * - * Used by the RubyMethod#to_proc method. - * - */ - private IRubyObject mproc(ThreadContext context, Block block) { - try { - context.preMproc(); - - return RubyKernel.proc(context, context.getRuntime().getNil(), block); - } finally { - context.postMproc(); - } - } - - /** Delegate a block call to a bound method call. - * - * Used by the RubyMethod#to_proc method. - * - */ - public static IRubyObject bmcall(IRubyObject blockArg, IRubyObject arg1, - IRubyObject self, Block unusedBlock) { - ThreadContext context = blockArg.getRuntime().getCurrentContext(); - - if (blockArg instanceof RubyArray) { - // ENEBO: Very wrong - return ((RubyMethod) arg1).call(context, ((RubyArray) blockArg).toJavaArray(), Block.NULL_BLOCK); - } - // ENEBO: Very wrong - return ((RubyMethod) arg1).call(context, new IRubyObject[] { blockArg }, Block.NULL_BLOCK); - } - - @JRubyMethod(name = "unbind", frame = true) - public RubyUnboundMethod unbind(Block unusedBlock) { - RubyUnboundMethod unboundMethod = - RubyUnboundMethod.newUnboundMethod(implementationModule, methodName, originModule, originName, method); - unboundMethod.infectBy(this); - - return unboundMethod; - } - - @JRubyMethod(name = {"inspect", "to_s"}) - @Override - public IRubyObject inspect() { - StringBuilder buf = new StringBuilder("#<"); - char delimeter = '#'; - - buf.append(getMetaClass().getRealClass().getName()).append(": "); - - if (implementationModule.isSingleton()) { - IRubyObject attached = ((MetaClass) implementationModule).getAttached(); - if (receiver == null) { - buf.append(implementationModule.inspect().toString()); - } else if (receiver == attached) { - buf.append(attached.inspect().toString()); - delimeter = '.'; - } else { - buf.append(receiver.inspect().toString()); - buf.append('(').append(attached.inspect().toString()).append(')'); - delimeter = '.'; - } - } else { - buf.append(originModule.getName()); - - if (implementationModule != originModule) { - buf.append('(').append(implementationModule.getName()).append(')'); - } - } - - buf.append(delimeter).append(methodName).append('>'); - - RubyString str = getRuntime().newString(buf.toString()); - str.setTaint(isTaint()); - return str; - } -} - -/* - **** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006-2007 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2007 William N Dortch <bill.dortch@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.lang.reflect.Modifier; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.Iterator; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.locks.ReentrantLock; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyConstant; -import org.jruby.anno.JavaMethodDescriptor; -import org.jruby.anno.TypePopulator; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.compiler.ASTInspector; -import org.jruby.internal.runtime.methods.AliasMethod; -import org.jruby.internal.runtime.methods.DynamicMethod; -import org.jruby.internal.runtime.methods.FullFunctionCallbackMethod; -import org.jruby.internal.runtime.methods.SimpleCallbackMethod; -import org.jruby.internal.runtime.methods.MethodMethod; -import org.jruby.internal.runtime.methods.ProcMethod; -import org.jruby.internal.runtime.methods.UndefinedMethod; -import org.jruby.internal.runtime.methods.WrapperMethod; -import org.jruby.parser.StaticScope; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.CacheMap; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import static org.jruby.runtime.Visibility.*; -import static org.jruby.anno.FrameField.*; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.builtin.Variable; -import org.jruby.runtime.callback.Callback; -import org.jruby.runtime.component.VariableEntry; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.ClassProvider; -import org.jruby.util.IdUtil; -import org.jruby.exceptions.RaiseException; -import org.jruby.internal.runtime.methods.JavaMethod; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.MethodFactory; -import org.jruby.runtime.MethodIndex; - -/** - * - * @author jpetersen - */ -@JRubyClass(name="Module") -public class RubyModule extends RubyObject { - private static final boolean DEBUG = false; - - public static RubyClass createModuleClass(Ruby runtime, RubyClass moduleClass) { - moduleClass.index = ClassIndex.MODULE; - moduleClass.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyModule; - } - }; - - moduleClass.defineAnnotatedMethods(RubyModule.class); - moduleClass.defineAnnotatedMethods(ModuleKernelMethods.class); - - return moduleClass; - } - - public static class ModuleKernelMethods { - @JRubyMethod - public static IRubyObject autoload(IRubyObject recv, IRubyObject arg0, IRubyObject arg1) { - return RubyKernel.autoload(recv, arg0, arg1); - } - - @JRubyMethod(name = "autoload?") - public static IRubyObject autoload_p(ThreadContext context, IRubyObject recv, IRubyObject arg0) { - return RubyKernel.autoload_p(context, recv, arg0); - } - } - - static ObjectAllocator MODULE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyModule(runtime, klass); - } - }; - - @Override - public int getNativeTypeIndex() { - return ClassIndex.MODULE; - } - - @Override - public boolean isModule() { - return true; - } - - @Override - public boolean isClass() { - return false; - } - - public boolean isSingleton() { - return false; - } - - // superClass may be null. - protected RubyClass superClass; - - public int index; - - public static class KindOf { - public static final KindOf DEFAULT_KIND_OF = new KindOf(); - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj.getMetaClass().hasModuleInHierarchy(type); - } - } - - public boolean isInstance(IRubyObject object) { - return kindOf.isKindOf(object, this); - } - - public KindOf kindOf = KindOf.DEFAULT_KIND_OF; - - public final int id; - - // Containing class...The parent of Object is null. Object should always be last in chain. - public RubyModule parent; - - // ClassId is the name of the class/module sans where it is located. - // If it is null, then it an anonymous class. - protected String classId; - - - // CONSTANT TABLE - - // Lock used for variableTable/constantTable writes. The RubyObject variableTable - // write methods are overridden here to use this lock rather than Java - // synchronization for faster concurrent writes for modules/classes. - protected final ReentrantLock variableWriteLock = new ReentrantLock(); - - protected transient volatile ConstantTableEntry[] constantTable = - new ConstantTableEntry[CONSTANT_TABLE_DEFAULT_CAPACITY]; - - protected transient int constantTableSize; - - protected transient int constantTableThreshold = - (int)(CONSTANT_TABLE_DEFAULT_CAPACITY * CONSTANT_TABLE_LOAD_FACTOR); - - private final Map<String, DynamicMethod> methods = new ConcurrentHashMap<String, DynamicMethod>(12, 0.75f, 1); - - // ClassProviders return Java class/module (in #defineOrGetClassUnder and - // #defineOrGetModuleUnder) when class/module is opened using colon syntax. - private transient List<ClassProvider> classProviders; - - /** separate path for MetaClass construction - * - */ - protected RubyModule(Ruby runtime, RubyClass metaClass, boolean objectSpace) { - super(runtime, metaClass, objectSpace); - id = runtime.allocModuleId(); - // if (parent == null) parent = runtime.getObject(); - setFlag(USER7_F, !isClass()); - } - - /** used by MODULE_ALLOCATOR and RubyClass constructors - * - */ - protected RubyModule(Ruby runtime, RubyClass metaClass) { - this(runtime, metaClass, runtime.isObjectSpaceEnabled()); - } - - /** standard path for Module construction - * - */ - protected RubyModule(Ruby runtime) { - this(runtime, runtime.getModule()); - } - - public boolean needsImplementer() { - return getFlag(USER7_F); - } - - /** rb_module_new - * - */ - public static RubyModule newModule(Ruby runtime) { - return new RubyModule(runtime); - } - - /** rb_module_new/rb_define_module_id/rb_name_class/rb_set_class_path - * - */ - public static RubyModule newModule(Ruby runtime, String name, RubyModule parent, boolean setParent) { - RubyModule module = newModule(runtime); - module.setBaseName(name); - if (setParent) module.setParent(parent); - parent.setConstant(name, module); - return module; - } - - // synchronized method per JRUBY-1173 (unsafe Double-Checked Locking) - // FIXME: synchronization is still wrong in CP code - public synchronized void addClassProvider(ClassProvider provider) { - if (classProviders == null) { - List<ClassProvider> cp = Collections.synchronizedList(new ArrayList<ClassProvider>()); - cp.add(provider); - classProviders = cp; - } else { - synchronized(classProviders) { - if (!classProviders.contains(provider)) { - classProviders.add(provider); - } - } - } - } - - public void removeClassProvider(ClassProvider provider) { - if (classProviders != null) { - classProviders.remove(provider); - } - } - - private RubyClass searchProvidersForClass(String name, RubyClass superClazz) { - if (classProviders != null) { - synchronized(classProviders) { - RubyClass clazz; - for (ClassProvider classProvider: classProviders) { - if ((clazz = classProvider.defineClassUnder(this, name, superClazz)) != null) { - return clazz; - } - } - } - } - return null; - } - - private RubyModule searchProvidersForModule(String name) { - if (classProviders != null) { - synchronized(classProviders) { - RubyModule module; - for (ClassProvider classProvider: classProviders) { - if ((module = classProvider.defineModuleUnder(this, name)) != null) { - return module; - } - } - } - } - return null; - } - - /** Getter for property superClass. - * @return Value of property superClass. - */ - public RubyClass getSuperClass() { - return superClass; - } - - protected void setSuperClass(RubyClass superClass) { - this.superClass = superClass; - } - - public RubyModule getParent() { - return parent; - } - - public void setParent(RubyModule parent) { - this.parent = parent; - } - - public Map<String, DynamicMethod> getMethods() { - return methods; - } - - - // note that addMethod now does its own put, so any change made to - // functionality here should be made there as well - private void putMethod(String name, DynamicMethod method) { - getMethods().put(name, method); - } - - /** - * Is this module one that in an included one (e.g. an IncludedModuleWrapper). - */ - public boolean isIncluded() { - return false; - } - - public RubyModule getNonIncludedClass() { - return this; - } - - public String getBaseName() { - return classId; - } - - public void setBaseName(String name) { - classId = name; - } - - private volatile String bareName; - private volatile String fullName; - - /** - * Generate a fully-qualified class name or a #-style name for anonymous and singleton classes. - * - * Ruby C equivalent = "classname" - * - * @return The generated class name - */ - public String getName() { - if (fullName == null) { - fullName = calculateFullName(); - } - return fullName; - } - - private String calculateFullName() { - if (getBaseName() == null) { - if (bareName == null) { - if (isClass()) { - bareName = "#<" + "Class" + ":01x" + Integer.toHexString(System.identityHashCode(this)) + ">"; - } else { - bareName = "#<" + "Module" + ":01x" + Integer.toHexString(System.identityHashCode(this)) + ">"; - } - } - - return bareName; - } - - String result = getBaseName(); - RubyClass objectClass = getRuntime().getObject(); - - for (RubyModule p = this.getParent(); p != null && p != objectClass; p = p.getParent()) { - String pName = p.getBaseName(); - // This is needed when the enclosing class or module is a singleton. - // In that case, we generated a name such as null::Foo, which broke - // Marshalling, among others. The correct thing to do in this situation - // is to insert the generate the name of form #<Class:01xasdfasd> if - // it's a singleton module/class, which this code accomplishes. - if(pName == null) { - pName = p.getName(); - } - result = pName + "::" + result; - } - - return result; - } - - /** - * Create a wrapper to use for including the specified module into this one. - * - * Ruby C equivalent = "include_class_new" - * - * @return The module wrapper - */ - public IncludedModuleWrapper newIncludeClass(RubyClass superClazz) { - IncludedModuleWrapper includedModule = new IncludedModuleWrapper(getRuntime(), superClazz, this); - - // include its parent (and in turn that module's parents) - if (getSuperClass() != null) { - includedModule.includeModule(getSuperClass()); - } - - return includedModule; - } - /** - * Finds a class that is within the current module (or class). - * - * @param name to be found in this module (or class) - * @return the class or null if no such class - */ - public RubyClass getClass(String name) { - IRubyObject module; - if ((module = getConstantAt(name)) instanceof RubyClass) { - return (RubyClass)module; - } - return null; - } - - public RubyClass fastGetClass(String internedName) { - IRubyObject module; - if ((module = fastGetConstantAt(internedName)) instanceof RubyClass) { - return (RubyClass)module; - } - return null; - } - - /** - * Include a new module in this module or class. - * - * @param arg The module to include - */ - public synchronized void includeModule(IRubyObject arg) { - assert arg != null; - - testFrozen("module"); - if (!isTaint()) { - getRuntime().secure(4); - } - - if (!(arg instanceof RubyModule)) { - throw getRuntime().newTypeError("Wrong argument type " + arg.getMetaClass().getName() + - " (expected Module)."); - } - - RubyModule module = (RubyModule) arg; - - // Make sure the module we include does not already exist - if (isSame(module)) { - return; - } - - infectBy(module); - - doIncludeModule(module); - } - - public void defineMethod(String name, Callback method) { - Visibility visibility = name.equals("initialize") ? - PRIVATE : PUBLIC; - addMethod(name, new FullFunctionCallbackMethod(this, method, visibility)); - } - - public void defineAnnotatedMethod(Class clazz, String name) { - // FIXME: This is probably not very efficient, since it loads all methods for each call - boolean foundMethod = false; - for (Method method : clazz.getDeclaredMethods()) { - if (method.getName().equals(name) && defineAnnotatedMethod(method, MethodFactory.createFactory(getRuntime().getJRubyClassLoader()))) { - foundMethod = true; - } - } - - if (!foundMethod) { - throw new RuntimeException("No JRubyMethod present for method " + name + "on class " + clazz.getName()); - } - } - - public void defineAnnotatedConstants(Class clazz) { - Field[] declaredFields = clazz.getDeclaredFields(); - for (Field field : declaredFields) { - if(Modifier.isStatic(field.getModifiers())) { - defineAnnotatedConstant(field); - } - } - } - - public boolean defineAnnotatedConstant(Field field) { - JRubyConstant jrubyConstant = field.getAnnotation(JRubyConstant.class); - - if (jrubyConstant == null) return false; - - String[] names = jrubyConstant.value(); - if(names.length == 0) { - names = new String[]{field.getName()}; - } - - Class tp = field.getType(); - IRubyObject realVal; - - try { - if(tp == Integer.class || tp == Integer.TYPE || tp == Short.class || tp == Short.TYPE || tp == Byte.class || tp == Byte.TYPE) { - realVal = RubyNumeric.int2fix(getRuntime(), field.getInt(null)); - } else if(tp == Boolean.class || tp == Boolean.TYPE) { - realVal = field.getBoolean(null) ? getRuntime().getTrue() : getRuntime().getFalse(); - } else { - realVal = getRuntime().getNil(); - } - } catch(Exception e) { - realVal = getRuntime().getNil(); - } - - - for(String name : names) { - this.fastSetConstant(name, realVal); - } - - return true; - } - - public void defineAnnotatedMethods(Class clazz) { - defineAnnotatedMethodsIndividually(clazz); - } - - public static class MethodClumper { - Map<String, List<JavaMethodDescriptor>> annotatedMethods = new HashMap<String, List<JavaMethodDescriptor>>(); - Map<String, List<JavaMethodDescriptor>> staticAnnotatedMethods = new HashMap<String, List<JavaMethodDescriptor>>(); - Map<String, List<JavaMethodDescriptor>> annotatedMethods1_8 = new HashMap<String, List<JavaMethodDescriptor>>(); - Map<String, List<JavaMethodDescriptor>> staticAnnotatedMethods1_8 = new HashMap<String, List<JavaMethodDescriptor>>(); - Map<String, List<JavaMethodDescriptor>> annotatedMethods1_9 = new HashMap<String, List<JavaMethodDescriptor>>(); - Map<String, List<JavaMethodDescriptor>> staticAnnotatedMethods1_9 = new HashMap<String, List<JavaMethodDescriptor>>(); - - public void clump(Class cls) { - Method[] declaredMethods = cls.getDeclaredMethods(); - for (Method method: declaredMethods) { - JRubyMethod anno = method.getAnnotation(JRubyMethod.class); - if (anno == null) continue; - - JavaMethodDescriptor desc = new JavaMethodDescriptor(method); - - String name = anno.name().length == 0 ? method.getName() : anno.name()[0]; - - List<JavaMethodDescriptor> methodDescs; - Map<String, List<JavaMethodDescriptor>> methodsHash = null; - if (desc.isStatic) { - if (anno.compat() == CompatVersion.RUBY1_8) { - methodsHash = staticAnnotatedMethods1_8; - } else if (anno.compat() == CompatVersion.RUBY1_9) { - methodsHash = staticAnnotatedMethods1_9; - } else { - methodsHash = staticAnnotatedMethods; - } - } else { - if (anno.compat() == CompatVersion.RUBY1_8) { - methodsHash = annotatedMethods1_8; - } else if (anno.compat() == CompatVersion.RUBY1_9) { - methodsHash = annotatedMethods1_9; - } else { - methodsHash = annotatedMethods; - } - } - - methodDescs = methodsHash.get(name); - if (methodDescs == null) { - methodDescs = new ArrayList<JavaMethodDescriptor>(); - methodsHash.put(name, methodDescs); - } - - methodDescs.add(desc); - } - } - - public Map<String, List<JavaMethodDescriptor>> getAnnotatedMethods() { - return annotatedMethods; - } - - public Map<String, List<JavaMethodDescriptor>> getAnnotatedMethods1_8() { - return annotatedMethods1_8; - } - - public Map<String, List<JavaMethodDescriptor>> getAnnotatedMethods1_9() { - return annotatedMethods1_9; - } - - public Map<String, List<JavaMethodDescriptor>> getStaticAnnotatedMethods() { - return staticAnnotatedMethods; - } - - public Map<String, List<JavaMethodDescriptor>> getStaticAnnotatedMethods1_8() { - return staticAnnotatedMethods1_8; - } - - public Map<String, List<JavaMethodDescriptor>> getStaticAnnotatedMethods1_9() { - return staticAnnotatedMethods1_9; - } - } - - public void defineAnnotatedMethodsIndividually(Class clazz) { - String x = clazz.getSimpleName(); - TypePopulator populator = null; - - if (RubyInstanceConfig.FULL_TRACE_ENABLED) { - // we need full traces, use default (slow) populator - if (DEBUG) System.out.println("trace mode, using default populator"); - populator = TypePopulator.DEFAULT; - } else { - try { - String qualifiedName = "org.jruby.gen." + clazz.getCanonicalName().replace('.', '$'); - - if (DEBUG) System.out.println("looking for " + qualifiedName + "$Populator"); - - Class populatorClass = Class.forName(qualifiedName + "$Populator"); - populator = (TypePopulator)populatorClass.newInstance(); - } catch (Throwable t) { - if (DEBUG) System.out.println("Could not find it, using default populator"); - populator = TypePopulator.DEFAULT; - } - } - - populator.populate(this, clazz); - } - - @Deprecated - private void defineAnnotatedMethodsIndexed(Class clazz) { - MethodFactory methodFactory = MethodFactory.createFactory(getRuntime().getJRubyClassLoader()); - methodFactory.defineIndexedAnnotatedMethods(this, clazz, methodDefiningCallback); - } - - private static MethodFactory.MethodDefiningCallback methodDefiningCallback = new MethodFactory.MethodDefiningCallback() { - public void define(RubyModule module, JavaMethodDescriptor desc, DynamicMethod dynamicMethod) { - JRubyMethod jrubyMethod = desc.anno; - if (jrubyMethod.frame()) { - for (String name : jrubyMethod.name()) { - ASTInspector.FRAME_AWARE_METHODS.add(name); - } - } - if(jrubyMethod.compat() == CompatVersion.BOTH || - module.getRuntime().getInstanceConfig().getCompatVersion() == jrubyMethod.compat()) { - RubyModule singletonClass; - - if (jrubyMethod.meta()) { - singletonClass = module.getSingletonClass(); - dynamicMethod.setImplementationClass(singletonClass); - - String baseName; - if (jrubyMethod.name().length == 0) { - baseName = desc.name; - singletonClass.addMethod(baseName, dynamicMethod); - } else { - baseName = jrubyMethod.name()[0]; - for (String name : jrubyMethod.name()) { - singletonClass.addMethod(name, dynamicMethod); - } - } - - if (jrubyMethod.alias().length > 0) { - for (String alias : jrubyMethod.alias()) { - singletonClass.defineAlias(alias, baseName); - } - } - } else { - String baseName; - if (jrubyMethod.name().length == 0) { - baseName = desc.name; - module.addMethod(baseName, dynamicMethod); - } else { - baseName = jrubyMethod.name()[0]; - for (String name : jrubyMethod.name()) { - module.addMethod(name, dynamicMethod); - } - } - - if (jrubyMethod.alias().length > 0) { - for (String alias : jrubyMethod.alias()) { - module.defineAlias(alias, baseName); - } - } - - if (jrubyMethod.module()) { - singletonClass = module.getSingletonClass(); - // module/singleton methods are all defined public - DynamicMethod moduleMethod = dynamicMethod.dup(); - moduleMethod.setVisibility(PUBLIC); - - if (jrubyMethod.name().length == 0) { - baseName = desc.name; - singletonClass.addMethod(desc.name, moduleMethod); - } else { - baseName = jrubyMethod.name()[0]; - for (String name : jrubyMethod.name()) { - singletonClass.addMethod(name, moduleMethod); - } - } - - if (jrubyMethod.alias().length > 0) { - for (String alias : jrubyMethod.alias()) { - singletonClass.defineAlias(alias, baseName); - } - } - } - } - } - } - }; - - public boolean defineAnnotatedMethod(String name, List<JavaMethodDescriptor> methods, MethodFactory methodFactory) { - JavaMethodDescriptor desc = methods.get(0); - if (methods.size() == 1) { - return defineAnnotatedMethod(desc, methodFactory); - } else { - DynamicMethod dynamicMethod = methodFactory.getAnnotatedMethod(this, methods); - methodDefiningCallback.define(this, desc, dynamicMethod); - - return true; - } - } - - public boolean defineAnnotatedMethod(Method method, MethodFactory methodFactory) { - JRubyMethod jrubyMethod = method.getAnnotation(JRubyMethod.class); - - if (jrubyMethod == null) return false; - - if(jrubyMethod.compat() == CompatVersion.BOTH || - getRuntime().getInstanceConfig().getCompatVersion() == jrubyMethod.compat()) { - JavaMethodDescriptor desc = new JavaMethodDescriptor(method); - DynamicMethod dynamicMethod = methodFactory.getAnnotatedMethod(this, desc); - methodDefiningCallback.define(this, desc, dynamicMethod); - - return true; - } - return false; - } - - public boolean defineAnnotatedMethod(JavaMethodDescriptor desc, MethodFactory methodFactory) { - JRubyMethod jrubyMethod = desc.anno; - - if (jrubyMethod == null) return false; - - if(jrubyMethod.compat() == CompatVersion.BOTH || - getRuntime().getInstanceConfig().getCompatVersion() == jrubyMethod.compat()) { - DynamicMethod dynamicMethod = methodFactory.getAnnotatedMethod(this, desc); - methodDefiningCallback.define(this, desc, dynamicMethod); - - return true; - } - return false; - } - - public void defineFastMethod(String name, Callback method) { - Visibility visibility = name.equals("initialize") ? - PRIVATE : PUBLIC; - addMethod(name, new SimpleCallbackMethod(this, method, visibility)); - } - - public void defineFastMethod(String name, Callback method, Visibility visibility) { - addMethod(name, new SimpleCallbackMethod(this, method, visibility)); - } - - public void definePrivateMethod(String name, Callback method) { - addMethod(name, new FullFunctionCallbackMethod(this, method, PRIVATE)); - } - - public void defineFastPrivateMethod(String name, Callback method) { - addMethod(name, new SimpleCallbackMethod(this, method, PRIVATE)); - } - - public void defineFastProtectedMethod(String name, Callback method) { - addMethod(name, new SimpleCallbackMethod(this, method, PROTECTED)); - } - - public void undefineMethod(String name) { - addMethod(name, UndefinedMethod.getInstance()); - } - - /** rb_undef - * - */ - public void undef(ThreadContext context, String name) { - Ruby runtime = context.getRuntime(); - - if (this == runtime.getObject()) runtime.secure(4); - - if (runtime.getSafeLevel() >= 4 && !isTaint()) { - throw new SecurityException("Insecure: can't undef"); - } - testFrozen("module"); - if (name.equals("__id__") || name.equals("__send__")) { - runtime.getWarnings().warn(ID.UNDEFINING_BAD, "undefining `"+ name +"' may cause serious problem"); - } - DynamicMethod method = searchMethod(name); - if (method.isUndefined()) { - String s0 = " class"; - RubyModule c = this; - - if (c.isSingleton()) { - IRubyObject obj = ((MetaClass)c).getAttached(); - - if (obj != null && obj instanceof RubyModule) { - c = (RubyModule) obj; - s0 = ""; - } - } else if (c.isModule()) { - s0 = " module"; - } - - throw runtime.newNameError("Undefined method " + name + " for" + s0 + " '" + c.getName() + "'", name); - } - addMethod(name, UndefinedMethod.getInstance()); - - if (isSingleton()) { - IRubyObject singleton = ((MetaClass)this).getAttached(); - singleton.callMethod(context, "singleton_method_undefined", runtime.newSymbol(name)); - } else { - callMethod(context, "method_undefined", runtime.newSymbol(name)); - } - } - - @JRubyMethod(name = "include?", required = 1) - public IRubyObject include_p(ThreadContext context, IRubyObject arg) { - if (!arg.isModule()) { - throw context.getRuntime().newTypeError(arg, context.getRuntime().getModule()); - } - - for (RubyModule p = this; p != null; p = p.getSuperClass()) { - if ((p instanceof IncludedModuleWrapper) && ((IncludedModuleWrapper) p).getNonIncludedClass() == arg) { - return context.getRuntime().getTrue(); - } - } - - return context.getRuntime().getFalse(); - } - - // TODO: Consider a better way of synchronizing - public void addMethod(String name, DynamicMethod method) { - Ruby runtime = getRuntime(); - - if (this == runtime.getObject()) runtime.secure(4); - - if (runtime.getSafeLevel() >= 4 && !isTaint()) { - throw runtime.newSecurityError("Insecure: can't define method"); - } - testFrozen("class/module"); - - // We can safely reference methods here instead of doing getMethods() since if we - // are adding we are not using a IncludedModuleWrapper. - synchronized(getMethods()) { - // If we add a method which already is cached in this class, then we should update the - // cachemap so it stays up to date. - DynamicMethod existingMethod = getMethods().put(name, method); - if (existingMethod != null) { - runtime.getCacheMap().remove(existingMethod); - } - } - } - - public void removeMethod(ThreadContext context, String name) { - Ruby runtime = context.getRuntime(); - - if (this == runtime.getObject()) runtime.secure(4); - - if (runtime.getSafeLevel() >= 4 && !isTaint()) { - throw runtime.newSecurityError("Insecure: can't remove method"); - } - testFrozen("class/module"); - - // We can safely reference methods here instead of doing getMethods() since if we - // are adding we are not using a IncludedModuleWrapper. - synchronized(getMethods()) { - DynamicMethod method = (DynamicMethod) getMethods().remove(name); - if (method == null) { - throw runtime.newNameError("method '" + name + "' not defined in " + getName(), name); - } - - runtime.getCacheMap().remove(method); - } - - if (isSingleton()) { - IRubyObject singleton = ((MetaClass)this).getAttached(); - singleton.callMethod(context, "singleton_method_removed", runtime.newSymbol(name)); - } else { - callMethod(context, "method_removed", runtime.newSymbol(name)); - } - } - - /** - * Search through this module and supermodules for method definitions. Cache superclass definitions in this class. - * - * @param name The name of the method to search for - * @return The method, or UndefinedMethod if not found - */ - public DynamicMethod searchMethod(String name) { - DynamicMethod method = getMethods().get(name); - - if (method != null) return method; - - return superClass == null ? UndefinedMethod.getInstance() : superClass.searchMethod(name); - } - - /** - * Search through this module and supermodules for method definitions. Cache superclass definitions in this class. - * - * @param name The name of the method to search for - * @return The method, or UndefinedMethod if not found - */ - public DynamicMethod retrieveMethod(String name) { - return getMethods().get(name); - } - - /** - * Search through this module and supermodules for method definitions. Cache superclass definitions in this class. - * - * @param name The name of the method to search for - * @return The method, or UndefinedMethod if not found - */ - public RubyModule findImplementer(RubyModule clazz) { - for (RubyModule searchModule = this; searchModule != null; searchModule = searchModule.getSuperClass()) { - if (searchModule.isSame(clazz)) { - return searchModule; - } - } - - return null; - } - - public void addModuleFunction(String name, DynamicMethod method) { - addMethod(name, method); - getSingletonClass().addMethod(name, method); - } - - /** rb_define_module_function - * - */ - public void defineModuleFunction(String name, Callback method) { - definePrivateMethod(name, method); - getSingletonClass().defineMethod(name, method); - } - - /** rb_define_module_function - * - */ - public void definePublicModuleFunction(String name, Callback method) { - defineMethod(name, method); - getSingletonClass().defineMethod(name, method); - } - - /** rb_define_module_function - * - */ - public void defineFastModuleFunction(String name, Callback method) { - defineFastPrivateMethod(name, method); - getSingletonClass().defineFastMethod(name, method); - } - - /** rb_define_module_function - * - */ - public void defineFastPublicModuleFunction(String name, Callback method) { - defineFastMethod(name, method); - getSingletonClass().defineFastMethod(name, method); - } - - /** rb_alias - * - */ - public synchronized void defineAlias(String name, String oldName) { - testFrozen("module"); - if (oldName.equals(name)) { - return; - } - Ruby runtime = getRuntime(); - if (this == runtime.getObject()) { - runtime.secure(4); - } - DynamicMethod method = searchMethod(oldName); - DynamicMethod oldMethod = searchMethod(name); - if (method.isUndefined()) { - if (isModule()) { - method = runtime.getObject().searchMethod(oldName); - } - - if (method.isUndefined()) { - throw runtime.newNameError("undefined method `" + oldName + "' for " + - (isModule() ? "module" : "class") + " `" + getName() + "'", oldName); - } - } - CacheMap cacheMap = runtime.getCacheMap(); - cacheMap.remove(method); - cacheMap.remove(oldMethod); - if (oldMethod != oldMethod.getRealMethod()) { - cacheMap.remove(oldMethod.getRealMethod()); - } - putMethod(name, new AliasMethod(this, method, oldName)); - } - - public synchronized void defineAliases(List<String> aliases, String oldName) { - testFrozen("module"); - Ruby runtime = getRuntime(); - if (this == runtime.getObject()) { - runtime.secure(4); - } - DynamicMethod method = searchMethod(oldName); - if (method.isUndefined()) { - if (isModule()) { - method = runtime.getObject().searchMethod(oldName); - } - - if (method.isUndefined()) { - throw runtime.newNameError("undefined method `" + oldName + "' for " + - (isModule() ? "module" : "class") + " `" + getName() + "'", oldName); - } - } - CacheMap cacheMap = runtime.getCacheMap(); - cacheMap.remove(method); - for (String name: aliases) { - if (oldName.equals(name)) continue; - DynamicMethod oldMethod = searchMethod(name); - cacheMap.remove(oldMethod); - if (oldMethod != oldMethod.getRealMethod()) { - cacheMap.remove(oldMethod.getRealMethod()); - } - putMethod(name, new AliasMethod(this, method, oldName)); - } - } - - /** this method should be used only by interpreter or compiler - * - */ - public RubyClass defineOrGetClassUnder(String name, RubyClass superClazz) { - // This method is intended only for defining new classes in Ruby code, - // so it uses the allocator of the specified superclass or default to - // the Object allocator. It should NOT be used to define classes that require a native allocator. - - Ruby runtime = getRuntime(); - IRubyObject classObj = getConstantAt(name); - RubyClass clazz; - - if (classObj != null) { - if (!(classObj instanceof RubyClass)) throw runtime.newTypeError(name + " is not a class"); - clazz = (RubyClass)classObj; - - if (superClazz != null) { - RubyClass tmp = clazz.getSuperClass(); - while (tmp != null && tmp.isIncluded()) tmp = tmp.getSuperClass(); // need to skip IncludedModuleWrappers - if (tmp != null) tmp = tmp.getRealClass(); - if (tmp != superClazz) throw runtime.newTypeError("superclass mismatch for class " + name); - // superClazz = null; - } - - if (runtime.getSafeLevel() >= 4) throw runtime.newTypeError("extending class prohibited"); - } else if (classProviders != null && (clazz = searchProvidersForClass(name, superClazz)) != null) { - // reopen a java class - } else { - if (superClazz == null) superClazz = runtime.getObject(); - clazz = RubyClass.newClass(runtime, superClazz, name, superClazz.getAllocator(), this, true); - } - - return clazz; - } - - /** this method should be used only by interpreter or compiler - * - */ - public RubyModule defineOrGetModuleUnder(String name) { - // This method is intended only for defining new modules in Ruby code - Ruby runtime = getRuntime(); - IRubyObject moduleObj = getConstantAt(name); - RubyModule module; - if (moduleObj != null) { - if (!moduleObj.isModule()) throw runtime.newTypeError(name + " is not a module"); - if (runtime.getSafeLevel() >= 4) throw runtime.newSecurityError("extending module prohibited"); - module = (RubyModule)moduleObj; - } else if (classProviders != null && (module = searchProvidersForModule(name)) != null) { - // reopen a java module - } else { - module = RubyModule.newModule(runtime, name, this, true); - } - return module; - } - - /** rb_define_class_under - * this method should be used only as an API to define/open nested classes - */ - public RubyClass defineClassUnder(String name, RubyClass superClass, ObjectAllocator allocator) { - return getRuntime().defineClassUnder(name, superClass, allocator, this); - } - - /** rb_define_module_under - * this method should be used only as an API to define/open nested module - */ - public RubyModule defineModuleUnder(String name) { - return getRuntime().defineModuleUnder(name, this); - } - - // FIXME: create AttrReaderMethod, AttrWriterMethod, for faster attr access - private void addAccessor(ThreadContext context, String internedName, boolean readable, boolean writeable) { - assert internedName == internedName.intern() : internedName + " is not interned"; - - final Ruby runtime = context.getRuntime(); - - // Check the visibility of the previous frame, which will be the frame in which the class is being eval'ed - Visibility attributeScope = context.getCurrentVisibility(); - if (attributeScope == PRIVATE) { - //FIXME warning - } else if (attributeScope == MODULE_FUNCTION) { - attributeScope = PRIVATE; - // FIXME warning - } - final String variableName = ("@" + internedName).intern(); - if (readable) { - // FIXME: should visibility be set to current visibility? - addMethod(internedName, new JavaMethod(this, PUBLIC) { - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) { - if (args.length != 0) Arity.raiseArgumentError(runtime, args.length, 0, 0); - - IRubyObject variable = self.getInstanceVariables().fastGetInstanceVariable(variableName); - - return variable == null ? runtime.getNil() : variable; - } - - @Override - public Arity getArity() { - return Arity.noArguments(); - } - }); - callMethod(context, "method_added", runtime.fastNewSymbol(internedName)); - } - if (writeable) { - internedName = (internedName + "=").intern(); - // FIXME: should visibility be set to current visibility? - addMethod(internedName, new JavaMethod(this, PUBLIC) { - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) { - // ENEBO: Can anyone get args to be anything but length 1? - if (args.length != 1) Arity.raiseArgumentError(runtime, args.length, 1, 1); - - return self.getInstanceVariables().fastSetInstanceVariable(variableName, args[0]); - } - - @Override - public Arity getArity() { - return Arity.singleArgument(); - } - }); - callMethod(context, "method_added", runtime.fastNewSymbol(internedName)); - } - } - - /** set_method_visibility - * - */ - public void setMethodVisibility(IRubyObject[] methods, Visibility visibility) { - if (getRuntime().getSafeLevel() >= 4 && !isTaint()) { - throw getRuntime().newSecurityError("Insecure: can't change method visibility"); - } - - for (int i = 0; i < methods.length; i++) { - exportMethod(methods[i].asJavaString(), visibility); - } - } - - /** rb_export_method - * - */ - public void exportMethod(String name, Visibility visibility) { - if (this == getRuntime().getObject()) { - getRuntime().secure(4); - } - - DynamicMethod method = searchMethod(name); - - if (method.isUndefined()) { - throw getRuntime().newNameError("undefined method '" + name + "' for " + - (isModule() ? "module" : "class") + " '" + getName() + "'", name); - } - - if (method.getVisibility() != visibility) { - if (this == method.getImplementationClass()) { - method.setVisibility(visibility); - } else { - // FIXME: Why was this using a FullFunctionCallbackMethod before that did callSuper? - addMethod(name, new WrapperMethod(this, method, visibility)); - } - } - } - - /** - * MRI: rb_method_boundp - * - */ - public boolean isMethodBound(String name, boolean checkVisibility) { - DynamicMethod method = searchMethod(name); - if (!method.isUndefined()) { - return !(checkVisibility && method.getVisibility() == PRIVATE); - } - return false; - } - - public IRubyObject newMethod(IRubyObject receiver, String name, boolean bound) { - DynamicMethod method = searchMethod(name); - if (method.isUndefined()) { - throw getRuntime().newNameError("undefined method `" + name + - "' for class `" + this.getName() + "'", name); - } - - RubyModule implementationModule = method.getImplementationClass(); - RubyModule originModule = this; - while (originModule != implementationModule && originModule.isSingleton()) { - originModule = ((MetaClass)originModule).getRealClass(); - } - - RubyMethod newMethod = null; - if (bound) { - newMethod = RubyMethod.newMethod(implementationModule, name, originModule, name, method, receiver); - } else { - newMethod = RubyUnboundMethod.newUnboundMethod(implementationModule, name, originModule, name, method); - } - newMethod.infectBy(this); - - return newMethod; - } - - @JRubyMethod(name = "define_method", frame = true, visibility = PRIVATE, reads = VISIBILITY) - public IRubyObject define_method(ThreadContext context, IRubyObject arg0, Block block) { - Ruby runtime = context.getRuntime(); - String name = arg0.asJavaString().intern(); - DynamicMethod newMethod = null; - Visibility visibility = context.getCurrentVisibility(); - - if (visibility == MODULE_FUNCTION) visibility = PRIVATE; - RubyProc proc = runtime.newProc(Block.Type.LAMBDA, block); - - // a normal block passed to define_method changes to do arity checking; make it a lambda - proc.getBlock().type = Block.Type.LAMBDA; - - newMethod = createProcMethod(name, visibility, proc); - - RuntimeHelpers.addInstanceMethod(this, name, newMethod, context.getPreviousVisibility(), context, runtime); - - return proc; - } - - @JRubyMethod(name = "define_method", frame = true, visibility = PRIVATE, reads = VISIBILITY) - public IRubyObject define_method(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - Ruby runtime = context.getRuntime(); - IRubyObject body; - String name = arg0.asJavaString().intern(); - DynamicMethod newMethod = null; - Visibility visibility = context.getCurrentVisibility(); - - if (visibility == MODULE_FUNCTION) visibility = PRIVATE; - if (runtime.getProc().isInstance(arg1)) { - // double-testing args.length here, but it avoids duplicating the proc-setup code in two places - RubyProc proc = (RubyProc)arg1; - body = proc; - - newMethod = createProcMethod(name, visibility, proc); - } else if (runtime.getMethod().isInstance(arg1)) { - RubyMethod method = (RubyMethod)arg1; - body = method; - - newMethod = new MethodMethod(this, method.unbind(null), visibility); - } else { - throw runtime.newTypeError("wrong argument type " + arg1.getType().getName() + " (expected Proc/Method)"); - } - - RuntimeHelpers.addInstanceMethod(this, name, newMethod, context.getPreviousVisibility(), context, runtime); - - return body; - } - @Deprecated - public IRubyObject define_method(ThreadContext context, IRubyObject[] args, Block block) { - switch (args.length) { - case 1: - return define_method(context, args[0], block); - case 2: - return define_method(context, args[0], args[1], block); - default: - throw context.getRuntime().newArgumentError("wrong # of arguments(" + args.length + " for 2)"); - } - } - - private DynamicMethod createProcMethod(String name, Visibility visibility, RubyProc proc) { - Block block = proc.getBlock(); - block.getBinding().getFrame().setKlazz(this); - block.getBinding().getFrame().setName(name); - - StaticScope scope = block.getBody().getStaticScope(); - - // for zsupers in define_method (blech!) we tell the proc scope to act as the "argument" scope - scope.setArgumentScope(true); - - Arity arity = block.arity(); - // just using required is broken...but no more broken than before zsuper refactoring - scope.setRequiredArgs(arity.required()); - - if(!arity.isFixed()) { - scope.setRestArg(arity.required()); - } - - return new ProcMethod(this, proc, visibility); - } - - @Deprecated - public IRubyObject executeUnder(ThreadContext context, Callback method, IRubyObject[] args, Block block) { - context.preExecuteUnder(this, block); - try { - return method.execute(this, args, block); - } finally { - context.postExecuteUnder(); - } - } - - @JRubyMethod(name = "name") - public RubyString name() { - return getRuntime().newString(getBaseName() == null ? "" : getName()); - } - - protected IRubyObject cloneMethods(RubyModule clone) { - RubyModule realType = this.getNonIncludedClass(); - for (Map.Entry<String, DynamicMethod> entry : getMethods().entrySet()) { - DynamicMethod method = entry.getValue(); - // Do not clone cached methods - // FIXME: MRI copies all methods here - if (method.getImplementationClass() == realType || method instanceof UndefinedMethod) { - - // A cloned method now belongs to a new class. Set it. - // TODO: Make DynamicMethod immutable - DynamicMethod clonedMethod = method.dup(); - clonedMethod.setImplementationClass(clone); - clone.putMethod(entry.getKey(), clonedMethod); - } - } - - return clone; - } - - /** rb_mod_init_copy - * - */ - @JRubyMethod(name = "initialize_copy", required = 1) - @Override - public IRubyObject initialize_copy(IRubyObject original) { - super.initialize_copy(original); - - RubyModule originalModule = (RubyModule)original; - - if (!getMetaClass().isSingleton()) setMetaClass(originalModule.getSingletonClassClone()); - setSuperClass(originalModule.getSuperClass()); - - if (originalModule.hasVariables()){ - syncVariables(originalModule.getVariableList()); - } - - originalModule.cloneMethods(this); - - return this; - } - - /** rb_mod_included_modules - * - */ - @JRubyMethod(name = "included_modules") - public RubyArray included_modules(ThreadContext context) { - RubyArray ary = context.getRuntime().newArray(); - - for (RubyModule p = getSuperClass(); p != null; p = p.getSuperClass()) { - if (p.isIncluded()) { - ary.append(p.getNonIncludedClass()); - } - } - - return ary; - } - - /** rb_mod_ancestors - * - */ - @JRubyMethod(name = "ancestors") - public RubyArray ancestors(ThreadContext context) { - return context.getRuntime().newArray(getAncestorList()); - } - - @Deprecated - public RubyArray ancestors() { - return getRuntime().newArray(getAncestorList()); - } - - public List<IRubyObject> getAncestorList() { - ArrayList<IRubyObject> list = new ArrayList<IRubyObject>(); - - for (RubyModule p = this; p != null; p = p.getSuperClass()) { - if(!p.isSingleton()) { - list.add(p.getNonIncludedClass()); - } - } - - return list; - } - - public boolean hasModuleInHierarchy(RubyModule type) { - // XXX: This check previously used callMethod("==") to check for equality between classes - // when scanning the hierarchy. However the == check may be safe; we should only ever have - // one instance bound to a given type/constant. If it's found to be unsafe, examine ways - // to avoid the == call. - for (RubyModule p = this; p != null; p = p.getSuperClass()) { - if (p.getNonIncludedClass() == type) return true; - } - - return false; - } - - @Override - public int hashCode() { - return id; - } - - @JRubyMethod(name = "hash") - @Override - public RubyFixnum hash() { - return getRuntime().newFixnum(id); - } - - /** rb_mod_to_s - * - */ - @JRubyMethod(name = "to_s") - @Override - public IRubyObject to_s() { - if(isSingleton()){ - IRubyObject attached = ((MetaClass)this).getAttached(); - StringBuilder buffer = new StringBuilder("#<Class:"); - if (attached != null) { // FIXME: figure out why we get null sometimes - if(attached instanceof RubyClass || attached instanceof RubyModule){ - buffer.append(attached.inspect()); - }else{ - buffer.append(attached.anyToString()); - } - } - buffer.append(">"); - return getRuntime().newString(buffer.toString()); - } - return getRuntime().newString(getName()); - } - - /** rb_mod_eqq - * - */ - @JRubyMethod(name = "===", required = 1) - @Override - public RubyBoolean op_eqq(ThreadContext context, IRubyObject obj) { - return context.getRuntime().newBoolean(isInstance(obj)); - } - - @JRubyMethod(name = "==", required = 1) - @Override - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - return super.op_equal(context, other); - } - - /** rb_mod_freeze - * - */ - @JRubyMethod(name = "freeze") - @Override - public IRubyObject freeze(ThreadContext context) { - to_s(); - return super.freeze(context); - } - - /** rb_mod_le - * - */ - @JRubyMethod(name = "<=", required = 1) - public IRubyObject op_le(IRubyObject obj) { - if (!(obj instanceof RubyModule)) { - throw getRuntime().newTypeError("compared with non class/module"); - } - - if (isKindOfModule((RubyModule) obj)) { - return getRuntime().getTrue(); - } else if (((RubyModule) obj).isKindOfModule(this)) { - return getRuntime().getFalse(); - } - - return getRuntime().getNil(); - } - - /** rb_mod_lt - * - */ - @JRubyMethod(name = "<", required = 1) - public IRubyObject op_lt(IRubyObject obj) { - return obj == this ? getRuntime().getFalse() : op_le(obj); - } - - /** rb_mod_ge - * - */ - @JRubyMethod(name = ">=", required = 1) - public IRubyObject op_ge(IRubyObject obj) { - if (!(obj instanceof RubyModule)) { - throw getRuntime().newTypeError("compared with non class/module"); - } - - return ((RubyModule) obj).op_le(this); - } - - /** rb_mod_gt - * - */ - @JRubyMethod(name = ">", required = 1) - public IRubyObject op_gt(IRubyObject obj) { - return this == obj ? getRuntime().getFalse() : op_ge(obj); - } - - /** rb_mod_cmp - * - */ - @JRubyMethod(name = "<=>", required = 1) - public IRubyObject op_cmp(IRubyObject obj) { - if (this == obj) return getRuntime().newFixnum(0); - if (!(obj instanceof RubyModule)) return getRuntime().getNil(); - - RubyModule module = (RubyModule) obj; - - if (module.isKindOfModule(this)) { - return getRuntime().newFixnum(1); - } else if (this.isKindOfModule(module)) { - return getRuntime().newFixnum(-1); - } - - return getRuntime().getNil(); - } - - public boolean isKindOfModule(RubyModule type) { - for (RubyModule p = this; p != null; p = p.getSuperClass()) { - if (p.isSame(type)) { - return true; - } - } - - return false; - } - - protected boolean isSame(RubyModule module) { - return this == module; - } - - /** rb_mod_initialize - * - */ - @JRubyMethod(name = "initialize", frame = true, visibility = PRIVATE) - public IRubyObject initialize(Block block) { - if (block.isGiven()) { - // class and module bodies default to public, so make the block's visibility public. JRUBY-1185. - block.getBinding().setVisibility(PUBLIC); - block.yield(getRuntime().getCurrentContext(), this, this, this, false); - } - - return getRuntime().getNil(); - } - - public void addReadWriteAttribute(ThreadContext context, String name) { - addAccessor(context, name.intern(), true, true); - } - - public void addReadAttribute(ThreadContext context, String name) { - addAccessor(context, name.intern(), true, false); - } - - public void addWriteAttribute(ThreadContext context, String name) { - addAccessor(context, name.intern(), false, true); - } - - /** rb_mod_attr - * - */ - @JRubyMethod(name = "attr", required = 1, optional = 1, visibility = PRIVATE, reads = VISIBILITY) - public IRubyObject attr(ThreadContext context, IRubyObject[] args) { - boolean writeable = args.length > 1 ? args[1].isTrue() : false; - - addAccessor(context, args[0].asJavaString().intern(), true, writeable); - - return getRuntime().getNil(); - } - - /** - * @deprecated - */ - public IRubyObject attr_reader(IRubyObject[] args) { - return attr_reader(getRuntime().getCurrentContext(), args); - } - - /** rb_mod_attr_reader - * - */ - @JRubyMethod(name = "attr_reader", rest = true, visibility = PRIVATE, reads = VISIBILITY) - public IRubyObject attr_reader(ThreadContext context, IRubyObject[] args) { - for (int i = 0; i < args.length; i++) { - addAccessor(context, args[i].asJavaString().intern(), true, false); - } - - return context.getRuntime().getNil(); - } - - /** rb_mod_attr_writer - * - */ - @JRubyMethod(name = "attr_writer", rest = true, visibility = PRIVATE, reads = VISIBILITY) - public IRubyObject attr_writer(ThreadContext context, IRubyObject[] args) { - for (int i = 0; i < args.length; i++) { - addAccessor(context, args[i].asJavaString().intern(), false, true); - } - - return context.getRuntime().getNil(); - } - - /** - * @deprecated - */ - public IRubyObject attr_accessor(IRubyObject[] args) { - return attr_accessor(getRuntime().getCurrentContext(), args); - } - - /** rb_mod_attr_accessor - * - */ - @JRubyMethod(name = "attr_accessor", rest = true, visibility = PRIVATE, reads = VISIBILITY) - public IRubyObject attr_accessor(ThreadContext context, IRubyObject[] args) { - for (int i = 0; i < args.length; i++) { - // This is almost always already interned, since it will be called with a symbol in most cases - // but when created from Java code, we might get an argument that needs to be interned. - // addAccessor has as a precondition that the string MUST be interned - addAccessor(context, args[i].asJavaString().intern(), true, true); - } - - return context.getRuntime().getNil(); - } - - /** - * Get a list of all instance methods names of the provided visibility unless not is true, then - * get all methods which are not the provided - * - * @param args passed into one of the Ruby instance_method methods - * @param visibility to find matching instance methods against - * @param not if true only find methods not matching supplied visibility - * @return a RubyArray of instance method names - */ - private RubyArray instance_methods(IRubyObject[] args, final Visibility visibility, boolean not) { - boolean includeSuper = args.length > 0 ? args[0].isTrue() : true; - RubyArray ary = getRuntime().newArray(); - Set<String> seen = new HashSet<String>(); - - for (RubyModule type = this; type != null; type = type.getSuperClass()) { - RubyModule realType = type.getNonIncludedClass(); - for (Iterator iter = type.getMethods().entrySet().iterator(); iter.hasNext();) { - Map.Entry entry = (Map.Entry) iter.next(); - DynamicMethod method = (DynamicMethod) entry.getValue(); - String methodName = (String) entry.getKey(); - - if (! seen.contains(methodName)) { - seen.add(methodName); - - if (method.getImplementationClass() == realType && - (!not && method.getVisibility() == visibility || (not && method.getVisibility() != visibility)) && - ! method.isUndefined()) { - - ary.append(getRuntime().newString(methodName)); - } - } - } - - if (!includeSuper) { - break; - } - } - - return ary; - } - - @JRubyMethod(name = "instance_methods", optional = 1) - public RubyArray instance_methods(IRubyObject[] args) { - return instance_methods(args, PRIVATE, true); - } - - @JRubyMethod(name = "public_instance_methods", optional = 1) - public RubyArray public_instance_methods(IRubyObject[] args) { - return instance_methods(args, PUBLIC, false); - } - - @JRubyMethod(name = "instance_method", required = 1) - public IRubyObject instance_method(IRubyObject symbol) { - return newMethod(null, symbol.asJavaString(), false); - } - - /** rb_class_protected_instance_methods - * - */ - @JRubyMethod(name = "protected_instance_methods", optional = 1) - public RubyArray protected_instance_methods(IRubyObject[] args) { - return instance_methods(args, PROTECTED, false); - } - - /** rb_class_private_instance_methods - * - */ - @JRubyMethod(name = "private_instance_methods", optional = 1) - public RubyArray private_instance_methods(IRubyObject[] args) { - return instance_methods(args, PRIVATE, false); - } - - /** rb_mod_append_features - * - */ - @JRubyMethod(name = "append_features", required = 1, visibility = PRIVATE) - public RubyModule append_features(IRubyObject module) { - if (!(module instanceof RubyModule)) { - // MRI error message says Class, even though Module is ok - throw getRuntime().newTypeError(module,getRuntime().getClassClass()); - } - ((RubyModule) module).includeModule(this); - return this; - } - - /** rb_mod_extend_object - * - */ - @JRubyMethod(name = "extend_object", required = 1, visibility = PRIVATE) - public IRubyObject extend_object(IRubyObject obj) { - obj.getSingletonClass().includeModule(this); - return obj; - } - - /** rb_mod_include - * - */ - @JRubyMethod(name = "include", required = 1, rest = true, visibility = PRIVATE) - public RubyModule include(IRubyObject[] modules) { - ThreadContext context = getRuntime().getCurrentContext(); - // MRI checks all types first: - for (int i = modules.length; --i >= 0; ) { - IRubyObject obj = modules[i]; - if (!obj.isModule()) throw context.getRuntime().newTypeError(obj, context.getRuntime().getModule()); - } - for (int i = modules.length - 1; i >= 0; i--) { - modules[i].callMethod(context, "append_features", this); - modules[i].callMethod(context, "included", this); - } - - return this; - } - - @JRubyMethod(name = "included", required = 1) - public IRubyObject included(ThreadContext context, IRubyObject other) { - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "extended", required = 1, frame = true) - public IRubyObject extended(ThreadContext context, IRubyObject other, Block block) { - return context.getRuntime().getNil(); - } - - private void setVisibility(ThreadContext context, IRubyObject[] args, Visibility visibility) { - if (context.getRuntime().getSafeLevel() >= 4 && !isTaint()) { - throw context.getRuntime().newSecurityError("Insecure: can't change method visibility"); - } - - if (args.length == 0) { - // Note: we change current frames visibility here because the methods which call - // this method are all "fast" (e.g. they do not created their own frame). - context.setCurrentVisibility(visibility); - } else { - setMethodVisibility(args, visibility); - } - } - - /** rb_mod_public - * - */ - @JRubyMethod(name = "public", rest = true, visibility = PRIVATE, writes = VISIBILITY) - public RubyModule rbPublic(ThreadContext context, IRubyObject[] args) { - setVisibility(context, args, PUBLIC); - return this; - } - - /** rb_mod_protected - * - */ - @JRubyMethod(name = "protected", rest = true, visibility = PRIVATE, writes = VISIBILITY) - public RubyModule rbProtected(ThreadContext context, IRubyObject[] args) { - setVisibility(context, args, PROTECTED); - return this; - } - - /** rb_mod_private - * - */ - @JRubyMethod(name = "private", rest = true, visibility = PRIVATE, writes = VISIBILITY) - public RubyModule rbPrivate(ThreadContext context, IRubyObject[] args) { - setVisibility(context, args, PRIVATE); - return this; - } - - /** rb_mod_modfunc - * - */ - @JRubyMethod(name = "module_function", rest = true, visibility = PRIVATE, writes = VISIBILITY) - public RubyModule module_function(ThreadContext context, IRubyObject[] args) { - if (context.getRuntime().getSafeLevel() >= 4 && !isTaint()) { - throw context.getRuntime().newSecurityError("Insecure: can't change method visibility"); - } - - if (args.length == 0) { - context.setCurrentVisibility(MODULE_FUNCTION); - } else { - setMethodVisibility(args, PRIVATE); - - for (int i = 0; i < args.length; i++) { - String name = args[i].asJavaString().intern(); - DynamicMethod method = searchMethod(name); - assert !method.isUndefined() : "undefined method '" + name + "'"; - getSingletonClass().addMethod(name, new WrapperMethod(getSingletonClass(), method, PUBLIC)); - callMethod(context, "singleton_method_added", context.getRuntime().fastNewSymbol(name)); - } - } - return this; - } - - @JRubyMethod(name = "method_added", required = 1, visibility = PRIVATE) - public IRubyObject method_added(ThreadContext context, IRubyObject nothing) { - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "method_removed", required = 1, visibility = PRIVATE) - public IRubyObject method_removed(ThreadContext context, IRubyObject nothing) { - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "method_undefined", required = 1, visibility = PRIVATE) - public IRubyObject method_undefined(ThreadContext context, IRubyObject nothing) { - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "method_defined?", required = 1) - public RubyBoolean method_defined_p(ThreadContext context, IRubyObject symbol) { - return isMethodBound(symbol.asJavaString(), true) ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - @JRubyMethod(name = "public_method_defined?", required = 1) - public IRubyObject public_method_defined(ThreadContext context, IRubyObject symbol) { - DynamicMethod method = searchMethod(symbol.asJavaString()); - - return context.getRuntime().newBoolean(!method.isUndefined() && method.getVisibility() == PUBLIC); - } - - @JRubyMethod(name = "protected_method_defined?", required = 1) - public IRubyObject protected_method_defined(ThreadContext context, IRubyObject symbol) { - DynamicMethod method = searchMethod(symbol.asJavaString()); - - return context.getRuntime().newBoolean(!method.isUndefined() && method.getVisibility() == PROTECTED); - } - - @JRubyMethod(name = "private_method_defined?", required = 1) - public IRubyObject private_method_defined(ThreadContext context, IRubyObject symbol) { - DynamicMethod method = searchMethod(symbol.asJavaString()); - - return context.getRuntime().newBoolean(!method.isUndefined() && method.getVisibility() == PRIVATE); - } - - @JRubyMethod(name = "public_class_method", rest = true) - public RubyModule public_class_method(IRubyObject[] args) { - getMetaClass().setMethodVisibility(args, PUBLIC); - return this; - } - - @JRubyMethod(name = "private_class_method", rest = true) - public RubyModule private_class_method(IRubyObject[] args) { - getMetaClass().setMethodVisibility(args, PRIVATE); - return this; - } - - @JRubyMethod(name = "alias_method", required = 2, visibility = PRIVATE) - public RubyModule alias_method(ThreadContext context, IRubyObject newId, IRubyObject oldId) { - String newName = newId.asJavaString(); - defineAlias(newName, oldId.asJavaString()); - RubySymbol newSym = newId instanceof RubySymbol ? (RubySymbol)newId : - context.getRuntime().newSymbol(newName); - if (isSingleton()) { - ((MetaClass)this).getAttached().callMethod(context, "singleton_method_added", newSym); - } else { - callMethod(context, "method_added", newSym); - } - return this; - } - - @JRubyMethod(name = "undef_method", required = 1, rest = true, visibility = PRIVATE) - public RubyModule undef_method(ThreadContext context, IRubyObject[] args) { - for (int i=0; i<args.length; i++) { - undef(context, args[i].asJavaString()); - } - return this; - } - - @JRubyMethod(name = {"module_eval", "class_eval"}, frame = true) - public IRubyObject module_eval(ThreadContext context, Block block) { - return specificEval(context, this, block); - } - @JRubyMethod(name = {"module_eval", "class_eval"}, frame = true) - public IRubyObject module_eval(ThreadContext context, IRubyObject arg0, Block block) { - return specificEval(context, this, arg0, block); - } - @JRubyMethod(name = {"module_eval", "class_eval"}, frame = true) - public IRubyObject module_eval(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - return specificEval(context, this, arg0, arg1, block); - } - @JRubyMethod(name = {"module_eval", "class_eval"}, frame = true) - public IRubyObject module_eval(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) { - return specificEval(context, this, arg0, arg1, arg2, block); - } - @Deprecated - public IRubyObject module_eval(ThreadContext context, IRubyObject[] args, Block block) { - return specificEval(context, this, args, block); - } - - @JRubyMethod(name = "remove_method", required = 1, rest = true, visibility = PRIVATE) - public RubyModule remove_method(ThreadContext context, IRubyObject[] args) { - for(int i=0;i<args.length;i++) { - removeMethod(context, args[i].asJavaString()); - } - return this; - } - - public static void marshalTo(RubyModule module, MarshalStream output) throws java.io.IOException { - output.registerLinkTarget(module); - output.writeString(MarshalStream.getPathFromClass(module)); - } - - public static RubyModule unmarshalFrom(UnmarshalStream input) throws java.io.IOException { - String name = RubyString.byteListToString(input.unmarshalString()); - RubyModule result = UnmarshalStream.getModuleFromPath(input.getRuntime(), name); - input.registerLinkTarget(result); - return result; - } - - /* Module class methods */ - - /** - * Return an array of nested modules or classes. - */ - @JRubyMethod(name = "nesting", frame = true, meta = true) - public static RubyArray nesting(ThreadContext context, IRubyObject recv, Block block) { - Ruby runtime = context.getRuntime(); - RubyModule object = runtime.getObject(); - StaticScope scope = context.getCurrentScope().getStaticScope(); - RubyArray result = runtime.newArray(); - - for (StaticScope current = scope; current.getModule() != object; current = current.getPreviousCRefScope()) { - result.append(current.getModule()); - } - - return result; - } - - private void doIncludeModule(RubyModule includedModule) { - boolean skip = false; - - RubyModule currentModule = this; - while (includedModule != null) { - - if (getNonIncludedClass() == includedModule.getNonIncludedClass()) { - throw getRuntime().newArgumentError("cyclic include detected"); - } - - boolean superclassSeen = false; - - // scan class hierarchy for module - for (RubyModule superClass = this.getSuperClass(); superClass != null; superClass = superClass.getSuperClass()) { - if (superClass instanceof IncludedModuleWrapper) { - if (superClass.getNonIncludedClass() == includedModule.getNonIncludedClass()) { - if (!superclassSeen) { - currentModule = superClass; - } - skip = true; - break; - } - } else { - superclassSeen = true; - } - } - - if (!skip) { - - // blow away caches for any methods that are redefined by module - getRuntime().getCacheMap().moduleIncluded(currentModule, includedModule); - - // In the current logic, if we get here we know that module is not an - // IncludedModuleWrapper, so there's no need to fish out the delegate. But just - // in case the logic should change later, let's do it anyway: - currentModule.setSuperClass(new IncludedModuleWrapper(getRuntime(), currentModule.getSuperClass(), - includedModule.getNonIncludedClass())); - currentModule = currentModule.getSuperClass(); - } - - includedModule = includedModule.getSuperClass(); - skip = false; - } - } - - - // - ////////////////// CLASS VARIABLE RUBY METHODS //////////////// - // - - @JRubyMethod(name = "class_variable_defined?", required = 1) - public IRubyObject class_variable_defined_p(ThreadContext context, IRubyObject var) { - String internedName = validateClassVariable(var.asJavaString().intern()); - RubyModule module = this; - do { - if (module.fastHasClassVariable(internedName)) { - return context.getRuntime().getTrue(); - } - } while ((module = module.getSuperClass()) != null); - - return context.getRuntime().getFalse(); - } - - /** rb_mod_cvar_get - * - */ - @JRubyMethod(name = "class_variable_get", required = 1, visibility = PRIVATE) - public IRubyObject class_variable_get(IRubyObject var) { - return fastGetClassVar(validateClassVariable(var.asJavaString()).intern()); - } - - /** rb_mod_cvar_set - * - */ - @JRubyMethod(name = "class_variable_set", required = 2, visibility = PRIVATE) - public IRubyObject class_variable_set(IRubyObject var, IRubyObject value) { - return fastSetClassVar(validateClassVariable(var.asJavaString()).intern(), value); - } - - /** rb_mod_remove_cvar - * - */ - @JRubyMethod(name = "remove_class_variable", required = 1, visibility = PRIVATE) - public IRubyObject remove_class_variable(ThreadContext context, IRubyObject name) { - String javaName = validateClassVariable(name.asJavaString()); - IRubyObject value; - - if ((value = deleteClassVariable(javaName)) != null) { - return value; - } - - if (fastIsClassVarDefined(javaName)) { - throw cannotRemoveError(javaName); - } - - throw context.getRuntime().newNameError("class variable " + javaName + " not defined for " + getName(), javaName); - } - - /** rb_mod_class_variables - * - */ - @JRubyMethod(name = "class_variables") - public RubyArray class_variables(ThreadContext context) { - Set<String> names = new HashSet<String>(); - - for (RubyModule p = this; p != null; p = p.getSuperClass()) { - for (String name : p.getClassVariableNameList()) { - names.add(name); - } - } - - Ruby runtime = context.getRuntime(); - RubyArray ary = runtime.newArray(); - - for (String name : names) { - ary.append(runtime.newString(name)); - } - - return ary; - } - - - // - ////////////////// CONSTANT RUBY METHODS //////////////// - // - - /** rb_mod_const_defined - * - */ - @JRubyMethod(name = "const_defined?", required = 1) - public RubyBoolean const_defined_p(ThreadContext context, IRubyObject symbol) { - // Note: includes part of fix for JRUBY-1339 - return context.getRuntime().newBoolean(fastIsConstantDefined(validateConstant(symbol.asJavaString()).intern())); - } - - /** rb_mod_const_get - * - */ - @JRubyMethod(name = "const_get", required = 1) - public IRubyObject const_get(IRubyObject symbol) { - return fastGetConstant(validateConstant(symbol.asJavaString()).intern()); - } - - /** rb_mod_const_set - * - */ - @JRubyMethod(name = "const_set", required = 2) - public IRubyObject const_set(IRubyObject symbol, IRubyObject value) { - return fastSetConstant(validateConstant(symbol.asJavaString()).intern(), value); - } - - @JRubyMethod(name = "remove_const", required = 1, visibility = PRIVATE) - public IRubyObject remove_const(ThreadContext context, IRubyObject name) { - String id = validateConstant(name.asJavaString()); - IRubyObject value; - if ((value = deleteConstant(id)) != null) { - if (value != UNDEF) { - return value; - } - context.getRuntime().getLoadService().removeAutoLoadFor(getName() + "::" + id); - // FIXME: I'm not sure this is right, but the old code returned - // the undef, which definitely isn't right... - return context.getRuntime().getNil(); - } - - if (hasConstantInHierarchy(id)) { - throw cannotRemoveError(id); - } - - throw context.getRuntime().newNameError("constant " + id + " not defined for " + getName(), id); - } - - private boolean hasConstantInHierarchy(final String name) { - for (RubyModule p = this; p != null; p = p.getSuperClass()) { - if (p.hasConstant(name)) { - return true; - } - } - return false; - } - - /** - * Base implementation of Module#const_missing, throws NameError for specific missing constant. - * - * @param name The constant name which was found to be missing - * @return Nothing! Absolutely nothing! (though subclasses might choose to return something) - */ - @JRubyMethod(name = "const_missing", required = 1, frame = true) - public IRubyObject const_missing(ThreadContext context, IRubyObject name, Block block) { - /* Uninitialized constant */ - if (this != context.getRuntime().getObject()) { - throw context.getRuntime().newNameError("uninitialized constant " + getName() + "::" + name.asJavaString(), "" + getName() + "::" + name.asJavaString()); - } - - throw context.getRuntime().newNameError("uninitialized constant " + name.asJavaString(), name.asJavaString()); - } - - /** rb_mod_constants - * - */ - @JRubyMethod(name = "constants") - public RubyArray constants(ThreadContext context) { - Ruby runtime = context.getRuntime(); - RubyArray array = runtime.newArray(); - RubyModule objectClass = runtime.getObject(); - - if (getRuntime().getModule() == this) { - - for (String name : objectClass.getStoredConstantNameList()) { - array.append(runtime.newString(name)); - } - - } else if (objectClass == this) { - - for (String name : getStoredConstantNameList()) { - array.append(runtime.newString(name)); - } - - } else { - Set<String> names = new HashSet<String>(); - for (RubyModule p = this; p != null; p = p.getSuperClass()) { - if (objectClass != p) { - for (String name : p.getStoredConstantNameList()) { - names.add(name); - } - } - } - for (String name : names) { - array.append(runtime.newString(name)); - } - } - - return array; - } - - - // - ////////////////// CLASS VARIABLE API METHODS //////////////// - // - - /** - * Set the named class variable to the given value, provided taint and freeze allow setting it. - * - * Ruby C equivalent = "rb_cvar_set" - * - * @param name The variable name to set - * @param value The value to set it to - */ - public IRubyObject setClassVar(String name, IRubyObject value) { - RubyModule module = this; - do { - if (module.hasClassVariable(name)) { - return module.storeClassVariable(name, value); - } - } while ((module = module.getSuperClass()) != null); - - return storeClassVariable(name, value); - } - - public IRubyObject fastSetClassVar(final String internedName, final IRubyObject value) { - assert internedName == internedName.intern() : internedName + " is not interned"; - RubyModule module = this; - do { - if (module.fastHasClassVariable(internedName)) { - return module.fastStoreClassVariable(internedName, value); - } - } while ((module = module.getSuperClass()) != null); - - return fastStoreClassVariable(internedName, value); - } - - /** - * Retrieve the specified class variable, searching through this module, included modules, and supermodules. - * - * Ruby C equivalent = "rb_cvar_get" - * - * @param name The name of the variable to retrieve - * @return The variable's value, or throws NameError if not found - */ - public IRubyObject getClassVar(String name) { - assert IdUtil.isClassVariable(name); - IRubyObject value; - RubyModule module = this; - - do { - if ((value = module.variableTableFetch(name)) != null) return value; - } while ((module = module.getSuperClass()) != null); - - throw getRuntime().newNameError("uninitialized class variable " + name + " in " + getName(), name); - } - - public IRubyObject fastGetClassVar(String internedName) { - assert internedName == internedName.intern() : internedName + " is not interned"; - assert IdUtil.isClassVariable(internedName); - IRubyObject value; - RubyModule module = this; - - do { - if ((value = module.variableTableFastFetch(internedName)) != null) return value; - } while ((module = module.getSuperClass()) != null); - - throw getRuntime().newNameError("uninitialized class variable " + internedName + " in " + getName(), internedName); - } - - /** - * Is class var defined? - * - * Ruby C equivalent = "rb_cvar_defined" - * - * @param name The class var to determine "is defined?" - * @return true if true, false if false - */ - public boolean isClassVarDefined(String name) { - RubyModule module = this; - do { - if (module.hasClassVariable(name)) return true; - } while ((module = module.getSuperClass()) != null); - - return false; - } - - public boolean fastIsClassVarDefined(String internedName) { - assert internedName == internedName.intern() : internedName + " is not interned"; - RubyModule module = this; - do { - if (module.fastHasClassVariable(internedName)) return true; - } while ((module = module.getSuperClass()) != null); - - return false; - } - - - /** rb_mod_remove_cvar - * - * FIXME: any good reason to have two identical methods? (same as remove_class_variable) - */ - public IRubyObject removeCvar(IRubyObject name) { // Wrong Parameter ? - String internedName = validateClassVariable(name.asJavaString()); - IRubyObject value; - - if ((value = deleteClassVariable(internedName)) != null) { - return value; - } - - if (fastIsClassVarDefined(internedName)) { - throw cannotRemoveError(internedName); - } - - throw getRuntime().newNameError("class variable " + internedName + " not defined for " + getName(), internedName); - } - - - // - ////////////////// CONSTANT API METHODS //////////////// - // - - public IRubyObject getConstantAt(String name) { - IRubyObject value; - if ((value = fetchConstant(name)) != UNDEF) { - return value; - } - deleteConstant(name); - return getRuntime().getLoadService().autoload(getName() + "::" + name); - } - - public IRubyObject fastGetConstantAt(String internedName) { - assert internedName == internedName.intern() : internedName + " is not interned"; - IRubyObject value; - if ((value = fastFetchConstant(internedName)) != UNDEF) { - return value; - } - deleteConstant(internedName); - return getRuntime().getLoadService().autoload(getName() + "::" + internedName); - } - - /** - * Retrieve the named constant, invoking 'const_missing' should that be appropriate. - * - * @param name The constant to retrieve - * @return The value for the constant, or null if not found - */ - public IRubyObject getConstant(String name) { - assert IdUtil.isConstant(name); - boolean retryForModule = false; - IRubyObject value; - RubyModule p = this; - - retry: while (true) { - while (p != null) { - if ((value = p.constantTableFetch(name)) != null) { - if (value != UNDEF) { - return value; - } - p.deleteConstant(name); - if (getRuntime().getLoadService().autoload( - p.getName() + "::" + name) == null) { - break; - } - continue; - } - p = p.getSuperClass(); - } - - if (!retryForModule && !isClass()) { - retryForModule = true; - p = getRuntime().getObject(); - continue retry; - } - - break; - } - - return callMethod(getRuntime().getCurrentContext(), - "const_missing", getRuntime().newSymbol(name)); - } - - public IRubyObject fastGetConstant(String internedName) { - assert internedName == internedName.intern() : internedName + " is not interned"; - assert IdUtil.isConstant(internedName); - boolean retryForModule = false; - IRubyObject value; - RubyModule p = this; - - retry: while (true) { - while (p != null) { - if ((value = p.constantTableFastFetch(internedName)) != null) { - if (value != UNDEF) { - return value; - } - p.deleteConstant(internedName); - if (getRuntime().getLoadService().autoload( - p.getName() + "::" + internedName) == null) { - break; - } - continue; - } - p = p.getSuperClass(); - } - - if (!retryForModule && !isClass()) { - retryForModule = true; - p = getRuntime().getObject(); - continue retry; - } - - break; - } - - return callMethod(getRuntime().getCurrentContext(), - "const_missing", getRuntime().fastNewSymbol(internedName)); - } - - // not actually called anywhere (all known uses call the fast version) - public IRubyObject getConstantFrom(String name) { - return fastGetConstantFrom(name.intern()); - } - - public IRubyObject fastGetConstantFrom(String internedName) { - assert internedName == internedName.intern() : internedName + " is not interned"; - assert IdUtil.isConstant(internedName); - RubyClass objectClass = getRuntime().getObject(); - IRubyObject value; - - RubyModule p = this; - - while (p != null) { - if ((value = p.constantTableFastFetch(internedName)) != null) { - if (value != UNDEF) { - if (p == objectClass && this != objectClass) { - String badCName = getName() + "::" + internedName; - getRuntime().getWarnings().warn(ID.CONSTANT_BAD_REFERENCE, "toplevel constant " + - internedName + " referenced by " + badCName, badCName); - } - return value; - } - p.deleteConstant(internedName); - if (getRuntime().getLoadService().autoload( - p.getName() + "::" + internedName) == null) { - break; - } - continue; - } - p = p.getSuperClass(); - } - - return callMethod(getRuntime().getCurrentContext(), - "const_missing", getRuntime().fastNewSymbol(internedName)); - } - /** - * Set the named constant on this module. Also, if the value provided is another Module and - * that module has not yet been named, assign it the specified name. - * - * @param name The name to assign - * @param value The value to assign to it; if an unnamed Module, also set its basename to name - * @return The result of setting the variable. - */ - public IRubyObject setConstant(String name, IRubyObject value) { - IRubyObject oldValue; - if ((oldValue = fetchConstant(name)) != null) { - if (oldValue == UNDEF) { - getRuntime().getLoadService().removeAutoLoadFor(getName() + "::" + name); - } else { - getRuntime().getWarnings().warn(ID.CONSTANT_ALREADY_INITIALIZED, "already initialized constant " + name, name); - } - } - - storeConstant(name, value); - - // if adding a module under a constant name, set that module's basename to the constant name - if (value instanceof RubyModule) { - RubyModule module = (RubyModule)value; - if (module.getBaseName() == null) { - module.setBaseName(name); - module.setParent(this); - } - /* - module.setParent(this); - */ - } - return value; - } - - public IRubyObject fastSetConstant(String internedName, IRubyObject value) { - assert internedName == internedName.intern() : internedName + " is not interned"; - IRubyObject oldValue; - if ((oldValue = fastFetchConstant(internedName)) != null) { - if (oldValue == UNDEF) { - getRuntime().getLoadService().removeAutoLoadFor(getName() + "::" + internedName); - } else { - getRuntime().getWarnings().warn(ID.CONSTANT_ALREADY_INITIALIZED, "already initialized constant " + internedName, internedName); - } - } - - fastStoreConstant(internedName, value); - - // if adding a module under a constant name, set that module's basename to the constant name - if (value instanceof RubyModule) { - RubyModule module = (RubyModule)value; - if (module.getBaseName() == null) { - module.setBaseName(internedName); - module.setParent(this); - } - /* - module.setParent(this); - */ - } - return value; - } - - /** rb_define_const - * - */ - public void defineConstant(String name, IRubyObject value) { - assert value != null; - - if (this == getRuntime().getClassClass()) { - getRuntime().secure(4); - } - - if (!IdUtil.isValidConstantName(name)) { - throw getRuntime().newNameError("bad constant name " + name, name); - } - - setConstant(name, value); - } - - // Fix for JRUBY-1339 - search hierarchy for constant - /** rb_const_defined_at - * - */ - public boolean isConstantDefined(String name) { - assert IdUtil.isConstant(name); - boolean isObject = this == getRuntime().getObject(); - - RubyModule module = this; - - do { - Object value; - if ((value = module.constantTableFetch(name)) != null) { - if (value != UNDEF) return true; - return getRuntime().getLoadService().autoloadFor( - module.getName() + "::" + name) != null; - } - - } while (isObject && (module = module.getSuperClass()) != null ); - - return false; - } - - public boolean fastIsConstantDefined(String internedName) { - assert internedName == internedName.intern() : internedName + " is not interned"; - assert IdUtil.isConstant(internedName); - boolean isObject = this == getRuntime().getObject(); - - RubyModule module = this; - - do { - Object value; - if ((value = module.constantTableFastFetch(internedName)) != null) { - if (value != UNDEF) return true; - return getRuntime().getLoadService().autoloadFor( - module.getName() + "::" + internedName) != null; - } - - } while (isObject && (module = module.getSuperClass()) != null ); - - return false; - } - - // - ////////////////// COMMON CONSTANT / CVAR METHODS //////////////// - // - - private RaiseException cannotRemoveError(String id) { - return getRuntime().newNameError("cannot remove " + id + " for " + getName(), id); - } - - - // - ////////////////// INTERNAL MODULE VARIABLE API METHODS //////////////// - // - - /** - * Behaves similarly to {@link #getClassVar(String)}. Searches this - * class/module <em>and its ancestors</em> for the specified internal - * variable. - * - * @param name the internal variable name - * @return the value of the specified internal variable if found, else null - * @see #setInternalModuleVariable(String, IRubyObject) - */ - public boolean hasInternalModuleVariable(final String name) { - RubyModule module = this; - do { - if (module.hasInternalVariable(name)) { - return true; - } - } while ((module = module.getSuperClass()) != null); - - return false; - } - /** - * Behaves similarly to {@link #getClassVar(String)}. Searches this - * class/module <em>and its ancestors</em> for the specified internal - * variable. - * - * @param name the internal variable name - * @return the value of the specified internal variable if found, else null - * @see #setInternalModuleVariable(String, IRubyObject) - */ - public IRubyObject searchInternalModuleVariable(final String name) { - RubyModule module = this; - IRubyObject value; - do { - if ((value = module.getInternalVariable(name)) != null) { - return value; - } - } while ((module = module.getSuperClass()) != null); - - return null; - } - - /** - * Behaves similarly to {@link #setClassVar(String, IRubyObject)}. If the - * specified internal variable is found in this class/module <em>or an ancestor</em>, - * it is set where found. Otherwise it is set in this module. - * - * @param name the internal variable name - * @param value the internal variable value - * @see #searchInternalModuleVariable(String) - */ - public void setInternalModuleVariable(final String name, final IRubyObject value) { - RubyModule module = this; - do { - if (module.hasInternalVariable(name)) { - module.setInternalVariable(name, value); - return; - } - } while ((module = module.getSuperClass()) != null); - - setInternalVariable(name, value); - } - - // - ////////////////// LOW-LEVEL CLASS VARIABLE INTERFACE //////////////// - // - // fetch/store/list class variables for this module - // - - public boolean hasClassVariable(String name) { - assert IdUtil.isClassVariable(name); - return variableTableContains(name); - } - - public boolean fastHasClassVariable(String internedName) { - assert IdUtil.isClassVariable(internedName); - return variableTableFastContains(internedName); - } - - public IRubyObject fetchClassVariable(String name) { - assert IdUtil.isClassVariable(name); - return variableTableFetch(name); - } - - public IRubyObject fastFetchClassVariable(String internedName) { - assert IdUtil.isClassVariable(internedName); - return variableTableFastFetch(internedName); - } - - public IRubyObject storeClassVariable(String name, IRubyObject value) { - assert IdUtil.isClassVariable(name) && value != null; - ensureClassVariablesSettable(); - return variableTableStore(name, value); - } - - public IRubyObject fastStoreClassVariable(String internedName, IRubyObject value) { - assert IdUtil.isClassVariable(internedName) && value != null; - ensureClassVariablesSettable(); - return variableTableFastStore(internedName, value); - } - - public IRubyObject deleteClassVariable(String name) { - assert IdUtil.isClassVariable(name); - ensureClassVariablesSettable(); - return variableTableRemove(name); - } - - public List<Variable<IRubyObject>> getClassVariableList() { - ArrayList<Variable<IRubyObject>> list = new ArrayList<Variable<IRubyObject>>(); - VariableTableEntry[] table = variableTableGetTable(); - IRubyObject readValue; - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - if (IdUtil.isClassVariable(e.name)) { - if ((readValue = e.value) == null) readValue = variableTableReadLocked(e); - list.add(new VariableEntry<IRubyObject>(e.name, readValue)); - } - } - } - return list; - } - - public List<String> getClassVariableNameList() { - ArrayList<String> list = new ArrayList<String>(); - VariableTableEntry[] table = variableTableGetTable(); - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - if (IdUtil.isClassVariable(e.name)) { - list.add(e.name); - } - } - } - return list; - } - - protected static final String ERR_INSECURE_SET_CLASS_VAR = "Insecure: can't modify class variable"; - protected static final String ERR_FROZEN_CVAR_TYPE = "class/module "; - - protected final String validateClassVariable(String name) { - if (IdUtil.isValidClassVariableName(name)) { - return name; - } - throw getRuntime().newNameError("`" + name + "' is not allowed as a class variable name", name); - } - - protected final void ensureClassVariablesSettable() { - Ruby runtime = getRuntime(); - - if (!isFrozen() && (runtime.getSafeLevel() < 4 || isTaint())) { - return; - } - - if (runtime.getSafeLevel() >= 4 && !isTaint()) { - throw runtime.newSecurityError(ERR_INSECURE_SET_CONSTANT); - } - if (isFrozen()) { - if (this instanceof RubyModule) { - throw runtime.newFrozenError(ERR_FROZEN_CONST_TYPE); - } else { - throw runtime.newFrozenError(""); - } - } - } - - // - ////////////////// LOW-LEVEL CONSTANT INTERFACE //////////////// - // - // fetch/store/list constants for this module - // - - public boolean hasConstant(String name) { - assert IdUtil.isConstant(name); - return constantTableContains(name); - } - - public boolean fastHasConstant(String internedName) { - assert IdUtil.isConstant(internedName); - return constantTableFastContains(internedName); - } - - // returns the stored value without processing undefs (autoloads) - public IRubyObject fetchConstant(String name) { - assert IdUtil.isConstant(name); - return constantTableFetch(name); - } - - // returns the stored value without processing undefs (autoloads) - public IRubyObject fastFetchConstant(String internedName) { - assert IdUtil.isConstant(internedName); - return constantTableFastFetch(internedName); - } - - public IRubyObject storeConstant(String name, IRubyObject value) { - assert IdUtil.isConstant(name) && value != null; - ensureConstantsSettable(); - return constantTableStore(name, value); - } - - public IRubyObject fastStoreConstant(String internedName, IRubyObject value) { - assert IdUtil.isConstant(internedName) && value != null; - ensureConstantsSettable(); - return constantTableFastStore(internedName, value); - } - - // removes and returns the stored value without processing undefs (autoloads) - public IRubyObject deleteConstant(String name) { - assert IdUtil.isConstant(name); - ensureConstantsSettable(); - return constantTableRemove(name); - } - - public List<Variable<IRubyObject>> getStoredConstantList() { - ArrayList<Variable<IRubyObject>> list = new ArrayList<Variable<IRubyObject>>(); - ConstantTableEntry[] table = constantTableGetTable(); - for (int i = table.length; --i >= 0; ) { - for (ConstantTableEntry e = table[i]; e != null; e = e.next) { - list.add(e); - } - } - return list; - } - - public List<String> getStoredConstantNameList() { - ArrayList<String> list = new ArrayList<String>(); - ConstantTableEntry[] table = constantTableGetTable(); - for (int i = table.length; --i >= 0; ) { - for (ConstantTableEntry e = table[i]; e != null; e = e.next) { - list.add(e.name); - } - } - return list; - } - - protected static final String ERR_INSECURE_SET_CONSTANT = "Insecure: can't modify constant"; - protected static final String ERR_FROZEN_CONST_TYPE = "class/module "; - - protected final String validateConstant(String name) { - if (IdUtil.isValidConstantName(name)) { - return name; - } - throw getRuntime().newNameError("wrong constant name " + name, name); - } - - protected final void ensureConstantsSettable() { - Ruby runtime = getRuntime(); - - if (!isFrozen() && (runtime.getSafeLevel() < 4 || isTaint())) { - return; - } - - if (runtime.getSafeLevel() >= 4 && !isTaint()) { - throw runtime.newSecurityError(ERR_INSECURE_SET_CONSTANT); - } - if (isFrozen()) { - if (this instanceof RubyModule) { - throw runtime.newFrozenError(ERR_FROZEN_CONST_TYPE); - } else { - throw runtime.newFrozenError(""); - } - } - } - - - // - ////////////////// VARIABLE TABLE METHODS //////////////// - // - // Overridden to use variableWriteLock in place of synchronization - // - - @Override - protected IRubyObject variableTableStore(String name, IRubyObject value) { - int hash = name.hashCode(); - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - VariableTableEntry[] table; - VariableTableEntry e; - if ((table = variableTable) == null) { - table = new VariableTableEntry[VARIABLE_TABLE_DEFAULT_CAPACITY]; - e = new VariableTableEntry(hash, name.intern(), value, null); - table[hash & (VARIABLE_TABLE_DEFAULT_CAPACITY - 1)] = e; - variableTableThreshold = (int)(VARIABLE_TABLE_DEFAULT_CAPACITY * VARIABLE_TABLE_LOAD_FACTOR); - variableTableSize = 1; - variableTable = table; - return value; - } - int potentialNewSize; - if ((potentialNewSize = variableTableSize + 1) > variableTableThreshold) { - table = variableTableRehash(); - } - int index; - for (e = table[index = hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - e.value = value; - return value; - } - } - // external volatile value initialization intended to obviate the need for - // readValueUnderLock technique used in ConcurrentHashMap. may be a little - // slower, but better to pay a price on first write rather than all reads. - e = new VariableTableEntry(hash, name.intern(), value, table[index]); - table[index] = e; - variableTableSize = potentialNewSize; - variableTable = table; // write-volatile - } finally { - lock.unlock(); - } - return value; - } - - @Override - protected IRubyObject variableTableFastStore(String internedName, IRubyObject value) { - assert internedName == internedName.intern() : internedName + " not interned"; - int hash = internedName.hashCode(); - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - VariableTableEntry[] table; - VariableTableEntry e; - if ((table = variableTable) == null) { - table = new VariableTableEntry[VARIABLE_TABLE_DEFAULT_CAPACITY]; - e = new VariableTableEntry(hash, internedName, value, null); - table[hash & (VARIABLE_TABLE_DEFAULT_CAPACITY - 1)] = e; - variableTableThreshold = (int)(VARIABLE_TABLE_DEFAULT_CAPACITY * VARIABLE_TABLE_LOAD_FACTOR); - variableTableSize = 1; - variableTable = table; - return value; - } - int potentialNewSize; - if ((potentialNewSize = variableTableSize + 1) > variableTableThreshold) { - table = variableTableRehash(); - } - int index; - for (e = table[index = hash & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - e.value = value; - return value; - } - } - // external volatile value initialization intended to obviate the need for - // readValueUnderLock technique used in ConcurrentHashMap. may be a little - // slower, but better to pay a price on first write rather than all reads. - e = new VariableTableEntry(hash, internedName, value, table[index]); - table[index] = e; - variableTableSize = potentialNewSize; - variableTable = table; // write-volatile - } finally { - lock.unlock(); - } - return value; - } - - @Override - protected IRubyObject variableTableRemove(String name) { - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - VariableTableEntry[] table; - if ((table = variableTable) != null) { - int hash = name.hashCode(); - int index = hash & (table.length - 1); - VariableTableEntry first = table[index]; - VariableTableEntry e; - for (e = first; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - IRubyObject oldValue = e.value; - // All entries following removed node can stay - // in list, but all preceding ones need to be - // cloned. - VariableTableEntry newFirst = e.next; - for (VariableTableEntry p = first; p != e; p = p.next) { - newFirst = new VariableTableEntry(p.hash, p.name, p.value, newFirst); - } - table[index] = newFirst; - variableTableSize--; - variableTable = table; // write-volatile - return oldValue; - } - } - } - } finally { - lock.unlock(); - } - return null; - } - - @Override - protected IRubyObject variableTableReadLocked(VariableTableEntry entry) { - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - return entry.value; - } finally { - lock.unlock(); - } - } - - @Override - protected void variableTableSync(List<Variable<IRubyObject>> vars) { - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - variableTableSize = 0; - variableTableThreshold = (int)(VARIABLE_TABLE_DEFAULT_CAPACITY * VARIABLE_TABLE_LOAD_FACTOR); - variableTable = new VariableTableEntry[VARIABLE_TABLE_DEFAULT_CAPACITY]; - for (Variable<IRubyObject> var : vars) { - assert !var.isConstant() && var.getValue() != null; - variableTableStore(var.getName(), var.getValue()); - } - } finally { - lock.unlock(); - } - } - - @Override - public void syncVariables(List<Variable<IRubyObject>> variables) { - ArrayList<Variable<IRubyObject>> constants = new ArrayList<Variable<IRubyObject>>(variables.size()); - Variable<IRubyObject> var; - for (Iterator<Variable<IRubyObject>> iter = variables.iterator(); iter.hasNext(); ) { - if ((var = iter.next()).isConstant()) { - constants.add(var); - iter.remove(); - } - } - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - variableTableSync(variables); - constantTableSync(constants); - } finally { - lock.unlock(); - } - } - - @Override - @SuppressWarnings("unchecked") - @Deprecated // born deprecated - public Map getVariableMap() { - Map map = variableTableGetMap(); - constantTableGetMap(map); - return map; - } - - @Override - public boolean hasVariables() { - return variableTableGetSize() > 0 || constantTableGetSize() > 0; - } - - @Override - public int getVariableCount() { - return variableTableGetSize() + constantTableGetSize(); - } - - @Override - public List<Variable<IRubyObject>> getVariableList() { - VariableTableEntry[] vtable = variableTableGetTable(); - ConstantTableEntry[] ctable = constantTableGetTable(); - ArrayList<Variable<IRubyObject>> list = new ArrayList<Variable<IRubyObject>>(); - IRubyObject readValue; - for (int i = vtable.length; --i >= 0; ) { - for (VariableTableEntry e = vtable[i]; e != null; e = e.next) { - if ((readValue = e.value) == null) readValue = variableTableReadLocked(e); - list.add(new VariableEntry<IRubyObject>(e.name, readValue)); - } - } - for (int i = ctable.length; --i >= 0; ) { - for (ConstantTableEntry e = ctable[i]; e != null; e = e.next) { - list.add(e); - } - } - return list; - } - - @Override - public List<String> getVariableNameList() { - VariableTableEntry[] vtable = variableTableGetTable(); - ConstantTableEntry[] ctable = constantTableGetTable(); - ArrayList<String> list = new ArrayList<String>(); - for (int i = vtable.length; --i >= 0; ) { - for (VariableTableEntry e = vtable[i]; e != null; e = e.next) { - list.add(e.name); - } - } - for (int i = ctable.length; --i >= 0; ) { - for (ConstantTableEntry e = ctable[i]; e != null; e = e.next) { - list.add(e.name); - } - } - return list; - } - - - // - ////////////////// CONSTANT TABLE METHODS, ETC. //////////////// - // - - protected static final int CONSTANT_TABLE_DEFAULT_CAPACITY = 8; // MUST be power of 2! - protected static final int CONSTANT_TABLE_MAXIMUM_CAPACITY = 1 << 30; - protected static final float CONSTANT_TABLE_LOAD_FACTOR = 0.75f; - - protected static final class ConstantTableEntry implements Variable<IRubyObject> { - final int hash; - final String name; - final IRubyObject value; - final ConstantTableEntry next; - - // constant table entry values are final; if a constant is redefined, the - // entry will be removed and replaced with a new entry. - ConstantTableEntry( - int hash, - String name, - IRubyObject value, - ConstantTableEntry next) { - this.hash = hash; - this.name = name; - this.value = value; - this.next = next; - } - - public String getName() { - return name; - } - - public IRubyObject getValue() { - return value; - } - public final boolean isClassVariable() { - return false; - } - - public final boolean isConstant() { - return true; - } - - public final boolean isInstanceVariable() { - return false; - } - - public final boolean isRubyVariable() { - return true; - } - } - - protected boolean constantTableContains(String name) { - int hash = name.hashCode(); - ConstantTableEntry[] table; - for (ConstantTableEntry e = (table = constantTable)[hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - return true; - } - } - return false; - } - - protected boolean constantTableFastContains(String internedName) { - ConstantTableEntry[] table; - for (ConstantTableEntry e = (table = constantTable)[internedName.hashCode() & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - return true; - } - } - return false; - } - - protected IRubyObject constantTableFetch(String name) { - int hash = name.hashCode(); - ConstantTableEntry[] table; - for (ConstantTableEntry e = (table = constantTable)[hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - return e.value; - } - } - return null; - } - - protected IRubyObject constantTableFastFetch(String internedName) { - ConstantTableEntry[] table; - for (ConstantTableEntry e = (table = constantTable)[internedName.hashCode() & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - return e.value; - } - } - return null; - } - - protected IRubyObject constantTableStore(String name, IRubyObject value) { - int hash = name.hashCode(); - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - ConstantTableEntry[] table; - ConstantTableEntry e; - ConstantTableEntry first; - int potentialNewSize; - if ((potentialNewSize = constantTableSize + 1) > constantTableThreshold) { - table = constantTableRehash(); - } else { - table = constantTable; - } - int index; - for (e = first = table[index = hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - // if value is unchanged, do nothing - if (value == e.value) { - return value; - } - // create new entry, prepend to any trailing entries - ConstantTableEntry newFirst = new ConstantTableEntry(e.hash, e.name, value, e.next); - // all entries before this one must be cloned - for (ConstantTableEntry n = first; n != e; n = n.next) { - newFirst = new ConstantTableEntry(n.hash, n.name, n.value, newFirst); - } - table[index] = newFirst; - constantTable = table; // write-volatile - return value; - } - } - table[index] = new ConstantTableEntry(hash, name.intern(), value, table[index]); - constantTableSize = potentialNewSize; - constantTable = table; // write-volatile - } finally { - lock.unlock(); - } - return value; - } - - protected IRubyObject constantTableFastStore(String internedName, IRubyObject value) { - assert internedName == internedName.intern() : internedName + " not interned"; - int hash = internedName.hashCode(); - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - ConstantTableEntry[] table; - ConstantTableEntry e; - ConstantTableEntry first; - int potentialNewSize; - if ((potentialNewSize = constantTableSize + 1) > constantTableThreshold) { - table = constantTableRehash(); - } else { - table = constantTable; - } - int index; - for (e = first = table[index = hash & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - // if value is unchanged, do nothing - if (value == e.value) { - return value; - } - // create new entry, prepend to any trailing entries - ConstantTableEntry newFirst = new ConstantTableEntry(e.hash, e.name, value, e.next); - // all entries before this one must be cloned - for (ConstantTableEntry n = first; n != e; n = n.next) { - newFirst = new ConstantTableEntry(n.hash, n.name, n.value, newFirst); - } - table[index] = newFirst; - constantTable = table; // write-volatile - return value; - } - } - table[index] = new ConstantTableEntry(hash, internedName, value, table[index]); - constantTableSize = potentialNewSize; - constantTable = table; // write-volatile - } finally { - lock.unlock(); - } - return value; - } - - protected IRubyObject constantTableRemove(String name) { - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - ConstantTableEntry[] table; - if ((table = constantTable) != null) { - int hash = name.hashCode(); - int index = hash & (table.length - 1); - ConstantTableEntry first = table[index]; - ConstantTableEntry e; - for (e = first; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - IRubyObject oldValue = e.value; - // All entries following removed node can stay - // in list, but all preceding ones need to be - // cloned. - ConstantTableEntry newFirst = e.next; - for (ConstantTableEntry p = first; p != e; p = p.next) { - newFirst = new ConstantTableEntry(p.hash, p.name, p.value, newFirst); - } - table[index] = newFirst; - constantTableSize--; - constantTable = table; // write-volatile - return oldValue; - } - } - } - } finally { - lock.unlock(); - } - return null; - } - - - protected ConstantTableEntry[] constantTableGetTable() { - return constantTable; - } - - protected int constantTableGetSize() { - if (constantTable != null) { - return constantTableSize; - } - return 0; - } - - protected void constantTableSync(List<Variable<IRubyObject>> vars) { - ReentrantLock lock; - (lock = variableWriteLock).lock(); - try { - constantTableSize = 0; - constantTableThreshold = (int)(CONSTANT_TABLE_DEFAULT_CAPACITY * CONSTANT_TABLE_LOAD_FACTOR); - constantTable = new ConstantTableEntry[CONSTANT_TABLE_DEFAULT_CAPACITY]; - for (Variable<IRubyObject> var : vars) { - assert var.isConstant() && var.getValue() != null; - constantTableStore(var.getName(), var.getValue()); - } - } finally { - lock.unlock(); - } - } - - // MUST be called from synchronized/locked block! - // should only be called by constantTableStore/constantTableFastStore - private final ConstantTableEntry[] constantTableRehash() { - ConstantTableEntry[] oldTable = constantTable; - int oldCapacity; - if ((oldCapacity = oldTable.length) >= CONSTANT_TABLE_MAXIMUM_CAPACITY) { - return oldTable; - } - - int newCapacity = oldCapacity << 1; - ConstantTableEntry[] newTable = new ConstantTableEntry[newCapacity]; - constantTableThreshold = (int)(newCapacity * CONSTANT_TABLE_LOAD_FACTOR); - int sizeMask = newCapacity - 1; - ConstantTableEntry e; - for (int i = oldCapacity; --i >= 0; ) { - // We need to guarantee that any existing reads of old Map can - // proceed. So we cannot yet null out each bin. - e = oldTable[i]; - - if (e != null) { - ConstantTableEntry next = e.next; - int idx = e.hash & sizeMask; - - // Single node on list - if (next == null) - newTable[idx] = e; - - else { - // Reuse trailing consecutive sequence at same slot - ConstantTableEntry lastRun = e; - int lastIdx = idx; - for (ConstantTableEntry last = next; - last != null; - last = last.next) { - int k = last.hash & sizeMask; - if (k != lastIdx) { - lastIdx = k; - lastRun = last; - } - } - newTable[lastIdx] = lastRun; - - // Clone all remaining nodes - for (ConstantTableEntry p = e; p != lastRun; p = p.next) { - int k = p.hash & sizeMask; - ConstantTableEntry m = new ConstantTableEntry(p.hash, p.name, p.value, newTable[k]); - newTable[k] = m; - } - } - } - } - constantTable = newTable; - return newTable; - } - - - /** - * Method to help ease transition to new variables implementation. - * Will likely be deprecated in the near future. - */ - @SuppressWarnings("unchecked") - protected Map constantTableGetMap() { - HashMap map = new HashMap(); - ConstantTableEntry[] table; - if ((table = constantTable) != null) { - for (int i = table.length; --i >= 0; ) { - for (ConstantTableEntry e = table[i]; e != null; e = e.next) { - map.put(e.name, e.value); - } - } - } - return map; - } - - /** - * Method to help ease transition to new variables implementation. - * Will likely be deprecated in the near future. - */ - @SuppressWarnings("unchecked") - protected Map constantTableGetMap(Map map) { - ConstantTableEntry[] table; - if ((table = constantTable) != null) { - for (int i = table.length; --i >= 0; ) { - for (ConstantTableEntry e = table[i]; e != null; e = e.next) { - map.put(e.name, e.value); - } - } - } - return map; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ - -package org.jruby; - -import static org.jruby.runtime.Visibility.PRIVATE; -import static org.jruby.runtime.Visibility.PROTECTED; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.exceptions.JumpException; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallType; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.Sprintf; - -/** - * @author Anders Bengtsson - */ -@JRubyClass(name="NameError", parent="StandardError") -public class RubyNameError extends RubyException { - private IRubyObject name; - - /** - * Nested class whose instances act as thunks reacting to to_str method - * called from (Exception#to_str, Exception#message) - * MRI equivalent: rb_cNameErrorMesg, class name: "message", construction method: "!", - * to_str implementation: "name_err_mesg_to_str" - * - * TODO: this class should not be lookupable - */ - @JRubyClass(name = "NameError::Message", parent = "Object") - public static final class RubyNameErrorMessage extends RubyObject { - - static ObjectAllocator NAMEERRORMESSAGE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - IRubyObject dummy = new RubyObject(runtime, runtime.getObject()); - return new RubyNameErrorMessage(runtime, dummy, dummy, Visibility.PRIVATE, CallType.VARIABLE); - } - }; - - private final IRubyObject object; - private final IRubyObject method; - private final Visibility visibility; - private final CallType callType; - - RubyNameErrorMessage(Ruby runtime, IRubyObject object, IRubyObject method, Visibility visibility, CallType callType) { - super(runtime, runtime.getNameErrorMessage(), false); - this.object = object; - this.method = method; - this.visibility = visibility; - this.callType = callType; - } - - @JRubyMethod(name = "_load", meta = true) - public static IRubyObject load(IRubyObject recv, IRubyObject arg) { - return arg; - } - - @JRubyMethod(name = "_dump") - public IRubyObject dump(ThreadContext context, IRubyObject arg) { - return to_str(context); - } - - @JRubyMethod(name = "to_str") - public IRubyObject to_str(ThreadContext context) { - String format = null; - - if (visibility == PRIVATE) { - format = "private method `%s' called for %s"; - } else if (visibility == PROTECTED) { - format = "protected method `%s' called for %s"; - } else if (callType == CallType.VARIABLE) { - format = "undefined local variable or method `%s' for %s"; - } else if (callType == CallType.SUPER) { - format = "super: no superclass method `%s'"; - } - - if (format == null) format = "undefined method `%s' for %s"; - - String description = null; - - if (object.isNil()) { - description = "nil"; - } else if (object instanceof RubyBoolean && object.isTrue()) { - description = "true"; - } else if (object instanceof RubyBoolean && !object.isTrue()) { - description = "false"; - } else { - try { - description = RubyObject.inspect(context, object).toString(); - } catch(JumpException e) {} - - if (description == null || description.length() > 65) description = object.anyToString().toString(); - } - - if (description.length() == 0 || (description.length() > 0 && description.charAt(0) != '#')) { - description = description + ":" + object.getMetaClass().getRealClass().getName(); - } - - Ruby runtime = getRuntime(); - RubyArray arr = runtime.newArray(method, runtime.newString(description)); - RubyString msg = runtime.newString(Sprintf.sprintf(runtime.newString(format), arr).toString()); - if (object.isTaint()) msg.setTaint(true); - return msg; - } - } - - private static ObjectAllocator NAMEERROR_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyNameError(runtime, klass); - } - }; - - public static RubyClass createNameErrorClass(Ruby runtime, RubyClass standardErrorClass) { - RubyClass nameErrorClass = runtime.defineClass("NameError", standardErrorClass, NAMEERROR_ALLOCATOR); - nameErrorClass.defineAnnotatedMethods(RubyNameError.class); - return nameErrorClass; - } - - public static RubyClass createNameErrorMessageClass(Ruby runtime, RubyClass nameErrorClass) { - RubyClass messageClass = nameErrorClass.defineClassUnder("Message", runtime.getObject(), RubyNameErrorMessage.NAMEERRORMESSAGE_ALLOCATOR); - messageClass.defineAnnotatedMethods(RubyNameErrorMessage.class); - return messageClass; - } - - protected RubyNameError(Ruby runtime, RubyClass exceptionClass) { - this(runtime, exceptionClass, exceptionClass.getName()); - } - - public RubyNameError(Ruby runtime, RubyClass exceptionClass, String message) { - this(runtime, exceptionClass, message, null); - } - - public RubyNameError(Ruby runtime, RubyClass exceptionClass, String message, String name) { - super(runtime, exceptionClass, message); - this.name = name == null ? runtime.getNil() : runtime.newString(name); - } - - @JRubyMethod(name = "exception", rest = true, meta = true) - public static RubyException newRubyNameError(IRubyObject recv, IRubyObject[] args) { - RubyClass klass = (RubyClass)recv; - - RubyException newError = (RubyException) klass.allocate(); - - newError.callInit(args, Block.NULL_BLOCK); - - return newError; - } - - @JRubyMethod(name = "initialize", optional = 2, frame = true) - @Override - public IRubyObject initialize(IRubyObject[] args, Block block) { - if (args.length > 1) { - name = args[args.length - 1]; - int newLength = args.length > 2 ? args.length - 2 : args.length - 1; - - IRubyObject []tmpArgs = new IRubyObject[newLength]; - System.arraycopy(args, 0, tmpArgs, 0, newLength); - args = tmpArgs; - } else { - name = getRuntime().getNil(); - } - - super.initialize(args, block); - return this; - } - - @JRubyMethod(name = "to_s") - @Override - public IRubyObject to_s() { - if (message.isNil()) return getRuntime().newString(message.getMetaClass().getName()); - RubyString str = message.convertToString(); - if (str != message) message = str; - if (isTaint()) message.setTaint(true); - return message; - } - - @JRubyMethod(name = "name") - public IRubyObject name() { - return name; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * - * @author jpetersen - */ -@JRubyClass(name="NilClass") -public class RubyNil extends RubyObject { - public RubyNil(Ruby runtime) { - super(runtime, runtime.getNilClass(), false); - flags |= NIL_F | FALSE_F; - } - - public static final ObjectAllocator NIL_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return runtime.getNil(); - } - }; - - public static RubyClass createNilClass(Ruby runtime) { - RubyClass nilClass = runtime.defineClass("NilClass", runtime.getObject(), NIL_ALLOCATOR); - runtime.setNilClass(nilClass); - nilClass.index = ClassIndex.NIL; - - nilClass.defineAnnotatedMethods(RubyNil.class); - - nilClass.getMetaClass().undefineMethod("new"); - - // FIXME: This is causing a verification error for some reason - //nilClass.dispatcher = callbackFactory.createDispatcher(nilClass); - - return nilClass; - } - - @Override - public int getNativeTypeIndex() { - return ClassIndex.NIL; - } - - @Override - public boolean isImmediate() { - return true; - } - - @Override - public RubyClass getSingletonClass() { - return metaClass; - } - - @Override - public Class<?> getJavaClass() { - return void.class; - } - - // Methods of the Nil Class (nil_*): - - /** nil_to_i - * - */ - @JRubyMethod(name = "to_i") - public static RubyFixnum to_i(IRubyObject recv) { - return RubyFixnum.zero(recv.getRuntime()); - } - - /** - * nil_to_f - * - */ - @JRubyMethod(name = "to_f") - public static RubyFloat to_f(IRubyObject recv) { - return RubyFloat.newFloat(recv.getRuntime(), 0.0D); - } - - /** nil_to_s - * - */ - @JRubyMethod(name = "to_s") - public static RubyString to_s(IRubyObject recv) { - return RubyString.newEmptyString(recv.getRuntime()); - } - - /** nil_to_a - * - */ - @JRubyMethod(name = "to_a") - public static RubyArray to_a(IRubyObject recv) { - return recv.getRuntime().newEmptyArray(); - } - - /** nil_inspect - * - */ - @JRubyMethod(name = "inspect") - public static RubyString inspect(IRubyObject recv) { - return recv.getRuntime().newString("nil"); - } - - /** nil_type - * - */ - @JRubyMethod(name = "type") - public static RubyClass type(IRubyObject recv) { - return recv.getRuntime().getNilClass(); - } - - /** nil_and - * - */ - @JRubyMethod(name = "&", required = 1) - public static RubyBoolean op_and(IRubyObject recv, IRubyObject obj) { - return recv.getRuntime().getFalse(); - } - - /** nil_or - * - */ - @JRubyMethod(name = "|", required = 1) - public static RubyBoolean op_or(IRubyObject recv, IRubyObject obj) { - return recv.getRuntime().newBoolean(obj.isTrue()); - } - - /** nil_xor - * - */ - @JRubyMethod(name = "^", required = 1) - public static RubyBoolean op_xor(IRubyObject recv, IRubyObject obj) { - return recv.getRuntime().newBoolean(obj.isTrue()); - } - - @JRubyMethod(name = "nil?") - public IRubyObject nil_p() { - return getRuntime().getTrue(); - } - - @Override - public RubyFixnum id() { - return getRuntime().newFixnum(4); - } - - @Override - public IRubyObject taint(ThreadContext context) { - return this; - } - - @Override - public IRubyObject freeze(ThreadContext context) { - return this; - } - - /** nilclass_to_c - * - */ - @JRubyMethod(name = "to_c", compat = CompatVersion.RUBY1_9) - public static IRubyObject to_c(ThreadContext context, IRubyObject recv) { - return RubyComplex.newComplexCanonicalize(context, RubyFixnum.zero(context.getRuntime())); - } - - /** nilclass_to_r - * - */ - @JRubyMethod(name = "to_r", compat = CompatVersion.RUBY1_9) - public static IRubyObject to_r(ThreadContext context, IRubyObject recv) { - return RubyRational.newRationalCanonicalize(context, RubyFixnum.zero(context.getRuntime())); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Koichiro Ohba <koichiro@meadowy.org> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.nio.ByteBuffer; -import java.nio.CharBuffer; -import java.nio.charset.CharacterCodingException; -import java.nio.charset.Charset; -import java.nio.charset.CharsetDecoder; -import java.nio.charset.CharsetEncoder; -import java.nio.charset.UnsupportedCharsetException; -import java.util.HashMap; -import java.util.Map; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; - -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.KCode; - -@JRubyModule(name="NKF") -public class RubyNKF { - public static final NKFCharset AUTO = new NKFCharset(0, "x-JISAutoDetect"); - public static final NKFCharset JIS = new NKFCharset(1, "iso-2022-jp"); - public static final NKFCharset EUC = new NKFCharset(2, "EUC-JP"); - public static final NKFCharset SJIS = new NKFCharset(3, "Windows-31J"); - public static final NKFCharset BINARY = new NKFCharset(4, null); - public static final NKFCharset NOCONV = new NKFCharset(4, null); - public static final NKFCharset UNKNOWN = new NKFCharset(0, null); - public static final NKFCharset ASCII = new NKFCharset(5, "iso-8859-1"); - public static final NKFCharset UTF8 = new NKFCharset(6, "UTF-8"); - public static final NKFCharset UTF16 = new NKFCharset(8, "UTF-16"); - public static final NKFCharset UTF32 = new NKFCharset(12, "UTF-32"); - public static final NKFCharset OTHER = new NKFCharset(16, null); - - public static class NKFCharset { - private final int value; - private final String charset; - - public NKFCharset(int v, String c) { - value = v; - charset = c; - } - - public int getValue() { - return value; - } - - public String getCharset() { - return charset; - } - } - - public static void createNKF(Ruby runtime) { - RubyModule nkfModule = runtime.defineModule("NKF"); - - nkfModule.defineConstant("AUTO", RubyFixnum.newFixnum(runtime, AUTO.getValue())); - nkfModule.defineConstant("JIS", RubyFixnum.newFixnum(runtime, JIS.getValue())); - nkfModule.defineConstant("EUC", RubyFixnum.newFixnum(runtime, EUC.getValue())); - nkfModule.defineConstant("SJIS", RubyFixnum.newFixnum(runtime, SJIS.getValue())); - nkfModule.defineConstant("BINARY", RubyFixnum.newFixnum(runtime, BINARY.getValue())); - nkfModule.defineConstant("NOCONV", RubyFixnum.newFixnum(runtime, NOCONV.getValue())); - nkfModule.defineConstant("UNKNOWN", RubyFixnum.newFixnum(runtime, UNKNOWN.getValue())); - nkfModule.defineConstant("ASCII", RubyFixnum.newFixnum(runtime, ASCII.getValue())); - nkfModule.defineConstant("UTF8", RubyFixnum.newFixnum(runtime, UTF8.getValue())); - nkfModule.defineConstant("UTF16", RubyFixnum.newFixnum(runtime, UTF16.getValue())); - nkfModule.defineConstant("UTF32", RubyFixnum.newFixnum(runtime, UTF32.getValue())); - nkfModule.defineConstant("OTHER", RubyFixnum.newFixnum(runtime, OTHER.getValue())); - - RubyString version = runtime.newString("2.0.7 (JRuby 2007-05-11)"); - RubyString nkfVersion = runtime.newString("2.0.7"); - RubyString nkfDate = runtime.newString("2007-05-11"); - - ThreadContext context = runtime.getCurrentContext(); - - version.freeze(context); - nkfVersion.freeze(context); - nkfDate.freeze(context); - - nkfModule.defineAnnotatedMethods(RubyNKF.class); - } - - @JRubyMethod(name = "guess", required = 1, module = true) - public static IRubyObject guess(ThreadContext context, IRubyObject recv, IRubyObject s) { - Ruby runtime = context.getRuntime(); - if (!s.respondsTo("to_str")) { - throw runtime.newTypeError("can't convert " + s.getMetaClass() + " into String"); - } - ByteList bytes = s.convertToString().getByteList(); - ByteBuffer buf = ByteBuffer.wrap(bytes.unsafeBytes(), bytes.begin(), bytes.length()); - CharsetDecoder decoder = Charset.forName("x-JISAutoDetect").newDecoder(); - try { - decoder.decode(buf); - } catch (CharacterCodingException e) { - return runtime.newFixnum(UNKNOWN.getValue()); - } - if (!decoder.isCharsetDetected()) { - return runtime.newFixnum(UNKNOWN.getValue()); - } - Charset charset = decoder.detectedCharset(); - String name = charset.name(); -// System.out.println("detect: " + name + "\n"); - if ("Shift_JIS".equals(name)) - return runtime.newFixnum(SJIS.getValue()); - if ("windows-31j".equals(name)) - return runtime.newFixnum(SJIS.getValue()); - else if ("EUC-JP".equals(name)) - return runtime.newFixnum(EUC.getValue()); - else if ("ISO-2022-JP".equals(name)) - return runtime.newFixnum(JIS.getValue()); - else - return runtime.newFixnum(UNKNOWN.getValue()); - } - - @JRubyMethod(name = "guess1", required = 1, module = true) - public static IRubyObject guess1(ThreadContext context, IRubyObject recv, IRubyObject str) { - return guess(context, recv, str); - } - - @JRubyMethod(name = "guess2", required = 1, module = true) - public static IRubyObject guess2(ThreadContext context, IRubyObject recv, IRubyObject str) { - return guess(context, recv, str); - } - - @JRubyMethod(name = "nkf", required = 2, module = true) - public static IRubyObject nkf(ThreadContext context, IRubyObject recv, IRubyObject opt, IRubyObject str) { - Ruby runtime = context.getRuntime(); - - if (!opt.respondsTo("to_str")) { - throw runtime.newTypeError("can't convert " + opt.getMetaClass() + " into String"); - } - - if (!str.respondsTo("to_str")) { - throw runtime.newTypeError("can't convert " + str.getMetaClass() + " into String"); - } - - Map<String, NKFCharset> options = parseOpt(opt.convertToString().toString()); - - NKFCharset nc = options.get("input"); - if (nc.getValue() == AUTO.getValue()) { - KCode kcode = runtime.getKCode(); - if (kcode == KCode.SJIS) { - nc = SJIS; - } else if (kcode == KCode.EUC) { - nc = EUC; - } else if (kcode == KCode.UTF8) { - nc = UTF8; - } - } - String decodeCharset = nc.getCharset(); - String encodeCharset = options.get("output").getCharset(); - - return convert(context, decodeCharset, encodeCharset, str); - } - - private static IRubyObject convert(ThreadContext context, String decodeCharset, - String encodeCharset, IRubyObject str) { - Ruby runtime = context.getRuntime(); - CharsetDecoder decoder; - CharsetEncoder encoder; - try { - decoder = Charset.forName(decodeCharset).newDecoder(); - encoder = Charset.forName(encodeCharset).newEncoder(); - } catch (UnsupportedCharsetException e) { - throw runtime.newArgumentError("invalid encoding"); - } - - ByteList bytes = str.convertToString().getByteList(); - ByteBuffer buf = ByteBuffer.wrap(bytes.unsafeBytes(), bytes.begin(), bytes.length()); - try { - CharBuffer cbuf = decoder.decode(buf); - buf = encoder.encode(cbuf); - } catch (CharacterCodingException e) { - throw runtime.newArgumentError("invalid encoding"); - } - byte[] arr = buf.array(); - - return runtime.newString(new ByteList(arr, 0, buf.limit())); - - } - - private static int optionUTF(String s, int i) { - int n = 8; - if (i+1 < s.length() && Character.isDigit(s.charAt(i+1))) { - n = Character.digit(s.charAt(i+1), 10); - if (i+2 < s.length() && Character.isDigit(s.charAt(i+2))) { - n *= 10; - n += Character.digit(s.charAt(i+2), 10); - } - } - return n; - } - - private static Map<String, NKFCharset> parseOpt(String s) { - Map<String, NKFCharset> options = new HashMap<String, NKFCharset>(); - - // default options - options.put("input", AUTO); - options.put("output", JIS); - - for (int i = 0; i < s.length(); i++) { - switch (s.charAt(i)) { - case 'b': - break; - case 'u': - break; - case 'j': // iso-2022-jp - options.put("output", JIS); - break; - case 's': // Shift_JIS - options.put("output", SJIS); - break; - case 'e': // EUC-JP - options.put("output", EUC); - break; - case 'w': // UTF-8 - { - int n = optionUTF(s, i); - if (n == 32) - options.put("output", UTF32); - else if (n == 16) - options.put("output", UTF16); - else - options.put("output", UTF8); - } - break; - case 'J': // iso-2022-jp - options.put("input", JIS); - break; - case 'S': // Shift_JIS - options.put("input", SJIS); - break; - case 'E': // EUC-JP - options.put("input", EUC); - break; - case 'W': // UTF-8 - { - int n = optionUTF(s, i); - if (n == 32) - options.put("input", UTF32); - else if (n == 16) - options.put("input", UTF16); - else - options.put("input", UTF8); - } - break; - case 't': - break; - case 'r': - break; - case 'h': - break; - case 'm': - break; - case 'M': - break; - case 'l': - break; - case 'f': - break; - case 'F': - break; - case 'Z': - break; - case 'X': - break; - case 'x': - break; - case 'B': - break; - case 'T': - break; - case 'd': - break; - case 'c': - break; - case 'I': - break; - case 'L': - break; - case '-': - if (s.charAt(i+1) == '-') { - // long name option - } - default: - } - } - return options; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ - -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.builtin.IRubyObject; - -@JRubyClass(name="NoMethodError", parent="NameError") -public class RubyNoMethodError extends RubyNameError { - private IRubyObject args; - - private static final ObjectAllocator NOMETHODERROR_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyNoMethodError(runtime, klass); - } - }; - - public static RubyClass createNoMethodErrorClass(Ruby runtime, RubyClass nameErrorClass) { - RubyClass noMethodErrorClass = runtime.defineClass("NoMethodError", nameErrorClass, NOMETHODERROR_ALLOCATOR); - - noMethodErrorClass.defineAnnotatedMethods(RubyNoMethodError.class); - - return noMethodErrorClass; - } - - protected RubyNoMethodError(Ruby runtime, RubyClass exceptionClass) { - super(runtime, exceptionClass, exceptionClass.getName()); - this.args = runtime.getNil(); - } - - public RubyNoMethodError(Ruby runtime, RubyClass exceptionClass, String message, String name, IRubyObject args) { - super(runtime, exceptionClass, message, name); - this.args = args; - } - - @JRubyMethod(name = "initialize", optional = 3, frame = true) - public IRubyObject initialize(IRubyObject[] args, Block block) { - if (args.length > 2) { - this.args = args[args.length - 1]; - IRubyObject []tmpArgs = new IRubyObject[args.length - 1]; - System.arraycopy(args, 0, tmpArgs, 0, tmpArgs.length); - args = tmpArgs; - } else { - this.args = getRuntime().getNil(); - } - - super.initialize(args, block); - return this; - } - - @JRubyMethod(name = "args") - public IRubyObject args() { - return args; - } - -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2006 Antti Karanta <Antti.Karanta@napa.fi> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import static org.jruby.util.Numeric.f_abs; -import static org.jruby.util.Numeric.f_arg; -import static org.jruby.util.Numeric.f_negative_p; - -import java.math.BigInteger; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.exceptions.RaiseException; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Block; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.Convert; - -/** - * Base class for all numerical types in ruby. - */ -// TODO: Numeric.new works in Ruby and it does here too. However trying to use -// that instance in a numeric operation should generate an ArgumentError. Doing -// this seems so pathological I do not see the need to fix this now. -@JRubyClass(name="Numeric", include="Comparable") -public class RubyNumeric extends RubyObject { - - public static RubyClass createNumericClass(Ruby runtime) { - RubyClass numeric = runtime.defineClass("Numeric", runtime.getObject(), NUMERIC_ALLOCATOR); - runtime.setNumeric(numeric); - - numeric.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyNumeric; - } - }; - - numeric.includeModule(runtime.getComparable()); - numeric.defineAnnotatedMethods(RubyNumeric.class); - - return numeric; - } - - protected static final ObjectAllocator NUMERIC_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyNumeric(runtime, klass); - } - }; - - public static double DBL_EPSILON=2.2204460492503131e-16; - - private static IRubyObject convertToNum(double val, Ruby runtime) { - - if (val >= (double) RubyFixnum.MAX || val < (double) RubyFixnum.MIN) { - return RubyBignum.newBignum(runtime, val); - } - return RubyFixnum.newFixnum(runtime, (long) val); - } - - public RubyNumeric(Ruby runtime, RubyClass metaClass) { - super(runtime, metaClass); - } - - public RubyNumeric(Ruby runtime, RubyClass metaClass, boolean useObjectSpace) { - super(runtime, metaClass, useObjectSpace); - } - - // The implementations of these are all bonus (see TODO above) I was going - // to throw an error from these, but it appears to be the wrong place to - // do it. - public double getDoubleValue() { - return 0; - } - - public long getLongValue() { - return 0; - } - - public static RubyNumeric newNumeric(Ruby runtime) { - return new RubyNumeric(runtime, runtime.getNumeric()); - } - - /* ================ - * Utility Methods - * ================ - */ - - /** rb_num2int, NUM2INT - * - */ - public static int num2int(IRubyObject arg) { - long num = num2long(arg); - - checkInt(arg, num); - return (int)num; - } - - /** check_int - * - */ - public static void checkInt(IRubyObject arg, long num){ - String s; - if (num < Integer.MIN_VALUE) { - s = "small"; - } else if (num > Integer.MAX_VALUE) { - s = "big"; - } else { - return; - } - throw arg.getRuntime().newRangeError("integer " + num + " too " + s + " to convert to `int'"); - } - - /** - * NUM2CHR - */ - public static byte num2chr(IRubyObject arg) { - if (arg instanceof RubyString) { - String value = ((RubyString) arg).toString(); - - if (value != null && value.length() > 0) return (byte) value.charAt(0); - } - - return (byte) num2int(arg); - } - - /** rb_num2long and FIX2LONG (numeric.c) - * - */ - public static long num2long(IRubyObject arg) { - if (arg instanceof RubyFixnum) { - return ((RubyFixnum) arg).getLongValue(); - } - if (arg.isNil()) { - throw arg.getRuntime().newTypeError("no implicit conversion from nil to integer"); - } - - if (arg instanceof RubyFloat) { - double aFloat = ((RubyFloat) arg).getDoubleValue(); - if (aFloat <= (double) Long.MAX_VALUE && aFloat >= (double) Long.MIN_VALUE) { - return (long) aFloat; - } else { - // TODO: number formatting here, MRI uses "%-.10g", 1.4 API is a must? - throw arg.getRuntime().newRangeError("float " + aFloat + " out of range of integer"); - } - } else if (arg instanceof RubyBignum) { - return RubyBignum.big2long((RubyBignum) arg); - } - return arg.convertToInteger().getLongValue(); - } - - /** rb_dbl2big + LONG2FIX at once (numeric.c) - * - */ - public static IRubyObject dbl2num(Ruby runtime, double val) { - if (Double.isInfinite(val)) { - throw runtime.newFloatDomainError(val < 0 ? "-Infinity" : "Infinity"); - } - if (Double.isNaN(val)) { - throw runtime.newFloatDomainError("NaN"); - } - return convertToNum(val,runtime); - } - - /** rb_num2dbl and NUM2DBL - * - */ - public static double num2dbl(IRubyObject arg) { - if (arg instanceof RubyFloat) { - return ((RubyFloat) arg).getDoubleValue(); - } else if (arg instanceof RubyString) { - throw arg.getRuntime().newTypeError("no implicit conversion to float from string"); - } else if (arg == arg.getRuntime().getNil()) { - throw arg.getRuntime().newTypeError("no implicit conversion to float from nil"); - } - return arg.convertToFloat().getDoubleValue(); - } - - /** rb_dbl_cmp (numeric.c) - * - */ - public static IRubyObject dbl_cmp(Ruby runtime, double a, double b) { - if (Double.isNaN(a) || Double.isNaN(b)) { - return runtime.getNil(); - } - if (a > b) { - return RubyFixnum.one(runtime); - } - if (a < b) { - return RubyFixnum.minus_one(runtime); - } - return RubyFixnum.zero(runtime); - } - - public static long fix2long(IRubyObject arg) { - return ((RubyFixnum) arg).getLongValue(); - } - - public static int fix2int(IRubyObject arg) { - long num = arg instanceof RubyFixnum ? fix2long(arg) : num2long(arg); - - checkInt(arg, num); - return (int) num; - } - - public static RubyInteger str2inum(Ruby runtime, RubyString str, int base) { - return str2inum(runtime,str,base,false); - } - - public static RubyNumeric int2fix(Ruby runtime, long val) { - return RubyFixnum.newFixnum(runtime,val); - } - - /** rb_num2fix - * - */ - public static IRubyObject num2fix(IRubyObject val) { - if (val instanceof RubyFixnum) { - return val; - } - if (val instanceof RubyBignum) { - // any BigInteger is bigger than Fixnum and we don't have FIXABLE - throw val.getRuntime().newRangeError("integer " + val + " out of range of fixnum"); - } - return RubyFixnum.newFixnum(val.getRuntime(), num2long(val)); - } - - /** - * Converts a string representation of an integer to the integer value. - * Parsing starts at the beginning of the string (after leading and - * trailing whitespace have been removed), and stops at the end or at the - * first character that can't be part of an integer. Leading signs are - * allowed. If <code>base</code> is zero, strings that begin with '0[xX]', - * '0[bB]', or '0' (optionally preceded by a sign) will be treated as hex, - * binary, or octal numbers, respectively. If a non-zero base is given, - * only the prefix (if any) that is appropriate to that base will be - * parsed correctly. For example, if the base is zero or 16, the string - * "0xff" will be converted to 256, but if the base is 10, it will come out - * as zero, since 'x' is not a valid decimal digit. If the string fails - * to parse as a number, zero is returned. - * - * @param runtime the ruby runtime - * @param str the string to be converted - * @param base the expected base of the number (for example, 2, 8, 10, 16), - * or 0 if the method should determine the base automatically - * (defaults to 10). Values 0 and 2-36 are permitted. Any other - * value will result in an ArgumentError. - * @param strict if true, enforce the strict criteria for String encoding of - * numeric values, as required by Integer('n'), and raise an - * exception when those criteria are not met. Otherwise, allow - * lax expression of values, as permitted by String#to_i, and - * return a value in almost all cases (excepting illegal radix). - * TODO: describe the rules/criteria - * @return a RubyFixnum or (if necessary) a RubyBignum representing - * the result of the conversion, which will be zero if the - * conversion failed. - */ - public static RubyInteger str2inum(Ruby runtime, RubyString str, int base, boolean strict) { - if (base != 0 && (base < 2 || base > 36)) { - throw runtime.newArgumentError("illegal radix " + base); - } - ByteList bytes = str.getByteList(); - try { - return runtime.newFixnum(Convert.byteListToLong(bytes, base, strict)); - } catch (InvalidIntegerException e) { - return str2inumIIE(strict, runtime, str); - } catch (NumberTooLargeException e) { - return str2inumNTLE(strict, runtime, str, bytes, base); - } - } - - private static RubyInteger str2inumIIE(boolean strict, Ruby runtime, RubyString str) throws RaiseException { - if (strict) { - throw runtime.newArgumentError("invalid value for Integer: " + str.callMethod(runtime.getCurrentContext(), "inspect").toString()); - } - return RubyFixnum.zero(runtime); - } - - private static RubyInteger str2inumNTLE(boolean strict, Ruby runtime, RubyString str, ByteList bytes, int base) { - try { - BigInteger bi = Convert.byteListToBigInteger(bytes, base, strict); - return new RubyBignum(runtime, bi); - } catch (InvalidIntegerException e2) { - return str2inumIIE(strict, runtime, str); - } - } - - public static RubyFloat str2fnum(Ruby runtime, RubyString arg) { - return str2fnum(runtime,arg,false); - } - - /** - * Converts a string representation of a floating-point number to the - * numeric value. Parsing starts at the beginning of the string (after - * leading and trailing whitespace have been removed), and stops at the - * end or at the first character that can't be part of a number. If - * the string fails to parse as a number, 0.0 is returned. - * - * @param runtime the ruby runtime - * @param arg the string to be converted - * @param strict if true, enforce the strict criteria for String encoding of - * numeric values, as required by Float('n'), and raise an - * exception when those criteria are not met. Otherwise, allow - * lax expression of values, as permitted by String#to_f, and - * return a value in all cases. - * TODO: describe the rules/criteria - * @return a RubyFloat representing the result of the conversion, which - * will be 0.0 if the conversion failed. - */ - public static RubyFloat str2fnum(Ruby runtime, RubyString arg, boolean strict) { - final double ZERO = 0.0; - - try { - return new RubyFloat(runtime,Convert.byteListToDouble(arg.getByteList(),strict)); - } catch (NumberFormatException e) { - if (strict) { - throw runtime.newArgumentError("invalid value for Float(): " - + arg.callMethod(runtime.getCurrentContext(), "inspect").toString()); - } - return new RubyFloat(runtime,ZERO); - } - } - - /** Numeric methods. (num_*) - * - */ - - protected IRubyObject[] getCoerced(ThreadContext context, IRubyObject other, boolean error) { - IRubyObject result; - - try { - result = other.callMethod(context, "coerce", this); - } catch (RaiseException e) { - if (error) { - throw getRuntime().newTypeError( - other.getMetaClass().getName() + " can't be coerced into " + getMetaClass().getName()); - } - - return null; - } - - if (!(result instanceof RubyArray) || ((RubyArray)result).getLength() != 2) { - throw getRuntime().newTypeError("coerce must return [x, y]"); - } - - return ((RubyArray)result).toJavaArray(); - } - - protected IRubyObject callCoerced(ThreadContext context, String method, IRubyObject other, boolean err) { - IRubyObject[] args = getCoerced(context, other, err); - if(args == null) { - return getRuntime().getNil(); - } - return args[0].callMethod(context, method, args[1]); - } - - protected IRubyObject callCoerced(ThreadContext context, String method, IRubyObject other) { - IRubyObject[] args = getCoerced(context, other, false); - if(args == null) { - return getRuntime().getNil(); - } - return args[0].callMethod(context, method, args[1]); - } - - // beneath are rewritten coercions that reflect MRI logic, the aboves are used only by RubyBigDecimal - - /** coerce_body - * - */ - protected final IRubyObject coerceBody(ThreadContext context, IRubyObject other) { - return other.callMethod(context, "coerce", this); - } - - /** do_coerce - * - */ - protected final RubyArray doCoerce(ThreadContext context, IRubyObject other, boolean err) { - IRubyObject result; - try { - result = coerceBody(context, other); - } catch (RaiseException e) { - if (err) { - throw getRuntime().newTypeError( - other.getMetaClass().getName() + " can't be coerced into " + getMetaClass().getName()); - } - return null; - } - - if (!(result instanceof RubyArray) || ((RubyArray) result).getLength() != 2) { - throw getRuntime().newTypeError("coerce must return [x, y]"); - } - return (RubyArray) result; - } - - /** rb_num_coerce_bin - * coercion taking two arguments - */ - protected final IRubyObject coerceBin(ThreadContext context, String method, IRubyObject other) { - RubyArray ary = doCoerce(context, other, true); - return (ary.eltInternal(0)).callMethod(context, method, ary.eltInternal(1)); - } - - /** rb_num_coerce_cmp - * coercion used for comparisons - */ - protected final IRubyObject coerceCmp(ThreadContext context, String method, IRubyObject other) { - RubyArray ary = doCoerce(context, other, false); - if (ary == null) { - return getRuntime().getNil(); // MRI does it! - } - return (ary.eltInternal(0)).callMethod(context, method, ary.eltInternal(1)); - } - - /** rb_num_coerce_relop - * coercion used for relative operators - */ - protected final IRubyObject coerceRelOp(ThreadContext context, String method, IRubyObject other) { - RubyArray ary = doCoerce(context, other, false); - if (ary == null) { - return RubyComparable.cmperr(this, other); - } - - return unwrapCoerced(context, method, other, ary); - } - - private final IRubyObject unwrapCoerced(ThreadContext context, String method, IRubyObject other, RubyArray ary) { - IRubyObject result = (ary.eltInternal(0)).callMethod(context, method, ary.eltInternal(1)); - if (result.isNil()) { - return RubyComparable.cmperr(this, other); - } - return result; - } - - public RubyNumeric asNumeric() { - return this; - } - - /* ================ - * Instance Methods - * ================ - */ - - /** num_sadded - * - */ - @JRubyMethod(name = "singleton_method_added") - public IRubyObject sadded(IRubyObject name) { - throw getRuntime().newTypeError("can't define singleton method " + name + " for " + getType().getName()); - } - - /** num_init_copy - * - */ - @Override - @JRubyMethod(name = "initialize_copy", visibility = Visibility.PRIVATE) - public IRubyObject initialize_copy(IRubyObject arg) { - throw getRuntime().newTypeError("can't copy " + getType().getName()); - } - - /** num_coerce - * - */ - @JRubyMethod(name = "coerce") - public IRubyObject coerce(IRubyObject other) { - if (getClass() == other.getClass()) return getRuntime().newArray(other, this); - - IRubyObject cdr = RubyKernel.new_float(this, this); - IRubyObject car = RubyKernel.new_float(this, other); - - return getRuntime().newArray(car, cdr); - } - - /** num_uplus - * - */ - @JRubyMethod(name = "+@") - public IRubyObject op_uplus() { - return this; - } - - /** num_uminus - * - */ - @JRubyMethod(name = "-@") - public IRubyObject op_uminus(ThreadContext context) { - RubyFixnum zero = RubyFixnum.zero(getRuntime()); - RubyArray ary = zero.doCoerce(context, this, true); - return ary.eltInternal(0).callMethod(context, MethodIndex.OP_MINUS, "-", ary.eltInternal(1)); - } - - /** num_cmp - * - */ - @JRubyMethod(name = "<=>") - public IRubyObject op_cmp(IRubyObject other) { - if (this == other) { // won't hurt fixnums - return RubyFixnum.zero(getRuntime()); - } - return getRuntime().getNil(); - } - - /** num_eql - * - */ - @JRubyMethod(name = "eql?") - public IRubyObject eql_p(ThreadContext context, IRubyObject other) { - if (getClass() != other.getClass()) return getRuntime().getFalse(); - return equalInternal(context, this, other) ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - /** num_quo - * - */ - @JRubyMethod(name = "quo") - public IRubyObject quo(ThreadContext context, IRubyObject other) { - return callMethod(context, "/", other); - } - - /** num_quo - * - */ - @JRubyMethod(name = "quo", compat = CompatVersion.RUBY1_9) - public IRubyObject quo_19(ThreadContext context, IRubyObject other) { - return RubyRational.newRationalRaw(context.getRuntime(), this).callMethod(context, "/", other); - } - - /** num_div - * - */ - @JRubyMethod(name = "div") - public IRubyObject div(ThreadContext context, IRubyObject other) { - return callMethod(context, "/", other).convertToFloat().floor(); - } - - /** num_divmod - * - */ - @JRubyMethod(name = "divmod") - public IRubyObject divmod(ThreadContext context, IRubyObject other) { - return RubyArray.newArray(getRuntime(), div(context, other), modulo(context, other)); - } - - /** num_fdiv (1.9) */ - @JRubyMethod(name = "fdiv", compat = CompatVersion.RUBY1_9) - public IRubyObject fdiv(ThreadContext context, IRubyObject other) { - return RuntimeHelpers.invoke(context, this.convertToFloat(), "/", other); - } - - /** num_modulo - * - */ - @JRubyMethod(name = "modulo") - public IRubyObject modulo(ThreadContext context, IRubyObject other) { - return callMethod(context, "%", other); - } - - /** num_remainder - * - */ - @JRubyMethod(name = "remainder") - public IRubyObject remainder(ThreadContext context, IRubyObject dividend) { - IRubyObject z = callMethod(context, "%", dividend); - IRubyObject x = this; - RubyFixnum zero = RubyFixnum.zero(getRuntime()); - - if (!equalInternal(context, z, zero) && - ((x.callMethod(context, MethodIndex.OP_LT, "<", zero).isTrue() && - dividend.callMethod(context, MethodIndex.OP_GT, ">", zero).isTrue()) || - (x.callMethod(context, MethodIndex.OP_GT, ">", zero).isTrue() && - dividend.callMethod(context, MethodIndex.OP_LT, "<", zero).isTrue()))) { - return z.callMethod(context, MethodIndex.OP_MINUS, "-", dividend); - } else { - return z; - } - } - - /** num_abs - * - */ - @JRubyMethod(name = "abs") - public IRubyObject abs(ThreadContext context) { - if (callMethod(context, MethodIndex.OP_LT, "<", RubyFixnum.zero(getRuntime())).isTrue()) { - return callMethod(context, "-@"); - } - return this; - } - - /** num_to_int - * - */ - @JRubyMethod(name = "to_int") - public IRubyObject to_int(ThreadContext context) { - return RuntimeHelpers.invoke(context, this, "to_i"); - } - - /** num_scalar_p - * - */ - @JRubyMethod(name = "scalar?", compat = CompatVersion.RUBY1_9) - public IRubyObject scalar_p() { - return getRuntime().getTrue(); - } - - /** num_int_p - * - */ - @JRubyMethod(name = "integer?") - public IRubyObject integer_p() { - return getRuntime().getFalse(); - } - - /** num_zero_p - * - */ - @JRubyMethod(name = "zero?") - public IRubyObject zero_p(ThreadContext context) { - return equalInternal(context, this, RubyFixnum.zero(getRuntime())) ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - /** num_nonzero_p - * - */ - @JRubyMethod(name = "nonzero?") - public IRubyObject nonzero_p(ThreadContext context) { - if (callMethod(context, "zero?").isTrue()) { - return getRuntime().getNil(); - } - return this; - } - - /** num_floor - * - */ - @JRubyMethod(name = "floor") - public IRubyObject floor() { - return convertToFloat().floor(); - } - - /** num_ceil - * - */ - @JRubyMethod(name = "ceil") - public IRubyObject ceil() { - return convertToFloat().ceil(); - } - - /** num_round - * - */ - @JRubyMethod(name = "round") - public IRubyObject round() { - return convertToFloat().round(); - } - - /** num_truncate - * - */ - @JRubyMethod(name = "truncate") - public IRubyObject truncate() { - return convertToFloat().truncate(); - } - - @JRubyMethod(name = "step", required = 1, optional = 1, frame = true) - public IRubyObject step(ThreadContext context, IRubyObject[] args, Block block) { - switch (args.length) { - case 0: throw context.getRuntime().newArgumentError(0, 1); - case 1: return step(context, args[0], block); - case 2: return step(context, args[0], args[1], block); - default: throw context.getRuntime().newArgumentError(args.length, 2); - } - } - - @JRubyMethod(name = "step", frame = true) - public IRubyObject step(ThreadContext context, IRubyObject arg0, Block block) { - return step(context, arg0, RubyFixnum.one(context.getRuntime()), block); - } - - @JRubyMethod(name = "step", frame = true) - public IRubyObject step(ThreadContext context, IRubyObject to, IRubyObject step, Block block) { - if (this instanceof RubyFixnum && to instanceof RubyFixnum && step instanceof RubyFixnum) { - long value = getLongValue(); - long end = ((RubyFixnum) to).getLongValue(); - long diff = ((RubyFixnum) step).getLongValue(); - - if (diff == 0) { - throw getRuntime().newArgumentError("step cannot be 0"); - } - if (diff > 0) { - for (long i = value; i <= end; i += diff) { - block.yield(context, RubyFixnum.newFixnum(getRuntime(), i)); - } - } else { - for (long i = value; i >= end; i += diff) { - block.yield(context, RubyFixnum.newFixnum(getRuntime(), i)); - } - } - } else if (this instanceof RubyFloat || to instanceof RubyFloat || step instanceof RubyFloat) { - double beg = num2dbl(this); - double end = num2dbl(to); - double unit = num2dbl(step); - - if (unit == 0) { - throw getRuntime().newArgumentError("step cannot be 0"); - } - - double n = (end - beg)/unit; - double err = (Math.abs(beg) + Math.abs(end) + Math.abs(end - beg)) / Math.abs(unit) * DBL_EPSILON; - - if (err>0.5) { - err=0.5; - } - n = Math.floor(n + err) + 1; - - for(double i = 0; i < n; i++){ - block.yield(context, RubyFloat.newFloat(getRuntime(), i * unit + beg)); - } - - } else { - RubyNumeric i = this; - - int cmp; - String cmpString; - if (((RubyBoolean) step.callMethod(context, MethodIndex.OP_GT, ">", RubyFixnum.zero(getRuntime()))).isTrue()) { - cmp = MethodIndex.OP_GT; - } else { - cmp = MethodIndex.OP_LT; - } - cmpString = MethodIndex.NAMES.get(cmp); - - while (true) { - if (i.callMethod(context, cmp, cmpString, to).isTrue()) { - break; - } - block.yield(context, i); - i = (RubyNumeric) i.callMethod(context, MethodIndex.OP_PLUS, "+", step); - } - } - return this; - } - - /** num_equal, doesn't override RubyObject.op_equal - * - */ - protected final IRubyObject op_num_equal(ThreadContext context, IRubyObject other) { - // it won't hurt fixnums - if (this == other) return getRuntime().getTrue(); - - return other.callMethod(context, MethodIndex.EQUALEQUAL, "==", this); - } - - /** num_numerator - * - */ - @JRubyMethod(name = "numerator", compat = CompatVersion.RUBY1_9) - public IRubyObject numerator(ThreadContext context) { - return RubyRational.newRationalConvert(context, this).callMethod(context, "numerator"); - } - - /** num_denominator - * - */ - @JRubyMethod(name = "denominator", compat = CompatVersion.RUBY1_9) - public IRubyObject denominator(ThreadContext context) { - return RubyRational.newRationalConvert(context, this).callMethod(context, "denominator"); - } - - /** numeric_to_c - * - */ - @JRubyMethod(name = "to_c", compat = CompatVersion.RUBY1_9) - public IRubyObject to_c(ThreadContext context) { - return RubyComplex.newComplexCanonicalize(context, this); - } - - /** numeric_re - * - */ - @JRubyMethod(name = "re", compat = CompatVersion.RUBY1_9) - public IRubyObject re(ThreadContext context) { - return RubyComplex.newComplexConvert(context, this); - } - - /** numeric_im - * - */ - @JRubyMethod(name = "im", compat = CompatVersion.RUBY1_9) - public IRubyObject im(ThreadContext context) { - return RubyComplex.newComplexConvert(context, RubyFixnum.zero(context.getRuntime()), this); - } - - /** numeric_real - * - */ - @JRubyMethod(name = "real", compat = CompatVersion.RUBY1_9) - public IRubyObject real(ThreadContext context) { - return this; - } - - /** numeric_image - * - */ - @JRubyMethod(name = {"image", "imag"}, compat = CompatVersion.RUBY1_9) - public IRubyObject image(ThreadContext context) { - return RubyFixnum.zero(context.getRuntime()); - } - - /** numeric_arg - * - */ - @JRubyMethod(name = "arg", compat = CompatVersion.RUBY1_9) - public IRubyObject arg(ThreadContext context) { - if (!f_negative_p(context, this)) return RubyFixnum.zero(context.getRuntime()); - return context.getRuntime().getMath().fastFetchConstant("PI"); - } - - /** numeric_polar - * - */ - @JRubyMethod(name = "polar", compat = CompatVersion.RUBY1_9) - public IRubyObject polar(ThreadContext context) { - return context.getRuntime().newArray(f_abs(context, this), f_arg(context, this)); - } - - /** numeric_real - * - */ - @JRubyMethod(name = "conjugate", compat = CompatVersion.RUBY1_9) - public IRubyObject conjugate(ThreadContext context) { - return this; - } - - public static class InvalidIntegerException extends NumberFormatException { - private static final long serialVersionUID = 55019452543252148L; - - public InvalidIntegerException() { - super(); - } - public InvalidIntegerException(String message) { - super(message); - } - public Throwable fillInStackTrace() { - return this; - } - } - - public static class NumberTooLargeException extends NumberFormatException { - private static final long serialVersionUID = -1835120694982699449L; - public NumberTooLargeException() { - super(); - } - public NumberTooLargeException(String message) { - super(message); - } - public Throwable fillInStackTrace() { - return this; - } - } -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Ola Bini <ola.bini@ki.se> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2007 MenTaLguY <mental@rydia.net> - * Copyright (C) 2007 William N Dortch <bill.dortch@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.io.Serializable; -import java.util.concurrent.atomic.AtomicBoolean; - -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.evaluator.ASTInterpreter; -import org.jruby.exceptions.JumpException; -import org.jruby.internal.runtime.methods.DynamicMethod; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallType; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.builtin.Variable; -import org.jruby.runtime.component.VariableEntry; -import org.jruby.util.IdUtil; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.javasupport.JavaObject; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.builtin.InstanceVariables; -import org.jruby.runtime.builtin.InternalVariables; -import org.jruby.runtime.marshal.CoreObjectType; -import org.jruby.util.TypeConverter; - -/** - * RubyObject is the only implementation of the - * {@link org.jruby.runtime.builtin.IRubyObject}. Every Ruby object in JRuby - * is represented by something that is an instance of RubyObject. In - * some of the core class implementations, this means doing a subclass - * that extends RubyObject, in other cases it means using a simple - * RubyObject instance and the data field to store specific - * information about the Ruby object. - * - * Some care has been taken to make the implementation be as - * monomorphic as possible, so that the Java Hotspot engine can - * improve performance of it. That is the reason for several patterns - * that might seem odd in this class. - * - * The IRubyObject interface used to have lots of methods for - * different things, but these have now mostly been refactored into - * several interfaces that gives access to that specific part of the - * object. This gives us the possibility to switch out that subsystem - * without changing interfaces again. For example, instance variable - * and internal variables are handled this way, but the implementation - * in RubyObject only returns "this" in {@link #getInstanceVariables()} and - * {@link #getInternalVariables()}. - * - * @author jpetersen - */ -@JRubyClass(name="Object", include="Kernel") -public class RubyObject implements Cloneable, IRubyObject, Serializable, CoreObjectType, InstanceVariables, InternalVariables { - - /** - * It's not valid to create a totally empty RubyObject. Since the - * RubyObject is always defined in relation to a runtime, that - * means that creating RubyObjects from outside the class might - * cause problems. - */ - private RubyObject(){}; - - /** - * A value that is used as a null sentinel in among other places - * the RubyArray implementation. It will cause large problems to - * call any methods on this object. - */ - public static final IRubyObject NEVER = new RubyObject(); - - /** - * A value that specifies an undefined value. This value is used - * as a sentinel for undefined constant values, and other places - * where neither null nor NEVER makes sense. - */ - public static final IRubyObject UNDEF = new RubyObject(); - - // The class of this object - protected transient RubyClass metaClass; - - /** - * The variableTable contains variables for an object, defined as: - * <ul> - * <li> instance variables - * <li> class variables (for classes/modules) - * <li> internal variables (such as those used when marshaling RubyRange and RubyException) - * </ul> - * - * Constants are stored separately, see {@link RubyModule}. - * - */ - protected transient volatile VariableTableEntry[] variableTable; - protected transient int variableTableSize; - protected transient int variableTableThreshold; - - // The dataStruct is a place where custom information can be - // contained for core implementations that doesn't necessarily - // want to go to the trouble of creating a subclass of - // RubyObject. The OpenSSL implementation uses this heavily to - // save holder objects containing Java cryptography objects. - // Java integration uses this to store the Java object ref. - protected transient Object dataStruct; - - protected int flags; // zeroed by jvm - public static final int ALL_F = -1; - public static final int FALSE_F = 1 << 0; - - /** - * This flag is a bit funny. It's used to denote that this value - * is nil. It's a bit counterintuitive for a Java programmer to - * not use subclassing to handle this case, since we have a - * RubyNil subclass anyway. Well, the reason for it being a flag - * is that the {@link #isNil()} method is called extremely often. So often - * that it gives a good speed boost to make it monomorphic and - * final. It turns out using a flag for this actually gives us - * better performance than having a polymorphic {@link #isNil()} method. - */ - public static final int NIL_F = 1 << 1; - - public static final int FROZEN_F = 1 << 2; - public static final int TAINTED_F = 1 << 3; - - public static final int FL_USHIFT = 4; - - public static final int USER0_F = (1<<(FL_USHIFT+0)); - public static final int USER1_F = (1<<(FL_USHIFT+1)); - public static final int USER2_F = (1<<(FL_USHIFT+2)); - public static final int USER3_F = (1<<(FL_USHIFT+3)); - public static final int USER4_F = (1<<(FL_USHIFT+4)); - public static final int USER5_F = (1<<(FL_USHIFT+5)); - public static final int USER6_F = (1<<(FL_USHIFT+6)); - public static final int USER7_F = (1<<(FL_USHIFT+7)); - - /** - * Sets or unsets a flag on this object. The only flags that are - * guaranteed to be valid to use as the first argument is: - * - * <ul> - * <li>{@link #FALSE_F}</li> - * <li>{@link NIL_F}</li> - * <li>{@link FROZEN_F}</li> - * <li>{@link TAINTED_F}</li> - * <li>{@link USER0_F}</li> - * <li>{@link USER1_F}</li> - * <li>{@link USER2_F}</li> - * <li>{@link USER3_F}</li> - * <li>{@link USER4_F}</li> - * <li>{@link USER5_F}</li> - * <li>{@link USER6_F}</li> - * <li>{@link USER7_F}</li> - * </ul> - * - * @param flag the actual flag to set or unset. - * @param set if true, the flag will be set, if false, the flag will be unset. - */ - public final void setFlag(int flag, boolean set) { - if (set) { - flags |= flag; - } else { - flags &= ~flag; - } - } - - /** - * Get the value of a custom flag on this object. The only - * guaranteed flags that can be sent in to this method is: - * - * <ul> - * <li>{@link #FALSE_F}</li> - * <li>{@link NIL_F}</li> - * <li>{@link FROZEN_F}</li> - * <li>{@link TAINTED_F}</li> - * <li>{@link USER0_F}</li> - * <li>{@link USER1_F}</li> - * <li>{@link USER2_F}</li> - * <li>{@link USER3_F}</li> - * <li>{@link USER4_F}</li> - * <li>{@link USER5_F}</li> - * <li>{@link USER6_F}</li> - * <li>{@link USER7_F}</li> - * </ul> - * - * @param flag the flag to get - * @return true if the flag is set, false otherwise - */ - public final boolean getFlag(int flag) { - return (flags & flag) != 0; - } - - private transient Finalizer finalizer; - - /** - * Class that keeps track of the finalizers for the object under - * operation. - */ - public class Finalizer implements Finalizable { - private long id; - private List<IRubyObject> finalizers; - private AtomicBoolean finalized; - - public Finalizer(long id) { - this.id = id; - this.finalized = new AtomicBoolean(false); - } - - public void addFinalizer(IRubyObject finalizer) { - if (finalizers == null) { - finalizers = new ArrayList<IRubyObject>(); - } - finalizers.add(finalizer); - } - - public void removeFinalizers() { - finalizers = null; - } - - @Override - public void finalize() { - if (finalized.compareAndSet(false, true)) { - if (finalizers != null) { - for (int i = 0; i < finalizers.size(); i++) { - IRubyObject finalizer = finalizers.get(i); - RuntimeHelpers.invoke( - finalizer.getRuntime().getCurrentContext(), - finalizer, "call", RubyObject.this.id()); - } - } - } - } - } - - /** - * Standard path for object creation. Objects are entered into ObjectSpace - * only if ObjectSpace is enabled. - */ - public RubyObject(Ruby runtime, RubyClass metaClass) { - this.metaClass = metaClass; - - if (runtime.isObjectSpaceEnabled()) addToObjectSpace(runtime); - if (runtime.getSafeLevel() >= 3) taint(runtime); - } - - /** - * Path for objects who want to decide whether they don't want to be in - * ObjectSpace even when it is on. (notably used by objects being - * considered immediate, they'll always pass false here) - */ - protected RubyObject(Ruby runtime, RubyClass metaClass, boolean useObjectSpace) { - this.metaClass = metaClass; - - if (useObjectSpace) addToObjectSpace(runtime); - if (runtime.getSafeLevel() >= 3) taint(runtime); - } - - private void addToObjectSpace(Ruby runtime) { - assert runtime.isObjectSpaceEnabled(); - runtime.getObjectSpace().add(this); - } - - /** - * Will create the Ruby class Object in the runtime - * specified. This method needs to take the actual class as an - * argument because of the Object class' central part in runtime - * initialization. - */ - public static RubyClass createObjectClass(Ruby runtime, RubyClass objectClass) { - objectClass.index = ClassIndex.OBJECT; - - objectClass.defineAnnotatedMethods(ObjectMethods.class); - - return objectClass; - } - - /** - * Interestingly, the Object class doesn't really have that many - * methods for itself. Instead almost all of the Object methods - * are really defined on the Kernel module. This class is a holder - * for all Object methods. - * - * @see RubyKernel - */ - public static class ObjectMethods { - @JRubyMethod(name = "initialize", visibility = Visibility.PRIVATE) - public static IRubyObject intialize(IRubyObject self) { - return self.getRuntime().getNil(); - } - } - - /** - * Default allocator instance for all Ruby objects. The only - * reason to not use this allocator is if you actually need to - * have all instances of something be a subclass of RubyObject. - * - * @see org.jruby.runtime.ObjectAllocator - */ - public static final ObjectAllocator OBJECT_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyObject(runtime, klass); - } - }; - - /** - * Will make sure that this object is added to the current object - * space. - * - * @see org.jruby.runtime.ObjectSpace - */ - public void attachToObjectSpace() { - getRuntime().getObjectSpace().add(this); - } - - /** - * This is overridden in the other concrete Java builtins to provide a fast way - * to determine what type they are. - * - * Will generally return a value from org.jruby.runtime.ClassIndex - * - * @see org.jruby.runtime.ClassInde - */ - public int getNativeTypeIndex() { - return ClassIndex.OBJECT; - } - - /** - * Specifically polymorphic method that are meant to be overridden - * by modules to specify that they are modules in an easy way. - */ - public boolean isModule() { - return false; - } - - /** - * Specifically polymorphic method that are meant to be overridden - * by classes to specify that they are classes in an easy way. - */ - public boolean isClass() { - return false; - } - - /** - * Is object immediate (def: Fixnum, Symbol, true, false, nil?). - */ - public boolean isImmediate() { - return false; - } - - /** rb_make_metaclass - * - * Will create a new meta class, insert this in the chain of - * classes for this specific object, and return the generated meta - * class. - */ - public RubyClass makeMetaClass(RubyClass superClass) { - MetaClass klass = new MetaClass(getRuntime(), superClass); // rb_class_boot - setMetaClass(klass); - - klass.setAttached(this); - klass.setMetaClass(superClass.getRealClass().getMetaClass()); - - return klass; - } - - /** - * Will return the Java interface that most closely can represent - * this object, when working through JAva integration - * translations. - */ - public Class getJavaClass() { - if (dataGetStruct() instanceof JavaObject) { - return ((JavaObject)dataGetStruct()).getValue().getClass(); - } - return getClass(); - } - - /** - * Simple helper to print any objects. - */ - public static void puts(Object obj) { - System.out.println(obj.toString()); - } - - /** - * This method is just a wrapper around the Ruby "==" method, - * provided so that RubyObjects can be used as keys in the Java - * HashMap object underlying RubyHash. - */ - @Override - public boolean equals(Object other) { - return other == this || - other instanceof IRubyObject && - callMethod(getRuntime().getCurrentContext(), MethodIndex.EQUALEQUAL, "==", (IRubyObject) other).isTrue(); - } - - /** - * The default toString method is just a wrapper that calls the - * Ruby "to_s" method. - */ - @Override - public String toString() { - return RuntimeHelpers.invoke(getRuntime().getCurrentContext(), this, "to_s").toString(); - } - - /** - * Will return the runtime that this object is associated with. - * - * @return current runtime - */ - public final Ruby getRuntime() { - return getMetaClass().getClassRuntime(); - } - - /** - * if exist return the meta-class else return the type of the object. - * - */ - public final RubyClass getMetaClass() { - return metaClass; - } - - /** - * Makes it possible to change the metaclass of an object. In - * practice, this is a simple version of Smalltalks Become, except - * that it doesn't work when we're dealing with subclasses. In - * practice it's used to change the singleton/meta class used, - * without changing the "real" inheritance chain. - */ - public void setMetaClass(RubyClass metaClass) { - this.metaClass = metaClass; - } - - /** - * Is this value frozen or not? Shortcut for doing - * getFlag(FROZEN_F). - * - * @return true if this object is frozen, false otherwise - */ - public boolean isFrozen() { - return (flags & FROZEN_F) != 0; - } - - /** - * Sets whether this object is frozen or not. Shortcut for doing - * setFlag(FROZEN_F, frozen). - * - * @param frozen should this object be frozen? - */ - public void setFrozen(boolean frozen) { - if (frozen) { - flags |= FROZEN_F; - } else { - flags &= ~FROZEN_F; - } - } - - /** rb_frozen_class_p - * - * Helper to test whether this object is frozen, and if it is will - * throw an exception based on the message. - */ - protected final void testFrozen(String message) { - if (isFrozen()) { - throw getRuntime().newFrozenError(message + " " + getMetaClass().getName()); - } - } - - /** - * The actual method that checks frozen with the default frozen message from MRI. - * If possible, call this instead of {@link #testFrozen}. - */ - protected void checkFrozen() { - testFrozen("can't modify frozen "); - } - - /** - * Gets the taint. Shortcut for getFlag(TAINTED_F). - * - * @return true if this object is tainted - */ - public boolean isTaint() { - return (flags & TAINTED_F) != 0; - } - - /** - * Sets the taint flag. Shortcut for setFlag(TAINTED_F, taint) - * - * @param taint should this object be tainted or not? - */ - public void setTaint(boolean taint) { - if (taint) { - flags |= TAINTED_F; - } else { - flags &= ~TAINTED_F; - } - } - - /** - * Does this object represent nil? See the docs for the {@link - * #NIL_F} flag for more information. - */ - public final boolean isNil() { - return (flags & NIL_F) != 0; - } - - /** - * Is this value a true value or not? Based on the {@link #FALSE_F} flag. - */ - public final boolean isTrue() { - return (flags & FALSE_F) == 0; - } - - /** - * Is this value a false value or not? Based on the {@link #FALSE_F} flag. - */ - public final boolean isFalse() { - return (flags & FALSE_F) != 0; - } - - /** - * Does this object respond to the specified message? Uses a - * shortcut if it can be proved that respond_to? haven't been - * overridden. - */ - public final boolean respondsTo(String name) { - if(getMetaClass().searchMethod("respond_to?") == getRuntime().getRespondToMethod()) { - return getMetaClass().isMethodBound(name, false); - } else { - return callMethod(getRuntime().getCurrentContext(),"respond_to?",getRuntime().newSymbol(name)).isTrue(); - } - } - - /** rb_singleton_class - * - * Note: this method is specialized for RubyFixnum, RubySymbol, - * RubyNil and RubyBoolean - * - * Will either return the existing singleton class for this - * object, or create a new one and return that. - */ - public RubyClass getSingletonClass() { - RubyClass klass; - - if (getMetaClass().isSingleton() && ((MetaClass)getMetaClass()).getAttached() == this) { - klass = getMetaClass(); - } else { - klass = makeMetaClass(getMetaClass()); - } - - klass.setTaint(isTaint()); - if (isFrozen()) klass.setFrozen(true); - - return klass; - } - - /** rb_singleton_class_clone - * - * Will make sure that if the current objects class is a - * singleton, it will get cloned. - * - * @return either a real class, or a clone of the current singleton class - */ - protected RubyClass getSingletonClassClone() { - RubyClass klass = getMetaClass(); - - if (!klass.isSingleton()) return klass; - - MetaClass clone = new MetaClass(getRuntime()); - clone.flags = flags; - - if (this instanceof RubyClass) { - clone.setMetaClass(clone); - } else { - clone.setMetaClass(klass.getSingletonClassClone()); - } - - clone.setSuperClass(klass.getSuperClass()); - - if (klass.hasVariables()) { - clone.syncVariables(klass.getVariableList()); - } - - klass.cloneMethods(clone); - - ((MetaClass)clone.getMetaClass()).setAttached(clone); - - ((MetaClass)clone).setAttached(((MetaClass)klass).getAttached()); - - return clone; - } - - /** init_copy - * - * Initializes a copy with variable and special instance variable - * information, and then call the initialize_copy Ruby method. - */ - private static void initCopy(IRubyObject clone, RubyObject original) { - assert !clone.isFrozen() : "frozen object (" + clone.getMetaClass().getName() + ") allocated"; - - original.copySpecialInstanceVariables(clone); - - if (original.hasVariables()) { - clone.syncVariables(original.getVariableList()); - } - - /* FIXME: finalizer should be dupped here */ - clone.callMethod(clone.getRuntime().getCurrentContext(), "initialize_copy", original); - } - - /** OBJ_INFECT - * - * Infects this object with traits from the argument obj. In real - * terms this currently means that if obj is tainted, this object - * will get tainted too. It's possible to hijack this method to do - * other infections if that would be interesting. - */ - public IRubyObject infectBy(IRubyObject obj) { - if (obj.isTaint()) setTaint(true); - return this; - } - - /** - * The protocol for super method invocation is a bit complicated - * in Ruby. In real terms it involves first finding the real - * implementation class (the super class), getting the name of the - * method to call from the frame, and then invoke that on the - * super class with the current self as the actual object - * invoking. - */ - public IRubyObject callSuper(ThreadContext context, IRubyObject[] args, Block block) { - RubyModule klazz = context.getFrameKlazz(); - - RubyClass superClass = RuntimeHelpers.findImplementerIfNecessary(getMetaClass(), klazz).getSuperClass(); - - if (superClass == null) { - String name = context.getFrameName(); - return RuntimeHelpers.callMethodMissing(context, this, klazz.searchMethod(name), name, args, this, CallType.SUPER, block); - } - return RuntimeHelpers.invokeAs(context, superClass, this, context.getFrameName(), args, CallType.SUPER, block); - } - - /** - * Will invoke a named method with no arguments and no block. - */ - public final IRubyObject callMethod(ThreadContext context, String name) { - return RuntimeHelpers.invoke(context, this, name); - } - - /** - * Will invoke a named method with one argument and no block with - * functional invocation. - */ - public final IRubyObject callMethod(ThreadContext context, String name, IRubyObject arg) { - return RuntimeHelpers.invoke(context, this, name, arg); - } - - /** - * Will invoke a named method with the supplied arguments and no - * block with functional invocation. - */ - public final IRubyObject callMethod(ThreadContext context, String name, IRubyObject[] args) { - return RuntimeHelpers.invoke(context, this, name, args); - } - - /** - * Will invoke a named method with the supplied arguments and - * supplied block with functional invocation. - */ - public final IRubyObject callMethod(ThreadContext context, String name, IRubyObject[] args, Block block) { - return RuntimeHelpers.invoke(context, this, name, args, block); - } - - /** - * Will invoke an indexed method with the no arguments and no - * block. - */ - public final IRubyObject callMethod(ThreadContext context, int methodIndex, String name) { - return RuntimeHelpers.invoke(context, this, name); - } - - /** - * Will invoke an indexed method with the one argument and no - * block with a functional invocation. - */ - public final IRubyObject callMethod(ThreadContext context, int methodIndex, String name, IRubyObject arg) { - return RuntimeHelpers.invoke(context, this, name, arg, Block.NULL_BLOCK); - } - - /** - * Call the Ruby initialize method with the supplied arguments and block. - */ - public final void callInit(IRubyObject[] args, Block block) { - callMethod(getRuntime().getCurrentContext(), "initialize", args, block); - } - - /** rb_to_id - * - * Will try to convert this object to a String using the Ruby - * "to_str" if the object isn't already a String. If this still - * doesn't work, will throw a Ruby TypeError. - * - */ - public String asJavaString() { - IRubyObject asString = checkStringType(); - if(!asString.isNil()) return ((RubyString)asString).asJavaString(); - throw getRuntime().newTypeError(inspect().toString() + " is not a symbol"); - } - - /** - * Tries to convert this object to a Ruby Array using the "to_ary" - * method. - */ - public RubyArray convertToArray() { - return (RubyArray) TypeConverter.convertToType(this, getRuntime().getArray(), MethodIndex.TO_ARY, "to_ary"); - } - - /** - * Tries to convert this object to a Ruby Hash using the "to_hash" - * method. - */ - public RubyHash convertToHash() { - return (RubyHash)TypeConverter.convertToType(this, getRuntime().getHash(), MethodIndex.TO_HASH, "to_hash"); - } - - /** - * Tries to convert this object to a Ruby Float using the "to_f" - * method. - */ - public RubyFloat convertToFloat() { - return (RubyFloat) TypeConverter.convertToType(this, getRuntime().getFloat(), MethodIndex.TO_F, "to_f"); - } - - /** - * Tries to convert this object to a Ruby Integer using the "to_int" - * method. - */ - public RubyInteger convertToInteger() { - return convertToInteger(MethodIndex.TO_INT, "to_int"); - } - - /** - * Tries to convert this object to a Ruby Integer using the - * supplied conversion method. - */ - public RubyInteger convertToInteger(int convertMethodIndex, String convertMethod) { - IRubyObject val = TypeConverter.convertToType(this, getRuntime().getInteger(), convertMethodIndex, convertMethod, true); - if (!(val instanceof RubyInteger)) throw getRuntime().newTypeError(getMetaClass().getName() + "#" + convertMethod + " should return Integer"); - return (RubyInteger)val; - } - - /** - * Tries to convert this object to a Ruby String using the - * "to_str" method. - */ - public RubyString convertToString() { - return (RubyString) TypeConverter.convertToType(this, getRuntime().getString(), MethodIndex.TO_STR, "to_str"); - } - - /** - * Tries to convert this object to the specified Ruby type, using - * a specific conversion method. - */ - public final IRubyObject convertToType(RubyClass target, int convertMethodIndex) { - return TypeConverter.convertToType(this, target, convertMethodIndex, (String)MethodIndex.NAMES.get(convertMethodIndex)); - } - - /** rb_obj_as_string - * - * First converts this object into a String using the "to_s" - * method, infects it with the current taint and returns it. If - * to_s doesn't return a Ruby String, {@link #anyToString} is used - * instead. - */ - public RubyString asString() { - IRubyObject str = RuntimeHelpers.invoke(getRuntime().getCurrentContext(), this, "to_s"); - - if (!(str instanceof RubyString)) return (RubyString)anyToString(); - if (isTaint()) str.setTaint(true); - return (RubyString) str; - } - - /** rb_check_string_type - * - * Tries to return a coerced string representation of this object, - * using "to_str". If that returns something other than a String - * or nil, an empty String will be returned. - * - */ - public IRubyObject checkStringType() { - IRubyObject str = TypeConverter.convertToTypeWithCheck(this, getRuntime().getString(), MethodIndex.TO_STR, "to_str"); - if(!str.isNil() && !(str instanceof RubyString)) { - str = RubyString.newEmptyString(getRuntime()); - } - return str; - } - - /** rb_check_array_type - * - * Returns the result of trying to convert this object to an Array - * with "to_ary". - */ - public IRubyObject checkArrayType() { - return TypeConverter.convertToTypeWithCheck(this, getRuntime().getArray(), MethodIndex.TO_ARY, "to_ary"); - } - - /** specific_eval - * - * Evaluates the block or string inside of the context of this - * object, using the supplied arguments. If a block is given, this - * will be yielded in the specific context of this object. If no - * block is given then a String-like object needs to be the first - * argument, and this string will be evaluated. Second and third - * arguments in the args-array is optional, but can contain the - * filename and line of the string under evaluation. - */ - @Deprecated - public IRubyObject specificEval(ThreadContext context, RubyModule mod, IRubyObject[] args, Block block) { - if (block.isGiven()) { - if (args.length > 0) throw getRuntime().newArgumentError(args.length, 0); - - return yieldUnder(context, mod, block); - } - - if (args.length == 0) { - throw getRuntime().newArgumentError("block not supplied"); - } else if (args.length > 3) { - String lastFuncName = context.getFrameName(); - throw getRuntime().newArgumentError( - "wrong # of arguments: " + lastFuncName + "(src) or " + lastFuncName + "{..}"); - } - - // We just want the TypeError if the argument doesn't convert to a String (JRUBY-386) - RubyString evalStr; - if (args[0] instanceof RubyString) { - evalStr = (RubyString)args[0]; - } else { - evalStr = args[0].convertToString(); - } - - String file; - int line; - if (args.length > 1) { - file = args[1].convertToString().asJavaString(); - if (args.length > 2) { - line = (int)(args[2].convertToInteger().getLongValue() - 1); - } else { - line = 0; - } - } else { - file = "(eval)"; - line = 0; - } - - return evalUnder(context, mod, evalStr, file, line); - } - - /** specific_eval - * - * Evaluates the block or string inside of the context of this - * object, using the supplied arguments. If a block is given, this - * will be yielded in the specific context of this object. If no - * block is given then a String-like object needs to be the first - * argument, and this string will be evaluated. Second and third - * arguments in the args-array is optional, but can contain the - * filename and line of the string under evaluation. - */ - public IRubyObject specificEval(ThreadContext context, RubyModule mod, Block block) { - if (block.isGiven()) { - return yieldUnder(context, mod, block); - } else { - throw context.getRuntime().newArgumentError("block not supplied"); - } - } - - /** specific_eval - * - * Evaluates the block or string inside of the context of this - * object, using the supplied arguments. If a block is given, this - * will be yielded in the specific context of this object. If no - * block is given then a String-like object needs to be the first - * argument, and this string will be evaluated. Second and third - * arguments in the args-array is optional, but can contain the - * filename and line of the string under evaluation. - */ - public IRubyObject specificEval(ThreadContext context, RubyModule mod, IRubyObject arg, Block block) { - if (block.isGiven()) throw context.getRuntime().newArgumentError(1, 0); - - // We just want the TypeError if the argument doesn't convert to a String (JRUBY-386) - RubyString evalStr; - if (arg instanceof RubyString) { - evalStr = (RubyString)arg; - } else { - evalStr = arg.convertToString(); - } - - String file = "(eval)"; - int line = 0; - - return evalUnder(context, mod, evalStr, file, line); - } - - /** specific_eval - * - * Evaluates the block or string inside of the context of this - * object, using the supplied arguments. If a block is given, this - * will be yielded in the specific context of this object. If no - * block is given then a String-like object needs to be the first - * argument, and this string will be evaluated. Second and third - * arguments in the args-array is optional, but can contain the - * filename and line of the string under evaluation. - */ - public IRubyObject specificEval(ThreadContext context, RubyModule mod, IRubyObject arg0, IRubyObject arg1, Block block) { - if (block.isGiven()) throw context.getRuntime().newArgumentError(2, 0); - - // We just want the TypeError if the argument doesn't convert to a String (JRUBY-386) - RubyString evalStr; - if (arg0 instanceof RubyString) { - evalStr = (RubyString)arg0; - } else { - evalStr = arg0.convertToString(); - } - - String file = arg1.convertToString().asJavaString(); - int line = 0; - - return evalUnder(context, mod, evalStr, file, line); - } - - /** specific_eval - * - * Evaluates the block or string inside of the context of this - * object, using the supplied arguments. If a block is given, this - * will be yielded in the specific context of this object. If no - * block is given then a String-like object needs to be the first - * argument, and this string will be evaluated. Second and third - * arguments in the args-array is optional, but can contain the - * filename and line of the string under evaluation. - */ - public IRubyObject specificEval(ThreadContext context, RubyModule mod, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) { - if (block.isGiven()) throw context.getRuntime().newArgumentError(2, 0); - - // We just want the TypeError if the argument doesn't convert to a String (JRUBY-386) - RubyString evalStr; - if (arg0 instanceof RubyString) { - evalStr = (RubyString)arg0; - } else { - evalStr = arg0.convertToString(); - } - - String file = arg1.convertToString().asJavaString(); - int line = (int)(arg2.convertToInteger().getLongValue() - 1); - - return evalUnder(context, mod, evalStr, file, line); - } - - /** - * Evaluates the string src with self set to the current object, - * using the module under as the context. - * @deprecated Call with an int line number and String file - */ - public IRubyObject evalUnder(final ThreadContext context, RubyModule under, IRubyObject src, IRubyObject file, IRubyObject line) { - return evalUnder(context, under, src.convertToString(), file.convertToString().toString(), (int) (line.convertToInteger().getLongValue() - 1)); - } - - /** - * Evaluates the string src with self set to the current object, - * using the module under as the context. - */ - public IRubyObject evalUnder(final ThreadContext context, RubyModule under, RubyString src, String file, int line) { - Visibility savedVisibility = context.getCurrentVisibility(); - context.setCurrentVisibility(Visibility.PUBLIC); - context.preExecuteUnder(under, Block.NULL_BLOCK); - try { - return ASTInterpreter.evalSimple(context, this, src, - file, line); - } finally { - context.postExecuteUnder(); - context.setCurrentVisibility(savedVisibility); - } - } - - /** - * Will yield to the specific block changing the self to be the - * current object instead of the self that is part of the frame - * saved in the block frame. This method is the basis for the Ruby - * instance_eval and module_eval methods. The arguments sent in to - * it in the args array will be yielded to the block. This makes - * it possible to emulate both instance_eval and instance_exec - * with this implementation. - */ - private IRubyObject yieldUnder(final ThreadContext context, RubyModule under, IRubyObject[] args, Block block) { - context.preExecuteUnder(under, block); - - Visibility savedVisibility = block.getBinding().getVisibility(); - block.getBinding().setVisibility(Visibility.PUBLIC); - - try { - IRubyObject valueInYield; - boolean aValue; - if (args.length == 1) { - valueInYield = args[0]; - aValue = false; - } else { - valueInYield = RubyArray.newArrayNoCopy(context.getRuntime(), args); - aValue = true; - } - - // FIXME: This is an ugly hack to resolve JRUBY-1381; I'm not proud of it - block = block.cloneBlock(); - block.getBinding().setSelf(RubyObject.this); - block.getBinding().getFrame().setSelf(RubyObject.this); - // end hack - - return block.yield(context, valueInYield, RubyObject.this, context.getRubyClass(), aValue); - //TODO: Should next and return also catch here? - } catch (JumpException.BreakJump bj) { - return (IRubyObject) bj.getValue(); - } finally { - block.getBinding().setVisibility(savedVisibility); - - context.postExecuteUnder(); - } - } - - /** - * Will yield to the specific block changing the self to be the - * current object instead of the self that is part of the frame - * saved in the block frame. This method is the basis for the Ruby - * instance_eval and module_eval methods. The arguments sent in to - * it in the args array will be yielded to the block. This makes - * it possible to emulate both instance_eval and instance_exec - * with this implementation. - */ - private IRubyObject yieldUnder(final ThreadContext context, RubyModule under, Block block) { - context.preExecuteUnder(under, block); - - Visibility savedVisibility = block.getBinding().getVisibility(); - block.getBinding().setVisibility(Visibility.PUBLIC); - - try { - // FIXME: This is an ugly hack to resolve JRUBY-1381; I'm not proud of it - block = block.cloneBlock(); - block.getBinding().setSelf(RubyObject.this); - block.getBinding().getFrame().setSelf(RubyObject.this); - // end hack - - return block.yield(context, this, this, context.getRubyClass(), false); - //TODO: Should next and return also catch here? - } catch (JumpException.BreakJump bj) { - return (IRubyObject) bj.getValue(); - } finally { - block.getBinding().setVisibility(savedVisibility); - - context.postExecuteUnder(); - } - } - - // Methods of the Object class (rb_obj_*): - - /** rb_obj_equal - * - * Will by default use identity equality to compare objects. This - * follows the Ruby semantics. - */ - @JRubyMethod(name = "==", required = 1) - public IRubyObject op_equal(ThreadContext context, IRubyObject obj) { - return this == obj ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - /** rb_obj_equal - * - * Will use Java identity equality. - */ - @JRubyMethod(name = "equal?", required = 1) - public IRubyObject equal_p(ThreadContext context, IRubyObject obj) { - return this == obj ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - /** method used for Hash key comparison (specialized for String, Symbol and Fixnum) - * - * Will by default just call the Ruby method "eql?" - */ - public boolean eql(IRubyObject other) { - return callMethod(getRuntime().getCurrentContext(), MethodIndex.EQL_P, "eql?", other).isTrue(); - } - - /** rb_obj_equal - * - * Just like "==" and "equal?", "eql?" will use identity equality for Object. - */ - @JRubyMethod(name = "eql?", required = 1) - public IRubyObject eql_p(IRubyObject obj) { - return this == obj ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - /** rb_equal - * - * The Ruby "===" method is used by default in case/when - * statements. The Object implementation first checks Java identity - * equality and then calls the "==" method too. - */ - @JRubyMethod(name = "===", required = 1) - public IRubyObject op_eqq(ThreadContext context, IRubyObject other) { - return context.getRuntime().newBoolean(equalInternal(context, this, other)); - } - - /** - * Helper method for checking equality, first using Java identity - * equality, and then calling the "==" method. - */ - protected static boolean equalInternal(final ThreadContext context, final IRubyObject that, final IRubyObject other){ - return that == other || that.callMethod(context, MethodIndex.EQUALEQUAL, "==", other).isTrue(); - } - - /** - * Helper method for checking equality, first using Java identity - * equality, and then calling the "eql?" method. - */ - protected static boolean eqlInternal(final ThreadContext context, final IRubyObject that, final IRubyObject other){ - return that == other || that.callMethod(context, MethodIndex.EQL_P, "eql?", other).isTrue(); - } - - /** rb_obj_init_copy - * - * Initializes this object as a copy of the original, that is the - * parameter to this object. Will make sure that the argument - * actually has the same real class as this object. It shouldn't - * be possible to initialize an object with something totally - * different. - */ - @JRubyMethod(name = "initialize_copy", required = 1, visibility = Visibility.PRIVATE) - public IRubyObject initialize_copy(IRubyObject original) { - if (this == original) return this; - checkFrozen(); - - if (getMetaClass().getRealClass() != original.getMetaClass().getRealClass()) { - throw getRuntime().newTypeError("initialize_copy should take same class object"); - } - - return this; - } - - /** obj_respond_to - * - * respond_to?( aSymbol, includePriv=false ) -> true or false - * - * Returns true if this object responds to the given method. Private - * methods are included in the search only if the optional second - * parameter evaluates to true. - * - * @return true if this responds to the given method - * - * !!! For some reason MRI shows the arity of respond_to? as -1, when it should be -2; that's why this is rest instead of required, optional = 1 - * - * Going back to splitting according to method arity. MRI is wrong - * about most of these anyway, and since we have arity splitting - * in both the compiler and the interpreter, the performance - * benefit is important for this method. - */ - @JRubyMethod(name = "respond_to?") - public RubyBoolean respond_to_p(IRubyObject mname) { - String name = mname.asJavaString(); - return getRuntime().newBoolean(getMetaClass().isMethodBound(name, true)); - } - - /** obj_respond_to - * - * respond_to?( aSymbol, includePriv=false ) -> true or false - * - * Returns true if this object responds to the given method. Private - * methods are included in the search only if the optional second - * parameter evaluates to true. - * - * @return true if this responds to the given method - * - * !!! For some reason MRI shows the arity of respond_to? as -1, when it should be -2; that's why this is rest instead of required, optional = 1 - * - * Going back to splitting according to method arity. MRI is wrong - * about most of these anyway, and since we have arity splitting - * in both the compiler and the interpreter, the performance - * benefit is important for this method. - */ - @JRubyMethod(name = "respond_to?") - public RubyBoolean respond_to_p(IRubyObject mname, IRubyObject includePrivate) { - String name = mname.asJavaString(); - return getRuntime().newBoolean(getMetaClass().isMethodBound(name, !includePrivate.isTrue())); - } - - /** rb_obj_id - * - * Return the internal id of an object. - * - * FIXME: Should this be renamed to match its ruby name? - */ - @JRubyMethod(name = {"object_id", "__id__"}) - public synchronized IRubyObject id() { - return getRuntime().newFixnum(getRuntime().getObjectSpace().idOf(this)); - } - - /** rb_obj_id_obsolete - * - * Old id version. This one is bound to the "id" name and will emit a deprecation warning. - */ - @JRubyMethod(name = "id") - public synchronized IRubyObject id_deprecated() { - getRuntime().getWarnings().warn(ID.DEPRECATED_METHOD, "Object#id will be deprecated; use Object#object_id", "Object#id", "Object#object_id"); - return id(); - } - - /** rb_obj_id - * - * Will return the hash code of this object. In comparison to MRI, - * this method will use the Java identity hash code instead of - * using rb_obj_id, since the usage of id in JRuby will incur the - * cost of some. ObjectSpace maintenance. - */ - @JRubyMethod(name = "hash") - public RubyFixnum hash() { - return getRuntime().newFixnum(super.hashCode()); - } - - /** - * Override the Object#hashCode method to make sure that the Ruby - * hash is actually used as the hashcode for Ruby objects. If the - * Ruby "hash" method doesn't return a number, the Object#hashCode - * implementation will be used instead. - */ - @Override - public int hashCode() { - IRubyObject hashValue = callMethod(getRuntime().getCurrentContext(), MethodIndex.HASH, "hash"); - - if (hashValue instanceof RubyFixnum) return (int) RubyNumeric.fix2long(hashValue); - - return super.hashCode(); - } - - /** rb_obj_class - * - * Returns the real class of this object, excluding any - * singleton/meta class in the inheritance chain. - */ - @JRubyMethod(name = "class") - public RubyClass type() { - return getMetaClass().getRealClass(); - } - - /** rb_obj_type - * - * The deprecated version of type, that emits a deprecation - * warning. - */ - @JRubyMethod(name = "type") - public RubyClass type_deprecated() { - getRuntime().getWarnings().warn(ID.DEPRECATED_METHOD, "Object#type is deprecated; use Object#class", "Object#type", "Object#class"); - return type(); - } - - /** rb_obj_clone - * - * This method should be overridden only by: Proc, Method, - * UnboundedMethod, Binding. It will use the defined allocated of - * the object, then clone the singleton class, taint the object, - * call initCopy and then copy frozen state. - */ - @JRubyMethod(name = "clone", frame = true) - public IRubyObject rbClone() { - if (isImmediate()) throw getRuntime().newTypeError("can't clone " + getMetaClass().getName()); - - // We're cloning ourselves, so we know the result should be a RubyObject - RubyObject clone = (RubyObject)getMetaClass().getRealClass().allocate(); - clone.setMetaClass(getSingletonClassClone()); - if (isTaint()) clone.setTaint(true); - - initCopy(clone, this); - - if (isFrozen()) clone.setFrozen(true); - return clone; - } - - /** rb_obj_dup - * - * This method should be overridden only by: Proc - * - * Will allocate a new instance of the real class of this object, - * and then initialize that copy. It's different from {@link - * #rbClone} in that it doesn't copy the singleton class. - */ - @JRubyMethod(name = "dup") - public IRubyObject dup() { - if (isImmediate()) throw getRuntime().newTypeError("can't dup " + getMetaClass().getName()); - - IRubyObject dup = getMetaClass().getRealClass().allocate(); - if (isTaint()) dup.setTaint(true); - - initCopy(dup, this); - - return dup; - } - - /** - * Lots of MRI objects keep their state in non-lookupable ivars - * (e:g. Range, Struct, etc). This method is responsible for - * dupping our java field equivalents - */ - protected void copySpecialInstanceVariables(IRubyObject clone) { - } - - /** rb_obj_display - * - * call-seq: - * obj.display(port=$>) => nil - * - * Prints <i>obj</i> on the given port (default <code>$></code>). - * Equivalent to: - * - * def display(port=$>) - * port.write self - * end - * - * For example: - * - * 1.display - * "cat".display - * [ 4, 5, 6 ].display - * puts - * - * <em>produces:</em> - * - * 1cat456 - * - */ - @JRubyMethod(name = "display", optional = 1) - public IRubyObject display(ThreadContext context, IRubyObject[] args) { - IRubyObject port = args.length == 0 ? context.getRuntime().getGlobalVariables().get("$>") : args[0]; - - port.callMethod(context, "write", this); - - return context.getRuntime().getNil(); - } - - /** rb_obj_tainted - * - * call-seq: - * obj.tainted? => true or false - * - * Returns <code>true</code> if the object is tainted. - * - */ - @JRubyMethod(name = "tainted?") - public RubyBoolean tainted_p(ThreadContext context) { - return context.getRuntime().newBoolean(isTaint()); - } - - /** rb_obj_taint - * - * call-seq: - * obj.taint -> obj - * - * Marks <i>obj</i> as tainted---if the <code>$SAFE</code> level is - * set appropriately, many method calls which might alter the running - * programs environment will refuse to accept tainted strings. - */ - @JRubyMethod(name = "taint") - public IRubyObject taint(ThreadContext context) { - taint(context.getRuntime()); - return this; - } - - private void taint(Ruby runtime) { - runtime.secure(4); - if (!isTaint()) { - testFrozen("object"); - setTaint(true); - } - } - - /** rb_obj_untaint - * - * call-seq: - * obj.untaint => obj - * - * Removes the taint from <i>obj</i>. - * - * Only callable in if more secure than 3. - */ - @JRubyMethod(name = "untaint") - public IRubyObject untaint(ThreadContext context) { - context.getRuntime().secure(3); - - if (isTaint()) { - testFrozen("object"); - setTaint(false); - } - - return this; - } - - /** rb_obj_freeze - * - * call-seq: - * obj.freeze => obj - * - * Prevents further modifications to <i>obj</i>. A - * <code>TypeError</code> will be raised if modification is attempted. - * There is no way to unfreeze a frozen object. See also - * <code>Object#frozen?</code>. - * - * a = [ "a", "b", "c" ] - * a.freeze - * a << "z" - * - * <em>produces:</em> - * - * prog.rb:3:in `<<': can't modify frozen array (TypeError) - * from prog.rb:3 - */ - @JRubyMethod(name = "freeze") - public IRubyObject freeze(ThreadContext context) { - if ((flags & FROZEN_F) == 0) { - if (context.getRuntime().getSafeLevel() >= 4 && isTaint()) { - throw context.getRuntime().newSecurityError("Insecure: can't freeze object"); - } - flags |= FROZEN_F; - } - return this; - } - - /** rb_obj_frozen_p - * - * call-seq: - * obj.frozen? => true or false - * - * Returns the freeze status of <i>obj</i>. - * - * a = [ "a", "b", "c" ] - * a.freeze #=> ["a", "b", "c"] - * a.frozen? #=> true - */ - @JRubyMethod(name = "frozen?") - public RubyBoolean frozen_p(ThreadContext context) { - return context.getRuntime().newBoolean(isFrozen()); - } - - /** inspect_obj - * - * The internal helper method that takes care of the part of the - * inspection that inspects instance variables. - */ - private StringBuilder inspectObj(StringBuilder part) { - ThreadContext context = getRuntime().getCurrentContext(); - String sep = ""; - - for (Variable<IRubyObject> ivar : getInstanceVariableList()) { - part.append(sep).append(" ").append(ivar.getName()).append("="); - part.append(ivar.getValue().callMethod(context, "inspect")); - sep = ","; - } - part.append(">"); - return part; - } - - /** rb_inspect - * - * The internal helper that ensures a RubyString instance is returned - * so dangerous casting can be omitted - * Prefered over callMethod(context, "inspect") - */ - static RubyString inspect(ThreadContext context, IRubyObject object) { - return RubyString.objAsString(context, object.callMethod(context, "inspect")); - } - - /** rb_obj_inspect - * - * call-seq: - * obj.inspect => string - * - * Returns a string containing a human-readable representation of - * <i>obj</i>. If not overridden, uses the <code>to_s</code> method to - * generate the string. - * - * [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]" - * Time.new.inspect #=> "Wed Apr 09 08:54:39 CDT 2003" - */ - @JRubyMethod(name = "inspect") - public IRubyObject inspect() { - Ruby runtime = getRuntime(); - if ((!isImmediate()) && - // TYPE(obj) == T_OBJECT - !(this instanceof RubyClass) && - this != runtime.getObject() && - this != runtime.getModule() && - !(this instanceof RubyModule) && - // TODO: should have #hasInstanceVariables method, though - // this will work here: - hasVariables()) { - - StringBuilder part = new StringBuilder(); - String cname = getMetaClass().getRealClass().getName(); - part.append("#<").append(cname).append(":0x"); - part.append(Integer.toHexString(System.identityHashCode(this))); - - if (runtime.isInspecting(this)) { - /* 6:tags 16:addr 1:eos */ - part.append(" ...>"); - return runtime.newString(part.toString()); - } - try { - runtime.registerInspecting(this); - return runtime.newString(inspectObj(part).toString()); - } finally { - runtime.unregisterInspecting(this); - } - } - - if (isNil()) return RubyNil.inspect(this); - return RuntimeHelpers.invoke(runtime.getCurrentContext(), this, "to_s"); - } - - /** rb_obj_is_instance_of - * - * call-seq: - * obj.instance_of?(class) => true or false - * - * Returns <code>true</code> if <i>obj</i> is an instance of the given - * class. See also <code>Object#kind_of?</code>. - */ - @JRubyMethod(name = "instance_of?", required = 1) - public RubyBoolean instance_of_p(ThreadContext context, IRubyObject type) { - if (type() == type) { - return context.getRuntime().getTrue(); - } else if (!(type instanceof RubyModule)) { - throw context.getRuntime().newTypeError("class or module required"); - } else { - return context.getRuntime().getFalse(); - } - } - - - /** rb_obj_is_kind_of - * - * call-seq: - * obj.is_a?(class) => true or false - * obj.kind_of?(class) => true or false - * - * Returns <code>true</code> if <i>class</i> is the class of - * <i>obj</i>, or if <i>class</i> is one of the superclasses of - * <i>obj</i> or modules included in <i>obj</i>. - * - * module M; end - * class A - * include M - * end - * class B < A; end - * class C < B; end - * b = B.new - * b.instance_of? A #=> false - * b.instance_of? B #=> true - * b.instance_of? C #=> false - * b.instance_of? M #=> false - * b.kind_of? A #=> true - * b.kind_of? B #=> true - * b.kind_of? C #=> false - * b.kind_of? M #=> true - */ - @JRubyMethod(name = {"kind_of?", "is_a?"}, required = 1) - public RubyBoolean kind_of_p(ThreadContext context, IRubyObject type) { - // TODO: Generalize this type-checking code into IRubyObject helper. - if (!(type instanceof RubyModule)) { - // TODO: newTypeError does not offer enough for ruby error string... - throw context.getRuntime().newTypeError("class or module required"); - } - - return context.getRuntime().newBoolean(((RubyModule)type).isInstance(this)); - } - - /** rb_obj_methods - * - * call-seq: - * obj.methods => array - * - * Returns a list of the names of methods publicly accessible in - * <i>obj</i>. This will include all the methods accessible in - * <i>obj</i>'s ancestors. - * - * class Klass - * def kMethod() - * end - * end - * k = Klass.new - * k.methods[0..9] #=> ["kMethod", "freeze", "nil?", "is_a?", - * "class", "instance_variable_set", - * "methods", "extend", "__send__", "instance_eval"] - * k.methods.length #=> 42 - */ - @JRubyMethod(name = "methods", optional = 1) - public IRubyObject methods(ThreadContext context, IRubyObject[] args) { - boolean all = true; - if (args.length == 1) { - all = args[0].isTrue(); - } - - RubyArray singletonMethods = null; - if (getMetaClass().isSingleton()) { - singletonMethods = - getMetaClass().instance_methods(new IRubyObject[] {context.getRuntime().getFalse()}); - if (all) { - singletonMethods.concat(getMetaClass().getSuperClass().instance_methods(new IRubyObject[] {context.getRuntime().getTrue()})); - } - } else { - if (all) { - singletonMethods = getMetaClass().instance_methods(new IRubyObject[] {context.getRuntime().getTrue()}); - } else { - singletonMethods = context.getRuntime().newEmptyArray(); - } - } - - return singletonMethods; - } - - /** rb_obj_public_methods - * - * call-seq: - * obj.public_methods(all=true) => array - * - * Returns the list of public methods accessible to <i>obj</i>. If - * the <i>all</i> parameter is set to <code>false</code>, only those methods - * in the receiver will be listed. - */ - @JRubyMethod(name = "public_methods", optional = 1) - public IRubyObject public_methods(ThreadContext context, IRubyObject[] args) { - if (args.length == 0) { - args = new IRubyObject[] { context.getRuntime().getTrue() }; - } - - return getMetaClass().public_instance_methods(args); - } - - /** rb_obj_protected_methods - * - * call-seq: - * obj.protected_methods(all=true) => array - * - * Returns the list of protected methods accessible to <i>obj</i>. If - * the <i>all</i> parameter is set to <code>false</code>, only those methods - * in the receiver will be listed. - * - * Internally this implementation uses the - * {@link RubyModule#protected_instance_methods} method. - */ - @JRubyMethod(name = "protected_methods", optional = 1) - public IRubyObject protected_methods(ThreadContext context, IRubyObject[] args) { - if (args.length == 0) { - args = new IRubyObject[] { context.getRuntime().getTrue() }; - } - - return getMetaClass().protected_instance_methods(args); - } - - /** rb_obj_private_methods - * - * call-seq: - * obj.private_methods(all=true) => array - * - * Returns the list of private methods accessible to <i>obj</i>. If - * the <i>all</i> parameter is set to <code>false</code>, only those methods - * in the receiver will be listed. - * - * Internally this implementation uses the - * {@link RubyModule#private_instance_methods} method. - */ - @JRubyMethod(name = "private_methods", optional = 1) - public IRubyObject private_methods(ThreadContext context, IRubyObject[] args) { - if (args.length == 0) { - args = new IRubyObject[] { context.getRuntime().getTrue() }; - } - - return getMetaClass().private_instance_methods(args); - } - - /** rb_obj_singleton_methods - * - * call-seq: - * obj.singleton_methods(all=true) => array - * - * Returns an array of the names of singleton methods for <i>obj</i>. - * If the optional <i>all</i> parameter is true, the list will include - * methods in modules included in <i>obj</i>. - * - * module Other - * def three() end - * end - * - * class Single - * def Single.four() end - * end - * - * a = Single.new - * - * def a.one() - * end - * - * class << a - * include Other - * def two() - * end - * end - * - * Single.singleton_methods #=> ["four"] - * a.singleton_methods(false) #=> ["two", "one"] - * a.singleton_methods #=> ["two", "one", "three"] - */ - // TODO: This is almost RubyModule#instance_methods on the metaClass. Perhaps refactor. - @JRubyMethod(name = "singleton_methods", optional = 1) - public RubyArray singleton_methods(ThreadContext context, IRubyObject[] args) { - boolean all = true; - if(args.length == 1) { - all = args[0].isTrue(); - } - - RubyArray singletonMethods; - if (getMetaClass().isSingleton()) { - singletonMethods = getMetaClass().instance_methods(new IRubyObject[] {context.getRuntime().getFalse()}); - if (all) { - RubyClass superClass = getMetaClass().getSuperClass(); - while (superClass.isIncluded()) { - singletonMethods.concat(superClass.instance_methods(new IRubyObject[] {context.getRuntime().getFalse()})); - superClass = superClass.getSuperClass(); - } - } - } else { - singletonMethods = context.getRuntime().newEmptyArray(); - } - - return singletonMethods; - } - - /** rb_obj_method - * - * call-seq: - * obj.method(sym) => method - * - * Looks up the named method as a receiver in <i>obj</i>, returning a - * <code>Method</code> object (or raising <code>NameError</code>). The - * <code>Method</code> object acts as a closure in <i>obj</i>'s object - * instance, so instance variables and the value of <code>self</code> - * remain available. - * - * class Demo - * def initialize(n) - * @iv = n - * end - * def hello() - * "Hello, @iv = #{@iv}" - * end - * end - * - * k = Demo.new(99) - * m = k.method(:hello) - * m.call #=> "Hello, @iv = 99" - * - * l = Demo.new('Fred') - * m = l.method("hello") - * m.call #=> "Hello, @iv = Fred" - */ - @JRubyMethod(name = "method", required = 1) - public IRubyObject method(IRubyObject symbol) { - return getMetaClass().newMethod(this, symbol.asJavaString(), true); - } - - /** - * Internal method that helps to convert any object into the - * format of a class name and a hex string inside of #<>. - */ - public IRubyObject anyToString() { - String cname = getMetaClass().getRealClass().getName(); - /* 6:tags 16:addr 1:eos */ - RubyString str = getRuntime().newString("#<" + cname + ":0x" + Integer.toHexString(System.identityHashCode(this)) + ">"); - str.setTaint(isTaint()); - return str; - } - - /** rb_any_to_s - * - * call-seq: - * obj.to_s => string - * - * Returns a string representing <i>obj</i>. The default - * <code>to_s</code> prints the object's class and an encoding of the - * object id. As a special case, the top-level object that is the - * initial execution context of Ruby programs returns ``main.'' - */ - @JRubyMethod(name = "to_s") - public IRubyObject to_s() { - return anyToString(); - } - - /** rb_any_to_a - * - * call-seq: - * obj.to_a -> anArray - * - * Returns an array representation of <i>obj</i>. For objects of class - * <code>Object</code> and others that don't explicitly override the - * method, the return value is an array containing <code>self</code>. - * However, this latter behavior will soon be obsolete. - * - * self.to_a #=> -:1: warning: default `to_a' will be obsolete - * "hello".to_a #=> ["hello"] - * Time.new.to_a #=> [39, 54, 8, 9, 4, 2003, 3, 99, true, "CDT"] - * - * The default to_a method is deprecated. - */ - @JRubyMethod(name = "to_a", visibility = Visibility.PUBLIC) - public RubyArray to_a() { - getRuntime().getWarnings().warn(ID.DEPRECATED_METHOD, "default 'to_a' will be obsolete", "to_a"); - return getRuntime().newArray(this); - } - - /** rb_obj_instance_eval - * - * call-seq: - * obj.instance_eval(string [, filename [, lineno]] ) => obj - * obj.instance_eval {| | block } => obj - * - * Evaluates a string containing Ruby source code, or the given block, - * within the context of the receiver (_obj_). In order to set the - * context, the variable +self+ is set to _obj_ while - * the code is executing, giving the code access to _obj_'s - * instance variables. In the version of <code>instance_eval</code> - * that takes a +String+, the optional second and third - * parameters supply a filename and starting line number that are used - * when reporting compilation errors. - * - * class Klass - * def initialize - * @secret = 99 - * end - * end - * k = Klass.new - * k.instance_eval { @secret } #=> 99 - */ - @JRubyMethod(name = "instance_eval", frame = true) - public IRubyObject instance_eval(ThreadContext context, Block block) { - return specificEval(context, getInstanceEvalClass(), block); - } - @JRubyMethod(name = "instance_eval", frame = true) - public IRubyObject instance_eval(ThreadContext context, IRubyObject arg0, Block block) { - return specificEval(context, getInstanceEvalClass(), arg0, block); - } - @JRubyMethod(name = "instance_eval", frame = true) - public IRubyObject instance_eval(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - return specificEval(context, getInstanceEvalClass(), arg0, arg1, block); - } - @JRubyMethod(name = "instance_eval", frame = true) - public IRubyObject instance_eval(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) { - return specificEval(context, getInstanceEvalClass(), arg0, arg1, arg2, block); - } - @Deprecated - public IRubyObject instance_eval(ThreadContext context, IRubyObject[] args, Block block) { - RubyModule klazz; - - if (isImmediate()) { - // Ruby uses Qnil here, we use "dummy" because we need a class - klazz = context.getRuntime().getDummy(); - } else { - klazz = getSingletonClass(); - } - - return specificEval(context, klazz, args, block); - } - - private RubyModule getInstanceEvalClass() { - if (isImmediate()) { - // Ruby uses Qnil here, we use "dummy" because we need a class - return getRuntime().getDummy(); - } else { - return getSingletonClass(); - } - } - - /** rb_obj_instance_exec - * - * call-seq: - * obj.instance_exec(arg...) {|var...| block } => obj - * - * Executes the given block within the context of the receiver - * (_obj_). In order to set the context, the variable +self+ is set - * to _obj_ while the code is executing, giving the code access to - * _obj_'s instance variables. Arguments are passed as block parameters. - * - * class Klass - * def initialize - * @secret = 99 - * end - * end - * k = Klass.new - * k.instance_exec(5) {|x| @secret+x } #=> 104 - */ - @JRubyMethod(name = "instance_exec", optional = 3, frame = true) - public IRubyObject instance_exec(ThreadContext context, IRubyObject[] args, Block block) { - if (!block.isGiven()) throw context.getRuntime().newArgumentError("block not supplied"); - - RubyModule klazz; - if (isImmediate()) { - // Ruby uses Qnil here, we use "dummy" because we need a class - klazz = context.getRuntime().getDummy(); - } else { - klazz = getSingletonClass(); - } - - return yieldUnder(context, klazz, args, block); - } - - /** rb_obj_extend - * - * call-seq: - * obj.extend(module, ...) => obj - * - * Adds to _obj_ the instance methods from each module given as a - * parameter. - * - * module Mod - * def hello - * "Hello from Mod.\n" - * end - * end - * - * class Klass - * def hello - * "Hello from Klass.\n" - * end - * end - * - * k = Klass.new - * k.hello #=> "Hello from Klass.\n" - * k.extend(Mod) #=> #<Klass:0x401b3bc8> - * k.hello #=> "Hello from Mod.\n" - */ - @JRubyMethod(name = "extend", required = 1, rest = true) - public IRubyObject extend(IRubyObject[] args) { - Ruby runtime = getRuntime(); - - // Make sure all arguments are modules before calling the callbacks - for (int i = 0; i < args.length; i++) { - if (!args[i].isModule()) throw runtime.newTypeError(args[i], runtime.getModule()); - } - - ThreadContext context = runtime.getCurrentContext(); - - // MRI extends in order from last to first - for (int i = args.length - 1; i >= 0; i--) { - args[i].callMethod(context, "extend_object", this); - args[i].callMethod(context, "extended", this); - } - return this; - } - - /** rb_obj_dummy - * - * Default initialize method. This one gets defined in some other - * place as a Ruby method. - */ - public IRubyObject initialize() { - return getRuntime().getNil(); - } - - /** rb_f_send - * - * send( aSymbol [, args ]* ) -> anObject - * - * Invokes the method identified by aSymbol, passing it any arguments - * specified. You can use __send__ if the name send clashes with an - * existing method in this object. - * - * <pre> - * class Klass - * def hello(*args) - * "Hello " + args.join(' ') - * end - * end - * - * k = Klass.new - * k.send :hello, "gentle", "readers" - * </pre> - * - * @return the result of invoking the method identified by aSymbol. - */ - @JRubyMethod(name = {"send", "__send__"}) - public IRubyObject send(ThreadContext context, Block block) { - throw context.getRuntime().newArgumentError(0, 1); - } - @JRubyMethod(name = {"send", "__send__"}) - public IRubyObject send(ThreadContext context, IRubyObject arg0, Block block) { - String name = arg0.asJavaString(); - - return getMetaClass().finvoke(context, this, name, block); - } - @JRubyMethod(name = {"send", "__send__"}) - public IRubyObject send(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - String name = arg0.asJavaString(); - - return getMetaClass().finvoke(context, this, name, arg1, block); - } - @JRubyMethod(name = {"send", "__send__"}) - public IRubyObject send(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2, Block block) { - String name = arg0.asJavaString(); - - return getMetaClass().finvoke(context, this, name, arg1, arg2, block); - } - @JRubyMethod(name = {"send", "__send__"}, rest = true) - public IRubyObject send(ThreadContext context, IRubyObject[] args, Block block) { - String name = args[0].asJavaString(); - int newArgsLength = args.length - 1; - - IRubyObject[] newArgs; - if (newArgsLength == 0) { - newArgs = IRubyObject.NULL_ARRAY; - } else { - newArgs = new IRubyObject[newArgsLength]; - System.arraycopy(args, 1, newArgs, 0, newArgs.length); - } - - return getMetaClass().finvoke(context, this, name, newArgs, block); - } - - /** rb_false - * - * call_seq: - * nil.nil? => true - * <anything_else>.nil? => false - * - * Only the object <i>nil</i> responds <code>true</code> to <code>nil?</code>. - */ - @JRubyMethod(name = "nil?") - public IRubyObject nil_p(ThreadContext context) { - return context.getRuntime().getFalse(); - } - - /** rb_obj_pattern_match - * - * call-seq: - * obj =~ other => false - * - * Pattern Match---Overridden by descendents (notably - * <code>Regexp</code> and <code>String</code>) to provide meaningful - * pattern-match semantics. - */ - @JRubyMethod(name = "=~", required = 1) - public IRubyObject op_match(ThreadContext context, IRubyObject arg) { - return context.getRuntime().getFalse(); - } - - public IRubyObject to_java() { - throw getRuntime().newTypeError(getMetaClass().getBaseName() + " cannot coerce to a Java type."); - } - - public IRubyObject as(Class javaClass) { - throw getRuntime().newTypeError(getMetaClass().getBaseName() + " cannot coerce to a Java type."); - } - - /** - * @see org.jruby.runtime.builtin.IRubyObject#getType() - */ - public RubyClass getType() { - return type(); - } - - /** - * @see org.jruby.runtime.builtin.IRubyObject#dataWrapStruct() - */ - public synchronized void dataWrapStruct(Object obj) { - this.dataStruct = obj; - } - - /** - * @see org.jruby.runtime.builtin.IRubyObject#dataGetStruct() - */ - public synchronized Object dataGetStruct() { - return dataStruct; - } - - /** - * Adds the specified object as a finalizer for this object. - */ - public void addFinalizer(IRubyObject finalizer) { - if (this.finalizer == null) { - this.finalizer = new Finalizer(getRuntime().getObjectSpace().idOf(this)); - getRuntime().addFinalizer(this.finalizer); - } - this.finalizer.addFinalizer(finalizer); - } - - /** - * Remove all the finalizers for this object. - */ - public void removeFinalizers() { - if (finalizer != null) { - finalizer.removeFinalizers(); - finalizer = null; - getRuntime().removeFinalizer(this.finalizer); - } - } - - - // - // INSTANCE VARIABLE RUBY METHODS - // - - /** rb_obj_ivar_defined - * - * call-seq: - * obj.instance_variable_defined?(symbol) => true or false - * - * Returns <code>true</code> if the given instance variable is - * defined in <i>obj</i>. - * - * class Fred - * def initialize(p1, p2) - * @a, @b = p1, p2 - * end - * end - * fred = Fred.new('cat', 99) - * fred.instance_variable_defined?(:@a) #=> true - * fred.instance_variable_defined?("@b") #=> true - * fred.instance_variable_defined?("@c") #=> false - */ - @JRubyMethod(name = "instance_variable_defined?", required = 1) - public IRubyObject instance_variable_defined_p(ThreadContext context, IRubyObject name) { - if (variableTableContains(validateInstanceVariable(name.asJavaString()))) { - return context.getRuntime().getTrue(); - } - return context.getRuntime().getFalse(); - } - - /** rb_obj_ivar_get - * - * call-seq: - * obj.instance_variable_get(symbol) => obj - * - * Returns the value of the given instance variable, or nil if the - * instance variable is not set. The <code>@</code> part of the - * variable name should be included for regular instance - * variables. Throws a <code>NameError</code> exception if the - * supplied symbol is not valid as an instance variable name. - * - * class Fred - * def initialize(p1, p2) - * @a, @b = p1, p2 - * end - * end - * fred = Fred.new('cat', 99) - * fred.instance_variable_get(:@a) #=> "cat" - * fred.instance_variable_get("@b") #=> 99 - */ - @JRubyMethod(name = "instance_variable_get", required = 1) - public IRubyObject instance_variable_get(ThreadContext context, IRubyObject name) { - IRubyObject value; - if ((value = variableTableFetch(validateInstanceVariable(name.asJavaString()))) != null) { - return value; - } - return context.getRuntime().getNil(); - } - - /** rb_obj_ivar_set - * - * call-seq: - * obj.instance_variable_set(symbol, obj) => obj - * - * Sets the instance variable names by <i>symbol</i> to - * <i>object</i>, thereby frustrating the efforts of the class's - * author to attempt to provide proper encapsulation. The variable - * did not have to exist prior to this call. - * - * class Fred - * def initialize(p1, p2) - * @a, @b = p1, p2 - * end - * end - * fred = Fred.new('cat', 99) - * fred.instance_variable_set(:@a, 'dog') #=> "dog" - * fred.instance_variable_set(:@c, 'cat') #=> "cat" - * fred.inspect #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">" - */ - @JRubyMethod(name = "instance_variable_set", required = 2) - public IRubyObject instance_variable_set(IRubyObject name, IRubyObject value) { - ensureInstanceVariablesSettable(); - return variableTableStore(validateInstanceVariable(name.asJavaString()), value); - } - - /** rb_obj_remove_instance_variable - * - * call-seq: - * obj.remove_instance_variable(symbol) => obj - * - * Removes the named instance variable from <i>obj</i>, returning that - * variable's value. - * - * class Dummy - * attr_reader :var - * def initialize - * @var = 99 - * end - * def remove - * remove_instance_variable(:@var) - * end - * end - * d = Dummy.new - * d.var #=> 99 - * d.remove #=> 99 - * d.var #=> nil - */ - @JRubyMethod(name = "remove_instance_variable", required = 1, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject remove_instance_variable(ThreadContext context, IRubyObject name, Block block) { - ensureInstanceVariablesSettable(); - IRubyObject value; - if ((value = variableTableRemove(validateInstanceVariable(name.asJavaString()))) != null) { - return value; - } - throw context.getRuntime().newNameError("instance variable " + name.asJavaString() + " not defined", name.asJavaString()); - } - - /** rb_obj_instance_variables - * - * call-seq: - * obj.instance_variables => array - * - * Returns an array of instance variable names for the receiver. Note - * that simply defining an accessor does not create the corresponding - * instance variable. - * - * class Fred - * attr_accessor :a1 - * def initialize - * @iv = 3 - * end - * end - * Fred.new.instance_variables #=> ["@iv"] - */ - @JRubyMethod(name = "instance_variables") - public RubyArray instance_variables(ThreadContext context) { - Ruby runtime = context.getRuntime(); - List<String> nameList = getInstanceVariableNameList(); - - RubyArray array = runtime.newArray(nameList.size()); - - for (String name : nameList) { - array.append(runtime.newString(name)); - } - - return array; - } - - // - // INSTANCE VARIABLE API METHODS - // - - /** - * Dummy method to avoid a cast, and to avoid polluting the - * IRubyObject interface with all the instance variable management - * methods. - */ - public InstanceVariables getInstanceVariables() { - return this; - } - - /** - * @see org.jruby.runtime.builtin.InstanceVariables#hasInstanceVariable - */ - public boolean hasInstanceVariable(String name) { - assert IdUtil.isInstanceVariable(name); - return variableTableContains(name); - } - - /** - * @see org.jruby.runtime.builtin.InstanceVariables#fastHasInstanceVariable - */ - public boolean fastHasInstanceVariable(String internedName) { - assert IdUtil.isInstanceVariable(internedName); - return variableTableFastContains(internedName); - } - - /** - * @see org.jruby.runtime.builtin.InstanceVariables#getInstanceVariable - */ - public IRubyObject getInstanceVariable(String name) { - assert IdUtil.isInstanceVariable(name); - return variableTableFetch(name); - } - - /** - * @see org.jruby.runtime.builtin.InstanceVariables#fastGetInstanceVariable - */ - public IRubyObject fastGetInstanceVariable(String internedName) { - assert IdUtil.isInstanceVariable(internedName); - return variableTableFastFetch(internedName); - } - - /** rb_iv_set / rb_ivar_set - * - * @see org.jruby.runtime.builtin.InstanceVariables#setInstanceVariable - */ - public IRubyObject setInstanceVariable(String name, IRubyObject value) { - assert IdUtil.isInstanceVariable(name) && value != null; - ensureInstanceVariablesSettable(); - return variableTableStore(name, value); - } - - /** - * @see org.jruby.runtime.builtin.InstanceVariables#fastSetInstanceVariable - */ - public IRubyObject fastSetInstanceVariable(String internedName, IRubyObject value) { - assert IdUtil.isInstanceVariable(internedName) && value != null; - ensureInstanceVariablesSettable(); - return variableTableFastStore(internedName, value); - } - - /** - * @see org.jruby.runtime.builtin.InstanceVariables#removeInstanceVariable - */ - public IRubyObject removeInstanceVariable(String name) { - assert IdUtil.isInstanceVariable(name); - ensureInstanceVariablesSettable(); - return variableTableRemove(name); - } - - /** - * @see org.jruby.runtime.builtin.InstanceVariables#getInstanceVariableList - */ - public List<Variable<IRubyObject>> getInstanceVariableList() { - VariableTableEntry[] table = variableTableGetTable(); - ArrayList<Variable<IRubyObject>> list = new ArrayList<Variable<IRubyObject>>(); - IRubyObject readValue; - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - if (IdUtil.isInstanceVariable(e.name)) { - if ((readValue = e.value) == null) readValue = variableTableReadLocked(e); - list.add(new VariableEntry<IRubyObject>(e.name, readValue)); - } - } - } - return list; - } - - /** - * @see org.jruby.runtime.builtin.InstanceVariables#getInstanceVariableNameList - */ - public List<String> getInstanceVariableNameList() { - VariableTableEntry[] table = variableTableGetTable(); - ArrayList<String> list = new ArrayList<String>(); - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - if (IdUtil.isInstanceVariable(e.name)) { - list.add(e.name); - } - } - } - return list; - } - - /** - * The error message used when some one tries to modify an - * instance variable in a high security setting. - */ - protected static final String ERR_INSECURE_SET_INST_VAR = "Insecure: can't modify instance variable"; - - /** - * Checks if the name parameter represents a legal instance variable name, and otherwise throws a Ruby NameError - */ - protected String validateInstanceVariable(String name) { - if (IdUtil.isValidInstanceVariableName(name)) return name; - - throw getRuntime().newNameError("`" + name + "' is not allowable as an instance variable name", name); - } - - /** - * Makes sure that instance variables can be set on this object, - * including information about whether this object is frozen, or - * tainted. Will throw a suitable exception in that case. - */ - protected void ensureInstanceVariablesSettable() { - if (!isFrozen() && (getRuntime().getSafeLevel() < 4 || isTaint())) { - return; - } - - if (getRuntime().getSafeLevel() >= 4 && !isTaint()) { - throw getRuntime().newSecurityError(ERR_INSECURE_SET_INST_VAR); - } - if (isFrozen()) { - if (this instanceof RubyModule) { - throw getRuntime().newFrozenError("class/module "); - } else { - throw getRuntime().newFrozenError(""); - } - } - } - - // - // INTERNAL VARIABLE METHODS - // - - /** - * Dummy method to avoid a cast, and to avoid polluting the - * IRubyObject interface with all the instance variable management - * methods. - */ - public InternalVariables getInternalVariables() { - return this; - } - - /** - * @see org.jruby.runtime.builtin.InternalVariables#hasInternalVariable - */ - public boolean hasInternalVariable(String name) { - assert !isRubyVariable(name); - return variableTableContains(name); - } - - /** - * @see org.jruby.runtime.builtin.InternalVariables#fastHasInternalVariable - */ - public boolean fastHasInternalVariable(String internedName) { - assert !isRubyVariable(internedName); - return variableTableFastContains(internedName); - } - - /** - * @see org.jruby.runtime.builtin.InternalVariables#getInternalVariable - */ - public IRubyObject getInternalVariable(String name) { - assert !isRubyVariable(name); - return variableTableFetch(name); - } - - /** - * @see org.jruby.runtime.builtin.InternalVariables#fastGetInternalVariable - */ - public IRubyObject fastGetInternalVariable(String internedName) { - assert !isRubyVariable(internedName); - return variableTableFastFetch(internedName); - } - - /** - * @see org.jruby.runtime.builtin.InternalVariables#setInternalVariable - */ - public void setInternalVariable(String name, IRubyObject value) { - assert !isRubyVariable(name); - variableTableStore(name, value); - } - - /** - * @see org.jruby.runtime.builtin.InternalVariables#fastSetInternalVariable - */ - public void fastSetInternalVariable(String internedName, IRubyObject value) { - assert !isRubyVariable(internedName); - variableTableFastStore(internedName, value); - } - - /** - * @see org.jruby.runtime.builtin.InternalVariables#removeInternalVariable - */ - public IRubyObject removeInternalVariable(String name) { - assert !isRubyVariable(name); - return variableTableRemove(name); - } - - /** - * Sync one variable table with another - this is used to make - * rbClone work correctly. - */ - public void syncVariables(List<Variable<IRubyObject>> variables) { - variableTableSync(variables); - } - - /** - * @see org.jruby.runtime.builtin.InternalVariables#getInternalVariableList - */ - public List<Variable<IRubyObject>> getInternalVariableList() { - VariableTableEntry[] table = variableTableGetTable(); - ArrayList<Variable<IRubyObject>> list = new ArrayList<Variable<IRubyObject>>(); - IRubyObject readValue; - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - if (!isRubyVariable(e.name)) { - if ((readValue = e.value) == null) readValue = variableTableReadLocked(e); - list.add(new VariableEntry<IRubyObject>(e.name, readValue)); - } - } - } - return list; - } - - - // - // COMMON VARIABLE METHODS - // - - /** - * Returns true if object has any variables, defined as: - * <ul> - * <li> instance variables - * <li> class variables - * <li> constants - * <li> internal variables, such as those used when marshaling Ranges and Exceptions - * </ul> - * @return true if object has any variables, else false - */ - public boolean hasVariables() { - return variableTableGetSize() > 0; - } - - /** - * Returns the amount of instance variables, class variables, - * constants and internal variables this object has. - */ - public int getVariableCount() { - return variableTableGetSize(); - } - - /** - * Gets a list of all variables in this object. - */ - // TODO: must override in RubyModule to pick up constants - public List<Variable<IRubyObject>> getVariableList() { - VariableTableEntry[] table = variableTableGetTable(); - ArrayList<Variable<IRubyObject>> list = new ArrayList<Variable<IRubyObject>>(); - IRubyObject readValue; - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - if ((readValue = e.value) == null) readValue = variableTableReadLocked(e); - list.add(new VariableEntry<IRubyObject>(e.name, readValue)); - } - } - return list; - } - - /** - * Gets a name list of all variables in this object. - */ - // TODO: must override in RubyModule to pick up constants - public List<String> getVariableNameList() { - VariableTableEntry[] table = variableTableGetTable(); - ArrayList<String> list = new ArrayList<String>(); - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - list.add(e.name); - } - } - return list; - } - - /** - * Gets internal access to the getmap for variables. - */ - @SuppressWarnings("unchecked") - @Deprecated // born deprecated - public Map getVariableMap() { - return variableTableGetMap(); - } - - /** - * Check the syntax of a Ruby variable, including that it's longer - * than zero characters, and starts with either an @ or a capital - * letter. - */ - // FIXME: this should go somewhere more generic -- maybe IdUtil - protected static final boolean isRubyVariable(String name) { - char c; - return name.length() > 0 && ((c = name.charAt(0)) == '@' || (c <= 'Z' && c >= 'A')); - } - - // - // VARIABLE TABLE METHODS, ETC. - // - - protected static final int VARIABLE_TABLE_DEFAULT_CAPACITY = 8; // MUST be power of 2! - protected static final int VARIABLE_TABLE_MAXIMUM_CAPACITY = 1 << 30; - protected static final float VARIABLE_TABLE_LOAD_FACTOR = 0.75f; - protected static final VariableTableEntry[] VARIABLE_TABLE_EMPTY_TABLE = new VariableTableEntry[0]; - - /** - * Every entry in the variable map is represented by an instance - * of this class. - */ - protected static final class VariableTableEntry { - final int hash; - final String name; - volatile IRubyObject value; - final VariableTableEntry next; - - VariableTableEntry(int hash, String name, IRubyObject value, VariableTableEntry next) { - assert name == name.intern() : name + " is not interned"; - this.hash = hash; - this.name = name; - this.value = value; - this.next = next; - } - } - - /** - * Reads the value of the specified entry, locked on the current - * object. - */ - protected synchronized IRubyObject variableTableReadLocked(VariableTableEntry entry) { - return entry.value; - } - - /** - * Checks if the variable table contains a variable of the - * specified name. - */ - protected boolean variableTableContains(String name) { - VariableTableEntry[] table; - if ((table = variableTable) != null) { - int hash = name.hashCode(); - for (VariableTableEntry e = table[hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - return true; - } - } - } - return false; - } - - /** - * Checks if the variable table contains the the variable of the - * specified name, where the precondition is that the name must be - * an interned Java String. - */ - protected boolean variableTableFastContains(String internedName) { - assert internedName == internedName.intern() : internedName + " not interned"; - VariableTableEntry[] table; - if ((table = variableTable) != null) { - for (VariableTableEntry e = table[internedName.hashCode() & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - return true; - } - } - } - return false; - } - - /** - * Fetch an object from the variable table based on the name. - * - * @return the object or null if not found - */ - protected IRubyObject variableTableFetch(String name) { - VariableTableEntry[] table; - IRubyObject readValue; - if ((table = variableTable) != null) { - int hash = name.hashCode(); - for (VariableTableEntry e = table[hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - if ((readValue = e.value) != null) return readValue; - return variableTableReadLocked(e); - } - } - } - return null; - } - - /** - * Fetch an object from the variable table based on the name, - * where the name must be an interned Java String. - * - * @return the object or null if not found - */ - protected IRubyObject variableTableFastFetch(String internedName) { - assert internedName == internedName.intern() : internedName + " not interned"; - VariableTableEntry[] table; - IRubyObject readValue; - if ((table = variableTable) != null) { - for (VariableTableEntry e = table[internedName.hashCode() & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - if ((readValue = e.value) != null) return readValue; - return variableTableReadLocked(e); - } - } - } - return null; - } - - /** - * Store a value in the variable store under the specific name. - */ - protected IRubyObject variableTableStore(String name, IRubyObject value) { - int hash = name.hashCode(); - synchronized(this) { - VariableTableEntry[] table; - VariableTableEntry e; - if ((table = variableTable) == null) { - table = new VariableTableEntry[VARIABLE_TABLE_DEFAULT_CAPACITY]; - e = new VariableTableEntry(hash, name.intern(), value, null); - table[hash & (VARIABLE_TABLE_DEFAULT_CAPACITY - 1)] = e; - variableTableThreshold = (int)(VARIABLE_TABLE_DEFAULT_CAPACITY * VARIABLE_TABLE_LOAD_FACTOR); - variableTableSize = 1; - variableTable = table; - return value; - } - int potentialNewSize; - if ((potentialNewSize = variableTableSize + 1) > variableTableThreshold) { - table = variableTableRehash(); - } - int index; - for (e = table[index = hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - e.value = value; - return value; - } - } - e = new VariableTableEntry(hash, name.intern(), value, table[index]); - table[index] = e; - variableTableSize = potentialNewSize; - variableTable = table; // write-volatile - } - return value; - } - - /** - * Will store the value under the specified name, where the name - * needs to be an interned Java String. - */ - protected IRubyObject variableTableFastStore(String internedName, IRubyObject value) { - assert internedName == internedName.intern() : internedName + " not interned"; - int hash = internedName.hashCode(); - synchronized(this) { - VariableTableEntry[] table; - VariableTableEntry e; - if ((table = variableTable) == null) { - table = new VariableTableEntry[VARIABLE_TABLE_DEFAULT_CAPACITY]; - e = new VariableTableEntry(hash, internedName, value, null); - table[hash & (VARIABLE_TABLE_DEFAULT_CAPACITY - 1)] = e; - variableTableThreshold = (int)(VARIABLE_TABLE_DEFAULT_CAPACITY * VARIABLE_TABLE_LOAD_FACTOR); - variableTableSize = 1; - variableTable = table; - return value; - } - int potentialNewSize; - if ((potentialNewSize = variableTableSize + 1) > variableTableThreshold) { - table = variableTableRehash(); - } - int index; - for (e = table[index = hash & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - e.value = value; - return value; - } - } - e = new VariableTableEntry(hash, internedName, value, table[index]); - table[index] = e; - variableTableSize = potentialNewSize; - variableTable = table; // write-volatile - } - return value; - } - - /** - * Removes the entry with the specified name from the variable - * table, and returning the removed value. - */ - protected IRubyObject variableTableRemove(String name) { - synchronized(this) { - VariableTableEntry[] table; - if ((table = variableTable) != null) { - int hash = name.hashCode(); - int index = hash & (table.length - 1); - VariableTableEntry first = table[index]; - VariableTableEntry e; - for (e = first; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - IRubyObject oldValue = e.value; - // All entries following removed node can stay - // in list, but all preceding ones need to be - // cloned. - VariableTableEntry newFirst = e.next; - for (VariableTableEntry p = first; p != e; p = p.next) { - newFirst = new VariableTableEntry(p.hash, p.name, p.value, newFirst); - } - table[index] = newFirst; - variableTableSize--; - variableTable = table; // write-volatile - return oldValue; - } - } - } - } - return null; - } - - /** - * Get the actual table used to save variable entries. - */ - protected VariableTableEntry[] variableTableGetTable() { - VariableTableEntry[] table; - if ((table = variableTable) != null) { - return table; - } - return VARIABLE_TABLE_EMPTY_TABLE; - } - - /** - * Get the size of the variable table. - */ - protected int variableTableGetSize() { - if (variableTable != null) { - return variableTableSize; - } - return 0; - } - - /** - * Synchronize the variable table with the argument. In real terms - * this means copy all entries into a newly allocated table. - */ - protected void variableTableSync(List<Variable<IRubyObject>> vars) { - synchronized(this) { - variableTableSize = 0; - variableTableThreshold = (int)(VARIABLE_TABLE_DEFAULT_CAPACITY * VARIABLE_TABLE_LOAD_FACTOR); - variableTable = new VariableTableEntry[VARIABLE_TABLE_DEFAULT_CAPACITY]; - for (Variable<IRubyObject> var : vars) { - variableTableStore(var.getName(), var.getValue()); - } - } - } - - /** - * Rehashes the variable table. Must be called from a synchronized - * block. - */ - // MUST be called from synchronized/locked block! - // should only be called by variableTableStore/variableTableFastStore - protected final VariableTableEntry[] variableTableRehash() { - VariableTableEntry[] oldTable = variableTable; - int oldCapacity; - if ((oldCapacity = oldTable.length) >= VARIABLE_TABLE_MAXIMUM_CAPACITY) { - return oldTable; - } - - int newCapacity = oldCapacity << 1; - VariableTableEntry[] newTable = new VariableTableEntry[newCapacity]; - variableTableThreshold = (int)(newCapacity * VARIABLE_TABLE_LOAD_FACTOR); - int sizeMask = newCapacity - 1; - VariableTableEntry e; - for (int i = oldCapacity; --i >= 0; ) { - // We need to guarantee that any existing reads of old Map can - // proceed. So we cannot yet null out each bin. - e = oldTable[i]; - - if (e != null) { - VariableTableEntry next = e.next; - int idx = e.hash & sizeMask; - - // Single node on list - if (next == null) - newTable[idx] = e; - - else { - // Reuse trailing consecutive sequence at same slot - VariableTableEntry lastRun = e; - int lastIdx = idx; - for (VariableTableEntry last = next; - last != null; - last = last.next) { - int k = last.hash & sizeMask; - if (k != lastIdx) { - lastIdx = k; - lastRun = last; - } - } - newTable[lastIdx] = lastRun; - - // Clone all remaining nodes - for (VariableTableEntry p = e; p != lastRun; p = p.next) { - int k = p.hash & sizeMask; - VariableTableEntry m = new VariableTableEntry(p.hash, p.name, p.value, newTable[k]); - newTable[k] = m; - } - } - } - } - variableTable = newTable; - return newTable; - } - - /** - * Method to help ease transition to new variables implementation. - * Will likely be deprecated in the near future. - */ - @SuppressWarnings("unchecked") - protected Map variableTableGetMap() { - HashMap map = new HashMap(); - VariableTableEntry[] table; - IRubyObject readValue; - if ((table = variableTable) != null) { - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - if ((readValue = e.value) == null) readValue = variableTableReadLocked(e); - map.put(e.name, readValue); - } - } - } - return map; - } - - /** - * Method to help ease transition to new variables implementation. - * Will likely be deprecated in the near future. - */ - @SuppressWarnings("unchecked") - protected Map variableTableGetMap(Map map) { - VariableTableEntry[] table; - IRubyObject readValue; - if ((table = variableTable) != null) { - for (int i = table.length; --i >= 0; ) { - for (VariableTableEntry e = table[i]; e != null; e = e.next) { - if ((readValue = e.value) == null) readValue = variableTableReadLocked(e); - map.put(e.name, readValue); - } - } - } - return map; - } - - /** - * Tries to support Java serialization of Ruby objects. This is - * still experimental and might not work. - */ - // NOTE: Serialization is primarily supported for testing purposes, and there is no general - // guarantee that serialization will work correctly. Specifically, instance variables pointing - // at symbols, threads, modules, classes, and other unserializable types are not detected. - private void writeObject(ObjectOutputStream out) throws IOException { - out.defaultWriteObject(); - // write out ivar count followed by name/value pairs - List<String> names = getInstanceVariableNameList(); - out.writeInt(names.size()); - for (String name : names) { - out.writeObject(name); - out.writeObject(getInstanceVariables().getInstanceVariable(name)); - } - } - - /** - * Tries to support Java unserialization of Ruby objects. This is - * still experimental and might not work. - */ - private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { - in.defaultReadObject(); - // rest in ivar count followed by name/value pairs - int ivarCount = in.readInt(); - for (int i = 0; i < ivarCount; i++) { - setInstanceVariable((String)in.readObject(), (IRubyObject)in.readObject()); - } - } - -} - -package org.jruby; - -import org.jruby.runtime.Block; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * - * @author nicksieger - */ -public interface RubyObjectAdapter { - - boolean isKindOf(IRubyObject value, RubyModule rubyModule); - - IRubyObject setInstanceVariable(IRubyObject obj, String variableName, IRubyObject value); - - IRubyObject[] convertToJavaArray(IRubyObject array); - - RubyInteger convertToRubyInteger(IRubyObject obj); - - IRubyObject getInstanceVariable(IRubyObject obj, String variableName); - - RubyString convertToRubyString(IRubyObject obj); - - // These call* assume ThreadContext = receiver.getRuntime().getCurrentContext() - IRubyObject callMethod(IRubyObject receiver, String methodName); - - IRubyObject callMethod(IRubyObject receiver, String methodName, IRubyObject singleArg); - - IRubyObject callMethod(IRubyObject receiver, String methodName, IRubyObject[] args); - - IRubyObject callMethod(IRubyObject receiver, String methodName, IRubyObject[] args, Block block); - - IRubyObject callSuper(IRubyObject receiver, IRubyObject[] args); - - IRubyObject callSuper(IRubyObject receiver, IRubyObject[] args, Block block); -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.util.Iterator; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.runtime.Block; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -@JRubyModule(name="ObjectSpace") -public class RubyObjectSpace { - - /** Create the ObjectSpace module and add it to the Ruby runtime. - * - */ - public static RubyModule createObjectSpaceModule(Ruby runtime) { - RubyModule objectSpaceModule = runtime.defineModule("ObjectSpace"); - runtime.setObjectSpaceModule(objectSpaceModule); - - objectSpaceModule.defineAnnotatedMethods(RubyObjectSpace.class); - - return objectSpaceModule; - } - - @JRubyMethod(name = "define_finalizer", required = 1, optional = 1, frame = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject define_finalizer(IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = recv.getRuntime(); - IRubyObject finalizer = null; - if (args.length == 2) { - finalizer = args[1]; - if (!finalizer.respondsTo("call")) { - throw runtime.newArgumentError("wrong type argument " - + finalizer.getType() + " (should be callable)"); - } - } else { - finalizer = runtime.newProc(Block.Type.PROC, block); - } - IRubyObject obj = args[0]; - runtime.getObjectSpace().addFinalizer(obj, finalizer); - return runtime.newArray(runtime.newFixnum(runtime.getSafeLevel()), finalizer); - } - - @JRubyMethod(name = "undefine_finalizer", required = 1, frame = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject undefine_finalizer(IRubyObject recv, IRubyObject arg1, Block block) { - recv.getRuntime().getObjectSpace().removeFinalizers(RubyNumeric.fix2long(arg1.id())); - return recv; - } - - @JRubyMethod(name = "_id2ref", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject id2ref(IRubyObject recv, IRubyObject id) { - Ruby runtime = id.getRuntime(); - if (!(id instanceof RubyFixnum)) { - throw recv.getRuntime().newTypeError(id, recv.getRuntime().getFixnum()); - } - RubyFixnum idFixnum = (RubyFixnum) id; - long longId = idFixnum.getLongValue(); - if (longId == 0) { - return runtime.getFalse(); - } else if (longId == 2) { - return runtime.getTrue(); - } else if (longId == 4) { - return runtime.getNil(); - } else if (longId % 2 != 0) { - // odd - return runtime.newFixnum((longId - 1) / 2); - } else { - IRubyObject object = runtime.getObjectSpace().id2ref(longId); - if (object == null) { - return runtime.getNil(); - } - return object; - } - } - - @JRubyMethod(name = "each_object", optional = 1, frame = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject each_object(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - RubyModule rubyClass; - if (args.length == 0) { - rubyClass = recv.getRuntime().getObject(); - } else { - if (!(args[0] instanceof RubyModule)) throw recv.getRuntime().newTypeError("class or module required"); - rubyClass = (RubyModule) args[0]; - } - Ruby runtime = recv.getRuntime(); - int count = 0; - if (rubyClass != runtime.getClassClass()) { - if (!runtime.isObjectSpaceEnabled()) { - throw runtime.newRuntimeError("ObjectSpace is disabled; each_object will only work with Class, pass +O to enable"); - } - Iterator iter = recv.getRuntime().getObjectSpace().iterator(rubyClass); - - IRubyObject obj = null; - while ((obj = (IRubyObject)iter.next()) != null) { - count++; - block.yield(context, obj); - } - } else { - Iterator iter = runtime.getObject().subclasses(true).iterator(); - - while (iter.hasNext()) { - count++; - block.yield(context, (IRubyObject)iter.next()); - } - } - return recv.getRuntime().newFixnum(count); - } - - @JRubyMethod(name = "garbage_collect", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject garbage_collect(IRubyObject recv) { - return RubyGC.start(recv); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.callback.Callback; - -/** - * - * @author jpetersen - */ -@JRubyModule(name="Precision") -public class RubyPrecision { - - public static RubyModule createPrecisionModule(Ruby runtime) { - RubyModule precisionModule = runtime.defineModule("Precision"); - runtime.setPrecision(precisionModule); - - precisionModule.defineAnnotatedMethods(RubyPrecision.class); - - return precisionModule; - } - - public static IRubyObject induced_from(IRubyObject receiver, IRubyObject source, Block block) { - throw receiver.getRuntime().newTypeError("Undefined conversion from " + source.getMetaClass().getName() + " into " + ((RubyClass)receiver).getName()); - } - - @JRubyMethod(name = "append_features", required = 1, frame = true, module = true) - public static IRubyObject append_features(IRubyObject receiver, IRubyObject include, Block block) { - if (include instanceof RubyModule) { - ((RubyModule) include).includeModule(receiver); - include.getSingletonClass().defineMethod("induced_from", new Callback() { - - public IRubyObject execute(IRubyObject recv, IRubyObject[] args, Block block) { - Arity.checkArgumentCount(recv.getRuntime(), args, 1, 1); - - return RubyPrecision.induced_from(recv, args[0], block); - } - - public Arity getArity() { - return Arity.ONE_ARGUMENT; - } - }); - } - return receiver; - } - - - @JRubyMethod(name = "prec", required = 1, frame = true) - public static IRubyObject prec(ThreadContext context, IRubyObject receiver, IRubyObject type, Block block) { - return type.callMethod(context, "induced_from", receiver); - } - - @JRubyMethod(name = "prec_i", frame = true) - public static IRubyObject prec_i(ThreadContext context, IRubyObject receiver, Block block) { - return receiver.getRuntime().getInteger().callMethod(context, "induced_from", receiver); - } - - @JRubyMethod(name = "prec_f", frame = true) - public static IRubyObject prec_f(ThreadContext context, IRubyObject receiver, Block block) { - return receiver.getRuntime().getFloat().callMethod(context, "induced_from", receiver); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2005 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2007 Miguel Covarrubias <mlcovarrubias@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.exceptions.JumpException; -import org.jruby.internal.runtime.JumpTarget; -import org.jruby.java.MiniJava; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * @author jpetersen - */ -@JRubyClass(name="Proc") -public class RubyProc extends RubyObject implements JumpTarget { - private Block block = Block.NULL_BLOCK; - private Block.Type type; - private String file; - private int line; - - public RubyProc(Ruby runtime, RubyClass rubyClass, Block.Type type) { - super(runtime, rubyClass); - - this.type = type; - } - - private static ObjectAllocator PROC_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - RubyProc instance = RubyProc.newProc(runtime, Block.Type.PROC); - - instance.setMetaClass(klass); - - return instance; - } - }; - - public static RubyClass createProcClass(Ruby runtime) { - RubyClass procClass = runtime.defineClass("Proc", runtime.getObject(), PROC_ALLOCATOR); - runtime.setProc(procClass); - - procClass.defineAnnotatedMethods(RubyProc.class); - - return procClass; - } - - public Block getBlock() { - return block; - } - - // Proc class - - public static RubyProc newProc(Ruby runtime, Block.Type type) { - return new RubyProc(runtime, runtime.getProc(), type); - } - public static RubyProc newProc(Ruby runtime, Block block, Block.Type type) { - RubyProc proc = new RubyProc(runtime, runtime.getProc(), type); - proc.callInit(NULL_ARRAY, block); - - return proc; - } - - /** - * Create a new instance of a Proc object. We override this method (from RubyClass) - * since we need to deal with special case of Proc.new with no arguments or block arg. In - * this case, we need to check previous frame for a block to consume. - */ - @JRubyMethod(name = "new", rest = true, frame = true, meta = true) - public static IRubyObject newInstance(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - // No passed in block, lets check next outer frame for one ('Proc.new') - if (!block.isGiven()) { - block = context.getPreviousFrame().getBlock(); - } - - if (block.isGiven() && block.getProcObject() != null) { - return block.getProcObject(); - } - - IRubyObject obj = ((RubyClass) recv).allocate(); - - obj.callMethod(context, "initialize", args, block); - return obj; - } - - @JRubyMethod(name = "initialize", frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(ThreadContext context, Block procBlock) { - if (!procBlock.isGiven()) { - throw getRuntime().newArgumentError("tried to create Proc object without a block"); - } - - if (type == Block.Type.LAMBDA && procBlock == null) { - // TODO: warn "tried to create Proc object without a block" - } - - block = procBlock.cloneBlock(); - block.type = type; - block.setProcObject(this); - - file = context.getFile(); - line = context.getLine(); - return this; - } - - @JRubyMethod(name = "clone") - public IRubyObject rbClone() { - RubyProc newProc = new RubyProc(getRuntime(), getRuntime().getProc(), type); - newProc.block = getBlock(); - newProc.file = file; - newProc.line = line; - // TODO: CLONE_SETUP here - return newProc; - } - - @JRubyMethod(name = "dup") - public IRubyObject dup() { - RubyProc newProc = new RubyProc(getRuntime(), getRuntime().getProc(), type); - newProc.block = getBlock(); - newProc.file = file; - newProc.line = line; - return newProc; - } - - @JRubyMethod(name = "==", required = 1) - public IRubyObject op_equal(IRubyObject other) { - if (!(other instanceof RubyProc)) return getRuntime().getFalse(); - - if (this == other || this.block == ((RubyProc)other).block) { - return getRuntime().getTrue(); - } - - return getRuntime().getFalse(); - } - - @JRubyMethod(name = "to_s") - public IRubyObject to_s() { - return RubyString.newString(getRuntime(), - "#<Proc:0x" + Integer.toString(block.hashCode(), 16) + "@" + - file + ":" + (line + 1) + ">"); - } - - @JRubyMethod(name = "binding") - public IRubyObject binding() { - return getRuntime().newBinding(block.getBinding()); - } - - @JRubyMethod(name = {"call", "[]"}, rest = true, frame = true) - public IRubyObject call(ThreadContext context, IRubyObject[] args) { - return call(context, args, null); - } - - public IRubyObject call(ThreadContext context, IRubyObject[] args, IRubyObject self) { - assert args != null; - - Ruby runtime = getRuntime(); - Block newBlock = block.cloneBlock(); - JumpTarget jumpTarget = newBlock.getBinding().getFrame().getJumpTarget(); - - try { - if (self != null) newBlock.getBinding().setSelf(self); - - return newBlock.call(context, args); - } catch (JumpException.BreakJump bj) { - switch(block.type) { - case LAMBDA: if (bj.getTarget() == jumpTarget) { - return (IRubyObject) bj.getValue(); - } else { - throw runtime.newLocalJumpError("break", (IRubyObject)bj.getValue(), "unexpected break"); - } - case PROC: - if (newBlock.isEscaped()) { - throw runtime.newLocalJumpError("break", (IRubyObject)bj.getValue(), "break from proc-closure"); - } else { - throw bj; - } - default: throw bj; - } - } catch (JumpException.ReturnJump rj) { - Object target = rj.getTarget(); - - if (target == jumpTarget && block.type == Block.Type.LAMBDA) return (IRubyObject) rj.getValue(); - - if (type == Block.Type.THREAD) { - throw runtime.newThreadError("return can't jump across threads"); - } - throw rj; - } catch (JumpException.RetryJump rj) { - throw runtime.newLocalJumpError("retry", (IRubyObject)rj.getValue(), "retry not supported outside rescue"); - } - } - - @JRubyMethod(name = "arity") - public RubyFixnum arity() { - return getRuntime().newFixnum(block.arity().getValue()); - } - - @JRubyMethod(name = "to_proc") - public RubyProc to_proc() { - return this; - } - - public IRubyObject as(Class asClass) { - final Ruby ruby = getRuntime(); - if (!asClass.isInterface()) { - throw ruby.newTypeError(asClass.getCanonicalName() + " is not an interface"); - } - - return MiniJava.javaToRuby(ruby, Proxy.newProxyInstance(Ruby.getClassLoader(), new Class[] {asClass}, new InvocationHandler() { - public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { - IRubyObject[] rubyArgs = new IRubyObject[args.length + 1]; - rubyArgs[0] = RubySymbol.newSymbol(ruby, method.getName()); - for (int i = 1; i < rubyArgs.length; i++) { - rubyArgs[i] = MiniJava.javaToRuby(ruby, args[i - 1]); - } - return MiniJava.rubyToJava(call(ruby.getCurrentContext(), rubyArgs)); - } - })); - } -} -/* - **** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.ext.posix.POSIX; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.BlockCallback; -import org.jruby.runtime.CallBlock; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - - -/** - */ - -@JRubyModule(name="Process") -public class RubyProcess { - - public static RubyModule createProcessModule(Ruby runtime) { - RubyModule process = runtime.defineModule("Process"); - runtime.setProcess(process); - - // TODO: NOT_ALLOCATABLE_ALLOCATOR is probably ok here. Confirm. JRUBY-415 - RubyClass process_status = process.defineClassUnder("Status", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setProcStatus(process_status); - - RubyModule process_uid = process.defineModuleUnder("UID"); - runtime.setProcUID(process_uid); - - RubyModule process_gid = process.defineModuleUnder("GID"); - runtime.setProcGID(process_gid); - - RubyModule process_sys = process.defineModuleUnder("Sys"); - runtime.setProcSys(process_sys); - - process.defineAnnotatedMethods(RubyProcess.class); - process_status.defineAnnotatedMethods(RubyStatus.class); - process_uid.defineAnnotatedMethods(UserID.class); - process_gid.defineAnnotatedMethods(GroupID.class); - process_sys.defineAnnotatedMethods(Sys.class); - - process.defineConstant("PRIO_PROCESS", runtime.newFixnum(0)); - process.defineConstant("PRIO_PGRP", runtime.newFixnum(1)); - process.defineConstant("PRIO_USER", runtime.newFixnum(2)); - - process.defineConstant("WNOHANG", runtime.newFixnum(1)); - - return process; - } - - @JRubyClass(name="Process::Status") - public static class RubyStatus extends RubyObject { - private long status = 0L; - - private static final long EXIT_SUCCESS = 0L; - public RubyStatus(Ruby runtime, RubyClass metaClass, long status) { - super(runtime, metaClass); - this.status = status; - } - - public static RubyStatus newProcessStatus(Ruby runtime, long status) { - return new RubyStatus(runtime, runtime.getProcStatus(), status); - } - - // Bunch of methods still not implemented - @JRubyMethod(name = {"to_int", "pid", "stopped?", "stopsig", "signaled?", "termsig?", "exited?", "coredump?"}) - public IRubyObject not_implemented() { - String error = "Process::Status#" + getRuntime().getCurrentContext().getFrameName() + " not implemented"; - throw getRuntime().newNotImplementedError(error); - } - - @JRubyMethod(name = {"&"}) - public IRubyObject not_implemented1(IRubyObject arg) { - String error = "Process::Status#" + getRuntime().getCurrentContext().getFrameName() + " not implemented"; - throw getRuntime().newNotImplementedError(error); - } - - @JRubyMethod - public IRubyObject exitstatus() { - return getRuntime().newFixnum(status); - } - - @JRubyMethod(name = ">>") - public IRubyObject op_rshift(IRubyObject other) { - long shiftValue = other.convertToInteger().getLongValue(); - return getRuntime().newFixnum(status >> shiftValue); - } - - @JRubyMethod(name = "==") - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - return other.callMethod(context, MethodIndex.EQUALEQUAL, "==", this.to_i()); - } - - @JRubyMethod - public IRubyObject to_i() { - return getRuntime().newFixnum(shiftedValue()); - } - - @JRubyMethod - public IRubyObject to_s() { - return getRuntime().newString(String.valueOf(shiftedValue())); - } - - @JRubyMethod - public IRubyObject inspect() { - return getRuntime().newString("#<Process::Status: pid=????,exited(" + String.valueOf(status) + ")>"); - } - - @JRubyMethod(name = "success?") - public IRubyObject success_p() { - return getRuntime().newBoolean(status == EXIT_SUCCESS); - } - - private long shiftedValue() { - return status << 8; - } - } - - @JRubyModule(name="Process::UID") - public static class UserID { - @JRubyMethod(name = "change_privilege", module = true) - public static IRubyObject change_privilege(IRubyObject self, IRubyObject arg) { - throw self.getRuntime().newNotImplementedError("Process::UID::change_privilege not implemented yet"); - } - - @JRubyMethod(name = "eid", module = true) - public static IRubyObject eid(IRubyObject self) { - return euid(self); - } - - @JRubyMethod(name = "eid=", module = true) - public static IRubyObject eid(IRubyObject self, IRubyObject arg) { - return euid_set(self, arg); - } - - @JRubyMethod(name = "grant_privilege", module = true) - public static IRubyObject grant_privilege(IRubyObject self, IRubyObject arg) { - throw self.getRuntime().newNotImplementedError("Process::UID::grant_privilege not implemented yet"); - } - - @JRubyMethod(name = "re_exchange", module = true) - public static IRubyObject re_exchange(ThreadContext context, IRubyObject self) { - return switch_rb(context, self, Block.NULL_BLOCK); - } - - @JRubyMethod(name = "re_exchangeable?", module = true) - public static IRubyObject re_exchangeable_p(IRubyObject self) { - throw self.getRuntime().newNotImplementedError("Process::UID::re_exchangeable? not implemented yet"); - } - - @JRubyMethod(name = "rid", module = true) - public static IRubyObject rid(IRubyObject self) { - return uid(self); - } - - @JRubyMethod(name = "sid_available?", module = true) - public static IRubyObject sid_available_p(IRubyObject self) { - throw self.getRuntime().newNotImplementedError("Process::UID::sid_available not implemented yet"); - } - - @JRubyMethod(name = "switch", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject switch_rb(ThreadContext context, IRubyObject self, Block block) { - Ruby runtime = self.getRuntime(); - int uid = runtime.getPosix().getuid(); - int euid = runtime.getPosix().geteuid(); - - if (block.isGiven()) { - try { - runtime.getPosix().seteuid(uid); - runtime.getPosix().setuid(euid); - - return block.yield(context, runtime.getNil()); - } finally { - runtime.getPosix().seteuid(euid); - runtime.getPosix().setuid(uid); - } - } else { - runtime.getPosix().seteuid(uid); - runtime.getPosix().setuid(euid); - - return RubyFixnum.zero(runtime); - } - } - } - - @JRubyModule(name="Process::GID") - public static class GroupID { - @JRubyMethod(name = "change_privilege", module = true) - public static IRubyObject change_privilege(IRubyObject self, IRubyObject arg) { - throw self.getRuntime().newNotImplementedError("Process::GID::change_privilege not implemented yet"); - } - - @JRubyMethod(name = "eid", module = true) - public static IRubyObject eid(IRubyObject self) { - return egid(self); - } - - @JRubyMethod(name = "eid=", module = true) - public static IRubyObject eid(IRubyObject self, IRubyObject arg) { - return RubyProcess.egid_set(self, arg); - } - - @JRubyMethod(name = "grant_privilege", module = true) - public static IRubyObject grant_privilege(IRubyObject self, IRubyObject arg) { - throw self.getRuntime().newNotImplementedError("Process::GID::grant_privilege not implemented yet"); - } - - @JRubyMethod(name = "re_exchange", module = true) - public static IRubyObject re_exchange(ThreadContext context, IRubyObject self) { - return switch_rb(context, self, Block.NULL_BLOCK); - } - - @JRubyMethod(name = "re_exchangeable?", module = true) - public static IRubyObject re_exchangeable_p(IRubyObject self) { - throw self.getRuntime().newNotImplementedError("Process::GID::re_exchangeable? not implemented yet"); - } - - @JRubyMethod(name = "rid", module = true) - public static IRubyObject rid(IRubyObject self) { - return gid(self); - } - - @JRubyMethod(name = "sid_available?", module = true) - public static IRubyObject sid_available_p(IRubyObject self) { - throw self.getRuntime().newNotImplementedError("Process::GID::sid_available not implemented yet"); - } - - @JRubyMethod(name = "switch", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject switch_rb(ThreadContext context, IRubyObject self, Block block) { - Ruby runtime = self.getRuntime(); - int gid = runtime.getPosix().getgid(); - int egid = runtime.getPosix().getegid(); - - if (block.isGiven()) { - try { - runtime.getPosix().setegid(gid); - runtime.getPosix().setgid(egid); - - return block.yield(context, runtime.getNil()); - } finally { - runtime.getPosix().setegid(egid); - runtime.getPosix().setgid(gid); - } - } else { - runtime.getPosix().setegid(gid); - runtime.getPosix().setgid(egid); - - return RubyFixnum.zero(runtime); - } - } - } - - @JRubyModule(name="Process::Sys") - public static class Sys { - @JRubyMethod(name = "getegid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject getegid(IRubyObject self) { - return egid(self); - } - - @JRubyMethod(name = "geteuid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject geteuid(IRubyObject self) { - return euid(self); - } - - @JRubyMethod(name = "getgid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject getgid(IRubyObject self) { - return gid(self); - } - - @JRubyMethod(name = "getuid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject getuid(IRubyObject self) { - return uid(self); - } - - @JRubyMethod(name = "setegid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject setegid(IRubyObject recv, IRubyObject arg) { - return egid_set(recv, arg); - } - - @JRubyMethod(name = "seteuid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject seteuid(IRubyObject recv, IRubyObject arg) { - return euid_set(recv, arg); - } - - @JRubyMethod(name = "setgid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject setgid(IRubyObject recv, IRubyObject arg) { - return gid_set(recv, arg); - } - - @JRubyMethod(name = "setuid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject setuid(IRubyObject recv, IRubyObject arg) { - return uid_set(recv, arg); - } - } - - @JRubyMethod(name = "abort", optional = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject abort(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - return RubyKernel.abort(context, recv, args); - } - - @JRubyMethod(name = "exit!", optional = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject exit_bang(IRubyObject recv, IRubyObject[] args) { - return RubyKernel.exit_bang(recv, args); - } - - @JRubyMethod(name = "groups", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject groups(IRubyObject recv) { - throw recv.getRuntime().newNotImplementedError("Process#groups not yet implemented"); - } - - @JRubyMethod(name = "setrlimit", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject setrlimit(IRubyObject recv, IRubyObject[] args) { - throw recv.getRuntime().newNotImplementedError("Process#setrlimit not yet implemented"); - } - - @JRubyMethod(name = "getpgrp", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject getpgrp(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().getpgrp()); - } - - @JRubyMethod(name = "groups=", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject groups_set(IRubyObject recv, IRubyObject arg) { - throw recv.getRuntime().newNotImplementedError("Process#groups not yet implemented"); - } - - @JRubyMethod(name = "waitpid", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject waitpid(IRubyObject recv, IRubyObject[] args) { - Ruby runtime = recv.getRuntime(); - int pid = -1; - int flags = 0; - if (args.length > 0) { - pid = (int)args[0].convertToInteger().getLongValue(); - } - if (args.length > 1) { - flags = (int)args[1].convertToInteger().getLongValue(); - } - - int[] status = new int[1]; - pid = runtime.getPosix().waitpid(pid, status, flags); - - if (pid == -1) { - throw runtime.newErrnoECHILDError(); - } - - runtime.getGlobalVariables().set( - "$?", - RubyProcess.RubyStatus.newProcessStatus(runtime, status[0])); - return runtime.newFixnum(pid); - } - - @JRubyMethod(name = "wait", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject wait(IRubyObject recv, IRubyObject[] args) { - Ruby runtime = recv.getRuntime(); - - if (args.length > 0) { - return waitpid(recv, args); - } - - int[] status = new int[1]; - int pid = runtime.getPosix().wait(status); - - if (pid == -1) { - throw runtime.newErrnoECHILDError(); - } - - runtime.getGlobalVariables().set( - "$?", - RubyProcess.RubyStatus.newProcessStatus(runtime, status[0])); - return runtime.newFixnum(pid); - } - - @JRubyMethod(name = "waitall", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject waitall(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - POSIX posix = runtime.getPosix(); - RubyArray results = recv.getRuntime().newArray(); - - int[] status = new int[1]; - int result = posix.wait(status); - while (result != -1) { - results.append(runtime.newArray(runtime.newFixnum(result), RubyProcess.RubyStatus.newProcessStatus(runtime, status[0]))); - result = posix.wait(status); - } - - return results; - } - - @JRubyMethod(name = "setsid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject setsid(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().setsid()); - } - - @JRubyMethod(name = "setpgrp", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject setpgrp(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().setpgid(0, 0)); - } - - @JRubyMethod(name = "egid=", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject egid_set(IRubyObject recv, IRubyObject arg) { - recv.getRuntime().getPosix().setegid((int)arg.convertToInteger().getLongValue()); - return RubyFixnum.zero(recv.getRuntime()); - } - - @JRubyMethod(name = "euid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject euid(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().geteuid()); - } - - @JRubyMethod(name = "uid=", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject uid_set(IRubyObject recv, IRubyObject arg) { - recv.getRuntime().getPosix().setuid((int)arg.convertToInteger().getLongValue()); - return RubyFixnum.zero(recv.getRuntime()); - } - - @JRubyMethod(name = "gid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject gid(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().getgid()); - } - - @JRubyMethod(name = "maxgroups", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject maxgroups(IRubyObject recv) { - throw recv.getRuntime().newNotImplementedError("Process#maxgroups not yet implemented"); - } - - @JRubyMethod(name = "getpriority", required = 2, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject getpriority(IRubyObject recv, IRubyObject arg1, IRubyObject arg2) { - int which = (int)arg1.convertToInteger().getLongValue(); - int who = (int)arg2.convertToInteger().getLongValue(); - int result = recv.getRuntime().getPosix().getpriority(which, who); - - return recv.getRuntime().newFixnum(result); - } - - @JRubyMethod(name = "uid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject uid(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().getuid()); - } - - @JRubyMethod(name = "waitpid2", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject waitpid2(IRubyObject recv, IRubyObject[] args) { - Ruby runtime = recv.getRuntime(); - int pid = -1; - int flags = 0; - if (args.length > 0) { - pid = (int)args[0].convertToInteger().getLongValue(); - } - if (args.length > 1) { - flags = (int)args[1].convertToInteger().getLongValue(); - } - - int[] status = new int[1]; - pid = runtime.getPosix().waitpid(pid, status, flags); - - if (pid == -1) { - throw runtime.newErrnoECHILDError(); - } - - return runtime.newArray(runtime.newFixnum(pid), RubyProcess.RubyStatus.newProcessStatus(runtime, status[0])); - } - - @JRubyMethod(name = "initgroups", required = 2, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject initgroups(IRubyObject recv, IRubyObject arg1, IRubyObject arg2) { - throw recv.getRuntime().newNotImplementedError("Process#initgroups not yet implemented"); - } - - @JRubyMethod(name = "maxgroups=", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject maxgroups_set(IRubyObject recv, IRubyObject arg) { - throw recv.getRuntime().newNotImplementedError("Process#maxgroups_set not yet implemented"); - } - - @JRubyMethod(name = "ppid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject ppid(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().getppid()); - } - - @JRubyMethod(name = "gid=", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject gid_set(IRubyObject recv, IRubyObject arg) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().setgid((int)arg.convertToInteger().getLongValue())); - } - - @JRubyMethod(name = "wait2", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject wait2(IRubyObject recv, IRubyObject[] args) { - return waitpid2(recv, args); - } - - @JRubyMethod(name = "euid=", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject euid_set(IRubyObject recv, IRubyObject arg) { - recv.getRuntime().getPosix().seteuid((int)arg.convertToInteger().getLongValue()); - return RubyFixnum.zero(recv.getRuntime()); - } - - @JRubyMethod(name = "setpriority", required = 3, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject setpriority(IRubyObject recv, IRubyObject arg1, IRubyObject arg2, IRubyObject arg3) { - int which = (int)arg1.convertToInteger().getLongValue(); - int who = (int)arg2.convertToInteger().getLongValue(); - int prio = (int)arg3.convertToInteger().getLongValue(); - int result = recv.getRuntime().getPosix().setpriority(which, who, prio); - - return recv.getRuntime().newFixnum(result); - } - - @JRubyMethod(name = "setpgid", required = 2, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject setpgid(IRubyObject recv, IRubyObject arg1, IRubyObject arg2) { - int pid = (int)arg1.convertToInteger().getLongValue(); - int gid = (int)arg2.convertToInteger().getLongValue(); - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().setpgid(pid, gid)); - } - - @JRubyMethod(name = "getpgid", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject getpgid(IRubyObject recv, IRubyObject arg) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().getpgid((int)arg.convertToInteger().getLongValue())); - } - - @JRubyMethod(name = "getrlimit", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject getrlimit(IRubyObject recv, IRubyObject arg) { - throw recv.getRuntime().newNotImplementedError("Process#getrlimit not yet implemented"); - } - - @JRubyMethod(name = "egid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject egid(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().getegid()); - } - - private static String[] signals = new String[] {"EXIT", "HUP", "INT", "QUIT", "ILL", "TRAP", - "ABRT", "POLL", "FPE", "KILL", "BUS", "SEGV", "SYS", "PIPE", "ALRM", "TERM", "URG", "STOP", - "TSTP", "CONT", "CHLD", "TTIN", "TTOU", "XCPU", "XFSZ", "VTALRM", "PROF", "USR1", "USR2"}; - - private static int parseSignalString(Ruby runtime, String value) { - int startIndex = 0; - boolean negative = value.startsWith("-"); - - if (negative) startIndex++; - - boolean signalString = value.startsWith("SIG", startIndex); - - if (signalString) startIndex += 3; - - String signalName = value.substring(startIndex); - - // FIXME: This table will get moved into POSIX library so we can get all actual supported - // signals. This is a quick fix to support basic signals until that happens. - for (int i = 0; i < signals.length; i++) { - if (signals[i].equals(signalName)) return negative ? -i : i; - } - - throw runtime.newArgumentError("unsupported name `SIG" + signalName + "'"); - } - - @JRubyMethod(name = "kill", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject kill(IRubyObject recv, IRubyObject[] args) { - if (args.length < 2) { - throw recv.getRuntime().newArgumentError("wrong number of arguments -- kill(sig, pid...)"); - } - - Ruby runtime = recv.getRuntime(); - int signal; - if (args[0] instanceof RubyFixnum) { - signal = (int) ((RubyFixnum) args[0]).getLongValue(); - } else if (args[0] instanceof RubySymbol) { - signal = parseSignalString(runtime, args[0].toString()); - } else if (args[0] instanceof RubyString) { - signal = parseSignalString(runtime, args[0].toString()); - } else { - signal = parseSignalString(runtime, args[0].checkStringType().toString()); - } - - boolean processGroupKill = signal < 0; - - if (processGroupKill) signal = -signal; - - POSIX posix = runtime.getPosix(); - for (int i = 1; i < args.length; i++) { - int pid = RubyNumeric.num2int(args[i]); - - // FIXME: It may be possible to killpg on systems which support it. POSIX library - // needs to tell whether a particular method works or not - if (pid == 0) pid = runtime.getPosix().getpid(); - posix.kill(processGroupKill ? -pid : pid, signal); - } - - return runtime.newFixnum(args.length - 1); - - } - - @JRubyMethod(name = "detach", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject detach(ThreadContext context, IRubyObject recv, IRubyObject arg) { - final int pid = (int)arg.convertToInteger().getLongValue(); - Ruby runtime = recv.getRuntime(); - - BlockCallback callback = new BlockCallback() { - public IRubyObject call(ThreadContext context, IRubyObject[] args, Block block) { - int[] status = new int[1]; - int result = context.getRuntime().getPosix().waitpid(pid, status, 0); - - return context.getRuntime().newFixnum(result); - } - }; - - return RubyThread.newInstance( - runtime.getThread(), - IRubyObject.NULL_ARRAY, - CallBlock.newCallClosure(recv, (RubyModule)recv, Arity.NO_ARGUMENTS, callback, context)); - } - - @JRubyMethod(name = "times", frame = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject times(IRubyObject recv, Block unusedBlock) { - Ruby runtime = recv.getRuntime(); - double currentTime = System.currentTimeMillis() / 1000.0; - double startTime = runtime.getStartTime() / 1000.0; - RubyFloat zero = runtime.newFloat(0.0); - return RubyStruct.newStruct(runtime.getTmsStruct(), - new IRubyObject[] { runtime.newFloat(currentTime - startTime), zero, zero, zero }, - Block.NULL_BLOCK); - } - - @JRubyMethod(name = "pid", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject pid(IRubyObject recv) { - return recv.getRuntime().newFixnum(recv.getRuntime().getPosix().getpid()); - } - - @JRubyMethod(name = "fork", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject fork(ThreadContext context, IRubyObject recv, Block block) { - return RubyKernel.fork(context, recv, block); - } - - @JRubyMethod(name = "exit", optional = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject exit(IRubyObject recv, IRubyObject[] args) { - return RubyKernel.exit(recv, args); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001 Ed Sinjiashvili <slorcim@users.sourceforge.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; -import java.util.List; - -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.exceptions.RaiseException; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.BlockCallback; -import org.jruby.runtime.CallBlock; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ObjectMarshal; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.builtin.Variable; -import org.jruby.runtime.component.VariableEntry; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; - -/** - * @author jpetersen - */ -@JRubyClass(name="Range", include="Enumerable") -public class RubyRange extends RubyObject { - private IRubyObject begin; - private IRubyObject end; - private boolean isExclusive; - - public static RubyClass createRangeClass(Ruby runtime) { - RubyClass result = runtime.defineClass("Range", runtime.getObject(), RANGE_ALLOCATOR); - runtime.setRange(result); - result.kindOf = new RubyModule.KindOf() { - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyRange; - } - }; - - result.setMarshal(RANGE_MARSHAL); - result.includeModule(runtime.getEnumerable()); - - // We override Enumerable#member? since ranges in 1.8.1 are continuous. - // result.defineMethod("member?", callbackFactory.getMethod("include_p", RubyKernel.IRUBY_OBJECT)); - // result.defineMethod("===", callbackFactory.getMethod("include_p", RubyKernel.IRUBY_OBJECT)); - - result.defineAnnotatedMethods(RubyRange.class); - return result; - } - - private static final ObjectAllocator RANGE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyRange(runtime, klass); - } - }; - - private RubyRange(Ruby runtime, RubyClass klass) { - super(runtime, klass); - begin = end = runtime.getNil(); - } - - public static RubyRange newRange(Ruby runtime, ThreadContext context, IRubyObject begin, IRubyObject end, boolean isExclusive) { - RubyRange range = new RubyRange(runtime, runtime.getRange()); - range.init(context, begin, end, isExclusive); - return range; - } - - public static RubyRange newExclusiveRange(Ruby runtime, ThreadContext context, IRubyObject begin, IRubyObject end) { - RubyRange range = new RubyRange(runtime, runtime.getRange()); - range.init(context, begin, end, true); - return range; - } - - public static RubyRange newInclusiveRange(Ruby runtime, ThreadContext context, IRubyObject begin, IRubyObject end) { - RubyRange range = new RubyRange(runtime, runtime.getRange()); - range.init(context, begin, end, false); - return range; - } - - protected void copySpecialInstanceVariables(IRubyObject clone) { - RubyRange range = (RubyRange)clone; - range.begin = begin; - range.end = end; - range.isExclusive = isExclusive; - } - - final long[] begLen(long len, int err){ - long beg = RubyNumeric.num2long(this.begin); - long end = RubyNumeric.num2long(this.end); - - if (beg < 0) { - beg += len; - if (beg < 0) { - if (err != 0) throw getRuntime().newRangeError(beg + ".." + (isExclusive ? "." : "") + end + " out of range"); - return null; - } - } - - if (err == 0 || err == 2) { - if (beg > len) { - if (err != 0) throw getRuntime().newRangeError(beg + ".." + (isExclusive ? "." : "") + end + " out of range"); - return null; - } - if (end > len) end = len; - } - - if (end < 0) end += len; - if (!isExclusive) end++; - len = end - beg; - if (len < 0) len = 0; - - return new long[]{beg, len}; - } - - private void init(ThreadContext context, IRubyObject begin, IRubyObject end, boolean isExclusive) { - if (!(begin instanceof RubyFixnum && end instanceof RubyFixnum)) { - try { - IRubyObject result = begin.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", end); - if (result.isNil()) throw getRuntime().newArgumentError("bad value for range"); - } catch (RaiseException re) { - throw getRuntime().newArgumentError("bad value for range"); - } - } - - this.begin = begin; - this.end = end; - this.isExclusive = isExclusive; - } - - @JRubyMethod(name = "initialize", required = 2, optional = 1, frame = true) - public IRubyObject initialize(ThreadContext context, IRubyObject[] args, Block unusedBlock) { - init(context, args[0], args[1], args.length > 2 && args[2].isTrue()); - return getRuntime().getNil(); - } - - @JRubyMethod(name = {"first", "begin"}) - public IRubyObject first() { - return begin; - } - - @JRubyMethod(name = {"last", "end"}) - public IRubyObject last() { - return end; - } - - @JRubyMethod(name = "hash") - public RubyFixnum hash(ThreadContext context) { - long hash = isExclusive ? 1 : 0; - long h = hash; - - long v = begin.callMethod(context, MethodIndex.HASH, "hash").convertToInteger().getLongValue(); - hash ^= v << 1; - v = end.callMethod(context, MethodIndex.HASH, "hash").convertToInteger().getLongValue(); - hash ^= v << 9; - hash ^= h << 24; - return getRuntime().newFixnum(hash); - } - - private static byte[] DOTDOTDOT = "...".getBytes(); - private static byte[] DOTDOT = "..".getBytes(); - - @JRubyMethod(name = "inspect") - public IRubyObject inspect(ThreadContext context) { - RubyString str = inspect(context, begin).strDup(context.getRuntime()); - RubyString str2 = inspect(context, end); - - str.cat(isExclusive ? DOTDOTDOT : DOTDOT); - str.concat(str2); - str.infectBy(str2); - return str; - } - - @JRubyMethod(name = "to_s") - public IRubyObject to_s(ThreadContext context) { - RubyString str = RubyString.objAsString(context, begin).strDup(context.getRuntime()); - RubyString str2 = RubyString.objAsString(context, end); - - str.cat(isExclusive ? DOTDOTDOT : DOTDOT); - str.concat(str2); - str.infectBy(str2); - return str; - - } - - @JRubyMethod(name = "exclude_end?") - public RubyBoolean exclude_end_p() { - return getRuntime().newBoolean(isExclusive); - } - - @JRubyMethod(name = "==", required = 1) - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - if (this == other) return getRuntime().getTrue(); - if (!(other instanceof RubyRange)) return getRuntime().getFalse(); - RubyRange otherRange = (RubyRange) other; - - if (equalInternal(context, begin, otherRange.begin) && - equalInternal(context, end, otherRange.end) && - isExclusive == otherRange.isExclusive) return getRuntime().getTrue(); - - return getRuntime().getFalse(); - } - - @JRubyMethod(name = "eql?", required = 1) - public IRubyObject eql_p(ThreadContext context, IRubyObject other) { - if (this == other) return getRuntime().getTrue(); - if (!(other instanceof RubyRange)) return getRuntime().getFalse(); - RubyRange otherRange = (RubyRange)other; - - if (eqlInternal(context, begin, otherRange.begin) && - eqlInternal(context, end, otherRange.end) && - isExclusive == otherRange.isExclusive) return getRuntime().getTrue(); - - return getRuntime().getFalse(); - } - - private static abstract class RangeCallBack { - abstract void call(ThreadContext context, IRubyObject arg); - } - - private static final class StepBlockCallBack extends RangeCallBack implements BlockCallback { - final Block block; - IRubyObject iter; - final IRubyObject step; - - StepBlockCallBack(Block block, IRubyObject iter, IRubyObject step) { - this.block = block; - this.iter = iter; - this.step = step; - } - - public IRubyObject call(ThreadContext context, IRubyObject[] args, Block originalBlock) { - call(context, args[0]); - return context.getRuntime().getNil(); - } - - void call(ThreadContext context, IRubyObject arg) { - if (iter instanceof RubyFixnum) { - iter = RubyFixnum.newFixnum(context.getRuntime(), ((RubyFixnum)iter).getLongValue() - 1); - } else { - iter = iter.callMethod(context, MethodIndex.OP_MINUS, "-", RubyFixnum.one(context.getRuntime())); - } - if (iter == RubyFixnum.zero(context.getRuntime())) { - block.yield(context, arg); - iter = step; - } - } - } - - private IRubyObject rangeLt(ThreadContext context, IRubyObject a, IRubyObject b) { - IRubyObject result = a.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", b); - if (result.isNil()) return null; - return RubyComparable.cmpint(context, result, a, b) < 0 ? getRuntime().getTrue() : null; - } - - private IRubyObject rangeLe(ThreadContext context, IRubyObject a, IRubyObject b) { - IRubyObject result = a.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", b); - if (result.isNil()) return null; - int c = RubyComparable.cmpint(context, result, a, b); - if (c == 0) return RubyFixnum.zero(getRuntime()); - return c < 0 ? getRuntime().getTrue() : null; - } - - private void rangeEach(ThreadContext context, RangeCallBack callback) { - IRubyObject v = begin; - if (isExclusive) { - while (rangeLt(context, v, end) != null) { - callback.call(context, v); - v = v.callMethod(context, "succ"); - } - } else { - IRubyObject c; - while ((c = rangeLe(context, v, end)) != null && c.isTrue()) { - callback.call(context, v); - if (c == RubyFixnum.zero(getRuntime())) break; - v = v.callMethod(context, "succ"); - } - } - } - - @JRubyMethod(name = "each", frame = true) - public IRubyObject each(ThreadContext context, final Block block) { - final Ruby runtime = context.getRuntime(); - - if (begin instanceof RubyFixnum && end instanceof RubyFixnum) { - long lim = ((RubyFixnum) end).getLongValue(); - if (!isExclusive) lim++; - - for (long i = ((RubyFixnum) begin).getLongValue(); i < lim; i++) { - block.yield(context, RubyFixnum.newFixnum(runtime, i)); - } - } else if (begin instanceof RubyString) { - ((RubyString) begin).upto(context, end, isExclusive, block); - } else { - if (!begin.respondsTo("succ")) throw getRuntime().newTypeError( - "can't iterate from " + begin.getMetaClass().getName()); - rangeEach(context, new RangeCallBack() { - @Override - void call(ThreadContext context, IRubyObject arg) { - block.yield(context, arg); - } - }); - } - return this; - } - - @JRubyMethod(name = "step", optional = 1, frame = true) - public IRubyObject step(ThreadContext context, IRubyObject[] args, Block block) { - final Ruby runtime = context.getRuntime(); - final IRubyObject step; - if (args.length == 0) { - step = RubyFixnum.one(runtime); - } else { - step = args[0]; - } - - long unit = RubyNumeric.num2long(step); - if (unit < 0) throw runtime.newArgumentError("step can't be negative"); - - if (begin instanceof RubyFixnum && end instanceof RubyFixnum) { - if (unit == 0) throw runtime.newArgumentError("step can't be 0"); - - long e = ((RubyFixnum)end).getLongValue(); - if (!isExclusive) e++; - - for (long i = ((RubyFixnum)begin).getLongValue(); i < e; i += unit) { - block.yield(context, RubyFixnum.newFixnum(runtime, i)); - } - } else { - IRubyObject tmp = begin.checkStringType(); - if (!tmp.isNil()) { - if (unit == 0) throw runtime.newArgumentError("step can't be 0"); - // rb_iterate((VALUE(*)_((VALUE)))str_step, (VALUE)args, step_i, (VALUE)iter); - StepBlockCallBack callback = new StepBlockCallBack(block, RubyFixnum.one(runtime), step); - Block blockCallback = CallBlock.newCallClosure(this, runtime.getRange(), Arity.singleArgument(), callback, context); - ((RubyString)tmp).upto(context, end, isExclusive, blockCallback); - } else if (begin instanceof RubyNumeric) { - if (equalInternal(context, step, RubyFixnum.zero(runtime))) { - throw runtime.newArgumentError("step can't be 0"); - } - final String method; - final int methodIndex; - if (isExclusive) { - method = "<"; - methodIndex = MethodIndex.OP_LT; - } else { - method = "<="; - methodIndex = MethodIndex.OP_LE; - } - IRubyObject beg = begin; - while (beg.callMethod(context, methodIndex, method, end).isTrue()) { - block.yield(context, beg); - beg = beg.callMethod(context, MethodIndex.OP_PLUS, "+", step); - } - } else { - if (unit == 0) throw runtime.newArgumentError("step can't be 0"); - if (!begin.respondsTo("succ")) throw runtime.newTypeError( - "can't iterate from " + begin.getMetaClass().getName()); - // range_each_func(range, step_i, b, e, args); - rangeEach(context, new StepBlockCallBack(block, RubyFixnum.one(runtime), step)); - } - } - return this; - } - - @JRubyMethod(name = {"include?", "member?", "==="}, required = 1) - public RubyBoolean include_p(ThreadContext context, IRubyObject obj) { - if (rangeLe(context, begin, obj) != null) { - if (isExclusive) { - if (rangeLt(context, obj, end) != null) return context.getRuntime().getTrue(); - } else { - if (rangeLe(context, obj, end) != null) return context.getRuntime().getTrue(); - } - } - return context.getRuntime().getFalse(); - } - - private static final ObjectMarshal RANGE_MARSHAL = new ObjectMarshal() { - public void marshalTo(Ruby runtime, Object obj, RubyClass type, - MarshalStream marshalStream) throws IOException { - RubyRange range = (RubyRange)obj; - - marshalStream.registerLinkTarget(range); - List<Variable<IRubyObject>> attrs = range.getVariableList(); - - attrs.add(new VariableEntry<IRubyObject>("begin", range.begin)); - attrs.add(new VariableEntry<IRubyObject>("end", range.end)); - attrs.add(new VariableEntry<IRubyObject>("excl", range.isExclusive ? runtime.getTrue() : runtime.getFalse())); - - marshalStream.dumpVariables(attrs); - } - - public Object unmarshalFrom(Ruby runtime, RubyClass type, - UnmarshalStream unmarshalStream) throws IOException { - RubyRange range = (RubyRange)type.allocate(); - - unmarshalStream.registerLinkTarget(range); - - unmarshalStream.defaultVariablesUnmarshal(range); - - range.begin = range.removeInternalVariable("begin"); - range.end = range.removeInternalVariable("end"); - range.isExclusive = range.removeInternalVariable("excl").isTrue(); - - return range; - } - }; -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import static org.jruby.util.Numeric.f_add; -import static org.jruby.util.Numeric.f_cmp; -import static org.jruby.util.Numeric.f_div; -import static org.jruby.util.Numeric.f_equal_p; -import static org.jruby.util.Numeric.f_expt; -import static org.jruby.util.Numeric.f_floor; -import static org.jruby.util.Numeric.f_gcd; -import static org.jruby.util.Numeric.f_idiv; -import static org.jruby.util.Numeric.f_mul; -import static org.jruby.util.Numeric.f_negate; -import static org.jruby.util.Numeric.f_negative_p; -import static org.jruby.util.Numeric.f_one_p; -import static org.jruby.util.Numeric.f_rshift; -import static org.jruby.util.Numeric.f_sub; -import static org.jruby.util.Numeric.f_to_f; -import static org.jruby.util.Numeric.f_to_i; -import static org.jruby.util.Numeric.f_to_r; -import static org.jruby.util.Numeric.f_to_s; -import static org.jruby.util.Numeric.f_truncate; -import static org.jruby.util.Numeric.f_xor; -import static org.jruby.util.Numeric.f_zero_p; -import static org.jruby.util.Numeric.i_gcd; -import static org.jruby.util.Numeric.i_ilog2; -import static org.jruby.util.Numeric.ldexp; - -import org.joni.encoding.specific.ASCIIEncoding; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.common.IRubyWarnings; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Arity; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.Frame; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.Numeric; - -/** - * 1.9 rational.c as of revision: 18876 - */ - -@JRubyClass(name = "Rational", parent = "Numeric", include = "Precision") -public class RubyRational extends RubyNumeric { - - public static RubyClass createRationalClass(Ruby runtime) { - RubyClass rationalc = runtime.defineClass("Rational", runtime.getNumeric(), RATIONAL_ALLOCATOR); // because one can Complex.send(:allocate) - runtime.setRational(rationalc); - - rationalc.index = ClassIndex.RATIONAL; - rationalc.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyRational; - } - }; - - ThreadContext context = runtime.getCurrentContext(); - rationalc.callMethod(context, "private_class_method", runtime.newSymbol("allocate")); - - rationalc.defineAnnotatedMethods(RubyRational.class); - - return rationalc; - } - - private static ObjectAllocator RATIONAL_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyRational(runtime, klass, RubyFixnum.zero(runtime), RubyFixnum.one(runtime)); - } - }; - - /** internal - * - */ - private RubyRational(Ruby runtime, IRubyObject clazz, IRubyObject num, IRubyObject den) { - super(runtime, (RubyClass)clazz); - this.num = num; - this.den = den; - } - - /** rb_rational_raw - * - */ - static RubyRational newRationalRaw(Ruby runtime, IRubyObject x, RubyObject y) { - return new RubyRational(runtime, runtime.getRational(), x, y); - } - - /** rb_rational_raw1 - * - */ - static RubyRational newRationalRaw(Ruby runtime, IRubyObject x) { - return new RubyRational(runtime, runtime.getRational(), x, RubyFixnum.one(runtime)); - } - - /** rb_rational_new1 - * - */ - static IRubyObject newRationalCanonicalize(ThreadContext context, IRubyObject x) { - return newRationalCanonicalize(context, x, RubyFixnum.one(context.getRuntime())); - } - - /** rb_rational_new - * - */ - private static IRubyObject newRationalCanonicalize(ThreadContext context, IRubyObject x, IRubyObject y) { - return canonicalizeInternal(context, context.getRuntime().getRational(), x, y); - } - - /** f_rational_new2 - * - */ - private static IRubyObject newRational(ThreadContext context, IRubyObject clazz, IRubyObject x, IRubyObject y) { - assert x instanceof RubyRational && y instanceof RubyRational; - return canonicalizeInternal(context, clazz, x, y); - } - - /** f_rational_new1 - * - */ - private static IRubyObject newRational(ThreadContext context, IRubyObject clazz, IRubyObject x) { - assert x instanceof RubyRational; - return canonicalizeInternal(context, clazz, x, RubyFixnum.one(context.getRuntime())); - } - - /** f_rational_new_no_reduce2 - * - */ - private static IRubyObject newRationalNoReduce(ThreadContext context, IRubyObject clazz, IRubyObject x, IRubyObject y) { - assert x instanceof RubyRational && y instanceof RubyRational; - return canonicalizeInternalNoReduce(context, clazz, x, y); - } - - /** f_rational_new_no_reduce1 - * - */ - private static IRubyObject newRationalNoReduce(ThreadContext context, IRubyObject clazz, IRubyObject x) { - assert x instanceof RubyRational; - return canonicalizeInternalNoReduce(context, clazz, x, RubyFixnum.one(context.getRuntime())); - } - - /** f_rational_new_bang2 - * - */ - private static RubyRational newRationalBang(ThreadContext context, IRubyObject clazz, IRubyObject x, IRubyObject y) { - assert !f_negative_p(context, y) && !(f_zero_p(context, y)); - return new RubyRational(context.getRuntime(), clazz, x, y); - } - - /** f_rational_new_bang1 - * - */ - private static RubyRational newRationalBang(ThreadContext context, IRubyObject clazz, IRubyObject x) { - return newRationalBang(context, clazz, x, RubyFixnum.one(context.getRuntime())); - } - - private IRubyObject num; - private IRubyObject den; - - /** nurat_s_new_bang - * - */ - @Deprecated - public static IRubyObject newInstanceBang(ThreadContext context, IRubyObject recv, IRubyObject[]args) { - switch (args.length) { - case 1: return newInstanceBang(context, recv, args[0]); - case 2: return newInstanceBang(context, recv, args[0], args[1]); - } - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 1); - return null; - } - - @JRubyMethod(name = "new!", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject newInstanceBang(ThreadContext context, IRubyObject recv, IRubyObject num) { - return newInstanceBang(context, recv, num, RubyFixnum.one(context.getRuntime())); - } - - @JRubyMethod(name = "new!", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject newInstanceBang(ThreadContext context, IRubyObject recv, IRubyObject num, IRubyObject den) { - if (!(num instanceof RubyInteger)) num = f_to_i(context, num); - if (!(den instanceof RubyInteger)) den = f_to_i(context, den); - - Ruby runtime = context.getRuntime(); - IRubyObject res = f_cmp(context, den, RubyFixnum.zero(runtime)); - if (res == RubyFixnum.minus_one(runtime)) { - num = f_negate(context, num); - den = f_negate(context, den); - } else if (res == RubyFixnum.zero(runtime)) { - throw runtime.newZeroDivisionError(); - } - - return new RubyRational(runtime, recv, num, den); - } - - /** nurat_int_check - * - */ - private static void intCheck(IRubyObject num) { - if (!(num instanceof RubyFixnum ) && !(num instanceof RubyBignum)) throw num.getRuntime().newArgumentError("not an integer"); - } - - /** nurat_s_canonicalize_internal - * - */ - private static IRubyObject canonicalizeInternal(ThreadContext context, IRubyObject clazz, IRubyObject num, IRubyObject den) { - Ruby runtime = context.getRuntime(); - IRubyObject res = f_cmp(context, den, RubyFixnum.zero(runtime)); - if (res == RubyFixnum.minus_one(runtime)) { - num = f_negate(context, num); - den = f_negate(context, den); - } else if (res == RubyFixnum.zero(runtime)) { - throw runtime.newZeroDivisionError(); - } - - IRubyObject gcd = f_gcd(context, num, den); - num = f_idiv(context, num, gcd); - den = f_idiv(context, den, gcd); - - if (f_one_p(context, den) && ((RubyModule)clazz).fastHasConstant("Unify")) return num; - return new RubyRational(context.getRuntime(), clazz, num, den); - } - - /** nurat_s_canonicalize_internal_no_reduce - * - */ - private static IRubyObject canonicalizeInternalNoReduce(ThreadContext context, IRubyObject clazz, IRubyObject num, IRubyObject den) { - Ruby runtime = context.getRuntime(); - IRubyObject res = f_cmp(context, den, RubyFixnum.zero(runtime)); - if (res == RubyFixnum.minus_one(runtime)) { - num = f_negate(context, num); - den = f_negate(context, den); - } else if (res == RubyFixnum.zero(runtime)) { - throw runtime.newZeroDivisionError(); - } - - if (f_equal_p(context, den, RubyFixnum.one(runtime)) && ((RubyModule)clazz).fastHasConstant("Unify")) return num; - return new RubyRational(context.getRuntime(), clazz, num, den); - } - - /** nurat_s_new - * - */ - @Deprecated - public static IRubyObject newInstance(ThreadContext context, IRubyObject clazz, IRubyObject[]args) { - switch (args.length) { - case 1: return newInstance(context, clazz, args[0]); - case 2: return newInstance(context, clazz, args[0], args[1]); - } - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 1); - return null; - } - - @JRubyMethod(name = "new", meta = true) - public static IRubyObject newInstance(ThreadContext context, IRubyObject clazz, IRubyObject num) { - intCheck(num); - return canonicalizeInternal(context, clazz, num, RubyFixnum.one(context.getRuntime())); - } - - @JRubyMethod(name = "new", meta = true) - public static IRubyObject newInstance(ThreadContext context, IRubyObject clazz, IRubyObject num, IRubyObject den) { - intCheck(num); - intCheck(den); - return canonicalizeInternal(context, clazz, num, den); - } - - /** rb_Rational1 - * - */ - public static IRubyObject newRationalConvert(ThreadContext context, IRubyObject x) { - return newRationalConvert(context, x, RubyFixnum.one(context.getRuntime())); - } - - /** rb_Rational/rb_Rational2 - * - */ - public static IRubyObject newRationalConvert(ThreadContext context, IRubyObject x, IRubyObject y) { - return convert(context, context.getRuntime().getRational(), x, y); - } - - @Deprecated - public static IRubyObject convert(ThreadContext context, IRubyObject clazz, IRubyObject[]args) { - switch (args.length) { - case 0: return convert(context, clazz); - case 1: return convert(context, clazz, args[0]); - case 2: return convert(context, clazz, args[0], args[1]); - } - Arity.raiseArgumentError(context.getRuntime(), args.length, 0, 2); - return null; - } - - /** nurat_s_convert - * - */ - @JRubyMethod(name = "convert", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject convert(ThreadContext context, IRubyObject recv) { - IRubyObject nil = context.getRuntime().getNil(); - return convertCommon(context, recv, nil, nil); - } - - /** nurat_s_convert - * - */ - @JRubyMethod(name = "convert", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject convert(ThreadContext context, IRubyObject recv, IRubyObject a1) { - return convertCommon(context, recv, a1, context.getRuntime().getNil()); - } - - /** nurat_s_convert - * - */ - @JRubyMethod(name = "convert", meta = true, visibility = Visibility.PRIVATE) - public static IRubyObject convert(ThreadContext context, IRubyObject recv, IRubyObject a1, IRubyObject a2) { - return convertCommon(context, recv, a1, a2); - } - - private static IRubyObject convertCommon(ThreadContext context, IRubyObject recv, IRubyObject a1, IRubyObject a2) { - if (a1 instanceof RubyComplex) { - RubyComplex a1Complex = (RubyComplex)a1; - if (a1Complex.getImage() instanceof RubyFloat || !f_zero_p(context, a1Complex.getImage())) { - IRubyObject s = f_to_s(context, a1); - throw context.getRuntime().newArgumentError("can't accept " + s.convertToString()); - } - a1 = a1Complex.getReal(); - } - if (a2 instanceof RubyComplex) { - RubyComplex a2Complex = (RubyComplex)a2; - if (a2Complex.getImage() instanceof RubyFloat || !f_zero_p(context, a2Complex.getImage())) { - IRubyObject s = f_to_s(context, a2); - throw context.getRuntime().newArgumentError("can't accept " + s.convertToString()); - } - a2 = a2Complex.getReal(); - } - - Frame frame = context.getCurrentFrame(); - IRubyObject backref = frame.getBackRef(); - if (backref != null && backref instanceof RubyMatchData) ((RubyMatchData)backref).use(); - - if (a1 instanceof RubyFloat) { - a1 = f_to_r(context, a1); - } else if (a1 instanceof RubyString) { - a1 = str_to_r_strict(context, a1); - } - - if (a2 instanceof RubyFloat) { - a2 = f_to_r(context, a2); - } else if (a2 instanceof RubyString) { - a2 = str_to_r_strict(context, a2); - } - - frame.setBackRef(backref); - - if (a1 instanceof RubyRational) { - if (a2.isNil() || f_zero_p(context, a2)) return a1; - return f_div(context, a1, a2); - } - - if (a2 instanceof RubyRational) { - return f_div(context, a1, a2); - } - - return a2.isNil() ? newInstance(context, recv, a1) : newInstance(context, recv, a1, a2); - } - - /** nurat_s_induced_from - * - */ - @JRubyMethod(name = "induced_from", meta = true) - public static IRubyObject induced_from(ThreadContext context, IRubyObject recv, IRubyObject arg) { - return f_to_r(context, arg); - } - - /** nurat_numerator - * - */ - @JRubyMethod(name = "numerator") - public IRubyObject numerator(ThreadContext context) { - return num; - } - - /** nurat_denominator - * - */ - @JRubyMethod(name = "denominator") - public IRubyObject denominator(ThreadContext context) { - return den; - } - - /** f_imul - * - */ - private static IRubyObject f_imul(ThreadContext context, long a, long b) { - Ruby runtime = context.getRuntime(); - if (a == 0 || b == 0) { - return RubyFixnum.zero(runtime); - } else if (a == 1) { - return RubyFixnum.newFixnum(runtime, b); - } else if (b == 1) { - return RubyFixnum.newFixnum(runtime, a); - } - - long c = a * b; - if(c / a != b) { - return RubyBignum.newBignum(runtime, a).op_mul(context, RubyBignum.newBignum(runtime, b)); - } - return RubyFixnum.newFixnum(runtime, c); - } - - /** f_addsub - * - */ - private IRubyObject f_addsub(ThreadContext context, IRubyObject anum, IRubyObject aden, IRubyObject bnum, IRubyObject bden, boolean plus) { - Ruby runtime = context.getRuntime(); - IRubyObject num, den, g, a, b; - if (anum instanceof RubyFixnum && aden instanceof RubyFixnum && - bnum instanceof RubyFixnum && bden instanceof RubyFixnum) { - long an = ((RubyFixnum)anum).getLongValue(); - long ad = ((RubyFixnum)aden).getLongValue(); - long bn = ((RubyFixnum)bnum).getLongValue(); - long bd = ((RubyFixnum)bden).getLongValue(); - long ig = i_gcd(ad, bd); - - g = RubyFixnum.newFixnum(runtime, ig); - a = f_imul(context, an, bd / ig); - b = f_imul(context, bn, ad / ig); - } else { - g = f_gcd(context, aden, bden); - a = f_mul(context, anum, f_idiv(context, bden, g)); - b = f_mul(context, bnum, f_idiv(context, aden, g)); - } - - IRubyObject c = plus ? f_add(context, a, b) : f_sub(context, a, b); - - b = f_idiv(context, aden, g); - g = f_gcd(context, c, g); - num = f_idiv(context, c, g); - a = f_idiv(context, bden, g); - den = f_mul(context, a, b); - - return RubyRational.newRationalNoReduce(context, getMetaClass(), num, den); - } - - /** nurat_add - * - */ - @JRubyMethod(name = "+") - public IRubyObject op_add(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - return f_addsub(context, num, den, other, RubyFixnum.one(context.getRuntime()), true); - case ClassIndex.FLOAT: - return f_add(context, f_to_f(context, this), other); - case ClassIndex.RATIONAL: - RubyRational otherRational = (RubyRational)other; - return f_addsub(context, num, den, otherRational.num, otherRational.den, true); - } - return coerceBin(context, "+", other); - } - - /** nurat_sub - * - */ - @JRubyMethod(name = "-") - public IRubyObject op_sub(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - return f_addsub(context, num, den, other, RubyFixnum.one(context.getRuntime()), false); - case ClassIndex.FLOAT: - return f_sub(context, f_to_f(context, this), other); - case ClassIndex.RATIONAL: - RubyRational otherRational = (RubyRational)other; - return f_addsub(context, num, den, otherRational.num, otherRational.den, false); - } - return coerceBin(context, "-", other); - } - - /** f_muldiv - * - */ - private IRubyObject f_muldiv(ThreadContext context, IRubyObject anum, IRubyObject aden, IRubyObject bnum, IRubyObject bden, boolean mult) { - if (!mult) { - if (f_negative_p(context, bnum)) { - anum = f_negate(context, anum); - bnum = f_negate(context, bnum); - } - IRubyObject tmp = bnum; - bnum = bden; - bden = tmp; - } - - final IRubyObject num, den; - if (anum instanceof RubyFixnum && aden instanceof RubyFixnum && - bnum instanceof RubyFixnum && bden instanceof RubyFixnum) { - long an = ((RubyFixnum)anum).getLongValue(); - long ad = ((RubyFixnum)aden).getLongValue(); - long bn = ((RubyFixnum)bnum).getLongValue(); - long bd = ((RubyFixnum)bden).getLongValue(); - long g1 = i_gcd(an, bd); - long g2 = i_gcd(ad, bn); - - num = f_imul(context, an / g1, bn / g2); - den = f_imul(context, ad / g2, bd / g1); - } else { - IRubyObject g1 = f_gcd(context, anum, bden); - IRubyObject g2 = f_gcd(context, aden, bnum); - - num = f_mul(context, f_idiv(context, anum, g1), f_idiv(context, bnum, g2)); - den = f_mul(context, f_idiv(context, aden, g2), f_idiv(context, bden, g1)); - } - return RubyRational.newRationalNoReduce(context, getMetaClass(), num, den); - - } - - /** nurat_mul - * - */ - @JRubyMethod(name = "*") - public IRubyObject op_mul(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - return f_muldiv(context, num, den, other, RubyFixnum.one(context.getRuntime()), true); - case ClassIndex.FLOAT: - return f_mul(context, f_to_f(context, this), other); - case ClassIndex.RATIONAL: - RubyRational otherRational = (RubyRational)other; - return f_muldiv(context, num, den, otherRational.num, otherRational.den, true); - } - return coerceBin(context, "*", other); - } - - /** nurat_div - * - */ - @JRubyMethod(name = "/") - public IRubyObject op_div(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - if (f_zero_p(context, other)) throw context.getRuntime().newZeroDivisionError(); - return f_muldiv(context, num, den, other, RubyFixnum.one(context.getRuntime()), false); - case ClassIndex.FLOAT: - return f_to_f(context, this).callMethod(context, "/", other); - case ClassIndex.RATIONAL: - if (f_zero_p(context, other)) throw context.getRuntime().newZeroDivisionError(); - RubyRational otherRational = (RubyRational)other; - return f_muldiv(context, num, den, otherRational.num, otherRational.den, false); - } - return coerceBin(context, "/", other); - } - - /** nurat_fdiv - * - */ - @JRubyMethod(name = "fdiv") - public IRubyObject op_fdiv(ThreadContext context, IRubyObject other) { - return f_div(context, f_to_f(context, this), other); - } - - /** nurat_expt - * - */ - @JRubyMethod(name = "**") - public IRubyObject op_expt(ThreadContext context, IRubyObject other) { - Ruby runtime = context.getRuntime(); - - if (f_zero_p(context, other)) { - return RubyRational.newRationalBang(context, getMetaClass(), RubyFixnum.one(runtime)); - } - - if (other instanceof RubyRational) { - RubyRational otherRational = (RubyRational)other; - if (f_one_p(context, otherRational.den)) other = otherRational.num; - } - - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - final IRubyObject tnum, tden; - IRubyObject res = f_cmp(context, other, RubyFixnum.zero(runtime)); - if (res == RubyFixnum.one(runtime)) { - tnum = f_expt(context, num, other); - tden = f_expt(context, den, other); - } else if (res == RubyFixnum.minus_one(runtime)){ - tnum = f_expt(context, den, f_negate(context, other)); - tden = f_expt(context, num, f_negate(context, other)); - } else { - tnum = tden = RubyFixnum.one(runtime); - } - return RubyRational.newRational(context, getMetaClass(), tnum, tden); - case ClassIndex.FLOAT: - case ClassIndex.RATIONAL: - return f_expt(context, f_to_f(context, this), other); - } - return coerceBin(context, "**", other); - } - - - /** nurat_cmp - * - */ - @JRubyMethod(name = "<=>") - public IRubyObject op_cmp(ThreadContext context, IRubyObject other) { - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - if (den instanceof RubyFixnum && ((RubyFixnum)den).getLongValue() == 1) return f_cmp(context, num, other); - return f_cmp(context, this, RubyRational.newRationalBang(context, getMetaClass(), other)); - - case ClassIndex.FLOAT: - return f_cmp(context, f_to_f(context, this), other); - - case ClassIndex.RATIONAL: - RubyRational otherRational = (RubyRational)other; - final IRubyObject num1, num2; - if (num instanceof RubyFixnum && den instanceof RubyFixnum && - otherRational.num instanceof RubyFixnum && otherRational.den instanceof RubyFixnum) { - num1 = f_imul(context, ((RubyFixnum)num).getLongValue(), ((RubyFixnum)otherRational.den).getLongValue()); - num2 = f_imul(context, ((RubyFixnum)otherRational.num).getLongValue(), ((RubyFixnum)den).getLongValue()); - } else { - num1 = f_mul(context, num, otherRational.den); - num2 = f_mul(context, otherRational.num, den); - } - return f_cmp(context, f_sub(context, num1, num2), RubyFixnum.zero(context.getRuntime())); - } - return coerceBin(context, "<=>", other); - } - - /** nurat_equal_p - * - */ - @JRubyMethod(name = "==") - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - Ruby runtime = context.getRuntime(); - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - if (f_zero_p(context, num) && f_zero_p(context, den)) return runtime.getTrue(); - if (!(den instanceof RubyFixnum) || ((RubyFixnum)den).getLongValue() != 1) return runtime.getFalse(); - if (f_equal_p(context, num, other)) return runtime.getTrue(); - return runtime.getFalse(); - - case ClassIndex.FLOAT: - return f_equal_p(context, f_to_f(context, this), other) ? runtime.getTrue() : runtime.getFalse(); - - case ClassIndex.RATIONAL: - RubyRational otherRational = (RubyRational)other; - if (f_zero_p(context, num) && f_zero_p(context, otherRational.num)) return runtime.getTrue(); - if (f_equal_p(context, num, otherRational.num) && f_equal_p(context, den, otherRational.den)) return runtime.getTrue(); - return runtime.getFalse(); - } - return f_equal_p(context, other, this) ? runtime.getTrue() : runtime.getFalse(); - } - - /** nurat_coerce - * - */ - @JRubyMethod(name = "coerce") - public IRubyObject op_coerce(ThreadContext context, IRubyObject other) { - Ruby runtime = context.getRuntime(); - switch (other.getMetaClass().index) { - case ClassIndex.FIXNUM: - case ClassIndex.BIGNUM: - return runtime.newArray(RubyRational.newRationalBang(context, getMetaClass(), other), this); - case ClassIndex.FLOAT: - return runtime.newArray(other, f_to_f(context, this)); - } - throw runtime.newTypeError(other.getMetaClass() + " can't be coerced into " + getMetaClass()); - } - - /** nurat_idiv - * - */ - @JRubyMethod(name = "div") - public IRubyObject op_idiv(ThreadContext context, IRubyObject other) { - return f_floor(context, f_div(context, this, other)); - } - - /** nurat_mod - * - */ - @JRubyMethod(name = {"modulo", "%"}) - public IRubyObject op_mod(ThreadContext context, IRubyObject other) { - IRubyObject val = f_floor(context, f_div(context, this, other)); - return f_sub(context, this, f_mul(context, other, val)); - } - - /** nurat_divmod - * - */ - @JRubyMethod(name = "divmod") - public IRubyObject op_divmod(ThreadContext context, IRubyObject other) { - IRubyObject val = f_floor(context, f_div(context, this, other)); - return context.getRuntime().newArray(val, f_sub(context, this, f_mul(context, other, val))); - } - - /** nurat_rem - * - */ - @JRubyMethod(name = "remainder") - public IRubyObject op_rem(ThreadContext context, IRubyObject other) { - IRubyObject val = f_truncate(context, f_div(context, this, other)); - return f_sub(context, this, f_mul(context, other, val)); - } - - /** nurat_abs - * - */ - @JRubyMethod(name = "abs") - public IRubyObject op_abs(ThreadContext context) { - if (!f_negative_p(context, this)) return this; - return f_negate(context, this); - } - - /** nurat_floor - * - */ - @JRubyMethod(name = "floor") - public IRubyObject op_floor(ThreadContext context) { - return f_idiv(context, num, den); - } - - /** nurat_ceil - * - */ - @JRubyMethod(name = "ceil") - public IRubyObject op_ceil(ThreadContext context) { - return f_negate(context, f_idiv(context, f_negate(context, num), den)); - } - - /** nurat_truncate - * - */ - @JRubyMethod(name = {"truncate", "to_i"}) - public IRubyObject op_truncate(ThreadContext context) { - if (f_negative_p(context, num)) { - return f_negate(context, f_idiv(context, f_negate(context, num), den)); - } - return f_idiv(context, num, den); - } - - /** nurat_round - * - */ - @JRubyMethod(name = "round") - public IRubyObject op_round(ThreadContext context) { - IRubyObject two = RubyFixnum.two(context.getRuntime()); - if (f_negative_p(context, num)) { - IRubyObject tnum = f_negate(context, num); - tnum = f_add(context, f_mul(context, tnum, two), den); - IRubyObject tden = f_mul(context, den, two); - return f_negate(context, f_idiv(context, tnum, tden)); - } else { - IRubyObject tnum = f_add(context, f_mul(context, num, two), den); - IRubyObject tden = f_mul(context, den, two); - return f_idiv(context, tnum, tden); - } - } - - /** nurat_to_f - * - */ - private static long ML = (long)(Math.log(Double.MAX_VALUE) / Math.log(2.0) - 1); - @JRubyMethod(name = "to_f") - public IRubyObject to_f(ThreadContext context) { - Ruby runtime = context.getRuntime(); - if (f_zero_p(context, num)) return runtime.newFloat(0); - - IRubyObject num = this.num; - IRubyObject den = this.den; - - boolean minus = false; - if (f_negative_p(context, num)) { - num = f_negate(context, num); - minus = true; - } - - long nl = i_ilog2(context, num); - long dl = i_ilog2(context, den); - - long ne = 0; - if (nl > ML) { - ne = nl - ML; - num = f_rshift(context, num, RubyFixnum.newFixnum(runtime, ne)); - } - - long de = 0; - if (dl > ML) { - de = dl - ML; - den = f_rshift(context, den, RubyFixnum.newFixnum(runtime, de)); - } - - long e = ne - de; - - if (e > 1023 || e < -1022) { - runtime.getWarnings().warn(IRubyWarnings.ID.FLOAT_OUT_OF_RANGE, "out of Float range", getMetaClass()); - return runtime.newFloat(e > 0 ? Double.MAX_VALUE : 0); - } - - double f = RubyNumeric.num2dbl(num) / RubyNumeric.num2dbl(den); - - if (minus) { - f = -f; - f = ldexp(f, e); - } - - if (Double.isInfinite(f) || Double.isNaN(f)) { - runtime.getWarnings().warn(IRubyWarnings.ID.FLOAT_OUT_OF_RANGE, "out of Float range", getMetaClass()); - } - - return runtime.newFloat(f); - } - - /** nurat_to_r - * - */ - @JRubyMethod(name = "to_r") - public IRubyObject to_r(ThreadContext context) { - return this; - } - - /** nurat_to_r - * - */ - @JRubyMethod(name = "hash") - public IRubyObject hash(ThreadContext context) { - return f_xor(context, num, den); - } - - /** nurat_to_s - * - */ - @JRubyMethod(name = "to_s") - public IRubyObject to_s(ThreadContext context) { - return RuntimeHelpers.invoke(context, context.getRuntime().getKernel(), "format", context.getRuntime().newString("%d/%d"), num, den); - } - - /** nurat_inspect - * - */ - @JRubyMethod(name = "inspect") - public IRubyObject inspect(ThreadContext context) { - return RuntimeHelpers.invoke(context, context.getRuntime().getKernel(), "format", context.getRuntime().newString("(%d/%d)"), num, den); - } - - /** nurat_marshal_dump - * - */ - @JRubyMethod(name = "marshal_dump") - public IRubyObject marshal_dump(ThreadContext context) { - return context.getRuntime().newArray(num, den); - } - - /** nurat_marshal_load - * - */ - @JRubyMethod(name = "marshal_load") - public IRubyObject marshal_load(ThreadContext context, IRubyObject arg) { - RubyArray a = arg.convertToArray(); - num = a.size() > 0 ? a.eltInternal(0) : context.getRuntime().getNil(); - den = a.size() > 1 ? a.eltInternal(1) : context.getRuntime().getNil(); - - if (f_zero_p(context, den)) throw context.getRuntime().newZeroDivisionError(); - return this; - } - - /** rb_gcd - * - */ - @JRubyMethod(name = "gcd") - public IRubyObject gcd(ThreadContext context, IRubyObject other) { - intCheck(other); - return f_gcd(context, this, other); - } - - /** rb_lcm - * - */ - @JRubyMethod(name = "lcm") - public IRubyObject lcm(ThreadContext context, IRubyObject other) { - intCheck(other); - return Numeric.f_lcm(context, this, other); - } - - /** rb_gcdlcm - * - */ - @JRubyMethod(name = "gcdlcm") - public IRubyObject gcdlcm(ThreadContext context, IRubyObject other) { - intCheck(other); - return context.getRuntime().newArray(f_gcd(context, this, other), Numeric.f_lcm(context, this, other)); - } - - - static RubyArray str_to_r_internal(ThreadContext context, IRubyObject recv) { - RubyString s = recv.callMethod(context, "strip").convertToString(); - ByteList bytes = s.getByteList(); - - Ruby runtime = context.getRuntime(); - if (bytes.realSize == 0) return runtime.newArray(runtime.getNil(), recv); - - IRubyObject m = RubyRegexp.newRegexp(runtime, Numeric.RationalPatterns.rat_pat).callMethod(context, "match", s); - - if (!m.isNil()) { - IRubyObject si = m.callMethod(context, "[]", RubyFixnum.one(runtime)); - IRubyObject nu = m.callMethod(context, "[]", RubyFixnum.two(runtime)); - IRubyObject de = m.callMethod(context, "[]", RubyFixnum.three(runtime)); - IRubyObject re = m.callMethod(context, "post_match"); - - RubyArray a = nu.callMethod(context, "split", RubyRegexp.newRegexp(runtime, Numeric.RationalPatterns.an_e_pat)).convertToArray(); - IRubyObject ifp = a.eltInternal(0); - IRubyObject exp = a.size() != 2 ? runtime.getNil() : a.eltInternal(1); - - a = ifp.callMethod(context, "split", RubyRegexp.newRegexp(runtime, Numeric.RationalPatterns.a_dot_pat)).convertToArray(); - IRubyObject ip = a.eltInternal(0); - IRubyObject fp = a.size() != 2 ? runtime.getNil() : a.eltInternal(1); - - IRubyObject v = RubyRational.newRationalCanonicalize(context, f_to_i(context, ip)); - - if (!fp.isNil()) { - bytes = fp.convertToString().getByteList(); - int count = 0; - byte[]buf = bytes.bytes; - int i = bytes.begin; - int end = i + bytes.realSize; - while (i < end) if (ASCIIEncoding.INSTANCE.isDigit(buf[i++])) count++; - IRubyObject l = f_expt(context, RubyFixnum.newFixnum(runtime, 10), RubyFixnum.newFixnum(runtime, count)); - v = f_mul(context, v, l); - v = f_add(context, v, f_to_i(context, fp)); - v = f_div(context, v, l); - } - if (!exp.isNil()) { - v = f_mul(context, v, f_expt(context, RubyFixnum.newFixnum(runtime, 10), f_to_i(context, exp))); - } - if (!si.isNil()) { - bytes = si.convertToString().getByteList(); - if (bytes.length() > 0 && bytes.get(0) == '-') v = f_negate(context, v); - } - if (!de.isNil()) { - v = f_div(context, v, f_to_i(context, de)); - } - return runtime.newArray(v, re); - } - return runtime.newArray(runtime.getNil(), recv); - } - - private static IRubyObject str_to_r_strict(ThreadContext context, IRubyObject recv) { - RubyArray a = str_to_r_internal(context, recv); - if (a.eltInternal(0).isNil() || a.eltInternal(1).convertToString().getByteList().length() > 0) { - IRubyObject s = recv.callMethod(context, "inspect"); - throw context.getRuntime().newArgumentError("invalid value for Rational: " + s.convertToString()); - } - return a.eltInternal(0); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004-2005 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 David Corbin <dcorbin@users.sourceforge.net> - * Copyright (C) 2006 Nick Sieger <nicksieger@gmail.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.lang.ref.SoftReference; -import java.util.concurrent.ConcurrentHashMap; -import java.util.Iterator; -import java.util.Map; - -import org.joni.Matcher; -import org.joni.NameEntry; -import org.joni.Option; -import org.joni.Regex; -import org.joni.Region; -import org.joni.Syntax; -import org.joni.WarnCallback; -import org.joni.encoding.Encoding; -import org.joni.exception.JOniException; - -import static org.jruby.anno.FrameField.*; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.parser.ReOptions; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.Frame; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.ByteList; -import org.jruby.util.KCode; -import org.jruby.util.TypeConverter; - -/** - * - */ -@JRubyClass(name="Regexp") -public class RubyRegexp extends RubyObject implements ReOptions, WarnCallback { - private KCode kcode; - private Regex pattern; - private ByteList str; - - private static final int REGEXP_LITERAL_F = 1 << 11; - private static final int REGEXP_KCODE_DEFAULT = 1 << 12; - - public void setLiteral() { - flags |= REGEXP_LITERAL_F; - } - - public void clearLiteral() { - flags &= ~REGEXP_LITERAL_F; - } - - public boolean isLiteral() { - return (flags & REGEXP_LITERAL_F) != 0; - } - - public void setKCodeDefault() { - flags |= REGEXP_KCODE_DEFAULT; - } - - public void clearKCodeDefault() { - flags &= ~REGEXP_KCODE_DEFAULT; - } - - public boolean isKCodeDefault() { - return (flags & REGEXP_KCODE_DEFAULT) != 0; - } - - public KCode getKCode() { - return kcode; - } - - private static Map<ByteList, Regex> getPatternCache() { - Map<ByteList, Regex> cache = patternCache.get(); - if (cache == null) { - cache = new ConcurrentHashMap<ByteList, Regex>(5); - patternCache = new SoftReference<Map<ByteList, Regex>>(cache); - } - return cache; - } - - static volatile SoftReference<Map<ByteList, Regex>> patternCache = new SoftReference<Map<ByteList, Regex>>(null); - - public static RubyClass createRegexpClass(Ruby runtime) { - RubyClass regexpClass = runtime.defineClass("Regexp", runtime.getObject(), REGEXP_ALLOCATOR); - runtime.setRegexp(regexpClass); - regexpClass.index = ClassIndex.REGEXP; - regexpClass.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyRegexp; - } - }; - - regexpClass.defineConstant("IGNORECASE", runtime.newFixnum(RE_OPTION_IGNORECASE)); - regexpClass.defineConstant("EXTENDED", runtime.newFixnum(RE_OPTION_EXTENDED)); - regexpClass.defineConstant("MULTILINE", runtime.newFixnum(RE_OPTION_MULTILINE)); - - regexpClass.defineAnnotatedMethods(RubyRegexp.class); - - return regexpClass; - } - - private static ObjectAllocator REGEXP_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - RubyRegexp instance = new RubyRegexp(runtime, klass); - return instance; - } - }; - - /** used by allocator - * - */ - private RubyRegexp(Ruby runtime, RubyClass klass) { - super(runtime, klass); - } - - /** default constructor - * - */ - private RubyRegexp(Ruby runtime) { - super(runtime, runtime.getRegexp()); - } - - // used only by the compiler/interpreter (will set the literal flag) - public static RubyRegexp newRegexp(Ruby runtime, String pattern, int options) { - return newRegexp(runtime, ByteList.create(pattern), options); - } - - // used only by the compiler/interpreter (will set the literal flag) - public static RubyRegexp newRegexp(Ruby runtime, ByteList pattern, int options) { - RubyRegexp regexp = newRegexp(runtime, pattern, options, false); - regexp.setLiteral(); - return regexp; - } - - public static RubyRegexp newRegexp(Ruby runtime, ByteList pattern, int options, boolean quote) { - RubyRegexp regexp = new RubyRegexp(runtime); - regexp.initialize(pattern, options, quote); - return regexp; - } - - // internal usage - static RubyRegexp newRegexp(Ruby runtime, Regex regex) { - RubyRegexp regexp = new RubyRegexp(runtime); - regexp.pattern = regex; - regexp.str = ByteList.EMPTY_BYTELIST; - return regexp; - } - - public void warn(String message) { - getRuntime().getWarnings().warn(ID.MISCELLANEOUS, message); - } - - @JRubyMethod(name = "kcode") - public IRubyObject kcode(ThreadContext context) { - return (!isKCodeDefault() && kcode != null) ? - context.getRuntime().newString(kcode.name()) : context.getRuntime().getNil(); - } - - @Override - public int getNativeTypeIndex() { - return ClassIndex.REGEXP; - } - - public Regex getPattern() { - return pattern; - } - - private void check() { - if (pattern == null || str == null) throw getRuntime().newTypeError("uninitialized Regexp"); - } - - @JRubyMethod(name = "hash") - @Override - public RubyFixnum hash() { - check(); - int hashval = (int)pattern.getOptions(); - int len = this.str.realSize; - int p = this.str.begin; - while (len-->0) { - hashval = hashval * 33 + str.bytes[p++]; - } - hashval = hashval + (hashval>>5); - return getRuntime().newFixnum(hashval); - } - - @JRubyMethod(name = {"==", "eql?"}, required = 1) - @Override - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - if(this == other) return context.getRuntime().getTrue(); - if(!(other instanceof RubyRegexp)) return context.getRuntime().getFalse(); - RubyRegexp otherRegex = (RubyRegexp)other; - - check(); - otherRegex.check(); - - return context.getRuntime().newBoolean(str.equal(otherRegex.str) && - kcode == otherRegex.kcode && pattern.getOptions() == otherRegex.pattern.getOptions()); - } - - @JRubyMethod(name = "~", reads = {LASTLINE, BACKREF}, writes = BACKREF) - public IRubyObject op_match2(ThreadContext context) { - Ruby runtime = context.getRuntime(); - IRubyObject line = context.getCurrentFrame().getLastLine(); - if(!(line instanceof RubyString)) { - context.getCurrentFrame().setBackRef(runtime.getNil()); - return runtime.getNil(); - } - int start = search(context, (RubyString)line, 0, false); - if(start < 0) { - return runtime.getNil(); - } else { - return runtime.newFixnum(start); - } - } - - /** rb_reg_eqq - * - */ - @JRubyMethod(name = "===", required = 1, writes = BACKREF) - public IRubyObject eqq(ThreadContext context, IRubyObject str) { - Ruby runtime = context.getRuntime(); - if(!(str instanceof RubyString)) str = str.checkStringType(); - - if (str.isNil()) { - context.getCurrentFrame().setBackRef(runtime.getNil()); - return runtime.getFalse(); - } - int start = search(context, (RubyString)str, 0, false); - return (start < 0) ? runtime.getFalse() : runtime.getTrue(); - } - - private static final int REGEX_QUOTED = 1; - private void initialize(ByteList bytes, int options, boolean quote) { - if (!isTaint() && getRuntime().getSafeLevel() >= 4) throw getRuntime().newSecurityError("Insecure: can't modify regexp"); - checkFrozen(); - if (isLiteral()) throw getRuntime().newSecurityError("can't modify literal regexp"); - - setKCode(options); - - Map<ByteList, Regex> cache = getPatternCache(); - Regex pat = cache.get(bytes); - - if (pat != null && - pat.getEncoding() == kcode.getEncoding() && - pat.getOptions() == (options & 0xf) && - ((pat.getUserOptions() & REGEX_QUOTED) != 0) == quote) { // cache hit - pattern = pat; - } else { - if (quote) bytes = quote(bytes, getRuntime().getKCode()); - makeRegexp(bytes, bytes.begin, bytes.realSize, options & 0xf, kcode.getEncoding()); - if (quote) pattern.setUserOptions(REGEX_QUOTED); - cache.put(bytes, pattern); - } - - str = bytes; - } - - private void makeRegexp(ByteList bytes, int start, int len, int flags, Encoding enc) { - try { - pattern = new Regex(bytes.bytes, start, start + len, flags, enc, Syntax.DEFAULT, this); - } catch(Exception e) { - rb_reg_raise(bytes.bytes, start, len, e.getMessage(), flags); - } - } - - private final void rb_reg_raise(byte[] s, int start, int len, String err,int flags) { - throw getRuntime().newRegexpError(err + ": " + rb_reg_desc(s,start, len,flags)); - } - - private final StringBuilder rb_reg_desc(byte[] s, int start, int len, int flags) { - StringBuilder sb = new StringBuilder("/"); - rb_reg_expr_str(sb, s, start, len); - sb.append("/"); - - if((flags & ReOptions.RE_OPTION_MULTILINE) != 0) sb.append("m"); - if((flags & ReOptions.RE_OPTION_IGNORECASE) != 0) sb.append("i"); - if((flags & ReOptions.RE_OPTION_EXTENDED) != 0) sb.append("x"); - - if (kcode != null && !isKCodeDefault()) { - sb.append(kcode.name().charAt(0)); - } - return sb; - } - - private final void rb_reg_expr_str(StringBuilder sb, byte[] s, int start, int len) { - int p,pend; - boolean need_escape = false; - p = start; - pend = start+len; - Encoding enc = kcode.getEncoding(); - while(p<pend) { - if(s[p] == '/' || (!(' ' == s[p] || (!Character.isWhitespace(s[p]) && - !Character.isISOControl(s[p]))) && - enc.length(s[p])==1)) { - need_escape = true; - break; - } - p += enc.length(s[p]); - } - if(!need_escape) { - sb.append(new ByteList(s,start,len,false).toString()); - } else { - p = 0; - while(p < pend) { - if(s[p] == '\\') { - int n = enc.length(s[p+1]) + 1; - sb.append(new ByteList(s,p,n,false).toString()); - p += n; - continue; - } else if(s[p] == '/') { - sb.append("\\/"); - } else if(enc.length(s[p])!=1) { - sb.append(new ByteList(s,p,enc.length(s[p]),false).toString()); - p += enc.length(s[p]); - continue; - } else if((' ' == s[p] || (!Character.isWhitespace(s[p]) && - !Character.isISOControl(s[p])))) { - sb.append((char)(s[p]&0xFF)); - } else if(!Character.isWhitespace((char)(s[p]&0xFF))) { - sb.append('\\'); - sb.append(Integer.toString((int)(s[p]&0377),8)); - } else { - sb.append((char)(s[p]&0xFF)); - } - p++; - } - } - } - - /** rb_reg_init_copy - */ - @JRubyMethod(name = "initialize_copy", required = 1) - @Override - public IRubyObject initialize_copy(IRubyObject re) { - if(this == re) return this; - - checkFrozen(); - - if (getMetaClass().getRealClass() != re.getMetaClass().getRealClass()) { - throw getRuntime().newTypeError("wrong argument type"); - } - - RubyRegexp regexp = (RubyRegexp)re; - regexp.check(); - - initialize(regexp.str, regexp.getOptions(), false); - - return this; - } - - /** rb_set_kcode - */ - private int getKcode() { - if(kcode == KCode.NONE) { - return 16; - } else if(kcode == KCode.EUC) { - return 32; - } else if(kcode == KCode.SJIS) { - return 48; - } else if(kcode == KCode.UTF8) { - return 64; - } - return 0; - } - - /** - */ - private void setKCode(int options) { - clearKCodeDefault(); - switch(options & ~0xf) { - case 0: - default: - setKCodeDefault(); - kcode = getRuntime().getKCode(); - break; - case 16: - kcode = KCode.NONE; - break; - case 32: - kcode = KCode.EUC; - break; - case 48: - kcode = KCode.SJIS; - break; - case 64: - kcode = KCode.UTF8; - break; - } - } - - /** rb_reg_options - */ - private int getOptions() { - check(); - int options = (int)(pattern.getOptions() & (RE_OPTION_IGNORECASE|RE_OPTION_MULTILINE|RE_OPTION_EXTENDED)); - if(!isKCodeDefault()) { - options |= getKcode(); - } - return options; - } - - /** rb_reg_initialize_m - */ - @JRubyMethod(name = "initialize", optional = 3, visibility = Visibility.PRIVATE) - public IRubyObject initialize_m(IRubyObject[] args) { - ByteList bytes; - int regexFlags = 0; - - if(args[0] instanceof RubyRegexp) { - if(args.length > 1) { - getRuntime().getWarnings().warn(ID.REGEXP_IGNORED_FLAGS, "flags" + (args.length == 3 ? " and encoding" : "") + " ignored"); - } - RubyRegexp regexp = (RubyRegexp)args[0]; - regexp.check(); - - regexFlags = (int)regexp.pattern.getOptions() & 0xF; - if (!regexp.isKCodeDefault() && regexp.kcode != null && regexp.kcode != KCode.NIL) { - if (regexp.kcode == KCode.NONE) { - regexFlags |= 16; - } else if (regexp.kcode == KCode.EUC) { - regexFlags |= 32; - } else if (regexp.kcode == KCode.SJIS) { - regexFlags |= 48; - } else if (regexp.kcode == KCode.UTF8) { - regexFlags |= 64; - } - } - bytes = regexp.str; - } else { - if (args.length >= 2) { - if (args[1] instanceof RubyFixnum) { - regexFlags = RubyNumeric.fix2int(args[1]); - } else if (args[1].isTrue()) { - regexFlags = RE_OPTION_IGNORECASE; - } - } - if (args.length == 3 && !args[2].isNil()) { - ByteList kcodeBytes = args[2].convertToString().getByteList(); - char first = kcodeBytes.length() > 0 ? kcodeBytes.charAt(0) : 0; - regexFlags &= ~0x70; - switch (first) { - case 'n': case 'N': - regexFlags |= 16; - break; - case 'e': case 'E': - regexFlags |= 32; - break; - case 's': case 'S': - regexFlags |= 48; - break; - case 'u': case 'U': - regexFlags |= 64; - break; - default: - break; - } - } - bytes = args[0].convertToString().getByteList(); - } - initialize(bytes, regexFlags, false); - - return this; - } - - @JRubyMethod(name = {"new", "compile"}, required = 1, optional = 2, meta = true) - public static RubyRegexp newInstance(IRubyObject recv, IRubyObject[] args) { - RubyClass klass = (RubyClass)recv; - - RubyRegexp re = (RubyRegexp) klass.allocate(); - re.callInit(args, Block.NULL_BLOCK); - - return re; - } - - @JRubyMethod(name = "options") - public IRubyObject options() { - return getRuntime().newFixnum(getOptions()); - } - - /** rb_reg_search - */ - public int search(ThreadContext context, RubyString str, int pos, boolean reverse) { - Ruby runtime = context.getRuntime(); - Frame frame = context.getCurrentRubyFrame(); - - ByteList value = str.getByteList(); - if (pos > value.realSize || pos < 0) { - frame.setBackRef(runtime.getNil()); - return -1; - } - - return performSearch(reverse, pos, value, frame, runtime, context, str); - } - - private int performSearch(boolean reverse, int pos, ByteList value, Frame frame, Ruby runtime, ThreadContext context, RubyString str) { - check(); - - int realSize = value.realSize; - int begin = value.begin; - int range = reverse ? -pos : realSize - pos; - - Matcher matcher = pattern.matcher(value.bytes, begin, begin + realSize); - - int result = matcher.search(begin + pos, begin + pos + range, Option.NONE); - - if (result < 0) { - frame.setBackRef(runtime.getNil()); - return result; - } - - updateBackRef(context, str, frame, matcher); - - return result; - } - - final RubyMatchData updateBackRef(ThreadContext context, RubyString str, Frame frame, Matcher matcher) { - Ruby runtime = context.getRuntime(); - IRubyObject backref = frame.getBackRef(); - final RubyMatchData match; - if (backref == null || backref.isNil() || ((RubyMatchData)backref).used()) { - match = new RubyMatchData(runtime); - } else { - match = (RubyMatchData)backref; - match.setTaint(runtime.getSafeLevel() >= 3); - } - - match.regs = matcher.getRegion(); // lazy, null when no groups defined - match.begin = matcher.getBegin(); - match.end = matcher.getEnd(); - - match.str = (RubyString)str.strDup(runtime).freeze(context); - match.pattern = pattern; - - frame.setBackRef(match); - - match.infectBy(this); - match.infectBy(str); - return match; - } - - /** rb_reg_match - * - */ - @JRubyMethod(name = "=~", required = 1, reads = BACKREF, writes = BACKREF) - @Override - public IRubyObject op_match(ThreadContext context, IRubyObject str) { - int start; - if(str.isNil()) { - context.getCurrentFrame().setBackRef(context.getRuntime().getNil()); - return str; - } - - start = search(context, str.convertToString(), 0, false); - - if (start < 0) return context.getRuntime().getNil(); - - return RubyFixnum.newFixnum(context.getRuntime(), start); - } - - /** rb_reg_match_m - * - */ - @JRubyMethod(name = "match", required = 1, reads = BACKREF) - public IRubyObject match_m(ThreadContext context, IRubyObject str) { - if (op_match(context, str).isNil()) return context.getRuntime().getNil(); - - IRubyObject result = context.getCurrentFrame().getBackRef(); - if (result instanceof RubyMatchData) { - ((RubyMatchData)result).use(); - } - return result; - } - - - public RubyString regsub(RubyString str, RubyString src, Matcher matcher) { - Region regs = matcher.getRegion(); - int mbeg = matcher.getBegin(); - int mend = matcher.getEnd(); - - int p,s,e; - p = s = 0; - int no = -1; - ByteList bs = str.getByteList(); - ByteList srcbs = src.getByteList(); - e = bs.length(); - RubyString val = null; - Encoding enc = kcode.getEncoding(); - - int beg, end; - while(s < e) { - int ss = s; - char c = bs.charAt(s++); - if(enc.length((byte)c) != 1) { - s += enc.length((byte)c) - 1; - continue; - } - if (c != '\\' || s == e) continue; - if (val == null) val = RubyString.newString(getRuntime(), new ByteList(ss - p)); - - val.cat(bs.bytes, bs.begin + p, ss - p); - c = bs.charAt(s++); - p = s; - - switch(c) { - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - no = c - '0'; - break; - case '&': - no = 0; - break; - case '`': - beg = regs == null ? mbeg : regs.beg[0]; - val.cat(srcbs.bytes, srcbs.begin, beg); - continue; - - case '\'': - end = regs == null ? mend : regs.end[0]; - val.cat(srcbs.bytes, srcbs.begin + end, src.getByteList().realSize - end); - continue; - - case '+': - if (regs == null) { - if (mbeg == -1) { - no = 0; - continue; - } - } else { - no = regs.numRegs-1; - while(regs.beg[no] == -1 && no > 0) no--; - if (no == 0) continue; - } - break; - case '\\': - val.cat(bs.bytes, s - 1, 1); - continue; - default: - val.cat(bs.bytes, s - 2, 2); - continue; - } - - if (regs != null) { - if (no >= 0) { - if (no >= regs.numRegs || regs.beg[no] == -1) continue; - val.cat(srcbs.bytes, srcbs.begin + regs.beg[no], regs.end[no] - regs.beg[no]); - } - } else { - if (no != 0 || mbeg == -1) continue; - val.cat(srcbs.bytes, srcbs.begin + mbeg, mend - mbeg); - } - } - - if(p < e) { - if(val == null) { - val = RubyString.newString(getRuntime(), bs.makeShared(p, e-p)); - } else { - val.cat(bs.bytes, bs.begin + p, e - p); - } - } - if (val == null) return str; - - return val; - } - - final int adjustStartPos(RubyString str, int pos, boolean reverse) { - check(); - ByteList value = str.getByteList(); - return pattern.adjustStartPosition(value.bytes, value.begin, value.realSize, pos, reverse); - } - - @JRubyMethod(name = "casefold?") - public IRubyObject casefold_p(ThreadContext context) { - check(); - - return context.getRuntime().newBoolean((pattern.getOptions() & RE_OPTION_IGNORECASE) != 0); - } - - /** rb_reg_source - * - */ - @JRubyMethod(name = "source") - public IRubyObject source() { - Ruby runtime = getRuntime(); - check(); - RubyString str = RubyString.newStringShared(runtime, this.str); - if(isTaint()) { - str.taint(runtime.getCurrentContext()); - } - return str; - } - - final int length() { - return str.realSize; - } - - /** rb_reg_inspect - * - */ - @JRubyMethod(name = "inspect") - @Override - public IRubyObject inspect() { - check(); - return getRuntime().newString(ByteList.create(rb_reg_desc(str.bytes, str.begin, str.realSize, pattern.getOptions()).toString())); - } - - private final static int EMBEDDABLE = RE_OPTION_MULTILINE|RE_OPTION_IGNORECASE|RE_OPTION_EXTENDED; - - @JRubyMethod(name = "to_s") - @Override - public IRubyObject to_s() { - RubyString ss = getRuntime().newString("(?"); - check(); - - int options = pattern.getOptions(); - int ptr = str.begin; - int len = str.realSize; - byte[] bytes = str.bytes; - again: do { - if (len >= 4 && bytes[ptr] == '(' && bytes[ptr + 1] == '?') { - boolean err = true; - ptr += 2; - if ((len -= 2) > 0) { - do { - if (bytes[ptr] == 'm') { - options |= RE_OPTION_MULTILINE; - } else if (bytes[ptr] == 'i') { - options |= RE_OPTION_IGNORECASE; - } else if (bytes[ptr] == 'x') { - options |= RE_OPTION_EXTENDED; - } else { - break; - } - ptr++; - } while(--len > 0); - } - if (len > 1 && bytes[ptr] == '-') { - ++ptr; - --len; - do { - if (bytes[ptr] == 'm') { - options &= ~RE_OPTION_MULTILINE; - } else if (bytes[ptr] == 'i') { - options &= ~RE_OPTION_IGNORECASE; - } else if (bytes[ptr] == 'x') { - options &= ~RE_OPTION_EXTENDED; - } else { - break; - } - ptr++; - } while(--len > 0); - } - - if (bytes[ptr] == ')') { - --len; - ++ptr; - continue again; - } - - if (bytes[ptr] == ':' && bytes[ptr + len - 1] == ')') { - try { - new Regex(bytes, ++ptr, ptr + (len-=2) ,Option.DEFAULT, kcode.getEncoding(), Syntax.DEFAULT); - err = false; - } catch (JOniException e) { - err = true; - } - } - - if (err) { - options = (int)pattern.getOptions(); - ptr = str.begin; - len = str.realSize; - } - } - if ((options & RE_OPTION_MULTILINE) !=0 ) ss.cat((byte)'m'); - if ((options & RE_OPTION_IGNORECASE) !=0 ) ss.cat((byte)'i'); - if ((options & RE_OPTION_EXTENDED) !=0 ) ss.cat((byte)'x'); - - if ((options & EMBEDDABLE) != EMBEDDABLE) { - ss.cat((byte)'-'); - if ((options & RE_OPTION_MULTILINE) == 0) ss.cat((byte)'m'); - if ((options & RE_OPTION_IGNORECASE) == 0) ss.cat((byte)'i'); - if ((options & RE_OPTION_EXTENDED) == 0) ss.cat((byte)'x'); - } - ss.cat((byte)':'); - rb_reg_expr_str(ss, ptr, len); - ss.cat((byte)')'); - ss.infectBy(this); - return ss; - } while(true); - } - - private final void rb_reg_expr_str(RubyString ss, int s, int len) { - int p = s; - int pend = p + len; - boolean need_escape = false; - Encoding enc = kcode.getEncoding(); - while (p < pend) { - if (str.bytes[p] == '/' || (!enc.isPrint(str.bytes[p] & 0xff) && enc.length(str.bytes[p]) == 1)) { - need_escape = true; - break; - } - p += enc.length(str.bytes[p]); - } - if (!need_escape) { - ss.cat(str.bytes, s, len); - } else { - p = s; - while (p<pend) { - if (str.bytes[p] == '\\') { - int n = enc.length(str.bytes[p+1]) + 1; - ss.cat(str.bytes, p, n); - p += n; - continue; - } else if (str.bytes[p] == '/') { - ss.cat((byte)'\\'); - ss.cat(str.bytes, p, 1); - } else if (enc.length(str.bytes[p]) != 1) { - ss.cat(str.bytes, p, enc.length(str.bytes[p])); - p += enc.length(str.bytes[p]); - continue; - } else if (enc.isPrint(str.bytes[p] & 0xff)) { - ss.cat(str.bytes,p,1); - } else if (!enc.isSpace(str.bytes[p] & 0xff)) { - ss.cat(ByteList.create(Integer.toString(str.bytes[p] & 0377, 8))); - } else { - ss.cat(str.bytes, p, 1); - } - p++; - } - } - } - - /** rb_reg_s_quote - * - */ - @JRubyMethod(name = {"quote", "escape"}, required = 1, optional = 1, meta = true) - public static RubyString quote(IRubyObject recv, IRubyObject[] args) { - IRubyObject kcode = args.length == 2 ? args[1] : null; - IRubyObject str = args[0]; - KCode code = recv.getRuntime().getKCode(); - - if (kcode != null && !kcode.isNil()) { - code = KCode.create(recv.getRuntime(), kcode.toString()); - } - - RubyString src = str.convertToString(); - RubyString dst = RubyString.newString(recv.getRuntime(), quote(src.getByteList(), code)); - dst.infectBy(src); - return dst; - } - - /** rb_reg_quote - * - */ - public static ByteList quote(ByteList str, KCode kcode) { - ByteList bs = str; - int tix = 0; - int s = bs.begin; - char c; - int send = s+bs.length(); - Encoding enc = kcode.getEncoding(); - meta_found: do { - for(; s<send; s++) { - c = (char)(bs.bytes[s]&0xFF); - if(enc.length((byte)c) != 1) { - int n = enc.length((byte)c); - while(n-- > 0 && s < send) { - s++; - } - s--; - continue; - } - switch (c) { - case '[': case ']': case '{': case '}': - case '(': case ')': case '|': case '-': - case '*': case '.': case '\\': - case '?': case '+': case '^': case '$': - case ' ': case '#': - case '\t': case '\f': case '\n': case '\r': - break meta_found; - } - } - return bs; - } while(false); - ByteList b1 = new ByteList(send*2); - System.arraycopy(bs.bytes,bs.begin,b1.bytes,b1.begin,s-bs.begin); - tix += (s-bs.begin); - - for(; s<send; s++) { - c = (char)(bs.bytes[s]&0xFF); - if(enc.length((byte)c) != 1) { - int n = enc.length((byte)c); - while(n-- > 0 && s < send) { - b1.bytes[tix++] = bs.bytes[s++]; - } - s--; - continue; - } - - switch(c) { - case '[': case ']': case '{': case '}': - case '(': case ')': case '|': case '-': - case '*': case '.': case '\\': - case '?': case '+': case '^': case '$': - case '#': - b1.bytes[tix++] = '\\'; - break; - case ' ': - b1.bytes[tix++] = '\\'; - b1.bytes[tix++] = ' '; - continue; - case '\t': - b1.bytes[tix++] = '\\'; - b1.bytes[tix++] = 't'; - continue; - case '\n': - b1.bytes[tix++] = '\\'; - b1.bytes[tix++] = 'n'; - continue; - case '\r': - b1.bytes[tix++] = '\\'; - b1.bytes[tix++] = 'r'; - continue; - case '\f': - b1.bytes[tix++] = '\\'; - b1.bytes[tix++] = 'f'; - continue; - } - b1.bytes[tix++] = (byte)c; - } - b1.realSize = tix; - return b1; - } - - - /** rb_reg_nth_match - * - */ - public static IRubyObject nth_match(int nth, IRubyObject match) { - if (match.isNil()) return match; - RubyMatchData m = (RubyMatchData)match; - - int start, end; - - if (m.regs == null) { - if (nth >= 1) return match.getRuntime().getNil(); - if (nth < 0 && ++nth <= 0) return match.getRuntime().getNil(); - start = m.begin; - end = m.end; - } else { - if (nth >= m.regs.numRegs) return match.getRuntime().getNil(); - if (nth < 0 && (nth+=m.regs.numRegs) <= 0) return match.getRuntime().getNil(); - start = m.regs.beg[nth]; - end = m.regs.end[nth]; - } - - if (start == -1) return match.getRuntime().getNil(); - - RubyString str = m.str.makeShared(match.getRuntime(), start, end - start); - str.infectBy(match); - return str; - } - - /** rb_reg_last_match - * - */ - public static IRubyObject last_match(IRubyObject match) { - return nth_match(0, match); - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public static IRubyObject last_match_s(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - switch (args.length) { - case 0: - return last_match_s(context, recv); - case 1: - return last_match_s(context, recv, args[0]); - default: - Arity.raiseArgumentError(recv.getRuntime(), args.length, 0, 1); - return null; // not reached - } - } - - /** rb_reg_s_last_match / match_getter - * - */ - @JRubyMethod(name = "last_match", meta = true, reads = BACKREF) - public static IRubyObject last_match_s(ThreadContext context, IRubyObject recv) { - IRubyObject match = context.getCurrentFrame().getBackRef(); - if (match instanceof RubyMatchData) ((RubyMatchData)match).use(); - return match; - } - - /** rb_reg_s_last_match - * - */ - @JRubyMethod(name = "last_match", meta = true, reads = BACKREF) - public static IRubyObject last_match_s(ThreadContext context, IRubyObject recv, IRubyObject nth) { - IRubyObject match = context.getCurrentFrame().getBackRef(); - if (match.isNil()) return match; - return nth_match(((RubyMatchData)match).backrefNumber(nth), match); - } - - /** rb_reg_match_pre - * - */ - public static IRubyObject match_pre(IRubyObject match) { - if (match.isNil()) return match; - RubyMatchData m = (RubyMatchData)match; - - int beg = m.regs == null ? m.begin : m.regs.beg[0]; - - if(beg == -1) match.getRuntime().getNil(); - - RubyString str = m.str.makeShared(match.getRuntime(), 0, beg); - str.infectBy(match); - return str; - } - - /** rb_reg_match_post - * - */ - public static IRubyObject match_post(IRubyObject match) { - if (match.isNil()) return match; - RubyMatchData m = (RubyMatchData)match; - - int end; - if (m.regs == null) { - if (m.begin == -1) return match.getRuntime().getNil(); - end = m.end; - } else { - if (m.regs.beg[0] == -1) return match.getRuntime().getNil(); - end = m.regs.end[0]; - } - - RubyString str = m.str.makeShared(match.getRuntime(), end, m.str.getByteList().realSize - end); - str.infectBy(match); - return str; - } - - /** rb_reg_match_last - * - */ - public static IRubyObject match_last(IRubyObject match) { - if (match.isNil()) return match; - RubyMatchData m = (RubyMatchData)match; - - if (m.regs == null || m.regs.beg[0] == -1) return match.getRuntime().getNil(); - - int i; - for (i=m.regs.numRegs-1; m.regs.beg[i]==-1 && i>0; i--); - if (i == 0) return match.getRuntime().getNil(); - - return nth_match(i,match); - } - - /** rb_reg_s_union - * - */ - @JRubyMethod(name = "union", rest = true, meta = true) - public static IRubyObject union(ThreadContext context, IRubyObject recv, IRubyObject[] args) { - if (args.length == 0) { - return newRegexp(recv.getRuntime(), ByteList.create("(?!)"), 0, false); - } else if (args.length == 1) { - IRubyObject v = TypeConverter.convertToTypeWithCheck(args[0], recv.getRuntime().getRegexp(), 0, "to_regexp"); - if(!v.isNil()) { - return v; - } else { - // newInstance here - return newRegexp(recv.getRuntime(), quote(recv,args).getByteList(), 0, false); - } - } else { - KCode kcode = null; - IRubyObject kcode_re = recv.getRuntime().getNil(); - RubyString source = recv.getRuntime().newString(); - IRubyObject[] _args = new IRubyObject[3]; - - for (int i = 0; i < args.length; i++) { - if (0 < i) { - source.cat((byte)'|'); - } - IRubyObject v = TypeConverter.convertToTypeWithCheck(args[i], recv.getRuntime().getRegexp(), 0, "to_regexp"); - if (!v.isNil()) { - if (!((RubyRegexp)v).isKCodeDefault()) { - if (kcode == null) { - kcode_re = v; - kcode = ((RubyRegexp)v).kcode; - } else if (((RubyRegexp)v).kcode != kcode) { - IRubyObject str1 = kcode_re.inspect(); - IRubyObject str2 = v.inspect(); - throw recv.getRuntime().newArgumentError("mixed kcode " + str1 + " and " + str2); - } - } - v = ((RubyRegexp)v).to_s(); - } else { - v = quote(recv, new IRubyObject[]{args[i]}); - } - source.append(v); - } - - _args[0] = source; - _args[1] = recv.getRuntime().getNil(); - if (kcode == null) { - _args[2] = recv.getRuntime().getNil(); - } else if (kcode == KCode.NONE) { - _args[2] = recv.getRuntime().newString("n"); - } else if (kcode == KCode.EUC) { - _args[2] = recv.getRuntime().newString("e"); - } else if (kcode == KCode.SJIS) { - _args[2] = recv.getRuntime().newString("s"); - } else if (kcode == KCode.UTF8) { - _args[2] = recv.getRuntime().newString("u"); - } - return recv.callMethod(context, "new", _args); - } - } - - /** rb_reg_names - * - */ - @JRubyMethod(name = "names", compat = CompatVersion.RUBY1_9) - public IRubyObject names() { - if (pattern.numberOfNames() == 0) return getRuntime().newEmptyArray(); - - RubyArray ary = getRuntime().newArray(pattern.numberOfNames()); - for (Iterator<NameEntry> i = pattern.namedBackrefIterator(); i.hasNext();) { - NameEntry e = i.next(); - ary.append(RubyString.newStringShared(getRuntime(), e.name, e.nameP, e.nameEnd - e.nameP)); - } - return ary; - } - - /** rb_reg_named_captures - * - */ - @JRubyMethod(name = "named_captures", compat = CompatVersion.RUBY1_9) - public IRubyObject named_captures(ThreadContext context) { - RubyHash hash = RubyHash.newHash(getRuntime()); - if (pattern.numberOfNames() == 0) return hash; - - for (Iterator<NameEntry> i = pattern.namedBackrefIterator(); i.hasNext();) { - NameEntry e = i.next(); - int[]backrefs = e.getBackRefs(); - RubyArray ary = getRuntime().newArray(backrefs.length); - - for (int backref : backrefs) ary.append(RubyFixnum.newFixnum(getRuntime(), backref)); - hash.fastASet(RubyString.newStringShared(getRuntime(), e.name, e.nameP, e.nameEnd - e.nameP).freeze(context), ary); - } - return hash; - } - - public static RubyRegexp unmarshalFrom(UnmarshalStream input) throws java.io.IOException { - RubyRegexp result = newRegexp(input.getRuntime(), input.unmarshalString(), input.unmarshalInt(), false); - input.registerLinkTarget(result); - return result; - } - - public static void marshalTo(RubyRegexp regexp, MarshalStream output) throws java.io.IOException { - output.registerLinkTarget(regexp); - output.writeString(new String(regexp.str.bytes,regexp.str.begin,regexp.str.realSize)); - output.writeInt(regexp.pattern.getOptions() & EMBEDDABLE); - } -} - -package org.jruby; - -import org.jruby.runtime.builtin.IRubyObject; - -/** - * - * @author nicksieger - */ -public interface RubyRuntimeAdapter { - IRubyObject eval(Ruby runtime, String script); -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyModule; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Block; -import org.jruby.runtime.CallType; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -import org.jruby.util.SignalFacade; -import org.jruby.util.NoFunctionalitySignalFacade; - -@JRubyModule(name="Signal") -public class RubySignal { - private final static SignalFacade SIGNALS = getSignalFacade(); - - private final static SignalFacade getSignalFacade() { - try { - Class realFacadeClass = Class.forName("org.jruby.util.SunSignalFacade"); - return (SignalFacade)realFacadeClass.newInstance(); - } catch(Throwable e) { - return new NoFunctionalitySignalFacade(); - } - } - - // NOTE: The indicies here match exactly the signal values; do not reorder - public static final String[] NAMES = { - "EXIT", "HUP", "INT", "QUIT", "ILL", "TRAP", "ABRT", "EMT", - "FPE", "KILL", "BUS", "SEGV", "SYS", "PIPE", "ALRM", "TERM", "URG", - "STOP", "TSTP", "CONT", "CHLD", "TTIN", "TTOU", "IO", "XCPU", - "XFSZ", "VTALRM", "PROF", "WINCH", "INFO", "USR1", "USR2"}; - - public static void createSignal(Ruby runtime) { - RubyModule mSignal = runtime.defineModule("Signal"); - - mSignal.defineAnnotatedMethods(RubySignal.class); - } - - @JRubyMethod(name = "trap", required = 1, optional = 1, frame = true, meta = true) - public static IRubyObject trap(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = recv.getRuntime(); - runtime.getLoadService().require("jsignal"); - return RuntimeHelpers.invoke(context, runtime.getKernel(), "__jtrap", args, block); - } - - @JRubyMethod(name = "list", meta = true) - public static IRubyObject list(ThreadContext context, IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - RubyHash names = RubyHash.newHash(runtime); - for (int i = 0; i < NAMES.length; i++) { - names.op_aset(context, runtime.newString(NAMES[i]), runtime.newFixnum(i)); - } - // IOT is also 6 - names.op_aset(context, runtime.newString("IOT"), runtime.newFixnum(6)); - // CLD is also 20 - names.op_aset(context, runtime.newString("CLD"), runtime.newFixnum(20)); - return names; - } - - @JRubyMethod(name = "__jtrap_kernel", required = 3,meta = true) - public static IRubyObject __jtrap_kernel(final IRubyObject recv, IRubyObject arg1, IRubyObject arg2, IRubyObject arg3) { - return SIGNALS.trap(recv, arg1, arg2, arg3); - } -}// RubySignal -/* - **** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2004 David Corbin <dcorbin@users.sourceforge.net> - * Copyright (C) 2005 Tim Azzopardi <tim@tigerfive.com> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2006 Ola Bini <ola@ologix.com> - * Copyright (C) 2007 Nick Sieger <nicksieger@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import static org.jruby.anno.FrameField.BACKREF; -import static org.jruby.anno.FrameField.LASTLINE; - -import java.io.UnsupportedEncodingException; -import java.util.Locale; - -import org.joni.Matcher; -import org.joni.Option; -import org.joni.Regex; -import org.joni.Region; -import org.joni.encoding.Encoding; -import org.joni.encoding.specific.ASCIIEncoding; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.exceptions.RaiseException; -import org.jruby.java.MiniJava; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.Frame; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.ByteList; -import org.jruby.util.Numeric; -import org.jruby.util.Pack; -import org.jruby.util.Sprintf; -import org.jruby.util.string.JavaCrypt; - -/** - * Implementation of Ruby String class - * - * Concurrency: no synchronization is required among readers, but - * all users must synchronize externally with writers. - * - */ -@JRubyClass(name="String", include={"Enumerable", "Comparable"}) -public class RubyString extends RubyObject { - private static final ASCIIEncoding ASCII = ASCIIEncoding.INSTANCE; - - // string doesn't share any resources - private static final int SHARE_LEVEL_NONE = 0; - // string has it's own ByteList, but it's pointing to a shared buffer (byte[]) - private static final int SHARE_LEVEL_BUFFER = 1; - // string doesn't have it's own ByteList (values) - private static final int SHARE_LEVEL_BYTELIST = 2; - - private volatile int shareLevel = SHARE_LEVEL_NONE; - - private ByteList value; - - private static ObjectAllocator STRING_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return RubyString.newEmptyString(runtime, klass); - } - }; - - public static RubyClass createStringClass(Ruby runtime) { - RubyClass stringClass = runtime.defineClass("String", runtime.getObject(), STRING_ALLOCATOR); - runtime.setString(stringClass); - stringClass.index = ClassIndex.STRING; - stringClass.kindOf = new RubyModule.KindOf() { - @Override - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubyString; - } - }; - - stringClass.includeModule(runtime.getComparable()); - stringClass.includeModule(runtime.getEnumerable()); - stringClass.defineAnnotatedMethods(RubyString.class); - - return stringClass; - } - - /** short circuit for String key comparison - * - */ - @Override - public final boolean eql(IRubyObject other) { - if (other.getMetaClass() == getRuntime().getString()) return value.equal(((RubyString)other).value); - return super.eql(other); - } - - private RubyString(Ruby runtime, RubyClass rubyClass, CharSequence value) { - super(runtime, rubyClass); - assert value != null; - this.value = new ByteList(ByteList.plain(value), false); - } - - private RubyString(Ruby runtime, RubyClass rubyClass, byte[] value) { - super(runtime, rubyClass); - assert value != null; - this.value = new ByteList(value); - } - - private RubyString(Ruby runtime, RubyClass rubyClass, ByteList value) { - super(runtime, rubyClass); - assert value != null; - this.value = value; - } - - private RubyString(Ruby runtime, RubyClass rubyClass, ByteList value, boolean objectSpace) { - super(runtime, rubyClass, objectSpace); - assert value != null; - this.value = value; - } - - - /** Create a new String which uses the same Ruby runtime and the same - * class like this String. - * - * This method should be used to satisfy RCR #38. - * @deprecated - */ - public RubyString newString(CharSequence s) { - return new RubyString(getRuntime(), getType(), s); - } - - /** Create a new String which uses the same Ruby runtime and the same - * class like this String. - * - * This method should be used to satisfy RCR #38. - * @deprecated - */ - public RubyString newString(ByteList s) { - return new RubyString(getRuntime(), getMetaClass(), s); - } - - // Methods of the String class (rb_str_*): - - /** rb_str_new2 - * - */ - public static RubyString newString(Ruby runtime, CharSequence str) { - return new RubyString(runtime, runtime.getString(), str); - } - - public static RubyString newEmptyString(Ruby runtime) { - return newEmptyString(runtime, runtime.getString()); - } - - public static RubyString newEmptyString(Ruby runtime, RubyClass metaClass) { - RubyString empty = new RubyString(runtime, metaClass, ByteList.EMPTY_BYTELIST); - empty.shareLevel = SHARE_LEVEL_BYTELIST; - return empty; - } - - public static RubyString newUnicodeString(Ruby runtime, String str) { - try { - return new RubyString(runtime, runtime.getString(), new ByteList(str.getBytes("UTF8"), false)); - } catch (UnsupportedEncodingException uee) { - return new RubyString(runtime, runtime.getString(), str); - } - } - - @Deprecated - public static RubyString newString(Ruby runtime, RubyClass clazz, CharSequence str) { - return new RubyString(runtime, clazz, str); - } - - public static RubyString newString(Ruby runtime, byte[] bytes) { - return new RubyString(runtime, runtime.getString(), bytes); - } - - public static RubyString newString(Ruby runtime, byte[] bytes, int start, int length) { - byte[] copy = new byte[length]; - System.arraycopy(bytes, start, copy, 0, length); - return new RubyString(runtime, runtime.getString(), new ByteList(copy, false)); - } - - public static RubyString newString(Ruby runtime, ByteList bytes) { - return new RubyString(runtime, runtime.getString(), bytes); - } - - public static RubyString newStringLight(Ruby runtime, ByteList bytes) { - return new RubyString(runtime, runtime.getString(), bytes, false); - } - - public static RubyString newStringShared(Ruby runtime, RubyString orig) { - orig.shareLevel = SHARE_LEVEL_BYTELIST; - RubyString str = new RubyString(runtime, runtime.getString(), orig.value); - str.shareLevel = SHARE_LEVEL_BYTELIST; - return str; - } - - public static RubyString newStringShared(Ruby runtime, ByteList bytes) { - return newStringShared(runtime, runtime.getString(), bytes); - } - - public static RubyString newStringShared(Ruby runtime, RubyClass clazz, ByteList bytes) { - RubyString str = new RubyString(runtime, clazz, bytes); - str.shareLevel = SHARE_LEVEL_BYTELIST; - return str; - } - - public static RubyString newStringShared(Ruby runtime, byte[] bytes, int start, int length) { - RubyString str = new RubyString(runtime, runtime.getString(), new ByteList(bytes, start, length, false)); - str.shareLevel = SHARE_LEVEL_BUFFER; - return str; - } - - @Override - public int getNativeTypeIndex() { - return ClassIndex.STRING; - } - - @Override - public Class getJavaClass() { - return String.class; - } - - @Override - public RubyString convertToString() { - return this; - } - - @Override - public String toString() { - return value.toString(); - } - - /** rb_str_dup - * - */ - @Deprecated - public final RubyString strDup() { - return strDup(getRuntime(), getMetaClass()); - } - - public final RubyString strDup(Ruby runtime) { - return strDup(runtime, getMetaClass()); - } - - @Deprecated - final RubyString strDup(RubyClass clazz) { - return strDup(getRuntime(), getMetaClass()); - } - - final RubyString strDup(Ruby runtime, RubyClass clazz) { - shareLevel = SHARE_LEVEL_BYTELIST; - RubyString dup = new RubyString(runtime, clazz, value); - dup.shareLevel = SHARE_LEVEL_BYTELIST; - - dup.infectBy(this); - return dup; - } - - public final RubyString makeShared(Ruby runtime, int index, int len) { - if (len == 0) { - RubyString s = newEmptyString(runtime, getMetaClass()); - s.infectBy(this); - return s; - } - - if (shareLevel == SHARE_LEVEL_NONE) shareLevel = SHARE_LEVEL_BUFFER; - RubyString shared = new RubyString(runtime, getMetaClass(), value.makeShared(index, len)); - shared.shareLevel = SHARE_LEVEL_BUFFER; - - shared.infectBy(this); - return shared; - } - - final void modifyCheck() { - if ((flags & FROZEN_F) != 0) throw getRuntime().newFrozenError("string"); - - if (!isTaint() && getRuntime().getSafeLevel() >= 4) { - throw getRuntime().newSecurityError("Insecure: can't modify string"); - } - } - - private final void modifyCheck(byte[] b, int len) { - if (value.bytes != b || value.realSize != len) throw getRuntime().newRuntimeError("string modified"); - } - - private final void frozenCheck() { - if (isFrozen()) throw getRuntime().newRuntimeError("string frozen"); - } - - /** rb_str_modify - * - */ - public final void modify() { - modifyCheck(); - - if (shareLevel != SHARE_LEVEL_NONE) { - if (shareLevel == SHARE_LEVEL_BYTELIST) { - value = value.dup(); - } else { - value.unshare(); - } - shareLevel = SHARE_LEVEL_NONE; - } - - value.invalidate(); - } - - /** rb_str_modify (with length bytes ensured) - * - */ - public final void modify(int length) { - modifyCheck(); - - if (shareLevel != SHARE_LEVEL_NONE) { - if (shareLevel == SHARE_LEVEL_BYTELIST) { - value = value.dup(length); - } else { - value.unshare(length); - } - shareLevel = SHARE_LEVEL_NONE; - } else { - value.ensure(length); - } - - value.invalidate(); - } - - private final void view(ByteList bytes) { - modifyCheck(); - - value = bytes; - shareLevel = SHARE_LEVEL_NONE; - } - - private final void view(byte[]bytes) { - modifyCheck(); - - value.replace(bytes); - shareLevel = SHARE_LEVEL_NONE; - - value.invalidate(); - } - - private final void view(int index, int len) { - modifyCheck(); - - if (shareLevel != SHARE_LEVEL_NONE) { - if (shareLevel == SHARE_LEVEL_BYTELIST) { - // if len == 0 then shared empty - value = value.makeShared(index, len); - shareLevel = SHARE_LEVEL_BUFFER; - } else { - value.view(index, len); - } - } else { - value.view(index, len); - // FIXME this below is temporary, but its much safer for COW (it prevents not shared Strings with begin != 0) - // this allows now e.g.: ByteList#set not to be begin aware - shareLevel = SHARE_LEVEL_BUFFER; - } - - value.invalidate(); - } - - public static String bytesToString(byte[] bytes, int beg, int len) { - return new String(ByteList.plain(bytes, beg, len)); - } - - public static String byteListToString(ByteList bytes) { - return bytesToString(bytes.unsafeBytes(), bytes.begin(), bytes.length()); - } - - public static String bytesToString(byte[] bytes) { - return bytesToString(bytes, 0, bytes.length); - } - - public static byte[] stringToBytes(String string) { - return ByteList.plain(string); - } - - public static boolean isDigit(int c) { - return c >= '0' && c <= '9'; - } - - public static boolean isUpper(int c) { - return c >= 'A' && c <= 'Z'; - } - - public static boolean isLower(int c) { - return c >= 'a' && c <= 'z'; - } - - public static boolean isLetter(int c) { - return isUpper(c) || isLower(c); - } - - public static boolean isAlnum(int c) { - return isUpper(c) || isLower(c) || isDigit(c); - } - - public static boolean isPrint(int c) { - return c >= 0x20 && c <= 0x7E; - } - - @Override - public RubyString asString() { - return this; - } - - @Override - public IRubyObject checkStringType() { - return this; - } - - @JRubyMethod(name = {"to_s", "to_str"}) - @Override - public IRubyObject to_s() { - Ruby runtime = getRuntime(); - if (getMetaClass().getRealClass() != runtime.getString()) { - return strDup(runtime, runtime.getString()); - } - return this; - } - - /* rb_str_cmp_m */ - @JRubyMethod(name = "<=>", required = 1) - public IRubyObject op_cmp(ThreadContext context, IRubyObject other) { - if (other instanceof RubyString) { - return context.getRuntime().newFixnum(op_cmp((RubyString)other)); - } - - // deal with case when "other" is not a string - if (other.respondsTo("to_str") && other.respondsTo("<=>")) { - IRubyObject result = other.callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", this); - - if (result instanceof RubyNumeric) { - return ((RubyNumeric) result).op_uminus(context); - } - } - - return context.getRuntime().getNil(); - } - - /** - * - */ - @JRubyMethod(name = "==", required = 1) - @Override - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - Ruby runtime = context.getRuntime(); - - if (this == other) return runtime.getTrue(); - - if (!(other instanceof RubyString)) { - if (!other.respondsTo("to_str")) return runtime.getFalse(); - - return other.callMethod(context, MethodIndex.EQUALEQUAL, "==", this).isTrue() ? runtime.getTrue() : runtime.getFalse(); - } - return value.equal(((RubyString)other).value) ? runtime.getTrue() : runtime.getFalse(); - } - - @JRubyMethod(name = "+", required = 1) - public IRubyObject op_plus(ThreadContext context, IRubyObject other) { - RubyString str = other.convertToString(); - - ByteList result = new ByteList(value.realSize + str.value.realSize); - result.realSize = value.realSize + str.value.realSize; - System.arraycopy(value.bytes, value.begin, result.bytes, 0, value.realSize); - System.arraycopy(str.value.bytes, str.value.begin, result.bytes, value.realSize, str.value.realSize); - - RubyString resultStr = newString(context.getRuntime(), result); - if (isTaint() || str.isTaint()) resultStr.setTaint(true); - return resultStr; - } - - @JRubyMethod(name = "*", required = 1) - public IRubyObject op_mul(ThreadContext context, IRubyObject other) { - RubyInteger otherInteger = (RubyInteger) other.convertToInteger(); - long len = otherInteger.getLongValue(); - - if (len < 0) throw context.getRuntime().newArgumentError("negative argument"); - - // we limit to int because ByteBuffer can only allocate int sizes - if (len > 0 && Integer.MAX_VALUE / len < value.length()) { - throw context.getRuntime().newArgumentError("argument too big"); - } - ByteList newBytes = new ByteList(value.length() * (int)len); - - for (int i = 0; i < len; i++) { - newBytes.append(value); - } - - RubyString newString = new RubyString(context.getRuntime(), getMetaClass(), newBytes); - newString.setTaint(isTaint()); - return newString; - } - - @JRubyMethod(name = "%", required = 1) - public IRubyObject op_format(ThreadContext context, IRubyObject arg) { - final RubyString s; - - IRubyObject tmp = arg.checkArrayType(); - if (tmp.isNil()) { - tmp = arg; - } - - // FIXME: Should we make this work with platform's locale, - // or continue hardcoding US? - s = Sprintf.sprintf(context.getRuntime(), Locale.US, value, tmp); - - s.infectBy(this); - return s; - } - - @JRubyMethod(name = "hash") - @Override - public RubyFixnum hash() { - return getRuntime().newFixnum(value.hashCode()); - } - - @Override - public int hashCode() { - return value.hashCode(); - } - - @Override - public boolean equals(Object other) { - if (this == other) return true; - - if (other instanceof RubyString) { - RubyString string = (RubyString) other; - - if (string.value.equal(value)) return true; - } - - return false; - } - - /** rb_obj_as_string - * - */ - public static RubyString objAsString(ThreadContext context, IRubyObject obj) { - if (obj instanceof RubyString) return (RubyString) obj; - - IRubyObject str = obj.callMethod(context, MethodIndex.TO_S, "to_s"); - - if (!(str instanceof RubyString)) return (RubyString) obj.anyToString(); - - if (obj.isTaint()) str.setTaint(true); - - return (RubyString) str; - } - - /** rb_str_cmp - * - */ - public int op_cmp(RubyString other) { - return value.cmp(other.value); - } - - /** rb_to_id - * - */ - @Override - public String asJavaString() { - // TODO: This used to intern; but it didn't appear to change anything - // turning that off, and it's unclear if it was needed. Plus, we intern - // - return toString(); - } - - public IRubyObject doClone(){ - return newString(getRuntime(), value.dup()); - } - - public RubyString cat(byte[] str) { - modify(value.realSize + str.length); - System.arraycopy(str, 0, value.bytes, value.begin + value.realSize, str.length); - value.realSize += str.length; - return this; - } - - public RubyString cat(byte[] str, int beg, int len) { - modify(value.realSize + len); - System.arraycopy(str, beg, value.bytes, value.begin + value.realSize, len); - value.realSize += len; - return this; - } - - public RubyString cat(ByteList str) { - modify(value.realSize + str.realSize); - System.arraycopy(str.bytes, str.begin, value.bytes, value.begin + value.realSize, str.realSize); - value.realSize += str.realSize; - return this; - } - - public RubyString cat(byte ch) { - modify(value.realSize + 1); - value.bytes[value.begin + value.realSize] = ch; - value.realSize++; - return this; - } - - /** rb_str_replace_m - * - */ - @JRubyMethod(name = {"replace", "initialize_copy"}, required = 1) - public RubyString replace(IRubyObject other) { - if (this == other) return this; - - modifyCheck(); - - RubyString otherStr = stringValue(other); - - otherStr.shareLevel = shareLevel = SHARE_LEVEL_BYTELIST; - - value = otherStr.value; - - infectBy(other); - return this; - } - - @JRubyMethod(name = "reverse") - public RubyString reverse(ThreadContext context) { - if (value.length() <= 1) return strDup(context.getRuntime()); - - ByteList buf = new ByteList(value.length()+2); - buf.realSize = value.length(); - int src = value.length() - 1; - int dst = 0; - - while (src >= 0) buf.set(dst++, value.get(src--)); - - RubyString rev = new RubyString(context.getRuntime(), getMetaClass(), buf); - rev.infectBy(this); - return rev; - } - - @JRubyMethod(name = "reverse!") - public RubyString reverse_bang() { - if (value.length() > 1) { - modify(); - for (int i = 0; i < (value.length() / 2); i++) { - byte b = (byte) value.get(i); - - value.set(i, value.get(value.length() - i - 1)); - value.set(value.length() - i - 1, b); - } - } - - return this; - } - - /** rb_str_s_new - * - */ - public static RubyString newInstance(IRubyObject recv, IRubyObject[] args, Block block) { - RubyString newString = newStringShared(recv.getRuntime(), ByteList.EMPTY_BYTELIST); - newString.setMetaClass((RubyClass) recv); - newString.callInit(args, block); - return newString; - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with zero or one arguments - */ - public IRubyObject initialize(IRubyObject[] args, Block unusedBlock) { - switch (args.length) { - case 0: - return this; - case 1: - return initialize(args[0]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 0, 1); - return null; // not reached - } - } - - @JRubyMethod(frame = true, visibility = Visibility.PRIVATE) - @Override - public IRubyObject initialize() { - return this; - } - - @JRubyMethod(frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject arg0) { - replace(arg0); - - return this; - } - - @JRubyMethod - public IRubyObject casecmp(IRubyObject other) { - int compare = value.caseInsensitiveCmp(stringValue(other).value); - return RubyFixnum.newFixnum(getRuntime(), compare); - } - - /** rb_str_match - * - */ - @JRubyMethod(name = "=~") - @Override - public IRubyObject op_match(ThreadContext context, IRubyObject other) { - if (other instanceof RubyRegexp) return ((RubyRegexp) other).op_match(context, this); - if (other instanceof RubyString) { - throw context.getRuntime().newTypeError("type mismatch: String given"); - } - return other.callMethod(context, "=~", this); - } - - /** rb_str_match2 - * - */ - @JRubyMethod(name = "~", reads = {LASTLINE, BACKREF}, writes = BACKREF) - public IRubyObject op_match2(ThreadContext context) { - return RubyRegexp.newRegexp(context.getRuntime(), value, 0, false).op_match2(context); - } - - /** - * String#match(pattern) - * - * rb_str_match_m - * - * @param pattern Regexp or String - */ - @JRubyMethod - public IRubyObject match(ThreadContext context, IRubyObject pattern) { - return getPattern(pattern, false).callMethod(context, "match", this); - } - - /** rb_str_capitalize - * - */ - @JRubyMethod - public IRubyObject capitalize(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.capitalize_bang(context); - return str; - } - - /** rb_str_capitalize_bang - * - */ - @JRubyMethod(name = "capitalize!") - public IRubyObject capitalize_bang(ThreadContext context) { - if (value.realSize == 0) { - modifyCheck(); - return context.getRuntime().getNil(); - } - - modify(); - - int s = value.begin; - int send = s + value.realSize; - byte[]buf = value.bytes; - - - - boolean modify = false; - - int c = buf[s] & 0xff; - if (ASCII.isLower(c)) { - buf[s] = (byte)ASCIIEncoding.asciiToUpper(c); - modify = true; - } - - while (++s < send) { - c = (char)(buf[s] & 0xff); - if (ASCII.isUpper(c)) { - buf[s] = (byte)ASCIIEncoding.asciiToLower(c); - modify = true; - } - } - - if (modify) return this; - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = ">=") - public IRubyObject op_ge(ThreadContext context, IRubyObject other) { - if (other instanceof RubyString) { - return context.getRuntime().newBoolean(op_cmp((RubyString) other) >= 0); - } - - return RubyComparable.op_ge(context, this, other); - } - - @JRubyMethod(name = ">") - public IRubyObject op_gt(ThreadContext context, IRubyObject other) { - if (other instanceof RubyString) { - return context.getRuntime().newBoolean(op_cmp((RubyString) other) > 0); - } - - return RubyComparable.op_gt(context, this, other); - } - - @JRubyMethod(name = "<=") - public IRubyObject op_le(ThreadContext context, IRubyObject other) { - if (other instanceof RubyString) { - return context.getRuntime().newBoolean(op_cmp((RubyString) other) <= 0); - } - - return RubyComparable.op_le(context, this, other); - } - - @JRubyMethod(name = "<") - public IRubyObject op_lt(ThreadContext context, IRubyObject other) { - if (other instanceof RubyString) { - return context.getRuntime().newBoolean(op_cmp((RubyString) other) < 0); - } - - return RubyComparable.op_lt(context, this, other); - } - - @JRubyMethod(name = "eql?") - public IRubyObject str_eql_p(ThreadContext context, IRubyObject other) { - if (!(other instanceof RubyString)) return context.getRuntime().getFalse(); - RubyString otherString = (RubyString)other; - return value.equal(otherString.value) ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - /** rb_str_upcase - * - */ - @JRubyMethod - public RubyString upcase(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.upcase_bang(context); - return str; - } - - /** rb_str_upcase_bang - * - */ - @JRubyMethod(name = "upcase!") - public IRubyObject upcase_bang(ThreadContext context) { - if (value.realSize == 0) { - modifyCheck(); - return context.getRuntime().getNil(); - } - - modify(); - - int s = value.begin; - int send = s + value.realSize; - byte []buf = value.bytes; - - boolean modify = false; - while (s < send) { - int c = buf[s] & 0xff; - if (ASCII.isLower(c)) { - buf[s] = (byte)ASCIIEncoding.asciiToUpper(c); - modify = true; - } - s++; - } - - if (modify) return this; - return context.getRuntime().getNil(); - } - - /** rb_str_downcase - * - */ - @JRubyMethod - public RubyString downcase(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.downcase_bang(context); - return str; - } - - /** rb_str_downcase_bang - * - */ - @JRubyMethod(name = "downcase!") - public IRubyObject downcase_bang(ThreadContext context) { - if (value.realSize == 0) { - modifyCheck(); - return context.getRuntime().getNil(); - } - - modify(); - - int s = value.begin; - int send = s + value.realSize; - byte []buf = value.bytes; - - boolean modify = false; - while (s < send) { - int c = buf[s] & 0xff; - if (ASCII.isUpper(c)) { - buf[s] = (byte)ASCIIEncoding.asciiToLower(c); - modify = true; - } - s++; - } - - if (modify) return this; - return context.getRuntime().getNil(); - } - - /** rb_str_swapcase - * - */ - @JRubyMethod - public RubyString swapcase(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.swapcase_bang(context); - return str; - } - - /** rb_str_swapcase_bang - * - */ - @JRubyMethod(name = "swapcase!") - public IRubyObject swapcase_bang(ThreadContext context) { - if (value.realSize == 0) { - modifyCheck(); - return context.getRuntime().getNil(); - } - - modify(); - - int s = value.begin; - int send = s + value.realSize; - byte[]buf = value.bytes; - - boolean modify = false; - while (s < send) { - int c = buf[s] & 0xff; - if (ASCII.isUpper(c)) { - buf[s] = (byte)ASCIIEncoding.asciiToLower(c); - modify = true; - } else if (ASCII.isLower(c)) { - buf[s] = (byte)ASCIIEncoding.asciiToUpper(c); - modify = true; - } - s++; - } - - if (modify) return this; - return context.getRuntime().getNil(); - } - - /** rb_str_dump - * - */ - @JRubyMethod - public IRubyObject dump() { - RubyString s = new RubyString(getRuntime(), getMetaClass(), inspectIntoByteList(true)); - s.infectBy(this); - return s; - } - - @JRubyMethod - public IRubyObject insert(ThreadContext context, IRubyObject indexArg, IRubyObject stringArg) { - // MRI behavior: first check for ability to convert to String... - RubyString s = (RubyString)stringArg.convertToString(); - ByteList insert = s.value; - - // ... and then the index - int index = (int) indexArg.convertToInteger().getLongValue(); - if (index < 0) index += value.length() + 1; - - if (index < 0 || index > value.length()) { - throw context.getRuntime().newIndexError("index " + index + " out of range"); - } - - modify(); - - value.unsafeReplace(index, 0, insert); - this.infectBy(s); - return this; - } - - /** rb_str_inspect - * - */ - @JRubyMethod - @Override - public IRubyObject inspect() { - RubyString s = getRuntime().newString(inspectIntoByteList(false)); - s.infectBy(this); - return s; - } - - private ByteList inspectIntoByteList(boolean ignoreKCode) { - Ruby runtime = getRuntime(); - Encoding enc = runtime.getKCode().getEncoding(); - final int length = value.length(); - ByteList sb = new ByteList(length + 2 + length / 100); - - sb.append('\"'); - - for (int i = 0; i < length; i++) { - int c = value.get(i) & 0xFF; - - if (!ignoreKCode) { - int seqLength = enc.length((byte)c); - - if (seqLength > 1 && (i + seqLength -1 < length)) { - // don't escape multi-byte characters, leave them as bytes - sb.append(value, i, seqLength); - i += seqLength - 1; - continue; - } - } - - if (isAlnum(c)) { - sb.append((char)c); - } else if (c == '\"' || c == '\\') { - sb.append('\\').append((char)c); - } else if (c == '#' && isEVStr(i, length)) { - sb.append('\\').append((char)c); - } else if (isPrint(c)) { - sb.append((char)c); - } else if (c == '\n') { - sb.append('\\').append('n'); - } else if (c == '\r') { - sb.append('\\').append('r'); - } else if (c == '\t') { - sb.append('\\').append('t'); - } else if (c == '\f') { - sb.append('\\').append('f'); - } else if (c == '\u000B') { - sb.append('\\').append('v'); - } else if (c == '\u0007') { - sb.append('\\').append('a'); - } else if (c == '\u0008') { - sb.append('\\').append('b'); - } else if (c == '\u001B') { - sb.append('\\').append('e'); - } else { - sb.append(ByteList.plain(Sprintf.sprintf(runtime,"\\%03o",c))); - } - } - - sb.append('\"'); - return sb; - } - - private boolean isEVStr(int i, int length) { - if (i+1 >= length) return false; - int c = value.get(i+1) & 0xFF; - - return c == '$' || c == '@' || c == '{'; - } - - /** rb_str_length - * - */ - @JRubyMethod(name = {"length", "size"}) - public RubyFixnum length() { - return getRuntime().newFixnum(value.length()); - } - - /** rb_str_empty - * - */ - @JRubyMethod(name = "empty?") - public RubyBoolean empty_p(ThreadContext context) { - return isEmpty() ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - public boolean isEmpty() { - return value.length() == 0; - } - - /** rb_str_append - * - */ - public RubyString append(IRubyObject other) { - infectBy(other); - return cat(stringValue(other).value); - } - - /** rb_str_concat - * - */ - @JRubyMethod(name = {"concat", "<<"}) - public RubyString concat(IRubyObject other) { - if (other instanceof RubyFixnum) { - long value = ((RubyFixnum) other).getLongValue(); - if (value >= 0 && value < 256) return cat((byte) value); - } - return append(other); - } - - /** rb_str_crypt - * - */ - @JRubyMethod(name = "crypt") - public RubyString crypt(ThreadContext context, IRubyObject other) { - ByteList salt = stringValue(other).getByteList(); - if (salt.realSize < 2) { - throw context.getRuntime().newArgumentError("salt too short(need >=2 bytes)"); - } - - salt = salt.makeShared(0, 2); - RubyString s = RubyString.newStringShared(context.getRuntime(), JavaCrypt.crypt(salt, this.getByteList())); - s.infectBy(this); - s.infectBy(other); - return s; - } - - /* RubyString aka rb_string_value */ - public static RubyString stringValue(IRubyObject object) { - return (RubyString) (object instanceof RubyString ? object : - object.convertToString()); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with one or two args. - */ - public IRubyObject sub(ThreadContext context, IRubyObject[] args, Block block) { - RubyString str = strDup(context.getRuntime()); - str.sub_bang(context, args, block); - return str; - } - - /** rb_str_sub - * - */ - @JRubyMethod(name = "sub", frame = true) - public IRubyObject sub(ThreadContext context, IRubyObject arg0, Block block) { - RubyString str = strDup(context.getRuntime()); - str.sub_bang(context, arg0, block); - return str; - } - - /** rb_str_sub - * - */ - @JRubyMethod(name = "sub", frame = true) - public IRubyObject sub(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - RubyString str = strDup(context.getRuntime()); - str.sub_bang(context, arg0, arg1, block); - return str; - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with one or two arguments. - */ - public IRubyObject sub_bang(ThreadContext context, IRubyObject[] args, Block block) { - switch (args.length) { - case 1: - return sub_bang(context, args[0], block); - case 2: - return sub_bang(context, args[0], args[1], block); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_sub_bang - * - */ - @JRubyMethod(name = "sub!", frame = true, reads = BACKREF, writes = BACKREF) - public IRubyObject sub_bang(ThreadContext context, IRubyObject arg0, Block block) { - if (block.isGiven()) { - RubyRegexp rubyRegex = getPattern(arg0, true); - Regex regex = rubyRegex.getPattern(); - return subBangCommon(regex, context, true, rubyRegex, block, null, false); - } else { - throw context.getRuntime().newArgumentError("wrong number of arguments (1 for 2)"); - } - } - - /** rb_str_sub_bang - * - */ - @JRubyMethod(name = "sub!", frame = true, reads = BACKREF, writes = BACKREF) - public IRubyObject sub_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - RubyString repl = arg1.convertToString(); - RubyRegexp rubyRegex = getPattern(arg0, true); - Regex regex = rubyRegex.getPattern(); - return subBangCommon(regex, context, false, rubyRegex, block, repl, repl.isTaint()); - } - - private IRubyObject subBangCommon(Regex regex, ThreadContext context, final boolean iter, RubyRegexp rubyRegex, Block block, RubyString repl, boolean tainted) { - - int range = value.begin + value.realSize; - Matcher matcher = regex.matcher(value.bytes, value.begin, range); - - Frame frame = context.getPreviousFrame(); - if (matcher.search(value.begin, range, Option.NONE) >= 0) { - if (iter) { - byte[] bytes = value.bytes; - int size = value.realSize; - RubyMatchData match = rubyRegex.updateBackRef(context, this, frame, matcher); - match.use(); - if (regex.numberOfCaptures() == 0) { - repl = objAsString(context, block.yield(context, substr(matcher.getBegin(), matcher.getEnd() - matcher.getBegin()))); - } else { - Region region = matcher.getRegion(); - repl = objAsString(context, block.yield(context, substr(region.beg[0], region.end[0] - region.beg[0]))); - } - modifyCheck(bytes, size); - frozenCheck(); - frame.setBackRef(match); - } else { - repl = rubyRegex.regsub(repl, this, matcher); - rubyRegex.updateBackRef(context, this, frame, matcher); - } - - final int beg; - final int plen; - if (regex.numberOfCaptures() == 0) { - beg = matcher.getBegin(); - plen = matcher.getEnd() - beg; - } else { - Region region = matcher.getRegion(); - beg = region.beg[0]; - plen = region.end[0] - beg; - } - - ByteList replValue = repl.value; - if (replValue.realSize > plen) { - modify(value.realSize + replValue.realSize - plen); - } else { - modify(); - } - if (repl.isTaint()) { - tainted = true; - } - if (replValue.realSize != plen) { - int src = value.begin + beg + plen; - int dst = value.begin + beg + replValue.realSize; - int length = value.realSize - beg - plen; - System.arraycopy(value.bytes, src, value.bytes, dst, length); - } - System.arraycopy(replValue.bytes, replValue.begin, value.bytes, value.begin + beg, replValue.realSize); - value.realSize += replValue.realSize - plen; - if (tainted) { - setTaint(true); - } - return this; - } else { - frame.setBackRef(context.getRuntime().getNil()); - return context.getRuntime().getNil(); - } - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with one or two arguments. - */ - public IRubyObject gsub(ThreadContext context, IRubyObject[] args, Block block) { - switch (args.length) { - case 1: - return gsub(context, args[0], block); - case 2: - return gsub(context, args[0], args[1], block); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_gsub - * - */ - @JRubyMethod(name = "gsub", frame = true, reads = BACKREF, writes = BACKREF) - public IRubyObject gsub(ThreadContext context, IRubyObject arg0, Block block) { - return gsub(context, arg0, block, false); - } - - /** rb_str_gsub - * - */ - @JRubyMethod(name = "gsub", frame = true, reads = BACKREF, writes = BACKREF) - public IRubyObject gsub(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - return gsub(context, arg0, arg1, block, false); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with one or two arguments. - */ - public IRubyObject gsub_bang(ThreadContext context, IRubyObject[] args, Block block) { - switch (args.length) { - case 1: - return gsub_bang(context, args[0], block); - case 2: - return gsub_bang(context, args[0], args[1], block); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_gsub_bang - * - */ - @JRubyMethod(name = "gsub!", frame = true, reads = BACKREF, writes = BACKREF) - public IRubyObject gsub_bang(ThreadContext context, IRubyObject arg0, Block block) { - return gsub(context, arg0, block, true); - } - - /** rb_str_gsub_bang - * - */ - @JRubyMethod(name = "gsub!", frame = true, reads = BACKREF, writes = BACKREF) - public IRubyObject gsub_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block) { - return gsub(context, arg0, arg1, block, true); - } - - private final IRubyObject gsub(ThreadContext context, IRubyObject arg0, Block block, final boolean bang) { - if (block.isGiven()) { - RubyRegexp rubyRegex = getPattern(arg0, true); - Regex regex = rubyRegex.getPattern(); - return gsubCommon(regex, context, bang, true, rubyRegex, block, null, false); - } else { - throw context.getRuntime().newArgumentError("wrong number of arguments (1 for 2)"); - } - } - - private final IRubyObject gsub(ThreadContext context, IRubyObject arg0, IRubyObject arg1, Block block, final boolean bang) { - IRubyObject repl = arg1.convertToString(); - RubyRegexp rubyRegex = getPattern(arg0, true); - Regex regex = rubyRegex.getPattern(); - return gsubCommon(regex, context, bang, false, rubyRegex, block, repl, repl.isTaint()); - } - - private IRubyObject gsubCommon(Regex regex, ThreadContext context, final boolean bang, final boolean iter, RubyRegexp rubyRegex, Block block, IRubyObject repl, boolean tainted) { - - int begin = value.begin; - int range = begin + value.realSize; - Matcher matcher = regex.matcher(value.bytes, begin, range); - - int beg = matcher.search(begin, range, Option.NONE); - - Frame frame = context.getPreviousFrame(); - - if (beg < 0) { - frame.setBackRef(context.getRuntime().getNil()); - return bang ? context.getRuntime().getNil() : strDup(context.getRuntime()); /* bang: true, no match, no substitution */ - } - - int blen = value.realSize + 30; /* len + margin */ - ByteList dest = new ByteList(blen); - dest.realSize = blen; - int buf = 0; - int bp = 0; - int cp = value.begin; - - int offset = 0; - RubyString val; - - RubyMatchData match = null; - while (beg >= 0) { - final int begz; - final int endz; - if (iter) { - byte[] bytes = value.bytes; - int size = value.realSize; - match = rubyRegex.updateBackRef(context, this, frame, matcher); - match.use(); - if (regex.numberOfCaptures() == 0) { - begz = matcher.getBegin(); - endz = matcher.getEnd(); - val = objAsString(context, block.yield(context, substr(context.getRuntime(), begz, endz - begz))); - } else { - Region region = matcher.getRegion(); - begz = region.beg[0]; - endz = region.end[0]; - val = objAsString(context, block.yield(context, substr(context.getRuntime(), begz, endz - begz))); - } - modifyCheck(bytes, size); - if (bang) { - frozenCheck(); - } - } else { - val = rubyRegex.regsub((RubyString) repl, this, matcher); - if (regex.numberOfCaptures() == 0) { - begz = matcher.getBegin(); - endz = matcher.getEnd(); - } else { - Region region = matcher.getRegion(); - begz = region.beg[0]; - endz = region.end[0]; - } - } - - if (val.isTaint()) { - tainted = true; - } - ByteList vbuf = val.value; - int len = (bp - buf) + (beg - offset) + vbuf.realSize + 3; - if (blen < len) { - while (blen < len) { - blen <<= 1; - } - len = bp - buf; - dest.realloc(blen); - dest.realSize = blen; - bp = buf + len; - } - len = beg - offset; /* copy pre-match substr */ - System.arraycopy(value.bytes, cp, dest.bytes, bp, len); - bp += len; - System.arraycopy(vbuf.bytes, vbuf.begin, dest.bytes, bp, vbuf.realSize); - bp += vbuf.realSize; - offset = endz; - - if (begz == endz) { - if (value.realSize <= endz) { - break; - } - len = regex.getEncoding().length(value.bytes[begin + endz]); - System.arraycopy(value.bytes, begin + endz, dest.bytes, bp, len); - bp += len; - offset = endz + len; - } - cp = begin + offset; - if (offset > value.realSize) { - break; - } - beg = matcher.search(cp, range, Option.NONE); - } - - if (value.realSize > offset) { - int len = bp - buf; - if (blen - len < value.realSize - offset) { - blen = len + value.realSize - offset; - dest.realloc(blen); - bp = buf + len; - } - System.arraycopy(value.bytes, cp, dest.bytes, bp, value.realSize - offset); - bp += value.realSize - offset; - } - - if (match != null) { - frame.setBackRef(match); - } else { - rubyRegex.updateBackRef(context, this, frame, matcher); - } - - dest.realSize = bp - buf; - if (bang) { - view(dest); - if (tainted) { - setTaint(true); - } - return this; - } else { - RubyString destStr = new RubyString(context.getRuntime(), getMetaClass(), dest); - destStr.infectBy(this); - if (tainted) { - destStr.setTaint(true); - } - return destStr; - } - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with one or two args. - */ - public IRubyObject index(ThreadContext context, IRubyObject[] args) { - switch (args.length) { - case 1: - return index(context, args[0]); - case 2: - return index(context, args[0], args[1]); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_index_m - * - */ - @JRubyMethod(reads = BACKREF, writes = BACKREF) - public IRubyObject index(ThreadContext context, IRubyObject arg0) { - return indexCommon(0, arg0, context); - } - - /** rb_str_index_m - * - */ - @JRubyMethod(reads = BACKREF, writes = BACKREF) - public IRubyObject index(ThreadContext context, IRubyObject arg0, IRubyObject arg1) { - int pos = RubyNumeric.num2int(arg1); - - if (pos < 0) { - pos += value.realSize; - if (pos < 0) { - if (arg0 instanceof RubyRegexp) { - context.getPreviousFrame().setBackRef(context.getRuntime().getNil()); - } - return context.getRuntime().getNil(); - } - } - - return indexCommon(pos, arg0, context); - } - - private IRubyObject indexCommon(int pos, IRubyObject sub, ThreadContext context) throws RaiseException { - if (sub instanceof RubyRegexp) { - RubyRegexp regSub = (RubyRegexp) sub; - - pos = regSub.adjustStartPos(this, pos, false); - pos = regSub.search(context, this, pos, false); - } else if (sub instanceof RubyFixnum) { - int c_int = RubyNumeric.fix2int(sub); - if (c_int < 0x00 || c_int > 0xFF) { - // out of byte range - // there will be no match for sure - return context.getRuntime().getNil(); - } - byte c = (byte) c_int; - byte[] bytes = value.bytes; - int end = value.begin + value.realSize; - - pos += value.begin; - for (; pos < end; pos++) { - if (bytes[pos] == c) { - return RubyFixnum.newFixnum(context.getRuntime(), pos - value.begin); - } - } - return context.getRuntime().getNil(); - } else if (sub instanceof RubyString) { - pos = strIndex((RubyString) sub, pos); - } else { - IRubyObject tmp = sub.checkStringType(); - - if (tmp.isNil()) { - throw context.getRuntime().newTypeError("type mismatch: " + sub.getMetaClass().getName() + " given"); - } - pos = strIndex((RubyString) tmp, pos); - } - - return pos == -1 ? context.getRuntime().getNil() : RubyFixnum.newFixnum(context.getRuntime(), pos); - } - - private int strIndex(RubyString sub, int offset) { - if (offset < 0) { - offset += value.realSize; - if (offset < 0) return -1; - } - - if (value.realSize - offset < sub.value.realSize) return -1; - if (sub.value.realSize == 0) return offset; - return value.indexOf(sub.value, offset); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with one or two arguments. - */ - public IRubyObject rindex(ThreadContext context, IRubyObject[] args) { - switch (args.length) { - case 1: - return rindex(context, args[0]); - case 2: - return rindex(context, args[0], args[1]); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_rindex_m - * - */ - @JRubyMethod(reads = BACKREF, writes = BACKREF) - public IRubyObject rindex(ThreadContext context, IRubyObject arg0) { - return rindexCommon(arg0, value.realSize, context); - } - - /** rb_str_rindex_m - * - */ - @JRubyMethod(reads = BACKREF, writes = BACKREF) - public IRubyObject rindex(ThreadContext context, IRubyObject arg0, IRubyObject arg1) { - int pos = RubyNumeric.num2int(arg1); - - if (pos < 0) { - pos += value.realSize; - if (pos < 0) { - if (arg0 instanceof RubyRegexp) { - context.getPreviousFrame().setBackRef(context.getRuntime().getNil()); - } - return context.getRuntime().getNil(); - } - } - if (pos > value.realSize) pos = value.realSize; - - return rindexCommon(arg0, pos, context); - } - - private IRubyObject rindexCommon(final IRubyObject sub, int pos, ThreadContext context) throws RaiseException { - - if (sub instanceof RubyRegexp) { - RubyRegexp regSub = (RubyRegexp) sub; - if (regSub.length() > 0) { - pos = regSub.adjustStartPos(this, pos, true); - pos = regSub.search(context, this, pos, true); - } - if (pos >= 0) { - return RubyFixnum.newFixnum(context.getRuntime(), pos); - } - } else if (sub instanceof RubyString) { - pos = strRindex((RubyString) sub, pos); - if (pos >= 0) return RubyFixnum.newFixnum(context.getRuntime(), pos); - } else if (sub instanceof RubyFixnum) { - int c_int = RubyNumeric.fix2int(sub); - if (c_int < 0x00 || c_int > 0xFF) { - // out of byte range - // there will be no match for sure - return context.getRuntime().getNil(); - } - byte c = (byte) c_int; - - byte[] bytes = value.bytes; - int pbeg = value.begin; - int p = pbeg + pos; - - if (pos == value.realSize) { - if (pos == 0) { - return context.getRuntime().getNil(); - } - --p; - } - while (pbeg <= p) { - if (bytes[p] == c) { - return RubyFixnum.newFixnum(context.getRuntime(), p - value.begin); - } - p--; - } - return context.getRuntime().getNil(); - } else { - IRubyObject tmp = sub.checkStringType(); - if (tmp.isNil()) throw context.getRuntime().newTypeError("type mismatch: " + sub.getMetaClass().getName() + " given"); - pos = strRindex((RubyString) tmp, pos); - if (pos >= 0) return RubyFixnum.newFixnum(context.getRuntime(), pos); - } - - return context.getRuntime().getNil(); - } - - private int strRindex(RubyString sub, int pos) { - int subLength = sub.value.realSize; - - /* substring longer than string */ - if (value.realSize < subLength) return -1; - if (value.realSize - pos < subLength) pos = value.realSize - subLength; - - return value.lastIndexOf(sub.value, pos); - } - - /* rb_str_substr */ - public IRubyObject substr(int beg, int len) { - return substr(getRuntime(), beg, len); - } - - public IRubyObject substr(Ruby runtime, int beg, int len) { - int length = value.length(); - if (len < 0 || beg > length) return getRuntime().getNil(); - - if (beg < 0) { - beg += length; - if (beg < 0) return getRuntime().getNil(); - } - - int end = Math.min(length, beg + len); - return makeShared(getRuntime(), beg, end - beg); - } - - - - /* rb_str_replace */ - public IRubyObject replace(int beg, int len, RubyString replaceWith) { - if (beg + len >= value.length()) len = value.length() - beg; - - modify(); - value.unsafeReplace(beg,len,replaceWith.value); - - return infectBy(replaceWith); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the versions with one or two args - */ - public IRubyObject op_aref(ThreadContext context, IRubyObject[] args) { - switch (args.length) { - case 1: - return op_aref(context, args[0]); - case 2: - return op_aref(context, args[0], args[1]); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_aref, rb_str_aref_m - * - */ - @JRubyMethod(name = {"[]", "slice"}, reads = BACKREF, writes = BACKREF) - public IRubyObject op_aref(ThreadContext context, IRubyObject arg1, IRubyObject arg2) { - if (arg1 instanceof RubyRegexp) { - if(((RubyRegexp)arg1).search(context, this, 0, false) >= 0) { - return RubyRegexp.nth_match(RubyNumeric.fix2int(arg2), context.getCurrentFrame().getBackRef()); - } - return context.getRuntime().getNil(); - } - return substr(context.getRuntime(), RubyNumeric.fix2int(arg1), RubyNumeric.fix2int(arg2)); - } - - /** rb_str_aref, rb_str_aref_m - * - */ - @JRubyMethod(name = {"[]", "slice"}, reads = BACKREF, writes = BACKREF) - public IRubyObject op_aref(ThreadContext context, IRubyObject arg) { - if (arg instanceof RubyRegexp) { - if(((RubyRegexp)arg).search(context, this, 0, false) >= 0) { - return RubyRegexp.nth_match(0, context.getCurrentFrame().getBackRef()); - } - return context.getRuntime().getNil(); - } else if (arg instanceof RubyString) { - return value.indexOf(stringValue(arg).value) != -1 ? - arg : context.getRuntime().getNil(); - } else if (arg instanceof RubyRange) { - long[] begLen = ((RubyRange) arg).begLen(value.length(), 0); - return begLen == null ? context.getRuntime().getNil() : - substr(context.getRuntime(), (int) begLen[0], (int) begLen[1]); - } - int idx = (int) arg.convertToInteger().getLongValue(); - - if (idx < 0) idx += value.length(); - if (idx < 0 || idx >= value.length()) return context.getRuntime().getNil(); - - return context.getRuntime().newFixnum(value.get(idx) & 0xFF); - } - - /** - * rb_str_subpat_set - * - */ - private void subpatSet(ThreadContext context, RubyRegexp regexp, int nth, IRubyObject repl) { - RubyMatchData match; - int start, end, len; - if (regexp.search(context, this, 0, false) < 0) throw context.getRuntime().newIndexError("regexp not matched"); - - match = (RubyMatchData)context.getCurrentFrame().getBackRef(); - - if (match.regs == null) { - if (nth >= 1) throw context.getRuntime().newIndexError("index " + nth + " out of regexp"); - if (nth < 0) { - if(-nth >= 1) throw context.getRuntime().newIndexError("index " + nth + " out of regexp"); - nth += 1; - } - start = match.begin; - if(start == -1) throw context.getRuntime().newIndexError("regexp group " + nth + " not matched"); - end = match.end; - } else { - if(nth >= match.regs.numRegs) throw context.getRuntime().newIndexError("index " + nth + " out of regexp"); - if(nth < 0) { - if(-nth >= match.regs.numRegs) throw context.getRuntime().newIndexError("index " + nth + " out of regexp"); - nth += match.regs.numRegs; - } - start = match.regs.beg[nth]; - if(start == -1) throw context.getRuntime().newIndexError("regexp group " + nth + " not matched"); - end = match.regs.end[nth]; - } - - len = end - start; - replace(start, len, stringValue(repl)); - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with two or three args. - */ - public IRubyObject op_aset(ThreadContext context, IRubyObject[] args) { - switch (args.length) { - case 2: - return op_aset(context, args[0], args[1]); - case 3: - return op_aset(context, args[0], args[1], args[2]); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 2, 3); - return null; // not reached - } - } - - /** rb_str_aset, rb_str_aset_m - * - */ - @JRubyMethod(name = "[]=", reads = BACKREF) - public IRubyObject op_aset(ThreadContext context, IRubyObject arg0, IRubyObject arg1) { - if (arg0 instanceof RubyFixnum || arg0.respondsTo("to_int")) { // FIXME: RubyNumeric or RubyInteger instead? - int idx = RubyNumeric.fix2int(arg0); - - if (idx < 0) idx += value.length(); - - if (idx < 0 || idx >= value.length()) { - throw context.getRuntime().newIndexError("string index out of bounds"); - } - if (arg1 instanceof RubyFixnum) { - modify(); - value.set(idx, (byte) RubyNumeric.fix2int(arg1)); - } else { - replace(idx, 1, stringValue(arg1)); - } - return arg1; - } - if (arg0 instanceof RubyRegexp) { - RubyString repl = stringValue(arg1); - subpatSet(context, (RubyRegexp) arg0, 0, repl); - return repl; - } - if (arg0 instanceof RubyString) { - RubyString orig = (RubyString)arg0; - int beg = value.indexOf(orig.value); - if (beg < 0) throw context.getRuntime().newIndexError("string not matched"); - replace(beg, orig.value.length(), stringValue(arg1)); - return arg1; - } - if (arg0 instanceof RubyRange) { - long[] begLen = ((RubyRange) arg0).begLen(value.realSize, 2); - replace((int) begLen[0], (int) begLen[1], stringValue(arg1)); - return arg1; - } - throw context.getRuntime().newTypeError("wrong argument type"); - } - - /** rb_str_aset, rb_str_aset_m - * - */ - @JRubyMethod(name = "[]=", reads = BACKREF) - public IRubyObject op_aset(ThreadContext context, IRubyObject arg0, IRubyObject arg1, IRubyObject arg2) { - if (arg0 instanceof RubyRegexp) { - RubyString repl = stringValue(arg2); - int nth = RubyNumeric.fix2int(arg1); - subpatSet(context, (RubyRegexp) arg0, nth, repl); - return repl; - } - RubyString repl = stringValue(arg2); - int beg = RubyNumeric.fix2int(arg0); - int len = RubyNumeric.fix2int(arg1); - if (len < 0) throw context.getRuntime().newIndexError("negative length"); - int strLen = value.length(); - if (beg < 0) beg += strLen; - - if (beg < 0 || (beg > 0 && beg > strLen)) { - throw context.getRuntime().newIndexError("string index out of bounds"); - } - if (beg + len > strLen) len = strLen - beg; - - replace(beg, len, repl); - return repl; - } - - /** - * Variable arity version for compatibility. Not bound as a Ruby method. - * @deprecated Use the versions with one or two args. - */ - public IRubyObject slice_bang(ThreadContext context, IRubyObject[] args) { - switch (args.length) { - case 1: - return slice_bang(context, args[0]); - case 2: - return slice_bang(context, args[0], args[1]); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_slice_bang - * - */ - @JRubyMethod(name = "slice!", reads = BACKREF, writes = BACKREF) - public IRubyObject slice_bang(ThreadContext context, IRubyObject arg0) { - IRubyObject result = op_aref(context, arg0); - if (result.isNil()) return result; - - op_aset(context, arg0, RubyString.newEmptyString(context.getRuntime())); - return result; - } - - /** rb_str_slice_bang - * - */ - @JRubyMethod(name = "slice!", reads = BACKREF, writes = BACKREF) - public IRubyObject slice_bang(ThreadContext context, IRubyObject arg0, IRubyObject arg1) { - IRubyObject result = op_aref(context, arg0, arg1); - if (result.isNil()) return result; - - op_aset(context, arg0, arg1, RubyString.newEmptyString(context.getRuntime())); - return result; - } - - @JRubyMethod(name = {"succ", "next"}) - public IRubyObject succ(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.succ_bang(); - return str; - } - - @JRubyMethod(name = {"succ!", "next!"}) - public IRubyObject succ_bang() { - if (value.length() == 0) { - modifyCheck(); - return this; - } - - modify(); - - boolean alnumSeen = false; - int pos = -1; - int c = 0; - int n = 0; - for (int i = value.length() - 1; i >= 0; i--) { - c = value.get(i) & 0xFF; - if (isAlnum(c)) { - alnumSeen = true; - if ((isDigit(c) && c < '9') || (isLower(c) && c < 'z') || (isUpper(c) && c < 'Z')) { - value.set(i, (byte)(c + 1)); - pos = -1; - break; - } - pos = i; - n = isDigit(c) ? '1' : (isLower(c) ? 'a' : 'A'); - value.set(i, (byte)(isDigit(c) ? '0' : (isLower(c) ? 'a' : 'A'))); - } - } - if (!alnumSeen) { - for (int i = value.length() - 1; i >= 0; i--) { - c = value.get(i) & 0xFF; - if (c < 0xff) { - value.set(i, (byte)(c + 1)); - pos = -1; - break; - } - pos = i; - n = '\u0001'; - value.set(i, 0); - } - } - if (pos > -1) { - // This represents left most digit in a set of incremented - // values? Therefore leftmost numeric must be '1' and not '0' - // 999 -> 1000, not 999 -> 0000. whereas chars should be - // zzz -> aaaa and non-alnum byte values should be "\377" -> "\001\000" - value.insert(pos, (byte) n); - } - return this; - } - - /** rb_str_upto_m - * - */ - @JRubyMethod(name = "upto", required = 1, frame = true) - public IRubyObject upto(ThreadContext context, IRubyObject str, Block block) { - return upto(context, str, false, block); - } - - /* rb_str_upto */ - public IRubyObject upto(ThreadContext context, IRubyObject str, boolean excl, Block block) { - RubyString end = str.convertToString(); - - int n = value.cmp(end.value); - if (n > 0 || (excl && n == 0)) return this; - - IRubyObject afterEnd = end.callMethod(context, "succ"); - RubyString current = this; - - while (!current.op_equal(context, afterEnd).isTrue()) { - block.yield(context, current); - if (!excl && current.op_equal(context, end).isTrue()) break; - current = current.callMethod(context, "succ").convertToString(); - if (excl && current.op_equal(context, end).isTrue()) break; - if (current.value.realSize > end.value.realSize || current.value.realSize == 0) break; - } - - return this; - } - - /** rb_str_include - * - */ - @JRubyMethod(name = "include?", required = 1) - public RubyBoolean include_p(ThreadContext context, IRubyObject obj) { - if (obj instanceof RubyFixnum) { - int c = RubyNumeric.fix2int(obj); - for (int i = 0; i < value.length(); i++) { - if (value.get(i) == (byte)c) { - return context.getRuntime().getTrue(); - } - } - return context.getRuntime().getFalse(); - } - ByteList str = stringValue(obj).value; - return context.getRuntime().newBoolean(value.indexOf(str) != -1); - } - - /** - * Variable-arity version for compatibility. Not bound as a Ruby method. - * @deprecated Use the versions with zero or one args. - */ - public IRubyObject to_i(IRubyObject[] args) { - switch (args.length) { - case 0: - return to_i(); - case 1: - return to_i(args[0]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 0, 1); - return null; // not reached - } - } - - /** rb_str_to_i - * - */ - @JRubyMethod(name = "to_i") - public IRubyObject to_i() { - return RubyNumeric.str2inum(getRuntime(), this, 10); - } - - /** rb_str_to_i - * - */ - @JRubyMethod(name = "to_i") - public IRubyObject to_i(IRubyObject arg0) { - long base = arg0.convertToInteger().getLongValue(); - return RubyNumeric.str2inum(getRuntime(), this, (int) base); - } - - /** rb_str_oct - * - */ - @JRubyMethod(name = "oct") - public IRubyObject oct(ThreadContext context) { - if (isEmpty()) return context.getRuntime().newFixnum(0); - - int base = 8; - - int ix = value.begin; - - while(ix < value.begin+value.realSize && ASCII.isSpace(value.bytes[ix] & 0xff)) { - ix++; - } - - int pos = (value.bytes[ix] == '-' || value.bytes[ix] == '+') ? ix+1 : ix; - if((pos+1) < value.begin+value.realSize && value.bytes[pos] == '0') { - if(value.bytes[pos+1] == 'x' || value.bytes[pos+1] == 'X') { - base = 16; - } else if(value.bytes[pos+1] == 'b' || value.bytes[pos+1] == 'B') { - base = 2; - } else if(value.bytes[pos+1] == 'd' || value.bytes[pos+1] == 'D') { - base = 10; - } - } - return RubyNumeric.str2inum(context.getRuntime(), this, base); - } - - /** rb_str_hex - * - */ - @JRubyMethod(name = "hex") - public IRubyObject hex(ThreadContext context) { - return RubyNumeric.str2inum(context.getRuntime(), this, 16); - } - - /** rb_str_to_f - * - */ - @JRubyMethod(name = "to_f") - public IRubyObject to_f() { - return RubyNumeric.str2fnum(getRuntime(), this); - } - - /** - * Variable arity version for compatibility. Not bound to a Ruby method. - * @deprecated Use the versions with zero, one, or two args. - */ - public RubyArray split(ThreadContext context, IRubyObject[] args) { - switch (args.length) { - case 0: - return split(context); - case 1: - return split(context, args[0]); - case 2: - return split(context, args[0], args[1]); - default: - Arity.raiseArgumentError(context.getRuntime(), args.length, 0, 2); - return null; // not reached - } - } - - /** rb_str_split_m - * - */ - @JRubyMethod(writes = BACKREF) - public RubyArray split(ThreadContext context) { - return split(context, context.getRuntime().getNil()); - } - - /** rb_str_split_m - * - */ - @JRubyMethod(writes = BACKREF) - public RubyArray split(ThreadContext context, IRubyObject arg0) { - return splitCommon(arg0, false, 0, 0, context); - } - - /** rb_str_split_m - * - */ - @JRubyMethod(writes = BACKREF) - public RubyArray split(ThreadContext context, IRubyObject arg0, IRubyObject arg1) { - final int lim = RubyNumeric.fix2int(arg1); - if (lim <= 0) { - return splitCommon(arg0, false, lim, 1, context); - } else { - if (lim == 1) return value.realSize == 0 ? context.getRuntime().newArray() : context.getRuntime().newArray(this); - return splitCommon(arg0, true, lim, 1, context); - } - } - - private RubyArray splitCommon(IRubyObject spat, final boolean limit, final int lim, final int i, ThreadContext context) { - final RubyArray result; - if (spat.isNil() && (spat = context.getRuntime().getGlobalVariables().get("$;")).isNil()) { - result = awkSplit(limit, lim, i); - } else { - if (spat instanceof RubyString && ((RubyString) spat).value.realSize == 1) { - RubyString strSpat = (RubyString) spat; - if (strSpat.value.bytes[strSpat.value.begin] == (byte) ' ') { - result = awkSplit(limit, lim, i); - } else { - result = split(context, spat, limit, lim, i); - } - } else { - result = split(context, spat, limit, lim, i); - } - } - - if (!limit && lim == 0) { - while (result.size() > 0 && ((RubyString) result.eltInternal(result.size() - 1)).value.realSize == 0) { - result.pop(); - } - } - - return result; - } - - private RubyArray split(ThreadContext context, IRubyObject pat, boolean limit, int lim, int i) { - Ruby runtime = context.getRuntime(); - - final Regex regex = getPattern(pat, true).getPattern(); - int beg, end, start; - - int begin = value.begin; - start = begin; - beg = 0; - - int range = value.begin + value.realSize; - final Matcher matcher = regex.matcher(value.bytes, value.begin, range); - - boolean lastNull = false; - RubyArray result = runtime.newArray(); - if (regex.numberOfCaptures() == 0) { // shorter path, no captures defined, no region will be returned - while ((end = matcher.search(start, range, Option.NONE)) >= 0) { - if (start == end + begin && matcher.getBegin() == matcher.getEnd()) { - if (value.realSize == 0) { - result.append(newEmptyString(runtime, getMetaClass())); - break; - } else if (lastNull) { - result.append(substr(runtime, beg, regex.getEncoding().length(value.bytes[begin + beg]))); - beg = start - begin; - } else { - if (start == range) { - start++; - } else { - start += regex.getEncoding().length(value.bytes[start]); - } - lastNull = true; - continue; - } - } else { - result.append(substr(beg, end - beg)); - beg = matcher.getEnd(); - start = begin + matcher.getEnd(); - } - lastNull = false; - if (limit && lim <= ++i) break; - } - } else { - while ((end = matcher.search(start, range, Option.NONE)) >= 0) { - final Region region = matcher.getRegion(); - if (start == end + begin && region.beg[0] == region.end[0]) { - if (value.realSize == 0) { - result.append(newEmptyString(runtime, getMetaClass())); - break; - } else if (lastNull) { - result.append(substr(beg, regex.getEncoding().length(value.bytes[begin + beg]))); - beg = start - begin; - } else { - if (start == range) { - start++; - } else { - start += regex.getEncoding().length(value.bytes[start]); - } - lastNull = true; - continue; - } - } else { - result.append(substr(beg, end - beg)); - beg = start = region.end[0]; - start += begin; - } - lastNull = false; - - for (int idx=1; idx<region.numRegs; idx++) { - if (region.beg[idx] == -1) continue; - if (region.beg[idx] == region.end[idx]) { - result.append(newEmptyString(runtime, getMetaClass())); - } else { - result.append(substr(region.beg[idx], region.end[idx] - region.beg[idx])); - } - } - if (limit && lim <= ++i) break; - } - } - - // only this case affects backrefs - context.getCurrentFrame().setBackRef(runtime.getNil()); - - if (value.realSize > 0 && (limit || value.realSize > beg || lim < 0)) { - if (value.realSize == beg) { - result.append(newEmptyString(runtime, getMetaClass())); - } else { - result.append(substr(beg, value.realSize - beg)); - } - } - - return result; - } - - private RubyArray awkSplit(boolean limit, int lim, int i) { - Ruby runtime = getRuntime(); - RubyArray result = runtime.newArray(); - - byte[]bytes = value.bytes; - int p = value.begin; - int endp = p + value.realSize; - - boolean skip = true; - - int end, beg = 0; - for (end = beg = 0; p < endp; p++) { - if (skip) { - if (ASCII.isSpace(bytes[p] & 0xff)) { - beg++; - } else { - end = beg + 1; - skip = false; - if (limit && lim <= i) break; - } - } else { - if (ASCII.isSpace(bytes[p] & 0xff)) { - result.append(makeShared(runtime, beg, end - beg)); - skip = true; - beg = end + 1; - if (limit) i++; - } else { - end++; - } - } - } - - if (value.realSize > 0 && (limit || value.realSize > beg || lim < 0)) { - if (value.realSize == beg) { - result.append(newEmptyString(runtime, getMetaClass())); - } else { - result.append(makeShared(runtime, beg, value.realSize - beg)); - } - } - return result; - } - - /** get_pat - * - */ - private final RubyRegexp getPattern(IRubyObject obj, boolean quote) { - if (obj instanceof RubyRegexp) { - return (RubyRegexp)obj; - } else if (!(obj instanceof RubyString)) { - IRubyObject val = obj.checkStringType(); - if (val.isNil()) throw getRuntime().newTypeError("wrong argument type " + obj.getMetaClass() + " (expected Regexp)"); - obj = val; - } - - return RubyRegexp.newRegexp(getRuntime(), ((RubyString)obj).value, 0, quote); - } - - /** rb_str_scan - * - */ - @JRubyMethod(name = "scan", required = 1, frame = true, reads = BACKREF, writes = BACKREF) - public IRubyObject scan(ThreadContext context, IRubyObject arg, Block block) { - Ruby runtime = context.getRuntime(); - Frame frame = context.getPreviousFrame(); - - final RubyRegexp rubyRegex = getPattern(arg, true); - final Regex regex = rubyRegex.getPattern(); - - int range = value.begin + value.realSize; - final Matcher matcher = regex.matcher(value.bytes, value.begin, range); - matcher.value = 0; // implicit start argument to scanOnce(NG) - - IRubyObject result; - if (!block.isGiven()) { - RubyArray ary = runtime.newArray(); - - if (regex.numberOfCaptures() == 0) { - while ((result = scanOnceNG(rubyRegex, matcher, range)) != null) ary.append(result); - } else { - while ((result = scanOnce(rubyRegex, matcher, range)) != null) ary.append(result); - } - - if (ary.size() > 0) { - rubyRegex.updateBackRef(context, this, frame, matcher); - } else { - frame.setBackRef(runtime.getNil()); - } - return ary; - } else { - byte[]bytes = value.bytes; - int size = value.realSize; - RubyMatchData match = null; - - if (regex.numberOfCaptures() == 0) { - while ((result = scanOnceNG(rubyRegex, matcher, range)) != null) { - match = rubyRegex.updateBackRef(context, this, frame, matcher); - match.use(); - block.yield(context, result); - modifyCheck(bytes, size); - } - } else { - while ((result = scanOnce(rubyRegex, matcher, range)) != null) { - match = rubyRegex.updateBackRef(context, this, frame, matcher); - match.use(); - block.yield(context, result); - modifyCheck(bytes, size); - } - } - frame.setBackRef(match == null ? runtime.getNil() : match); - return this; - } - } - - /** - * rb_enc_check - */ - @SuppressWarnings("unused") - private Encoding encodingCheck(RubyRegexp pattern) { - // For 1.9 compatibility, should check encoding compat between string and pattern - return pattern.getKCode().getEncoding(); - } - - // no group version - private IRubyObject scanOnceNG(RubyRegexp regex, Matcher matcher, int range) { - if (matcher.search(matcher.value + value.begin, range, Option.NONE) >= 0) { - int end = matcher.getEnd(); - if (matcher.getBegin() == end) { - if (value.realSize > end) { - matcher.value = end + regex.getPattern().getEncoding().length(value.bytes[value.begin + end]); - } else { - matcher.value = end + 1; - } - } else { - matcher.value = end; - } - return substr(matcher.getBegin(), end - matcher.getBegin()).infectBy(regex); - } - return null; - } - - // group version - private IRubyObject scanOnce(RubyRegexp regex, Matcher matcher, int range) { - if (matcher.search(matcher.value + value.begin, range, Option.NONE) >= 0) { - Region region = matcher.getRegion(); - int end = region.end[0]; - if (region.beg[0] == end) { - if (value.realSize > end) { - matcher.value = end + regex.getPattern().getEncoding().length(value.bytes[value.begin + end]); - } else { - matcher.value = end + 1; - } - } else { - matcher.value = end; - } - - RubyArray result = getRuntime().newArray(region.numRegs); - for (int i=1; i<region.numRegs; i++) { - int beg = region.beg[i]; - if (beg == -1) { - result.append(getRuntime().getNil()); - } else { - result.append(substr(beg, region.end[i] - beg).infectBy(regex)); - } - } - return result; - } - return null; - } - - private static final ByteList SPACE_BYTELIST = new ByteList(ByteList.plain(" ")); - - private final IRubyObject justify(IRubyObject arg0, char jflag) { - Ruby runtime = getRuntime(); - - int width = RubyFixnum.num2int(arg0); - - int f, flen = 0; - byte[]fbuf; - - IRubyObject pad; - - f = SPACE_BYTELIST.begin; - flen = SPACE_BYTELIST.realSize; - fbuf = SPACE_BYTELIST.bytes; - pad = runtime.getNil(); - - return justifyCommon(width, jflag, flen, fbuf, f, runtime, pad); - } - - private final IRubyObject justify(IRubyObject arg0, IRubyObject arg1, char jflag) { - Ruby runtime = getRuntime(); - - int width = RubyFixnum.num2int(arg0); - - int f, flen = 0; - byte[]fbuf; - - IRubyObject pad; - - pad = arg1.convertToString(); - ByteList fList = ((RubyString)pad).value; - f = fList.begin; - flen = fList.realSize; - - if (flen == 0) throw runtime.newArgumentError("zero width padding"); - - fbuf = fList.bytes; - - return justifyCommon(width, jflag, flen, fbuf, f, runtime, pad); - } - - private IRubyObject justifyCommon(int width, char jflag, int flen, byte[] fbuf, int f, Ruby runtime, IRubyObject pad) { - if (width < 0 || value.realSize >= width) return strDup(runtime); - - ByteList res = new ByteList(width); - res.realSize = width; - - int p = res.begin; - int pend; - byte[] pbuf = res.bytes; - - if (jflag != 'l') { - int n = width - value.realSize; - pend = p + ((jflag == 'r') ? n : n / 2); - if (flen <= 1) { - while (p < pend) { - pbuf[p++] = fbuf[f]; - } - } else { - int q = f; - while (p + flen <= pend) { - System.arraycopy(fbuf, f, pbuf, p, flen); - p += flen; - } - while (p < pend) { - pbuf[p++] = fbuf[q++]; - } - } - } - - System.arraycopy(value.bytes, value.begin, pbuf, p, value.realSize); - - if (jflag != 'r') { - p += value.realSize; - pend = res.begin + width; - if (flen <= 1) { - while (p < pend) { - pbuf[p++] = fbuf[f]; - } - } else { - while (p + flen <= pend) { - System.arraycopy(fbuf, f, pbuf, p, flen); - p += flen; - } - while (p < pend) { - pbuf[p++] = fbuf[f++]; - } - } - } - - RubyString resStr = new RubyString(runtime, getMetaClass(), res); - resStr.infectBy(this); - if (flen > 0) { - resStr.infectBy(pad); - } - return resStr; - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated use the one or two argument versions. - */ - public IRubyObject ljust(IRubyObject [] args) { - switch (args.length) { - case 1: - return ljust(args[0]); - case 2: - return ljust(args[0], args[1]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_ljust - * - */ - @JRubyMethod - public IRubyObject ljust(IRubyObject arg0) { - return justify(arg0, 'l'); - } - - /** rb_str_ljust - * - */ - @JRubyMethod - public IRubyObject ljust(IRubyObject arg0, IRubyObject arg1) { - return justify(arg0, arg1, 'l'); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated use the one or two argument versions. - */ - public IRubyObject rjust(IRubyObject [] args) { - switch (args.length) { - case 1: - return rjust(args[0]); - case 2: - return rjust(args[0], args[1]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_rjust - * - */ - @JRubyMethod - public IRubyObject rjust(IRubyObject arg0) { - return justify(arg0, 'r'); - } - - /** rb_str_rjust - * - */ - @JRubyMethod - public IRubyObject rjust(IRubyObject arg0, IRubyObject arg1) { - return justify(arg0, arg1, 'r'); - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated use the one or two argument versions. - */ - public IRubyObject center(IRubyObject [] args) { - switch (args.length) { - case 1: - return center(args[0]); - case 2: - return center(args[0], args[1]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 1, 2); - return null; // not reached - } - } - - /** rb_str_center - * - */ - @JRubyMethod - public IRubyObject center(IRubyObject arg0) { - return justify(arg0, 'c'); - } - - /** rb_str_center - * - */ - @JRubyMethod - public IRubyObject center(IRubyObject arg0, IRubyObject arg1) { - return justify(arg0, arg1, 'c'); - } - - @JRubyMethod(name = "chop") - public IRubyObject chop(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.chop_bang(); - return str; - } - - /** rb_str_chop_bang - * - */ - @JRubyMethod(name = "chop!") - public IRubyObject chop_bang() { - int end = value.realSize - 1; - if (end < 0) return getRuntime().getNil(); - - if ((value.bytes[value.begin + end]) == '\n') { - if (end > 0 && (value.bytes[value.begin + end - 1]) == '\r') end--; - } - - view(0, end); - return this; - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby - * - * @param args - * @return - * @deprecated Use the zero or one argument versions. - */ - public RubyString chomp(IRubyObject[] args) { - switch (args.length) { - case 0: - return chomp(); - case 1: - return chomp(args[0]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 0, 1); - return null; // not reached - } - } - - /** rb_str_chop - * - */ - @JRubyMethod - public RubyString chomp() { - RubyString str = strDup(getRuntime()); - str.chomp_bang(); - return str; - } - - /** rb_str_chop - * - */ - @JRubyMethod - public RubyString chomp(IRubyObject arg0) { - RubyString str = strDup(getRuntime()); - str.chomp_bang(arg0); - return str; - } - - /** - * Variable-arity version for compatibility. Not bound to Ruby. - * @deprecated Use the zero or one argument versions. - */ - public IRubyObject chomp_bang(IRubyObject[] args) { - switch (args.length) { - case 0: - return chomp_bang(); - case 1: - return chomp_bang(args[0]); - default: - Arity.raiseArgumentError(getRuntime(), args.length, 0, 1); - return null; // not reached - } - } - - /** - * rb_str_chomp_bang - * - * In the common case, removes CR and LF characters in various ways depending on the value of - * the optional args[0]. - * If args.length==0 removes one instance of CR, CRLF or LF from the end of the string. - * If args.length>0 and args[0] is "\n" then same behaviour as args.length==0 . - * If args.length>0 and args[0] is "" then removes trailing multiple LF or CRLF (but no CRs at - * all(!)). - * @param args See method description. - */ - @JRubyMethod(name = "chomp!") - public IRubyObject chomp_bang() { - IRubyObject rsObj; - - int len = value.length(); - if (len == 0) return getRuntime().getNil(); - byte[]buff = value.bytes; - - rsObj = getRuntime().getGlobalVariables().get("$/"); - - if (rsObj == getRuntime().getGlobalVariables().getDefaultSeparator()) { - int realSize = value.realSize; - int begin = value.begin; - if (buff[begin + len - 1] == (byte)'\n') { - realSize--; - if (realSize > 0 && buff[begin + realSize - 1] == (byte)'\r') realSize--; - view(0, realSize); - } else if (buff[begin + len - 1] == (byte)'\r') { - realSize--; - view(0, realSize); - } else { - modifyCheck(); - return getRuntime().getNil(); - } - return this; - } - - return chompBangCommon(rsObj); - } - - /** - * rb_str_chomp_bang - * - * In the common case, removes CR and LF characters in various ways depending on the value of - * the optional args[0]. - * If args.length==0 removes one instance of CR, CRLF or LF from the end of the string. - * If args.length>0 and args[0] is "\n" then same behaviour as args.length==0 . - * If args.length>0 and args[0] is "" then removes trailing multiple LF or CRLF (but no CRs at - * all(!)). - * @param args See method description. - */ - @JRubyMethod(name = "chomp!") - public IRubyObject chomp_bang(IRubyObject arg0) { - return chompBangCommon(arg0); - } - - private IRubyObject chompBangCommon(IRubyObject rsObj) { - - if (rsObj.isNil()) { - return getRuntime().getNil(); - } - RubyString rs = rsObj.convertToString(); - int len = value.realSize; - int begin = value.begin; - if (len == 0) { - return getRuntime().getNil(); - } - byte[] buff = value.bytes; - int rslen = rs.value.realSize; - - if (rslen == 0) { - while (len > 0 && buff[begin + len - 1] == (byte) '\n') { - len--; - if (len > 0 && buff[begin + len - 1] == (byte) '\r') { - len--; - } - } - if (len < value.realSize) { - view(0, len); - return this; - } - return getRuntime().getNil(); - } - - if (rslen > len) { - return getRuntime().getNil(); - } - byte newline = rs.value.bytes[rslen - 1]; - - if (rslen == 1 && newline == (byte) '\n') { - buff = value.bytes; - int realSize = value.realSize; - if (buff[begin + len - 1] == (byte) '\n') { - realSize--; - if (realSize > 0 && buff[begin + realSize - 1] == (byte) '\r') { - realSize--; - } - view(0, realSize); - } else if (buff[begin + len - 1] == (byte) '\r') { - realSize--; - view(0, realSize); - } else { - modifyCheck(); - return getRuntime().getNil(); - } - return this; - } - - if (buff[begin + len - 1] == newline && rslen <= 1 || value.endsWith(rs.value)) { - view(0, value.realSize - rslen); - return this; - } - - return getRuntime().getNil(); - } - - /** rb_str_lstrip - * - */ - @JRubyMethod - public IRubyObject lstrip(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.lstrip_bang(); - return str; - } - - /** rb_str_lstrip_bang - */ - @JRubyMethod(name = "lstrip!") - public IRubyObject lstrip_bang() { - if (value.realSize == 0) return getRuntime().getNil(); - - int i=0; - while (i < value.realSize && ASCII.isSpace(value.bytes[value.begin + i] & 0xff)) i++; - - if (i > 0) { - view(i, value.realSize - i); - return this; - } - - return getRuntime().getNil(); - } - - /** rb_str_rstrip - * - */ - @JRubyMethod - public IRubyObject rstrip(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.rstrip_bang(); - return str; - } - - /** rb_str_rstrip_bang - */ - @JRubyMethod(name = "rstrip!") - public IRubyObject rstrip_bang() { - if (value.realSize == 0) return getRuntime().getNil(); - int i=value.realSize - 1; - - while (i >= 0 && value.bytes[value.begin+i] == 0) i--; - while (i >= 0 && ASCII.isSpace(value.bytes[value.begin + i] & 0xff)) i--; - - if (i < value.realSize - 1) { - view(0, i + 1); - return this; - } - - return getRuntime().getNil(); - } - - /** rb_str_strip - * - */ - @JRubyMethod - public IRubyObject strip(ThreadContext context) { - RubyString str = strDup(context.getRuntime()); - str.strip_bang(); - return str; - } - - /** rb_str_strip_bang - */ - @JRubyMethod(name = "strip!") - public IRubyObject strip_bang() { - IRubyObject l = lstrip_bang(); - IRubyObject r = rstrip_bang(); - - if(l.isNil() && r.isNil()) { - return l; - } - return this; - } - - /** rb_str_count - * - */ - @JRubyMethod(name = "count", required = 1, rest = true) - public IRubyObject count(IRubyObject[] args) { - if (args.length < 1) throw getRuntime().newArgumentError("wrong number of arguments"); - if (value.realSize == 0) return getRuntime().newFixnum(0); - - boolean[]table = new boolean[TRANS_SIZE]; - boolean init = true; - for (int i=0; i<args.length; i++) { - RubyString s = args[i].convertToString(); - s.setup_table(table, init); - init = false; - } - - int s = value.begin; - int send = s + value.realSize; - byte[]buf = value.bytes; - int i = 0; - - while (s < send) if (table[buf[s++] & 0xff]) i++; - - return getRuntime().newFixnum(i); - } - - /** rb_str_delete - * - */ - @JRubyMethod(name = "delete", required = 1, rest = true) - public IRubyObject delete(ThreadContext context, IRubyObject[] args) { - RubyString str = strDup(context.getRuntime()); - str.delete_bang(args); - return str; - } - - /** rb_str_delete_bang - * - */ - @JRubyMethod(name = "delete!", required = 1, rest = true) - public IRubyObject delete_bang(IRubyObject[] args) { - if (args.length < 1) throw getRuntime().newArgumentError("wrong number of arguments"); - - boolean[]squeeze = new boolean[TRANS_SIZE]; - - boolean init = true; - for (int i=0; i<args.length; i++) { - RubyString s = args[i].convertToString(); - s.setup_table(squeeze, init); - init = false; - } - - modify(); - - if (value.realSize == 0) return getRuntime().getNil(); - int s = value.begin; - int t = s; - int send = s + value.realSize; - byte[]buf = value.bytes; - boolean modify = false; - - while (s < send) { - if (squeeze[buf[s] & 0xff]) { - modify = true; - } else { - buf[t++] = buf[s]; - } - s++; - } - value.realSize = t - value.begin; - - if (modify) return this; - return getRuntime().getNil(); - } - - /** rb_str_squeeze - * - */ - @JRubyMethod(name = "squeeze", rest = true) - public IRubyObject squeeze(ThreadContext context, IRubyObject[] args) { - RubyString str = strDup(context.getRuntime()); - str.squeeze_bang(args); - return str; - } - - /** rb_str_squeeze_bang - * - */ - @JRubyMethod(name = "squeeze!", rest = true) - public IRubyObject squeeze_bang(IRubyObject[] args) { - if (value.realSize == 0) { - modifyCheck(); - return getRuntime().getNil(); - } - - final boolean squeeze[] = new boolean[TRANS_SIZE]; - - if (args.length == 0) { - for (int i=0; i<TRANS_SIZE; i++) squeeze[i] = true; - } else { - boolean init = true; - for (int i=0; i<args.length; i++) { - RubyString s = args[i].convertToString(); - s.setup_table(squeeze, init); - init = false; - } - } - - modify(); - - int s = value.begin; - int t = s; - int send = s + value.realSize; - byte[]buf = value.bytes; - int save = -1; - - while (s < send) { - int c = buf[s++] & 0xff; - if (c != save || !squeeze[c]) buf[t++] = (byte)(save = c); - } - - if (t - value.begin != value.realSize) { // modified - value.realSize = t - value.begin; - return this; - } - - return getRuntime().getNil(); - } - - /** rb_str_tr - * - */ - @JRubyMethod - public IRubyObject tr(ThreadContext context, IRubyObject src, IRubyObject repl) { - RubyString str = strDup(context.getRuntime()); - str.tr_trans(src, repl, false); - return str; - } - - /** rb_str_tr_bang - * - */ - @JRubyMethod(name = "tr!") - public IRubyObject tr_bang(IRubyObject src, IRubyObject repl) { - return tr_trans(src, repl, false); - } - - private static final class TR { - int gen, now, max; - int p, pend; - byte[]buf; - } - - private static final int TRANS_SIZE = 256; - - /** tr_setup_table - * - */ - private final void setup_table(boolean[]table, boolean init) { - final boolean[]buf = new boolean[TRANS_SIZE]; - final TR tr = new TR(); - int c; - - boolean cflag = false; - - tr.p = value.begin; - tr.pend = value.begin + value.realSize; - tr.buf = value.bytes; - tr.gen = tr.now = tr.max = 0; - - if (value.realSize > 1 && value.bytes[value.begin] == '^') { - cflag = true; - tr.p++; - } - - if (init) for (int i=0; i<TRANS_SIZE; i++) table[i] = true; - - for (int i=0; i<TRANS_SIZE; i++) buf[i] = cflag; - while ((c = trnext(tr)) >= 0) buf[c & 0xff] = !cflag; - for (int i=0; i<TRANS_SIZE; i++) table[i] = table[i] && buf[i]; - } - - /** tr_trans - * - */ - private final IRubyObject tr_trans(IRubyObject src, IRubyObject repl, boolean sflag) { - if (value.realSize == 0) return getRuntime().getNil(); - - ByteList replList = repl.convertToString().value; - - if (replList.realSize == 0) return delete_bang(new IRubyObject[]{src}); - - ByteList srcList = src.convertToString().value; - - final TR trsrc = new TR(); - final TR trrepl = new TR(); - - boolean cflag = false; - boolean modify = false; - - trsrc.p = srcList.begin; - trsrc.pend = srcList.begin + srcList.realSize; - trsrc.buf = srcList.bytes; - if (srcList.realSize >= 2 && srcList.bytes[srcList.begin] == '^') { - cflag = true; - trsrc.p++; - } - - trrepl.p = replList.begin; - trrepl.pend = replList.begin + replList.realSize; - trrepl.buf = replList.bytes; - - trsrc.gen = trrepl.gen = 0; - trsrc.now = trrepl.now = 0; - trsrc.max = trrepl.max = 0; - - int c; - final int[]trans = new int[TRANS_SIZE]; - if (cflag) { - for (int i=0; i<TRANS_SIZE; i++) trans[i] = 1; - while ((c = trnext(trsrc)) >= 0) trans[c & 0xff] = -1; - while ((c = trnext(trrepl)) >= 0); - for (int i=0; i<TRANS_SIZE; i++) { - if (trans[i] >= 0) trans[i] = trrepl.now; - } - } else { - for (int i=0; i<TRANS_SIZE; i++) trans[i] = -1; - while ((c = trnext(trsrc)) >= 0) { - int r = trnext(trrepl); - if (r == -1) r = trrepl.now; - trans[c & 0xff] = r; - } - } - - modify(); - - int s = value.begin; - int send = s + value.realSize; - byte sbuf[] = value.bytes; - - if (sflag) { - int t = s; - int c0, last = -1; - while (s < send) { - c0 = sbuf[s++]; - if ((c = trans[c0 & 0xff]) >= 0) { - if (last == c) continue; - last = c; - sbuf[t++] = (byte)(c & 0xff); - modify = true; - } else { - last = -1; - sbuf[t++] = (byte)c0; - } - } - - if (value.realSize > (t - value.begin)) { - value.realSize = t - value.begin; - modify = true; - } - } else { - while (s < send) { - if ((c = trans[sbuf[s] & 0xff]) >= 0) { - sbuf[s] = (byte)(c & 0xff); - modify = true; - } - s++; - } - } - - if (modify) return this; - return getRuntime().getNil(); - } - - /** trnext - * - */ - private final int trnext(TR t) { - byte [] buf = t.buf; - - for (;;) { - if (t.gen == 0) { - if (t.p == t.pend) return -1; - if (t.p < t.pend -1 && buf[t.p] == '\\') t.p++; - t.now = buf[t.p++]; - if (t.p < t.pend - 1 && buf[t.p] == '-') { - t.p++; - if (t.p < t.pend) { - if (t.now > ((int)buf[t.p] & 0xFF)) { - t.p++; - continue; - } - t.gen = 1; - t.max = (int)buf[t.p++] & 0xFF; - } - } - return t.now & 0xff; - } else if (++t.now < t.max) { - return t.now & 0xff; - } else { - t.gen = 0; - return t.max & 0xff; - } - } - } - - /** rb_str_tr_s - * - */ - @JRubyMethod - public IRubyObject tr_s(ThreadContext context, IRubyObject src, IRubyObject repl) { - RubyString str = strDup(context.getRuntime()); - str.tr_trans(src, repl, true); - return str; - } - - /** rb_str_tr_s_bang - * - */ - @JRubyMethod(name = "tr_s!") - public IRubyObject tr_s_bang(IRubyObject src, IRubyObject repl) { - return tr_trans(src, repl, true); - } - - /** rb_str_each_line - * - */ - @JRubyMethod(name = {"each_line", "each"}, required = 0, optional = 1, frame = true) - public IRubyObject each_line(ThreadContext context, IRubyObject[] args, Block block) { - byte newline; - int p = value.begin; - int pend = p + value.realSize; - int s; - int ptr = p; - int len = value.realSize; - int rslen; - IRubyObject line; - - - IRubyObject _rsep; - if (args.length == 0) { - _rsep = getRuntime().getGlobalVariables().get("$/"); - } else { - _rsep = args[0]; - } - - if(_rsep.isNil()) { - block.yield(context, this); - return this; - } - - RubyString rsep = stringValue(_rsep); - ByteList rsepValue = rsep.value; - byte[] strBytes = value.bytes; - - rslen = rsepValue.realSize; - - if(rslen == 0) { - newline = '\n'; - } else { - newline = rsepValue.bytes[rsepValue.begin + rslen-1]; - } - - s = p; - p+=rslen; - - for(; p < pend; p++) { - if(rslen == 0 && strBytes[p] == '\n') { - if(strBytes[++p] != '\n') { - continue; - } - while(p < pend && strBytes[p] == '\n') { - p++; - } - } - if(ptr<p && strBytes[p-1] == newline && - (rslen <= 1 || - ByteList.memcmp(rsepValue.bytes, rsepValue.begin, rslen, strBytes, p-rslen, rslen) == 0)) { - line = RubyString.newStringShared(getRuntime(), getMetaClass(), this.value.makeShared(s-ptr, p-s)); - line.infectBy(this); - block.yield(context, line); - modifyCheck(strBytes,len); - s = p; - } - } - - if(s != pend) { - if(p > pend) { - p = pend; - } - line = RubyString.newStringShared(getRuntime(), getMetaClass(), this.value.makeShared(s-ptr, p-s)); - line.infectBy(this); - block.yield(context, line); - } - - return this; - } - - /** - * rb_str_each_byte - */ - @JRubyMethod(name = "each_byte", frame = true) - public RubyString each_byte(ThreadContext context, Block block) { - Ruby runtime = getRuntime(); - // Check the length every iteration, since - // the block can modify this string. - for (int i = 0; i < value.length(); i++) { - block.yield(context, runtime.newFixnum(value.get(i) & 0xFF)); - } - return this; - } - - /** rb_str_intern - * - */ - public RubySymbol intern() { - String s = toString(); - if (s.length() == 0) { - throw getRuntime().newArgumentError("interning empty string"); - } - if (s.indexOf('\0') >= 0) { - throw getRuntime().newArgumentError("symbol string may not contain '\\0'"); - } - return getRuntime().newSymbol(s); - } - - @JRubyMethod(name = {"to_sym", "intern"}) - public RubySymbol to_sym() { - return intern(); - } - - @JRubyMethod(name = "sum", optional = 1) - public RubyInteger sum(IRubyObject[] args) { - if (args.length > 1) { - throw getRuntime().newArgumentError("wrong number of arguments (" + args.length + " for 1)"); - } - - long bitSize = 16; - if (args.length == 1) { - long bitSizeArg = ((RubyInteger) args[0].convertToInteger()).getLongValue(); - if (bitSizeArg > 0) { - bitSize = bitSizeArg; - } - } - - long result = 0; - for (int i = 0; i < value.length(); i++) { - result += value.get(i) & 0xFF; - } - return getRuntime().newFixnum(bitSize == 0 ? result : result % (long) Math.pow(2, bitSize)); - } - - /** string_to_c - * - */ - @JRubyMethod(name = "to_c", reads = BACKREF, writes = BACKREF, compat = CompatVersion.RUBY1_9) - public IRubyObject to_c(ThreadContext context) { - Ruby runtime = context.getRuntime(); - Frame frame = context.getCurrentFrame(); - IRubyObject backref = frame.getBackRef(); - if (backref != null && backref instanceof RubyMatchData) ((RubyMatchData)backref).use(); - - IRubyObject s = RuntimeHelpers.invoke( - context, this, "gsub", - RubyRegexp.newRegexp(runtime, Numeric.ComplexPatterns.underscores_pat), - runtime.newString(new ByteList(new byte[]{'_'}))); - - RubyArray a = RubyComplex.str_to_c_internal(context, s); - - frame.setBackRef(backref); - - if (!a.eltInternal(0).isNil()) { - return a.eltInternal(0); - } else { - return RubyComplex.newComplexCanonicalize(context, RubyFixnum.zero(runtime)); - } - } - - /** string_to_r - * - */ - @JRubyMethod(name = "to_r", reads = BACKREF, writes = BACKREF, compat = CompatVersion.RUBY1_9) - public IRubyObject to_r(ThreadContext context) { - Ruby runtime = context.getRuntime(); - Frame frame = context.getCurrentFrame(); - IRubyObject backref = frame.getBackRef(); - if (backref != null && backref instanceof RubyMatchData) ((RubyMatchData)backref).use(); - - IRubyObject s = RuntimeHelpers.invoke( - context, this, "gsub", - RubyRegexp.newRegexp(runtime, Numeric.ComplexPatterns.underscores_pat), - runtime.newString(new ByteList(new byte[]{'_'}))); - - RubyArray a = RubyRational.str_to_r_internal(context, s); - - frame.setBackRef(backref); - - if (!a.eltInternal(0).isNil()) { - return a.eltInternal(0); - } else { - return RubyRational.newRationalCanonicalize(context, RubyFixnum.zero(runtime)); - } - } - - public static RubyString unmarshalFrom(UnmarshalStream input) throws java.io.IOException { - RubyString result = newString(input.getRuntime(), input.unmarshalString()); - input.registerLinkTarget(result); - return result; - } - - /** - * @see org.jruby.util.Pack#unpack - */ - @JRubyMethod - public RubyArray unpack(IRubyObject obj) { - return Pack.unpack(getRuntime(), this.value, stringValue(obj).value); - } - - public void empty() { - value = ByteList.EMPTY_BYTELIST; - shareLevel = SHARE_LEVEL_BYTELIST; - } - - /** - * Mutator for internal string representation. - * - * @param value The new java.lang.String this RubyString should encapsulate - * @deprecated - */ - public void setValue(CharSequence value) { - view(ByteList.plain(value)); - } - - public void setValue(ByteList value) { - view(value); - } - - public CharSequence getValue() { - return toString(); - } - - public byte[] getBytes() { - return value.bytes(); - } - - public ByteList getByteList() { - return value; - } - - /** used by ar-jdbc - * - */ - public String getUnicodeValue() { - try { - return new String(value.bytes,value.begin,value.realSize, "UTF8"); - } catch (Exception e) { - throw new RuntimeException("Something's seriously broken with encodings", e); - } - } - - @Override - public IRubyObject to_java() { - return MiniJava.javaToRuby(getRuntime(), new String(getBytes())); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006 Ola Bini <ola@ologix.com> - * Copyright (C) 2006 Ryan Bell <ryan.l.bell@gmail.com> - * Copyright (C) 2007 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2008 Vladimir Sizikov <vsizikov@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.util.ArrayList; -import java.util.List; - -import org.jruby.anno.FrameField; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.runtime.Block; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.TypeConverter; -import org.jruby.util.io.InvalidValueException; -import org.jruby.util.io.ModeFlags; -import org.jruby.util.io.Stream; - -@JRubyClass(name="StringIO") -public class RubyStringIO extends RubyObject { - private static ObjectAllocator STRINGIO_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyStringIO(runtime, klass); - } - }; - - public static RubyClass createStringIOClass(final Ruby runtime) { - RubyClass stringIOClass = runtime.defineClass( - "StringIO", runtime.fastGetClass("Data"), STRINGIO_ALLOCATOR); - - stringIOClass.defineAnnotatedMethods(RubyStringIO.class); - stringIOClass.includeModule(runtime.getEnumerable()); - - return stringIOClass; - } - - @JRubyMethod(name = "open", optional = 2, frame = true, meta = true) - public static IRubyObject open(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - RubyStringIO strio = (RubyStringIO)((RubyClass)recv).newInstance(context, args, Block.NULL_BLOCK); - IRubyObject val = strio; - - if (block.isGiven()) { - try { - val = block.yield(context, strio); - } finally { - strio.doFinalize(); - } - } - return val; - } - - protected RubyStringIO(Ruby runtime, RubyClass klass) { - super(runtime, klass); - } - - private long pos = 0L; - private int lineno = 0; - private boolean eof = false; - - /** - * ATTN: the value of internal might be reset to null - * (during StringIO.open with block), so watch out for that. - */ - private RubyString internal; - - // Has read/write been closed or is it still open for business - private boolean closedRead = false; - private boolean closedWrite = false; - - // Support IO modes that this object was opened with - ModeFlags modes; - - private void initializeModes(Object modeArgument) { - try { - if (modeArgument == null) { - modes = new ModeFlags(RubyIO.getIOModesIntFromString(getRuntime(), "r+")); - } else if (modeArgument instanceof Long) { - modes = new ModeFlags(((Long)modeArgument).longValue()); - } else { - modes = new ModeFlags(RubyIO.getIOModesIntFromString(getRuntime(), (String) modeArgument)); - } - } catch (InvalidValueException e) { - throw getRuntime().newErrnoEINVALError(); - } - setupModes(); - } - - @JRubyMethod(name = "initialize", optional = 2, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, Block unusedBlock) { - Object modeArgument = null; - switch (args.length) { - case 0: - internal = RubyString.newEmptyString(getRuntime()); - modeArgument = "r+"; - break; - case 1: - internal = args[0].convertToString(); - modeArgument = internal.isFrozen() ? "r" : "r+"; - break; - case 2: - internal = args[0].convertToString(); - if (args[1] instanceof RubyFixnum) { - modeArgument = RubyFixnum.fix2long(args[1]); - } else { - modeArgument = args[1].convertToString().toString(); - } - break; - } - - initializeModes(modeArgument); - - if (modes.isWritable() && internal.isFrozen()) { - throw getRuntime().newErrnoEACCESError("Permission denied"); - } - - if (modes.isTruncate()) { - internal.modifyCheck(); - internal.empty(); - } - - return this; - } - - @JRubyMethod(visibility = Visibility.PRIVATE) - public IRubyObject initialize_copy(IRubyObject other) { - - RubyStringIO otherIO = (RubyStringIO) TypeConverter.convertToType( - other, getRuntime().fastGetClass("StringIO"), - MethodIndex.getIndex("to_strio"), "to_strio"); - - if (this == otherIO) { - return this; - } - - pos = otherIO.pos; - lineno = otherIO.lineno; - eof = otherIO.eof; - closedRead = otherIO.closedRead; - closedWrite = otherIO.closedWrite; - internal = otherIO.internal; - modes = otherIO.modes; - if (otherIO.isTaint()) { - setTaint(true); - } - - return this; - } - - @JRubyMethod(name = "<<", required = 1) - public IRubyObject append(ThreadContext context, IRubyObject arg) { - writeInternal(context, arg); - return this; - } - - @JRubyMethod(name = "binmode") - public IRubyObject binmode() { - return this; - } - - @JRubyMethod(name = "close", frame=true) - public IRubyObject close() { - checkInitialized(); - checkOpen(); - - closedRead = true; - closedWrite = true; - - return getRuntime().getNil(); - } - - private void doFinalize() { - closedRead = true; - closedWrite = true; - internal = null; - } - - @JRubyMethod(name = "closed?") - public IRubyObject closed_p() { - checkInitialized(); - return getRuntime().newBoolean(closedRead && closedWrite); - } - - @JRubyMethod(name = "close_read") - public IRubyObject close_read() { - checkReadable(); - closedRead = true; - - return getRuntime().getNil(); - } - - @JRubyMethod(name = "closed_read?") - public IRubyObject closed_read_p() { - checkInitialized(); - return getRuntime().newBoolean(closedRead); - } - - @JRubyMethod(name = "close_write") - public IRubyObject close_write() { - checkWritable(); - closedWrite = true; - - return getRuntime().getNil(); - } - - @JRubyMethod(name = "closed_write?") - public IRubyObject closed_write_p() { - checkInitialized(); - return getRuntime().newBoolean(closedWrite); - } - - @JRubyMethod(name = "each", optional = 1, frame = true, writes = FrameField.LASTLINE) - public IRubyObject each(ThreadContext context, IRubyObject[] args, Block block) { - IRubyObject line = gets(context, args); - - while (!line.isNil()) { - block.yield(context, line); - line = gets(context, args); - } - - return this; - } - - @JRubyMethod(name = "each_byte", frame = true) - public IRubyObject each_byte(ThreadContext context, Block block) { - checkReadable(); - Ruby runtime = context.getRuntime(); - ByteList bytes = internal.getByteList(); - - // Check the length every iteration, since - // the block can modify this string. - while (pos < bytes.length()) { - block.yield(context, runtime.newFixnum(bytes.get((int) pos++) & 0xFF)); - } - return runtime.getNil(); - } - - @JRubyMethod(name = "each_line", optional = 1, frame = true) - public IRubyObject each_line(ThreadContext context, IRubyObject[] args, Block block) { - return each(context, args, block); - } - - @JRubyMethod(name = {"eof", "eof?"}) - public IRubyObject eof() { - return getRuntime().newBoolean(isEOF()); - } - - private boolean isEOF() { - return (pos >= internal.getByteList().length()) || eof; - } - - @JRubyMethod(name = "fcntl") - public IRubyObject fcntl() { - throw getRuntime().newNotImplementedError("fcntl not implemented"); - } - - @JRubyMethod(name = "fileno") - public IRubyObject fileno() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "flush") - public IRubyObject flush() { - return this; - } - - @JRubyMethod(name = "fsync") - public IRubyObject fsync() { - return RubyFixnum.zero(getRuntime()); - } - - @JRubyMethod(name = "getc") - public IRubyObject getc() { - checkReadable(); - if (pos >= internal.getByteList().length()) { - return getRuntime().getNil(); - } - return getRuntime().newFixnum(internal.getByteList().get((int)pos++) & 0xFF); - } - - private IRubyObject internalGets(ThreadContext context, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - - if (pos < internal.getByteList().realSize && !eof) { - boolean isParagraph = false; - - ByteList sep; - if (args.length > 0) { - if (args[0].isNil()) { - ByteList buf = internal.getByteList().makeShared( - (int)pos, internal.getByteList().realSize - (int)pos); - pos += buf.realSize; - return RubyString.newString(runtime, buf); - } - sep = args[0].convertToString().getByteList(); - if (sep.realSize == 0) { - isParagraph = true; - sep = Stream.PARAGRAPH_SEPARATOR; - } - } else { - sep = ((RubyString)runtime.getGlobalVariables().get("$/")).getByteList(); - } - - ByteList ss = internal.getByteList(); - - if (isParagraph) { - swallowLF(ss); - if (pos == ss.realSize) { - return runtime.getNil(); - } - } - - int ix = ss.indexOf(sep, (int)pos); - - ByteList add; - if (-1 == ix) { - ix = internal.getByteList().realSize; - add = new ByteList(new byte[0], false); - } else { - add = isParagraph? NEWLINE : sep; - } - - ByteList line = internal.getByteList().makeShared((int)pos, ix - (int)pos); - line.unshare(); - line.append(add); - line.invalidate(); - pos = ix + add.realSize; - lineno++; - - return RubyString.newString(runtime,line); - } - return runtime.getNil(); - } - - private void swallowLF(ByteList list) { - while (pos < list.realSize) { - if (list.get((int)pos) == '\n') { - pos++; - } else { - break; - } - } - } - - @JRubyMethod(name = "gets", optional = 1, writes = FrameField.LASTLINE) - public IRubyObject gets(ThreadContext context, IRubyObject[] args) { - checkReadable(); - - IRubyObject result = internalGets(context, args); - context.getCurrentFrame().setLastLine(result); - - return result; - } - - @JRubyMethod(name = {"tty?", "isatty"}) - public IRubyObject isatty() { - return getRuntime().getFalse(); - } - - @JRubyMethod(name = {"length", "size"}) - public IRubyObject length() { - checkFinalized(); - return getRuntime().newFixnum(internal.getByteList().length()); - } - - @JRubyMethod(name = "lineno") - public IRubyObject lineno() { - return getRuntime().newFixnum(lineno); - } - - @JRubyMethod(name = "lineno=", required = 1) - public IRubyObject set_lineno(IRubyObject arg) { - lineno = RubyNumeric.fix2int(arg); - - return getRuntime().getNil(); - } - - @JRubyMethod(name = "path") - public IRubyObject path() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "pid") - public IRubyObject pid() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = {"pos", "tell"}) - public IRubyObject pos() { - return getRuntime().newFixnum(pos); - } - - @JRubyMethod(name = "pos=", required = 1) - public IRubyObject set_pos(IRubyObject arg) { - pos = RubyNumeric.fix2int(arg); - if (pos < 0) { - throw getRuntime().newErrnoEINVALError("Invalid argument"); - } - - return getRuntime().getNil(); - } - - @JRubyMethod(name = "print", rest = true) - public IRubyObject print(ThreadContext context, IRubyObject[] args) { - Ruby runtime = context.getRuntime(); - if (args.length != 0) { - for (int i=0,j=args.length;i<j;i++) { - append(context, args[i]); - } - } else { - IRubyObject arg = runtime.getGlobalVariables().get("$_"); - append(context, arg.isNil() ? runtime.newString("nil") : arg); - } - IRubyObject sep = runtime.getGlobalVariables().get("$\\"); - if (!sep.isNil()) { - append(context, sep); - } - return getRuntime().getNil(); - } - - @JRubyMethod(name = "printf", required = 1, rest = true) - public IRubyObject printf(ThreadContext context, IRubyObject[] args) { - append(context, RubyKernel.sprintf(context, this, args)); - return getRuntime().getNil(); - } - - @JRubyMethod(name = "putc", required = 1) - public IRubyObject putc(IRubyObject obj) { - checkWritable(); - byte c = RubyNumeric.num2chr(obj); - checkFrozen(); - - internal.modify(); - ByteList bytes = internal.getByteList(); - if (modes.isAppendable()) { - pos = bytes.length(); - bytes.append(c); - } else { - if (pos >= bytes.length()) { - bytes.length((int)pos + 1); - } - - bytes.set((int) pos, c); - pos++; - } - - return obj; - } - - public static final ByteList NEWLINE = ByteList.create("\n"); - - @JRubyMethod(name = "puts", rest = true) - public IRubyObject puts(ThreadContext context, IRubyObject[] args) { - checkWritable(); - - // FIXME: the code below is a copy of RubyIO.puts, - // and we should avoid copy-paste. - - if (args.length == 0) { - callMethod(context, "write", RubyString.newStringShared(getRuntime(), NEWLINE)); - return getRuntime().getNil(); - } - - for (int i = 0; i < args.length; i++) { - String line; - - if (args[i].isNil()) { - line = "nil"; - } else { - IRubyObject tmp = args[i].checkArrayType(); - if (!tmp.isNil()) { - RubyArray arr = (RubyArray) tmp; - if (getRuntime().isInspecting(arr)) { - line = "[...]"; - } else { - inspectPuts(context, arr); - continue; - } - } else { - line = args[i].toString(); - } - } - - callMethod(context, "write", getRuntime().newString(line)); - - if (!line.endsWith("\n")) { - callMethod(context, "write", RubyString.newStringShared(getRuntime(), NEWLINE)); - } - } - return getRuntime().getNil(); - } - - private IRubyObject inspectPuts(ThreadContext context, RubyArray array) { - try { - getRuntime().registerInspecting(array); - return puts(context, array.toJavaArray()); - } finally { - getRuntime().unregisterInspecting(array); - } - } - - @SuppressWarnings("fallthrough") - @JRubyMethod(name = "read", optional = 2) - public IRubyObject read(IRubyObject[] args) { - checkReadable(); - - ByteList buf = null; - int length = 0; - int oldLength = 0; - RubyString originalString = null; - - switch (args.length) { - case 2: - originalString = args[1].convertToString(); - // must let original string know we're modifying, so shared buffers aren't damaged - originalString.modify(); - buf = originalString.getByteList(); - case 1: - if (!args[0].isNil()) { - length = RubyNumeric.fix2int(args[0]); - oldLength = length; - - if (length < 0) { - throw getRuntime().newArgumentError("negative length " + length + " given"); - } - if (length > 0 && pos >= internal.getByteList().length()) { - eof = true; - if (buf != null) buf.realSize = 0; - return getRuntime().getNil(); - } else if (eof) { - if (buf != null) buf.realSize = 0; - return getRuntime().getNil(); - } - break; - } - case 0: - oldLength = -1; - length = internal.getByteList().length(); - - if (length <= pos) { - eof = true; - if (buf == null) { - buf = new ByteList(); - } else { - buf.realSize = 0; - } - - return getRuntime().newString(buf); - } else { - length -= pos; - } - break; - default: - getRuntime().newArgumentError(args.length, 0); - } - - if (buf == null) { - int internalLength = internal.getByteList().length(); - - if (internalLength > 0) { - if (internalLength >= pos + length) { - buf = new ByteList(internal.getByteList(), (int) pos, length); - } else { - int rest = (int) (internal.getByteList().length() - pos); - - if (length > rest) length = rest; - buf = new ByteList(internal.getByteList(), (int) pos, length); - } - } - } else { - int rest = (int) (internal.getByteList().length() - pos); - - if (length > rest) length = rest; - - // Yow...this is ugly - buf.realSize = length; - buf.replace(0, length, internal.getByteList().bytes, (int) pos, length); - } - - if (buf == null) { - if (!eof) buf = new ByteList(); - length = 0; - } else { - length = buf.length(); - pos += length; - } - - if (oldLength < 0 || oldLength > length) eof = true; - - return originalString != null ? originalString : getRuntime().newString(buf); - } - - @JRubyMethod(name = "readchar") - public IRubyObject readchar() { - IRubyObject c = getc(); - - if (c.isNil()) throw getRuntime().newEOFError(); - - return c; - } - - @JRubyMethod(name = "readline", optional = 1, writes = FrameField.LASTLINE) - public IRubyObject readline(ThreadContext context, IRubyObject[] args) { - IRubyObject line = gets(context, args); - - if (line.isNil()) throw getRuntime().newEOFError(); - - return line; - } - - @JRubyMethod(name = "readlines", optional = 1) - public IRubyObject readlines(ThreadContext context, IRubyObject[] arg) { - checkReadable(); - - List<IRubyObject> lns = new ArrayList<IRubyObject>(); - while (!(isEOF())) { - IRubyObject line = internalGets(context, arg); - if (line.isNil()) { - break; - } - lns.add(line); - } - - return getRuntime().newArray(lns); - } - - @JRubyMethod(name = "reopen", required = 0, optional = 2) - public IRubyObject reopen(IRubyObject[] args) { - if (args.length == 1 && !(args[0] instanceof RubyString)) { - return initialize_copy(args[0]); - } - - // reset the state - doRewind(); - closedRead = false; - closedWrite = false; - return initialize(args, Block.NULL_BLOCK); - } - - @JRubyMethod(name = "rewind") - public IRubyObject rewind() { - doRewind(); - return RubyFixnum.zero(getRuntime()); - } - - private void doRewind() { - this.pos = 0L; - this.eof = false; - this.lineno = 0; - } - - @JRubyMethod(name = "seek", required = 1, optional = 1, frame=true) - public IRubyObject seek(IRubyObject[] args) { - // MRI 1.8.7 behavior: - // checkOpen(); - checkFinalized(); - long amount = RubyNumeric.num2long(args[0]); - int whence = Stream.SEEK_SET; - long newPosition = pos; - - if (args.length > 1 && !args[0].isNil()) whence = RubyNumeric.fix2int(args[1]); - - if (whence == Stream.SEEK_CUR) { - newPosition += amount; - } else if (whence == Stream.SEEK_END) { - newPosition = internal.getByteList().length() + amount; - } else { - newPosition = amount; - } - - if (newPosition < 0) throw getRuntime().newErrnoEINVALError(); - - pos = newPosition; - eof = false; - - return RubyFixnum.zero(getRuntime()); - } - - @JRubyMethod(name = "string=", required = 1) - public IRubyObject set_string(IRubyObject arg) { - return reopen(new IRubyObject[] { arg.convertToString() }); - } - - @JRubyMethod(name = "sync=", required = 1) - public IRubyObject set_sync(IRubyObject args) { - return args; - } - - @JRubyMethod(name = "string") - public IRubyObject string() { - if (internal == null) { - return getRuntime().getNil(); - } else { - return internal; - } - } - - @JRubyMethod(name = "sync") - public IRubyObject sync() { - return getRuntime().getTrue(); - } - - @JRubyMethod(name = "sysread", optional = 2) - public IRubyObject sysread(IRubyObject[] args) { - IRubyObject obj = read(args); - - if (isEOF()) { - if (obj.isNil() || ((RubyString) obj).getByteList().length() == 0) { - throw getRuntime().newEOFError(); - } - } - - return obj; - } - - @JRubyMethod(name = "truncate", required = 1) - public IRubyObject truncate(IRubyObject arg) { - checkWritable(); - - int len = RubyFixnum.fix2int(arg); - if (len < 0) { - throw getRuntime().newErrnoEINVALError("negative legnth"); - } - - internal.modify(); - internal.getByteList().length(len); - return arg; - } - - @JRubyMethod(name = "ungetc", required = 1) - public IRubyObject ungetc(IRubyObject arg) { - checkReadable(); - - int c = RubyNumeric.num2int(arg); - if (pos == 0) return getRuntime().getNil(); - internal.modify(); - pos--; - - ByteList bytes = internal.getByteList(); - - if (bytes.length() <= pos) { - bytes.length((int)pos + 1); - } - - bytes.set((int) pos, c); - return getRuntime().getNil(); - } - - @JRubyMethod(name = {"write", "syswrite"}, required = 1) - public IRubyObject write(ThreadContext context, IRubyObject arg) { - return context.getRuntime().newFixnum(writeInternal(context, arg)); - } - - private int writeInternal(ThreadContext context, IRubyObject arg) { - checkWritable(); - checkFrozen(); - - RubyString val = arg.asString(); - internal.modify(); - - if (modes.isAppendable()) { - internal.getByteList().append(val.getByteList()); - pos = internal.getByteList().length(); - } else { - int left = internal.getByteList().length()-(int)pos; - internal.getByteList().replace((int)pos,Math.min(val.getByteList().length(),left),val.getByteList()); - pos += val.getByteList().length(); - } - - if (val.isTaint()) { - internal.setTaint(true); - } - - return val.getByteList().length(); - } - - /* rb: check_modifiable */ - @Override - protected void checkFrozen() { - checkInitialized(); - if (internal.isFrozen()) throw getRuntime().newIOError("not modifiable string"); - } - - /* rb: readable */ - private void checkReadable() { - checkInitialized(); - if (closedRead || !modes.isReadable()) { - throw getRuntime().newIOError("not opened for reading"); - } - } - - /* rb: writable */ - private void checkWritable() { - checkInitialized(); - if (closedWrite || !modes.isWritable()) { - throw getRuntime().newIOError("not opened for writing"); - } - - // Tainting here if we ever want it. (secure 4) - } - - private void checkInitialized() { - if (modes == null) { - throw getRuntime().newIOError("uninitialized stream"); - } - } - - private void checkFinalized() { - if (internal == null) { - throw getRuntime().newIOError("not opened"); - } - } - - private void checkOpen() { - if (closedRead && closedWrite) { - throw getRuntime().newIOError("closed stream"); - } - } - - private void setupModes() { - closedWrite = false; - closedRead = false; - - if (modes.isReadOnly()) closedWrite = true; - if (!modes.isReadable()) closedRead = true; - } -} -package org.jruby; - -import org.joni.Matcher; -import org.joni.Option; -import org.joni.Regex; -import org.joni.Region; -import org.joni.encoding.Encoding; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.exceptions.RaiseException; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; - -/** - * @author kscott - * - */ -@JRubyClass(name="StringScanner") -public class RubyStringScanner extends RubyObject { - - private RubyString str; - private int pos = 0; - private int lastPos = -1; - - private Region regs; - private int beg = -1; - private int end = -1; - // not to be confused with RubyObject's flags - private int scannerFlags; - - private static final int MATCHED_STR_SCN_F = 1 << 11; - - private static ObjectAllocator STRINGSCANNER_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyStringScanner(runtime, klass); - } - }; - - public static RubyClass createScannerClass(final Ruby runtime) { - RubyClass scannerClass = runtime.defineClass("StringScanner", runtime.getObject(), STRINGSCANNER_ALLOCATOR); - scannerClass.defineAnnotatedMethods(RubyStringScanner.class); - ThreadContext context = runtime.getCurrentContext(); - scannerClass.setConstant("Version", runtime.newString("0.7.0").freeze(context)); - scannerClass.setConstant("Id", runtime.newString("$Id: strscan.c 13506 2007-09-24 08:56:24Z nobu $").freeze(context)); - - RubyClass standardError = runtime.getStandardError(); - RubyClass error = scannerClass.defineClassUnder( - "Error", standardError, standardError.getAllocator()); - - RubyClass objClass = runtime.getObject(); - if (!objClass.isConstantDefined("ScanError")) { - objClass.defineConstant("ScanError", error); - } - - return scannerClass; - } - - private void clearMatched() { - scannerFlags &= ~MATCHED_STR_SCN_F; - } - - private void setMatched() { - scannerFlags |= MATCHED_STR_SCN_F; - } - - private boolean isMatched() { - return (scannerFlags & MATCHED_STR_SCN_F) != 0; - } - - private void check() { - if (str == null) throw getRuntime().newArgumentError("uninitialized StringScanner object"); - } - - protected RubyStringScanner(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - // second argument is allowed, but ignored (MRI) - @JRubyMethod(name = "initialize", required = 1, optional = 1, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, Block unusedBlock) { - str = args[0].convertToString(); - return this; - } - - @JRubyMethod(name = "initialize_copy", frame=true, visibility = Visibility.PRIVATE) - @Override - public IRubyObject initialize_copy(IRubyObject other) { - if (this == other) return this; - if (!(other instanceof RubyStringScanner)) { - throw getRuntime().newTypeError("wrong argument type " - + other.getMetaClass() + " (expected StringScanner)"); - } - - RubyStringScanner otherScanner = (RubyStringScanner)other; - str = otherScanner.str; - pos = otherScanner.pos; - lastPos = otherScanner.lastPos; - scannerFlags = otherScanner.scannerFlags; - - regs = otherScanner.regs != null ? otherScanner.regs.clone() : null; - beg = otherScanner.beg; - end = otherScanner.end; - - return this; - } - - @JRubyMethod(name = "reset") - public IRubyObject reset() { - check(); - pos = 0; - clearMatched(); - return this; - } - - @JRubyMethod(name = "terminate") - public IRubyObject terminate() { - check(); - pos = str.getByteList().realSize; - clearMatched(); - return this; - } - - @JRubyMethod(name = "clear") - public IRubyObject clear() { - check(); - getRuntime().getWarnings().warning(ID.DEPRECATED_METHOD, "StringScanner#clear is obsolete; use #terminate instead", "StringScanner#clear", "#terminate"); - return terminate(); - } - - @JRubyMethod(name = "string") - public RubyString string() { - return str; - } - - @JRubyMethod(name = "string=", required = 1) - public IRubyObject set_string(ThreadContext context, IRubyObject str) { - this.str = (RubyString) str.convertToString().strDup(context.getRuntime()).freeze(context); - pos = 0; - clearMatched(); - return str; - } - - @JRubyMethod(name = {"concat", "<<"}, required = 1) - public IRubyObject concat(IRubyObject obj) { - check(); - str.append(obj); // append will call convertToString() - return this; - } - - @JRubyMethod(name = {"pos", "pointer"}) - public RubyFixnum pos() { - check(); - return RubyFixnum.newFixnum(getRuntime(), pos); - } - - @JRubyMethod(name = {"pos=", "pointer="}) - public IRubyObject set_pos(IRubyObject pos) { - check(); - int i = RubyNumeric.num2int(pos); - int size = str.getByteList().realSize; - if (i < 0) i += size; - if (i < 0 || i > size) throw getRuntime().newRangeError("index out of range."); - this.pos = i; - return RubyFixnum.newFixnum(getRuntime(), i); - } - - private IRubyObject extractRange(Ruby runtime, int beg, int end) { - int size = str.getByteList().realSize; - if (beg > size) return getRuntime().getNil(); - if (end > size) end = size; - return str.makeShared(runtime, beg, end - beg); - } - - private IRubyObject extractBegLen(Ruby runtime, int beg, int len) { - assert len >= 0; - int size = str.getByteList().realSize; - if (beg > size) return getRuntime().getNil(); - if (beg + len > size) len = size - beg; - return str.makeShared(runtime, beg, len); - } - - private IRubyObject scan(IRubyObject regex, boolean succptr, boolean getstr, boolean headonly) { - if (!(regex instanceof RubyRegexp)) throw getRuntime().newTypeError("wrong argument type " + regex.getMetaClass() + " (expected Regexp)"); - check(); - - Regex pattern = ((RubyRegexp)regex).getPattern(); - - clearMatched(); - int rest = str.getByteList().realSize - pos; - if (rest < 0) return getRuntime().getNil(); - - ByteList value = str.getByteList(); - Matcher matcher = pattern.matcher(value.bytes, value.begin + pos, value.begin + value.realSize); - - final int ret; - if (headonly) { - ret = matcher.match(value.begin + pos, value.begin + value.realSize, Option.NONE); - } else { - ret = matcher.search(value.begin + pos, value.begin + value.realSize, Option.NONE); - } - - regs = matcher.getRegion(); - if (regs == null) { - beg = matcher.getBegin(); - end = matcher.getEnd(); - } else { - beg = regs.beg[0]; - end = regs.end[0]; - } - - if (ret < 0) return getRuntime().getNil(); - setMatched(); - - lastPos = pos; - if (succptr) pos += end; - return getstr ? extractBegLen(getRuntime(), lastPos, end) : RubyFixnum.newFixnum(getRuntime(), end); - } - - @JRubyMethod(name = "scan", required = 1) - public IRubyObject scan(IRubyObject regex) { - return scan(regex, true, true, true); - } - - @JRubyMethod(name = "match?", required = 1) - public IRubyObject match_p(IRubyObject regex) { - return scan(regex, false, false, true); - } - - @JRubyMethod(name = "skip", required = 1) - public IRubyObject skip(IRubyObject regex) { - return scan(regex, true, false, true); - } - - @JRubyMethod(name = "check", required = 1) - public IRubyObject check(IRubyObject regex) { - return scan(regex, false, true, true); - } - - @JRubyMethod(name = "scan_full", required = 3) - public IRubyObject scan_full(IRubyObject regex, IRubyObject s, IRubyObject f) { - return scan(regex, s.isTrue(), f.isTrue(), true); - } - - @JRubyMethod(name = "scan_until", required = 1) - public IRubyObject scan_until(IRubyObject regex) { - return scan(regex, true, true, false); - } - - @JRubyMethod(name = "exist?", required = 1) - public IRubyObject exist_p(IRubyObject regex) { - return scan(regex, false, false, false); - } - - @JRubyMethod(name = "skip_until", required = 1) - public IRubyObject skip_until(IRubyObject regex) { - return scan(regex, true, false, false); - } - - @JRubyMethod(name = "check_until", required = 1) - public IRubyObject check_until(IRubyObject regex) { - return scan(regex, false, true, false); - } - - @JRubyMethod(name = "search_full", required = 3) - public IRubyObject search_full(IRubyObject regex, IRubyObject s, IRubyObject f) { - return scan(regex, s.isTrue(), f.isTrue(), false); - } - - private void adjustRegisters() { - beg = 0; - end = pos - lastPos; - regs = null; - } - - @JRubyMethod(name = "getch") - public IRubyObject getch(ThreadContext context) { - check(); - clearMatched(); - - Ruby runtime = context.getRuntime(); - ByteList value = str.getByteList(); - - if (pos >= value.realSize) return runtime.getNil(); - - Encoding enc = runtime.getKCode().getEncoding(); - - int len; - if (enc.isSingleByte()) { - len = 1; - } else { - len = enc.length(value.bytes[value.begin + pos]); - } - - if (pos + len > value.realSize) len = value.realSize - pos; - lastPos = pos; - pos += len; - - setMatched(); - adjustRegisters(); - - return extractRange(runtime, lastPos + beg, lastPos + end); - } - - @JRubyMethod(name = "get_byte") - public IRubyObject get_byte(ThreadContext context) { - check(); - clearMatched(); - if (pos >= str.getByteList().realSize) return getRuntime().getNil(); - - lastPos = pos; - pos++; - - setMatched(); - adjustRegisters(); - - return extractRange(context.getRuntime(), lastPos + beg, lastPos + end); - } - - @JRubyMethod(name = "getbyte") - public IRubyObject getbyte(ThreadContext context) { - context.getRuntime().getWarnings().warning(ID.DEPRECATED_METHOD, - "StringScanner#getbyte is obsolete; use #get_byte instead", - "StringScanner#getbyte", "#get_byte"); - return get_byte(context); - } - - @JRubyMethod(name = "peek", required = 1) - public IRubyObject peek(ThreadContext context, IRubyObject length) { - check(); - - int len = RubyNumeric.num2int(length); - if (len < 0) { - throw context.getRuntime().newArgumentError("negative string size (or size too big)"); - } - - ByteList value = str.getByteList(); - if (pos >= value.realSize) return RubyString.newEmptyString(getRuntime()).infectBy(str); - if (pos + len > value.realSize) len = value.realSize - pos; - - return extractBegLen(context.getRuntime(), pos, len); - } - - @JRubyMethod(name = "peep", required = 1) - public IRubyObject peep(ThreadContext context, IRubyObject length) { - getRuntime().getWarnings().warning( - ID.DEPRECATED_METHOD, "StringScanner#peep is obsolete; use #peek instead", - "StringScanner#peep", "#peek"); - return peek(context, length); - } - - @JRubyMethod(name = "unscan") - public IRubyObject unscan() { - check(); - Ruby runtime = getRuntime(); - - if (!isMatched()) { - RubyClass errorClass = runtime.fastGetClass("StringScanner").fastGetClass("Error"); - throw new RaiseException(RubyException.newException( - runtime, errorClass, "unscan failed: previous match had failed")); - } - pos = lastPos; - clearMatched(); - return this; - } - - @JRubyMethod(name = "beginning_of_line?", alias = "bol?") - public IRubyObject bol_p() { - check(); - ByteList value = str.getByteList(); - if (pos > value.realSize) return getRuntime().getNil(); - if (pos == 0) return getRuntime().getTrue(); - return value.bytes[(value.begin + pos) - 1] == (byte)'\n' ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "eos?") - public RubyBoolean eos_p(ThreadContext context) { - check(); - return pos >= str.getByteList().realSize ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - @JRubyMethod(name = "empty?") - public RubyBoolean empty_p(ThreadContext context) { - getRuntime().getWarnings().warning(ID.DEPRECATED_METHOD, "StringScanner#empty? is obsolete; use #eos? instead", "StringScanner#empty?", "#eos?"); - return eos_p(context); - } - - @JRubyMethod(name = "rest?") - public RubyBoolean rest_p(ThreadContext context) { - check(); - return pos >= str.getByteList().realSize ? context.getRuntime().getFalse() : context.getRuntime().getTrue(); - } - - @JRubyMethod(name = "matched?") - public RubyBoolean matched_p(ThreadContext context) { - check(); - return isMatched() ? context.getRuntime().getTrue() : context.getRuntime().getFalse(); - } - - @JRubyMethod(name = "matched") - public IRubyObject matched(ThreadContext context) { - check(); - if (!isMatched()) return getRuntime().getNil(); - return extractRange(context.getRuntime(), lastPos + beg, lastPos + end); - } - - @JRubyMethod(name = "matched_size") - public IRubyObject matched_size() { - check(); - if (!isMatched()) return getRuntime().getNil(); - return RubyFixnum.newFixnum(getRuntime(), end - beg); - } - - @JRubyMethod(name = "matchedsize") - public IRubyObject matchedsize() { - getRuntime().getWarnings().warning(ID.DEPRECATED_METHOD, "StringScanner#matchedsize is obsolete; use #matched_size instead", - "StringScanner#matchedize", "#matched_size"); - return matched_size(); - } - - @JRubyMethod(name = "[]", required = 1) - public IRubyObject op_aref(ThreadContext context, IRubyObject idx) { - check(); - if (!isMatched()) return context.getRuntime().getNil(); - int i = RubyNumeric.num2int(idx); - - int numRegs = regs == null ? 1 : regs.numRegs; - if (i < 0) i += numRegs; - if (i < 0 || i >= numRegs) return context.getRuntime().getNil(); - - if (regs == null) { - assert i == 0; - if (beg == -1) return getRuntime().getNil(); - return extractRange(context.getRuntime(), lastPos + beg, lastPos + end); - } else { - if (regs.beg[i] == -1) return getRuntime().getNil(); - return extractRange(context.getRuntime(), lastPos + regs.beg[i], lastPos + regs.end[i]); - } - } - - @JRubyMethod(name = "pre_match") - public IRubyObject pre_match(ThreadContext context) { - check(); - if (!isMatched()) return context.getRuntime().getNil(); - return extractRange(context.getRuntime(), 0, lastPos + beg); - } - - @JRubyMethod(name = "post_match") - public IRubyObject post_match(ThreadContext context) { - check(); - if (!isMatched()) return context.getRuntime().getNil(); - return extractRange(context.getRuntime(), lastPos + end, str.getByteList().realSize); - } - - @JRubyMethod(name = "rest") - public IRubyObject rest(ThreadContext context) { - check(); - ByteList value = str.getByteList(); - if (pos >= value.realSize) return RubyString.newEmptyString(context.getRuntime()).infectBy(str); - return extractRange(context.getRuntime(), pos, value.realSize); - } - - @JRubyMethod(name = "rest_size") - public RubyFixnum rest_size() { - check(); - ByteList value = str.getByteList(); - if (pos >= value.realSize) return RubyFixnum.zero(getRuntime()); - return RubyFixnum.newFixnum(getRuntime(), value.realSize - pos); - } - - @JRubyMethod(name = "restsize") - public RubyFixnum restsize() { - getRuntime().getWarnings().warning(ID.DEPRECATED_METHOD, "StringScanner#restsize is obsolete; use #rest_size instead", "StringScanner#restsize", "#rest_size"); - return rest_size(); - } - - @JRubyMethod(name = "inspect") - @Override - public IRubyObject inspect() { - if (str == null) return inspect("(uninitialized)"); - if (pos >= str.getByteList().realSize) return inspect("fin"); - if (pos == 0) return inspect(pos + "/" + str.getByteList().realSize + " @ " + inspect2()); - return inspect(pos + "/" + str.getByteList().realSize + " " + inspect1() + " @ " + inspect2()); - } - - private IRubyObject inspect(String msg) { - IRubyObject result = getRuntime().newString("#<" + getMetaClass() + " " + msg + ">"); - if (str != null) result.infectBy(str); - return result; - } - - private static final int INSPECT_LENGTH = 5; - - private IRubyObject inspect1() { - if (pos == 0) return RubyString.newEmptyString(getRuntime()); - if (pos > INSPECT_LENGTH) { - return RubyString.newString(getRuntime(), "...".getBytes()).append(str.substr(pos - INSPECT_LENGTH, INSPECT_LENGTH)).inspect(); - } else { - return str.substr(0, pos).inspect(); - } - } - - private IRubyObject inspect2() { - if (pos >= str.getByteList().realSize) return RubyString.newEmptyString(getRuntime()); - int len = str.getByteList().realSize - pos; - if (len > INSPECT_LENGTH) { - return ((RubyString)str.substr(pos, INSPECT_LENGTH)).cat("...".getBytes()).inspect(); - } else { - return str.substr(pos, len).inspect(); - } - } - - @JRubyMethod(name = "must_C_version", meta = true) - public static IRubyObject mustCversion(IRubyObject recv) { - return recv; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2005 Charles O Nutter <headius@headius.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.util.List; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.Frame; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.ByteList; -import org.jruby.util.IdUtil; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.exceptions.RaiseException; -import org.jruby.internal.runtime.methods.CallConfiguration; -import org.jruby.internal.runtime.methods.DynamicMethod; -import org.jruby.runtime.ClassIndex; - -/** - * @author jpetersen - */ -@JRubyClass(name="Struct") -public class RubyStruct extends RubyObject { - private IRubyObject[] values; - - /** - * Constructor for RubyStruct. - * @param runtime - * @param rubyClass - */ - public RubyStruct(Ruby runtime, RubyClass rubyClass) { - super(runtime, rubyClass); - - int size = RubyNumeric.fix2int(getInternalVariable((RubyClass)rubyClass, "__size__")); - - values = new IRubyObject[size]; - - for (int i = 0; i < size; i++) { - values[i] = getRuntime().getNil(); - } - } - - public static RubyClass createStructClass(Ruby runtime) { - // TODO: NOT_ALLOCATABLE_ALLOCATOR may be ok here, but it's unclear how Structs - // work with marshalling. Confirm behavior and ensure we're doing this correctly. JRUBY-415 - RubyClass structClass = runtime.defineClass("Struct", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setStructClass(structClass); - structClass.index = ClassIndex.STRUCT; - structClass.includeModule(runtime.getEnumerable()); - structClass.defineAnnotatedMethods(RubyStruct.class); - - return structClass; - } - - @Override - public int getNativeTypeIndex() { - return ClassIndex.STRUCT; - } - - private static IRubyObject getInternalVariable(RubyClass type, String internedName) { - RubyClass structClass = type.getRuntime().getStructClass(); - IRubyObject variable; - - while (type != null && type != structClass) { - if ((variable = type.fastGetInternalVariable(internedName)) != null) { - return variable; - } - - type = type.getSuperClass(); - } - - return type.getRuntime().getNil(); - } - - private RubyClass classOf() { - return getMetaClass() instanceof MetaClass ? getMetaClass().getSuperClass() : getMetaClass(); - } - - private void modify() { - testFrozen("Struct is frozen"); - - if (!isTaint() && getRuntime().getSafeLevel() >= 4) { - throw getRuntime().newSecurityError("Insecure: can't modify struct"); - } - } - - @JRubyMethod - public RubyFixnum hash(ThreadContext context) { - Ruby runtime = getRuntime(); - int h = getMetaClass().getRealClass().hashCode(); - - for (int i = 0; i < values.length; i++) { - h = (h << 1) | (h < 0 ? 1 : 0); - h ^= RubyNumeric.num2long(values[i].callMethod(context, MethodIndex.HASH, "hash")); - } - - return runtime.newFixnum(h); - } - - private IRubyObject setByName(String name, IRubyObject value) { - RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__"); - - assert !member.isNil() : "uninitialized struct"; - - modify(); - - for (int i = 0,k=member.getLength(); i < k; i++) { - if (member.eltInternal(i).asJavaString().equals(name)) { - return values[i] = value; - } - } - - throw notStructMemberError(name); - } - - private IRubyObject getByName(String name) { - RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__"); - - assert !member.isNil() : "uninitialized struct"; - - for (int i = 0,k=member.getLength(); i < k; i++) { - if (member.eltInternal(i).asJavaString().equals(name)) { - return values[i]; - } - } - - throw notStructMemberError(name); - } - - // Struct methods - - /** Create new Struct class. - * - * MRI: rb_struct_s_def / make_struct - * - */ - @JRubyMethod(name = "new", required = 1, rest = true, frame = true, meta = true) - public static RubyClass newInstance(IRubyObject recv, IRubyObject[] args, Block block) { - String name = null; - boolean nilName = false; - Ruby runtime = recv.getRuntime(); - - if (args.length > 0) { - IRubyObject firstArgAsString = args[0].checkStringType(); - if (!firstArgAsString.isNil()) { - name = ((RubyString)firstArgAsString).getByteList().toString(); - } else if (args[0].isNil()) { - nilName = true; - } - } - - RubyArray member = runtime.newArray(); - - for (int i = (name == null && !nilName) ? 0 : 1; i < args.length; i++) { - member.append(runtime.newSymbol(args[i].asJavaString())); - } - - RubyClass newStruct; - RubyClass superClass = (RubyClass)recv; - - if (name == null || nilName) { - newStruct = RubyClass.newClass(runtime, superClass); - newStruct.setAllocator(STRUCT_INSTANCE_ALLOCATOR); - newStruct.makeMetaClass(superClass.getMetaClass()); - newStruct.inherit(superClass); - } else { - if (!IdUtil.isConstant(name)) { - throw runtime.newNameError("identifier " + name + " needs to be constant", name); - } - - IRubyObject type = superClass.getConstantAt(name); - if (type != null) { - ThreadContext context = runtime.getCurrentContext(); - Frame frame = context.getCurrentFrame(); - runtime.getWarnings().warn(ID.STRUCT_CONSTANT_REDEFINED, frame.getFile(), frame.getLine(), "redefining constant Struct::" + name, name); - superClass.remove_const(context, runtime.newString(name)); - } - newStruct = superClass.defineClassUnder(name, superClass, STRUCT_INSTANCE_ALLOCATOR); - } - - newStruct.index = ClassIndex.STRUCT; - - newStruct.fastSetInternalVariable("__size__", member.length()); - newStruct.fastSetInternalVariable("__member__", member); - - newStruct.getSingletonClass().defineAnnotatedMethods(StructMethods.class); - - // define access methods. - for (int i = (name == null && !nilName) ? 0 : 1; i < args.length; i++) { - final String memberName = args[i].asJavaString(); - // if we are storing a name as well, index is one too high for values - final int index = (name == null && !nilName) ? i : i - 1; - newStruct.addMethod(memberName, new DynamicMethod(newStruct, Visibility.PUBLIC, CallConfiguration.NO_FRAME_NO_SCOPE) { - @Override - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) { - Arity.checkArgumentCount(self.getRuntime(), args, 0, 0); - return ((RubyStruct)self).get(index); - } - - @Override - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name) { - return ((RubyStruct)self).get(index); - } - - @Override - public DynamicMethod dup() { - return this; - } - }); - newStruct.addMethod(memberName + "=", new DynamicMethod(newStruct, Visibility.PUBLIC, CallConfiguration.NO_FRAME_NO_SCOPE) { - @Override - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args, Block block) { - Arity.checkArgumentCount(self.getRuntime(), args, 1, 1); - return ((RubyStruct)self).set(args[0], index); - } - - @Override - public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg) { - return ((RubyStruct)self).set(arg, index); - } - - @Override - public DynamicMethod dup() { - return this; - } - }); - } - - if (block.isGiven()) { - // Struct bodies should be public by default, so set block visibility to public. JRUBY-1185. - block.getBinding().setVisibility(Visibility.PUBLIC); - block.yield(runtime.getCurrentContext(), null, newStruct, newStruct, false); - } - - return newStruct; - } - - // For binding purposes on the newly created struct types - public static class StructMethods { - @JRubyMethod(name = {"new", "[]"}, rest = true, frame = true) - public static IRubyObject newStruct(IRubyObject recv, IRubyObject[] args, Block block) { - return RubyStruct.newStruct(recv, args, block); - } - - @JRubyMethod - public static IRubyObject members(IRubyObject recv, Block block) { - return RubyStruct.members(recv, block); - } - } - - /** Create new Structure. - * - * MRI: struct_alloc - * - */ - public static RubyStruct newStruct(IRubyObject recv, IRubyObject[] args, Block block) { - RubyStruct struct = new RubyStruct(recv.getRuntime(), (RubyClass) recv); - - struct.callInit(args, block); - - return struct; - } - - @JRubyMethod(rest = true, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, Block unusedBlock) { - modify(); - - int size = RubyNumeric.fix2int(getInternalVariable(getMetaClass(), "__size__")); - - if (args.length > size) { - throw getRuntime().newArgumentError("struct size differs (" + args.length +" for " + size + ")"); - } - - for (int i = 0; i < args.length; i++) { - values[i] = args[i]; - } - - return getRuntime().getNil(); - } - - public static RubyArray members(IRubyObject recv, Block block) { - RubyArray member = (RubyArray) getInternalVariable((RubyClass) recv, "__member__"); - - assert !member.isNil() : "uninitialized struct"; - - RubyArray result = recv.getRuntime().newArray(member.getLength()); - for (int i = 0,k=member.getLength(); i < k; i++) { - result.append(recv.getRuntime().newString(member.eltInternal(i).asJavaString())); - } - - return result; - } - - @JRubyMethod - public RubyArray members() { - return members(classOf(), Block.NULL_BLOCK); - } - - @JRubyMethod - public RubyArray select(ThreadContext context, Block block) { - RubyArray array = RubyArray.newArray(context.getRuntime()); - - for (int i = 0; i < values.length; i++) { - if (block.yield(context, values[i]).isTrue()) { - array.append(values[i]); - } - } - - return array; - } - - public IRubyObject set(IRubyObject value, int index) { - RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__"); - - assert !member.isNil() : "uninitialized struct"; - - modify(); - - return values[index] = value; - } - - private RaiseException notStructMemberError(String name) { - return getRuntime().newNameError(name + " is not struct member", name); - } - - public IRubyObject get(int index) { - RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__"); - - assert !member.isNil() : "uninitialized struct"; - - return values[index]; - } - - @Override - public void copySpecialInstanceVariables(IRubyObject clone) { - RubyStruct struct = (RubyStruct)clone; - struct.values = new IRubyObject[values.length]; - System.arraycopy(values, 0, struct.values, 0, values.length); - } - - @JRubyMethod(name = "==", required = 1) - public IRubyObject op_equal(ThreadContext context, IRubyObject other) { - if (this == other) return getRuntime().getTrue(); - if (!(other instanceof RubyStruct)) return getRuntime().getFalse(); - if (getMetaClass().getRealClass() != other.getMetaClass().getRealClass()) return getRuntime().getFalse(); - - Ruby runtime = getRuntime(); - RubyStruct otherStruct = (RubyStruct)other; - for (int i = 0; i < values.length; i++) { - if (!equalInternal(context, values[i], otherStruct.values[i])) return runtime.getFalse(); - } - return runtime.getTrue(); - } - - @JRubyMethod(name = "eql?", required = 1) - public IRubyObject eql_p(ThreadContext context, IRubyObject other) { - if (this == other) return getRuntime().getTrue(); - if (!(other instanceof RubyStruct)) return getRuntime().getFalse(); - if (getMetaClass() != other.getMetaClass()) return getRuntime().getFalse(); - - Ruby runtime = getRuntime(); - RubyStruct otherStruct = (RubyStruct)other; - for (int i = 0; i < values.length; i++) { - if (!eqlInternal(context, values[i], otherStruct.values[i])) return runtime.getFalse(); - } - return runtime.getTrue(); - } - - /** inspect_struct - * - */ - private IRubyObject inspectStruct(final ThreadContext context) { - RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__"); - - assert !member.isNil() : "uninitialized struct"; - - ByteList buffer = new ByteList("#<struct ".getBytes()); - buffer.append(getMetaClass().getRealClass().getRealClass().getName().getBytes()); - buffer.append(' '); - - for (int i = 0,k=member.getLength(); i < k; i++) { - if (i > 0) buffer.append(',').append(' '); - // FIXME: MRI has special case for constants here - buffer.append(RubyString.objAsString(context, member.eltInternal(i)).getByteList()); - buffer.append('='); - buffer.append(inspect(context, values[i]).getByteList()); - } - - buffer.append('>'); - return getRuntime().newString(buffer); // OBJ_INFECT - } - - @JRubyMethod(name = {"inspect", "to_s"}) - public IRubyObject inspect(ThreadContext context) { - if (getRuntime().isInspecting(this)) return getRuntime().newString("#<struct " + getMetaClass().getRealClass().getName() + ":...>"); - - try { - getRuntime().registerInspecting(this); - return inspectStruct(context); - } finally { - getRuntime().unregisterInspecting(this); - } - } - - @JRubyMethod(name = {"to_a", "values"}) - public RubyArray to_a() { - return getRuntime().newArray(values); - } - - @JRubyMethod(name = {"size", "length"} ) - public RubyFixnum size() { - return getRuntime().newFixnum(values.length); - } - - @JRubyMethod(name = "each", backtrace = true) - public IRubyObject each(ThreadContext context, Block block) { - for (int i = 0; i < values.length; i++) { - block.yield(context, values[i]); - } - - return this; - } - - @JRubyMethod(frame = true) - public IRubyObject each_pair(ThreadContext context, Block block) { - RubyArray member = (RubyArray) getInternalVariable(classOf(), "__member__"); - - assert !member.isNil() : "uninitialized struct"; - - for (int i = 0; i < values.length; i++) { - block.yield(context, getRuntime().newArrayNoCopy(new IRubyObject[]{member.eltInternal(i), values[i]})); - } - - return this; - } - - @JRubyMethod(name = "[]", required = 1) - public IRubyObject aref(IRubyObject key) { - if (key instanceof RubyString || key instanceof RubySymbol) { - return getByName(key.asJavaString()); - } - - int idx = RubyNumeric.fix2int(key); - - idx = idx < 0 ? values.length + idx : idx; - - if (idx < 0) { - throw getRuntime().newIndexError("offset " + idx + " too large for struct (size:" + values.length + ")"); - } else if (idx >= values.length) { - throw getRuntime().newIndexError("offset " + idx + " too large for struct (size:" + values.length + ")"); - } - - return values[idx]; - } - - @JRubyMethod(name = "[]=", required = 2) - public IRubyObject aset(IRubyObject key, IRubyObject value) { - if (key instanceof RubyString || key instanceof RubySymbol) { - return setByName(key.asJavaString(), value); - } - - int idx = RubyNumeric.fix2int(key); - - idx = idx < 0 ? values.length + idx : idx; - - if (idx < 0) { - throw getRuntime().newIndexError("offset " + idx + " too large for struct (size:" + values.length + ")"); - } else if (idx >= values.length) { - throw getRuntime().newIndexError("offset " + idx + " too large for struct (size:" + values.length + ")"); - } - - modify(); - return values[idx] = value; - } - - // FIXME: This is copied code from RubyArray. Both RE, Struct, and Array should share one impl - // This is also hacky since I construct ruby objects to access ruby arrays through aref instead - // of something lower. - @JRubyMethod(rest = true) - public IRubyObject values_at(IRubyObject[] args) { - long olen = values.length; - RubyArray result = getRuntime().newArray(args.length); - - for (int i = 0; i < args.length; i++) { - if (args[i] instanceof RubyFixnum) { - result.append(aref(args[i])); - continue; - } - - long beglen[]; - if (!(args[i] instanceof RubyRange)) { - } else if ((beglen = ((RubyRange) args[i]).begLen(olen, 0)) == null) { - continue; - } else { - int beg = (int) beglen[0]; - int len = (int) beglen[1]; - int end = len; - for (int j = 0; j < end; j++) { - result.append(aref(getRuntime().newFixnum(j + beg))); - } - continue; - } - result.append(aref(getRuntime().newFixnum(RubyNumeric.num2long(args[i])))); - } - - return result; - } - - public static void marshalTo(RubyStruct struct, MarshalStream output) throws java.io.IOException { - output.registerLinkTarget(struct); - output.dumpDefaultObjectHeader('S', struct.getMetaClass()); - - List members = ((RubyArray) getInternalVariable(struct.classOf(), "__member__")).getList(); - output.writeInt(members.size()); - - for (int i = 0; i < members.size(); i++) { - RubySymbol name = (RubySymbol) members.get(i); - output.dumpObject(name); - output.dumpObject(struct.values[i]); - } - } - - public static RubyStruct unmarshalFrom(UnmarshalStream input) throws java.io.IOException { - Ruby runtime = input.getRuntime(); - - RubySymbol className = (RubySymbol) input.unmarshalObject(); - RubyClass rbClass = pathToClass(runtime, className.asJavaString()); - if (rbClass == null) { - throw runtime.newNameError("uninitialized constant " + className, className.asJavaString()); - } - - RubyArray mem = members(rbClass, Block.NULL_BLOCK); - - int len = input.unmarshalInt(); - IRubyObject[] values = new IRubyObject[len]; - for(int i = 0; i < len; i++) { - values[i] = runtime.getNil(); - } - RubyStruct result = newStruct(rbClass, values, Block.NULL_BLOCK); - input.registerLinkTarget(result); - for(int i = 0; i < len; i++) { - IRubyObject slot = input.unmarshalObject(); - if(!mem.eltInternal(i).toString().equals(slot.toString())) { - throw runtime.newTypeError("struct " + rbClass.getName() + " not compatible (:" + slot + " for :" + mem.eltInternal(i) + ")"); - } - result.aset(runtime.newFixnum(i), input.unmarshalObject()); - } - return result; - } - - private static RubyClass pathToClass(Ruby runtime, String path) { - // FIXME: Throw the right ArgumentError's if the class is missing - // or if it's a module. - return (RubyClass) runtime.getClassFromPath(path); - } - - private static ObjectAllocator STRUCT_INSTANCE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - RubyStruct instance = new RubyStruct(runtime, klass); - - instance.setMetaClass(klass); - - return instance; - } - }; - - @Override - @JRubyMethod(required = 1) - public IRubyObject initialize_copy(IRubyObject arg) { - if (this == arg) return this; - RubyStruct original = (RubyStruct) arg; - - values = new IRubyObject[original.values.length]; - System.arraycopy(original.values, 0, values, 0, original.values.length); - - return this; - } - -} -/* - ***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Joey Gibson <joey@joeygibson.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Derek Berner <derek.berner@state.nm.us> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * Copyright (C) 2007 William N Dortch <bill.dortch@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.util.concurrent.locks.ReentrantLock; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Block; -import org.jruby.runtime.BlockCallback; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.marshal.UnmarshalStream; -import org.jruby.util.ByteList; - -/** - * Represents a Ruby symbol (e.g. :bar) - */ -@JRubyClass(name="Symbol") -public class RubySymbol extends RubyObject { - private final String symbol; - private final int id; - private final ByteList symbolBytes; - - /** - * - * @param runtime - * @param internedSymbol the String value of the new Symbol. This <em>must</em> - * have been previously interned - */ - private RubySymbol(Ruby runtime, String internedSymbol) { - super(runtime, runtime.getSymbol(), false); - // symbol string *must* be interned - - assert internedSymbol == internedSymbol.intern() : internedSymbol + " is not interned"; - - this.symbol = internedSymbol; - this.symbolBytes = ByteList.create(symbol); - - this.id = runtime.allocSymbolId(); - } - - public static RubyClass createSymbolClass(Ruby runtime) { - RubyClass symbolClass = runtime.defineClass("Symbol", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setSymbol(symbolClass); - RubyClass symbolMetaClass = symbolClass.getMetaClass(); - symbolClass.index = ClassIndex.SYMBOL; - symbolClass.kindOf = new RubyModule.KindOf() { - public boolean isKindOf(IRubyObject obj, RubyModule type) { - return obj instanceof RubySymbol; - } - }; - - symbolClass.defineAnnotatedMethods(RubySymbol.class); - symbolMetaClass.undefineMethod("new"); - - return symbolClass; - } - - @Override - public int getNativeTypeIndex() { - return ClassIndex.SYMBOL; - } - - /** rb_to_id - * - * @return a String representation of the symbol - */ - @Override - public String asJavaString() { - return symbol; - } - - /** short circuit for Symbol key comparison - * - */ - @Override - public final boolean eql(IRubyObject other) { - return other == this; - } - - @Override - public boolean isImmediate() { - return true; - } - - @Override - public RubyClass getSingletonClass() { - throw getRuntime().newTypeError("can't define singleton"); - } - - public static RubySymbol getSymbolLong(Ruby runtime, long id) { - return runtime.getSymbolTable().lookup(id); - } - - /* Symbol class methods. - * - */ - - public static RubySymbol newSymbol(Ruby runtime, String name) { - return runtime.getSymbolTable().getSymbol(name); - } - - @JRubyMethod(name = "to_i") - public RubyFixnum to_i() { - return getRuntime().newFixnum(id); - } - - @JRubyMethod(name = "to_int") - public RubyFixnum to_int() { - if (getRuntime().getVerbose().isTrue()) { - getRuntime().getWarnings().warn(ID.SYMBOL_AS_INTEGER, "treating Symbol as an integer"); - } - return to_i(); - } - - @JRubyMethod(name = "inspect") - @Override - public IRubyObject inspect() { - Ruby runtime = getRuntime(); - return runtime.newString(":" + - (isSymbolName(symbol) ? symbol : RubyString.newStringShared(runtime, symbolBytes).dump().toString())); - } - - @JRubyMethod(name = "to_s") - @Override - public IRubyObject to_s() { - return RubyString.newStringShared(getRuntime(), symbolBytes); - } - - @JRubyMethod(name = "id2name") - public IRubyObject id2name() { - return to_s(); - } - - @JRubyMethod(name = "===", required = 1) - @Override - public IRubyObject op_eqq(ThreadContext context, IRubyObject other) { - return super.op_equal(context, other); - } - - @Override - public RubyFixnum hash() { - return getRuntime().newFixnum(hashCode()); - } - - @Override - public int hashCode() { - return id; - } - - public int getId() { - return id; - } - - @Override - public boolean equals(Object other) { - return other == this; - } - - @JRubyMethod(name = "to_sym") - public IRubyObject to_sym() { - return this; - } - - @Override - public IRubyObject freeze(ThreadContext context) { - return this; - } - - @Override - public IRubyObject taint(ThreadContext context) { - return this; - } - - private static class ToProcCallback implements BlockCallback { - private RubySymbol symbol; - public ToProcCallback(RubySymbol symbol) { - this.symbol = symbol; - } - - public IRubyObject call(ThreadContext ctx, IRubyObject[] args, Block blk) { - IRubyObject[] currentArgs = args; - switch(currentArgs.length) { - case 0: throw symbol.getRuntime().newArgumentError("no receiver given"); - case 1: { - if((currentArgs[0] instanceof RubyArray) && ((RubyArray)currentArgs[0]).getLength() != 0) { - // This is needed to unpack stuff - currentArgs = ((RubyArray)currentArgs[0]).toJavaArrayMaybeUnsafe(); - IRubyObject[] args2 = new IRubyObject[currentArgs.length-1]; - System.arraycopy(currentArgs, 1, args2, 0, args2.length); - return RuntimeHelpers.invoke(ctx, currentArgs[0], symbol.symbol, args2); - } else { - return RuntimeHelpers.invoke(ctx, currentArgs[0], symbol.symbol); - } - } - default: { - IRubyObject[] args2 = new IRubyObject[currentArgs.length-1]; - System.arraycopy(currentArgs, 1, args2, 0, args2.length); - return RuntimeHelpers.invoke(ctx, currentArgs[0], symbol.symbol, args2); - } - } - } - } - /* - @JRubyMethod - public IRubyObject to_proc() { - return RubyProc.newProc(getRuntime(), - CallBlock.newCallClosure(this, getRuntime().getSymbol(), Arity.noArguments(), new ToProcCallback(this), getRuntime().getCurrentContext()), - Block.Type.PROC); - } - */ - private static boolean isIdentStart(char c) { - return ((c >= 'a' && c <= 'z')|| (c >= 'A' && c <= 'Z') - || c == '_'); - } - private static boolean isIdentChar(char c) { - return ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') - || c == '_'); - } - - private static boolean isIdentifier(String s) { - if (s == null || s.length() <= 0) { - return false; - } - - if (!isIdentStart(s.charAt(0))) { - return false; - } - for (int i = 1; i < s.length(); i++) { - if (!isIdentChar(s.charAt(i))) { - return false; - } - } - - return true; - } - - /** - * is_special_global_name from parse.c. - * @param s - * @return - */ - private static boolean isSpecialGlobalName(String s) { - if (s == null || s.length() <= 0) { - return false; - } - - int length = s.length(); - - switch (s.charAt(0)) { - case '~': case '*': case '$': case '?': case '!': case '@': case '/': case '\\': - case ';': case ',': case '.': case '=': case ':': case '<': case '>': case '\"': - case '&': case '`': case '\'': case '+': case '0': - return length == 1; - case '-': - return (length == 1 || (length == 2 && isIdentChar(s.charAt(1)))); - - default: - // we already confirmed above that length > 0 - for (int i = 0; i < length; i++) { - if (!Character.isDigit(s.charAt(i))) { - return false; - } - } - } - return true; - } - - private static boolean isSymbolName(String s) { - if (s == null || s.length() < 1) { - return false; - } - - int length = s.length(); - - char c = s.charAt(0); - switch (c) { - case '$': - if (length > 1 && isSpecialGlobalName(s.substring(1))) { - return true; - } - return isIdentifier(s.substring(1)); - case '@': - int offset = 1; - if (length >= 2 && s.charAt(1) == '@') { - offset++; - } - - return isIdentifier(s.substring(offset)); - case '<': - return (length == 1 || (length == 2 && (s.equals("<<") || s.equals("<="))) || - (length == 3 && s.equals("<=>"))); - case '>': - return (length == 1) || (length == 2 && (s.equals(">>") || s.equals(">="))); - case '=': - return ((length == 2 && (s.equals("==") || s.equals("=~"))) || - (length == 3 && s.equals("==="))); - case '*': - return (length == 1 || (length == 2 && s.equals("**"))); - case '+': - return (length == 1 || (length == 2 && s.equals("+@"))); - case '-': - return (length == 1 || (length == 2 && s.equals("-@"))); - case '|': case '^': case '&': case '/': case '%': case '~': case '`': - return length == 1; - case '[': - return s.equals("[]") || s.equals("[]="); - } - - if (!isIdentStart(c)) { - return false; - } - - boolean localID = (c >= 'a' && c <= 'z'); - int last = 1; - - for (; last < length; last++) { - char d = s.charAt(last); - - if (!isIdentChar(d)) { - break; - } - } - - if (last == length) { - return true; - } else if (localID && last == length - 1) { - char d = s.charAt(last); - - return d == '!' || d == '?' || d == '='; - } - - return false; - } - - @JRubyMethod(name = "all_symbols", meta = true) - public static IRubyObject all_symbols(IRubyObject recv) { - return recv.getRuntime().getSymbolTable().all_symbols(); - } - - public static RubySymbol unmarshalFrom(UnmarshalStream input) throws java.io.IOException { - RubySymbol result = newSymbol(input.getRuntime(), RubyString.byteListToString(input.unmarshalString())); - input.registerLinkTarget(result); - return result; - } - - public static class SymbolTable { - static final int DEFAULT_INITIAL_CAPACITY = 2048; // *must* be power of 2! - static final int MAXIMUM_CAPACITY = 1 << 30; - static final float DEFAULT_LOAD_FACTOR = 0.75f; - - private final ReentrantLock tableLock = new ReentrantLock(); - private volatile SymbolEntry[] symbolTable; - private int size; - private int threshold; - private final float loadFactor; - private final Ruby runtime; - - public SymbolTable(Ruby runtime) { - this.runtime = runtime; - this.loadFactor = DEFAULT_LOAD_FACTOR; - this.threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR); - this.symbolTable = new SymbolEntry[DEFAULT_INITIAL_CAPACITY]; - } - - // note all fields are final -- rehash creates new entries when necessary. - // as documented in java.util.concurrent.ConcurrentHashMap.java, that will - // statistically affect only a small percentage (< 20%) of entries for a given rehash. - static class SymbolEntry { - final int hash; - final String name; - final RubySymbol symbol; - final SymbolEntry next; - - SymbolEntry(int hash, String name, RubySymbol symbol, SymbolEntry next) { - this.hash = hash; - this.name = name; - this.symbol = symbol; - this.next = next; - } - } - - public RubySymbol getSymbol(String name) { - int hash = name.hashCode(); - SymbolEntry[] table; - for (SymbolEntry e = (table = symbolTable)[hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - return e.symbol; - } - } - ReentrantLock lock; - (lock = tableLock).lock(); - try { - int potentialNewSize; - if ((potentialNewSize = size + 1) > threshold) { - table = rehash(); - } else { - table = symbolTable; - } - int index; - // try lookup again under lock - for (SymbolEntry e = table[index = hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - return e.symbol; - } - } - String internedName; - RubySymbol symbol = new RubySymbol(runtime, internedName = name.intern()); - table[index] = new SymbolEntry(hash, internedName, symbol, table[index]); - size = potentialNewSize; - // write-volatile - symbolTable = table; - return symbol; - } finally { - lock.unlock(); - } - } - - public RubySymbol fastGetSymbol(String internedName) { - assert internedName == internedName.intern() : internedName + " is not interned"; - SymbolEntry[] table; - for (SymbolEntry e = (table = symbolTable)[internedName.hashCode() & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - return e.symbol; - } - } - ReentrantLock lock; - (lock = tableLock).lock(); - try { - int potentialNewSize; - if ((potentialNewSize = size + 1) > threshold) { - table = rehash(); - } else { - table = symbolTable; - } - int index; - int hash; - // try lookup again under lock - for (SymbolEntry e = table[index = (hash = internedName.hashCode()) & (table.length - 1)]; e != null; e = e.next) { - if (internedName == e.name) { - return e.symbol; - } - } - RubySymbol symbol = new RubySymbol(runtime, internedName); - table[index] = new SymbolEntry(hash, internedName, symbol, table[index]); - size = potentialNewSize; - // write-volatile - symbolTable = table; - return symbol; - } finally { - lock.unlock(); - } - } - - // backwards-compatibility, but threadsafe now - public RubySymbol lookup(String name) { - int hash = name.hashCode(); - SymbolEntry[] table; - for (SymbolEntry e = (table = symbolTable)[hash & (table.length - 1)]; e != null; e = e.next) { - if (hash == e.hash && name.equals(e.name)) { - return e.symbol; - } - } - return null; - } - - public RubySymbol lookup(long id) { - SymbolEntry[] table = symbolTable; - for (int i = table.length; --i >= 0; ) { - for (SymbolEntry e = table[i]; e != null; e = e.next) { - if (id == e.symbol.id) { - return e.symbol; - } - } - } - return null; - } - - public RubyArray all_symbols() { - SymbolEntry[] table = this.symbolTable; - RubyArray array = runtime.newArray(this.size); - for (int i = table.length; --i >= 0; ) { - for (SymbolEntry e = table[i]; e != null; e = e.next) { - array.append(e.symbol); - } - } - return array; - } - - // not so backwards-compatible here, but no one should have been - // calling this anyway. - @Deprecated - public void store(RubySymbol symbol) { - throw new UnsupportedOperationException(); - } - - private SymbolEntry[] rehash() { - SymbolEntry[] oldTable = symbolTable; - int oldCapacity; - if ((oldCapacity = oldTable.length) >= MAXIMUM_CAPACITY) { - return oldTable; - } - - int newCapacity = oldCapacity << 1; - SymbolEntry[] newTable = new SymbolEntry[newCapacity]; - threshold = (int)(newCapacity * loadFactor); - int sizeMask = newCapacity - 1; - SymbolEntry e; - for (int i = oldCapacity; --i >= 0; ) { - // We need to guarantee that any existing reads of old Map can - // proceed. So we cannot yet null out each bin. - e = oldTable[i]; - - if (e != null) { - SymbolEntry next = e.next; - int idx = e.hash & sizeMask; - - // Single node on list - if (next == null) - newTable[idx] = e; - - else { - // Reuse trailing consecutive sequence at same slot - SymbolEntry lastRun = e; - int lastIdx = idx; - for (SymbolEntry last = next; - last != null; - last = last.next) { - int k = last.hash & sizeMask; - if (k != lastIdx) { - lastIdx = k; - lastRun = last; - } - } - newTable[lastIdx] = lastRun; - - // Clone all remaining nodes - for (SymbolEntry p = e; p != lastRun; p = p.next) { - int k = p.hash & sizeMask; - SymbolEntry n = newTable[k]; - newTable[k] = new SymbolEntry(p.hash, p.name, p.symbol, n); - } - } - } - } - symbolTable = newTable; - return newTable; - } - - } -} -package org.jruby; - -import java.io.IOException; -import java.util.List; -import java.util.Map; -import java.util.HashMap; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ObjectMarshal; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.builtin.Variable; -import org.jruby.runtime.component.VariableEntry; -import org.jruby.runtime.marshal.MarshalStream; -import org.jruby.runtime.marshal.UnmarshalStream; - -@JRubyClass(name="SystemCallError", parent="StandardError") -public class RubySystemCallError extends RubyException { - private IRubyObject errno = getRuntime().getNil(); - - private final static Map<String, String> defaultMessages = new HashMap<String, String>(); - static { - defaultMessages.put("Errno::EPERM", "Operation not permitted"); - defaultMessages.put("Errno::ENOENT", "No such file or directory"); - defaultMessages.put("Errno::ESRCH", "No such process"); - defaultMessages.put("Errno::EINTR", "Interrupted system call"); - defaultMessages.put("Errno::EIO", "Input/output error"); - defaultMessages.put("Errno::ENXIO", "Device not configured"); - defaultMessages.put("Errno::E2BIG", "Argument list too long"); - defaultMessages.put("Errno::ENOEXEC", "Exec format error"); - defaultMessages.put("Errno::EBADF", "Bad file descriptor"); - defaultMessages.put("Errno::ECHILD", "No child processes"); - defaultMessages.put("Errno::EDEADLK", "Resource deadlock avoided"); - defaultMessages.put("Errno::ENOMEM", "Cannot allocate memory"); - defaultMessages.put("Errno::EACCES", "Permission denied"); - defaultMessages.put("Errno::EFAULT", "Bad address"); - defaultMessages.put("Errno::ENOTBLK", "Block device required"); - defaultMessages.put("Errno::EBUSY", "Resource busy"); - defaultMessages.put("Errno::EEXIST", "File exists"); - defaultMessages.put("Errno::EXDEV", "Cross-device link"); - defaultMessages.put("Errno::ENODEV", "Operation not supported by device"); - defaultMessages.put("Errno::ENOTDIR", "Not a directory"); - defaultMessages.put("Errno::EISDIR", "Is a directory"); - defaultMessages.put("Errno::EINVAL", "Invalid argument"); - defaultMessages.put("Errno::ENFILE", "Too many open files in system"); - defaultMessages.put("Errno::EMFILE", "Too many open files"); - defaultMessages.put("Errno::ENOTTY", "Inappropriate ioctl for device"); - defaultMessages.put("Errno::ETXTBSY", "Text file busy"); - defaultMessages.put("Errno::EFBIG", "File too large"); - defaultMessages.put("Errno::ENOSPC", "No space left on device"); - defaultMessages.put("Errno::ESPIPE", "Illegal seek"); - defaultMessages.put("Errno::EROFS", "Read-only file system"); - defaultMessages.put("Errno::EMLINK", "Too many links"); - defaultMessages.put("Errno::EPIPE", "Broken pipe"); - defaultMessages.put("Errno::EDOM", "Numerical argument out of domain"); - defaultMessages.put("Errno::ERANGE", "Result too large"); - defaultMessages.put("Errno::EAGAIN", "Resource temporarily unavailable"); - defaultMessages.put("Errno::EWOULDBLOCK", "Resource temporarily unavailable"); - defaultMessages.put("Errno::EINPROGRESS", "Operation now in progress"); - defaultMessages.put("Errno::EALREADY", "Operation already in progress"); - defaultMessages.put("Errno::ENOTSOCK", "Socket operation on non-socket"); - defaultMessages.put("Errno::EDESTADDRREQ", "Destination address required"); - defaultMessages.put("Errno::EMSGSIZE", "Message too long"); - defaultMessages.put("Errno::EPROTOTYPE", "Protocol wrong type for socket"); - defaultMessages.put("Errno::ENOPROTOOPT", "Protocol not available"); - defaultMessages.put("Errno::EPROTONOSUPPORT", "Protocol not supported"); - defaultMessages.put("Errno::ESOCKTNOSUPPORT", "Socket type not supported"); - defaultMessages.put("Errno::EPFNOSUPPORT", "Protocol family not supported"); - defaultMessages.put("Errno::EAFNOSUPPORT", "Address family not supported by protocol family"); - defaultMessages.put("Errno::EADDRINUSE", "Address already in use"); - defaultMessages.put("Errno::EADDRNOTAVAIL", "Can't assign requested address"); - defaultMessages.put("Errno::ENETDOWN", "Network is down"); - defaultMessages.put("Errno::ENETUNREACH", "Network is unreachable"); - defaultMessages.put("Errno::ENETRESET", "Network dropped connection on reset"); - defaultMessages.put("Errno::ECONNABORTED", "Software caused connection abort"); - defaultMessages.put("Errno::ECONNRESET", "Connection reset by peer"); - defaultMessages.put("Errno::ENOBUFS", "No buffer space available"); - defaultMessages.put("Errno::EISCONN", "Socket is already connected"); - defaultMessages.put("Errno::ENOTCONN", "Socket is not connected"); - defaultMessages.put("Errno::ESHUTDOWN", "Can't send after socket shutdown"); - defaultMessages.put("Errno::ETOOMANYREFS", "Too many references: can't splice"); - defaultMessages.put("Errno::ETIMEDOUT", "Operation timed out"); - defaultMessages.put("Errno::ECONNREFUSED", "Connection refused"); - defaultMessages.put("Errno::ELOOP", "Too many levels of symbolic links"); - defaultMessages.put("Errno::ENAMETOOLONG", "File name too long"); - defaultMessages.put("Errno::EHOSTDOWN", "Host is down"); - defaultMessages.put("Errno::EHOSTUNREACH", "No route to host"); - defaultMessages.put("Errno::ENOTEMPTY", "Directory not empty"); - defaultMessages.put("Errno::EUSERS", "Too many users"); - defaultMessages.put("Errno::EDQUOT", "Disc quota exceeded"); - defaultMessages.put("Errno::ESTALE", "Stale NFS file handle"); - defaultMessages.put("Errno::EREMOTE", "Too many levels of remote in path"); - defaultMessages.put("Errno::ENOLCK", "No locks available"); - defaultMessages.put("Errno::ENOSYS", "Function not implemented"); - defaultMessages.put("Errno::EOVERFLOW", "Value too large to be stored in data type"); - defaultMessages.put("Errno::EIDRM", "Identifier removed"); - defaultMessages.put("Errno::ENOMSG", "No message of desired type"); - defaultMessages.put("Errno::EILSEQ", "Illegal byte sequence"); - defaultMessages.put("Errno::EBADMSG", "Bad message"); - defaultMessages.put("Errno::EMULTIHOP", "EMULTIHOP (Reserved)"); - defaultMessages.put("Errno::ENODATA", "No message available on STREAM"); - defaultMessages.put("Errno::ENOLINK", "ENOLINK (Reserved)"); - defaultMessages.put("Errno::ENOSR", "No STREAM resources"); - defaultMessages.put("Errno::ENOSTR", "Not a STREAM"); - defaultMessages.put("Errno::EPROTO", "Protocol error"); - defaultMessages.put("Errno::ETIME", "STREAM ioctl timeout"); - defaultMessages.put("Errno::EOPNOTSUPP", "Operation not supported"); - defaultMessages.put("Errno::EOPNOTSUPP_DARWIN", "Operation not supported"); - } - - protected RubySystemCallError(Ruby runtime, RubyClass rubyClass) { - super(runtime, rubyClass, null); - } - - public RubySystemCallError(Ruby runtime, RubyClass rubyClass, String message, int errno) { - super(runtime, rubyClass, message); - this.errno = runtime.newFixnum(errno); - } - - private static ObjectAllocator SYSTEM_CALL_ERROR_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - RubyException instance = new RubySystemCallError(runtime, klass); - - instance.setMetaClass(klass); - - return instance; - } - }; - - private static final ObjectMarshal SYSTEM_CALL_ERROR_MARSHAL = new ObjectMarshal() { - public void marshalTo(Ruby runtime, Object obj, RubyClass type, - MarshalStream marshalStream) throws IOException { - RubySystemCallError exc = (RubySystemCallError) obj; - marshalStream.registerLinkTarget(exc); - - List<Variable<IRubyObject>> attrs = exc.getVariableList(); - attrs.add(new VariableEntry<IRubyObject>( - "mesg", exc.message == null ? runtime.getNil() : exc.message)); - attrs.add(new VariableEntry<IRubyObject>("errno", exc.errno)); - attrs.add(new VariableEntry<IRubyObject>("bt", exc.getBacktrace())); - marshalStream.dumpVariables(attrs); - } - - public Object unmarshalFrom(Ruby runtime, RubyClass type, - UnmarshalStream unmarshalStream) throws IOException { - RubySystemCallError exc = (RubySystemCallError) type.allocate(); - - unmarshalStream.registerLinkTarget(exc); - unmarshalStream.defaultVariablesUnmarshal(exc); - - exc.message = exc.removeInternalVariable("mesg"); - exc.errno = exc.removeInternalVariable("errno"); - exc.set_backtrace(exc.removeInternalVariable("bt")); - - return exc; - } - }; - - public static RubyClass createSystemCallErrorClass(Ruby runtime, RubyClass standardError) { - RubyClass exceptionClass = runtime.defineClass("SystemCallError", standardError, SYSTEM_CALL_ERROR_ALLOCATOR); - - exceptionClass.setMarshal(SYSTEM_CALL_ERROR_MARSHAL); - - runtime.callbackFactory(RubyClass.class); - exceptionClass.defineAnnotatedMethods(RubySystemCallError.class); - - return exceptionClass; - } - - @JRubyMethod(optional = 2, required=0, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, Block block) { - RubyClass sCallErorrClass = getRuntime().getSystemCallError(); - RubyClass klass = getMetaClass().getRealClass(); - - IRubyObject msg = getRuntime().getNil(); - IRubyObject err = getRuntime().getNil(); - - boolean isErrnoClass = !klass.equals(sCallErorrClass); - - if (!isErrnoClass) { - // one optional, one required args - Arity.checkArgumentCount(getRuntime(), args, 1, 2); - msg = args[0]; - if (args.length == 2) { - err = args[1]; - } - if (args.length == 1 && (msg instanceof RubyFixnum)) { - err = msg; - msg = getRuntime().getNil(); - } - } else { - // one optional and no required args - Arity.checkArgumentCount(getRuntime(), args, 0, 1); - if (args.length == 1) { - msg = args[0]; - } - // try to get errno out of the class - err = klass.fastGetConstant("Errno"); - } - - if (!err.isNil()) { - errno = err.convertToInteger(); - } - - String val = defaultMessages.get(klass.getName()); - if (val == null) { - val = "Unknown error"; - } - - // MRI behavior: we don't print errno for actual Errno errors - if (!errno.isNil() && !isErrnoClass) { - val += " " + errno.toString(); - } - - if (!msg.isNil()) { - val += " - " + msg.convertToString(); - } - - message = getRuntime().newString(val); - return this; - } - - @JRubyMethod - public IRubyObject errno() { - return errno; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ - -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -@JRubyClass(name="SystemExit", parent="Exception") -public class RubySystemExit extends RubyException { - IRubyObject status; - - private static ObjectAllocator SYSTEMEXIT_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubySystemExit(runtime, klass); - } - }; - - public static RubyClass createSystemExitClass(Ruby runtime, RubyClass exceptionClass) { - RubyClass systemExitClass = runtime.defineClass("SystemExit", exceptionClass, SYSTEMEXIT_ALLOCATOR); - - systemExitClass.defineAnnotatedMethods(RubySystemExit.class); - - return systemExitClass; - } - - public static RubySystemExit newInstance(Ruby runtime, int status) { - RubyClass exc = runtime.getSystemExit(); - IRubyObject[] exArgs = new IRubyObject[] { - runtime.newFixnum(status), - runtime.newString("exit") }; - return (RubySystemExit) exc.newInstance(runtime.getCurrentContext(), exArgs, Block.NULL_BLOCK); - } - - protected RubySystemExit(Ruby runtime, RubyClass exceptionClass) { - super(runtime, exceptionClass); - status = runtime.getNil(); - } - - @JRubyMethod(name = "initialize", optional = 2, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[]args, Block block) { - status = RubyFixnum.zero(getRuntime()); - if (args.length > 0 && args[0] instanceof RubyFixnum) { - status = args[0]; - IRubyObject[]tmpArgs = new IRubyObject[args.length - 1]; - System.arraycopy(args, 1, tmpArgs, 0, tmpArgs.length); - args = tmpArgs; - } - super.initialize(args, block); - return this; - } - - @JRubyMethod(name = "status") - public IRubyObject status() { - return status; - } - - @JRubyMethod(name = "success?") - public IRubyObject success_p() { - if (status.isNil()) return getRuntime().getTrue(); - if (status.equals(RubyFixnum.zero(getRuntime()))) return getRuntime().getTrue(); - return getRuntime().getFalse(); - } - -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002 Jason Voegele <jason@jvoegele.com> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; -import java.nio.channels.Channel; -import java.nio.channels.SelectableChannel; -import java.nio.channels.SelectionKey; -import java.nio.channels.Selector; -import java.util.HashMap; -import java.util.Map; - -import java.util.Set; -import org.jruby.common.IRubyWarnings.ID; -import org.jruby.exceptions.RaiseException; -import org.jruby.exceptions.ThreadKill; -import org.jruby.internal.runtime.FutureThread; -import org.jruby.internal.runtime.NativeThread; -import org.jruby.internal.runtime.RubyRunnable; -import org.jruby.internal.runtime.ThreadLike; -import org.jruby.internal.runtime.ThreadService; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -import java.util.concurrent.ExecutionException; -import java.util.concurrent.locks.ReentrantLock; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.runtime.ObjectMarshal; -import org.jruby.runtime.Visibility; - -/** - * Implementation of Ruby's <code>Thread</code> class. Each Ruby thread is - * mapped to an underlying Java Virtual Machine thread. - * <p> - * Thread encapsulates the behavior of a thread of execution, including the main - * thread of the Ruby script. In the descriptions that follow, the parameter - * <code>aSymbol</code> refers to a symbol, which is either a quoted string or a - * <code>Symbol</code> (such as <code>:name</code>). - * - * Note: For CVS history, see ThreadClass.java. - */ -@JRubyClass(name="Thread") -public class RubyThread extends RubyObject { - private ThreadLike threadImpl; - private RubyFixnum priority; - private transient Map<IRubyObject, IRubyObject> threadLocalVariables; - private boolean abortOnException; - private IRubyObject finalResult; - private RaiseException exitingException; - private IRubyObject receivedException; - private RubyThreadGroup threadGroup; - - private final ThreadService threadService; - private volatile boolean isStopped = false; - private volatile boolean isDead = false; - public Object stopLock = new Object(); - - private volatile boolean killed = false; - public Object killLock = new Object(); - - public final ReentrantLock lock = new ReentrantLock(); - - private static final boolean DEBUG = false; - - protected RubyThread(Ruby runtime, RubyClass type) { - super(runtime, type); - this.threadService = runtime.getThreadService(); - finalResult = runtime.getNil(); - } - - /** - * Dispose of the current thread by removing it from its parent ThreadGroup. - */ - public void dispose() { - threadGroup.remove(this); - } - - public static RubyClass createThreadClass(Ruby runtime) { - // FIXME: In order for Thread to play well with the standard 'new' behavior, - // it must provide an allocator that can create empty object instances which - // initialize then fills with appropriate data. - RubyClass threadClass = runtime.defineClass("Thread", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setThread(threadClass); - - threadClass.defineAnnotatedMethods(RubyThread.class); - - RubyThread rubyThread = new RubyThread(runtime, threadClass); - // TODO: need to isolate the "current" thread from class creation - rubyThread.threadImpl = new NativeThread(rubyThread, Thread.currentThread()); - runtime.getThreadService().setMainThread(Thread.currentThread(), rubyThread); - - // set to default thread group - runtime.getDefaultThreadGroup().addDirectly(rubyThread); - - threadClass.setMarshal(ObjectMarshal.NOT_MARSHALABLE_MARSHAL); - - return threadClass; - } - - /** - * <code>Thread.new</code> - * <p> - * Thread.new( <i>[ arg ]*</i> ) {| args | block } -> aThread - * <p> - * Creates a new thread to execute the instructions given in block, and - * begins running it. Any arguments passed to Thread.new are passed into the - * block. - * <pre> - * x = Thread.new { sleep .1; print "x"; print "y"; print "z" } - * a = Thread.new { print "a"; print "b"; sleep .2; print "c" } - * x.join # Let the threads finish before - * a.join # main thread exits... - * </pre> - * <i>produces:</i> abxyzc - */ - @JRubyMethod(name = {"new", "fork"}, rest = true, frame = true, meta = true) - public static IRubyObject newInstance(IRubyObject recv, IRubyObject[] args, Block block) { - return startThread(recv, args, true, block); - } - - /** - * Basically the same as Thread.new . However, if class Thread is - * subclassed, then calling start in that subclass will not invoke the - * subclass's initialize method. - */ - @JRubyMethod(name = "start", rest = true, frame = true, meta = true) - public static RubyThread start(IRubyObject recv, IRubyObject[] args, Block block) { - return startThread(recv, args, false, block); - } - - public static RubyThread adopt(IRubyObject recv, Thread t) { - return adoptThread(recv, t, Block.NULL_BLOCK); - } - - private static RubyThread adoptThread(final IRubyObject recv, Thread t, Block block) { - final Ruby runtime = recv.getRuntime(); - final RubyThread rubyThread = new RubyThread(runtime, (RubyClass) recv); - - rubyThread.threadImpl = new NativeThread(rubyThread, t); - ThreadContext context = runtime.getThreadService().registerNewThread(rubyThread); - - context.preAdoptThread(); - - // set to default thread group - runtime.getDefaultThreadGroup().addDirectly(rubyThread); - - return rubyThread; - } - - @JRubyMethod(name = "initialize", rest = true, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject[] args, Block block) { - Ruby runtime = getRuntime(); - if (!block.isGiven()) throw runtime.newThreadError("must be called with a block"); - - RubyRunnable runnable = new RubyRunnable(this, args, block); - if (RubyInstanceConfig.POOLING_ENABLED) { - threadImpl = new FutureThread(this, runnable); - } else { - Thread thread = new Thread(runnable); - thread.setDaemon(true); - threadImpl = new NativeThread(this, thread); - } - - // set to default thread group - runtime.getDefaultThreadGroup().addDirectly(this); - - threadImpl.start(); - - // We yield here to hopefully permit the target thread to schedule - // MRI immediately schedules it, so this is close but not exact - Thread.yield(); - - return this; - } - - private static RubyThread startThread(final IRubyObject recv, final IRubyObject[] args, boolean callInit, Block block) { - RubyThread rubyThread = new RubyThread(recv.getRuntime(), (RubyClass) recv); - - if (callInit) { - rubyThread.callInit(args, block); - } else { - // for Thread::start, which does not call the subclass's initialize - rubyThread.initialize(args, block); - } - - return rubyThread; - } - - private void ensureNotCurrent() { - if (this == getRuntime().getCurrentContext().getThread()) { - throw new RuntimeException("internal thread method called from another thread"); - } - } - - public synchronized void cleanTerminate(IRubyObject result) { - finalResult = result; - isStopped = true; - isDead = true; - } - - public void pollThreadEvents() { - pollThreadEvents(getRuntime().getCurrentContext()); - } - - public void pollThreadEvents(ThreadContext context) { - // check for criticalization *before* locking ourselves - threadService.waitForCritical(); - - if (killed) throwThreadKill(); - if (receivedException != null) receivedAnException(context); - } - - private void throwThreadKill() { - throw new ThreadKill(); - } - - /** - * Returns the status of the global ``abort on exception'' condition. The - * default is false. When set to true, will cause all threads to abort (the - * process will exit(0)) if an exception is raised in any thread. See also - * Thread.abort_on_exception= . - */ - @JRubyMethod(name = "abort_on_exception", meta = true) - public static RubyBoolean abort_on_exception_x(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - return runtime.isGlobalAbortOnExceptionEnabled() ? runtime.getTrue() : runtime.getFalse(); - } - - @JRubyMethod(name = "abort_on_exception=", required = 1, meta = true) - public static IRubyObject abort_on_exception_set_x(IRubyObject recv, IRubyObject value) { - recv.getRuntime().setGlobalAbortOnExceptionEnabled(value.isTrue()); - return value; - } - - @JRubyMethod(name = "current", meta = true) - public static RubyThread current(IRubyObject recv) { - return recv.getRuntime().getCurrentContext().getThread(); - } - - @JRubyMethod(name = "main", meta = true) - public static RubyThread main(IRubyObject recv) { - return recv.getRuntime().getThreadService().getMainThread(); - } - - @JRubyMethod(name = "pass", meta = true) - public static IRubyObject pass(IRubyObject recv) { - Ruby runtime = recv.getRuntime(); - ThreadService ts = runtime.getThreadService(); - boolean critical = ts.getCritical(); - - ts.setCritical(false); - - Thread.yield(); - - ts.setCritical(critical); - - return recv.getRuntime().getNil(); - } - - @JRubyMethod(name = "list", meta = true) - public static RubyArray list(IRubyObject recv) { - RubyThread[] activeThreads = recv.getRuntime().getThreadService().getActiveRubyThreads(); - - return recv.getRuntime().newArrayNoCopy(activeThreads); - } - - private IRubyObject getSymbolKey(IRubyObject originalKey) { - if (originalKey instanceof RubySymbol) { - return originalKey; - } else if (originalKey instanceof RubyString) { - return getRuntime().newSymbol(originalKey.asJavaString()); - } else if (originalKey instanceof RubyFixnum) { - getRuntime().getWarnings().warn(ID.FIXNUMS_NOT_SYMBOLS, "Do not use Fixnums as Symbols"); - throw getRuntime().newArgumentError(originalKey + " is not a symbol"); - } else { - throw getRuntime().newTypeError(originalKey + " is not a symbol"); - } - } - - private synchronized Map<IRubyObject, IRubyObject> getThreadLocals() { - if (threadLocalVariables == null) { - threadLocalVariables = new HashMap<IRubyObject, IRubyObject>(); - } - return threadLocalVariables; - } - - @JRubyMethod(name = "[]", required = 1) - public IRubyObject op_aref(IRubyObject key) { - IRubyObject value; - if ((value = getThreadLocals().get(getSymbolKey(key))) != null) { - return value; - } - return getRuntime().getNil(); - } - - @JRubyMethod(name = "[]=", required = 2) - public IRubyObject op_aset(IRubyObject key, IRubyObject value) { - key = getSymbolKey(key); - - getThreadLocals().put(key, value); - return value; - } - - @JRubyMethod(name = "abort_on_exception") - public RubyBoolean abort_on_exception() { - return abortOnException ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "abort_on_exception=", required = 1) - public IRubyObject abort_on_exception_set(IRubyObject val) { - abortOnException = val.isTrue(); - return val; - } - - @JRubyMethod(name = "alive?") - public RubyBoolean alive_p() { - return !isDead && threadImpl.isAlive() ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "join", optional = 1, backtrace = true) - public IRubyObject join(IRubyObject[] args) { - long timeoutMillis = Long.MAX_VALUE; - if (args.length > 0) { - if (args.length > 1) { - throw getRuntime().newArgumentError(args.length,1); - } - // MRI behavior: value given in seconds; converted to Float; less - // than or equal to zero returns immediately; returns nil - timeoutMillis = (long)(1000.0D * args[0].convertToFloat().getValue()); - if (timeoutMillis <= 0) { - // TODO: not sure that we should skip calling join() altogether. - // Thread.join() has some implications for Java Memory Model, etc. - if (threadImpl.isAlive()) { - return getRuntime().getNil(); - } else { - return this; - } - } - } - if (isCurrent()) { - throw getRuntime().newThreadError("thread tried to join itself"); - } - try { - if (threadService.getCritical()) { - // If the target thread is sleeping or stopped, wake it - synchronized (stopLock) { - stopLock.notify(); - } - - // interrupt the target thread in case it's blocking or waiting - // WARNING: We no longer interrupt the target thread, since this usually means - // interrupting IO and with NIO that means the channel is no longer usable. - // We either need a new way to handle waking a target thread that's waiting - // on IO, or we need to accept that we can't wake such threads and must wait - // for them to complete their operation. - //threadImpl.interrupt(); - } - - RubyThread currentThread = getRuntime().getCurrentContext().getThread(); - final long timeToWait = Math.min(timeoutMillis, 200); - - // We need this loop in order to be able to "unblock" the - // join call without actually calling interrupt. - long start = System.currentTimeMillis(); - while(true) { - currentThread.pollThreadEvents(); - threadImpl.join(timeToWait); - if (!threadImpl.isAlive()) { - break; - } - if (System.currentTimeMillis() - start > timeoutMillis) { - break; - } - } - } catch (InterruptedException ie) { - ie.printStackTrace(); - assert false : ie; - } catch (ExecutionException ie) { - ie.printStackTrace(); - assert false : ie; - } - - if (exitingException != null) { - throw exitingException; - } - - if (threadImpl.isAlive()) { - return getRuntime().getNil(); - } else { - return this; - } - } - - @JRubyMethod(name = "value") - public IRubyObject value() { - join(new IRubyObject[0]); - synchronized (this) { - return finalResult; - } - } - - @JRubyMethod(name = "group") - public IRubyObject group() { - if (threadGroup == null) { - return getRuntime().getNil(); - } - - return threadGroup; - } - - void setThreadGroup(RubyThreadGroup rubyThreadGroup) { - threadGroup = rubyThreadGroup; - } - - @JRubyMethod(name = "inspect") - @Override - public IRubyObject inspect() { - // FIXME: There's some code duplication here with RubyObject#inspect - StringBuilder part = new StringBuilder(); - String cname = getMetaClass().getRealClass().getName(); - part.append("#<").append(cname).append(":0x"); - part.append(Integer.toHexString(System.identityHashCode(this))); - - if (threadImpl.isAlive()) { - if (isStopped) { - part.append(getRuntime().newString(" sleep")); - } else if (killed) { - part.append(getRuntime().newString(" aborting")); - } else { - part.append(getRuntime().newString(" run")); - } - } else { - part.append(" dead"); - } - - part.append(">"); - return getRuntime().newString(part.toString()); - } - - @JRubyMethod(name = "key?", required = 1) - public RubyBoolean key_p(IRubyObject key) { - key = getSymbolKey(key); - - return getRuntime().newBoolean(getThreadLocals().containsKey(key)); - } - - @JRubyMethod(name = "keys") - public RubyArray keys() { - IRubyObject[] keys = new IRubyObject[getThreadLocals().size()]; - - return RubyArray.newArrayNoCopy(getRuntime(), getThreadLocals().keySet().toArray(keys)); - } - - @JRubyMethod(name = "critical=", required = 1, meta = true) - public static IRubyObject critical_set(IRubyObject receiver, IRubyObject value) { - receiver.getRuntime().getThreadService().setCritical(value.isTrue()); - - return value; - } - - @JRubyMethod(name = "critical", meta = true) - public static IRubyObject critical(IRubyObject receiver) { - return receiver.getRuntime().newBoolean(receiver.getRuntime().getThreadService().getCritical()); - } - - @JRubyMethod(name = "stop", meta = true) - public static IRubyObject stop(IRubyObject receiver) { - RubyThread rubyThread = receiver.getRuntime().getThreadService().getCurrentContext().getThread(); - Object stopLock = rubyThread.stopLock; - - synchronized (stopLock) { - rubyThread.pollThreadEvents(); - try { - rubyThread.isStopped = true; - // attempt to decriticalize all if we're the critical thread - receiver.getRuntime().getThreadService().setCritical(false); - - stopLock.wait(); - } catch (InterruptedException ie) { - rubyThread.pollThreadEvents(); - } - rubyThread.isStopped = false; - } - - return receiver.getRuntime().getNil(); - } - - @JRubyMethod(name = "kill", required = 1, frame = true, meta = true) - public static IRubyObject kill(IRubyObject receiver, IRubyObject rubyThread, Block block) { - if (!(rubyThread instanceof RubyThread)) throw receiver.getRuntime().newTypeError(rubyThread, receiver.getRuntime().getThread()); - return ((RubyThread)rubyThread).kill(); - } - - @JRubyMethod(name = "exit", frame = true, meta = true) - public static IRubyObject s_exit(IRubyObject receiver, Block block) { - RubyThread rubyThread = receiver.getRuntime().getThreadService().getCurrentContext().getThread(); - - rubyThread.killed = true; - // attempt to decriticalize all if we're the critical thread - receiver.getRuntime().getThreadService().setCritical(false); - - throw new ThreadKill(); - } - - @JRubyMethod(name = "stop?") - public RubyBoolean stop_p() { - // not valid for "dead" state - return getRuntime().newBoolean(isStopped); - } - - @JRubyMethod(name = "wakeup") - public RubyThread wakeup() { - synchronized (stopLock) { - stopLock.notifyAll(); - } - - return this; - } - - @JRubyMethod(name = "priority") - public RubyFixnum priority() { - return priority; - } - - @JRubyMethod(name = "priority=", required = 1) - public IRubyObject priority_set(IRubyObject priority) { - // FIXME: This should probably do some translation from Ruby priority levels to Java priority levels (until we have green threads) - int iPriority = RubyNumeric.fix2int(priority); - - if (iPriority < Thread.MIN_PRIORITY) { - iPriority = Thread.MIN_PRIORITY; - } else if (iPriority > Thread.MAX_PRIORITY) { - iPriority = Thread.MAX_PRIORITY; - } - - this.priority = RubyFixnum.newFixnum(getRuntime(), iPriority); - - if (threadImpl.isAlive()) { - threadImpl.setPriority(iPriority); - } - return this.priority; - } - - @JRubyMethod(name = "raise", optional = 2, frame = true) - public IRubyObject raise(IRubyObject[] args, Block block) { - ensureNotCurrent(); - Ruby runtime = getRuntime(); - - if (DEBUG) System.out.println("thread " + Thread.currentThread() + " before raising"); - RubyThread currentThread = getRuntime().getCurrentContext().getThread(); - try { - while (!(currentThread.lock.tryLock() && this.lock.tryLock())) { - if (currentThread.lock.isHeldByCurrentThread()) currentThread.lock.unlock(); - } - - currentThread.pollThreadEvents(); - if (DEBUG) System.out.println("thread " + Thread.currentThread() + " raising"); - receivedException = prepareRaiseException(runtime, args, block); - - // If the target thread is sleeping or stopped, wake it - synchronized (stopLock) { - stopLock.notify(); - } - - // interrupt the target thread in case it's blocking or waiting - // WARNING: We no longer interrupt the target thread, since this usually means - // interrupting IO and with NIO that means the channel is no longer usable. - // We either need a new way to handle waking a target thread that's waiting - // on IO, or we need to accept that we can't wake such threads and must wait - // for them to complete their operation. - //threadImpl.interrupt(); - - // new interrupt, to hopefully wake it out of any blocking IO - this.interrupt(); - } finally { - if (currentThread.lock.isHeldByCurrentThread()) currentThread.lock.unlock(); - if (this.lock.isHeldByCurrentThread()) this.lock.unlock(); - } - - return this; - } - - private IRubyObject prepareRaiseException(Ruby runtime, IRubyObject[] args, Block block) { - if(args.length == 0) { - IRubyObject lastException = runtime.getGlobalVariables().get("$!"); - if(lastException.isNil()) { - return new RaiseException(runtime, runtime.getRuntimeError(), "", false).getException(); - } - return lastException; - } - - IRubyObject exception; - ThreadContext context = getRuntime().getCurrentContext(); - - if(args.length == 1) { - if(args[0] instanceof RubyString) { - return runtime.getRuntimeError().newInstance(context, args, block); - } - - if(!args[0].respondsTo("exception")) { - return runtime.newTypeError("exception class/object expected").getException(); - } - exception = args[0].callMethod(context, "exception"); - } else { - if (!args[0].respondsTo("exception")) { - return runtime.newTypeError("exception class/object expected").getException(); - } - - exception = args[0].callMethod(context, "exception", args[1]); - } - - if (!runtime.getException().isInstance(exception)) { - return runtime.newTypeError("exception object expected").getException(); - } - - if (args.length == 3) { - ((RubyException) exception).set_backtrace(args[2]); - } - - return exception; - } - - @JRubyMethod(name = "run") - public IRubyObject run() { - // if stopped, unstop - synchronized (stopLock) { - if (isStopped) { - isStopped = false; - stopLock.notifyAll(); - } - } - - return this; - } - - public void sleep(long millis) throws InterruptedException { - assert this == getRuntime().getCurrentContext().getThread(); - synchronized (stopLock) { - pollThreadEvents(); - try { - isStopped = true; - stopLock.wait(millis); - } finally { - isStopped = false; - pollThreadEvents(); - } - } - } - - @JRubyMethod(name = "status") - public IRubyObject status() { - if (threadImpl.isAlive()) { - if (isStopped || currentSelector != null && currentSelector.isOpen()) { - return getRuntime().newString("sleep"); - } else if (killed) { - return getRuntime().newString("aborting"); - } - - return getRuntime().newString("run"); - } else if (exitingException != null) { - return getRuntime().getNil(); - } else { - return getRuntime().getFalse(); - } - } - - @JRubyMethod(name = {"kill", "exit", "terminate"}) - public IRubyObject kill() { - // need to reexamine this - RubyThread currentThread = getRuntime().getCurrentContext().getThread(); - - // If the killee thread is the same as the killer thread, just die - if (currentThread == this) throwThreadKill(); - - try { - if (DEBUG) System.out.println("thread " + Thread.currentThread() + " trying to kill"); - while (!(currentThread.lock.tryLock() && this.lock.tryLock())) { - if (currentThread.lock.isHeldByCurrentThread()) currentThread.lock.unlock(); - } - - currentThread.pollThreadEvents(); - - if (DEBUG) System.out.println("thread " + Thread.currentThread() + " succeeded with kill"); - killed = true; - - // If the target thread is sleeping or stopped, wake it - synchronized (stopLock) { - stopLock.notify(); - } - - // interrupt the target thread in case it's blocking or waiting - // WARNING: We no longer interrupt the target thread, since this usually means - // interrupting IO and with NIO that means the channel is no longer usable. - // We either need a new way to handle waking a target thread that's waiting - // on IO, or we need to accept that we can't wake such threads and must wait - // for them to complete their operation. - //threadImpl.interrupt(); - - // new interrupt, to hopefully wake it out of any blocking IO - this.interrupt(); - } finally { - if (currentThread.lock.isHeldByCurrentThread()) currentThread.lock.unlock(); - if (this.lock.isHeldByCurrentThread()) this.lock.unlock(); - } - - try { - threadImpl.join(); - } catch (InterruptedException ie) { - // we were interrupted, check thread events again - currentThread.pollThreadEvents(); - } catch (ExecutionException ie) { - // we were interrupted, check thread events again - currentThread.pollThreadEvents(); - } - - return this; - } - - @JRubyMethod(name = {"kill!", "exit!", "terminate!"}) - public IRubyObject kill_bang() { - throw getRuntime().newNotImplementedError("Thread#kill!, exit!, and terminate! are not safe and not supported"); - } - - @JRubyMethod(name = "safe_level") - public IRubyObject safe_level() { - throw getRuntime().newNotImplementedError("Thread-specific SAFE levels are not supported"); - } - - private boolean isCurrent() { - return threadImpl.isCurrent(); - } - - public void exceptionRaised(RaiseException exception) { - assert isCurrent(); - - RubyException rubyException = exception.getException(); - Ruby runtime = rubyException.getRuntime(); - if (runtime.getSystemExit().isInstance(rubyException)) { - threadService.getMainThread().raise(new IRubyObject[] {rubyException}, Block.NULL_BLOCK); - } else if (abortOnException(runtime)) { - runtime.printError(rubyException); - RubyException systemExit = RubySystemExit.newInstance(runtime, 1); - systemExit.message = rubyException.message; - systemExit.set_backtrace(rubyException.backtrace()); - threadService.getMainThread().raise(new IRubyObject[] {systemExit}, Block.NULL_BLOCK); - return; - } else if (runtime.getDebug().isTrue()) { - runtime.printError(exception.getException()); - } - exitingException = exception; - } - - private boolean abortOnException(Ruby runtime) { - return (runtime.isGlobalAbortOnExceptionEnabled() || abortOnException); - } - - public static RubyThread mainThread(IRubyObject receiver) { - return receiver.getRuntime().getThreadService().getMainThread(); - } - - private Selector currentSelector; - - @Deprecated - public boolean selectForAccept(RubyIO io) { - return select(io, SelectionKey.OP_ACCEPT); - } - - public boolean select(RubyIO io, int ops) { - Channel channel = io.getChannel(); - - if (channel instanceof SelectableChannel) { - SelectableChannel selectable = (SelectableChannel)channel; - - synchronized (selectable.blockingLock()) { - boolean oldBlocking = selectable.isBlocking(); - - try { - selectable.configureBlocking(false); - - io.addBlockingThread(this); - currentSelector = selectable.provider().openSelector(); - - SelectionKey key = selectable.register(currentSelector, ops); - - int result = currentSelector.select(); - - // check for thread events, in case we've been woken up to die - pollThreadEvents(); - - if (result == 1) { - Set<SelectionKey> keySet = currentSelector.selectedKeys(); - - if (keySet.iterator().next() == key) { - return true; - } - } - - return false; - } catch (IOException ioe) { - throw io.getRuntime().newRuntimeError("Error with selector: " + ioe); - } finally { - if (currentSelector != null) { - try { - currentSelector.close(); - } catch (IOException ioe) { - throw io.getRuntime().newRuntimeError("Could not close selector"); - } - } - currentSelector = null; - io.removeBlockingThread(this); - try { - selectable.configureBlocking(oldBlocking); - } catch (IOException ioe) { - // ignore; I don't like doing it, but it seems like we - // really just need to make all channels non-blocking by - // default and use select when implementing blocking ops, - // so if this remains set non-blocking, perhaps it's not - // such a big deal... - } - } - } - } else { - // can't select, just have to do a blocking call - return true; - } - } - - public void interrupt() { - if (currentSelector != null) { - currentSelector.wakeup(); - } - } - - public void beforeBlockingCall() { - isStopped = true; - } - - public void afterBlockingCall() { - isStopped = false; - } - - private void receivedAnException(ThreadContext context) { - // clear this so we don't keep re-throwing - IRubyObject raiseException = receivedException; - receivedException = null; - RubyModule kernelModule = getRuntime().getKernel(); - if (DEBUG) { - System.out.println("thread " + Thread.currentThread() + " before propagating exception: " + killed); - } - kernelModule.callMethod(context, "raise", raiseException); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.util.HashMap; -import java.util.Map; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; - -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * Implementation of Ruby's <code>ThreadGroup</code> class. This is currently - * just a stub. - * <p> - * - * @author Charles O Nutter (headius@headius.com) - */ -@JRubyClass(name="ThreadGroup") -public class RubyThreadGroup extends RubyObject { - private Map<Integer, IRubyObject> rubyThreadList = new HashMap<Integer, IRubyObject>(); - private boolean enclosed = false; - - // ENEBO: Can these be fast? - public static RubyClass createThreadGroupClass(Ruby runtime) { - RubyClass threadGroupClass = runtime.defineClass("ThreadGroup", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setThreadGroup(threadGroupClass); - - threadGroupClass.defineAnnotatedMethods(RubyThreadGroup.class); - - // create the default thread group - RubyThreadGroup defaultThreadGroup = new RubyThreadGroup(runtime, threadGroupClass); - runtime.setDefaultThreadGroup(defaultThreadGroup); - threadGroupClass.defineConstant("Default", defaultThreadGroup); - - return threadGroupClass; - } - - @JRubyMethod(name = "new", frame = true, meta = true) - public static IRubyObject newInstance(IRubyObject recv, Block block) { - return new RubyThreadGroup(recv.getRuntime(), (RubyClass)recv); - } - - @JRubyMethod(name = "add", required = 1, frame = true) - public synchronized IRubyObject add(IRubyObject rubyThread, Block block) { - if (!(rubyThread instanceof RubyThread)) throw getRuntime().newTypeError(rubyThread, getRuntime().getThread()); - - // synchronize on the RubyThread for threadgroup updates - if (isFrozen()) { - throw getRuntime().newTypeError("can't add to frozen ThreadGroup"); - } - - RubyThread thread = (RubyThread)rubyThread; - - // we only add live threads - if (thread.alive_p().isTrue()) { - addDirectly(thread); - } - - return this; - } - - void addDirectly(RubyThread rubyThread) { - synchronized (rubyThread) { - IRubyObject oldGroup = rubyThread.group(); - if (oldGroup != getRuntime().getNil()) { - RubyThreadGroup threadGroup = (RubyThreadGroup) oldGroup; - threadGroup.rubyThreadList.remove(System.identityHashCode(rubyThread)); - } - - rubyThread.setThreadGroup(this); - rubyThreadList.put(System.identityHashCode(rubyThread), rubyThread); - } - } - - public synchronized void remove(RubyThread rubyThread) { - rubyThread.setThreadGroup(null); - rubyThreadList.remove(System.identityHashCode(rubyThread)); - } - - @JRubyMethod(name = "enclose", frame = true) - public IRubyObject enclose(Block block) { - enclosed = true; - - return this; - } - - @JRubyMethod(name = "enclosed?", frame = true) - public IRubyObject enclosed_p(Block block) { - return new RubyBoolean(getRuntime(), enclosed); - } - - @JRubyMethod(name = "list", frame = true) - public synchronized IRubyObject list(Block block) { - return getRuntime().newArrayNoCopy((IRubyObject[]) rubyThreadList.values().toArray(new IRubyObject[rubyThreadList.size()])); - } - - private RubyThreadGroup(Ruby runtime, RubyClass type) { - super(runtime, type); - } - -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2001 Chad Fowler <chadfowler@chadfowler.com> - * Copyright (C) 2001-2004 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002 Benoit Cerrina <b.cerrina@wanadoo.fr> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Joey Gibson <joey@joeygibson.com> - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * Copyright (C) 2006 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2006 Ola Bini <ola.bini@ki.se> - * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.lang.ref.SoftReference; -import java.util.Date; -import java.util.HashMap; -import java.util.Locale; -import java.util.Map; -import java.util.TimeZone; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import org.joda.time.DateTime; -import org.joda.time.DateTimeZone; -import org.joda.time.format.DateTimeFormat; -import org.joda.time.format.DateTimeFormatter; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyMethod; -import org.jruby.runtime.Block; -import org.jruby.runtime.ClassIndex; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.util.ByteList; -import org.jruby.util.RubyDateFormat; - -/** The Time class. - * - * @author chadfowler, jpetersen - */ -@JRubyClass(name="Time", include="Comparable") -public class RubyTime extends RubyObject { - public static final String UTC = "UTC"; - private DateTime dt; - private long usec; - - private final static DateTimeFormatter ONE_DAY_CTIME_FORMATTER = DateTimeFormat.forPattern("EEE MMM d HH:mm:ss yyyy").withLocale(Locale.ENGLISH); - private final static DateTimeFormatter TWO_DAY_CTIME_FORMATTER = DateTimeFormat.forPattern("EEE MMM dd HH:mm:ss yyyy").withLocale(Locale.ENGLISH); - - private final static DateTimeFormatter TO_S_FORMATTER = DateTimeFormat.forPattern("EEE MMM dd HH:mm:ss Z yyyy").withLocale(Locale.ENGLISH); - private final static DateTimeFormatter TO_S_UTC_FORMATTER = DateTimeFormat.forPattern("EEE MMM dd HH:mm:ss 'UTC' yyyy").withLocale(Locale.ENGLISH); - - // There are two different popular TZ formats: legacy (AST+3:00:00, GMT-3), and - // newer one (US/Pacific, America/Los_Angeles). This pattern is to detect - // the legacy TZ format in order to convert it to the newer format - // understood by Java API. - private static final Pattern TZ_PATTERN - = Pattern.compile("(\\D+?)([\\+-]?)(\\d+)(:\\d+)?(:\\d+)?"); - - private static final ByteList TZ_STRING = ByteList.create("TZ"); - - public static DateTimeZone getLocalTimeZone(Ruby runtime) { - RubyString tzVar = runtime.newString(TZ_STRING); - RubyHash h = ((RubyHash)runtime.getObject().fastGetConstant("ENV")); - IRubyObject tz = h.op_aref(runtime.getCurrentContext(), tzVar); - if (tz == null || ! (tz instanceof RubyString)) { - return DateTimeZone.getDefault(); - } else { - String zone = tz.toString(); - DateTimeZone cachedZone = runtime.getLocalTimezoneCache().get(zone); - - if (cachedZone != null) return cachedZone; - - String originalZone = zone; - - // Value of "TZ" property is of a bit different format, - // which confuses the Java's TimeZone.getTimeZone(id) method, - // and so, we need to convert it. - - Matcher tzMatcher = TZ_PATTERN.matcher(zone); - if (tzMatcher.matches()) { - String sign = tzMatcher.group(2); - String hours = tzMatcher.group(3); - String minutes = tzMatcher.group(4); - - // GMT+00:00 --> Etc/GMT, see "MRI behavior" - // comment below. - if (("00".equals(hours) || "0".equals(hours)) - && (minutes == null || ":00".equals(minutes) || ":0".equals(minutes))) { - zone = "Etc/GMT"; - } else { - // Invert the sign, since TZ format and Java format - // use opposite signs, sigh... Also, Java API requires - // the sign to be always present, be it "+" or "-". - sign = ("-".equals(sign)? "+" : "-"); - - // Always use "GMT" since that's required by Java API. - zone = "GMT" + sign + hours; - - if (minutes != null) { - zone += minutes; - } - } - } - - // MRI behavior: With TZ equal to "GMT" or "UTC", Time.now - // is *NOT* considered as a proper GMT/UTC time: - // ENV['TZ']="GMT" - // Time.now.gmt? ==> false - // ENV['TZ']="UTC" - // Time.now.utc? ==> false - // Hence, we need to adjust for that. - if ("GMT".equalsIgnoreCase(zone) || "UTC".equalsIgnoreCase(zone)) { - zone = "Etc/" + zone; - } - - DateTimeZone dtz = DateTimeZone.forTimeZone(TimeZone.getTimeZone(zone)); - runtime.getLocalTimezoneCache().put(originalZone, dtz); - return dtz; - } - } - - public RubyTime(Ruby runtime, RubyClass rubyClass) { - super(runtime, rubyClass); - } - - public RubyTime(Ruby runtime, RubyClass rubyClass, DateTime dt) { - super(runtime, rubyClass); - this.dt = dt; - } - - // We assume that these two time instances - // occurred at the same time. - private static final long BASE_TIME_MILLIS = System.currentTimeMillis(); - private static final long BASE_TIME_NANOS = System.nanoTime(); - - private static ObjectAllocator TIME_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - long usecsPassed = (System.nanoTime() - BASE_TIME_NANOS) / 1000L; - long millisTime = BASE_TIME_MILLIS + usecsPassed / 1000L; - long usecs = usecsPassed % 1000L; - - DateTimeZone dtz = getLocalTimeZone(runtime); - DateTime dt = new DateTime(millisTime, dtz); - RubyTime rt = new RubyTime(runtime, klass, dt); - rt.setUSec(usecs); - - return rt; - } - }; - - public static RubyClass createTimeClass(Ruby runtime) { - RubyClass timeClass = runtime.defineClass("Time", runtime.getObject(), TIME_ALLOCATOR); - timeClass.index = ClassIndex.TIME; - runtime.setTime(timeClass); - - timeClass.includeModule(runtime.getComparable()); - - timeClass.defineAnnotatedMethods(RubyTime.class); - - return timeClass; - } - - public void setUSec(long usec) { - this.usec = usec; - } - - public long getUSec() { - return usec; - } - - public void updateCal(DateTime dt) { - this.dt = dt; - } - - protected long getTimeInMillis() { - return dt.getMillis(); // For JDK 1.4 we can use "cal.getTimeInMillis()" - } - - public static RubyTime newTime(Ruby runtime, long milliseconds) { - return newTime(runtime, new DateTime(milliseconds)); - } - - public static RubyTime newTime(Ruby runtime, DateTime dt) { - return new RubyTime(runtime, runtime.getTime(), dt); - } - - public static RubyTime newTime(Ruby runtime, DateTime dt, long usec) { - RubyTime t = new RubyTime(runtime, runtime.getTime(), dt); - t.setUSec(usec); - return t; - } - - @Override - public Class<?> getJavaClass() { - return Date.class; - } - - @JRubyMethod(name = "initialize_copy", required = 1) - @Override - public IRubyObject initialize_copy(IRubyObject original) { - if (!(original instanceof RubyTime)) { - throw getRuntime().newTypeError("Expecting an instance of class Time"); - } - - RubyTime originalTime = (RubyTime) original; - - // We can just use dt, since it is immutable - dt = originalTime.dt; - usec = originalTime.usec; - - return this; - } - - @JRubyMethod(name = "succ") - public RubyTime succ() { - return newTime(getRuntime(),dt.plusSeconds(1)); - } - - @JRubyMethod(name = {"gmtime", "utc"}) - public RubyTime gmtime() { - dt = dt.withZone(DateTimeZone.UTC); - return this; - } - - @JRubyMethod(name = "localtime") - public RubyTime localtime() { - dt = dt.withZone(getLocalTimeZone(getRuntime())); - return this; - } - - @JRubyMethod(name = {"gmt?", "utc?", "gmtime?"}) - public RubyBoolean gmt() { - return getRuntime().newBoolean(dt.getZone().getID().equals("UTC")); - } - - @JRubyMethod(name = {"getgm", "getutc"}) - public RubyTime getgm() { - return newTime(getRuntime(), dt.withZone(DateTimeZone.UTC), getUSec()); - } - - @JRubyMethod(name = "getlocal") - public RubyTime getlocal() { - return newTime(getRuntime(), dt.withZone(getLocalTimeZone(getRuntime())), getUSec()); - } - - @JRubyMethod(name = "strftime", required = 1) - public RubyString strftime(IRubyObject format) { - final RubyDateFormat rubyDateFormat = new RubyDateFormat("-", Locale.US); - rubyDateFormat.applyPattern(format.toString()); - rubyDateFormat.setDateTime(dt); - String result = rubyDateFormat.format(null); - return getRuntime().newString(result); - } - - @JRubyMethod(name = ">=", required = 1) - public IRubyObject op_ge(ThreadContext context, IRubyObject other) { - if (other instanceof RubyTime) { - return getRuntime().newBoolean(cmp((RubyTime) other) >= 0); - } - - return RubyComparable.op_ge(context, this, other); - } - - @JRubyMethod(name = ">", required = 1) - public IRubyObject op_gt(ThreadContext context, IRubyObject other) { - if (other instanceof RubyTime) { - return getRuntime().newBoolean(cmp((RubyTime) other) > 0); - } - - return RubyComparable.op_gt(context, this, other); - } - - @JRubyMethod(name = "<=", required = 1) - public IRubyObject op_le(ThreadContext context, IRubyObject other) { - if (other instanceof RubyTime) { - return getRuntime().newBoolean(cmp((RubyTime) other) <= 0); - } - - return RubyComparable.op_le(context, this, other); - } - - @JRubyMethod(name = "<", required = 1) - public IRubyObject op_lt(ThreadContext context, IRubyObject other) { - if (other instanceof RubyTime) { - return getRuntime().newBoolean(cmp((RubyTime) other) < 0); - } - - return RubyComparable.op_lt(context, this, other); - } - - private int cmp(RubyTime other) { - long millis = getTimeInMillis(); - long millis_other = other.getTimeInMillis(); - long usec_other = other.usec; - - if (millis > millis_other || (millis == millis_other && usec > usec_other)) { - return 1; - } else if (millis < millis_other || (millis == millis_other && usec < usec_other)) { - return -1; - } - - return 0; - } - - @JRubyMethod(name = "+", required = 1) - public IRubyObject op_plus(IRubyObject other) { - long time = getTimeInMillis(); - - if (other instanceof RubyTime) { - throw getRuntime().newTypeError("time + time ?"); - } - long adjustment = (long) (RubyNumeric.num2dbl(other) * 1000000); - int micro = (int) (adjustment % 1000); - adjustment = adjustment / 1000; - - time += adjustment; - - RubyTime newTime = new RubyTime(getRuntime(), getMetaClass()); - newTime.dt = new DateTime(time).withZone(dt.getZone()); - newTime.setUSec(micro); - - return newTime; - } - - private IRubyObject opMinus(RubyTime other) { - long time = getTimeInMillis() * 1000 + getUSec(); - - time -= other.getTimeInMillis() * 1000 + other.getUSec(); - - return RubyFloat.newFloat(getRuntime(), time / 1000000.0); // float number of seconds - } - - @JRubyMethod(name = "-", required = 1) - public IRubyObject op_minus(IRubyObject other) { - if (other instanceof RubyTime) return opMinus((RubyTime) other); - - long time = getTimeInMillis(); - long adjustment = (long) (RubyNumeric.num2dbl(other) * 1000000); - int micro = (int) (adjustment % 1000); - adjustment = adjustment / 1000; - - time -= adjustment; - - RubyTime newTime = new RubyTime(getRuntime(), getMetaClass()); - newTime.dt = new DateTime(time).withZone(dt.getZone()); - newTime.setUSec(micro); - - return newTime; - } - - @JRubyMethod(name = "===", required = 1) - @Override - public IRubyObject op_eqq(ThreadContext context, IRubyObject other) { - return (RubyNumeric.fix2int(callMethod(context, MethodIndex.OP_SPACESHIP, "<=>", other)) == 0) ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "<=>", required = 1) - public IRubyObject op_cmp(ThreadContext context, IRubyObject other) { - if (other instanceof RubyTime) { - return context.getRuntime().newFixnum(cmp((RubyTime) other)); - } - - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "eql?", required = 1) - @Override - public IRubyObject eql_p(IRubyObject other) { - if (other instanceof RubyTime) { - RubyTime otherTime = (RubyTime)other; - return (usec == otherTime.usec && getTimeInMillis() == otherTime.getTimeInMillis()) ? getRuntime().getTrue() : getRuntime().getFalse(); - } - return getRuntime().getFalse(); - } - - @JRubyMethod(name = {"asctime", "ctime"}) - public RubyString asctime() { - DateTimeFormatter simpleDateFormat; - - if (dt.getDayOfMonth() < 10) { - simpleDateFormat = ONE_DAY_CTIME_FORMATTER; - } else { - simpleDateFormat = TWO_DAY_CTIME_FORMATTER; - } - String result = simpleDateFormat.print(dt); - return getRuntime().newString(result); - } - - @JRubyMethod(name = {"to_s", "inspect"}) - @Override - public IRubyObject to_s() { - DateTimeFormatter simpleDateFormat; - if (dt.getZone() == DateTimeZone.UTC) { - simpleDateFormat = TO_S_UTC_FORMATTER; - } else { - simpleDateFormat = TO_S_FORMATTER; - } - - String result = simpleDateFormat.print(dt); - - return getRuntime().newString(result); - } - - @JRubyMethod(name = "to_a") - @Override - public RubyArray to_a() { - return getRuntime().newArrayNoCopy(new IRubyObject[] { sec(), min(), hour(), mday(), month(), - year(), wday(), yday(), isdst(), zone() }); - } - - @JRubyMethod(name = "to_f") - public RubyFloat to_f() { - long time = getTimeInMillis(); - time = time * 1000 + usec; - return RubyFloat.newFloat(getRuntime(), time / 1000000.0); - } - - @JRubyMethod(name = {"to_i", "tv_sec"}) - public RubyInteger to_i() { - return getRuntime().newFixnum(getTimeInMillis() / 1000); - } - - @JRubyMethod(name = {"usec", "tv_usec"}) - public RubyInteger usec() { - return getRuntime().newFixnum(dt.getMillisOfSecond() * 1000 + getUSec()); - } - - public void setMicroseconds(long mic) { - long millis = getTimeInMillis() % 1000; - long withoutMillis = getTimeInMillis() - millis; - withoutMillis += (mic / 1000); - dt = dt.withMillis(withoutMillis); - usec = mic % 1000; - } - - public long microseconds() { - return getTimeInMillis() % 1000 * 1000 + usec; - } - - @JRubyMethod(name = "sec") - public RubyInteger sec() { - return getRuntime().newFixnum(dt.getSecondOfMinute()); - } - - @JRubyMethod(name = "min") - public RubyInteger min() { - return getRuntime().newFixnum(dt.getMinuteOfHour()); - } - - @JRubyMethod(name = "hour") - public RubyInteger hour() { - return getRuntime().newFixnum(dt.getHourOfDay()); - } - - @JRubyMethod(name = {"mday", "day"}) - public RubyInteger mday() { - return getRuntime().newFixnum(dt.getDayOfMonth()); - } - - @JRubyMethod(name = {"month", "mon"}) - public RubyInteger month() { - return getRuntime().newFixnum(dt.getMonthOfYear()); - } - - @JRubyMethod(name = "year") - public RubyInteger year() { - return getRuntime().newFixnum(dt.getYear()); - } - - @JRubyMethod(name = "wday") - public RubyInteger wday() { - return getRuntime().newFixnum((dt.getDayOfWeek()%7)); - } - - @JRubyMethod(name = "yday") - public RubyInteger yday() { - return getRuntime().newFixnum(dt.getDayOfYear()); - } - - @JRubyMethod(name = {"gmt_offset", "gmtoff", "utc_offset"}) - public RubyInteger gmt_offset() { - int offset = dt.getZone().getOffsetFromLocal(dt.getMillis()); - - return getRuntime().newFixnum((int)(offset/1000)); - } - - @JRubyMethod(name = {"isdst", "dst?"}) - public RubyBoolean isdst() { - return getRuntime().newBoolean(!dt.getZone().isStandardOffset(dt.getMillis())); - } - - @JRubyMethod(name = "zone") - public RubyString zone() { - String zone = dt.getZone().getShortName(dt.getMillis()); - if(zone.equals("+00:00")) { - zone = "GMT"; - } - return getRuntime().newString(zone); - } - - public void setDateTime(DateTime dt) { - this.dt = dt; - } - - public DateTime getDateTime() { - return this.dt; - } - - public Date getJavaDate() { - return this.dt.toDate(); - } - - @JRubyMethod(name = "hash") - @Override - public RubyFixnum hash() { - // modified to match how hash is calculated in 1.8.2 - return getRuntime().newFixnum((int)(((dt.getMillis() / 1000) ^ microseconds()) << 1) >> 1); - } - - @JRubyMethod(name = "_dump", optional = 1, frame = true) - public RubyString dump(IRubyObject[] args, Block unusedBlock) { - RubyString str = (RubyString) mdump(new IRubyObject[] { this }); - str.syncVariables(this.getVariableList()); - return str; - } - - public RubyObject mdump(final IRubyObject[] args) { - RubyTime obj = (RubyTime)args[0]; - DateTime dateTime = obj.dt.withZone(DateTimeZone.UTC); - byte dumpValue[] = new byte[8]; - int pe = - 0x1 << 31 | - (dateTime.getYear()-1900) << 14 | - (dateTime.getMonthOfYear()-1) << 10 | - dateTime.getDayOfMonth() << 5 | - dateTime.getHourOfDay(); - int se = - dateTime.getMinuteOfHour() << 26 | - dateTime.getSecondOfMinute() << 20 | - (dateTime.getMillisOfSecond() * 1000 + (int)usec); // dump usec, not msec - - for(int i = 0; i < 4; i++) { - dumpValue[i] = (byte)(pe & 0xFF); - pe >>>= 8; - } - for(int i = 4; i < 8 ;i++) { - dumpValue[i] = (byte)(se & 0xFF); - se >>>= 8; - } - return RubyString.newString(obj.getRuntime(), new ByteList(dumpValue,false)); - } - - @JRubyMethod(name = "initialize", frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(Block block) { - return this; - } - - /* Time class methods */ - - public static IRubyObject s_new(IRubyObject recv, IRubyObject[] args, Block block) { - Ruby runtime = recv.getRuntime(); - RubyTime time = new RubyTime(runtime, (RubyClass) recv, new DateTime(getLocalTimeZone(runtime))); - time.callInit(args,block); - return time; - } - - /** - * @deprecated Use {@link #newInstance(ThreadContext, IRubyObject)} - */ - @Deprecated - public static IRubyObject newInstance(ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) { - return newInstance(context, recv); - } - - @JRubyMethod(name = "now", backtrace = true, meta = true) - public static IRubyObject newInstance(ThreadContext context, IRubyObject recv) { - IRubyObject obj = ((RubyClass) recv).allocate(); - obj.getMetaClass().getBaseCallSites()[RubyClass.CS_IDX_INITIALIZE].call(context, obj); - return obj; - } - - @JRubyMethod(name = "at", meta = true) - public static IRubyObject at(ThreadContext context, IRubyObject recv, IRubyObject arg) { - Ruby runtime = context.getRuntime(); - final RubyTime time; - - if (arg instanceof RubyTime) { - RubyTime other = (RubyTime) arg; - time = new RubyTime(runtime, (RubyClass) recv, other.dt); - time.setUSec(other.getUSec()); - } else { - time = new RubyTime(runtime, (RubyClass) recv, - new DateTime(0L, getLocalTimeZone(runtime))); - - long seconds = RubyNumeric.num2long(arg); - long millisecs = 0; - long microsecs = 0; - - // In the case of two arguments, MRI will discard the portion of - // the first argument after a decimal point (i.e., "floor"). - // However in the case of a single argument, any portion after - // the decimal point is honored. - if (arg instanceof RubyFloat) { - double dbl = ((RubyFloat) arg).getDoubleValue(); - long micro = (long) ((dbl - seconds) * 1000000); - millisecs = micro / 1000; - microsecs = micro % 1000; - } - time.setUSec(microsecs); - time.dt = time.dt.withMillis(seconds * 1000 + millisecs); - } - - time.getMetaClass().getBaseCallSites()[RubyClass.CS_IDX_INITIALIZE].call(context, time); - - return time; - } - - @JRubyMethod(name = "at", meta = true) - public static IRubyObject at(ThreadContext context, IRubyObject recv, IRubyObject arg1, IRubyObject arg2) { - Ruby runtime = context.getRuntime(); - - RubyTime time = new RubyTime(runtime, (RubyClass) recv, - new DateTime(0L, getLocalTimeZone(runtime))); - - long seconds = RubyNumeric.num2long(arg1); - long millisecs = 0; - long microsecs = 0; - - long tmp = RubyNumeric.num2long(arg2); - millisecs = tmp / 1000; - microsecs = tmp % 1000; - - time.setUSec(microsecs); - time.dt = time.dt.withMillis(seconds * 1000 + millisecs); - - time.getMetaClass().getBaseCallSites()[RubyClass.CS_IDX_INITIALIZE].call(context, time); - - return time; - } - - @JRubyMethod(name = {"local", "mktime"}, required = 1, optional = 9, meta = true) - public static RubyTime new_local(IRubyObject recv, IRubyObject[] args) { - return createTime(recv, args, false); - } - - @JRubyMethod(name = {"utc", "gm"}, required = 1, optional = 9, meta = true) - public static RubyTime new_utc(IRubyObject recv, IRubyObject[] args) { - return createTime(recv, args, true); - } - - @JRubyMethod(name = "_load", required = 1, frame = true, meta = true) - public static RubyTime load(IRubyObject recv, IRubyObject from, Block block) { - return s_mload(recv, (RubyTime)(((RubyClass)recv).allocate()), from); - } - - protected static RubyTime s_mload(IRubyObject recv, RubyTime time, IRubyObject from) { - Ruby runtime = recv.getRuntime(); - - DateTime dt = new DateTime(DateTimeZone.UTC); - - byte[] fromAsBytes = null; - fromAsBytes = from.convertToString().getBytes(); - if(fromAsBytes.length != 8) { - throw runtime.newTypeError("marshaled time format differ"); - } - int p=0; - int s=0; - for (int i = 0; i < 4; i++) { - p |= ((int)fromAsBytes[i] & 0xFF) << (8 * i); - } - for (int i = 4; i < 8; i++) { - s |= ((int)fromAsBytes[i] & 0xFF) << (8 * (i - 4)); - } - if ((p & (1<<31)) == 0) { - dt = dt.withMillis(p * 1000L + s); - } else { - p &= ~(1<<31); - dt = dt.withYear(((p >>> 14) & 0xFFFF) + 1900); - dt = dt.withMonthOfYear(((p >>> 10) & 0xF) + 1); - dt = dt.withDayOfMonth(((p >>> 5) & 0x1F)); - dt = dt.withHourOfDay((p & 0x1F)); - dt = dt.withMinuteOfHour(((s >>> 26) & 0x3F)); - dt = dt.withSecondOfMinute(((s >>> 20) & 0x3F)); - // marsaling dumps usec, not msec - dt = dt.withMillisOfSecond((s & 0xFFFFF) / 1000); - dt = dt.withZone(getLocalTimeZone(runtime)); - time.setUSec((s & 0xFFFFF) % 1000); - } - time.setDateTime(dt); - return time; - } - - private static final String[] MONTHS = {"jan", "feb", "mar", "apr", "may", "jun", - "jul", "aug", "sep", "oct", "nov", "dec"}; - - private static final Map<String, Integer> MONTHS_MAP = new HashMap<String, Integer>(); - static { - for (int i = 0; i < MONTHS.length; i++) { - MONTHS_MAP.put(MONTHS[i], i + 1); - } - } - - private static final int[] time_min = {1, 0, 0, 0, Integer.MIN_VALUE}; - private static final int[] time_max = {31, 23, 59, 60, Integer.MAX_VALUE}; - - private static final int ARG_SIZE = 7; - - private static RubyTime createTime(IRubyObject recv, IRubyObject[] args, boolean gmt) { - Ruby runtime = recv.getRuntime(); - int len = ARG_SIZE; - - if (args.length == 10) { - args = new IRubyObject[] { args[5], args[4], args[3], args[2], args[1], args[0], runtime.getNil() }; - } else { - // MRI accepts additional wday argument which appears to be ignored. - len = args.length; - - if (len < ARG_SIZE) { - IRubyObject[] newArgs = new IRubyObject[ARG_SIZE]; - System.arraycopy(args, 0, newArgs, 0, args.length); - for (int i = len; i < ARG_SIZE; i++) { - newArgs[i] = runtime.getNil(); - } - args = newArgs; - len = ARG_SIZE; - } - } - - if (args[0] instanceof RubyString) { - args[0] = RubyNumeric.str2inum(runtime, (RubyString) args[0], 10, false); - } - - int year = (int) RubyNumeric.num2long(args[0]); - int month = 1; - - if (len > 1) { - if (!args[1].isNil()) { - IRubyObject tmp = args[1].checkStringType(); - if (!tmp.isNil()) { - String monthString = tmp.toString().toLowerCase(); - Integer monthInt = MONTHS_MAP.get(monthString); - - if (monthInt != null) { - month = monthInt; - } else { - try { - month = Integer.parseInt(monthString); - } catch (NumberFormatException nfExcptn) { - throw runtime.newArgumentError("Argument out of range."); - } - } - } else { - month = (int) RubyNumeric.num2long(args[1]); - } - } - if (1 > month || month > 12) { - throw runtime.newArgumentError("Argument out of range: for month: " + month); - } - } - - int[] int_args = { 1, 0, 0, 0, 0, 0 }; - - for (int i = 0; int_args.length >= i + 2; i++) { - if (!args[i + 2].isNil()) { - if (!(args[i + 2] instanceof RubyNumeric)) { - args[i + 2] = args[i + 2].callMethod( - runtime.getCurrentContext(), "to_i"); - } - - long value = RubyNumeric.num2long(args[i + 2]); - if (time_min[i] > value || value > time_max[i]) { - throw runtime.newArgumentError("argument out of range."); - } - int_args[i] = (int) value; - } - } - - if (0 <= year && year < 39) { - year += 2000; - } else if (69 <= year && year < 139) { - year += 1900; - } - - DateTimeZone dtz; - if (gmt) { - dtz = DateTimeZone.UTC; - } else { - dtz = getLocalTimeZone(runtime); - } - - DateTime dt; - // set up with min values and then add to allow rolling over - try { - dt = new DateTime(year, 1, 1, 0, 0 , 0, 0, dtz); - - dt = dt.plusMonths(month - 1) - .plusDays(int_args[0] - 1) - .plusHours(int_args[1]) - .plusMinutes(int_args[2]) - .plusSeconds(int_args[3]); - } catch (org.joda.time.IllegalFieldValueException e) { - throw runtime.newArgumentError("time out of range"); - } - - RubyTime time = new RubyTime(runtime, (RubyClass) recv, dt); - // Ignores usec if 8 args (for compatibility with parsedate) or if not supplied. - if (args.length != 8 && !args[6].isNil()) { - int usec = int_args[4] % 1000; - int msec = int_args[4] / 1000; - - if (int_args[4] < 0) { - msec -= 1; - usec += 1000; - } - time.dt = dt.withMillis(dt.getMillis() + msec); - time.setUSec(usec); - } - - time.callInit(IRubyObject.NULL_ARRAY, Block.NULL_BLOCK); - return time; - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2004 Charles O Nutter <headius@headius.com> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.internal.runtime.methods.DynamicMethod; -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -/** - * - * Note: This was renamed from UnboundMethod.java - * - * @author jpetersen - */ -@JRubyClass(name="UnboundMethod", parent="Method") -public class RubyUnboundMethod extends RubyMethod { - protected RubyUnboundMethod(Ruby runtime) { - super(runtime, runtime.getUnboundMethod()); - } - - public static RubyUnboundMethod newUnboundMethod( - RubyModule implementationModule, - String methodName, - RubyModule originModule, - String originName, - DynamicMethod method) { - RubyUnboundMethod newMethod = new RubyUnboundMethod(implementationModule.getRuntime()); - - newMethod.implementationModule = implementationModule; - newMethod.methodName = methodName; - newMethod.originModule = originModule; - newMethod.originName = originName; - newMethod.method = method; - - return newMethod; - } - - public static RubyClass defineUnboundMethodClass(Ruby runtime) { - // TODO: NOT_ALLOCATABLE_ALLOCATOR is probably ok here. Confirm. JRUBY-415 - RubyClass newClass = - runtime.defineClass("UnboundMethod", runtime.getMethod(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - runtime.setUnboundMethod(newClass); - - newClass.defineAnnotatedMethods(RubyUnboundMethod.class); - - return newClass; - } - - /** - * @see org.jruby.RubyMethod#call(IRubyObject[]) - */ - @JRubyMethod(name = {"call", "[]"}, rest = true, frame = true) - @Override - public IRubyObject call(ThreadContext context, IRubyObject[] args, Block block) { - throw context.getRuntime().newTypeError("you cannot call unbound method; bind first"); - } - - /** - * @see org.jruby.RubyMethod#unbind() - */ - @JRubyMethod(name = "unbind", frame = true) - @Override - public RubyUnboundMethod unbind(Block block) { - return this; - } - - @JRubyMethod(name = "bind", required = 1, frame = true) - public RubyMethod bind(ThreadContext context, IRubyObject aReceiver, Block block) { - RubyClass receiverClass = aReceiver.getMetaClass(); - - if (!originModule.isInstance(aReceiver)) { - if (originModule instanceof MetaClass) { - throw context.getRuntime().newTypeError("singleton method called for a different object"); - } else if (receiverClass instanceof MetaClass && receiverClass.getMethods().containsKey(originName)) { - throw context.getRuntime().newTypeError("method `" + originName + "' overridden"); - } else if ( - !(originModule.isModule() ? originModule.isInstance(aReceiver) : aReceiver.getType() == originModule)) { - // FIX replace type() == ... with isInstanceOf(...) - throw context.getRuntime().newTypeError("bind argument must be an instance of " + originModule.getName()); - } - } - return RubyMethod.newMethod(implementationModule, methodName, receiverClass, originName, method, aReceiver); - } - - @JRubyMethod(name = "clone") - @Override - public RubyMethod rbClone() { - return newUnboundMethod(implementationModule, methodName, originModule, originName, method); - } - - @JRubyMethod(name = "to_proc", frame = true) - @Override - public IRubyObject to_proc(ThreadContext context, Block unusedBlock) { - return super.to_proc(context, unusedBlock); - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2007 Ola Bini <ola.bini@gmail.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.IOException; - -import java.util.Iterator; -import java.util.List; -import java.util.Map; - -import java.util.regex.Pattern; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyModule; - -import org.jruby.runtime.Block; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.builtin.IRubyObject; - -import org.jruby.javasupport.JavaEmbedUtils; - -import org.jruby.javasupport.JavaUtil; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.MethodIndex; -import org.jruby.runtime.Visibility; - -import org.jruby.yaml.JRubyRepresenter; -import org.jruby.yaml.JRubyConstructor; -import org.jruby.yaml.JRubySerializer; -import org.jruby.util.IOInputStream; -import org.jruby.util.IOOutputStream; - -import org.jvyamlb.Representer; -import org.jvyamlb.Constructor; -import org.jvyamlb.ParserImpl; -import org.jvyamlb.PositioningParserImpl; -import org.jvyamlb.Scanner; -import org.jvyamlb.ScannerImpl; -import org.jvyamlb.Composer; -import org.jvyamlb.ComposerImpl; -import org.jvyamlb.PositioningScannerImpl; -import org.jvyamlb.PositioningComposerImpl; -import org.jvyamlb.Serializer; -import org.jvyamlb.ResolverImpl; -import org.jvyamlb.EmitterImpl; -import org.jvyamlb.exceptions.YAMLException; -import org.jvyamlb.YAMLConfig; -import org.jvyamlb.YAML; -import org.jvyamlb.PositioningScanner; -import org.jvyamlb.Positionable; -import org.jvyamlb.Position; - -/** - * @author <a href="mailto:ola.bini@ki.se">Ola Bini</a> - */ -@JRubyModule(name="YAML") -public class RubyYAML { - public static RubyModule createYAMLModule(Ruby runtime) { - RubyModule result = runtime.defineModule("YAML"); - - runtime.getKernel().callMethod(runtime.getCurrentContext(),"require", runtime.newString("stringio")); - - result.defineAnnotatedMethods(RubyYAML.class); - - RubyClass obj = runtime.getObject(); - RubyClass clazz = runtime.getClassClass(); - RubyClass hash = runtime.getHash(); - RubyClass array = runtime.getArray(); - RubyClass struct = runtime.getStructClass(); - RubyClass exception = runtime.getException(); - RubyClass string = runtime.getString(); - RubyClass symbol = runtime.getSymbol(); - RubyClass range = runtime.getRange(); - RubyClass regexp = runtime.getRegexp(); - RubyClass time = runtime.getTime(); - RubyClass date = runtime.fastGetClass("Date"); - RubyClass fixnum = runtime.getFixnum(); - RubyClass bignum = runtime.getBignum(); - RubyClass flt = runtime.getFloat(); - RubyClass trueClass = runtime.getTrueClass(); - RubyClass falseClass = runtime.getFalseClass(); - RubyClass nilClass = runtime.getNilClass(); - - clazz.defineAnnotatedMethods(YAMLClassMethods.class); - - obj.defineAnnotatedMethods(YAMLObjectMethods.class); - - hash.defineAnnotatedMethods(YAMLHashMethods.class); - - array.defineAnnotatedMethods(YAMLArrayMethods.class); - - struct.defineAnnotatedMethods(YAMLStructMethods.class); - - exception.defineAnnotatedMethods(YAMLExceptionMethods.class); - - string.defineAnnotatedMethods(YAMLStringMethods.class); - - symbol.defineAnnotatedMethods(YAMLSymbolMethods.class); - - range.defineAnnotatedMethods(YAMLRangeMethods.class); - - regexp.defineAnnotatedMethods(YAMLRegexpMethods.class); - - time.defineAnnotatedMethods(YAMLTimeMethods.class); - - date.defineAnnotatedMethods(YAMLDateMethods.class); - - bignum.defineAnnotatedMethods(YAMLNumericMethods.class); - - fixnum.defineAnnotatedMethods(YAMLNumericMethods.class); - - flt.defineAnnotatedMethods(YAMLNumericMethods.class); - - trueClass.defineAnnotatedMethods(YAMLTrueMethods.class); - - falseClass.defineAnnotatedMethods(YAMLFalseMethods.class); - - nilClass.defineAnnotatedMethods(YAMLNilMethods.class); - - runtime.setObjectToYamlMethod(runtime.getObject().searchMethod("to_yaml")); - - return result; - } - - @JRubyMethod(name = "dump", required = 1, optional = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject dump(IRubyObject self, IRubyObject[] args) { - IRubyObject obj = args[0]; - Ruby runtime = self.getRuntime(); - IRubyObject val = runtime.newArray(obj); - if(args.length>1) { - return RuntimeHelpers.invoke(runtime.getCurrentContext(), self,"dump_all", val, args[1]); - } else { - return self.callMethod(runtime.getCurrentContext(),"dump_all", val); - } - } - - @JRubyMethod(name = "dump_all", required = 1, optional = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject dump_all(IRubyObject self, IRubyObject[] args) { - ThreadContext context = self.getRuntime().getCurrentContext(); - RubyArray objs = (RubyArray)args[0]; - IRubyObject io = null; - IRubyObject io2 = null; - if(args.length == 2 && args[1] != null && !args[1].isNil()) { - io = args[1]; - } - YAMLConfig cfg = YAML.config().version("1.0"); - IOOutputStream iox = null; - if(null == io) { - io2 = self.getRuntime().fastGetClass("StringIO").callMethod(context, "new"); - iox = new IOOutputStream(io2); - } else { - iox = new IOOutputStream(io); - } - Serializer ser = new JRubySerializer(new EmitterImpl(iox,cfg),new ResolverImpl(),cfg); - try { - ser.open(); - Representer r = new JRubyRepresenter(ser, cfg); - for(Iterator iter = objs.getList().iterator();iter.hasNext();) { - r.represent(iter.next()); - } - ser.close(); - } catch(IOException e) { - throw self.getRuntime().newIOErrorFromException(e); - } - if(null == io) { - io2.callMethod(context, "rewind"); - return io2.callMethod(context, "read"); - } else { - return io; - } - } - - @JRubyMethod(name = "_parse_internal", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject parse_internal(IRubyObject self, IRubyObject arg) { - boolean debug = self.getRuntime().getDebug().isTrue(); - IRubyObject io = check_yaml_port(arg); - Scanner scn = null; - try { - if(io instanceof RubyString) { - scn = debug ? new PositioningScannerImpl(((RubyString)io).getByteList()) : new ScannerImpl(((RubyString)io).getByteList()); - } else { - scn = debug ? new PositioningScannerImpl(new IOInputStream(io)) : new ScannerImpl(new IOInputStream(io)); - } - Composer ctor = - debug ? - new PositioningComposerImpl(new PositioningParserImpl((PositioningScanner)scn,YAML.config().version("1.0")),new ResolverImpl()) : - new ComposerImpl(new ParserImpl(scn,YAML.config().version("1.0")),new ResolverImpl()) - ; - if(ctor.checkNode()) { - return JavaEmbedUtils.javaToRuby(self.getRuntime(),ctor.getNode()); - } - return self.getRuntime().getNil(); - } catch(YAMLException e) { - if(self.getRuntime().getDebug().isTrue()) { - Position.Range range = ((Positionable)e).getRange(); - throw self.getRuntime().newArgumentError("syntax error on " + range.start + ":" + range.end + ": " + e.getMessage()); - } else { - throw self.getRuntime().newArgumentError("syntax error:" + e.getMessage()); - } - } - } - - @JRubyMethod(name = "load", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject load(IRubyObject self, IRubyObject arg) { - boolean debug = self.getRuntime().getDebug().isTrue(); - IRubyObject io = check_yaml_port(arg); - Scanner scn = null; - try { - if(io instanceof RubyString) { - scn = debug ? new PositioningScannerImpl(((RubyString)io).getByteList()) : new ScannerImpl(((RubyString)io).getByteList()); - } else { - scn = debug ? new PositioningScannerImpl(new IOInputStream(io)) : new ScannerImpl(new IOInputStream(io)); - } - Constructor ctor = - debug ? - new JRubyConstructor(self, new PositioningComposerImpl(new PositioningParserImpl((PositioningScanner)scn,YAML.config().version("1.0")),new ResolverImpl())) : - new JRubyConstructor(self, new ComposerImpl(new ParserImpl(scn,YAML.config().version("1.0")),new ResolverImpl())) - ; - if(ctor.checkData()) { - return JavaEmbedUtils.javaToRuby(self.getRuntime(),ctor.getData()); - } - return self.getRuntime().getNil(); - } catch(YAMLException e) { - if(self.getRuntime().getDebug().isTrue()) { - Position.Range range = ((Positionable)e).getRange(); - throw self.getRuntime().newArgumentError("syntax error on " + range.start + ":" + range.end + ": " + e.getMessage()); - } else { - throw self.getRuntime().newArgumentError("syntax error:" + e.getMessage()); - } - } - } - - @JRubyMethod(name = "load_file", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject load_file(IRubyObject self, IRubyObject arg) { - Ruby runtime = self.getRuntime(); - ThreadContext context = runtime.getCurrentContext(); - IRubyObject io = RuntimeHelpers.invoke(context, runtime.getFile(),"open", arg, runtime.newString("r")); - IRubyObject val = self.callMethod(context,"load", io); - io.callMethod(context, "close"); - return val; - } - - @JRubyMethod(name = "each_document", required = 1, frame = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject each_document(IRubyObject self, IRubyObject arg, Block block) { - boolean debug = self.getRuntime().getDebug().isTrue(); - ThreadContext context = self.getRuntime().getCurrentContext(); - IRubyObject io = arg; - Scanner scn = null; - try { - if(io instanceof RubyString) { - scn = debug ? new PositioningScannerImpl(((RubyString)io).getByteList()) : new ScannerImpl(((RubyString)io).getByteList()); - } else { - scn = debug ? new PositioningScannerImpl(new IOInputStream(io)) : new ScannerImpl(new IOInputStream(io)); - } - Constructor ctor = - debug ? - new JRubyConstructor(self, new PositioningComposerImpl(new PositioningParserImpl((PositioningScanner)scn,YAML.config().version("1.0")),new ResolverImpl())) : - new JRubyConstructor(self, new ComposerImpl(new ParserImpl(scn,YAML.config().version("1.0")),new ResolverImpl())) - ; - while(ctor.checkData()) { - block.yield(context, JavaEmbedUtils.javaToRuby(self.getRuntime(),ctor.getData())); - } - return self.getRuntime().getNil(); - } catch(YAMLException e) { - if(self.getRuntime().getDebug().isTrue()) { - Position.Range range = ((Positionable)e).getRange(); - throw self.getRuntime().newArgumentError("syntax error on " + range.start + ":" + range.end + ": " + e.getMessage()); - } else { - throw self.getRuntime().newArgumentError("syntax error:" + e.getMessage()); - } - } - } - - @JRubyMethod(name = "load_documents", required = 1, frame = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject load_documents(IRubyObject self, IRubyObject arg, Block block) { - boolean debug = self.getRuntime().getDebug().isTrue(); - ThreadContext context = self.getRuntime().getCurrentContext(); - IRubyObject io = check_yaml_port(arg); - Scanner scn = null; - try { - if(io instanceof RubyString) { - scn = debug ? new PositioningScannerImpl(((RubyString)io).getByteList()) : new ScannerImpl(((RubyString)io).getByteList()); - } else { - scn = debug ? new PositioningScannerImpl(new IOInputStream(io)) : new ScannerImpl(new IOInputStream(io)); - } - Constructor ctor = - debug ? - new JRubyConstructor(self, new PositioningComposerImpl(new PositioningParserImpl((PositioningScanner)scn,YAML.config().version("1.0")),new ResolverImpl())) : - new JRubyConstructor(self, new ComposerImpl(new ParserImpl(scn,YAML.config().version("1.0")),new ResolverImpl())) - ; - while(ctor.checkData()) { - block.yield(context, JavaEmbedUtils.javaToRuby(self.getRuntime(),ctor.getData())); - } - return self.getRuntime().getNil(); - } catch(YAMLException e) { - if(self.getRuntime().getDebug().isTrue()) { - Position.Range range = ((Positionable)e).getRange(); - throw self.getRuntime().newArgumentError("syntax error on " + range.start + ":" + range.end + ": " + e.getMessage()); - } else { - throw self.getRuntime().newArgumentError("syntax error:" + e.getMessage()); - } - } - } - - @JRubyMethod(name = "load_stream", required = 1, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject load_stream(IRubyObject self, IRubyObject arg) { - boolean debug = self.getRuntime().getDebug().isTrue(); - ThreadContext context = self.getRuntime().getCurrentContext(); - IRubyObject d = self.getRuntime().getNil(); - IRubyObject io = arg; - Scanner scn = null; - try { - if(io instanceof RubyString) { - scn = debug ? new PositioningScannerImpl(((RubyString)io).getByteList()) : new ScannerImpl(((RubyString)io).getByteList()); - } else { - scn = debug ? new PositioningScannerImpl(new IOInputStream(io)) : new ScannerImpl(new IOInputStream(io)); - } - Constructor ctor = - debug ? - new JRubyConstructor(self, new PositioningComposerImpl(new PositioningParserImpl((PositioningScanner)scn,YAML.config().version("1.0")),new ResolverImpl())) : - new JRubyConstructor(self, new ComposerImpl(new ParserImpl(scn,YAML.config().version("1.0")),new ResolverImpl())) - ; - while(ctor.checkData()) { - if(d.isNil()) { - d = self.getRuntime().fastGetModule("YAML").fastGetClass("Stream").callMethod(context,"new", d); - } - d.callMethod(context,"add", JavaEmbedUtils.javaToRuby(self.getRuntime(),ctor.getData())); - } - return d; - } catch(YAMLException e) { - if(self.getRuntime().getDebug().isTrue()) { - Position.Range range = ((Positionable)e).getRange(); - throw self.getRuntime().newArgumentError("syntax error on " + range.start + ":" + range.end + ": " + e.getMessage()); - } else { - throw self.getRuntime().newArgumentError("syntax error:" + e.getMessage()); - } - } - } - - @JRubyMethod(name = "dump_stream", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject dump_stream(IRubyObject self, IRubyObject[] args) { - ThreadContext context = self.getRuntime().getCurrentContext(); - IRubyObject stream = self.getRuntime().fastGetModule("YAML").fastGetClass("Stream").callMethod(context, "new"); - for(int i=0,j=args.length;i<j;i++) { - stream.callMethod(context,"add", args[i]); - } - return stream.callMethod(context, "emit"); - } - - @JRubyMethod(name = "quick_emit_node", required = 1, rest = true, frame = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject quick_emit_node(IRubyObject self, IRubyObject[] args, Block block) { - return block.yield(self.getRuntime().getCurrentContext(), args[0]); - } - -// @JRubyMethod(name = "quick_emit_node", rest = true, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject quick_emit(IRubyObject self, IRubyObject[] args) { - return self.getRuntime().getNil(); - } - - // prepares IO port type for load (ported from ext/syck/rubyext.c) - private static IRubyObject check_yaml_port(IRubyObject port) { - if (port instanceof RubyString) { - // OK - } - else if (port.respondsTo("read")) { - if (port.respondsTo("binmode")) { - ThreadContext context = port.getRuntime().getCurrentContext(); - port.callMethod(context, "binmode"); - } - } - else { - throw port.getRuntime().newTypeError("instance of IO needed"); - } - return port; - } - - @JRubyClass(name="Hash") - public static class YAMLHashMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject hash_to_yaml_node(IRubyObject self, IRubyObject arg) { - Ruby runtime = self.getRuntime(); - ThreadContext context = runtime.getCurrentContext(); - return RuntimeHelpers.invoke(context, arg, "map", self.callMethod(context, "taguri"), self, self.callMethod(context, "to_yaml_style")); - } - } - - @JRubyClass(name="Object") - public static class YAMLObjectMethods { - @JRubyMethod(name = "to_yaml_properties") - public static IRubyObject obj_to_yaml_properties(IRubyObject self) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return self.callMethod(context, "instance_variables").callMethod(context, "sort"); - } - @JRubyMethod(name = "to_yaml_style") - public static IRubyObject obj_to_yaml_style(IRubyObject self) { - return self.getRuntime().getNil(); - } - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject obj_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - Map mep = (Map)(new RubyHash(self.getRuntime())); - RubyArray props = (RubyArray)self.callMethod(context, "to_yaml_properties"); - for(Iterator iter = props.getList().iterator(); iter.hasNext();) { - String m = iter.next().toString(); - mep.put(self.getRuntime().newString(m.substring(1)), self.callMethod(context,"instance_variable_get", self.getRuntime().newString(m))); - } - return RuntimeHelpers.invoke(context, arg, "map", self.callMethod(context, "taguri"), (IRubyObject)mep, self.callMethod(context, "to_yaml_style")); - } - @JRubyMethod(name = "to_yaml", rest = true) - public static IRubyObject obj_to_yaml(IRubyObject self, IRubyObject[] args) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return self.getRuntime().fastGetModule("YAML").callMethod(context,"dump", self); - } - @JRubyMethod(name = "taguri") - public static IRubyObject obj_taguri(IRubyObject self) { - return self.getRuntime().newString("!ruby/object:" + self.getType().getName()); - } - } - - @JRubyClass(name="Class") - public static class YAMLClassMethods { - @JRubyMethod(name = "to_yaml", rest = true) - public static IRubyObject class_to_yaml(IRubyObject self, IRubyObject[] args) { - throw self.getRuntime().newTypeError("can't dump anonymous class " + self.getType().getName()); - } - } - - @JRubyClass(name="Array") - public static class YAMLArrayMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject array_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return RuntimeHelpers.invoke(context, arg, "seq", self.callMethod(context, "taguri"), self, self.callMethod(context, "to_yaml_style")); - } - } - - @JRubyClass(name="Struct") - public static class YAMLStructMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject struct_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - Map mep = (Map)(new RubyHash(self.getRuntime())); - for(Iterator iter = ((RubyArray)self.callMethod(context, "members")).getList().iterator();iter.hasNext();) { - IRubyObject key = self.getRuntime().newString(iter.next().toString()); - mep.put(key,self.callMethod(context,MethodIndex.AREF, "[]", key)); - } - for(Iterator iter = ((RubyArray)self.callMethod(context, "to_yaml_properties")).getList().iterator(); iter.hasNext();) { - String m = iter.next().toString(); - mep.put(self.getRuntime().newString(m.substring(1)), self.callMethod(context,"instance_variable_get", self.getRuntime().newString(m))); - } - return RuntimeHelpers.invoke(context, arg, "map", self.callMethod(context, "taguri"), (IRubyObject)mep, self.callMethod(context, "to_yaml_style")); - } - @JRubyMethod(name = "taguri") - public static IRubyObject struct_taguri(IRubyObject self) { - return self.getRuntime().newString("!ruby/struct:" + self.getType().getName()); - } - } - - @JRubyClass(name="Exception") - public static class YAMLExceptionMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject exception_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - Map mep = (Map)(new RubyHash(self.getRuntime())); - mep.put(self.getRuntime().newString("message"),self.callMethod(context, "message")); - for(Iterator iter = ((RubyArray)self.callMethod(context, "to_yaml_properties")).getList().iterator(); iter.hasNext();) { - String m = iter.next().toString(); - mep.put(self.getRuntime().newString(m.substring(1)), self.callMethod(context,"instance_variable_get", self.getRuntime().newString(m))); - } - return RuntimeHelpers.invoke(context, arg,"map", self.callMethod(context, "taguri"), (IRubyObject)mep, self.callMethod(context, "to_yaml_style")); - } - @JRubyMethod(name = "taguri") - public static IRubyObject exception_taguri(IRubyObject self) { - return self.getRuntime().newString("!ruby/exception:" + self.getType().getName()); - } - } - - private static final Pattern AFTER_NEWLINE = Pattern.compile("\n.+", Pattern.DOTALL); - @JRubyClass(name="String") - public static class YAMLStringMethods { - @JRubyMethod(name = "is_complex_yaml?") - public static IRubyObject string_is_complex(IRubyObject self) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return (self.callMethod(context, "to_yaml_style").isTrue() || - ((List)self.callMethod(context, "to_yaml_properties")).isEmpty() || - AFTER_NEWLINE.matcher(self.toString()).find()) ? self.getRuntime().getTrue() : self.getRuntime().getFalse(); - } - @JRubyMethod(name = "is_binary_data?") - public static IRubyObject string_is_binary(IRubyObject self) { - ThreadContext context = self.getRuntime().getCurrentContext(); - if(self.callMethod(context, MethodIndex.EMPTY_P, "empty?").isTrue()) { - return self.getRuntime().getNil(); - } - return self.toString().indexOf('\0') != -1 ? self.getRuntime().getTrue() : self.getRuntime().getFalse(); - } - private static JRubyRepresenter into(IRubyObject arg) { - IRubyObject jobj = arg.getInstanceVariables().fastGetInstanceVariable("@java_object"); - if(jobj != null) { - return (JRubyRepresenter)(((org.jruby.javasupport.JavaObject)jobj).getValue()); - } - return null; - } - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject string_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - Ruby rt = self.getRuntime(); - if(self.callMethod(context, "is_binary_data?").isTrue()) { - return RuntimeHelpers.invoke(context, arg, "scalar", rt.newString("tag:yaml.org,2002:binary"), rt.newArray(self).callMethod(context, "pack", rt.newString("m")), rt.newString("|")); - } - if(((List)self.callMethod(context, "to_yaml_properties")).isEmpty()) { - JRubyRepresenter rep = into(arg); - if(rep != null) { - try { - return JavaUtil.convertJavaToRuby(rt,rep.scalar(self.callMethod(context, "taguri").toString(),self.convertToString().getByteList(),self.toString().startsWith(":") ? "\"" : self.callMethod(context, "to_yaml_style").toString())); - } catch(IOException e) { - throw rt.newIOErrorFromException(e); - } - } else { - return RuntimeHelpers.invoke(context, arg, "scalar", self.callMethod(context, "taguri"), self, self.toString().startsWith(":") ? rt.newString("\"") : self.callMethod(context, "to_yaml_style")); - } - } - - Map mep = (Map)(new RubyHash(self.getRuntime())); - mep.put(self.getRuntime().newString("str"),rt.newString(self.toString())); - for(Iterator iter = ((RubyArray)self.callMethod(context, "to_yaml_properties")).getList().iterator(); iter.hasNext();) { - String m = iter.next().toString(); - mep.put(self.getRuntime().newString(m), self.callMethod(context,"instance_variable_get", self.getRuntime().newString(m))); - } - return RuntimeHelpers.invoke(context, arg, "map", self.callMethod(context, "taguri"), (IRubyObject)mep, self.callMethod(context, "to_yaml_style")); - } - } - - @JRubyClass(name="Symbol") - public static class YAMLSymbolMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject symbol_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return RuntimeHelpers.invoke(context, arg, "scalar", self.callMethod(context, "taguri"), self.callMethod(context, "inspect"), self.callMethod(context, "to_yaml_style")); - } - @JRubyMethod(name = "taguri") - public static IRubyObject symbol_taguri(IRubyObject self) { - return self.getRuntime().newString("tag:yaml.org,2002:str"); - } - } - - @JRubyClass(name="Numeric") - public static class YAMLNumericMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject numeric_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - String val = self.toString(); - if("Infinity".equals(val)) { - val = ".Inf"; - } else if("-Infinity".equals(val)) { - val = "-.Inf"; - } else if("NaN".equals(val)) { - val = ".NaN"; - } - return RuntimeHelpers.invoke(context, arg,"scalar", self.callMethod(context, "taguri"), self.getRuntime().newString(val), self.callMethod(context, "to_yaml_style")); - } - } - - @JRubyClass(name="Range") - public static class YAMLRangeMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject range_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - Map mep = (Map)(new RubyHash(self.getRuntime())); - mep.put(self.getRuntime().newString("begin"),self.callMethod(context, "begin")); - mep.put(self.getRuntime().newString("end"),self.callMethod(context, "end")); - mep.put(self.getRuntime().newString("excl"),self.callMethod(context, "exclude_end?")); - for(Iterator iter = ((RubyArray)self.callMethod(context, "to_yaml_properties")).getList().iterator(); iter.hasNext();) { - String m = iter.next().toString(); - mep.put(self.getRuntime().newString(m.substring(1)), self.callMethod(context,"instance_variable_get", self.getRuntime().newString(m))); - } - return RuntimeHelpers.invoke(context, arg, "map", self.callMethod(context, "taguri"), (IRubyObject)mep, self.callMethod(context, "to_yaml_style")); - } - } - - @JRubyClass(name="Regexp") - public static class YAMLRegexpMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject regexp_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return RuntimeHelpers.invoke(context, arg, "scalar", self.callMethod(context, "taguri"), self.callMethod(context, "inspect"), self.callMethod(context, "to_yaml_style")); - } - } - - @JRubyClass(name="Time") - public static class YAMLTimeMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject time_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - IRubyObject tz = self.getRuntime().newString("Z"); - IRubyObject difference_sign = self.getRuntime().newString("-"); - self = self.dup(); - if(!self.callMethod(context, "utc?").isTrue()) { - IRubyObject utc_same_instant = self.callMethod(context, "utc"); - IRubyObject utc_same_writing = RuntimeHelpers.invoke(context, self.getRuntime().getTime(), "utc", new IRubyObject[]{ - self.callMethod(context, "year"),self.callMethod(context, "month"),self.callMethod(context, "day"),self.callMethod(context, "hour"), - self.callMethod(context, "min"),self.callMethod(context, "sec"),self.callMethod(context, "usec")}); - IRubyObject difference_to_utc = utc_same_writing.callMethod(context,MethodIndex.OP_MINUS, "-", utc_same_instant); - IRubyObject absolute_difference; - if(difference_to_utc.callMethod(context,MethodIndex.OP_LT, "<", RubyFixnum.zero(self.getRuntime())).isTrue()) { - difference_sign = self.getRuntime().newString("-"); - absolute_difference = RubyFixnum.zero(self.getRuntime()).callMethod(context,MethodIndex.OP_MINUS, "-", difference_to_utc); - } else { - difference_sign = self.getRuntime().newString("+"); - absolute_difference = difference_to_utc; - } - IRubyObject difference_minutes = absolute_difference.callMethod(context,"/", self.getRuntime().newFixnum(60)).callMethod(context, "round"); - tz = self.getRuntime().newString("%s%02d:%02d").callMethod(context,"%", self.getRuntime().newArrayNoCopy(new IRubyObject[]{difference_sign,difference_minutes.callMethod(context,"/", self.getRuntime().newFixnum(60)),difference_minutes.callMethod(context,"%", self.getRuntime().newFixnum(60))})); - } - IRubyObject standard = self.callMethod(context,"strftime", self.getRuntime().newString("%Y-%m-%d %H:%M:%S")); - if(self.callMethod(context, "usec").callMethod(context, "nonzero?").isTrue()) { - standard = standard.callMethod(context, MethodIndex.OP_PLUS, "+", self.getRuntime().newString(".%06d").callMethod(context,"%", self.getRuntime().newArray(self.callMethod(context, "usec")))); - } - standard = standard.callMethod(context,MethodIndex.OP_PLUS, "+", self.getRuntime().newString(" %s").callMethod(context,"%", self.getRuntime().newArray(tz))); - return RuntimeHelpers.invoke(context, arg, "scalar", self.callMethod(context, "taguri"), standard, self.callMethod(context, "to_yaml_style")); - } - } - - @JRubyClass(name="Date") - public static class YAMLDateMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject date_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return RuntimeHelpers.invoke(context, arg, "scalar", self.callMethod(context, "taguri"), self.callMethod(context, MethodIndex.TO_S, "to_s"), self.callMethod(context, "to_yaml_style")); - } - } - - @JRubyClass(name="TrueClass") - public static class YAMLTrueMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject true_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return RuntimeHelpers.invoke(context, arg, "scalar", self.callMethod(context, "taguri"), self.callMethod(context, MethodIndex.TO_S, "to_s"), self.callMethod(context, "to_yaml_style")); - } - @JRubyMethod(name = "taguri") - public static IRubyObject true_taguri(IRubyObject self) { - return self.getRuntime().newString("tag:yaml.org,2002:bool"); - } - } - - @JRubyClass(name="FalseClass") - public static class YAMLFalseMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject false_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return RuntimeHelpers.invoke(context, arg, "scalar", self.callMethod(context, "taguri"), self.callMethod(context, MethodIndex.TO_S, "to_s"), self.callMethod(context, "to_yaml_style")); - } - @JRubyMethod(name = "taguri") - public static IRubyObject false_taguri(IRubyObject self) { - return self.getRuntime().newString("tag:yaml.org,2002:bool"); - } - } - - @JRubyClass(name="NilClass") - public static class YAMLNilMethods { - @JRubyMethod(name = "to_yaml_node", required = 1) - public static IRubyObject nil_to_yaml_node(IRubyObject self, IRubyObject arg) { - ThreadContext context = self.getRuntime().getCurrentContext(); - return RuntimeHelpers.invoke(context, arg,"scalar", self.callMethod(context, "taguri"), self.getRuntime().newString(""), self.callMethod(context, "to_yaml_style")); - } - } -}// RubyYAML -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2006 Ola Bini <ola@ologix.com> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import java.io.InputStream; -import java.io.IOException; - -import java.util.List; -import java.util.ArrayList; - -import java.util.zip.GZIPInputStream; -import java.util.zip.GZIPOutputStream; -import org.jruby.anno.FrameField; -import org.jruby.anno.JRubyMethod; -import org.jruby.anno.JRubyClass; -import org.jruby.anno.JRubyModule; - -import org.jruby.exceptions.RaiseException; -import org.jruby.javasupport.util.RuntimeHelpers; -import org.jruby.runtime.Arity; - -import org.jruby.runtime.Block; -import org.jruby.runtime.ObjectAllocator; -import org.jruby.runtime.ThreadContext; -import org.jruby.runtime.Visibility; -import org.jruby.runtime.builtin.IRubyObject; - -import org.jruby.util.IOInputStream; -import org.jruby.util.IOOutputStream; -import org.jruby.util.CRC32Ext; -import org.jruby.util.Adler32Ext; -import org.jruby.util.ZlibInflate; -import org.jruby.util.ZlibDeflate; - -import org.jruby.util.ByteList; - -@JRubyModule(name="Zlib") -public class RubyZlib { - /** Create the Zlib module and add it to the Ruby runtime. - * - */ - public static RubyModule createZlibModule(Ruby runtime) { - RubyModule result = runtime.defineModule("Zlib"); - - RubyClass gzfile = result.defineClassUnder("GzipFile", runtime.getObject(), RubyGzipFile.GZIPFILE_ALLOCATOR); - gzfile.defineAnnotatedMethods(RubyGzipFile.class); - - RubyClass gzreader = result.defineClassUnder("GzipReader", gzfile, RubyGzipReader.GZIPREADER_ALLOCATOR); - gzreader.includeModule(runtime.getEnumerable()); - gzreader.defineAnnotatedMethods(RubyGzipReader.class); - - RubyClass standardError = runtime.getStandardError(); - RubyClass zlibError = result.defineClassUnder("Error", standardError, standardError.getAllocator()); - gzreader.defineClassUnder("Error", zlibError, zlibError.getAllocator()); - - RubyClass gzwriter = result.defineClassUnder("GzipWriter", gzfile, RubyGzipWriter.GZIPWRITER_ALLOCATOR); - gzwriter.defineAnnotatedMethods(RubyGzipWriter.class); - - result.defineConstant("ZLIB_VERSION",runtime.newString("1.2.1")); - result.defineConstant("VERSION",runtime.newString("0.6.0")); - - result.defineConstant("BINARY",runtime.newFixnum(0)); - result.defineConstant("ASCII",runtime.newFixnum(1)); - result.defineConstant("UNKNOWN",runtime.newFixnum(2)); - - result.defineConstant("DEF_MEM_LEVEL",runtime.newFixnum(8)); - result.defineConstant("MAX_MEM_LEVEL",runtime.newFixnum(9)); - - result.defineConstant("OS_UNIX",runtime.newFixnum(3)); - result.defineConstant("OS_UNKNOWN",runtime.newFixnum(255)); - result.defineConstant("OS_CODE",runtime.newFixnum(11)); - result.defineConstant("OS_ZSYSTEM",runtime.newFixnum(8)); - result.defineConstant("OS_VMCMS",runtime.newFixnum(4)); - result.defineConstant("OS_VMS",runtime.newFixnum(2)); - result.defineConstant("OS_RISCOS",runtime.newFixnum(13)); - result.defineConstant("OS_MACOS",runtime.newFixnum(7)); - result.defineConstant("OS_OS2",runtime.newFixnum(6)); - result.defineConstant("OS_AMIGA",runtime.newFixnum(1)); - result.defineConstant("OS_QDOS",runtime.newFixnum(12)); - result.defineConstant("OS_WIN32",runtime.newFixnum(11)); - result.defineConstant("OS_ATARI",runtime.newFixnum(5)); - result.defineConstant("OS_MSDOS",runtime.newFixnum(0)); - result.defineConstant("OS_CPM",runtime.newFixnum(9)); - result.defineConstant("OS_TOPS20",runtime.newFixnum(10)); - - result.defineConstant("DEFAULT_STRATEGY",runtime.newFixnum(0)); - result.defineConstant("FILTERED",runtime.newFixnum(1)); - result.defineConstant("HUFFMAN_ONLY",runtime.newFixnum(2)); - - result.defineConstant("NO_FLUSH",runtime.newFixnum(0)); - result.defineConstant("SYNC_FLUSH",runtime.newFixnum(2)); - result.defineConstant("FULL_FLUSH",runtime.newFixnum(3)); - result.defineConstant("FINISH",runtime.newFixnum(4)); - - result.defineConstant("NO_COMPRESSION",runtime.newFixnum(0)); - result.defineConstant("BEST_SPEED",runtime.newFixnum(1)); - result.defineConstant("DEFAULT_COMPRESSION",runtime.newFixnum(-1)); - result.defineConstant("BEST_COMPRESSION",runtime.newFixnum(9)); - - result.defineConstant("MAX_WBITS",runtime.newFixnum(15)); - - result.defineAnnotatedMethods(RubyZlib.class); - - result.defineClassUnder("StreamEnd",zlibError, zlibError.getAllocator()); - result.defineClassUnder("StreamError",zlibError, zlibError.getAllocator()); - result.defineClassUnder("BufError",zlibError, zlibError.getAllocator()); - result.defineClassUnder("NeedDict",zlibError, zlibError.getAllocator()); - result.defineClassUnder("MemError",zlibError, zlibError.getAllocator()); - result.defineClassUnder("VersionError",zlibError, zlibError.getAllocator()); - result.defineClassUnder("DataError",zlibError, zlibError.getAllocator()); - - RubyClass gzError = gzfile.defineClassUnder("Error",zlibError, zlibError.getAllocator()); - gzfile.defineClassUnder("CRCError",gzError, gzError.getAllocator()); - gzfile.defineClassUnder("NoFooter",gzError, gzError.getAllocator()); - gzfile.defineClassUnder("LengthError",gzError, gzError.getAllocator()); - - // ZStream actually *isn't* allocatable - RubyClass zstream = result.defineClassUnder("ZStream", runtime.getObject(), ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR); - zstream.defineAnnotatedMethods(ZStream.class); - zstream.undefineMethod("new"); - - RubyClass infl = result.defineClassUnder("Inflate", zstream, Inflate.INFLATE_ALLOCATOR); - infl.defineAnnotatedMethods(Inflate.class); - - RubyClass defl = result.defineClassUnder("Deflate", zstream, Deflate.DEFLATE_ALLOCATOR); - defl.defineAnnotatedMethods(Deflate.class); - - runtime.getKernel().callMethod(runtime.getCurrentContext(),"require",runtime.newString("stringio")); - - return result; - } - - @JRubyClass(name="Zlib::Error", parent="StandardError") - public static class Error {} - @JRubyClass(name="Zlib::StreamEnd", parent="Zlib::Error") - public static class StreamEnd extends Error {} - @JRubyClass(name="Zlib::StreamError", parent="Zlib::Error") - public static class StreamError extends Error {} - @JRubyClass(name="Zlib::BufError", parent="Zlib::Error") - public static class BufError extends Error {} - @JRubyClass(name="Zlib::NeedDict", parent="Zlib::Error") - public static class NeedDict extends Error {} - @JRubyClass(name="Zlib::MemError", parent="Zlib::Error") - public static class MemError extends Error {} - @JRubyClass(name="Zlib::VersionError", parent="Zlib::Error") - public static class VersionError extends Error {} - @JRubyClass(name="Zlib::DataError", parent="Zlib::Error") - public static class DataError extends Error {} - - @JRubyMethod(name = "zlib_version", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject zlib_version(IRubyObject recv) { - return ((RubyModule)recv).fastGetConstant("ZLIB_VERSION"); - } - - @JRubyMethod(name = "version", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject version(IRubyObject recv) { - return ((RubyModule)recv).fastGetConstant("VERSION"); - } - - @JRubyMethod(name = "crc32", optional = 2, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject crc32(IRubyObject recv, IRubyObject[] args) throws Exception { - args = Arity.scanArgs(recv.getRuntime(),args,0,2); - long crc = 0; - ByteList bytes = null; - - if (!args[0].isNil()) bytes = args[0].convertToString().getByteList(); - if (!args[1].isNil()) crc = RubyNumeric.num2long(args[1]); - - CRC32Ext ext = new CRC32Ext((int)crc); - if (bytes != null) { - ext.update(bytes.unsafeBytes(), bytes.begin(), bytes.length()); - } - - return recv.getRuntime().newFixnum(ext.getValue()); - } - - @JRubyMethod(name = "adler32", optional = 2, module = true, visibility = Visibility.PRIVATE) - public static IRubyObject adler32(IRubyObject recv, IRubyObject[] args) throws Exception { - args = Arity.scanArgs(recv.getRuntime(),args,0,2); - int adler = 1; - ByteList bytes = null; - if (!args[0].isNil()) bytes = args[0].convertToString().getByteList(); - if (!args[1].isNil()) adler = RubyNumeric.fix2int(args[1]); - - Adler32Ext ext = new Adler32Ext(adler); - if (bytes != null) { - ext.update(bytes.unsafeBytes(), bytes.begin(), bytes.length()); // it's safe since adler.update doesn't modify the array - } - return recv.getRuntime().newFixnum(ext.getValue()); - } - - private final static long[] crctab = new long[]{ - 0L, 1996959894L, 3993919788L, 2567524794L, 124634137L, 1886057615L, 3915621685L, 2657392035L, 249268274L, 2044508324L, 3772115230L, 2547177864L, 162941995L, - 2125561021L, 3887607047L, 2428444049L, 498536548L, 1789927666L, 4089016648L, 2227061214L, 450548861L, 1843258603L, 4107580753L, 2211677639L, 325883990L, - 1684777152L, 4251122042L, 2321926636L, 335633487L, 1661365465L, 4195302755L, 2366115317L, 997073096L, 1281953886L, 3579855332L, 2724688242L, 1006888145L, - 1258607687L, 3524101629L, 2768942443L, 901097722L, 1119000684L, 3686517206L, 2898065728L, 853044451L, 1172266101L, 3705015759L, 2882616665L, 651767980L, - 1373503546L, 3369554304L, 3218104598L, 565507253L, 1454621731L, 3485111705L, 3099436303L, 671266974L, 1594198024L, 3322730930L, 2970347812L, 795835527L, - 1483230225L, 3244367275L, 3060149565L, 1994146192L, 31158534L, 2563907772L, 4023717930L, 1907459465L, 112637215L, 2680153253L, 3904427059L, 2013776290L, - 251722036L, 2517215374L, 3775830040L, 2137656763L, 141376813L, 2439277719L, 3865271297L, 1802195444L, 476864866L, 2238001368L, 4066508878L, 1812370925L, - 453092731L, 2181625025L, 4111451223L, 1706088902L, 314042704L, 2344532202L, 4240017532L, 1658658271L, 366619977L, 2362670323L, 4224994405L, 1303535960L, - 984961486L, 2747007092L, 3569037538L, 1256170817L, 1037604311L, 2765210733L, 3554079995L, 1131014506L, 879679996L, 2909243462L, 3663771856L, 1141124467L, - 855842277L, 2852801631L, 3708648649L, 1342533948L, 654459306L, 3188396048L, 3373015174L, 1466479909L, 544179635L, 3110523913L, 3462522015L, 1591671054L, - 702138776L, 2966460450L, 3352799412L, 1504918807L, 783551873L, 3082640443L, 3233442989L, 3988292384L, 2596254646L, 62317068L, 1957810842L, 3939845945L, - 2647816111L, 81470997L, 1943803523L, 3814918930L, 2489596804L, 225274430L, 2053790376L, 3826175755L, 2466906013L, 167816743L, 2097651377L, 4027552580L, - 2265490386L, 503444072L, 1762050814L, 4150417245L, 2154129355L, 426522225L, 1852507879L, 4275313526L, 2312317920L, 282753626L, 1742555852L, 4189708143L, - 2394877945L, 397917763L, 1622183637L, 3604390888L, 2714866558L, 953729732L, 1340076626L, 3518719985L, 2797360999L, 1068828381L, 1219638859L, 3624741850L, - 2936675148L, 906185462L, 1090812512L, 3747672003L, 2825379669L, 829329135L, 1181335161L, 3412177804L, 3160834842L, 628085408L, 1382605366L, 3423369109L, - 3138078467L, 570562233L, 1426400815L, 3317316542L, 2998733608L, 733239954L, 1555261956L, 3268935591L, 3050360625L, 752459403L, 1541320221L, 2607071920L, - 3965973030L, 1969922972L, 40735498L, 2617837225L, 3943577151L, 1913087877L, 83908371L, 2512341634L, 3803740692L, 2075208622L, 213261112L, 2463272603L, - 3855990285L, 2094854071L, 198958881L, 2262029012L, 4057260610L, 1759359992L, 534414190L, 2176718541L, 4139329115L, 1873836001L, 414664567L, 2282248934L, - 4279200368L, 1711684554L, 285281116L, 2405801727L, 4167216745L, 1634467795L, 376229701L, 2685067896L, 3608007406L, 1308918612L, 956543938L, 2808555105L, - 3495958263L, 1231636301L, 1047427035L, 2932959818L, 3654703836L, 1088359270L, 936918000L, 2847714899L, 3736837829L, 1202900863L, 817233897L, 3183342108L, - 3401237130L, 1404277552L, 615818150L, 3134207493L, 3453421203L, 1423857449L, 601450431L, 3009837614L, 3294710456L, 1567103746L, 711928724L, 3020668471L, - 3272380065L, 1510334235L, 755167117}; - - @JRubyMethod(name = "crc_table", module = true, visibility = Visibility.PRIVATE) - public static IRubyObject crc_table(IRubyObject recv) { - List<IRubyObject> ll = new ArrayList<IRubyObject>(crctab.length); - for(int i=0;i<crctab.length;i++) { - ll.add(recv.getRuntime().newFixnum(crctab[i])); - } - return recv.getRuntime().newArray(ll); - } - - - @JRubyClass(name="Zlib::ZStream") - public static abstract class ZStream extends RubyObject { - protected boolean closed = false; - protected boolean ended = false; - protected boolean finished = false; - - protected abstract int internalTotalOut(); - protected abstract boolean internalStreamEndP(); - protected abstract void internalEnd(); - protected abstract void internalReset(); - protected abstract int internalAdler(); - protected abstract IRubyObject internalFinish() throws Exception; - protected abstract int internalTotalIn(); - protected abstract void internalClose(); - - public ZStream(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - @JRubyMethod(name = "initialize", frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(Block unusedBlock) { - return this; - } - - @JRubyMethod(name = "flust_next_out") - public IRubyObject flush_next_out() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "total_out") - public IRubyObject total_out() { - return getRuntime().newFixnum(internalTotalOut()); - } - - @JRubyMethod(name = "stream_end?") - public IRubyObject stream_end_p() { - return internalStreamEndP() ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "data_type") - public IRubyObject data_type() { - return getRuntime().fastGetModule("Zlib").fastGetConstant("UNKNOWN"); - } - - @JRubyMethod(name = "closed?") - public IRubyObject closed_p() { - return closed ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "ended?") - public IRubyObject ended_p() { - return ended ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "end") - public IRubyObject end() { - if(!ended) { - internalEnd(); - ended = true; - } - return getRuntime().getNil(); - } - - @JRubyMethod(name = "reset") - public IRubyObject reset() { - internalReset(); - return getRuntime().getNil(); - } - - @JRubyMethod(name = "avail_out") - public IRubyObject avail_out() { - return RubyFixnum.zero(getRuntime()); - } - - @JRubyMethod(name = "avail_out=", required = 1) - public IRubyObject set_avail_out(IRubyObject p1) { - return p1; - } - - @JRubyMethod(name = "adler") - public IRubyObject adler() { - return getRuntime().newFixnum(internalAdler()); - } - - @JRubyMethod(name = "finish") - public IRubyObject finish() throws Exception { - if(!finished) { - finished = true; - return internalFinish(); - } - return RubyString.newEmptyString(getRuntime()); - } - - @JRubyMethod(name = "avail_in") - public IRubyObject avail_in() { - return RubyFixnum.zero(getRuntime()); - } - - @JRubyMethod(name = "flush_next_in") - public IRubyObject flush_next_in() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "total_in") - public IRubyObject total_in() { - return getRuntime().newFixnum(internalTotalIn()); - } - - @JRubyMethod(name = "finished?") - public IRubyObject finished_p() { - return finished ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "close") - public IRubyObject close() { - if(!closed) { - internalClose(); - closed = true; - } - return getRuntime().getNil(); - } - } - - @JRubyClass(name="Zlib::Inflate", parent="Zlib::ZStream") - public static class Inflate extends ZStream { - protected static final ObjectAllocator INFLATE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new Inflate(runtime, klass); - } - }; - - @JRubyMethod(name = "inflate", required = 1, meta = true) - public static IRubyObject s_inflate(IRubyObject recv, IRubyObject string) throws Exception { - return ZlibInflate.s_inflate(recv,string.convertToString().getByteList()); - } - - public Inflate(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - private ZlibInflate infl; - - @JRubyMethod(name = "initialize", rest = true, visibility = Visibility.PRIVATE) - public IRubyObject _initialize(IRubyObject[] args) throws Exception { - infl = new ZlibInflate(this); - return this; - } - - @JRubyMethod(name = "<<", required = 1) - public IRubyObject append(IRubyObject arg) { - infl.append(arg); - return this; - } - - @JRubyMethod(name = "sync_point?") - public IRubyObject sync_point_p() { - return infl.sync_point(); - } - - @JRubyMethod(name = "set_dictionary", required = 1) - public IRubyObject set_dictionary(IRubyObject arg) throws Exception { - return infl.set_dictionary(arg); - } - - @JRubyMethod(name = "inflate", required = 1) - public IRubyObject inflate(IRubyObject string) throws Exception { - return infl.inflate(string.convertToString().getByteList()); - } - - @JRubyMethod(name = "sync", required = 1) - public IRubyObject sync(IRubyObject string) { - return infl.sync(string); - } - - protected int internalTotalOut() { - return infl.getInflater().getTotalOut(); - } - - protected boolean internalStreamEndP() { - return infl.getInflater().finished(); - } - - protected void internalEnd() { - infl.getInflater().end(); - } - - protected void internalReset() { - infl.getInflater().reset(); - } - - protected int internalAdler() { - return infl.getInflater().getAdler(); - } - - protected IRubyObject internalFinish() throws Exception { - infl.finish(); - return getRuntime().getNil(); - } - - public IRubyObject finished_p() { - return infl.getInflater().finished() ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - protected int internalTotalIn() { - return infl.getInflater().getTotalIn(); - } - - protected void internalClose() { - infl.close(); - } - } - - @JRubyClass(name="Zlib::Deflate", parent="Zlib::ZStream") - public static class Deflate extends ZStream { - protected static final ObjectAllocator DEFLATE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new Deflate(runtime, klass); - } - }; - - @JRubyMethod(name = "deflate", required = 1, optional = 1, meta = true) - public static IRubyObject s_deflate(IRubyObject recv, IRubyObject[] args) throws Exception { - args = Arity.scanArgs(recv.getRuntime(),args,1,1); - int level = -1; - if(!args[1].isNil()) { - level = RubyNumeric.fix2int(args[1]); - } - return ZlibDeflate.s_deflate(recv,args[0].convertToString().getByteList(),level); - } - - public Deflate(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - private ZlibDeflate defl; - - @JRubyMethod(name = "initialize", optional = 4, visibility = Visibility.PRIVATE) - public IRubyObject _initialize(IRubyObject[] args) throws Exception { - args = Arity.scanArgs(getRuntime(),args,0,4); - int level = -1; - int window_bits = 15; - int memlevel = 8; - int strategy = 0; - if(!args[0].isNil()) { - level = RubyNumeric.fix2int(args[0]); - } - if(!args[1].isNil()) { - window_bits = RubyNumeric.fix2int(args[1]); - } - if(!args[2].isNil()) { - memlevel = RubyNumeric.fix2int(args[2]); - } - if(!args[3].isNil()) { - strategy = RubyNumeric.fix2int(args[3]); - } - defl = new ZlibDeflate(this,level,window_bits,memlevel,strategy); - return this; - } - - @JRubyMethod(name = "<<", required = 1) - public IRubyObject append(IRubyObject arg) throws Exception { - defl.append(arg); - return this; - } - - @JRubyMethod(name = "params", required = 2) - public IRubyObject params(IRubyObject level, IRubyObject strategy) { - defl.params(RubyNumeric.fix2int(level),RubyNumeric.fix2int(strategy)); - return getRuntime().getNil(); - } - - @JRubyMethod(name = "set_dictionary", required = 1) - public IRubyObject set_dictionary(IRubyObject arg) throws Exception { - return defl.set_dictionary(arg); - } - - @JRubyMethod(name = "flush", optional = 1) - public IRubyObject flush(IRubyObject[] args) throws Exception { - int flush = 2; // SYNC_FLUSH - if(args.length == 1) { - if(!args[0].isNil()) { - flush = RubyNumeric.fix2int(args[0]); - } - } - return defl.flush(flush); - } - - @JRubyMethod(name = "deflate", required = 1, optional = 1) - public IRubyObject deflate(IRubyObject[] args) throws Exception { - args = Arity.scanArgs(getRuntime(),args,1,1); - int flush = 0; // NO_FLUSH - if(!args[1].isNil()) { - flush = RubyNumeric.fix2int(args[1]); - } - return defl.deflate(args[0].convertToString().getByteList(),flush); - } - - protected int internalTotalOut() { - return defl.getDeflater().getTotalOut(); - } - - protected boolean internalStreamEndP() { - return defl.getDeflater().finished(); - } - - protected void internalEnd() { - defl.getDeflater().end(); - } - - protected void internalReset() { - defl.getDeflater().reset(); - } - - protected int internalAdler() { - return defl.getDeflater().getAdler(); - } - - protected IRubyObject internalFinish() throws Exception { - return defl.finish(); - } - - protected int internalTotalIn() { - return defl.getDeflater().getTotalIn(); - } - - protected void internalClose() { - defl.close(); - } - } - - @JRubyClass(name="Zlib::GzipFile") - public static class RubyGzipFile extends RubyObject { - @JRubyClass(name="Zlib::GzipFile::Error", parent="Zlib::Error") - public static class Error {} - @JRubyClass(name="Zlib::GzipFile::CRCError", parent="Zlib::GzipFile::Error") - public static class CRCError extends Error {} - @JRubyClass(name="Zlib::GzipFile::NoFooter", parent="Zlib::GzipFile::Error") - public static class NoFooter extends Error {} - @JRubyClass(name="Zlib::GzipFile::LengthError", parent="Zlib::GzipFile::Error") - public static class LengthError extends Error {} - - private static IRubyObject wrap(ThreadContext context, RubyGzipFile instance, - IRubyObject io, Block block) throws IOException { - if (block.isGiven()) { - try { - block.yield(context, instance); - - return instance.getRuntime().getNil(); - } finally { - if (!instance.isClosed()) instance.close(); - } - } - - return io; - } - - @JRubyMethod(name = "wrap", required = 1, frame = true, meta = true) - public static IRubyObject wrap(ThreadContext context, IRubyObject recv, IRubyObject io, Block block) throws IOException { - Ruby runtime = recv.getRuntime(); - RubyGzipFile instance; - - // TODO: People extending GzipWriter/reader will break. Find better way here. - if (recv == runtime.getModule("Zlib").getClass("GzipWriter")) { - instance = RubyGzipWriter.newGzipWriter(recv, new IRubyObject[] { io }, block); - } else { - instance = RubyGzipReader.newInstance(recv, new IRubyObject[] { io }, block); - } - - return wrap(context, instance, io, block); - } - - protected static final ObjectAllocator GZIPFILE_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyGzipFile(runtime, klass); - } - }; - - @JRubyMethod(name = "new", frame = true, meta = true) - public static RubyGzipFile newInstance(IRubyObject recv, Block block) { - RubyClass klass = (RubyClass)recv; - - RubyGzipFile result = (RubyGzipFile) klass.allocate(); - - result.callInit(new IRubyObject[0], block); - - return result; - } - - protected boolean closed = false; - protected boolean finished = false; - private int os_code = 255; - private int level = -1; - private String orig_name; - private String comment; - protected IRubyObject realIo; - private IRubyObject mtime; - - public RubyGzipFile(Ruby runtime, RubyClass type) { - super(runtime, type); - mtime = runtime.getNil(); - } - - @JRubyMethod(name = "os_code") - public IRubyObject os_code() { - return getRuntime().newFixnum(os_code); - } - - @JRubyMethod(name = "closed?") - public IRubyObject closed_p() { - return closed ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - protected boolean isClosed() { - return closed; - } - - @JRubyMethod(name = "orig_name") - public IRubyObject orig_name() { - return orig_name == null ? getRuntime().getNil() : getRuntime().newString(orig_name); - } - - @JRubyMethod(name = "to_io") - public IRubyObject to_io() { - return realIo; - } - - @JRubyMethod(name = "comment") - public IRubyObject comment() { - return comment == null ? getRuntime().getNil() : getRuntime().newString(comment); - } - - @JRubyMethod(name = "crc") - public IRubyObject crc() { - return RubyFixnum.zero(getRuntime()); - } - - @JRubyMethod(name = "mtime") - public IRubyObject mtime() { - return mtime; - } - - @JRubyMethod(name = "sync") - public IRubyObject sync() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "finish") - public IRubyObject finish() throws IOException { - if (!finished) { - //io.finish(); - } - finished = true; - return realIo; - } - - @JRubyMethod(name = "close") - public IRubyObject close() throws IOException { - return null; - } - - @JRubyMethod(name = "level") - public IRubyObject level() { - return getRuntime().newFixnum(level); - } - - @JRubyMethod(name = "sync=", required = 1) - public IRubyObject set_sync(IRubyObject ignored) { - return getRuntime().getNil(); - } - } - - @JRubyClass(name="Zlib::GzipReader", parent="Zlib::GzipFile", include="Enumerable") - public static class RubyGzipReader extends RubyGzipFile { - @JRubyClass(name="Zlib::GzipReader::Error", parent="Zlib::GzipReader") - public static class Error {} - protected static final ObjectAllocator GZIPREADER_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyGzipReader(runtime, klass); - } - }; - - @JRubyMethod(name = "new", rest = true, frame = true, meta = true) - public static RubyGzipReader newInstance(IRubyObject recv, IRubyObject[] args, Block block) { - RubyClass klass = (RubyClass)recv; - RubyGzipReader result = (RubyGzipReader)klass.allocate(); - result.callInit(args, block); - return result; - } - - @JRubyMethod(name = "open", required = 1, frame = true, meta = true) - public static IRubyObject open(final ThreadContext context, IRubyObject recv, IRubyObject filename, Block block) throws IOException { - Ruby runtime = recv.getRuntime(); - IRubyObject io = RuntimeHelpers.invoke(context, runtime.getFile(), "open", filename, runtime.newString("rb")); - RubyGzipFile instance = newInstance(recv, new IRubyObject[]{io}, Block.NULL_BLOCK); - - return RubyGzipFile.wrap(context, instance, io, block); - } - - public RubyGzipReader(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - private int line; - private InputStream io; - - @JRubyMethod(name = "initialize", required = 1, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize(IRubyObject io, Block unusedBlock) { - realIo = io; - try { - this.io = new GZIPInputStream(new IOInputStream(io)); - } catch (IOException e) { - Ruby runtime = io.getRuntime(); - RubyClass errorClass = runtime.fastGetModule("Zlib").fastGetClass("GzipReader").fastGetClass("Error"); - throw new RaiseException(RubyException.newException(runtime, errorClass, e.getMessage())); - } - - line = 1; - - return this; - } - - @JRubyMethod(name = "rewind") - public IRubyObject rewind() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "lineno") - public IRubyObject lineno() { - return getRuntime().newFixnum(line); - } - - @JRubyMethod(name = "readline", writes = FrameField.LASTLINE) - public IRubyObject readline(ThreadContext context) throws IOException { - IRubyObject dst = gets(context, new IRubyObject[0]); - if (dst.isNil()) { - throw getRuntime().newEOFError(); - } - return dst; - } - - public IRubyObject internalGets(IRubyObject[] args) throws IOException { - ByteList sep = ((RubyString)getRuntime().getGlobalVariables().get("$/")).getByteList(); - if (args.length > 0) { - sep = args[0].convertToString().getByteList(); - } - return internalSepGets(sep); - } - - private IRubyObject internalSepGets(ByteList sep) throws IOException { - ByteList result = new ByteList(); - int ce = io.read(); - while (ce != -1 && sep.indexOf(ce) == -1) { - result.append((byte)ce); - ce = io.read(); - } - line++; - result.append(sep); - return RubyString.newString(getRuntime(),result); - } - - @JRubyMethod(name = "gets", optional = 1, writes = FrameField.LASTLINE) - public IRubyObject gets(ThreadContext context, IRubyObject[] args) throws IOException { - IRubyObject result = internalGets(args); - if (!result.isNil()) { - context.getCurrentFrame().setLastLine(result); - } - return result; - } - - private final static int BUFF_SIZE = 4096; - - @JRubyMethod(name = "read", optional = 1) - public IRubyObject read(IRubyObject[] args) throws IOException { - if (args.length == 0 || args[0].isNil()) { - ByteList val = new ByteList(10); - byte[] buffer = new byte[BUFF_SIZE]; - int read = io.read(buffer); - while (read != -1) { - val.append(buffer,0,read); - read = io.read(buffer); - } - return RubyString.newString(getRuntime(),val); - } - - int len = RubyNumeric.fix2int(args[0]); - if (len < 0) { - throw getRuntime().newArgumentError("negative length " + len + " given"); - } else if (len > 0) { - byte[] buffer = new byte[len]; - int toRead = len; - int offset = 0; - int read = 0; - while (toRead > 0) { - read = io.read(buffer,offset,toRead); - if (read == -1) { - break; - } - toRead -= read; - offset += read; - } // hmm... - return RubyString.newString(getRuntime(),new ByteList(buffer,0,len-toRead,false)); - } - - return RubyString.newEmptyString(getRuntime()); - } - - @JRubyMethod(name = "lineno=", required = 1) - public IRubyObject set_lineno(IRubyObject lineArg) { - line = RubyNumeric.fix2int(lineArg); - return lineArg; - } - - @JRubyMethod(name = "pos") - public IRubyObject pos() { - return RubyFixnum.zero(getRuntime()); - } - - @JRubyMethod(name = "readchar") - public IRubyObject readchar() throws IOException { - int value = io.read(); - if (value == -1) { - throw getRuntime().newEOFError(); - } - return getRuntime().newFixnum(value); - } - - @JRubyMethod(name = "getc") - public IRubyObject getc() throws IOException { - int value = io.read(); - return value == -1 ? getRuntime().getNil() : getRuntime().newFixnum(value); - } - - private boolean isEof() throws IOException { - return ((GZIPInputStream)io).available() != 1; - } - - @JRubyMethod(name = "close") - public IRubyObject close() throws IOException { - if (!closed) { - io.close(); - } - this.closed = true; - return getRuntime().getNil(); - } - - @JRubyMethod(name = "eof") - public IRubyObject eof() throws IOException { - return isEof() ? getRuntime().getTrue() : getRuntime().getFalse(); - } - - @JRubyMethod(name = "eof?") - public IRubyObject eof_p() throws IOException { - return eof(); - } - - @JRubyMethod(name = "unused") - public IRubyObject unused() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "tell") - public IRubyObject tell() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "each", optional = 1, frame = true) - public IRubyObject each(ThreadContext context, IRubyObject[] args, Block block) throws IOException { - ByteList sep = ((RubyString)getRuntime().getGlobalVariables().get("$/")).getByteList(); - - if (args.length > 0 && !args[0].isNil()) { - sep = args[0].convertToString().getByteList(); - } - - while (!isEof()) { - block.yield(context, internalSepGets(sep)); - } - - return getRuntime().getNil(); - } - - @JRubyMethod(name = "ungetc", required = 1) - public IRubyObject ungetc(IRubyObject arg) { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "readlines", optional = 1) - public IRubyObject readlines(IRubyObject[] args) throws IOException { - List<IRubyObject> array = new ArrayList<IRubyObject>(); - - if (args.length != 0 && args[0].isNil()) { - array.add(read(new IRubyObject[0])); - } else { - ByteList seperator = ((RubyString)getRuntime().getGlobalVariables().get("$/")).getByteList(); - if (args.length > 0) { - seperator = args[0].convertToString().getByteList(); - } - while (!isEof()) { - array.add(internalSepGets(seperator)); - } - } - return getRuntime().newArray(array); - } - - @JRubyMethod(name = "each_byte", frame = true) - public IRubyObject each_byte(ThreadContext context, Block block) throws IOException { - int value = io.read(); - - while (value != -1) { - block.yield(context, getRuntime().newFixnum(value)); - value = io.read(); - } - - return getRuntime().getNil(); - } - } - - @JRubyClass(name="Zlib::GzipWriter", parent="Zlib::GzipFile") - public static class RubyGzipWriter extends RubyGzipFile { - protected static final ObjectAllocator GZIPWRITER_ALLOCATOR = new ObjectAllocator() { - public IRubyObject allocate(Ruby runtime, RubyClass klass) { - return new RubyGzipWriter(runtime, klass); - } - }; - - @JRubyMethod(name = "new", rest = true, frame = true, meta = true) - public static RubyGzipWriter newGzipWriter(IRubyObject recv, IRubyObject[] args, Block block) { - RubyClass klass = (RubyClass)recv; - - RubyGzipWriter result = (RubyGzipWriter)klass.allocate(); - result.callInit(args, block); - return result; - } - - @JRubyMethod(name = "open", required = 1, optional = 2, frame = true, meta = true) - public static IRubyObject open(final ThreadContext context, IRubyObject recv, IRubyObject[] args, Block block) throws IOException { - Ruby runtime = recv.getRuntime(); - IRubyObject level = runtime.getNil(); - IRubyObject strategy = runtime.getNil(); - - if (args.length > 1) { - level = args[1]; - if (args.length > 2) strategy = args[2]; - } - - IRubyObject io = RuntimeHelpers.invoke(context, runtime.getFile(), "open", args[0], runtime.newString("wb")); - RubyGzipFile instance = newGzipWriter(recv, new IRubyObject[]{io, level, strategy}, Block.NULL_BLOCK); - - return RubyGzipFile.wrap(context, instance, io, block); - } - - public RubyGzipWriter(Ruby runtime, RubyClass type) { - super(runtime, type); - } - - private GZIPOutputStream io; - - @JRubyMethod(name = "initialize", required = 1, rest = true, frame = true, visibility = Visibility.PRIVATE) - public IRubyObject initialize2(IRubyObject[] args, Block unusedBlock) throws IOException { - realIo = (RubyObject)args[0]; - this.io = new GZIPOutputStream(new IOOutputStream(args[0])); - - return this; - } - - @JRubyMethod(name = "close") - public IRubyObject close() throws IOException { - if (!closed) { - io.close(); - } - this.closed = true; - - return getRuntime().getNil(); - } - - @JRubyMethod(name = "append", required = 1) - public IRubyObject append(IRubyObject p1) throws IOException { - this.write(p1); - return this; - } - - @JRubyMethod(name = "printf", required = 1, rest = true) - public IRubyObject printf(ThreadContext context, IRubyObject[] args) throws IOException { - write(RubyKernel.sprintf(context, this, args)); - return context.getRuntime().getNil(); - } - - @JRubyMethod(name = "print", rest = true) - public IRubyObject print(IRubyObject[] args) throws IOException { - if (args.length != 0) { - for (int i = 0, j = args.length; i < j; i++) { - write(args[i]); - } - } - - IRubyObject sep = getRuntime().getGlobalVariables().get("$\\"); - if (!sep.isNil()) { - write(sep); - } - - return getRuntime().getNil(); - } - - @JRubyMethod(name = "pos") - public IRubyObject pos() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "orig_name=", required = 1) - public IRubyObject set_orig_name(IRubyObject ignored) { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "comment=", required = 1) - public IRubyObject set_comment(IRubyObject ignored) { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "putc", required = 1) - public IRubyObject putc(IRubyObject p1) throws IOException { - io.write(RubyNumeric.fix2int(p1)); - return p1; - } - - @JRubyMethod(name = "puts", rest = true) - public IRubyObject puts(ThreadContext context, IRubyObject[] args) throws IOException { - RubyStringIO sio = (RubyStringIO)getRuntime().fastGetClass("StringIO").newInstance(context, new IRubyObject[0], Block.NULL_BLOCK); - sio.puts(context, args); - write(sio.string()); - - return getRuntime().getNil(); - } - - public IRubyObject finish() throws IOException { - if (!finished) { - io.finish(); - } - finished = true; - return realIo; - } - - @JRubyMethod(name = "flush", optional = 1) - public IRubyObject flush(IRubyObject[] args) throws IOException { - if (args.length == 0 || args[0].isNil() || RubyNumeric.fix2int(args[0]) != 0) { // Zlib::NO_FLUSH - io.flush(); - } - return getRuntime().getNil(); - } - - @JRubyMethod(name = "mtime=", required = 1) - public IRubyObject set_mtime(IRubyObject ignored) { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "tell") - public IRubyObject tell() { - return getRuntime().getNil(); - } - - @JRubyMethod(name = "write", required = 1) - public IRubyObject write(IRubyObject p1) throws IOException { - ByteList bytes = p1.convertToString().getByteList(); - io.write(bytes.unsafeBytes(), bytes.begin(), bytes.length()); - return getRuntime().newFixnum(bytes.length()); - } - } -} -/***** BEGIN LICENSE BLOCK ***** - * Version: CPL 1.0/GPL 2.0/LGPL 2.1 - * - * The contents of this file are subject to the Common Public - * License Version 1.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.eclipse.org/legal/cpl-v10.html - * - * Software distributed under the License is distributed on an "AS - * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or - * implied. See the License for the specific language governing - * rights and limitations under the License. - * - * Copyright (C) 2002 Jan Arne Petersen <jpetersen@uni-bonn.de> - * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se> - * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org> - * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de> - * - * Alternatively, the contents of this file may be used under the terms of - * either of the GNU General Public License Version 2 or later (the "GPL"), - * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), - * in which case the provisions of the GPL or the LGPL are applicable instead - * of those above. If you wish to allow use of your version of this file only - * under the terms of either the GPL or the LGPL, and not to allow others to - * use your version of this file under the terms of the CPL, indicate your - * decision by deleting the provisions above and replace them with the notice - * and other provisions required by the GPL or the LGPL. If you do not delete - * the provisions above, a recipient may use your version of this file under - * the terms of any one of the CPL, the GPL or the LGPL. - ***** END LICENSE BLOCK *****/ -package org.jruby; - -import org.jruby.runtime.Arity; -import org.jruby.runtime.Block; -import org.jruby.runtime.builtin.IRubyObject; -import org.jruby.runtime.callback.Callback; - -/** - * - * @author jpetersen - */ -public final class TopSelfFactory { - - /** - * Constructor for TopSelfFactory. - */ - private TopSelfFactory() { - super(); - } - - public static IRubyObject createTopSelf(final Ruby runtime) { - IRubyObject topSelf = new RubyObject(runtime, runtime.getObject()); - - topSelf.getSingletonClass().defineFastMethod("to_s", new Callback() { - /** - * @see org.jruby.runtime.callback.Callback#execute(IRubyObject, IRubyObject[]) - */ - public IRubyObject execute(IRubyObject recv, IRubyObject[] args, Block block) { - return runtime.newString("main"); - } - - /** - * @see org.jruby.runtime.callback.Callback#getArity() - */ - public Arity getArity() { - return Arity.noArguments(); - } - }); - - // The following three methods must be defined fast, since they expect to modify the current frame - // (i.e. they expect no frame will be allocated for them). JRUBY-1185. - topSelf.getSingletonClass().defineFastPrivateMethod("include", new Callback() { - /** - * @see org.jruby.runtime.callback.Callback#execute(IRubyObject, IRubyObject[]) - */ - public IRubyObject execute(IRubyObject recv, IRubyObject[] args, Block block) { - runtime.secure(4); - return runtime.getObject().include(args); - } - - /** - * @see org.jruby.runtime.callback.Callback#getArity() - */ - public Arity getArity() { - return Arity.optional(); - } - }); - - topSelf.getSingletonClass().defineFastPrivateMethod("public", new Callback() { - /** - * @see org.jruby.runtime.callback.Callback#execute(IRubyObject, IRubyObject[]) - */ - public IRubyObject execute(IRubyObject recv, IRubyObject[] args, Block unusedBlock) { - return runtime.getObject().rbPublic(recv.getRuntime().getCurrentContext(), args); - } - - /** - * @see org.jruby.runtime.callback.Callback#getArity() - */ - public Arity getArity() { - return Arity.optional(); - } - }); - - topSelf.getSingletonClass().defineFastPrivateMethod("private", new Callback() { - /** - * @see org.jruby.runtime.callback.Callback#execute(IRubyObject, IRubyObject[]) - */ - public IRubyObject execute(IRubyObject recv, IRubyObject[] args, Block unusedBlock) { - return runtime.getObject().rbPrivate(recv.getRuntime().getCurrentContext(), args); - } - - /** - * @see org.jruby.runtime.callback.Callback#getArity() - */ - public Arity getArity() { - return Arity.optional(); - } - }); - - return topSelf; - } -} |