Subversion Repositories gelsvn

/* ----------------------------------------------------------------------

 * RPly library, read/write PLY files

 * Diego Nehab, Princeton University

 * http://www.cs.princeton.edu/~diego/professional/rply

 *

 * This library is distributed under the MIT License. See notice

 * at the end of this file.

 * ---------------------------------------------------------------------- */

#include <stdio.h>

#include <ctype.h>

#include <assert.h>

#include <string.h>

#include <limits.h>

#include <float.h>

#include <stdarg.h>

#include <stdlib.h>

#include <stddef.h>

#include "rply.h"

/* ----------------------------------------------------------------------

 * Constants 

 * ---------------------------------------------------------------------- */

#define WORDSIZE 256

#define LINESIZE 1024

#define BUFFERSIZE (8*1024)

typedef enum e_ply_io_mode_ {

    PLY_READ, 

    PLY_WRITE

} e_ply_io_mode;

static const char *const ply_storage_mode_list[] = {

    "binary_big_endian", "binary_little_endian", "ascii", NULL

};     /* order matches e_ply_storage_mode enum */

static const char *const ply_type_list[] = {

    "int8", "uint8", "int16", "uint16", 

    "int32", "uint32", "float32", "float64",

    "char", "uchar", "short", "ushort", 

    "int", "uint", "float", "double",

    "list", NULL

};     /* order matches e_ply_type enum */

/* ----------------------------------------------------------------------

 * Property reading callback argument

 *

 * element: name of element being processed

 * property: name of property being processed

 * nelements: number of elements of this kind in file

 * instance_index: index current element of this kind being processed

 * length: number of values in current list (or 1 for scalars)

 * value_index: index of current value int this list (or 0 for scalars)

 * value: value of property

 * pdata/idata: user data defined with ply_set_cb

 *

 * Returns handle to ply file if succesful, NULL otherwise.

 * ---------------------------------------------------------------------- */

typedef struct t_ply_argument_ {

    p_ply_element element;

    int instance_index;

    p_ply_property property;

    int length, value_index;

    double value;

    void *pdata;

    int idata;

} t_ply_argument;

/* ----------------------------------------------------------------------

 * Property information

 *

 * name: name of this property

 * type: type of this property (list or type of scalar value)

 * length_type, value_type: type of list property count and values

 * read_cb: function to be called when this property is called

 *

 * Returns 1 if should continue processing file, 0 if should abort.

 * ---------------------------------------------------------------------- */

typedef struct t_ply_property_ {

    char name[WORDSIZE];

    e_ply_type type, value_type, length_type;

    p_ply_read_cb read_cb;

    void *pdata;

    int idata;

} t_ply_property; 

/* ----------------------------------------------------------------------

 * Element information

 *

 * name: name of this property

 * ninstances: number of elements of this type in file

 * property: property descriptions for this element

 * nproperty: number of properties in this element

 *

 * Returns 1 if should continue processing file, 0 if should abort.

 * ---------------------------------------------------------------------- */

typedef struct t_ply_element_ {

    char name[WORDSIZE];

    int ninstances;

    p_ply_property property;

    int nproperties;

} t_ply_element;

/* ----------------------------------------------------------------------

 * Input/output driver

 *

 * Depending on file mode, different functions are used to read/write 

 * property fields. The drivers make it transparent to read/write in ascii, 

 * big endian or little endian cases.

 * ---------------------------------------------------------------------- */

typedef int (*p_ply_ihandler)(p_ply ply, double *value);

typedef int (*p_ply_ichunk)(p_ply ply, void *anydata, size_t size);

typedef struct t_ply_idriver_ {

    p_ply_ihandler ihandler[16];

    p_ply_ichunk ichunk;

    const char *name;

} t_ply_idriver;

typedef t_ply_idriver *p_ply_idriver;

typedef int (*p_ply_ohandler)(p_ply ply, double value);

typedef int (*p_ply_ochunk)(p_ply ply, void *anydata, size_t size);

