cde/cde/programs/dtwm/WmParse.c

/*
 * CDE - Common Desktop Environment
 *
 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
 *
 * These libraries and programs are free software; you can
 * redistribute them and/or modify them under the terms of the GNU
 * Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * These libraries and programs are distributed in the hope that
 * they will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with these libraries and programs; if not, write
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301 USA
 */
/******************************<+>*************************************
 **********************************************************************
 **
 **  File:        WmParse.c
 **
 **  Project:     HP/Motif Workspace Manager (dtwm)
 **
 **  Description:
 **  -----------
 **  This file contains the generic parsing routines
 **
 **
 *********************************************************************
 **
 ** (c) Copyright 1987, 1988, 1989, 1990, 1991 HEWLETT-PACKARD COMPANY
 ** ALL RIGHTS RESERVED
 **
 **********************************************************************
 **********************************************************************
 **
 **
 **********************************************************************
 ******************************<+>*************************************/

/* ANSI C definitions,  This should be the first thing in WmGlobal.h */
#ifdef __STDC__
#define Const const
#else
#define Const /**/
#endif


/*
 * Included Files:
 */
#include <stdio.h>
#include <X11/Intrinsic.h>
#include "WmGlobal.h"
#include "WmParse.h"
#include "WmParseP.h"
#include <stdlib.h>
#include <ctype.h>

/*
 * Internal routines
 */

static DtWmpParseBuf * _DtWmpIncBuf (
    DtWmpParseBuf *pWmPB);



#ifndef MAXLINE
#define MAXLINE		(MAXWMPATH+1)
#endif
#define MAX_QUOTE_DEPTH	10

/*
 *  This flags non-OSF code in those sections that were lifted
 *  from mwm.
 */
#define PARSE_LIB


/*
 * Defines used to maintain code similarity between OSF/mwm source
 * routines and these routines.
 */
#define cfileP			((pWmPB)->pFile)
#define linec   		((pWmPB)->lineNumber)
#define line			((pWmPB)->pchLine)
#define parseP			((pWmPB)->pchNext)
#define ScanWhitespace(s)	(_DtWmParseSkipWhitespaceC(s))
#define PeekAhead(s,l)		(_DtWmParsePeekAhead(s,l))


/*************************************<->*************************************
 *
 *  _DtWmParseSkipWhitespace(pWmPB)
 *
 *
 *  Description:
 *  -----------
 *  Scan the current string, skipping over all white space characters.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB = ptr to parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  pWmPB = parse buffer modified; current line ptr may be moved.
 *
 *
 *  Comments:
 *  --------
 *  Assumes there's a current line in the parse buffer
 * 
 *************************************<->***********************************/

void _DtWmParseSkipWhitespace(DtWmpParseBuf *pWmPB)
{
    _DtWmParseSkipWhitespaceC (&(pWmPB->pchNext));

} /* END OF FUNCTION _DtWmParseSkipWhitespace */


/*************************************<->*************************************
 *
 *  _DtWmParseNextToken (pWmPB)
 *
 *
 *  Description:
 *  -----------
 *  Returns the next quoted or whitespace-terminated nonquoted string in the
 *  current line buffer.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= ptr to parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= ptr to null terminated string.
 *  pWmPB	= current line modified internally.
 *
 *
 *  Comments:
 *  --------
 *  May alter the line buffer contents.
 *  Handles quoted strings and characters, removing trailing whitespace from
 *  quoted strings.
 *  Returns NULL string if the line is empty or is a comment.
 *  Does not use session manager style algorithm for dealing with
 *  quoted strings.
 * 
 *************************************<->***********************************/

unsigned char *
_DtWmParseNextToken (
    DtWmpParseBuf *pWmPB 
    )
{
    return (_DtWmParseNextTokenC (&(pWmPB->pchNext), False));
}


/*************************************<->*************************************
 *
 *  _DtWmParseNextTokenExpand (pWmPB)
 *
 *
 *  Description:
 *  -----------
 *  Returns the next quoted or whitespace-terminated nonquoted string in the
 *  current line buffer. Environment variables found in the are expanded.
 *  Characters quoted by '\' are passed through unaffected with the 
 *  quoting '\' removed.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= ptr to parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= ptr to null terminated string.
 *		  Free this string with XtFree().
 *  pWmPB	= current line modified internally.
 *
 *
 *  Comments:
 *  --------
 *  May alter the line buffer contents.
 *  Handles quoted strings and characters, removing trailing whitespace from
 *  quoted strings.
 *  Returns NULL string if the line is empty or is a comment.
 * 
 *************************************<->***********************************/

unsigned char *
_DtWmParseNextTokenExpand (
    DtWmpParseBuf *pWmPB 
    )
{
    unsigned char *pch;
    unsigned char *pchReturn = NULL;

    /* isolate the next token */
    pch = _DtWmParseNextTokenC (&(pWmPB->pchNext), False);

    /* expand environment variables, a copy of the string is returned */
    pchReturn = _DtWmParseExpandEnvironmentVariables (pch, NULL);

    /* 
     * If a token was found, but no copy returned, there were no 
     * environment variables. This routine needs to return a copy, 
     * so make one now.
     */
    if (pch && !pchReturn) 
	pchReturn = (unsigned char *) XtNewString ((String) pch);

    return (pchReturn);
}


