source: branches/2.0/drmaa2_utils/drmaa_utils/conf.c @ 77

/* $Id: conf.c 13 2011-04-20 15:41:43Z mmamonski $ */
/*
 *  PSNC DRMAA 2.0 utilities library
 *  Copyright (C) 2012  Poznan Supercomputing and Networking Center
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

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

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

#include <drmaa_utils/common.h>
#include <drmaa_utils/conf_impl.h>
#include <drmaa_utils/conf_tab.h>
#include <drmaa_utils/logging.h>
#include <drmaa_utils/util.h>

#ifndef lint
static char rcsid[]
#       ifdef __GNUC__
                __attribute__ ((unused))
#       endif
        = "$Id: conf.c 13 2011-04-20 15:41:43Z mmamonski $";
#endif


fsd_conf_dict_t *
fsd_conf_read(
                fsd_conf_dict_t  * volatile configuration,
                const char *filename, bool must_exist,
                const char *content, size_t content_len
                )
{
        fsd_conf_dict_t *volatile result = NULL;
        fsd_conf_parser_t *parser = NULL;
        fsd_conf_lexer_t *lexer = NULL;
        char *file_content = NULL;
        size_t file_content_len = 0;

        fsd_log_enter((
                "(filename=%s, must_exist=%s, content=%s)",
                filename, must_exist ? "true" : "false", content
                ));

        TRY
         {
                fsd_malloc( parser, fsd_conf_parser_t );
                fsd_malloc( lexer, fsd_conf_lexer_t );

                parser->lexer = lexer;
                parser->result = NULL;
                parser->n_errors = 0;
                parser->errors = NULL;

                lexer->parser = parser;
                lexer->filename = filename;
                lexer->buffer = NULL;
                lexer->buflen = 0;
                lexer->pos = NULL;
                lexer->lineno = 0;
                lexer->cline = NULL;

                if( filename )
                        TRY
                         {
                                fsd_read_file(
                                                filename, must_exist,
                                                &file_content, &file_content_len
                                                );
                         }
                        EXCEPT_DEFAULT
                         {
                                const fsd_exc_t *e = fsd_exc_get();
                                if( must_exist )
                                        fsd_exc_raise_fmt( e->code(e), "%s: %s", filename, e->message(e) );
                                else
                                 {
                                        fsd_log_warning(( "%s: %s", filename, e->message(e) ));
                                 }
                         }
                        END_TRY

                if( file_content )
                 {
                        lexer->buffer = (const uchar*)file_content;
                        lexer->buflen = file_content_len;
                        fsd_log_trace(( "content from file" ));
                 }
                else if( content )
                 {
                        lexer->buffer = (const uchar*)content;
                        lexer->buflen = content_len;
                        fsd_log_trace(( "content from memory" ));
                 }

                if( lexer->buffer )
                 {
                        lexer->pos = lexer->cline = lexer->buffer;
                        lexer->lineno = 1;

                        fsd_conf_parse( parser, lexer );
                        result = parser->result;
                 }

                if( parser->n_errors > 0 )
                 {
                        fsd_exc_raise(
                                        fsd_exc_new(
                                                        FSD_ERRNO_INTERNAL_ERROR,
                                                        fsd_explode( (const char*const*)parser->errors, '\n',
                                                                parser->n_errors ),
                                                        true
                                                        )
                                        );
                 }
         }
        ELSE
         {
                configuration = fsd_conf_dict_merge( configuration, result );
                result = NULL;
         }
        FINALLY
         {
                if( parser )
                 {
                        if( parser->errors )
                         {
                                int i;
                                for( i=0;  i < parser->n_errors;  i++ )
                                        fsd_free( parser->errors[i] );
                                fsd_free( parser->errors );
                         }
                        fsd_free( parser );
                 }
                fsd_free( lexer );
                fsd_free( file_content );
                fsd_conf_dict_destroy( result );
         }
        END_TRY

        fsd_log_return(( "" ));
        return configuration;
}



int
fsd_conf_lex(
                union YYSTYPE *lvalp, struct YYLTYPE *locp,
                fsd_conf_lexer_t *lexer
                )
{
        const uchar *c = lexer->pos;
        const uchar *end = lexer->buffer + lexer->buflen;
        const char *error = NULL;
        int result;

        while( c<end )
                switch( *c )
                 {
                        case '#':  /* a comment */
                                while( c<end && *c != '\n' )
                                        c++;
                        case '\n':  /* no break */
                                lexer->lineno++;
                                lexer->cline = c+1;
                        case ' ':  case '\t':  case '\r':  /* no break */
                                c++;
                                break;
                        default:
                                goto token_begin;
                 }

