Refactor token_t and token_type_t to have scpi_ prefix

Jan Breuer

2014-09-24 be3350c620036306fb5f2db3535cb110f187d5e8

Refactor token_t and token_type_t to have scpi_ prefix

 libscpi/inc/scpi/types.h

@@ -123,7 +123,7 @@
    typedef int (*scpi_error_callback_t)(scpi_t * context, int_fast16_t error);

    /* scpi lexer */
    enum _token_type_t {
    enum _scpi_token_type_t {
        TokComma,
        TokSemicolon,
        TokQuiestion,
@@ -150,14 +150,14 @@
        TokInvalid,
        TokUnknown,
    };
    typedef enum _token_type_t token_type_t;
    typedef enum _scpi_token_type_t scpi_token_type_t;

    struct _token_t {
        token_type_t type;
    struct _scpi_token_t {
        scpi_token_type_t type;
        const char * ptr;
        int len;
    };
    typedef struct _token_t token_t;
    typedef struct _scpi_token_t scpi_token_t;

    struct _lex_state_t {
        const char * buffer;
@@ -175,8 +175,8 @@
    typedef enum _message_termination_t message_termination_t;
    
    struct _scpi_parser_state_t {
        token_t programHeader;
        token_t programData;
        scpi_token_t programHeader;
        scpi_token_t programData;
        int numberOfParameters;
        message_termination_t termination;
    };
@@ -250,7 +250,7 @@
    typedef struct _scpi_data_parameter_t scpi_data_parameter_t;
    
    struct _scpi_parameter_t {
        token_type_t type;
        scpi_token_type_t type;
        scpi_data_parameter_t data;
        scpi_number_parameter_t number;
    };

 libscpi/src/lexer.c

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

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

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

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

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

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

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

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

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

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

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

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

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

int lexArbitraryBlockProgramData(lex_state_t * state, token_t * token) {
int lexArbitraryBlockProgramData(lex_state_t * state, scpi_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 lexProgramExpression(lex_state_t * state, token_t * token) {
int lexProgramExpression(lex_state_t * state, scpi_token_t * token) {
    token->ptr = state->pos;

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

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

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

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

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

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

    skipChr(state, '\r');

 libscpi/src/lexer_private.h

@@ -45,18 +45,18 @@
#endif

    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;
    int lexWhiteSpace(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexProgramHeader(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexCharacterProgramData(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexDecimalNumericProgramData(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexSuffixProgramData(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexNondecimalNumericData(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexStringProgramData(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexArbitraryBlockProgramData(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexProgramExpression(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexComma(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexSemicolon(lex_state_t * state, scpi_token_t * token) LOCAL;
    int lexNewLine(lex_state_t * state, scpi_token_t * token) LOCAL;

#ifdef    __cplusplus
}

 libscpi/src/parser.c

@@ -373,7 +373,7 @@
/* parsing parameters */

scpi_bool_t SCPI_Parameter(scpi_t * context, scpi_parameter_t * parameter, scpi_bool_t mandatory) {
    token_t token;
    scpi_token_t token;
    lex_state_t * state;
    int32_t value;

@@ -524,8 +524,8 @@
    }
}

int parseProgramData(lex_state_t * state, token_t * token) {
    token_t tmp;
int parseProgramData(lex_state_t * state, scpi_token_t * token) {
    scpi_token_t tmp;
    int result = 0;
    int wsLen;
    int suffixLen;
@@ -556,10 +556,10 @@
    return result + realLen;
}

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

    int result;
    token_t tmp;
    scpi_token_t tmp;
    int paramCount = 0;

    token->len = -1;
@@ -599,7 +599,7 @@
    return token->len;
}

static void invalidateToken(token_t * token, const char * ptr) {
static void invalidateToken(scpi_token_t * token, const char * ptr) {
    token->len = 0;
    token->ptr = ptr;
    token->type = TokUnknown;
@@ -607,7 +607,7 @@

int detectProgramMessageUnit(scpi_parser_state_t * state, const char * buffer, int len) {
    lex_state_t lex_state;
    token_t tmp;
    scpi_token_t tmp;
    int result = 0;

    lex_state.buffer = lex_state.pos = buffer;

 libscpi/src/parser_private.h

@@ -43,8 +43,8 @@
extern "C" {
#endif

    int parseProgramData(lex_state_t * state, token_t * token) LOCAL;
    int parseAllProgramData(lex_state_t * state, token_t * token, int * numberOfParameters) LOCAL;
    int parseProgramData(lex_state_t * state, scpi_token_t * token) LOCAL;
    int parseAllProgramData(lex_state_t * state, scpi_token_t * token, int * numberOfParameters) LOCAL;
    int detectProgramMessageUnit(scpi_parser_state_t * state, const char * buffer, int len) LOCAL;

#ifdef    __cplusplus

 libscpi/src/units.c

@@ -250,7 +250,7 @@
 * @return 
 */
scpi_bool_t SCPI_ParamTranslateNumberVal(scpi_t * context, scpi_parameter_t * parameter) {
    token_t token;
    scpi_token_t token;
    lex_state_t state;

    state.buffer = parameter->data.ptr;

 libscpi/test/test_lexer_parser.c

@@ -25,10 +25,10 @@
    return 0;
}

typedef int (*lexfn_t)(lex_state_t * state, token_t * token);
typedef int (*lexfn2_t)(lex_state_t * state, token_t * token, int * cnt);
typedef int (*lexfn_t)(lex_state_t * state, scpi_token_t * token);
typedef int (*lexfn2_t)(lex_state_t * state, scpi_token_t * token, int * cnt);

const char * typeToStr(token_type_t type) {
const char * typeToStr(scpi_token_type_t type) {
    switch (type) {
        case TokComma: return "TokComma";
        case TokSemicolon: return "TokSemicolon";
@@ -58,7 +58,7 @@
    }
}

void printToken(token_t * token) {
void printToken(scpi_token_t * token) {
    printf("Token:\r\n");
    printf("\t->type = %s\r\n", typeToStr(token->type));
    printf("\t->ptr = %p (\"%.*s\")\r\n", token->ptr, token->len, token->ptr);
@@ -68,9 +68,9 @@

#if 0

static void TEST_TOKEN(const char * str, lexfn_t fn, int offset, int len, token_type_t tp) {
static void TEST_TOKEN(const char * str, lexfn_t fn, int offset, int len, scpi_token_type_t tp) {
    lex_state_t state;
    token_t token;
    scpi_token_t token;

    state.buffer = state.pos = str;
    state.len = strlen(str);
@@ -86,9 +86,9 @@
    lexfn_t fn = f;                             \
    int offset = o;                             \
    int len = l;                                \
    token_type_t tp = t;                        \
    scpi_token_type_t tp = t;                        \
    lex_state_t state;                          \
    token_t token;                              \
    scpi_token_t token;                              \
                                                \
    state.buffer = state.pos = str;             \
    state.len = strlen(str);                    \
@@ -215,9 +215,9 @@
    lexfn2_t fn = f;                            \
    int offset = o;                             \
    int len = l;                                \
    token_type_t tp = t;                        \
    scpi_token_type_t tp = t;                        \
    lex_state_t state;                          \
    token_t token;                              \
    scpi_token_t token;                              \
    int count;                                  \
                                                \
    state.buffer = state.pos = str;             \