Refactoring token constants

Jan Breuer

2015-01-18 794a6e9f2e3e2ebefd9269772d35f7f3e9e21166

Refactoring token constants

 libscpi/inc/scpi/types.h

@@ -131,31 +131,31 @@

    /* scpi lexer */
    enum _scpi_token_type_t {
        TokComma,
        TokSemicolon,
        TokQuiestion,
        TokNewLine,
        TokHexnum,
        TokOctnum,
        TokBinnum,
        TokProgramMnemonic,
        TokDecimalNumericProgramData,
        TokDecimalNumericProgramDataWithSuffix,
        TokSuffixProgramData,
        TokArbitraryBlockProgramData,
        TokSingleQuoteProgramData,
        TokDoubleQuoteProgramData,
        TokProgramExpression,
        TokCompoundProgramHeader,
        TokIncompleteCompoundProgramHeader,
        TokCommonProgramHeader,
        TokIncompleteCommonProgramHeader,
        TokCompoundQueryProgramHeader,
        TokCommonQueryProgramHeader,
        TokWhiteSpace,
        TokAllProgramData,
        TokInvalid,
        TokUnknown,
        SCPI_TOKEN_COMMA,
        SCPI_TOKEN_SEMICOLON,
        SCPI_TOKEN_QUESTION,
        SCPI_TOKEN_NL,
        SCPI_TOKEN_HEXNUM,
        SCPI_TOKEN_OCTNUM,
        SCPI_TOKEN_BINNUM,
        SCPI_TOKEN_PROGRAM_MNEMONIC,
        SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA,
        SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX,
        SCPI_TOKEN_SUFFIX_PROGRAM_DATA,
        SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA,
        SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA,
        SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA,
        SCPI_TOKEN_PROGRAM_EXPRESSION,
        SCPI_TOKEN_COMPOUND_PROGRAM_HEADER,
        SCPI_TOKEN_INCOMPLETE_COMPOUND_PROGRAM_HEADER,
        SCPI_TOKEN_COMMON_PROGRAM_HEADER,
        SCPI_TOKEN_INCOMPLETE_COMMON_PROGRAM_HEADER,
        SCPI_TOKEN_COMPOUND_QUERY_PROGRAM_HEADER,
        SCPI_TOKEN_COMMON_QUERY_PROGRAM_HEADER,
        SCPI_TOKEN_WS,
        SCPI_TOKEN_ALL_PROGRAM_DATA,
        SCPI_TOKEN_INVALID,
        SCPI_TOKEN_UNKNOWN,
    };
    typedef enum _scpi_token_type_t scpi_token_type_t;

@@ -175,9 +175,9 @@

    /* scpi parser */   
    enum _message_termination_t {
        PmutNone,
        PmutNewLine,
        PmutSemicolon,                
        SCPI_MESSAGE_TERMINATION_NONE,
        SCPI_MESSAGE_TERMINATION_NL,
        SCPI_MESSAGE_TERMINATION_SEMICOLON,                
    };
    typedef enum _message_termination_t message_termination_t;
    

 libscpi/src/lexer.c

@@ -333,9 +333,9 @@
    token->len = state->pos - token->ptr;

    if (token->len > 0) {
        token->type = TokWhiteSpace;
        token->type = SCPI_TOKEN_WS;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
    }

    return token->len;
@@ -402,32 +402,32 @@
int scpiLex_ProgramHeader(lex_state_t * state, scpi_token_t * token) {
    int res;
    token->ptr = state->pos;
    token->type = TokUnknown;
    token->type = SCPI_TOKEN_UNKNOWN;

    res = skipCommonProgramHeader(state);
    if (res >= SKIP_OK) {
        if (skipChr(state, '?') >= SKIP_OK) {
            token->type = TokCommonQueryProgramHeader;
            token->type = SCPI_TOKEN_COMMON_QUERY_PROGRAM_HEADER;
        } else {
            token->type = TokCommonProgramHeader;
            token->type = SCPI_TOKEN_COMMON_PROGRAM_HEADER;
        }
    } else if (res <= SKIP_INCOMPLETE) {
        token->type = TokIncompleteCommonProgramHeader;
        token->type = SCPI_TOKEN_INCOMPLETE_COMMON_PROGRAM_HEADER;
    } else if (res == SKIP_NONE) {
        res = skipCompoundProgramHeader(state);

        if (res >= SKIP_OK) {
            if (skipChr(state, '?') >= SKIP_OK) {
                token->type = TokCompoundQueryProgramHeader;
                token->type = SCPI_TOKEN_COMPOUND_QUERY_PROGRAM_HEADER;
            } else {
                token->type = TokCompoundProgramHeader;
                token->type = SCPI_TOKEN_COMPOUND_PROGRAM_HEADER;
            }
        } else if (res <= SKIP_INCOMPLETE) {
            token->type = TokIncompleteCompoundProgramHeader;
            token->type = SCPI_TOKEN_INCOMPLETE_COMPOUND_PROGRAM_HEADER;
        } 
    }

    if (token->type != TokUnknown) {
    if (token->type != SCPI_TOKEN_UNKNOWN) {
        token->len = state->pos - token->ptr;
    } else {
        token->len = 0;
@@ -456,9 +456,9 @@

    token->len = state->pos - token->ptr;
    if (token->len > 0) {
        token->type = TokProgramMnemonic;
        token->type = SCPI_TOKEN_PROGRAM_MNEMONIC;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
    }

    return token->len;
@@ -517,9 +517,9 @@

    token->len = state->pos - token->ptr;
    if (token->len > 0) {
        token->type = TokDecimalNumericProgramData;
        token->type = SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
    }

    return token->len;
@@ -545,9 +545,9 @@

    token->len = state->pos - token->ptr;
    if ((token->len > 0)) {
        token->type = TokSuffixProgramData;
        token->type = SCPI_TOKEN_SUFFIX_PROGRAM_DATA;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
        state->pos = token->ptr;
        token->len = 0;
    }
@@ -597,15 +597,15 @@
            if (isH(state->pos[0])) {
                state->pos++;
                someNumbers = skipHexNum(state);
                token->type = TokHexnum;
                token->type = SCPI_TOKEN_HEXNUM;
            } else if (isQ(state->pos[0])) {
                state->pos++;
                someNumbers = skipOctNum(state);
                token->type = TokOctnum;
                token->type = SCPI_TOKEN_OCTNUM;
            } else if (isB(state->pos[0])) {
                state->pos++;
                someNumbers = skipBinNum(state);
                token->type = TokBinnum;
                token->type = SCPI_TOKEN_BINNUM;
            }
        }
    }
@@ -614,7 +614,7 @@
        token->ptr += 2; // ignore number prefix
        token->len = state->pos - token->ptr;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
        state->pos = token->ptr;
        token->len = 0;
    }
