Example #1
0
static VOID
eqck_idstrip(char *idname, char *stripid )
{
    register char	*cp = idname;

    if (*cp == '"')		/* Get rid of starting double quote */ 
	CMnext(cp);

    /* Get rid of embedded double quotes */
    while (*cp)
    {
	if (*cp == '"')
	{
	    if (*(cp+1) == '"')		/* Skip escaped embedded quotes */
		CMnext(cp);
	    if (*(cp+1) == '\0')	/* Skip last quote */
	    {
	    	*stripid = '\0';
	    	break;
	    }	
	}
	CMcpyinc(cp, stripid);
    }
    if (*stripid != '\0')
	*stripid = '\0';
}
Example #2
0
/*{
** Name: cus_trmwhite 	- Trim trailing white space.
**
** Description:
**      Used by the parser facility for trimming trailing white space
**      in character texts residing in memory. The text may be null terminated
**	but doesn't have to be. This is the reason why the length argument
**	is passed along with the buffer pointer. This routine is currently
**	only used in calls to psf_error to make text presented to recipients
**	of error messages more user friendly.
**
** Inputs:
**      len				Max length to be scanned for white space
**	bufp				Pointer to the buf holding char data
**					(does not have to be null terminated)
** Outputs:
**	Returns:
**	    Length			Length of non-white part of the string
**
**	Exceptions:
**	    None.
**
** Side Effects:
**	    None.
**
** History:
**	11-apr-87 (stec)
**          written
**	16-apr-87 (stec)
**	    changed a little.
**	    Addressed performance and Kanji issues.
**	02-may-1990 (fred)
**	    Revamped to trim trailing white space from an arbitrary string.
**	    Previously, it was assumed that trailing white space started
**	    with the first bit o' white space from the beginning.  The routine
**	    will now trim from the end back.  This was necessitated for BLOB
**	    support which is the first case of a datatype name with an embedded
**	    blank (standard name - 'long varchar').
**	25-mar-93 (rickh)
**	    Moved here from PSFTRMWH.C and renamed with a cuf prefix.
*/
i4
cus_trmwhite(
	u_i4	len,
	char	*bufp)
{
    register char   *ep;    /* pointer to end of buffer (one beyond) */
    register char   *p;
    register char   *save_p;

    if (!bufp)
    {
	return (0);
    }

    p = bufp;
    save_p = p;
    ep = p + (int)len;
    for (; (p < ep) && (*p != EOS); )
    {
	if (!CMwhite(p))
	    save_p = CMnext(p);
	else
	    CMnext(p);
    }

    return ((i4)(save_p - bufp));
}
Example #3
0
/*
** Name: gwsxa_rightTrimBlank - trim blanks off tails of a (possibly non-terminated)
**	 string. 
** 
** Description:
**	This routine walks through a (possibly non-NULL-terminated) string
**	up to maxlen bytes looking for last non-space character. It then
**      steps over that character and replaces the ensuing space with a NULL.
**
**      This function differs from gwsxa_zapblank() above in that it will
**      allow embeded spaces to remain within the string.
**
** Returns:
**	Nothing.
**
** History:
**	04-Dec-2008 (coomi01) b121323
**	    Created
*/
VOID
gwsxa_rightTrimBlank(char *str, i4 maxlen)
{
    char *notBlankPtr;
    char *currPtr;
    char *endPtr;

    /*
    **  If passed an empty string then just return
    */
    if (!str || (maxlen<=0) )
	return;

    /*
    ** Init the pointers 
    */
    currPtr  = str;
    endPtr   = &str[maxlen];
    notBlankPtr = NULL;

    /* 
    ** Careful, The string maybe dbyte
    */
    while ( currPtr < endPtr )
    {
	if ( (*currPtr != EOS) && !CMspace(currPtr) )
	{
	    /* Save non-space position */
	    notBlankPtr = currPtr;
	}

	/*
	** Step forward
	*/
	CMnext(currPtr);
    }

    if ( NULL != notBlankPtr )
    {
	/* 
	** Step foward, over last non-blank
	*/
	CMnext(notBlankPtr);

	/* 
	** But do not write beyound buffer end
	*/
	if (notBlankPtr < endPtr)
	{
	    *notBlankPtr = EOS;
	}
    }
    else
    {
	/* 
	** String entirely composed of spaces 
	*/
	*str = EOS;
    }
}
Example #4
0
/*
 * regtry - try match at specific point
 */
