Refactor public and private functions

Jan Breuer

2013-10-24 43d97ad8631dd8a1ab9966f38e345627188baf47

Refactor public and private functions

 - hide private headers in src folder
 - hide private functions by attribute hidden
 - remove SCPI_ prefix from private functions

 libscpi/Makefile

@@ -30,9 +30,12 @@

HDRS = $(addprefix inc/scpi/, \
    scpi.h constants.h debug.h error.h \
    fifo.h ieee488.h minimal.h parser.h \
    types.h units.h lexer.h \
    ) src/utils.h
    ieee488.h minimal.h parser.h types.h units.h \
    ) \
    $(addprefix src/, \
    lexer_private.h utils_private.h fifo_private.h \
    parser_private.h \
    ) \


TESTS = $(addprefix test/, \

 libscpi/inc/scpi/parser.h

@@ -40,7 +40,6 @@
#include <string.h>
#include "scpi/types.h"
#include "scpi/debug.h"
#include "scpi/lexer.h"

#ifdef    __cplusplus
extern "C" {
@@ -69,12 +68,6 @@
    int32_t SCPI_ParamGetChoiceVal(scpi_t * context, scpi_parameter_t * parameter, const char * options[]);

    bool_t SCPI_Parameter(scpi_t * context, scpi_parameter_t * parameter, bool_t mandatory);



    int SCPI_ParseProgramData(lex_state_t * state, token_t * token);
    int SCPI_ParseAllProgramData(lex_state_t * state, token_t * token, int * numberOfParameters);
    int SCPI_DetectProgramMessageUnit(scpi_parser_state_t * state, const char * buffer, int len);

#ifdef    __cplusplus
}

 libscpi/src/error.c

@@ -39,7 +39,7 @@
#include "scpi/parser.h"
#include "scpi/ieee488.h"
#include "scpi/error.h"
#include "scpi/fifo.h"
#include "fifo_private.h"

/* basic FIFO */
static fifo_t local_error_queue;

 libscpi/src/fifo.c

@@ -1,5 +1,5 @@

#include "scpi/fifo.h"
#include "fifo_private.h"

void fifo_init(fifo_t * fifo) {
    fifo->wr = 0;

 libscpi/src/fifo_private.h

File was renamed from libscpi/inc/scpi/fifo.h
@@ -38,6 +38,7 @@
#define    SCPI_FIFO_H

#include "scpi/types.h"
#include "utils_private.h"

#ifdef    __cplusplus
extern "C" {
@@ -54,11 +55,11 @@
    };
    typedef struct _fifo_t fifo_t;

    void fifo_init(fifo_t * fifo);
    void fifo_clear(fifo_t * fifo);
    bool_t fifo_add(fifo_t * fifo, int16_t value);
    bool_t fifo_remove(fifo_t * fifo, int16_t * value);
    bool_t fifo_count(fifo_t * fifo, int16_t * value);
    void fifo_init(fifo_t * fifo) LOCAL;
    void fifo_clear(fifo_t * fifo) LOCAL;
    bool_t fifo_add(fifo_t * fifo, int16_t value) LOCAL;
    bool_t fifo_remove(fifo_t * fifo, int16_t * value) LOCAL;
    bool_t fifo_count(fifo_t * fifo, int16_t * value) LOCAL;

#ifdef    __cplusplus
}

 libscpi/src/lexer.c

@@ -38,7 +38,7 @@
#include <stdio.h>
#include <string.h>

#include "scpi/lexer.h"
#include "lexer_private.h"

/* identify character */
static int isws(int c) {
@@ -70,7 +70,7 @@
    }
}

int SCPI_LexIsEos(lex_state_t * state) {
int lexIsEos(lex_state_t * state) {
    return iseos(state);
}

@@ -212,7 +212,7 @@
}

/* tokens */
int SCPI_LexWhiteSpace(lex_state_t * state, token_t * token) {
int lexWhiteSpace(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;

    skipWs(state);
@@ -270,7 +270,7 @@
    }
}

