/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/***************************************************************************
 * Description: General purpose map object                                 *
 * Author:      Gal Shachor <shachor@il.ibm.com>                           *
 * Author:      Mladen Turk <mturk@apache.org>                             *
 * Version:     $Revision: 1647863 $                                          *
 ***************************************************************************/
#if defined(AS400) && !defined(AS400_UTF8)
#include "apr_xlate.h"
#endif

#include "jk_global.h"
#include "jk_pool.h"
#include "jk_util.h"
#include "jk_map.h"

#define CAPACITY_INC_SIZE   (50)
#define LENGTH_OF_LINE      (8192)
#define JK_MAP_RECURSION    (20)
#define JK_MAP_REFERENCE    (".reference")
#define JK_MAP_REFERENCE_SZ (strlen(JK_MAP_REFERENCE))

/* Taken from APR tables/apr_hash.c */
/*
 * This is the popular `times 33' hash algorithm which is used by
 * perl and also appears in Berkeley DB. This is one of the best
 * known hash functions for strings because it is both computed
 * very fast and distributes very well.
 *
 * The originator may be Dan Bernstein but the code in Berkeley DB
 * cites Chris Torek as the source. The best citation I have found
 * is "Chris Torek, Hash function for text in C, Usenet message
 * <27038@mimsy.umd.edu> in comp.lang.c , October, 1990." in Rich
 * Salz's USENIX 1992 paper about INN which can be found at
 * <http://citeseer.nj.nec.com/salz92internetnews.html>.
 *
 * The magic of number 33, i.e. why it works better than many other
 * constants, prime or not, has never been adequately explained by
 * anyone. So I try an explanation: if one experimentally tests all
 * multipliers between 1 and 256 (as I did while writing a low-level
 * data structure library some time ago) one detects that even
 * numbers are not useable at all. The remaining 128 odd numbers
 * (except for the number 1) work more or less all equally well.
 * They all distribute in an acceptable way and this way fill a hash
 * table with an average percent of approx. 86%.
 *
 * If one compares the chi^2 values of the variants (see
 * Bob Jenkins ``Hashing Frequently Asked Questions'' at
 * http://burtleburtle.net/bob/hash/hashfaq.html for a description
 * of chi^2), the number 33 not even has the best value. But the
 * number 33 and a few other equally good numbers like 17, 31, 63,
 * 127 and 129 have nevertheless a great advantage to the remaining
 * numbers in the large set of possible multipliers: their multiply
 * operation can be replaced by a faster operation based on just one
 * shift plus either a single addition or subtraction operation. And
 * because a hash function has to both distribute good _and_ has to
 * be very fast to compute, those few numbers should be preferred.
 *
 *                  -- Ralf S. Engelschall <rse@engelschall.com>
 */
#define COMPUTE_KEY_HASH(key, hash)    \
{                                                    \
    const unsigned char *p;                          \
    hash = 0;                                        \
    for (p = (const unsigned char *)key; *p; p++) {  \
        hash = hash * 33 + *p;                       \
    }                                                \
}

static volatile int global_map_id = 0;
static void trim_prp_comment(char *prp);
static size_t trim(char *s);
static int map_realloc(jk_map_t *m);
static char *jk_map_replace_properties(jk_map_t *m, jk_map_t *env, char *value);

int jk_map_alloc(jk_map_t **m)
{
    if (m) {
        *m = (jk_map_t *)calloc(1, sizeof(jk_map_t));
        if (*m)
            return jk_map_open(*m);
    }

    return JK_FALSE;
}

int jk_map_free(jk_map_t **m)
{
    int rc = JK_FALSE;

    if (m && *m) {
        jk_map_close(*m);
        free(*m);
        *m = NULL;
    }

    return rc;
}

int jk_map_open(jk_map_t *m)
{
    int rc = JK_FALSE;

    if (m) {
        jk_open_pool(&m->p, m->buf, sizeof(jk_pool_atom_t) * SMALL_POOL_SIZE);
        m->id = ++global_map_id;
        m->capacity = 0;
        m->size = 0;
        m->keys  = NULL;
        m->names = NULL;
        m->values = NULL;
        rc = JK_TRUE;
    }

    return rc;
}

