color xml arm相关

#--------------------------------------------------------------------------
#                             C O L O R S
#--------------------------------------------------------------------------
 
def GetColor(ea, what):
    """
    Get item color
 
    @param ea: address of the item
    @param what: type of the item (one of  CIC_* constants)
 
    @return: color code in RGB (hex 0xBBGGRR)
    """
    if what not in [ CIC_ITEM, CIC_FUNC, CIC_SEGM ]:
        raise ValueError, "'what' must be one of CIC_ITEM, CIC_FUNC and CIC_SEGM"
 
    if what == CIC_ITEM:
        return idaapi.get_item_color(ea)
 
    if what == CIC_FUNC:
        func = idaapi.get_func(ea)
        if func:
            return func.color
        else:
            return DEFCOLOR
 
    if what == CIC_SEGM:
        seg = idaapi.getseg(ea)
        if seg:
            return seg.color
        else:
            return DEFCOLOR
 
# color item codes:
CIC_ITEM = 1         # one instruction or data
CIC_FUNC = 2         # function
CIC_SEGM = 3         # segment
 
DEFCOLOR = 0xFFFFFFFF  # Default color
 
def SetColor(ea, what, color):
    """
    Set item color
 
    @param ea: address of the item
    @param what: type of the item (one of CIC_* constants)
    @param color: new color code in RGB (hex 0xBBGGRR)
 
    @return: success (True or False)
    """
    if what not in [ CIC_ITEM, CIC_FUNC, CIC_SEGM ]:
        raise ValueError, "'what' must be one of CIC_ITEM, CIC_FUNC and CIC_SEGM"
 
    if what == CIC_ITEM:
        return idaapi.set_item_color(ea, color)
 
    if what == CIC_FUNC:
        func = idaapi.get_func(ea)
        if func:
            func.color = color
            return bool(idaapi.update_func(func))
        else:
            return False
 
    if what == CIC_SEGM:
        seg = idaapi.getseg(ea)
        if seg:
            seg.color = color
            return bool(seg.update())
        else:
            return False
 
#--------------------------------------------------------------------------
#                               X M L
#--------------------------------------------------------------------------
 
def SetXML(path, name, value):
    """
    Set or update one or more XML values.
 
    @param path: XPath expression of elements where to create value(s)
    @param name: name of the element/attribute
                 (use @XXX for an attribute) to create.
                 If 'name' is empty, the elements or
                 attributes returned by XPath are directly
                 updated to contain the new 'value'.
    @param value: value of the element/attribute
 
    @return: success (True or False)
    """
    return idaapi.set_xml(path, name, value)
 
def GetXML(path):
    """
    Get one XML value.
 
    @param path: XPath expression to an element
                 or attribute whose value is requested
 
    @return: the value, None if failed
    """
    v = idaapi.value_t()
    if idaapi.get_xml(path):
        return v.str
    else:
        return None
 
#----------------------------------------------------------------------------
#                       A R M   S P E C I F I C
#----------------------------------------------------------------------------
def ArmForceBLJump(ea):
    """
    Some ARM compilers in Thumb mode use BL (branch-and-link)
    instead of B (branch) for long jumps, since BL has more range.
    By default, IDA tries to determine if BL is a jump or a call.
    You can override IDA's decision using commands in Edit/Other menu
    (Force BL call/Force BL jump) or the following two functions.
 
    Force BL instruction to be a jump
 
    @param ea: address of the BL instruction
 
    @return: 1-ok, 0-failed
    """
    return Eval("ArmForceBLJump(0x%x)"%ea)
 
def ArmForceBLCall(ea):
    """
    Force BL instruction to be a call
 
    @param ea: address of the BL instruction
 
    @return: 1-ok, 0-failed
    """
    return Eval("ArmForceBLCall(0x%x)"%ea)
 
#--------------------------------------------------------------------------
# Compatibility macros:
def Compile(file):           return CompileEx(file, 1)
def OpOffset(ea,base):       return OpOff(ea,-1,base)
def OpNum(ea):               return OpNumber(ea,-1)
def OpChar(ea):              return OpChr(ea,-1)
def OpSegment(ea):           return OpSeg(ea,-1)
def OpDec(ea):               return OpDecimal(ea,-1)
def OpAlt1(ea, opstr):       return OpAlt(ea, 0, opstr)
def OpAlt2(ea, opstr):       return OpAlt(ea, 1, opstr)
def StringStp(x):            return SetCharPrm(INF_ASCII_BREAK,x)
def LowVoids(x):             return SetLongPrm(INF_LOW_OFF,x)
def HighVoids(x):            return SetLongPrm(INF_HIGH_OFF,x)
def TailDepth(x):            return SetLongPrm(INF_MAXREF,x)
def Analysis(x):             return SetCharPrm(INF_AUTO,x)
def Tabs(x):                 return SetCharPrm(INF_ENTAB,x)
#def Comments(x):             SetCharPrm(INF_CMTFLAG,((x) ? (SW_ALLCMT|GetCharPrm(INF_CMTFLAG)) : (~SW_ALLCMT&GetCharPrm(INF_CMTFLAG))))
def Voids(x):                return SetCharPrm(INF_VOIDS,x)
def XrefShow(x):             return SetCharPrm(INF_XREFNUM,x)
def Indent(x):               return SetCharPrm(INF_INDENT,x)
def CmtIndent(x):            return SetCharPrm(INF_COMMENT,x)
def AutoShow(x):             return SetCharPrm(INF_SHOWAUTO,x)
def MinEA():                 return GetLongPrm(INF_MIN_EA)
def MaxEA():                 return GetLongPrm(INF_MAX_EA)
def BeginEA():               return GetLongPrm(INF_BEGIN_EA)
def set_start_cs(x):         return SetLongPrm(INF_START_CS,x)
def set_start_ip(x):         return SetLongPrm(INF_START_IP,x)
 