int SCPI_LexProgramHeader(lex_state_t * state, token_t * token) {
int lexProgramHeader(lex_state_t * state, token_t * token) {
    int res;
    token->ptr = state->pos;
    token->type = TokUnknown;
@@ -309,7 +309,7 @@
}

/* 7.7.1 <CHARACTER PROGRAM DATA> */
int SCPI_LexCharacterProgramData(lex_state_t * state, token_t * token) {
int lexCharacterProgramData(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;

    if (!iseos(state) && isalpha(state->pos[0])) {
@@ -360,7 +360,7 @@
    return someNumbers;
}

int SCPI_LexDecimalNumericProgramData(lex_state_t * state, token_t * token) {
int lexDecimalNumericProgramData(lex_state_t * state, token_t * token) {
    const char * rollback;
    token->ptr = state->pos;

@@ -385,7 +385,7 @@
}

/* 7.7.3 <SUFFIX PROGRAM DATA> */
int SCPI_LexSuffixProgramData(lex_state_t * state, token_t * token) {
int lexSuffixProgramData(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;

    skipChr(state, '/');
@@ -442,7 +442,7 @@
    return someNumbers;
}

int SCPI_LexNondecimalNumericData(lex_state_t * state, token_t * token) {
int lexNondecimalNumericData(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;
    int someNumbers = 0;
    if (skipChr(state, '#')) {
@@ -503,7 +503,7 @@
    skipQuoteProgramData(state, '\'');
}

int SCPI_LexStringProgramData(lex_state_t * state, token_t * token) {
int lexStringProgramData(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;

    if (!iseos(state)) {
@@ -549,7 +549,7 @@
    return isdigit(c) && (c != '0');
}

int SCPI_LexArbitraryBlockProgramData(lex_state_t * state, token_t * token) {
int lexArbitraryBlockProgramData(lex_state_t * state, token_t * token) {
    int i;
    int j = 0;
    const char * ptr = state->pos;
@@ -622,7 +622,7 @@

// TODO: 7.7.7.2-2 recursive - any program data

int SCPI_LexProgramExpression(lex_state_t * state, token_t * token) {
int lexProgramExpression(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;

    if (!iseos(state) && ischr(state, '(')) {
@@ -648,7 +648,7 @@
    return token->len;
}

int SCPI_LexComma(lex_state_t * state, token_t * token) {
int lexComma(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;

    if (skipChr(state, ',')) {
@@ -662,7 +662,7 @@
    return token->len;
}

int SCPI_LexSemicolon(lex_state_t * state, token_t * token) {
int lexSemicolon(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;

    if (skipChr(state, ';')) {
@@ -676,7 +676,7 @@
    return token->len;
}

int SCPI_LexNewLine(lex_state_t * state, token_t * token) {
int lexNewLine(lex_state_t * state, token_t * token) {
    token->ptr = state->pos;

    skipChr(state, '\r');

 libscpi/src/lexer_private.h

File was renamed from libscpi/inc/scpi/lexer.h
@@ -38,25 +38,25 @@
#define    SCPI_LEXER_H

#include "scpi/types.h"
#include "utils_private.h"

#ifdef    __cplusplus
extern "C" {
#endif

    int SCPI_LexIsEos(lex_state_t * state);
    int SCPI_LexWhiteSpace(lex_state_t * state, token_t * token);
    int SCPI_LexProgramHeader(lex_state_t * state, token_t * token);
    int SCPI_LexQuestion(lex_state_t * state, token_t * token);
    int SCPI_LexCharacterProgramData(lex_state_t * state, token_t * token);
    int SCPI_LexDecimalNumericProgramData(lex_state_t * state, token_t * token);
    int SCPI_LexSuffixProgramData(lex_state_t * state, token_t * token);
    int SCPI_LexNondecimalNumericData(lex_state_t * state, token_t * token);
    int SCPI_LexStringProgramData(lex_state_t * state, token_t * token);
    int SCPI_LexArbitraryBlockProgramData(lex_state_t * state, token_t * token);
    int SCPI_LexProgramExpression(lex_state_t * state, token_t * token);
    int SCPI_LexComma(lex_state_t * state, token_t * token);
    int SCPI_LexSemicolon(lex_state_t * state, token_t * token);
    int SCPI_LexNewLine(lex_state_t * state, token_t * token);
    int lexIsEos(lex_state_t * state) LOCAL;
    int lexWhiteSpace(lex_state_t * state, token_t * token) LOCAL;
    int lexProgramHeader(lex_state_t * state, token_t * token) LOCAL;
    int lexCharacterProgramData(lex_state_t * state, token_t * token) LOCAL;
    int lexDecimalNumericProgramData(lex_state_t * state, token_t * token) LOCAL;
    int lexSuffixProgramData(lex_state_t * state, token_t * token) LOCAL;
    int lexNondecimalNumericData(lex_state_t * state, token_t * token) LOCAL;
    int lexStringProgramData(lex_state_t * state, token_t * token) LOCAL;
    int lexArbitraryBlockProgramData(lex_state_t * state, token_t * token) LOCAL;
    int lexProgramExpression(lex_state_t * state, token_t * token) LOCAL;
    int lexComma(lex_state_t * state, token_t * token) LOCAL;
    int lexSemicolon(lex_state_t * state, token_t * token) LOCAL;
    int lexNewLine(lex_state_t * state, token_t * token) LOCAL;

#ifdef    __cplusplus
}

 libscpi/src/parser.c

@@ -39,8 +39,8 @@

#include "scpi/config.h"
#include "scpi/parser.h"
#include "scpi/lexer.h"
#include "utils.h"
#include "parser_private.h"
#include "lexer_private.h"
#include "scpi/error.h"
#include "scpi/constants.h"

@@ -166,7 +166,7 @@
    while (1) {
        result = 0;

        r = SCPI_DetectProgramMessageUnit(state, data, len);
        r = detectProgramMessageUnit(state, data, len);

        if (state->programHeader.type == TokInvalid) {
            SCPI_ErrorPush(context, SCPI_ERROR_INVALID_CHARACTER);
@@ -253,7 +253,7 @@


        while (1) {
            cmdlen = SCPI_DetectProgramMessageUnit(&context->parser_state, context->buffer.data + totcmdlen, context->buffer.position - totcmdlen);
            cmdlen = 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;
@@ -394,7 +394,7 @@
        return FALSE;
    }
    if (context->input_count != 0) {
        SCPI_LexComma(state, &token);
        lexComma(state, &token);
        if (token.type != TokComma) {
            SCPI_ErrorPush(context, SCPI_ERROR_INVALID_SEPARATOR);
            return FALSE;
@@ -403,7 +403,7 @@

    context->input_count++;

    SCPI_ParseProgramData(&context->param_list.lex_state, &token);
    parseProgramData(&context->param_list.lex_state, &token);

    parameter->type = token.type;
    parameter->data.ptr = token.ptr;
@@ -521,21 +521,21 @@
    }
}

int SCPI_ParseProgramData(lex_state_t * state, token_t * token) {
int parseProgramData(lex_state_t * state, token_t * token) {
    token_t tmp;
    int result = 0;
    int wsLen;
    int suffixLen;
    int realLen = 0;
    realLen += SCPI_LexWhiteSpace(state, &tmp);
    realLen += lexWhiteSpace(state, &tmp);

    if (result == 0) result = SCPI_LexNondecimalNumericData(state, token);
    if (result == 0) result = SCPI_LexCharacterProgramData(state, token);
    if (result == 0) result = lexNondecimalNumericData(state, token);
    if (result == 0) result = lexCharacterProgramData(state, token);
    if (result == 0) {
        result = SCPI_LexDecimalNumericProgramData(state, token);
        result = lexDecimalNumericProgramData(state, token);
        if (result != 0) {
            wsLen = SCPI_LexWhiteSpace(state, &tmp);
            suffixLen = SCPI_LexSuffixProgramData(state, &tmp);
            wsLen = lexWhiteSpace(state, &tmp);
            suffixLen = lexSuffixProgramData(state, &tmp);
            if (suffixLen > 0) {
                token->len += wsLen + suffixLen;
                token->type = TokDecimalNumericProgramDataWithSuffix;
@@ -544,16 +544,16 @@
        }
    }

    if (result == 0) result = SCPI_LexStringProgramData(state, token);
    if (result == 0) result = SCPI_LexArbitraryBlockProgramData(state, token);
    if (result == 0) result = SCPI_LexProgramExpression(state, token);
    if (result == 0) result = lexStringProgramData(state, token);
    if (result == 0) result = lexArbitraryBlockProgramData(state, token);
    if (result == 0) result = lexProgramExpression(state, token);

    realLen += SCPI_LexWhiteSpace(state, &tmp);
    realLen += lexWhiteSpace(state, &tmp);

    return result + realLen;
}

int SCPI_ParseAllProgramData(lex_state_t * state, token_t * token, int * numberOfParameters) {
int parseAllProgramData(lex_state_t * state, token_t * token, int * numberOfParameters) {

    int result;
    token_t tmp;
@@ -564,7 +564,7 @@
    token->ptr = state->pos;


    for (result = 1; result != 0; result = SCPI_LexComma(state, &tmp)) {
    for (result = 1; result != 0; result = lexComma(state, &tmp)) {
        token->len += result;

        if (result == 0) {
@@ -574,7 +574,7 @@
            break;
        }

        result = SCPI_ParseProgramData(state, &tmp);
        result = parseProgramData(state, &tmp);
        if (tmp.type != TokUnknown) {
            token->len += result;
        } else {
@@ -602,7 +602,7 @@
    token->type = TokUnknown;
}

int SCPI_DetectProgramMessageUnit(scpi_parser_state_t * state, const char * buffer, int len) {
int detectProgramMessageUnit(scpi_parser_state_t * state, const char * buffer, int len) {
    lex_state_t lex_state;
    token_t tmp;
    int result = 0;
@@ -612,11 +612,11 @@
    state->numberOfParameters = 0;

    /* ignore whitespace at the begginig */
    SCPI_LexWhiteSpace(&lex_state, &tmp);
    lexWhiteSpace(&lex_state, &tmp);

    if (SCPI_LexProgramHeader(&lex_state, &state->programHeader) >= 0) {
        if (SCPI_LexWhiteSpace(&lex_state, &tmp) > 0) {
            SCPI_ParseAllProgramData(&lex_state, &state->programData, &state->numberOfParameters);
    if (lexProgramHeader(&lex_state, &state->programHeader) >= 0) {
        if (lexWhiteSpace(&lex_state, &tmp) > 0) {
            parseAllProgramData(&lex_state, &state->programData, &state->numberOfParameters);
        } else {
            invalidateToken(&state->programData, lex_state.pos);
        }
@@ -625,10 +625,10 @@
        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 (result == 0) result = lexNewLine(&lex_state, &tmp);
    if (result == 0) result = lexSemicolon(&lex_state, &tmp);

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

        state->programHeader.len = 1;

 libscpi/src/parser_private.h

copy from libscpi/inc/scpi/fifo.h
copy to libscpi/src/parser_private.h
File was copied from libscpi/inc/scpi/fifo.h
@@ -26,42 +26,30 @@
 */

/**
 * @file   scpi_fifo.h
 * @date   Thu Nov 15 10:58:45 UTC 2012
 * @file   parser_private.h
 * 
 * @brief  basic FIFO implementation
 * @brief  SCPI Parser private definitions
 * 
 * 
 */

#ifndef SCPI_FIFO_H
#define    SCPI_FIFO_H
#ifndef SCPI_PARSER_PRIVATE_H
#define    SCPI_PARSER_PRIVATE_H

#include "scpi/types.h"
#include "utils_private.h"

#ifdef    __cplusplus
extern "C" {
#endif


#define FIFO_SIZE 16

    struct _fifo_t {
        int16_t wr;
        int16_t rd;
        int16_t size;
        int16_t data[FIFO_SIZE];
    };
    typedef struct _fifo_t fifo_t;

    void fifo_init(fifo_t * fifo);
    void fifo_clear(fifo_t * fifo);
    bool_t fifo_add(fifo_t * fifo, int16_t value);
    bool_t fifo_remove(fifo_t * fifo, int16_t * value);
    bool_t fifo_count(fifo_t * fifo, int16_t * value);
    int parseProgramData(lex_state_t * state, token_t * token) LOCAL;
    int parseAllProgramData(lex_state_t * state, token_t * token, int * numberOfParameters) LOCAL;
    int detectProgramMessageUnit(scpi_parser_state_t * state, const char * buffer, int len) LOCAL;

#ifdef    __cplusplus
}
#endif

#endif    /* SCPI_FIFO_H */
#endif    /* SCPI_PARSER_PRIVATE_H */


 libscpi/src/units.c

@@ -37,9 +37,9 @@
#include <string.h>
#include "scpi/parser.h"
#include "scpi/units.h"
#include "utils.h"
#include "utils_private.h"
#include "scpi/error.h"
#include "scpi/lexer.h"
#include "lexer_private.h"


/*
@@ -259,14 +259,14 @@

    switch(parameter->type) {
        case TokDecimalNumericProgramDataWithSuffix:
            SCPI_LexDecimalNumericProgramData(&state, &token);
            SCPI_LexWhiteSpace(&state, &token);
            SCPI_LexSuffixProgramData(&state, &token);
            lexDecimalNumericProgramData(&state, &token);
            lexWhiteSpace(&state, &token);
            lexSuffixProgramData(&state, &token);

            return transformNumber(context, token.ptr, token.len, &parameter->number);
        case TokProgramMnemonic:
            SCPI_LexWhiteSpace(&state, &token);
            SCPI_LexCharacterProgramData(&state, &token);
            lexWhiteSpace(&state, &token);
            lexCharacterProgramData(&state, &token);

            /* convert string to special number type */
            return translateSpecialNumber(context->special_numbers, token.ptr, token.len, &parameter->number);

 libscpi/src/utils.c

@@ -41,7 +41,7 @@
#include <string.h>
#include <ctype.h>

#include "utils.h"
#include "utils_private.h"

static size_t patternSeparatorShortPos(const char * pattern, size_t len);
static size_t patternSeparatorPos(const char * pattern, size_t len);

 libscpi/src/utils_private.h

File was renamed from libscpi/src/utils.h
@@ -60,7 +60,6 @@
    bool_t locateText(const char * str1, size_t len1, const char ** str2, size_t * len2) LOCAL;
    bool_t locateStr(const char * str1, size_t len1, const char ** str2, size_t * len2) LOCAL;
    size_t skipWhitespace(const char * cmd, size_t len) LOCAL;
    size_t skipColon(const char * cmd, size_t len) LOCAL;
    bool_t matchPattern(const char * pattern, size_t pattern_len, const char * str, size_t str_len) LOCAL;
    bool_t matchCommand(const char * pattern, const char * cmd, size_t len) LOCAL;


 libscpi/test/test_fifo.c

@@ -9,7 +9,7 @@
#include <stdlib.h>
#include "CUnit/Basic.h"

#include "scpi/fifo.h"
#include "../src/fifo_private.h"

/*
 * CUnit Test Suite

 libscpi/test/test_lexer_parser.c

@@ -9,8 +9,9 @@
#include <stdlib.h>
#include "CUnit/Basic.h"

#include "scpi/lexer.h"
#include "../src/lexer_private.h"
#include "scpi/parser.h"
#include "../src/parser_private.h"

/*
 * CUnit Test Suite
@@ -102,110 +103,110 @@


void testWhiteSpace(void) {
    TEST_TOKEN("  \t MEAS", SCPI_LexWhiteSpace, 0, 4, TokWhiteSpace);
    TEST_TOKEN("MEAS", SCPI_LexWhiteSpace, 0, 0, TokUnknown);
    TEST_TOKEN("  \t MEAS", lexWhiteSpace, 0, 4, TokWhiteSpace);
    TEST_TOKEN("MEAS", lexWhiteSpace, 0, 0, TokUnknown);
}

void testNondecimal(void) {
    TEST_TOKEN("#H123fe5A", SCPI_LexNondecimalNumericData, 2, 7, TokHexnum);
    TEST_TOKEN("#B0111010101", SCPI_LexNondecimalNumericData, 2, 10, TokBinnum);
    TEST_TOKEN("#Q125725433", SCPI_LexNondecimalNumericData, 2, 9, TokOctnum);
    TEST_TOKEN("#H123fe5A", lexNondecimalNumericData, 2, 7, TokHexnum);
    TEST_TOKEN("#B0111010101", lexNondecimalNumericData, 2, 10, TokBinnum);
    TEST_TOKEN("#Q125725433", lexNondecimalNumericData, 2, 9, TokOctnum);
}

void testCharacterProgramData(void) {
    TEST_TOKEN("abc_213as564", SCPI_LexCharacterProgramData, 0, 12, TokProgramMnemonic);
    TEST_TOKEN("abc_213as564 , ", SCPI_LexCharacterProgramData, 0, 12, TokProgramMnemonic);
    TEST_TOKEN("abc_213as564", lexCharacterProgramData, 0, 12, TokProgramMnemonic);
    TEST_TOKEN("abc_213as564 , ", lexCharacterProgramData, 0, 12, TokProgramMnemonic);
}

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

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

void testProgramHeader(void) {
    TEST_TOKEN("*IDN? ", SCPI_LexProgramHeader, 0, 5, TokCommonQueryProgramHeader);
    TEST_TOKEN("*RST ", SCPI_LexProgramHeader, 0, 4, TokCommonProgramHeader);
    TEST_TOKEN("*?; ", SCPI_LexProgramHeader, 0, 1, TokIncompleteCommonProgramHeader);
    TEST_TOKEN(":*IDN?; ", SCPI_LexProgramHeader, 0, 1, TokIncompleteCompoundProgramHeader);
    TEST_TOKEN("MEAS:VOLT:DC? ", SCPI_LexProgramHeader, 0, 13, TokCompoundQueryProgramHeader);
    TEST_TOKEN("CONF:VOLT:DC ", SCPI_LexProgramHeader, 0, 12, TokCompoundProgramHeader);
    TEST_TOKEN(":MEAS:VOLT:DC? ", SCPI_LexProgramHeader, 0, 14, TokCompoundQueryProgramHeader);
    TEST_TOKEN(":MEAS::VOLT:DC? ", SCPI_LexProgramHeader, 0, 6, TokIncompleteCompoundProgramHeader);
    TEST_TOKEN("*IDN?", SCPI_LexProgramHeader, 0, 5, TokCommonQueryProgramHeader);
    TEST_TOKEN("*RST", SCPI_LexProgramHeader, 0, 4, TokCommonProgramHeader);   
    TEST_TOKEN("CONF:VOLT:DC", SCPI_LexProgramHeader, 0, 12, TokCompoundProgramHeader);
    TEST_TOKEN("]]", SCPI_LexProgramHeader, 0, 0, TokUnknown);
    TEST_TOKEN("*IDN? ", lexProgramHeader, 0, 5, TokCommonQueryProgramHeader);
    TEST_TOKEN("*RST ", lexProgramHeader, 0, 4, TokCommonProgramHeader);
    TEST_TOKEN("*?; ", lexProgramHeader, 0, 1, TokIncompleteCommonProgramHeader);
    TEST_TOKEN(":*IDN?; ", lexProgramHeader, 0, 1, TokIncompleteCompoundProgramHeader);
    TEST_TOKEN("MEAS:VOLT:DC? ", lexProgramHeader, 0, 13, TokCompoundQueryProgramHeader);
    TEST_TOKEN("CONF:VOLT:DC ", lexProgramHeader, 0, 12, TokCompoundProgramHeader);
    TEST_TOKEN(":MEAS:VOLT:DC? ", lexProgramHeader, 0, 14, TokCompoundQueryProgramHeader);
    TEST_TOKEN(":MEAS::VOLT:DC? ", lexProgramHeader, 0, 6, TokIncompleteCompoundProgramHeader);
    TEST_TOKEN("*IDN?", lexProgramHeader, 0, 5, TokCommonQueryProgramHeader);
    TEST_TOKEN("*RST", lexProgramHeader, 0, 4, TokCommonProgramHeader);   
    TEST_TOKEN("CONF:VOLT:DC", lexProgramHeader, 0, 12, TokCompoundProgramHeader);
    TEST_TOKEN("]]", lexProgramHeader, 0, 0, TokUnknown);
}

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

void testExpression(void) {
    TEST_TOKEN("( 1 + 2 )", SCPI_LexProgramExpression, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2 ) , ", SCPI_LexProgramExpression, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2  , ", SCPI_LexProgramExpression, 0, 0, TokUnknown);
    TEST_TOKEN("( 1 + 2 )", lexProgramExpression, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2 ) , ", lexProgramExpression, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2  , ", lexProgramExpression, 0, 0, TokUnknown);
}

void testString(void) {
    TEST_TOKEN("\"ahoj\"", SCPI_LexStringProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("\"ahoj\" ", SCPI_LexStringProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("'ahoj' ", SCPI_LexStringProgramData, 1, 4, TokSingleQuoteProgramData);
    TEST_TOKEN("'ahoj ", SCPI_LexStringProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("'ah''oj' ", SCPI_LexStringProgramData, 1, 6, TokSingleQuoteProgramData);
    TEST_TOKEN("'ah\"oj' ", SCPI_LexStringProgramData, 1, 5, TokSingleQuoteProgramData);
    TEST_TOKEN("\"ah\"\"oj\" ", SCPI_LexStringProgramData, 1, 6, TokDoubleQuoteProgramData);
    TEST_TOKEN("\"ahoj\"", lexStringProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("\"ahoj\" ", lexStringProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("'ahoj' ", lexStringProgramData, 1, 4, TokSingleQuoteProgramData);
    TEST_TOKEN("'ahoj ", lexStringProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("'ah''oj' ", lexStringProgramData, 1, 6, TokSingleQuoteProgramData);
    TEST_TOKEN("'ah\"oj' ", lexStringProgramData, 1, 5, TokSingleQuoteProgramData);
    TEST_TOKEN("\"ah\"\"oj\" ", lexStringProgramData, 1, 6, TokDoubleQuoteProgramData);
}

void testProgramData(void) {
    TEST_TOKEN("#H123fe5A", SCPI_ParseProgramData, 2, 7, TokHexnum);
    TEST_TOKEN("  #H123fe5A ", SCPI_ParseProgramData, 4, 7, TokHexnum);
    TEST_TOKEN("#B0111010101", SCPI_ParseProgramData, 2, 10, TokBinnum);
    TEST_TOKEN("#Q125725433", SCPI_ParseProgramData, 2, 9, TokOctnum);
    TEST_TOKEN("#H123fe5A", parseProgramData, 2, 7, TokHexnum);
    TEST_TOKEN("  #H123fe5A ", parseProgramData, 4, 7, TokHexnum);
    TEST_TOKEN("#B0111010101", parseProgramData, 2, 10, TokBinnum);
    TEST_TOKEN("#Q125725433", parseProgramData, 2, 9, TokOctnum);

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

    TEST_TOKEN("#12AB", SCPI_ParseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#12AB, ", SCPI_ParseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#13AB", SCPI_ParseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("#12\r\n, ", SCPI_ParseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#02AB, ", SCPI_ParseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("#12AB", parseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#12AB, ", parseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#13AB", parseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("#12\r\n, ", parseProgramData, 3, 2, TokArbitraryBlockProgramData);
    TEST_TOKEN("#02AB, ", parseProgramData, 0, 0, TokUnknown);

    TEST_TOKEN("( 1 + 2 ) , ", SCPI_ParseProgramData, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2  , ", SCPI_ParseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("( 1 + 2 ) , ", parseProgramData, 0, 9, TokProgramExpression);
    TEST_TOKEN("( 1 + 2  , ", parseProgramData, 0, 0, TokUnknown);

    TEST_TOKEN("\"ahoj\" ", SCPI_ParseProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("'ahoj' ", SCPI_ParseProgramData, 1, 4, TokSingleQuoteProgramData);
    TEST_TOKEN("'ahoj ", SCPI_ParseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("'ah''oj' ", SCPI_ParseProgramData, 1, 6, TokSingleQuoteProgramData);
    TEST_TOKEN("'ah\"oj' ", SCPI_ParseProgramData, 1, 5, TokSingleQuoteProgramData);
    TEST_TOKEN("\"ah\"\"oj\" ", SCPI_ParseProgramData, 1, 6, TokDoubleQuoteProgramData);
    TEST_TOKEN("\"ahoj\" ", parseProgramData, 1, 4, TokDoubleQuoteProgramData);
    TEST_TOKEN("'ahoj' ", parseProgramData, 1, 4, TokSingleQuoteProgramData);
    TEST_TOKEN("'ahoj ", parseProgramData, 0, 0, TokUnknown);
    TEST_TOKEN("'ah''oj' ", parseProgramData, 1, 6, TokSingleQuoteProgramData);
    TEST_TOKEN("'ah\"oj' ", parseProgramData, 1, 5, TokSingleQuoteProgramData);
    TEST_TOKEN("\"ah\"\"oj\" ", parseProgramData, 1, 6, TokDoubleQuoteProgramData);
    
    TEST_TOKEN("abc_213as564 , ", SCPI_LexCharacterProgramData, 0, 12, TokProgramMnemonic);
    TEST_TOKEN("abc_213as564 , ", lexCharacterProgramData, 0, 12, TokProgramMnemonic);
    
    TEST_TOKEN("1.5E12 V", SCPI_ParseProgramData, 0, 8, TokDecimalNumericProgramDataWithSuffix);
    TEST_TOKEN("1.5E12 V", parseProgramData, 0, 8, TokDecimalNumericProgramDataWithSuffix);
}


@@ -233,12 +234,12 @@


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


@@ -246,7 +247,7 @@
    const char * str = s;                                                       \
    scpi_parser_state_t state;                                                  \
    int result;                                                                 \
    result = SCPI_DetectProgramMessageUnit(&state, str, strlen(str));           \
    result = detectProgramMessageUnit(&state, str, strlen(str));           \
    CU_ASSERT_EQUAL(state.programHeader.ptr, str + h);                          \
    CU_ASSERT_EQUAL(state.programHeader.len, hl);                               \
    CU_ASSERT_EQUAL(state.programHeader.type, ht);                              \
@@ -266,10 +267,10 @@
}

void testBoolParameter(void) {
    TEST_TOKEN(" 1", SCPI_ParseProgramData, 1, 1, TokDecimalNumericProgramData);
    TEST_TOKEN(" 0", SCPI_ParseProgramData, 1, 1, TokDecimalNumericProgramData);
    TEST_TOKEN(" ON", SCPI_ParseProgramData, 1, 2, TokProgramMnemonic);
    TEST_TOKEN("OFF ", SCPI_ParseProgramData, 0, 3, TokProgramMnemonic);
    TEST_TOKEN(" 1", parseProgramData, 1, 1, TokDecimalNumericProgramData);
    TEST_TOKEN(" 0", parseProgramData, 1, 1, TokDecimalNumericProgramData);
    TEST_TOKEN(" ON", parseProgramData, 1, 2, TokProgramMnemonic);
    TEST_TOKEN("OFF ", parseProgramData, 0, 3, TokProgramMnemonic);
    
    // TODO: finish bool test
}

 libscpi/test/test_scpi_utils.c

@@ -39,7 +39,7 @@
#include "CUnit/Basic.h"

#include "scpi/scpi.h"
#include "../src/utils.h"
#include "../src/utils_private.h"

/*
 * CUnit Test Suite