自学教程：C++ EMSG2函数代码示例

/// Gets the hostname of the current machine.////// @param hostname   Buffer to store the hostname./// @param size       Size of `hostname`.void os_get_hostname(char *hostname, size_t size){#ifdef HAVE_SYS_UTSNAME_H  struct utsname vutsname;  if (uname(&vutsname) < 0) {    *hostname = '/0';  } else {    xstrlcpy(hostname, vutsname.nodename, size);  }#elif defined(WIN32)  wchar_t host_utf16[MAX_COMPUTERNAME_LENGTH + 1];  DWORD host_wsize = sizeof(host_utf16) / sizeof(host_utf16[0]);  if (GetComputerNameW(host_utf16, &host_wsize) == 0) {    *hostname = '/0';    DWORD err = GetLastError();    EMSG2("GetComputerNameW failed: %d", err);    return;  }  host_utf16[host_wsize] = '/0';  char *host_utf8;  int conversion_result = utf16_to_utf8(host_utf16, &host_utf8);  if (conversion_result != 0) {    EMSG2("utf16_to_utf8 failed: %d", conversion_result);    return;  }  xstrlcpy(hostname, host_utf8, size);  xfree(host_utf8);#else  EMSG("os_get_hostname failed: missing uname()");  *hostname = '/0';#endif}

/* * Load library and get all pointers. * Parameter 'libname' provides name of DLL. * Return OK or FAIL. */    static intruby_runtime_link_init(char *libname, int verbose){    int i;    if (hinstRuby)	return OK;    hinstRuby = load_dll(libname);    if (!hinstRuby)    {	if (verbose)	    EMSG2(_(e_loadlib), libname);	return FAIL;    }    for (i = 0; ruby_funcname_table[i].ptr; ++i)    {	if (!(*ruby_funcname_table[i].ptr = symbol_from_dll(hinstRuby,			ruby_funcname_table[i].name)))	{	    close_dll(hinstRuby);	    hinstRuby = NULL;	    if (verbose)		EMSG2(_(e_loadfunc), ruby_funcname_table[i].name);	    return FAIL;	}    }    return OK;}

    static intlua_link_init(char *libname, int verbose){    const luaV_Reg *reg;    if (hinstLua) return OK;    hinstLua = load_dll(libname);    if (!hinstLua)    {	if (verbose)	    EMSG2(_(e_loadlib), libname);	return FAIL;    }    for (reg = luaV_dll; reg->func; reg++)    {	if ((*reg->func = symbol_from_dll(hinstLua, reg->name)) == NULL)	{	    close_dll(hinstLua);	    hinstLua = 0;	    if (verbose)		EMSG2(_(e_loadfunc), reg->name);	    return FAIL;	}    }    return OK;}

/* * Allocate a variable for a List and fill it from "*arg". * Return OK or FAIL. */    intget_list_tv(char_u **arg, typval_T *rettv, int evaluate){    list_T	*l = NULL;    typval_T	tv;    listitem_T	*item;    if (evaluate)    {	l = list_alloc();	if (l == NULL)	    return FAIL;    }    *arg = skipwhite(*arg + 1);    while (**arg != ']' && **arg != NUL)    {	if (eval1(arg, &tv, evaluate) == FAIL)	/* recursive! */	    goto failret;	if (evaluate)	{	    item = listitem_alloc();	    if (item != NULL)	    {		item->li_tv = tv;		item->li_tv.v_lock = 0;		list_append(l, item);	    }	    else		clear_tv(&tv);	}	if (**arg == ']')	    break;	if (**arg != ',')	{	    EMSG2(_("E696: Missing comma in List: %s"), *arg);	    goto failret;	}	*arg = skipwhite(*arg + 1);    }    if (**arg != ']')    {	EMSG2(_("E697: Missing end of List ']': %s"), *arg);failret:	if (evaluate)	    list_free(l);	return FAIL;    }    *arg = skipwhite(*arg + 1);    if (evaluate)	rettv_list_set(rettv, l);    return OK;}

/* * Get a font structure for highlighting. */    GuiFontgui_mch_get_font(char_u *name, int giveErrorIfMissing){    if(vimjs_check_font((char*)name))         return (char*)vim_strsave(name);    if (giveErrorIfMissing)        EMSG2(_(e_font), name);    return NOFONT;}

/// Add item with key "key" to hashtable "ht".////// @param ht/// @param key////// @returns FAIL when out of memory or the key is already present.int hash_add(hashtab_T *ht, char_u *key){  hash_T hash = hash_hash(key);  hashitem_T *hi = hash_lookup(ht, key, hash);  if (!HASHITEM_EMPTY(hi)) {    EMSG2(_(e_intern2), "hash_add()");    return FAIL;  }  return hash_add_item(ht, hi, key, hash);}

/* * Lookup a property type by name.  First in "buf" and when not found in the * global types. * When not found gives an error message and returns NULL. */    static proptype_T *lookup_prop_type(char_u *name, buf_T *buf){    proptype_T *type = find_prop(name, buf);    if (type == NULL)	type = find_prop(name, NULL);    if (type == NULL)	EMSG2(_(e_type_not_exist), name);    return type;}

