Ignore:
Timestamp:
Aug 12, 2019, 5:13:22 PM (4 months ago)
Author:
matszpk
Message:

CLRadeonExtender: ROCm: Add next stuff to parse MsgPack? metadata.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdbin/ROCmBinaries.cpp

    r4882 r4883  
    14531453}
    14541454
     1455static CString parseMsgPackString(const cxbyte*& dataPtr, const cxbyte* dataEnd)
     1456{
     1457    if (dataPtr>=dataEnd)
     1458        throw ParseException("MsgPack: Can't parse string");
     1459    size_t size = 0;
     1460   
     1461    if ((*dataPtr&0xe0) == 0xa0)
     1462        size = (*dataPtr++) & 0x1f;
     1463    else
     1464    {
     1465        const cxbyte code = *dataPtr++;
     1466        switch (code)
     1467        {
     1468            case 0xd9:
     1469                if (dataPtr>=dataEnd)
     1470                    throw ParseException("MsgPack: Can't parse string size");
     1471                size = *dataPtr++;
     1472                break;
     1473            case 0xda:
     1474                if (dataPtr+1>=dataEnd)
     1475                    throw ParseException("MsgPack: Can't parse string size");
     1476                size = *dataPtr++;
     1477                size |= uint32_t(*dataPtr++)<<8;
     1478                break;
     1479            case 0xdb:
     1480                if (dataPtr+3>=dataEnd)
     1481                    throw ParseException("MsgPack: Can't parse string size");
     1482                for (cxuint i = 0; i < 32; i+=8)
     1483                    size |= uint32_t(*dataPtr++)<<i;
     1484                break;
     1485            default:
     1486                throw ParseException("MsgPack: Can't parse string");
     1487        }
     1488    }
     1489   
     1490    if (dataPtr+size > dataEnd)
     1491        throw ParseException("MsgPack: Can't parse string");
     1492    const char* strData = reinterpret_cast<const char*>(dataPtr);
     1493    CString out(strData, strData + size);
     1494    dataPtr += size;
     1495    return out;
     1496}
     1497
    14551498static Array<cxbyte> parseMsgPackData(const cxbyte*& dataPtr, const cxbyte* dataEnd)
    14561499{
     
    14821525    }
    14831526   
    1484     Array<cxbyte> out(size);
    14851527    if (dataPtr+size > dataEnd)
    14861528        throw ParseException("MsgPack: Can't parse byte-array");
    1487     std::copy(dataPtr, dataPtr + size, out.begin());
     1529    Array<cxbyte> out(dataPtr, dataPtr + size);
    14881530    dataPtr += size;
    14891531    return out;
     1532}
     1533
     1534static void skipMsgPackObject(const cxbyte*& dataPtr, const cxbyte* dataEnd)
     1535{
     1536    if (dataPtr>=dataEnd)
     1537        throw ParseException("MsgPack: Can't skip object");
     1538    if (*dataPtr==0xc0 || *dataPtr==0xc2 || *dataPtr==0xc3 ||
     1539        *dataPtr < 0x80 || *dataPtr >= 0xe0)
     1540        dataPtr++;
     1541    else if (*dataPtr==0xcc || *dataPtr==0xd0)
     1542    {
     1543        if (dataPtr+1>=dataEnd)
     1544            throw ParseException("MsgPack: Can't skip object");
     1545        dataPtr += 2;
     1546    }
     1547    else if (*dataPtr==0xcd || *dataPtr==0xd1)
     1548    {
     1549        if (dataPtr+2>=dataEnd)
     1550            throw ParseException("MsgPack: Can't skip object");
     1551        dataPtr += 3;
     1552    }
     1553    else if (*dataPtr==0xce || *dataPtr==0xd2 || *dataPtr==0xca)
     1554    {
     1555        if (dataPtr+4>=dataEnd)
     1556            throw ParseException("MsgPack: Can't skip object");
     1557        dataPtr += 5;
     1558    }
     1559    else if (*dataPtr==0xcf || *dataPtr==0xd3 || *dataPtr==0xcb)
     1560    {
     1561        if (dataPtr+8>=dataEnd)
     1562            throw ParseException("MsgPack: Can't skip object");
     1563        dataPtr += 9;
     1564    }
     1565    else if(((*dataPtr)&0xe0)==0xa0)
     1566    {
     1567        const size_t size = *dataPtr&0x1f;
     1568        if (dataPtr+size>=dataEnd)
     1569            throw ParseException("MsgPack: Can't skip object");
     1570        dataPtr += size+1;
     1571    }
     1572    else if (*dataPtr == 0xc4 || *dataPtr == 0xd9)
     1573    {
     1574        dataPtr++;
     1575        if (dataPtr>=dataEnd)
     1576            throw ParseException("MsgPack: Can't skip object");
     1577        const size_t size = *dataPtr++;
     1578        if (dataPtr+size>=dataEnd)
     1579            throw ParseException("MsgPack: Can't skip object");
     1580        dataPtr += size;
     1581    }
     1582    else if (*dataPtr == 0xc5 || *dataPtr == 0xda)
     1583    {
     1584        dataPtr++;
     1585        if (dataPtr+1>=dataEnd)
     1586            throw ParseException("MsgPack: Can't skip object");
     1587        size_t size = *dataPtr++;
     1588        size |= (*dataPtr++)<<8;
     1589        if (dataPtr+size>=dataEnd)
     1590            throw ParseException("MsgPack: Can't skip object");
     1591        dataPtr += size;
     1592    }
     1593    else if (*dataPtr == 0xc6 || *dataPtr == 0xdb)
     1594    {
     1595        dataPtr++;
     1596        if (dataPtr+1>=dataEnd)
     1597            throw ParseException("MsgPack: Can't skip object");
     1598        size_t size = 0;
     1599        for (cxuint i = 0; i < 32; i+=8)
     1600            size |= (*dataPtr++)<<i;
     1601        if (dataPtr+size>=dataEnd)
     1602            throw ParseException("MsgPack: Can't skip object");
     1603        dataPtr += size;
     1604    }
     1605    else if ((*dataPtr&0xf0) == 0x90 || (*dataPtr&0xf0) == 0x80)
     1606    {
     1607        const bool isMap = (*dataPtr<0x90);
     1608        size_t size = (*dataPtr++)&15;
     1609        if (isMap)
     1610            size <<= 1;
     1611        for (size_t i = 0; i < size; i++)
     1612            skipMsgPackObject(dataPtr, dataEnd);
     1613    }
     1614    else if (*dataPtr == 0xdc || *dataPtr==0xde)
     1615    {
     1616        const bool isMap = (*dataPtr==0xde);
     1617        dataPtr++;
     1618        if (dataPtr>=dataEnd)
     1619            throw ParseException("MsgPack: Can't skip object");
     1620        size_t size = *dataPtr++;
     1621        size |= (*dataPtr++)<<8;
     1622        if (dataPtr+size>=dataEnd)
     1623            throw ParseException("MsgPack: Can't skip object");
     1624        if (isMap)
     1625            size<<=1;
     1626        for (size_t i = 0; i < size; i++)
     1627            skipMsgPackObject(dataPtr, dataEnd);
     1628    }
     1629    else if (*dataPtr == 0xdd || *dataPtr==0xdf)
     1630    {
     1631        const bool isMap = (*dataPtr==0xdf);
     1632        dataPtr++;
     1633        if (dataPtr>=dataEnd)
     1634            throw ParseException("MsgPack: Can't skip object");
     1635        size_t size = 0;
     1636        for (cxuint i = 0; i < 32; i+=8)
     1637            size |= (*dataPtr++)<<i;
     1638        if (dataPtr+size>=dataEnd)
     1639            throw ParseException("MsgPack: Can't skip object");
     1640        if (isMap)
     1641            size<<=1;
     1642        for (size_t i = 0; i < size; i++)
     1643            skipMsgPackObject(dataPtr, dataEnd);
     1644    }
     1645}
     1646
     1647class CLRX_INTERNAL MsgPackMapParser;
     1648
     1649class CLRX_INTERNAL MsgPackArrayParser
     1650{
     1651private:
     1652    const cxbyte*& dataPtr;
     1653    const cxbyte* dataEnd;
     1654    size_t count;
     1655public:
     1656    MsgPackArrayParser(const cxbyte*& _dataPtr, const cxbyte* _dataEnd);
     1657   
     1658    void parseNil();
     1659    bool parseBool();
     1660    uint64_t parseInteger(cxbyte signess);
     1661    double parseFloat();
     1662    CString parseString();
     1663    Array<cxbyte> parseData();
     1664    MsgPackArrayParser parseArray();
     1665    MsgPackMapParser parseMap();
     1666    size_t end(); // return left elements
     1667};
     1668
     1669class CLRX_INTERNAL MsgPackMapParser
     1670{
     1671private:
     1672    const cxbyte*& dataPtr;
     1673    const cxbyte* dataEnd;
     1674    size_t count;
     1675    bool keyLeft;
     1676public:
     1677    MsgPackMapParser(const cxbyte*& _dataPtr, const cxbyte* _dataEnd);
     1678   
     1679    void parseKeyNil();
     1680    bool parseKeyBool();
     1681    uint64_t parseKeyInteger(cxbyte signess);
     1682    double parseKeyFloat();
     1683    CString parseKeyString();
     1684    Array<cxbyte> parseKeyData();
     1685    MsgPackArrayParser parseKeyArray();
     1686    MsgPackMapParser parseKeyMap();
     1687    void parseValueNil();
     1688    bool parseValueBool();
     1689    uint64_t parseValueInteger(cxbyte signess);
     1690    double parseValueFloat();
     1691    CString parseValueString();
     1692    Array<cxbyte> parseValueData();
     1693    MsgPackArrayParser parseValueArray();
     1694    MsgPackMapParser parseValueMap();
     1695    size_t end(); // return left elements
     1696};
     1697
     1698//////////////////
     1699MsgPackArrayParser::MsgPackArrayParser(const cxbyte*& _dataPtr, const cxbyte* _dataEnd)
     1700        : dataPtr(_dataPtr), dataEnd(_dataEnd), count(0)
     1701{
     1702    if (dataPtr==dataEnd)
     1703        throw ParseException("MsgPack: Can't parse array of elements");
     1704   
     1705    if (((*dataPtr) & 0xf0) == 0x90)
     1706        count = (*dataPtr++) & 15;
     1707    else
     1708    {
     1709        const cxbyte code = *dataPtr++;
     1710        if (code == 0xdc)
     1711        {
     1712            if (dataPtr+1 >= dataEnd)
     1713                throw ParseException("MsgPack: Can't parse array size");
     1714            count = *dataPtr++;
     1715            count |= (*dataPtr++)<<8;
     1716        }
     1717        else if (code == 0xdd)
     1718        {
     1719            if (dataPtr+3 >= dataEnd)
     1720                throw ParseException("MsgPack: Can't parse array size");
     1721            for (cxuint i = 0; i < 32; i+=8)
     1722                count |= uint32_t(*dataPtr++)<<i;
     1723        }
     1724        else
     1725            throw ParseException("MsgPack: Can't parse array of elements");
     1726    }
     1727}
     1728
     1729void MsgPackArrayParser::parseNil()
     1730{
     1731    if (count == 0)
     1732        throw ParseException("MsgPack: No left element to parse");
     1733    parseMsgPackNil(dataPtr, dataEnd);
     1734    count--;
     1735}
     1736
     1737bool MsgPackArrayParser::parseBool()
     1738{
     1739    if (count == 0)
     1740        throw ParseException("MsgPack: No left element to parse");
     1741    auto v = parseMsgPackBool(dataPtr, dataEnd);
     1742    count--;
     1743    return v;
     1744}
     1745
     1746uint64_t MsgPackArrayParser::parseInteger(cxbyte signess)
     1747{
     1748    if (count == 0)
     1749        throw ParseException("MsgPack: No left element to parse");
     1750    auto v = parseMsgPackInteger(dataPtr, dataEnd, signess);
     1751    count--;
     1752    return v;
     1753}
     1754
     1755double MsgPackArrayParser::parseFloat()
     1756{
     1757    if (count == 0)
     1758        throw ParseException("MsgPack: No left element to parse");
     1759    auto v = parseMsgPackFloat(dataPtr, dataEnd);
     1760    count--;
     1761    return v;
     1762}
     1763
     1764CString MsgPackArrayParser::parseString()
     1765{
     1766    if (count == 0)
     1767        throw ParseException("MsgPack: No left element to parse");
     1768    auto v = parseMsgPackString(dataPtr, dataEnd);
     1769    count--;
     1770    return v;
     1771}
     1772
     1773Array<cxbyte> MsgPackArrayParser::parseData()
     1774{
     1775    if (count == 0)
     1776        throw ParseException("MsgPack: No left element to parse");
     1777    auto v = parseMsgPackData(dataPtr, dataEnd);
     1778    count--;
     1779    return v;
     1780}
     1781
     1782MsgPackArrayParser MsgPackArrayParser::parseArray()
     1783{
     1784    if (count == 0)
     1785        throw ParseException("MsgPack: No left element to parse");
     1786    auto v = MsgPackArrayParser(dataPtr, dataEnd);
     1787    count--;
     1788    return v;
     1789}
     1790
     1791MsgPackMapParser MsgPackArrayParser::parseMap()
     1792{
     1793    if (count == 0)
     1794        throw ParseException("MsgPack: No left element to parse");
     1795    auto v = MsgPackMapParser(dataPtr, dataEnd);
     1796    count--;
     1797    return v;
     1798}
     1799
     1800size_t MsgPackArrayParser::end()
     1801{
     1802    for (size_t i = 0; i < count; i++)
     1803        skipMsgPackObject(dataPtr, dataEnd);
     1804    return count;
     1805}
     1806
     1807//////////////////
     1808MsgPackMapParser::MsgPackMapParser(const cxbyte*& _dataPtr, const cxbyte* _dataEnd)
     1809        : dataPtr(_dataPtr), dataEnd(_dataEnd), count(0), keyLeft(true)
     1810{
     1811    if (dataPtr==dataEnd)
     1812        throw ParseException("MsgPack: Can't parse map");
     1813   
     1814    if (((*dataPtr) & 0xf0) == 0x80)
     1815        count = (*dataPtr++) & 15;
     1816    else
     1817    {
     1818        const cxbyte code = *dataPtr++;
     1819        if (code == 0xde)
     1820        {
     1821            if (dataPtr+1 >= dataEnd)
     1822                throw ParseException("MsgPack: Can't parse map size");
     1823            count = *dataPtr++;
     1824            count |= (*dataPtr++)<<8;
     1825        }
     1826        else if (code == 0xdf)
     1827        {
     1828            if (dataPtr+3 >= dataEnd)
     1829                throw ParseException("MsgPack: Can't parse map size");
     1830            for (cxuint i = 0; i < 32; i+=8)
     1831                count |= uint32_t(*dataPtr++)<<i;
     1832        }
     1833        else
     1834            throw ParseException("MsgPack: Can't parse map");
     1835    }
     1836}
     1837
     1838void MsgPackMapParser::parseKeyNil()
     1839{
     1840    if (count == 0)
     1841        throw ParseException("MsgPack: No left element to parse");
     1842    if (!keyLeft)
     1843        throw ParseException("MsgPack: Key already parsed");
     1844    parseMsgPackNil(dataPtr, dataEnd);
     1845    keyLeft = false;
     1846}
     1847
     1848bool MsgPackMapParser::parseKeyBool()
     1849{
     1850    if (count == 0)
     1851        throw ParseException("MsgPack: No left element to parse");
     1852    if (!keyLeft)
     1853        throw ParseException("MsgPack: Key already parsed");
     1854    auto v = parseMsgPackBool(dataPtr, dataEnd);
     1855    keyLeft = false;
     1856    return v;
     1857}
     1858
     1859uint64_t MsgPackMapParser::parseKeyInteger(cxbyte signess)
     1860{
     1861    if (count == 0)
     1862        throw ParseException("MsgPack: No left element to parse");
     1863    if (!keyLeft)
     1864        throw ParseException("MsgPack: Key already parsed");
     1865    auto v = parseMsgPackInteger(dataPtr, dataEnd, signess);
     1866    keyLeft = false;
     1867    return v;
    14901868}
    14911869
Note: See TracChangeset for help on using the changeset viewer.