aboutsummaryrefslogtreecommitdiff
path: root/xorg-server/hw/xprint/Oid.c
diff options
context:
space:
mode:
Diffstat (limited to 'xorg-server/hw/xprint/Oid.c')
-rw-r--r--xorg-server/hw/xprint/Oid.c3181
1 files changed, 0 insertions, 3181 deletions
diff --git a/xorg-server/hw/xprint/Oid.c b/xorg-server/hw/xprint/Oid.c
deleted file mode 100644
index a2af00108..000000000
--- a/xorg-server/hw/xprint/Oid.c
+++ /dev/null
@@ -1,3181 +0,0 @@
-/*
-(c) Copyright 1996 Hewlett-Packard Company
-(c) Copyright 1996 International Business Machines Corp.
-(c) Copyright 1996 Sun Microsystems, Inc.
-(c) Copyright 1996 Novell, Inc.
-(c) Copyright 1996 Digital Equipment Corp.
-(c) Copyright 1996 Fujitsu Limited
-(c) Copyright 1996 Hitachi, Ltd.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-Except as contained in this notice, the names of the copyright holders shall
-not be used in advertising or otherwise to promote the sale, use or other
-dealings in this Software without prior written authorization from said
-copyright holders.
-*/
-
-#ifdef HAVE_DIX_CONFIG_H
-#include <dix-config.h>
-#endif
-
-#include "attributes.h"
-
-/*
- * XpOidNotify value strings
- */
-#define NOTIFY_EMAIL_STR "{{event-report-job-completed} electronic-mail}"
-#define NOTIFY_NONE_STR "{}"
-
-#define SafeStrLen(s) ((s) ? strlen((s)) : 0)
-
-/*
- * entry type for the object identifier string map
- */
-typedef struct _XpOidStringMapEntry
-{
- const char* string;
- int length;
- int msg_set;
- int msg_number;
- const char* default_message;
-
-} XpOidStringMapEntry;
-
-/*
- * include the auto-generated static XpOidStringMap
- */
-#include "OidStrs.h"
-
-/*
- * XpOid static function declarations
- */
-static XpOid XpOidParse(const char* value_string,
- const char** ptr_return);
-/*
- * XpOidList static function declarations
- */
-static XpOidList* XpOidListParse(const char* value_string,
- const XpOidList* valid_oids,
- const char** ptr_return, int i);
-
-/*
- * XpOidList static function declarations
- */
-static XpOidCardList* XpOidCardListParse(const char* value_string,
- const XpOidCardList* valid_cards,
- const char** ptr_return, int i);
-
-/*
- * XpOidMediumSourceSize static function declarations
- */
-static XpOidMediumSS* MediumSSParse(const char* value_string,
- const XpOidList* valid_trays,
- const XpOidList* valid_medium_sizes,
- const char** ptr_return, int i);
-static XpOidMediumContinuousSize* MediumContinuousSizeParse(const char*,
- const char**);
-static void MediumContinuousSizeDelete(XpOidMediumContinuousSize* me);
-static XpOidMediumDiscreteSizeList* MediumDiscreteSizeListParse(const char*,
- const XpOidList*,
- const char**,
- int i);
-static void MediumDiscreteSizeListDelete(XpOidMediumDiscreteSizeList* list);
-
-static BOOL ParseArea(const char* value_string,
- const char** ptr_return,
- XpOidArea* area_return);
-static BOOL ParseRealRange(const char* value_string,
- const char** ptr_return,
- XpOidRealRange* range_return);
-
-/*
- * XpOidTrayMediumList static function declarations
- */
-static XpOidTrayMediumList* TrayMediumListParse(const char* value_string,
- const XpOidList* valid_trays,
- const char** ptr_return,
- int i);
-static void TrayMediumListValidate(XpOidTrayMediumList* me,
- const XpOidMediumSS* msss);
-
-/*
- * XpOidDocFmt
- */
-static BOOL XpOidDocFmtNext(XpOidDocFmt* doc_fmt,
- const char* value_string,
- const char** ptr_return);
-
-/*
- * XpOidDocFmtListParse
- */
-static XpOidDocFmtList* XpOidDocFmtListParse(const char* value_string,
- const XpOidDocFmtList* valid_fmts,
- const char** ptr_return, int i);
-
-/*
- * misc. parsing static function declarations
- */
-static BOOL ParseBoolValue(const char* value_string,
- const char** ptr_return,
- BOOL* bool_return);
-static BOOL ParseRealValue(const char* value_string,
- const char** ptr_return,
- float* real_return);
-static BOOL ParseSeqEnd(
- const char* value_string,
- const char** ptr_return);
-static BOOL ParseSeqStart(
- const char* value_string,
- const char** ptr_return);
-static BOOL ParseUnspecifiedValue(
- const char* value_string,
- const char** ptr_return);
-static int SpanToken(
- const char* string);
-static int SpanWhitespace(
- const char* string);
-
-/*
- * String comparison function.
- */
-#ifdef HAVE_STRCASECMP
-# define StrnCaseCmp(s1, s2, len) strncasecmp(s1, s2, len)
-#else
-static int StrnCaseCmp(const char *s1, const char *s2, size_t len);
-#endif
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidString
- *
- * Description:
- *
- * Obtain the string representation of an XpOid.
- *
- * Example: XpOidString(xpoid_copy_count) returns "copy-count".
- *
- * Return value:
- *
- * A const pointer to the string.
- */
-const char*
-XpOidString(XpOid xp_oid)
-{
- /*
- * XpOid enum values are index values into the string map
- */
- return XpOidStringMap[xp_oid].string;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidStringLength
- *
- * Description:
- *
- * Obtain the length of the string representation for a given
- * XpOid.
- *
- * Return value:
- *
- * The string length in bytes.
- *
- */
-int
-XpOidStringLength(XpOid xp_oid)
-{
- /*
- * XpOid enum values are index values into the string map
- */
- return XpOidStringMap[xp_oid].length;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidFromString
- *
- * Description:
- *
- * Obtains the XpOid given a string representation of an XpOid.
- *
- * Example: XpOidFromString("copy-count") returns 'xpoid_copy_count'.
- *
- * Return value:
- *
- * The XpOid if successful. 'xpoid_none' if the string pointed to by
- * 'value is not recognized or if 'value' is NULL.
- */
-XpOid
-XpOidFromString(const char* value)
-{
- if(value == (const char*)NULL)
- return xpoid_none;
- else
- return XpOidParse(value, (const char**)NULL);
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidParse
- *
- * Description:
- *
- * Parse the next whitespace-delimited string from 'value_string'
- * updating 'ptr_return' to point to the next unparsed location in
- * 'value_string'. 'ptr_return' can be NULL.
- *
- * Return value:
- *
- * The corresponding XpOid for the parsed name string.
- * A return value of xpoid_none is returned if the parsed name
- * was not a valid oid or if no name was found.
- *
- */
-static XpOid
-XpOidParse(const char* value_string,
- const char** ptr_return)
-{
- const char* ptr;
- int length;
- int i;
- /*
- * skip leading whitespace
- */
- ptr = value_string + SpanWhitespace(value_string);
- /*
- * get the whitespace-delimited token length
- */
- length = SpanToken(ptr);
- /*
- * match the oid string in the map
- */
- for(i = 0; i < XpOidStringMapCount; i++)
- if(length == XpOidStringMap[i].length)
- if(strncmp(ptr, XpOidStringMap[i].string, length) == 0)
- break;
- if(i == XpOidStringMapCount)
- i = xpoid_none;
- /*
- * update the return pointer and return
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = ptr+length;
- return i;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidListNew
- *
- * Description:
- *
- * Creates a new XpOidList initialized from a whitespace-delimited
- * list of recognized string representations of oids. The returned
- * list will contain only oids found within the passed 'valid_oids'
- * XpOidList.
- *
- * Note: One may notice that in order to create an XpOidList with
- * this function, an XpOidList is needed; the 'valid_oids' list
- * is often an statically initialized structure. XpOidListInit
- * can also be used.
- *
- * Return value:
- *
- * NULL if the passed 'value_string' is NULL.
- *
- * If the list indicated by 'value_string' is empty or contains only
- * unrecognized oid string representations, a new XpOidList
- * containing zero elements is returned.
- *
- * If 'valid_oids' is NULL all oids are considered valid.
- *
- */
-XpOidList*
-XpOidListNew(const char* value_string,
- const XpOidList* valid_oids)
-{
- if(value_string == (const char*)NULL)
- return (XpOidList*)NULL;
- else
- {
- const char* ptr;
- return XpOidListParse(value_string, valid_oids, &ptr, 0);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidListDelete
- *
- * Description:
- *
- * Frees the memory allocated for 'list'.
- *
- * Return value:
- *
- * None.
- *
- */
-void
-XpOidListDelete(XpOidList* list)
-{
- if(list != (XpOidList*)NULL)
- {
- XpOidFree((char*)list->list);
- XpOidFree((char*)list);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidListParse
- *
- * Description:
- *
- * This function recursively parses the whitespace-delimited list of
- * oid string representations passed via 'value_string'. Oids are
- * only added to the resulting list if they are found within the
- * passed 'valid_oids' XpOidList.
- *
- * 'ptr_return' points to a char* variable allocated by the
- * caller, and is really only of use during recursion (upon return to
- * the original caller, it will point to the end of value_string).
- *
- * 'value_string' and 'ptr_return' *cannot* be NULL.
- *
- * Return value:
- *
- * A newly allocated and initialized XpOidList.
- *
- * If the list indicated by 'value_string' is empty or contains only
- * unrecognized oid string representations, a new XpOidList
- * containing zero elements is returned.
- *
- * If 'valid_oids' is NULL all oids are considered valid.
- *
- */
-static XpOidList*
-XpOidListParse(const char* value_string,
- const XpOidList* valid_oids,
- const char** ptr_return,
- int i)
-{
- XpOid oid;
- XpOidList* list;
- /*
- * parse the next valid oid out of the value string
- */
- ptr_return = &value_string;
- while(1)
- {
- if(**ptr_return == '\0')
- {
- /*
- * end of value string; stop parsing
- */
- oid = xpoid_none;
- break;
- }
- /*
- * parse the next oid from the value
- */
- oid = XpOidParse(*ptr_return, ptr_return);
- if(xpoid_none == oid)
- {
- /*
- * unrecognized oid; keep parsing
- */
- continue;
- }
- if((const XpOidList*)NULL == valid_oids
- ||
- XpOidListHasOid(valid_oids, oid))
- {
- /*
- * valid oid found; stop parsing
- */
- break;
- }
- }
-
- if(oid == xpoid_none)
- {
- /*
- * end of value string; allocate the list structure
- */
- list = (XpOidList*)XpOidCalloc(1, sizeof(XpOidList));
- list->count = i;
- list->list = (XpOid*)XpOidCalloc(i, sizeof(XpOid));
- }
- else
- {
- /*
- * recurse
- */
- list = XpOidListParse(*ptr_return, valid_oids, ptr_return, i+1);
- /*
- * set the oid in the list
- */
- list->list[i] = oid;
- }
- /*
- * return
- */
- return list;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidListHasOid
- *
- * Description:
- *
- * Determines if 'oid' is an element of 'list'.
- *
- * Return value:
- *
- * xTrue if the oid is found in the list.
- *
- * xFalse if the oid is not in the list, or if 'list' is NULL.
- *
- */
-BOOL
-XpOidListHasOid(const XpOidList* list, XpOid oid)
-{
- int i;
- if(list != (XpOidList*)NULL)
- for(i = 0; i < list->count; i++)
- if(list->list[i] == oid)
- return xTrue;
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidListGetIndex
- *
- * Description:
- *
- * Returns the array index of 'oid' in 'list'
- *
- * Return value:
- *
- * The index of 'oid' in list.
- *
- * -1 if the oid is not in the list, or if 'list' is NULL.
- *
- */
-int
-XpOidListGetIndex(const XpOidList* list, XpOid oid)
-{
- int i;
- if(list != (XpOidList*)NULL)
- for(i = 0; i < list->count; i++)
- if(list->list[i] == oid)
- return i;
- return -1;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidListString
- *
- * Description:
- *
- * Creates a string representation of an XpOidList structure.
- *
- * Return value:
- *
- * A newly allocated
- *
- */
-char*
-XpOidListString(const XpOidList* me)
-{
- int i;
- int length;
- char* str;
- char* ptr;
- /*
- * allocate enough memory for the oid string representations,
- * including intervening whitespace
- */
- for(i = 0, length = 0; i < XpOidListCount(me); i++)
- length += XpOidStringLength(XpOidListGetOid(me, i)) + 1;
- str = XpOidMalloc(length+1);
- /*
- * format the list
- */
- for(i = 0, ptr = str; i < XpOidListCount(me); i++)
-#if defined(sun) && !defined(SVR4)
- {
- sprintf(ptr, "%s ", XpOidString(XpOidListGetOid(me, i)));
- ptr += strlen(ptr);
- }
-#else
- ptr += sprintf(ptr, "%s ", XpOidString(XpOidListGetOid(me, i)));
-#endif
- /*
- * chop trailing whitespace or terminate empty string
- */
- str[length] = '\0';
- /*
- * return
- */
- return str;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidLinkedListNew
- *
- * Description:
- *
- * Creates a new instance of an empty XpOidLinkedList.
- *
- * Return value:
- *
- * The new XpOidLinkedList.
- *
- */
-XpOidLinkedList*
-XpOidLinkedListNew()
-{
- return (XpOidLinkedList*)XpOidCalloc(1, sizeof(XpOidLinkedList));
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidLinkedListDelete
- *
- * Description:
- *
- * Frees the memory allocated for a XpOidLinkedList.
- *
- * Return value:
- *
- * None.
- *
- */
-void
-XpOidLinkedListDelete(XpOidLinkedList* me)
-{
- if(me != (XpOidLinkedList*)NULL)
- {
- while(me->head)
- {
- me->current = me->head;
- me->head = me->current->next;
- XpOidFree((char*)me->current);
- }
- XpOidFree((char*)me);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidLinkedListGetOid
- *
- * Description:
- *
- * Retrieves the oid at position 'i' (zero-based) in the
- * XpOidLinkedList 'me'.
- *
- * Return value:
- *
- * The oid at position 'i'.
- *
- * xpoid_none if the oid was not found, or the list is empty (or if
- * the list contains xpoid_none at position 'i').
- */
-XpOid
-XpOidLinkedListGetOid(XpOidLinkedList* me, int i)
-{
- if(me == (XpOidLinkedList*)NULL || i < 0 || i >= me->count)
- {
- return xpoid_none;
- }
- else
- {
- me->current = me->head;
- while(i--) me->current = me->current->next;
- return me->current->oid;
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidLinkedListAddOid
- *
- * Description:
- *
- * Adds an oid to the end of an XpOidLinkedList.
- *
- * Return value:
- *
- * None.
- *
- */
-void
-XpOidLinkedListAddOid(XpOidLinkedList* me, XpOid oid)
-{
- me->current = (XpOidNode)XpOidCalloc(1, sizeof(struct XpOidNodeStruct));
- me->current->oid = oid;
- ++me->count;
- if(me->tail)
- {
- me->tail->next = me->current;
- me->tail = me->current;
- }
- else
- me->head = me->tail = me->current;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidLinkedListGetIndex
- *
- * Description:
- *
- * Returns the position of an oid in a XpOidLinkedList.
- *
- * Return value:
- *
- * The zero-based position of 'oid' in the list.
- *
- * -1 if the oid is not in the list, or if 'me' is NULL.
- *
- */
-int
-XpOidLinkedListGetIndex(XpOidLinkedList* me, XpOid oid)
-{
- if((XpOidLinkedList*)NULL != me)
- {
- int i = 0;
- me->current = me->head;
- while(me->current)
- if(me->current->oid == oid)
- {
- return i;
- }
- else
- {
- ++i;
- me->current = me->current->next;
- }
- }
- return -1;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidLinkedListHasOid
- *
- * Description:
- *
- * Determines if an oid is an element of a XpOidLinkedList.
- *
- * Return value:
- *
- * xTrue if the oid is found in the list.
- *
- * xFalse if the oid is not in the list, or if 'me' is NULL.
- */
-BOOL
-XpOidLinkedListHasOid(XpOidLinkedList* me,
- XpOid oid)
-{
- if((XpOidLinkedList*)NULL != me)
- {
- me->current = me->head;
- while(me->current)
- if(me->current->oid == oid)
- return xTrue;
- else
- me->current = me->current->next;
- }
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidLinkedListFirstOid
- *
- * Description:
- *
- * Positions the XpOidLinkedList 'current' pointer to the first entry
- * in the list.
- *
- * Return value:
- *
- * The first oid in the list, or xpoid_none if the list NULL or
- * empty.
- */
-XpOid
-XpOidLinkedListFirstOid(XpOidLinkedList* me)
-{
- if((XpOidLinkedList*)NULL != me && (me->current = me->head))
- return me->current->oid;
- else
- return xpoid_none;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidLinkedListNextOid
- *
- * Description:
- *
- * Positions the XpOidLinkedList 'current' pointer to the next entry
- * in the list.
- *
- * Return value:
- *
- * The next oid, or xpoid_none if the end of the list has been
- * reached.
- */
-XpOid
-XpOidLinkedListNextOid(XpOidLinkedList* me)
-{
- if(me->current ? (me->current = me->current->next) : xFalse)
- return me->current->oid;
- else
- return xpoid_none;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidMediumSSNew
- *
- * Description:
- *
- * Creates a new XpOidMediumSS initialized from a string value
- * specified using the medium-source-sizes syntax. See
- * MediumSSParse() below for parsing details.
- *
- * Return value:
- *
- * NULL if the passed 'value_string' is NULL, or if a syntax error is
- * encountered while parsing the medium-source-sizes value.
- *
- */
-XpOidMediumSS*
-XpOidMediumSSNew(const char* value_string,
- const XpOidList* valid_trays,
- const XpOidList* valid_medium_sizes)
-{
- if(value_string == (const char*)NULL)
- return (XpOidMediumSS*)NULL;
- else
- {
- const char* ptr = value_string + SpanWhitespace(value_string);
- if(*ptr == '\0')
- return (XpOidMediumSS*)NULL;
- else
- return MediumSSParse(ptr, valid_trays, valid_medium_sizes,
- &ptr, 0);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: MediumSSParse
- *
- * Description:
- *
- * 'ptr_return' *cannot* be NULL.
- *
- *
- * Return value:
- *
- *
- *
- */
-static XpOidMediumSS*
-MediumSSParse(const char* value_string,
- const XpOidList* valid_trays,
- const XpOidList* valid_medium_sizes,
- const char** ptr_return,
- int i)
-{
- XpOidMediumSS* medium_ss;
- XpOidMediumSourceSize mss;
- /*
- * check for the start of a new MediumSourceSize sequence
- */
- if(ParseSeqStart(value_string, ptr_return))
- {
- /*
- * check for an unspecified tray value
- */
- if(ParseUnspecifiedValue(*ptr_return, ptr_return))
- mss.input_tray = xpoid_unspecified;
- else
- {
- const char* tray_str;
- *ptr_return += SpanWhitespace(*ptr_return);
- tray_str = *ptr_return;
- /*
- * parse out the input tray
- */
- mss.input_tray = XpOidParse(*ptr_return, ptr_return);
- if((const XpOidList*)NULL != valid_trays
- &&
- !XpOidListHasOid(valid_trays, mss.input_tray)
- )
- mss.input_tray = xpoid_none;
- if(xpoid_none == mss.input_tray)
- {
- char* invalid_tray_str;
- int len = *ptr_return - tray_str;
- if(len > 0)
- {
- invalid_tray_str = XpOidMalloc(len+1);
- strncpy(invalid_tray_str, tray_str, len);
- invalid_tray_str[len] = '\0';
- ErrorF("%s\nInvalid tray (%s) found. Will attempt to continue parsing.\n",
- XPMSG_WARN_MSS, invalid_tray_str);
- XpOidFree(invalid_tray_str);
- }
- }
- }
- /*
- * attempt to parse a Continuous MediumSize sequence
- */
- mss.ms.continuous_size =
- MediumContinuousSizeParse(*ptr_return, ptr_return);
- if(mss.ms.continuous_size != (XpOidMediumContinuousSize*)NULL)
- {
- mss.mstag = XpOidMediumSS_CONTINUOUS;
- }
- else
- {
- /*
- * not continuous, try Discrete MediumSize
- */
- mss.ms.discrete =
- MediumDiscreteSizeListParse(*ptr_return, valid_medium_sizes,
- ptr_return, 0);
- if(mss.ms.discrete == (XpOidMediumDiscreteSizeList*)NULL)
- {
- const char* tray_str;
- /*
- * syntax error (MediumDiscreteSizeListParse reports error)
- */
- switch(mss.input_tray)
- {
- case xpoid_none:
- tray_str = "an invalid";
- break;
- case xpoid_unspecified:
- tray_str = "default (tray specifier omitted)";
- break;
- default:
- tray_str = XpOidString(mss.input_tray);
- break;
- }
- ErrorF("%s\nError occurred while parsing medium sizes for %s tray.\n",
- XPMSG_WARN_MSS, tray_str);
- return NULL;
- }
- mss.mstag = XpOidMediumSS_DISCRETE;
- }
- /*
- * parse out the MediumSourceSize sequence end
- */
- if(!ParseSeqEnd(*ptr_return, ptr_return))
- {
- /*
- * syntax error
- */
- ErrorF("%s\nSequence End expected. Unparsed data: %s\n",
- XPMSG_WARN_MSS, *ptr_return);
- return NULL;
- }
- /*
- * recurse to parse the next MediumSourceSize sequence
- */
- medium_ss = MediumSSParse(*ptr_return,
- valid_trays, valid_medium_sizes,
- ptr_return,
- xpoid_none == mss.input_tray ? i : i+1);
- if(medium_ss == (XpOidMediumSS*)NULL
- ||
- xpoid_none == mss.input_tray)
- {
- /*
- * syntax error or invalid tray - clean up
- */
- switch(mss.mstag)
- {
- case XpOidMediumSS_CONTINUOUS:
- MediumContinuousSizeDelete(mss.ms.continuous_size);
- break;
- case XpOidMediumSS_DISCRETE:
- MediumDiscreteSizeListDelete(mss.ms.discrete);
- break;
- }
- if(medium_ss == (XpOidMediumSS*)NULL)
- /*
- * syntax error - return
- */
- return NULL;
- }
- if(xpoid_none != mss.input_tray)
- {
- /*
- * copy the current MediumSourceSize into the array
- */
- memmove((medium_ss->mss)+i, &mss, sizeof(XpOidMediumSourceSize));
- }
- }
- else
- {
- /*
- * MediumSourceSize sequence start not found
- */
- if(**ptr_return == '\0')
- {
- if(0 == i)
- {
- ErrorF("%s\nNo valid trays found.\n", XPMSG_WARN_MSS);
- return NULL;
- }
- /*
- * end of value string; allocate the MediumSS structure
- */
- medium_ss = (XpOidMediumSS*)XpOidCalloc(1, sizeof(XpOidMediumSS));
- medium_ss->count = i;
- medium_ss->mss = (XpOidMediumSourceSize*)
- XpOidCalloc(i, sizeof(XpOidMediumSourceSize));
- }
- else
- {
- /*
- * syntax error
- */
- ErrorF("%s\nSequence Start expected.\nunparsed data: %s\n",
- XPMSG_WARN_MSS, *ptr_return);
- return NULL;
- }
- }
- return medium_ss;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidMediumSSDelete
- *
- * Description:
- *
- *
- *
- * Return value:
- *
- *
- *
- */
-void
-XpOidMediumSSDelete(XpOidMediumSS* me)
-{
- if(me != (XpOidMediumSS*)NULL)
- {
- int i;
- for(i = 0; i < me->count; i++)
- {
- switch((me->mss)[i].mstag)
- {
- case XpOidMediumSS_CONTINUOUS:
- MediumContinuousSizeDelete((me->mss)[i].ms.continuous_size);
- break;
- case XpOidMediumSS_DISCRETE:
- MediumDiscreteSizeListDelete((me->mss)[i].ms.discrete);
- break;
- }
- }
- XpOidFree((char*)me);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidMediumSSHasSize
- *
- * Description:
- *
- *
- *
- * Return value:
- *
- *
- *
- */
-BOOL
-XpOidMediumSSHasSize(XpOidMediumSS* me, XpOid page_size)
-{
- int i_mss, i_ds;
- XpOidMediumDiscreteSizeList* ds_list;
-
- if(me != (XpOidMediumSS*)NULL && page_size != xpoid_none)
- for(i_mss = 0; i_mss < me->count; i_mss++)
- {
- switch((me->mss)[i_mss].mstag)
- {
- case XpOidMediumSS_DISCRETE:
- ds_list = (me->mss)[i_mss].ms.discrete;
- for(i_ds = 0; i_ds < ds_list->count; i_ds++)
- if(page_size == (ds_list->list)[i_ds].page_size)
- return xTrue;
- break;
-
- case XpOidMediumSS_CONTINUOUS:
- /*
- * unsupported
- */
- break;
- }
- }
- /*
- * return
- */
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidMediumSSString
- *
- * Description:
- *
- * Creates a string representation of an XpOidMediumSS structure.
- *
- * Return value:
- *
- * A newly allocated
- *
- */
-char* XpOidMediumSSString(const XpOidMediumSS* me)
-{
- int itray, isize;
- int valid_size_count;
- int length;
- char* str;
- char* ptr;
- XpOidMediumDiscreteSize* ds;
- char buf[128];
- /*
- * determine the size of the string representation
- */
- for(itray = 0, length = 0; itray < XpOidMediumSSCount(me); itray++)
- {
- if(xpoid_none == me->mss[itray].input_tray
- ||
- XpOidMediumSS_CONTINUOUS == me->mss[itray].mstag)
- {
- /*
- * skip invalid tray or unsupported continuous size spec
- */
- continue;
- }
- for(isize = 0, valid_size_count = 0;
- isize < me->mss[itray].ms.discrete->count;
- isize++)
- {
- ds = me->mss[itray].ms.discrete->list+isize;
- if(ds->page_size == xpoid_none)
- continue;
- ++valid_size_count;
- length += XpOidStringLength(ds->page_size);
- length += ds->long_edge_feeds ? 4 : 5; /* "True" or "False" */
-#if defined(sun) && !defined(SVR4)
- sprintf(buf, "{%.4f %.4f %.4f %.4f}",
- ds->assured_reproduction_area.minimum_x,
- ds->assured_reproduction_area.maximum_x,
- ds->assured_reproduction_area.minimum_y,
- ds->assured_reproduction_area.maximum_y);
- length += strlen(buf);
-#else
- length += sprintf(buf, "{%.4f %.4f %.4f %.4f}",
- ds->assured_reproduction_area.minimum_x,
- ds->assured_reproduction_area.maximum_x,
- ds->assured_reproduction_area.minimum_y,
- ds->assured_reproduction_area.maximum_y);
-#endif
- length += 5; /* "{<size> <feed> <area>} " */
- }
- if(valid_size_count == 0)
- {
- /*
- * no valid sizes, skip
- */
- continue;
- }
- if(xpoid_unspecified == me->mss[itray].input_tray)
- length += 2; /* "''" */
- else
- length += XpOidStringLength(me->mss[itray].input_tray);
- length += 4; /* "{<tray> <sizes>} " */
- }
- /*
- * allocate
- */
- str = XpOidMalloc(length+1);
- /*
- * format
- */
- for(itray = 0, ptr = str; itray < XpOidMediumSSCount(me); itray++)
- {
- if(xpoid_none == me->mss[itray].input_tray
- ||
- XpOidMediumSS_CONTINUOUS == me->mss[itray].mstag)
- {
- /*
- * skip invalid tray or unsupported continuous size spec
- */
- continue;
- }
- /*
- * check to ensure all of the specified sizes are valid
- */
- for(isize = 0, valid_size_count = 0;
- isize < me->mss[itray].ms.discrete->count;
- isize++)
- {
- ds = me->mss[itray].ms.discrete->list+isize;
- if(ds->page_size != xpoid_none)
- ++valid_size_count;
- }
- if(valid_size_count == 0)
- {
- /*
- * no valid sizes, skip
- */
- continue;
- }
-
- if(xpoid_unspecified == me->mss[itray].input_tray)
- {
-#if defined(sun) && !defined(SVR4)
- sprintf(ptr, "{'' ");
- ptr += strlen(ptr);
-#else
- ptr += sprintf(ptr, "{'' ");
-#endif
- }
- else
- {
-#if defined(sun) && !defined(SVR4)
- sprintf(ptr, "{%s ", XpOidString(me->mss[itray].input_tray));
- ptr += strlen(ptr);
-#else
- ptr += sprintf(ptr, "{%s ",
- XpOidString(me->mss[itray].input_tray));
-#endif
- }
- for(isize = 0; isize < me->mss[itray].ms.discrete->count; isize++)
- {
- ds = me->mss[itray].ms.discrete->list+isize;
- if(ds->page_size != xpoid_none)
-#if defined(sun) && !defined(SVR4)
- {
- sprintf(ptr, "{%s %s {%.4f %.4f %.4f %.4f}} ",
- XpOidString(ds->page_size),
- ds->long_edge_feeds ? "True" : "False",
- ds->assured_reproduction_area.minimum_x,
- ds->assured_reproduction_area.maximum_x,
- ds->assured_reproduction_area.minimum_y,
- ds->assured_reproduction_area.maximum_y);
- ptr += strlen(ptr);
- }
-#else
- ptr += sprintf(ptr, "{%s %s {%.4f %.4f %.4f %.4f}} ",
- XpOidString(ds->page_size),
- ds->long_edge_feeds ? "True" : "False",
- ds->assured_reproduction_area.minimum_x,
- ds->assured_reproduction_area.maximum_x,
- ds->assured_reproduction_area.minimum_y,
- ds->assured_reproduction_area.maximum_y);
-#endif
- }
-#if defined(sun) && !defined(SVR4)
- sprintf(ptr, "} ");
- ptr += strlen(ptr);
-#else
- ptr += sprintf(ptr, "} ");
-#endif
- }
- /*
- * chop trailing whitespace or terminate empty string
- */
- str[length] = '\0';
- /*
- * return
- */
- return str;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: MediumContinuousSizeParse
- *
- * Description:
- *
- * 'ptr_return' *cannot* be NULL.
- *
- *
- * Return value:
- *
- *
- *
- */
-static XpOidMediumContinuousSize*
-MediumContinuousSizeParse(const char* value_string,
- const char** ptr_return)
-{
- const char* first_nonws_ptr;
- XpOidMediumContinuousSize* mcs = NULL;
- /*
- * skip leading whitespace
- */
- first_nonws_ptr = value_string + SpanWhitespace(value_string);
- /*
- * parse out the MediumSize sequence start char
- */
- if(!ParseSeqStart(first_nonws_ptr, ptr_return))
- goto MediumContinuousSizeParse_error;
- /*
- * peek ahead to see if it looks like we actually have a continuous
- * size spec (looking for the sequence start char on the 1st range spec)
- */
- if(!ParseSeqStart(*ptr_return, (const char**)NULL))
- goto MediumContinuousSizeParse_error;
- /*
- * Ok, let's go for it
- */
- mcs = (XpOidMediumContinuousSize*)
- XpOidCalloc(1, sizeof(XpOidMediumContinuousSize));
- /*
- * "range across the feed direction"
- */
- if(!ParseRealRange(*ptr_return, ptr_return, &mcs->range_across_feed))
- goto MediumContinuousSizeParse_error;
- /*
- * "increment across the feed direction" (optional, default 0)
- */
- if(!ParseUnspecifiedValue(*ptr_return, ptr_return))
- if(!ParseRealValue(*ptr_return, ptr_return,
- &mcs->increment_across_feed))
- goto MediumContinuousSizeParse_error;
- /*
- * "range in the feed direction"
- */
- if(!ParseRealRange(*ptr_return, ptr_return, &mcs->range_in_feed))
- goto MediumContinuousSizeParse_error;
- /*
- * "increment in the feed direction" (optional, default 0)
- */
- if(!ParseUnspecifiedValue(*ptr_return, ptr_return))
- if(!ParseRealValue(*ptr_return, ptr_return,
- &mcs->increment_in_feed))
- goto MediumContinuousSizeParse_error;
- /*
- * "long edge feeds" flag (default TRUE)
- */
- if(ParseUnspecifiedValue(*ptr_return, ptr_return))
- mcs->long_edge_feeds = xTrue;
- else
- if(!ParseBoolValue(*ptr_return, ptr_return, &mcs->long_edge_feeds))
- goto MediumContinuousSizeParse_error;
- /*
- * "generic assured reproduction area"
- */
- if(!ParseArea(*ptr_return, ptr_return, &mcs->assured_reproduction_area))
- goto MediumContinuousSizeParse_error;
- /*
- * parse out the MediumSize sequence end character
- */
- if(!ParseSeqEnd(*ptr_return, ptr_return))
- goto MediumContinuousSizeParse_error;
- /*
- * return
- */
- return mcs;
-
-
- MediumContinuousSizeParse_error:
- /*
- * syntax error - don't log since this function may be called
- * as a lookahead
- */
- *ptr_return = first_nonws_ptr;
- XpOidFree((char*)mcs);
- return NULL;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: MediumContinuousSizeDelete
- *
- * Description:
- *
- * 'ptr_return' *cannot* be NULL.
- *
- *
- * Return value:
- *
- *
- *
- */
-static void
-MediumContinuousSizeDelete(XpOidMediumContinuousSize* me)
-{
- XpOidFree((char*)me);
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: MediumDiscreteSizeListParse
- *
- * Description:
- *
- * 'ptr_return' *cannot* be NULL.
- *
- * Return value:
- *
- *
- *
- */
-static XpOidMediumDiscreteSizeList*
-MediumDiscreteSizeListParse(const char* value_string,
- const XpOidList* valid_medium_sizes,
- const char** ptr_return,
- int i)
-{
- XpOidMediumDiscreteSizeList* list;
- XpOidMediumDiscreteSize mds;
- /*
- * check for the start of a new MediumSize sequence
- */
- if(ParseSeqStart(value_string, ptr_return))
- {
- /*
- * "page size"
- */
- mds.page_size = XpOidParse(*ptr_return, ptr_return);
- if((const XpOidList*)NULL != valid_medium_sizes
- &&
- !XpOidListHasOid(valid_medium_sizes, mds.page_size)
- )
- mds.page_size = xpoid_none;
- /*
- * "long edge feeds" flag (default TRUE)
- */
- if(ParseUnspecifiedValue(*ptr_return, ptr_return))
- mds.long_edge_feeds = xTrue;
- else
- if(!ParseBoolValue(*ptr_return, ptr_return,
- &mds.long_edge_feeds))
- {
- /*
- * syntax error
- */
- ErrorF("%s\nBoolean expected.\nunparsed data: %s\n",
- XPMSG_WARN_MSS, *ptr_return);
- return (XpOidMediumDiscreteSizeList*)NULL;
- }
- /*
- * "assured reproduction area"
- */
- if(!ParseArea(*ptr_return, ptr_return,
- &mds.assured_reproduction_area))
- {
- /*
- * syntax error
- */
- ErrorF("%s\nArea specification error.\nunparsed data: %s\n",
- XPMSG_WARN_MSS, *ptr_return);
- return (XpOidMediumDiscreteSizeList*)NULL;
- }
- /*
- * parse out the MediumSize sequence end character
- */
- if(!ParseSeqEnd(*ptr_return, ptr_return))
- {
- ErrorF("%s\nSequence End expected. Unparsed data: %s\n",
- XPMSG_WARN_MSS, *ptr_return);
- return (XpOidMediumDiscreteSizeList*)NULL;
- }
- /*
- * recurse to parse the next Discrete MediumSize sequence
- */
- if(mds.page_size == xpoid_none)
- {
- list = MediumDiscreteSizeListParse(*ptr_return, valid_medium_sizes,
- ptr_return, i);
- }
- else
- {
- list = MediumDiscreteSizeListParse(*ptr_return, valid_medium_sizes,
- ptr_return, i+1);
- if(list != (XpOidMediumDiscreteSizeList*)NULL)
- {
- /*
- * copy the current discrete MediumSize into the list
- */
- memmove((list->list)+i, &mds, sizeof(XpOidMediumDiscreteSize));
- }
- }
- }
- else
- {
- /*
- * MediumSize sequence start not found; end of the discrete sizes
- * list
- */
- if(0 == i)
- {
- ErrorF("%s\nNo valid medium sizes found for tray.\n",
- XPMSG_WARN_MSS);
- return (XpOidMediumDiscreteSizeList*)NULL;
- }
- list = (XpOidMediumDiscreteSizeList*)
- XpOidCalloc(1, sizeof(XpOidMediumDiscreteSizeList));
- list->count = i;
- list->list = (XpOidMediumDiscreteSize*)
- XpOidCalloc(i, sizeof(XpOidMediumDiscreteSize));
- }
- return list;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: MediumDiscreteSizeListDelete
- *
- * Description:
- *
- *
- *
- * Return value:
- *
- *
- *
- */
-static void
-MediumDiscreteSizeListDelete(XpOidMediumDiscreteSizeList* list)
-{
- if(list != (XpOidMediumDiscreteSizeList*)NULL)
- {
- XpOidFree((char*)list->list);
- XpOidFree((char*)list);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidTrayMediumListNew
- *
- * Description:
- *
- * Only need the valid trays; validation requires bumping up against
- * msss using TrayMediumListValidate; this needs valid trays
- * because of unspecified trays ion msss, but
- * TrayMediumListValidate will take care of invalid sizes...
- *
- * Return value:
- *
- *
- *
- */
-XpOidTrayMediumList*
-XpOidTrayMediumListNew(const char* value_string,
- const XpOidList* valid_trays,
- const XpOidMediumSS* msss)
-{
- if(value_string == (const char*)NULL)
- return (XpOidTrayMediumList*)NULL;
- else
- {
- const char* ptr;
- XpOidTrayMediumList* me;
- me = TrayMediumListParse(value_string, valid_trays, &ptr, 0);
- if((XpOidTrayMediumList*)NULL != me)
- TrayMediumListValidate(me, msss);
- return me;
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidTrayMediumListDelete
- *
- * Description:
- *
- *
- *
- * Return value:
- *
- *
- *
- */
-void
-XpOidTrayMediumListDelete(XpOidTrayMediumList* list)
-{
- if(list != (XpOidTrayMediumList*)NULL)
- {
- XpOidFree((char*)list->list);
- XpOidFree((char*)list);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: TrayMediumListParse
- *
- * Description:
- *
- * 'ptr_return' *cannot* be NULL.
- *
- * Return value:
- *
- *
- *
- */
-static XpOidTrayMediumList*
-TrayMediumListParse(const char* value_string,
- const XpOidList* valid_trays,
- const char** ptr_return, int i)
-{
- XpOidTrayMedium tm;
- XpOidTrayMediumList* list;
- /*
- * check for the start of a new InputTrayMedium sequence
- */
- if(ParseSeqStart(value_string, ptr_return))
- {
- /*
- * "input tray"
- */
- tm.input_tray = XpOidParse(*ptr_return, ptr_return);
- if((XpOidList*)NULL != valid_trays
- &&
- !XpOidListHasOid(valid_trays, tm.input_tray)
- )
- tm.input_tray = xpoid_none;
- /*
- * "medium"
- */
- tm.medium = XpOidParse(*ptr_return, ptr_return);
- /*
- * parse out the InputTrayMedium sequence end character
- */
- if(!ParseSeqEnd(*ptr_return, ptr_return))
- {
- ErrorF("%s\n", XPMSG_WARN_ITM);
- return NULL;
- }
- /*
- * recurse to parse the next InputTrayMedium sequence
- */
- list = TrayMediumListParse(*ptr_return, valid_trays, ptr_return, i+1);
- if(list != (XpOidTrayMediumList*)NULL)
- {
- /*
- * copy the current InputTrayMedium into the list
- */
- memmove((list->list)+i, &tm, sizeof(XpOidTrayMedium));
- }
- }
- else
- {
- /*
- * InputTrayMedium sequence start not found
- */
- if(**ptr_return == '\0')
- {
- /*
- * end of the list
- */
- list = (XpOidTrayMediumList*)
- XpOidCalloc(1, sizeof(XpOidTrayMediumList));
- list->count = i;
- list->list = (XpOidTrayMedium*)
- XpOidCalloc(i, sizeof(XpOidTrayMedium));
- }
- else
- {
- /*
- * syntax error
- */
- ErrorF("%s\n", XPMSG_WARN_ITM);
- return NULL;
- }
- }
- /*
- * return
- */
- return list;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: TrayMediumListValidate
- *
- * Description:
- *
- * Validate the input-trays-medium list based on a passed
- * medium-source-sizes-supported structure. The validated
- * input-trays-medium list will have the same number of entries upon
- * return from this function. Invalid entries are indicated by
- * setting the tray specification to xpoid_none.
- *
- * Return value:
- *
- * None.
- *
- */
-static void
-TrayMediumListValidate(XpOidTrayMediumList* me,
- const XpOidMediumSS* msss)
-{
- int i_mss, i_ds, i_itm;
- XpOid current_tray, current_medium;
- XpOidMediumDiscreteSizeList* unspecified_tray_ds;
- XpOidMediumDiscreteSizeList* tray_ds;
-
- if(msss == (XpOidMediumSS*)NULL
- ||
- me == (XpOidTrayMediumList*)NULL)
- {
- return;
- }
- /*
- * loop through the input trays medium list
- */
- for(i_itm = 0; i_itm < XpOidTrayMediumListCount(me); i_itm++)
- {
- current_tray = XpOidTrayMediumListTray(me, i_itm);
- if(current_tray == xpoid_none)
- continue;
- current_medium = XpOidTrayMediumListMedium(me, i_itm);
- if(current_medium == xpoid_none)
- {
- /*
- * no medium; invalidate this entry
- */
- me->list[i_itm].input_tray = xpoid_none;
- continue;
- }
- /*
- * loop through the MediumSourceSizes, looking for an appropriate
- * discrete sizes spec for the current tray
- */
- unspecified_tray_ds = (XpOidMediumDiscreteSizeList*)NULL;
- tray_ds = (XpOidMediumDiscreteSizeList*)NULL;
- for(i_mss = 0;
- i_mss < msss->count &&
- tray_ds == (XpOidMediumDiscreteSizeList*)NULL;
- i_mss++)
- {
- switch((msss->mss)[i_mss].mstag)
- {
- case XpOidMediumSS_DISCRETE:
- if((msss->mss)[i_mss].input_tray == current_tray)
- tray_ds = (msss->mss)[i_mss].ms.discrete;
- else if((msss->mss)[i_mss].input_tray == xpoid_unspecified)
- unspecified_tray_ds = (msss->mss)[i_mss].ms.discrete;
- break;
-
- case XpOidMediumSS_CONTINUOUS:
- /*
- * unsupported
- */
- break;
- }
- }
- /*
- * if the tray was not matched, use the unspecified tray size
- * list
- */
- if(tray_ds == (XpOidMediumDiscreteSizeList*)NULL)
- {
- if(unspecified_tray_ds == (XpOidMediumDiscreteSizeList*)NULL)
- {
- /*
- * not even an unspecified tray, invalidate this
- * input-trays-medium entry.
- */
- me->list[i_itm].input_tray = xpoid_none;
- continue;
- }
- else
- tray_ds = unspecified_tray_ds;
- }
- /*
- * loop through the discrete sizes list, looking for a size that
- * matches the medium for the current input tray
- */
- for(i_ds = 0; i_ds < tray_ds->count; i_ds++)
- {
- /*
- * check to see if the current input tray's medium size
- * matches the current discrete size
- *
- * Note: in the CDEnext SI, medium identifiers coincide with
- * medium-size identifiers. If the DP-Medium object is
- * ever implemented, this check would need to be
- * changed so that the input tray's medium size is
- * obtained from the indicated Medium object, and not
- * inferred from the medium identifier itself.
- */
- if((tray_ds->list)[i_ds].page_size == current_medium)
- {
- /*
- * The current input tray's medium size matches the
- * current discrete medium size.
- */
- break;
- }
- }
- if(i_ds == tray_ds->count)
- {
- /*
- * The current input tray's medium size was not found in the
- * discrete size list; mark the input tray medium entry
- * invalid
- */
- me->list[i_itm].input_tray = xpoid_none;
- }
-
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidTrayMediumListString
- *
- * Description:
- *
- * Creates a string representation of an XpOidTrayMediumList structure.
- *
- * Return value:
- *
- * A newly allocated
- *
- */
-char* XpOidTrayMediumListString(const XpOidTrayMediumList* me)
-{
- int i;
- int length;
- char* str;
- char* ptr;
- XpOid tray;
- /*
- * allocate enough memory for the string representation,
- * including intervening delimiters and whitespace
- */
- for(i = 0, length = 0; i < XpOidTrayMediumListCount(me); i++)
- {
- tray = XpOidTrayMediumListTray(me, i);
- if(xpoid_none != tray)
- {
- length += XpOidStringLength(tray);
- length += XpOidStringLength(XpOidTrayMediumListMedium(me, i));
- length += 4;
- }
- }
- str = XpOidMalloc(length+1);
- /*
- * format the list
- */
- for(i = 0, ptr = str; i < XpOidTrayMediumListCount(me); i++)
- {
- tray = XpOidTrayMediumListTray(me, i);
- if(xpoid_none != tray)
- {
-#if defined(sun) && !defined(SVR4)
- sprintf(ptr, "{%s %s} ",
- XpOidString(tray),
- XpOidString(XpOidTrayMediumListMedium(me, i)));
- ptr += strlen(ptr);
-#else
- ptr += sprintf(ptr, "{%s %s} ",
- XpOidString(tray),
- XpOidString(XpOidTrayMediumListMedium(me, i)));
-#endif
- }
- }
- /*
- * chop trailing whitespace or terminate empty string
- */
- str[length] = '\0';
- /*
- * return
- */
- return str;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidTrayMediumListHasTray
- *
- * Description:
- *
- * Determines if 'tray' is found in 'list'.
- *
- * Return value:
- *
- * xTrue if the tray is found in the list.
- *
- * xFalse if the tray is not in the list, or if 'list' is NULL.
- *
- */
-BOOL
-XpOidTrayMediumListHasTray(const XpOidTrayMediumList* list, XpOid tray)
-{
- int i;
- if(list != (XpOidTrayMediumList*)NULL && tray != xpoid_none)
- for(i = 0; i < list->count; i++)
- if(XpOidTrayMediumListTray(list, i) == tray)
- return xTrue;
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: ParseArea
- *
- * Description:
- *
- * Skips leading whitespace and parses out and returns a XpOidArea.
- *
- * Return value:
- *
- * xTrue if the XpOidArea was successfully parsed. ptr_return is
- * updated to point to location where the parsing ended.
- *
- * xFalse if a XpOidArea was not found; ptr_return is updated
- * to point to the first non-whitespace char in value_string.
- *
- */
-static BOOL
-ParseArea(const char* value_string,
- const char** ptr_return,
- XpOidArea* area_return)
-{
- const char* first_nonws_ptr;
- const char* ptr;
- /*
- * skip leading whitespace
- */
- first_nonws_ptr = value_string + SpanWhitespace(value_string);
- /*
- * parse out the area sequence start
- */
- if(!ParseSeqStart(first_nonws_ptr, &ptr))
- goto ParseArea_error;
- /*
- * parse the minimum x value
- */
- if(!ParseRealValue(ptr, &ptr,
- area_return ? &area_return->minimum_x : NULL))
- goto ParseArea_error;
- /*
- * parse the maximum x value
- */
- if(!ParseRealValue(ptr, &ptr,
- area_return ? &area_return->maximum_x : NULL))
- goto ParseArea_error;
- /*
- * parse the minimum y value
- */
- if(!ParseRealValue(ptr, &ptr,
- area_return ? &area_return->minimum_y : NULL))
- goto ParseArea_error;
- /*
- * parse the maximum y value
- */
- if(!ParseRealValue(ptr, &ptr,
- area_return ? &area_return->maximum_y : NULL))
- goto ParseArea_error;
- /*
- * parse out the area sequence end
- */
- if(!ParseSeqEnd(ptr, &ptr))
- goto ParseArea_error;
- /*
- * update the return pointer
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = ptr;
- /*
- * return
- */
- return xTrue;
-
-
- ParseArea_error:
- /*
- * syntax error
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = first_nonws_ptr;
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: ParseRealRange
- *
- * Description:
- *
- * Skips leading whitespace and parses out and returns a
- * XpOidRealRange.
- *
- * Return value:
- *
- * xTrue if the XpOidRealRange was successfully
- * parsed. ptr_return is updated to point to location where the
- * parsing ended.
- *
- * xFalse if a XpOidRealRange was not found; ptr_return is
- * updated to point to the first non-whitespace char in value_string.
- *
- */
-static BOOL
-ParseRealRange(const char* value_string,
- const char** ptr_return,
- XpOidRealRange* range_return)
-{
- const char* first_nonws_ptr;
- const char* ptr;
- /*
- * skip leading whitespace
- */
- first_nonws_ptr = value_string + SpanWhitespace(value_string);
- /*
- * parse out the range sequence start
- */
- if(!ParseSeqStart(first_nonws_ptr, &ptr))
- goto ParseRealRange_error;
- /*
- * parse the lower bound
- */
- if(!ParseRealValue(ptr, &ptr,
- range_return ? &range_return->lower_bound : NULL))
- goto ParseRealRange_error;
- /*
- * parse the upper bound
- */
- if(!ParseRealValue(ptr, &ptr,
- range_return ? &range_return->upper_bound : NULL))
- goto ParseRealRange_error;
- /*
- * parse out the range sequence end
- */
- if(!ParseSeqEnd(ptr, &ptr))
- goto ParseRealRange_error;
- /*
- * update the return pointer
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = ptr;
- /*
- * return
- */
- return xTrue;
-
-
- ParseRealRange_error:
- /*
- * syntax error
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = first_nonws_ptr;
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidNotifyParse
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-XpOidNotify XpOidNotifyParse(const char* value_string)
-{
- const char* ptr = value_string;
-
- if(value_string == (const char*)NULL)
- return XPOID_NOTIFY_NONE;
- /*
- * look for an event handling profile sequence start
- */
- if(!ParseSeqStart(value_string, &ptr))
- {
- if('\0' == *ptr)
- /*
- * empty value is valid
- */
- return XPOID_NOTIFY_NONE;
- else
- return XPOID_NOTIFY_UNSUPPORTED;
- }
- /*
- * look for an event set sequence start
- */
- if(!ParseSeqStart(ptr, &ptr))
- {
- /*
- * check for an empty event handling profile
- */
- if(ParseSeqEnd(ptr, &ptr))
- {
- ptr += SpanWhitespace(ptr);
- if(*ptr == '\0')
- /*
- * valid empty event handling profile sequence
- */
- return XPOID_NOTIFY_NONE;
- }
- return XPOID_NOTIFY_UNSUPPORTED;
- }
- /*
- * the only event in the set should be report job completed
- */
- if(xpoid_val_event_report_job_completed != XpOidParse(ptr, &ptr))
- return XPOID_NOTIFY_UNSUPPORTED;
- /*
- * event set sequence end
- */
- if(!ParseSeqEnd(ptr, &ptr))
- return XPOID_NOTIFY_UNSUPPORTED;
- /*
- * delivery method of electronic mail
- */
- if(xpoid_val_delivery_method_electronic_mail != XpOidParse(ptr, &ptr))
- return XPOID_NOTIFY_UNSUPPORTED;
- /*
- * event handling profile sequence end
- */
- if(!ParseSeqEnd(ptr, &ptr))
- return XPOID_NOTIFY_UNSUPPORTED;
- /*
- * end of value
- */
- ptr += SpanWhitespace(ptr);
- if('\0' == *ptr)
- /*
- * valid supported notification profile
- */
- return XPOID_NOTIFY_EMAIL;
- else
- return XPOID_NOTIFY_UNSUPPORTED;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidNotifyString
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-const char* XpOidNotifyString(XpOidNotify notify)
-{
- switch(notify)
- {
- case XPOID_NOTIFY_NONE:
- return NOTIFY_NONE_STR;
- case XPOID_NOTIFY_EMAIL:
- return NOTIFY_EMAIL_STR;
- case XPOID_NOTIFY_UNSUPPORTED:
- return (const char *)NULL;
- }
-
- ErrorF("XpOidNotifyString: Unsupported notify=%ld\n", (long)notify);
- return (const char *)NULL;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtNew
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-XpOidDocFmt*
-XpOidDocFmtNew(const char* value_string)
-{
- XpOidDocFmt* doc_fmt;
- const char* ptr;
-
- if((const char*)NULL == value_string)
- return (XpOidDocFmt*)NULL;
- ptr = value_string + SpanWhitespace(value_string);
- if('\0' == *ptr)
- return (XpOidDocFmt*)NULL;
- /*
- * get the document format from the value string
- */
- doc_fmt = (XpOidDocFmt*)XpOidCalloc(1, sizeof(XpOidDocFmt));
- if(xTrue == XpOidDocFmtNext(doc_fmt, ptr, &ptr))
- {
- /*
- * verify that the document format is the only value specified
- */
- ptr += SpanWhitespace(ptr);
- if('\0' == *ptr)
- /*
- * valid document-format value
- */
- return doc_fmt;
- }
- /*
- * invalid
- */
- XpOidDocFmtDelete(doc_fmt);
- ErrorF("%s\n", XPMSG_WARN_DOC_FMT);
- return (XpOidDocFmt*)NULL;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtDelete
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-void
-XpOidDocFmtDelete(XpOidDocFmt* doc_fmt)
-{
- if((XpOidDocFmt*)NULL != doc_fmt)
- {
- XpOidFree(doc_fmt->format);
- XpOidFree(doc_fmt->variant);
- XpOidFree(doc_fmt->version);
- XpOidFree(doc_fmt);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtString
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-char*
-XpOidDocFmtString(XpOidDocFmt* doc_fmt)
-{
- if((XpOidDocFmt*)NULL != doc_fmt)
- {
- if((char*)NULL != doc_fmt->format)
- {
- char* str = XpOidMalloc(1+SafeStrLen(doc_fmt->format)+
- 1+SafeStrLen(doc_fmt->variant)+
- 1+SafeStrLen(doc_fmt->version)+
- 1+1);
- sprintf(str, "{%s %s %s}", doc_fmt->format,
- (char*)NULL != doc_fmt->variant ? doc_fmt->variant : "",
- (char*)NULL != doc_fmt->version ? doc_fmt->version : "");
- return str;
- }
- }
- return (char*)NULL;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtNext
- *
- * Description:
- *
- * Assumes non-NULL value string.
- *
- * Return value:
- *
- *
- */
-static BOOL
-XpOidDocFmtNext(XpOidDocFmt* doc_fmt,
- const char* value_string,
- const char** ptr_return)
-{
- const char* ptr;
- const char* first_nonws_ptr;
- const char* format;
- const char* variant;
- const char* version;
- int format_len;
- int variant_len;
- int version_len;
- /*
- * skip leading whitespace
- */
- ptr = value_string + SpanWhitespace(value_string);
- first_nonws_ptr = ptr;
- /*
- * sequence start
- */
- if(!ParseSeqStart(ptr, &ptr))
- goto XpOidDocFmtNext_error;
- /*
- * skip whitepace to the start of the document format, and save the
- * location
- */
- ptr += SpanWhitespace(ptr);
- format = ptr;
- /*
- * document format
- */
- if(0 == (format_len = SpanToken(ptr)))
- goto XpOidDocFmtNext_error;
- ptr += format_len;
- /*
- * optional variant
- */
- ptr += SpanWhitespace(ptr);
- variant = ptr;
- if(0 != (variant_len = SpanToken(ptr)))
- {
- ptr += variant_len;
- /*
- * optional version
- */
- ptr += SpanWhitespace(ptr);
- version = ptr;
- version_len = SpanToken(ptr);
- ptr += version_len;
- }
- else
- version_len = 0;
- /*
- * sequence end
- */
- if(!ParseSeqEnd(ptr, &ptr))
- goto XpOidDocFmtNext_error;
- /*
- * update return pointer
- */
- if((const char**)NULL != ptr_return)
- *ptr_return = ptr;
- /*
- * update the passed document format struct
- */
- memset(doc_fmt, 0, sizeof(XpOidDocFmt));
- doc_fmt->format = XpOidMalloc(format_len+1);
- strncpy(doc_fmt->format, format, format_len);
- doc_fmt->format[format_len] = '\0';
- if(0 < variant_len)
- {
- doc_fmt->variant = XpOidMalloc(variant_len+1);
- strncpy(doc_fmt->variant, variant, variant_len);
- doc_fmt->variant[variant_len] = '\0';
- if(0 < version_len)
- {
- doc_fmt->version = XpOidMalloc(version_len+1);
- strncpy(doc_fmt->version, version, version_len);
- doc_fmt->version[version_len] = '\0';
- }
- }
- return xTrue;
-
- XpOidDocFmtNext_error:
- if((const char**)NULL != ptr_return)
- *ptr_return = first_nonws_ptr;
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtListNew
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-XpOidDocFmtList*
-XpOidDocFmtListNew(const char* value_string,
- const XpOidDocFmtList* valid_fmts)
-{
- if((char*)NULL != value_string)
- {
- const char* ptr;
- return XpOidDocFmtListParse(value_string, valid_fmts, &ptr, 0);
- }
- return (XpOidDocFmtList*)NULL;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtListDelete
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-void
-XpOidDocFmtListDelete(XpOidDocFmtList* list)
-{
- if((XpOidDocFmtList*)NULL != list)
- {
- int i;
- for(i = 0; i < list->count; i++)
- {
- XpOidFree(list->list[i].format);
- XpOidFree(list->list[i].variant);
- XpOidFree(list->list[i].version);
- }
- XpOidFree(list->list);
- XpOidFree(list);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtListString
- *
- * Description:
- *
- * Assumes the passed structure is valid.
- *
- * Return value:
- *
- *
- */
-char*
-XpOidDocFmtListString(const XpOidDocFmtList* list)
-{
- if((XpOidDocFmtList*)NULL != list)
- {
- if(0 < list->count)
- {
- int i;
- int str_len;
- char* str;
- char* ptr;
- /*
- * allocate the return string
- */
- for(i = 0, str_len = 0; i < list->count; i++)
- {
- str_len +=
- 1 + SafeStrLen(list->list[i].format) +
- 1 + SafeStrLen(list->list[i].variant) +
- 1 + SafeStrLen(list->list[i].version) + 2;
- }
- str = XpOidMalloc(str_len+1);
- /*
- * print the list into the string and return it
- */
- ptr = str;
- for(i = 0; i < list->count; i++)
- {
- XpOidDocFmt* df = &list->list[i];
-
-#if defined(sun) && !defined(SVR4)
- sprintf(ptr, "{%s %s %s} ",
- df->format,
- (char*)NULL != df->variant ? df->variant : "",
- (char*)NULL != df->version ? df->version : "");
- ptr += strlen(ptr);
-#else
- ptr +=
- sprintf(ptr, "{%s %s %s} ",
- df->format,
- (char*)NULL != df->variant ? df->variant : "",
- (char*)NULL != df->version ? df->version : "");
-#endif
- }
- return str;
- }
- }
- return (char*)NULL;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtListParse
- *
- * Description:
- *
- * Assumes the passed value_string and ptr_return are non-NULL.
- *
- * Return value:
- *
- *
- */
-static XpOidDocFmtList*
-XpOidDocFmtListParse(const char* value_string,
- const XpOidDocFmtList* valid_fmts,
- const char** ptr_return,
- int i)
-{
- XpOidDocFmt doc_fmt;
- XpOidDocFmtList* list;
- BOOL status;
- /*
- * get the next document-format from the value string, skipping
- * values not found in the passed list of valid formats
- */
- *ptr_return = value_string;
- while((status = XpOidDocFmtNext(&doc_fmt, *ptr_return, ptr_return))
- &&
- (const XpOidDocFmtList*)NULL != valid_fmts
- &&
- !XpOidDocFmtListHasFmt(valid_fmts, &doc_fmt)
- );
-
- if(xFalse == status)
- {
- if('\0' == **ptr_return)
- {
- if(0 == i)
- {
- /*
- * empty value string
- */
- return (XpOidDocFmtList*)NULL;
- }
- else
- {
- /*
- * done parsing; allocate the list and return
- */
- list =
- (XpOidDocFmtList*)XpOidCalloc(1, sizeof(XpOidDocFmtList));
- list->count = i;
- list->list = (XpOidDocFmt*)XpOidCalloc(i, sizeof(XpOidDocFmt));
- return list;
- }
- }
- else
- {
- /*
- * invalid document format
- */
- ErrorF("%s\n", XPMSG_WARN_DOCFMT_LIST);
- return (XpOidDocFmtList*)NULL;
- }
- }
- else
- {
- /*
- * recurse to parse remaining document formats
- */
- list = XpOidDocFmtListParse(*ptr_return, valid_fmts, ptr_return, i+1);
- if((XpOidDocFmtList*)NULL != list)
- {
- /*
- * add this doc fmt to the list
- */
- list->list[i].format = doc_fmt.format;
- list->list[i].variant = doc_fmt.variant;
- list->list[i].version = doc_fmt.version;
- }
- return list;
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidDocFmtListHasFmt
- *
- * Description:
- *
- * Assumes the passed structure is valid.
- *
- * Return value:
- *
- *
- */
-BOOL
-XpOidDocFmtListHasFmt(const XpOidDocFmtList* list,
- const XpOidDocFmt* fmt)
-{
- int i;
- if(list != (XpOidDocFmtList*)NULL
- &&
- fmt != (XpOidDocFmt*)NULL
- &&
- fmt->format != (char*)NULL
- )
- {
- for(i = 0; i < list->count; i++)
- {
- /*
- * formats must match
- */
- if(strcmp(fmt->format, list->list[i].format) != 0)
- continue;
- /*
- * variants must both be NULL or match
- */
- if(fmt->variant == (char*)NULL)
- {
- if(list->list[i].variant == (char*)NULL)
- return xTrue;
- else
- continue;
- }
- if(list->list[i].variant == (char*)NULL)
- continue;
- if(strcmp(fmt->variant, list->list[i].variant) != 0)
- continue;
- /*
- * versions must both be NULL or match
- */
- if(fmt->version == (char*)NULL)
- {
- if(list->list[i].version == (char*)NULL)
- return xTrue;
- else
- continue;
- }
- if(list->list[i].version == (char*)NULL)
- continue;
- if(strcmp(fmt->version, list->list[i].version) == 0)
- return xTrue;
- }
- }
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidCardListNew
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-XpOidCardList*
-XpOidCardListNew(const char* value_string, const XpOidCardList* valid_cards)
-{
- if((const char*)NULL != value_string)
- {
- const char* ptr;
-
- return XpOidCardListParse(value_string, valid_cards, &ptr, 0);
- }
- else
- return (XpOidCardList*)NULL;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidCardListDelete
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-void
-XpOidCardListDelete(XpOidCardList* list)
-{
- if((XpOidCardList*)NULL != list)
- {
- XpOidFree(list->list);
- XpOidFree(list);
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidCardListString
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-char*
-XpOidCardListString(const XpOidCardList* list)
-{
- if((XpOidCardList*)NULL != list)
- {
- char buf[48];
- int str_len;
- char* str;
- int i;
- char* ptr;
- /*
- * allocate the output string
- */
- for(i = 0, str_len = 0; i < list->count; i++)
-#if defined(sun) && !defined(SVR4)
- {
- sprintf(buf, "%lu", list->list[i]) + 1;
- str_len += strlen(buf);
- }
-#else
- str_len += sprintf(buf, "%lu", list->list[i]) + 1;
-#endif
- str = XpOidMalloc(str_len+1);
- /*
- * write the list to the string
- */
- for(i = 0, ptr = str; i < list->count; i++)
-#if defined(sun) && !defined(SVR4)
- {
- sprintf(ptr, "%lu ", list->list[i]);
- ptr += strlen(ptr);
- }
-#else
- ptr += sprintf(ptr, "%lu ", list->list[i]);
-#endif
- return str;
- }
- else
- return (char*)NULL;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidCardListHasCard
- *
- * Description:
- *
- * Determines if 'card' is an element of 'list'.
- *
- * Return value:
- *
- * xTrue if the card is found in the list.
- *
- * xFalse if the card is not in the list, or if 'list' is NULL.
- *
- */
-BOOL
-XpOidCardListHasCard(const XpOidCardList* list, unsigned long card)
-{
- int i;
- if(list != (XpOidCardList*)NULL)
- for(i = 0; i < list->count; i++)
- if(list->list[i] == card)
- return xTrue;
- return xFalse;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidCardListParse
- *
- * Description:
- *
- * Assumes the passed value_string and ptr_return are non-NULL.
- *
- * Return value:
- *
- *
- */
-static XpOidCardList*
-XpOidCardListParse(const char* value_string,
- const XpOidCardList* valid_cards,
- const char** ptr_return,
- int i)
-{
- unsigned long card;
- XpOidCardList* list;
- BOOL status;
-
- /*
- * get the next card from the value string, skipping values not
- * found in the passed list of valid cards
- */
- *ptr_return = value_string;
- while((status = XpOidParseUnsignedValue(*ptr_return, ptr_return, &card))
- &&
- (const XpOidCardList*)NULL != valid_cards
- &&
- !XpOidCardListHasCard(valid_cards, card)
- );
-
- if(xFalse == status)
- {
- if('\0' == **ptr_return)
- {
- if(0 == i)
- {
- /*
- * empty value string
- */
- return (XpOidCardList*)NULL;
- }
- else
- {
- /*
- * done parsing; allocate the list and return
- */
- list = (XpOidCardList*)XpOidCalloc(1, sizeof(XpOidCardList));
- list->count = i;
- list->list =
- (unsigned long*)XpOidCalloc(i, sizeof(unsigned long));
- return list;
- }
- }
- else
- {
- /*
- * parsing error
- */
- ErrorF("%s\n", XPMSG_WARN_CARD_LIST);
- return (XpOidCardList*)NULL;
- }
- }
- else
- {
- /*
- * recurse to parse remaining cardinal values
- */
- list = XpOidCardListParse(*ptr_return, valid_cards, ptr_return, i+1);
- if((XpOidCardList*)NULL != list)
- {
- /*
- * add this value to the list
- */
- list->list[i] = card;
- }
- return list;
- }
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: ParseBoolValue
- *
- * Description:
- *
- *
- * Return value:
- *
- *
- */
-static BOOL
-ParseBoolValue(const char* value_string,
- const char** ptr_return,
- BOOL* bool_return)
-{
- const char* ptr;
- int length;
- BOOL status;
- /*
- * skip leading whitespace
- */
- ptr = value_string + SpanWhitespace(value_string);
- /*
- * get the whitespace-delimited token length
- */
- length = SpanToken(ptr);
- /*
- * determine if true or false or bad
- */
- if(StrnCaseCmp(ptr, "TRUE", length) == 0)
- {
- if(bool_return != (BOOL*)NULL)
- *bool_return = xTrue;
- status = xTrue;
- }
- else if(StrnCaseCmp(ptr, "FALSE", length) == 0)
- {
- if(bool_return != (BOOL*)NULL)
- *bool_return = xFalse;
- status = xTrue;
- }
- else
- {
- /*
- * syntax error
- */
- status = xFalse;
- }
- /*
- * update the return pointer and return
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = status ? ptr+length : ptr;
- return status;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: XpOidParseUnsignedValue
- *
- * Description:
- *
- * Skips leading whitespace and parses out and returns a unsigned number.
- *
- * Return value:
- *
- * xTrue if a unsigned number was successfully parsed. ptr_return is
- * updated to point to location where the unsigned number parsing
- * ended.
- *
- * xFalse if a unsigned number was not found; ptr_return is updated
- * to point to the first non-whitespace char in value_string.
- *
- */
-BOOL
-XpOidParseUnsignedValue(const char* value_string,
- const char** ptr_return,
- unsigned long* unsigned_return)
-{
- long value;
- BOOL status;
- const char* first_nonws_ptr;
- const char* ptr;
- /*
- * skip leading whitespace
- */
- first_nonws_ptr = value_string + SpanWhitespace(value_string);
- value = strtol(first_nonws_ptr, (char**)(&ptr), 0);
- if(ptr == first_nonws_ptr || value < 0)
- status = xFalse;
- else
- status = xTrue;
- /*
- * update return parms
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = ptr;
- if(unsigned_return != (unsigned long*)NULL)
- *unsigned_return = (unsigned long)value;
- /*
- * return
- */
- return status;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: ParseRealValue
- *
- * Description:
- *
- * Skips leading whitespace and parses out and returns a real number.
- *
- * Return value:
- *
- * xTrue if a real number was successfully parsed. ptr_return is
- * updated to point to location where the real number parsing
- * ended.
- *
- * xFalse if a real number was not found; ptr_return is updated
- * to point to the first non-whitespace char in value_string.
- *
- */
-static BOOL
-ParseRealValue(const char* value_string,
- const char** ptr_return,
- float* real_return)
-{
- float real_value;
- BOOL status;
- const char* first_nonws_ptr;
- const char* ptr;
- /*
- * skip leading whitespace
- */
- first_nonws_ptr = value_string + SpanWhitespace(value_string);
- real_value = (float)strtod(first_nonws_ptr, (char**)(&ptr));
- if(ptr == first_nonws_ptr)
- status = xFalse;
- else
- status = xTrue;
- /*
- * update return parms
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = ptr;
- if(real_return != (float*)NULL)
- *real_return = real_value;
- /*
- * return
- */
- return status;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: ParseSeqEnd
- *
- * Description:
- *
- * Description:
- *
- * Skips leading whitespace and parses out the sequence end
- * character '}'.
- *
- * Return value:
- *
- * xTrue if the sequence end character was parsed; ptr_return is
- * updated to point to the first char following the sequence end
- * character.
- *
- * xFalse if the sequence end character was not found; ptr_return is
- * updated to point to the first non-whitespace char in value_string.
- *
- */
-static BOOL
-ParseSeqEnd(const char* value_string,
- const char** ptr_return)
-{
- const char* ptr;
- BOOL status;
- /*
- * skip leading whitespace
- */
- ptr = value_string + SpanWhitespace(value_string);
- /*
- * parse out the sequence end character
- */
- if(*ptr == '}')
- {
- status = xTrue;
- ++ptr;
- }
- else
- status = xFalse;
- /*
- * update the return pointer
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = ptr;
- /*
- * return
- */
- return status;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: ParseSeqStart
- *
- * Description:
- *
- * Skips leading whitespace and parses out the sequence start
- * character '{'.
- *
- * Return value:
- *
- * xTrue if the sequence start character was parsed; ptr_return is
- * updated to point to the first char following the sequence start
- * character.
- *
- * xFalse if the sequence start character was not found; ptr_return is
- * updated to point to the first non-whitespace char in value_string.
- *
- */
-static BOOL
-ParseSeqStart(const char* value_string,
- const char** ptr_return)
-{
- const char* ptr;
- BOOL status;
- /*
- * skip leading whitespace
- */
- ptr = value_string + SpanWhitespace(value_string);
- /*
- * parse out the sequence start character
- */
- if(*ptr == '{')
- {
- status = xTrue;
- ++ptr;
- }
- else
- status = xFalse;
- /*
- * update the return pointer
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = ptr;
- /*
- * return
- */
- return status;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: ParseUnspecifiedValue
- *
- * Description:
- *
- * Skips leading whitespace and parses out an unspecified optional
- * value (i.e. matching '' or "" - skips all data between the set of
- * quotes).
- *
- * Return value:
- *
- * xTrue if an unspecified value was parsed; ptr_return is updated to
- * point to the first char following the trailing quote.
- *
- * xFalse if an unspecified value was not found; ptr_return is updated
- * to point to the first non-whitespace char in value_string.
- *
- */
-static BOOL
-ParseUnspecifiedValue(const char* value_string,
- const char** ptr_return)
-{
- BOOL status;
- const char* ptr;
- /*
- * skip leading whitespace
- */
- ptr = value_string + SpanWhitespace(value_string);
- /*
- * parse out an unspecified optional value ('' or "")
- */
- if(*ptr == '\'' || *ptr == '"')
- {
- char delim[2];
-
- if(ptr_return != (const char**)NULL)
- {
- delim[0] = *ptr;
- delim[1] = '\0';
- /*
- * skip over the matching delimiter
- */
- ++ptr;
- ptr += strcspn(ptr, delim);
- if(*ptr != '\0')
- ++ptr;
- }
- status = xTrue;
- }
- else
- status = xFalse;
- /*
- * update the return pointer
- */
- if(ptr_return != (const char**)NULL)
- *ptr_return = ptr;
- /*
- * return
- */
- return status;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: SpanToken
- *
- * Description:
- *
- * Returns the length of the initial segment of the passed string
- * that consists entirely of non-whitespace and non-sequence
- * delimiter characters.
- *
- *
- */
-static int
-SpanToken(const char* string)
-{
- const char* ptr;
- for(ptr = string;
- *ptr != '\0' && !isspace(*ptr) && *ptr != '{' && *ptr != '}';
- ++ptr);
- return ptr - string;
-}
-
-/*
- * ------------------------------------------------------------------------
- * Name: SpanWhitespace
- *
- * Description:
- *
- * Returns the length of the initial segment of the passed string
- * that consists entirely of whitespace characters.
- *
- *
- */
-static int
-SpanWhitespace(const char* string)
-{
- const char* ptr;
- for(ptr = string; *ptr != '\0' && isspace(*ptr); ++ptr);
- return ptr - string;
-}
-
-#ifndef HAVE_STRCASECMP
-/*
- * ------------------------------------------------------------------------
- * Name: StrnCaseCmp
- *
- * Description:
- *
- * Implements strncasecmp() for those platforms that need it.
- *
- *
- */
-static int
-StrnCaseCmp(const char *s1, const char *s2, size_t len)
-{
- char c1, c2;
- int result;
-
- while (len--)
- {
- c1 = *s1++;
- c2 = *s2++;
- result = tolower(c1) - tolower(c2);
-
- if (result != 0)
- return result;
- }
-
- return 0;
-}
-#endif