ThreadManager.xcsm

//xlang Source, Name:ThreadManager.xcsm 
//Date: Sun Sep 02:03:10 2018 

class ThreadManager{

	public static Object threadLock = new Object();
    
    public static long currentThreadId = 0;
    public static int currentFrameId = 0;
    
    public static const int XDBG_STATE_UPDATE	=	0;	//状态更新
	public static const int XDBG_STATE_CREATE	=	1;	//线程创建
	public static const int XDBG_STATE_EXIT		=	2;	//线程退出
	public static const int XDBG_STATE_EXCEPTION = 	4;	//捕获异常
    public static const int XDBG_STATE_REIGGEBP 	= 	8;	//触发断点
    
    public static class StackFrame{
		public int id;
		public String source;
        public long ip;
        public int line;
        public int column;
        public long moffset;
        public String method ;
        public String path ;
        public StackFrame(int _id, JsonObject frame){
			id = id;
            if (frame != nilptr){
                source = frame.getString("source");
                String tmofst = frame.getString("moffset");
                if (tmofst != nilptr){
                    moffset = tmofst.parseLong();
                }
                ip = frame.getLong("ip");
                method = frame.getString("method");
                path = frame.getString("path");
                line = frame.getInt("line");
                column = frame.getInt("column");
            }
        }
    };
    
    public static class ThreadObject{
		public long id;
        public bool bInterrupt;
        public String name;
        public bool bException;
        public bool bSender = false;
        public StackFrame [] frames;       
        
        public String except_name;
        public String except_msg; 
        public String except_addr;
        
        public ThreadObject(@NotNilptr JsonObject thread){
			parse(thread);
        }
        
        public void parse(@NotNilptr JsonObject thread){
			id = thread.getLong("id");
			name = thread.getString("name");
            if (name != nilptr && name.length() == 0){
				name = "Thread:" + id;
            }
            bInterrupt = thread.getBool("interrupt");
            if (thread.has("sender")){
                bSender = thread.getBool("sender");
            }
            JsonObject exception = (JsonObject)thread.get("exception");
            
            if (exception != nilptr){
                bException = true;
				parseException(exception);
            }
            
			parseStack((JsonArray)thread.get("stack"));
            
        }
        
        public void parseException(@NotNilptr JsonObject exception){
			except_name = exception.getString("name");
            except_msg = exception.getString("msg");
            if (except_msg == nilptr || except_msg.length() == 0){
                except_msg = "<没有更多信息>";
            }
            except_addr = exception.getString("address");
        }
        
        public void parseStack(JsonArray stacks){
			if (stacks != nilptr){
				int size = stacks.length();
				frames = new StackFrame[size];
				for (int i = 0; i < size; i ++){
					frames[i] = new StackFrame(i, (JsonObject)stacks.get(i));
				}
            }
        }
    };
    
    
    static Map<long, ThreadObject> thread_list = new Map<long, ThreadObject>();
    
    public static void Update(@NotNilptr JsonObject root, bool reset){
		synchronized(threadLock){
        
			if (reset){
				thread_list.clear();
            }
          
            JsonArray threads = (JsonArray)root.get("threads");
            int action = root.getInt("action");
            
            bool remove = false;
            
            if (action == XDBG_STATE_EXIT){
				remove = true;
            }

            if (threads != nilptr){ 
                int c = threads.length();
                bool bNeedUpdateFrame = false;
                bool interrupted = false;
                for (int i = 0; i < c; i++){
                    JsonObject thread = (JsonObject)threads.get(i);
                    if (thread == nilptr){
                        continue;
                    }
                    long tid = 0;
                    
                    if (remove){
                        tid = thread.getLong("id");
                        thread_list.remove(tid);
                    }else{
                        ThreadObject to = new ThreadObject(thread);
                        tid = to.id;
                        if (tid != 0){
                            thread_list.put(tid, to);
                            interrupted = to.bInterrupt;
                            if (to.bSender){
                                setThreadFrameId(tid, 0);
                            }
                        }
                    }
                    if (tid != 0){
                        XStackInfor.updateThread(tid, action);
                        if (tid == currentThreadId){
                            bNeedUpdateFrame = interrupted;
                        }
                    }
                }
                if (bNeedUpdateFrame){
                    updateDisplayInformation();
                }
            }
        }
    }
    
    public static bool isCurrentInterrupt(){
		bool bInterrupt = false;
		synchronized(threadLock){
			Map.Iterator<long,ThreadObject> iter = thread_list.find(currentThreadId);
			if (iter != nilptr){
                ThreadObject to = iter.getValue();
                if (to != nilptr){
                    bInterrupt = to.bInterrupt;
                }
			}
		}
        return bInterrupt;
    }
    
    public static void updateControlPane(long thread){
		bool bInterrupt = false;
		synchronized(threadLock){
			Map.Iterator<long,ThreadObject> iter = thread_list.find(thread);
			if (iter != nilptr){
                ThreadObject to = iter.getValue();
                if (to != nilptr){
                    bInterrupt = to.bInterrupt;
                }
			}
		}
        XWorkspace.workspace.refreshDebugControl(bInterrupt);
    }
    
    public static void updateDisplayInformation(){
        if (currentThreadId > 0){
            updateControlPane(currentThreadId);
            XWorkspace.workspace.debuggee.queryFrame(currentThreadId, currentFrameId);
        }
    }
    
    public static void setThreadFrameId(long tid, int frame){
		synchronized(threadLock){
			currentThreadId = tid;
			currentFrameId = frame;
        }
    }
    
    public static void setCurrentThread(long tid, int frame){
		setThreadFrameId(tid, frame);
        updateDisplayInformation();
    }
    
    public static ThreadObject getThread(long tid){
		synchronized(threadLock){
			Map.Iterator<long, ThreadObject> iterator = thread_list.find(tid);
            if (iterator != nilptr){
				return iterator.getValue();
			}
        }
        return nilptr;
    }
};