Annotation of embedaddon/libpdel/structs/type/structs_type_union.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/types.h>
! 42:
! 43: #include <stdio.h>
! 44: #include <stdlib.h>
! 45: #include <stdarg.h>
! 46: #include <string.h>
! 47: #include <assert.h>
! 48: #include <errno.h>
! 49:
! 50: #include "structs/structs.h"
! 51: #include "structs/type/array.h"
! 52: #include "structs/type/string.h"
! 53: #include "structs/type/union.h"
! 54: #include "util/typed_mem.h"
! 55:
! 56: /*********************************************************************
! 57: PUBLIC FUNCTIONS
! 58: *********************************************************************/
! 59:
! 60: int
! 61: structs_union_set(const struct structs_type *type, const char *name,
! 62: void *data, const char *field_name)
! 63: {
! 64: const struct structs_ufield *fields;
! 65: const struct structs_ufield *ofield;
! 66: const struct structs_ufield *field;
! 67: struct structs_union *un;
! 68: const char *mtype;
! 69: void *new_un;
! 70:
! 71: /* Find item */
! 72: if ((type = structs_find(type, name, (void **)&data, 0)) == NULL)
! 73: return (-1);
! 74:
! 75: /* Sanity check */
! 76: if (type->tclass != STRUCTS_TYPE_UNION) {
! 77: errno = EINVAL;
! 78: return (-1);
! 79: }
! 80:
! 81: /* Get union info */
! 82: fields = type->args[0].v;
! 83: mtype = type->args[1].s;
! 84: un = data;
! 85:
! 86: /* Find the old field */
! 87: for (ofield = fields; ofield->name != NULL
! 88: && strcmp(ofield->name, un->field_name) != 0; ofield++);
! 89: if (ofield->name == NULL) {
! 90: assert(0);
! 91: errno = EINVAL;
! 92: return (-1);
! 93: }
! 94:
! 95: /* Check if the union is already set to the desired field */
! 96: if (strcmp(un->field_name, field_name) == 0)
! 97: return (0);
! 98:
! 99: /* Find the new field */
! 100: for (field = fields; field->name != NULL
! 101: && strcmp(field->name, field_name) != 0; field++);
! 102: if (field->name == NULL) {
! 103: errno = ENOENT;
! 104: return (-1);
! 105: }
! 106:
! 107: /* Create a new union with the new field type */
! 108: if ((new_un = MALLOC(mtype, field->type->size)) == NULL)
! 109: return (-1);
! 110: if ((*field->type->init)(field->type, new_un) == -1) {
! 111: FREE(mtype, new_un);
! 112: return (-1);
! 113: }
! 114:
! 115: /* Replace existing union with new one having desired type */
! 116: (*ofield->type->uninit)(ofield->type, un->un);
! 117: FREE(mtype, un->un);
! 118: un->un = new_un;
! 119:
! 120: /* Set field name */
! 121: *((const char **)&un->field_name) = field->name;
! 122: return (0);
! 123: }
! 124:
! 125: /*********************************************************************
! 126: UNION TYPE METHODS
! 127: *********************************************************************/
! 128:
! 129: int
! 130: structs_union_init(const struct structs_type *type, void *data)
! 131: {
! 132: const struct structs_ufield *const field = type->args[0].v;
! 133: const char *const mtype = type->args[1].s;
! 134: struct structs_union *const un = data;
! 135:
! 136: /* Sanity */
! 137: if (field->name == NULL) {
! 138: errno = EINVAL;
! 139: return (-1);
! 140: }
! 141: assert(type->tclass == STRUCTS_TYPE_UNION);
! 142:
! 143: /* Allocate union memory */
! 144: if ((un->un = MALLOC(mtype, field->type->size)) == NULL)
! 145: return (-1);
! 146:
! 147: /* Initialize field using first member type */
! 148: if ((*field->type->init)(field->type, un->un) == -1) {
! 149: FREE(mtype, un->un);
! 150: return (-1);
! 151: }
! 152:
! 153: /* Set field name */
! 154: *((const char **)&un->field_name) = field->name;
! 155: return (0);
! 156: }
! 157:
! 158: int
! 159: structs_union_copy(const struct structs_type *type, const void *from, void *to)
! 160: {
! 161: const struct structs_union *const fun = from;
! 162: const struct structs_ufield *const fields = type->args[0].v;
! 163: const struct structs_ufield *field;
! 164: const char *const mtype = type->args[1].s;
! 165: struct structs_union *const tun = to;
! 166:
! 167: /* Sanity check */
! 168: assert(type->tclass == STRUCTS_TYPE_UNION);
! 169:
! 170: /* Find field */
! 171: for (field = fields; field->name != NULL
! 172: && strcmp(fun->field_name, field->name) != 0; field++);
! 173: if (field->name == NULL) {
! 174: assert(0);
! 175: errno = EINVAL;
! 176: return (-1);
! 177: }
! 178:
! 179: /* Allocate copy union */
! 180: if ((tun->un = MALLOC(mtype, field->type->size)) == NULL)
! 181: return (-1);
! 182:
! 183: /* Copy field */
! 184: if ((*field->type->copy)(field->type, fun->un, tun->un) == -1) {
! 185: FREE(mtype, tun->un);
! 186: return (-1);
! 187: }
! 188:
! 189: /* Set field name */
! 190: *((const char **)&tun->field_name) = fun->field_name;
! 191: return (0);
! 192: }
! 193:
! 194: int
! 195: structs_union_equal(const struct structs_type *type,
! 196: const void *v1, const void *v2)
! 197: {
! 198: const struct structs_union *const un1 = v1;
! 199: const struct structs_union *const un2 = v2;
! 200: const struct structs_ufield *const fields = type->args[0].v;
! 201: const struct structs_ufield *field;
! 202:
! 203: /* Sanity check */
! 204: assert(type->tclass == STRUCTS_TYPE_UNION);
! 205:
! 206: /* Check if fields are the same */
! 207: if (strcmp(un1->field_name, un2->field_name) != 0)
! 208: return (0);
! 209:
! 210: /* Find field */
! 211: for (field = fields; field->name != NULL
! 212: && strcmp(un1->field_name, field->name) != 0; field++);
! 213: if (field->name == NULL) {
! 214: assert(0);
! 215: errno = EINVAL;
! 216: return (-1);
! 217: }
! 218:
! 219: /* Compare them */
! 220: return ((*field->type->equal)(field->type, un1->un, un2->un));
! 221: }
! 222:
! 223: int
! 224: structs_union_encode(const struct structs_type *type, const char *mtype,
! 225: struct structs_data *code, const void *data)
! 226: {
! 227: const struct structs_union *const un = data;
! 228: const struct structs_ufield *const fields = type->args[0].v;
! 229: const struct structs_ufield *field;
! 230: struct structs_data ncode;
! 231: struct structs_data fcode;
! 232:
! 233: /* Sanity check */
! 234: assert(type->tclass == STRUCTS_TYPE_UNION);
! 235:
! 236: /* Find field */
! 237: for (field = fields; field->name != NULL
! 238: && strcmp(un->field_name, field->name) != 0; field++);
! 239: if (field->name == NULL) {
! 240: assert(0);
! 241: errno = EINVAL;
! 242: return (-1);
! 243: }
! 244:
! 245: /* Encode name */
! 246: if (structs_string_encode(&structs_type_string,
! 247: TYPED_MEM_TEMP, &ncode, &field->name) == -1)
! 248: return (-1);
! 249:
! 250: /* Encode field */
! 251: if ((*field->type->encode)(field->type,
! 252: TYPED_MEM_TEMP, &fcode, un->un) == -1) {
! 253: FREE(TYPED_MEM_TEMP, ncode.data);
! 254: return (-1);
! 255: }
! 256:
! 257: /* Allocate code buffer */
! 258: code->length = ncode.length + fcode.length;
! 259: if ((code->data = MALLOC(mtype, code->length)) == NULL) {
! 260: FREE(TYPED_MEM_TEMP, fcode.data);
! 261: FREE(TYPED_MEM_TEMP, ncode.data);
! 262: return (-1);
! 263: }
! 264:
! 265: /* Copy encoded name and field */
! 266: memcpy(code->data, ncode.data, ncode.length);
! 267: memcpy(code->data + ncode.length, fcode.data, fcode.length);
! 268:
! 269: /* Done */
! 270: FREE(TYPED_MEM_TEMP, ncode.data);
! 271: FREE(TYPED_MEM_TEMP, fcode.data);
! 272: return (0);
! 273: }
! 274:
! 275: int
! 276: structs_union_decode(const struct structs_type *type, const u_char *code,
! 277: size_t cmax, void *data, char *ebuf, size_t emax)
! 278: {
! 279: const struct structs_ufield *const fields = type->args[0].v;
! 280: const char *const mtype = type->args[1].s;
! 281: struct structs_union *const un = data;
! 282: const struct structs_ufield *field;
! 283: char *field_name;
! 284: int nlen;
! 285: int flen;
! 286:
! 287: /* Sanity check */
! 288: assert(type->tclass == STRUCTS_TYPE_UNION);
! 289:
! 290: /* Decode field name */
! 291: if ((nlen = structs_string_decode(&structs_type_string,
! 292: code, cmax, &field_name, ebuf, emax)) == -1)
! 293: return (-1);
! 294:
! 295: /* Find field */
! 296: for (field = fields; field->name != NULL
! 297: && strcmp(field_name, field->name) != 0; field++);
! 298: if (field->name == NULL) {
! 299: snprintf(ebuf, emax, "unknown union field \"%s\"", field_name);
! 300: FREE(STRUCTS_TYPE_STRING_MTYPE, field_name);
! 301: return (-1);
! 302: }
! 303: FREE(STRUCTS_TYPE_STRING_MTYPE, field_name);
! 304:
! 305: /* Allocate field memory */
! 306: if ((un->un = MALLOC(mtype, field->type->size)) == NULL) {
! 307: memset(un, 0, sizeof(*un));
! 308: return (-1);
! 309: }
! 310:
! 311: /* Decode field */
! 312: if ((flen = (*field->type->decode)(field->type,
! 313: code + nlen, cmax - nlen, un->un, ebuf, emax)) == -1) {
! 314: FREE(mtype, un->un);
! 315: memset(un, 0, sizeof(*un));
! 316: return (-1);
! 317: }
! 318:
! 319: /* Set field name */
! 320: *((const char **)&un->field_name) = field->name;
! 321: return (nlen + flen);
! 322: }
! 323:
! 324: void
! 325: structs_union_free(const struct structs_type *type, void *data)
! 326: {
! 327: const char *const mtype = type->args[1].s;
! 328: const struct structs_union *const un = data;
! 329: const struct structs_ufield *const fields = type->args[0].v;
! 330: const struct structs_ufield *field;
! 331:
! 332: /* Sanity check */
! 333: assert(type->tclass == STRUCTS_TYPE_UNION);
! 334:
! 335: /* Find field */
! 336: for (field = fields; field->name != NULL
! 337: && strcmp(un->field_name, field->name) != 0; field++);
! 338: if (field->name == NULL) {
! 339: assert(0);
! 340: return;
! 341: }
! 342:
! 343: /* Free it */
! 344: (*field->type->uninit)(field->type, un->un);
! 345: FREE(mtype, un->un);
! 346: }
! 347:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to structs_type_union.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / structs / type