/*

 * This software is copyrighted as noted below.  It may be freely copied,

 * modified, and redistributed, provided that the copyright notice is 

 * preserved on all copies.

 * 

 * There is no warranty or other guarantee of fitness for this software,

 * it is provided solely "as is".  Bug reports or fixes may be sent

 * to the author, who may or may not act on them as he desires.

 *

 * You may not include this software in a program or other software product

 * without supplying the source, or without informing the end-user that the 

 * source is available for no extra charge.

 *

 * If you modify this software, you should include a notice giving the

 * name of the person performing the modification, the date of modification,

 * and the reason for such modification.

 */

/* 

 * rle_putcom.c - Add a picture comment to the header struct.

 * 

 * Author:  Spencer W. Thomas

 *      Computer Science Dept.

 *      University of Utah

 * Date:    Mon Feb  2 1987

 * Copyright (c) 1987, University of Utah

 */

#include <stdio.h>

#include "netpbm/mallocvar.h"

#include "netpbm/pm.h"

#include "rle.h"

/*****************************************************************

 * TAG( match )

 * 

 * Match a name against a test string for "name=value" or "name".

 * If it matches name=value, return pointer to value part, if just

 * name, return pointer to NUL at end of string.  If no match, return NULL.

 *

 * Inputs:

 *  n:  Name to match.  May also be "name=value" to make it easier

 *      to replace comments.

 *  v:  Test string.

 * Outputs:

 *  Returns pointer as above.

 * Assumptions:

 *  [None]

 * Algorithm:

 *  [None]

 */

static const char *

match(const char * const nArg,

      const char * const vArg) {

    const char * n;

    const char * v;

    for (n = nArg, v = vArg; *n != '\0' && *n != '=' && *n == *v; ++n, ++v)

        ;

    if (*n == '\0' || *n == '=') {

        if (*v == '\0')

            return v;

        else if (*v == '=')

            return ++v;

    }

    return NULL;

}

/*****************************************************************

 * TAG( rle_putcom )

 * 

 * Put a comment into the header struct.

 * Inputs:

 *  value:      Value to add to comments.

 *  the_hdr:    Header struct to add to.

 * Outputs:

 *  the_hdr:    Modified header struct.

 *  Returns previous value;

 * Assumptions:

 *  value pointer can be used as is (data is NOT copied).

 * Algorithm:

 *  Find match if any, else add at end (realloc to make bigger).

 */

const char *

rle_putcom(const char * const value,

           rle_hdr *    const the_hdr) {

    if ( the_hdr->comments == NULL) {

        MALLOCARRAY_NOFAIL(the_hdr->comments, 2);

        the_hdr->comments[0] = value;

        the_hdr->comments[1] = NULL;

    } else {

        const char ** cp;

        const char * v;

        const char ** old_comments;

        int i;

        for (i = 2, cp = the_hdr->comments; *cp != NULL; ++i, ++cp) {

            overflow_add(i, 1);

            if (match(value, *cp) != NULL) {

                v = *cp;

                *cp = value;

                return v;

            }

        }

        /* Not found */

        /* Can't realloc because somebody else might be pointing to this

         * comments block.  Of course, if this were true, then the

         * assignment above would change the comments for two headers.

         * But at least, that won't crash the program.  Realloc will.

         * This would work a lot better in C++, where hdr1 = hdr2

         * could copy the pointers, too.

         */

        old_comments = the_hdr->comments;

        MALLOCARRAY(the_hdr->comments, i);

        if (the_hdr->comments == NULL)

            pm_error("Unable to allocate memory for comments");

        the_hdr->comments[--i] = NULL;

        the_hdr->comments[--i] = value;

        for (--i; i >= 0; --i)

            the_hdr->comments[i] = old_comments[i];

    }

    return NULL;

}

/*****************************************************************

 * TAG( rle_delcom )

 * 

 * Delete a comment from header struct.

 * Inputs:

 *  name:       Name of comment to delete.

 *  the_hdr:    Header to delete comment from.

 * Outputs:

 *  the_hdr:    Modified header struct.

 *  Returns original comment value.

 * Assumptions:

 *  [None]

 * Algorithm:

 *  [None]

 */

const char *

rle_delcom(const char * const name,

           rle_hdr *    const the_hdr) {

    const char * v = NULL;

    if (the_hdr->comments == NULL)

        v = NULL;

    else {

        const char ** cp;

        for (cp = the_hdr->comments; *cp != NULL; ++cp)

            if (match(name, *cp) != NULL) {

                v = *cp;

                for ( ; *cp != NULL; ++cp)

                    *cp = cp[1];

                break;

            }

        /* Not found */

        if (*the_hdr->comments == NULL)

            the_hdr->comments = NULL;

    }

    return v;

}