/*************************************<->*************************************
 *
 *  _DtWmParseBackUp (pWmPB, pchTok)
 *
 *
 *  Description:
 *  -----------
 *  Backs up to the previous token (the one before pchTok) 
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= ptr to parse buffer
 *  pchTok	= ptr to a token in the parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  Returns	= ptr to prev token
 *
 *
 *  Comments:
 *  --------
 *  Operates on the line buffer in the pWmPB structure. Backs up
 *  the next pointer and writes a space over the interpolated
 *  NULL (if any).
 * 
 *************************************<->***********************************/

unsigned char *
_DtWmParseBackUp (
    DtWmpParseBuf *pWmPB,
    unsigned char *pchTok
    )
{
    if ((pchTok > pWmPB->pchLine) &&
	(pchTok < (pWmPB->pchLine +  pWmPB->cLineSize)))
    {
	unsigned char *pch;
	unsigned char *pchLast;
	int chlen;

	pch = pchLast = pWmPB->pchLine;

	/*
	 * Search from beginning (because of multibyte chars) to
	 * find the token before the string we're interested in.
	 */
	while ((pch < pchTok))
	{
	    chlen = mblen ((char *)pch, MB_CUR_MAX);
	    if (*pch == '\0')
	    {
		pch++;
		if (pch == pchTok)
		{
		    /*
		     * Found the NULL preceding the string passed in!
		     * Replace it with a blank and return the previous
		     * token (pointed to by pchLast).
		     */
		    *(pch - 1) = DTWM_CHAR_SPACE;
		    break;
		}
		else
		{
		    /* 
		     * Remember the beginning of this token.
		     */
		    pchLast = pch;
		}
	    }
	    else if (chlen < 1)
	    {
		break;
	    }
	    else
	    {
		pch += chlen;
	    }
	}

	pWmPB->pchNext = pchLast;
    }
    return (pWmPB->pchNext);
}



/*************************************<->*************************************
 *
 *  _DtWmParseSkipWhitespaceC(linePP)
 *
 *
 *  Description:
 *  -----------
 *  Scan the string, skipping over all white space characters.
 *
 *
 *  Inputs:
 *  ------
 *  linePP = nonNULL pointer to current line buffer pointer
 *
 * 
 *  Outputs:
 *  -------
 *  linePP = nonNULL pointer to revised line buffer pointer
 *
 *
 *  Comments:
 *  --------
 *  Assumes linePP is nonNULL
 * 
 *************************************<->***********************************/

void _DtWmParseSkipWhitespaceC(unsigned char  **linePP)
{
    while (*linePP && 
	   (mblen ((char *)*linePP, MB_CUR_MAX) == 1) && 
	   isspace (**linePP))
    {
        (*linePP)++;
    }

} /* END OF FUNCTION _DtWmParseSkipWhitespaceC */



/*************************************<->*************************************
 *
 *  _DtWmParseNextTokenC (linePP, SmBehavior)
 *
 *
 *  Description:
 *  -----------
 *  Returns the next quoted or whitespace-terminated nonquoted string in the
 *  line buffer.
 *  Additional functionality added to GetString in that anything in a
 *  quoted string is considered sacred and nothing will be stripped from
 *  the middle of a quoted string.
 *
 *
 *  Inputs:
 *  ------
 *  linePP =  pointer to current line buffer pointer.
 *  SmBehavior = flag that enables parsing session manager hints  if True.
 *               If False, this behaves as the normal OSF mwm GetString
 *               routine.
 *
 * 
 *  Outputs:
 *  -------
 *  linePP =  pointer to revised line buffer pointer.
 *  Return =  string 
 *
 *
 *  Comments:
 *  --------
 *  May alter the line buffer contents.
 *  Handles quoted strings and characters, removing trailing whitespace from
 *  quoted strings.
 *  Returns NULL string if the line is empty or is a comment.
 *  Code stolen from dtmwm.
 * 
 *************************************<->***********************************/

