/*
* Return TRUE if "name" looks like some xterm name.
* Seiichi Sato mentioned that "mlterm" works like xterm.
*/
int vim_is_xterm(char_u *name)
{
if (name == NULL)
return FALSE;
return STRNICMP(name, "xterm", 5) == 0
|| STRNICMP(name, "nxterm", 6) == 0
|| STRNICMP(name, "kterm", 5) == 0
|| STRNICMP(name, "mlterm", 6) == 0
|| STRNICMP(name, "rxvt", 4) == 0
|| STRCMP(name, "builtin_xterm") == 0;
}
/*
* Return TRUE if "name" is a terminal for which 'ttyfast' should be set.
* This should include all windowed terminal emulators.
*/
int vim_is_fastterm(char_u *name)
{
if (name == NULL)
return FALSE;
if (vim_is_xterm(name) || vim_is_vt300(name) || vim_is_iris(name))
return TRUE;
return STRNICMP(name, "hpterm", 6) == 0
|| STRNICMP(name, "sun-cmd", 7) == 0
|| STRNICMP(name, "screen", 6) == 0
|| STRNICMP(name, "dtterm", 6) == 0;
}
int vim_is_iris(char_u *name)
{
if (name == NULL)
return FALSE;
return STRNICMP(name, "iris-ansi", 9) == 0
|| STRCMP(name, "builtin_iris-ansi") == 0;
}
// strnicmp that does not respect the locale: for ascii comparisons only
int
strnicmp_ignore_locale(const char *s1, const char *s2, size_t length)
{
LOCALE_DEF;
if (USE_LOCALE)
return STRNICMP(s1, s2, length);
while (length-- > 0)
{
char c1 = *s1++;
char c2 = *s2++;
int diff = tolower_ignore_locale(c1) - tolower_ignore_locale(c2);
if (diff != 0)
{
return diff;
}
else
{
if('\0' == c1)
{
return 0;
}
}
}
return 0;
}
int vim_is_vt300(char_u *name)
{
if (name == NULL)
return FALSE; /* actually all ANSI comp. terminals should be here */
/* catch VT100 - VT5xx */
return (STRNICMP(name, "vt", 2) == 0
&& vim_strchr((char_u *)"12345", name[2]) != NULL)
|| STRCMP(name, "builtin_vt320") == 0;
}
bool MultipleSequence::loadInformation(FILE* fp, int* no, char*** seqFileName, int** seqIndex)
{
ASSERT(fp);
char buf[MAX_BUF], *p, *q;
int i;
int hNumberLen = strlen(H_NUMBER);
int hFileNameLen = strlen(H_FILE_NAME);
while (fgets(buf, MAX_BUF, fp))
{
// Number : 2
if (!STRNICMP(buf, H_NUMBER, hNumberLen))
{
*no = atoi(buf+hNumberLen);
*seqFileName = new char*[*no];
*seqIndex = new int[*no];
}
else if (!STRNICMP(buf, H_FILE_NAME, hFileNameLen))
{
p = buf+hFileNameLen;
i = atoi(p);
ASSERT(i < *no);
p = strchr(p, H_FILE_DELIMETER); // start of filename
ASSERT(p);
q = strchr(++p, H_FILE_DELIMETER); // end of filename
ASSERT(q);
*q = '\0'; q++; // start of index
p = StringEx::trim(p); // trim
(*seqIndex)[i] = atoi(q);
(*seqFileName)[i] = new char[strlen(p)+1];
strcpy((*seqFileName)[i], p);
if (i == *no-1) return true;
}
}
return false;
}
CAPTEUR *OneWire_ChercherPere(char *Id)
{
CAPTEUR *Capteur;
int i;
BOOL bOK;
//Parcours des capteurs
for(Capteur=g_LstCapteur; Capteur!=NULL; Capteur = Capteur->Suivant)
{
bOK = TRUE;
if(STRNICMP(Id, Capteur->Id, 15)!=0) bOK = FALSE;
if(bOK == TRUE) return Capteur;
}
return NULL;
}
/*
* This routine converts HTML escape sequence
* back to the original ASCII representation.
* - returns the number of characters dropped.
*/
int convertHTMLcodes(char *s, int len)
{
if (len <=0 || s==(char*)NULL || *s=='\0')
return 0;
if (s[1] == '#')
{
int val, o;
if (sscanf(s,"&#%d;",&val) == 1)
{
o = 3;
while (s[o] != ';')
{
o++;
if (o > 5)
break;
}
if (o < 5)
strcpy(s+1, s+1+o);
*s = val;
return o;
}
}
else
{
int
i,
codes = sizeof(html_codes) / sizeof(html_code);
for (i=0; i < codes; i++)
{
if (html_codes[i].len <= len)
if (STRNICMP(s, html_codes[i].code, html_codes[i].len) == 0)
{
strcpy(s+1, s+html_codes[i].len);
*s = html_codes[i].val;
return html_codes[i].len-1;
}
}
}
return 0;
}
/*
* Isolate the menu name.
* Skip the menu name, and translate <Tab> into a real TAB.
*/
static char_u *menu_translate_tab_and_shift(char_u *arg_start)
{
char_u *arg = arg_start;
while (*arg && !vim_iswhite(*arg)) {
if ((*arg == '\\' || *arg == Ctrl_V) && arg[1] != NUL)
arg++;
else if (STRNICMP(arg, "<TAB>", 5) == 0) {
*arg = TAB;
STRMOVE(arg + 1, arg + 5);
}
arg++;
}
if (*arg != NUL)
*arg++ = NUL;
arg = skipwhite(arg);
return arg;
}
/*
* Parse the 'guicursor' option ("what" is SHAPE_CURSOR) or 'mouseshape'
* ("what" is SHAPE_MOUSE).
* Returns error message for an illegal option, NULL otherwise.
*/
char_u *parse_shape_opt(int what)
{
char_u *modep;
char_u *colonp;
char_u *commap;
char_u *slashp;
char_u *p, *endp;
int idx = 0; /* init for GCC */
int all_idx;
int len;
int i;
int found_ve = FALSE; /* found "ve" flag */
int round;
/*
* First round: check for errors; second round: do it for real.
*/
for (round = 1; round <= 2; ++round) {
/*
* Repeat for all comma separated parts.
*/
modep = p_guicursor;
while (*modep != NUL) {
colonp = vim_strchr(modep, ':');
if (colonp == NULL)
return (char_u *)N_("E545: Missing colon");
if (colonp == modep)
return (char_u *)N_("E546: Illegal mode");
commap = vim_strchr(modep, ',');
/*
* Repeat for all mode's before the colon.
* For the 'a' mode, we loop to handle all the modes.
*/
all_idx = -1;
assert(modep < colonp);
while (modep < colonp || all_idx >= 0) {
if (all_idx < 0) {
/* Find the mode. */
if (modep[1] == '-' || modep[1] == ':')
len = 1;
else
len = 2;
if (len == 1 && TOLOWER_ASC(modep[0]) == 'a')
all_idx = SHAPE_IDX_COUNT - 1;
else {
for (idx = 0; idx < SHAPE_IDX_COUNT; ++idx)
if (STRNICMP(modep, shape_table[idx].name, len)
== 0)
break;
if (idx == SHAPE_IDX_COUNT
|| (shape_table[idx].used_for & what) == 0)
return (char_u *)N_("E546: Illegal mode");
if (len == 2 && modep[0] == 'v' && modep[1] == 'e')
found_ve = TRUE;
}
modep += len + 1;
}
if (all_idx >= 0)
idx = all_idx--;
else if (round == 2) {
{
/* Set the defaults, for the missing parts */
shape_table[idx].shape = SHAPE_BLOCK;
shape_table[idx].blinkwait = 700L;
shape_table[idx].blinkon = 400L;
shape_table[idx].blinkoff = 250L;
}
}
/* Parse the part after the colon */
for (p = colonp + 1; *p && *p != ','; ) {
{
/*
* First handle the ones with a number argument.
*/
i = *p;
len = 0;
if (STRNICMP(p, "ver", 3) == 0)
len = 3;
else if (STRNICMP(p, "hor", 3) == 0)
len = 3;
else if (STRNICMP(p, "blinkwait", 9) == 0)
len = 9;
else if (STRNICMP(p, "blinkon", 7) == 0)
len = 7;
else if (STRNICMP(p, "blinkoff", 8) == 0)
len = 8;
if (len != 0) {
p += len;
if (!VIM_ISDIGIT(*p))
return (char_u *)N_("E548: digit expected");
long digits = getdigits(&p);
assert(digits <= INT_MAX);
int n = (int)digits;
if (len == 3) { /* "ver" or "hor" */
if (n == 0)
return (char_u *)N_("E549: Illegal percentage");
if (round == 2) {
if (TOLOWER_ASC(i) == 'v')
shape_table[idx].shape = SHAPE_VER;
else
shape_table[idx].shape = SHAPE_HOR;
shape_table[idx].percentage = n;
}
} else if (round == 2) {
if (len == 9)
shape_table[idx].blinkwait = n;
else if (len == 7)
shape_table[idx].blinkon = n;
else
shape_table[idx].blinkoff = n;
}
} else if (STRNICMP(p, "block", 5) == 0) {
if (round == 2)
shape_table[idx].shape = SHAPE_BLOCK;
p += 5;
} else { /* must be a highlight group name then */
endp = vim_strchr(p, '-');
if (commap == NULL) { /* last part */
if (endp == NULL)
endp = p + STRLEN(p); /* find end of part */
} else if (endp > commap || endp == NULL)
endp = commap;
slashp = vim_strchr(p, '/');
if (slashp != NULL && slashp < endp) {
/* "group/langmap_group" */
i = syn_check_group(p, (int)(slashp - p));
p = slashp + 1;
}
if (round == 2) {
shape_table[idx].id = syn_check_group(p,
(int)(endp - p));
shape_table[idx].id_lm = shape_table[idx].id;
if (slashp != NULL && slashp < endp)
shape_table[idx].id = i;
}
p = endp;
}
} /* if (what != SHAPE_MOUSE) */
if (*p == '-')
++p;
}
}
modep = p;
if (*modep == ',')
++modep;
}
}
/* If the 's' flag is not given, use the 'v' cursor for 's' */
if (!found_ve) {
{
shape_table[SHAPE_IDX_VE].shape = shape_table[SHAPE_IDX_V].shape;
shape_table[SHAPE_IDX_VE].percentage =
shape_table[SHAPE_IDX_V].percentage;
shape_table[SHAPE_IDX_VE].blinkwait =
shape_table[SHAPE_IDX_V].blinkwait;
shape_table[SHAPE_IDX_VE].blinkon =
shape_table[SHAPE_IDX_V].blinkon;
shape_table[SHAPE_IDX_VE].blinkoff =
shape_table[SHAPE_IDX_V].blinkoff;
shape_table[SHAPE_IDX_VE].id = shape_table[SHAPE_IDX_V].id;
shape_table[SHAPE_IDX_VE].id_lm = shape_table[SHAPE_IDX_V].id_lm;
}
}
return NULL;
}
// Replace any terminal code strings in from[] with the equivalent internal
// vim representation. This is used for the "from" and "to" part of a
// mapping, and the "to" part of a menu command.
// Any strings like "<C-UP>" are also replaced, unless 'cpoptions' contains
// '<'.
// K_SPECIAL by itself is replaced by K_SPECIAL KS_SPECIAL KE_FILLER.
//
// The replacement is done in result[] and finally copied into allocated
// memory. If this all works well *bufp is set to the allocated memory and a
// pointer to it is returned. If something fails *bufp is set to NULL and from
// is returned.
//
// CTRL-V characters are removed. When "from_part" is TRUE, a trailing CTRL-V
// is included, otherwise it is removed (for ":map xx ^V", maps xx to
// nothing). When 'cpoptions' does not contain 'B', a backslash can be used
// instead of a CTRL-V.
char_u * replace_termcodes (
char_u *from,
char_u **bufp,
int from_part,
int do_lt, // also translate <lt>
int special // always accept <key> notation
)
{
ssize_t i;
size_t slen;
char_u key;
size_t dlen = 0;
char_u *src;
int do_backslash; // backslash is a special character
int do_special; // recognize <> key codes
char_u *result; // buffer for resulting string
do_backslash = (vim_strchr(p_cpo, CPO_BSLASH) == NULL);
do_special = (vim_strchr(p_cpo, CPO_SPECI) == NULL) || special;
// Allocate space for the translation. Worst case a single character is
// replaced by 6 bytes (shifted special key), plus a NUL at the end.
result = xmalloc(STRLEN(from) * 6 + 1);
src = from;
// Check for #n at start only: function key n
if (from_part && src[0] == '#' && VIM_ISDIGIT(src[1])) { // function key
result[dlen++] = K_SPECIAL;
result[dlen++] = 'k';
if (src[1] == '0') {
result[dlen++] = ';'; // #0 is F10 is "k;"
} else {
result[dlen++] = src[1]; // #3 is F3 is "k3"
}
src += 2;
}
// Copy each byte from *from to result[dlen]
while (*src != NUL) {
// If 'cpoptions' does not contain '<', check for special key codes,
// like "<C-S-LeftMouse>"
if (do_special && (do_lt || STRNCMP(src, "<lt>", 4) != 0)) {
// Replace <SID> by K_SNR <script-nr> _.
// (room: 5 * 6 = 30 bytes; needed: 3 + <nr> + 1 <= 14)
if (STRNICMP(src, "<SID>", 5) == 0) {
if (current_SID <= 0) {
EMSG(_(e_usingsid));
} else {
src += 5;
result[dlen++] = K_SPECIAL;
result[dlen++] = (int)KS_EXTRA;
result[dlen++] = (int)KE_SNR;
sprintf((char *)result + dlen, "%" PRId64, (int64_t)current_SID);
dlen += STRLEN(result + dlen);
result[dlen++] = '_';
continue;
}
}
slen = trans_special(&src, result + dlen, TRUE);
if (slen) {
dlen += slen;
continue;
}
}
if (do_special) {
char_u *p, *s, len;
// Replace <Leader> by the value of "mapleader".
// Replace <LocalLeader> by the value of "maplocalleader".
// If "mapleader" or "maplocalleader" isn't set use a backslash.
if (STRNICMP(src, "<Leader>", 8) == 0) {
len = 8;
p = get_var_value((char_u *)"g:mapleader");
} else if (STRNICMP(src, "<LocalLeader>", 13) == 0) {
len = 13;
p = get_var_value((char_u *)"g:maplocalleader");
} else {
len = 0;
p = NULL;
}
if (len != 0) {
// Allow up to 8 * 6 characters for "mapleader".
if (p == NULL || *p == NUL || STRLEN(p) > 8 * 6) {
s = (char_u *)"\\";
} else {
s = p;
}
while (*s != NUL) {
result[dlen++] = *s++;
}
src += len;
continue;
}
}
// Remove CTRL-V and ignore the next character.
// For "from" side the CTRL-V at the end is included, for the "to"
// part it is removed.
// If 'cpoptions' does not contain 'B', also accept a backslash.
key = *src;
if (key == Ctrl_V || (do_backslash && key == '\\')) {
++src; // skip CTRL-V or backslash
if (*src == NUL) {
if (from_part) {
result[dlen++] = key;
}
break;
}
}
// skip multibyte char correctly
for (i = (*mb_ptr2len)(src); i > 0; --i) {
// If the character is K_SPECIAL, replace it with K_SPECIAL
// KS_SPECIAL KE_FILLER.
// If compiled with the GUI replace CSI with K_CSI.
if (*src == K_SPECIAL) {
result[dlen++] = K_SPECIAL;
result[dlen++] = KS_SPECIAL;
result[dlen++] = KE_FILLER;
} else {
result[dlen++] = *src;
}
++src;
}
}
result[dlen] = NUL;
*bufp = xrealloc(result, dlen + 1);
return *bufp;
}
/*
* Try translating a <> name at (*srcp)[], return the key and modifiers.
* srcp is advanced to after the <> name.
* returns 0 if there is no match.
*/
int
find_special_key (
char_u **srcp,
int *modp,
int keycode, /* prefer key code, e.g. K_DEL instead of DEL */
int keep_x_key /* don't translate xHome to Home key */
)
{
char_u *last_dash;
char_u *end_of_name;
char_u *src;
char_u *bp;
int modifiers;
int bit;
int key;
unsigned long n;
int l;
src = *srcp;
if (src[0] != '<')
return 0;
/* Find end of modifier list */
last_dash = src;
for (bp = src + 1; *bp == '-' || vim_isIDc(*bp); bp++) {
if (*bp == '-') {
last_dash = bp;
if (bp[1] != NUL) {
if (has_mbyte)
l = mb_ptr2len(bp + 1);
else
l = 1;
if (bp[l + 1] == '>')
bp += l; /* anything accepted, like <C-?> */
}
}
if (bp[0] == 't' && bp[1] == '_' && bp[2] && bp[3])
bp += 3; /* skip t_xx, xx may be '-' or '>' */
else if (STRNICMP(bp, "char-", 5) == 0) {
vim_str2nr(bp + 5, NULL, &l, TRUE, TRUE, NULL, NULL);
bp += l + 5;
break;
}
}
if (*bp == '>') { /* found matching '>' */
end_of_name = bp + 1;
/* Which modifiers are given? */
modifiers = 0x0;
for (bp = src + 1; bp < last_dash; bp++) {
if (*bp != '-') {
bit = name_to_mod_mask(*bp);
if (bit == 0x0)
break; /* Illegal modifier name */
modifiers |= bit;
}
}
/*
* Legal modifier name.
*/
if (bp >= last_dash) {
if (STRNICMP(last_dash + 1, "char-", 5) == 0
&& VIM_ISDIGIT(last_dash[6])) {
/* <Char-123> or <Char-033> or <Char-0x33> */
vim_str2nr(last_dash + 6, NULL, NULL, TRUE, TRUE, NULL, &n);
key = (int)n;
} else {
/*
* Modifier with single letter, or special key name.
*/
if (has_mbyte)
l = mb_ptr2len(last_dash + 1);
else
l = 1;
if (modifiers != 0 && last_dash[l + 1] == '>')
key = PTR2CHAR(last_dash + 1);
else {
key = get_special_key_code(last_dash + 1);
if (!keep_x_key)
key = handle_x_keys(key);
}
}
/*
* get_special_key_code() may return NUL for invalid
* special key name.
*/
if (key != NUL) {
/*
* Only use a modifier when there is no special key code that
* includes the modifier.
*/
key = simplify_key(key, &modifiers);
if (!keycode) {
/* don't want keycode, use single byte code */
if (key == K_BS)
key = BS;
else if (key == K_DEL || key == K_KDEL)
key = DEL;
}
/*
* Normal Key with modifier: Try to make a single byte code.
*/
if (!IS_SPECIAL(key))
key = extract_modifiers(key, &modifiers);
*modp = modifiers;
*srcp = end_of_name;
return key;
}
}
}
return 0;
}
DWORD
GetToken(
IN LPTSTR pszBegin,
OUT LPTSTR* ppszEnd,
OUT LPDWORD pflTokenType,
IN DWORD flFlags
)
/*++
Routine Description:
GetToken attempts to locate and type the next token. It takes the
beginning of the token and determines the end of the token (i.e.
the beginning of the next token, so that it can be called again).
It also sets the TOKEN_TYPE_* bits for all of the token types which
are appropriate to the specified type.
Arguments:
pszBegin - A pointer to the first character in the token.
ppszEnd - A pointer to the location in which to store the end of
the current token (actually, the first character of the
next token).
pflTokenType- The place to store the token type. Token types are
defined in TOKEN.H.
flFlags - Flags to determine operation. Currently MBZ.
Return Value:
DWORD
Success - 0
Failure - ERROR_INVALID_PARAMETER
ERROR_INVALID_NAME
ERROR_FILENAME_EXCED_RANGE
--*/
{
register TCHAR chFirstChar;
register DWORD cbTokenLen;
BOOL fComputernameOnly = FALSE;
DWORD usNameError = 0;
DWORD cbTrailingDotSpace;
DWORD iLow, iHigh, iMid;
LONG iCmpVal;
LCID lcid = GetThreadLocale();
BOOL bDBCS = (PRIMARYLANGID( LANGIDFROMLCID(lcid)) == LANG_JAPANESE) ||
(PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_KOREAN) ||
(PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_CHINESE);
extern DWORD cbMaxPathCompLen;
//
// This macro is used to make sure that the error value is set only
// once in the computername-only case.
//
#define SET_COMPUTERNAMEONLY(err) if (! fComputernameOnly) \
{ \
fComputernameOnly = TRUE; \
usNameError = err; \
}
if (flFlags & GTF_RESERVED) {
return ERROR_INVALID_PARAMETER;
}
//
// Initialize the token type to 0
//
*pflTokenType = 0;
//
// Store the first character
//
chFirstChar = *pszBegin;
//
// Return immediately if the string is a null string
//
if (chFirstChar == TCHAR_EOS) {
*ppszEnd = pszBegin;
*pflTokenType = TOKEN_TYPE_EOS;
#ifdef DEVDEBUG
DbgPrint("GetToken - returning TOKEN_TYPE_EOS\n");
#endif
return 0;
}
//
// Handle single-character, non-component tokens
//
if ((chFirstChar == TCHAR_BACKSLASH) || (chFirstChar == TCHAR_FWDSLASH)) {
*pflTokenType = TOKEN_TYPE_SLASH;
} else if (chFirstChar == TCHAR_COLON) {
*pflTokenType = TOKEN_TYPE_COLON;
}
//
// If we get here and the token type is non-zero, we have a single
// character token. We set <ppszEnd> and return 0.
//
if (*pflTokenType) {
*ppszEnd = pszBegin + 1;
#ifdef DEVDEBUG
DbgPrint("GetToken - *pflTokenType=%x\n", *pflTokenType);
#endif
return 0;
}
//
// If we get here, the token is a component, find the end of the
// component by looking for the first character in the string which
// isn't a valid component character.
//
// IMPORTANT: There are certain names which are not valid component
// names but which may be valid computernames. If we hit
// such a name, we set the <fComputernameOnly> flag. Later
// on, we check to see if the name is a valid computername.
// If it is, we allow it; otherwise, we return an error.
//
cbTokenLen = STRCSPN(pszBegin, szNonComponentChars);
//
// We return an error if the first character is not a valid component
// character, if the component is too long, or if the first
// non-component character in the string is an illegal character.
//
if (cbTokenLen == 0) {
#ifdef DEVDEBUG
DbgPrint("GetToken - returning ERROR_INVALID_NAME (token len = 0)\n");
#endif
return ERROR_INVALID_NAME;
}
if (cbTokenLen > cbMaxPathCompLen) {
SET_COMPUTERNAMEONLY(ERROR_FILENAME_EXCED_RANGE);
}
if (IsIllegalCharacter(pszBegin + cbTokenLen)) {
#ifdef DEVDEBUG
DbgPrint("GetToken - returning ERROR_INVALID_NAME (illegal char)\n");
#endif
return ERROR_INVALID_NAME;
}
//
// Now we need to determine where the trailing dots and spaces begin,
// and make sure that the component name contains something other
// than dots and spaces, unless it's "." or ".."
//
// NOTE: If there are not trailing dots or spaces, <cbTrailingDotSpace>
// is set to <cbTokenLen>.
//
cbTrailingDotSpace = TrailingDotsAndSpaces(pszBegin, cbTokenLen );
//
// See if the token has only trailing dots and spaces
//
if (cbTrailingDotSpace == 0) {
//
// Return an error if the length of the token is greater than 2.
//
if (cbTokenLen > 2) {
SET_COMPUTERNAMEONLY(ERROR_INVALID_NAME);
}
//
// Return an error if the first character is not a dot or if the
// token length is 2 and the second character is not a dot.
//
if ((chFirstChar != TCHAR_DOT) || ((cbTokenLen == 2) && (pszBegin[1] != TCHAR_DOT))) {
SET_COMPUTERNAMEONLY(ERROR_INVALID_NAME);
}
//
// Now we're OK, since the token is either "." or ".."
//
}
//
// WE HAVE A VALID COMPONENT
//
*pflTokenType = TOKEN_TYPE_COMPONENT;
//
// Now we determine if this token matches any of the component-based
// types.
//
//
// Is it a drive?
//
if (IS_DRIVE(chFirstChar) && (cbTokenLen == 1)) {
*pflTokenType |= TOKEN_TYPE_DRIVE;
}
//
// Is it "." or ".." ?
//
// Since we've already validated this string, we know that if it
// contains nothing but dots and spaces it must be one of these
// two.
//
if (cbTrailingDotSpace == 0) {
*pflTokenType |= cbTokenLen == 1 ? TOKEN_TYPE_DOT : TOKEN_TYPE_DOTDOT;
}
//
// If the 8.3 flag is specified, we also have to check that the
// component is in 8.3 format. We determine this as follows:
//
// Find the first dot in the token (or the end of the token).
// Verify that at least 1 and at most 8 characters precede it.
// Verify that at most 3 characters follow it.
// Verify that none of the characters which follow it are dots.
//
// The exceptions to this are "." and "..". Therefore, we don't check
// this until after we've already determined that this component is
// neither of those.
//
if ((cbTrailingDotSpace != 0) && (flFlags & GTF_8_DOT_3)) {
DWORD cbFirstDot;
BOOL fNoDot;
cbFirstDot = STRCSPN(pszBegin, _text_SingleDot);
if (fNoDot = cbFirstDot >= cbTokenLen) {
cbFirstDot = cbTokenLen;
}
if (cbFirstDot == 0
|| cbFirstDot > 8
|| cbTokenLen - cbFirstDot > 4
|| (! fNoDot && STRCSPN(pszBegin + cbFirstDot + 1, _text_SingleDot)
< cbTokenLen - (cbFirstDot + 1))) {
SET_COMPUTERNAMEONLY(ERROR_INVALID_NAME);
}
if( bDBCS ) {
//
// In case of MBCS, We also need to check the string is valid in MBCS
// because Unicode character count is not eqaul MBCS byte count
CHAR szCharToken[13]; // 8 + 3 + dot + null
int cbConverted = 0;
BOOL bDefaultUsed = FALSE;
// Convert Unicode string to Mbcs.
cbConverted = WideCharToMultiByte( CP_OEMCP, 0,
pszBegin, -1,
szCharToken, sizeof(szCharToken),
NULL, &bDefaultUsed );
// If the converted langth is larger than the buffer, or the WideChar string
// contains some character that is can not be repesented by MultiByte code page,
// set error.
if( cbConverted == FALSE || bDefaultUsed == TRUE ) {
SET_COMPUTERNAMEONLY(ERROR_INVALID_NAME);
} else {
cbConverted -= 1; // Remove NULL;
cbFirstDot = strcspn(szCharToken, ".");
if (fNoDot = cbFirstDot >= (DWORD)cbConverted) {
cbFirstDot = cbConverted;
}
if (cbFirstDot == 0
|| cbFirstDot > 8
|| cbConverted - cbFirstDot > 4
|| (! fNoDot && strcspn(szCharToken + cbFirstDot + 1, ".")
< cbConverted - (cbFirstDot + 1))) {
SET_COMPUTERNAMEONLY(ERROR_INVALID_NAME);
}
}
}
}
//
// Does it contain wildcards?
//
// If so, set the appropriate flag(s).
//
// If not, it may be a valid computername.
//
if (STRCSPN(pszBegin, szWildcards) < cbTokenLen) {
*pflTokenType |= TOKEN_TYPE_WILDCARD;
//
// Special case the single '*' token
//
if (cbTokenLen == 1 && chFirstChar == TCHAR_STAR) {
*pflTokenType |= TOKEN_TYPE_WILDONE;
}
} else {
if( cbTokenLen <= MAX_PATH ) {
*pflTokenType |= TOKEN_TYPE_COMPUTERNAME;
}
}
//
// IMPORTANT: Now we've determined if the token is a valid computername.
// If the <fComputernameOnly> flag is set and it's a valid
// computername, then we turn off all other bits. If it's
// not a valid computername, we return the stored error.
// If the flag isn't set, we continue with the component name
// processing.
//
if (fComputernameOnly) {
if (*pflTokenType & TOKEN_TYPE_COMPUTERNAME) {
*pflTokenType = TOKEN_TYPE_COMPUTERNAME;
} else {
#ifdef DEVDEBUG
DbgPrint("GetToken - returning usNameError (%u)\n", usNameError);
#endif
return usNameError;
}
} else {
//
// Is this an LPT[1-9] token?
//
if (STRNICMP(pszBegin, szLPTName, LPT_TOKEN_LEN) == 0
&& IS_NON_ZERO_DIGIT(pszBegin[LPT_TOKEN_LEN])
&& cbTrailingDotSpace == LPT_TOKEN_LEN + 1) {
*pflTokenType |= TOKEN_TYPE_LPT;
}
//
// Is this an COM[1-9] token?
//
if (STRNICMP(pszBegin, szCOMName, COM_TOKEN_LEN) == 0
&& IS_NON_ZERO_DIGIT(pszBegin[COM_TOKEN_LEN])
&& cbTrailingDotSpace == COM_TOKEN_LEN + 1) {
*pflTokenType |= TOKEN_TYPE_COM;
}
//
// The remainder of the component-based token types are determined
// by string comparisons. In order to speed things up, we store
// these strings in sorted order and do a binary search on them,
// which reduces the worst-case number of comparisons from N to
// log N (where N is the number of strings).
//
iLow = (ULONG)-1;
iHigh = NUM_STRING_TOKENS;
while (iHigh - iLow > 1) {
iMid = (iLow + iHigh) / 2;
//
// We do the comparison up to the length of the longer of the
// two strings. This guarantees us a valid non-zero value for
// iCmpVal if they don't match. It also means that they won't
// match unless they're the same length.
//
iCmpVal = STRNICMP(pszBegin,
StringTokenTable[iMid].pszTokenName,
max(StringTokenTable[iMid].cbTokenLen,
cbTrailingDotSpace) );
if (iCmpVal < 0) {
iHigh = iMid;
} else if (iCmpVal > 0) {
iLow = iMid;
} else {
//
// We have a match!
//
*pflTokenType |= StringTokenTable[iMid].flTokenType;
//
// We can only match one, so don't bother continuing
//
break;
}
}
}
//
// We're done; set the end pointer and return with success
//
*ppszEnd = pszBegin + cbTokenLen;
#ifdef DEVDEBUG
DbgPrint("GetToken - returning success\n");
#endif
return 0;
}
int find_special_key(const char_u **srcp, const size_t src_len, int *const modp,
const bool keycode, const bool keep_x_key,
const bool in_string)
{
const char_u *last_dash;
const char_u *end_of_name;
const char_u *src;
const char_u *bp;
const char_u *const end = *srcp + src_len - 1;
int modifiers;
int bit;
int key;
uvarnumber_T n;
int l;
if (src_len == 0) {
return 0;
}
src = *srcp;
if (src[0] != '<') {
return 0;
}
// Find end of modifier list
last_dash = src;
for (bp = src + 1; bp <= end && (*bp == '-' || ascii_isident(*bp)); bp++) {
if (*bp == '-') {
last_dash = bp;
if (bp + 1 <= end) {
l = utfc_ptr2len_len(bp + 1, (int)(end - bp) + 1);
// Anything accepted, like <C-?>.
// <C-"> or <M-"> are not special in strings as " is
// the string delimiter. With a backslash it works: <M-\">
if (end - bp > l && !(in_string && bp[1] == '"') && bp[2] == '>') {
bp += l;
} else if (end - bp > 2 && in_string && bp[1] == '\\'
&& bp[2] == '"' && bp[3] == '>') {
bp += 2;
}
}
}
if (end - bp > 3 && bp[0] == 't' && bp[1] == '_') {
bp += 3; // skip t_xx, xx may be '-' or '>'
} else if (end - bp > 4 && STRNICMP(bp, "char-", 5) == 0) {
vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0);
bp += l + 5;
break;
}
}
if (bp <= end && *bp == '>') { // found matching '>'
end_of_name = bp + 1;
/* Which modifiers are given? */
modifiers = 0x0;
for (bp = src + 1; bp < last_dash; bp++) {
if (*bp != '-') {
bit = name_to_mod_mask(*bp);
if (bit == 0x0) {
break; // Illegal modifier name
}
modifiers |= bit;
}
}
// Legal modifier name.
if (bp >= last_dash) {
if (STRNICMP(last_dash + 1, "char-", 5) == 0
&& ascii_isdigit(last_dash[6])) {
// <Char-123> or <Char-033> or <Char-0x33>
vim_str2nr(last_dash + 6, NULL, NULL, STR2NR_ALL, NULL, &n, 0);
key = (int)n;
} else {
int off = 1;
// Modifier with single letter, or special key name.
if (in_string && last_dash[1] == '\\' && last_dash[2] == '"') {
off = 2;
}
l = mb_ptr2len(last_dash + 1);
if (modifiers != 0 && last_dash[l + 1] == '>') {
key = PTR2CHAR(last_dash + off);
} else {
key = get_special_key_code(last_dash + off);
if (!keep_x_key) {
key = handle_x_keys(key);
}
}
}
// get_special_key_code() may return NUL for invalid
// special key name.
if (key != NUL) {
// Only use a modifier when there is no special key code that
// includes the modifier.
key = simplify_key(key, &modifiers);
if (!keycode) {
// don't want keycode, use single byte code
if (key == K_BS) {
key = BS;
} else if (key == K_DEL || key == K_KDEL) {
key = DEL;
}
}
// Normal Key with modifier:
// Try to make a single byte code (except for Alt/Meta modifiers).
if (!IS_SPECIAL(key)) {
key = extract_modifiers(key, &modifiers);
}
*modp = modifiers;
*srcp = end_of_name;
return key;
}
}
}
return 0;
}
/*
* Decode one item and put it in "res". If "res" is NULL only advance.
* Must already have skipped white space.
*
* Return FAIL for a decoding error.
* Return MAYBE for an incomplete message.
*/
static int
json_decode_item(js_read_T *reader, typval_T *res, int options)
{
char_u *p;
int len;
fill_numbuflen(reader);
p = reader->js_buf + reader->js_used;
switch (*p)
{
case '[': /* array */
return json_decode_array(reader, res, options);
case '{': /* object */
return json_decode_object(reader, res, options);
case '"': /* string */
return json_decode_string(reader, res);
case ',': /* comma: empty item */
if ((options & JSON_JS) == 0)
return FAIL;
/* FALLTHROUGH */
case NUL: /* empty */
if (res != NULL)
{
res->v_type = VAR_SPECIAL;
res->vval.v_number = VVAL_NONE;
}
return OK;
default:
if (VIM_ISDIGIT(*p) || *p == '-')
{
char_u *sp = p;
#ifdef FEAT_FLOAT
if (*sp == '-')
{
++sp;
if (*sp == NUL)
return MAYBE;
if (!VIM_ISDIGIT(*sp))
return FAIL;
}
sp = skipdigits(sp);
if (*sp == '.' || *sp == 'e' || *sp == 'E')
{
if (res == NULL)
{
float_T f;
len = string2float(p, &f);
}
else
{
res->v_type = VAR_FLOAT;
len = string2float(p, &res->vval.v_float);
}
}
else
#endif
{
long nr;
vim_str2nr(reader->js_buf + reader->js_used,
NULL, &len, 0, /* what */
&nr, NULL, 0);
if (res != NULL)
{
res->v_type = VAR_NUMBER;
res->vval.v_number = nr;
}
}
reader->js_used += len;
return OK;
}
if (STRNICMP((char *)p, "false", 5) == 0)
{
reader->js_used += 5;
if (res != NULL)
{
res->v_type = VAR_SPECIAL;
res->vval.v_number = VVAL_FALSE;
}
return OK;
}
if (STRNICMP((char *)p, "true", 4) == 0)
{
reader->js_used += 4;
if (res != NULL)
{
res->v_type = VAR_SPECIAL;
res->vval.v_number = VVAL_TRUE;
}
return OK;
}
if (STRNICMP((char *)p, "null", 4) == 0)
{
reader->js_used += 4;
if (res != NULL)
{
res->v_type = VAR_SPECIAL;
res->vval.v_number = VVAL_NULL;
}
return OK;
}
/* check for truncated name */
len = (int)(reader->js_end - (reader->js_buf + reader->js_used));
if ((len < 5 && STRNICMP((char *)p, "false", len) == 0)
|| (len < 4 && (STRNICMP((char *)p, "true", len) == 0
|| STRNICMP((char *)p, "null", len) == 0)))
return MAYBE;
break;
}
if (res != NUL)
{
res->v_type = VAR_SPECIAL;
res->vval.v_number = VVAL_NONE;
}
return FAIL;
}
DBGSTATIC NET_API_STATUS
GetCmdValue(
IN DWORD argc,
IN LPTSTR argv[],
IN LPTSTR SwitchName,
IN OUT LPWSTR * ParmValue
)
/*++
Routine Description :
read a parameter from command line
Arguments :
argc, argv : command line parameters
SwitchName : parameter name
Return Value :
return NO_ERROR if successfully retrive the requested parameter and
ParmValue is set appropriately.
return ERROR_INVALID_PARAMETER if it can't retrive the parameter.
ReplFinish is called to terminate service.
--*/
{
NET_API_STATUS ApiStatus = NO_ERROR; // innocent until proven guilty
LPTSTR SepaPtr;
DWORD i;
*ParmValue = NULL;
NetpAssert( SwitchName[0] == TCHAR_FWDSLASH );
for(i = 0; i < argc; i++) {
SepaPtr = STRCHR(argv[i], (TCHAR) ':');
if (SepaPtr == NULL) {
ReplConfigReportBadParmValue( SwitchName, NULL );
ApiStatus = ERROR_INVALID_PARAMETER;
break;
}
if (STRNICMP(argv[i], SwitchName, (SepaPtr - argv[i])) == 0) {
*ParmValue = NetpAllocWStrFromTStr( SepaPtr + 1 ); // skip colon.
if(*ParmValue == NULL) {
NetpKdPrint(( "[REPL] GetCmdValue: out of memory.\n" ));
ReplFinish(
SERVICE_UIC_CODE(
SERVICE_UIC_RESOURCE,
SERVICE_UIC_M_MEMORY),
NULL);
ApiStatus = ERROR_NOT_ENOUGH_MEMORY;
break;
}
break;
}
}
IF_DEBUG(REPL) {
NetpKdPrint(( "GetCmdValue: returning " FORMAT_API_STATUS
" while searching for '" FORMAT_LPTSTR "',\n",
ApiStatus, SwitchName ));
NetpKdPrint(( " *ParmValue = " FORMAT_LPVOID ".\n",
(LPVOID) *ParmValue));
}
return( ApiStatus );
}
/*
* Return TRUE if "name" appears to be that of a terminal
* known to support the xterm-style mouse protocol.
* Relies on term_is_xterm having been set to its correct value.
*/
int use_xterm_like_mouse(char_u *name)
{
return name != NULL
&& (term_is_xterm || STRNICMP(name, "screen", 6) == 0);
}
/*
* Decode one item and put it in "res". If "res" is NULL only advance.
* Must already have skipped white space.
*
* Return FAIL for a decoding error (and give an error).
* Return MAYBE for an incomplete message.
*/
static int
json_decode_item(js_read_T *reader, typval_T *res, int options)
{
char_u *p;
int len;
int retval;
garray_T stack;
typval_T item;
typval_T *cur_item;
json_dec_item_T *top_item;
char_u key_buf[NUMBUFLEN];
ga_init2(&stack, sizeof(json_dec_item_T), 100);
cur_item = res;
init_tv(&item);
if (res != NULL)
init_tv(res);
fill_numbuflen(reader);
p = reader->js_buf + reader->js_used;
for (;;)
{
top_item = NULL;
if (stack.ga_len > 0)
{
top_item = ((json_dec_item_T *)stack.ga_data) + stack.ga_len - 1;
json_skip_white(reader);
p = reader->js_buf + reader->js_used;
if (*p == NUL)
{
retval = MAYBE;
if (top_item->jd_type == JSON_OBJECT)
/* did get the key, clear it */
clear_tv(&top_item->jd_key_tv);
goto theend;
}
if (top_item->jd_type == JSON_OBJECT_KEY
|| top_item->jd_type == JSON_ARRAY)
{
/* Check for end of object or array. */
if (*p == (top_item->jd_type == JSON_ARRAY ? ']' : '}'))
{
++reader->js_used; /* consume the ']' or '}' */
--stack.ga_len;
if (stack.ga_len == 0)
{
retval = OK;
goto theend;
}
if (cur_item != NULL)
cur_item = &top_item->jd_tv;
goto item_end;
}
}
}
if (top_item != NULL && top_item->jd_type == JSON_OBJECT_KEY
&& (options & JSON_JS)
&& reader->js_buf[reader->js_used] != '"'
&& reader->js_buf[reader->js_used] != '\''
&& reader->js_buf[reader->js_used] != '['
&& reader->js_buf[reader->js_used] != '{')
{
char_u *key;
/* accept an object key that is not in quotes */
key = p = reader->js_buf + reader->js_used;
while (*p != NUL && *p != ':' && *p > ' ')
++p;
if (cur_item != NULL)
{
cur_item->v_type = VAR_STRING;
cur_item->vval.v_string = vim_strnsave(key, (int)(p - key));
top_item->jd_key = cur_item->vval.v_string;
}
reader->js_used += (int)(p - key);
}
else
{
switch (*p)
{
case '[': /* start of array */
if (top_item && top_item->jd_type == JSON_OBJECT_KEY)
{
retval = FAIL;
break;
}
if (ga_grow(&stack, 1) == FAIL)
{
retval = FAIL;
break;
}
if (cur_item != NULL && rettv_list_alloc(cur_item) == FAIL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_NONE;
retval = FAIL;
break;
}
++reader->js_used; /* consume the '[' */
top_item = ((json_dec_item_T *)stack.ga_data)
+ stack.ga_len;
top_item->jd_type = JSON_ARRAY;
++stack.ga_len;
if (cur_item != NULL)
{
top_item->jd_tv = *cur_item;
cur_item = &item;
}
continue;
case '{': /* start of object */
if (top_item && top_item->jd_type == JSON_OBJECT_KEY)
{
retval = FAIL;
break;
}
if (ga_grow(&stack, 1) == FAIL)
{
retval = FAIL;
break;
}
if (cur_item != NULL && rettv_dict_alloc(cur_item) == FAIL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_NONE;
retval = FAIL;
break;
}
++reader->js_used; /* consume the '{' */
top_item = ((json_dec_item_T *)stack.ga_data)
+ stack.ga_len;
top_item->jd_type = JSON_OBJECT_KEY;
++stack.ga_len;
if (cur_item != NULL)
{
top_item->jd_tv = *cur_item;
cur_item = &top_item->jd_key_tv;
}
continue;
case '"': /* string */
retval = json_decode_string(reader, cur_item, *p);
break;
case '\'':
if (options & JSON_JS)
retval = json_decode_string(reader, cur_item, *p);
else
{
EMSG(_(e_invarg));
retval = FAIL;
}
break;
case ',': /* comma: empty item */
if ((options & JSON_JS) == 0)
{
EMSG(_(e_invarg));
retval = FAIL;
break;
}
/* FALLTHROUGH */
case NUL: /* empty */
if (cur_item != NULL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_NONE;
}
retval = OK;
break;
default:
if (VIM_ISDIGIT(*p) || *p == '-')
{
#ifdef FEAT_FLOAT
char_u *sp = p;
if (*sp == '-')
{
++sp;
if (*sp == NUL)
{
retval = MAYBE;
break;
}
if (!VIM_ISDIGIT(*sp))
{
EMSG(_(e_invarg));
retval = FAIL;
break;
}
}
sp = skipdigits(sp);
if (*sp == '.' || *sp == 'e' || *sp == 'E')
{
if (cur_item == NULL)
{
float_T f;
len = string2float(p, &f);
}
else
{
cur_item->v_type = VAR_FLOAT;
len = string2float(p, &cur_item->vval.v_float);
}
}
else
#endif
{
varnumber_T nr;
vim_str2nr(reader->js_buf + reader->js_used,
NULL, &len, 0, /* what */
&nr, NULL, 0);
if (cur_item != NULL)
{
cur_item->v_type = VAR_NUMBER;
cur_item->vval.v_number = nr;
}
}
reader->js_used += len;
retval = OK;
break;
}
if (STRNICMP((char *)p, "false", 5) == 0)
{
reader->js_used += 5;
if (cur_item != NULL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_FALSE;
}
retval = OK;
break;
}
if (STRNICMP((char *)p, "true", 4) == 0)
{
reader->js_used += 4;
if (cur_item != NULL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_TRUE;
}
retval = OK;
break;
}
if (STRNICMP((char *)p, "null", 4) == 0)
{
reader->js_used += 4;
if (cur_item != NULL)
{
cur_item->v_type = VAR_SPECIAL;
cur_item->vval.v_number = VVAL_NULL;
}
retval = OK;
break;
}
#ifdef FEAT_FLOAT
if (STRNICMP((char *)p, "NaN", 3) == 0)
{
reader->js_used += 3;
if (cur_item != NULL)
{
cur_item->v_type = VAR_FLOAT;
cur_item->vval.v_float = NAN;
}
retval = OK;
break;
}
if (STRNICMP((char *)p, "Infinity", 8) == 0)
{
reader->js_used += 8;
if (cur_item != NULL)
{
cur_item->v_type = VAR_FLOAT;
cur_item->vval.v_float = INFINITY;
}
retval = OK;
break;
}
#endif
/* check for truncated name */
len = (int)(reader->js_end - (reader->js_buf + reader->js_used));
if (
(len < 5 && STRNICMP((char *)p, "false", len) == 0)
#ifdef FEAT_FLOAT
|| (len < 8 && STRNICMP((char *)p, "Infinity", len) == 0)
|| (len < 3 && STRNICMP((char *)p, "NaN", len) == 0)
#endif
|| (len < 4 && (STRNICMP((char *)p, "true", len) == 0
|| STRNICMP((char *)p, "null", len) == 0)))
retval = MAYBE;
else
retval = FAIL;
break;
}
/* We are finished when retval is FAIL or MAYBE and when at the
* toplevel. */
if (retval == FAIL)
break;
if (retval == MAYBE || stack.ga_len == 0)
goto theend;
if (top_item != NULL && top_item->jd_type == JSON_OBJECT_KEY
&& cur_item != NULL)
{
top_item->jd_key = get_tv_string_buf_chk(cur_item, key_buf);
if (top_item->jd_key == NULL)
{
clear_tv(cur_item);
EMSG(_(e_invarg));
retval = FAIL;
goto theend;
}
}
}
item_end:
top_item = ((json_dec_item_T *)stack.ga_data) + stack.ga_len - 1;
switch (top_item->jd_type)
{
case JSON_ARRAY:
if (res != NULL)
{
listitem_T *li = listitem_alloc();
if (li == NULL)
{
clear_tv(cur_item);
retval = FAIL;
goto theend;
}
li->li_tv = *cur_item;
list_append(top_item->jd_tv.vval.v_list, li);
}
if (cur_item != NULL)
cur_item = &item;
json_skip_white(reader);
p = reader->js_buf + reader->js_used;
if (*p == ',')
++reader->js_used;
else if (*p != ']')
{
if (*p == NUL)
retval = MAYBE;
else
{
EMSG(_(e_invarg));
retval = FAIL;
}
goto theend;
}
break;
case JSON_OBJECT_KEY:
json_skip_white(reader);
p = reader->js_buf + reader->js_used;
if (*p != ':')
{
if (cur_item != NULL)
clear_tv(cur_item);
if (*p == NUL)
retval = MAYBE;
else
{
EMSG(_(e_invarg));
retval = FAIL;
}
goto theend;
}
++reader->js_used;
json_skip_white(reader);
top_item->jd_type = JSON_OBJECT;
if (cur_item != NULL)
cur_item = &item;
break;
case JSON_OBJECT:
if (cur_item != NULL
&& dict_find(top_item->jd_tv.vval.v_dict,
top_item->jd_key, -1) != NULL)
{
EMSG2(_("E938: Duplicate key in JSON: \"%s\""),
top_item->jd_key);
clear_tv(&top_item->jd_key_tv);
clear_tv(cur_item);
retval = FAIL;
goto theend;
}
if (cur_item != NULL)
{
dictitem_T *di = dictitem_alloc(top_item->jd_key);
clear_tv(&top_item->jd_key_tv);
if (di == NULL)
{
clear_tv(cur_item);
retval = FAIL;
goto theend;
}
di->di_tv = *cur_item;
di->di_tv.v_lock = 0;
if (dict_add(top_item->jd_tv.vval.v_dict, di) == FAIL)
{
dictitem_free(di);
retval = FAIL;
goto theend;
}
}
json_skip_white(reader);
p = reader->js_buf + reader->js_used;
if (*p == ',')
++reader->js_used;
else if (*p != '}')
{
if (*p == NUL)
retval = MAYBE;
else
{
EMSG(_(e_invarg));
retval = FAIL;
}
goto theend;
}
top_item->jd_type = JSON_OBJECT_KEY;
if (cur_item != NULL)
cur_item = &top_item->jd_key_tv;
break;
}
}
/* Get here when parsing failed. */
if (res != NULL)
{
clear_tv(res);
res->v_type = VAR_SPECIAL;
res->vval.v_number = VVAL_NONE;
}
EMSG(_(e_invarg));
theend:
ga_clear(&stack);
return retval;
}
/*
* Either execute a command by calling the shell or start a new shell
*/
int
mch_call_shell(
char_u *cmd,
int options) /* SHELL_, see vim.h */
{
int x;
int tmode = cur_tmode;
out_flush();
#ifdef MCH_WRITE_DUMP
if (fdDump)
{
fprintf(fdDump, "mch_call_shell(\"%s\", %d)\n", cmd, options);
fflush(fdDump);
}
#endif
/*
* Catch all deadly signals while running the external command, because a
* CTRL-C, Ctrl-Break or illegal instruction might otherwise kill us.
*/
signal(SIGINT, SIG_IGN);
signal(SIGILL, SIG_IGN);
signal(SIGFPE, SIG_IGN);
signal(SIGSEGV, SIG_IGN);
signal(SIGTERM, SIG_IGN);
signal(SIGABRT, SIG_IGN);
if (options & SHELL_COOKED)
settmode(TMODE_COOK); /* set to normal mode */
if (cmd == NULL)
{
x = mch_system(p_sh, options);
}
else
{
/* we use "command" or "cmd" to start the shell; slow but easy */
char_u *newcmd;
newcmd = lalloc(
STRLEN(p_sh) + STRLEN(p_shcf) + STRLEN(cmd) + 10, TRUE);
if (newcmd != NULL)
{
if (STRNICMP(cmd, "start ", 6) == 0)
{
sprintf((char *)newcmd, "%s\0", cmd+6);
if (WinExec((LPCSTR)newcmd, SW_SHOWNORMAL) > 31)
x = 0;
else
x = -1;
}
else
{
sprintf((char *)newcmd, "%s%s %s %s",
"",
p_sh,
p_shcf,
cmd);
x = mch_system((char *)newcmd, options);
}
vim_free(newcmd);
}
}
if (tmode == TMODE_RAW)
settmode(TMODE_RAW); /* set to raw mode */
if (x && !(options & SHELL_SILENT) && !emsg_silent)
{
smsg(_("shell returned %d"), x);
msg_putchar('\n');
}
#ifdef FEAT_TITLE
resettitle();
#endif
signal(SIGINT, SIG_DFL);
signal(SIGILL, SIG_DFL);
signal(SIGFPE, SIG_DFL);
signal(SIGSEGV, SIG_DFL);
signal(SIGTERM, SIG_DFL);
signal(SIGABRT, SIG_DFL);
return x;
}