int jk_map_close(jk_map_t *m)
{
    int rc = JK_FALSE;

    if (m) {
        jk_close_pool(&m->p);
        rc = JK_TRUE;
    }

    return rc;
}

void *jk_map_get(jk_map_t *m, const char *name, const void *def)
{
    const void *rc = (void *)def;

    if (m && name) {
        unsigned int i;
        unsigned int hash;
        COMPUTE_KEY_HASH(name, hash)
        for (i = 0; i < m->size; i++) {
            if (m->keys[i] == hash && strcmp(m->names[i], name) == 0) {
                rc = m->values[i];
                break;
            }
        }
    }

    return (void *)rc;          /* DIRTY */
}

int jk_map_get_id(jk_map_t *m, const char *name)
{
    int rc = -1;
    if (m && name) {
        unsigned int i;
        unsigned int hash;
        COMPUTE_KEY_HASH(name, hash)
        for (i = 0; i < m->size; i++) {
            if (m->keys[i] == hash && strcmp(m->names[i], name) == 0) {
                rc = i;
                break;
            }
        }
    }

    return rc;
}

const char *jk_map_get_string(jk_map_t *m, const char *name, const char *def)
{
    const char *rc = def;

    if (m && name) {
        unsigned int i;
        unsigned int hash;
        COMPUTE_KEY_HASH(name, hash)
        for (i = 0; i < m->size; i++) {
            if (m->keys[i] == hash && strcmp(m->names[i], name) == 0) {
                rc = m->values[i];
                break;
            }
        }
    }

    return rc;
}


int jk_map_get_int(jk_map_t *m, const char *name, int def)
{
    char buf[100];
    const char *rc;
    size_t len;
    int int_res;

    sprintf(buf, "%d", def);
    rc = jk_map_get_string(m, name, buf);

    len = strlen(rc);
    if (len) {
        const char *lastchar = &rc[0] + len - 1;
        int multit = 1;
        if ('m' == *lastchar || 'M' == *lastchar) {
            multit = 1024 * 1024;
        }
        else if ('k' == *lastchar || 'K' == *lastchar) {
            multit = 1024;
        }
        /* Safe because atoi() will stop at any non-numeric lastchar */
        int_res = atoi(rc) * multit;
    }
    else
        int_res = def;

    return int_res;
}

double jk_map_get_double(jk_map_t *m, const char *name, double def)
{
    char buf[100];
    const char *rc;

    sprintf(buf, "%f", def);
    rc = jk_map_get_string(m, name, buf);

    return atof(rc);
}

int jk_map_get_bool(jk_map_t *m, const char *name, int def)
{
    char buf[100];
    const char *rc;

    sprintf(buf, "%d", def);
    rc = jk_map_get_string(m, name, buf);

    return jk_get_bool_code(rc, def);
}

char **jk_map_get_string_list(jk_map_t *m,
                              const char *name,
                              unsigned int *list_len, const char *def)
{
    const char *l = jk_map_get_string(m, name, def);
    char **ar = NULL;

#ifdef _MT_CODE_PTHREAD
    char *lasts;
#endif

    *list_len = 0;

    if (l) {
        unsigned capacity = 0;
        unsigned idex = 0;
        char *p;
        char *v = jk_pool_strdup(&m->p, l);

        if (!v) {
            return NULL;
        }

        /*
         * GS, in addition to VG's patch, we now need to
         * strtok also by a "*"
         */
#ifdef _MT_CODE_PTHREAD
        for (p = strtok_r(v, " \t,", &lasts);
             p; p = strtok_r(NULL, " \t,", &lasts))
#else
        for (p = strtok(v, " \t,"); p; p = strtok(NULL, " \t,"))
#endif

        {
            if (idex == capacity) {
                ar = jk_pool_realloc(&m->p,
                                     sizeof(char *) * (capacity + 5),
                                     ar, sizeof(char *) * capacity);
                if (!ar) {
                    return NULL;
                }
                capacity += 5;
            }
            ar[idex] = jk_pool_strdup(&m->p, p);
            idex++;
        }

        *list_len = idex;
    }

    return ar;
}

