parse.c

Go to the documentation of this file.

/*
 * luau (Lib Update/Auto-Update): Simple Update Library
 * Copyright (C) 2003  David Eklund
 *
 * - This library is free software; you can redistribute it and/or             -
 * - modify it under the terms of the GNU Lesser General Public                -
 * - License as published by the Free Software Foundation; either              -
 * - version 2.1 of the License, or (at your option) any later version.        -
 * -                                                                           -
 * - This library is distributed in the hope that it will be useful,           -
 * - but WITHOUT ANY WARRANTY; without even the implied warranty of            -
 * - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         -
 * - Lesser General Public License for more details.                           -
 * -                                                                           -
 * - You should have received a copy of the GNU Lesser General Public          -
 * - License along with this library; if not, write to the Free Software       -
 * - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA -
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <string.h>
#include <glib.h>
#include <ctype.h>

#include "parse.h"
#include "util.h"
#include "error.h"

#ifdef WITH_DMALLOC
#  include <dmalloc.h>
#endif

LUAU_parsedLine *
lutil_parse_parseLine(char *input) {
        LUAU_parsedLine *parsed = (LUAU_parsedLine*) malloc(sizeof(LUAU_parsedLine));
        char *arg, *ptr;
        
        parsed->args = g_ptr_array_new();
        
        parsed->keyword = lutil_parse_nextToken_r(input, &ptr);
        while ((arg = lutil_parse_nextToken_r(NULL, &ptr)) != NULL)
                g_ptr_array_add(parsed->args, arg);
        
        return parsed;
}

char
lutil_parse_parseSymbol(const char *input, const GPtrArray *symbols) {
        char *curr;
        char result = -1;
        int i;
        
        for (i = 0; i < symbols->len; i += 2) {
                curr = g_ptr_array_index(symbols, i);
                if (lutil_streq(input, curr)) {
                        result = GPOINTER_TO_INT (g_ptr_array_index(symbols, i+1));
                        break;
                }
        }
        
        return result;
}

char
lutil_parse_parseSymbolArray(const char *input, const char *symbols[]) {
        const char *curr;
        char result = -1;
        int i;
        
        for (i = 0; symbols[i] != NULL; i += 2) {
                curr = symbols[i];
                if (lutil_streq(input, curr)) {
                        result = (symbols[i+1])[0];
                        break;
                }
        }
        
        return result;
}

void
lutil_parse_freeParsedLine(LUAU_parsedLine *line) {
        int i;
        
        if (line != NULL) {
                g_free(line->keyword);
                
                for (i = 0; i < line->args->len; ++i)
                        g_free(g_ptr_array_index(line->args, i));
                
                g_ptr_array_free(line->args, TRUE);
                
                g_free(line);
        }
}

char *
lutil_parse_nextToken(char *input) {
        static char *currentString = NULL;
        
        return lutil_parse_nextToken_r(input, &currentString);
}

char *
lutil_parse_nextToken_r(char *input, char **ptrptr) {
        char quoted = 0, *temp;
        GString *result = g_string_new("");
        gboolean escaped = FALSE, append;
        
        if (input != NULL)
                *ptrptr = input;
        if (*ptrptr == NULL) {
                ERROR("No input specified!");
                return NULL;
        }
        
        /* skip leading whitespace */
        while (**ptrptr == ' ') 
                ++*ptrptr;
        
        while (**ptrptr != '\0') {
                if (escaped) {
                        /* if given an escaped sequence of anything other than '\\' or '\"' inside a doubly quoted string or
                         * a '\'' inside a singly quoted string, we pass the back-slash through. */
                        if (**ptrptr != '\\' && **ptrptr != quoted)
                                g_string_append_c(result, '\\');
                        
                        append = TRUE;
                        escaped = FALSE;
                } else if (quoted) {
                        if (**ptrptr == quoted) {
                                append = FALSE;
                                quoted = 0;
                        } else {
                                append = TRUE;
                        }
                } else {
                        if (**ptrptr == ' ') {
                                ++*ptrptr;
                                break;
                        } else if (**ptrptr == '\\') {
                                escaped = TRUE;
                                append = FALSE;
                        } else if (**ptrptr == '"' || **ptrptr == '\'') {
                                quoted = **ptrptr;
                                append = FALSE;
                        } else {
                                append = TRUE;
                        }
                }
                if (append)
                        g_string_append_c(result, **ptrptr);
                
                ++*ptrptr;
        }
        
        if (quoted) 
                ERROR("Quote not closed - multi-line quotes not supported");
        if (escaped)
                ERROR("Back-slash at end of line - not supported");
        
        temp = result->str;
        g_string_free(result, FALSE);
        
        if (*temp == '\0') { /* empty string */
                g_free(temp);
                return NULL;
        } else {
                return temp;
        }
}

char *
lutil_parse_deleteWhitespace(char* string) {
        int i;
        
        if (string == NULL)
                return NULL;
        
        while (isspace(*string)) ++string;
        for (i = strlen(string)-1; i >= 0 && isspace(string[i]); --i) 
                string[i] = '\0';
        
        return string;
}

char *
lutil_parse_skipString(char* input, char* string) {
        return (input + strlen(string));
}

---