parse.cpp

windows mobile RIL软件

    }
    fRet = TRUE;

    Error:
    if (!fRet)
    {
        rszPointer = szData;
    }
    return fRet;
}

//
// NOTE: caller is responsible for free'ing the storage used by rszOut
//
BOOL ParseUnlimitedString(const LPCSTR szData, LPSTR& rszOut, UINT& rcbOut, LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(ParseUnlimitedString);
    LPSTR pchTerminatingQuote;
    BOOL fRet = FALSE;

    rszOut = NULL;
    rszPointer = szData;

    // Skip over the leading quote
    if (*rszPointer != '\"')
    {
        goto Error;
    }
    rszPointer++;

    // Calculate string length
    pchTerminatingQuote = strchr(rszPointer, '\"');
    if (!pchTerminatingQuote)
    {
        goto Error;
    }
    rcbOut = pchTerminatingQuote - rszPointer + 1;

    // Allocate sufficient storage for the string
    rszOut = new char[rcbOut];
    if (!rszOut)
    {
        goto Error;
    }

    // Copy the string into the allocated buffer
    (void)strncpyz(rszOut, rszPointer, rcbOut);
    *(rszOut + rcbOut - 1) = '\0';
    rszPointer = pchTerminatingQuote + 1;
    fRet = TRUE;

    Error:
    if (!fRet)
    {
        delete[] rszOut;
        rszOut = NULL;
        rcbOut = 0;
        rszPointer = szData;
    }
    return fRet;
}

//
// NOTE: caller is responsible for free'ing the storage used by rszOut
//
BOOL ParseUnlimitedUnquotedString(const LPCSTR szData, const char chDelimiter, LPSTR& rszOut, UINT& rcbOut, LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(ParseUnlimitedUnquotedString);
    LPSTR pchTerminator;
    BOOL fRet = FALSE;

    rszOut = NULL;
    rszPointer = szData;

    // Calculate string length
    pchTerminator = strchr(rszPointer, chDelimiter);
    if (!pchTerminator)
    {
        goto Error;
    }
    rcbOut = pchTerminator - rszPointer + 1;

    // Allocate sufficient storage for the string
    rszOut = new char[rcbOut];
    if (!rszOut)
    {
        goto Error;
    }

    // Copy the string into the allocated buffer
    (void)strncpyz(rszOut, rszPointer, rcbOut);
    *(rszOut + rcbOut - 1) = '\0';
    rszPointer = pchTerminator;
    fRet = TRUE;

    Error:
    if (!fRet)
    {
        delete[] rszOut;
        rszOut = NULL;
        rcbOut = 0;
        rszPointer = szData;
    }
    return fRet;
}


//
//
//
BOOL ParseRange(const LPCSTR szData, RILRANGE& rrrRange, LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(ParseRange);
    UINT nValue;
    BOOL fRet = FALSE;

    rszPointer = szData;

    // Parse "("
    if ('(' != *rszPointer)
    {
        goto Error;
    }
    rszPointer++;

    // Parse "<min>"
    if (!ParseUInt(rszPointer, TRUE, nValue, rszPointer))
    {
        goto Error;
    }
    rrrRange.dwMinValue = nValue;

    // Try parsing ")" for ranges with a single value
    if (')' == *rszPointer)
    {
        rrrRange.dwMaxValue = nValue;
        rszPointer++;
        fRet = TRUE;
        goto Error; // ...although not really an error
    }

    // Parse "-"
    if ('-' != *rszPointer)
    {
        goto Error;
    }
    rszPointer++;

    // Parse "<max>"
    if (!ParseUInt(rszPointer, TRUE, nValue, rszPointer))
    {
        goto Error;
    }
    rrrRange.dwMaxValue = nValue;
    DEBUGCHK(rrrRange.dwMinValue <= rrrRange.dwMaxValue);

    // Parse ")"
    if (')' != *rszPointer)
    {
        goto Error;
    }
    rszPointer++;
    fRet = TRUE;

    Error:
    if (!fRet)
    {
        rszPointer = szData;
    }
    return fRet;
}