static bool			/* 0 failure, 1 success */
regtry(RE_EXP *prog, char *string)
{
    register i4  i;
    register char **sp;
    register char **ep;

    reginput = string;
    regstartp = prog->startp;
    regendp = prog->endp;

    sp = prog->startp;
    ep = prog->endp;
    for (i = NSUBEXP; i > 0; i--) {
        *sp = NULL;
# ifndef DOUBLEBYTE
        CMnext( *sp );
# else
        sp++;
# endif /* #ifndef DOUBLEBYTE */
        *ep = NULL;
# ifndef DOUBLEBYTE
        CMnext( *ep );
# else
        ep++;
# endif /* #ifndef DOUBLEBYTE */
    }
    if (regmatch(prog->program + 1)) {
        prog->startp[0] = string;
        prog->endp[0] = reginput;
        return( TRUE );
    } else
        return( FALSE );
}
Example #5
0
size_t
STtrmnwhite_DB(
	char	*string,
	size_t    max_len)
{
	register char *p = string;
	register char *nw = p;
	register char *end = p + max_len;

	/*
	** after the loop, nw points to the first character beyond
	** the last non-white character.  Done this way because you
	** can't reverse scan a string with CM efficiently
	*/
	while (p < end && *p != EOS)
	{
		if (!CMwhite(p))
		{
			CMnext(p);
			nw = p;
		}
		else
			CMnext(p);
	}

	{
		register size_t nwl = nw - string;
		if (nwl < max_len)
			*nw = EOS;
		return nwl;
	}
}
Example #6
0
STATUS
s_srem_set()
{
    char	*s;
    char	*send;
    i4		pos;
    i4		n;
    char	short_remark[OOSHORTREMSIZE+1];

    if (St_sr_given)
    {
	s_error(0x3A8, NONFATAL, NULL);
	s_cmd_skip();
	return FAIL;
    }
    if (Cact_ren == NULL)
    {
	    s_error(0x38A, FATAL, NULL);
    }

    St_sr_given = TRUE;

    Tokchar++;
    while (CMspace(Tokchar) || *Tokchar == '\t')
    {
	CMnext(Tokchar);
    }

    s = short_remark;
    send = s + OOSHORTREMSIZE;
    while (*Tokchar != '\n' && *Tokchar != EOS)
    {
        if (s <= send-CMbytecnt(Tokchar))
	{
	    if (*Tokchar == '\t')
	    {
		/* if tab, replace it with the one blank */
		*s = ' ';
		s++;
		Tokchar++;
	    }
	    else
	    {
		CMcpyinc(Tokchar, s);
	    }
	}
	else
	{
	    CMnext(Tokchar);
	}
    }

    *s = EOS;
    Cact_ren->ren_shortrem = STalloc(short_remark);

    return OK;
}
Example #7
0
static i4
yylex( FILE *input )
{
	char *pscan;

	if( yygetline( input ) != OK )
		return( tEOF );

	/* Unless the -C flag was specified, blank out all of the comments */
	pscan = infile->yytext;
	while (pass_comments == FALSE && *pscan != EOS)
	{
		if (infile->yycomment == TRUE)
		{
			/* Look for the 'end comment' identifier */
			if (STbcompare(pscan,2,ERx("*/"),2,FALSE) == 0)
			{
				/* Blank out the 'end comment' characters */
				CMcpychar(ERx(" "), pscan);
				CMnext(pscan);
				CMcpychar(ERx(" "), pscan);

				/* Remember that the comment has ended */
				infile->yycomment = FALSE;
			}
			/* Blank out non-whitespace characters of the comment */
			else if (!CMwhite(pscan))
			{
				CMcpychar(ERx(" "), pscan);
			}
			/* Whitespace chars are skipped, this lets \n thru */
		}
		/* Look for the 'begin comment' identifier */
		else if (STbcompare(pscan,2,ERx("/*"),2,FALSE) == 0)
		{
			/* Blank out the 'begin comment' characters */
			CMcpychar(ERx(" "), pscan);
			CMnext(pscan);
			CMcpychar(ERx(" "), pscan);
			infile->yycomment = TRUE;
		}
		CMnext(pscan);	/* Continue the scan with the next character */
	}

	if( is_history(infile->yytext ) == OK)
	{
		return( tHISTORY ); 
	}

	if( *infile->yytext == '#' ) 
		return( tDIRECTIVE );

	return( tSOURCE );
}
Example #8
0
static void
yyputline( char *outtext)
{
	char token_buf[MAX_LINE+1];
	char token_val[MAX_LINE+1];
	char *p = token_buf;
	static char *symc = ERx( 
	   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_$");
	i4 symc_l = STlength(symc);
	i4 defidx;
	static i4  iterate_level = 0;

	/* Check to make sure we don't have runaway recursion */
	if (iterate_level++ > MAX_ITERATION)
	{
		SIfprintf( stderr, E_YAPP006 );
		yydump();
	}

	/* Break up the string into tokens and try to resolve symbols */
	while (*outtext != EOS)
	{
		p = token_buf;
		while (STindex(symc, outtext, symc_l) != NULL) {
			STlcopy(outtext, p, 1);
			CMnext(outtext);
			CMnext(p);
		}

		/* Found a token that may be defined as a symbol */
		if (p != token_buf)
		{
			/* If the token is defined then translate the */
			/* value of the substituted text, otherwise just */
			/* output the untranslated text. */
			STcopy(ERx(""), p);
			if (OK == is_defined(token_buf, token_val)) 
				yyputline( token_val );
			else 
				SIprintf("%s", token_buf);
		}

		/* The text being processed at this point is whitespace, */
		/* operators, or some other characters that are not */
		/* valid for tokens. */
		else 
		{
			SIputc(*outtext, stdout);
			CMnext(outtext);
		}
	}
	iterate_level--;
}
Example #9
0
/*
** Name: Disp_Form
**
** Decription:
**      Disposition: form-data; recevied with no filename.  Implies a page
**      variable name.
**      Extract the variable and store it in the upload structure for use
**      later.
**
** Inputs:
**      sess        ice session structure
**      line        pointer to the current line
**      linelen     length of the line
**
** Outputs:
**      pos         number of characters handled.
**
** Return:
**      GSTAT_OK    success
**      other       failure
**
** History:
**      23-Oct-98 (fanra01)
**          Created.
*/
static GSTATUS
Disp_Form (WTS_SESSION* sess, char* line, i4  linelen, i4 * pos)
{
    GSTATUS     err = GSTAT_OK;
    PWTS_UPLOAD load= sess->load;
    char*       p = line + *pos;
    char*       varname;
    i4          remain = linelen - *pos;
    i4          i = 0;
    i4          j = 0;

    if (STbcompare ("name", 4, p, 0, TRUE) == 0)
    {
        /*
        ** Find the first quote after name
        */
        while ((*p != '\"') && (i < remain))
        {
            CMbyteinc(i,p);
            CMnext(p);
        }
        CMbyteinc(i,p);     /* skip the quote */
        CMnext(p);
        varname= p;
        while ((*p != '\"') && (i < remain))
        {
            j+=CMbytecnt(p);
            CMbyteinc(i,p);
            CMnext(p);
        }
        CMbyteinc(i,p);     /* skip the quote */
        CMnext(p);
        /*
        ** Allocate space for the variable name a '=' character and an EOS
        */
        if ((err = GAlloc (&load->varname, j+2, FALSE)) == GSTAT_OK)
        {
            MEfill (j+2, 0, load->varname);
            MECOPY_VAR_MACRO (varname, j, load->varname);
            STcat (load->varname, "=");
        }
        *pos += i;
        load->state = US_VAL;
    }
    else
    {
        HandlerException (sess, line, linelen, pos);
    }
    return (err);
}
Example #10
0
static uchar
lookup(char *opname)
{
    i4  opn;
    uchar rtn = opNONE;
     
    /* 
    ** If there's an "=<value>" following the flag, point argval at the value,
    ** and then replace the "=" with an EOS... 
    */

    if (NULL != (argval = STindex(opname, ERx("="), 0)))
    {
	*argval = EOS;
	CMnext(argval);
	if (*argval == EOS)
	    return opNONE;
    }

    /* Look up the flag in the table... */

    for (opn = 0; opn < NUM_OPT; opn++)
    {
	if (!STbcompare(opname,99,option[opn].op_text,99,FALSE))
	{
	    if (rtn == opNONE)  /* First candidate we've found? */
		rtn = option[opn].op_id;
	    else
		return opNONE;  /* Not unique, apparently. */
	}
    }

    return rtn;
}
Example #11
0
char *
STrindex_DB(
	const char	*str,
	const char	*mstr,
	register size_t	len)
{
	char	*where = NULL;

	if (len <= 0)
		len = MAXI2;

	while (len > 0 && *str != '\0')
	{
		if (CMcmpcase(str, mstr) == 0)
			where = (char *)str;

		CMbytedec(len, str);
		CMnext(str);
	}

	if (where != NULL && *where != '\0')
		return (where);
	else
		return (NULL);
}
Example #12
0
static VOID
eqck_idschar(char *idname )
{
    register char	*cp = idname;

    if (*cp == '_')		/* Check if first char is an underscore */ 
    {
	er_write (E_EQ0515_FIPS_IDCHAR, EQ_WARN, 1, idname);
	return;
    }

    /* Check for special characters anywhere in the identifier */
    while (*cp)
    {
	/*
	** Check for special characters anywhere or for an underscore as
	** the last character.
	*/
	if (*cp == '$' || *cp == '@' || *cp == '#'
	    || (*cp == '_' && *(cp+1) == '\0'))
	{
	    er_write (E_EQ0515_FIPS_IDCHAR, EQ_WARN, 1, idname);
	    break;
	}
	CMnext(cp);
    }		
}
Example #13
0
/*
** Name: FWrite_Fenc
**
** Decription:
**      An encoding description for the following file.  Stored for use in
**      the furture.
**
** Inputs:
**      sess        ice session structure
**      line        pointer to the current line
**      linelen     length of the line
**
** Outputs:
**      pos         number of characters handled.
**
** Return:
**      GSTAT_OK    success
**      other       failure
**
** History:
**      23-Oct-98 (fanra01)
**          Created.
*/
static GSTATUS
FParm_Fenc (WTS_SESSION* sess, char* line, i4  linelen, i4 * pos)
{
    GSTATUS     err = GSTAT_OK;
    PWTS_UPLOAD load= sess->load;
    i4          remain = linelen - *pos;
    char*       p = line + *pos;
    char*       enc = NULL;
    i4          i=0;

    if ((err = GAlloc (&enc, remain + 1, FALSE)) == GSTAT_OK)
    {
        load->encode = enc;
        while (CMwhite(p))
        {
            CMbyteinc(i,p);
            CMnext(p);
        }
        while (i < remain)
        {
            CMbyteinc(i,p);
            CMcpyinc (p, enc);
        }
        load->state = US_FPARM;
    }
    *pos += i;
    return (err);
}
Example #14
0
/*
** Name: File_Mime
**
** Decription:
**      The mime type of the following file.  Extracted an saved for use in
**      in the future.
**
** Inputs:
**      sess        ice session structure
**      line        pointer to the current line
**      linelen     length of the line
**
** Outputs:
**      pos         number of characters handled.
**
** Return:
**      GSTAT_OK    success
**      other       failure
**
** History:
**      23-Oct-98 (fanra01)
**          Created.
*/
static GSTATUS
File_Mime (WTS_SESSION* sess, char* line, i4  linelen, i4 * pos)
{
    GSTATUS     err = GSTAT_OK;
    PWTS_UPLOAD load= sess->load;
    i4          remain = linelen - *pos;
    char*       p = line + *pos;
    char*       mime = NULL;
    i4          i=0;

    if ((err = GAlloc (&mime, remain + 1, FALSE)) == GSTAT_OK)
    {
        load->type = mime;
        while ((remain > 0) && CMwhite(p))
        {
            CMbyteinc(i,p);
            CMnext(p);
        }
        while (i < remain)
        {
            CMbyteinc(i,p);
            CMcpyinc (p, mime);
        }
        load->state = US_FPARM;
    }
    *pos += i;
    return (err);
}
Example #15
0
/*
** Name: check_path_chars   - test path characters are supported.
**
** Description:
**  Test that the characters in the path are permitted.
**
** Inputs:
**  loc                 Pointer to location structure containing path.
**
** Outputs:
**  status              More detailed error code for failure.
**
** Returns:
**  result      OK      No invalid characters found.
**              FAIL    Invalid characters found in path.
**
** History:
**      14-Feb-2005 (fanra01)
**          Create to replace call to LOisvalid.
**	03-Jun-2005 (drivi01)
**	    Replaced Window's portion of check_path_chars
**	    with LOisvalid.
**  11-Jul-2005 (fanra01)
**      Add status output.
*/
static i4
check_path_chars( LOCATION* loc, STATUS* status )
{
    i4 result = OK;
    char	dev[MAX_LOC];
    char	path[MAX_LOC];
    char	file[MAX_LOC];
    char	ext[MAX_LOC];
    char	vers[MAX_LOC];
    char	*p;

# if defined(NT_GENERIC)

    if (!LOisvalid( loc, &result ))
    {
        if (status != NULL)
        {
            *status = result;
        }
        return FAIL;
    }

# else  /* NT_GENERIC */
    if (LOdetail( loc, dev, path, file, ext, vers ) != OK)
        return FAIL;
    for (p = path; *p != EOS; CMnext(p))
    {
	if (!(CMalpha(p) || CMdigit(p) || CMcmpnocase(p, PATH_SEPARATOR) ||
        '_' || *p == ' '))
	    return FAIL;
    }
    for (p = file; *p != EOS; CMnext(p))
    {
	if (!(CMalpha(p) || CMdigit(p) || *p == '_' || *p == ' '))
	    return FAIL;
    }
    for (p = ext; *p != EOS; CMnext(p))
    {
	if (!(CMalpha(p) || CMdigit(p) || *p == '_' || *p == ' '))
	    return FAIL;
    }
# endif /* NT_GENERIC */
    
    return(result);
}
Example #16
0
/*
** Get the next character:
** It does not modify the parameter 'lpcText'
*/
char PeekNextChar (const char* lpcText)
{
	char* pch = (char*)lpcText;
	if (!pch)
		return '\0';
	CMnext(pch);
	if (!pch)
		return '\0';
	return *pch;
}
Example #17
0
/*{
** Name:	RPgetwords - parse a string into words
**
** Description:
**	RPgetwords() is similar to the CL STgetwords(), but allows
**	for the specification of word delimiters.  Consecutive word
**	delimiters in the parse string result in blank words.  The character
**	that follows the last non-white space character of each word is
**	replaced by the EOS character.
**
** Inputs:
**	delims		- pointer to string of delimiters
**	string		- pointer to string to be parsed
**	wordcount	- size of 'wordarray'
**
** Outputs:
**	wordcount	- number of words found
**	wordarray	- array of character pointers holding starting address
**			  of each word.
**
** Returns:
**	none
**
** Side effects:
**	Words in 'string' are terminated with EOS.
**/
void
RPgetwords(
char	*delims,
char	*string,
i4	*wordcount,
char	**wordarray)
{
	i4	count = 0;
	char	**org;
	char	*p;

	org = wordarray;

	while (count < *wordcount)
	{
		*wordarray++ = string;
		++count;

		p = string;
		while (*string != EOS && STindex(delims, string, 0) == NULL)
		{
			if (!CMwhite(string))
				p = string;
			CMnext(string);
		}
		if (p < string && !CMwhite(p))
			CMnext(p);

		if (*string == EOS)
		{
			*p = EOS;
			break;
		}

		*p = EOS;
		CMnext(string);
	}

	if (count < *wordcount)
		org[count] = NULL;
	*wordcount = count;
}
Example #18
0
/*
 * regpiece - something followed by possible [*+?]
 *
 * Note that the branching code sequences used for ? and the general cases
 * of * and + are somewhat optimized:  they use the same NOTHING node as
 * both the endmarker for their branch list and the body of the last branch.
 * It might seem that this node could be dispensed with entirely, but the
 * endmarker role is not redundant.
 */
static char *
regpiece(i4 *flagp)
{
    register char *ret;
    register char op;
    register char *next;
    i4 flags;

    ret = regatom(&flags);
    if (ret == NULL)
        return(NULL);

    op = *regparse;
    if (!ISMULT(op)) {
        *flagp = flags;
        return(ret);
    }

    if (!(flags&HASWIDTH) && op != '?')
        _FAIL("*+ operand could be empty");
    *flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);

    if (op == '*' && (flags&SIMPLE))
        reginsert(STAR, ret);
    else if (op == '*') {
        /* Emit x* as (x&|), where & means "self". */
        reginsert(BRANCH, ret);			/* Either x */
        regoptail(ret, regnode(BACK));		/* and loop */
        regoptail(ret, ret);			/* back */
        regtail(ret, regnode(BRANCH));		/* or */
        regtail(ret, regnode(NOTHING));		/* null. */
    } else if (op == '+' && (flags&SIMPLE))
        reginsert(PLUS, ret);
    else if (op == '+') {
        /* Emit x+ as x(&|), where & means "self". */
        next = regnode(BRANCH);			/* Either */
        regtail(ret, next);
        regtail(regnode(BACK), ret);		/* loop back */
        regtail(next, regnode(BRANCH));		/* or */
        regtail(ret, regnode(NOTHING));		/* null. */
    } else if (op == '?') {
        /* Emit x? as (x|) */
        reginsert(BRANCH, ret);			/* Either x */
        regtail(ret, regnode(BRANCH));		/* or */
        next = regnode(NOTHING);		/* null. */
        regtail(ret, next);
        regoptail(ret, next);
    }
    CMnext( regparse );
    if (ISMULT(*regparse))
        _FAIL("nested *?+");

    return(ret);
}
Example #19
0
/*
 * regrepeat - repeatedly match something simple, report how many
 */