/* * Load library and get all pointers. * Parameter 'libname' provides name of DLL. * Return OK or FAIL. */    static intpython_runtime_link_init(char *libname, int verbose){    int i;#if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON3)    /* Can't have Python and Python3 loaded at the same time.     * It cause a crash, because RTLD_GLOBAL is needed for     * standard C extension libraries of one or both python versions. */    if (python3_loaded())    {	if (verbose)	    EMSG(_("E836: This Vim cannot execute :python after using :py3"));	return FAIL;    }#endif    if (hinstPython)	return OK;    hinstPython = load_dll(libname);    if (!hinstPython)    {	if (verbose)	    EMSG2(_(e_loadlib), libname);	return FAIL;    }    for (i = 0; python_funcname_table[i].ptr; ++i)    {	if ((*python_funcname_table[i].ptr = symbol_from_dll(hinstPython,			python_funcname_table[i].name)) == NULL)	{	    close_dll(hinstPython);	    hinstPython = 0;	    if (verbose)		EMSG2(_(e_loadfunc), python_funcname_table[i].name);	    return FAIL;	}    }    return OK;}

/* * Remove item "item" from Dictionary "dict" and free it. */    voiddictitem_remove(dict_T *dict, dictitem_T *item){    hashitem_T	*hi;    hi = hash_find(&dict->dv_hashtab, item->di_key);    if (HASHITEM_EMPTY(hi))	EMSG2(_(e_intern2), "dictitem_remove()");    else	hash_remove(&dict->dv_hashtab, hi);    dictitem_free(item);}

static voidshow_one_mark(    int c,    char_u *arg,    pos_T *p,    char_u *name,    int current                    /* in current file */){  static int did_title = FALSE;  int mustfree = FALSE;  if (c == -1) {                            /* finish up */    if (did_title)      did_title = FALSE;    else {      if (arg == NULL)        MSG(_("No marks set"));      else        EMSG2(_("E283: No marks matching /"%s/""), arg);    }  }  /* don't output anything if 'q' typed at --more-- prompt */  else if (!got_int           && (arg == NULL || vim_strchr(arg, c) != NULL)           && p->lnum != 0) {    if (!did_title) {      /* Highlight title */      MSG_PUTS_TITLE(_("/nmark line  col file/text"));      did_title = TRUE;    }    msg_putchar('/n');    if (!got_int) {      sprintf((char *)IObuff, " %c %6ld %4d ", c, p->lnum, p->col);      msg_outtrans(IObuff);      if (name == NULL && current) {        name = mark_line(p, 15);        mustfree = TRUE;      }      if (name != NULL) {        msg_outtrans_attr(name, current ? HL_ATTR(HLF_D) : 0);        if (mustfree) {          xfree(name);        }      }    }    ui_flush();                    /* show one line at a time */  }}

/* * Go over all entries in "d2" and add them to "d1". * When "action" is "error" then a duplicate key is an error. * When "action" is "force" then a duplicate key is overwritten. * Otherwise duplicate keys are ignored ("action" is "keep"). */    voiddict_extend(dict_T *d1, dict_T *d2, char_u *action){    dictitem_T	*di1;    hashitem_T	*hi2;    int		todo;    char_u	*arg_errmsg = (char_u *)N_("extend() argument");    todo = (int)d2->dv_hashtab.ht_used;    for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2)    {	if (!HASHITEM_EMPTY(hi2))	{	    --todo;	    di1 = dict_find(d1, hi2->hi_key, -1);	    if (d1->dv_scope != 0)	    {		/* Disallow replacing a builtin function in l: and g:.		 * Check the key to be valid when adding to any scope. */		if (d1->dv_scope == VAR_DEF_SCOPE			&& HI2DI(hi2)->di_tv.v_type == VAR_FUNC			&& var_check_func_name(hi2->hi_key, di1 == NULL))		    break;		if (!valid_varname(hi2->hi_key))		    break;	    }	    if (di1 == NULL)	    {		di1 = dictitem_copy(HI2DI(hi2));		if (di1 != NULL && dict_add(d1, di1) == FAIL)		    dictitem_free(di1);	    }	    else if (*action == 'e')	    {		EMSG2(_("E737: Key already exists: %s"), hi2->hi_key);		break;	    }	    else if (*action == 'f' && HI2DI(hi2) != di1)	    {		if (tv_check_lock(di1->di_tv.v_lock, arg_errmsg, TRUE)		      || var_check_ro(di1->di_flags, arg_errmsg, TRUE))		    break;		clear_tv(&di1->di_tv);		copy_tv(&HI2DI(hi2)->di_tv, &di1->di_tv);	    }	}    }}