unsigned char *
_DtWmParseNextTokenC (
    unsigned char **linePP, 
    Boolean SmBehavior 
    )
{
/***********************************************************************
 *
 * The following code is duplicated from WmResParse.c (GetStringC)
 * GetStringC is the HP DT version of GetString. 
 *
 * It works here through the magic of #defines.
 *
 ***********************************************************************/
    unsigned char *lineP = *linePP;
    unsigned char *endP;
    unsigned char *curP;
    unsigned char *lnwsP;
    unsigned int  level = 0, checkLev, i, quoteLevel[MAX_QUOTE_DEPTH];
    int            chlen;

    /* get rid of leading white space */
    ScanWhitespace (&lineP);

    /*
     * Return NULL if line is empty, whitespace, or begins with a comment.
     */
    if (
	*lineP == '\0' ||
	((chlen = mblen ((char *)lineP, MB_CUR_MAX)) < 1) ||
        ((chlen == 1) && ((*lineP == '!') || 
			  ((!SmBehavior) && (*lineP == '#'))))
       )
    {
        *linePP = lineP;
        return (NULL);
    }

    if ((chlen == 1) && (*lineP == '"'))
    /* Quoted string */
    {
	quoteLevel[level] = 1;	
	/*
	 * Start beyond double quote and find the end of the quoted string.
	 * '\' quotes the next character.
	 * Otherwise,  matching double quote or NULL terminates the string.
	 *
	 * We use lnwsP to point to the last non-whitespace character in the
	 * quoted string.  When we have found the end of the quoted string,
	 * increment lnwsP and if lnwsP < endP, write NULL into *lnwsP.
	 * This removes any trailing whitespace without overwriting the 
	 * matching quote, needed later.  If the quoted string was all 
	 * whitespace, then this will write a NULL at the beginning of the 
	 * string that will be returned -- OK.
	 */
	lnwsP = lineP++;                /* lnwsP points to first '"' */
	curP = endP = lineP;            /* other pointers point beyond */

        while ((*endP = *curP) &&
               ((chlen = mblen ((char *)curP, MB_CUR_MAX)) > 0) &&
	       ((chlen > 1) || (*curP != '"')))
	/* Haven't found matching quote yet.
	 * First byte of next character has been copied to endP.
	 */
        {
	    curP++;
	    if ((chlen == 1) && (*endP == '\\') && 
		((chlen = mblen ((char *)curP, MB_CUR_MAX)) > 0))
	    /* character quote:
	     * copy first byte of quoted nonNULL character down.
	     * point curP to next byte
	     */
	    {
		if (SmBehavior)
		{
		    /*
		     * Check to see if this is a quoted quote - if it is
		     * strip off a level - if not - it's sacred leave it alone
		     */
		    checkLev = PeekAhead((curP - 1), quoteLevel[level]);
		    if(checkLev > 0)
		    {
			if(quoteLevel[level] >= checkLev)
			{
			    if (level > 0) level--;
			}
			else if (level < MAX_QUOTE_DEPTH)
			{
			    level++;
			    quoteLevel[level] = checkLev;
			}
			
			for(i = 0;i < (checkLev - 2);i++)
			{
			    *endP++ = *curP++;curP++;
			}
			*endP = *curP++;
		    }
		}
		else 
		{
		*endP = *curP++;
		}
            }

	    if (chlen == 1)
	    /* Singlebyte character:  character copy finished. */
	    {
	        if (isspace (*endP))
	        /* whitespace character:  leave lnwsP unchanged. */
	        {
	            endP++;
	        }
	        else
	        /* non-whitespace character:  point lnwsP to it. */
	        {
	            lnwsP = endP++;
	        }
	    }
	    else if (chlen > 1)
	    /* Multibyte (nonwhitespace) character:  point lnwsP to it.
	     * Finish character byte copy.
	     */
	    {
	        lnwsP = endP++;
		while (--chlen)
		{
		    *endP++ = *curP++;
		    lnwsP++;
		}
	    }
        }

	/*
	 *  Found matching quote or NULL.  
	 *  NULL out any trailing whitespace.
	 */

	lnwsP++;
	if (lnwsP < endP)
        {
	    *lnwsP = '\0';
        }
    }

    else
    /* Unquoted string */
    {
        /* 
	 * Find the end of the nonquoted string.
	 * '\' quotes the next character.
	 * Otherwise,  whitespace, NULL, or '#' terminates the string.
	 */
        curP = endP = lineP;

        while ((*endP = *curP) &&
               ((chlen = mblen ((char *)curP, MB_CUR_MAX)) > 0) &&
               ((chlen > 1) || (!isspace (*curP) && 
			        (SmBehavior || (*curP != '#')))))
	/* Haven't found whitespace or '#' yet.
	 * First byte of next character has been copied to endP.
	 */
        {
	    curP++;
	    if ((chlen == 1) && (*endP == '\\') && 
		((chlen = mblen ((char *)curP, MB_CUR_MAX)) > 0))
	    /* character quote:
	     * copy first byte of quoted nonNULL character down.
	     * point curP to next byte
	     */
	    {
		*endP = *curP++;
            }
	    endP++;
	    if (chlen > 1)
	    /* Multibyte character:  finish character copy. */
	    {
		while (--chlen)
		{
		    *endP++ = *curP++;
		}
	    }
        }
    }

    /*
     * Three cases for *endP:
     *   '#' --> write NULL over # and point to NULL
     *   whitespace or
     *     matching quote -> write NULL over char and point beyond
     *   NULL -> point to NULL 
     */

    if (!SmBehavior && (*endP == '#'))
    {
	*endP = '\0';       /* write NULL over '#' */
	*linePP = endP;     /* point to NULL */
    }
    else if (*endP != '\0')
    {
	*endP = '\0';       /* write NULL over terminator */
	*linePP = ++curP;   /* point beyond terminator */
    }
    else
    {
	*linePP = endP;
    }
    return ((unsigned char *)lineP);

} /* END OF FUNCTION _DtWmParseNextTokenC */



/*************************************<->*************************************
 *
 *  (DtWmParseBuf *) _DtWmParseNewBuf (void)
 *
 *
 *  Description:
 *  -----------
 *  Allocates a new parse record for parsing. 
 *
 *  Inputs:
 *  ------
 *  none 
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= ptr to parse buffer record, NULL if memory allocation
 *		  error.
 *
 *
 *  Comments:
 *  --------
 *  Call this first before using the other DtWmp routines that require
 *  a parse buffer. Treat this as an opaque type; use the provided 
 *  routines to create, access, and destroy this structure.
 * 
 *************************************<->***********************************/

DtWmpParseBuf * 
_DtWmParseNewBuf ( void )

{
    DtWmpParseBuf *pWmPB;

    pWmPB = (DtWmpParseBuf *) XtMalloc (sizeof (DtWmpParseBuf));
    if (pWmPB)
    {
	pWmPB->pchLine = (unsigned char *) XtMalloc (MAXLINE+1);
	if (!pWmPB->pchLine)
	{
	    XtFree ((char *)pWmPB);
	    pWmPB = NULL;
	}
    }

    if (pWmPB)
    {
	pWmPB->lineNumber = 0;
	pWmPB->pchNext = pWmPB->pchLine;
	pWmPB->cLineSize = MAXLINE+1;
	pWmPB->pFile = NULL;
	*(pWmPB->pchLine) = '\0';
    }

    return (pWmPB);

} /* END OF FUNCTION _DtWmParseNewBuf */