static i4
regrepeat(char *p)
{
    register i4  count = 0;
    register char *scan;
    register char *opnd;

    scan = reginput;
    opnd = OPERAND(p);
    switch (OP(p)) {
    case ANY:
        count = STlength(scan);
        scan += count;
        break;
    case EXACTLY:
        while (*opnd == *scan) {
            CMbyteinc( count, scan );
            CMnext( scan );
        }
        break;
    case ANYOF:
        while (*scan != '\0' && STchr(opnd, *scan) != NULL) {
            CMbyteinc( count, scan );
            CMnext( scan );
        }
        break;
    case ANYBUT:
        while (*scan != '\0' && STchr(opnd, *scan) == NULL) {
            CMbyteinc( count, scan );
            CMnext( scan );
        }
        break;
    default:		/* Oh dear.  Called inappropriately. */
        _error("internal foulup");
        count = 0;	/* Best compromise. */
        break;
    }
    reginput = scan;

    return(count);
}
Example #20
0
/*
 * regc - emit (if appropriate) a byte of code
 */
static void
regc( char *b )
{
    if (regcode != &regdummy) {
        CMcpychar( b, regcode );
        CMnext( regcode );
    } else
# ifndef DOUBLEBYTE
        regsize++;
# else
        CMbyteinc(regsize, b);
# endif /* #ifndef DOUBLEBYTE */
}
Example #21
0
static int __inline IsBefore(char *p1 ,char *p2)
{
  char *p;
  if (!p1 || !p2)
    return 0;
  for (p=p1; *p ; CMnext(p))
    {
    if (_istalpha (*p))
      {
      p1=p;
      break;
      }
    }
  for (p=p2; *p ; CMnext(p))
    {
    if (_istalpha (*p))
      {
      p2=p;
      break;
      }
    }
  return (_tcsicmp (p1,p2)<0);
}
Example #22
0
void
main(int argc, char *argv[])
{
    char 	buf[ 4096 ];
    LPSTR	lpCmdLine;
    char	*startquote;
    char	*endquote;

    STprintf(buf, ERx( "iiabf abf" ));
    
    lpCmdLine = GetCommandLine();

    /*
    ** The current executable could have been invoked with the
    ** executable name in quotes.  If that is the case, skip
    ** over the quotes before looking for the arguments.
    */
    lpCmdLine = STskipblank( lpCmdLine, STlength(lpCmdLine) );
    if ( *lpCmdLine == '"' )
    {
	startquote = lpCmdLine;
	CMnext( startquote );
        if ( (endquote = STindex( startquote, "\"", 0 )) != NULL )
        {
    	    CMnext( endquote );
    	    lpCmdLine = endquote;
        }
    }
    if ( lpCmdLine = STindex(lpCmdLine, " ", 0) )
        STcat(buf, lpCmdLine);

    if ( execute(buf) != OK )
        PCexit(FAIL);

    PCexit(OK);
}
Example #23
0
int ExtractValue (char* pToken, int nKeyLen, char* szValue)
{
	int nEqual = 0;
	char* pItem = &pToken[nKeyLen];
	szValue[0] = '\0';
	if (pItem)
	{
		if (pItem[0] == '=')
		{
			nEqual = 1;
			CMnext(pItem);
			STcopy (pItem, szValue);
		}
	}
	return nEqual;
}
Example #24
0
char
*FIND_SEPstring(char *token,char *string)
{
    i4                     token_len ;
    i4                     string_len ;
    char                  *cp = NULL ;
    char                  *pp = NULL ;
    char                  *tp = NULL ;

    if (token == NULL || *token == EOS)
    {
        if (tracing&TRACE_PARM)
            SIfprintf(traceptr,ERx("FIND_SEPstring> token is null\n"));
        return (NULL);
    }
    if (string == NULL || *string == EOS)
    {
        if (tracing&TRACE_PARM)
            SIfprintf(traceptr,ERx("FIND_SEPstring> string is null\n"));
        return (NULL);
    }
    string_len = STlength(string);

    if ((token_len = STlength(token)) < string_len)
    {
        if (tracing&TRACE_PARM)
            SIfprintf(traceptr
                      ,ERx("FIND_SEPstring> token <%s> is too small (%d chars)\n")
                      ,token,token_len);

        return (NULL);
    }

    for (tp = token, cp = NULL, pp = NULL
                                     ; (*tp != EOS)&&(cp == NULL)&&(token_len-- >= string_len)
            ; CMnext(tp))
    {
        if ((STbcompare(tp, string_len, string, string_len, TRUE) == 0)
                &&((pp == NULL)||CMoper(pp)||CMwhite(pp)))
        {
            cp = tp;
        }
        pp = tp;
    }

    return (cp);
}
Example #25
0
static bool
apply_list( bool (*proc) (char *, bool) )
{
    char *featname, *featnext;
    bool only;
    char savechar;
    bool rtn = TRUE;

    /* 
    ** Flag whether there's only one package in the list.  Some of the
    ** processing functions care.  
    */

    only = (NULL == STindex(featlist, ERx(","), 0));

    /* Loop through each feature name in the list... */

    for (featname = featlist; featname && *featname;)
    {
	/* Find the next one, and make sure current one is EOS-terminated... */

	featnext = STindex(featname, ERx(","), 0);
	if (featnext != NULL)
	{
	    savechar = *featnext;
	    *featnext = EOS;
	}

        /* Call the processing routine... */

	if (!(*proc)(featname,only))
	    rtn = FALSE;

  	/* Onward through the fog... */

	if (featnext == NULL)
	    break;

	*(featname = featnext) = savechar;
	CMnext(featname);
    }

    return rtn;
}
Example #26
0
STATUS
create_canon_fe(SEPFILE *res_ptr)
{
    STATUS                 ret_val = OK ;   /* if OK, refresh FE screen */
    char                   do_com_result ;

#ifdef VMS
    if (SEPtcsubs < 4)
	PCsleep(1000);
#endif
    show_cursor();

    do_com_result = do_comments();
    append_line(OPEN_CANON,1);
    switch (do_com_result)
    {
       case 'R':
       case 'r':
		append_sepfile(res_ptr);
		break;
       case 'E':
       case 'e':
		break;
       case 'I':
       case 'i':
		append_line(SKIP_SYMBOL,1);
		break;
    }
    append_line(CLOSE_CANON,1);
    kfe_ptr = kfebuffer;                /* reset counter for key buffer */

    if (canonAns == EOS)
    {
	disp_prompt(NULLSTR,NULL,NULL);	/* erase prompt */
    }
    else
    {
	CMnext(kfe_ptr);
	ret_val = FAIL;			/* don't refresh FE screen */
    }
    return (ret_val);
}
Example #27
0
/*
** Name: gwsxa_zapblank - trim blanks off a (possibly non-terminated)
**	 string. 
** 
** Description:
**	This routine walks through a (possibly non-NULL-terminated) string
**	up to maxlen bytes looking for a space. It replaces the space with
**      a NULL value. The use of this function is primarily to convert
**	a blank-padded string to a regular NULL-terminated string for 
**	error reporting.
**
** Returns:
**	Nothing.
**
** History:
**	14-sep-92 (robf)
**	    Created
*/
VOID
gwsxa_zapblank(char *str,i4 maxlen)
{
	i4 i;

	/*
	**	If passed an empty string then just return
	*/
	if (!str)
		return;

	for( i=0; i<maxlen; i++)
	{
		if(CMspace(str))
			break;
		CMnext(str);
	}
	if( i!=maxlen)
		*str= EOS;
}
Example #28
0
char *
STindex_DB(
	const char	*str,
	const char	*mstr,
	size_t	len)
{
	if (str == NULL || mstr == NULL)
		return (NULL);

	if (len <= 0)
		len = 32767;

	while (len > 0 && *str != '\0')
	{
		if (CMcmpcase(str, mstr) == 0)
			return ((char *)str);

		CMbytedec(len, str);
		CMnext(str);
	}

	return (NULL);
}
Example #29
0
/*{
** Name:	mktimestamp - make time stamp
**
** Description:
**	Convert the system specific time string (from TMstr) into a
**	Replicator timestamp of the form dd-mmm-yyy hh:mm:ss.
**	mktimestamp() is only intended as a temporary fix to the problem
**	regarding availablity of TMbreak().
**
** Inputs:
**	timestr
**
** Outputs:
**	timestamp
**
** Returns:
**	none
*/
static void
mktimestamp(
char *timestr,
char *timestamp)
{
	char	*tmwords[MAX_TMWORDS];
	char	*dom;
	char	*mon;
	char	*yr;
	char	*hms;
	i4	count;

	*timestamp = EOS;
	count = MAX_TMWORDS;

# ifdef VMS
	if CMspace(timestr)
		CMnext(timestr);
	RPgetwords(ERx(" -"), timestr, &count, tmwords);
	if (count < 3)
		return;
	dom = tmwords[0];
	mon = tmwords[1];
	yr = tmwords[2];
	hms = tmwords[3];
# else
	STgetwords(timestr, &count, tmwords);
	if (count < 5)
		return;
	mon = tmwords[1];
	dom = tmwords[2];
	hms = tmwords[3];
	yr = tmwords[4];
# endif

	STprintf(timestamp, ERx("%.2s-%.3s-%.4s %.8s"), dom, mon, yr, hms);
}
Example #30
0
/*
 * regmatch - main matching routine
 *
 * Conceptually the strategy is simple:  check to see whether the current
 * node matches, call self recursively to see whether the rest matches,
 * and then act accordingly.  In practice we make some effort to avoid
 * recursion, in particular by going through "ordinary" nodes (that don't
 * need to know whether the rest of the match failed) by a loop instead of
 * by recursion.
 */
