Problem: Using old style function declarations.
Solution: Change to new style function declarations. (script by Hirohito
Higashi)
/****************************************************************************/
void
-gui_mch_prepare(argc, argv)
- int *argc;
- char **argv;
+gui_mch_prepare(int *argc, char **argv)
{
PtInit(NULL);
}
* Bring the Vim window to the foreground.
*/
void
-gui_mch_set_foreground()
+gui_mch_set_foreground(void)
{
PhWindowEvent_t event;
};
void
-mch_set_mouse_shape(shape)
- int shape;
+mch_set_mouse_shape(int shape)
{
int id;
}
void
-gui_mch_clear_all()
+gui_mch_clear_all(void)
{
PhRect_t text_rect = {
{ gui.border_width, gui.border_width },
* Don't know how to get the actual name, thus use the provided name.
*/
char_u *
-gui_mch_get_fontname(font, name)
- GuiFont font;
- char_u *name;
+gui_mch_get_fontname(GuiFont font, char_u *name)
{
if (name == NULL)
return NULL;
* Get IM status. When IM is on, return not 0. Else return 0.
*/
int
-im_get_status()
+im_get_status(void)
{
int status = 0;
HIMC hImc;
} signicon_t;
void
-gui_mch_drawsign(row, col, typenr)
- int row;
- int col;
- int typenr;
+gui_mch_drawsign(int row, int col, int typenr)
{
signicon_t *sign;
int x, y, w, h;
}
void *
-gui_mch_register_sign(signfile)
- char_u *signfile;
+gui_mch_register_sign(char_u *signfile)
{
signicon_t sign, *psign;
char_u *ext;
}
void
-gui_mch_destroy_sign(sign)
- void *sign;
+gui_mch_destroy_sign(void *sign)
{
if (sign)
{
}
static void
-make_tooltip(beval, text, pt)
- BalloonEval *beval;
- char *text;
- POINT pt;
+make_tooltip(BalloonEval *beval, char *text, POINT pt)
{
TOOLINFO *pti;
int ToolInfoSize;
}
static void
-delete_tooltip(beval)
- BalloonEval *beval;
+delete_tooltip(BalloonEval *beval)
{
PostMessage(beval->balloon, WM_CLOSE, 0, 0);
}
/*ARGSUSED*/
static VOID CALLBACK
-BevalTimerProc(hwnd, uMsg, idEvent, dwTime)
- HWND hwnd;
- UINT uMsg;
- UINT_PTR idEvent;
- DWORD dwTime;
+BevalTimerProc(
+ HWND hwnd,
+ UINT uMsg,
+ UINT_PTR idEvent,
+ DWORD dwTime)
{
POINT pt;
RECT rect;
/*ARGSUSED*/
void
-gui_mch_disable_beval_area(beval)
- BalloonEval *beval;
+gui_mch_disable_beval_area(BalloonEval *beval)
{
// TRACE0("gui_mch_disable_beval_area {{{");
KillTimer(s_textArea, BevalTimerId);
/*ARGSUSED*/
void
-gui_mch_enable_beval_area(beval)
- BalloonEval *beval;
+gui_mch_enable_beval_area(BalloonEval *beval)
{
// TRACE0("gui_mch_enable_beval_area |||");
if (beval == NULL)
}
void
-gui_mch_post_balloon(beval, mesg)
- BalloonEval *beval;
- char_u *mesg;
+gui_mch_post_balloon(BalloonEval *beval, char_u *mesg)
{
POINT pt;
// TRACE0("gui_mch_post_balloon {{{");
/*ARGSUSED*/
BalloonEval *
-gui_mch_create_beval_area(target, mesg, mesgCB, clientData)
- void *target; /* ignored, always use s_textArea */
- char_u *mesg;
- void (*mesgCB)(BalloonEval *, int);
- void *clientData;
+gui_mch_create_beval_area(
+ void *target, /* ignored, always use s_textArea */
+ char_u *mesg,
+ void (*mesgCB)(BalloonEval *, int),
+ void *clientData)
{
/* partially stolen from gui_beval.c */
BalloonEval *beval;
}
void
-gui_mch_destroy_beval_area(beval)
- BalloonEval *beval;
+gui_mch_destroy_beval_area(BalloonEval *beval)
{
vim_free(beval);
}
* Set the colors to their default values.
*/
void
-gui_mch_def_colors()
+gui_mch_def_colors(void)
{
gui.norm_pixel = GetSysColor(COLOR_WINDOWTEXT);
gui.back_pixel = GetSysColor(COLOR_WINDOW);
*/
/*ARGSUSED*/
char_u *
-gui_mch_get_fontname(font, name)
- GuiFont font;
- char_u *name;
+gui_mch_get_fontname(GuiFont font, char_u *name)
{
if (name == NULL)
return NULL;
* Set the current tab to "nr". First tab is 1.
*/
void
-gui_mch_set_curtab(nr)
- int nr;
+gui_mch_set_curtab(int nr)
{
if (s_tabhwnd == NULL)
return;
* Handler of gui.wide_font (p_guifontwide) changed notification.
*/
void
-gui_mch_wide_font_changed()
+gui_mch_wide_font_changed(void)
{
# ifndef MSWIN16_FASTTEXT
LOGFONT lf;
* Return TRUE if the GUI window is maximized, filling the whole screen.
*/
int
-gui_mch_maximized()
+gui_mch_maximized(void)
{
WINDOWPLACEMENT wp;
* new Rows and Columns. This is like resizing the window.
*/
void
-gui_mch_newfont()
+gui_mch_newfont(void)
{
RECT rect;
*/
static void
-gui_x11_timer_cb(timed_out, interval_id)
- XtPointer timed_out;
- XtIntervalId *interval_id UNUSED;
+gui_x11_timer_cb(
+ XtPointer timed_out,
+ XtIntervalId *interval_id UNUSED)
{
*((int *)timed_out) = TRUE;
}
static void
-gui_x11_visibility_cb(w, dud, event, dum)
- Widget w UNUSED;
- XtPointer dud UNUSED;
- XEvent *event;
- Boolean *dum UNUSED;
+gui_x11_visibility_cb(
+ Widget w UNUSED,
+ XtPointer dud UNUSED,
+ XEvent *event,
+ Boolean *dum UNUSED)
{
if (event->type != VisibilityNotify)
return;
}
static void
-gui_x11_expose_cb(w, dud, event, dum)
- Widget w UNUSED;
- XtPointer dud UNUSED;
- XEvent *event;
- Boolean *dum UNUSED;
+gui_x11_expose_cb(
+ Widget w UNUSED,
+ XtPointer dud UNUSED,
+ XEvent *event,
+ Boolean *dum UNUSED)
{
XExposeEvent *gevent;
int new_x;
#endif
static void
-gui_x11_resize_window_cb(w, dud, event, dum)
- Widget w UNUSED;
- XtPointer dud UNUSED;
- XEvent *event;
- Boolean *dum UNUSED;
+gui_x11_resize_window_cb(
+ Widget w UNUSED,
+ XtPointer dud UNUSED,
+ XEvent *event,
+ Boolean *dum UNUSED)
{
static int lastWidth, lastHeight;
}
static void
-gui_x11_focus_change_cb(w, data, event, dum)
- Widget w UNUSED;
- XtPointer data UNUSED;
- XEvent *event;
- Boolean *dum UNUSED;
+gui_x11_focus_change_cb(
+ Widget w UNUSED,
+ XtPointer data UNUSED,
+ XEvent *event,
+ Boolean *dum UNUSED)
{
gui_focus_change(event->type == FocusIn);
}
static void
-gui_x11_enter_cb(w, data, event, dum)
- Widget w UNUSED;
- XtPointer data UNUSED;
- XEvent *event UNUSED;
- Boolean *dum UNUSED;
+gui_x11_enter_cb(
+ Widget w UNUSED,
+ XtPointer data UNUSED,
+ XEvent *event UNUSED,
+ Boolean *dum UNUSED)
{
gui_focus_change(TRUE);
}
static void
-gui_x11_leave_cb(w, data, event, dum)
- Widget w UNUSED;
- XtPointer data UNUSED;
- XEvent *event UNUSED;
- Boolean *dum UNUSED;
+gui_x11_leave_cb(
+ Widget w UNUSED,
+ XtPointer data UNUSED,
+ XEvent *event UNUSED,
+ Boolean *dum UNUSED)
{
gui_focus_change(FALSE);
}
#endif
void
-gui_x11_key_hit_cb(w, dud, event, dum)
- Widget w UNUSED;
- XtPointer dud UNUSED;
- XEvent *event;
- Boolean *dum UNUSED;
+gui_x11_key_hit_cb(
+ Widget w UNUSED,
+ XtPointer dud UNUSED,
+ XEvent *event,
+ Boolean *dum UNUSED)
{
XKeyPressedEvent *ev_press;
#ifdef FEAT_XIM
}
static void
-gui_x11_mouse_cb(w, dud, event, dum)
- Widget w UNUSED;
- XtPointer dud UNUSED;
- XEvent *event;
- Boolean *dum UNUSED;
+gui_x11_mouse_cb(
+ Widget w UNUSED,
+ XtPointer dud UNUSED,
+ XEvent *event,
+ Boolean *dum UNUSED)
{
static XtIntervalId timer = (XtIntervalId)0;
static int timed_out = TRUE;
#ifdef FEAT_SNIFF
/* ARGSUSED */
static void
-gui_x11_sniff_request_cb(closure, source, id)
- XtPointer closure UNUSED;
- int *source UNUSED;
- XtInputId *id UNUSED;
+gui_x11_sniff_request_cb(
+ XtPointer closure UNUSED,
+ int *source UNUSED,
+ XtInputId *id UNUSED)
{
static char_u bytes[3] = {CSI, (int)KS_EXTRA, (int)KE_SNIFF};
* when vim is started, whether or not the GUI has been started.
*/
void
-gui_mch_prepare(argc, argv)
- int *argc;
- char **argv;
+gui_mch_prepare(int *argc, char **argv)
{
int arg;
int i;
* Return OK or FAIL.
*/
int
-gui_mch_init_check()
+gui_mch_init_check(void)
{
#ifdef FEAT_XIM
XtSetLanguageProc(NULL, NULL, NULL);
static void local_xsmp_handle_requests(XtPointer c, int *s, XtInputId *i);
static void
-local_xsmp_handle_requests(c, s, i)
- XtPointer c UNUSED;
- int *s UNUSED;
- XtInputId *i UNUSED;
+local_xsmp_handle_requests(
+ XtPointer c UNUSED,
+ int *s UNUSED,
+ XtInputId *i UNUSED)
{
if (xsmp_handle_requests() == FAIL)
XtRemoveInput(_xsmp_xtinputid);
* Returns OK for success, FAIL when the GUI can't be started.
*/
int
-gui_mch_init()
+gui_mch_init(void)
{
XtGCMask gc_mask;
XGCValues gc_vals;
* Called when starting the GUI fails after calling gui_mch_init().
*/
void
-gui_mch_uninit()
+gui_mch_uninit(void)
{
gui_x11_destroy_widgets();
XtCloseDisplay(gui.dpy);
* Called when the foreground or background color has been changed.
*/
void
-gui_mch_new_colors()
+gui_mch_new_colors(void)
{
long_u gc_mask;
XGCValues gc_vals;
* Open the GUI window which was created by a call to gui_mch_init().
*/
int
-gui_mch_open()
+gui_mch_open(void)
{
/* Actually open the window */
XtRealizeWidget(vimShell);
* Convert the tooltip fontset name to an XFontSet.
*/
void
-gui_init_tooltip_font()
+gui_init_tooltip_font(void)
{
XrmValue from, to;
#if defined(FEAT_MENU) || defined(PROTO)
/* Convert the menu font/fontset name to an XFontStruct/XFontset */
void
-gui_init_menu_font()
+gui_init_menu_font(void)
{
XrmValue from, to;
#endif
void
-gui_mch_exit(rc)
- int rc UNUSED;
+gui_mch_exit(int rc UNUSED)
{
#if 0
/* Lesstif gives an error message here, and so does Solaris. The man page
* Get the position of the top left corner of the window.
*/
int
-gui_mch_get_winpos(x, y)
- int *x, *y;
+gui_mch_get_winpos(int *x, *y)
{
Dimension xpos, ypos;
* coordinates.
*/
void
-gui_mch_set_winpos(x, y)
- int x, y;
+gui_mch_set_winpos(int x, y)
{
XtVaSetValues(vimShell,
XtNx, x,
}
void
-gui_mch_set_shellsize(width, height, min_width, min_height,
- base_width, base_height, direction)
- int width;
- int height;
- int min_width;
- int min_height;
- int base_width;
- int base_height;
- int direction UNUSED;
+gui_mch_set_shellsize(
+ int width,
+ int height,
+ int min_width,
+ int min_height,
+ int base_width,
+ int base_height,
+ int direction UNUSED)
{
#ifdef FEAT_XIM
height += xim_get_status_area_height(),
* Is there no way in X to find out how wide the borders really are?
*/
void
-gui_mch_get_screen_dimensions(screen_w, screen_h)
- int *screen_w;
- int *screen_h;
+gui_mch_get_screen_dimensions(
+ int *screen_w,
+ int *screen_h)
{
*screen_w = DisplayWidth(gui.dpy, DefaultScreen(gui.dpy)) - 10;
*screen_h = DisplayHeight(gui.dpy, DefaultScreen(gui.dpy)) - p_ghr;
* Return FAIL if the font could not be loaded, OK otherwise.
*/
int
-gui_mch_init_font(font_name, do_fontset)
- char_u *font_name;
- int do_fontset UNUSED;
+gui_mch_init_font(
+ char_u *font_name,
+ int do_fontset UNUSED)
{
XFontStruct *font = NULL;
* Get a font structure for highlighting.
*/
GuiFont
-gui_mch_get_font(name, giveErrorIfMissing)
- char_u *name;
- int giveErrorIfMissing;
+gui_mch_get_font(char_u *name, int giveErrorIfMissing)
{
XFontStruct *font;
* Don't know how to get the actual name, thus use the provided name.
*/
char_u *
-gui_mch_get_fontname(font, name)
- GuiFont font UNUSED;
- char_u *name;
+gui_mch_get_fontname(GuiFont font UNUSED, char_u *name)
{
if (name == NULL)
return NULL;
* Adjust gui.char_height (after 'linespace' was changed).
*/
int
-gui_mch_adjust_charheight()
+gui_mch_adjust_charheight(void)
{
#ifdef FEAT_XFONTSET
if (gui.fontset != NOFONTSET)
* Set the current text font.
*/
void
-gui_mch_set_font(font)
- GuiFont font;
+gui_mch_set_font(GuiFont font)
{
static Font prev_font = (Font)-1;
Font fid = ((XFontStruct *)font)->fid;
* Adjust the ascent, in case it's different.
*/
void
-gui_mch_set_fontset(fontset)
- GuiFontset fontset;
+gui_mch_set_fontset(GuiFontset fontset)
{
current_fontset = (XFontSet)fontset;
gui.char_ascent = fontset_ascent(current_fontset) + p_linespace / 2;
* If a font is not going to be used, free its structure.
*/
void
-gui_mch_free_font(font)
- GuiFont font;
+gui_mch_free_font(GuiFont font)
{
if (font != NOFONT)
XFreeFont(gui.dpy, (XFontStruct *)font);
* If a fontset is not going to be used, free its structure.
*/
void
-gui_mch_free_fontset(fontset)
- GuiFontset fontset;
+gui_mch_free_fontset(GuiFontset fontset)
{
if (fontset != NOFONTSET)
XFreeFontSet(gui.dpy, (XFontSet)fontset);
* Return a reference to the fontset, or NOFONTSET when failing.
*/
GuiFontset
-gui_mch_get_fontset(name, giveErrorIfMissing, fixed_width)
- char_u *name;
- int giveErrorIfMissing;
- int fixed_width;
+gui_mch_get_fontset(
+ char_u *name,
+ int giveErrorIfMissing,
+ int fixed_width)
{
XFontSet fontset;
char **missing, *def_str;
* Check if fontset "fs" is fixed width.
*/
static int
-check_fontset_sanity(fs)
- XFontSet fs;
+check_fontset_sanity(XFontSet fs)
{
XFontStruct **xfs;
char **font_name;
}
static int
-fontset_width(fs)
- XFontSet fs;
+fontset_width(XFontSet fs)
{
- return XmbTextEscapement(fs, "Vim", 3) / 3;
+ return XmbTextEscapement(fs, "Vim", 3) / 3;
}
int
-fontset_height(fs)
- XFontSet fs;
+fontset_height(
+ XFontSet fs)
{
XFontSetExtents *extents;
* characters in all fonts of the fontset.
*/
int
-fontset_height2(fs)
- XFontSet fs;
+fontset_height2(XFontSet fs)
{
XFontSetExtents *extents;
*/
static int
-fontset_ascent(fs)
- XFontSet fs;
+fontset_ascent(XFontSet fs)
{
XFontSetExtents *extents;
* Return INVALCOLOR for error.
*/
guicolor_T
-gui_mch_get_color(reqname)
- char_u *reqname;
+gui_mch_get_color(char_u *reqname)
{
int i;
char_u *name = reqname;
* Return FAIL if not able to find or allocate a color.
*/
static int
-find_closest_color(colormap, colorPtr)
- Colormap colormap;
- XColor *colorPtr;
+find_closest_color(Colormap colormap, XColor *colorPtr)
{
double tmp, distance, closestDistance;
int i, closest, numFound, cmap_size;
* Set the current text foreground color.
*/
void
-gui_mch_set_fg_color(color)
- guicolor_T color;
+gui_mch_set_fg_color(guicolor_T color)
{
if (color != prev_fg_color)
{
* Set the current text background color.
*/
void
-gui_mch_set_bg_color(color)
- guicolor_T color;
+gui_mch_set_bg_color(guicolor_T color)
{
if (color != prev_bg_color)
{
* Set the current text special color.
*/
void
-gui_mch_set_sp_color(color)
- guicolor_T color;
+gui_mch_set_sp_color(guicolor_T color)
{
prev_sp_color = color;
}
* create a mouse pointer that is blank
*/
static Cursor
-gui_x11_create_blank_mouse()
+gui_x11_create_blank_mouse(void)
{
Pixmap blank_pixmap = XCreatePixmap(gui.dpy, gui.wid, 1, 1, 1);
GC gc = XCreateGC(gui.dpy, blank_pixmap, (unsigned long)0, (XGCValues*)0);
* Draw a curled line at the bottom of the character cell.
*/
static void
-draw_curl(row, col, cells)
- int row;
- int col;
- int cells;
+draw_curl(int row, int col, int cells)
{
int i;
int offset;
}
void
-gui_mch_draw_string(row, col, s, len, flags)
- int row;
- int col;
- char_u *s;
- int len;
- int flags;
+gui_mch_draw_string(
+ int row,
+ int col,
+ char_u *s,
+ int len,
+ int flags)
{
int cells = len;
#ifdef FEAT_MBYTE
* Return OK if the key with the termcap name "name" is supported.
*/
int
-gui_mch_haskey(name)
- char_u *name;
+gui_mch_haskey(char_u *name)
{
int i;
* Return the text window-id and display. Only required for X-based GUI's
*/
int
-gui_get_x11_windis(win, dis)
- Window *win;
- Display **dis;
+gui_get_x11_windis(Window *win, Display **dis)
{
*win = XtWindow(vimShell);
*dis = gui.dpy;
}
void
-gui_mch_beep()
+gui_mch_beep(void)
{
XBell(gui.dpy, 0);
}
void
-gui_mch_flash(msec)
- int msec;
+gui_mch_flash(int msec)
{
/* Do a visual beep by reversing the foreground and background colors */
XFillRectangle(gui.dpy, gui.wid, gui.invert_gc, 0, 0,
* Invert a rectangle from row r, column c, for nr rows and nc columns.
*/
void
-gui_mch_invert_rectangle(r, c, nr, nc)
- int r;
- int c;
- int nr;
- int nc;
+gui_mch_invert_rectangle(
+ int r,
+ int c,
+ int nr,
+ int nc)
{
XFillRectangle(gui.dpy, gui.wid, gui.invert_gc,
FILL_X(c), FILL_Y(r), (nc) * gui.char_width, (nr) * gui.char_height);
* Iconify the GUI window.
*/
void
-gui_mch_iconify()
+gui_mch_iconify(void)
{
XIconifyWindow(gui.dpy, XtWindow(vimShell), DefaultScreen(gui.dpy));
}
* Bring the Vim window to the foreground.
*/
void
-gui_mch_set_foreground()
+gui_mch_set_foreground(void)
{
XMapRaised(gui.dpy, XtWindow(vimShell));
}
* Draw a cursor without focus.
*/
void
-gui_mch_draw_hollow_cursor(color)
- guicolor_T color;
+gui_mch_draw_hollow_cursor(guicolor_T color)
{
int w = 1;
* color "color".
*/
void
-gui_mch_draw_part_cursor(w, h, color)
- int w;
- int h;
- guicolor_T color;
+gui_mch_draw_part_cursor(int w, int h, guicolor_T color)
{
gui_mch_set_fg_color(color);
* immediately.
*/
void
-gui_mch_update()
+gui_mch_update(void)
{
XtInputMask mask, desired;
* or FAIL otherwise.
*/
int
-gui_mch_wait_for_chars(wtime)
- long wtime;
+gui_mch_wait_for_chars(long wtime)
{
int focus;
/* Flush any output to the screen */
void
-gui_mch_flush()
+gui_mch_flush(void)
{
XFlush(gui.dpy);
}
* (row2, col2) inclusive.
*/
void
-gui_mch_clear_block(row1, col1, row2, col2)
- int row1;
- int col1;
- int row2;
- int col2;
+gui_mch_clear_block(
+ int row1,
+ int col1,
+ int row2,
+ int col2)
{
int x;
}
void
-gui_mch_clear_all()
+gui_mch_clear_all(void)
{
XClearArea(gui.dpy, gui.wid, 0, 0, 0, 0, False);
}
* text further down within the scroll region.
*/
void
-gui_mch_delete_lines(row, num_lines)
- int row;
- int num_lines;
+gui_mch_delete_lines(int row, int num_lines)
{
if (gui.visibility == VisibilityFullyObscured)
return; /* Can't see the window */
* following text within the scroll region.
*/
void
-gui_mch_insert_lines(row, num_lines)
- int row;
- int num_lines;
+gui_mch_insert_lines(int row, int num_lines)
{
if (gui.visibility == VisibilityFullyObscured)
return; /* Can't see the window */
* Update the region revealed by scrolling up/down.
*/
static void
-gui_x11_check_copy_area()
+gui_x11_check_copy_area(void)
{
XEvent event;
XGraphicsExposeEvent *gevent;
*/
void
-clip_mch_lose_selection(cbd)
- VimClipboard *cbd;
+clip_mch_lose_selection(VimClipboard *cbd)
{
clip_x11_lose_selection(vimShell, cbd);
}
int
-clip_mch_own_selection(cbd)
- VimClipboard *cbd;
+clip_mch_own_selection(VimClipboard *cbd)
{
return clip_x11_own_selection(vimShell, cbd);
}
void
-clip_mch_request_selection(cbd)
- VimClipboard *cbd;
+clip_mch_request_selection(VimClipboard *cbd)
{
- clip_x11_request_selection(vimShell, gui.dpy, cbd);
+ clip_x11_request_selection(vimShell, gui.dpy, cbd);
}
void
-clip_mch_set_selection(cbd)
- VimClipboard *cbd;
+clip_mch_set_selection(
+ VimClipboard *cbd)
{
clip_x11_set_selection(cbd);
}
* Make a menu either grey or not grey.
*/
void
-gui_mch_menu_grey(menu, grey)
- vimmenu_T *menu;
- int grey;
+gui_mch_menu_grey(vimmenu_T *menu, int grey)
{
if (menu->id != (Widget)0)
{
* Make menu item hidden or not hidden
*/
void
-gui_mch_menu_hidden(menu, hidden)
- vimmenu_T *menu;
- int hidden;
+gui_mch_menu_hidden(vimmenu_T *menu, int hidden)
{
if (menu->id != (Widget)0)
{
* This is called after setting all the menus to grey/hidden or not.
*/
void
-gui_mch_draw_menubar()
+gui_mch_draw_menubar(void)
{
/* Nothing to do in X */
}
void
-gui_x11_menu_cb(w, client_data, call_data)
- Widget w UNUSED;
- XtPointer client_data;
- XtPointer call_data UNUSED;
+gui_x11_menu_cb(
+ Widget w UNUSED,
+ XtPointer client_data,
+ XtPointer call_data UNUSED)
{
gui_menu_cb((vimmenu_T *)client_data);
}
* Should put up a requester!
*/
static void
-gui_x11_wm_protocol_handler(w, client_data, event, dum)
- Widget w UNUSED;
- XtPointer client_data UNUSED;
- XEvent *event;
- Boolean *dum UNUSED;
+gui_x11_wm_protocol_handler(
+ Widget w UNUSED,
+ XtPointer client_data UNUSED,
+ XEvent *event,
+ Boolean *dum UNUSED)
{
/*
* Only deal with Client messages.
* Function called when property changed. Check for incoming commands
*/
static void
-gui_x11_send_event_handler(w, client_data, event, dum)
- Widget w UNUSED;
- XtPointer client_data UNUSED;
- XEvent *event;
- Boolean *dum UNUSED;
+gui_x11_send_event_handler(
+ Widget w UNUSED,
+ XtPointer client_data UNUSED,
+ XEvent *event,
+ Boolean *dum UNUSED)
{
XPropertyEvent *e = (XPropertyEvent *) event;
static XtIntervalId blink_timer = (XtIntervalId)0;
void
-gui_mch_set_blinking(waittime, on, off)
- long waittime, on, off;
+gui_mch_set_blinking(long waittime, on, off)
{
blink_waittime = waittime;
blink_ontime = on;
* Stop the cursor blinking. Show the cursor if it wasn't shown.
*/
void
-gui_mch_stop_blink()
+gui_mch_stop_blink(void)
{
if (blink_timer != (XtIntervalId)0)
{
* waiting time and shows the cursor.
*/
void
-gui_mch_start_blink()
+gui_mch_start_blink(void)
{
if (blink_timer != (XtIntervalId)0)
XtRemoveTimeOut(blink_timer);
}
static void
-gui_x11_blink_cb(timed_out, interval_id)
- XtPointer timed_out UNUSED;
- XtIntervalId *interval_id UNUSED;
+gui_x11_blink_cb(
+ XtPointer timed_out UNUSED,
+ XtIntervalId *interval_id UNUSED)
{
if (blink_state == BLINK_ON)
{
* Return the RGB value of a pixel as a long.
*/
long_u
-gui_mch_get_rgb(pixel)
- guicolor_T pixel;
+gui_mch_get_rgb(guicolor_T pixel)
{
XColor xc;
Colormap colormap;
* Add the callback functions.
*/
void
-gui_x11_callbacks(textArea, vimForm)
- Widget textArea;
- Widget vimForm;
+gui_x11_callbacks(Widget textArea, Widget vimForm)
{
XtAddEventHandler(textArea, VisibilityChangeMask, FALSE,
gui_x11_visibility_cb, (XtPointer)0);
}
void
-gui_mch_setmouse(x, y)
- int x;
- int y;
+gui_mch_setmouse(int x, int y)
{
if (gui.wid)
XWarpPointer(gui.dpy, (Window)0, gui.wid, 0, 0, 0, 0, x, y);
#if (defined(FEAT_GUI_MOTIF) && defined(FEAT_MENU)) || defined(PROTO)
XButtonPressedEvent *
-gui_x11_get_last_mouse_event()
+gui_x11_get_last_mouse_event(void)
{
return &last_mouse_event;
}
# define SIGN_WIDTH (gui.char_width * 2)
void
-gui_mch_drawsign(row, col, typenr)
- int row;
- int col;
- int typenr;
+gui_mch_drawsign(int row, int col, int typenr)
{
XImage *sign;
}
void *
-gui_mch_register_sign(signfile)
- char_u *signfile;
+gui_mch_register_sign(char_u *signfile)
{
XpmAttributes attrs;
XImage *sign = NULL;
}
void
-gui_mch_destroy_sign(sign)
- void *sign;
+gui_mch_destroy_sign(void *sign)
{
XDestroyImage((XImage*)sign);
}
* Use the blank mouse pointer or not.
*/
void
-gui_mch_mousehide(hide)
- int hide; /* TRUE = use blank ptr, FALSE = use parent ptr */
+gui_mch_mousehide(
+ int hide) /* TRUE = use blank ptr, FALSE = use parent ptr */
{
if (gui.pointer_hidden != hide)
{
};
void
-mch_set_mouse_shape(shape)
- int shape;
+mch_set_mouse_shape(int shape)
{
int id;
* passing a normal menu item here. Can't explain that, but better avoid it.
*/
void
-gui_mch_menu_set_tip(menu)
- vimmenu_T *menu;
+gui_mch_menu_set_tip(vimmenu_T *menu)
{
if (menu->id != NULL && menu->parent != NULL
&& menu_is_toolbar(menu->parent->name))
*/
static int
-comfcon3(v, c)
- int v;
- int c;
+comfcon3(int v, int c)
{
if (v == 2 && c == 2)
return 3;
*/
static int
-comvow3(v, c)
- int v;
- int c;
+comvow3(int v, int c)
{
switch (v)
{
*/
static int
-comcon3(k, c)
- int k;
- int c;
+comcon3(int k, int c)
{
switch (k)
{
/**********************************************************************/
static int
-kind_table_for_2(c)
- int c;
+kind_table_for_2(int c)
{
static char_u table[] =
{
* °á°ú: ÃʼºÀÌ ¾Æ´Ï¸é 0 (If it is not initial sound, return 0).
*/
static int
-fcon(c)
- int c;
+fcon(int c)
{
static char_u table[] =
{
* °á°ú: Áß¼ºÀÌ ¾Æ´Ï¸é 0 (If it is not medial vowel, return 0).
*/
static int
-vow(c)
- int c;
+vow(int c)
{
static char_u table[] =
{
* °á°ú: ¹ÞħÀÌ ¾Æ´Ï¸é 0 (If not prop, return 0)
*/
static int
-lcon(c)
- int c;
+lcon(int c)
{
static char_u table[] =
{
*/
static int
-comcon2(k, c)
- int k;
- int c;
+comcon2(int k, int c)
{
switch (k)
{
*/
static int
-comvow2(v, c)
- int v;
- int c;
+comvow2(int v, int c)
{
switch (v)
{
}
int
-hangul_input_state_get()
+hangul_input_state_get(void)
{
return hangul_input_state;
}
void
-hangul_input_state_set(state)
- int state;
+hangul_input_state_set(int state)
{
hangul_input_state = state;
hangul_input_clear();
}
int
-im_get_status()
+im_get_status(void)
{
return hangul_input_state_get();
}
void
-hangul_input_state_toggle()
+hangul_input_state_toggle(void)
{
if (hangul_input_state_get())
{
}
static int
-hangul_automata2(buf, c)
- char_u *buf;
- int_u *c;
+hangul_automata2(char_u *buf, int_u *c)
{
int t,t2;
}
static int
-hangul_automata3(buf, c)
- char_u *buf;
- int_u *c;
+hangul_automata3(char_u *buf, int_u *c)
{
int t, t2;
}
void
-hangul_keyboard_set()
+hangul_keyboard_set(void)
{
int keyboard;
char *s;
}
int
-hangul_input_process(s, len)
- char_u *s;
- int len;
+hangul_input_process(char_u *s, int len)
{
int n;
unsigned int c;
}
void
-hangul_input_clear()
+hangul_input_clear(void)
{
sp = 0;
f = F_NULL;
};
static void
-convert_ks_to_3(src, fp, mp, lp)
- const char_u *src;
- int *fp;
- int *mp;
- int *lp;
+convert_ks_to_3(
+ const char_u *src,
+ int *fp,
+ int *mp,
+ int *lp)
{
int h = *src;
int low = *(src + 1);
}
static int
-convert_3_to_ks(fv, mv, lv, des)
- int fv;
- int mv;
- int lv;
- char_u *des;
+convert_3_to_ks(
+ int fv,
+ int mv,
+ int lv,
+ char_u *des)
{
char_u key[3];
register int hi, lo, mi = 0, result, found;
}
char_u *
-hangul_string_convert(buf, p_len)
- char_u *buf;
- int *p_len;
+hangul_string_convert(char_u *buf, int *p_len)
{
char_u *tmpbuf = NULL;
vimconv_T vc;
}
char_u *
-hangul_composing_buffer_get(p_len)
- int *p_len;
+hangul_composing_buffer_get(int *p_len)
{
char_u *tmpbuf = NULL;
* Returns an error message or NULL;
*/
char_u *
-parse_printoptions()
+parse_printoptions(void)
{
return parse_list_options(p_popt, printer_opts, OPT_PRINT_NUM_OPTIONS);
}
* Returns an error message or NULL;
*/
char_u *
-parse_printmbfont()
+parse_printmbfont(void)
{
return parse_list_options(p_pmfn, mbfont_opts, OPT_MBFONT_NUM_OPTIONS);
}
* Only used for the printer at the moment...
*/
static char_u *
-parse_list_options(option_str, table, table_size)
- char_u *option_str;
- option_table_T *table;
- int table_size;
+parse_list_options(
+ char_u *option_str,
+ option_table_T *table,
+ int table_size)
{
char_u *stringp;
char_u *colonp;
* up well on white paper, so reduce their brightness.
*/
static long_u
-darken_rgb(rgb)
- long_u rgb;
+darken_rgb(long_u rgb)
{
return ((rgb >> 17) << 16)
+ (((rgb & 0xff00) >> 9) << 8)
}
static long_u
-prt_get_term_color(colorindex)
- int colorindex;
+prt_get_term_color(int colorindex)
{
/* TODO: Should check for xterm with 88 or 256 colors. */
if (t_colors > 8)
}
static void
-prt_get_attr(hl_id, pattr, modec)
- int hl_id;
- prt_text_attr_T *pattr;
- int modec;
+prt_get_attr(
+ int hl_id,
+ prt_text_attr_T *pattr,
+ int modec)
{
int colorindex;
long_u fg_color;
#endif /* FEAT_SYN_HL */
static void
-prt_set_fg(fg)
- long_u fg;
+prt_set_fg(long_u fg)
{
if (fg != curr_fg)
{
}
static void
-prt_set_bg(bg)
- long_u bg;
+prt_set_bg(long_u bg)
{
if (bg != curr_bg)
{
}
static void
-prt_set_font(bold, italic, underline)
- int bold;
- int italic;
- int underline;
+prt_set_font(int bold, int italic, int underline)
{
if (curr_bold != bold
|| curr_italic != italic
* Print the line number in the left margin.
*/
static void
-prt_line_number(psettings, page_line, lnum)
- prt_settings_T *psettings;
- int page_line;
- linenr_T lnum;
+prt_line_number(
+ prt_settings_T *psettings,
+ int page_line,
+ linenr_T lnum)
{
int i;
char_u tbuf[20];
* Get the currently effective header height.
*/
int
-prt_header_height()
+prt_header_height(void)
{
if (printer_opts[OPT_PRINT_HEADERHEIGHT].present)
return printer_opts[OPT_PRINT_HEADERHEIGHT].number;
* Return TRUE if using a line number for printing.
*/
int
-prt_use_number()
+prt_use_number(void)
{
return (printer_opts[OPT_PRINT_NUMBER].present
&& TOLOWER_ASC(printer_opts[OPT_PRINT_NUMBER].string[0]) == 'y');
* Returns PRT_UNIT_NONE if not recognized.
*/
int
-prt_get_unit(idx)
- int idx;
+prt_get_unit(int idx)
{
int u = PRT_UNIT_NONE;
int i;
* Print the page header.
*/
static void
-prt_header(psettings, pagenum, lnum)
- prt_settings_T *psettings;
- int pagenum;
- linenr_T lnum UNUSED;
+prt_header(
+ prt_settings_T *psettings,
+ int pagenum,
+ linenr_T lnum UNUSED)
{
int width = psettings->chars_per_line;
int page_line;
* Display a print status message.
*/
static void
-prt_message(s)
- char_u *s;
+prt_message(char_u *s)
{
screen_fill((int)Rows - 1, (int)Rows, 0, (int)Columns, ' ', ' ', 0);
screen_puts(s, (int)Rows - 1, 0, hl_attr(HLF_R));
}
void
-ex_hardcopy(eap)
- exarg_T *eap;
+ex_hardcopy(exarg_T *eap)
{
linenr_T lnum;
int collated_copies, uncollated_copies;
* Return the next column to print, or zero if the line is finished.
*/
static colnr_T
-hardcopy_line(psettings, page_line, ppos)
- prt_settings_T *psettings;
- int page_line;
- prt_pos_T *ppos;
+hardcopy_line(
+ prt_settings_T *psettings,
+ int page_line,
+ prt_pos_T *ppos)
{
colnr_T col;
char_u *line;
# endif
static void
-prt_write_file_raw_len(buffer, bytes)
- char_u *buffer;
- int bytes;
+prt_write_file_raw_len(char_u *buffer, int bytes)
{
if (!prt_file_error
&& fwrite(buffer, sizeof(char_u), bytes, prt_ps_fd)
}
static void
-prt_write_file(buffer)
- char_u *buffer;
+prt_write_file(char_u *buffer)
{
prt_write_file_len(buffer, (int)STRLEN(buffer));
}
static void
-prt_write_file_len(buffer, bytes)
- char_u *buffer;
- int bytes;
+prt_write_file_len(char_u *buffer, int bytes)
{
#ifdef EBCDIC
ebcdic2ascii(buffer, bytes);
* Write a string.
*/
static void
-prt_write_string(s)
- char *s;
+prt_write_string(char *s)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer), "%s", s);
prt_write_file(prt_line_buffer);
* Write an int and a space.
*/
static void
-prt_write_int(i)
- int i;
+prt_write_int(int i)
{
sprintf((char *)prt_line_buffer, "%d ", i);
prt_write_file(prt_line_buffer);
* Write a boolean and a space.
*/
static void
-prt_write_boolean(b)
- int b;
+prt_write_boolean(int b)
{
sprintf((char *)prt_line_buffer, "%s ", (b ? "T" : "F"));
prt_write_file(prt_line_buffer);
* Write PostScript to re-encode and define the font.
*/
static void
-prt_def_font(new_name, encoding, height, font)
- char *new_name;
- char *encoding;
- int height;
- char *font;
+prt_def_font(
+ char *new_name,
+ char *encoding,
+ int height,
+ char *font)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/_%s /VIM-%s /%s ref\n", new_name, encoding, font);
* Write a line to define the CID font.
*/
static void
-prt_def_cidfont(new_name, height, cidfont)
- char *new_name;
- int height;
- char *cidfont;
+prt_def_cidfont(char *new_name, int height, char *cidfont)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/_%s /%s[/%s] vim_composefont\n", new_name, prt_cmap, cidfont);
* Write a line to define a duplicate of a CID font
*/
static void
-prt_dup_cidfont(original_name, new_name)
- char *original_name;
- char *new_name;
+prt_dup_cidfont(char *original_name, char *new_name)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/%s %s d\n", new_name, original_name);
* is also rounded based on the precision + 1'th fractional digit.
*/
static void
-prt_real_bits(real, precision, pinteger, pfraction)
- double real;
- int precision;
- int *pinteger;
- int *pfraction;
+prt_real_bits(
+ double real,
+ int precision,
+ int *pinteger,
+ int *pfraction)
{
int i;
int integer;
* what decimal point character to use, but PS always requires a '.'.
*/
static void
-prt_write_real(val, prec)
- double val;
- int prec;
+prt_write_real(double val, int prec)
{
int integer;
int fraction;
* Write a line to define a numeric variable.
*/
static void
-prt_def_var(name, value, prec)
- char *name;
- double value;
- int prec;
+prt_def_var(char *name, double value, int prec)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"/%s ", name);
#define PRT_PS_FONT_TO_USER(scale, size) ((size) * ((scale)/1000.0))
static void
-prt_flush_buffer()
+prt_flush_buffer(void)
{
if (prt_ps_buffer.ga_len > 0)
{
static void
-prt_resource_name(filename, cookie)
- char_u *filename;
- void *cookie;
+prt_resource_name(char_u *filename, void *cookie)
{
char_u *resource_filename = cookie;
}
static int
-prt_find_resource(name, resource)
- char *name;
- struct prt_ps_resource_S *resource;
+prt_find_resource(char *name, struct prt_ps_resource_S *resource)
{
char_u *buffer;
int retval;
static struct prt_resfile_buffer_S prt_resfile;
static int
-prt_resfile_next_line()
+prt_resfile_next_line(void)
{
int idx;
}
static int
-prt_resfile_strncmp(offset, string, len)
- int offset;
- char *string;
- int len;
+prt_resfile_strncmp(int offset, char *string, int len)
{
/* Force not equal if string is longer than remainder of line */
if (len > (prt_resfile.line_end - (prt_resfile.line_start + offset)))
}
static int
-prt_resfile_skip_nonws(offset)
- int offset;
+prt_resfile_skip_nonws(int offset)
{
int idx;
}
static int
-prt_resfile_skip_ws(offset)
- int offset;
+prt_resfile_skip_ws(int offset)
{
int idx;
/* prt_next_dsc() - returns detail on next DSC comment line found. Returns true
* if a DSC comment is found, else false */
static int
-prt_next_dsc(p_dsc_line)
- struct prt_dsc_line_S *p_dsc_line;
+prt_next_dsc(struct prt_dsc_line_S *p_dsc_line)
{
int comment;
int offset;
* PS resource file so the file details can be added to the DSC header comments.
*/
static int
-prt_open_resource(resource)
- struct prt_ps_resource_S *resource;
+prt_open_resource(struct prt_ps_resource_S *resource)
{
int offset;
int seen_all;
}
static int
-prt_check_resource(resource, version)
- struct prt_ps_resource_S *resource;
- char_u *version;
+prt_check_resource(struct prt_ps_resource_S *resource, char_u *version)
{
/* Version number m.n should match, the revision number does not matter */
if (STRNCMP(resource->version, version, STRLEN(version)))
}
static void
-prt_dsc_start()
+prt_dsc_start(void)
{
prt_write_string("%!PS-Adobe-3.0\n");
}
static void
-prt_dsc_noarg(comment)
- char *comment;
+prt_dsc_noarg(char *comment)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s\n", comment);
}
static void
-prt_dsc_textline(comment, text)
- char *comment;
- char *text;
+prt_dsc_textline(char *comment, char *text)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s: %s\n", comment, text);
}
static void
-prt_dsc_text(comment, text)
- char *comment;
- char *text;
+prt_dsc_text(char *comment, char *text)
{
/* TODO - should scan 'text' for any chars needing escaping! */
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
#define prt_dsc_atend(c) prt_dsc_text((c), "atend")
static void
-prt_dsc_ints(comment, count, ints)
- char *comment;
- int count;
- int *ints;
+prt_dsc_ints(char *comment, int count, int *ints)
{
int i;
}
static void
-prt_dsc_resources(comment, type, string)
- char *comment; /* if NULL add to previous */
- char *type;
- char *string;
+prt_dsc_resources(
+ char *comment, /* if NULL add to previous */
+ char *type,
+ char *string)
{
if (comment != NULL)
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
}
static void
-prt_dsc_font_resource(resource, ps_font)
- char *resource;
- struct prt_ps_font_S *ps_font;
+prt_dsc_font_resource(char *resource, struct prt_ps_font_S *ps_font)
{
int i;
}
static void
-prt_dsc_requirements(duplex, tumble, collate, color, num_copies)
- int duplex;
- int tumble;
- int collate;
- int color;
- int num_copies;
+prt_dsc_requirements(
+ int duplex,
+ int tumble,
+ int collate,
+ int color,
+ int num_copies)
{
/* Only output the comment if we need to.
* Note: tumble is ignored if we are not duplexing
}
static void
-prt_dsc_docmedia(paper_name, width, height, weight, colour, type)
- char *paper_name;
- double width;
- double height;
- double weight;
- char *colour;
- char *type;
+prt_dsc_docmedia(
+ char *paper_name,
+ double width,
+ double height,
+ double weight,
+ char *colour,
+ char *type)
{
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%DocumentMedia: %s ", paper_name);
}
void
-mch_print_cleanup()
+mch_print_cleanup(void)
{
#ifdef FEAT_MBYTE
if (prt_out_mbyte)
}
static float
-to_device_units(idx, physsize, def_number)
- int idx;
- double physsize;
- int def_number;
+to_device_units(int idx, double physsize, int def_number)
{
float ret;
int u;
* Calculate margins for given width and height from printoptions settings.
*/
static void
-prt_page_margins(width, height, left, right, top, bottom)
- double width;
- double height;
- double *left;
- double *right;
- double *top;
- double *bottom;
+prt_page_margins(
+ double width,
+ double height,
+ double *left,
+ double *right,
+ double *top,
+ double *bottom)
{
*left = to_device_units(OPT_PRINT_LEFT, width, 10);
*right = width - to_device_units(OPT_PRINT_RIGHT, width, 5);
}
static void
-prt_font_metrics(font_scale)
- int font_scale;
+prt_font_metrics(int font_scale)
{
prt_line_height = (float)font_scale;
prt_char_width = (float)PRT_PS_FONT_TO_USER(font_scale, prt_ps_font->wx);
static int
-prt_get_cpl()
+prt_get_cpl(void)
{
if (prt_use_number())
{
#ifdef FEAT_MBYTE
static int
-prt_build_cid_fontname(font, name, name_len)
- int font;
- char_u *name;
- int name_len;
+prt_build_cid_fontname(int font, char_u *name, int name_len)
{
char *fontname;
* Get number of lines of text that fit on a page (excluding the header).
*/
static int
-prt_get_lpp()
+prt_get_lpp(void)
{
int lpp;
#ifdef FEAT_MBYTE
static int
-prt_match_encoding(p_encoding, p_cmap, pp_mbenc)
- char *p_encoding;
- struct prt_ps_mbfont_S *p_cmap;
- struct prt_ps_encoding_S **pp_mbenc;
+prt_match_encoding(
+ char *p_encoding,
+ struct prt_ps_mbfont_S *p_cmap,
+ struct prt_ps_encoding_S **pp_mbenc)
{
int mbenc;
int enc_len;
}
static int
-prt_match_charset(p_charset, p_cmap, pp_mbchar)
- char *p_charset;
- struct prt_ps_mbfont_S *p_cmap;
- struct prt_ps_charset_S **pp_mbchar;
+prt_match_charset(
+ char *p_charset,
+ struct prt_ps_mbfont_S *p_cmap,
+ struct prt_ps_charset_S **pp_mbchar)
{
int mbchar;
int char_len;
#endif
int
-mch_print_init(psettings, jobname, forceit)
- prt_settings_T *psettings;
- char_u *jobname;
- int forceit UNUSED;
+mch_print_init(
+ prt_settings_T *psettings,
+ char_u *jobname,
+ int forceit UNUSED)
{
int i;
char *paper_name;
}
static int
-prt_add_resource(resource)
- struct prt_ps_resource_S *resource;
+prt_add_resource(struct prt_ps_resource_S *resource)
{
FILE* fd_resource;
char_u resource_buffer[512];
}
int
-mch_print_begin(psettings)
- prt_settings_T *psettings;
+mch_print_begin(prt_settings_T *psettings)
{
time_t now;
int bbox[4];
}
void
-mch_print_end(psettings)
- prt_settings_T *psettings;
+mch_print_end(prt_settings_T *psettings)
{
prt_dsc_noarg("Trailer");
}
int
-mch_print_end_page()
+mch_print_end_page(void)
{
prt_flush_buffer();
}
int
-mch_print_begin_page(str)
- char_u *str UNUSED;
+mch_print_begin_page(char_u *str UNUSED)
{
int page_num[2];
}
int
-mch_print_blank_page()
+mch_print_blank_page(void)
{
return (mch_print_begin_page(NULL) ? (mch_print_end_page()) : FALSE);
}
static float prt_pos_y = 0;
void
-mch_print_start_line(margin, page_line)
- int margin;
- int page_line;
+mch_print_start_line(int margin, int page_line)
{
prt_pos_x = prt_left_margin;
if (margin)
}
int
-mch_print_text_out(p, len)
- char_u *p;
- int len UNUSED;
+mch_print_text_out(char_u *p, int len UNUSED)
{
int need_break;
char_u ch;
}
void
-mch_print_set_font(iBold, iItalic, iUnderline)
- int iBold;
- int iItalic;
- int iUnderline;
+mch_print_set_font(int iBold, int iItalic, int iUnderline)
{
int font = 0;
}
void
-mch_print_set_bg(bgcol)
- long_u bgcol;
+mch_print_set_bg(long_u bgcol)
{
prt_bgcol = (int)bgcol;
prt_attribute_change = TRUE;
}
void
-mch_print_set_fg(fgcol)
- long_u fgcol;
+mch_print_set_fg(long_u fgcol)
{
if (fgcol != (long_u)prt_fgcol)
{
* Returns NULL when out of memory.
*/
hashtab_T *
-hash_create()
+hash_create(void)
{
hashtab_T *ht;
* Initialize an empty hash table.
*/
void
-hash_init(ht)
- hashtab_T *ht;
+hash_init(hashtab_T *ht)
{
/* This zeroes all "ht_" entries and all the "hi_key" in "ht_smallarray". */
vim_memset(ht, 0, sizeof(hashtab_T));
* If "ht" is not freed then you should call hash_init() next!
*/
void
-hash_clear(ht)
- hashtab_T *ht;
+hash_clear(hashtab_T *ht)
{
if (ht->ht_array != ht->ht_smallarray)
vim_free(ht->ht_array);
* memory to the location of the key (it's always positive).
*/
void
-hash_clear_all(ht, off)
- hashtab_T *ht;
- int off;
+hash_clear_all(hashtab_T *ht, int off)
{
long todo;
hashitem_T *hi;
* (adding, setting or removing an item)!
*/
hashitem_T *
-hash_find(ht, key)
- hashtab_T *ht;
- char_u *key;
+hash_find(hashtab_T *ht, char_u *key)
{
return hash_lookup(ht, key, hash_hash(key));
}
* Like hash_find(), but caller computes "hash".
*/
hashitem_T *
-hash_lookup(ht, key, hash)
- hashtab_T *ht;
- char_u *key;
- hash_T hash;
+hash_lookup(hashtab_T *ht, char_u *key, hash_T hash)
{
hash_T perturb;
hashitem_T *freeitem;
* Called when exiting.
*/
void
-hash_debug_results()
+hash_debug_results(void)
{
#ifdef HT_DEBUG
fprintf(stderr, "\r\n\r\n\r\n\r\n");
* Returns FAIL when out of memory or the key is already present.
*/
int
-hash_add(ht, key)
- hashtab_T *ht;
- char_u *key;
+hash_add(hashtab_T *ht, char_u *key)
{
hash_T hash = hash_hash(key);
hashitem_T *hi;
* Returns OK or FAIL (out of memory).
*/
int
-hash_add_item(ht, hi, key, hash)
- hashtab_T *ht;
- hashitem_T *hi;
- char_u *key;
- hash_T hash;
+hash_add_item(
+ hashtab_T *ht,
+ hashitem_T *hi,
+ char_u *key,
+ hash_T hash)
{
/* If resizing failed before and it fails again we can't add an item. */
if (ht->ht_error && hash_may_resize(ht, 0) == FAIL)
* "hi" is invalid after this!
*/
void
-hash_set(hi, key)
- hashitem_T *hi;
- char_u *key;
+hash_set(hashitem_T *hi, char_u *key)
{
hi->hi_key = key;
}
* The caller must take care of freeing the item itself.
*/
void
-hash_remove(ht, hi)
- hashtab_T *ht;
- hashitem_T *hi;
+hash_remove(hashtab_T *ht, hashitem_T *hi)
{
--ht->ht_used;
hi->hi_key = HI_KEY_REMOVED;
* Must call hash_unlock() later.
*/
void
-hash_lock(ht)
- hashtab_T *ht;
+hash_lock(hashtab_T *ht)
{
++ht->ht_locked;
}
* Must call hash_unlock() later.
*/
void
-hash_lock_size(ht, size)
- hashtab_T *ht;
- int size;
+hash_lock_size(hashtab_T *ht, int size)
{
(void)hash_may_resize(ht, size);
++ht->ht_locked;
* This must balance a call to hash_lock().
*/
void
-hash_unlock(ht)
- hashtab_T *ht;
+hash_unlock(hashtab_T *ht)
{
--ht->ht_locked;
(void)hash_may_resize(ht, 0);
* Returns OK or FAIL (out of memory).
*/
static int
-hash_may_resize(ht, minitems)
- hashtab_T *ht;
- int minitems; /* minimal number of items */
+hash_may_resize(
+ hashtab_T *ht,
+ int minitems) /* minimal number of items */
{
hashitem_T temparray[HT_INIT_SIZE];
hashitem_T *oldarray, *newarray;
* lower the percentage the better.
*/
hash_T
-hash_hash(key)
- char_u *key;
+hash_hash(char_u *key)
{
hash_T hash;
char_u *p;
};
static void
-cs_usage_msg(x)
- csid_e x;
+cs_usage_msg(csid_e x)
{
(void)EMSG2(_("E560: Usage: cs[cope] %s"), cs_cmds[(int)x].usage);
}
* expansion.
*/
char_u *
-get_cscope_name(xp, idx)
- expand_T *xp UNUSED;
- int idx;
+get_cscope_name(expand_T *xp UNUSED, int idx)
{
int current_idx;
int i;
* Handle command line completion for :cscope command.
*/
void
-set_context_in_cscope_cmd(xp, arg, cmdidx)
- expand_T *xp;
- char_u *arg;
- cmdidx_T cmdidx;
+set_context_in_cscope_cmd(
+ expand_T *xp,
+ char_u *arg,
+ cmdidx_T cmdidx)
{
char_u *p;
* command function.
*/
static void
-do_cscope_general(eap, make_split)
- exarg_T *eap;
- int make_split; /* whether to split window */
+do_cscope_general(
+ exarg_T *eap,
+ int make_split) /* whether to split window */
{
cscmd_T *cmdp;
* PUBLIC: do_cscope
*/
void
-do_cscope(eap)
- exarg_T *eap;
+do_cscope(exarg_T *eap)
{
do_cscope_general(eap, FALSE);
}
* same as do_cscope, but splits window, too.
*/
void
-do_scscope(eap)
- exarg_T *eap;
+do_scscope(exarg_T *eap)
{
do_cscope_general(eap, TRUE);
}
*
*/
void
-do_cstag(eap)
- exarg_T *eap;
+do_cstag(exarg_T *eap)
{
int ret = FALSE;
* returns TRUE if eof, FALSE otherwise
*/
int
-cs_fgets(buf, size)
- char_u *buf;
- int size;
+cs_fgets(char_u *buf, int size)
{
char *p;
* called only from do_tag(), when popping the tag stack
*/
void
-cs_free_tags()
+cs_free_tags(void)
{
cs_manage_matches(NULL, NULL, -1, Free);
}
* called from do_tag()
*/
void
-cs_print_tags()
+cs_print_tags(void)
{
cs_manage_matches(NULL, NULL, -1, Print);
}
*/
#if defined(FEAT_EVAL) || defined(PROTO)
int
-cs_connection(num, dbpath, ppath)
- int num;
- char_u *dbpath;
- char_u *ppath;
+cs_connection(int num, char_u *dbpath, char_u *ppath)
{
int i;
* MAXPATHL 256
*/
static int
-cs_add(eap)
- exarg_T *eap UNUSED;
+cs_add(exarg_T *eap UNUSED)
{
char *fname, *ppath, *flags = NULL;
}
static void
-cs_stat_emsg(fname)
- char *fname;
+cs_stat_emsg(char *fname)
{
char *stat_emsg = _("E563: stat(%s) error: %d");
char *buf = (char *)alloc((unsigned)strlen(stat_emsg) + MAXPATHL + 10);
* routine uses a number of goto statements.
*/
static int
-cs_add_common(arg1, arg2, flags)
- char *arg1; /* filename - may contain environment variables */
- char *arg2; /* prepend path - may contain environment variables */
- char *flags;
+cs_add_common(
+ char *arg1, /* filename - may contain environment variables */
+ char *arg2, /* prepend path - may contain environment variables */
+ char *flags)
{
struct stat statbuf;
int ret;
static int
-cs_check_for_connections()
+cs_check_for_connections(void)
{
return (cs_cnt_connections() > 0);
} /* cs_check_for_connections */
static int
-cs_check_for_tags()
+cs_check_for_tags(void)
{
return (p_tags[0] != NUL && curbuf->b_p_tags != NULL);
} /* cs_check_for_tags */
* count the number of cscope connections
*/
static int
-cs_cnt_connections()
+cs_cnt_connections(void)
{
short i;
short cnt = 0;
} /* cs_cnt_connections */
static void
-cs_reading_emsg(idx)
- int idx; /* connection index */
+cs_reading_emsg(
+ int idx) /* connection index */
{
EMSGN(_("E262: error reading cscope connection %ld"), idx);
}
* count the number of matches for a given cscope connection.
*/
static int
-cs_cnt_matches(idx)
- int idx;
+cs_cnt_matches(int idx)
{
char *stok;
char *buf;
* Creates the actual cscope command query from what the user entered.
*/
static char *
-cs_create_cmd(csoption, pattern)
- char *csoption;
- char *pattern;
+cs_create_cmd(char *csoption, char *pattern)
{
char *cmd;
short search;
* the BSD license notice?
*/
static int
-cs_create_connection(i)
- int i;
+cs_create_connection(int i)
{
#ifdef UNIX
int to_cs[2], from_cs[2];
* returns TRUE if we jump to a tag or abort, FALSE if not.
*/
static int
-cs_find(eap)
- exarg_T *eap;
+cs_find(exarg_T *eap)
{
char *opt, *pat;
int i;
* common code for cscope find, shared by cs_find() and do_cstag()
*/
static int
-cs_find_common(opt, pat, forceit, verbose, use_ll, cmdline)
- char *opt;
- char *pat;
- int forceit;
- int verbose;
- int use_ll UNUSED;
- char_u *cmdline UNUSED;
+cs_find_common(
+ char *opt,
+ char *pat,
+ int forceit,
+ int verbose,
+ int use_ll UNUSED,
+ char_u *cmdline UNUSED)
{
int i;
char *cmd;
* print help
*/
static int
-cs_help(eap)
- exarg_T *eap UNUSED;
+cs_help(exarg_T *eap UNUSED)
{
cscmd_T *cmdp = cs_cmds;
static void
-clear_csinfo(i)
- int i;
+clear_csinfo(int i)
{
csinfo[i].fname = NULL;
csinfo[i].ppath = NULL;
static char *GetWin32Error(void);
static char *
-GetWin32Error()
+GetWin32Error(void)
{
char *msg = NULL;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
* insert a new cscope database filename into the filelist
*/
static int
-cs_insert_filelist(fname, ppath, flags, sb)
- char *fname;
- char *ppath;
- char *flags;
- struct stat *sb UNUSED;
+cs_insert_filelist(
+ char *fname,
+ char *ppath,
+ char *flags,
+ struct stat *sb UNUSED)
{
short i, j;
#ifndef UNIX
* find cscope command in command table
*/
static cscmd_T *
-cs_lookup_cmd(eap)
- exarg_T *eap;
+cs_lookup_cmd(exarg_T *eap)
{
cscmd_T *cmdp;
char *stok;
* nuke em
*/
static int
-cs_kill(eap)
- exarg_T *eap UNUSED;
+cs_kill(exarg_T *eap UNUSED)
{
char *stok;
short i;
* Actually kills a specific cscope connection.
*/
static void
-cs_kill_execute(i, cname)
- int i; /* cscope table index */
- char *cname; /* cscope database name */
+cs_kill_execute(
+ int i, /* cscope table index */
+ char *cname) /* cscope database name */
{
if (p_csverbose)
{
* characters to comply with ctags formatting.
*/
static char *
-cs_make_vim_style_matches(fname, slno, search, tagstr)
- char *fname;
- char *slno;
- char *search;
- char *tagstr;
+cs_make_vim_style_matches(
+ char *fname,
+ char *slno,
+ char *search,
+ char *tagstr)
{
/* vim style is ctags:
*
* Print: prints the tags
*/
static char *
-cs_manage_matches(matches, contexts, totmatches, cmd)
- char **matches;
- char **contexts;
- int totmatches;
- mcmd_e cmd;
+cs_manage_matches(
+ char **matches,
+ char **contexts,
+ int totmatches,
+ mcmd_e cmd)
{
static char **mp = NULL;
static char **cp = NULL;
* parse cscope output
*/
static char *
-cs_parse_results(cnumber, buf, bufsize, context, linenumber, search)
- int cnumber;
- char *buf;
- int bufsize;
- char **context;
- char **linenumber;
- char **search;
+cs_parse_results(
+ int cnumber,
+ char *buf,
+ int bufsize,
+ char **context,
+ char **linenumber,
+ char **search)
{
int ch;
char *p;
* write cscope find results to file
*/
static void
-cs_file_results(f, nummatches_a)
- FILE *f;
- int *nummatches_a;
+cs_file_results(FILE *f, int *nummatches_a)
{
int i, j;
char *buf;
* When there are no matches sets "*matches_p" to NULL.
*/
static void
-cs_fill_results(tagstr, totmatches, nummatches_a, matches_p, cntxts_p, matched)
- char *tagstr;
- int totmatches;
- int *nummatches_a;
- char ***matches_p;
- char ***cntxts_p;
- int *matched;
+cs_fill_results(
+ char *tagstr,
+ int totmatches,
+ int *nummatches_a,
+ char ***matches_p,
+ char ***cntxts_p,
+ int *matched)
{
int i, j;
char *buf;
/* get the requested path components */
static char *
-cs_pathcomponents(path)
- char *path;
+cs_pathcomponents(char *path)
{
int i;
char *s;
* called from cs_manage_matches()
*/
static void
-cs_print_tags_priv(matches, cntxts, num_matches)
- char **matches;
- char **cntxts;
- int num_matches;
+cs_print_tags_priv(char **matches, char **cntxts, int num_matches)
{
char *buf = NULL;
char *t_buf;
* read a cscope prompt (basically, skip over the ">> ")
*/
static int
-cs_read_prompt(i)
- int i;
+cs_read_prompt(int i)
{
int ch;
char *buf = NULL; /* buffer for possible error message from cscope */
* or not to free the filename. Called by cs_kill and cs_reset.
*/
static void
-cs_release_csp(i, freefnpp)
- int i;
- int freefnpp;
+cs_release_csp(int i, int freefnpp)
{
/*
* Trying to exit normally (not sure whether it is fit to UNIX cscope
* calls cs_kill on all cscope connections then reinits
*/
static int
-cs_reset(eap)
- exarg_T *eap UNUSED;
+cs_reset(exarg_T *eap UNUSED)
{
char **dblist = NULL, **pplist = NULL, **fllist = NULL;
int i;
* Contrast this with my development system (Digital Unix), which does.
*/
static char *
-cs_resolve_file(i, name)
- int i;
- char *name;
+cs_resolve_file(int i, char *name)
{
char *fullname;
int len;
* show all cscope connections
*/
static int
-cs_show(eap)
- exarg_T *eap UNUSED;
+cs_show(exarg_T *eap UNUSED)
{
short i;
if (cs_cnt_connections() == 0)
* Only called when VIM exits to quit any cscope sessions.
*/
void
-cs_end()
+cs_end(void)
{
int i;
}
static void
-make_modules()
+make_modules(void)
{
int i;
Scheme_Env *mod = NULL;
#define NIL(type) ((type)0)
static int
-sfvimwrite(f, buf, n, disc)
- Sfio_t *f; /* stream involved */
- char *buf; /* buffer to read from */
- int n; /* number of bytes to write */
- Sfdisc_t *disc; /* discipline */
+sfvimwrite(
+ Sfio_t *f, /* stream involved */
+ char *buf, /* buffer to read from */
+ int n, /* number of bytes to write */
+ Sfdisc_t *disc) /* discipline */
{
char_u *str;
* Create Vim discipline
*/
Sfdisc_t *
-sfdcnewvim()
+sfdcnewvim(void)
{
Sfdisc_t *disc;
#endif
void
-python_end()
+python_end(void)
{
static int recurse = 0;
#if (defined(DYNAMIC_PYTHON) && defined(FEAT_PYTHON3)) || defined(PROTO)
int
-python_loaded()
+python_loaded(void)
{
return (hinstPython != 0);
}
static void get_py3_exceptions(void);
static void
-get_py3_exceptions()
+get_py3_exceptions(void)
{
PyObject *exmod = PyImport_ImportModule("builtins");
PyObject *exdict = PyModule_GetDict(exmod);
*/
void
-python3_end()
+python3_end(void)
{
static int recurse = 0;
#if (defined(DYNAMIC_PYTHON3) && defined(DYNAMIC_PYTHON) && defined(FEAT_PYTHON) && defined(UNIX)) || defined(PROTO)
int
-python3_loaded()
+python3_loaded(void)
{
return (hinstPy3 != 0);
}
* Free ruby.dll
*/
static void
-end_dynamic_ruby()
+end_dynamic_ruby(void)
{
if (hinstRuby)
{
* else FALSE.
*/
int
-ruby_enabled(verbose)
- int verbose;
+ruby_enabled(int verbose)
{
return ruby_runtime_link_init((char *)p_rubydll, verbose) == OK;
}
#endif /* defined(DYNAMIC_RUBY) || defined(PROTO) */
void
-ruby_end()
+ruby_end(void)
{
#ifdef DYNAMIC_RUBY
end_dynamic_ruby();
return buf;
}
-static VALUE buffer_s_current()
+static VALUE buffer_s_current(void)
{
return buffer_new(curbuf);
}
-static VALUE buffer_s_count()
+static VALUE buffer_s_count(void)
{
buf_T *b;
int n = 0;
return win;
}
-static VALUE window_s_current()
+static VALUE window_s_current(void)
{
return window_new(curwin);
}
* Added line manipulation functions
* SegPhault - 03/07/05
*/
-static VALUE line_s_current()
+static VALUE line_s_current(void)
{
return get_buffer_line(curbuf, curwin->w_cursor.lnum);
}
return set_buffer_line(curbuf, curwin->w_cursor.lnum, str);
}
-static VALUE current_line_number()
+static VALUE current_line_number(void)
{
return INT2FIX((int)curwin->w_cursor.lnum);
}
-static VALUE window_s_count()
+static VALUE window_s_count(void)
{
#ifdef FEAT_WINDOWS
win_T *w;
* to process the waiting sniff requests
*/
void
-ProcessSniffRequests()
+ProcessSniffRequests(void)
{
static char buf[MAX_REQUEST_LEN];
int len;
}
static struct sn_cmd *
-find_sniff_cmd(cmd)
- char *cmd;
+find_sniff_cmd(char *cmd)
{
struct sn_cmd *sniff_cmd = NULL;
int i;
}
static int
-add_sniff_cmd(cmd, def, msg)
- char *cmd;
- char *def;
- char *msg;
+add_sniff_cmd(char *cmd, char *def, char *msg)
{
int rc = 0;
if (def != NULL && def[0] != NUL && find_sniff_cmd(cmd) == NULL)
* Handle ":sniff" command
*/
void
-ex_sniff(eap)
- exarg_T *eap;
+ex_sniff(exarg_T *eap)
{
char_u *arg = eap->arg;
char_u *symbol = NULL;
static void
-sniff_connect()
+sniff_connect(void)
{
if (sniff_connected)
return;
}
void
-sniff_disconnect(immediately)
- int immediately;
+sniff_disconnect(int immediately)
{
if (!sniff_connected)
return;
* Connect to Sniff: returns 1 on error
*/
static int
-ConnectToSniffEmacs()
+ConnectToSniffEmacs(void)
{
#ifdef WIN32 /* Windows Version of the Code */
HANDLE ToSniffEmacs[2], FromSniffEmacs[2];
* Handle one request from SNiFF+
*/
static void
-HandleSniffRequest(buffer)
- char *buffer;
+HandleSniffRequest(char *buffer)
{
char VICommand[MAX_REQUEST_LEN];
char command;
* <0 on error
*/
static int
-get_request(fd, buf, maxlen)
- int fd;
- char *buf;
- int maxlen;
+get_request(int fd, char *buf, int maxlen)
{
static char inbuf[1024];
static int pos = 0, bytes = 0;
static void
-SendRequest(command, symbol)
- struct sn_cmd *command;
- char *symbol;
+SendRequest(struct sn_cmd *command, char *symbol)
{
int cmd_type = command->cmd_type;
static char cmdstr[MAX_REQUEST_LEN];
static void
-WriteToSniff(str)
- char *str;
+WriteToSniff(char *str)
{
int bytes;
#ifdef WIN32
/*-------- vim helping functions --------------------------------*/
static void
-vi_msg(str)
- char *str;
+vi_msg(char *str)
{
if (str != NULL && *str != NUL)
MSG((char_u *)str);
}
static void
-vi_error_msg(str)
- char *str;
+vi_error_msg(char *str)
{
if (str != NULL && *str != NUL)
EMSG((char_u *)str);
}
static void
-vi_open_file(fname)
- char *fname;
+vi_open_file(char *fname)
{
++no_wait_return;
do_ecmd(0, (char_u *)fname, NULL, NULL, ECMD_ONE, ECMD_HIDE+ECMD_OLDBUF,
}
static buf_T *
-vi_find_buffer(fname)
- char *fname;
+vi_find_buffer(char *fname)
{ /* derived from buflist_findname() [buffer.c] */
buf_T *buf;
static char *
-vi_symbol_under_cursor()
+vi_symbol_under_cursor(void)
{
int len;
char *symbolp;
static char *
-vi_buffer_name()
+vi_buffer_name(void)
{
return (char *)curbuf->b_sfname;
}
static void
-vi_exec_cmd(vicmd)
- char *vicmd;
+vi_exec_cmd(char *vicmd)
{
do_cmdline_cmd((char_u *)vicmd); /* [ex_docmd.c] */
}
* derived from cursor_pos_info() [buffer.c]
*/
static void
-vi_set_cursor_pos(char_pos)
- long char_pos;
+vi_set_cursor_pos(long char_pos)
{
linenr_T lnum;
long char_count = 1; /* first position = 1 */
}
static long
-vi_cursor_pos()
+vi_cursor_pos(void)
{
linenr_T lnum;
long char_count=1; /* sniff starts with pos 1 */
#endif
void
-vim_tcl_init(arg)
- char *arg;
+vim_tcl_init(char *arg)
{
#ifndef DYNAMIC_TCL
Tcl_FindExecutable(arg);
* Return TRUE if the TCL interface can be used.
*/
int
-tcl_enabled(verbose)
- int verbose;
+tcl_enabled(int verbose)
{
if (!stubs_initialized && find_executable_arg != NULL
&& tcl_runtime_link_init((char *)p_tcldll, verbose) == OK)
#endif
void
-tcl_end()
+tcl_end(void)
{
#ifdef DYNAMIC_TCL
if (hTclLib)
* useless for this routine to return the exit code via Tcl_SetResult().
*/
static int
-exitcmd(dummy, interp, objc, objv)
- ClientData dummy UNUSED;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+exitcmd(
+ ClientData dummy UNUSED,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
int value = 0;
* "::vim::beep" - what Vi[m] does best :-)
*/
static int
-beepcmd(dummy, interp, objc, objv)
- ClientData dummy UNUSED;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+beepcmd(
+ ClientData dummy UNUSED,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
if (objc != 1)
{
* "::vim::buffer new" - create a new buffer (not implemented)
*/
static int
-buffercmd(dummy, interp, objc, objv)
- ClientData dummy UNUSED;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+buffercmd(
+ ClientData dummy UNUSED,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
char *name;
buf_T *buf;
* "::vim::window list" - create list of window commands.
*/
static int
-windowcmd(dummy, interp, objc, objv)
- ClientData dummy UNUSED;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+windowcmd(
+ ClientData dummy UNUSED,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
char *what, *string;
win_T *win;
* This function implements the buffer commands.
*/
static int
-bufselfcmd(ref, interp, objc, objv)
- ClientData ref;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+bufselfcmd(
+ ClientData ref,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
int opt, err, idx, flags;
int val1, val2, n, i;
* This function implements the window commands.
*/
static int
-winselfcmd(ref, interp, objc, objv)
- ClientData ref;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+winselfcmd(
+ ClientData ref,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
int err, idx, flags;
int val1, val2;
static int
-commandcmd(dummy, interp, objc, objv)
- ClientData dummy UNUSED;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+commandcmd(
+ ClientData dummy UNUSED,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
int err;
}
static int
-optioncmd(dummy, interp, objc, objv)
- ClientData dummy UNUSED;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+optioncmd(
+ ClientData dummy UNUSED,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
int err;
}
static int
-exprcmd(dummy, interp, objc, objv)
- ClientData dummy UNUSED;
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
+exprcmd(
+ ClientData dummy UNUSED,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[])
{
return tclvimexpr(interp, objc, objv, 1);
}
* Get a line number from 'obj' and convert it to vim's range.
*/
static int
-tclgetlinenum(interp, obj, valueP, buf)
- Tcl_Interp *interp;
- Tcl_Obj *obj;
- int *valueP;
- buf_T *buf;
+tclgetlinenum(
+ Tcl_Interp *interp,
+ Tcl_Obj *obj,
+ int *valueP,
+ buf_T *buf)
{
int err, i;
* Find the first window in the window list that displays the buffer.
*/
static win_T *
-tclfindwin(buf)
- buf_T *buf;
+tclfindwin(buf_T *buf)
{
win_T *win;
* Do-it-all function for "::vim::command", "$buf command" and "$win command".
*/
static int
-tcldoexcommand(interp, objc, objv, objn)
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
- int objn;
+tcldoexcommand(
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[],
+ int objn)
{
tcl_info saveinfo;
int err, flag, nobjs;
* Do-it-all function for "::vim::option", "$buf option" and "$win option".
*/
static int
-tclsetoption(interp, objc, objv, objn)
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
- int objn;
+tclsetoption(
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[],
+ int objn)
{
int err, nobjs, idx;
char_u *option;
* Do-it-all function for "::vim::expr", "$buf expr" and "$win expr".
*/
static int
-tclvimexpr(interp, objc, objv, objn)
- Tcl_Interp *interp;
- int objc;
- Tcl_Obj *CONST objv[];
- int objn;
+tclvimexpr(
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[],
+ int objn)
{
#ifdef FEAT_EVAL
char *expr, *str;
* Check for internal vim errors.
*/
static int
-vimerror(interp)
- Tcl_Interp *interp;
+vimerror(Tcl_Interp *interp)
{
if (got_int)
{
* tclsetdelcmd() - add Tcl callback command to a vim object
*/
static void
-delref(cref)
- ClientData cref;
+delref(ClientData cref)
{
struct ref *ref = (struct ref *)cref;
}
static char *
-tclgetref(interp, refstartP, prefix, vimobj, proc)
- Tcl_Interp *interp;
- void **refstartP; /* ptr to w_tcl_ref/b_tcl-ref member of
+tclgetref(
+ Tcl_Interp *interp,
+ void **refstartP, /* ptr to w_tcl_ref/b_tcl-ref member of
win_T/buf_T struct */
- char *prefix; /* "win" or "buf" */
- void *vimobj; /* win_T* or buf_T* */
- Tcl_ObjCmdProc *proc; /* winselfcmd or bufselfcmd */
+ char *prefix, /* "win" or "buf" */
+ void *vimobj, /* win_T* or buf_T* */
+ Tcl_ObjCmdProc *proc) /* winselfcmd or bufselfcmd */
{
struct ref *ref, *unused = NULL;
static char name[VARNAME_SIZE];
}
static char *
-tclgetwindow(interp, win)
- Tcl_Interp *interp;
- win_T *win;
+tclgetwindow(Tcl_Interp *interp, win_T *win)
{
return tclgetref(interp, &(win->w_tcl_ref), "win", (void *)win, winselfcmd);
}
static char *
-tclgetbuffer(interp, buf)
- Tcl_Interp *interp;
- buf_T *buf;
+tclgetbuffer(Tcl_Interp *interp, buf_T *buf)
{
return tclgetref(interp, &(buf->b_tcl_ref), "buf", (void *)buf, bufselfcmd);
}
static int
-tclsetdelcmd(interp, reflist, vimobj, delcmd)
- Tcl_Interp *interp;
- struct ref *reflist;
- void *vimobj;
- Tcl_Obj *delcmd;
+tclsetdelcmd(
+ Tcl_Interp *interp,
+ struct ref *reflist,
+ void *vimobj,
+ Tcl_Obj *delcmd)
{
if (reflist == &refsdeleted)
{
********************************************/
static int
-tcl_channel_close(instance, interp)
- ClientData instance;
- Tcl_Interp *interp UNUSED;
+tcl_channel_close(ClientData instance, Tcl_Interp *interp UNUSED)
{
int err = 0;
}
static int
-tcl_channel_input(instance, buf, bufsiz, errptr)
- ClientData instance UNUSED;
- char *buf UNUSED;
- int bufsiz UNUSED;
- int *errptr;
+tcl_channel_input(
+ ClientData instance UNUSED,
+ char *buf UNUSED,
+ int bufsiz UNUSED,
+ int *errptr)
{
/* input is currently not supported */
}
static int
-tcl_channel_output(instance, buf, bufsiz, errptr)
- ClientData instance;
- char *buf;
- int bufsiz;
- int *errptr;
+tcl_channel_output(
+ ClientData instance,
+ const char *buf,
+ int bufsiz,
+ int *errptr)
{
char_u *str;
int result;
}
static void
-tcl_channel_watch(instance, mask)
- ClientData instance UNUSED;
- int mask UNUSED;
+tcl_channel_watch(ClientData instance UNUSED, int mask UNUSED)
{
Tcl_SetErrno(EINVAL);
}
static int
-tcl_channel_gethandle(instance, direction, handleptr)
- ClientData instance UNUSED;
- int direction UNUSED;
- ClientData *handleptr UNUSED;
+tcl_channel_gethandle(
+ ClientData instance UNUSED,
+ int direction UNUSED,
+ ClientData *handleptr UNUSED)
{
Tcl_SetErrno(EINVAL);
return EINVAL;
**********************************/
static void
-tclupdatevars()
+tclupdatevars(void)
{
char varname[VARNAME_SIZE]; /* must be writeable */
char *name;
static int
-tclinit(eap)
- exarg_T *eap;
+tclinit(exarg_T *eap)
{
char varname[VARNAME_SIZE]; /* Tcl_LinkVar requires writeable varname */
char *name;
}
static void
-tclerrmsg(text)
- char *text;
+tclerrmsg(char *text)
{
char *next;
}
static void
-tclmsg(text)
- char *text;
+tclmsg(char *text)
{
char *next;
}
static void
-tcldelthisinterp()
+tcldelthisinterp(void)
{
if (!Tcl_InterpDeleted(tclinfo.interp))
Tcl_DeleteInterp(tclinfo.interp);
}
static int
-tclexit(error)
- int error;
+tclexit(int error)
{
int newerr = OK;
* ":tcl"
*/
void
-ex_tcl(eap)
- exarg_T *eap;
+ex_tcl(exarg_T *eap)
{
char_u *script;
int err;
* ":tclfile"
*/
void
-ex_tclfile(eap)
- exarg_T *eap;
+ex_tclfile(exarg_T *eap)
{
char *file = (char *)eap->arg;
int err;
* ":tcldo"
*/
void
-ex_tcldo(eap)
- exarg_T *eap;
+ex_tcldo(exarg_T *eap)
{
char *script, *line;
int err, rs, re, lnum;
}
static void
-tcldelallrefs(ref)
- struct ref *ref;
+tcldelallrefs(struct ref *ref)
{
struct ref *next;
int err;
}
void
-tcl_buffer_free(buf)
- buf_T *buf;
+tcl_buffer_free(buf_T *buf)
{
struct ref *reflist;
#if defined(FEAT_WINDOWS) || defined(PROTO)
void
-tcl_window_free(win)
- win_T *win;
+tcl_window_free(win_T *win)
{
struct ref *reflist;
* Returns FAIL or OK.
*/
int
-serverRegisterName(dpy, name)
- Display *dpy; /* display to register with */
- char_u *name; /* the name that will be used as a base */
+serverRegisterName(
+ Display *dpy, /* display to register with */
+ char_u *name) /* the name that will be used as a base */
{
int i;
int res;
}
static int
-DoRegisterName(dpy, name)
- Display *dpy;
- char_u *name;
+DoRegisterName(Display *dpy, char_u *name)
{
Window w;
XErrorHandler old_handler;
* Change any registered window ID.
*/
void
-serverChangeRegisteredWindow(dpy, newwin)
- Display *dpy; /* Display to register with */
- Window newwin; /* Re-register to this ID */
+serverChangeRegisteredWindow(
+ Display *dpy, /* Display to register with */
+ Window newwin) /* Re-register to this ID */
{
char_u propInfo[MAX_NAME_LENGTH + 20];
* Returns 0 for OK, negative for an error.
*/
int
-serverSendToVim(dpy, name, cmd, result, server, asExpr, localLoop, silent)
- Display *dpy; /* Where to send. */
- char_u *name; /* Where to send. */
- char_u *cmd; /* What to send. */
- char_u **result; /* Result of eval'ed expression */
- Window *server; /* Actual ID of receiving app */
- Bool asExpr; /* Interpret as keystrokes or expr ? */
- Bool localLoop; /* Throw away everything but result */
- int silent; /* don't complain about no server */
+serverSendToVim(
+ Display *dpy, /* Where to send. */
+ char_u *name, /* Where to send. */
+ char_u *cmd, /* What to send. */
+ char_u **result, /* Result of eval'ed expression */
+ Window *server, /* Actual ID of receiving app */
+ Bool asExpr, /* Interpret as keystrokes or expr ? */
+ Bool localLoop, /* Throw away everything but result */
+ int silent) /* don't complain about no server */
{
Window w;
char_u *property;
}
static int
-WaitForPend(p)
- void *p;
+WaitForPend(void *p)
{
PendingCommand *pending = (PendingCommand *) p;
return pending->result != NULL;
* Return TRUE if window "w" exists and has a "Vim" property on it.
*/
static int
-WindowValid(dpy, w)
- Display *dpy;
- Window w;
+WindowValid(Display *dpy, Window w)
{
XErrorHandler old_handler;
Atom *plist;
* Enter a loop processing X events & polling chars until we see a result
*/
static void
-ServerWait(dpy, w, endCond, endData, localLoop, seconds)
- Display *dpy;
- Window w;
- EndCond endCond;
- void *endData;
- int localLoop;
- int seconds;
+ServerWait(
+ Display *dpy,
+ Window w,
+ EndCond endCond,
+ void *endData,
+ int localLoop,
+ int seconds)
{
time_t start;
time_t now;
* Returns a newline separated list in allocated memory or NULL.
*/
char_u *
-serverGetVimNames(dpy)
- Display *dpy;
+serverGetVimNames(Display *dpy)
{
char_u *regProp;
char_u *entry;
*/
static struct ServerReply *
-ServerReplyFind(w, op)
- Window w;
- enum ServerReplyOp op;
+ServerReplyFind(Window w, enum ServerReplyOp op)
{
struct ServerReply *p;
struct ServerReply e;
* Issue an error if the id is invalid.
*/
Window
-serverStrToWin(str)
- char_u *str;
+serverStrToWin(char_u *str)
{
unsigned id = None;
* Return -1 if the window is invalid.
*/
int
-serverSendReply(name, str)
- char_u *name;
- char_u *str;
+serverSendReply(char_u *name, char_u *str)
{
char_u *property;
int length;
}
static int
-WaitForReply(p)
- void *p;
+WaitForReply(void *p)
{
Window *w = (Window *) p;
return ServerReplyFind(*w, SROP_Find) != NULL;
* Return -1 if the window becomes invalid while waiting.
*/
int
-serverReadReply(dpy, win, str, localLoop)
- Display *dpy;
- Window win;
- char_u **str;
- int localLoop;
+serverReadReply(
+ Display *dpy,
+ Window win,
+ char_u **str,
+ int localLoop)
{
int len;
char_u *s;
* Return TRUE and a non-malloc'ed string if there is. Else return FALSE.
*/
int
-serverPeekReply(dpy, win, str)
- Display *dpy;
- Window win;
- char_u **str;
+serverPeekReply(Display *dpy, Window win, char_u **str)
{
struct ServerReply *p;
* results.
*/
static int
-SendInit(dpy)
- Display *dpy;
+SendInit(Display *dpy)
{
XErrorHandler old_handler;
* removed from the registry property.
*/
static Window
-LookupName(dpy, name, delete, loose)
- Display *dpy; /* Display whose registry to check. */
- char_u *name; /* Name of a server. */
- int delete; /* If non-zero, delete info about name. */
- char_u **loose; /* Do another search matching -999 if not found
+LookupName(
+ Display *dpy, /* Display whose registry to check. */
+ char_u *name, /* Name of a server. */
+ int delete, /* If non-zero, delete info about name. */
+ char_u **loose) /* Do another search matching -999 if not found
Return result here if a match is found */
{
char_u *regProp, *entry;
* 3. The window will mistakenly be regarded valid because of own commWindow
*/
static void
-DeleteAnyLingerer(dpy, win)
- Display *dpy; /* Display whose registry to check. */
- Window win; /* Window to remove */
+DeleteAnyLingerer(
+ Display *dpy, /* Display whose registry to check. */
+ Window win) /* Window to remove */
{
char_u *regProp, *entry = NULL;
char_u *p;
* Return OK when successful.
*/
static int
-GetRegProp(dpy, regPropp, numItemsp, domsg)
- Display *dpy;
- char_u **regPropp;
- long_u *numItemsp;
- int domsg; /* When TRUE give error message. */
+GetRegProp(
+ Display *dpy,
+ char_u **regPropp,
+ long_u *numItemsp,
+ int domsg) /* When TRUE give error message. */
{
int result, actualFormat;
long_u bytesAfter;
* response.
*/
void
-serverEventProc(dpy, eventPtr, immediate)
- Display *dpy;
- XEvent *eventPtr; /* Information about event. */
- int immediate; /* Run event immediately. Should mostly be 0. */
+serverEventProc(
+ Display *dpy,
+ XEvent *eventPtr, /* Information about event. */
+ int immediate) /* Run event immediately. Should mostly be 0. */
{
char_u *propInfo;
int result, actualFormat;
* vim is idle.
*/
static void
-save_in_queue(propInfo, len)
- char_u *propInfo;
- long_u len;
+save_in_queue(char_u *propInfo, long_u len)
{
x_queue_T *node;
* Parses queued clientserver messages.
*/
void
-server_parse_messages()
+server_parse_messages(void)
{
x_queue_T *node;
* int the queue.
*/
int
-server_waiting()
+server_waiting(void)
{
return head.next != NULL && head.next != &head;
}
* "propInfo" will be freed.
*/
static void
-server_parse_message(dpy, propInfo, numItems)
- Display *dpy;
- char_u *propInfo; /* A string containing 0 or more X commands */
- long_u numItems; /* The size of propInfo in bytes. */
+server_parse_message(
+ Display *dpy,
+ char_u *propInfo, /* A string containing 0 or more X commands */
+ long_u numItems) /* The size of propInfo in bytes. */
{
char_u *p;
int code;
* Return: 0 for OK, -1 for error
*/
static int
-AppendPropCarefully(dpy, window, property, value, length)
- Display *dpy; /* Display on which to operate. */
- Window window; /* Window whose property is to be modified. */
- Atom property; /* Name of property. */
- char_u *value; /* Characters to append to property. */
- int length; /* How much to append */
+AppendPropCarefully(
+ Display *dpy, /* Display on which to operate. */
+ Window window, /* Window whose property is to be modified. */
+ Atom property, /* Name of property. */
+ char_u *value, /* Characters to append to property. */
+ int length) /* How much to append */
{
XErrorHandler old_handler;
* Another X Error handler, just used to check for errors.
*/
static int
-x_error_check(dpy, error_event)
- Display *dpy UNUSED;
- XErrorEvent *error_event UNUSED;
+x_error_check(Display *dpy UNUSED, XErrorEvent *error_event UNUSED)
{
got_x_error = TRUE;
return 0;
* Actually just checks if the name ends in a digit.
*/
static int
-IsSerialName(str)
- char_u *str;
+IsSerialName(char_u *str)
{
int len = STRLEN(str);
if you want to do things differently if the editor is started standalone
or in WorkShop mode. For example, in standalone mode you may not want to
add a footer/message area or a sign gutter. */
-int
-workshop_invoked()
+ int
+workshop_invoked(void)
{
static int result = -1;
if (result == -1) {
dummy = write(sd, buf, strlen(buf));
}
-void workshop_disconnect()
+void workshop_disconnect(void)
{
/* Probably need to send some message here */
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 1208,
/**/
1207,
/**/
projects / thirdparty / vim.git / commitdiff