//
//
//
BOOL ParseRangesFromString(const LPCSTR szData,
                           RILRANGE rgrrRange[],
                           DWORD& rdwNumRanges,
                           DWORD dwMaxRanges,
                           LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(ParseRanges);
    UINT nValue1;
    UINT nValue2;
    DWORD dwCurrentRange = 0;
    BOOL fRet = FALSE;

    rszPointer = szData;

    while (dwCurrentRange < dwMaxRanges)
    {
        // Parse the first value
        if (!ParseUInt(rszPointer, TRUE, nValue1, rszPointer))
        {
            goto Error;
        }

        // Parse "-"
        if (MatchStringBeginning(rszPointer, "-", rszPointer))
        {
            // Parse the second value
            if (!ParseUInt(rszPointer, TRUE, nValue2, rszPointer))
            {
                goto Error;
            }
        }
        else if (MatchStringBeginning(rszPointer, "x", rszPointer))
        {
            // The second digit of Value1 can be anything
            nValue1 *= 10;
            nValue2 = nValue1 + 9;
        }
        else
        {
            nValue2 = nValue1;
        }
        DEBUGCHK(nValue1 <= nValue2);

        rgrrRange[dwCurrentRange].dwMinValue = nValue1;
        rgrrRange[dwCurrentRange].dwMaxValue = nValue2;

        dwCurrentRange++;

        // Parse ","
        if (',' != *rszPointer)
        {
            break;
        }
        rszPointer++;
    }

    rdwNumRanges = dwCurrentRange;
    fRet = TRUE;

    Error:
    if (!fRet)
    {
        rszPointer = szData;
    }
    return fRet;
}

//
// Comparison routine used for binary search below
//
static int _cdecl BSCompareListValues(const void* pElem1, const void* pElem2)
{
    UINT n1 = ((LISTVALUEMAP*)pElem1)->nValue;
    UINT n2 = ((LISTVALUEMAP*)pElem2)->nValue;
    int iRet;

    if (n1 < n2)
    {
        iRet = -1;
    }
    else if (n1 == n2)
    {
        iRet = 0;
    }
    else
    {
        iRet = 1;
    }
    return iRet;
}

BOOL FlagFromValue(UINT nValue, const LISTVALUEMAP* const rglsmMapArray, const UINT nMapArrayLength, DWORD& Flag)
{
    LISTVALUEMAP lsmKey;
    LISTVALUEMAP* plsmFound;

    // Add correspondig flag to the mask
    lsmKey.nValue = nValue;
    plsmFound = (LISTVALUEMAP*)bsearch(&lsmKey, rglsmMapArray, nMapArrayLength, sizeof(LISTVALUEMAP), BSCompareListValues);
    if (plsmFound)
    {
        Flag = plsmFound->dwFlag;
        return TRUE;
    }
    else
    {
        Flag=0;
        return FALSE;
    }
}

//
// Comparison routine used for binary search below
//
static int _cdecl BSCompareListStrings(const void* pElem1, const void* pElem2)
{
    LPCSTR sz1 = ((LISTSTRINGMAP*)pElem1)->szString;
    LPCSTR sz2 = ((LISTSTRINGMAP*)pElem2)->szString;
    return strcmp(sz1, sz2);
}

BOOL FlagFromString(const LPCSTR szString, const LISTSTRINGMAP* const rglsmMapArray, const UINT nMapArrayLength, DWORD& Flag)
{
    LISTSTRINGMAP lsmKey;
    LISTSTRINGMAP* plsmFound;

    // Add correspondig flag to the mask
    lsmKey.szString = szString;
    plsmFound = (LISTSTRINGMAP*)bsearch(&lsmKey, rglsmMapArray, nMapArrayLength, sizeof(LISTSTRINGMAP), BSCompareListStrings);
    if (plsmFound)
    {
        Flag = plsmFound->dwFlag;
        return TRUE;
    }
    else
    {
        Flag=0;
        return FALSE;
    }
}

BOOL ValueFromFlag(UINT dwFlag, const LISTVALUEMAP* const rglsmMapArray, const UINT nMapArrayLength, UINT& Value)
{
    UINT i;
    for (i=0;i<nMapArrayLength;i++)
    {
        if (rglsmMapArray[i].dwFlag == dwFlag)
        {
            Value=rglsmMapArray[i].nValue;
            return TRUE;
        }
    }
    return FALSE;
}

BOOL StringFromFlag(UINT dwFlag, const LISTSTRINGMAP* const rglsmMapArray, const UINT nMapArrayLength, LPCSTR& szString)
{
    UINT i;
    for (i=0;i<nMapArrayLength;i++)
    {
        if (rglsmMapArray[i].dwFlag == dwFlag)
        {
            szString=rglsmMapArray[i].szString;
            return TRUE;
        }
    }
    return FALSE;
}

