/* BEGIN_ICS_COPYRIGHT7 ****************************************

Copyright (c) 2015-2017, Intel Corporation

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice,

      this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in the

      documentation and/or other materials provided with the distribution.

    * Neither the name of Intel Corporation nor the names of its contributors

      may be used to endorse or promote products derived from this software

      without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE

FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

** END_ICS_COPYRIGHT7   ****************************************/

/* [ICS VERSION STRING: unknown] */

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

 *

 * File: opaxmlextract.c

 *

 * Description:

 *	This file implements the opaxmlextract program.  opaxmlextract takes

 *	well-formed XML as input, extracts element values as specified by user

 *	input, and outputs data as lines (records) of data in CSV format.

 *

 *	opaxmlextract uses XML Lib to parse the XML.  It uses the folowing library

 *	functions:

 *	  IXmlParseFile()

 *

 *	opaxmlextract implements the following call-backs (handlers):

 *	  IXML_START_TAG_FUNC()

 *	  IXML_END_TAG_FUNC()

 *

 *	opaxmlextract takes 2 types of element names as input from the user - elements

 *	to be extracted, and those for which extraction is to be suppressed.  Both

 *	types of elements are stored in the Element Table (tbElements[]).  As

 *	opaxmlextract processes the XML (through the call-backs), it saves the values

 *	of elements to be extracted.  opaxmlextract outputs a record containing those

 *	values under the following conditions:

 *	  1 or more elements being extracted and containing a non-null value go out

 *	    of scope (the element containing those elements is ended)

 *	  An element changes value while it is in scope

 *

 *	During operation, opaxmlextract maintains the hierarchical "level" at which

 *	it is extracting (top-most level is 1).  Each nested element increases the

 *	level by 1.  opaxmlextract performs extraction on a (specified) element

 *	regardless of the level at which the element is found.

 *

 *	When an element is specified for suppression then no extraction will be

 *	performed during the extent of that element (begin through end).

 *	Suppression is maintained for elements specified inside the suppressed

 *	element, even if those elements have extraction specified.  Suppressed

 *	elements can be nested - opaxmlextract will resume extraction after the

 *	outermost suppressed element is ended.

 *

 *	Element names for extraction or suppression can be made context sensitive

 *	with an enclosing element name using syntax 'elem1.elem2'.  elem2 will

 *	be extracted (or extraction will be suppressed) when elem2 is enclosed

 *	by elem1.  The wildcard handling capability of XML Lib allows '*' to

 *	be specified as all or part of an element name.  The following are valid:

 *	        *.elem3  -  elem3 enclosed by any sequence of elements

 *	                    (elem1.elem3 or elem1.elem2.elem3)

 *	  elem1.*.elem3  -  elem3 enclosed by elem1 with any number of (but at

 *	                    least 1) intermediate elements.

 *

 *	opaxmlextract prepends any entered element name not containing '*'

 *	(anywhere) with '*.'.

 *

 *	NOTES:

 *	opaxmlextract performs extraction using XML Lib without maintaining

 *	its own stack of elements or element values.  Therefore it has the

 *	following characteristics:

 *	  Enclosing elements cannot contain values;

 *

 *	  If an element name specification is such that the element can be

 *	  extracted at multiple levels within the same context (enclosing

 *	  element), then when the inner-most element specification ends,

 *	  the element value becomes null (it does not revert to the outer

 *	  value).

 */

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

 *

 * INCLUDES

 */

#include <stddef.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <iba/ipublic.h>

#include <getopt.h>

#include "ixml.h"

#include "fnmatch.h"

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

 *

 * DEFINES

 */

#define ALLOW_MULTI_MATCH		1		// allow 1 tag to match mult elements

#define SUPPRESS_AND_EXTRACT	0		// allow 1 tag to suppress and extract

										// this option not fully implemented

										// procElementEnd would need more work

#define OK  0

#define ERROR (-1)

#define NAME_PROG  "opaxmlextract"		// Program name

#define MAX_PARAMS_FILE  512			// Max number of param file parameters

#define MAX_ELEMENTS  100				// Max number of elements parsable