typedef struct t_ply_odriver_ {

    p_ply_ohandler ohandler[16];

    p_ply_ochunk ochunk;

    const char *name;

} t_ply_odriver;

typedef t_ply_odriver *p_ply_odriver;

/* ----------------------------------------------------------------------

 * Ply file handle. 

 *

 * io_mode: read or write (from e_ply_io_mode)

 * storage_mode: mode of file associated with handle (from e_ply_storage_mode)

 * element: elements description for this file

 * nelement: number of different elements in file

 * comment: comments for this file

 * ncomments: number of comments in file

 * obj_info: obj_info items for this file

 * nobj_infos: number of obj_info items in file

 * fp: file pointer associated with ply file

 * c: last character read from ply file

 * buffer: last word/chunck of data read from ply file

 * buffer_first, buffer_last: interval of untouched good data in buffer

 * buffer_token: start of parsed token (line or word) in buffer

 * idriver, odriver: input driver used to get property fields from file 

 * argument: storage space for callback arguments

 * welement, wproperty: element/property type being written

 * winstance_index: index of instance of current element being written

 * wvalue_index: index of list property value being written 

 * wlength: number of values in list property being written

 * error_cb: callback for error messages

 * ---------------------------------------------------------------------- */

typedef struct t_ply_ {

    e_ply_io_mode io_mode;

    e_ply_storage_mode storage_mode;

    p_ply_element element;

    int nelements;

    char *comment;

    int ncomments;

    char *obj_info;

    int nobj_infos;

    FILE *fp;

    int c;

    char buffer[BUFFERSIZE];

    size_t buffer_first, buffer_token, buffer_last;

    p_ply_idriver idriver;

    p_ply_odriver odriver;

    t_ply_argument argument;

    int welement, wproperty;

    int winstance_index, wvalue_index, wlength;

    p_ply_error_cb error_cb;

} t_ply;

/* ----------------------------------------------------------------------

 * I/O functions and drivers

 * ---------------------------------------------------------------------- */

static t_ply_idriver ply_idriver_ascii;

static t_ply_idriver ply_idriver_binary;

static t_ply_idriver ply_idriver_binary_reverse;

static t_ply_odriver ply_odriver_ascii;

static t_ply_odriver ply_odriver_binary;

static t_ply_odriver ply_odriver_binary_reverse;

static int ply_read_word(p_ply ply);

static int ply_check_word(p_ply ply);

static int ply_read_line(p_ply ply);

static int ply_check_line(p_ply ply);

static int ply_read_chunk(p_ply ply, void *anybuffer, size_t size);

static int ply_read_chunk_reverse(p_ply ply, void *anybuffer, size_t size);

static int ply_write_chunk(p_ply ply, void *anybuffer, size_t size);

static int ply_write_chunk_reverse(p_ply ply, void *anybuffer, size_t size);

static void ply_reverse(void *anydata, size_t size);

/* ----------------------------------------------------------------------

 * String functions

 * ---------------------------------------------------------------------- */

static int ply_find_string(const char *item, const char* const list[]);

static p_ply_element ply_find_element(p_ply ply, const char *name);

static p_ply_property ply_find_property(p_ply_element element, 

        const char *name);

/* ----------------------------------------------------------------------

 * Header parsing

 * ---------------------------------------------------------------------- */

static int ply_read_header_format(p_ply ply);

static int ply_read_header_comment(p_ply ply);

static int ply_read_header_obj_info(p_ply ply);

static int ply_read_header_property(p_ply ply);

static int ply_read_header_element(p_ply ply);

/* ----------------------------------------------------------------------

 * Error handling

 * ---------------------------------------------------------------------- */

static void ply_error_cb(const char *message);

static void ply_error(p_ply ply, const char *fmt, ...);

/* ----------------------------------------------------------------------

 * Memory allocation and initialization

 * ---------------------------------------------------------------------- */

static void ply_init(p_ply ply);

static void ply_element_init(p_ply_element element);

static void ply_property_init(p_ply_property property);

static p_ply ply_alloc(void);

static p_ply_element ply_grow_element(p_ply ply);

