Tcl Source Code

MODULE_SCOPE Tcl_Obj *	TclGetProcessGlobalValue(ProcessGlobalValue *pgvPtr);
MODULE_SCOPE const char *TclGetSrcInfoForCmd(Interp *iPtr, int *lenPtr);
MODULE_SCOPE char *	TclGetStringStorage(Tcl_Obj *objPtr,
			    unsigned int *sizePtr);
MODULE_SCOPE int	TclGlob(Tcl_Interp *interp, char *pattern,
			    Tcl_Obj *unquotedPrefix, int globFlags,
			    Tcl_GlobTypeData *types);
MODULE_SCOPE size_t	TclFindUtfBarewordEnd(const char *src, size_t numBytes);
MODULE_SCOPE int	TclIncrObj(Tcl_Interp *interp, Tcl_Obj *valuePtr,
			    Tcl_Obj *incrPtr);
MODULE_SCOPE Tcl_Obj *	TclIncrObjVar2(Tcl_Interp *interp, Tcl_Obj *part1Ptr,
			    Tcl_Obj *part2Ptr, Tcl_Obj *incrPtr, int flags);
MODULE_SCOPE int	TclInfoExistsCmd(ClientData dummy, Tcl_Interp *interp,
			    int objc, Tcl_Obj *const objv[]);
MODULE_SCOPE Tcl_Obj *	TclInfoFrame(Tcl_Interp *interp, CmdFrame *framePtr);

{
    return CHAR_TYPE(byte) & (TYPE_SPACE) || byte == '\n';
}

/*
 *----------------------------------------------------------------------
 *
 * TclIsBareword --
 *
 *	Report whether byte is one that can be part of a "bareword".
 *	This concept is named in expression parsing, where it determines
 *	what can be a legal function name, but is the same definition used
 *	in determining what variable names can be parsed as variable
 *	substitutions without the benefit of enclosing braces.  The set of
 *	ASCII chars that are accepted are the numeric chars ('0'-'9'),

	return 1;
    }
    if (byte < 'A' || byte > 'Z') {
	return 0;
    }
    return 1;
}

/*
 *----------------------------------------------------------------------
 *
 * TclFindBarewordEndUni --
 *
 *      Scan src to the end of a "bareword".
 *      The set of chars that are accepted is alnum (UTF-8 compatible)
 *      and underscore ('_').
 *
 * Results:
 *      Returns length of word (equal offset in bytes to position after the
 *	end of word, 0 if not found).
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

size_t
TclFindUtfBarewordEnd(
    const char *src,
    size_t numBytes)
{
    size_t p = 0, l;
    Tcl_UniChar ch;

    while (p < numBytes) {
	/* 0-9,A-Z,a-Z,_ */
	if (TclIsBareword(src[p])) {
	    p++;
	    continue;
	}
	if (!(src[p] & 0x80) || numBytes <= 1) { /* single byte or end reached */
	    break;
	}
	/* test unicode alnum (consider NTS-char) */
	l = TclUtfToUniChar(src+p, &ch);
	if (!Tcl_UniCharIsAlnum(ch) || p+l > numBytes) {
	    break;
	}
	p += l;
    }
    return p;
}

/*
 *----------------------------------------------------------------------
 *
 * ParseWhiteSpace --
 *
 *	Scans up to numBytes bytes starting at src, consuming white space

	src++;
    } else {
	tokenPtr->type = TCL_TOKEN_TEXT;
	tokenPtr->start = src;
	tokenPtr->numComponents = 0;

	while (numBytes) {
	    size_t wordlen = TclFindUtfBarewordEnd(src, numBytes);

	    src += wordlen;
	    numBytes -= wordlen;
	    if (!numBytes) {
		break;
	    }
	    if ((src[0] == ':') && (numBytes != 1) && (src[1] == ':')) {
		src += 2;
		numBytes -= 2;
		while (numBytes && (*src == ':')) {
		    src++;
		    numBytes--;