#define MAX_LEVEL_PARSE  MAX_ELEMENTS	// Max parsing level

#define MAX_DELIMIT_CHARS  16			// Max size of delimiter string

#define MAX_INPUT_BUF  8192				// Max size of input buffer

#define MAX_PARAM_BUF  8192				// Max size of parameter file

#define MAX_FILENAME_CHARS  256			// Max size of file name

#define WHITE_SPACE  " \t\r\n"			// White space characters

#define OPTION_LEN 2			// string length of an option(eg. -P)

// Element table entry, elements selected by user and present parsed value

typedef struct 

{

	char	*pName;						// Element name

	char	*pAttrName;					// optional Attribute Name

	char	*pAttrValue;				// optional Attribute Value

	int		lenValue;					// Length of element value

										//   < 0 : pValue alloc'd but not in use

	char	*pValue;					// Element value

	int		flags;						// Flags (see ELEM_xxx below)

	int		level;						// Element nesting level (0 - not open)

} ELEMENT_TABLE_ENTRY;

// Element table flags:

#define ELEM_NAMEPREPEND  0x80			// Data prepended to element name

// list of elements which a given tag matched and the attribute value

// which the element selected.  This is generated by the start tag handler

// and used by the end tag handler for a given "matched" tag

typedef struct

{

	int		ix;							// element table index

	int		lenAttrValue;				// length of value

	char	*pAttrValue;				// value, NULL if not outputting attr

} ELEMENT_LIST_ENTRY;

typedef struct

{

	int		numElements;			// number of entrys in list

	ELEMENT_LIST_ENTRY Elements[1];	// variable length list

} ELEMENT_LIST;

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

 *

 * LOCAL FUNCTION PROTOTYPES

 */

int delWsLead(char *pStr);

int delWsTrail(char *pStr);

void dispExtractionRecord();

void dispHeaderRecord(int argc, char ** argv);

void errUsage(void);

int findElement(int start, const char *pElement, const char **pAttrib,

				char **pValue, int *length);

int findElementDup(const ELEMENT_TABLE_ENTRY *pElement);

void getRecu_opt( int argc, char ** argv, const char *pOptShort,

	struct option tbOptLong[] );

void *procElementBeg(IXmlParserState_t *pParserState, void *pParent, const char **ppAttrib);

void procElementEnd( IXmlParserState_t *pParserState, const IXML_FIELD *pField,

	void *pObject, void *pParent, XML_Char *pContent, unsigned length,

	boolean flValid );

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

 *

 * GLOBAL VARIABLES

 */

int		g_exitstatus  = 0;

int		g_verbose  = 0;

int		g_quiet  = 0;

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

 *

 * LOCAL VARIABLES

 */

int  levelParse  = 0;					// Parse nesting level

int  numElementsTable  = 0;				// Number of elements in tbElements[]

int  numElementsExtract  = 0;			// Number of elements to extract

int  ctElementsSuppress  = 0;			// Count of suppress elements being parsed

int  flElementChangeLast = FALSE;		// tbElement[] value change flag (last line)

int  flElementChange  = FALSE;			// tbElement[] value change flag

int  flHeaderOutput  = TRUE;			// Header output flag

XML_Parser  pParser  = NULL;			// Pointer to expat parser object

FILE  * hFileInput  = NULL;				// Input file handle (default stdin)

										// Input file name (default stdin)

char  nameFileInput[MAX_FILENAME_CHARS + 1]  = "stdin";

uint32  fvDebugProg  = 0;			// Debug/Trace variable as:

										//  0MMM MMMM NNNN NNNN  SSSS 21RC SIEB SNEB

// Command line option table, each has a short and long flag name

static const char* tbShortOptions="#vHe:s:X:P:d:Z:";

struct option tbOptions[] =

{

	// Basic controls

	{ "help", no_argument, NULL, 'h' },

	{ "verbose", no_argument, NULL, 'v' },

	{ "extract", required_argument, NULL, 'e' },

	{ "suppress", required_argument, NULL, 's' },

	{ "infile", required_argument, NULL, 'X' },

	{ "pfile", required_argument, NULL, 'P' },

	{ "delimit", required_argument, NULL, 'd' },