//
//
//
BOOL ParseRangeList(const LPCSTR szData, const LISTVALUEMAP* const rglvmMapArray, const UINT nMapArrayLength, DWORD& rdwMask,
                    LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(ParseRangeList);
    UINT nValue1;
    UINT nValue2;
    UINT i;
    BOOL fRet = FALSE;

    rdwMask = 0x00000000;
    rszPointer = szData;

    // Parse "("
    if ('(' != *rszPointer)
    {
        goto Error;
    }
    rszPointer++;

    while (1)
    {
        // Parse the first value
        if (!ParseUInt(rszPointer, TRUE, nValue1, rszPointer))
        {
            goto Error;
        }

        // Parse "-"
        if (MatchStringBeginning(rszPointer, "-", rszPointer))
        {
            // Parse the second value
            if (!ParseUInt(rszPointer, TRUE, nValue2, rszPointer))
            {
                goto Error;
            }
        }
        else if (MatchStringBeginning(rszPointer, "x", rszPointer))
        {
            // The second digit of Value1 can be anything
            nValue1 *= 10;
            nValue2 = nValue1 + 9;
        }
        else
        {
            nValue2 = nValue1;
        }
        DEBUGCHK(nValue1 <= nValue2);

        // Walk through this sub-range and add corresponding flags to the mask
        for (i = nValue1; i <= nValue2; i++)
        {
            DWORD Flag;
            if (FlagFromValue(i,rglvmMapArray,nMapArrayLength,Flag))
            {
                rdwMask |= Flag;
            }
        }

        // Parse ","
        if (',' != *rszPointer)
        {
            break;
        }
        rszPointer++;
    }

    // Parse ")"
    if (')' != *rszPointer)
    {
        goto Error;
    }
    rszPointer++;
    fRet = TRUE;

    Error:
    if (!fRet)
    {
        rszPointer = szData;
    }
    return fRet;
}

//
//
//
BOOL ParseStringList(const LPCSTR szData, const LISTSTRINGMAP* const rglsmMapArray, const UINT nMapArrayLength, DWORD& rdwMask,
                     LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(ParseStringList);
    char szString[MAX_PATH];
    BOOL fRet = FALSE;

    rdwMask = 0x00000000;
    rszPointer = szData;

    // Parse "("
    if ('(' != *rszPointer)
    {
        goto Error;
    }
    rszPointer++;

    while (1)
    {
        // Parse the next string
        if (!ParseString(rszPointer, szString, MAX_PATH, rszPointer))
        {
            goto Error;
        }

        // Add corresponding flag to the mask
        DWORD Flag;
        if (FlagFromString(szString, rglsmMapArray, nMapArrayLength,Flag))
        {
            rdwMask |= Flag;
        }

        // Parse ","
        if (',' != *rszPointer)
        {
            break;
        }
        rszPointer++;
    }

    // Parse ")"
    if (')' != *rszPointer)
    {
        goto Error;
    }
    rszPointer++;
    fRet = TRUE;

    Error:
    if (!fRet)
    {
        rszPointer = szData;
    }
    return fRet;
}


// Note that if ParsePartialResponse thinks there is a partial response, it will throw away
// the partial response up to the '+' character of the next response. This means that it will
// also throw away any leading <cr><lf> prefix on the next call. This works because
// ParseRspPrefix always returns TRUE, even if the <cr><lf> prefix isn't there. So, if you
// ever have ParseRspPrefix return FALSE if the prefix isn't there, go back into ParsePartialResponse
// and fix it to leave the prefix at the beginning of the next response.
//
//
//
BOOL ParseRspPrefix(const LPCSTR szData, LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(ParseRspPrefix);

    (void)MatchStringBeginning(szData, "\r\n", rszPointer);

    return TRUE;
}


//
//
//
BOOL ParseRspPostfix(const LPCSTR szData, LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(ParseRspPostfix);
    BOOL fRet;

    fRet = MatchStringBeginning(szData, "\r\n", rszPointer);
#ifdef EMP_DRIVER
	// On EMP platform it is acceptable to have only a '\r' in the response
	if (!fRet)
	{
		fRet = MatchStringBeginning(szData, "\r", rszPointer);
	}
#endif

    return fRet;
}


BOOL ParseRspParamSeparator(const LPCSTR szData, LPCSTR& rszPointer)
{
    // TBD_FUNCTION(ParseRspParamSeperator);

    return MatchStringBeginning(szData, ",", rszPointer);
}

//
//
//
BOOL FindRspPostfix(const LPCSTR szData, LPCSTR& rszPointer)
{
    // FUNCTION_TRACE(FindRspPostfix);
    BOOL fRet;

    fRet = MatchStringAnywhere(szData, "\r\n", rszPointer);
#ifdef EMP_DRIVER
	// On EMP platform it is acceptable to have only a '\r' in the response
	if (!fRet)
	{
		fRet = MatchStringAnywhere(szData, "\r", rszPointer);
	}
#endif

    return fRet;
}