static p_ply_property ply_grow_property(p_ply ply, p_ply_element element);

static void *ply_grow_array(p_ply ply, void **pointer, int *nmemb, int size);

/* ----------------------------------------------------------------------

 * Special functions

 * ---------------------------------------------------------------------- */

static e_ply_storage_mode ply_arch_endian(void);

static int ply_type_check(void); 

/* ----------------------------------------------------------------------

 * Auxiliary read functions

 * ---------------------------------------------------------------------- */

static int ply_read_element(p_ply ply, p_ply_element element, 

        p_ply_argument argument);

static int ply_read_property(p_ply ply, p_ply_element element, 

        p_ply_property property, p_ply_argument argument);

static int ply_read_list_property(p_ply ply, p_ply_element element, 

        p_ply_property property, p_ply_argument argument);

static int ply_read_scalar_property(p_ply ply, p_ply_element element, 

        p_ply_property property, p_ply_argument argument);

/* ----------------------------------------------------------------------

 * Buffer support functions

 * ---------------------------------------------------------------------- */

/* pointers to tokenized word and line in buffer */

#define BWORD(p) (p->buffer + p->buffer_token)

#define BLINE(p) (p->buffer + p->buffer_token)

/* pointer to start of untouched bytes in buffer */

#define BFIRST(p) (p->buffer + p->buffer_first) 

/* number of bytes untouched in buffer */

#define BSIZE(p) (p->buffer_last - p->buffer_first) 

/* consumes data from buffer */

#define BSKIP(p, s) (p->buffer_first += s)

/* refills the buffer */

static int BREFILL(p_ply ply) {

    /* move untouched data to beginning of buffer */

    size_t size = BSIZE(ply);

    memmove(ply->buffer, BFIRST(ply), size);

    ply->buffer_last = size;

    ply->buffer_first = ply->buffer_token = 0;

    /* fill remaining with new data */

    size = fread(ply->buffer+size, 1, BUFFERSIZE-size-1, ply->fp);

    /* place sentinel so we can use str* functions with buffer */

    ply->buffer[BUFFERSIZE-1] = '\0';

    /* check if read failed */

    if (size <= 0) return 0;

    /* increase size to account for new data */

    ply->buffer_last += size;

    return 1;

}

/* ----------------------------------------------------------------------

 * Exported functions

 * ---------------------------------------------------------------------- */

/* ----------------------------------------------------------------------

 * Read support functions

 * ---------------------------------------------------------------------- */

p_ply ply_open(const char *name, p_ply_error_cb error_cb) {

    char magic[5] = "    ";

    FILE *fp = NULL; 

    p_ply ply = NULL;

    if (error_cb == NULL) error_cb = ply_error_cb;

    if (!ply_type_check()) {

        error_cb("Incompatible type system");

        return NULL;

    }

    assert(name);

    fp = fopen(name, "rb");

    if (!fp) {

        error_cb("Unable to open file");

        return NULL;

    }

    if (fread(magic, 1, 4, fp) < 4) {

        error_cb("Error reading from file");

        fclose(fp);

        return NULL;

    }

    if (strcmp(magic, "ply\n")) {

        fclose(fp);

        error_cb("Not a PLY file. Expected magic number 'ply\\n'");

        return NULL;

    }

    ply = ply_alloc();

    if (!ply) {

        error_cb("Out of memory");

        fclose(fp);

        return NULL;

    }

    ply->fp = fp;

    ply->io_mode = PLY_READ;

    ply->error_cb = error_cb;

    return ply;

}

int ply_read_header(p_ply ply) {

    assert(ply && ply->fp && ply->io_mode == PLY_READ);

    if (!ply_read_word(ply)) return 0;

    /* parse file format */

    if (!ply_read_header_format(ply)) {

        ply_error(ply, "Invalid file format");

        return 0;

    }

    /* parse elements, comments or obj_infos until the end of header */

    while (strcmp(BWORD(ply), "end_header")) {

        if (!ply_read_header_comment(ply) && 

                !ply_read_header_element(ply) && 

                !ply_read_header_obj_info(ply)) {

            ply_error(ply, "Unexpected token '%s'", BWORD(ply));

            return 0;

        }

    }

    return 1;

}