int *jk_map_get_int_list(jk_map_t *m,
                         const char *name,
                         unsigned int *list_len,
                         const char *def)
{
    const char *l = jk_map_get_string(m, name, def);
    int *ar = NULL;

#ifdef _MT_CODE_PTHREAD
    char *lasts;
#endif

    if (l) {
        unsigned int capacity = 0;
        unsigned int idex = 0;
        char *p;
        char *v = jk_pool_strdup(&m->p, l);

        if (!v) {
            return NULL;
        }

        /*
         * GS, in addition to VG's patch, we now need to
         * strtok also by a "*"
         */
#ifdef _MT_CODE_PTHREAD
        for (p = strtok_r(v, " \t,", &lasts);
             p; p = strtok_r(NULL, " \t,", &lasts))
#else
        for (p = strtok(v, " \t,"); p; p = strtok(NULL, " \t,"))
#endif

        {
            if (idex == capacity) {
                ar = jk_pool_realloc(&m->p,
                                     sizeof(int) * (capacity + 5),
                                     ar, sizeof(int) * capacity);
                if (!ar) {
                    return NULL;
                }
                capacity += 5;
            }
            ar[idex] = atoi(p);
            idex++;
        }

        *list_len = idex;
    }
    return ar;
}

int jk_map_add(jk_map_t *m, const char *name, const void *value)
{
    int rc = JK_FALSE;

    if (m && name) {
        unsigned int hash;
        COMPUTE_KEY_HASH(name, hash)
        map_realloc(m);

        if (m->size < m->capacity) {
            m->values[m->size] = value;
            m->names[m->size] = jk_pool_strdup(&m->p, name);
            m->keys[m->size] = hash;
            m->size++;
            rc = JK_TRUE;
        }
    }

    return rc;
}

int jk_map_put(jk_map_t *m, const char *name, const void *value, void **old)
{
    int rc = JK_FALSE;

    if (m && name) {
        unsigned int i;
        unsigned int hash;
        COMPUTE_KEY_HASH(name, hash)
        for (i = 0; i < m->size; i++) {
            if (m->keys[i] == hash && strcmp(m->names[i], name) == 0) {
                break;
            }
        }

        if (i < m->size) {
            if (old)
                *old = (void *)m->values[i];        /* DIRTY */
            m->values[i] = value;
            rc = JK_TRUE;
        }
        else {
            rc = jk_map_add(m, name, value);
        }
    }

    return rc;
}


static int jk_map_validate_property(char *prp, jk_logger_t *l)
{
    /* check the worker properties */
    if (!jk_is_valid_property(prp)) {
        jk_log(l, JK_LOG_ERROR,
               "The attribute '%s' is not supported - please check"
               " the documentation for the supported attributes.",
               prp);
        return JK_FALSE;
    }
    if (jk_is_deprecated_property(prp)) {
        jk_log(l, JK_LOG_WARNING,
               "The attribute '%s' is deprecated - please check"
               " the documentation for the correct replacement.",
               prp);
    }
    return JK_TRUE;
}

static int jk_map_handle_duplicates(jk_map_t *m, const char *prp, char **v,
                                    int treatment, jk_logger_t *l)
{
    const char *oldv = jk_map_get_string(m, prp, NULL);
    if (oldv) {
        if ((treatment == JK_MAP_HANDLE_DUPLICATES)
            && jk_is_unique_property(prp) == JK_FALSE) {
            char *tmpv = jk_pool_alloc(&m->p,
                                       strlen(*v) + strlen(oldv) + 3);
            if (tmpv) {
                char sep = '*';
                if (jk_is_path_property(prp))
                    sep = PATH_SEPERATOR;
                else if (jk_is_cmd_line_property(prp))
                    sep = ' ';
                else if (jk_is_list_property(prp))
                    sep = ',';
                sprintf(tmpv, "%s%c%s", oldv, sep, *v);
            }
            *v = tmpv;
            if (JK_IS_DEBUG_LEVEL(l))
                jk_log(l, JK_LOG_DEBUG,
                       "Concatenated value is: %s -> %s",
                       prp, *v);
            return JK_FALSE;
        }
        else {
            jk_log(l, JK_LOG_WARNING,
                   "Duplicate key '%s' detected - previous value '%s'"
                   " will be overwritten with '%s'.",
                   prp, oldv ? oldv : "(null)", v ? *v : "(null)");
            return JK_TRUE;
        }
    }
    else {
        return JK_TRUE;
    }
}

