phpdebugger.py

Wxpython Implemented on Windows CE, Source code

                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)