token_begin:
        locp->first_line = lexer->lineno;
        locp->first_column = c - lexer->cline + 1;

        if( c == end )
                result = 0;
        else
                switch( *c )
                 {
                        case ':':  case ',':  case '{':  case '}':
                                result = *c++;
                                break;

                        case '0':  case '1':  case '2':  case '3':  case '4':
                        case '5':  case '6':  case '7':  case '8':  case '9':
                         {
                                int v = 0;
                                while( c < end  &&  '0' <= *c  &&  *c <= '9' )
                                 {
                                        v *= 10;
                                        v += *c - '0';
                                        c++;
                                 }
                                lvalp->integer = v;
                                result = INTEGER;
                                break;
                         }

                        case '"':  case '\'':
                         {
                                uchar delimiter;
                                const uchar *begin;
                                delimiter = *c++;
                                begin = c;
                                
                                while( c < end  &&  *c != delimiter )
                                        c++;
                                if( c == end )
                                 {
                                        error = "expected string delimiter but EOF found";
                                        result = LEXER_ERROR;
                                 }
                                else
                                 {
                                        lvalp->string = fsd_strndup( (const char*)begin, c-begin );
                                        result = STRING;
                                        c++;
                                 }
                                break;
                         }

                        default:
                         {
                                const uchar *begin = c;
                                while( c<end  &&  !isspace(*c) )
                                        switch( *c )
                                         {
                                                case ':':  case ',':  case '{':  case '}':
                                                        goto end_of_string;
                                                default:
                                                        c++;
                                                        break;
                                         }
                        end_of_string:
                                lvalp->string = fsd_strndup( (const char*)begin, c-begin );
                                result = STRING;
                                break;
                         }
                 }

        locp->last_line = lexer->lineno;
        locp->last_column = c - lexer->cline;
        if( locp->last_column < locp->first_column )
                locp->last_column = locp->first_column;
        lexer->pos = c;

        if( error )
                fsd_conf_error( locp, lexer->parser, lexer, error );

        return result;
}



void
fsd_conf_error(
                struct YYLTYPE *locp,
                fsd_conf_parser_t *parser, fsd_conf_lexer_t *lexer,
                const char *fmt, ...
                )
{
        char *volatile message = NULL;
        va_list args;

        TRY
         {
                va_start( args, fmt );
                message = fsd_vasprintf( fmt, args );
                va_end( args );

                fsd_realloc( parser->errors, parser->n_errors+1, char* );
                parser->errors[ parser->n_errors ] = fsd_asprintf(
                                "%s:%d:%d: %s",
                                parser->lexer->filename, locp->first_line, locp->first_column,
                                message );
                fsd_log_error(("Parser error: %s:%d:%d: %s", parser->lexer->filename, locp->first_line, locp->first_column, message ));
                parser->n_errors ++;
         }
        FINALLY
         { fsd_free( message ); }
        END_TRY
}



fsd_conf_option_t *
fsd_conf_option_create( fsd_conf_type_t type, void *value )
{
        fsd_conf_option_t *o = NULL;

        fsd_malloc( o, fsd_conf_option_t );
        o->type = type;
        switch( type )
         {
                case FSD_CONF_INTEGER:
                        o->val.integer = *(int*)value;
                        break;
                case FSD_CONF_STRING:
                        o->val.string = (char*)value;
                        break;
                case FSD_CONF_DICT:
                        o->val.dict = (fsd_conf_dict_t*)value;
                        break;
                default:
                        fsd_assert(false);
                        break;
         }
        return o;
}


void
fsd_conf_option_destroy( fsd_conf_option_t *option )
{
        if( option == NULL )
                return;
        switch( option->type )
         {
                case FSD_CONF_INTEGER:
                        break;
                case FSD_CONF_STRING:
                        fsd_free( option->val.string );
                        break;
                case FSD_CONF_DICT:
                        fsd_conf_dict_destroy( option->val.dict );
                        break;
                default:
                        fsd_assert( false );
         }
        fsd_free( option );
}


fsd_conf_option_t *
fsd_conf_option_merge( fsd_conf_option_t *lhs, fsd_conf_option_t *rhs )
{
        if( lhs->type == rhs->type  &&  rhs->type == FSD_CONF_DICT )
         {
                lhs->val.dict = fsd_conf_dict_merge( lhs->val.dict, rhs->val.dict );
                fsd_free( rhs );
                return lhs;
         }
        else
         {
                fsd_conf_option_destroy( lhs );
                return rhs;
         }
}


void
fsd_conf_option_dump( fsd_conf_option_t *option )
{
        if( option == NULL )
         {
                printf( "(null)" );
                return;
         }
        switch( option->type )
         {
                case FSD_CONF_STRING:
                        printf( "\"%s\"", option->val.string );
                        break;
                case FSD_CONF_INTEGER:
                        printf( "%d", option->val.integer );
                        break;
                case FSD_CONF_DICT:
                        fsd_conf_dict_dump( option->val.dict );
                        break;
         }
}