/* * Show the mapping associated with a menu item or hierarchy in a sub-menu. */static int show_menus(char_u *path_name, int modes){  char_u      *p;  char_u      *name;  vimmenu_T   *menu;  vimmenu_T   *parent = NULL;  menu = root_menu;  name = path_name = vim_strsave(path_name);  /* First, find the (sub)menu with the given name */  while (*name) {    p = menu_name_skip(name);    while (menu != NULL) {      if (menu_name_equal(name, menu)) {        /* Found menu */        if (*p != NUL && menu->children == NULL) {          EMSG(_(e_notsubmenu));          free(path_name);          return FAIL;        } else if ((menu->modes & modes) == 0x0) {          EMSG(_(e_othermode));          free(path_name);          return FAIL;        }        break;      }      menu = menu->next;    }    if (menu == NULL) {      EMSG2(_(e_nomenu), name);      free(path_name);      return FAIL;    }    name = p;    parent = menu;    menu = menu->children;  }  free(path_name);  /* Now we have found the matching menu, and we list the mappings */  /* Highlight title */  MSG_PUTS_TITLE(_("/n--- Menus ---"));  show_menus_recursive(parent, modes, 0);  return OK;}

/* * Set the (sub)menu with the given name to enabled or disabled. * Called recursively. */static int menu_nable_recurse(vimmenu_T *menu, char_u *name, int modes, int enable){  char_u      *p;  if (menu == NULL)    return OK;                  /* Got to bottom of hierarchy */  /* Get name of this element in the menu hierarchy */  p = menu_name_skip(name);  /* Find the menu */  while (menu != NULL) {    if (*name == NUL || *name == '*' || menu_name_equal(name, menu)) {      if (*p != NUL) {        if (menu->children == NULL) {          EMSG(_(e_notsubmenu));          return FAIL;        }        if (menu_nable_recurse(menu->children, p, modes, enable)            == FAIL)          return FAIL;      } else if (enable)        menu->enabled |= modes;      else        menu->enabled &= ~modes;      /*       * When name is empty, we are doing all menu items for the given       * modes, so keep looping, otherwise we are just doing the named       * menu item (which has been found) so break here.       */      if (*name != NUL && *name != '*')        break;    }    menu = menu->next;  }  if (*name != NUL && *name != '*' && menu == NULL) {    EMSG2(_(e_nomenu), name);    return FAIL;  }  return OK;}

//.........这里部分代码省略.........    /* save the fix part of the path */    search_ctx->ffsc_fix_path = vim_strnsave(path, (int)(wc_part - path));    /*     * copy wc_path and add restricts to the '**' wildcard.     * The octet after a '**' is used as a (binary) counter.     * So '**3' is transposed to '**^C' ('^C' is ASCII value 3)     * or '**76' is transposed to '**N'( 'N' is ASCII value 76).     * For EBCDIC you get different character values.     * If no restrict is given after '**' the default is used.     * Due to this technique the path looks awful if you print it as a     * string.     */    len = 0;    while (*wc_part != NUL) {      if (len + 5 >= MAXPATHL) {        EMSG(_(e_pathtoolong));        break;      }      if (STRNCMP(wc_part, "**", 2) == 0) {        ff_expand_buffer[len++] = *wc_part++;        ff_expand_buffer[len++] = *wc_part++;        llevel = strtol((char *)wc_part, &errpt, 10);        if ((char_u *)errpt != wc_part && llevel > 0 && llevel < 255)          ff_expand_buffer[len++] = llevel;        else if ((char_u *)errpt != wc_part && llevel == 0)          /* restrict is 0 -> remove already added '**' */          len -= 2;        else          ff_expand_buffer[len++] = FF_MAX_STAR_STAR_EXPAND;        wc_part = (char_u *)errpt;        if (*wc_part != NUL && !vim_ispathsep(*wc_part)) {          EMSG2(_(                  "E343: Invalid path: '**[number]' must be at the end of the path or be followed by '%s'."),              PATHSEPSTR);          goto error_return;        }      } else        ff_expand_buffer[len++] = *wc_part++;    }    ff_expand_buffer[len] = NUL;    search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer);  } else    search_ctx->ffsc_fix_path = vim_strsave(path);  if (search_ctx->ffsc_start_dir == NULL) {    /* store the fix part as startdir.     * This is needed if the parameter path is fully qualified.     */    search_ctx->ffsc_start_dir = vim_strsave(search_ctx->ffsc_fix_path);    search_ctx->ffsc_fix_path[0] = NUL;  }  /* create an absolute path */  if (STRLEN(search_ctx->ffsc_start_dir)      + STRLEN(search_ctx->ffsc_fix_path) + 3 >= MAXPATHL) {    EMSG(_(e_pathtoolong));    goto error_return;  }  STRCPY(ff_expand_buffer, search_ctx->ffsc_start_dir);  add_pathsep(ff_expand_buffer);  {    size_t eb_len = STRLEN(ff_expand_buffer);    char_u *buf = xmalloc(eb_len + STRLEN(search_ctx->ffsc_fix_path) + 1);

