directives_tally.c

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007-2011 Mike Kinghan, imk@strudl.org                  *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@strudl.org                *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   Redistributions of source code must retain the above copyright        *
 *   notice, this list of conditions and the following disclaimer.         *
 *                                                                         *
 *   Redistributions in binary form must reproduce the above copyright     *
 *   notice, this list of conditions and the following disclaimer in the   *
 *   documentation and/or other materials provided with the distribution.  *
 *                                                                         *
 *   Neither the name of Symbian Software Ltd. nor the names of its        *
 *   contributors may be used to endorse or promote products derived from  *
 *   this software without specific prior written permission.              *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS    *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,   *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
 *   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    *
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,*
 *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF *
 *   THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH  *
 *   DAMAGE.                                                               *
 *                                                                         *
 **************************************************************************/
#include "state_utils.h"
#include "ptr_set.h"
#include "report.h"
#include "args.h"
#include "lexicon.h"

STATE_DEF(directives_tally)
{
    ptr_vector_h directives_tab;
}
STATE_T(directives_tally);
NO_PUBLIC_STATE(directives_tally);
IMPLEMENT(directives_tally,USER_INITABLE);

DEFINE_USER_INIT(directives_tally)(STATE_T(directives_tally) * st_state)
{
    st_state->directives_tab =
        ptr_vector_new((dtor_t)ptr_set_dispose,(cloner_t)ptr_set_copy);
}

DEFINE_USER_FINIS(directives_tally)(STATE_T(directives_tally) * st_state)
{
    ptr_vector_dispose(st_state->directives_tab);
}
/* Helpers */


typedef struct directive {
    directive_type_t type;      
    char const *keyword;        
} directive_t;


static directive_t const directives_dict[] = {
    {   HASH_IF,                IF },
    {   HASH_IFDEF,             IFDEF },
    {   HASH_IFNDEF,    IFNDEF },
    {   HASH_ELSE,              ELSE },
    {   HASH_ELIF,              ELIF },
    {   HASH_ENDIF,             ENDIF },
    {   HASH_DEFINE,    DEFINE },
    {   HASH_UNDEF,             UNDEF },
    {   HASH_INCLUDE,   INCLUDE },
    {   HASH_PRAGMA,    PRAGMA },
    {   HASH_ERROR,             ERROR },
    {   HASH_UNKNOWN, NULL }
};

/* Helpers */

static canonical_string_const_h
directive_text_lookup(canonical_string_const_h cl, directive_type_t directive_type)
{
    canonical_string_h found = NULL;
    char const *text = canonical_string_text(cl);
    ptr_vector_h directives_tab = GET_STATE(directives_tally,directives_tab);
    size_t ntypes = ptr_vector_count(directives_tab);
    ptr_set_h directive_tab = NULL;
    for (       ; ntypes <= (size_t)directive_type; ++ntypes) {
        ptr_vector_append(directives_tab,
                          ptr_set_new((comparator_t)canonical_string_compare,
                                      (dtor_t)canonical_string_dispose,
                                      (cloner_t)canonical_string_copy));
    }

    directive_tab = ptr_vector_at(directives_tab,directive_type);
    found = ptr_set_search(directive_tab,text,strlen(text));
    return found;
}

static void
directive_text_add(canonical_string_const_h cl, directive_type_t directive_type)
{
    ptr_vector_h directives_tab = GET_STATE(directives_tally,directives_tab);
    ptr_set_h directive_tab = ptr_vector_at(directives_tab,directive_type);
    ptr_set_insert(directive_tab,cl);
}

/* API *********************************************************************/

directive_type_t
get_directive_type(char const **keyword)
{
    directive_t const * directive = directives_dict;
    for (       ; directive->type != HASH_UNKNOWN; ++directive) {
        if (match_keyword(keyword,directive->keyword)) {
            break;
        }
    }
    return directive->type;
}

char const *
get_directive_keyword(directive_type_t directive_type)
{
    directive_t const * directive = directives_dict;
    for (       ; directive->type != HASH_UNKNOWN; ++directive) {
        if (directive->type == directive_type) {
            break;
        }
    }
    return directive->keyword;
}

void
directive_tally(canonical_string_const_h cl, directive_type_t directive_type)
{
    canonical_string_const_h found = directive_text_lookup(cl,directive_type);
    if (!found) {
        directive_text_add(cl,directive_type);
        report_directive(cl,directive_type);
    } else if (!GET_PUBLIC(args,list_only_once)) {
        report_directive(found,directive_type);
    }
}

/* EOF*/