1   package debugger.resources;
2   
3   import debugger.resources.pr.TraceContainer;
4   import gate.AnnotationSet;
5   import gate.Gate;
6   import gate.annotation.AnnotationSetImpl;
7   import gate.creole.ExecutionException;
8   import gate.creole.ExecutionInterruptedException;
9   import gate.creole.SerialAnalyserController;
10  import gate.event.AnnotationSetEvent;
11  import gate.event.AnnotationSetListener;
12  import gate.gui.MainFrame;
13  import gate.gui.SerialControllerEditor;
14  import gate.jape.RightHandSide;
15  import gate.jape.SinglePhaseTransducer;
16  
17  import java.awt.event.ActionEvent;
18  import java.util.HashMap;
19  import java.util.Iterator;
20  
21  import debugger.ClassRipper;
22  import debugger.JapeDebugger;
23  import debugger.gui.GuiFactory;
24  import debugger.gui.actions.debugging.ExecuteRHSAction;
25  import debugger.gui.actions.debugging.GoNextBreakpointAction;
26  import debugger.gui.actions.debugging.RunControllerAction;
27  import debugger.gui.actions.resources.LrResourceSelectedAction;
28  import debugger.gui.actions.resources.RuleSelectedAction;
29  import debugger.resources.pr.PhaseModel;
30  import debugger.resources.pr.PrModel;
31  import debugger.resources.pr.RuleModel;
32  
33  import javax.swing.*;
34  
35  /**
36   * Copyright (c) Ontos AG (http://www.ontosearch.com).
37   * This class is part of JAPE Debugger component for
38   * GATE (Copyright (c) "The University of Sheffield" see http://gate.ac.uk/) <br>
39   * @author Andrey Shafirin
40   */
41  public class PhaseController implements AnnotationSetListener {
42      private static PhaseController ourInstance;
43      private static int DebugLevel = 3;
44  //    private PhaseView phaseView;
45      private SPTLock sptLock;
46      private boolean isStopAfterRHSExec;
47      private AnnotationSet ruleAnnotations;
48      private TraceContainer traceContainer = new TraceContainer();
49  
50      private SinglePhaseTransducer currentSPT;
51      private RightHandSide currentRHS;
52  
53      public boolean isStopAfterRHSExec() {
54          return isStopAfterRHSExec;
55      }
56  
57      public void setStopAfterRHSExec(boolean stopAfterRHSExec) {
58          isStopAfterRHSExec = stopAfterRHSExec;
59      }
60  
61      public void continueSPT() {
62          synchronized (sptLock) {
63              this.sptLock.notifyAll();
64          }
65      }
66  
67  //    public static PhaseController getInstance()
68  //    {
69  //        if(ourInstance == null)
70  //        {
71  ////            ourInstance = new Phase
72  //            return new PhaseController();
73  //        }
74  //        return ourInstance;
75  //    }
76  
77      public void RuleMatched(SPTLock sptLock, SinglePhaseTransducer spt, RightHandSide rhs,
78                              gate.Document document, HashMap bindings,
79                              AnnotationSet inputAS, AnnotationSet outputAS) {
80          if (DebugLevel >= 5) {
81              System.out.print("DEBUG [" + this.getClass().getName() + "]: ");
82              System.out.println("RuleMatched(..) rhs phaseName/ruleName: [" + rhs.getPhaseName() + "/" + rhs.getRuleName() + "]");
83          }
84          // save lock to be able to continue SPT execution later
85          this.sptLock = sptLock;
86          // looking up for rule
87          PhaseModel phase = ResourcesFactory.getPrRoot().getPhase(spt);
88          if (phase == null) return;
89  
90          RuleModel rule = phase.getRule(rhs.getRuleName());
91          if (null != rule) {
92              if (rule.isStopOnMatch()) {
93                  if (DebugLevel >= 4) {
94                      System.out.print("DEBUG [" + this.getClass().getName() + "]: ");
95                      System.out.println("rule match break point catched! rhs phaseName/ruleName: [" + rhs.getPhaseName() + "/" + rhs.getRuleName() + "]");
96                  }
97                  rule.setBindings(bindings);
98                  LrResourceSelectedAction.getInstance().actionPerformed(
99                          ResourcesFactory.getLrRoot().getDocumentModel(document));
100                 //ResourcesFactory.setCurrentRuleModel(rule);
101                 RuleSelectedAction.getInstance().actionPerformed(rule);
102                 SwingUtilities.invokeLater(new Runnable(){
103                     public void run()
104                     {
105                         ExecuteRHSAction.getInstance().setEnabled(true);
106                         GoNextBreakpointAction.getInstance().setEnabled(true);
107                         // Andrey Shafirn
108                         //RunControllerAction.getInstance().setEnabled(true);
109                         GuiFactory.getDebugPanel().selectJapeRulePanel();
110                         JapeDebugger.getMainFrame().requestFocus();
111                     }
112                 });
113 
114                 MainFrame.unlockGUI();
115                 document.getAnnotations().addAnnotationSetListener(this);
116                 this.ruleAnnotations = new AnnotationSetImpl(document);
117                 this.currentSPT = spt;
118                 this.currentRHS = rhs;
119                 try {
120                     synchronized (sptLock) {
121                         sptLock.wait();
122                     }
123                 } catch (InterruptedException e) {
124                     e.printStackTrace();
125                 }
126             }
127         }
128     }
129 
130     public void RuleFinished(SPTLock sptLock, SinglePhaseTransducer spt,
131                              RightHandSide rhs, gate.Document document, HashMap bindings,
132                              AnnotationSet inputAS, AnnotationSet outputAS) {
133         if (DebugLevel >= 5) {
134             System.out.print("DEBUG [" + this.getClass().getName() + "]: ");
135             System.out.println("RuleFinished(..) rhs phaseName/ruleName: [" + rhs.getPhaseName() + "/" + rhs.getRuleName() + "]");
136         }
137         // save lock to be able to continue SPT execution later
138         this.sptLock = sptLock;
139         // looking up for rule
140         PhaseModel phase = ResourcesFactory.getPrRoot().getPhase(spt);
141         if (phase == null) return;
142 
143         RuleModel rule = phase.getRule(rhs.getRuleName());
144         if (null != rule) {
145             if (DebugLevel >= 4) {
146                 System.out.print("DEBUG [" + this.getClass().getName() + "]: ");
147                 System.out.println("RHS executed! rhs phaseName/ruleName: [" + rhs.getPhaseName() + "/" + rhs.getRuleName() + "]");
148             }
149             if (rule.isStopOnMatch()) {
150 //                DebugController.getInstance().getRuleController().addCreatedAnnotations(spt, rhs, this.ruleAnnotations.get());
151                 RuleModel rm = rule;//DebugController.getInstance().getResourceController().getResourceModel().getPRResource(spt).getPhase(spt).getRule(rhs);
152                 rm.getAnnotationHistory().addAnnotationSet(this.ruleAnnotations.get());
153                 document.getAnnotations().removeAnnotationSetListener(this);
154             }
155             if (this.isStopAfterRHSExec) {
156                 if (this.currentSPT != spt || this.currentRHS != rhs) {
157                     throw new RuntimeException("Rule Finished called for another rule!!!");
158                 }
159 //                rule.setSPT(spt);
160                 rule.setBindings(bindings);//???
161                 LrResourceSelectedAction.getInstance().actionPerformed(
162                         ResourcesFactory.getLrRoot().getDocumentModel(document));
163                 //ResourcesFactory.setCurrentRuleModel(rule);
164                 RuleSelectedAction.getInstance().actionPerformed(rule);
165                 SwingUtilities.invokeLater(new Runnable(){
166                     public void run()
167                     {
168                         ExecuteRHSAction.getInstance().setEnabled(false);
169                         GoNextBreakpointAction.getInstance().setEnabled(true);
170                         // Andrey Shafirn
171                         //RunControllerAction.getInstance().setEnabled(true);
172                         GuiFactory.getDebugPanel().selectJapeRulePanel();
173                         JapeDebugger.getMainFrame().requestFocus();
174                     }
175                 });
176 
177 
178                 MainFrame.unlockGUI();
179                 try {
180                     synchronized (sptLock) {
181                         sptLock.wait();
182                     }
183                 } catch (InterruptedException e) {
184                     e.printStackTrace();
185                 }
186             }
187         }
188     }
189 
190     /**Called when a new {@link gate.Annotation} has been added*/
191     public void annotationAdded
192             (AnnotationSetEvent
193             e) {
194         this.ruleAnnotations.add(e.getAnnotation());
195     }
196 
197     /**Called when an {@link gate.Annotation} has been removed*/
198     public void annotationRemoved
199             (AnnotationSetEvent
200             e) {
201         // TODO: probably we'll need to add AnnotationSetListener to this annotation
202         // to remove references to annotations removed by another rules later
203         this.ruleAnnotations.remove(e.getAnnotation());
204     }
205 
206     public void runControllerButtonActionPerformed(ActionEvent ae) {
207         for (Iterator it = Gate.getCreoleRegister().getVrInstances().iterator(); it.hasNext();) {
208             Object current = it.next();
209             if (current instanceof SerialControllerEditor) {
210                 SerialAnalyserController controller = null;
211                 try {
212                     controller = (SerialAnalyserController) ClassRipper.getFieldValue(current, "controller");
213                 } catch (IllegalAccessException e) {
214                     e.printStackTrace();
215                 }
216                 if (controller != null) {
217                     final SerialAnalyserController controller1 = controller;
218                     Runnable runnable = new Runnable() {
219                         public void run() {
220                             try {
221                                 Gate.setExecutable(controller1);
222                                 controller1.execute();
223                             } catch (ExecutionInterruptedException eie) {
224                                 eie.printStackTrace();
225                             } catch (ExecutionException e) {
226                                 e.printStackTrace();
227                             } catch (Exception ee) {
228                                 ee.printStackTrace();
229                             } finally {
230                                 Gate.setExecutable(null);
231                             }
232                         }
233                     };
234                     Thread thread = new Thread(Thread.currentThread().getThreadGroup(), runnable, "ApplicationViewer1");
235                     thread.setPriority(Thread.MIN_PRIORITY);
236                     thread.start();
237                 }
238                 break;
239             }
240         }
241     }
242 
243     public void TraceTransit(TraceContainer traceContainer) {
244         this.traceContainer.addAll(traceContainer);
245         //System.out.println("count in Phase " + this.traceContainer.size());
246     }
247 
248     public TraceContainer getRuleTrace() {
249         return this.traceContainer;
250     }
251 
252     public SinglePhaseTransducer getSPT() {
253 //        return DebugController.getInstance().getRuleController().getSPT();
254         return null;
255     }
256 
257 }
258