pcresolveBridge.py

Go to the documentation of this file.

 
 
try:
    from pcresolve import analyze_project as _pcresolveAnalyze
except ImportError:
    _pcresolveAnalyze = None
 
_analysisCache = {}
_lookupCache = {}
 
 
 
 
 
def buildCallsiteLookup(projPath, libName):
    global _analysisCache, _lookupCache
    cacheKey = (projPath, libName)
    if cacheKey in _lookupCache:
        return _lookupCache[cacheKey]
 
    if _pcresolveAnalyze is None:
        _lookupCache[cacheKey] = {}
        return _lookupCache[cacheKey]
 
    # Two-layer cache: raw analysis (projPath) → filtered lookup (projPath, libName)
    # 双层缓存：原始分析（projPath）→ 过滤查找（projPath, libName）
    if projPath in _analysisCache:
        result = _analysisCache[projPath]
    else:
        try:
            result = _pcresolveAnalyze(projPath, scope_model="v2")
        except Exception:
            _analysisCache[projPath] = None
            _lookupCache[cacheKey] = {}
            return _lookupCache[cacheKey]
        _analysisCache[projPath] = result
 
    if result is None:
        _lookupCache[cacheKey] = {}
        return _lookupCache[cacheKey]
 
    # Seed empty entries for every file PCResolve analyzed, so that
    # "0 target calls" is distinguishable from "not analyzed" in
    # getCallFunction — avoids falling back to the old extractor for
    # files that PCResolve already determined have no target library calls.
    # 为所有已分析的文件初始化空记录，"0调用"与"未分析"可由getCallFunction
    # 区分——避免对PCResolve已判无目标库调用的文件回退到旧提取器。
    lookup = {}
    for fileResult in result.files:
        lookup[fileResult.file_path] = {}
 
    for call in result.all_api_calls:
        if not _matchesLibname(call, libName):
            continue
 
        record = _convertApiCall(call, projPath)
        key = call.file_path
        if key not in lookup:
            lookup[key] = {}
        lookup[key][record['id']] = record
 
    # Sort by source position within each file, matching getCallFunction ordering
    # 在每个文件内按源码位置排序，与getCallFunction排序一致
    for filePath in lookup:
        lookup[filePath] = dict(sorted(
            lookup[filePath].items(),
            key=lambda kv: (kv[1]['lineno'], kv[1]['col_offset']),
        ))
 
    _lookupCache[cacheKey] = lookup
    return lookup
 
 
 
 
def _resetCache():
    global _analysisCache, _lookupCache
    _analysisCache = {}
    _lookupCache = {}
 
 
 
 
def _convertApiCall(callObj, projPath):
    from Tool.callsite import makeCallsiteRecord
 
    resolved = callObj.resolved_func or callObj.func_name or ''
 
    return makeCallsiteRecord(
        file_path=callObj.file_path,
        call_text=callObj.expression,
        format_api=f"{resolved}({callObj.parameters})" if resolved else callObj.expression,
        parameters=callObj.parameters,
        lineno=callObj.lineno,
        col_offset=callObj.col_offset,
        end_lineno=callObj.end_lineno or None,
        end_col_offset=callObj.end_col_offset or None,
        proj_path=projPath,
    )
 
 
 
 
def _matchesLibname(callObj, libName):
    deco = getattr(callObj, 'decorated_by', []) or []
    return callObj.top_library == libName or libName in deco