/*************************************<->*************************************
 *
 *  (DtWmParseBuf *) _DtWmpIncBuf (pWmPB)
 *
 *
 *  Description:
 *  -----------
 *  Increases the size of the line buffer in the parse buffer
 *
 *  Inputs:
 *  ------
 *  pWmPB 	= pointer to a parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= ptr to parse buffer record, NULL if memory allocation
 *		  error.
 *
 *
 *  Comments:
 *  --------
 * 
 *************************************<->***********************************/

static DtWmpParseBuf * 
_DtWmpIncBuf (
    DtWmpParseBuf *pWmPB)

{
    if (pWmPB)
    {
	int ix;

	if (pWmPB->pFile)
	{
	    /* save index into old string */
	    ix = pWmPB->pchNext - pWmPB->pchLine;
	}

	pWmPB->pchLine = (unsigned char *) 
	    XtRealloc ((char *)pWmPB->pchLine, (pWmPB->cLineSize + MAXLINE));
	if (pWmPB->pchLine)
	{
	    pWmPB->cLineSize += MAXLINE;

	    if (pWmPB->pFile)
	    {
		/* restore index into new string */
		pWmPB->pchNext = pWmPB->pchLine + ix;
	    }
	}
    }

    return (pWmPB);

} /* END OF FUNCTION _DtWmpIncBuf */


/*************************************<->*************************************
 *
 *  _DtWmParseDestroyBuf (pWmPB)
 *
 *
 *  Description:
 *  -----------
 *  Destroys a parse buffer record, freeing any allocated memory.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= ptr to previously allocated parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  none
 *
 *
 *  Comments:
 *  --------
 *  Destroys parse buffers allocated by _DtWmParseNewBuf.
 * 
 *************************************<->***********************************/

void 
_DtWmParseDestroyBuf (
    DtWmpParseBuf *pWmPB
    )

{
    if (pWmPB)
    {
	if (pWmPB->pchLine)
	{
	    XtFree ((char *) pWmPB->pchLine);
	}
	XtFree ((char *) pWmPB);
    }

} /* END OF FUNCTION _DtWmParseDestroyBuf */


/*************************************<->*************************************
 *
 *  (unsigned char *) _DtWmParseSetLine (pWmPB, pch)
 *
 *
 *  Description:
 *  -----------
 *  Sets a line into the parse buffer structure. This is used in cases
 *  where parsing of an embedded string, usually a default, is done
 *  instead of parsing out of a file.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= previously allocated parse buffer 
 *  pch		= ptr to unsigned char string (zero terminated)
 * 
 *  Outputs:
 *  -------
 *  Return	= pch
 *
 *
 *  Comments:
 *  --------
 *  This resets any previous setting of the file pointer. EOF wil be 
 *  returned when the string pointed to by pch is exhausted.
 *
 *  Resets line number count.
 * 
 *************************************<->***********************************/

void 
_DtWmParseSetLine (
    DtWmpParseBuf  *pWmPB,
    unsigned char  *pch
    )

{
    if (pWmPB)
    {
	pWmPB->pchLine = pch;
	pWmPB->pchNext = pWmPB->pchLine;
	pWmPB->pFile = NULL;
	pWmPB->lineNumber = 0;
    }

} /* END OF FUNCTION _DtWmParseSetLine */


/*************************************<->*************************************
 *
 *  (FILE *) _DtWmParseSetFile (pWmPB, pFile)
 *
 *
 *  Description:
 *  -----------
 *  Sets the file pointer in a parse buffer. This is used when parsing 
 *  from a file is required. 
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= pointer to a parse buffer
 *  pFile	= pointer to an opened FILE
 * 
 *  Outputs:
 *  -------
 *  Return	= pFile
 *
 *
 *  Comments:
 *  --------
 *  You fopen the file first, then pass in the FILE * returned to this
 *  routine.
 *
 *  Resets line number count.
 * 
 *************************************<->***********************************/

void 
_DtWmParseSetFile (
    DtWmpParseBuf *pWmPB,
    FILE *pFile
    )

{
    if (pWmPB)
    {
	pWmPB->pchLine[0] = '\0';
	pWmPB->pchNext = NULL;
	pWmPB->pFile = pFile;
	pWmPB->lineNumber = 0;
    }

} /* END OF FUNCTION _DtWmParseSetFile */


/*************************************<->*************************************
 *
 *  (unsigned char *) _DtWmParseNextLine ( pWmPB )
 *
 *
 *  Description:
 *  -----------
 *  Returns a pointer to the next line to parse.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= pointer to a parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= pointer to next line to parse or NULL on EOF.
 *
 *
 *  Comments:
 *  --------
 *  
 * 
 *************************************<->***********************************/

unsigned char * 
_DtWmParseNextLine (
    DtWmpParseBuf *pWmPB
    )