	{ "noheader", no_argument, NULL, 'H' },

	{ "debug", required_argument, NULL, 'Z' },

	{ 0 }

};

// Element table; contains information about each element of interest.

//  Elements to be extracted are contained at the beginning of the table

//  (0 - numElementsExtract-1); elements for which extraction is suppressed

//  are contained at the end of the table

//  (numElementsExtract - numElementsTable-1).

ELEMENT_TABLE_ENTRY  tbElements[MAX_ELEMENTS + 1];

// IXML_FIELD table; contains information for the XML Lib parser.  For

// purposes of opaxmlextract, a call-back on every start tag and end tag

// is required; therefore IXML_FIELD tag is set to "*" and format to 'w'.

IXML_FIELD  tbFields[] =

{

	{tag:"*", format:'w', subfields:tbFields, start_func:procElementBeg,

		end_func:procElementEnd},

	{NULL}

};

// Delimiter string buffer

char  bfDelimit[MAX_DELIMIT_CHARS + 1] = ";";

// Input buffer

char  bfInput[MAX_INPUT_BUF];

void *mymalloc(size_t size, const char* desc)

{

	void *ret = malloc(size);

	if (! ret)

	{

		fprintf(stderr, NAME_PROG ": Unable to Allocate %s Memory\n", desc);

		exit(1);

	}

	return ret;

}

void *myrealloc(void* ptr, size_t size, const char* desc)

{

	void *ret = realloc(ptr, size);

	if (! ret)

	{

		fprintf(stderr, NAME_PROG ": Unable to Re-Allocate %s Memory\n", desc);

		exit(1);

	}

	return ret;

}

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

 *

 * delWsLead()

 *

 * Description:

 *	Delete leading white space from a string.  White space is defined by the

 *	string WHITE_SPACE.

 *

 * Inputs:

 *	   pStr - Pointer to string from which to delete leading white space

 *

 * Outputs:

 *	ERROR - pStr NULL

 *	   OK - white space deleted, no white space to delete

 */

int delWsLead(char *pStr)

{

	int		nChar;

	char	*pChar;

	if (!pStr)

		return (ERROR);

	nChar = strspn(pStr, WHITE_SPACE);

	if (nChar != 0)

	{

		pChar = pStr + nChar;

		memmove(pStr, pChar, strlen(pChar) + 1);

	}

	return (OK);

}	// End of delWsLead()

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

 *

 * delWsTrail()

 *

 * Description:

 *	Delete trailing white space from a string.  White space is defined by the

 *	string WHITE_SPACE.

 *

 * Inputs:

 *	   pStr - Pointer to string from which to delete trailing white space

 *

 * Outputs:

 *	ERROR - pStr NULL

 *	   OK - white space deleted, no white space to delete

 */

int delWsTrail(char *pStr)

{

	int		nChar;

	char	*pChar;

	if (!(pChar = pStr))

		return (ERROR);					// pStr is NULL

	while (TRUE)

	{

		// Find next non-white space char

		nChar = strspn(pChar, WHITE_SPACE);

		if (pChar[nChar])

		{

			// Find next white space char

			pChar += nChar;

			pChar += strcspn(pChar, WHITE_SPACE);

			if (!*pChar)

				break;				// No trailing white space

		}

		// Found first white space char after last non-white space char

		else

		{

			*pChar = 0;

			break;

		}

	}	// End of while (TRUE)

	return (OK);

}	// End of delWsTrail()

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

 *

 * dispExtractionRecord()

 *

 * Description:

 *	Display (output) 1 record of extraction data if element change flag

 *	indicates an element has changed since the last output.

 *

 * Inputs:

 *	none

 *

 * Outputs:

 *	none

 */

void dispExtractionRecord()

{

	int		ix;							// Loop index

	// Check element change flag

	if (!flElementChangeLast)

		return;

	// Output extraction record: element values

	for (ix = 0; ix < numElementsExtract; ix++)

	{

		(void)delWsTrail(tbElements[ix].pValue);

		if (ix > 0)

			printf("%s", bfDelimit);

		printf("%s", tbElements[ix].pValue ? tbElements[ix].pValue : "" );

	}

	printf("\n");

	flElementChangeLast = FALSE;

}	// End of dispExtractionRecord()

