Changeset 3339 in CLRX


Ignore:
Timestamp:
Sep 8, 2017, 3:19:31 PM (10 months ago)
Author:
matszpk
Message:

CLRadeonExtender: Yet another killing code lines by macros.

Location:
CLRadeonExtender/trunk/amdasm
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdasm/AsmInternals.h

    r3338 r3339  
    317317    }
    318318
     319#define ASM_NOTGOOD_BY_ERROR(PLACE, STRING) \
     320    { \
     321        asmr.printError(PLACE, STRING); \
     322        good = false; \
     323    }
     324
     325#define ASM_NOTGOOD_BY_ERROR1(GOOD, PLACE, STRING) \
     326    { \
     327        asmr.printError(PLACE, STRING); \
     328        GOOD = false; \
     329    }
     330
    319331extern CLRX_INTERNAL cxbyte cstrtobyte(const char*& str, const char* end);
    320332
  • CLRadeonExtender/trunk/amdasm/AsmPseudoOps.cpp

    r3338 r3339  
    475475   
    476476    if (!asmr.isWriteableSection())
    477     {
    478         asmr.printError(pseudoOpPlace,
    479                         "Writing data into non-writeable section is illegal");
    480         return;
    481     }
     477        PSEUDOOP_RETURN_BY_ERROR("Writing data into non-writeable section is illegal")
    482478   
    483479    skipSpacesToEnd(linePtr, end);
  • CLRadeonExtender/trunk/amdasm/Assembler.cpp

    r3249 r3339  
    221221    skipSpacesToEnd(linePtr, asmr.line + asmr.lineSize);
    222222    if (linePtr != asmr.line + asmr.lineSize)
    223     {
    224         asmr.printError(linePtr, "Garbages at end of line");
    225         return false;
    226     }
     223        ASM_FAIL_BY_ERROR(linePtr, "Garbages at end of line")
    227224    return true;
    228225}
     
    238235        return false;
    239236    if (expr->isEmpty() && requiredExpr)
    240     {
    241         asmr.printError(exprPlace, "Expected expression");
    242         return false;
    243     }
     237        ASM_FAIL_BY_ERROR(exprPlace, "Expected expression")
    244238    if (expr->isEmpty()) // do not set if empty expression
    245239        return true;
     
    248242        return false;
    249243    else if (sectionId != ASMSECT_ABS)
    250     {   // if not absolute value
    251         asmr.printError(exprPlace, "Expression must be absolute!");
    252         return false;
    253     }
     244        // if not absolute value
     245        ASM_FAIL_BY_ERROR(exprPlace, "Expression must be absolute!")
    254246    return true;
    255247}
     
    265257        return false;
    266258    if (expr->isEmpty())
    267     {
    268         asmr.printError(exprPlace, "Expected expression");
    269         return false;
    270     }
     259        ASM_FAIL_BY_ERROR(exprPlace, "Expected expression")
    271260    if (!expr->evaluate(asmr, value, sectionId)) // failed evaluation!
    272261        return false;
     
    284273        return false;
    285274    if (expr->isEmpty())
    286     {
    287         asmr.printError(exprPlace, "Expected expression");
    288         return false;
    289     }
     275        ASM_FAIL_BY_ERROR(exprPlace, "Expected expression")
    290276    if (expr->getSymOccursNum()==0)
    291277    {
     
    294280            return false;
    295281        if (sectionId != asmr.currentSection)
    296         {   // if jump outside current section (.text)
    297             asmr.printError(exprPlace, "Jump over current section!");
    298             return false;
    299         }
     282            // if jump outside current section (.text)
     283            ASM_FAIL_BY_ERROR(exprPlace, "Jump over current section!")
    300284        return true;
    301285    }
     
    317301        if (!requiredArg)
    318302            return true; // succeed
    319         asmr.printError(linePtr, (std::string("Expected ")+objName).c_str());
    320         return false;
     303        ASM_FAIL_BY_ERROR(linePtr, (std::string("Expected ")+objName).c_str())
    321304    }
    322305    const char* nameStr = linePtr;
     
    356339            return true; // succeed
    357340        }
    358         asmr.printError(linePtr, (std::string("Expected ")+objName).c_str());
    359         return false;
     341        ASM_FAIL_BY_ERROR(linePtr, (std::string("Expected ")+objName).c_str())
    360342    }
    361343    const char* nameStr = linePtr;
     
    389371            return true;
    390372        }
    391         asmr.printError(linePtr, (std::string(objName)+" is too long").c_str());
    392         return false;
     373        ASM_FAIL_BY_ERROR(linePtr, (std::string(objName)+" is too long").c_str())
    393374    }
    394375    const size_t outStrSize = std::min(maxOutStrSize-1, size_t(linePtr-nameStr));
     
    408389    }
    409390    if (*linePtr != ',')
    410     {
    411         asmr.printError(linePtr, "Expected ',' before argument");
    412         return false;
    413     }
     391        ASM_FAIL_BY_ERROR(linePtr, "Expected ',' before argument")
    414392    linePtr++;
    415393    haveComma = true;
     
    422400    skipSpacesToEnd(linePtr, end);
    423401    if (linePtr == end || *linePtr != ',')
    424     {
    425         asmr.printError(linePtr, "Expected ',' before argument");
    426         return false;
    427     }
     402        ASM_FAIL_BY_ERROR(linePtr, "Expected ',' before argument")
    428403    linePtr++;
    429404    return true;
     
    438413    if (*linePtr != ',')
    439414    {
    440         asmr.printError(linePtr, "Expected ',' before next value");
    441415        linePtr++;
    442         return false;
     416        ASM_FAIL_BY_ERROR(linePtr-1, "Expected ',' before next value")
    443417    }
    444418    else
     
    470444            value = table[index].second;
    471445        else // end of this map
    472         {
    473             asmr.printError(namePlace, (std::string("Unknown ")+objName).c_str());
    474             return false;
    475         }
     446            ASM_FAIL_BY_ERROR(namePlace, (std::string("Unknown ")+objName).c_str())
    476447        return true;
    477448    }
     
    497468                dimMask |= 4;
    498469            else
    499             {
    500                 asmr.printError(dimPlace, "Unknown dimension type");
    501                 return false;
    502             }
     470                ASM_FAIL_BY_ERROR(dimPlace, "Unknown dimension type")
    503471    }
    504472    else // error
     
    694662bool Assembler::parseString(std::string& strarray, const char*& linePtr)
    695663{
     664    Assembler& asmr = *this; // for error
    696665    const char* end = line+lineSize;
    697666    const char* startPlace = linePtr;
     
    701670    {
    702671        while (linePtr != end && !isSpace(*linePtr) && *linePtr != ',') linePtr++;
    703         printError(startPlace, "Expected string");
    704         return false;
     672        ASM_FAIL_BY_ERROR(startPlace, "Expected string");
    705673    }
    706674    linePtr++;
     
    713681            uint16_t value;
    714682            if (linePtr == end)
    715             {
    716                 printError(startPlace, "Unterminated character of string");
    717                 return false;
    718             }
     683                ASM_FAIL_BY_ERROR(startPlace, "Unterminated character of string")
    719684            if (*linePtr == 'x')
    720685            {   // hex
     
    722687                linePtr++;
    723688                if (linePtr == end)
    724                 {
    725                     printError(startPlace, "Unterminated character of string");
    726                     return false;
    727                 }
     689                    ASM_FAIL_BY_ERROR(startPlace, "Unterminated character of string")
    728690                value = 0;
    729691                if (isXDigit(*linePtr))
     
    742704                    }
    743705                else
    744                 {
    745                     printError(charPlace, "Expected hexadecimal character code");
    746                     return false;
    747                 }
     706                    ASM_FAIL_BY_ERROR(charPlace, "Expected hexadecimal character code")
    748707                value &= 0xff;
    749708            }
     
    758717                    value = (value<<3) + uint64_t(*linePtr-'0');
    759718                    if (value > 255)
    760                     {
    761                         printError(charPlace, "Octal code out of range");
    762                         return false;
    763                     }
     719                        ASM_FAIL_BY_ERROR(charPlace, "Octal code out of range")
    764720                }
    765721            }
     
    809765    }
    810766    if (linePtr == end)
    811     {
    812         printError(startPlace, "Unterminated string");
    813         return false;
    814     }
     767        ASM_FAIL_BY_ERROR(startPlace, "Unterminated string");
    815768    linePtr++;
    816769    return true;
     
    819772bool Assembler::parseLiteral(uint64_t& value, const char*& linePtr)
    820773{
     774    Assembler& asmr = *this; // for error
    821775    const char* startPlace = linePtr;
    822776    const char* end = line+lineSize;
     
    825779        linePtr++;
    826780        if (linePtr == end)
    827         {
    828             printError(startPlace, "Unterminated character literal");
    829             return false;
    830         }
     781            ASM_FAIL_BY_ERROR(startPlace, "Unterminated character literal")
    831782        if (*linePtr == '\'')
    832         {
    833             printError(startPlace, "Empty character literal");
    834             return false;
    835         }
     783            ASM_FAIL_BY_ERROR(startPlace, "Empty character literal");
    836784       
    837785        if (*linePtr != '\\')
     
    839787            value = *linePtr++;
    840788            if (linePtr == end || *linePtr != '\'')
    841             {
    842                 printError(startPlace, "Missing ''' at end of literal");
    843                 return false;
    844             }
     789                ASM_FAIL_BY_ERROR(startPlace, "Missing ''' at end of literal")
    845790            linePtr++;
    846791            return true;
     
    850795            linePtr++;
    851796            if (linePtr == end)
    852             {
    853                 printError(startPlace, "Unterminated character literal");
    854                 return false;
    855             }
     797                ASM_FAIL_BY_ERROR(startPlace, "Unterminated character literal")
    856798            if (*linePtr == 'x')
    857799            {   // hex
    858800                linePtr++;
    859801                if (linePtr == end)
    860                 {
    861                     printError(startPlace, "Unterminated character literal");
    862                     return false;
    863                 }
     802                    ASM_FAIL_BY_ERROR(startPlace, "Unterminated character literal")
    864803                value = 0;
    865804                if (isXDigit(*linePtr))
     
    878817                    }
    879818                else
    880                 {
    881                     printError(startPlace, "Expected hexadecimal character code");
    882                     return false;
    883                 }
     819                    ASM_FAIL_BY_ERROR(startPlace, "Expected hexadecimal character code")
    884820                value &= 0xff;
    885821            }
     
    891827                {
    892828                    if (!isODigit(*linePtr))
    893                     {
    894                         printError(startPlace, "Expected octal character code");
    895                         return false;
    896                     }
     829                        ASM_FAIL_BY_ERROR(startPlace, "Expected octal character code");
    897830                    value = (value<<3) + uint64_t(*linePtr-'0');
    898831                    if (value > 255)
    899                     {
    900                         printError(startPlace, "Octal code out of range");
    901                         return false;
    902                     }
     832                        ASM_FAIL_BY_ERROR(startPlace, "Octal code out of range")
    903833                }
    904834            }
     
    943873            }
    944874            if (linePtr == end || *linePtr != '\'')
    945             {
    946                 printError(startPlace, "Missing ''' at end of literal");
    947                 return false;
    948             }
     875                ASM_FAIL_BY_ERROR(startPlace, "Missing ''' at end of literal")
    949876            linePtr++;
    950877            return true;
     
    1033960bool Assembler::parseMacroArgValue(const char*& string, std::string& outStr)
    1034961{
     962    Assembler& asmr = *this;
    1035963    const char* end = line+lineSize;
    1036964    bool firstNonSpace = false;
     
    10761004            }
    10771005        }
    1078         if (string == end)
    1079         {   /* if unterminated string */
    1080             printError(string, "Unterminated quoted string");
    1081             return false;
    1082         }
     1006        if (string == end) /* if unterminated string */
     1007            ASM_FAIL_BY_ERROR(string, "Unterminated quoted string")
    10831008        string++;
    10841009        return true;
     
    10961021        }
    10971022        if (string == end)
    1098         {
    1099             printError(string, "Unterminated quoted string");
    1100             return false;
    1101         }
     1023            ASM_FAIL_BY_ERROR(string, "Unterminated quoted string")
    11021024        string++;
    11031025        return true;
     
    12971219             const char* linePtr, bool reassign, bool baseExpr)
    12981220{
     1221    Assembler& asmr = *this;
    12991222    skipSpacesToEnd(linePtr, line+lineSize);
    13001223    size_t symNameLength = symbolName.size();
     
    13081231    {
    13091232        if (symbolName == ".")
    1310         {
    1311             printError(symbolPlace, "Symbol '.' requires a resolved expression");
    1312             return false;
    1313         }
     1233            ASM_FAIL_BY_ERROR(symbolPlace, "Symbol '.' requires a resolved expression")
    13141234        initializeOutputFormat();
    13151235        ++linePtr;
     
    13201240        skipSpacesToEnd(linePtr, line+lineSize);
    13211241        if (linePtr != line+lineSize)
    1322         {
    1323             printError(linePtr, "Garbages at end of expression");
    1324             return false;
    1325         }
     1242            ASM_FAIL_BY_ERROR(linePtr, "Garbages at end of expression")
    13261243       
    13271244        std::pair<AsmSymbolEntry*, bool> res =
     
    13861303   
    13871304    if (linePtr != line+lineSize)
    1388     {
    1389         printError(linePtr, "Garbages at end of expression");
    1390         return false;
    1391     }
     1305        ASM_FAIL_BY_ERROR(linePtr, "Garbages at end of expression")
    13921306    if (expr->isEmpty()) // empty expression, we treat as error
    1393     {
    1394         printError(exprPlace, "Expected assignment expression");
    1395         return false;
    1396     }
     1307        ASM_FAIL_BY_ERROR(exprPlace, "Expected assignment expression")
    13971308   
    13981309    if (symbolName == ".")
     
    14051316            return assignOutputCounter(symbolPlace, value, sectionId);
    14061317        else
    1407         {
    1408             printError(symbolPlace, "Symbol '.' requires a resolved expression");
    1409             return false;
    1410         }
     1318            ASM_FAIL_BY_ERROR(symbolPlace, "Symbol '.' requires a resolved expression")
    14111319    }
    14121320   
     
    14591367            cxuint sectionId, cxbyte fillValue)
    14601368{
     1369    Assembler& asmr = *this;
    14611370    initializeOutputFormat();
    14621371    if (currentSection != sectionId && sectionId != ASMSECT_ABS)
    1463     {
    1464         printError(symbolPlace, "Illegal section change for symbol '.'");
    1465         return false;
    1466     }
     1372        ASM_FAIL_BY_ERROR(symbolPlace, "Illegal section change for symbol '.'")
    14671373    if (currentSection != ASMSECT_ABS && int64_t(currentOutPos) > int64_t(value))
    1468     {   /* check attempt to move backwards only for section that is not absolute */
    1469         printError(symbolPlace, "Attempt to move backwards");
    1470         return false;
    1471     }
     1374        /* check attempt to move backwards only for section that is not absolute */
     1375        ASM_FAIL_BY_ERROR(symbolPlace, "Attempt to move backwards")
    14721376    if (!isAddressableSection())
    1473     {
    1474         printError(symbolPlace,
    1475                    "Change output counter inside non-addressable section is illegal");
    1476         return false;
    1477     }
     1377        ASM_FAIL_BY_ERROR(symbolPlace,
     1378                   "Change output counter inside non-addressable section is illegal")
    14781379    if (currentSection==ASMSECT_ABS && fillValue!=0)
    14791380        printWarning(symbolPlace, "Fill value is ignored inside absolute section");
     
    15691470               bool& included)
    15701471{
     1472    Assembler& asmr = *this;
    15711473    if (clauseType == AsmClauseType::MACRO || clauseType == AsmClauseType::IF ||
    15721474        clauseType == AsmClauseType::REPEAT)
     
    15961498            return false;
    15971499        case AsmClauseType::MACRO:
    1598             if (clauseType == AsmClauseType::ELSEIF)
    1599                 printError(string,
    1600                        "No '.if' before '.elseif' inside macro");
    1601             else // else
    1602                 printError(string,
    1603                        "No '.if' before '.else' inside macro");
    1604             return false;
     1500            ASM_FAIL_BY_ERROR(string, clauseType == AsmClauseType::ELSEIF ?
     1501                        "No '.if' before '.elseif' inside macro" :
     1502                        "No '.if' before '.aelse' inside macro")
    16051503        case AsmClauseType::REPEAT:
    1606             if (clauseType == AsmClauseType::ELSEIF)
    1607                 printError(string,
    1608                        "No '.if' before '.elseif' inside repetition");
    1609             else // else
    1610                 printError(string,
    1611                        "No '.if' before '.else' inside repetition");
    1612             return false;
     1504            ASM_FAIL_BY_ERROR(string, clauseType == AsmClauseType::ELSEIF ?
     1505                        "No '.if' before '.elseif' inside repetition" :
     1506                        "No '.if' before '.else' inside repetition")
    16131507        default:
    16141508            break;
     
    16251519bool Assembler::popClause(const char* string, AsmClauseType clauseType)
    16261520{
     1521    Assembler& asmr = *this;
    16271522    if (clauses.empty())
    16281523    {   // no clauses
     
    16421537        case AsmClauseType::ELSEIF:
    16431538            if (clauseType == AsmClauseType::MACRO)
    1644             {
    1645                 printError(string, "Ending macro across conditionals");
    1646                 return false;
    1647             }
    1648             else if (clauseType == AsmClauseType::REPEAT)
    1649             {
    1650                 printError(string, "Ending repetition across conditionals");
    1651                 return false;
    1652             }
     1539                ASM_FAIL_BY_ERROR(string, "Ending macro across conditionals")
     1540            if (clauseType == AsmClauseType::REPEAT)
     1541                ASM_FAIL_BY_ERROR(string, "Ending repetition across conditionals")
    16531542            break;
    16541543        case AsmClauseType::MACRO:
    16551544            if (clauseType == AsmClauseType::REPEAT)
    1656             {
    1657                 printError(string, "Ending repetition across macro");
    1658                 return false;
    1659             }
     1545                ASM_FAIL_BY_ERROR(string, "Ending repetition across macro")
    16601546            if (clauseType == AsmClauseType::IF)
    1661             {
    1662                 printError(string, "Ending conditional across macro");
    1663                 return false;
    1664             }
     1547                ASM_FAIL_BY_ERROR(string, "Ending conditional across macro")
    16651548            break;
    16661549        case AsmClauseType::REPEAT:
    16671550            if (clauseType == AsmClauseType::MACRO)
    1668             {
    1669                 printError(string, "Ending macro across repetition");
    1670                 return false;
    1671             }
     1551                ASM_FAIL_BY_ERROR(string, "Ending macro across repetition")
    16721552            if (clauseType == AsmClauseType::IF)
    1673             {
    1674                 printError(string, "Ending conditional across repetition");
    1675                 return false;
    1676             }
     1553                ASM_FAIL_BY_ERROR(string, "Ending conditional across repetition")
    16771554            break;
    16781555        default:
     
    20651942bool Assembler::includeFile(const char* pseudoOpPlace, const std::string& filename)
    20661943{
     1944    Assembler& asmr = *this;
    20671945    if (inclusionLevel == 500)
    2068     {
    2069         printError(pseudoOpPlace, "Inclusion level is greater than 500");
    2070         return false;
    2071     }
     1946        ASM_FAIL_BY_ERROR(pseudoOpPlace, "Inclusion level is greater than 500")
    20721947    std::unique_ptr<AsmInputFilter> newInputFilter(new AsmStreamInputFilter(
    20731948                getSourcePos(pseudoOpPlace), filename));
Note: See TracChangeset for help on using the changeset viewer.