int jk_map_read_property(jk_map_t *m, jk_map_t *env, const char *str,
                         int treatment, jk_logger_t *l)
{
    int rc = JK_TRUE;
    char buf[LENGTH_OF_LINE + 1];
    char *prp = &buf[0];

    if (strlen(str) > LENGTH_OF_LINE) {
        jk_log(l, JK_LOG_ERROR,
               "Line too long (%d > %d), ignoring entry",
               strlen(str), LENGTH_OF_LINE);
        return JK_FALSE;
    }

    strcpy(prp, str);
    if (trim(prp)) {
        char *v = strchr(prp, '=');
        if (v) {
            *v = '\0';
            v++;
            if (trim(v) && trim(prp)) {
                if (treatment == JK_MAP_HANDLE_RAW) {
                    v = jk_pool_strdup(&m->p, v);
                }
                else {
                    if (jk_map_validate_property(prp, l) == JK_FALSE)
                        return JK_FALSE;
                    v = jk_map_replace_properties(m, env, v);
                    if (jk_map_handle_duplicates(m, prp, &v, treatment, l) == JK_TRUE)
                        v = jk_pool_strdup(&m->p, v);
                }
                if (v) {
                    if (JK_IS_DEBUG_LEVEL(l))
                        jk_log(l, JK_LOG_DEBUG,
                               "Adding property '%s' with value '%s' to map.",
                               prp, v);
                    jk_map_put(m, prp, v, NULL);
                }
                else {
                    JK_LOG_NULL_PARAMS(l);
                    rc = JK_FALSE;
                }
            }
        }
    }
    return rc;
}


int jk_map_read_properties(jk_map_t *m, jk_map_t *env, const char *f, time_t *modified,
                           int treatment, jk_logger_t *l)
{
    int rc = JK_FALSE;

    if (m && f) {
        struct stat statbuf;
        FILE *fp;
        if (jk_stat(f, &statbuf) == -1)
            return JK_FALSE;
#if defined(AS400) && !defined(AS400_UTF8)
        fp = fopen(f, "r, o_ccsid=0");
#else
        fp = fopen(f, "r");
#endif

        if (fp) {
            char buf[LENGTH_OF_LINE + 1];
            char *prp;

            rc = JK_TRUE;

            while (NULL != (prp = fgets(buf, LENGTH_OF_LINE, fp))) {
                trim_prp_comment(prp);
                if (*prp) {
                    if ((rc = jk_map_read_property(m, env, prp, treatment, l)) == JK_FALSE)
                        break;
                }
            }
            fclose(fp);
            if (modified)
                *modified = statbuf.st_mtime;
        }
    }

    return rc;
}


int jk_map_size(jk_map_t *m)
{
    if (m) {
        return m->size;
    }

    return -1;
}

const char *jk_map_name_at(jk_map_t *m, int idex)
{
    if (m && idex >= 0) {
        return m->names[idex];  /* DIRTY */
    }

    return NULL;
}

void *jk_map_value_at(jk_map_t *m, int idex)
{
    if (m && idex >= 0) {
        return (void *)m->values[idex]; /* DIRTY */
    }

    return NULL;
}

void jk_map_dump(jk_map_t *m, jk_logger_t *l)
{
    if (m) {
        int s = jk_map_size(m);
        int i;
        for (i=0;i<s;i++) {
            if (!jk_map_name_at(m, i)) {
                jk_log(l, JK_LOG_WARNING,
                       "Map contains empty name at index %d\n", i);
            }
            if (!jk_map_value_at(m, i)) {
                jk_log(l, JK_LOG_WARNING,
                       "Map contains empty value for name '%s' at index %d\n",
                       jk_map_name_at(m, i), i);
            }
            if (JK_IS_DEBUG_LEVEL(l)) {
                jk_log(l, JK_LOG_DEBUG,
                       "Dump of map %d: '%s' -> '%s'", m->id,
                       jk_map_name_at(m, i) ? jk_map_name_at(m, i) : "(null)",
                       jk_map_value_at(m, i) ? jk_map_value_at(m, i) : "(null)");
            }
        }
    }
}