static i4			/* 0 failure, 1 success */
regmatch(char *prog)
{
    register char *scan;	/* Current node. */
    char *next;		/* Next node. */

    scan = prog;
#ifdef xDEBUG
    if (scan != NULL && regnarrate)
        SIfprintf(stderr, "%s(\n", regprop(scan));
#endif
    while (scan != NULL) {
#ifdef xDEBUG
        if (regnarrate)
            SIfprintf(stderr, "%s...\n", regprop(scan));
#endif
        next = regnext(scan);

        switch (OP(scan)) {
        case BOL:
            if (reginput != regbol)
                return(0);
            break;
        case EOL:
            if (*reginput != '\0')
                return(0);
            break;
        case ANY:
            if (*reginput == '\0')
                return(0);
            CMnext( reginput );
            break;
        case EXACTLY: {
            register i4  len;
            register char *opnd;

            opnd = OPERAND(scan);
            /* Inline the first character, for speed. */
            if (*opnd != *reginput)
                return(0);
            len = STlength(opnd);
            if (len > 1 && STncmp( opnd, reginput,
                                   len ) != 0
               )
                return(0);
            reginput += len;
        }
        break;
        case ANYOF:
            if (*reginput == '\0' || STchr(OPERAND(scan),
                                           *reginput) == NULL
               )
                return(0);
            CMnext( reginput );
            break;
        case ANYBUT:
            if (*reginput == '\0' || STchr(OPERAND(scan),
                                           *reginput) != NULL
               )
                return(0);
            CMnext( reginput );
            break;
        case NOTHING:
            break;
        case BACK:
            break;
        case OPEN+1:
        case OPEN+2:
        case OPEN+3:
        case OPEN+4:
        case OPEN+5:
        case OPEN+6:
        case OPEN+7:
        case OPEN+8:
        case OPEN+9: {
            register i4  no;
            register char *save;

            no = OP(scan) - OPEN;
            save = reginput;

            if (regmatch(next)) {
                /*
                 * Don't set startp if some later
                 * invocation of the same parentheses
                 * already has.
                 */
                if (regstartp[no] == NULL)
                    regstartp[no] = save;
                return(1);
            } else
                return(0);
        }
        break;
        case CLOSE+1:
        case CLOSE+2:
        case CLOSE+3:
        case CLOSE+4:
        case CLOSE+5:
        case CLOSE+6:
        case CLOSE+7:
        case CLOSE+8:
        case CLOSE+9: {
            register i4  no;
            register char *save;

            no = OP(scan) - CLOSE;
            save = reginput;

            if (regmatch(next)) {
                /*
                 * Don't set endp if some later
                 * invocation of the same parentheses
                 * already has.
                 */
                if (regendp[no] == NULL)
                    regendp[no] = save;
                return(1);
            } else
                return(0);
        }
        break;
        case BRANCH: {
            register char *save;

            if (OP(next) != BRANCH)		/* No choice. */
                next = OPERAND(scan);	/* Avoid recursion. */
            else {
                do {
                    save = reginput;
                    if (regmatch(OPERAND(scan)))
                        return(1);
                    reginput = save;
                    scan = regnext(scan);
                } while (scan != NULL && OP(scan) == BRANCH);
                return(0);
                /* NOTREACHED */
            }
        }
        break;
        case STAR:
        case PLUS: {
            register char nextch;
            register i4  no;
            register char *save;
            register i4  minx;

            /*
             * Lookahead to avoid useless match attempts
             * when we know what character comes next.
             */
            nextch = '\0';
            if (OP(next) == EXACTLY)
                nextch = *OPERAND(next);
            minx = (OP(scan) == STAR) ? 0 : 1;
            save = reginput;
            no = regrepeat(OPERAND(scan));
            while (no >= minx) {
                /* If it could work, try it. */
                if (nextch == '\0' || *reginput == nextch)
                    if (regmatch(next))
                        return(1);
                /* Couldn't or didn't -- back up. */
                no--;
                reginput = save + no;
            }
            return(0);
        }
        break;
        case END:
            return(1);	/* Success! */
            break;
        default:
            _error("memory corruption");
            return(0);
            break;
        }

        scan = next;
    }

    /*
     * We get here only if there's trouble -- normally "case END" is
     * the terminating point.
     */
    _error("corrupted pointers");
    return(0);
}