void printElement(FILE *f, ELEMENT_TABLE_ENTRY *pElement, int verbose)

{

	// Output complete name string if verbose or name not prepended

	if (verbose || !(pElement->flags & ELEM_NAMEPREPEND))

		fprintf(f, "%s", pElement->pName);

	else

		fprintf(f, "%s", &pElement->pName[2]);

	if (pElement->pAttrName)

	{

		fprintf(f, ":%s", pElement->pAttrName);

		if (pElement->pAttrValue)

			fprintf(f, ":%s", pElement->pAttrValue);

	}

}

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

 *

 * dispHeaderRecord()

 *

 * Description:

 *	Display (output) header line containing names of elements extracted.  This

 *	line preceeds the extraction data.  If verbose is set, preceed the header

 *	line with a line containing the program name and command line options.

 *

 * Inputs:

 *	argc, argv - Inputs to main()

 *

 * Outputs:

 *	none

 */

void dispHeaderRecord(int argc, char ** argv)

{

	int		ix;							// Loop index

	// Output header record only if output enabled

	if (flHeaderOutput)

	{

		// Output element names as a header

		for (ix = 0; ix < numElementsExtract; ix++)

		{

			if (ix > 0)

				printf("%s", bfDelimit);

			printElement(stdout,&tbElements[ix], g_verbose);

		}

		printf("\n");

	}

}	// End of dispHeaderRecord()

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

 *

 * errUsage()

 *

 * Description:

 *	Output information about program usage and parameters.

 *

 * Inputs:

 *	none

 *

 * Outputs:

 *	none

 */

void errUsage(void)

{

	fprintf(stderr, "Usage: " NAME_PROG " [-v][-H][-d delimiter][-e element][-s element]\n");

	fprintf(stderr, "                        [-X input_file] [-P param_file]\n");

	fprintf(stderr, "  -e/--extract element      - name of an XML element to extract\n");

	fprintf(stderr, "                              can be used multiple times\n");

	fprintf(stderr, "                              elements can be nested in any order, but will\n");

	fprintf(stderr, "                              be output in the order specified\n");

	fprintf(stderr, "                              optionally an attribute or\n");

	fprintf(stderr, "                              attribute and value can be specified\n");

	fprintf(stderr, "                              -e element\n");

	fprintf(stderr, "                              -e element:attrName\n");

	fprintf(stderr, "                              -e element:attrName:attrValue\n\n");

	fprintf(stderr, "                              Note that elements can be compound values\n");

	fprintf(stderr, "                              separated by a dot. For example,\n");

	fprintf(stderr, "                              'Switches.Node' is a Node element contained\n"); 

	fprintf(stderr, "                              within a Switches element.\n\n"); 

	fprintf(stderr, "                              If its desired to output the attribute value as\n");

	fprintf(stderr, "                              opposed to the element value, a specification such\n");

	fprintf(stderr, "                              as '-e FIs.Node:id' can be used, which will return\n");

	fprintf(stderr, "                              the value of the id attribute of any Node elements\n");

	fprintf(stderr, "                              within FIs element. If desired a specific element\n");

	fprintf(stderr, "                              can be selected by its attribute value, such as\n");

	fprintf(stderr, "                              '-e MulticastFDB.Value:LID:0xc000', which will\n");

	fprintf(stderr, "                              return the value of the Value element within\n");

	fprintf(stderr, "                              Multicast FDB element where the Value element has\n");

	fprintf(stderr, "                              an attribute of LID with a value of 0xc000.\n\n");

#if ALLOW_MULTI_MATCH

	fprintf(stderr, "                              A given element can be specified multiple\n");

	fprintf(stderr, "                              times each with a different AttrName or attrValue\n");

#else

	fprintf(stderr, "                              a given element can be specified only once\n");

#endif

	fprintf(stderr, "  -s/--suppress element     - name of XML element to suppress extraction\n");

	fprintf(stderr, "                              can be used multiple times, order does not matter\n");

	fprintf(stderr, "                              supports same syntaxes as -e\n");

	fprintf(stderr, "  -d/--delimit delimiter    - delimiter output between element names and values\n");

	fprintf(stderr, "                              default is semicolon\n");

	fprintf(stderr, "  -X/--infile input_file    - parse XML in input_file\n");

	fprintf(stderr, "  -P/--pfile param_file     - read command parameters from param_file\n");

	fprintf(stderr, "  -H/--noheader             - do not output element name header record\n");

	fprintf(stderr, "  -v/--verbose              - verbose output: progress reports during extraction\n");

	fprintf(stderr, "                              and element name prepended wildcard characters\n");

	fprintf(stderr, "  --help                    - print this usage text.\n");

	if (hFileInput && (hFileInput != stdin))

		fclose(hFileInput);

	exit(2);

}	// End of errUsage()

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

 *

 * findElement()

 *

 * Description:

 *	Find specified element name in element table using wildcard matching.

 *	Search suppression elements first by starting search at end of table

 *	and searching toward beginning.

 *

 * Inputs:

 *	start - first element in table to check (end of table)

 *	pElement - Pointer to element name

 *	ppAttrib - attribute list from tag being processed

 *

 * Outputs:

 *	Index of element table containing element name, else

 *	ERROR - Element name not found

 *

 *	*pValue, *length - if matched a Name:attrName style specifier, the value of

 *						the attribute matched.  Otherwise NULL,0

 *						(caller must free *pValue if non-NULL)

 */

