Add ifndef TRUE/FALSE

Jan Breuer

2013-10-08 1be423e019d9876dbfa20300a481406ad39f05f0

 libscpi/src/parser.c

@@ -167,7 +167,9 @@

        r = SCPI_DetectProgramMessageUnit(state, data, len);

        if (state->programHeader.len > 0) {
        if (state->programHeader.type == TokInvalid) {
            SCPI_ErrorPush(context, SCPI_ERROR_UNEXPECTED_CHARACTER);
        } else if (state->programHeader.len > 0) {
            if (findCommandHeader(context, state->programHeader.ptr, state->programHeader.len)) {

                context->param_list.lex_state.buffer = state->programData.ptr;
@@ -340,6 +342,17 @@
    return result;
}

/**
 * Write boolean value to the result
 * @param context
 * @param val
 * @return
 */
size_t SCPI_ResultBool(scpi_t * context, bool_t val) {
    return SCPI_ResultIntBase(context, val ? 1 : 0, 10);
}


/* parsing parameters */

bool_t SCPI_Parameter(scpi_t * context, scpi_parameter_t * parameter, bool_t mandatory) {
@@ -448,6 +461,26 @@
    *len = parameter->data.len;
}

/* SCPI-99 7.3 Boolean Program Data */
bool_t SCPI_ParamGetBoolVal(scpi_t * context, scpi_parameter_t * parameter) {
    switch (parameter->type) {
        case TokDecimalNumericProgramData:
            return parameter->number.value ? 1 : 0;
        case TokProgramMnemonic:
            if (compareStr("ON", 2, parameter->data.ptr, parameter->data.len)) {
                return TRUE;
            } else if (compareStr("OFF", 3, parameter->data.ptr, parameter->data.len)) {
                return FALSE;
            } else {
                SCPI_ErrorPush(context, SCPI_ERROR_INVALID_PARAMETER);
                return FALSE;
            }
        default:
            SCPI_ErrorPush(context, SCPI_ERROR_INVALID_PARAMETER);
            return FALSE;
    }
}

int SCPI_ParseProgramData(lex_state_t * state, token_t * token) {
    token_t tmp;
    int result = 0;
@@ -523,6 +556,12 @@
    return token->len;
}

static void invalidateToken(token_t * token, const char * ptr) {
    token->len = 0;
    token->ptr = ptr;
    token->type = TokUnknown;
}

int SCPI_DetectProgramMessageUnit(scpi_parser_state_t * state, const char * buffer, int len) {
    lex_state_t lex_state;
    token_t tmp;
@@ -530,6 +569,7 @@

    lex_state.buffer = lex_state.pos = buffer;
    lex_state.len = len;
    state->numberOfParameters = 0;

    /* ignore whitespace at the begginig */
    SCPI_LexWhiteSpace(&lex_state, &tmp);
@@ -538,25 +578,25 @@
        if (SCPI_LexWhiteSpace(&lex_state, &tmp) > 0) {
            SCPI_ParseAllProgramData(&lex_state, &state->programData, &state->numberOfParameters);
        } else {
            state->programData.len = 0;
            state->programData.ptr = lex_state.pos;
            state->programData.type = TokUnknown;
            state->numberOfParameters = 0;
            invalidateToken(&state->programData, lex_state.pos);
        }
    } else {
        state->programHeader.len = 0;
        state->programData.ptr = lex_state.buffer;
        state->programHeader.type = TokUnknown;

        state->programData.len = 0;
        state->programData.ptr = lex_state.buffer;
        state->programData.type = TokUnknown;
        state->numberOfParameters = 0;
        invalidateToken(&state->programHeader, lex_state.buffer);
        invalidateToken(&state->programData, lex_state.buffer);
    }

    if (result == 0) result = SCPI_LexNewLine(&lex_state, &tmp);
    if (result == 0) result = SCPI_LexSemicolon(&lex_state, &tmp);

    if (!SCPI_LexIsEos(&lex_state) && (result == 0)) {
        lex_state.pos++;

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

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

    if (TokSemicolon == tmp.type) {
        state->termination = PmutSemicolon;
    } else if (TokNewLine == tmp.type) {