@@ -662,7 +662,7 @@
    if (!iseos(state)) {
        if (ischr(state, '"')) {
            state->pos++;
            token->type = TokDoubleQuoteProgramData;
            token->type = SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA;
            skipDoubleQuoteProgramData(state);
            if (!iseos(state) && ischr(state, '"')) {
                state->pos++;
@@ -672,7 +672,7 @@
            }
        } else if (ischr(state, '\'')) {
            state->pos++;
            token->type = TokSingleQuoteProgramData;
            token->type = SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA;
            skipSingleQuoteProgramData(state);
            if (!iseos(state) && ischr(state, '\'')) {
                state->pos++;
@@ -689,7 +689,7 @@
        token->ptr++;
        token->len -= 2;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
        state->pos = token->ptr;
        token->len = 0;
    }
@@ -747,9 +747,9 @@
    }

    if ((token->len > 0)) {
        token->type = TokArbitraryBlockProgramData;
        token->type = SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
        state->pos = token->ptr;
        token->len = 0;
    }
@@ -802,9 +802,9 @@
    }

    if ((token->len > 0)) {
        token->type = TokProgramExpression;
        token->type = SCPI_TOKEN_PROGRAM_EXPRESSION;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
        state->pos = token->ptr;
        token->len = 0;
    }
@@ -823,10 +823,10 @@

    if (skipChr(state, ',')) {
        token->len = 1;
        token->type = TokComma;
        token->type = SCPI_TOKEN_COMMA;
    } else {
        token->len = 0;
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
    }

    return token->len;
@@ -843,10 +843,10 @@

    if (skipChr(state, ';')) {
        token->len = 1;
        token->type = TokSemicolon;
        token->type = SCPI_TOKEN_SEMICOLON;
    } else {
        token->len = 0;
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
    }

    return token->len;
@@ -867,9 +867,9 @@
    token->len = state->pos - token->ptr;

    if ((token->len > 0)) {
        token->type = TokNewLine;
        token->type = SCPI_TOKEN_NL;
    } else {
        token->type = TokUnknown;
        token->type = SCPI_TOKEN_UNKNOWN;
        state->pos = token->ptr;
        token->len = 0;
    }

 libscpi/src/parser.c