{
/***********************************************************************
 *
 * The following code is duplicated from WmResParse.c (GetNextLine)
 * It works here through the magic of #defines.
 *
 ***********************************************************************/

    unsigned char	*string;
    int				len;
    int   chlen;
    wchar_t last;
    wchar_t wdelim;
    char delim;
    int lastlen;

    if (cfileP != NULL)
    /* read fopened file */
    {
	if ((string = (unsigned char *) 
		      fgets ((char *)line, MAXLINE, cfileP)) != NULL)
	{
#ifdef PARSE_LIB
	    if (strlen((char *)string) > (size_t)pWmPB->cLineSize)
	    {
		/*
		 * Bump size of destination buffer
		 */
		pWmPB->cLineSize = 1 + strlen((char *)string);
		pWmPB->pchLine = (unsigned char *) 
		    XtRealloc ((char *)pWmPB->pchLine, 
			       (pWmPB->cLineSize));
	    }
#endif /* PARSE_LIB */

	    lastlen = 0;
	    while (*string &&
		   ((len = mblen((char *)string, MB_CUR_MAX)) > 0))
	    {
		mbtowc(&last, (char *)string, MB_CUR_MAX);
		lastlen = len;
		string += len;
	    }
	    delim = '\\';
	    mbtowc(&wdelim, &delim, MB_CUR_MAX);
	    if (lastlen == 1 && last == wdelim)
	    {
		do
		{
		    if (!fgets((char *)string, MAXLINE - (string - line), cfileP))
			break;

		    lastlen = 0;
		    while (*string &&
			   ((len = mblen((char *)string, MB_CUR_MAX)) > 0))
		    {
			mbtowc(&last, (char *)string, MB_CUR_MAX);
			lastlen = len;
			string += len;
		    }
		    linec++;
		}
		while (lastlen == 1 && last == wdelim);
	    }
	    string = line;
	}
    }
    else if ((parseP != NULL) && (*parseP != '\0'))
    /* read parse string */
    {
#ifdef PARSE_LIB
        if (strlen((char *)parseP) > (size_t)pWmPB->cLineSize)
	{
	    /*
	     * Bump size of destination buffer
	     */
	    pWmPB->cLineSize = 1 + strlen((char *)parseP);
	    pWmPB->pchLine = (unsigned char *) 
		XtRealloc ((char *)pWmPB->pchLine, 
			   (pWmPB->cLineSize));
	}
#endif /* PARSE_LIB */
	string = line;

	while ((*parseP != '\0') &&
               ((chlen = mblen ((char *)parseP, MB_CUR_MAX)) != 0) &&
	       (*parseP != '\n'))
	/* copy all but end-of-line and newlines to line buffer */
	{
            if (chlen == -1)
	       parseP++;
	    else
            {
                while (chlen--)
                {
                   *(string++) = *(parseP++);
                }
            }
        }
	*string = '\0';
	if (*parseP == '\n')
	{
	    parseP++;
	}
    }
    else
    {
	string = NULL;
    }

    linec++;
#ifdef PARSE_LIB
    if (cfileP)
    {
	/* update pchNext to get next line */
	pWmPB->pchNext = string;
    }
#endif /* PARSE_LIB */
    return (string);


} /* END OF FUNCTION _DtWmParseNextLine */


/*************************************<->*************************************
 *
 *  (unsigned char *) _DtWmParseCurrentChar (pWmPB)
 *
 *
 *  Description:
 *  -----------
 *  Returns a pointer to the rest of the current line.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= pointer to a parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= pointer to the rest of the current line
 *
 *
 *  Comments:
 *  --------
 *  Useful in cases where you want to look at a char before getting the
 *  next token or if you want to treat the rest of the line as a
 *  single token.
 * 
 *************************************<->***********************************/

unsigned char * 
_DtWmParseCurrentChar (
    DtWmpParseBuf *pWmPB
    )

{
    return (pWmPB ? pWmPB->pchNext : (unsigned char *)NULL);

} /* END OF FUNCTION _DtWmParseCurrentChar */



/*************************************<->*************************************
 *
 *  (unsigned char *) _DtWmParseNextChar (pWmPB)
 *
 *
 *  Description:
 *  -----------
 *  Advances the pointer to the next char and returns a pointer
 *  to the new current char.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= pointer to a parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= pointer to the rest of the current line
 *
 *
 *  Comments:
 *  --------
 * 
 *************************************<->***********************************/

unsigned char * 
_DtWmParseNextChar (
    DtWmpParseBuf *pWmPB
    )

{
    unsigned char *pch = NULL;
    int chlen;

    if (pWmPB &&
	pWmPB->pchNext &&
	(chlen = mblen((char *)pWmPB->pchNext, MB_CUR_MAX) > 0))
    {
	pch = (pWmPB->pchNext += chlen);
    }

    return (pch);
}


/*************************************<->*************************************
 *
 *  (int) _DtWmParseLineNumber (pWmPB)
 *
 *
 *  Description:
 *  -----------
 *  Returns the number of the current line of what's being parsed.
 *
 *
 *  Inputs:
 *  ------
 *  pWmPB	= ptr to parse buffer
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= number of current line
 *
 *
 *  Comments:
 *  --------
 *  Used for error reporting.
 *
 *  The line number is computed by counting '\n' characters.
 * 
 *************************************<->***********************************/

int 
_DtWmParseLineNumber (
    DtWmpParseBuf *pWmPB
    )

{
    return (pWmPB ? pWmPB->lineNumber : 0);

} /* END OF FUNCTION _DtWmParseLineNumber */


/*************************************<->*************************************
 *
 *  _DtWmParseToLower (string)
 *
 *
 *  Description:
 *  -----------
 *  Lower all characters in a string.
 *
 *
 *  Inputs:
 *  ------
 *  string = NULL-terminated character string or NULL
 *
 * 
 *  Outputs:
 *  -------
 *  string = NULL-terminated lower case character string or NULL
 *
 *
 *  Comments:
 *  --------
 *  Can handle multi-byte characters
 * 
 *************************************<->***********************************/