int ply_set_read_cb(p_ply ply, const char *element_name, 

        const char* property_name, p_ply_read_cb read_cb, 

        void *pdata, int idata) {

    p_ply_element element = NULL; 

    p_ply_property property = NULL;

    assert(ply && element_name && property_name);

    element = ply_find_element(ply, element_name);

    if (!element) return 0;

    property = ply_find_property(element, property_name);

    if (!property) return 0;

    property->read_cb = read_cb;

    property->pdata = pdata;

    property->idata = idata;

    return (int) element->ninstances;

}

int ply_read(p_ply ply) {

    int i;

    p_ply_argument argument;

    assert(ply && ply->fp && ply->io_mode == PLY_READ);

    argument = &ply->argument;

    /* for each element type */

    for (i = 0; i < ply->nelements; i++) {

        p_ply_element element = &ply->element[i];

        argument->element = element;

        if (!ply_read_element(ply, element, argument))

            return 0;

    }

    return 1;

}

/* ----------------------------------------------------------------------

 * Write support functions

 * ---------------------------------------------------------------------- */

p_ply ply_create(const char *name, e_ply_storage_mode storage_mode, 

        p_ply_error_cb error_cb) {

    FILE *fp = NULL;

    p_ply ply = NULL;

    if (error_cb == NULL) error_cb = ply_error_cb;

    if (!ply_type_check()) {

        error_cb("Incompatible type system");

        return NULL;

    }

    assert(name && storage_mode <= PLY_DEFAULT);

    fp = fopen(name, "wb");

    if (!fp) {

        error_cb("Unable to create file");

        return NULL;

    }

    ply = ply_alloc();

    if (!ply) {

        fclose(fp);

        error_cb("Out of memory");

        return NULL;

    }

    ply->io_mode = PLY_WRITE;

    if (storage_mode == PLY_DEFAULT) storage_mode = ply_arch_endian();

    if (storage_mode == PLY_ASCII) ply->odriver = &ply_odriver_ascii;

    else if (storage_mode == ply_arch_endian()) 

        ply->odriver = &ply_odriver_binary;

    else ply->odriver = &ply_odriver_binary_reverse;

    ply->storage_mode = storage_mode;

    ply->fp = fp;

    ply->error_cb = error_cb;

    return ply;

}

int ply_add_element(p_ply ply, const char *name, int ninstances) {

    p_ply_element element = NULL;

    assert(ply && ply->fp && ply->io_mode == PLY_WRITE);

    assert(name && strlen(name) < WORDSIZE && ninstances >= 0);

    if (strlen(name) >= WORDSIZE || ninstances < 0) {

        ply_error(ply, "Invalid arguments");

        return 0;

    }

    element = ply_grow_element(ply);

    if (!element) return 0;

    strcpy(element->name, name);

    element->ninstances = ninstances;

    return 1;

}

int ply_add_scalar_property(p_ply ply, const char *name, e_ply_type type) {

    p_ply_element element = NULL;

    p_ply_property property = NULL;

    assert(ply && ply->fp && ply->io_mode == PLY_WRITE);

    assert(name && strlen(name) < WORDSIZE);

    assert(type < PLY_LIST);

    if (strlen(name) >= WORDSIZE || type >= PLY_LIST) {

        ply_error(ply, "Invalid arguments");

        return 0;

    }

    element = &ply->element[ply->nelements-1];

    property = ply_grow_property(ply, element);

    if (!property) return 0;

    strcpy(property->name, name);

    property->type = type;

    return 1;

}

