KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jruby > runtime > ThreadContext


1 /***** BEGIN LICENSE BLOCK *****
2  * Version: CPL 1.0/GPL 2.0/LGPL 2.1
3  *
4  * The contents of this file are subject to the Common Public
5  * License Version 1.0 (the "License"); you may not use this file
6  * except in compliance with the License. You may obtain a copy of
7  * the License at http://www.eclipse.org/legal/cpl-v10.html
8  *
9  * Software distributed under the License is distributed on an "AS
10  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
11  * implied. See the License for the specific language governing
12  * rights and limitations under the License.
13  *
14  * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>
15  * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>
16  * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>
17  * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com>
18  * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>
19  * Copyright (C) 2006 Michael Studman <codehaus@michaelstudman.com>
20  * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com>
21  *
22  * Alternatively, the contents of this file may be used under the terms of
23  * either of the GNU General Public License Version 2 or later (the "GPL"),
24  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
25  * in which case the provisions of the GPL or the LGPL are applicable instead
26  * of those above. If you wish to allow use of your version of this file only
27  * under the terms of either the GPL or the LGPL, and not to allow others to
28  * use your version of this file under the terms of the CPL, indicate your
29  * decision by deleting the provisions above and replace them with the notice
30  * and other provisions required by the GPL or the LGPL. If you do not delete
31  * the provisions above, a recipient may use your version of this file under
32  * the terms of any one of the CPL, the GPL or the LGPL.
33  ***** END LICENSE BLOCK *****/

34 package org.jruby.runtime;
35
36 import org.jruby.Ruby;
37 import org.jruby.RubyArray;
38 import org.jruby.RubyClass;
39 import org.jruby.RubyModule;
40 import org.jruby.RubyThread;
41 import org.jruby.lexer.yacc.ISourcePosition;
42 import org.jruby.lexer.yacc.SourcePositionFactory;
43 import org.jruby.parser.LocalStaticScope;
44 import org.jruby.parser.StaticScope;
45 import org.jruby.runtime.builtin.IRubyObject;
46 import org.jruby.util.collections.SinglyLinkedList;
47
48 /**
49  * @author jpetersen
50  */