void _DtWmParseToLower (char  *string)
{
    char *pch = string;
    int            chlen;

    while ((chlen = mblen (pch, MB_CUR_MAX)) > 0)
    {
        if ((chlen == 1) && (isupper (*pch)))
	{
	    *pch = tolower(*pch);
	}
	pch += chlen;
    }

} /* END OF FUNCTION _DtWmParseToLower */



/*************************************<->*************************************
 *
 *  _DtWmParsePeekAhead (currentChar, currentLev)
 *
 *
 *  Description:
 *  -----------
 *  Returns a new level value if this is a new nesting level of quoted string
 *  Otherwise it returns a zero
 *
 *
 *  Inputs:
 *  ------
 *  currentChar = current position in the string
 *  currentLev = current level of nesting
 *
 * 
 *  Outputs:
 *  -------
 *  Returns either a new level of nesting or zero if the character is copied in
 *
 *
 *  Comments:
 *  --------
 * 
 *************************************<->***********************************/
unsigned int _DtWmParsePeekAhead(unsigned char *currentChar,
		       unsigned int currentLev)


{
    Boolean		done = False;
    unsigned int 	tmpLev = 1;
    unsigned int	chlen;

    while (((chlen = mblen ((char *)currentChar, MB_CUR_MAX)) > 0) &&
	   (chlen == 1) && ((*currentChar == '"') || (*currentChar == '\\'))
	   && (done == False))
    {
	currentChar++;

	if(((chlen = mblen ((char *)currentChar, MB_CUR_MAX)) > 0) && 
	   (chlen == 1) &&
	   ((*currentChar == '"') || (*currentChar == '\\')))
	{
	    tmpLev++;
	    if(*currentChar == '"')
	    {
		done = True;
	    }
	    else
	    {
		currentChar++;
	    }
	}
    }

    /*
     * Figure out if this is truly a new level of nesting - else ignore it
     * This section probably could do some error checking and return -1
	 * If so, change type of routine from unsigned int to int
     */
    if(done == True)
    {
	return(tmpLev);
    }
    else
    {
	return(0);
    }
} /* END OF FUNCTION _DtWmParsePeekAhead */



/*************************************<->*************************************
 *
 *  (unsigned char *) _DtWmParseFilenameExpand (pchFilename)
 *
 *
 *  Description:
 *  -----------
 *  Returns a copy of a file name with environment variables
 *  expanded.
 *
 *
 *  Inputs:
 *  ------
 *  pchFilename	= ptr to a zero terminated character string (filename)
 *
 * 
 *  Outputs:
 *  -------
 *  Return	= ptr to a new file name with environment variables 
 *                expanded.
 *
 *
 *  Comments:
 *  --------
 *  The passed in string is temporarily modified inside here.
 * 
 *  Free the returned string with XtFree().
 *
 *  Returns NULL on a memory allocation error.
 *
 *  Environment variables that can't be expanded are removed from
 *  the returned copy.
 *
 *  If no environment variables, you get a copy of the string back.
 * 
 *************************************<->***********************************/
unsigned char *
_DtWmParseFilenameExpand (
    unsigned char *pchFilename
    )

{
    unsigned char *pchN, *pchNew, *pchO;
    unsigned char *pchEnv, *pchEnv0, *pchEnv1;
    unsigned char chSave;
    int len, n, nx, ix;
    unsigned char pchBrk[] = { DTWM_CHAR_ENVIRONMENT,
			       DTWM_CHAR_DIRECTORY,
			       '\0'
			     };

    len = strlen ((char *)pchFilename);
    pchNew = (unsigned char *) XtMalloc (1+len);
    pchO = pchFilename;
    chSave = '\0';
    ix = 0;

    while (pchNew && pchO && *pchO)
    {
	/* find next environment variable */
	pchEnv0 = (unsigned char *) 
		strchr ((char *)pchO, (int) DTWM_CHAR_ENVIRONMENT);
	if (pchEnv0)
	{
	    /* length to this point */
	    n = pchEnv0 - pchO;

	    /* copy up to environment character */
	    if (n) 
	    {
		memcpy (&pchNew[ix], pchO, n);
		ix += n;
	    }

	    /* skip environment character */
	    pchEnv0++;	

	    /* end of variable is at one of:
	     *   start of next variable,
	     *   start of next directory,
	     *   end of string 
	     */
	    pchEnv1 = (unsigned char *) 
			strpbrk ((char *)pchEnv0, (char *)pchBrk);

	    if (pchEnv1)
	    {
		/* next string starts after this one */
		pchO = pchEnv1; 
		n = pchEnv1 - pchEnv0 + 1;

		/* replace this char with NULL for now */
		chSave = *pchEnv1;
		*pchEnv1 = '\0';
	    }
	    else
	    {
		/* This environment variable is the last thing on
		 * the line. Signal all done.
		 */
		n = strlen ((char *) pchO);
		pchO += n;
	    }

	    pchEnv = (unsigned char *) getenv ((char *)pchEnv0);
	    if (pchEnv) 
	    {
	        nx = strlen ((char *) pchEnv);
	        if (nx > n)
	        {
		    len += nx - n;
		    pchNew = (unsigned char *) 
			XtRealloc ((char *)pchNew, 1+len);
		}
		if (pchNew)
		{
		    memcpy (&pchNew[ix], pchEnv, nx);
		    ix += nx;
		}
		else 
		{
		    continue;
		}
	    }

	    if (chSave)
	    {
		*pchO = chSave;
		chSave = '\0';
	    }
	    /* keep a kosher string */
	    pchNew[ix] = '\0';
	}
	else
	{
	    /* copy the rest of the string */
	    n = strlen ((char *) pchO);
	    memcpy (&pchNew[ix], pchO, n);
	    pchO += n;

	    /* remember the NULL! (a famous battle cry) */
	    pchNew[ix + n] = '\0';
	}
    }

    return (pchNew);

} /* END OF FUNCTION _DtWmParseFilenameExpand */