int ply_add_list_property(p_ply ply, const char *name, 

        e_ply_type length_type, e_ply_type value_type) {

    p_ply_element element = NULL;

    p_ply_property property = NULL;

    assert(ply && ply->fp && ply->io_mode == PLY_WRITE);

    assert(name && strlen(name) < WORDSIZE);

    if (strlen(name) >= WORDSIZE) {

        ply_error(ply, "Invalid arguments");

        return 0;

    }

    assert(length_type < PLY_LIST);

    assert(value_type < PLY_LIST);

    if (length_type >= PLY_LIST || value_type >= PLY_LIST) {

        ply_error(ply, "Invalid arguments");

        return 0;

    }

    element = &ply->element[ply->nelements-1];

    property = ply_grow_property(ply, element);

    if (!property) return 0;

    strcpy(property->name, name);

    property->type = PLY_LIST;

    property->length_type = length_type;

    property->value_type = value_type;

    return 1;

}

int ply_add_property(p_ply ply, const char *name, e_ply_type type,

        e_ply_type length_type, e_ply_type value_type) {

    if (type == PLY_LIST) 

        return ply_add_list_property(ply, name, length_type, value_type);

    else 

        return ply_add_scalar_property(ply, name, type);

}

int ply_add_comment(p_ply ply, const char *comment) {

    char *new_comment = NULL;

    assert(ply && comment && strlen(comment) < LINESIZE);

    if (!comment || strlen(comment) >= LINESIZE) {

        ply_error(ply, "Invalid arguments");

        return 0;

    }

    new_comment = (char *) ply_grow_array(ply, (void **) &ply->comment,

            &ply->ncomments, LINESIZE);

    if (!new_comment) return 0;

    strcpy(new_comment, comment);

    return 1;

}

int ply_add_obj_info(p_ply ply, const char *obj_info) {

    char *new_obj_info = NULL;

    assert(ply && obj_info && strlen(obj_info) < LINESIZE);

    if (!obj_info || strlen(obj_info) >= LINESIZE) {

        ply_error(ply, "Invalid arguments");

        return 0;

    }

    new_obj_info = (char *) ply_grow_array(ply, (void **) &ply->obj_info,

            &ply->nobj_infos, LINESIZE);

    if (!new_obj_info) return 0;

    strcpy(new_obj_info, obj_info);

    return 1;

}

int ply_write_header(p_ply ply) {

    int i, j;

    assert(ply && ply->fp && ply->io_mode == PLY_WRITE);

    assert(ply->element || ply->nelements == 0); 

    assert(!ply->element || ply->nelements > 0); 

    if (fprintf(ply->fp, "ply\nformat %s 1.0\n", 

                ply_storage_mode_list[ply->storage_mode]) <= 0) goto error;

    for (i = 0; i < ply->ncomments; i++)

        if (fprintf(ply->fp, "comment %s\n", ply->comment + LINESIZE*i) <= 0)

            goto error;

    for (i = 0; i < ply->nobj_infos; i++)

        if (fprintf(ply->fp, "obj_info %s\n", ply->obj_info + LINESIZE*i) <= 0)

            goto error;

    for (i = 0; i < ply->nelements; i++) {

        p_ply_element element = &ply->element[i];

        assert(element->property || element->nproperties == 0); 

        assert(!element->property || element->nproperties > 0); 

        if (fprintf(ply->fp, "element %s %ld\n", element->name, 

                    element->ninstances) <= 0) goto error;

        for (j = 0; j < element->nproperties; j++) {

            p_ply_property property = &element->property[j];

            if (property->type == PLY_LIST) {

                if (fprintf(ply->fp, "property list %s %s %s\n", 

                            ply_type_list[property->length_type],

                            ply_type_list[property->value_type],

                            property->name) <= 0) goto error;

            } else {

                if (fprintf(ply->fp, "property %s %s\n", 

                            ply_type_list[property->type],

                            property->name) <= 0) goto error;

            }

        }

    }

    return fprintf(ply->fp, "end_header\n") > 0;

error:

    ply_error(ply, "Error writing to file");

    return 0;

}