/* * Remove the (sub)menu with the given name from the menu hierarchy * Called recursively. */static intremove_menu (    vimmenu_T **menup,    char_u *name,    int modes,    bool silent                     /* don't give error messages */){    vimmenu_T   *menu;    vimmenu_T   *child;    char_u      *p;    if (*menup == NULL)        return OK;                  /* Got to bottom of hierarchy */    /* Get name of this element in the menu hierarchy */    p = menu_name_skip(name);    /* Find the menu */    while ((menu = *menup) != NULL) {        if (*name == NUL || menu_name_equal(name, menu)) {            if (*p != NUL && menu->children == NULL) {                if (!silent)                    EMSG(_(e_notsubmenu));                return FAIL;            }            if ((menu->modes & modes) != 0x0) {                if (remove_menu(&menu->children, p, modes, silent) == FAIL)                    return FAIL;            } else if (*name != NUL) {                if (!silent)                    EMSG(_(e_othermode));                return FAIL;            }            /*             * When name is empty, we are removing all menu items for the given             * modes, so keep looping, otherwise we are just removing the named             * menu item (which has been found) so break here.             */            if (*name != NUL)                break;            /* Remove the menu item for the given mode[s].  If the menu item             * is no longer valid in ANY mode, delete it */            menu->modes &= ~modes;            if (modes & MENU_TIP_MODE)                free_menu_string(menu, MENU_INDEX_TIP);            if ((menu->modes & MENU_ALL_MODES) == 0)                free_menu(menup);            else                menup = &menu->next;        } else            menup = &menu->next;    }    if (*name != NUL) {        if (menu == NULL) {            if (!silent)                EMSG2(_(e_nomenu), name);            return FAIL;        }        /* Recalculate modes for menu based on the new updated children */        menu->modes &= ~modes;        child = menu->children;        for (; child != NULL; child = child->next)            menu->modes |= child->modes;        if (modes & MENU_TIP_MODE) {            free_menu_string(menu, MENU_INDEX_TIP);        }        if ((menu->modes & MENU_ALL_MODES) == 0) {            /* The menu item is no longer valid in ANY mode, so delete it */            *menup = menu;            free_menu(menup);        }    }    return OK;}