int findElement(int start, const char *pElement, const char **ppAttrib,

				char **pValue, int *length)

{

	int		ix;

	*pValue = NULL;

	*length = 0;

	for (ix = start; ix >= 0; ix--)

	{

		ELEMENT_TABLE_ENTRY *p = &tbElements[ix];

		if (!fnmatch(p->pName, pElement, 0))

	   	{

			int i;

			if (! p->pAttrName)

				return (ix);	// match only on tag name

			// search for matching attribute

			// even index in ppAttrib is name, odd is corresponding value

			for (i=0; ppAttrib[i]; i += 2)

			{

				if (!fnmatch(p->pAttrName, ppAttrib[i], 0))

				{

					if (! p->pAttrValue)

					{

						// match on Attr Name and return attr value

						*length = strlen(ppAttrib[i+1]);

						*pValue = mymalloc(*length+1, "Attribute Value");

						strcpy(*pValue, ppAttrib[i+1]);

						return (ix);

					}

					// match on attr value

					if (! fnmatch(p->pAttrValue, ppAttrib[i+1], 0))

						return (ix);

				}

			}

		}

	}

	return (ERROR);

}	// End of findElement()

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

 *

 * findElementDup()

 *

 * Description:

 *	Find specified element name in element table using duplicate (2-way)

 *	wildcard matching.  Search element table from beginning to end since

 *	there is no need to check suppression elements first.

 *

 * Inputs:

 *	pElement - Pointer to element name

 *

 * Outputs:

 *	Index of element table containing element name, else

 *	ERROR - Element name not found

 */

int findElementDup(const ELEMENT_TABLE_ENTRY *pElement)

{

	int		ix;

	for (ix = 0; ix < numElementsTable; ix++)

	{

		ELEMENT_TABLE_ENTRY *p = &tbElements[ix];

		if (0 == fnmatch(p->pName, pElement->pName, 0)

			|| 0 == fnmatch(pElement->pName, p->pName, 0))

		{

#if ALLOW_MULTI_MATCH

			if ((p->pAttrName == NULL) != (pElement->pAttrName == NULL))

				continue;

			if (p->pAttrName && pElement->pAttrName)

			{

				if ( 0 == fnmatch(p->pAttrName, pElement->pAttrName, 0) ||

						0 == fnmatch(pElement->pAttrName, p->pAttrName, 0) )

				{

					if ((p->pAttrValue == NULL) != (pElement->pAttrValue == NULL))

						continue;

					if ( p->pAttrValue && pElement->pAttrValue &&

							! ( 0 == fnmatch(p->pAttrValue, pElement->pAttrValue, 0) ||

							0 == fnmatch(pElement->pAttrValue, p->pAttrValue, 0) ) )

						continue;

					return (ix);

				}

				continue;

			}

#else

			// allow different values for same attr because won't both match

			// the same tag

			if (p->pAttrName && pElement->pAttrName

				&& (0 == fnmatch(p->pAttrName, pElement->pAttrName, 0)

					|| 0 == fnmatch(pElement->pAttrName, p->pAttrName, 0))

				&& p->pAttrValue && pElement->pAttrValue

				&& ! (0 == fnmatch(p->pAttrValue, pElement->pAttrValue, 0)

						|| 0 == fnmatch(pElement->pAttrValue, p->pAttrValue, 0)))

					continue;

#endif

			return (ix);

		}	// End of if (0 == fnmatch(p->pName, pElement->pName, 0)

	}	// End of for (ix = 0; ix < numElementsTable; ix++)

	return (ERROR);

}	// End of findElementDup()