int ply_write(p_ply ply, double value) {

    p_ply_element element = NULL;

    p_ply_property property = NULL;

    int type = -1;

    int breakafter = 0;

    if (ply->welement > ply->nelements) return 0;

    element = &ply->element[ply->welement];

    if (ply->wproperty > element->nproperties) return 0;

    property = &element->property[ply->wproperty];

    if (property->type == PLY_LIST) {

        if (ply->wvalue_index == 0) {

            type = property->length_type;

            ply->wlength = (int) value;

        } else type = property->value_type;

    } else {

        type = property->type;

        ply->wlength = 0;

    }

    if (!ply->odriver->ohandler[type](ply, value)) {

        ply_error(ply, "Failed writing %s of %s %d (%s: %s)", 

                    property->name, element->name, 

                    ply->winstance_index, 

                    ply->odriver->name, ply_type_list[type]);

        return 0;

    }

    ply->wvalue_index++;

    if (ply->wvalue_index > ply->wlength) {

        ply->wvalue_index = 0;

        ply->wproperty++;

    }

    if (ply->wproperty >= element->nproperties) {

        ply->wproperty = 0;

        ply->winstance_index++;

        if (ply->storage_mode == PLY_ASCII) breakafter = 1;

    }

    if (ply->winstance_index >= element->ninstances) {

        ply->winstance_index = 0;

        ply->welement++;

    }

    return !breakafter || putc('\n', ply->fp) > 0;

}

int ply_close(p_ply ply) {

    int i;

    assert(ply && ply->fp);

    assert(ply->element || ply->nelements == 0);

    assert(!ply->element || ply->nelements > 0);

    /* write last chunk to file */

    if (ply->io_mode == PLY_WRITE && 

      fwrite(ply->buffer, 1, ply->buffer_last, ply->fp) < ply->buffer_last) {

        ply_error(ply, "Error closing up");

        return 0;

    }

    fclose(ply->fp);

    /* free all memory used by handle */

    if (ply->element) {

        for (i = 0; i < ply->nelements; i++) {

            p_ply_element element = &ply->element[i];

            if (element->property) free(element->property);

        }

        free(ply->element);

    }

    if (ply->obj_info) free(ply->obj_info);

    if (ply->comment) free(ply->comment);

    free(ply);

    return 1;

}

/* ----------------------------------------------------------------------

 * Query support functions

 * ---------------------------------------------------------------------- */

p_ply_element ply_get_next_element(p_ply ply, 

        p_ply_element last) {

    assert(ply);

    if (!last) return ply->element;

    last++;

    if (last < ply->element + ply->nelements) return last;

    else return NULL;

}

int ply_get_element_info(p_ply_element element, const char** name,

        int *ninstances) {

    assert(element);

    if (name) *name = element->name;

    if (ninstances) *ninstances = (int) element->ninstances;

    return 1;

}

p_ply_property ply_get_next_property(p_ply_element element, 

        p_ply_property last) {

    assert(element);

    if (!last) return element->property;

    last++;

    if (last < element->property + element->nproperties) return last;

    else return NULL;

}

int ply_get_property_info(p_ply_property property, const char** name,

        e_ply_type *type, e_ply_type *length_type, e_ply_type *value_type) {

    assert(property);

    if (name) *name = property->name;

    if (type) *type = property->type;

    if (length_type) *length_type = property->length_type;

    if (value_type) *value_type = property->value_type;

    return 1;

}

const char *ply_get_next_comment(p_ply ply, const char *last) {

    assert(ply);

    if (!last) return ply->comment; 

    last += LINESIZE;

    if (last < ply->comment + LINESIZE*ply->ncomments) return last;

    else return NULL;

}

const char *ply_get_next_obj_info(p_ply ply, const char *last) {

    assert(ply);

    if (!last) return ply->obj_info; 

    last += LINESIZE;

    if (last < ply->obj_info + LINESIZE*ply->nobj_infos) return last;

    else return NULL;

}

/* ----------------------------------------------------------------------

 * Callback argument support functions 

 * ---------------------------------------------------------------------- */

int ply_get_argument_element(p_ply_argument argument, 

        p_ply_element *element, int *instance_index) {

    assert(argument);

    if (!argument) return 0;

    if (element) *element = argument->element;

    if (instance_index) *instance_index = argument->instance_index;

    return 1;

}