/* * Allocate a variable for a Dictionary and fill it from "*arg". * Return OK or FAIL.  Returns NOTDONE for {expr}. */    intget_dict_tv(char_u **arg, typval_T *rettv, int evaluate){    dict_T	*d = NULL;    typval_T	tvkey;    typval_T	tv;    char_u	*key = NULL;    dictitem_T	*item;    char_u	*start = skipwhite(*arg + 1);    char_u	buf[NUMBUFLEN];    /*     * First check if it's not a curly-braces thing: {expr}.     * Must do this without evaluating, otherwise a function may be called     * twice.  Unfortunately this means we need to call eval1() twice for the     * first item.     * But {} is an empty Dictionary.     */    if (*start != '}')    {	if (eval1(&start, &tv, FALSE) == FAIL)	/* recursive! */	    return FAIL;	if (*start == '}')	    return NOTDONE;    }    if (evaluate)    {	d = dict_alloc();	if (d == NULL)	    return FAIL;    }    tvkey.v_type = VAR_UNKNOWN;    tv.v_type = VAR_UNKNOWN;    *arg = skipwhite(*arg + 1);    while (**arg != '}' && **arg != NUL)    {	if (eval1(arg, &tvkey, evaluate) == FAIL)	/* recursive! */	    goto failret;	if (**arg != ':')	{	    EMSG2(_("E720: Missing colon in Dictionary: %s"), *arg);	    clear_tv(&tvkey);	    goto failret;	}	if (evaluate)	{	    key = get_tv_string_buf_chk(&tvkey, buf);	    if (key == NULL)	    {		/* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */		clear_tv(&tvkey);		goto failret;	    }	}	*arg = skipwhite(*arg + 1);	if (eval1(arg, &tv, evaluate) == FAIL)	/* recursive! */	{	    if (evaluate)		clear_tv(&tvkey);	    goto failret;	}	if (evaluate)	{	    item = dict_find(d, key, -1);	    if (item != NULL)	    {		EMSG2(_("E721: Duplicate key in Dictionary: /"%s/""), key);		clear_tv(&tvkey);		clear_tv(&tv);		goto failret;	    }	    item = dictitem_alloc(key);	    clear_tv(&tvkey);	    if (item != NULL)	    {		item->di_tv = tv;		item->di_tv.v_lock = 0;		if (dict_add(d, item) == FAIL)		    dictitem_free(item);	    }	}	if (**arg == '}')	    break;	if (**arg != ',')	{	    EMSG2(_("E722: Missing comma in Dictionary: %s"), *arg);	    goto failret;	}	*arg = skipwhite(*arg + 1);    }    if (**arg != '}')//.........这里部分代码省略.........

/* * Load library and get all pointers. * Parameter 'libname' provides name of DLL. * Return OK or FAIL. */static intpy3_runtime_link_init(char *libname, int verbose){	int i;	void *ucs_from_string, *ucs_decode, *ucs_as_encoded_string;# if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON)	/* Can't have Python and Python3 loaded at the same time.	 * It cause a crash, because RTLD_GLOBAL is needed for	 * standard C extension libraries of one or both python versions. */	if (python_loaded()) {		if (verbose)			EMSG(_("E837: This Vim cannot execute :py3 after using :python"));		return FAIL;	}# endif	if (hinstPy3 != 0)		return OK;	hinstPy3 = load_dll(libname);	if (!hinstPy3) {		if (verbose)			EMSG2(_(e_loadlib), libname);		return FAIL;	}	for (i = 0; py3_funcname_table[i].ptr; ++i) {		if ((*py3_funcname_table[i].ptr = symbol_from_dll(hinstPy3,										  py3_funcname_table[i].name)) == NULL) {			close_dll(hinstPy3);			hinstPy3 = 0;			if (verbose)				EMSG2(_(e_loadfunc), py3_funcname_table[i].name);			return FAIL;		}	}	/* Load unicode functions separately as only the ucs2 or the ucs4 functions	 * will be present in the library. */# if PY_VERSION_HEX >= 0x030300f0	ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicode_FromString");	ucs_decode = symbol_from_dll(hinstPy3, "PyUnicode_Decode");	ucs_as_encoded_string = symbol_from_dll(hinstPy3,											"PyUnicode_AsEncodedString");# else	ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicodeUCS2_FromString");	ucs_decode = symbol_from_dll(hinstPy3,								 "PyUnicodeUCS2_Decode");	ucs_as_encoded_string = symbol_from_dll(hinstPy3,											"PyUnicodeUCS2_AsEncodedString");	if (!ucs_from_string || !ucs_decode || !ucs_as_encoded_string) {		ucs_from_string = symbol_from_dll(hinstPy3,										  "PyUnicodeUCS4_FromString");		ucs_decode = symbol_from_dll(hinstPy3,									 "PyUnicodeUCS4_Decode");		ucs_as_encoded_string = symbol_from_dll(hinstPy3,												"PyUnicodeUCS4_AsEncodedString");	}# endif	if (ucs_from_string && ucs_decode && ucs_as_encoded_string) {		py3_PyUnicode_FromString = ucs_from_string;		py3_PyUnicode_Decode = ucs_decode;		py3_PyUnicode_AsEncodedString = ucs_as_encoded_string;	} else {		close_dll(hinstPy3);		hinstPy3 = 0;		if (verbose)			EMSG2(_(e_loadfunc), "PyUnicode_UCSX_*");		return FAIL;	}	return OK;}

//.........这里部分代码省略.........		case VVAL_FALSE: ga_concat(gap, (char_u *)"false"); break;		case VVAL_TRUE: ga_concat(gap, (char_u *)"true"); break;		case VVAL_NONE: break;		case VVAL_NULL: ga_concat(gap, (char_u *)"null"); break;	    }	    break;	case VAR_NUMBER:	    vim_snprintf((char *)numbuf, NUMBUFLEN, "%ld",						    (long)val->vval.v_number);	    ga_concat(gap, numbuf);	    break;	case VAR_STRING:	    res = val->vval.v_string;	    write_string(gap, res);	    break;	case VAR_FUNC:	    /* no JSON equivalent */	    EMSG(_(e_invarg));	    return FAIL;	case VAR_LIST:	    l = val->vval.v_list;	    if (l == NULL)		ga_concat(gap, (char_u *)"null");	    else	    {		if (l->lv_copyID == copyID)		    ga_concat(gap, (char_u *)"[]");		else		{		    listitem_T	*li;		    l->lv_copyID = copyID;		    ga_append(gap, '[');		    for (li = l->lv_first; li != NULL && !got_int; )		    {			if (json_encode_item(gap, &li->li_tv, copyID) == FAIL)			    return FAIL;			li = li->li_next;			if (li != NULL)			    ga_append(gap, ',');		    }		    ga_append(gap, ']');		    l->lv_copyID = 0;		}	    }	    break;	case VAR_DICT:	    d = val->vval.v_dict;	    if (d == NULL)		ga_concat(gap, (char_u *)"null");	    else	    {		if (d->dv_copyID == copyID)		    ga_concat(gap, (char_u *)"{}");		else		{		    int		first = TRUE;		    int		todo = (int)d->dv_hashtab.ht_used;		    hashitem_T	*hi;		    d->dv_copyID = copyID;		    ga_append(gap, '{');		    for (hi = d->dv_hashtab.ht_array; todo > 0 && !got_int;									 ++hi)			if (!HASHITEM_EMPTY(hi))			{			    --todo;			    if (first)				first = FALSE;			    else				ga_append(gap, ',');			    write_string(gap, hi->hi_key);			    ga_append(gap, ':');			    if (json_encode_item(gap, &dict_lookup(hi)->di_tv,							      copyID) == FAIL)				return FAIL;			}		    ga_append(gap, '}');		    d->dv_copyID = 0;		}	    }	    break;#ifdef FEAT_FLOAT	case VAR_FLOAT:	    vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", val->vval.v_float);	    ga_concat(gap, numbuf);	    break;#endif	default: EMSG2(_(e_intern2), "json_encode_item()"); break;		 return FAIL;    }    return OK;}

/* * ":delmarks[!] [marks]" */void ex_delmarks(exarg_T *eap){  char_u      *p;  int from, to;  int i;  int lower;  int digit;  int n;  if (*eap->arg == NUL && eap->forceit)    /* clear all marks */    clrallmarks(curbuf);  else if (eap->forceit)    EMSG(_(e_invarg));  else if (*eap->arg == NUL)    EMSG(_(e_argreq));  else {    /* clear specified marks only */    for (p = eap->arg; *p != NUL; ++p) {      lower = ASCII_ISLOWER(*p);      digit = VIM_ISDIGIT(*p);      if (lower || digit || ASCII_ISUPPER(*p)) {        if (p[1] == '-') {          /* clear range of marks */          from = *p;          to = p[2];          if (!(lower ? ASCII_ISLOWER(p[2])                : (digit ? VIM_ISDIGIT(p[2])                   : ASCII_ISUPPER(p[2])))              || to < from) {            EMSG2(_(e_invarg2), p);            return;          }          p += 2;        } else          /* clear one lower case mark */          from = to = *p;        for (i = from; i <= to; ++i) {          if (lower)            curbuf->b_namedm[i - 'a'].lnum = 0;          else {            if (digit)              n = i - '0' + NMARKS;            else              n = i - 'A';            namedfm[n].fmark.mark.lnum = 0;            vim_free(namedfm[n].fname);            namedfm[n].fname = NULL;          }        }      } else        switch (*p) {        case '"': curbuf->b_last_cursor.lnum = 0; break;        case '^': curbuf->b_last_insert.lnum = 0; break;        case '.': curbuf->b_last_change.lnum = 0; break;        case '[': curbuf->b_op_start.lnum    = 0; break;        case ']': curbuf->b_op_end.lnum      = 0; break;        case '<': curbuf->b_visual.vi_start.lnum = 0; break;        case '>': curbuf->b_visual.vi_end.lnum   = 0; break;        case ' ': break;        default:  EMSG2(_(e_invarg2), p);          return;        }    }  }}

//.........这里部分代码省略.........	    res = val->vval.v_string;	    write_string(gap, res);	    break;	case VAR_FUNC:	case VAR_JOB:	case VAR_CHANNEL:	    /* no JSON equivalent TODO: better error */	    EMSG(_(e_invarg));	    return FAIL;	case VAR_LIST:	    l = val->vval.v_list;	    if (l == NULL)		ga_concat(gap, (char_u *)"null");	    else	    {		if (l->lv_copyID == copyID)		    ga_concat(gap, (char_u *)"[]");		else		{		    listitem_T	*li;		    l->lv_copyID = copyID;		    ga_append(gap, '[');		    for (li = l->lv_first; li != NULL && !got_int; )		    {			if (json_encode_item(gap, &li->li_tv, copyID,						   options & JSON_JS) == FAIL)			    return FAIL;			if ((options & JSON_JS)				&& li->li_next == NULL				&& li->li_tv.v_type == VAR_SPECIAL				&& li->li_tv.vval.v_number == VVAL_NONE)			    /* add an extra comma if the last item is v:none */			    ga_append(gap, ',');			li = li->li_next;			if (li != NULL)			    ga_append(gap, ',');		    }		    ga_append(gap, ']');		    l->lv_copyID = 0;		}	    }	    break;	case VAR_DICT:	    d = val->vval.v_dict;	    if (d == NULL)		ga_concat(gap, (char_u *)"null");	    else	    {		if (d->dv_copyID == copyID)		    ga_concat(gap, (char_u *)"{}");		else		{		    int		first = TRUE;		    int		todo = (int)d->dv_hashtab.ht_used;		    hashitem_T	*hi;		    d->dv_copyID = copyID;		    ga_append(gap, '{');		    for (hi = d->dv_hashtab.ht_array; todo > 0 && !got_int;									 ++hi)			if (!HASHITEM_EMPTY(hi))			{			    --todo;			    if (first)				first = FALSE;			    else				ga_append(gap, ',');			    if ((options & JSON_JS)						 && is_simple_key(hi->hi_key))				ga_concat(gap, hi->hi_key);			    else				write_string(gap, hi->hi_key);			    ga_append(gap, ':');			    if (json_encode_item(gap, &dict_lookup(hi)->di_tv,				      copyID, options | JSON_NO_NONE) == FAIL)				return FAIL;			}		    ga_append(gap, '}');		    d->dv_copyID = 0;		}	    }	    break;	case VAR_FLOAT:#ifdef FEAT_FLOAT	    vim_snprintf((char *)numbuf, NUMBUFLEN, "%g", val->vval.v_float);	    ga_concat(gap, numbuf);	    break;#endif	case VAR_UNKNOWN:	    EMSG2(_(e_intern2), "json_encode_item()");	    return FAIL;    }    return OK;}

/* * Given a menu descriptor, e.g. "File.New", find it in the menu hierarchy and * execute it. */void ex_emenu(exarg_T *eap){  vimmenu_T   *menu;  char_u      *name;  char_u      *saved_name;  char_u      *p;  int idx;  char_u      *mode;  saved_name = vim_strsave(eap->arg);  menu = root_menu;  name = saved_name;  while (*name) {    /* Find in the menu hierarchy */    p = menu_name_skip(name);    while (menu != NULL) {      if (menu_name_equal(name, menu)) {        if (*p == NUL && menu->children != NULL) {          EMSG(_("E333: Menu path must lead to a menu item"));          menu = NULL;        } else if (*p != NUL && menu->children == NULL) {          EMSG(_(e_notsubmenu));          menu = NULL;        }        break;      }      menu = menu->next;    }    if (menu == NULL || *p == NUL)      break;    menu = menu->children;    name = p;  }  free(saved_name);  if (menu == NULL) {    EMSG2(_("E334: Menu not found: %s"), eap->arg);    return;  }  /* Found the menu, so execute.   * Use the Insert mode entry when returning to Insert mode. */  if (restart_edit      && !current_SID      ) {    mode = (char_u *)"Insert";    idx = MENU_INDEX_INSERT;  } else if (eap->addr_count) {    pos_T tpos;    mode = (char_u *)"Visual";    idx = MENU_INDEX_VISUAL;    /* GEDDES: This is not perfect - but it is a     * quick way of detecting whether we are doing this from a     * selection - see if the range matches up with the visual     * select start and end.  */    if ((curbuf->b_visual.vi_start.lnum == eap->line1)        && (curbuf->b_visual.vi_end.lnum) == eap->line2) {      /* Set it up for visual mode - equivalent to gv.  */      VIsual_mode = curbuf->b_visual.vi_mode;      tpos = curbuf->b_visual.vi_end;      curwin->w_cursor = curbuf->b_visual.vi_start;      curwin->w_curswant = curbuf->b_visual.vi_curswant;    } else {      /* Set it up for line-wise visual mode */      VIsual_mode = 'V';      curwin->w_cursor.lnum = eap->line1;      curwin->w_cursor.col = 1;      tpos.lnum = eap->line2;      tpos.col = MAXCOL;      tpos.coladd = 0;    }    /* Activate visual mode */    VIsual_active = TRUE;    VIsual_reselect = TRUE;    check_cursor();    VIsual = curwin->w_cursor;    curwin->w_cursor = tpos;    check_cursor();    /* Adjust the cursor to make sure it is in the correct pos     * for exclusive mode */    if (*p_sel == 'e' && gchar_cursor() != NUL)      ++curwin->w_cursor.col;  } else {    mode = (char_u *)"Normal";    idx = MENU_INDEX_NORMAL;  }  if (idx != MENU_INDEX_INVALID && menu->strings[idx] != NULL) {    /* When executing a script or function execute the commands right now.     * Otherwise put them in the typeahead buffer. *///.........这里部分代码省略.........

/* * Load library and get all pointers. * Parameter 'libname' provides name of DLL. * Return OK or FAIL. */    static intpython_runtime_link_init(char *libname, int verbose){    int i;    void *ucs_as_encoded_string;#if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON3)    /* Can't have Python and Python3 loaded at the same time.     * It cause a crash, because RTLD_GLOBAL is needed for     * standard C extension libraries of one or both python versions. */    if (python3_loaded())    {	if (verbose)	    EMSG(_("E836: This Vim cannot execute :python after using :py3"));	return FAIL;    }#endif    if (hinstPython)	return OK;    hinstPython = load_dll(libname);    if (!hinstPython)    {	if (verbose)	    EMSG2(_(e_loadlib), libname);	return FAIL;    }    for (i = 0; python_funcname_table[i].ptr; ++i)    {	if ((*python_funcname_table[i].ptr = symbol_from_dll(hinstPython,			python_funcname_table[i].name)) == NULL)	{	    close_dll(hinstPython);	    hinstPython = 0;	    if (verbose)		EMSG2(_(e_loadfunc), python_funcname_table[i].name);	    return FAIL;	}    }    /* Load unicode functions separately as only the ucs2 or the ucs4 functions     * will be present in the library. */    ucs_as_encoded_string = symbol_from_dll(hinstPython,					     "PyUnicodeUCS2_AsEncodedString");    if (ucs_as_encoded_string == NULL)	ucs_as_encoded_string = symbol_from_dll(hinstPython,					     "PyUnicodeUCS4_AsEncodedString");    if (ucs_as_encoded_string != NULL)	py_PyUnicode_AsEncodedString = ucs_as_encoded_string;    else    {	close_dll(hinstPython);	hinstPython = 0;	if (verbose)	    EMSG2(_(e_loadfunc), "PyUnicode_UCSX_*");	return FAIL;    }    return OK;}

/* * Remove the (sub)menu with the given name from the menu hierarchy * Called recursively. */static int remove_menu (    vimmenu_T **menup,    char_u *name,    int modes,    int silent                     /* don't give error messages */){  vimmenu_T   *menu;  vimmenu_T   *child;  char_u      *p;  if (*menup == NULL)    return OK;                  /* Got to bottom of hierarchy */  /* Get name of this element in the menu hierarchy */  p = menu_name_skip(name);  /* Find the menu */  while ((menu = *menup) != NULL) {    if (*name == NUL || menu_name_equal(name, menu)) {      if (*p != NUL && menu->children == NULL) {        if (!silent)          EMSG(_(e_notsubmenu));        return FAIL;      }      if ((menu->modes & modes) != 0x0) {#if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF)        /*         * If we are removing all entries for this menu,MENU_ALL_MODES,         * Then kill any tearoff before we start         */        if (*p == NUL && modes == MENU_ALL_MODES) {          if (IsWindow(menu->tearoff_handle))            DestroyWindow(menu->tearoff_handle);        }#endif        if (remove_menu(&menu->children, p, modes, silent) == FAIL)          return FAIL;      } else if (*name != NUL) {        if (!silent)          EMSG(_(e_othermode));        return FAIL;      }      /*       * When name is empty, we are removing all menu items for the given       * modes, so keep looping, otherwise we are just removing the named       * menu item (which has been found) so break here.       */      if (*name != NUL)        break;      /* Remove the menu item for the given mode[s].  If the menu item       * is no longer valid in ANY mode, delete it */      menu->modes &= ~modes;      if (modes & MENU_TIP_MODE)        free_menu_string(menu, MENU_INDEX_TIP);      if ((menu->modes & MENU_ALL_MODES) == 0)        free_menu(menup);      else        menup = &menu->next;    } else      menup = &menu->next;  }  if (*name != NUL) {    if (menu == NULL) {      if (!silent)        EMSG2(_(e_nomenu), name);      return FAIL;    }    /* Recalculate modes for menu based on the new updated children */    menu->modes &= ~modes;#if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF)    if ((s_tearoffs) && (menu->children != NULL))     /* there's a tear bar.. */      child = menu->children->next;       /* don't count tearoff bar */    else#endif    child = menu->children;    for (; child != NULL; child = child->next)      menu->modes |= child->modes;    if (modes & MENU_TIP_MODE) {      free_menu_string(menu, MENU_INDEX_TIP);#if defined(FEAT_TOOLBAR) && !defined(FEAT_GUI_W32) /      && (defined(FEAT_BEVAL) || defined(FEAT_GUI_GTK))      /* Need to update the menu tip. */      if (gui.in_use)        gui_mch_menu_set_tip(menu);#endif    }    if ((menu->modes & MENU_ALL_MODES) == 0) {      /* The menu item is no longer valid in ANY mode, so delete it */#if defined(FEAT_GUI_W32) & defined(FEAT_TEAROFF)      if (s_tearoffs && menu->children != NULL)       /* there's a tear bar.. *///.........这里部分代码省略.........

//.........这里部分代码省略.........		    {			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;}

//.........这里部分代码省略.........    }    arg = skipwhite(arg);  } else if (eap->addr_count && eap->line2 != 0) {    pri_tab[0] = eap->line2;    i = 1;  } else    i = 0;  while (i < MENUDEPTH)    pri_tab[i++] = 500;  pri_tab[MENUDEPTH] = -1;              /* mark end of the table */  /*   * Check for "disable" or "enable" argument.   */  if (STRNCMP(arg, "enable", 6) == 0 && vim_iswhite(arg[6])) {    enable = TRUE;    arg = skipwhite(arg + 6);  } else if (STRNCMP(arg, "disable", 7) == 0 && vim_iswhite(arg[7])) {    enable = FALSE;    arg = skipwhite(arg + 7);  }  /*   * If there is no argument, display all menus.   */  if (*arg == NUL) {    show_menus(arg, modes);    return;  }  menu_path = arg;  if (*menu_path == '.') {    EMSG2(_(e_invarg2), menu_path);    goto theend;  }  map_to = menu_translate_tab_and_shift(arg);  /*   * If there is only a menu name, display menus with that name.   */  if (*map_to == NUL && !unmenu && enable == MAYBE) {    show_menus(menu_path, modes);    goto theend;  } else if (*map_to != NUL && (unmenu || enable != MAYBE)) {    EMSG(_(e_trailing));    goto theend;  }  if (enable != MAYBE) {    /*     * Change sensitivity of the menu.     * For the PopUp menu, remove a menu for each mode separately.     * Careful: menu_nable_recurse() changes menu_path.     */    if (STRCMP(menu_path, "*") == 0)            /* meaning: do all menus */      menu_path = (char_u *)"";    if (menu_is_popup(menu_path)) {      for (i = 0; i < MENU_INDEX_TIP; ++i)        if (modes & (1 << i)) {          p = popup_mode_name(menu_path, i);          menu_nable_recurse(root_menu, p, MENU_ALL_MODES, enable);          free(p);        }