/*      $NetBSD$ */

/*-
* Copyright (c) 2007 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Jachym Holecek <[email protected]>.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. 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.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by the NetBSD
*      Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <sys/errno.h>

#include <prop/proplib.h>

#include "prop_object_impl.h"
#include "prop_codec_impl.h"


extern const struct _prop_codec         prop_codec_xml;
extern const struct _prop_codec         prop_codec_scn;

static prop_codec_t                     prop_codec_table[] = {
#if defined(_PROPLIB_CODEC_XML)
       &prop_codec_xml,
#endif
#if defined(_PROPLIB_CODEC_SCN)
       &prop_codec_scn,
#endif
       NULL
};

/* Default to the codec with smallest external representation available. */
#if !defined(_PROP_DEFAULT_CODEC)
#if defined(_PROPLIB_CODEC_SCN)
#define _PROP_DEFAULT_CODEC     "scn"
#elif defined(_PROPLIB_CODEC_XML)
#define _PROP_DEFAULT_CODEC     "xml"
#else
#define _PROP_DEFAULT_CODEC     ""      /* Runtime failure */
#endif
#endif

static const char *
prop_skip_space(const char *str)
{
       if (str == NULL)
               return (NULL);

       while (*str == ' ' || *str == '\t' || *str == '\n' || *str == '\r')
               str++;

       return (str);
}

static prop_codec_t
prop_codec_guess(char c)
{
       int                     i;

       /*
        * Must be able to tell codec by the first non-white character.
        * For binary codecs this implies their header must not begin
        * with whitespace characters.
        */
       for (i = 0; prop_codec_table[i]; i++)
               if (strchr((const char *)prop_codec_table[i]->codec_sense,
                   c) != NULL)
                       return (prop_codec_table[i]);

       return (NULL);
}

static prop_object_t
prop_parse_single(prop_codec_t co, const char *str, prop_type_t type)
{
       prop_parser_t           pa;
       prop_object_t           po, pq;

       if (prop_parser_create(co, &pa))
               goto fail_0;

       if (prop_parser_exec(co, pa, (const u_char *)str, strlen(str)))
               goto fail_1;

       if ((po = prop_parser_yield(co, pa)) == NULL)
               goto fail_1;

       /* Expect ${str} contains exactly one object. */
       if ((pq = prop_parser_yield(co, pa)) != NULL) {
               prop_object_release(pq);
               goto fail_2;
       }

       if (prop_object_type(po) != type)
               goto fail_2;

       prop_parser_destroy(co, pa);
       return (po);

fail_2:
       prop_object_release(po);
fail_1:
       prop_parser_destroy(co, pa);
fail_0:
       return (NULL);
}

const char *
prop_codec_list(void)
{
       static boolean_t        doinit = TRUE;
       static char             names[8];       /* XXX Large enough */
       size_t                  idx = 0;
       int                     i;

       /* XXX locking? */
       if (doinit) {
               for (i = 0; prop_codec_table[i]; i++) {
                       strcpy(names + idx, prop_codec_table[i]->codec_name);
                       idx += strlen(prop_codec_table[i]->codec_name);

                       if (prop_codec_table[i + 1])
                               names[idx++] = ' ';
               }

               names[idx] = '\0';
               doinit = FALSE;
       }

       return (names);
}

prop_codec_t
prop_codec_lookup(const char *name)
{
       int                     i;

       if (name == NULL)
               name = _PROP_DEFAULT_CODEC;

       for (i = 0; prop_codec_table[i]; i++)
               if (strcmp(prop_codec_table[i]->codec_name, name) == 0)
                       return (prop_codec_table[i]);

       return (NULL);
}

prop_dictionary_t
prop_dictionary_internalize(const char *str)
{
       prop_codec_t            co;

       if ((str = prop_skip_space(str)) == NULL)
               return (NULL);

       if ((co = prop_codec_guess(*str)) == NULL)
               return (NULL);

       if (co->codec_dictionary_internalize)
               return ((co->codec_dictionary_internalize)(str));

       return (prop_parse_single(co, str, PROP_TYPE_DICTIONARY));
}

prop_array_t
prop_array_internalize(const char *str)
{
       prop_codec_t            co;

       if ((str = prop_skip_space(str)) == NULL)
               return (NULL);

       if ((co = prop_codec_guess(*str)) == NULL)
               return (NULL);

       if (co->codec_array_internalize)
               return ((co->codec_array_internalize)(str));

       return (prop_parse_single(co, str, PROP_TYPE_ARRAY));
}

char *
prop_dictionary_externalize(prop_dictionary_t pd)
{
       prop_codec_t            co = prop_codec_lookup(_PROP_DEFAULT_CODEC);

       _PROP_ASSERT(co);

       if (co->codec_dictionary_externalize)
               return ((co->codec_dictionary_externalize)(pd));

       if (co->codec_externalize_compound)
               return ((co->codec_externalize_compound)(pd));

       return (NULL);
}

char *
prop_array_externalize(prop_array_t pa)
{
       prop_codec_t            co = prop_codec_lookup(_PROP_DEFAULT_CODEC);

       _PROP_ASSERT(co);

       if (co->codec_array_externalize)
               return ((co->codec_array_externalize)(pa));

       if (co->codec_externalize_compound)
               return ((co->codec_externalize_compound)(pa));

       return (NULL);
}

char *
prop_codec_externalize(prop_codec_t co, prop_object_t po)
{
       _PROP_ASSERT(co);

       if (co->codec_externalize_compound)
               return ((co->codec_externalize_compound)(po));

       switch (prop_object_type(po)) {
       case PROP_TYPE_DICTIONARY:
               return ((co->codec_dictionary_externalize)(po));
       case PROP_TYPE_ARRAY:
               return ((co->codec_array_externalize)(po));
       default:
               return (NULL);
       }
}

int
prop_parser_create(prop_codec_t co, prop_parser_t *pp)
{
       _PROP_ASSERT(co);

       if (pp == NULL)
               return (EINVAL);

       if (co->codec_parser_create)
               return ((co->codec_parser_create)(pp));

       return (EOPNOTSUPP);
}

int
prop_parser_exec(prop_codec_t co, prop_parser_t pa, const u_char *str,
   size_t len)
{
       _PROP_ASSERT(co);

       if (co->codec_parser_exec)
               return ((co->codec_parser_exec)(pa, str, len));

       return (EOPNOTSUPP);
}

prop_object_t
prop_parser_yield(prop_codec_t co, prop_parser_t pa)
{
       _PROP_ASSERT(co);

       if (co->codec_parser_yield)
               return ((co->codec_parser_yield)(pa));

       return (NULL);
}

void
prop_parser_destroy(prop_codec_t co, prop_parser_t pa)
{
       _PROP_ASSERT(co);

       if (co->codec_parser_destroy)
               (co->codec_parser_destroy)(pa);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.