Ignore:
Timestamp:
Jan 31, 2018, 9:04:53 PM (23 months ago)
Author:
matszpk
Message:

CLRadeonExtender: ROCmBin: The first working version of the ROCm YAML metadata parser.

File:
1 edited

Legend:

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

    r3684 r3685  
    7979            break; // no comment and no end of line
    8080        else
     81        {
     82            ptr++;
    8183            lineNo++; // next line
    82     }
    83     return lineStart - ptr;
     84        }
     85    }
     86    return ptr - lineStart;
    8487}
    8588
     
    113116    const char* keyEnd = ptr;
    114117    while (ptr != end && *ptr!='\n' && isSpace(*ptr)) ptr++;
    115     if (ptr == end || *ptr==':')
     118    if (ptr == end || *ptr!=':')
    116119        throw ParseException(lineNo, "Expected colon");
    117120    ptr++;
     
    152155   
    153156    const char* wordPtr = ptr;
    154     while(ptr == end && isAlnum(*ptr)) ptr++;
     157    while(ptr != end && isAlnum(*ptr)) ptr++;
    155158    CString word(wordPtr, ptr);
    156159   
     
    164167            break;
    165168        }
    166     for (const char* v: { "0", "false", "f", "off", "no", "n"})
    167         if (::strcasecmp(word.c_str(), v) == 0)
    168         {
    169             isSet = true;
    170             value = false;
    171             break;
    172         }
     169    if (!isSet)
     170        for (const char* v: { "0", "false", "f", "off", "no", "n"})
     171            if (::strcasecmp(word.c_str(), v) == 0)
     172            {
     173                isSet = true;
     174                value = false;
     175                break;
     176            }
    173177    if (!isSet)
    174178        throw ParseException(lineNo, "Is not boolean value");
     
    312316    if (ptr == end)
    313317        return "";
     318    std::string buf;
    314319    if (*ptr=='"' || *ptr== '\'')
    315         std::string buf = parseYAMLString(ptr, end, lineNo);
     320        buf = parseYAMLString(ptr, end, lineNo);
    316321    // otherwise parse stream
    317322    else if (*ptr == '|' || *ptr == '>')
     
    358363        return buf;
    359364    }
    360     // single line string (unquoted)
    361     const char* strStart = ptr;
    362     while (ptr != end && *ptr!='\n' && *ptr!='#') ptr++;
    363     std::string buf(strStart, ptr);
     365    else
     366    {
     367        // single line string (unquoted)
     368        const char* strStart = ptr;
     369        while (ptr != end && *ptr!='\n' && *ptr!='#') ptr++;
     370        buf.assign(strStart, ptr);
     371    }
    364372   
    365373    if (singleValue)
     
    390398            // parse in line
    391399            elemConsumer->consume(ptr, end, lineNo, 0, false);
    392             if (ptr!=end && *ptr==',')
    393                 throw ParseException(lineNo, "Expected ','");
    394             else if (ptr!=end && *ptr==']')
     400            skipSpacesAndComments(ptr, end, lineNo);
     401            if (ptr!=end && *ptr==']')
    395402                // just end
    396403                break;
     404            else if (ptr==end || *ptr!=',')
     405                throw ParseException(lineNo, "Expected ','");
    397406            ptr++;
    398407            skipSpacesAndComments(ptr, end, lineNo);
     
    424433        if (afterMinus == ptr)
    425434            throw ParseException(lineNo, "No spaces after '-'");
    426         elemConsumer->consume(ptr, end, lineNo, indent0+1 + afterMinus-ptr, true);
     435        elemConsumer->consume(ptr, end, lineNo, indent0+1 + ptr-afterMinus, true);
    427436       
    428437        size_t indent = skipSpacesAndComments(ptr, end, lineNo);
     
    480489                cxuint prevIndent, bool singleValue)
    481490    {
     491        const size_t oldLineNo = lineNo;
    482492        std::string str = parseYAMLStringValue(ptr, end, lineNo, prevIndent, singleValue);
    483493        // parse printf string
     
    487497        const char* end2 = str.c_str() + str.size();
    488498        skipSpacesToLineEnd(ptr2, end2);
    489         printfInfo.id = cstrtovCStyle<uint32_t>(ptr2, end2, ptr2);
     499        try
     500        { printfInfo.id = cstrtovCStyle<uint32_t>(ptr2, end2, ptr2); }
     501        catch(const ParseException& ex)
     502        { throw ParseException(oldLineNo, ex.what()); }
    490503        skipSpacesToLineEnd(ptr2, end2);
    491504        if (ptr2==end || *ptr2!=':')
    492             throw ParseException(lineNo, "No colon after printf callId");
     505            throw ParseException(oldLineNo, "No colon after printf callId");
    493506        ptr2++;
    494507        skipSpacesToLineEnd(ptr2, end2);
     
    496509        skipSpacesToLineEnd(ptr2, end2);
    497510        if (ptr2==end || *ptr2!=':')
    498             throw ParseException(lineNo, "No colon after printf argsNum");
     511            throw ParseException(oldLineNo, "No colon after printf argsNum");
    499512        ptr2++;
    500513       
     
    513526        // format
    514527        printfInfo.format.assign(ptr2, end2);
     528       
     529        printfInfos.push_back(printfInfo);
    515530    }
    516531};
     
    683698    { "HiddenGlobalOffsetX", ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X },
    684699    { "HiddenGlobalOffsetY", ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Y },
    685     { "HiddenglobalOffsetZ", ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Z },
     700    { "HiddenGlobalOffsetZ", ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Z },
    686701    { "HiddenNone", ROCmValueKind::HIDDEN_NONE },
    687702    { "HiddenPrintfBuffer", ROCmValueKind::HIDDEN_PRINTF_BUFFER },
     
    701716    { "F64", ROCmValueType::FLOAT64 },
    702717    { "I16", ROCmValueType::INT16 },
    703     { "I8", ROCmValueType::INT8 },
    704718    { "I32", ROCmValueType::INT32 },
    705719    { "I64", ROCmValueType::INT64 },
    706     { "U8", ROCmValueType::UINT8 },
     720    { "I8", ROCmValueType::INT8 },
    707721    { "U16", ROCmValueType::UINT16 },
    708722    { "U32", ROCmValueType::UINT32 },
    709723    { "U64", ROCmValueType::UINT64 },
     724    { "U8", ROCmValueType::UINT8 },
    710725    { "Struct", ROCmValueType::STRUCTURE }
    711726};
     
    784799            {
    785800                // leave from kernels
    786                 metadataInfo.kernels.assign(kernels.begin(), kernels.end());
    787                 kernels.clear();
    788801                inKernels = false;
    789802                inKernel = false;
     
    802815                ptr += 3;
    803816                if (ptr!=end)
     817                {
     818                    lineNo++;
    804819                    ptr++; // to newline
     820                }
    805821                continue; // skip document start
    806822            }
     
    11031119                    if (vtypeIndex == rocmValueTypeNamesNum)
    11041120                        throw ParseException(lineNo, "Wrong argument value type");
    1105                     kernelArg.valueKind = rocmValueKindNames[vtypeIndex].second;
     1121                    kernelArg.valueType = rocmValueTypeNames[vtypeIndex].second;
    11061122                    break;
    11071123                }
     
    12681284    }
    12691285   
    1270     if (hasMetadataInfo() && metadata != nullptr && metadataSize != 0)
     1286    if ((creationFlags & ROCMBIN_CREATE_METADATAINFO) != 0 &&
     1287        metadata != nullptr && metadataSize != 0)
    12711288    {
    12721289        metadataInfo.reset(new ROCmMetadata());
Note: See TracChangeset for help on using the changeset viewer.