51 public class ThreadContext {
52     private final static int INITIAL_SIZE = 50;
53     
54     private final Ruby runtime;
55
56     // Is this thread currently with in a function trace?
57
private boolean isWithinTrace;
58     
59     // Is this thread currently doing an defined? defined should set things like $!
60
private boolean isWithinDefined;
61
62     private RubyThread thread;
63     
64     //private UnsynchronizedStack parentStack;
65
private RubyModule[] parentStack = new RubyModule[INITIAL_SIZE];
66     private int parentIndex = -1;
67     
68     //private UnsynchronizedStack frameStack;
69
private Frame[] frameStack = new Frame[INITIAL_SIZE];
70     private int frameIndex = -1;
71     //private UnsynchronizedStack crefStack;
72
private SinglyLinkedList[] crefStack = new SinglyLinkedList[INITIAL_SIZE];
73     private int crefIndex = -1;
74     
75     // List of active dynamic scopes. Each of these may have captured other dynamic scopes
76
// to implement closures.
77
private DynamicScope[] scopeStack = new DynamicScope[INITIAL_SIZE];
78     private int scopeIndex = -1;
79     
80     private String JavaDoc[] catchStack = new String JavaDoc[INITIAL_SIZE];
81     private int catchIndex = -1;
82
83     private int[] bindingFrameStack = new int[INITIAL_SIZE];
84     private int bindingFrameIndex = -1;
85
86     private RubyModule wrapper;
87
88     private ISourcePosition sourcePosition = new SourcePositionFactory(null).getDummyPosition();
89
90     /**
91      * Constructor for Context.
92      */

93     public ThreadContext(Ruby runtime) {
94         this.runtime = runtime;
95         
96         // TOPLEVEL self and a few others want a top-level scope. We create this one right
97
// away and then pass it into top-level parse so it ends up being the top level.
98
pushScope(new DynamicScope(new LocalStaticScope(null), null));
99     }
100     
101     Visibility lastVis;
102     CallType lastCallType;
103     
104     public Ruby getRuntime() {
105         return runtime;
106     }
107
108     /**
109      * Returns the lastCallStatus.
110      * @return LastCallStatus
111      */

112     public void setLastCallStatus(Visibility vis, CallType callType) {
113         lastVis = vis;
114         lastCallType = callType;
115     }
116     
117     public Visibility getLastVisibility() {
118         return lastVis;
119     }
120     
121     public CallType getLastCallType() {
122         return lastCallType;
123     }
124
125     public void printScope() {
126         System.out.println("SCOPE STACK:");
127         for (int i = 0; i <= scopeIndex; i++) {
128             System.out.println(scopeStack[i]);
129         }
130     }
131     
132     public DynamicScope getCurrentScope() {
133         return scopeStack[scopeIndex];
134     }
135     
136     private void expandFramesIfNecessary() {
137         if (frameIndex + 1 == frameStack.length) {
138             int newSize = frameStack.length * 2;
139             Frame[] newFrameStack = new Frame[newSize];
140             
141             System.arraycopy(frameStack, 0, newFrameStack, 0, frameStack.length);
142             
143             frameStack = newFrameStack;
144         }
145     }
146     
147     private void expandParentsIfNecessary() {
148         if (parentIndex + 1 == parentStack.length) {
149             int newSize = parentStack.length * 2;
150             RubyModule[] newParentStack = new RubyModule[newSize];
151             
152             System.arraycopy(parentStack, 0, newParentStack, 0, parentStack.length);
153             
154             parentStack = newParentStack;
155         }
156     }
157     
158     private void expandCrefsIfNecessary() {
159         if (crefIndex + 1 == crefStack.length) {
160             int newSize = crefStack.length * 2;
161             SinglyLinkedList[] newCrefStack = new SinglyLinkedList[newSize];
162             
163             System.arraycopy(crefStack, 0, newCrefStack, 0, crefStack.length);
164             
165             crefStack = newCrefStack;
166         }
167     }
168     
169     public void pushScope(DynamicScope scope) {
170         scopeStack[++scopeIndex] = scope;
171         expandScopesIfNecessary();
172     }
173     
174     public void popScope() {
175         scopeStack[scopeIndex--] = null;
176     }
177
178     private void expandScopesIfNecessary() {
179         if (scopeIndex + 1 == scopeStack.length) {
180             int newSize = scopeStack.length * 2;
181             DynamicScope[] newScopeStack = new DynamicScope[newSize];
182             
183             System.arraycopy(scopeStack, 0, newScopeStack, 0, scopeStack.length);
184             
185             scopeStack = newScopeStack;
186         }
187     }
188
189     public RubyThread getThread() {
190         return thread;
191     }
192
193     public void setThread(RubyThread thread) {
194         this.thread = thread;
195     }
196
197     public IRubyObject getLastline() {
198         return getCurrentScope().getLastLine();
199     }
200
201     public void setLastline(IRubyObject value) {
202         getCurrentScope().setLastLine(value);
203     }
204     
205     //////////////////// CATCH MANAGEMENT ////////////////////////
206
private void expandCatchIfNecessary() {
207         if (catchIndex + 1 == catchStack.length) {
208             int newSize = catchStack.length * 2;
209             String JavaDoc[] newCatchStack = new String JavaDoc[newSize];
210     
211             System.arraycopy(catchStack, 0, newCatchStack, 0, catchStack.length);
212             catchStack = newCatchStack;
213         }
214     }
215     
216     public void pushCatch(String JavaDoc catchSymbol) {
217         catchStack[++catchIndex] = catchSymbol;
218         expandCatchIfNecessary();
219     }
220
221     public void popCatch() {
222         catchIndex--;
223     }
224
225     public String JavaDoc[] getActiveCatches() {
226         if (catchIndex < 0) return new String JavaDoc[0];
227
228         String JavaDoc[] activeCatches = new String JavaDoc[catchIndex + 1];
229         System.arraycopy(catchStack, 0, activeCatches, 0, catchIndex + 1);
230         return activeCatches;
231     }
232     
233     //////////////////// FRAME MANAGEMENT ////////////////////////
234
private void pushFrameCopy() {
235         pushFrame(getCurrentFrame().duplicate());
236     }
237     
238     private void pushCallFrame(RubyModule clazz, String JavaDoc name,
239             IRubyObject self, IRubyObject[] args, Block block) {
240         pushFrame(new Frame(clazz, self, name, args, block, getPosition()));
241     }
242     
243     private void pushFrame() {
244         pushFrame(new Frame(getPosition()));
245     }
246     
247     private void pushFrame(Frame frame) {
248         frameStack[++frameIndex] = frame;
249         expandFramesIfNecessary();
250     }
251     
252     private void popFrame() {
253         Frame frame = (Frame)frameStack[frameIndex--];
254
255         setPosition(frame.getPosition());
256     }
257     
258     public Frame getCurrentFrame() {
259         return (Frame)frameStack[frameIndex];
260     }
261     
262     public Frame getPreviousFrame() {
263         int size = frameIndex + 1;
264         return size <= 1 ? null : (Frame) frameStack[size - 2];
265     }
266     
267     public int getFrameCount() {
268         return frameIndex + 1;
269     }
270     
271     public String JavaDoc getFrameName() {
272         return getCurrentFrame().getName();
273     }
274     
275     public IRubyObject[] getFrameArgs() {
276         return getCurrentFrame().getArgs();
277     }
278     
279     public void setFrameArgs(IRubyObject[] args) {
280         getCurrentFrame().setArgs(args);
281     }
282     
283     public IRubyObject getFrameSelf() {
284         return getCurrentFrame().getSelf();
285     }
286     
287     public void setFrameSelf(IRubyObject self) {
288         getCurrentFrame().setSelf(self);
289     }
290
291     public void setSelfToPrevious() {
292         getCurrentFrame().setSelf(getPreviousFrame().getSelf());
293     }
294
295     public RubyModule getFrameKlazz() {
296         return getCurrentFrame().getKlazz();
297     }
298     
299     public ISourcePosition getFramePosition() {
300         return getCurrentFrame().getPosition();
301     }
302     
303     public ISourcePosition getPreviousFramePosition() {
304         return getPreviousFrame().getPosition();
305     }
306
307     private void expandBindingFrameIfNecessary() {
308         if (bindingFrameIndex + 1 == bindingFrameStack.length) {
309             int newSize = bindingFrameStack.length * 2;
310             int[] newbindingFrameStack = new int[newSize];
311     
312             System.arraycopy(bindingFrameStack, 0, newbindingFrameStack, 0, bindingFrameStack.length);
313             bindingFrameStack = newbindingFrameStack;
314         }
315     }
316     
317     public void pushBindingFrame(int bindingDepth) {
318         bindingFrameStack[++bindingFrameIndex] = bindingDepth;
319         expandBindingFrameIfNecessary();
320     }
321
322     public void popBindingFrame() {
323         bindingFrameIndex--;
324     }
325
326
327     public int currentBindingFrame() {
328         if(bindingFrameIndex == -1) {
329             return 0;
330         } else {
331             return bindingFrameStack[bindingFrameIndex];
332         }
333     }
334
335     public ISourcePosition getPosition() {
336         return sourcePosition;
337     }
338     
339     public String JavaDoc getSourceFile() {
340         return sourcePosition.getFile();
341     }
342     
343     public int getSourceLine() {
344         return sourcePosition.getEndLine();
345     }
346
347     public void setPosition(ISourcePosition position) {
348         sourcePosition = position;
349     }
350
351     public IRubyObject getBackref() {
352         IRubyObject value = getCurrentScope().getBackRef();
353         
354         // DynamicScope does not preinitialize these values since they are virtually
355
// never used.
356
return value == null ? runtime.getNil() : value;
357     }
358
359     public void setBackref(IRubyObject backref) {
360         getCurrentScope().setBackRef(backref);
361     }
362
363     public Visibility getCurrentVisibility() {
364         return getCurrentFrame().getVisibility();
365     }
366
367     public Visibility getPreviousVisibility() {
368         return getPreviousFrame().getVisibility();
369     }
370     
371     public void setCurrentVisibility(Visibility visibility) {
372         getCurrentFrame().setVisibility(visibility);
373     }
374
375     public IRubyObject callSuper(IRubyObject[] args, Block block) {
376         Frame frame = getCurrentFrame();
377         
378         if (frame.getKlazz() == null) {
379             String JavaDoc name = frame.getName();
380             throw runtime.newNameError("superclass method '" + name + "' must be enabled by enableSuper().", name);
381         }
382
383         RubyClass superClass = frame.getKlazz().getSuperClass();
384         
385         assert superClass != null : "Superclass should always be something for " + frame.getKlazz().getBaseName();
386
387         return frame.getSelf().callMethod(this, superClass, frame.getName(), args, CallType.SUPER, block);
388     }
389
390     /**
391      * Yield to the block passed to the current frame.
392      *
393      * @param value The value to yield, either a single value or an array of values
394      * @return The result of the yield
395      */

396     public IRubyObject yield(IRubyObject value, Block block) {
397         return block.yield(this, value, null, null, false);
398     }
399     
400     /**
401      * Used by compiler
402      *
403      * @param block
404      */

405     public void raiseErrorIfNoBlock(Block block) {
406         if (!block.isGiven()) throw runtime.newLocalJumpError("yield called out of block");
407     }
408
409     public void pollThreadEvents() {
410         getThread().pollThreadEvents();
411     }
412     
413     public SinglyLinkedList peekCRef() {
414         return (SinglyLinkedList)crefStack[crefIndex];
415     }
416     
417     public void setCRef(SinglyLinkedList newCRef) {
418         crefStack[++crefIndex] = newCRef;
419         expandCrefsIfNecessary();
420     }
421     
422     public void unsetCRef() {
423         crefStack[crefIndex--] = null;
424     }
425     
426     public SinglyLinkedList pushCRef(RubyModule newModule) {
427         if (crefIndex == -1) {
428             crefStack[++crefIndex] = new SinglyLinkedList(newModule, null);
429         } else {
430             crefStack[crefIndex] = new SinglyLinkedList(newModule, (SinglyLinkedList)crefStack[crefIndex]);
431         }
432         
433         return (SinglyLinkedList)peekCRef();
434     }
435     
436     public RubyModule popCRef() {
437         assert !(crefIndex == -1) : "Tried to pop from empty CRef stack";
438         
439         RubyModule module = (RubyModule)peekCRef().getValue();
440         
441         SinglyLinkedList next = ((SinglyLinkedList)crefStack[crefIndex--]).getNext();
442         
443         if (next != null) {
444             crefStack[++crefIndex] = next;
445         } else {
446             crefStack[crefIndex+1] = null;
447         }
448         
449         return module;
450     }
451
452     public void pushRubyClass(RubyModule currentModule) {
453         assert currentModule != null : "Can't push null RubyClass";
454         
455         parentStack[++parentIndex] = currentModule;
456         expandParentsIfNecessary();
457     }
458     
459     public RubyModule popRubyClass() {
460         RubyModule ret = (RubyModule)parentStack[parentIndex];
461         parentStack[parentIndex--] = null;
462         return ret;
463     }
464     
465     public RubyModule getRubyClass() {
466         assert !(parentIndex == -1) : "Trying to get RubyClass from empty stack";
467         
468         RubyModule parentModule = (RubyModule)parentStack[parentIndex];
469
470         return parentModule.getNonIncludedClass();
471     }
472
473     public RubyModule getBindingRubyClass() {
474         RubyModule parentModule = null;
475         if(parentIndex == 0) {
476             parentModule = (RubyModule)parentStack[parentIndex];
477         } else {
478             parentModule = (RubyModule)parentStack[parentIndex-1];
479
480         }
481         return parentModule.getNonIncludedClass();
482     }
483
484     public boolean isTopLevel() {
485         return parentIndex == 0;
486     }
487
488     public RubyModule getWrapper() {
489         return wrapper;
490     }
491
492     public void setWrapper(RubyModule wrapper) {
493         this.wrapper = wrapper;
494     }
495
496     public boolean getConstantDefined(String JavaDoc name) {
497         IRubyObject result = null;
498         
499         // flipped from while to do to search current class first
500
for (SinglyLinkedList cbase = peekCRef(); cbase != null; cbase = cbase.getNext()) {
501           result = ((RubyModule) cbase.getValue()).getConstantAt(name);
502           if (result != null || runtime.getLoadService().autoload(name) != null) {
503               return true;
504           }
505         }
506         
507         return false;
508     }
509
510     public IRubyObject getConstant(String JavaDoc name) {
511         //RubyModule self = state.threadContext.getRubyClass();
512
SinglyLinkedList cbase = peekCRef();
513         RubyClass object = runtime.getObject();
514         IRubyObject result = null;
515         
516         // flipped from while to do to search current class first
517
do {
518           RubyModule klass = (RubyModule) cbase.getValue();
519           
520           // Not sure how this can happen
521
//if (NIL_P(klass)) return rb_const_get(CLASS_OF(self), id);
522
result = klass.getConstantAt(name);
523           if (result == null) {
524               if (runtime.getLoadService().autoload(name) != null) {
525                   continue;
526               }
527           } else {
528               return result;
529           }
530           cbase = cbase.getNext();
531         } while (cbase != null && cbase.getValue() != object);
532         
533         return ((RubyModule) peekCRef().getValue()).getConstant(name);
534     }
535
536     public IRubyObject getConstant(String JavaDoc name, RubyModule module) {
537         //RubyModule self = state.threadContext.getRubyClass();
538
SinglyLinkedList cbase = module.getCRef();
539         IRubyObject result = null;
540         
541         // flipped from while to do to search current class first
542
do {
543           RubyModule klass = (RubyModule) cbase.getValue();
544           
545           // Not sure how this can happen
546
//if (NIL_P(klass)) return rb_const_get(CLASS_OF(self), id);
547
result = klass.getConstantAt(name);
548           if (result == null) {
549               if (runtime.getLoadService().autoload(name) != null) {
550                   continue;
551               }
552           } else {
553               return result;
554           }
555           cbase = cbase.getNext();
556         } while (cbase != null);
557         
558         //System.out.println("CREF is " + state.threadContext.getCRef().getValue());
559
return ((RubyModule) peekCRef().getValue()).getConstant(name);
560     }
561
562     private void addBackTraceElement(RubyArray backtrace, Frame frame, Frame previousFrame) {
563         StringBuffer JavaDoc sb = new StringBuffer JavaDoc(100);
564         ISourcePosition position = frame.getPosition();
565     
566         if(previousFrame != null && frame.getName() != null && previousFrame.getName() != null &&
567            frame.getName().equals(previousFrame.getName()) &&
568            frame.getPosition().getFile().equals(previousFrame.getPosition().getFile()) &&
569            frame.getPosition().getEndLine() == previousFrame.getPosition().getEndLine()) {
570             return;
571         }
572     
573         sb.append(position.getFile()).append(':').append(position.getEndLine());
574     
575         if (previousFrame != null && previousFrame.getName() != null) {
576             sb.append(":in `").append(previousFrame.getName()).append('\'');
577         } else if (previousFrame == null && frame.getName() != null) {
578             sb.append(":in `").append(frame.getName()).append('\'');
579         }
580     
581         backtrace.append(backtrace.getRuntime().newString(sb.toString()));
582     }
583
584     /**
585      * Create an Array with backtrace information.
586      * @param runtime
587      * @param level
588      * @param nativeException
589      * @return an Array with the backtrace
590      */

591     public IRubyObject createBacktrace(int level, boolean nativeException) {
592         RubyArray backtrace = runtime.newArray();
593         int base = currentBindingFrame();
594         int traceSize = frameIndex - level;
595         
596         if (traceSize <= 0) {
597             return backtrace;
598         }
599         
600         if (nativeException) {
601             // assert level == 0;
602
addBackTraceElement(backtrace, frameStack[frameIndex], null);
603         }
604         
605         for (int i = traceSize; i > base; i--) {
606             addBackTraceElement(backtrace, (Frame) frameStack[i], (Frame) frameStack[i-1]);
607         }
608     
609         return backtrace;
610     }
611     
612     public void preAdoptThread() {
613         pushFrame();
614         pushRubyClass(runtime.getObject());
615         pushCRef(runtime.getObject());
616         getCurrentFrame().setSelf(runtime.getTopSelf());
617     }
618
619     public void preClassEval(StaticScope staticScope, RubyModule type) {
620         pushCRef(type);
621         pushRubyClass(type);
622         pushFrameCopy();
623         getCurrentFrame().setVisibility(Visibility.PUBLIC);
624         pushScope(new DynamicScope(staticScope, getCurrentScope()));
625     }
626     
627     public void postClassEval() {
628         popCRef();
629         popScope();
630         popRubyClass();
631         popFrame();
632     }
633     
634     public void preBsfApply(String JavaDoc[] names) {
635         // FIXME: I think we need these pushed somewhere?
636
LocalStaticScope staticScope = new LocalStaticScope(null);
637         staticScope.setVariables(names);
638         pushFrame();
639     }
640     
641     public void postBsfApply() {
642         popFrame();
643     }
644
645     public void preMethodCall(RubyModule implementationClass, RubyModule clazz,
646             IRubyObject self, String JavaDoc name, IRubyObject[] args, Block block, boolean noSuper) {
647         pushRubyClass((RubyModule)implementationClass.getCRef().getValue());
648         pushCallFrame(noSuper ? null : clazz, name, self, args, block);
649     }
650     
651     public void postMethodCall() {
652         popFrame();
653         popRubyClass();
654     }
655     
656     public void preDefMethodInternalCall(RubyModule clazz, String JavaDoc name,
657             IRubyObject self, IRubyObject[] args, Block block, boolean noSuper,
658             SinglyLinkedList cref, StaticScope staticScope) {
659         RubyModule implementationClass = (RubyModule)cref.getValue();
660         setCRef(cref);
661         pushCallFrame(noSuper ? null : clazz, name, self, args, block);
662         pushScope(new DynamicScope(staticScope, getCurrentScope()));
663         pushRubyClass(implementationClass);
664     }
665     
666     public void postDefMethodInternalCall() {
667         popRubyClass();
668         popScope();
669         popFrame();
670         unsetCRef();
671     }
672     
673     public void preCompiledMethod(RubyModule implementationClass, SinglyLinkedList cref) {
674         pushRubyClass(implementationClass);
675         setCRef(cref);
676     }
677     
678     public void postCompiledMethod() {
679         popRubyClass();
680         unsetCRef();
681     }
682     
683     // NEW! Push a scope into the frame, since this is now required to use it
684
// XXX: This is screwy...apparently Ruby runs internally-implemented methods in their own frames but in the *caller's* scope
685
public void preReflectedMethodInternalCall(RubyModule implementationClass, RubyModule klazz, IRubyObject self, String JavaDoc name, IRubyObject[] args, boolean noSuper, Block block) {
686         pushRubyClass((RubyModule)implementationClass.getCRef().getValue());
687         pushCallFrame(noSuper ? null : klazz, name, self, args, block);
688         getCurrentFrame().setVisibility(getPreviousFrame().getVisibility());
689     }
690     
691     public void postReflectedMethodInternalCall() {
692         popFrame();
693         popRubyClass();
694     }
695     
696     public void preInitCoreClasses() {
697         pushFrame();
698         setCurrentVisibility(Visibility.PRIVATE);
699     }
700     
701     public void preInitBuiltinClasses(RubyClass objectClass, IRubyObject topSelf) {
702         pushRubyClass(objectClass);
703         setCRef(objectClass.getCRef());
704         
705         Frame frame = getCurrentFrame();
706         frame.setSelf(topSelf);
707     }
708     
709     public void preNodeEval(RubyModule newWrapper, RubyModule rubyClass, IRubyObject self) {
710         setWrapper(newWrapper);
711         pushRubyClass(rubyClass);
712         pushCallFrame(null, null, self, IRubyObject.NULL_ARRAY, Block.NULL_BLOCK);
713         
714         setCRef(rubyClass.getCRef());
715     }
716     
717     public void postNodeEval(RubyModule newWrapper) {
718         popFrame();
719         popRubyClass();
720         setWrapper(newWrapper);
721         unsetCRef();
722     }
723     
724     // XXX: Again, screwy evaling under previous frame's scope
725
public void preExecuteUnder(RubyModule executeUnderClass, Block block) {
726         Frame frame = getCurrentFrame();
727         
728         pushRubyClass(executeUnderClass);
729         pushCRef(executeUnderClass);
730         pushCallFrame(frame.getKlazz(), frame.getName(), frame.getSelf(), frame.getArgs(), block);
731         getCurrentFrame().setVisibility(getPreviousFrame().getVisibility());
732     }
733     
734     public void postExecuteUnder() {
735         popFrame();
736         popRubyClass();
737         popCRef();
738     }
739     
740     public void preMproc() {
741         pushFrame();
742     }
743     
744     public void postMproc() {
745         popFrame();
746     }
747     
748     public void preRunThread(Frame currentFrame) {
749         pushFrame(currentFrame);
750     }
751     
752     public void preTrace() {
753         pushFrame();
754     }
755     
756     public void postTrace() {
757         popFrame();
758     }
759     
760     public void preForBlock(Block block, RubyModule klass) {
761         pushFrame(block.getFrame());
762         setCRef(block.getCRef());
763         getCurrentFrame().setVisibility(block.getVisibility());
764         pushScope(block.getDynamicScope());
765         pushRubyClass((klass != null) ? klass : block.getKlass());
766     }
767     
768     public void preYieldSpecificBlock(Block block, RubyModule klass) {
769         //System.out.println("IN RESTORE BLOCK (" + block.getDynamicScope() + ")");
770
pushFrame(block.getFrame());
771         setCRef(block.getCRef());
772         getCurrentFrame().setVisibility(block.getVisibility());
773         pushScope(block.getDynamicScope().cloneScope());
774         pushRubyClass((klass != null) ? klass : block.getKlass());
775     }
776     
777     public void preEvalWithBinding(Block block) {
778         pushBindingFrame(frameIndex);
779         pushFrame(block.getFrame());
780         setCRef(block.getCRef());
781         getCurrentFrame().setVisibility(block.getVisibility());
782         pushRubyClass(block.getKlass());
783     }
784
785     public void postEvalWithBinding() {
786         popFrame();
787         unsetCRef();
788         popRubyClass();
789         popBindingFrame();
790     }
791     
792     public void postYield() {
793         popScope();
794         popFrame();
795         unsetCRef();
796         popRubyClass();
797      }
798
799     public void preRootNode(DynamicScope scope) {
800         pushScope(scope);
801     }
802
803     public void postRootNode() {
804         popScope();
805     }
806
807     /**
808      * Is this thread actively tracing at this moment.
809      *
810      * @return true if so
811      * @see org.jruby.Ruby#callTraceFunction(String, ISourcePosition, IRubyObject, String, IRubyObject)
812      */

813     public boolean isWithinTrace() {
814         return isWithinTrace;
815     }
816
817     /**
818      * Set whether we are actively tracing or not on this thread.
819      *
820      * @param isWithinTrace true is so
821      * @see org.jruby.Ruby#callTraceFunction(String, ISourcePosition, IRubyObject, String, IRubyObject)
822      */

823     public void setWithinTrace(boolean isWithinTrace) {
824         this.isWithinTrace = isWithinTrace;
825     }
826     
827     /**
828      * Is this thread actively in defined? at the moment.
829      *
830      * @return true if within defined?
831      */

832     public boolean isWithinDefined() {
833         return isWithinDefined;
834     }
835     
836     /**
837      * Set whether we are actively within defined? or not.
838      *
839      * @param isWithinDefined true if so
840      */

841     public void setWithinDefined(boolean isWithinDefined) {
842         this.isWithinDefined = isWithinDefined;
843     }
844 }
845
Popular Tags