struct fsd_conf_dict_s {
        fsd_conf_dict_t *next;
        char *key;
        fsd_conf_option_t *value;
};


fsd_conf_dict_t *
fsd_conf_dict_create(void)
{
        fsd_conf_dict_t *dict = NULL;
        fsd_malloc( dict, fsd_conf_dict_t );
        dict->next = NULL;
        dict->key = NULL;
        dict->value = NULL;
        return dict;
}


void
fsd_conf_dict_destroy( fsd_conf_dict_t *dict )
{
        fsd_conf_dict_t *i;
        for( i = dict;  i != NULL;  )
         {
                fsd_conf_dict_t *c = i;
                i = i->next;
                fsd_free( c->key );
                fsd_conf_option_destroy( c->value );
                fsd_free( c );
         }
}


fsd_conf_option_t *
fsd_conf_dict_get(
                fsd_conf_dict_t *dict, const char *key )
{
        fsd_conf_dict_t *i;
        if( dict == NULL  ||  key == NULL )
                return NULL;
        for( i = dict->next;  i != NULL;  i = i->next )
         {
                if( !strcmp( i->key, key ) )
                        return i->value;
         }
        return NULL;
}


void
fsd_conf_dict_set(
                fsd_conf_dict_t *dict, const char *key, fsd_conf_option_t *value
                )
{
        fsd_conf_dict_t *i;
        for( i = dict->next;  i != NULL;  i = i->next )
         {
                if( !strcmp( i->key, key ) )
                        break;
         }

        if( i != NULL )
         {
                fsd_conf_option_destroy( i->value );
                i->value = value;
         }
        else
         {
                fsd_conf_dict_t* volatile n = NULL;
                TRY
                 {
                        fsd_malloc( n, fsd_conf_dict_t );
                        n->key = fsd_strdup( key );
                        n->value = value;
                 }
                EXCEPT_DEFAULT
                 {
                        fsd_free( n );
                        fsd_exc_reraise();
                 }
                ELSE
                 {
                        n->next = dict->next;
                        dict->next = n;
                 }
                END_TRY
         }
}


fsd_conf_dict_t *
fsd_conf_dict_merge( fsd_conf_dict_t *lhs, fsd_conf_dict_t *rhs )
{
        fsd_conf_dict_t *i, *j;

        if( lhs == NULL )
                return rhs;

        if( rhs == NULL )
                return lhs;

        for( j = rhs->next;  j != NULL;  )
         {
                fsd_conf_dict_t *r = j;
                j = j->next;

                for( i = lhs->next;  i != NULL;  i = i->next )
                        if( !strcmp( i->key, r->key ) )
                                break;

                if( i != NULL )
                 {
                        i->value = fsd_conf_option_merge( i->value, r->value );
                        fsd_free( r->key );
                        fsd_free( r );
                 }
                else
                 {
                        r->next = lhs->next;
                        lhs->next = r;
                 }
         }

        fsd_free( rhs );
        return lhs;
}


void
fsd_conf_dict_dump( fsd_conf_dict_t *dict )
{
        fsd_conf_dict_t *i;

        if( dict == NULL )
         {
                printf( "(null)" );
                return;
         }
        printf( "{" );
        for( i=dict->next;  i;  i = i->next )
         {
                if( i != dict->next )
                        printf( "," );
                printf( " %s=", i->key );
                fsd_conf_option_dump( i->value );
         }
        printf( " }" );
}


fsd_conf_option_t *
fsd_conf_option_create_noraise( fsd_conf_type_t type, void *value )
{
        fsd_conf_option_t *volatile result = NULL;
        TRY{ result = fsd_conf_option_create( type, value ); }
        EXCEPT_DEFAULT{}
        END_TRY
        return result;
}

fsd_conf_dict_t *
fsd_conf_dict_create_noraise(void)
{
        fsd_conf_dict_t *volatile result = NULL;
        TRY{ result = fsd_conf_dict_create(); }
        EXCEPT_DEFAULT{}
        END_TRY
        return result;
}

int
fsd_conf_dict_set_noraise(
                fsd_conf_dict_t *dict, const char *key, fsd_conf_option_t *value )
{
        volatile int rc = FSD_ERRNO_SUCCESS;
        TRY{ fsd_conf_dict_set( dict, key, value ); }
        EXCEPT_DEFAULT
         {
                const fsd_exc_t *e = fsd_exc_get();
                rc = e->code(e);
         }
        END_TRY
        return rc;
}