int jk_map_copy(jk_map_t *src, jk_map_t *dst)
{
    int sz = jk_map_size(src);
    int i;
    for (i = 0; i < sz; i++) {
        const char *name = jk_map_name_at(src, i);
        if (jk_map_get(dst, name, NULL) == NULL) {
            if (!jk_map_put(dst, name,
                            jk_pool_strdup(&dst->p, jk_map_get_string(src, name, NULL)),
                            NULL)) {
                return JK_FALSE;
            }
        }
    }
    return JK_TRUE;
}


static void trim_prp_comment(char *prp)
{
#if defined(AS400) && !defined(AS400_UTF8)
    char *comment;
    /* lots of lines that translate a '#' realtime deleted   */
    comment = strchr(prp, *APR_NUMBERSIGN);
#else
    char *comment = strchr(prp, '#');
#endif
    if (comment) {
        *comment = '\0';
    }
}

static size_t trim(char *s)
{
    size_t first;
    size_t len;

    /* check for empty strings */
    if (!(len = strlen(s)))
        return 0;
    for (len = len - 1; (len > 0) &&
        jk_isspace(s[len]); len--);
    if ((len > 0) || !jk_isspace(s[len])) {
        len++;
    }

    s[len] = '\0';
    len++;

    for (first = 0; (s[first] != '\0') &&
        jk_isspace(s[first]); first++);

    if (first > 0) {
        memmove(s, s + first, len - first);
    }

    return len;
}

static int map_realloc(jk_map_t *m)
{
    if (m->size == m->capacity) {
        const char **names;
        const void **values;
        unsigned int *keys;
        int capacity  = m->capacity + CAPACITY_INC_SIZE;
        size_t old_sz = m->capacity * sizeof(void *);
        size_t new_sz = capacity * sizeof(void *);

        names  = (const char  **)jk_pool_realloc(&m->p, new_sz, m->names, old_sz);
        values = (const void  **)jk_pool_realloc(&m->p, new_sz, m->values, old_sz);
        keys   = (unsigned int *)jk_pool_realloc(&m->p, new_sz, m->keys, old_sz);

        if (values && names && keys) {

            m->names  = names;
            m->values = values;
            m->keys   = keys;
            m->capacity = capacity;

            return JK_TRUE;
        }
    }

    return JK_FALSE;
}

/**
 *  Replace $(property) in value.
 *
 */
static char *jk_map_replace_properties(jk_map_t *m, jk_map_t *env, char *value)
{
    char *rc = value;
    char *env_start = rc;
    int rec = 0;

    while ((env_start = strstr(env_start, "$(")) != NULL) {
        char *env_end = strstr(env_start, ")");
        if (rec++ > 20)
            return rc;
        if (env_end) {
            char env_name[LENGTH_OF_LINE + 1] = "";
            const char *env_value;
#if defined(WIN32)
            char env_buf[LENGTH_OF_LINE + 1];
#endif
            *env_end = '\0';
            strcpy(env_name, env_start + 2);
            *env_end = ')';

            env_value = jk_map_get_string(m, env_name, NULL);
            if (!env_value) {
                env_value = getenv(env_name);
            }
            if (!env_value && env) {
                /* Search inside local environment table */
                env_value = jk_map_get_string(env, env_name, NULL);
            }

#if defined(WIN32)
            if (!env_value) {
                /* Try the env block from calling process */
                if (GetEnvironmentVariable(env_name, env_buf,
                                           sizeof(env_buf)))
                    env_value = &env_buf[0];
            }
#endif
            if (env_value) {
                size_t offset = 0;
                char *new_value = jk_pool_alloc(&m->p,
                                                (sizeof(char) *
                                                (strlen(rc) +
                                                strlen(env_value))));
                if (!new_value) {
                    break;
                }
                *env_start = '\0';
                strcpy(new_value, rc);
                strcat(new_value, env_value);
                strcat(new_value, env_end + 1);
                offset = env_start - rc + strlen(env_value);
                rc = new_value;
                /* Avoid recursive subst */
                env_start = rc + offset;
            }
            else {
                env_start = env_end;
            }
        }
        else {
            break;
        }
    }

    return rc;
}

/**
 *  Resolve references
 *
 */