/*************************************<->*************************************
 *
 *  unsigned char * _DtWmParseExpandEnvironmentVariables (pch, pchBrk)
 *
 *
 *  Description:
 *  -----------
 *  Expands environment variables in a string.
 *
 *
 *  Inputs:
 *  ------
 *  pch   = ptr to a zero terminated character string 
 *  pchBrk = array of "break" characters (see strpbrk()).
 * 	     defaults are used if this is NULL.
 * 
 *  Outputs:
 *  -------
 *  Return = string with expanded environment variables. (free with XtFree)
 *	     NULL string if no environment variables or backslashes
 *	     found in the string passed in.
 *
 *
 *  Comments:
 *  --------
 *  Free returned string with XtFree()
 *
 *  Environment variables that can't be expanded are removed from
 *  the returned copy.
 *
 *  Default delimiter set is [Space], [Tab], '$', [Newline], '\', '/'.
 *
 *  Variables of form $(..) and ${..} supported.
 *
 *  A backslash '\' in front of any character quotes it. The backslash 
 *  is removed in the returned string. A literal backslash needs to be
 *  quoted with a backslash.
 * 
 *************************************<->***********************************/
unsigned char *
_DtWmParseExpandEnvironmentVariables (
    unsigned char *pch,
    unsigned char *pchBrk
    )

{
    int chlen;
    unsigned char *pchStart;
    unsigned char chSave;
    unsigned char *pchEnvStart;
    unsigned char *pchEnvValue;
    unsigned char *pchReturn = NULL;
    unsigned char *pchNext;
    unsigned char *pchBreak;
    Boolean bEatBreak;
    Boolean bAlreadyAdvanced;
    int lenOriginal;
    int lenNonEnv;
    int lenEnvVar;
    int lenEnvValue;
    int lenReturn = 0;
    int lenSave;
    static unsigned char pchDefaultBrk[] = { 
				DTWM_CHAR_ENVIRONMENT,
				DTWM_CHAR_SPACE,
				DTWM_CHAR_TAB,
				DTWM_CHAR_NEW_LINE,
				DTWM_CHAR_BACKSLASH,
			        DTWM_CHAR_DIRECTORY,
				'\0' };
    unsigned char pchParenBrk[] = {   
				DTWM_CHAR_R_PAREN,
				'\0' };
    unsigned char pchBraceBrk[] = {   
				DTWM_CHAR_R_BRACE,
				'\0' };

    /* There needs to be something to look at */
    if (!pch)
	return (NULL);

    pchStart = pch;
    lenOriginal = strlen ((char *)pch);
    chlen = mblen ((char *)pch, MB_CUR_MAX);
    chSave = '\0';

    while (*pch && (chlen > 0))
    {
	if (chlen == 1)
	{
	    bAlreadyAdvanced = False;
	    switch (*pch)
	    {
		case DTWM_CHAR_BACKSLASH:
		    /*
		     * Copy up to start of quoted char
		     */
		    if (!pchReturn)
		    {
			lenReturn = lenOriginal + 1;
			pchReturn = (unsigned char *) 
			    XtMalloc (lenReturn * sizeof (unsigned char));
			pchReturn[0] = '\0';
		    }
		    chSave = *pch;
		    *pch = '\0';
		    strcat ((char *) pchReturn, (char *)pchStart);
		    *pch = chSave;
		    chSave = '\0';

		    /* 
		     * The next character is "escaped", skip over it.
		     */
		    pchStart = pch += chlen;
		    chlen = mblen ((char *)pch, MB_CUR_MAX);
		    break;

		case DTWM_CHAR_ENVIRONMENT:
		    /* save start of environment variable */
		    pchEnvStart = pch;
		    pch += chlen;
		    chlen = mblen ((char *)pch, MB_CUR_MAX);

		    /*
		     * Copy up to start of environment variable 
		     */
		    if (!pchReturn)
		    {
			lenReturn = lenOriginal + 1;
			pchReturn = (unsigned char *) 
			    XtMalloc (lenReturn * sizeof (unsigned char));
			pchReturn[0] = '\0';
			lenSave = 0;
		    }
		    else
		    {
			lenSave = strlen ((char *)pchReturn);
		    }
		    lenNonEnv = pchEnvStart - pchStart;
		    memcpy (&pchReturn[lenSave], pchStart, lenNonEnv);
		    pchReturn[lenSave+lenNonEnv] = '\0';

		    /* 
		     * Determine how we find the end of this 
		     * environment variable.
		     */
		    bEatBreak = False;
		    if ((chlen == 1)  &&
			(*pch == DTWM_CHAR_L_PAREN))
		    {
			pch += chlen;
			chlen = mblen ((char *)pch, MB_CUR_MAX);
			pchBreak = pchParenBrk;
			bEatBreak = True;
		    }
		    else if ((chlen == 1)  &&
			(*pch == DTWM_CHAR_L_BRACE))
		    {
			pch += chlen;
			chlen = mblen ((char *)pch, MB_CUR_MAX);
			pchBreak = pchBraceBrk;
			bEatBreak = True;
		    }
		    else if (pchBrk && *pchBrk)
		    {
			pchBreak = pchBrk;
		    }
		    else
		    {
			pchBreak = pchDefaultBrk;
		    }

		    /* 
		     * Look for end of environment variable
		     */
		    pchNext = (unsigned char *)
			    strpbrk ((char *)pch, (char *)pchBreak);

		    if (!pchNext)
		    {
			/* it's the rest of the string */
			chSave = '\0';
			bEatBreak = False;
			pchNext = pch + strlen ((char *) pch);
		    }
		    else
		    {
			/* temporarily put a string terminator here */
			chSave = *pchNext;
			*pchNext = '\0';
		    }

		    /*
		     * Lookup environment variable
		     */
		    lenEnvVar = strlen ((char *)pch);
		    pchEnvValue = (unsigned char *) getenv ((char *)pch);

		    if (pchEnvValue)
		    {
			/*
			 * Insure there's enough room in the return string
			 */
			lenEnvValue = strlen ((char *)pchEnvValue);
			if (!pchReturn)
			{
			    lenReturn = lenOriginal + 1 - lenEnvVar +
						lenEnvValue;
			    pchReturn = (unsigned char *) 
				XtMalloc (lenReturn * sizeof (unsigned char));
			    pchReturn[0] = '\0';
			}
			else
			{
			    lenReturn = lenReturn + 1 - lenEnvVar +
						lenEnvValue;
			    pchReturn = (unsigned char *) 
				XtRealloc ((char *)pchReturn, 
				    lenReturn * sizeof (unsigned char));
			}

			/*
			 * Tack it onto the return string
			 */
			strcat ((char *)pchReturn, (char *)pchEnvValue);
		    }

		    /*
		     * Advance the pointer for the next pass
		     */
		    if (chSave)
		    {
			/* restore saved character */
			*pchNext = chSave;
			chSave = '\0';

			/* 
			 *  If this was a closing paren, then skip it
			 */
			if (bEatBreak)
			{
			    chlen = mblen ((char *)pchNext, MB_CUR_MAX);
			    pchNext += chlen;
			}
		    }
		    pchStart = pch = pchNext;
		    chlen = mblen ((char *)pch, MB_CUR_MAX);
		    /*
		     * We're already pointing at the next character
		     * to process, don't advance again!
		     */
		    bAlreadyAdvanced = True;

		    break;

		default:
		    /* this character is not interesting */
		    break;
	    }

	    /*
	     * Move to the next character if we're not already
 	     * there.
	     */
	    if (!bAlreadyAdvanced)
	    {
		pch += chlen; 
		chlen = mblen ((char *)pch, MB_CUR_MAX);
	    }
	}
	else
	{
	    pch += chlen;
            chlen = mblen ((char *)pch, MB_CUR_MAX);
	}
    }

    if (pchReturn && *pchStart)
    {
	/*
	 * Copy remaining parts of the string
	 */
	strcat ((char *)pchReturn, (char *)pchStart);
    }

    return (pchReturn);

} /* END OF FUNCTION _DtWmParseExpandEnvironmentVariables */