int ply_get_argument_property(p_ply_argument argument, 

        p_ply_property *property, int *length, int *value_index) {

    assert(argument);

    if (!argument) return 0;

    if (property) *property = argument->property;

    if (length) *length = argument->length;

    if (value_index) *value_index = argument->value_index;

    return 1;

}

int ply_get_argument_user_data(p_ply_argument argument, void **pdata, 

        int *idata) {

    assert(argument);

    if (!argument) return 0;

    if (pdata) *pdata = argument->pdata;

    if (idata) *idata = argument->idata;

    return 1;

}

double ply_get_argument_value(p_ply_argument argument) {

    assert(argument);

    if (!argument) return 0.0;

    return argument->value;

}

/* ----------------------------------------------------------------------

 * Internal functions

 * ---------------------------------------------------------------------- */

static int ply_read_list_property(p_ply ply, p_ply_element element, 

        p_ply_property property, p_ply_argument argument) {

    int l;

    p_ply_read_cb read_cb = property->read_cb;

    p_ply_ihandler *driver = ply->idriver->ihandler; 

    /* get list length */

    p_ply_ihandler handler = driver[property->length_type];

    double length;

    if (!handler(ply, &length)) {

        ply_error(ply, "Error reading '%s' of '%s' number %d",

                property->name, element->name, argument->instance_index);

        return 0;

    }

    /* invoke callback to pass length in value field */

    argument->length = (int) length;

    argument->value_index = -1;

    argument->value = length;

    if (read_cb && !read_cb(argument)) {

        ply_error(ply, "Aborted by user");

        return 0;

    }

    /* read list values */

    handler = driver[property->value_type];

    /* for each value in list */

    for (l = 0; l < (int) length; l++) {

        /* read value from file */

        argument->value_index = l;

        if (!handler(ply, &argument->value)) {

            ply_error(ply, "Error reading value number %d of '%s' of "

                    "'%s' number %d", l+1, property->name, 

                    element->name, argument->instance_index);

            return 0;

        }

        /* invoke callback to pass value */

        if (read_cb && !read_cb(argument)) {

            ply_error(ply, "Aborted by user");

            return 0;

        }

    }

    return 1;

}

static int ply_read_scalar_property(p_ply ply, p_ply_element element, 

        p_ply_property property, p_ply_argument argument) {

    p_ply_read_cb read_cb = property->read_cb;

    p_ply_ihandler *driver = ply->idriver->ihandler; 

    p_ply_ihandler handler = driver[property->type];

    argument->length = 1;

    argument->value_index = 0;

    if (!handler(ply, &argument->value)) {

        ply_error(ply, "Error reading '%s' of '%s' number %d",

                property->name, element->name, argument->instance_index);

        return 0;

    }

    if (read_cb && !read_cb(argument)) {

        ply_error(ply, "Aborted by user");

        return 0;

    }

    return 1;

}

static int ply_read_property(p_ply ply, p_ply_element element, 

        p_ply_property property, p_ply_argument argument) {

    if (property->type == PLY_LIST) 

        return ply_read_list_property(ply, element, property, argument);

    else 

        return ply_read_scalar_property(ply, element, property, argument);

}

static int ply_read_element(p_ply ply, p_ply_element element, 

        p_ply_argument argument) {

    int j, k;

    /* for each element of this type */

    for (j = 0; j < element->ninstances; j++) {

        argument->instance_index = j;

        /* for each property */

        for (k = 0; k < element->nproperties; k++) {

            p_ply_property property = &element->property[k];

            argument->property = property;

            argument->pdata = property->pdata;

            argument->idata = property->idata;

            if (!ply_read_property(ply, element, property, argument))

                return 0;

        }

    }

    return 1;

}

static int ply_find_string(const char *item, const char* const list[]) {

    int i;

    assert(item && list);

    for (i = 0; list[i]; i++) 

        if (!strcmp(list[i], item)) return i;