@@ -168,7 +168,7 @@

        r = scpiParser_detectProgramMessageUnit(state, data, len);

        if (state->programHeader.type == TokInvalid) {
        if (state->programHeader.type == SCPI_TOKEN_INVALID) {
            SCPI_ErrorPush(context, SCPI_ERROR_INVALID_CHARACTER);
        } else if (state->programHeader.len > 0) {
            if (findCommandHeader(context, state->programHeader.ptr, state->programHeader.len)) {
@@ -258,12 +258,12 @@
        while (1) {
            cmdlen = scpiParser_detectProgramMessageUnit(&context->parser_state, context->buffer.data + totcmdlen, context->buffer.position - totcmdlen);
            totcmdlen += cmdlen;
            if (context->parser_state.termination == PmutNewLine) break;
            if (context->parser_state.programHeader.type == TokUnknown) break;
            if (context->parser_state.termination == SCPI_MESSAGE_TERMINATION_NL) break;
            if (context->parser_state.programHeader.type == SCPI_TOKEN_UNKNOWN) break;
            if (totcmdlen >= context->buffer.position) break;
        }

        if (context->parser_state.termination == PmutNewLine) {
        if (context->parser_state.termination == SCPI_MESSAGE_TERMINATION_NL) {
            result = SCPI_Parse(context, context->buffer.data, totcmdlen);
            memmove(context->buffer.data, context->buffer.data + totcmdlen, context->buffer.position - totcmdlen);
            context->buffer.position -= totcmdlen;
@@ -402,7 +402,7 @@
    parameter->number.base = 10;
    parameter->number.unit = SCPI_UNIT_NONE;
    parameter->number.type = SCPI_NUM_NUMBER;
    parameter->type = TokUnknown;
    parameter->type = SCPI_TOKEN_UNKNOWN;

    state = &context->param_list.lex_state;

@@ -411,13 +411,13 @@
            SCPI_ErrorPush(context, SCPI_ERROR_MISSING_PARAMETER);
        } else {
            parameter->number.type = SCPI_NUM_DEF;
            parameter->type = TokProgramMnemonic; // TODO: select something different
            parameter->type = SCPI_TOKEN_PROGRAM_MNEMONIC; // TODO: select something different
        }
        return FALSE;
    }
    if (context->input_count != 0) {
        scpiLex_Comma(state, &token);
        if (token.type != TokComma) {
        if (token.type != SCPI_TOKEN_COMMA) {
            SCPI_ErrorPush(context, SCPI_ERROR_INVALID_SEPARATOR);
            return FALSE;
        }
@@ -432,41 +432,41 @@
    parameter->data.len = token.len;

    switch (token.type) {
        case TokHexnum:
        case SCPI_TOKEN_HEXNUM:
            parameter->number.base = 16;
            strToLong(token.ptr, &value, 16);
            parameter->number.value = value;
            return TRUE;
        case TokOctnum:
        case SCPI_TOKEN_OCTNUM:
            parameter->number.base = 8;
            strToLong(token.ptr, &value, 8);
            parameter->number.value = value;
            return TRUE;
        case TokBinnum:
        case SCPI_TOKEN_BINNUM:
            parameter->number.base = 2;
            strToLong(token.ptr, &value, 2);
            parameter->number.value = value;
            return TRUE;
        case TokProgramMnemonic:
        case SCPI_TOKEN_PROGRAM_MNEMONIC:
            return TRUE;
        case TokDecimalNumericProgramData:
        case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
            strToDouble(token.ptr, &parameter->number.value);
            return TRUE;
        case TokDecimalNumericProgramDataWithSuffix:
        case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
            strToDouble(token.ptr, &parameter->number.value);
            return TRUE;
        case TokArbitraryBlockProgramData:
        case SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA:
            return TRUE;
        case TokSingleQuoteProgramData:
        case SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA:
            // TODO: replace double "single qoute"
            return TRUE;
        case TokDoubleQuoteProgramData:
        case SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA:
            // TODO: replace double "double qoute"
            return TRUE;
        case TokProgramExpression:
        case SCPI_TOKEN_PROGRAM_EXPRESSION:
            return TRUE;
        default:
            parameter->type = TokUnknown;
            parameter->type = SCPI_TOKEN_UNKNOWN;
            parameter->data.ptr = NULL;
            parameter->data.len = 0;
            SCPI_ErrorPush(context, SCPI_ERROR_INVALID_STRING_DATA);
@@ -482,12 +482,12 @@
 */
scpi_bool_t SCPI_ParamIsNumber(scpi_parameter_t * parameter, scpi_bool_t suffixAllowed) {
    switch (parameter->type) {
        case TokHexnum:
        case TokOctnum:
        case TokBinnum:
        case TokDecimalNumericProgramData:
        case SCPI_TOKEN_HEXNUM:
        case SCPI_TOKEN_OCTNUM:
        case SCPI_TOKEN_BINNUM:
        case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
            return TRUE;
        case TokDecimalNumericProgramDataWithSuffix:
        case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
            return suffixAllowed;
        default:
            return FALSE;
@@ -602,10 +602,10 @@
    
    if (result) {
        switch (param.type) {
            case TokDecimalNumericProgramData:
            case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
                *value = param.number.value ? 1 : 0;
                break;
            case TokProgramMnemonic:
            case SCPI_TOKEN_PROGRAM_MNEMONIC:
                if (compareStr("ON", 2, param.data.ptr, param.data.len)) {
                    *value = TRUE;
                } else if (compareStr("OFF", 3, param.data.ptr, param.data.len)) {
@@ -645,7 +645,7 @@
    
    result = SCPI_Parameter(context, &param, mandatory);
    if (result) {
        if (param.type == TokProgramMnemonic) {
        if (param.type == SCPI_TOKEN_PROGRAM_MNEMONIC) {
            for (res = 0; options[res]; ++res) {
                if (matchPattern(options[res], strlen(options[res]), param.data.ptr, param.data.len)) {
                    *value = res;
@@ -689,7 +689,7 @@
            suffixLen = scpiLex_SuffixProgramData(state, &tmp);
            if (suffixLen > 0) {
                token->len += wsLen + suffixLen;
                token->type = TokDecimalNumericProgramDataWithSuffix;
                token->type = SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX;
                result = token->len;
            }
        }
@@ -718,7 +718,7 @@
    int paramCount = 0;

    token->len = -1;
    token->type = TokAllProgramData;
    token->type = SCPI_TOKEN_ALL_PROGRAM_DATA;
    token->ptr = state->pos;


@@ -726,17 +726,17 @@
        token->len += result;

        if (result == 0) {
            token->type = TokUnknown;
            token->type = SCPI_TOKEN_UNKNOWN;
            token->len = 0;
            paramCount = -1;
            break;
        }

        result = scpiParser_parseProgramData(state, &tmp);
        if (tmp.type != TokUnknown) {
        if (tmp.type != SCPI_TOKEN_UNKNOWN) {
            token->len += result;
        } else {
            token->type = TokUnknown;
            token->type = SCPI_TOKEN_UNKNOWN;
            token->len = 0;
            paramCount = -1;
            break;
@@ -757,7 +757,7 @@
static void invalidateToken(scpi_token_t * token, const char * ptr) {
    token->len = 0;
    token->ptr = ptr;
    token->type = TokUnknown;
    token->type = SCPI_TOKEN_UNKNOWN;
}

/**
@@ -797,17 +797,17 @@
        lex_state.pos++;

        state->programHeader.len = 1;
        state->programHeader.type = TokInvalid;
        state->programHeader.type = SCPI_TOKEN_INVALID;

        invalidateToken(&state->programData, lex_state.buffer);        
    }

    if (TokSemicolon == tmp.type) {
        state->termination = PmutSemicolon;
    } else if (TokNewLine == tmp.type) {
        state->termination = PmutNewLine;
    if (SCPI_TOKEN_SEMICOLON == tmp.type) {
        state->termination = SCPI_MESSAGE_TERMINATION_SEMICOLON;
    } else if (SCPI_TOKEN_NL == tmp.type) {
        state->termination = SCPI_MESSAGE_TERMINATION_NL;
    } else {
        state->termination = PmutNone;
        state->termination = SCPI_MESSAGE_TERMINATION_NONE;
    }

    return lex_state.pos - lex_state.buffer;

 libscpi/src/units.c

@@ -264,20 +264,20 @@
    state.len = param.data.len;

    switch(param.type) {
        case TokDecimalNumericProgramData:
        case TokHexnum:
        case TokOctnum:
        case TokBinnum:
        case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA:
        case SCPI_TOKEN_HEXNUM:
        case SCPI_TOKEN_OCTNUM:
        case SCPI_TOKEN_BINNUM:
            result = TRUE;
            break;
        case TokDecimalNumericProgramDataWithSuffix:
        case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX:
            scpiLex_DecimalNumericProgramData(&state, &token);
            scpiLex_WhiteSpace(&state, &token);
            scpiLex_SuffixProgramData(&state, &token);

            result = transformNumber(context, token.ptr, token.len, &param.number);
            break;
        case TokProgramMnemonic:
        case SCPI_TOKEN_PROGRAM_MNEMONIC:
            scpiLex_WhiteSpace(&state, &token);
            scpiLex_CharacterProgramData(&state, &token);


 libscpi/test/test_lexer_parser.c

@@ -30,30 +30,30 @@

const char * typeToStr(scpi_token_type_t type) {
    switch (type) {
        case TokComma: return "TokComma";
        case TokSemicolon: return "TokSemicolon";
        case TokQuiestion: return "TokQuiestion";
        case TokNewLine: return "TokNewLine";
        case TokHexnum: return "TokHexnum";
        case TokOctnum: return "TokOctnum";
        case TokBinnum: return "TokBinnum";
        case TokProgramMnemonic: return "TokProgramMnemonic";
        case TokDecimalNumericProgramData: return "TokDecimalNumericProgramData";
        case TokDecimalNumericProgramDataWithSuffix: return "TokDecimalNumericProgramDataWithSuffix";
        case TokSuffixProgramData: return "TokSuffixProgramData";
        case TokArbitraryBlockProgramData: return "TokArbitraryBlockProgramData";
        case TokSingleQuoteProgramData: return "TokSingleQuoteProgramData";
        case TokDoubleQuoteProgramData: return "TokDoubleQuoteProgramData";
        case TokProgramExpression: return "TokProgramExpression";
        case TokCompoundProgramHeader: return "TokCompoundProgramHeader";
        case TokCommonProgramHeader: return "TokCommonProgramHeader";
        case TokCompoundQueryProgramHeader: return "TokCompoundQueryProgramHeader";
        case TokCommonQueryProgramHeader: return "TokCommonQueryProgramHeader";
        case TokWhiteSpace: return "TokWhiteSpace";
        case TokAllProgramData: return "TokAllProgramData";
        case TokIncompleteCompoundProgramHeader: return "TokIncompleteCompoundProgramHeader";
        case TokIncompleteCommonProgramHeader: return "TokIncompleteCommonProgramHeader";
        case TokInvalid: return "TokInvalid";
        case SCPI_TOKEN_COMMA: return "TokComma";
        case SCPI_TOKEN_SEMICOLON: return "TokSemicolon";
        case SCPI_TOKEN_QUESTION: return "TokQuiestion";
        case SCPI_TOKEN_NL: return "TokNewLine";
        case SCPI_TOKEN_HEXNUM: return "TokHexnum";
        case SCPI_TOKEN_OCTNUM: return "TokOctnum";
        case SCPI_TOKEN_BINNUM: return "TokBinnum";
        case SCPI_TOKEN_PROGRAM_MNEMONIC: return "TokProgramMnemonic";
        case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA: return "TokDecimalNumericProgramData";
        case SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX: return "TokDecimalNumericProgramDataWithSuffix";
        case SCPI_TOKEN_SUFFIX_PROGRAM_DATA: return "TokSuffixProgramData";
        case SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA: return "TokArbitraryBlockProgramData";
        case SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA: return "TokSingleQuoteProgramData";
        case SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA: return "TokDoubleQuoteProgramData";
        case SCPI_TOKEN_PROGRAM_EXPRESSION: return "TokProgramExpression";
        case SCPI_TOKEN_COMPOUND_PROGRAM_HEADER: return "TokCompoundProgramHeader";
        case SCPI_TOKEN_COMMON_PROGRAM_HEADER: return "TokCommonProgramHeader";
        case SCPI_TOKEN_COMPOUND_QUERY_PROGRAM_HEADER: return "TokCompoundQueryProgramHeader";
        case SCPI_TOKEN_COMMON_QUERY_PROGRAM_HEADER: return "TokCommonQueryProgramHeader";
        case SCPI_TOKEN_WS: return "TokWhiteSpace";
        case SCPI_TOKEN_ALL_PROGRAM_DATA: return "TokAllProgramData";
        case SCPI_TOKEN_INCOMPLETE_COMPOUND_PROGRAM_HEADER: return "TokIncompleteCompoundProgramHeader";
        case SCPI_TOKEN_INCOMPLETE_COMMON_PROGRAM_HEADER: return "TokIncompleteCommonProgramHeader";
        case SCPI_TOKEN_INVALID: return "TokInvalid";
        default: return "TokUnknown";
    }
}
@@ -86,9 +86,9 @@
    lexfn_t fn = f;                             \
    int offset = o;                             \
    int len = l;                                \
    scpi_token_type_t tp = t;                        \
    scpi_token_type_t tp = t;                   \
    lex_state_t state;                          \
    scpi_token_t token;                              \
    scpi_token_t token;                         \
                                                \
    state.buffer = state.pos = str;             \
    state.len = strlen(str);                    \
@@ -103,110 +103,110 @@


void testWhiteSpace(void) {
    TEST_TOKEN("  \t MEAS", scpiLex_WhiteSpace, 0, 4, TokWhiteSpace);
    TEST_TOKEN("MEAS", scpiLex_WhiteSpace, 0, 0, TokUnknown);
    TEST_TOKEN("  \t MEAS", scpiLex_WhiteSpace, 0, 4, SCPI_TOKEN_WS);
    TEST_TOKEN("MEAS", scpiLex_WhiteSpace, 0, 0, SCPI_TOKEN_UNKNOWN);
}

void testNondecimal(void) {
    TEST_TOKEN("#H123fe5A", scpiLex_NondecimalNumericData, 2, 7, TokHexnum);
    TEST_TOKEN("#B0111010101", scpiLex_NondecimalNumericData, 2, 10, TokBinnum);
    TEST_TOKEN("#Q125725433", scpiLex_NondecimalNumericData, 2, 9, TokOctnum);
    TEST_TOKEN("#H123fe5A", scpiLex_NondecimalNumericData, 2, 7, SCPI_TOKEN_HEXNUM);
    TEST_TOKEN("#B0111010101", scpiLex_NondecimalNumericData, 2, 10, SCPI_TOKEN_BINNUM);
    TEST_TOKEN("#Q125725433", scpiLex_NondecimalNumericData, 2, 9, SCPI_TOKEN_OCTNUM);
}

void testCharacterProgramData(void) {
    TEST_TOKEN("abc_213as564", scpiLex_CharacterProgramData, 0, 12, TokProgramMnemonic);
    TEST_TOKEN("abc_213as564 , ", scpiLex_CharacterProgramData, 0, 12, TokProgramMnemonic);
    TEST_TOKEN("abc_213as564", scpiLex_CharacterProgramData, 0, 12, SCPI_TOKEN_PROGRAM_MNEMONIC);
    TEST_TOKEN("abc_213as564 , ", scpiLex_CharacterProgramData, 0, 12, SCPI_TOKEN_PROGRAM_MNEMONIC);
}

void testDecimal(void) {
    TEST_TOKEN("10", scpiLex_DecimalNumericProgramData, 0, 2, TokDecimalNumericProgramData);
    TEST_TOKEN("10 , ", scpiLex_DecimalNumericProgramData, 0, 2, TokDecimalNumericProgramData);
    TEST_TOKEN("-10.5 , ", scpiLex_DecimalNumericProgramData, 0, 5, TokDecimalNumericProgramData);
    TEST_TOKEN("+.5 , ", scpiLex_DecimalNumericProgramData, 0, 3, TokDecimalNumericProgramData);
    TEST_TOKEN("-. , ", scpiLex_DecimalNumericProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("-1 e , ", scpiLex_DecimalNumericProgramData, 0, 2, TokDecimalNumericProgramData);
    TEST_TOKEN("-1 e 3, ", scpiLex_DecimalNumericProgramData, 0, 6, TokDecimalNumericProgramData);
    TEST_TOKEN("1.5E12", scpiLex_DecimalNumericProgramData, 0, 6, TokDecimalNumericProgramData);
    TEST_TOKEN("10", scpiLex_DecimalNumericProgramData, 0, 2, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("10 , ", scpiLex_DecimalNumericProgramData, 0, 2, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("-10.5 , ", scpiLex_DecimalNumericProgramData, 0, 5, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("+.5 , ", scpiLex_DecimalNumericProgramData, 0, 3, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("-. , ", scpiLex_DecimalNumericProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);
    TEST_TOKEN("-1 e , ", scpiLex_DecimalNumericProgramData, 0, 2, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("-1 e 3, ", scpiLex_DecimalNumericProgramData, 0, 6, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("1.5E12", scpiLex_DecimalNumericProgramData, 0, 6, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
}

void testSuffix(void) {
    TEST_TOKEN("A/V , ", scpiLex_SuffixProgramData, 0, 3, TokSuffixProgramData);
    TEST_TOKEN("mA.h", scpiLex_SuffixProgramData, 0, 4, TokSuffixProgramData);
    TEST_TOKEN("A/V , ", scpiLex_SuffixProgramData, 0, 3, SCPI_TOKEN_SUFFIX_PROGRAM_DATA);
    TEST_TOKEN("mA.h", scpiLex_SuffixProgramData, 0, 4, SCPI_TOKEN_SUFFIX_PROGRAM_DATA);
}

void testProgramHeader(void) {
    TEST_TOKEN("*IDN? ", scpiLex_ProgramHeader, 0, 5, TokCommonQueryProgramHeader);
    TEST_TOKEN("*RST ", scpiLex_ProgramHeader, 0, 4, TokCommonProgramHeader);
    TEST_TOKEN("*?; ", scpiLex_ProgramHeader, 0, 1, TokIncompleteCommonProgramHeader);
    TEST_TOKEN(":*IDN?; ", scpiLex_ProgramHeader, 0, 1, TokIncompleteCompoundProgramHeader);
    TEST_TOKEN("MEAS:VOLT:DC? ", scpiLex_ProgramHeader, 0, 13, TokCompoundQueryProgramHeader);
    TEST_TOKEN("CONF:VOLT:DC ", scpiLex_ProgramHeader, 0, 12, TokCompoundProgramHeader);
    TEST_TOKEN(":MEAS:VOLT:DC? ", scpiLex_ProgramHeader, 0, 14, TokCompoundQueryProgramHeader);
    TEST_TOKEN(":MEAS::VOLT:DC? ", scpiLex_ProgramHeader, 0, 6, TokIncompleteCompoundProgramHeader);
    TEST_TOKEN("*IDN?", scpiLex_ProgramHeader, 0, 5, TokCommonQueryProgramHeader);
    TEST_TOKEN("*RST", scpiLex_ProgramHeader, 0, 4, TokCommonProgramHeader);
    TEST_TOKEN("CONF:VOLT:DC", scpiLex_ProgramHeader, 0, 12, TokCompoundProgramHeader);
    TEST_TOKEN("]]", scpiLex_ProgramHeader, 0, 0, TokUnknown);
    TEST_TOKEN("*IDN? ", scpiLex_ProgramHeader, 0, 5, SCPI_TOKEN_COMMON_QUERY_PROGRAM_HEADER);
    TEST_TOKEN("*RST ", scpiLex_ProgramHeader, 0, 4, SCPI_TOKEN_COMMON_PROGRAM_HEADER);
    TEST_TOKEN("*?; ", scpiLex_ProgramHeader, 0, 1, SCPI_TOKEN_INCOMPLETE_COMMON_PROGRAM_HEADER);
    TEST_TOKEN(":*IDN?; ", scpiLex_ProgramHeader, 0, 1, SCPI_TOKEN_INCOMPLETE_COMPOUND_PROGRAM_HEADER);
    TEST_TOKEN("MEAS:VOLT:DC? ", scpiLex_ProgramHeader, 0, 13, SCPI_TOKEN_COMPOUND_QUERY_PROGRAM_HEADER);
    TEST_TOKEN("CONF:VOLT:DC ", scpiLex_ProgramHeader, 0, 12, SCPI_TOKEN_COMPOUND_PROGRAM_HEADER);
    TEST_TOKEN(":MEAS:VOLT:DC? ", scpiLex_ProgramHeader, 0, 14, SCPI_TOKEN_COMPOUND_QUERY_PROGRAM_HEADER);
    TEST_TOKEN(":MEAS::VOLT:DC? ", scpiLex_ProgramHeader, 0, 6, SCPI_TOKEN_INCOMPLETE_COMPOUND_PROGRAM_HEADER);
    TEST_TOKEN("*IDN?", scpiLex_ProgramHeader, 0, 5, SCPI_TOKEN_COMMON_QUERY_PROGRAM_HEADER);
    TEST_TOKEN("*RST", scpiLex_ProgramHeader, 0, 4, SCPI_TOKEN_COMMON_PROGRAM_HEADER);
    TEST_TOKEN("CONF:VOLT:DC", scpiLex_ProgramHeader, 0, 12, SCPI_TOKEN_COMPOUND_PROGRAM_HEADER);
    TEST_TOKEN("]]", scpiLex_ProgramHeader, 0, 0, SCPI_TOKEN_UNKNOWN);
}

void testArbitraryBlock(void) {
    TEST_TOKEN("#12AB", scpiLex_ArbitraryBlockProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#12AB, ", scpiLex_ArbitraryBlockProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#13AB", scpiLex_ArbitraryBlockProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("#12\r\n, ", scpiLex_ArbitraryBlockProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#02AB, ", scpiLex_ArbitraryBlockProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("#12AB", scpiLex_ArbitraryBlockProgramData, 3, 2, SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA);
    TEST_TOKEN("#12AB, ", scpiLex_ArbitraryBlockProgramData, 3, 2, SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA);
    TEST_TOKEN("#13AB", scpiLex_ArbitraryBlockProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);
    TEST_TOKEN("#12\r\n, ", scpiLex_ArbitraryBlockProgramData, 3, 2, SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA);
    TEST_TOKEN("#02AB, ", scpiLex_ArbitraryBlockProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);
}

void testExpression(void) {
    TEST_TOKEN("( 1 + 2 )", scpiLex_ProgramExpression, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2 ) , ", scpiLex_ProgramExpression, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2  , ", scpiLex_ProgramExpression, 0, 0, TokUnknown);
    TEST_TOKEN("( 1 + 2 )", scpiLex_ProgramExpression, 0, 9, SCPI_TOKEN_PROGRAM_EXPRESSION);
    TEST_TOKEN("( 1 + 2 ) , ", scpiLex_ProgramExpression, 0, 9, SCPI_TOKEN_PROGRAM_EXPRESSION);
    TEST_TOKEN("( 1 + 2  , ", scpiLex_ProgramExpression, 0, 0, SCPI_TOKEN_UNKNOWN);
}

void testString(void) {
    TEST_TOKEN("\"ahoj\"", scpiLex_StringProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("\"ahoj\" ", scpiLex_StringProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("'ahoj' ", scpiLex_StringProgramData, 1, 4, TokSingleQuoteProgramData);
    TEST_TOKEN("'ahoj ", scpiLex_StringProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("'ah''oj' ", scpiLex_StringProgramData, 1, 6, TokSingleQuoteProgramData);
    TEST_TOKEN("'ah\"oj' ", scpiLex_StringProgramData, 1, 5, TokSingleQuoteProgramData);
    TEST_TOKEN("\"ah\"\"oj\" ", scpiLex_StringProgramData, 1, 6, TokDoubleQuoteProgramData);
    TEST_TOKEN("\"ahoj\"", scpiLex_StringProgramData, 1, 4, SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("\"ahoj\" ", scpiLex_StringProgramData, 1, 4, SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("'ahoj' ", scpiLex_StringProgramData, 1, 4, SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("'ahoj ", scpiLex_StringProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);
    TEST_TOKEN("'ah''oj' ", scpiLex_StringProgramData, 1, 6, SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("'ah\"oj' ", scpiLex_StringProgramData, 1, 5, SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("\"ah\"\"oj\" ", scpiLex_StringProgramData, 1, 6, SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA);
}

void testProgramData(void) {
    TEST_TOKEN("#H123fe5A", scpiParser_parseProgramData, 2, 7, TokHexnum);
    TEST_TOKEN("  #H123fe5A ", scpiParser_parseProgramData, 4, 7, TokHexnum);
    TEST_TOKEN("#B0111010101", scpiParser_parseProgramData, 2, 10, TokBinnum);
    TEST_TOKEN("#Q125725433", scpiParser_parseProgramData, 2, 9, TokOctnum);
    TEST_TOKEN("#H123fe5A", scpiParser_parseProgramData, 2, 7, SCPI_TOKEN_HEXNUM);
    TEST_TOKEN("  #H123fe5A ", scpiParser_parseProgramData, 4, 7, SCPI_TOKEN_HEXNUM);
    TEST_TOKEN("#B0111010101", scpiParser_parseProgramData, 2, 10, SCPI_TOKEN_BINNUM);
    TEST_TOKEN("#Q125725433", scpiParser_parseProgramData, 2, 9, SCPI_TOKEN_OCTNUM);

    TEST_TOKEN("10", scpiParser_parseProgramData, 0, 2, TokDecimalNumericProgramData);
    TEST_TOKEN("10 , ", scpiParser_parseProgramData, 0, 2, TokDecimalNumericProgramData);
    TEST_TOKEN("-10.5 , ", scpiParser_parseProgramData, 0, 5, TokDecimalNumericProgramData);
    TEST_TOKEN("+.5 , ", scpiParser_parseProgramData, 0, 3, TokDecimalNumericProgramData);
    TEST_TOKEN("-. , ", scpiParser_parseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("-1 e , ", scpiParser_parseProgramData, 0, 4, TokDecimalNumericProgramDataWithSuffix);
    TEST_TOKEN("-1 e 3, ", scpiParser_parseProgramData, 0, 6, TokDecimalNumericProgramData);
    TEST_TOKEN("1.5E12", scpiParser_parseProgramData, 0, 6, TokDecimalNumericProgramData);
    TEST_TOKEN("10", scpiParser_parseProgramData, 0, 2, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("10 , ", scpiParser_parseProgramData, 0, 2, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("-10.5 , ", scpiParser_parseProgramData, 0, 5, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("+.5 , ", scpiParser_parseProgramData, 0, 3, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("-. , ", scpiParser_parseProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);
    TEST_TOKEN("-1 e , ", scpiParser_parseProgramData, 0, 4, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX);
    TEST_TOKEN("-1 e 3, ", scpiParser_parseProgramData, 0, 6, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN("1.5E12", scpiParser_parseProgramData, 0, 6, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);

    TEST_TOKEN("#12AB", scpiParser_parseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#12AB, ", scpiParser_parseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#13AB", scpiParser_parseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("#12\r\n, ", scpiParser_parseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#02AB, ", scpiParser_parseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("#12AB", scpiParser_parseProgramData, 3, 2, SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA);
    TEST_TOKEN("#12AB, ", scpiParser_parseProgramData, 3, 2, SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA);
    TEST_TOKEN("#13AB", scpiParser_parseProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);
    TEST_TOKEN("#12\r\n, ", scpiParser_parseProgramData, 3, 2, SCPI_TOKEN_ARBITRARY_BLOCK_PROGRAM_DATA);
    TEST_TOKEN("#02AB, ", scpiParser_parseProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);

    TEST_TOKEN("( 1 + 2 ) , ", scpiParser_parseProgramData, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2  , ", scpiParser_parseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("( 1 + 2 ) , ", scpiParser_parseProgramData, 0, 9, SCPI_TOKEN_PROGRAM_EXPRESSION);
    TEST_TOKEN("( 1 + 2  , ", scpiParser_parseProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);

    TEST_TOKEN("\"ahoj\" ", scpiParser_parseProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("'ahoj' ", scpiParser_parseProgramData, 1, 4, TokSingleQuoteProgramData);
    TEST_TOKEN("'ahoj ", scpiParser_parseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("'ah''oj' ", scpiParser_parseProgramData, 1, 6, TokSingleQuoteProgramData);
    TEST_TOKEN("'ah\"oj' ", scpiParser_parseProgramData, 1, 5, TokSingleQuoteProgramData);
    TEST_TOKEN("\"ah\"\"oj\" ", scpiParser_parseProgramData, 1, 6, TokDoubleQuoteProgramData);
    TEST_TOKEN("\"ahoj\" ", scpiParser_parseProgramData, 1, 4, SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("'ahoj' ", scpiParser_parseProgramData, 1, 4, SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("'ahoj ", scpiParser_parseProgramData, 0, 0, SCPI_TOKEN_UNKNOWN);
    TEST_TOKEN("'ah''oj' ", scpiParser_parseProgramData, 1, 6, SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("'ah\"oj' ", scpiParser_parseProgramData, 1, 5, SCPI_TOKEN_SINGLE_QUOTE_PROGRAM_DATA);
    TEST_TOKEN("\"ah\"\"oj\" ", scpiParser_parseProgramData, 1, 6, SCPI_TOKEN_DOUBLE_QUOTE_PROGRAM_DATA);
    
    TEST_TOKEN("abc_213as564 , ", scpiLex_CharacterProgramData, 0, 12, TokProgramMnemonic);
    TEST_TOKEN("abc_213as564 , ", scpiLex_CharacterProgramData, 0, 12, SCPI_TOKEN_PROGRAM_MNEMONIC);
    
    TEST_TOKEN("1.5E12 V", scpiParser_parseProgramData, 0, 8, TokDecimalNumericProgramDataWithSuffix);
    TEST_TOKEN("1.5E12 V", scpiParser_parseProgramData, 0, 8, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA_WITH_SUFFIX);
}


@@ -215,9 +215,9 @@
    lexfn2_t fn = f;                            \
    int offset = o;                             \
    int len = l;                                \
    scpi_token_type_t tp = t;                        \
    scpi_token_type_t tp = t;                   \
    lex_state_t state;                          \
    scpi_token_t token;                              \
    scpi_token_t token;                         \
    int count;                                  \
                                                \
    state.buffer = state.pos = str;             \
@@ -234,12 +234,12 @@


void testAllProgramData(void) {
    TEST_ALL_TOKEN("1.5E12 V", scpiParser_parseAllProgramData, 0, 8, TokAllProgramData, 1);
    TEST_ALL_TOKEN("1.5E12 V, abc_213as564, 10, #H123fe5A", scpiParser_parseAllProgramData, 0, 37, TokAllProgramData, 4);
    TEST_ALL_TOKEN("1.5E12 V, ", scpiParser_parseAllProgramData, 0, 0, TokUnknown, -1);
    TEST_ALL_TOKEN("#12\r\n, 1.5E12 V", scpiParser_parseAllProgramData, 0, 15, TokAllProgramData, 2);
    TEST_ALL_TOKEN(" ( 1 + 2 ) ,#12\r\n, 1.5E12 V", scpiParser_parseAllProgramData, 0, 27, TokAllProgramData, 3);
    TEST_ALL_TOKEN("\"ahoj\" , #12AB", scpiParser_parseAllProgramData, 0, 14, TokAllProgramData, 2);
    TEST_ALL_TOKEN("1.5E12 V", scpiParser_parseAllProgramData, 0, 8, SCPI_TOKEN_ALL_PROGRAM_DATA, 1);
    TEST_ALL_TOKEN("1.5E12 V, abc_213as564, 10, #H123fe5A", scpiParser_parseAllProgramData, 0, 37, SCPI_TOKEN_ALL_PROGRAM_DATA, 4);
    TEST_ALL_TOKEN("1.5E12 V, ", scpiParser_parseAllProgramData, 0, 0, SCPI_TOKEN_UNKNOWN, -1);
    TEST_ALL_TOKEN("#12\r\n, 1.5E12 V", scpiParser_parseAllProgramData, 0, 15, SCPI_TOKEN_ALL_PROGRAM_DATA, 2);
    TEST_ALL_TOKEN(" ( 1 + 2 ) ,#12\r\n, 1.5E12 V", scpiParser_parseAllProgramData, 0, 27, SCPI_TOKEN_ALL_PROGRAM_DATA, 3);
    TEST_ALL_TOKEN("\"ahoj\" , #12AB", scpiParser_parseAllProgramData, 0, 14, SCPI_TOKEN_ALL_PROGRAM_DATA, 2);
}


@@ -257,20 +257,20 @@
} while(0)

void testDetectProgramMessageUnit(void) {
    TEST_DETECT("*IDN?\r\n", 0, 5, TokCommonQueryProgramHeader, 5, 0, PmutNewLine);
    TEST_DETECT(" MEAS:VOLT:DC?\r\n", 1, 13, TokCompoundQueryProgramHeader, 14, 0, PmutNewLine);
    TEST_DETECT(" MEAS:VOLT:DC? 1.2 V\r\n", 1, 13, TokCompoundQueryProgramHeader, 15, 1, PmutNewLine);
    TEST_DETECT(" CONF:VOLT:DC 1.2 V, 100mv;", 1, 12, TokCompoundProgramHeader, 14, 2, PmutSemicolon);
    TEST_DETECT(" CONF:VOLT:DC 1.2 V, 100mv", 1, 12, TokCompoundProgramHeader, 14, 2, PmutNone);
    TEST_DETECT(" CONF:VOLT:DC 1.2 V, \r\n", 1, 12, TokCompoundProgramHeader, 14, -1, PmutNewLine);
    TEST_DETECT("[\r\n", 0, 1, TokInvalid, 0, 0, PmutNone);
    TEST_DETECT("*IDN?\r\n", 0, 5, SCPI_TOKEN_COMMON_QUERY_PROGRAM_HEADER, 5, 0, SCPI_MESSAGE_TERMINATION_NL);
    TEST_DETECT(" MEAS:VOLT:DC?\r\n", 1, 13, SCPI_TOKEN_COMPOUND_QUERY_PROGRAM_HEADER, 14, 0, SCPI_MESSAGE_TERMINATION_NL);
    TEST_DETECT(" MEAS:VOLT:DC? 1.2 V\r\n", 1, 13, SCPI_TOKEN_COMPOUND_QUERY_PROGRAM_HEADER, 15, 1, SCPI_MESSAGE_TERMINATION_NL);
    TEST_DETECT(" CONF:VOLT:DC 1.2 V, 100mv;", 1, 12, SCPI_TOKEN_COMPOUND_PROGRAM_HEADER, 14, 2, SCPI_MESSAGE_TERMINATION_SEMICOLON);
    TEST_DETECT(" CONF:VOLT:DC 1.2 V, 100mv", 1, 12, SCPI_TOKEN_COMPOUND_PROGRAM_HEADER, 14, 2, SCPI_MESSAGE_TERMINATION_NONE);
    TEST_DETECT(" CONF:VOLT:DC 1.2 V, \r\n", 1, 12, SCPI_TOKEN_COMPOUND_PROGRAM_HEADER, 14, -1, SCPI_MESSAGE_TERMINATION_NL);
    TEST_DETECT("[\r\n", 0, 1, SCPI_TOKEN_INVALID, 0, 0, SCPI_MESSAGE_TERMINATION_NONE);
}

void testBoolParameter(void) {
    TEST_TOKEN(" 1", scpiParser_parseProgramData, 1, 1, TokDecimalNumericProgramData);
    TEST_TOKEN(" 0", scpiParser_parseProgramData, 1, 1, TokDecimalNumericProgramData);
    TEST_TOKEN(" ON", scpiParser_parseProgramData, 1, 2, TokProgramMnemonic);
    TEST_TOKEN("OFF ", scpiParser_parseProgramData, 0, 3, TokProgramMnemonic);
    TEST_TOKEN(" 1", scpiParser_parseProgramData, 1, 1, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN(" 0", scpiParser_parseProgramData, 1, 1, SCPI_TOKEN_DECIMAL_NUMERIC_PROGRAM_DATA);
    TEST_TOKEN(" ON", scpiParser_parseProgramData, 1, 2, SCPI_TOKEN_PROGRAM_MNEMONIC);
    TEST_TOKEN("OFF ", scpiParser_parseProgramData, 0, 3, SCPI_TOKEN_PROGRAM_MNEMONIC);
}

int main() {