int jk_map_resolve_references(jk_map_t *m, const char *prefix,
                              int wildcard, int depth, jk_logger_t *l)
{
    int rc = JK_FALSE;

    JK_TRACE_ENTER(l);

    if (m && prefix) {
        if (depth <= JK_MAP_RECURSION) {
            size_t prelen = strlen(prefix);
            unsigned int i;
            rc = JK_TRUE;
            if (JK_IS_DEBUG_LEVEL(l))
                jk_log(l, JK_LOG_DEBUG,
                       "Checking for references with prefix %s with%s wildcard (recursion %d)",
                       prefix, wildcard? "" : "out", depth);
            for (i = 0; i < m->size; i++) {
                char *v = (char *)m->values[i];
                if (v && *v &&
                    !strncmp(m->names[i], prefix, prelen)) {
                    size_t remain = strlen(m->names[i]) - prelen;
                    if ((remain == JK_MAP_REFERENCE_SZ ) || (wildcard && remain > JK_MAP_REFERENCE_SZ)) {
                        remain = strlen(m->names[i]) - JK_MAP_REFERENCE_SZ;
                        if (!strncmp(m->names[i] + remain, JK_MAP_REFERENCE, JK_MAP_REFERENCE_SZ)) {
                            char *from = jk_pool_alloc(&m->p,
                                                       (sizeof(char) *
                                                       (strlen(v) + 2)));
                            char *to = jk_pool_alloc(&m->p,
                                                     (sizeof(char) *
                                                     (remain + 2)));
                            if (!from || !to) {
                                jk_log(l, JK_LOG_ERROR,
                                       "Error in string allocation");
                                rc = JK_FALSE;
                                break;
                            }
                            strcpy(from, v);
                            *(from+strlen(v))   = '.';
                            *(from+strlen(v)+1) = '\0';
                            strncpy(to, m->names[i], remain);
                            *(to+remain)   = '.';
                            *(to+remain+1) = '\0';

                            rc = jk_map_resolve_references(m, v, 0, depth+1, l);
                            if (rc == JK_FALSE) {
                                break;
                            }
                            if (JK_IS_DEBUG_LEVEL(l))
                                jk_log(l, JK_LOG_DEBUG,
                                       "Copying values from %s to %s",
                                       from, to);
                            rc = jk_map_inherit_properties(m, from, to, l);
                            if (rc == JK_FALSE) {
                                break;
                            }
                        }
                    }
                }
            }
        }
        else {
            jk_log(l, JK_LOG_ERROR,
                   "Recursion limit %d for worker references with prefix '%s' reached",
                   JK_MAP_RECURSION, prefix);
        }
    }
    else {
        JK_LOG_NULL_PARAMS(l);
    }
    JK_TRACE_EXIT(l);
    return rc;
}

/**
 *  Inherit properties
 *
 */
int jk_map_inherit_properties(jk_map_t *m, const char *from, const char *to, jk_logger_t *l)
{
    int rc = JK_FALSE;
    const char *prp;
    char *to_prp;

    if (m && from && to) {
        unsigned int i;
        for (i = 0; i < m->size; i++) {
            if (!strncmp(m->names[i], from, strlen(from))) {
                rc = JK_TRUE;
                prp = m->names[i] + strlen(from);
                to_prp = jk_pool_alloc(&m->p,
                                       (sizeof(char) *
                                       (strlen(to) +
                                       strlen(prp) + 1)));
                if (!to_prp) {
                    jk_log(l, JK_LOG_ERROR,
                           "Error in string allocation for attribute '%s.%s'",
                           to, prp);
                    rc = JK_FALSE;
                    break;
                }
                strcpy(to_prp, to);
                strcat(to_prp, prp);
                if (jk_map_get_id(m, to_prp) < 0 ) {
                    rc = jk_map_add(m, to_prp, m->values[i]);
                    if (rc == JK_FALSE) {
                        jk_log(l, JK_LOG_ERROR,
                               "Error when adding attribute '%s'",
                               to_prp);
                        break;
                    }
                }
            }
        }
        if ( rc == JK_FALSE) {
            jk_log(l, JK_LOG_ERROR,
                   "Reference '%s' not found",
                   from);
        }
    }
    else {
        JK_LOG_NULL_PARAMS(l);
    }
    return rc;
}