phpdebugger.py

Wxpython Implemented on Windows CE, Source code

        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(): u