--- /dev/null
+#---------------------------------------------------------------------------
+# Name: PHPDebugger.py
+# Purpose: php dbg client and supporting code
+# Author: Matt Fryer, Kevin Wang
+# Created: 2/1/06
+# Copyright: (c) 2006 ActiveGrid, Inc.
+# License: wxWindows License
+#---------------------------------------------------------------------------
+
+
+import os
+import socket
+import sys
+import threading
+import traceback
+import wx
+import DebuggerService
+import activegrid.util.sysutils as sysutils
+
+
+DBGC_REPLY = 0x0 # reply to previous DBGA_REQUEST request
+DBGC_STARTUP = 0x0001 # script startup
+DBGC_END = 0x0002 # script done
+DBGC_BREAKPOINT = 0x0003 # user definded breakpoint occured
+DBGC_STEPINTO_DONE = 0x0004 # step to the next statement is completed
+DBGC_STEPOVER_DONE = 0x0005 # step to the next statement is completed
+DBGC_STEPOUT_DONE = 0x0006 # step to the next statement is completed
+DBGC_EMBEDDED_BREAK = 0x0007 # breakpoint caused by DebugBreak() function
+DBGC_ERROR = 0x0010 # error occured
+DBGC_LOG = 0x0011 # logging support
+DBGC_SID = 0x0012 # send SID
+DBGC_PAUSE = 0x0013 # pause current session as soon as possible
+DBGC_AG_SHUTDOWN_REQ = 0x0201 # special ActiveGrid UI shutdown listening thread command
+
+
+FRAME_STACK = 100000 # "call:stack" - e.g. backtrace
+FRAME_SOURCE = 100100 # source text
+FRAME_SRC_TREE = 100200 # tree of source files
+FRAME_RAWDATA = 100300 # raw data or string
+FRAME_ERROR = 100400 # error notification
+FRAME_EVAL = 100500 # evaluating/watching
+FRAME_BPS = 100600 # set/remove breakpoint
+FRAME_BPL = 100700 # breakpoint(s) request = get the list
+FRAME_VER = 100800 # version request
+FRAME_SID = 100900 # session id info
+FRAME_SRCLINESINFO = 101000 # source lines info
+FRAME_SRCCTXINFO = 101100 # source contexts info
+FRAME_LOG = 101200 # logging
+FRAME_PROF = 101300 # profiler
+FRAME_PROF_C = 101400 # profiler counter/accuracy
+FRAME_SET_OPT = 101500 # set/update options
+
+
+DBGF_STARTED = 0x0001 # debugger has been started
+DBGF_FINISHED = 0x0002 # DBGC_END notification has been sent
+DBGF_WAITACK = 0x0004 # awaiting replay|request
+DBGF_UNSYNC = 0x0008 # protocol has been unsynchronized
+DBGF_REQUESTPENDING = 0x0010 # Debug session request pending
+DBGF_REQUESTFOUND = 0x0020 # Debug session request found
+DBGF_REJECTIONFOUND = 0x0040 # DBGSESSID=-1 found - session rejection
+
+
+E_ERROR = 1 << 0
+E_WARNING = 1 << 1
+E_PARSE = 1 << 2
+E_NOTICE = 1 << 3
+E_CORE_ERROR = 1 << 4
+E_CORE_WARNING = 1 << 5
+E_COMPILE_ERROR = 1 << 6
+E_COMPILE_WARNING = 1 << 7
+E_USER_ERROR = 1 << 8
+E_USER_WARNING = 1 << 9
+E_USER_NOTICE = 1 << 10
+
+
+BPS_DELETED = 0
+BPS_DISABLED = 1
+BPS_ENABLED = 2
+BPS_UNRESOLVED = 0x100
+
+
+DBG_SYNC = 0x5953
+DBG_SYNC2_STR = chr(0) + chr(0) + chr(89) + chr(83)
+RESPONSE_HEADER_SIZE = 16
+
+
+_VERBOSE = False
+def myprint(format, vlist=None):
+ if _VERBOSE:
+ if vlist:
+ print format % vlist
+ else:
+ print format
+
+
+#
+# 4 Char's to an Integer
+#
+def C4ToInt(ch, startPos):
+ retval = 0
+ pos = startPos
+
+ retval = retval + (CharToInt(ch[pos]) << 24)
+ pos = pos + 1
+ retval = retval + (CharToInt(ch[pos]) << 16)
+ pos = pos + 1
+ retval = retval + (CharToInt(ch[pos]) << 8)
+ pos = pos + 1
+ retval = retval + (CharToInt(ch[pos]) << 0)
+
+ return retval
+
+
+def CharToInt(ch):
+ return int((ord(ch) & 0x00FF));
+
+
+#
+# An Integer to 4 Char's
+#
+def IntToC4(num):
+ retval = chr((num >> 24) & 0x00FF)
+ retval += chr((num >> 16) & 0x00FF)
+ retval += chr((num >> 8 ) & 0x00FF)
+ retval += chr((num >> 0 ) & 0x00FF)
+
+ return retval
+
+
+DBGA_CONTINUE = IntToC4(0x8001)
+DBGA_STOP = IntToC4(0x8002)
+DBGA_STEPINTO = IntToC4(0x8003)
+DBGA_STEPOVER = IntToC4(0x8004)
+DBGA_STEPOUT = IntToC4(0x8005)
+DBGA_IGNORE = IntToC4(0x8006)
+DBGA_REQUEST = IntToC4(0x8010)
+
+
+def getCommandString(code):
+ if code == DBGC_REPLY:
+ return "REPLY"
+ elif code == DBGC_STARTUP:
+ return "STARTUP"
+ elif code == DBGC_END:
+ return "END"
+ elif code == DBGC_BREAKPOINT:
+ return "BREAKPOINT"
+ elif code == DBGC_STEPINTO_DONE:
+ return "STEPINTO DONE"
+ elif code == DBGC_STEPOVER_DONE:
+ return "STEPOVER DONE"
+ elif code == DBGC_STEPOUT_DONE:
+ return "STEPOUT DONE"
+ elif code == DBGC_EMBEDDED_BREAK:
+ return "EMBEDDED BREAK"
+ elif code == DBGC_PAUSE:
+ return "PAUSE"
+ elif code == DBGC_ERROR:
+ return "ERROR"
+ elif code == DBGC_LOG:
+ return "LOG"
+ elif code == DBGC_SID:
+ return "SEND SID"
+ elif code == DBGC_AG_SHUTDOWN_REQ:
+ return "AG SHUTDOWN REQ"
+
+
+def reportFlags(flagsValue):
+ flagsRetVal = ""
+ if flagsValue & DBGF_STARTED: # debugger has been started
+ flagsRetVal += "started+"
+ if flagsValue & DBGF_FINISHED: # DBGC_END notification has been sent
+ flagsRetVal += "finished+"
+ if flagsValue & DBGF_WAITACK: # awaiting replay|request
+ flagsRetVal += "awaiting ack+"
+ if flagsValue & DBGF_UNSYNC: # protocol has been unsynchronized
+ flagsRetVal += "protocol unsynchronized+"
+ if flagsValue & DBGF_REQUESTPENDING: # Debug session request pending
+ flagsRetVal += "request pending+"
+ if flagsValue & DBGF_REQUESTFOUND: # Debug session request found
+ flagsRetVal += "request found+"
+ if flagsValue & DBGF_REJECTIONFOUND : # DBGSESSID=-1 found - session rejection
+ flagsRetVal += "session rejection+"
+ return flagsRetVal
+
+
+def getErrorTypeString(code):
+ if code == E_ERROR:
+ return "[Error]"
+ elif code == E_WARNING:
+ return "[Warning]"
+ elif code == E_PARSE:
+ return "[Parse Error]"
+ elif code == E_NOTICE:
+ return "[Notice]"
+ elif code == E_CORE_ERROR:
+ return "[Core Error]"
+ elif code == E_CORE_WARNING:
+ return "[Core Warning]"
+ elif code == E_COMPILE_ERROR:
+ return "[Compile Error]"
+ elif code == E_COMPILE_WARNING:
+ return "[Compile Warning]"
+ elif code == E_USER_ERROR:
+ return "[User Error]"
+ elif code == E_USER_WARNING:
+ return "[User Warning]"
+ elif code == E_USER_NOTICE:
+ return "[User Notice]"
+ else:
+ return "[Unexpected Error]"
+
+
+class ResponseHeader(object):
+ def __init__(self, conn, blocking = False):
+ self.isValid = False
+ receivedData = conn.recv(RESPONSE_HEADER_SIZE, blocking)
+
+ if not receivedData:
+ myprint("Tried to get %d bytes of PHP DBG header, got None\n" % RESPONSE_HEADER_SIZE)
+ return
+ elif len(receivedData) != RESPONSE_HEADER_SIZE:
+ myprint("Tried to get %d bytes of PHP DBG header, got %d\n" % (RESPONSE_HEADER_SIZE, len(receivedData)))
+ return
+
+ self.sync = C4ToInt(receivedData, 0)
+ self.command = C4ToInt(receivedData, 4)
+ self.flags = C4ToInt(receivedData, 8)
+ self.toRead = C4ToInt(receivedData, 12)
+
+ myprint("ResponseHeader: sync=%x, command=%s, flags=(%s), toRead=%s\n", (self.sync, getCommandString(self.command), reportFlags(self.flags), self.toRead))
+ if self.sync != DBG_SYNC:
+ myprint("Sync wrong for header! Expected %x, got %s\n" % (DBG_SYNC, self.sync))
+ return
+
+ self.isValid = True
+
+
+class ResponsePacketFrame(object):
+ def __init__(self, conn, size, data, blocking = False):
+ self.isValid = False
+ self.conn = conn
+ self.data = ''
+
+ if data:
+ self.data = data
+ newlyReceived = False
+ elif conn:
+ newlyReceived = True
+
+ sizeToReceive = size
+ while True:
+ oneChunk = conn.recv(sizeToReceive, blocking)
+ sizeReceived = len(oneChunk)
+ if sizeReceived > 0:
+ self.data = self.data + oneChunk
+
+ if sizeReceived < sizeToReceive:
+ sizeToReceive = sizeToReceive - sizeReceived
+ continue
+ else:
+ break
+
+ if len(self.data) != size:
+ myprint("Expected to get %d bytes of a PHP DBG packet, got %d\n" % (size, len(self.data)))
+ return
+ else:
+ return
+
+ self.frameName = C4ToInt(self.data, 0)
+ self.frameSize = C4ToInt(self.data, 4)
+ if newlyReceived:
+ myprint("Newly received ResponsePacketFrame: frameName=%d, frameSize=%d", (self.frameName, self.frameSize))
+ else:
+ myprint("Created from existing ResponsePacketFrame: frameName=%d, frameSize=%d", (self.frameName, self.frameSize))
+
+ if self.frameSize == 0:
+ return
+
+ self.currPos = 8
+ self.totalDataLen = len(self.data)
+ self.length = 8 + self.frameSize
+ self.isValid = True
+ myprint("new ResponsePacketFrame: currPos=%s, totalDataLen=%s, length=%s", (repr(self.currPos), repr(self.totalDataLen), repr(self.length)))
+ return
+
+ def getNextInt(self):
+ myprint("getNextInt(): currPos=%s, totalDataLen=%s, length=%s", (repr(self.currPos), repr(self.totalDataLen), repr(self.length)))
+ if self.isValid and self.currPos + 4 <= self.length:
+ val = C4ToInt(self.data, self.currPos)
+ self.currPos = self.currPos + 4
+ myprint("getNextInt(): got an integar: %s", repr(val))
+ return val
+ else:
+ return self._errorReturn("getNextInt(): no more integar available with current frame: ")
+
+ def getNextString(self, strLen):
+ endPos = self.currPos + strLen
+ if self.isValid and endPos <= self.length:
+ #
+ # Trim the ending '\0'. TODO: confirm this applies to all raw string data.
+ #
+ str = self.data[self.currPos:endPos - 1]
+ self.currPos = endPos
+ myprint("getNextString(): got a string: %s", str)
+ return str
+ else:
+ return self._errorReturn("getNextString(): no more string available with current frame: ")
+
+ def getNextFrame(self, useAbsolutePos = False):
+ if useAbsolutePos:
+ #
+ # Skip this frame's header (8 bytes for frameSize and frameSize) and frame data (frameSize).
+ #
+ self.currPos = self.length
+
+ if self.isValid and self.currPos < self.totalDataLen:
+ return ResponsePacketFrame(None, None, self.data[self.currPos:])
+ else:
+ return self._errorReturn("getNextFrame(): no more frame available with current frame: ")
+
+ def _errorReturn(self, preMsg = ''):
+ myprint(preMsg + "frameName=%s, frameSize=%s, totalDataLen=%s, length=%s, currPos:%s", (repr(self.frameName), repr(self.frameSize), repr(self.totalDataLen), repr(self.length), repr(self.currPos)))
+ self.isValid = False
+ return None
+
+
+class PHPDBGFrame(object):
+ FRAME_HEADER_SIZE = 8
+ def __init__(self, frameType):
+ self.frameType = IntToC4(frameType)
+ self.frameData = ""
+
+ def addInt(self, intVal):
+ self.frameData = self.frameData + IntToC4(intVal)
+
+ def addChar(self, charVal):
+ self.frameData = self.frameData + charVal
+
+ def addStr(self, string):
+ #
+ # Add the trailing '\0'.
+ #
+ self.frameData = self.frameData + string + '\0'
+
+ def getSize(self):
+ return len(self.frameData) + PHPDBGFrame.FRAME_HEADER_SIZE
+
+ def writeFrame(self, conn):
+ header = self.frameType + IntToC4(len(self.frameData))
+ conn.sendall(header)
+ conn.sendall(self.frameData)
+
+
+class PHPDBGPacket(object):
+ def __init__(self, packetType):
+ self.header = DBG_SYNC2_STR + packetType
+ self.frames = []
+ self.packetSize = 0
+
+ def addFrame(self, frame):
+ self.frames.append(frame)
+ self.packetSize += frame.getSize()
+
+ def sendPacket(self, conn, flags = 0):
+ self.header += IntToC4(flags)
+ self.header += IntToC4(self.packetSize)
+ conn.sendall(self.header)
+ for frame in self.frames:
+ frame.writeFrame(conn)
+
+
+class PHPDBGException(Exception):
+ def __init__(self, msg = None, cause = None):
+ if (msg == None):
+ Exception.__init__(self)
+ elif (cause == None):
+ Exception.__init__(self, msg)
+ else:
+ Exception.__init__(self, "PHPDBGException: message:%s\n, cause:%s" % (msg, cause))
+
+
+class PHPDBGConnException(PHPDBGException):
+ pass
+
+
+class PHPDebuggerCallback(object):
+ ACTION_NONE = 0
+ ACTION_STOP = 1
+ ACTION_LISTEN = 2
+
+ def __init__(self, ui, service, lsnrHosti, lsnrPorti):
+ self.ui = ui
+ self.service = service
+ self.lsnrHost = lsnrHosti
+ self.lsnrPort = lsnrPorti
+ self.lsnrThr = None
+ self.lsnrAction = PHPDebuggerCallback.ACTION_NONE
+ self.clearInternals()
+ self.initLsnrThr()
+
+
+ ############################################################################
+ # Public callback functions begin
+ #
+ def Start(self):
+ self.lsnrThr.start()
+
+ def ShutdownServer(self, stopLsnr = True):
+ #
+ # First to tell php debugger to stop execution of the current PHP
+ # program. Disconnect with php dbg module too.
+ #
+ self.stopPhpDbg()
+
+ #
+ # Stop debug listener.
+ #
+ if stopLsnr:
+ self.stopLsnr()
+
+ def BreakExecution(self):
+ reqPacket = PHPDBGPacket(IntToC4(DBGC_PAUSE))
+
+ try:
+ reqPacket.sendPacket(self.lsnrThr)
+ self.awaitAndHandleResponse()
+ except PHPDBGConnException:
+ self.currConnFinished()
+ return
+
+ self.ui.LoadPHPFramesList(self.stackList)
+ return
+
+ def SingleStep(self):
+ reqPacket = PHPDBGPacket(DBGA_STEPINTO)
+
+ try:
+ reqPacket.sendPacket(self.lsnrThr)
+ self.lastCommand = DBGA_STEPINTO
+ self.awaitAndHandleResponse(blocking = True)
+ except PHPDBGConnException:
+ self.currConnFinished()
+ return
+
+ self.ui.LoadPHPFramesList(self.stackList)
+ return
+
+ def Next(self):
+ reqPacket = PHPDBGPacket(DBGA_STEPOVER)
+
+ try:
+ reqPacket.sendPacket(self.lsnrThr)
+ self.lastCommand = DBGA_STEPOVER
+ self.awaitAndHandleResponse(blocking = True)
+ except PHPDBGConnException:
+ self.currConnFinished()
+ return
+
+ self.ui.LoadPHPFramesList(self.stackList)
+ return
+
+ def Continue(self):
+ reqPacket = PHPDBGPacket(DBGA_CONTINUE)
+
+ try:
+ reqPacket.sendPacket(self.lsnrThr)
+ self.lastCommand = DBGA_CONTINUE
+ self.awaitAndHandleResponse(blocking = True)
+ except PHPDBGConnException:
+ self.currConnFinished()
+ return
+
+ self.ui.LoadPHPFramesList(self.stackList)
+ return
+
+ def Return(self):
+ reqPacket = PHPDBGPacket(DBGA_STEPOUT)
+
+ try:
+ reqPacket.sendPacket(self.lsnrThr)
+ self.lastCommand = DBGA_STEPOUT
+ self.awaitAndHandleResponse(blocking = True)
+ except PHPDBGConnException:
+ self.currConnFinished()
+ return
+
+ self.ui.LoadPHPFramesList(self.stackList)
+ return
+
+ def PushBreakpoints(self, noRemove = False):
+ tmpList = []
+ bps = self.service.GetMasterBreakpointDict()
+ for fileName in bps.keys():
+ if fileName.endswith('.php'):
+ lines = bps[fileName]
+ if lines:
+ for lineNo in lines:
+ if lineNo:
+ #
+ # A tuple (fileName, lineNo) is an item which is
+ # used as a key in self.bpDict.
+ #
+ tmpList.append(self.createBpKey(fileName, lineNo))
+ myprint("PushBreakpoints(): global breakpoint \'%s:%i\'", (fileName, lineNo))
+
+ #
+ # Check to see if we have any new breakpoints added.
+ #
+ for oneKey in tmpList:
+ if not self.bpDict.has_key(oneKey):
+ #
+ # A new breakpoint.
+ #
+ newBp = BreakPoint(self, oneKey[0], oneKey[1])
+ newBp.addSelf()
+ self.bpDict[oneKey] = newBp
+ myprint("PushBreakpoints(): newly added global breakpoint \'%s:%i\'", (oneKey[0], oneKey[1]))
+
+ if noRemove:
+ return
+
+ #
+ # Check to see if any bp that is in our list, but not in the latest
+ # global list. If so, it must have been removed recently in the
+ # global one. Remove it from our list and tell php debugger to do
+ # so as well.
+ #
+ toRemoveList = []
+ for oneKey in self.bpDict.keys():
+ if tmpList.count(oneKey) == 0:
+ toRemoveList.append((oneKey, self.bpDict[oneKey]))
+ myprint("PushBreakpoints(): recently removed global breakpoint \'%s:%i\'", (oneKey[0], oneKey[1]))
+
+ for bp in toRemoveList:
+ bp[1].removeSelf()
+ del self.bpDict[bp[0]]
+ myprint("PushBreakpoints(): successfully removed breakpoint \'%s:%i\' from both our local list and php debugger", (bp[0][0], bp[0][1]))
+
+ return
+ #
+ # Public callback functions end
+ ############################################################################
+
+
+ def newConnEventHandler(self):
+ #
+ # Ok, we've got a connection from the php debugger, and some initial
+ # frame data from it. Everything is ready and let's make some initial
+ # actions.
+ #
+ self.clearInternals()
+
+ try:
+ self.awaitAndHandleResponse(self.lsnrThr.getConnHeader())
+ except PHPDBGConnException:
+ self.currConnFinished()
+ return
+
+ self.PushBreakpoints(True)
+ self.ui.LoadPHPFramesList(self.stackList)
+
+ #
+ # This could be called when this object is constructed or when self is
+ # re-initialized after getting a new dbg module connection as a new
+ # session.
+ #
+ def clearInternals(self):
+ self.stackList = []
+ self.errStackList = []
+ self.stackFrameIndex = 0
+ self.isErrStack = False
+ self.errStr = ''
+ self.modList = []
+ self.stopOnError = True
+ self.lastCommand = None
+ self.evalRet = ''
+ self.modDict = {}
+ self.bpDict = {}
+ self.rawDataDict = {}
+ self.sessID = 0
+ self.sessType = 0
+ self.sessEnded = False
+ self.frameCounter = 1000
+ self.variableList = []
+ self.verMajor = 0
+ self.verMinor = 0
+ self.verDesc = None
+
+ def initLsnrThr(self):
+ self.actionEvent = threading.Event()
+ self.lsnrThr = PHPDBGLsnrThr(self, self.lsnrHost, self.lsnrPort, self.actionEvent, self.ui)
+
+ def awaitAndHandleResponse(self, header = None, blocking = False, disable = True, stopping = False):
+ if disable:
+ self.ui.DisableWhileDebuggerRunning()
+
+ while self.readResponse(header, blocking) != 0:
+ myprint("Waiting for response")
+
+ if stopping:
+ self.ui.DisableAfterStop()
+ else:
+ self.ui.EnableWhileDebuggerStopped()
+
+ def requestDBGVersion(self):
+ #TODO: necessary?
+ pass
+
+ def getSourceTree(self):
+ #TODO: necessary?
+ pass
+
+ def addDBGModName(self):
+ #TODO: necessary?
+ pass
+
+ def getNextFrameCounter(self):
+ self.frameCounter = self.frameCounter + 1
+ return self.frameCounter
+
+ def getVariables(self, stack):
+ self.variableList = []
+
+ reqPacket = PHPDBGPacket(DBGA_REQUEST)
+ reqFrame = PHPDBGFrame(FRAME_EVAL)
+
+ reqFrame.addInt(0)
+ reqFrame.addInt(stack.getFrameScopeId())
+ reqPacket.addFrame(reqFrame)
+ myprint("PHPDebuggerCallback::getVariables(): about to send eval request")
+
+ try:
+ reqPacket.sendPacket(self.lsnrThr)
+ self.awaitAndHandleResponse(disable = False)
+ except PHPDBGConnException:
+ self.currConnFinished()
+ return self.variableList
+
+ myprint("PHPDebuggerCallback::getVariables(): evalRet=%s", self.evalRet)
+ evalStr = PHPDBGEvalString(stack, self.evalRet)
+ if evalStr:
+ self.variableList = evalStr.getVars()
+ myprint("PHPDebuggerCallback::getVariables(): about to return")
+
+ return self.variableList
+
+ def evalBlock(self, stack, evalStr):
+ reqPacket = PHPDBGPacket(DBGA_REQUEST)
+ reqFrame1 = PHPDBGFrame(FRAME_EVAL)
+ reqFrame2 = PHPDBGFrame(FRAME_RAWDATA)
+
+ frameID = self.getNextFrameCounter()
+ reqFrame1.addInt(frameID)
+ reqFrame1.addInt(1)
+
+ reqFrame2.addInt(frameID)
+ reqFrame2.addInt(len(evalStr) + 1)
+ reqFrame2.addStr(evalString)
+
+ reqPacket.addFrame(reqFrame2)
+ reqPacket.addFrame(reqFrame1)
+
+ try:
+ reqPacket.sendPacket(self.lsnrThr)
+ self.awaitAndHandleResponse(disable = False)
+ except PHPDBGConnException:
+ self.currConnFinished()
+ return None
+
+ evalStr = PHPDBGEvalString(stack, self.evalRet)
+
+ return evalStr.getVars()
+
+ def getBPUnderHit(self):
+ for bp in self.bpDict.values():
+ if bp.isUnderHit():
+ return bp
+
+ return None
+
+ def getRawFrameData(self, frameNo):
+ if self.rawDataDict.has_key(frameNo):
+ #
+ # Once the frameData is consumed, remove it from rawDataDict.
+ #
+ return self.rawDataDict.pop(frameNo)
+ else:
+ #
+ # TODO: do we need to handle the case when the raw frame data hasn't
+ # been received before?
+ #
+ return None
+
+ def getModByNum(self, modNum):
+ if self.modDict.has_key(modNum):
+ return self.modDict[modNum]
+ else:
+ return None
+
+ def getModByFileName(self, fileName):
+ for mn, fn in self.modDict.iteritems():
+ if fn == fileName:
+ return mn
+
+ return 0
+
+ def setMod(self, modNum, fileName):
+ if modNum != 0 and fileName:
+ self.modDict[modNum] = fileName
+
+ return
+
+ def readResponse(self, headeri = None, blockingi = False):
+ inHeader = headeri
+ header = None
+ cmdReceived = 0
+ isFirstPacket = True
+ blocking = blockingi
+ self.isErrStack = False
+ self.rawDataDict.clear()
+
+ while True:
+ #
+ # If we have already received the first packet, we can't block any
+ # more.
+ #
+ if not isFirstPacket:
+ blocking = False
+
+ #
+ # If this is the first loop and we have a non-empty header passed in, use it. Otherwise,
+ # read in a new header. For subsequent loops, inHeader is None so we always read a new
+ # header from the wire.
+ #
+ if inHeader:
+ header = inHeader
+ inHeader = None
+ else:
+ header = ResponseHeader(self.lsnrThr, blocking)
+
+ if not header.isValid:
+ return 0
+
+ cmdReceived = header.command
+ frame = ResponsePacketFrame(self.lsnrThr, header.toRead, None, blocking)
+ if not frame.isValid:
+ return 0
+
+ isFirstPacket = False
+ isFirstStackFrame = True
+ while frame and frame.isValid:
+ frameName = frame.frameName
+ if frameName == FRAME_STACK:
+ if self.isErrStack:
+ self.errStackList = self.handleRespFrameStack(self.errStackList, frame, isFirstStackFrame)
+ else:
+ self.stackList = self.handleRespFrameStack(self.stackList, frame, isFirstStackFrame)
+
+ if isFirstStackFrame:
+ isFirstStackFrame = False
+ elif frameName == FRAME_SOURCE:
+ self.handleRespFrameSource(frame)
+ elif frameName == FRAME_SRC_TREE:
+ self.handleRespFrameSrcTree(frame)
+ elif frameName == FRAME_RAWDATA:
+ self.handleRespFrameRawdata(frame)
+ elif frameName == FRAME_ERROR:
+ self.handleRespFrameError(frame)
+ elif frameName == FRAME_EVAL:
+ self.handleRespFrameEval(frame)
+ elif frameName == FRAME_BPS:
+ self.handleRespFrameBps(frame)
+ elif frameName == FRAME_BPL:
+ self.handleRespFrameBpl(frame)
+ elif frameName == FRAME_VER:
+ self.handleRespFrameVer(frame)
+ elif frameName == FRAME_SID:
+ self.handleRespFrameSid(frame)
+ elif frameName == FRAME_SRCLINESINFO:
+ self.handleRespFrameSrclinesinfo(frame)
+ elif frameName == FRAME_SRCCTXINFO:
+ self.handleRespFrameSrcctxinfo(frame)
+ elif frameName == FRAME_LOG:
+ self.handleRespFrameLog(frame)
+ elif frameName == FRAME_PROF:
+ self.handleRespFrameProf(frame)
+ elif frameName == FRAME_PROF_C:
+ self.handleRespFrameProfC(frame)
+ elif frameName == FRAME_SET_OPT:
+ self.handleRespFrameSetOpt(frame)
+ else:
+ self.handleRespFrameUnknown(frame)
+ return 0
+
+ #
+ # After handling of this frame, force frame to point to the
+ # next one based on current frame's absolute size.
+ #
+ frame = frame.getNextFrame(True)
+
+ if cmdReceived == DBGC_REPLY:
+ self.handleRespCmdReply()
+ elif cmdReceived == DBGC_STARTUP:
+ self.handleRespCmdStartup()
+ elif cmdReceived == DBGC_END:
+ self.handleRespCmdEnd()
+ elif cmdReceived == DBGC_BREAKPOINT:
+ self.handleRespCmdBreakpoint()
+ cmdReceived = 0
+ elif cmdReceived == DBGC_STEPINTO_DONE:
+ self.handleRespCmdStepintoDone()
+ elif cmdReceived == DBGC_STEPOVER_DONE:
+ self.handleRespCmdStepoverDone()
+ elif cmdReceived == DBGC_STEPOUT_DONE:
+ self.handleRespCmdStepoutDone()
+ elif cmdReceived == DBGC_EMBEDDED_BREAK:
+ self.handleRespCmdEmbeddedBreak()
+ elif cmdReceived == DBGC_PAUSE:
+ self.handleRespCmdPause()
+ elif cmdReceived == DBGC_ERROR:
+ self.handleRespCmdError()
+ elif cmdReceived == DBGC_LOG:
+ self.handleRespCmdLog()
+ elif cmdReceived == DBGC_SID:
+ self.handleRespCmdSid()
+ else:
+ self.handleRespCmdUnknown()
+
+ return cmdReceived
+
+ def handleRespFrameStack(self, stackList, frame, isFirst):
+ if isFirst:
+ stackList = []
+ self.stackFrameIndex = 0
+
+ lineNo = frame.getNextInt()
+ modNo = frame.getNextInt()
+ scopeId = frame.getNextInt()
+ frameId = frame.getNextInt()
+ if modNo != 0:
+ newStackFrame = PHPStackFrame(self, self.getModByNum(modNo), lineNo, self.stackFrameIndex, scopeId, self.getRawFrameData(frameId), modNo)
+ stackList.append(newStackFrame)
+ self.stackFrameIndex = self.stackFrameIndex + 1
+
+ return stackList
+
+ def handleRespFrameSource(self, frame):
+ modNo = frame.getNextInt()
+ fromFilePos = frame.getNextInt()
+ error = frame.getNextInt()
+ fullSize = frame.getNextInt()
+ fileNameFrameId = frame.getNextInt()
+ textFrameId = frame.getNextInt()
+
+ fileName = self.getModByNum(modNo)
+ if not fileName:
+ self.setFileMod(modNo, fileNameFrameId)
+
+ #
+ # TODO: fullSize string and textFrameId are not handled here.
+ #
+ return
+
+ def handleRespFrameSrcTree(self, frame):
+ parentModNo = frame.getNextInt()
+ parentLineNo = frame.getNextInt()
+ modNo = frame.getNextInt()
+ fileNameFrameId = frame.getNextInt()
+
+ fileName = self.getModByNum(modNo)
+ if not fileName:
+ self.setFileMod(modNo, fileNameFrameId)
+
+ return
+
+ def handleRespFrameRawdata(self, frame):
+ frameNo = frame.getNextInt()
+ if frameNo > 0:
+ toRead = frame.getNextInt()
+ if toRead > 0:
+ str = frame.getNextString(toRead)
+ self.rawDataDict[frameNo] = str
+ myprint("handleRespFrameRawdata(): added \'%d\'=\'%s\' to rawDataDict.", (frameNo, str))
+
+ return
+
+ def handleRespFrameError(self, frame):
+ self.isErrStack = True
+
+ #
+ # Type of the error.
+ #
+ errInt0 = frame.getNextInt()
+ #
+ # ID of error message.
+ #
+ errInt1 = frame.getNextInt()
+
+ if errInt0 == E_ERROR:
+ errIdStr = "[Error]"
+ elif errInt0 == E_WARNING:
+ errIdStr = "[Warning]"
+ elif errInt0 == E_PARSE:
+ errIdStr = "[Parse Error]"
+ elif errInt0 == E_NOTICE:
+ errIdStr = "[Notice]"
+ elif errInt0 == E_CORE_ERROR:
+ errIdStr = "[Core Error]"
+ elif errInt0 == E_CORE_WARNING:
+ errIdStr = "[Core Warning]"
+ elif errInt0 == E_COMPILE_ERROR:
+ errIdStr = "[Compile Error]"
+ elif errInt0 == E_COMPILE_WARNING:
+ errIdStr = "[Compile Warning]"
+ elif errInt0 == E_USER_ERROR:
+ errIdStr = "[User Error]"
+ elif errInt0 == E_USER_WARNING:
+ errIdStr = "[User Warning]"
+ elif errInt0 == E_USER_NOTICE:
+ errIdStr = "[User Notice]"
+ else:
+ errIdStr = "[Unexpected Error]"
+
+ errMsg = self.getRawFrameData(errInt1)
+ if errMsg and len(errMsg) > 0:
+ self.errStr = errIdStr + ": " + errMsg + "\n"
+ else:
+ self.errStr = errIdStr + ": <Invalid Error Message>\n"
+
+ if not self.stopOnError:
+ if self.lastCommand == DBGA_CONTINUE:
+ self.Continue()
+ elif self.lastCommand == DBGA_STEPINTO:
+ self.SingleStep()
+ elif self.lastCommand == DBGA_STEPOUT:
+ self.Return()
+ elif self.lastCommand == DBGA_STEPOVER:
+ self.Next()
+
+ return
+
+ def handleRespFrameEval(self, frame):
+ evalInt0 = frame.getNextInt()
+ evalInt1 = frame.getNextInt()
+ evalInt2 = frame.getNextInt()
+ self.evalRet = self.getRawFrameData(evalInt1)
+ #TODO: is the following necessary?
+ evalStr = self.getRawFrameData(evalInt0)
+
+ return
+
+ def handleRespFrameBps(self, frame):
+ return
+
+ def handleRespFrameBpl(self, frame):
+ #
+ # Get this breakpoint.
+ #
+ dbgBp = []
+ for i in range(10):
+ dbgBp.append(frame.getNextInt())
+
+ if dbgBp[2] != 0:
+ #
+ # If filename is sent, get it from the rawDataDict.
+ #
+ fileName = self.getRawFrameData(dbgBp[2])
+ if not fileName:
+ return
+
+ #
+ # If this filename comes with a mod number, store this
+ # modNum/fileName into this session's modDict. Notice it might
+ # overwrite previous value.
+ #
+ if dbgBp[0] != 0:
+ self.setMod(dbgBp[0], fileName)
+ elif dbgBp[0] != 0:
+ #
+ # Use modNum to get the fileName.
+ #
+ fileName = self.getModByNum(dbgBp[0])
+ if not fileName:
+ return
+ else:
+ #
+ # Couldn't get the filename; nothing we can do with.
+ #
+ return
+
+ bpKey = self.createBpKey(fileName, dbgBp[1])
+ if not self.bpDict.has_key(bpKey):
+ #
+ # Not in our bp list? Anyway, create one for it.
+ #
+ ourBp = BreakPoint(self, fileName, dbgBp[1], dbgBp[0], dbgBp[3], dbgBp[4], dbgBp[5], dbgBp[6], dbgBp[7], dbgBp[8], dbgBp[9])
+ self.bpDict[bpKey] = ourBp
+ newlyCreated = True
+ else:
+ ourBp = self.bpDict[bpKey]
+ newlyCreated = False
+
+ #
+ # Update with the latest bp information.
+ #
+ if not newlyCreated:
+ ourBp.update(dbgBp)
+
+ return
+
+ def handleRespFrameVer(self, frame):
+ self.verMajor = frame.getNextInt()
+ self.verMinor = frame.getNextInt()
+ verFrameNo = frame.getNextInt()
+ self.verDesc = self.getRawFrameData(verFrameNo)
+ myprint("respFrameVer: verMajor=%s, verMinor=%s, verDesc=%s", (repr(self.verMajor), repr(self.verMinor), repr(self.verDesc)))
+
+ return
+
+ def handleRespFrameSid(self, frame):
+ self.sessID = frame.getNextInt()
+ self.sessType = frame.getNextInt()
+ myprint("respFrameSid: sessID=%s, sessType=%s", (self.sessID, self.sessType))
+
+ return
+
+ def handleRespFrameSrclinesinfo(self, frame):
+ return
+
+ def handleRespFrameSrcctxinfo(self, frame):
+ return
+
+ def handleRespFrameLog(self, frame):
+ #
+ # TODO:
+ # Now we don't do much here besides following the protocol to retrieve
+ # the data.
+ #
+ logId = frame.getNextInt()
+ logType = frame.getNextInt()
+ modNo = frame.getNextInt()
+ lineNo = frame.getNextInt()
+ fileNameFrameId = frame.getNextInt()
+ extInfo = frame.getNextInt()
+
+ fileName = self.getModByNum(modNo)
+ if not fileName:
+ self.setFileMod(modNo, fileNameFrameId)
+
+ return
+
+ def handleRespFrameProf(self, frame):
+ return
+
+ def handleRespFrameProfC(self, frame):
+ return
+
+ def handleRespFrameSetOpt(self, frame):
+ return
+
+ def handleRespCmdReply(self):
+ return
+
+ def handleRespCmdStartup(self):
+ return
+
+ def handleRespCmdEnd(self):
+ self.sessEnded = True
+ return
+
+ def handleRespCmdBreakpoint(self):
+ return
+
+ def handleRespCmdStepintoDone(self):
+ return
+
+ def handleRespCmdStepoverDone(self):
+ return
+
+ def handleRespCmdStepoutDone(self):
+ return
+
+ def handleRespCmdEmbeddedBreak(self):
+ return
+
+ def handleRespCmdPause(self):
+ return
+
+ def handleRespCmdError(self):
+ self.stackList = []
+
+ if len(self.errStackList) > 0:
+ self.errStr = self.errStr + "Stack Trace:\n"
+
+ while len(self.errStackList) > 0:
+ oneStack = self.errStackList.pop()
+ self.errStr = self.errStr + "%s\n" % oneStack.getLongDisplayStr()
+
+ self.ui.showErrorDialog(self.errStr, "PHP Error")
+ myprint("Got PHP Error:\n%s", self.errStr)
+
+ return
+
+ def handleRespCmdLog(self):
+ return
+
+ def handleRespCmdSid(self):
+ return
+
+ def setFileMod(self, modNo, fileNameFrameId):
+ if fileNameFrameId != 0:
+ fileName = self.getRawFrameData(fileNameFrameId)
+ if fileName and modNo != 0:
+ self.setMod(modNo, fileName)
+
+ return
+
+ def createBpKey(self, fileName, lineNo):
+ #
+ # This is to work around a bug in dbg module where it changes the path
+ # names that we pass to it to lower cases.
+ #
+ if sysutils.isWindows():
+ fileName = fileName.lower()
+
+ return (fileName, lineNo)
+
+ def setLsnrAction(self, actioni):
+ self.lsnrAction = actioni
+ return
+
+ def getLsnrAction(self):
+ return self.lsnrAction
+
+ def currConnFinished(self):
+ self.clearInternals()
+ self.setLsnrAction(PHPDebuggerCallback.ACTION_LISTEN)
+ self.actionEvent.set()
+ self.ui.DisableAfterStop()
+
+ def stopPhpDbg(self):
+ #
+ # TODO: should send a request to stop the current running PHP program.
+ # should handle network blocking issue correctly, otherwise, we
+ # might hang here.
+ #
+ reqPacket = PHPDBGPacket(DBGA_STOP)
+
+ try:
+ reqPacket.sendPacket(self.lsnrThr)
+ self.awaitAndHandleResponse(stopping = True)
+ except PHPDBGConnException:
+ pass
+
+ self.currConnFinished()
+ return
+
+ def stopLsnr(self):
+ if not self.lsnrThr:
+ return
+
+ #
+ # Then we try to stop our listener thread.
+ #
+ if self.lsnrThr.hasBeenConnected():
+ #
+ # If the listener thread has already accepted a connection from a
+ # php debug module/client, it is sleeping now and wait for this
+ # condition object to be set so that it can exit.
+ #
+ self.setLsnrAction(PHPDebuggerCallback.ACTION_STOP)
+ self.actionEvent.set()
+ else:
+ #
+ # If the listener thread has never been connected from a php debug
+ # module/client, it is still blocking on a accept() call. We
+ # connect to it here and send a special shutdown command asking it
+ # to exit.
+ #
+ shutdownMessage = IntToC4(DBG_SYNC) + IntToC4(DBGC_AG_SHUTDOWN_REQ) + IntToC4(0) + IntToC4(0)
+ tempSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ try:
+ tempSocket.connect((self.lsnrHost, self.lsnrPort))
+ tempSocket.sendall(shutdownMessage)
+ except:
+ myprint("shutdown connection/send message got exception!")
+
+ tempSocket.close()
+
+ self.lsnrThr.join()
+ self.lsnrThr = None
+
+
+class PHPDBGLsnrThr(threading.Thread):
+ def __init__(self, interfacei, hosti, porti, actionEventi, uii):
+ threading.Thread.__init__(self)
+ self.interface = interfacei
+ self.svrHost = hosti
+ self.svrPort = porti
+ self.actionEvent = actionEventi
+ self.svrSocket = None
+ self.clntConn = None
+ self.clntAddr = None
+ self.nonBlockingTimeout = 1
+ self.connHeader = None
+ self.ui = uii
+
+ def initSvrSocket(self):
+ self.svrSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ self.svrSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+ self.svrSocket.bind((self.svrHost, self.svrPort))
+
+ def waitForClntConn(self):
+ self.svrSocket.listen(5)
+ self.clntConn, self.clntAddr = self.svrSocket.accept()
+ self.clntConn.settimeout(self.nonBlockingTimeout)
+
+ def run(self):
+ #
+ # Initialize this server socket.
+ #
+ self.initSvrSocket()
+
+ while True:
+ #
+ # Block until we get a new connection from a php debug client or our
+ # debugger ui (with a special shutting down header/command).
+ #
+ self.waitForClntConn()
+
+ #
+ # Ok, a new connection comes in ... Read the header to see where it
+ # comes from.
+ #
+ self.connHeader = ResponseHeader(self)
+ if self.connHeader.command == DBGC_AG_SHUTDOWN_REQ:
+ #
+ # This is a special command coming from our UI asking this
+ # thread to exit. This only happens if after this thread has
+ # been waiting for new connections from PHP debug module, no one
+ # connects, and UI is ready to shutdown this thread.
+ #
+ self.shutdown()
+ break
+ else:
+ #
+ # Tell the main gui thread to handle this new connection.
+ #
+ wx.CallAfter(self.interface.newConnEventHandler)
+
+ #
+ # From now on, PHPDebuggerCallback will communicate with the php
+ # debug module using this thread's clntConn socket. This thread
+ # itself will keep sleeping until get notified to make some
+ # actions.
+ #
+ self.actionEvent.wait()
+ self.actionEvent.clear()
+
+ action = self.interface.getLsnrAction()
+ if action == PHPDebuggerCallback.ACTION_STOP:
+ self.shutdown()
+ break
+ elif action == PHPDebuggerCallback.ACTION_LISTEN:
+ if self.clntConn:
+ self.clntConn.shutdown(socket.SHUT_RDWR)
+ self.clntConn.close()
+ self.clntConn = None
+
+ continue
+ else:
+ continue
+
+ def shutdown(self):
+ #
+ # Cleanup and ready to exit.
+ #
+ self.clntConn.shutdown(socket.SHUT_RDWR)
+ self.clntConn.close()
+ self.svrSocket.close()
+
+ def recv(self, size, blocking = False):
+ if self.clntConn:
+ myprint("recv: trying to receive %d bytes of data ...", size)
+ if blocking:
+ self.clntConn.settimeout(None)
+ else:
+ self.clntConn.settimeout(self.nonBlockingTimeout)
+
+ try:
+ rData = self.clntConn.recv(size)
+ except socket.timeout:
+ myprint("recv: got timed out")
+ rData = None
+ except:
+ myprint("recv: got an unexpected exception: %s", sys.exc_info()[0])
+ raise PHPDBGConnException
+
+ return rData
+ else:
+ raise PHPDBGConnException
+
+ def sendall(self, message):
+ if self.clntConn:
+ try:
+ self.clntConn.sendall(message)
+ except:
+ myprint("sendall: got an unexpected exception: %s", sys.exc_info()[0])
+ raise PHPDBGConnException
+ else:
+ raise PHPDBGConnException
+
+ def hasBeenConnected(self):
+ return self.clntConn != None
+
+ def getConnHeader(self):
+ return self.connHeader
+
+
+class PHPValue(object):
+ PEV_NAMES = ("undefined", "long", "double", "string", "array", "object", "boolean", "resource", "reference", "soft reference", "null")
+ PEVT_UNKNOWN = 0
+ PEVT_LONG = 1
+ PEVT_DOUBLE = 2
+ PEVT_STRING = 3
+ PEVT_ARRAY = 4
+ PEVT_OBJECT = 5
+ PEVT_BOOLEAN = 6
+ PEVT_RESOURCE = 7
+ PEVT_REF = 8
+ PEVT_SOFTREF = 9
+ PEVT_NULL = 10
+
+ NULL_VALUE_STR = "NULL"
+ TRUE_VALUE_STR = "True"
+ FALSE_VALUE_STR = "False"
+ OBJECT_VALUE_STR = "<%s> object"
+ STRING_VALUE_STR = "\"%s\""
+ REFERENCE_VALUE_STR = "<reference><%s>"
+ RESOURCE_VALUE_STR = "<%s><%s>"
+
+ def __init__(self, frame, type, valueList):
+ self.fStackFrame = frame
+ self.fValueType = type
+
+ if type == self.PEVT_OBJECT:
+ self.fValueString = self.OBJECT_VALUE_STR % valueList[0]
+ self.fVariables = valueList[1:]
+ elif type == self.PEVT_ARRAY:
+ self.fValueString = ''
+ self.fVariables = valueList
+ else:
+ self.fVariables = []
+ if type == self.PEVT_STRING:
+ self.fValueString = self.STRING_VALUE_STR % valueList[0]
+ elif type == self.PEVT_NULL:
+ self.fValueString = self.NULL_VALUE_STR
+ elif type == self.PEVT_BOOLEAN:
+ if valueList[0] == "0":
+ self.fValueString = self.FALSE_VALUE_STR
+ else:
+ self.fValueString = self.TRUE_VALUE_STR
+ elif type == self.PEVT_REF or type == self.PEVT_SOFTREF:
+ self.fValueString = self.REFERENCE_VALUE_STR % valueList[0]
+ elif type == self.PEVT_RESOURCE:
+ self.fValueString = self.RESOURCE_VALUE_STR % (valueList[0], valueList[1])
+ else:
+ self.fValueString = valueList[0]
+
+ def addVariable(self, item):
+ if item != None:
+ self.fVariables.append(item)
+
+ return self.fVariables
+
+ def setParent(self, parent):
+ if self.fVariables != None and len(self.fVariables) > 0:
+ for item in self.fVariables:
+ item.setParent(parent)
+
+ def getReferenceType(self):
+ return self.fValueType
+
+ def getReferenceTypeName(self):
+ return self.PEV_NAMES[self.fValueType]
+
+ def setReferenceType(self, type):
+ self.fValueType = type
+
+ def getValueString(self):
+ return self.fValueString
+
+ def getChildrenVariables(self):
+ return self.fVariables
+
+ def hasVariables(self):
+ return len(self.fVariables) > 0
+
+ def childrenIsSortable(self):
+ #
+ # TODO: if self.fValueType != self.PEVT_ARRAY:
+ #
+ return True
+
+
+class PHPVariable(object):
+ def __init__(self, frame, parent, valueType, name, valueList):
+ self.fStackFrame = frame
+ self.fName = None
+ self.fLongName = None
+ self.fPureName = None
+ self.fValue = PHPValue(frame, valueType, valueList)
+ self.fParent = parent
+ self.setName(name)
+ self.setChildrensParent(valueList)
+
+ def setName(self, name):
+ self.fPureName = name
+
+ type = self.getReferenceType()
+ if type == PHPValue.PEVT_ARRAY:
+ numItems = len(self.getChildrenVariables())
+ self.fName = name + "[" + str(numItems) + "]"
+ else:
+ self.fName = name
+
+ if not self.fParent or self.fParent.getName() == None:
+ self.fLongName = name
+ else:
+ self.setLongName()
+
+ return
+
+ def setLongName(self):
+ parentType = self.fParent.getReferenceType()
+ if parentType == PHPValue.PEVT_ARRAY:
+ self.fLongName = self.fParent.getLongName() + "['" + self.fPureName + "']"
+ elif parentType == PHPValue.PEVT_OBJECT:
+ self.fLongName = self.fParent.getLongName() + "." + self.fName
+ else:
+ self.fLongName = self.fName
+
+ return
+
+ def getValue(self):
+ return self.fValue
+
+ def getValueString(self):
+ return self.fValue.getValueString()
+
+ def getChildrenVariables(self):
+ return self.fValue.getChildrenVariables()
+
+ def getName(self):
+ return self.fName
+
+ def getParent(self):
+ return self.fParent
+
+ def setParent(self, parent):
+ self.fParent = parent
+ self.setLongName()
+ return
+
+ def setChildrensParent(self, childrenList):
+ if self.fValue.hasVariables():
+ for child in self.fValue.getChildrenVariables():
+ child.setParent(self)
+
+ def getLongName(self):
+ return self.fLongName
+
+ def getReferenceTypeName(self):
+ return self.fValue.getReferenceTypeName()
+
+ def getReferenceType(self):
+ return self.fValue.getReferenceType()
+
+ def setReferenceType(self, type):
+ tp = self.getValue.setReferenceType(type)
+ return tp
+
+ def setValue(self, expression):
+ if self.fValue.getReferenceType() == PHPValue.PEVT_STRING:
+ evalString = self.fLongName + "=\"" + expression + "\""
+ else:
+ evalString = self.fLongName + "=" + expression
+
+ vars = self.fStackFrame.getPHPDBGInterface().evalBlock(self.fStackFrame, evalString)
+ self.fValue = vars[0].fValue
+
+ def toString(self):
+ rtype = self.getReferenceType()
+ if rtype == PHPValue.PEVT_ARRAY:
+ elements = len(self.fValue.getChildrenVariables())
+ if elements == 0:
+ tmpStr = self.getName() + " [no elements]"
+ elif elements == 1:
+ tmpStr = self.getName() + " [1 element]"
+ else:
+ tmpStr = self.getName() + " [" + str(elements) + " elements]"
+ elif rtype == PHPValue.PEVT_OBJECT:
+ tmpStr = self.getName() + " [ class: " + self.fValue.getValueString() + "]"
+ elif rtype == PHPValue.PEVT_STRING:
+ tmpStr = self.getName() + " = \"" + self.fValue.getValueString() + "\""
+ else:
+ tmpStr = self.getName() + " = " + self.fValue.getValueString()
+
+ return tmpStr
+
+ def hasChildren(self):
+ return self.fValue.hasVariables()
+
+ def childrenIsSortable(self):
+ return self.fValue.childrenIsSortable()
+
+
+class PHPStackFrame(object):
+ def __init__(self, interface, file, line, frameIndex, scopeId, desc, modNum):
+ self.interface = interface
+ self.fileName = file
+ self.lineNo = line
+ self.frameIndex = frameIndex
+ self.scopeId = scopeId
+ self.desc = desc
+ self.modNum = modNum
+ self.variables = []
+ self.shortFileName = None
+ self.shortDesc = None
+ self.displayStr = None
+ self.longDisplayStr = None
+
+ self._getFileNamesAndShortDesc()
+
+ myprint("PHPStackFrame::__init__(): new PHPStackFrame: file=%s, lineNo=%s, frameIndex=%s, scopeId=%s, desc=%s, modNum=%s, shortFileName=%s, shortDesc=%s", (repr(file), repr(line), repr(frameIndex), repr(scopeId), repr(desc), repr(modNum), repr(self.shortFileName), repr(self.shortDesc)))
+
+ def _getFileNamesAndShortDesc(self):
+ tmp = []
+ if self.desc:
+ tmp = self.desc.split("::")
+
+ if self.fileName:
+ self.shortFileName = os.path.basename(self.fileName)
+ if len(tmp) == 2:
+ self.shortDesc = tmp[1]
+ elif len(tmp) == 1:
+ self.shortDesc = tmp[0]
+ else:
+ self.shortDesc = None
+
+ return
+
+ #
+ # The fileName is None, we will try our best efforts to get it.
+ #
+ if len(tmp) == 2:
+ #
+ # We retrieved long finename from the description. If we haven't
+ # stored the file mod before, set this one as the new one.
+ # Otherwise, we prefer to keep the stored one.
+ #
+ if self.modNum != 0:
+ storedFileName = self.interface.getModByNum(self.modNum)
+ if not storedFileName:
+ self.interface.setMod(self.modNum, tmp[0])
+
+ self.fileName = tmp[0]
+ self.shortFileName = os.path.basename(tmp[0])
+ self.shortDesc = tmp[1]
+ elif len(tmp) == 1:
+ self.fileName = None
+ self.shortFileName = None
+ self.shortDesc = tmp[0]
+ else:
+ self.shortFileName = None
+ self.shortDesc = None
+ myprint("PHPStackFrame::_getFileNamesAndShortDesc(): something wrong with desc: %s?", self.desc)
+
+ return
+
+ def getShortFileName(self):
+ return self.shortFileName
+
+ def setShortFileName(self, shortFileName):
+ self.shortFileName = shortFileName
+
+ def getShortDesc(self):
+ return self.shortDesc
+
+ def getLineNo(self):
+ return self.lineNo
+
+ def getInterface(self):
+ return self.interface
+
+ def getVariables(self):
+ if len(self.variables) == 0:
+ self.variables = self.interface.getVariables(self)
+
+ return self.variables
+
+ def findVariables(self, s):
+ if self.hasVariables():
+ name = "$" + s
+ for var in self.variables:
+ if var.getName() == name:
+ return var
+
+ return None
+
+ def hasVariables(self):
+ if len(self.variables) == 0:
+ return False
+ else:
+ return True
+
+ def getName(self):
+ if self.getDesc():
+ return self.getDesc() + " [line: " + str(self.getLineNo()) + "]"
+ else:
+ return self.getFileName() + " [line: " + str(self.getLineNo()) + "]"
+
+ def getFileName(self):
+ return self.fileName
+
+ def setFileName(self, fileName):
+ self.fileName = fileName
+
+ def setDesc(self, desc):
+ self.desc = desc
+
+ def getDesc(self):
+ return self.desc
+
+ def getFrameScopeId(self):
+ return self.scopeId
+
+ def getFrameIndex(self):
+ return self.frameIndex
+
+ def getDisplayStr(self, stackList = None):
+ if self.displayStr:
+ return self.displayStr
+
+ if not self.shortFileName:
+ if stackList:
+ i = stackList.index(self)
+ for j in range(i + 1, len(stackList)):
+ self.shortFileName = stackList[j].getShortFileName()
+ if self.shortFileName:
+ self.fileName = stackList[j].getFileName()
+
+ if self.shortFileName:
+ if self.shortDesc:
+ self.displayStr = "<%s> at %s:%d" % (self.shortDesc, self.shortFileName, self.lineNo)
+ else:
+ self.displayStr = "%s:%d" % (self.shortFileName, self.lineNo)
+ else:
+ if self.shortDesc:
+ self.displayStr = "<%s>" % self.shortDesc
+ else:
+ self.displayStr = "<internal stack error>"
+
+ return self.displayStr
+
+ def getLongDisplayStr(self):
+ if self.longDisplayStr:
+ return self.longDisplayStr
+
+ if self.fileName:
+ if self.shortDesc:
+ self.longDisplayStr = "<%s> at %s:%d" % (self.shortDesc, self.fileName, self.lineNo)
+ else:
+ self.longDisplayStr = "%s:%d" % (self.fileName, self.lineNo)
+ else:
+ if self.shortDesc:
+ self.longDisplayStr = "<%s>" % self.shortDesc
+ else:
+ self.longDisplayStr = "<internal stack error>"
+
+ return self.longDisplayStr
+
+class BreakPoint(object):
+ def __init__(self, interface, fileName, lineNo, modNum = 0, state = BPS_ENABLED + BPS_UNRESOLVED, isTemp = 0, hitCount = 0, skipHits = 0, condition = 0, bpId = 0, isUnderHit = 0):
+ self.interface = interface
+ self.fileName = fileName
+ self.lineNo = lineNo
+ self.bpID = bpId
+ self.state = state
+ self.isTemp = isTemp
+ self.hitCount = hitCount
+ self.skipHits = skipHits
+ self.condition = condition
+ self.isUnderHit = 0
+ if modNum == 0:
+ self.modNum = self.interface.getModByFileName(fileName)
+ else:
+ self.modNum = modNum
+
+ if self.modNum:
+ self.fCounterOrZero = 0
+ else:
+ self.fCounterOrZero = interface.getNextFrameCounter()
+
+ def sendSelf(self):
+ reqPacket = PHPDBGPacket(DBGA_REQUEST)
+ reqFrame1 = PHPDBGFrame(FRAME_BPS)
+
+ if self.modNum:
+ reqFrame1.addInt(self.modNum)
+ else:
+ #
+ # 0 in modNum to tell to use fileName instead.
+ #
+ reqFrame1.addInt(0)
+
+ reqFrame1.addInt(self.lineNo) # lineNo
+ reqFrame1.addInt(self.fCounterOrZero) # fileName frameCounter or 0
+ reqFrame1.addInt(self.state) # state
+ reqFrame1.addInt(self.isTemp) # isTemp
+ reqFrame1.addInt(self.hitCount) # hitCount
+ reqFrame1.addInt(self.skipHits) # skipHits
+ reqFrame1.addInt(self.condition) # condition
+ reqFrame1.addInt(self.bpID) # breakpoint sequence id
+ reqFrame1.addInt(self.isUnderHit) # isUnderHit
+
+ if not self.modNum:
+ reqFrame2 = PHPDBGFrame(FRAME_RAWDATA)
+ reqFrame2.addInt(self.fCounterOrZero)
+ reqFrame2.addInt(len(self.fileName) + 1)
+ reqFrame2.addStr(self.fileName)
+ reqPacket.addFrame(reqFrame2)
+
+ reqPacket.addFrame(reqFrame1)
+
+ try:
+ reqPacket.sendPacket(self.interface.lsnrThr)
+ self.interface.awaitAndHandleResponse()
+ except PHPDBGConnException:
+ self.interface.currConnFinished()
+
+ return
+
+ def addSelf(self):
+ self.sendSelf()
+
+ def removeSelf(self):
+ self.state = BPS_DISABLED
+ self.sendSelf()
+
+ def isUnderHit(self):
+ return self.isUnderHit == 1
+
+ def update(self, dbgBp):
+ self.modNum = dbgBp[0]
+ self.state = dbgBp[3]
+ self.isTemp = dbgBp[4]
+ self.hitCount = dbgBp[5]
+ self.skipHits = dbgBp[6]
+ self.condition = dbgBp[7]
+ self.bpID = dbgBp[8]
+ self.isUnderHit = dbgBp[9]
+
+
+class PHPDBGEvalString(object):
+ def __init__(self, stackFrame, dataStr):
+ self.stackFrame = stackFrame
+ self.dataStr = dataStr
+
+ #
+ # Get a list of variables under self.stackFrame.
+ #
+ def getVars(self):
+ return self.parseAVariable(isRealVar = False)
+
+ #
+ # if isRealVar:
+ # returnList[0] = The Variable
+ # else:
+ # returnList = list of variables.
+ #
+ def parseAVariable(self, isRealVar = True):
+ returnList = []
+
+ #
+ # Get the variable name first. Notice we ignore this entity's data
+ # type here.
+ #
+ if isRealVar:
+ nameEntity = self.parseAnEntity()
+ if not nameEntity or len(nameEntity) != 2 or type(nameEntity[1]) != str:
+ myprint("PHPDBGEvalStr::parseAVariable() got a wrong name entity")
+ return returnList
+ else:
+ varName = nameEntity[1]
+
+ #
+ # Get the variable's value.
+ #
+ valueEntity = self.parseAnEntity()
+ if not valueEntity or len(valueEntity) < 1:
+ myprint("PHPDBGEvalStr::parseAVariable(): couldn't get a variable's value entity.")
+ return returnList
+
+ #
+ # This variable's data type.
+ #
+ varType = valueEntity[0]
+
+ if isRealVar:
+ #
+ # If this is a real variable, return a list which contains only
+ # this variable item.
+ #
+ #valueEntity = valueEntity[1:]
+ variable = PHPVariable(self.stackFrame, None, varType, varName, valueEntity[1:])
+ #myprint("xxxxCreated variable varName=%s, valueEntity=%s", (repr(varName), repr(valueEntity[1])))
+ myprint("xxxxCreated variable: %s", repr(variable.toString()))
+ returnList.append(variable)
+ else:
+ #
+ # If this is a root variable container, returns a list of
+ # variables under the root. Do a sanity check here.
+ #
+ if valueEntity[0] != PHPValue.PEVT_ARRAY:
+ myprint("PHPDBGEvalStr::parseAVariable(): failed to parse the root variable container.")
+ else:
+ returnList = valueEntity[1:]
+
+ return returnList
+
+ #
+ # An entity could be a variable's name or its value.
+ #
+ # returnList[0] = variable data type
+ # returnList[1:] = the real list
+ #
+ def parseAnEntity(self):
+ if not self.dataStr or len(self.dataStr) < 2 or (self.dataStr[1] != ':' and self.dataStr[1] != ';'):
+ myprint("PHPDBGEvalStr::parseAnEntity(): failed to parse %s.", repr(self.dataStr))
+ return None
+
+ returnList = []
+ typeChar = self.dataStr[0]
+ self.dataStr = self.dataStr[2:]
+ if typeChar == 'i':
+ returnList.append(PHPValue.PEVT_LONG)
+ self.parseInt(returnList)
+ elif typeChar == 'a':
+ returnList.append(PHPValue.PEVT_ARRAY)
+ self.parseArray(returnList)
+ elif typeChar == 's':
+ returnList.append(PHPValue.PEVT_STRING)
+ self.parseString(returnList)
+ elif typeChar == 'O':
+ returnList.append(PHPValue.PEVT_OBJECT)
+ self.parseObject(returnList)
+ elif typeChar == 'r':
+ returnList.append(PHPValue.PEVT_SOFTREF)
+ self.parseReference(returnList, isSoftRef = True)
+ elif typeChar == 'R':
+ returnList.append(PHPValue.PEVT_REF)
+ self.parseReference(returnList, isSoftRef = False)
+ elif typeChar == 'b':
+ returnList.append(PHPValue.PEVT_BOOLEAN)
+ self.parseBoolean(returnList)
+ elif typeChar == 'd':
+ returnList.append(PHPValue.PEVT_DOUBLE)
+ self.parseDouble(returnList)
+ elif typeChar == 'z':
+ returnList.append(PHPValue.PEVT_RESOURCE)
+ self.parseResource(returnList)
+ elif typeChar == 'N':
+ returnList.append(PHPValue.PEVT_NULL)
+ self.parseNull(returnList)
+ else:
+ myprint("PHPDBGEvalStr::parseAnEntity(): unknown data type: %s", typeChar)
+
+ return returnList
+
+ def parseInt(self, returnList):
+ myprint("enter parseInt().")
+ returnList.append(self.getAnIntStr(';'))
+
+ return
+
+ def parseArray(self, returnList):
+ myprint("enter parseArray().")
+ #
+ # The shortest array is 'a:0:{}'.
+ #
+ if len(self.dataStr) < 4:
+ myprint("PHPDBGEvalStr::parseArray(): failed (1) to parse an array: %s.", repr(self.dataStr))
+ return
+
+ expectedNumItems = self.getAnInt(':')
+ if len(self.dataStr) < 2 or self.dataStr[0] != '{':
+ myprint("PHPDBGEvalStr::parseArray(): failed (3) to parse an array: %s.", repr(self.dataStr))
+ return
+
+ self.dataStr = self.dataStr[1:]
+ varList = []
+ while self.dataStr and len(self.dataStr) > 0 and self.dataStr[0] != '}':
+ tmpList = self.parseAVariable()
+ if not tmpList or len(tmpList) != 1 or not tmpList[0]:
+ myprint("PHPDBGEvalStr::parseArray(): failed (4) to parse an array. dataStr=%s.", repr(self.dataStr))
+ break
+ else:
+ varList.append(tmpList[0])
+
+ if expectedNumItems != len(varList):
+ myprint("PHPDBGEvalStr::parseArray(): failed (5) expected no. of items=%d, but got %d", (expectedNumItems, len(varList)))
+
+ #
+ # An array should end with a '}'.
+ #
+ if self.dataStr and len(self.dataStr) > 0 and self.dataStr[0] == '}':
+ self.dataStr = self.dataStr[1:]
+ returnList.extend(varList)
+ else:
+ myprint("PHPDBGEvalStr::parseArray(): failed (6) to parse an array. dataStr=%s.", repr(self.dataStr))
+
+ myprint("parseArray() ends.")
+ return
+
+ def parseString(self, returnList, endChar = ';'):
+ myprint("enter parseString().")
+ #
+ # The shortest string is 's:<str_len>:"<str>"<endChar>'.
+ #
+ if len(self.dataStr) < 5:
+ myprint("PHPDBGEvalStr::parseString(): failed (1) to parse a string. dataStr=%s.", repr(self.dataStr))
+ return
+
+ expectedStrLen = self.getAnInt(':')
+ if len(self.dataStr) < expectedStrLen + 3 or self.dataStr[0] != '"':
+ myprint("PHPDBGEvalStr::parseString(): failed (3) to parse a string. dataStr=%s.", repr(self.dataStr))
+ return
+
+ strValue = self.dataStr[1:expectedStrLen + 1]
+ if self.dataStr[expectedStrLen + 1:expectedStrLen + 3] != '"' + endChar:
+ myprint("PHPDBGEvalStr::parseString(): failed (4) to parse a string. dataStr=%s.", repr(self.dataStr))
+ return
+
+ #
+ # Skip the starting double quote, real string, ending double quote, and ending semicolon.
+ #
+ self.dataStr = self.dataStr[expectedStrLen + 3:]
+ returnList.append(strValue)
+
+ return
+
+ def parseObject(self, returnList):
+ #
+ # A simple sanity check. The shortest object is:
+ # 'O:<class_name_len>:"<class_name>":<num_of_items>:{<list_of_items>}'
+ #
+ if not self.dataStr or len(self.dataStr) < 10:
+ myprint("PHPDBGEvalStr::parseObject(): failed (1) to parse an object: %s.", repr(self.dataStr))
+
+ #
+ # Get the class name in classNameList[0].
+ #
+ classNameList = []
+ self.parseString(classNameList, ':')
+
+ expectedNumItems = self.getAnInt(':')
+ if len(self.dataStr) < 2 or self.dataStr[0] != '{':
+ myprint("PHPDBGEvalStr::parseObject(): failed (2) to parse an object: %s.", repr(self.dataStr))
+ return
+
+ self.dataStr = self.dataStr[1:]
+ varList = []
+ while self.dataStr and len(self.dataStr) > 0 and self.dataStr[0] != '}':
+ tmpList = self.parseAVariable()
+ if not tmpList or len(tmpList) != 1 or not tmpList[0]:
+ myprint("PHPDBGEvalStr::parseObject(): failed (3) to parse an object. dataStr=%s.", repr(self.dataStr))
+ break
+ else:
+ varList.append(tmpList[0])
+
+ if expectedNumItems != len(varList):
+ myprint("PHPDBGEvalStr::parseObject(): failed (4) expected no. of items=%d, but got %d", (expectedNumItems, len(varList)))
+
+ #
+ # An object should end with a '}'.
+ #
+ if self.dataStr and len(self.dataStr) > 0 and self.dataStr[0] == '}':
+ self.dataStr = self.dataStr[1:]
+ returnList.append(classNameList[0])
+ returnList.extend(varList)
+ else:
+ myprint("PHPDBGEvalStr::parseObject(): failed (6) to parse an object. dataStr=%s.", repr(self.dataStr))
+
+ myprint("parseObject() ends.")
+ return
+
+ def parseReference(self, returnList, isSoftRef):
+ myprint("enter parseReference().")
+ intStr = self.getAnIntStr(';')
+ if intStr:
+ returnList.append(intStr)
+
+ return
+
+ def parseBoolean(self, returnList):
+ tmpBooleanStr = self.getAnIntStr(';')
+ returnList.append(tmpBooleanStr)
+
+ return
+
+ def parseDouble(self, returnList):
+ tmpStr = self.getAStrTillEndChar(';')
+ if tmpStr:
+ returnList.append(tmpStr)
+
+ return
+
+ def parseResource(self, returnList):
+ tmpList = []
+ self.parseString(tmpList, ':')
+
+ if len(tmpList) == 1:
+ returnList.extend(tmpList)
+ else:
+ return
+
+ resourceId = self.getAnIntStr(';')
+ if resourceId:
+ returnList.append(resourceId)
+
+ return
+
+ def parseNull(self, returnList):
+ return
+
+ def getAStrTillEndChar(self, endChar):
+ if len(self.dataStr) < 1:
+ myprint("PHPDBGEvalStr::getAStrTillEndChar(): no more data string to work with.")
+ return
+
+ i = self.findNextChar(self.dataStr, endChar)
+ if i == -1:
+ myprint("PHPDBGEvalStr::getAStrTillEndChar(): no double/float string supplied.")
+ return
+
+ tmpStr = self.dataStr[:i]
+ self.dataStr = self.dataStr[i + 1:]
+
+ if self.isFloat(tmpStr):
+ return tmpStr
+ else:
+ myprint("PHPDBGEvalStr::getAStrTillEndChar(): parsing error. tried to get an float number, but get %s.", tmpStr)
+ return None
+
+ def getAnInt(self, endChar):
+ tmpStr = self.getAnIntStr(endChar)
+ if tmpStr:
+ return int(tmpStr)
+ else:
+ return 0
+
+ def getAnIntStr(self, endChar):
+ if len(self.dataStr) == 0:
+ myprint("PHPDBGEvalStr::getAnIntStr(): no more data string to work with.")
+ return
+
+ i = self.findNextChar(self.dataStr, endChar)
+ if i == -1:
+ tmpStr = self.dataStr
+ self.dataStr = ''
+ else:
+ tmpStr = self.dataStr[:i]
+ self.dataStr = self.dataStr[i + 1:]
+
+ if self.isInt(tmpStr):
+ return tmpStr
+ else:
+ myprint("PHPDBGEvalStr::getAnIntStr(): parsing error. tried to get an integer, but get %s.", tmpStr)
+ return None
+
+ def isInt(self, aStr):
+ try:
+ int(aStr)
+ except ValueError:
+ return False
+
+ return True
+
+ def isFloat(self, aStr):
+ try:
+ float(aStr)
+ except ValueError:
+ return False
+
+ return True
+
+ def findNextChar(self, aStr, aChar):
+ try:
+ index = aStr.index(aChar)
+ except ValueError:
+ index = -1
+
+ return index
projects / wxWidgets.git / blobdiff