def WriteMap(filepath):
    return GenerateFile(OFILE_MAP, filepath, 0, BADADDR, GENFLG_MAPSEG|GENFLG_MAPNAME)
 
def WriteTxt(filepath, ea1, ea2):
    return GenerateFile(OFILE_ASM, filepath, ea1, ea2, 0)
 
def WriteExe(filepath):
    return GenerateFile(OFILE_EXE, filepath, 0, BADADDR, 0)
 
UTP_STRUCT = idaapi.UTP_STRUCT
UTP_ENUM   = idaapi.UTP_ENUM
 
def BeginTypeUpdating(utp):
    """
    Begin type updating. Use this function if you
    plan to call AddEnumConst or similar type modification functions
    many times or from inside a loop
 
    @param utp: one of UTP_xxxx consts
    @return: None
    """
    return idaapi.begin_type_updating(utp)
 
def EndTypeUpdating(utp):
    """
    End type updating. Refreshes the type system
    at the end of type modification operations
 
    @param utp: one of idaapi.UTP_xxxx consts
    @return: None
    """
    return idaapi.end_type_updating(utp)
 
def AddConst(enum_id, name,value): return AddConstEx(enum_id, name, value, idaapi.BADADDR)
def AddStruc(index, name):         return AddStrucEx(index,name, 0)
def AddUnion(index, name):         return AddStrucEx(index,name, 1)
def OpStroff(ea, n, strid):        return OpStroffEx(ea,n,strid, 0)
def OpEnum(ea, n, enumid):         return OpEnumEx(ea,n,enumid, 0)
def DelConst(constid, v, mask):    return DelConstEx(constid, v, 0, mask)
def GetConst(constid, v, mask):    return GetConstEx(constid, v, 0, mask)
def AnalyseArea(sEA, eEA):         return AnalyzeArea(sEA,eEA)
 
def MakeStruct(ea, name):                 return MakeStructEx(ea, -1, name)
def MakeCustomData(ea, size, dtid, fid):  return MakeCustomDataEx(ea, size, dtid, fid)
def Name(ea):                             return NameEx(BADADDR, ea)
def GetTrueName(ea):                      return GetTrueNameEx(BADADDR, ea)
def MakeName(ea, name):                   return MakeNameEx(ea,name,SN_CHECK)
 
#def GetFrame(ea):                return GetFunctionAttr(ea, FUNCATTR_FRAME)
#def GetFrameLvarSize(ea):        return GetFunctionAttr(ea, FUNCATTR_FRSIZE)
#def GetFrameRegsSize(ea):        return GetFunctionAttr(ea, FUNCATTR_FRREGS)
#def GetFrameArgsSize(ea):        return GetFunctionAttr(ea, FUNCATTR_ARGSIZE)
#def GetFunctionFlags(ea):        return GetFunctionAttr(ea, FUNCATTR_FLAGS)
#def SetFunctionFlags(ea, flags): return SetFunctionAttr(ea, FUNCATTR_FLAGS, flags)
 
#def SegStart(ea):                return GetSegmentAttr(ea, SEGATTR_START)
#def SegEnd(ea):                  return GetSegmentAttr(ea, SEGATTR_END)
#def SetSegmentType(ea, type):    return SetSegmentAttr(ea, SEGATTR_TYPE, type)
 
def SegCreate(a1, a2, base, use32, align, comb): return AddSeg(a1, a2, base, use32, align, comb)
def SegDelete(ea, flags):                        return DelSeg(ea, flags)
def SegBounds(ea, startea, endea, flags):        return SetSegBounds(ea, startea, endea, flags)
def SegRename(ea, name):                         return RenameSeg(ea, name)
def SegClass(ea, segclass):                      return SetSegClass(ea, segclass)
def SegAddrng(ea, bitness):                      return SetSegAddressing(ea, bitness)
def SegDefReg(ea, reg, value):                   return SetSegDefReg(ea, reg, value)
 
def Comment(ea):                return GetCommentEx(ea, 0)
"""Returns the regular comment or None"""
 
def RptCmt(ea):                 return GetCommentEx(ea, 1)
"""Returns the repeatable comment or None"""
 
def SetReg(ea, reg, value): return SetRegEx(ea, reg, value, SR_user)
 
# Convenience functions:
def here(): return ScreenEA()
def isEnabled(ea): return (PrevAddr(ea+1)==ea)
 
# Obsolete segdel macros:
SEGDEL_PERM   = 0x0001 # permanently, i.e. disable addresses
SEGDEL_KEEP   = 0x0002 # keep information (code & data, etc)
SEGDEL_SILENT = 0x0004 # be silent
 
ARGV = []
"""The command line arguments passed to IDA via the -S switch."""
 
# END OF IDC COMPATIBILY CODE