void getNextField(const char *arg, int extra, char **field, const char **rest)

{

	const char *p = rest?strchr(arg, ':'):NULL;

	int len;

	if (p)

   	{

		len = (p-arg);

		*rest = p+1;

	} else {

		len = strlen(arg);

		if (rest)

			*rest = NULL;

	}

	*field = mymalloc(len+1+extra, "Name");

	strncpy(*field, arg, len);

	(*field)[len] = '\0';

}

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

 *

 * getRecu_opt()

 *

 * Description:

 *	Get command line options (recursively).  Parses command line options

 *	using short and long option (parameter) definitions.  Parameters (global

 *	variables) are updated appropriately.  The parameter '-P param_file' which

 *	takes command line options from a file is also handled.  The -P parameter

 *	can be used within a parameter file; in such cases the function will call

 *	itself recursively.

 *

 * Inputs:

 *	     argc - Number of input parameters

 *	     argv - Array of pointers to input parameters

 *	pOptShort - Pointer to string of short option definitions

 *	tbOptLong - Array of long option definitions

 * 

 * Outputs:

 *	none

 */

void getRecu_opt( int argc, char ** argv, const char *pOptShort,

	struct option tbOptLong[] )

{

	int		ix;

	int		cOpt;						// Option parsing char                         

	int		ixOpt;						// Option parsing index

	int		lenStr;						// String length

	char	*pChar;						// Pointer to char

	ELEMENT_TABLE_ENTRY *pElement1,		// Pointers to element entries

			*pElement2;

	int		argc_recu;					// Recursive argc

	char	*argv_recu[MAX_PARAMS_FILE];  // Recursive argv

	int		optind_recu;				// Recursive optind

	char	*optarg_recu;				// Recursive optarg

	int		ctCharParam;				// Parameter file char count

	FILE	*hFileParam = NULL;			// Parameter file handle

	char	nameFileParam[MAX_FILENAME_CHARS +1];  // Parameter file name

	char	bfParam[MAX_PARAM_BUF + 1];

	// Input command line arguments

	while ((cOpt = getopt_long(argc, argv, pOptShort, tbOptLong, &ixOpt)) != -1)