/******************************<->*************************************
 *
 *  _DtWmParseMakeQuotedString (pchLine)
 *
 *
 *  Description:
 *  -----------
 *  Encapsulates the passed in "line" into a string argument quoted
 *  by double quotes. Special characters are "escaped" as needed.
 *
 *  Inputs:
 *  ------
 *  pchLine = ptr to string to enclose in quotes
 *
 *  Outputs:
 *  -------
 *  Return = ptr to quoted string 
 *
 *  Comment:
 *  -------
 *  Returned string should be freed with XtFree().
 * 
 ******************************<->***********************************/

unsigned char *
_DtWmParseMakeQuotedString (unsigned char *pchLine)
{
    unsigned char *pchRet;
    int iLen0, iLen1;
    int cSpecial;
    int i,j;
    int   chlen;

    iLen0 = strlen ((char *)pchLine);
    iLen1 = iLen0 + 2; /* for starting, ending quotes */

    for (i=0; i < iLen0; i++)
    {
        /*
	 * Count special chars to get estimate of new length
	 */
        chlen = mblen ((char *) &pchLine[i], MB_CUR_MAX);
	if ((chlen == 1) &&
	    ((pchLine[i] == '\\') ||
	     (pchLine[i] == '"')))
	{
	    iLen1++;
	}
	else if (chlen < 1)
	{
	    break;
	}
	else 
	{
	    i += chlen-1;
	}
    }

    pchRet = (unsigned char *) XtMalloc (1+iLen1);

    if (pchRet)
    {
	pchRet[0] = '"';	/* starting quote */
	/*
	 * Copy chars from old string to new one
	 */
	for (i=0, j=1; i < iLen0; i++, j++)
	{
	    chlen = mblen ((char *) &pchLine[i], MB_CUR_MAX);
	    if ((chlen == 1) &&
		((pchLine[i] == '\\') ||
		 (pchLine[i] == '"')))
	    {
		/* quote next char */
		pchRet[j++] = '\\';
	    }
	    else if (chlen < 1)
	    {
		break;
	    }
	    else while (chlen > 1)
	    {
		/* copy first bytes of multibyte char */
		pchRet[j++] = pchLine[i++];
		chlen--;
	    }
	    /* copy char */
            pchRet[j] = pchLine[i];
	}
	pchRet[j++] = '"'; 	/* ending quote */
	pchRet[j] = '\0';	/* end of string */
    }

    return (pchRet);

} /* END OF FUNCTION _DtWmParseMakeQuotedString */


/*==================== END OF FILE   WmParse.c ====================*/