    {

		lenStr = 0;

        switch (cOpt)

        {

		// Verbose

		case 'v':

			g_verbose = 1;

			break;

		// Extract element name specification

		case 'e':

		// Suppress element name specification

		case 's':

			// syntaxes supported:

			// Name    - match Tag with given name

			// Name:attr - select attr field of Tag with given name and attr

			// Name:attr:value - match Tag with given name and attr value

			// All three components allow "glob" style patterns

			if (numElementsTable == MAX_ELEMENTS)

			{

				fprintf(stderr, NAME_PROG ": Too many Elements\n");

				errUsage();

			}

			else if (!optarg || ! *optarg)

			{

				fprintf(stderr, NAME_PROG ": Missing Element\n");

				errUsage();

			}

			else

			{

				ELEMENT_TABLE_ENTRY *pElement = &tbElements[numElementsTable];

				const char *rest;

				// Tag Name

				getNextField(optarg, 2, &pElement->pName, &rest);

				if (! strchr(optarg, '*'))

				{

					// insert *. before string (extra 2 above allowed space)

					memmove(pElement->pName+2, pElement->pName, strlen(pElement->pName)+1);

					pElement->pName[0] = '*'; pElement->pName[1] = '.';

					pElement->flags |= ELEM_NAMEPREPEND;

				}

				if (rest) {

					// optional AttrName

					if (! *rest) // trailing colon

					{

						fprintf(stderr, NAME_PROG ": Attr Name missing: %s\n", optarg);

						errUsage();

					}

					getNextField(rest, 0, &pElement->pAttrName, &rest);

					if (rest) {

						// optional AttrValue

						if (! *rest) // trailing colon

						{

							fprintf(stderr, NAME_PROG ": Attr Value missing: %s\n", optarg);

							errUsage();

						}

						getNextField(rest, 0, &pElement->pAttrValue, NULL);

					}

				}

				if ((ix = findElementDup(&tbElements[numElementsTable])) != ERROR)

				{

					fprintf(stderr, NAME_PROG ": Duplicate (matching) Element: %s (matches: ", optarg);

					printElement(stderr, &tbElements[ix], FALSE);

					fprintf(stderr, ")\n");

					errUsage();

				}

			}

			// If suppress specification, leave at end of tbElements[]

			if (cOpt == 's')

				numElementsTable++;

			// If extraction specification w/no suppress elements, leave at

			//  end of tbElements[]

			else if ((cOpt == 'e') && (numElementsExtract == numElementsTable))

			{

				numElementsTable++;

				numElementsExtract++;

			}

			// If extraction specification w/suppress elements, move extraction

			//  to end of other extractions

			else if ((cOpt == 'e') && (numElementsExtract < numElementsTable))

			{

				// Swap last element table entry with first suppress element entry

				//  (NOTE: lenValue, pValue and level are zero, so no swap needed)

				pElement1 = &tbElements[numElementsExtract++];

				pElement2 = &tbElements[numElementsTable++];

				pChar = pElement1->pName;

				pElement1->pName = pElement2->pName;

				pElement2->pName = pChar;

				pChar = pElement1->pAttrName;

				pElement1->pAttrName = pElement2->pAttrName;

				pElement2->pAttrName = pChar;

				pChar = pElement1->pAttrValue;

				pElement1->pAttrValue = pElement2->pAttrValue;

				pElement2->pAttrValue = pChar;

				lenStr = pElement1->flags;

				pElement1->flags = pElement2->flags;

				pElement2->flags = lenStr;

			}

			break;

		// Delimiter string specification

		case 'd':

			if ( !optarg || ((lenStr = strlen(optarg)) == 0) ||

					(lenStr > MAX_DELIMIT_CHARS) )

			{

				fprintf(stderr, NAME_PROG ": Invalid delimiter size: %d\n", lenStr);

				errUsage();

			}

			strncpy(bfDelimit, optarg, sizeof(bfDelimit)-1);

			// Ensure null termination

			bfDelimit[MAX_DELIMIT_CHARS]=0;

			break;

		// Input file specification

		case 'X':

			if ( !optarg || ((lenStr = strlen(optarg)) == 0) ||

					(lenStr > MAX_FILENAME_CHARS) )

			{

				fprintf(stderr, NAME_PROG ": Missing Input File Name.\n");

				errUsage();

			}

			else if (hFileInput != stdin)

			{

				fprintf( stderr, NAME_PROG ": Multiple Input Files: %s and %s\n",

					nameFileInput, optarg );

				errUsage();

			}

			strncpy(nameFileInput, optarg, sizeof(nameFileInput)-1);

			// Ensure null termination

			nameFileInput[MAX_FILENAME_CHARS]=0;

			hFileInput = fopen(nameFileInput, "r");

			if (!hFileInput)

			{

				fprintf( stderr, NAME_PROG ": Unable to Open Input File: %s\n",

					nameFileInput );

				perror("");

				errUsage();

			}

			break;

		// Parameter file specification

		case 'P':

			if (!optarg || ((lenStr = strlen(optarg)) == 0) ||

					(lenStr > MAX_FILENAME_CHARS) )

			{

				fprintf(stderr, NAME_PROG ": Missing Parameter File Name.\n");

				errUsage();