* Fixed compilation warnings.

* Removed fucking K&R syntax. git-svn-id: svn://svn.zoy.org/elk/trunk@91 55e467fa-43c5-0310-a8a2-de718669efc6
2003-09-04 14:32:13 +00:00 · 2003-09-04 14:32:13 +00:00 · e81273f8a3
parent 6bc9b501c7
commit e81273f8a3
24 changed files with 401 additions and 362 deletions
--- a/lib/xlib/client.c
+++ b/lib/xlib/client.c
@ -30,6 +30,8 @@
 #include "xlib.h"
 #include <string.h>
 static Object Sym_Wm_Hints, Sym_Size_Hints;
 static Object P_Iconify_Window (Object w, Object scr) {
@ -81,8 +83,8 @@ static Object P_Wm_Command (Object w) {
    return ret;
 }
-static String_List_To_Text_Property (Object x, XTextProperty *ret) {
+static void String_List_To_Text_Property (Object x, XTextProperty *ret) {
-    register i, n;
+    register int i, n;
    register char **s;
    Object t;
    Alloca_Begin;
@ -101,7 +103,7 @@ static String_List_To_Text_Property (Object x, XTextProperty *ret) {
 static Object Text_Property_To_String_List (XTextProperty *p) {
    int n;
-    register i;
+    register int i;
    char **s;
    Object x, ret, t;
    GC_Node2;
@ -232,7 +234,7 @@ static Object P_Set_Wm_Class (Object w, Object name, Object class) {
 }
 static Object P_Set_Wm_Command (Object w, Object cmd) {
-    register i, n;
+    register int i, n;
    register char **argv;
    Object c;
    Alloca_Begin;
@ -304,7 +306,7 @@ static Object P_Set_Size_Hints (Object w, Object a, Object h) {
    Check_Type (w, T_Window);
    Check_Type (a, T_Atom);
-    bzero ((char *)&SZH, sizeof (SZH));        /* Not portable? */
+    memset ((char *)&SZH, 0, sizeof (SZH));        /* Not portable? */
    mask = Vector_To_Record (h, Size_Hints_Size, Sym_Size_Hints,
        Size_Hints_Rec);
    if ((mask & (PPosition|USPosition)) == (PPosition|USPosition))
@ -349,7 +351,7 @@ static Object P_Icon_Sizes (Object w) {
 }
 static Object P_Set_Icon_Sizes (Object w, Object v) {
-    register i, n;
+    register int i, n;
    XIconSize *p;
    Alloca_Begin;
@ -393,7 +395,7 @@ static Object P_Set_Transient_For (Object w, Object pw) {
    return Void;
 }
-elk_init_xlib_client () {
+void elk_init_xlib_client () {
    Define_Symbol (&Sym_Wm_Hints, "wm-hints");
    Define_Symbol (&Sym_Size_Hints, "size-hints");
    Define_Primitive (P_Iconify_Window,   "iconify-window",    2, 2, EVAL);
--- a/lib/xlib/color.c
+++ b/lib/xlib/color.c
@ -32,7 +32,7 @@
 Generic_Predicate (Color)
-static Color_Equal (Object x, Object y) {
+static int Color_Equal (Object x, Object y) {
    register XColor *p = &COLOR(x)->c, *q = &COLOR(y)->c;
    return p->red == q->red && p->green == q->green && p->blue == q->blue;
 }
@ -59,7 +59,7 @@ XColor *Get_Color (Object c) {
    return &COLOR(c)->c;
 }
-static unsigned short Get_RGB_Value (x) Object x; {
+static unsigned short Get_RGB_Value (Object x) {
    double d;
    d = Get_Double (x);
@ -68,11 +68,11 @@ static unsigned short Get_RGB_Value (x) Object x; {
    return (unsigned short)(d * 65535);
 }
-static Object P_Make_Color (r, g, b) Object r, g, b; {
+static Object P_Make_Color (Object r, Object g, Object b) {
    return Make_Color (Get_RGB_Value (r), Get_RGB_Value (g), Get_RGB_Value (b));
 }
-static Object P_Color_Rgb_Values (c) Object c; {
+static Object P_Color_Rgb_Values (Object c) {
    Object ret, t, x;
    GC_Node3;
@ -90,7 +90,7 @@ static Object P_Color_Rgb_Values (c) Object c; {
    return ret;
 }
-static Object P_Query_Color (cmap, p) Object cmap, p; {
+static Object P_Query_Color (Object cmap, Object p) {
    XColor c;
    Colormap cm = Get_Colormap (cmap);
@ -101,9 +101,9 @@ static Object P_Query_Color (cmap, p) Object cmap, p; {
    return Make_Color (c.red, c.green, c.blue);
 }
-static Object P_Query_Colors (cmap, v) Object cmap, v; {
+static Object P_Query_Colors (Object cmap, Object v) {
    Colormap cm = Get_Colormap (cmap);
-    register i, n;
+    register int i, n;
    Object ret;
    register XColor *p;
    GC_Node;
@ -130,7 +130,7 @@ static Object P_Query_Colors (cmap, v) Object cmap, v; {
    return ret;
 }
-static Object P_Lookup_Color (cmap, name) Object cmap, name; {
+static Object P_Lookup_Color (Object cmap, Object name) {
    XColor visual, exact;
    Colormap cm = Get_Colormap (cmap);
    Object ret, x;
@ -149,7 +149,7 @@ static Object P_Lookup_Color (cmap, name) Object cmap, name; {
    return ret;
 }
-elk_init_xlib_color () {
+void elk_init_xlib_color () {
    Generic_Define (Color, "color", "color?");
    Define_Primitive (P_Make_Color,       "make-color",       3, 3, EVAL);
    Define_Primitive (P_Color_Rgb_Values, "color-rgb-values", 1, 1, EVAL);
--- a/lib/xlib/colormap.c
+++ b/lib/xlib/colormap.c
@ -38,7 +38,7 @@ Generic_Print (Colormap, "#[colormap %lu]", COLORMAP(x)->cm)
 Generic_Get_Display (Colormap, COLORMAP)
-Object Make_Colormap (finalize, dpy, cmap) Display *dpy; Colormap cmap; {
+Object Make_Colormap (int finalize, Display *dpy, Colormap cmap) {
    Object cm;
    if (cmap == None)
@ -56,12 +56,12 @@ Object Make_Colormap (finalize, dpy, cmap) Display *dpy; Colormap cmap; {
    return cm;
 }
-Colormap Get_Colormap (c) Object c; {
+Colormap Get_Colormap (Object c) {
    Check_Type (c, T_Colormap);
    return COLORMAP(c)->cm;
 }
-Object P_Free_Colormap (c) Object c; {
+Object P_Free_Colormap (Object c) {
    Check_Type (c, T_Colormap);
    if (!COLORMAP(c)->free)
        XFreeColormap (COLORMAP(c)->dpy, COLORMAP(c)->cm);
@ -70,7 +70,7 @@ Object P_Free_Colormap (c) Object c; {
    return Void;
 }
-static Object P_Alloc_Color (cmap, color) Object cmap, color; {
+static Object P_Alloc_Color (Object cmap, Object color) {
    XColor c;
    Colormap cm = Get_Colormap (cmap);
    int r;
@ -84,7 +84,7 @@ static Object P_Alloc_Color (cmap, color) Object cmap, color; {
    return Make_Pixel (c.pixel);
 }
-static Object P_Alloc_Named_Color (cmap, name) Object cmap, name; {
+static Object P_Alloc_Named_Color (Object cmap, Object name) {
    Colormap cm = Get_Colormap (cmap);
    XColor screen, exact;
    int r;
@ -109,7 +109,7 @@ static Object P_Alloc_Named_Color (cmap, name) Object cmap, name; {
    return ret;
 }
-elk_init_xlib_colormap () {
+void elk_init_xlib_colormap () {
    Generic_Define (Colormap, "colormap", "colormap?");
    Define_Primitive (P_Colormap_Display, "colormap-display", 1, 1, EVAL);
    Define_Primitive (P_Free_Colormap,    "free-colormap",    1, 1, EVAL);
--- a/lib/xlib/cursor.c
+++ b/lib/xlib/cursor.c
@ -38,8 +38,7 @@ Generic_Print (Cursor, "#[cursor %lu]", CURSOR(x)->cursor)
 Generic_Get_Display (Cursor, CURSOR)
-static Object Internal_Make_Cursor (finalize, dpy, cursor)
+static Object Internal_Make_Cursor (int finalize, Display *dpy, Cursor cursor) {
        Display *dpy; Cursor cursor; {
    Object c;
    if (cursor == None)
@ -58,22 +57,22 @@ static Object Internal_Make_Cursor (finalize, dpy, cursor)
 }
 /* Backwards compatibility: */
-Object Make_Cursor (dpy, cursor) Display *dpy; Cursor cursor; {
+Object Make_Cursor (Display *dpy, Cursor cursor) {
    return Internal_Make_Cursor (1, dpy, cursor);
 }
-Object Make_Cursor_Foreign (dpy, cursor) Display *dpy; Cursor cursor; {
+Object Make_Cursor_Foreign (Display *dpy, Cursor cursor) {
    return Internal_Make_Cursor (0, dpy, cursor);
 }
-Cursor Get_Cursor (c) Object c; {
+Cursor Get_Cursor (Object c) {
    if (EQ(c, Sym_None))
        return None;
    Check_Type (c, T_Cursor);
    return CURSOR(c)->cursor;
 }
-Object P_Free_Cursor (c) Object c; {
+Object P_Free_Cursor (Object c) {
    Check_Type (c, T_Cursor);
    if (!CURSOR(c)->free)
        XFreeCursor (CURSOR(c)->dpy, CURSOR(c)->cursor);
@ -82,8 +81,8 @@ Object P_Free_Cursor (c) Object c; {
    return Void;
 }
-static Object P_Create_Cursor (srcp, maskp, x, y, f, b)
+static Object P_Create_Cursor (Object srcp, Object maskp, Object x, Object y,
-        Object srcp, maskp, x, y, f, b; {
+                               Object f, Object b) {
    Pixmap sp = Get_Pixmap (srcp), mp;
    Display *d = PIXMAP(srcp)->dpy;
@ -92,8 +91,8 @@ static Object P_Create_Cursor (srcp, maskp, x, y, f, b)
        Get_Color (f), Get_Color (b), Get_Integer (x), Get_Integer (y)));
 }
-static Object P_Create_Glyph_Cursor (srcf, srcc, maskf, maskc, f, b)
+static Object P_Create_Glyph_Cursor (Object srcf, Object srcc, Object maskf,
-        Object srcf, srcc, maskf, maskc, f, b; {
+                                     Object maskc, Object f, Object b) {
    Font sf = Get_Font (srcf), mf;
    Display *d = FONT(srcf)->dpy;
@ -103,14 +102,14 @@ static Object P_Create_Glyph_Cursor (srcf, srcc, maskf, maskc, f, b)
        Get_Color (f), Get_Color (b)));
 }
-static Object P_Recolor_Cursor (c, f, b) Object c, f, b; {
+static Object P_Recolor_Cursor (Object c, Object f, Object b) {
    Check_Type (c, T_Cursor);
    XRecolorCursor (CURSOR(c)->dpy, CURSOR(c)->cursor, Get_Color (f),
        Get_Color (b));
    return Void;
 }
-elk_init_xlib_cursor () {
+void elk_init_xlib_cursor () {
    Generic_Define (Cursor, "cursor", "cursor?");
    Define_Primitive (P_Cursor_Display, "cursor-display", 1, 1, EVAL);
    Define_Primitive (P_Free_Cursor,    "free-cursor",    1, 1, EVAL);
--- a/lib/xlib/display.c
+++ b/lib/xlib/display.c
@ -30,20 +30,25 @@
 #include "xlib.h"
-static Display_Visit (dp, f) Object *dp; int (*f)(); {
+#include <string.h>
 static int Display_Visit (Object *dp, int (*f)()) {
    (*f)(&DISPLAY(*dp)->after);
    return 0;
 }
 Generic_Predicate (Display)
 Generic_Equal (Display, DISPLAY, dpy)
-static Display_Print (d, port, raw, depth, length) Object d, port; {
+static int Display_Print (Object d, Object port,
                          int raw, int depth, int length) {
    Printf (port, "#[display %lu %s]", (unsigned)DISPLAY(d)->dpy,
        DisplayString (DISPLAY(d)->dpy));
    return 0;
 }
-Object Make_Display (finalize, dpy) Display *dpy; {
+Object Make_Display (int finalize, Display *dpy) {
    Object d;
    d = Find_Object (T_Display, (GENERIC)dpy, Match_X_Obj);
@ -58,7 +63,7 @@ Object Make_Display (finalize, dpy) Display *dpy; {
    return d;
 }
-static Object P_Open_Display (argc, argv) Object *argv; {
+static Object P_Open_Display (int argc, Object *argv) {
    register char *s;
    Display *dpy;
@ -73,7 +78,7 @@ static Object P_Open_Display (argc, argv) Object *argv; {
    return Make_Display (1, dpy);
 }
-Object P_Close_Display (d) Object d; {
+Object P_Close_Display (Object d) {
    register struct S_Display *p;
    Check_Type (d, T_Display);
@ -87,13 +92,13 @@ Object P_Close_Display (d) Object d; {
    return Void;
 }
-static Object P_Display_Default_Root_Window (d) Object d; {
+static Object P_Display_Default_Root_Window (Object d) {
    Check_Type (d, T_Display);
    return Make_Window (0, DISPLAY(d)->dpy,
        DefaultRootWindow (DISPLAY(d)->dpy));
 }
-static Object P_Display_Default_Colormap (d) Object d; {
+static Object P_Display_Default_Colormap (Object d) {
    register Display *dpy;
    Check_Type (d, T_Display);
@ -101,7 +106,7 @@ static Object P_Display_Default_Colormap (d) Object d; {
    return Make_Colormap (0, dpy, DefaultColormap (dpy, DefaultScreen (dpy)));
 }
-static Object P_Display_Default_Gcontext (d) Object d; {
+static Object P_Display_Default_Gcontext (Object d) {
    register Display *dpy;
    Check_Type (d, T_Display);
@ -109,7 +114,7 @@ static Object P_Display_Default_Gcontext (d) Object d; {
    return Make_Gc (0, dpy, DefaultGC (dpy, DefaultScreen (dpy)));
 }
-static Object P_Display_Default_Depth (d) Object d; {
+static Object P_Display_Default_Depth (Object d) {
    register Display *dpy;
    Check_Type (d, T_Display);
@ -117,32 +122,32 @@ static Object P_Display_Default_Depth (d) Object d; {
    return Make_Integer (DefaultDepth (dpy, DefaultScreen (dpy)));
 }
-static Object P_Display_Default_Screen_Number (d) Object d; {
+static Object P_Display_Default_Screen_Number (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (DefaultScreen (DISPLAY(d)->dpy));
 }
-int Get_Screen_Number (dpy, scr) Display *dpy; Object scr; {
+int Get_Screen_Number (Display *dpy, Object scr) {
-    register s;
+    register int s;
    if ((s = Get_Integer (scr)) < 0 || s > ScreenCount (dpy)-1)
        Primitive_Error ("invalid screen number");
    return s;
 }
-static Object P_Display_Cells (d, scr) Object d, scr; {
+static Object P_Display_Cells (Object d, Object scr) {
    Check_Type (d, T_Display);
    return Make_Integer (DisplayCells (DISPLAY(d)->dpy,
        Get_Screen_Number (DISPLAY(d)->dpy, scr)));
 }
-static Object P_Display_Planes (d, scr) Object d, scr; {
+static Object P_Display_Planes (Object d, Object scr) {
    Check_Type (d, T_Display);
    return Make_Integer (DisplayPlanes (DISPLAY(d)->dpy,
        Get_Screen_Number (DISPLAY(d)->dpy, scr)));
 }
-static Object P_Display_String (d) Object d; {
+static Object P_Display_String (Object d) {
    register char *s;
    Check_Type (d, T_Display);
@ -150,7 +155,7 @@ static Object P_Display_String (d) Object d; {
    return Make_String (s, strlen (s));
 }
-static Object P_Display_Vendor (d) Object d; {
+static Object P_Display_Vendor (Object d) {
    register char *s;
    Object ret, name;
    GC_Node;
@ -165,90 +170,90 @@ static Object P_Display_Vendor (d) Object d; {
    return ret;
 }
-static Object P_Display_Protocol_Version (d) Object d; {
+static Object P_Display_Protocol_Version (Object d) {
    Check_Type (d, T_Display);
    return Cons (Make_Integer (ProtocolVersion (DISPLAY(d)->dpy)),
        Make_Integer (ProtocolRevision (DISPLAY(d)->dpy)));
 }
-static Object P_Display_Screen_Count (d) Object d; {
+static Object P_Display_Screen_Count (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (ScreenCount (DISPLAY(d)->dpy));
 }
-static Object P_Display_Image_Byte_Order (d) Object d; {
+static Object P_Display_Image_Byte_Order (Object d) {
    Check_Type (d, T_Display);
    return Bits_To_Symbols ((unsigned long)ImageByteOrder (DISPLAY(d)->dpy),
        0, Byte_Order_Syms);
 }
-static Object P_Display_Bitmap_Unit (d) Object d; {
+static Object P_Display_Bitmap_Unit (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (BitmapUnit (DISPLAY(d)->dpy));
 }
-static Object P_Display_Bitmap_Bit_Order (d) Object d; {
+static Object P_Display_Bitmap_Bit_Order (Object d) {
    Check_Type (d, T_Display);
    return Bits_To_Symbols ((unsigned long)BitmapBitOrder (DISPLAY(d)->dpy),
        0, Byte_Order_Syms);
 }
-static Object P_Display_Bitmap_Pad (d) Object d; {
+static Object P_Display_Bitmap_Pad (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (BitmapPad (DISPLAY(d)->dpy));
 }
-static Object P_Display_Width (d) Object d; {
+static Object P_Display_Width (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (DisplayWidth (DISPLAY(d)->dpy,
        DefaultScreen (DISPLAY(d)->dpy)));
 }
-static Object P_Display_Height (d) Object d; {
+static Object P_Display_Height (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (DisplayHeight (DISPLAY(d)->dpy,
        DefaultScreen (DISPLAY(d)->dpy)));
 }
-static Object P_Display_Width_Mm (d) Object d; {
+static Object P_Display_Width_Mm (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (DisplayWidthMM (DISPLAY(d)->dpy,
        DefaultScreen (DISPLAY(d)->dpy)));
 }
-static Object P_Display_Height_Mm (d) Object d; {
+static Object P_Display_Height_Mm (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (DisplayHeightMM (DISPLAY(d)->dpy,
        DefaultScreen (DISPLAY(d)->dpy)));
 }
-static Object P_Display_Motion_Buffer_Size (d) Object d; {
+static Object P_Display_Motion_Buffer_Size (Object d) {
    Check_Type (d, T_Display);
    return Make_Unsigned_Long (XDisplayMotionBufferSize (DISPLAY(d)->dpy));
 }
-static Object P_Display_Flush_Output (d) Object d; {
+static Object P_Display_Flush_Output (Object d) {
    Check_Type (d, T_Display);
    XFlush (DISPLAY(d)->dpy);
    return Void;
 }
-static Object P_Display_Wait_Output (d, discard) Object d, discard; {
+static Object P_Display_Wait_Output (Object d, Object discard) {
    Check_Type (d, T_Display);
    Check_Type (discard, T_Boolean);
    XSync (DISPLAY(d)->dpy, EQ(discard, True));
    return Void;
 }
-static Object P_No_Op (d) Object d; {
+static Object P_No_Op (Object d) {
    Check_Type (d, T_Display);
    XNoOp (DISPLAY(d)->dpy);
    return Void;
 }
-static Object P_List_Depths (d, scr) Object d, scr; {
+static Object P_List_Depths (Object d, Object scr) {
    int num;
-    register *p, i;
+    register int *p, i;
    Object ret;
    Check_Type (d, T_Display);
@ -262,10 +267,10 @@ static Object P_List_Depths (d, scr) Object d, scr; {
    return ret;
 }
-static Object P_List_Pixmap_Formats (d) Object d; {
+static Object P_List_Pixmap_Formats (Object d) {
    register XPixmapFormatValues *p;
    int num;
-    register i;
+    register int i;
    Object ret;
    GC_Node;
@ -288,7 +293,7 @@ static Object P_List_Pixmap_Formats (d) Object d; {
    return ret;
 }
-elk_init_xlib_display () {
+void elk_init_xlib_display () {
    T_Display = Define_Type (0, "display", NOFUNC, sizeof (struct S_Display),
        Display_Equal, Display_Equal, Display_Print, Display_Visit);
    Define_Primitive (P_Displayp,        "display?",         1, 1, EVAL);
--- a/lib/xlib/event.c
+++ b/lib/xlib/event.c
@ -30,6 +30,8 @@
 #include "xlib.h"
 #include <string.h>
 #define MAX_ARGS 14
 static Object Argl, Argv;
@ -82,14 +84,14 @@ struct predicate_arg {
 };
 /*ARGSUSED*/
-static Event_Predicate (dpy, ep, ptr) Display *dpy; XEvent *ep;
+static int Event_Predicate (Display *dpy, XEvent *ep,
 #ifdef XLIB_RELEASE_5_OR_LATER
-                XPointer ptr; {
+                XPointer ptr) {
 #else
-                char *ptr; {
+                char *ptr) {
 #endif
    struct predicate_arg *ap = (struct predicate_arg *)ptr;
-    register i;
+    register int i;
    Object args;
    GC_Node;
@ -110,9 +112,9 @@ static Event_Predicate (dpy, ep, ptr) Display *dpy; XEvent *ep;
 * peek?: don't discard processed events.
 */
-static Object P_Handle_Events (argl) Object argl; {
+static Object P_Handle_Events (Object argl) {
    Object next, clause, func, ret, funcs[LASTEvent], args;
-    register i, discard, peek;
+    register int i, discard, peek;
    Display *dpy;
    char *errmsg = "event occurs more than once";
    GC_Node3; struct gcnode gcv;
@ -192,13 +194,13 @@ static Object P_Handle_Events (argl) Object argl; {
    return ret;
 }
-static Object Get_Time_Arg (t) Time t; {
+static Object Get_Time_Arg (Time t) {
    return t == CurrentTime ? Sym_Now : Make_Unsigned_Long ((unsigned long)t);
 }
-Object Get_Event_Args (ep) XEvent *ep; {
+Object Get_Event_Args (XEvent *ep) {
    Object tmpargs[MAX_ARGS];
-    register e, i;
+    register int e, i;
    register Object *a, *vp;
    struct gcnode gcv;
    Object dummy;
@ -422,7 +424,7 @@ Object Get_Event_Args (ep) XEvent *ep; {
    } break;
    case ClientMessage: {
        register XClientMessageEvent *p = (XClientMessageEvent *)ep;
-        register i;
+        register int i;
        a[1] = Make_Window (0, p->display, p->window);
        a[2] = Make_Atom (p->message_type);
@ -463,18 +465,18 @@ Object Get_Event_Args (ep) XEvent *ep; {
    return Argl;
 }
-void Destroy_Event_Args (args) Object args; {
+void Destroy_Event_Args (Object args) {
    Object t;
    for (t = args; !Nullp (t); t = Cdr (t))
        Car (t) = Null;
 }
-Encode_Event (e) Object e; {
+int Encode_Event (Object e) {
    Object s;
    register char *p;
    register struct event_desc *ep;
-    register n;
+    register int n;
    Check_Type (e, T_Symbol);
    s = SYMBOL(e)->name;
@ -487,10 +489,10 @@ Encode_Event (e) Object e; {
    return ep-Event_Table;
 }
-static Object P_Get_Motion_Events (w, from, to) Object w, from, to; {
+static Object P_Get_Motion_Events (Object w, Object from, Object to) {
    XTimeCoord *p;
    int n;
-    register i;
+    register int i;
    Object e, ret;
    GC_Node2;
@ -511,9 +513,9 @@ static Object P_Get_Motion_Events (w, from, to) Object w, from, to; {
    return ret;
 }
-static Object P_Event_Listen (d, wait_flag) Object d, wait_flag; {
+static Object P_Event_Listen (Object d, Object wait_flag) {
    Display *dpy;
-    register n;
+    register int n;
    XEvent e;
    Check_Type (d, T_Display);
@ -527,9 +529,9 @@ static Object P_Event_Listen (d, wait_flag) Object d, wait_flag; {
    return Make_Integer (n);
 }
-elk_init_xlib_event () {
+void elk_init_xlib_event () {
    Object t;
-    register i;
+    register int i;
    Argl = P_Make_List (Make_Integer (MAX_ARGS), Null);
    Global_GC_Link (Argl);
--- a/lib/xlib/extension.c
+++ b/lib/xlib/extension.c
@ -30,10 +30,12 @@
 #include "xlib.h"
-static Object P_List_Extensions (d) Object d; {
+#include <string.h>
 static Object P_List_Extensions (Object d) {
    Object ret;
    int n;
-    register i;
+    register int i;
    register char **p;
    GC_Node;
@ -54,7 +56,7 @@ static Object P_List_Extensions (d) Object d; {
    return ret;
 }
-static Object P_Query_Extension (d, name) Object d, name; {
+static Object P_Query_Extension (Object d, Object name) {
    int opcode, event, error;
    Object ret, t;
    GC_Node2;
@ -72,7 +74,7 @@ static Object P_Query_Extension (d, name) Object d, name; {
    return ret;
 }
-elk_init_xlib_extension () {
+void elk_init_xlib_extension () {
    Define_Primitive (P_List_Extensions,    "list-extensions",   1, 1, EVAL);
    Define_Primitive (P_Query_Extension,    "query-extension",   2, 2, EVAL);
 }
--- a/lib/xlib/font.c
+++ b/lib/xlib/font.c
@ -30,12 +30,14 @@
 #include "xlib.h"
 #include <string.h>
 Object Sym_Char_Info;
 static Object Sym_Font_Info, Sym_Min, Sym_Max;
 Generic_Predicate (Font)
-static Font_Equal (x, y) Object x, y; {
+static int Font_Equal (Object x, Object y) {
    Font id1 = FONT(x)->id, id2 = FONT(y)->id;
    if (id1 && id2)
        return id1 == id2 && FONT(x)->dpy == FONT(y)->dpy;
@ -43,16 +45,18 @@ static Font_Equal (x, y) Object x, y; {
        return 0;
 }
-Generic_Print (Font, "#[font %lu]", FONT(x)->id ? FONT(x)->id : POINTER(x))
+Generic_Print (Font, "#[font %lu]", FONT(x)->id ? FONT(x)->id
                                                : (unsigned int)FIXNUM(x))
-static Font_Visit (fp, f) Object *fp; int (*f)(); {
+static int Font_Visit (Object *fp, int (*f)()) {
    (*f)(&FONT(*fp)->name);
    return 0;
 }
 Generic_Get_Display (Font, FONT)
-static Object Internal_Make_Font (finalize, dpy, name, id, info)
+static Object Internal_Make_Font (int finalize, Display *dpy, Object name,
-        Display *dpy; Object name; Font id; XFontStruct *info; {
+                                  Font id, XFontStruct *info) {
    Object f;
    GC_Node;
@ -71,23 +75,22 @@ static Object Internal_Make_Font (finalize, dpy, name, id, info)
 }
 /* Backwards compatibility: */
-Object Make_Font (dpy, name, id, info)
+Object Make_Font (Display *dpy, Object name, Font id, XFontStruct *info) {
        Display *dpy; Object name; Font id; XFontStruct *info; {
    return Internal_Make_Font (1, dpy, name, id, info);
 }
-Object Make_Font_Foreign (dpy, name, id, info)
+Object Make_Font_Foreign (Display *dpy, Object name, Font id,
-        Display *dpy; Object name; Font id; XFontStruct *info; {
+                          XFontStruct *info) {
    return Internal_Make_Font (0, dpy, name, id, info);
 }
-Font Get_Font (f) Object f; {
+Font Get_Font (Object f) {
    Check_Type (f, T_Font);
    Open_Font_Maybe (f);
    return FONT(f)->id;
 }
-static XFontStruct *Internal_Open_Font (d, name) Display *d; Object name; {
+static XFontStruct *Internal_Open_Font (Display *d, Object name) {
    register char *s;
    XFontStruct *p;
    Alloca_Begin;
@ -101,7 +104,7 @@ static XFontStruct *Internal_Open_Font (d, name) Display *d; Object name; {
    return p;
 }
-static Object P_Open_Font (d, name) Object d, name; {
+static Object P_Open_Font (Object d, Object name) {
    XFontStruct *p;
    Check_Type (d, T_Display)
@ -109,7 +112,7 @@ static Object P_Open_Font (d, name) Object d, name; {
    return Make_Font (DISPLAY(d)->dpy, name, p->fid, p);
 }
-void Open_Font_Maybe (f) Object f; {
+void Open_Font_Maybe (Object f) {
    Object name;
    XFontStruct *p;
@ -124,7 +127,7 @@ void Open_Font_Maybe (f) Object f; {
    }
 }
-Object P_Close_Font (f) Object f; {
+Object P_Close_Font (Object f) {
    Check_Type (f, T_Font);
    if (FONT(f)->id)
        XUnloadFont (FONT(f)->dpy, FONT(f)->id);
@ -133,12 +136,12 @@ Object P_Close_Font (f) Object f; {
    return Void;
 }
-static Object P_Font_Name (f) Object f; {
+static Object P_Font_Name (Object f) {
    Check_Type (f, T_Font);
    return FONT(f)->name;
 }
-static Object P_Gcontext_Font (g) Object g; {
+static Object P_Gcontext_Font (Object g) {
    register struct S_Gc *p;
    register XFontStruct *info;
@ -150,11 +153,11 @@ static Object P_Gcontext_Font (g) Object g; {
    return Make_Font_Foreign (p->dpy, False, (Font)0, info);
 }
-static Object Internal_List_Fonts (d, pat, with_info) Object d, pat; {
+static Object Internal_List_Fonts (Object d, Object pat, int with_info) {
    char **ret;
    int n;
    XFontStruct *iret;
-    register i;
+    register int i;
    Object f, v;
    Display *dpy;
    GC_Node2;
@ -184,24 +187,24 @@ static Object Internal_List_Fonts (d, pat, with_info) Object d, pat; {
    return v;
 }
-static Object P_List_Font_Names (d, pat) Object d, pat; {
+static Object P_List_Font_Names (Object d, Object pat) {
    return Internal_List_Fonts (d, pat, 0);
 }
-static Object P_List_Fonts (d, pat) Object d, pat; {
+static Object P_List_Fonts (Object d, Object pat) {
    return Internal_List_Fonts (d, pat, 1);
 }
-static Object P_Font_Info (f) Object f; {
+static Object P_Font_Info (Object f) {
    Check_Type (f, T_Font);
    FI = *FONT(f)->info;
    return Record_To_Vector (Font_Info_Rec, Font_Info_Size,
        Sym_Font_Info, FONT(f)->dpy, ~0L);
 }
-static Object P_Char_Info (f, index) Object f, index; {
+static Object P_Char_Info (Object f, Object index) {
-    register t = TYPE(index);
+    register int t = TYPE(index);
-    register unsigned i;
+    register unsigned int i;
    register XCharStruct *cp;
    register XFontStruct *p;
    char *msg = "argument must be integer, character, 'min, or 'max";
@ -227,7 +230,7 @@ static Object P_Char_Info (f, index) Object f, index; {
                Range_Error (index);
            i -= p->min_char_or_byte2;
        } else {
-            register unsigned b1 = i & 0xff, b2 = (i >> 8) & 0xff;
+            register unsigned int b1 = i & 0xff, b2 = (i >> 8) & 0xff;
            if (b1 < p->min_byte1 || b1 > p->max_byte1 ||
                    b2 < p->min_char_or_byte2 || b2 > p->max_char_or_byte2)
                Range_Error (index);
@ -243,8 +246,8 @@ static Object P_Char_Info (f, index) Object f, index; {
        Sym_Char_Info, FONT(f)->dpy, ~0L);
 }
-static Object P_Font_Properties (f) Object f; {
+static Object P_Font_Properties (Object f) {
-    register i, n;
+    register int i, n;
    Object v, a, val, x;
    GC_Node4;
@ -264,7 +267,7 @@ static Object P_Font_Properties (f) Object f; {
    return v;
 }
-static Object P_Font_Path (d) Object d; {
+static Object P_Font_Path (Object d) {
    Object v;
    int i, n;
    char **ret;
@ -287,9 +290,9 @@ static Object P_Font_Path (d) Object d; {
    return P_Vector_To_List (v);
 }
-static Object P_Set_Font_Path (d, p) Object d, p; {
+static Object P_Set_Font_Path (Object d, Object p) {
    register char **path;
-    register i, n;
+    register int i, n;
    Object c;
    Alloca_Begin;
@ -306,7 +309,7 @@ static Object P_Set_Font_Path (d, p) Object d, p; {
    return Void;
 }
-elk_init_xlib_font () {
+void elk_init_xlib_font () {
    Define_Symbol (&Sym_Font_Info, "font-info");
    Define_Symbol (&Sym_Char_Info, "char-info");
    Define_Symbol (&Sym_Min, "min");
--- a/lib/xlib/gcontext.c
+++ b/lib/xlib/gcontext.c
@ -40,7 +40,7 @@ Generic_Print (Gc, "#[gcontext %lu]", GCONTEXT(x)->gc)
 Generic_Get_Display (Gc, GCONTEXT)
-Object Make_Gc (finalize, dpy, g) Display *dpy; GC g; {
+Object Make_Gc (int finalize, Display *dpy, GC g) {
    Object gc;
    if (g == None)
@ -58,7 +58,7 @@ Object Make_Gc (finalize, dpy, g) Display *dpy; GC g; {
    return gc;
 }
-static Object P_Create_Gc (w, g) Object w, g; {
+static Object P_Create_Gc (Object w, Object g) {
    unsigned long mask;
    Display *dpy;
    Drawable dr;
@ -68,7 +68,7 @@ static Object P_Create_Gc (w, g) Object w, g; {
    return Make_Gc (1, dpy, XCreateGC (dpy, dr, mask, &GCV));
 }
-static Object P_Copy_Gc (gc, w) Object gc, w; {
+static Object P_Copy_Gc (Object gc, Object w) {
    GC dst;
    Display *dpy;
    Drawable dr;
@ -80,7 +80,7 @@ static Object P_Copy_Gc (gc, w) Object gc, w; {
    return Make_Gc (1, dpy, dst);
 }
-static Object P_Change_Gc (gc, g) Object gc, g; {
+static Object P_Change_Gc (Object gc, Object g) {
    unsigned long mask;
    Check_Type (gc, T_Gc);
@ -89,7 +89,7 @@ static Object P_Change_Gc (gc, g) Object gc, g; {
    return Void;
 }
-Object P_Free_Gc (g) Object g; {
+Object P_Free_Gc (Object g) {
    Check_Type (g, T_Gc);
    if (!GCONTEXT(g)->free)
        XFreeGC (GCONTEXT(g)->dpy, GCONTEXT(g)->gc);
@ -98,7 +98,7 @@ Object P_Free_Gc (g) Object g; {
    return Void;
 }
-static Object P_Query_Best_Size (d, w, h, shape) Object d, w, h, shape; {
+static Object P_Query_Best_Size (Object d, Object w, Object h, Object shape) {
    unsigned int rw, rh;
    Check_Type (d, T_Display);
@ -109,10 +109,10 @@ static Object P_Query_Best_Size (d, w, h, shape) Object d, w, h, shape; {
    return Cons (Make_Integer (rw), Make_Integer (rh));
 }
-static Object P_Set_Gcontext_Clip_Rectangles (gc, x, y, v, ord)
+static Object P_Set_Gcontext_Clip_Rectangles (Object gc, Object x, Object y,
-        Object gc, x, y, v, ord; {
+                                              Object v, Object ord) {
    register XRectangle *p;
-    register i, n;
+    register int i, n;
    Alloca_Begin;
    Check_Type (gc, T_Gc);
@ -137,9 +137,9 @@ static Object P_Set_Gcontext_Clip_Rectangles (gc, x, y, v, ord)
    return Void;
 }
-static Object P_Set_Gcontext_Dashlist (gc, off, v) Object gc, off, v; {
+static Object P_Set_Gcontext_Dashlist (Object gc, Object off, Object v) {
    register char *p;
-    register i, n, d;
+    register int i, n, d;
    Alloca_Begin;
    Check_Type (gc, T_Gc);
@ -164,7 +164,7 @@ static Object P_Set_Gcontext_Dashlist (gc, off, v) Object gc, off, v; {
    GCSubwindowMode | GCGraphicsExposures | GCClipXOrigin | GCClipYOrigin |\
    GCDashOffset | GCArcMode)
-static Object P_Get_Gc_Values (gc) Object gc; {
+static Object P_Get_Gc_Values (Object gc) {
    unsigned long mask = ValidGCValuesBits;
    Check_Type (gc, T_Gc);
@ -174,7 +174,7 @@ static Object P_Get_Gc_Values (gc) Object gc; {
        mask);
 }
-elk_init_xlib_gcontext () {
+void elk_init_xlib_gcontext () {
    Define_Symbol (&Sym_Gc, "gcontext");
    Generic_Define (Gc, "gcontext", "gcontext?");
    Define_Primitive (P_Gc_Display,      "gcontext-display",    1, 1, EVAL);
--- a/lib/xlib/grab.c
+++ b/lib/xlib/grab.c
@ -32,20 +32,20 @@
 static Object Sym_Any;
-Time Get_Time (time) Object time; {
+Time Get_Time (Object time) {
    if (EQ(time, Sym_Now))
        return CurrentTime;
    return (Time)Get_Long (time);
 }
-static Get_Mode (m) Object m; {
+static int Get_Mode (Object m) {
    Check_Type (m, T_Boolean);
    return EQ(m, True) ? GrabModeSync : GrabModeAsync;
 }
-static Object P_Grab_Pointer (win, ownerp, events, psyncp, ksyncp, confine_to,
+static Object P_Grab_Pointer (Object win, Object ownerp, Object events,
-        cursor, time) Object win, ownerp, events, psyncp, ksyncp, confine_to,
+                              Object psyncp, Object ksyncp, Object confine_to,
-        cursor, time; {
+                              Object cursor, Object time) {
    Check_Type (win, T_Window);
    Check_Type (ownerp, T_Boolean);
    return Bits_To_Symbols ((unsigned long)XGrabPointer (WINDOW(win)->dpy,
@ -56,15 +56,15 @@ static Object P_Grab_Pointer (win, ownerp, events, psyncp, ksyncp, confine_to,
        0, Grabstatus_Syms);
 }
-static Object P_Ungrab_Pointer (d, time) Object d, time; {
+static Object P_Ungrab_Pointer (Object d, Object time) {
    Check_Type (d, T_Display);
    XUngrabPointer (DISPLAY(d)->dpy, Get_Time (time));
    return Void;
 }
-static Object P_Grab_Button (win, button, mods, ownerp, events, psyncp, ksyncp,
+static Object P_Grab_Button (Object win, Object button, Object mods,
-        confine_to, cursor) Object win, button, mods, ownerp, events,
+                             Object ownerp, Object events, Object psyncp,
-        psyncp, ksyncp, confine_to, cursor; {
+                             Object ksyncp, Object confine_to, Object cursor) {
    Check_Type (win, T_Window);
    Check_Type (ownerp, T_Boolean);
    XGrabButton (WINDOW(win)->dpy, Symbols_To_Bits (button, 0, Button_Syms),
@ -75,23 +75,23 @@ static Object P_Grab_Button (win, button, mods, ownerp, events, psyncp, ksyncp,
    return Void;
 }
-static Object P_Ungrab_Button (win, button, mods) Object win, button, mods; {
+static Object P_Ungrab_Button (Object win, Object button, Object mods) {
    Check_Type (win, T_Window);
    XUngrabButton (WINDOW(win)->dpy, Symbols_To_Bits (button, 0, Button_Syms),
        Symbols_To_Bits (mods, 1, State_Syms), WINDOW(win)->win);
    return Void;
 }
-static Object P_Change_Active_Pointer_Grab (d, events, cursor, time)
+static Object P_Change_Active_Pointer_Grab (Object d, Object events,
-        Object d, events, cursor, time; {
+                                            Object cursor, Object time) {
    Check_Type (d, T_Display);
    XChangeActivePointerGrab (DISPLAY(d)->dpy, Symbols_To_Bits (events, 1,
        Event_Syms), Get_Cursor (cursor), Get_Time (time));
    return Void;
 }
-static Object P_Grab_Keyboard (win, ownerp, psyncp, ksyncp, time) Object win,
+static Object P_Grab_Keyboard (Object win, Object ownerp, Object psyncp,
-        ownerp, psyncp, ksyncp, time; {
+                               Object ksyncp, Object time) {
    Check_Type (win, T_Window);
    Check_Type (ownerp, T_Boolean);
    return Bits_To_Symbols ((unsigned long)XGrabKeyboard (WINDOW(win)->dpy,
@ -100,14 +100,14 @@ static Object P_Grab_Keyboard (win, ownerp, psyncp, ksyncp, time) Object win,
        0, Grabstatus_Syms);
 }
-static Object P_Ungrab_Keyboard (d, time) Object d, time; {
+static Object P_Ungrab_Keyboard (Object d, Object time) {
    Check_Type (d, T_Display);
    XUngrabKeyboard (DISPLAY(d)->dpy, Get_Time (time));
    return Void;
 }
-static Object P_Grab_Key (win, key, mods, ownerp, psyncp, ksyncp) Object win,
+static Object P_Grab_Key (Object win, Object key, Object mods, Object ownerp,
-        key, mods, ownerp, psyncp, ksyncp; {
+                          Object psyncp, Object ksyncp) {
    int keycode = AnyKey;
    Check_Type (win, T_Window);
@ -120,7 +120,7 @@ static Object P_Grab_Key (win, key, mods, ownerp, psyncp, ksyncp) Object win,
    return Void;
 }
-static Object P_Ungrab_Key (win, key, mods) Object win, key, mods; {
+static Object P_Ungrab_Key (Object win, Object key, Object mods) {
    int keycode = AnyKey;
    Check_Type (win, T_Window);
@ -131,26 +131,26 @@ static Object P_Ungrab_Key (win, key, mods) Object win, key, mods; {
    return Void;
 }
-static Object P_Allow_Events (d, mode, time) Object d, mode, time; {
+static Object P_Allow_Events (Object d, Object mode, Object time) {
    Check_Type (d, T_Display);
    XAllowEvents (DISPLAY(d)->dpy, Symbols_To_Bits (mode, 0,
        Allow_Events_Syms), Get_Time (time));
    return Void;
 }
-static Object P_Grab_Server (d) Object d; {
+static Object P_Grab_Server (Object d) {
    Check_Type (d, T_Display);
    XGrabServer (DISPLAY(d)->dpy);
    return Void;
 }
-static Object P_Ungrab_Server (d) Object d; {
+static Object P_Ungrab_Server (Object d) {
    Check_Type (d, T_Display);
    XUngrabServer (DISPLAY(d)->dpy);
    return Void;
 }
-elk_init_xlib_grab () {
+void elk_init_xlib_grab () {
    Define_Primitive (P_Grab_Pointer,    "grab-pointer",    8, 8, EVAL);
    Define_Primitive (P_Ungrab_Pointer,  "ungrab-pointer",  2, 2, EVAL);
    Define_Primitive (P_Grab_Button,     "grab-button",     9, 9, EVAL);
--- a/lib/xlib/graphics.c
+++ b/lib/xlib/graphics.c
@ -30,11 +30,12 @@
 #include "xlib.h"
-extern XDrawPoints(), XDrawLines(), XDrawRectangle(), XFillRectangle();
+extern int XDrawPoints(), XDrawLines(), XDrawRectangle(), XFillRectangle();
-extern XDrawRectangles(), XFillRectangles(), XDrawArc(), XFillArc();
+extern int XDrawRectangles(), XFillRectangles(), XDrawArc(), XFillArc();
-extern XDrawArcs(), XFillArcs(), XFillPolygon();
+extern int XDrawArcs(), XFillArcs(), XFillPolygon();
-static Object P_Clear_Area (win, x, y, w, h, e) Object win, x, y, w, h, e; {
+static Object P_Clear_Area (Object win, Object x, Object y, Object w, Object h,
                            Object e) {
    Check_Type (win, T_Window);
    Check_Type (e, T_Boolean);
    XClearArea (WINDOW(win)->dpy, WINDOW(win)->win, Get_Integer (x),
@ -42,8 +43,9 @@ static Object P_Clear_Area (win, x, y, w, h, e) Object win, x, y, w, h, e; {
    return Void;
 }
-static Object P_Copy_Area (src, gc, sx, sy, w, h, dst, dx, dy) Object src, gc,
+static Object P_Copy_Area (Object src, Object gc, Object sx, Object sy,
-        sx, sy, w, h, dst, dx, dy; {
+                           Object w, Object h, Object dst, Object dx,
                           Object dy) {
    Display *dpy;
    Drawable ddst = Get_Drawable (dst, &dpy), dsrc = Get_Drawable (src, &dpy);
@ -54,8 +56,9 @@ static Object P_Copy_Area (src, gc, sx, sy, w, h, dst, dx, dy) Object src, gc,
    return Void;
 }
-static Object P_Copy_Plane (src, gc, plane, sx, sy, w, h, dst, dx, dy)
+static Object P_Copy_Plane (Object src, Object gc, Object plane, Object sx,
-        Object src, gc, plane, sx, sy, w, h, dst, dx, dy; {
+                            Object sy, Object w, Object h, Object dst,
                            Object dx, Object dy) {
    Display *dpy;
    Drawable ddst = Get_Drawable (dst, &dpy), dsrc = Get_Drawable (src, &dpy);
    register unsigned long p;
@ -70,7 +73,7 @@ static Object P_Copy_Plane (src, gc, plane, sx, sy, w, h, dst, dx, dy)
    return Void;
 }
-static Object P_Draw_Point (d, gc, x, y) Object d, gc, x, y; {
+static Object P_Draw_Point (Object d, Object gc, Object x, Object y) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
@ -79,12 +82,13 @@ static Object P_Draw_Point (d, gc, x, y) Object d, gc, x, y; {
    return Void;
 }
-static Object Internal_Draw_Points (d, gc, v, relative, func, shape)
+static Object Internal_Draw_Points (Object d, Object gc, Object v,
-        Object d, gc, v, relative, shape; int (*func)(); {
+                                    Object relative,
                                    int (*func)(), Object shape) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
    register XPoint *p;
-    register i, n;
+    register int i, n;
    int rel, sh;
    Alloca_Begin;
@ -111,12 +115,12 @@ static Object Internal_Draw_Points (d, gc, v, relative, func, shape)
    return Void;
 }
-static Object P_Draw_Points (d, gc, v, relative) Object d, gc, v, relative; {
+static Object P_Draw_Points (Object d, Object gc, Object v, Object relative) {
    return Internal_Draw_Points (d, gc, v, relative, XDrawPoints, Null);
 }
-static Object P_Draw_Line (d, gc, x1, y1, x2, y2)
+static Object P_Draw_Line (Object d, Object gc, Object x1, Object y1,
-        Object d, gc, x1, y1, x2, y2; {
+                           Object x2, Object y2) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
@ -126,15 +130,15 @@ static Object P_Draw_Line (d, gc, x1, y1, x2, y2)
    return Void;
 }
-static Object P_Draw_Lines (d, gc, v, relative) Object d, gc, v, relative; {
+static Object P_Draw_Lines (Object d, Object gc, Object v, Object relative) {
    return Internal_Draw_Points (d, gc, v, relative, XDrawLines, Null);
 }
-static Object P_Draw_Segments (d, gc, v) Object d, gc, v; {
+static Object P_Draw_Segments (Object d, Object gc, Object v) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
    register XSegment *p;
-    register i, n;
+    register int i, n;
    Alloca_Begin;
    Check_Type (gc, T_Gc);
@ -157,8 +161,8 @@ static Object P_Draw_Segments (d, gc, v) Object d, gc, v; {
    return Void;
 }
-static Object Internal_Draw_Rectangle (d, gc, x, y, w, h, func)
+static Object Internal_Draw_Rectangle (Object d, Object gc, Object x, Object y,
-        Object d, gc, x, y, w, h; int (*func)(); {
+                                       Object w, Object h, int (*func)()) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
@ -168,20 +172,22 @@ static Object Internal_Draw_Rectangle (d, gc, x, y, w, h, func)
    return Void;
 }
-static Object P_Draw_Rectangle (d, gc, x, y, w, h) Object d, gc, x, y, w, h; {
+static Object P_Draw_Rectangle (Object d, Object gc, Object x, Object y,
                                Object w, Object h) {
    return Internal_Draw_Rectangle (d, gc, x, y, w, h, XDrawRectangle);
 }
-static Object P_Fill_Rectangle (d, gc, x, y, w, h) Object d, gc, x, y, w, h; {
+static Object P_Fill_Rectangle (Object d, Object gc, Object x, Object y,
                                Object w, Object h) {
    return Internal_Draw_Rectangle (d, gc, x, y, w, h, XFillRectangle);
 }
-static Object Internal_Draw_Rectangles (d, gc, v, func)
+static Object Internal_Draw_Rectangles (Object d, Object gc, Object v,
-        Object d, gc, v; int (*func)(); {
+                                        int (*func)()) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
    register XRectangle *p;
-    register i, n;
+    register int i, n;
    Alloca_Begin;
    Check_Type (gc, T_Gc);
@ -204,16 +210,17 @@ static Object Internal_Draw_Rectangles (d, gc, v, func)
    return Void;
 }
-static Object P_Draw_Rectangles (d, gc, v) Object d, gc, v; {
+static Object P_Draw_Rectangles (Object d, Object gc, Object v) {
    return Internal_Draw_Rectangles (d, gc, v, XDrawRectangles);
 }
-static Object P_Fill_Rectangles (d, gc, v) Object d, gc, v; {
+static Object P_Fill_Rectangles (Object d, Object gc, Object v) {
    return Internal_Draw_Rectangles (d, gc, v, XFillRectangles);
 }
-static Object Internal_Draw_Arc (d, gc, x, y, w, h, a1, a2, func)
+static Object Internal_Draw_Arc (Object d, Object gc, Object x, Object y,
-        Object d, gc, x, y, w, h, a1, a2; int (*func)(); {
+                                 Object w, Object h, Object a1, Object a2,
                                 int (*func)()) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
@ -223,22 +230,22 @@ static Object Internal_Draw_Arc (d, gc, x, y, w, h, a1, a2, func)
    return Void;
 }
-static Object P_Draw_Arc (d, gc, x, y, w, h, a1, a2)
+static Object P_Draw_Arc (Object d, Object gc, Object x, Object y, Object w,
-        Object d, gc, x, y, w, h, a1, a2; {
+                          Object h, Object a1, Object a2) {
    return Internal_Draw_Arc (d, gc, x, y, w, h, a1, a2, XDrawArc);
 }
-static Object P_Fill_Arc (d, gc, x, y, w, h, a1, a2)
+static Object P_Fill_Arc (Object d, Object gc, Object x, Object y, Object w,
-        Object d, gc, x, y, w, h, a1, a2; {
+                          Object h, Object a1, Object a2) {
    return Internal_Draw_Arc (d, gc, x, y, w, h, a1, a2, XFillArc);
 }
-static Object Internal_Draw_Arcs (d, gc, v, func) Object d, gc, v;
+static Object Internal_Draw_Arcs (Object d, Object gc, Object v,
-        int (*func)(); {
+                                  int (*func)()) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
    register XArc *p;
-    register i, n;
+    register int i, n;
    Alloca_Begin;
    Check_Type (gc, T_Gc);
@ -263,20 +270,20 @@ static Object Internal_Draw_Arcs (d, gc, v, func) Object d, gc, v;
    return Void;
 }
-static Object P_Draw_Arcs (d, gc, v) Object d, gc, v; {
+static Object P_Draw_Arcs (Object d, Object gc, Object v) {
    return Internal_Draw_Arcs (d, gc, v, XDrawArcs);
 }
-static Object P_Fill_Arcs (d, gc, v) Object d, gc, v; {
+static Object P_Fill_Arcs (Object d, Object gc, Object v) {
    return Internal_Draw_Arcs (d, gc, v, XFillArcs);
 }
-static Object P_Fill_Polygon (d, gc, v, relative, shape)
+static Object P_Fill_Polygon (Object d, Object gc, Object v, Object relative,
-        Object d, gc, v, relative, shape; {
+                              Object shape) {
    return Internal_Draw_Points (d, gc, v, relative, XFillPolygon, shape);
 }
-elk_init_xlib_graphics () {
+void elk_init_xlib_graphics () {
    Define_Primitive (P_Clear_Area,        "clear-area",       6, 6, EVAL);
    Define_Primitive (P_Copy_Area,         "copy-area",        9, 9, EVAL);
    Define_Primitive (P_Copy_Plane,        "copy-plane",      10,10, EVAL);
--- a/lib/xlib/key.c
+++ b/lib/xlib/key.c
@ -30,11 +30,13 @@
 #include "xlib.h"
 #include <string.h>
 #ifdef XLIB_RELEASE_5_OR_LATER
 /* I don't know if XDisplayKeycodes() was already there in X11R4.
 */
-static Object P_Display_Min_Keycode (d) Object d; {
+static Object P_Display_Min_Keycode (Object d) {
    int mink, maxk;
    Check_Type (d, T_Display);
@ -42,7 +44,7 @@ static Object P_Display_Min_Keycode (d) Object d; {
    return Make_Integer (mink);
 }
-static Object P_Display_Max_Keycode (d) Object d; {
+static Object P_Display_Max_Keycode (Object d) {
    int mink, maxk;
    Check_Type (d, T_Display);
@ -51,12 +53,12 @@ static Object P_Display_Max_Keycode (d) Object d; {
 }
 #else
-static Object P_Display_Min_Keycode (d) Object d; {
+static Object P_Display_Min_Keycode (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (DISPLAY(d)->dpy->min_keycode);
 }
-static Object P_Display_Max_Keycode (d) Object d; {
+static Object P_Display_Max_Keycode (Object d) {
    Check_Type (d, T_Display);
    return Make_Integer (DISPLAY(d)->dpy->max_keycode);
 }
@ -66,7 +68,7 @@ static Object P_Display_Max_Keycode (d) Object d; {
 /* I'm not sure if this works correctly in X11R4:
 */
-static Object P_Display_Keysyms_Per_Keycode (d) Object d; {
+static Object P_Display_Keysyms_Per_Keycode (Object d) {
    KeySym *ksyms;
    int mink, maxk, ksyms_per_kode;
@ -78,7 +80,7 @@ static Object P_Display_Keysyms_Per_Keycode (d) Object d; {
 }
 #else
-static Object P_Display_Keysyms_Per_Keycode (d) Object d; {
+static Object P_Display_Keysyms_Per_Keycode (Object d) {
    Check_Type (d, T_Display);
    /* Force initialization: */
    Disable_Interrupts;
@ -88,21 +90,21 @@ static Object P_Display_Keysyms_Per_Keycode (d) Object d; {
 }
 #endif
-static Object P_String_To_Keysym (s) Object s; {
+static Object P_String_To_Keysym (Object s) {
    KeySym k;
    k = XStringToKeysym (Get_Strsym (s));
    return k == NoSymbol ? False : Make_Unsigned_Long ((unsigned long)k);
 }
-static Object P_Keysym_To_String (k) Object k; {
+static Object P_Keysym_To_String (Object k) {
    register char *s;
    s = XKeysymToString ((KeySym)Get_Long (k));
    return s ? Make_String (s, strlen (s)) : False;
 }
-static Object P_Keycode_To_Keysym (d, k, index) Object d, k, index; {
+static Object P_Keycode_To_Keysym (Object d, Object k, Object index) {
    Object ret;
    Check_Type (d, T_Display);
@ -113,7 +115,7 @@ static Object P_Keycode_To_Keysym (d, k, index) Object d, k, index; {
    return ret;
 }
-static Object P_Keysym_To_Keycode (d, k) Object d, k; {
+static Object P_Keysym_To_Keycode (Object d, Object k) {
    Object ret;
    Check_Type (d, T_Display);
@ -124,10 +126,10 @@ static Object P_Keysym_To_Keycode (d, k) Object d, k; {
    return ret;
 }
-static Object P_Lookup_String (d, k, mask) Object d, k, mask; {
+static Object P_Lookup_String (Object d, Object k, Object mask) {
    XKeyEvent e;
    char buf[1024];
-    register len;
+    register int len;
    KeySym keysym_return;
    XComposeStatus status_return;
@ -141,9 +143,9 @@ static Object P_Lookup_String (d, k, mask) Object d, k, mask; {
    return Make_String (buf, len);
 }
-static Object P_Rebind_Keysym (d, k, mods, str) Object d, k, mods, str; {
+static Object P_Rebind_Keysym (Object d, Object k, Object mods, Object str) {
    KeySym *p;
-    register i, n;
+    register int i, n;
    Alloca_Begin;
    Check_Type (d, T_Display);
@ -159,7 +161,7 @@ static Object P_Rebind_Keysym (d, k, mods, str) Object d, k, mods, str; {
    return Void;
 }
-static Object P_Refresh_Keyboard_Mapping (w, event) Object w, event; {
+static Object P_Refresh_Keyboard_Mapping (Object w, Object event) {
    static XMappingEvent fake;
    Check_Type (w, T_Window);
@ -171,7 +173,7 @@ static Object P_Refresh_Keyboard_Mapping (w, event) Object w, event; {
    return Void;
 }
-elk_init_xlib_key () {
+void elk_init_xlib_key () {
    Define_Primitive (P_Display_Min_Keycode, "display-min-keycode",
                                                              1, 1, EVAL);
    Define_Primitive (P_Display_Max_Keycode, "display-max-keycode",
--- a/lib/xlib/pixel.c
+++ b/lib/xlib/pixel.c
@ -36,7 +36,7 @@ Generic_Simple_Equal (Pixel, PIXEL, pix)
 Generic_Print (Pixel, "#[pixel 0x%lx]", PIXEL(x)->pix)
-Object Make_Pixel (val) unsigned long val; {
+Object Make_Pixel (unsigned long val) {
    Object pix;
    pix = Find_Object (T_Pixel, (GENERIC)0, Match_X_Obj, val);
@ -49,28 +49,28 @@ Object Make_Pixel (val) unsigned long val; {
    return pix;
 }
-unsigned long Get_Pixel (p) Object p; {
+unsigned long Get_Pixel (Object p) {
    Check_Type (p, T_Pixel);
    return PIXEL(p)->pix;
 }
-static Object P_Pixel_Value (p) Object p; {
+static Object P_Pixel_Value (Object p) {
    return Make_Unsigned_Long (Get_Pixel (p));
 }
-static Object P_Black_Pixel (d) Object d; {
+static Object P_Black_Pixel (Object d) {
    Check_Type (d, T_Display);
    return Make_Pixel (BlackPixel (DISPLAY(d)->dpy,
        DefaultScreen (DISPLAY(d)->dpy)));
 }
-static Object P_White_Pixel (d) Object d; {
+static Object P_White_Pixel (Object d) {
    Check_Type (d, T_Display);
    return Make_Pixel (WhitePixel (DISPLAY(d)->dpy,
        DefaultScreen (DISPLAY(d)->dpy)));
 }
-elk_init_xlib_pixel () {
+void elk_init_xlib_pixel () {
    Generic_Define (Pixel, "pixel", "pixel?");
    Define_Primitive (P_Pixel_Value,   "pixel-value",    1, 1, EVAL);
    Define_Primitive (P_Black_Pixel,   "black-pixel",    1, 1, EVAL);
--- a/lib/xlib/pixmap.c
+++ b/lib/xlib/pixmap.c
@ -38,8 +38,7 @@ Generic_Print (Pixmap, "#[pixmap %lu]", PIXMAP(x)->pm)
 Generic_Get_Display (Pixmap, PIXMAP)
-static Object Internal_Make_Pixmap (finalize, dpy, pix)
+static Object Internal_Make_Pixmap (int finalize, Display *dpy, Pixmap pix) {
        Display *dpy; Pixmap pix; {
    Object pm;
    if (pix == None)
@ -58,20 +57,20 @@ static Object Internal_Make_Pixmap (finalize, dpy, pix)
 }
 /* Backwards compatibility: */
-Object Make_Pixmap (dpy, pix) Display *dpy; Pixmap pix; {
+Object Make_Pixmap (Display *dpy, Pixmap pix) {
    return Internal_Make_Pixmap (1, dpy, pix);
 }
-Object Make_Pixmap_Foreign (dpy, pix) Display *dpy; Pixmap pix; {
+Object Make_Pixmap_Foreign (Display *dpy, Pixmap pix) {
    return Internal_Make_Pixmap (0, dpy, pix);
 }
-Pixmap Get_Pixmap (p) Object p; {
+Pixmap Get_Pixmap (Object p) {
    Check_Type (p, T_Pixmap);
    return PIXMAP(p)->pm;
 }
-Object P_Free_Pixmap (p) Object p; {
+Object P_Free_Pixmap (Object p) {
    Check_Type (p, T_Pixmap);
    if (!PIXMAP(p)->free)
        XFreePixmap (PIXMAP(p)->dpy, PIXMAP(p)->pm);
@ -80,7 +79,7 @@ Object P_Free_Pixmap (p) Object p; {
    return Void;
 }
-static Object P_Create_Pixmap (d, w, h, depth) Object d, w, h, depth; {
+static Object P_Create_Pixmap (Object d, Object w, Object h, Object depth) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
@ -88,9 +87,9 @@ static Object P_Create_Pixmap (d, w, h, depth) Object d, w, h, depth; {
        Get_Integer (h), Get_Integer (depth)));
 }
-static Object P_Create_Bitmap_From_Data (win, data, pw, ph)
+static Object P_Create_Bitmap_From_Data (Object win, Object data, Object pw,
-        Object win, data, pw, ph; {
+                                         Object ph) {
-    register w, h;
+    register int w, h;
    Check_Type (win, T_Window);
    Check_Type (data, T_String);
@ -103,9 +102,11 @@ static Object P_Create_Bitmap_From_Data (win, data, pw, ph)
            STRING(data)->data, w, h));
 }
-static Object P_Create_Pixmap_From_Bitmap_Data (win, data, pw, ph, fg, bg,
+static Object P_Create_Pixmap_From_Bitmap_Data (Object win, Object data,
-        depth) Object win, data, pw, ph, fg, bg, depth; {
+                                                Object pw, Object ph,
-    register w, h;
+                                                Object fg, Object bg,
                                                Object depth) {
    register int w, h;
    Check_Type (win, T_Window);
    Check_Type (data, T_String);
@ -119,7 +120,7 @@ static Object P_Create_Pixmap_From_Bitmap_Data (win, data, pw, ph, fg, bg,
                Get_Integer (depth)));
 }
-static Object P_Read_Bitmap_File (d, fn) Object d, fn; {
+static Object P_Read_Bitmap_File (Object d, Object fn) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
    unsigned width, height;
@ -146,7 +147,7 @@ static Object P_Read_Bitmap_File (d, fn) Object d, fn; {
    return ret;
 }
-static Object P_Write_Bitmap_File (argc, argv) Object *argv; {
+static Object P_Write_Bitmap_File (int argc, Object *argv) {
    Pixmap pm;
    int ret, xhot = -1, yhot = -1;
@ -164,7 +165,7 @@ static Object P_Write_Bitmap_File (argc, argv) Object *argv; {
    return Bits_To_Symbols ((unsigned long)ret, 0, Bitmapstatus_Syms);
 }
-elk_init_xlib_pixmap () {
+void elk_init_xlib_pixmap () {
    Generic_Define (Pixmap, "pixmap", "pixmap?");
    Define_Primitive (P_Pixmap_Display,    "pixmap-display",    1, 1, EVAL);
    Define_Primitive (P_Free_Pixmap,       "free-pixmap",       1, 1, EVAL);
--- a/lib/xlib/property.c
+++ b/lib/xlib/property.c
@ -30,6 +30,8 @@
 #include "xlib.h"
 #include <string.h>
 Object Sym_Now;
 Generic_Predicate (Atom)
@ -38,7 +40,7 @@ Generic_Simple_Equal (Atom, ATOM, atom)
 Generic_Print (Atom, "#[atom %lu]", ATOM(x)->atom)
-Object Make_Atom (a) Atom a; {
+Object Make_Atom (Atom a) {
    Object atom;
    if (a == None)
@ -54,21 +56,21 @@ Object Make_Atom (a) Atom a; {
 }
 /* Should be used with care */
-static Object P_Make_Atom (n) Object n; {
+static Object P_Make_Atom (Object n) {
    return Make_Atom ((Atom)Get_Long (n));
 }
-static Object P_Intern_Atom (d, name) Object d, name; {
+static Object P_Intern_Atom (Object d, Object name) {
    Check_Type (d, T_Display);
    return Make_Atom (XInternAtom (DISPLAY(d)->dpy, Get_Strsym (name), 0));
 }
-static Object P_Find_Atom (d, name) Object d, name; {
+static Object P_Find_Atom (Object d, Object name) {
    Check_Type (d, T_Display);
    return Make_Atom (XInternAtom (DISPLAY(d)->dpy, Get_Strsym (name), 1));
 }
-static Object P_Atom_Name (d, a) Object d, a; {
+static Object P_Atom_Name (Object d, Object a) {
    register char *s;
    Check_Type (d, T_Display);
@ -79,8 +81,8 @@ static Object P_Atom_Name (d, a) Object d, a; {
    return Make_String (s, strlen (s));
 }
-static Object P_List_Properties (w) Object w; {
+static Object P_List_Properties (Object w) {
-    register i;
+    register int i;
    int n;
    register Atom *ap;
    Object v;
@ -103,14 +105,14 @@ static Object P_List_Properties (w) Object w; {
    return v;
 }
-static Object P_Get_Property (w, prop, type, start, len, deletep)
+static Object P_Get_Property (Object w, Object prop, Object type, Object start,
-        Object w, prop, type, start, len, deletep; {
+                              Object len, Object deletep) {
    Atom req_type = AnyPropertyType, actual_type;
    int format;
    unsigned long nitems, bytes_left;
    unsigned char *data;
    Object ret, t, x;
-    register i;
+    register unsigned int i;
    GC_Node2;
    Check_Type (w, T_Window);
@ -162,9 +164,9 @@ static Object P_Get_Property (w, prop, type, start, len, deletep)
    return ret;
 }
-static Object P_Change_Property (w, prop, type, format, mode, data)
+static Object P_Change_Property (Object w, Object prop, Object type,
-        Object w, prop, type, format, mode, data; {
+                                 Object format, Object mode, Object data) {
-    register i, m, x, nitems, f;
+    register int i, m, x, nitems, f;
    char *buf;
    Alloca_Begin;
@ -200,16 +202,16 @@ static Object P_Change_Property (w, prop, type, format, mode, data)
    return Void;
 }
-static Object P_Delete_Property (w, prop) Object w, prop; {
+static Object P_Delete_Property (Object w, Object prop) {
    Check_Type (w, T_Window);
    Check_Type (prop, T_Atom);
    XDeleteProperty (WINDOW(w)->dpy, WINDOW(w)->win, ATOM(prop)->atom);
    return Void;
 }
-static Object P_Rotate_Properties (w, v, delta) Object w, v, delta; {
+static Object P_Rotate_Properties (Object w, Object v, Object delta) {
    Atom *p;
-    register i, n;
+    register int i, n;
    Alloca_Begin;
    Check_Type (w, T_Window);
@ -229,8 +231,8 @@ static Object P_Rotate_Properties (w, v, delta) Object w, v, delta; {
    return Void;
 }
-static Object P_Set_Selection_Owner (d, s, owner, time) Object d, s, owner,
+static Object P_Set_Selection_Owner (Object d, Object s, Object owner,
-        time; {
+                                     Object time) {
    Check_Type (d, T_Display);
    Check_Type (s, T_Atom);
    XSetSelectionOwner (DISPLAY(d)->dpy, ATOM(s)->atom, Get_Window (owner),
@ -238,15 +240,15 @@ static Object P_Set_Selection_Owner (d, s, owner, time) Object d, s, owner,
    return Void;
 }
-static Object P_Selection_Owner (d, s) Object d, s; {
+static Object P_Selection_Owner (Object d, Object s) {
    Check_Type (d, T_Display);
    Check_Type (s, T_Atom);
    return Make_Window (0, DISPLAY(d)->dpy,
        XGetSelectionOwner (DISPLAY(d)->dpy, ATOM(s)->atom));
 }
-static Object P_Convert_Selection (s, target, prop, w, time)
+static Object P_Convert_Selection (Object s, Object target, Object prop,
-        Object s, target, prop, w, time; {
+                                   Object w, Object time) {
    Atom p = None;
    Check_Type (s, T_Atom);
@ -261,7 +263,7 @@ static Object P_Convert_Selection (s, target, prop, w, time)
    return Void;
 }
-elk_init_xlib_property () {
+void elk_init_xlib_property () {
    Define_Symbol (&Sym_Now, "now");
    Generic_Define (Atom, "atom", "atom?");
    Define_Primitive (P_Make_Atom,         "make-atom",          1, 1, EVAL);
--- a/lib/xlib/text.c
+++ b/lib/xlib/text.c
@ -30,10 +30,10 @@
 #include "xlib.h"
-extern XDrawText(), XDrawText16();
+extern int XDrawText(), XDrawText16();
 static Object Sym_1byte, Sym_2byte;
-static Two_Byte (format) Object format; {
+static int Two_Byte (Object format) {
    Check_Type (format, T_Symbol);
    if (EQ(format, Sym_1byte))
        return 0;
@ -41,17 +41,18 @@ static Two_Byte (format) Object format; {
        return 1;
    Primitive_Error ("index format must be '1-byte or '2-byte");
    /*NOTREACHED*/
    return 0;
 }
-static Get_1_Byte_Char (x) Object x; {
+static int Get_1_Byte_Char (Object x) {
-    register c = Get_Integer (x);
+    register int c = Get_Integer (x);
    if (c < 0 || c > 255)
        Range_Error (x);
    return c;
 }
-static Get_2_Byte_Char (x) Object x; {
+static int Get_2_Byte_Char (Object x) {
-    register c = Get_Integer (x);
+    register int c = Get_Integer (x);
    if (c < 0 || c > 65535)
        Range_Error (x);
    return c;
@ -63,12 +64,13 @@ static Get_2_Byte_Char (x) Object x; {
 * long strings.
 */
-static Object Internal_Text_Metrics (font, t, f, width) Object font, t, f; {
+static Object Internal_Text_Metrics (Object font, Object t, Object f,
                                     int width) {
    char *s;
    XChar2b *s2;
    XFontStruct *info;
    Object *data;
-    register i, n;
+    register int i, n;
    int dir, fasc, fdesc;
    Alloca_Begin;
@ -80,7 +82,7 @@ static Object Internal_Text_Metrics (font, t, f, width) Object font, t, f; {
    if (Two_Byte (f)) {
        Alloca (s2, XChar2b*, n * sizeof (XChar2b));
        for (i = 0; i < n; i++) {
-            register c = Get_2_Byte_Char (data[i]);
+            register int c = Get_2_Byte_Char (data[i]);
            s2[i].byte1 = (c >> 8) & 0xff;
            s2[i].byte2 = c & 0xff;
        }
@ -102,19 +104,20 @@ static Object Internal_Text_Metrics (font, t, f, width) Object font, t, f; {
        Char_Info_Size, Sym_Char_Info, FONT(font)->dpy, ~0L);
 }
-static Object P_Text_Width (font, t, f) Object font, t, f; {
+static Object P_Text_Width (Object font, Object t, Object f) {
    return Internal_Text_Metrics (font, t, f, 1);
 }
-static Object P_Text_Extents (font, t, f) Object font, t, f; {
+static Object P_Text_Extents (Object font, Object t, Object f) {
    return Internal_Text_Metrics (font, t, f, 0);
 }
-static Object P_Draw_Image_Text (d, gc, x, y, t, f) Object d, gc, x, y, t, f; {
+static Object P_Draw_Image_Text (Object d, Object gc, Object x, Object y,
                                 Object t, Object f) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
    Object *data;
-    register i, n;
+    register int i, n;
    char *s;
    XChar2b *s2;
    Alloca_Begin;
@ -126,7 +129,7 @@ static Object P_Draw_Image_Text (d, gc, x, y, t, f) Object d, gc, x, y, t, f; {
    if (Two_Byte (f)) {
        Alloca (s2, XChar2b*, n * sizeof (XChar2b));
        for (i = 0; i < n; i++) {
-            register c = Get_2_Byte_Char (data[i]);
+            register int c = Get_2_Byte_Char (data[i]);
            s2[i].byte1 = (c >> 8) & 0xff;
            s2[i].byte2 = c & 0xff;
        }
@ -143,11 +146,12 @@ static Object P_Draw_Image_Text (d, gc, x, y, t, f) Object d, gc, x, y, t, f; {
    return Void;
 }
-static Object P_Draw_Poly_Text (d, gc, x, y, t, f) Object d, gc, x, y, t, f; {
+static Object P_Draw_Poly_Text (Object d, Object gc, Object x, Object y,
                                Object t, Object f) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
    Object *data;
-    register i, n, j, k;
+    register int i, n, j, k;
    int twobyte, nitems;
    XTextItem *items;
    int (*func)();
@ -173,7 +177,7 @@ static Object P_Draw_Poly_Text (d, gc, x, y, t, f) Object d, gc, x, y, t, f; {
                Alloca (p, XChar2b*, (i-k) * sizeof (XChar2b));
                ((XTextItem16 *)items)[j].chars = p;
                for ( ; k < i; k++, p++) {
-                    register c = Get_2_Byte_Char (data[k]);
+                    register int c = Get_2_Byte_Char (data[k]);
                    p->byte1 = (c >> 8) & 0xff;
                    p->byte2 = c & 0xff;
                }
@ -200,7 +204,7 @@ static Object P_Draw_Poly_Text (d, gc, x, y, t, f) Object d, gc, x, y, t, f; {
    return Void;
 }
-elk_init_xlib_text () {
+void elk_init_xlib_text () {
    Define_Primitive (P_Text_Width,       "text-width",        3, 3, EVAL);
    Define_Primitive (P_Text_Extents,     "xlib-text-extents", 3, 3, EVAL);
    Define_Primitive (P_Draw_Image_Text,  "draw-image-text",   6, 6, EVAL);
--- a/lib/xlib/type.c
+++ b/lib/xlib/type.c
@ -299,8 +299,8 @@ RECORD Size_Hints_Rec[] = {
 };
 int Size_Hints_Size = sizeof Size_Hints_Rec / sizeof (RECORD);
-unsigned long Vector_To_Record (v, len, sym, rp) Object v, sym;
+unsigned long Vector_To_Record (Object v, int len, Object sym,
-        register RECORD *rp; {
+                                register RECORD *rp) {
    register Object *p;
    unsigned long mask = 0;
@ -365,9 +365,9 @@ unsigned long Vector_To_Record (v, len, sym, rp) Object v, sym;
    return mask;
 }
-Object Record_To_Vector (rp, len, sym, dpy, flags) Object sym;
+Object Record_To_Vector (register RECORD *rp, int len, Object sym,
-        register RECORD *rp; Display *dpy; unsigned long flags; {
+                         Display *dpy, unsigned long flags) {
-    register i;
+    register int i;
    Object v, x;
    GC_Node2;
@ -391,13 +391,13 @@ Object Record_To_Vector (rp, len, sym, dpy, flags) Object sym;
        case T_PIXEL:
            x = Make_Pixel (*(unsigned long *)rp->slot); break;
        case T_PIXMAP:
-            if (*(unsigned long *)rp->slot == ~0L)
+            if (*(unsigned long *)rp->slot == ~0UL)
                x = Sym_None;
            else
                x = Make_Pixmap_Foreign (dpy, *(Pixmap *)rp->slot);
            break;
        case T_FONT:
-            if (*(unsigned long *)rp->slot == ~0L)
+            if (*(unsigned long *)rp->slot == ~0UL)
                x = Sym_None;
            else {
                register XFontStruct *info;
@ -793,10 +793,9 @@ SYMDESCR Error_Syms[] = {
    { 0, 0 }
 };
-static Init_Record (rec, size, name, var) RECORD *rec; char *name;
+static void Init_Record (RECORD *rec, int size, char *name, Object *var) {
        Object *var; {
    Object list, tail, cell;
-    register i;
+    register int i;
    char buf[128];
    GC_Node2;
@ -815,7 +814,7 @@ static Init_Record (rec, size, name, var) RECORD *rec; char *name;
    GC_Unlink;
 }
-elk_init_xlib_type () {
+void elk_init_xlib_type () {
    Init_Record (Set_Attr_Rec, Set_Attr_Size, "set-window-attributes",
        &Set_Attr_Slots);
    Init_Record (Conf_Rec, Conf_Size, "window-configuration", &Conf_Slots);
--- a/lib/xlib/util.c
+++ b/lib/xlib/util.c
@ -30,17 +30,20 @@
 #include "xlib.h"
-static Object P_Get_Default (d, program, option) Object d, program, option; {
+#include <string.h>
 static Object P_Get_Default (Object d, Object program, Object option) {
    register char *ret;
    Check_Type (d, T_Display);
-    if (ret = XGetDefault (DISPLAY(d)->dpy, Get_Strsym (program),
+    ret = XGetDefault (DISPLAY(d)->dpy, Get_Strsym (program),
-            Get_Strsym (option)))
+                       Get_Strsym (option));
    if (ret)
        return Make_String (ret, strlen (ret));
    return False;
 }
-static Object P_Resource_Manager_String (d) Object d; {
+static Object P_Resource_Manager_String (Object d) {
    register char *ret;
    Check_Type (d, T_Display);
@ -48,9 +51,9 @@ static Object P_Resource_Manager_String (d) Object d; {
    return ret ? Make_String (ret, strlen (ret)) : False;
 }
-static Object P_Parse_Geometry (string) Object string; {
+static Object P_Parse_Geometry (Object string) {
    Object ret, t;
-    register mask;
+    register int mask;
    int x, y;
    unsigned w, h;
@ -65,7 +68,7 @@ static Object P_Parse_Geometry (string) Object string; {
    return ret;
 }
-static Object P_Parse_Color (d, cmap, spec) Object d, cmap, spec; {
+static Object P_Parse_Color (Object d, Object cmap, Object spec) {
    XColor ret;
    Check_Type (d, T_Display);
@ -75,7 +78,7 @@ static Object P_Parse_Color (d, cmap, spec) Object d, cmap, spec; {
    return False;
 }
-elk_init_xlib_util () {
+void elk_init_xlib_util () {
    Define_Primitive (P_Get_Default,       "get-default",         3, 3, EVAL);
    Define_Primitive (P_Resource_Manager_String,
                        "resource-manager-string",                1, 1, EVAL);
--- a/lib/xlib/window.c
+++ b/lib/xlib/window.c
@ -41,7 +41,7 @@ Generic_Print (Window, "#[window %lu]", WINDOW(x)->win)
 Generic_Get_Display (Window, WINDOW)
-Object Make_Window (finalize, dpy, win) Display *dpy; Window win; {
+Object Make_Window (int finalize, Display *dpy, Window win) {
    Object w;
    if (win == None)
@ -62,14 +62,14 @@ Object Make_Window (finalize, dpy, win) Display *dpy; Window win; {
    return w;
 }
-Window Get_Window (w) Object w; {
+Window Get_Window (Object w) {
    if (EQ(w, Sym_None))
        return None;
    Check_Type (w, T_Window);
    return WINDOW(w)->win;
 }
-Drawable Get_Drawable (d, dpyp) Object d; Display **dpyp; {
+Drawable Get_Drawable (Object d, Display **dpyp) {
    if (TYPE(d) == T_Window) {
        *dpyp = WINDOW(d)->dpy;
        return (Drawable)WINDOW(d)->win;
@ -81,8 +81,9 @@ Drawable Get_Drawable (d, dpyp) Object d; Display **dpyp; {
    /*NOTREACHED*/
 }
-static Object P_Create_Window (parent, x, y, width, height, border_width, attr)
+static Object P_Create_Window (Object parent, Object x, Object y, Object width,
-        Object parent, x, y, width, height, border_width, attr; {
+                               Object height, Object border_width,
                               Object attr) {
    unsigned long mask;
    Window win;
@ -96,7 +97,7 @@ static Object P_Create_Window (parent, x, y, width, height, border_width, attr)
    return Make_Window (1, WINDOW(parent)->dpy, win);
 }
-static Object P_Configure_Window (w, conf) Object w, conf; {
+static Object P_Configure_Window (Object w, Object conf) {
    unsigned long mask;
    Check_Type (w, T_Window);
@ -105,7 +106,7 @@ static Object P_Configure_Window (w, conf) Object w, conf; {
    return Void;
 }
-static Object P_Change_Window_Attributes (w, attr) Object w, attr; {
+static Object P_Change_Window_Attributes (Object w, Object attr) {
    unsigned long mask;
    Check_Type (w, T_Window);
@ -114,14 +115,14 @@ static Object P_Change_Window_Attributes (w, attr) Object w, attr; {
    return Void;
 }
-static Object P_Get_Window_Attributes (w) Object w; {
+static Object P_Get_Window_Attributes (Object w) {
    Check_Type (w, T_Window);
    XGetWindowAttributes (WINDOW(w)->dpy, WINDOW(w)->win, &WA);
    return Record_To_Vector (Win_Attr_Rec, Win_Attr_Size, Sym_Get_Attr,
        WINDOW(w)->dpy, ~0L);
 }
-static Object P_Get_Geometry (d) Object d; {
+static Object P_Get_Geometry (Object d) {
    Display *dpy;
    Drawable dr = Get_Drawable (d, &dpy);
@ -133,19 +134,19 @@ static Object P_Get_Geometry (d) Object d; {
    return Record_To_Vector (Geometry_Rec, Geometry_Size, Sym_Geo, dpy, ~0L);
 }
-static Object P_Map_Window (w) Object w; {
+static Object P_Map_Window (Object w) {
    Check_Type (w, T_Window);
    XMapWindow (WINDOW(w)->dpy, WINDOW(w)->win);
    return Void;
 }
-static Object P_Unmap_Window (w) Object w; {
+static Object P_Unmap_Window (Object w) {
    Check_Type (w, T_Window);
    XUnmapWindow (WINDOW(w)->dpy, WINDOW(w)->win);
    return Void;
 }
-Object P_Destroy_Window (w) Object w; {
+Object P_Destroy_Window (Object w) {
    Check_Type (w, T_Window);
    if (!WINDOW(w)->free)
        XDestroyWindow (WINDOW(w)->dpy, WINDOW(w)->win);
@ -154,36 +155,35 @@ Object P_Destroy_Window (w) Object w; {
    return Void;
 }
-static Object P_Destroy_Subwindows (w) Object w; {
+static Object P_Destroy_Subwindows (Object w) {
    Check_Type (w, T_Window);
    XDestroySubwindows (WINDOW(w)->dpy, WINDOW(w)->win);
    return Void;
 }
-static Object P_Map_Subwindows (w) Object w; {
+static Object P_Map_Subwindows (Object w) {
    Check_Type (w, T_Window);
    XMapSubwindows (WINDOW(w)->dpy, WINDOW(w)->win);
    return Void;
 }
-static Object P_Unmap_Subwindows (w) Object w; {
+static Object P_Unmap_Subwindows (Object w) {
    Check_Type (w, T_Window);
    XUnmapSubwindows (WINDOW(w)->dpy, WINDOW(w)->win);
    return Void;
 }
-static Object P_Circulate_Subwindows (w, dir) Object w, dir; {
+static Object P_Circulate_Subwindows (Object w, Object dir) {
    Check_Type (w, T_Window);
    XCirculateSubwindows (WINDOW(w)->dpy, WINDOW(w)->win,
        Symbols_To_Bits (dir, 0, Circulate_Syms));
    return Void;
 }
-static Object P_Query_Tree (w) Object w; {
+static Object P_Query_Tree (Object w) {
    Window root, parent, *children;
    Display *dpy;
-    int i;
+    unsigned int i, n;
    unsigned n;
    Object v, ret;
    GC_Node2;
@ -210,7 +210,8 @@ static Object P_Query_Tree (w) Object w; {
    return ret;
 }
-static Object P_Translate_Coordinates (src, x, y, dst) Object src, x, y, dst; {
+static Object P_Translate_Coordinates (Object src, Object x, Object y,
                                       Object dst) {
    int rx, ry;
    Window child;
    Object l, t, z;
@ -232,7 +233,7 @@ static Object P_Translate_Coordinates (src, x, y, dst) Object src, x, y, dst; {
    return l;
 }
-static Object P_Query_Pointer (win) Object win; {
+static Object P_Query_Pointer (Object win) {
    Object l, t, z;
    Bool ret;
    Window root, child;
@ -260,7 +261,7 @@ static Object P_Query_Pointer (win) Object win; {
    return l;
 }
-elk_init_xlib_window () {
+void elk_init_xlib_window () {
    Define_Symbol (&Sym_Set_Attr, "set-window-attributes");
    Define_Symbol (&Sym_Get_Attr, "get-window-attributes");
    Define_Symbol (&Sym_Conf, "window-configuration");
--- a/lib/xlib/wm.c
+++ b/lib/xlib/wm.c
@ -32,7 +32,8 @@
 static Object Sym_Pointer_Root;
-static Object P_Reparent_Window (w, parent, x, y) Object w, parent, x, y; {
+static Object P_Reparent_Window (Object w, Object parent, Object x,
                                 Object y) {
    Check_Type (w, T_Window);
    Check_Type (parent, T_Window);
    XReparentWindow (WINDOW(w)->dpy, WINDOW(w)->win, WINDOW(parent)->win,
@ -40,19 +41,19 @@ static Object P_Reparent_Window (w, parent, x, y) Object w, parent, x, y; {
    return Void;
 }
-static Object P_Install_Colormap (c) Object c; {
+static Object P_Install_Colormap (Object c) {
    Check_Type (c, T_Colormap);
    XInstallColormap (COLORMAP(c)->dpy, COLORMAP(c)->cm);
    return Void;
 }
-static Object P_Uninstall_Colormap (c) Object c; {
+static Object P_Uninstall_Colormap (Object c) {
    Check_Type (c, T_Colormap);
    XUninstallColormap (COLORMAP(c)->dpy, COLORMAP(c)->cm);
    return Void;
 }
-static Object P_List_Installed_Colormaps (w) Object w; {
+static Object P_List_Installed_Colormaps (Object w) {
    int i, n;
    Colormap *ret;
    Object v;
@ -73,8 +74,8 @@ static Object P_List_Installed_Colormaps (w) Object w; {
    return v;
 }
-static Object P_Set_Input_Focus (d, win, revert_to, time) Object d, win,
+static Object P_Set_Input_Focus (Object d, Object win, Object revert_to,
-    revert_to, time; {
+                                 Object time) {
    Window focus = PointerRoot;
    Check_Type (d, T_Display);
@ -85,7 +86,7 @@ static Object P_Set_Input_Focus (d, win, revert_to, time) Object d, win,
    return Void;
 }
-static Object P_Input_Focus (d) Object d; {
+static Object P_Input_Focus (Object d) {
    Window win;
    int revert_to;
    Object ret, x;
@ -103,8 +104,9 @@ static Object P_Input_Focus (d) Object d; {
    return ret;
 }
-static Object P_General_Warp_Pointer (dpy, dst, dstx, dsty, src, srcx, srcy,
+static Object P_General_Warp_Pointer (Object dpy, Object dst, Object dstx,
-        srcw, srch) Object dpy, dst, dstx, dsty, src, srcx, srcy, srcw, srch; {
+                                      Object dsty, Object src, Object srcx,
                                      Object srcy, Object srcw, Object srch) {
    Check_Type (dpy, T_Display);
    XWarpPointer (DISPLAY(dpy)->dpy, Get_Window (src), Get_Window (dst),
        Get_Integer (srcx), Get_Integer (srcy), Get_Integer (srcw),
@ -112,8 +114,8 @@ static Object P_General_Warp_Pointer (dpy, dst, dstx, dsty, src, srcx, srcy,
    return Void;
 }
-static Object P_Bell (argc, argv) Object *argv; {
+static Object P_Bell (int argc, Object *argv) {
-    register percent = 0;
+    register int percent = 0;
    Check_Type (argv[0], T_Display);
    if (argc == 2) {
@ -125,30 +127,30 @@ static Object P_Bell (argc, argv) Object *argv; {
    return Void;
 }
-static Object P_Set_Access_Control (dpy, on) Object dpy, on; {
+static Object P_Set_Access_Control (Object dpy, Object on) {
    Check_Type (dpy, T_Display);
    Check_Type (on, T_Boolean);
    XSetAccessControl (DISPLAY(dpy)->dpy, EQ(on, True));
    return Void;
 }
-static Object P_Change_Save_Set (win, mode) Object win, mode; {
+static Object P_Change_Save_Set (Object win, Object mode) {
    Check_Type (win, T_Window);
    XChangeSaveSet (WINDOW(win)->dpy, WINDOW(win)->win,
        Symbols_To_Bits (mode, 0, Saveset_Syms));
    return Void;
 }
-static Object P_Set_Close_Down_Mode (dpy, mode) Object dpy, mode; {
+static Object P_Set_Close_Down_Mode (Object dpy, Object mode) {
    Check_Type (dpy, T_Display);
    XSetCloseDownMode (DISPLAY(dpy)->dpy,
        Symbols_To_Bits (mode, 0, Closemode_Syms));
    return Void;
 }
-static Object P_Get_Pointer_Mapping (dpy) Object dpy; {
+static Object P_Get_Pointer_Mapping (Object dpy) {
    unsigned char map[256];
-    register i, n;
+    register int i, n;
    Object ret;
    Check_Type (dpy, T_Display);
@ -159,8 +161,8 @@ static Object P_Get_Pointer_Mapping (dpy) Object dpy; {
    return ret;
 }
-static Object P_Set_Pointer_Mapping (dpy, map) Object dpy, map; {
+static Object P_Set_Pointer_Mapping (Object dpy, Object map) {
-    register i, n;
+    register int i, n;
    register unsigned char *p;
    Object ret;
    Alloca_Begin;
@ -177,7 +179,7 @@ static Object P_Set_Pointer_Mapping (dpy, map) Object dpy, map; {
    return ret;
 }
-elk_init_xlib_wm () {
+void elk_init_xlib_wm () {
    Define_Primitive (P_Reparent_Window,  "reparent-window",  4, 4, EVAL);
    Define_Primitive (P_Install_Colormap, "install-colormap", 1, 1, EVAL);
    Define_Primitive (P_Uninstall_Colormap,
--- a/lib/xlib/xerror.c
+++ b/lib/xlib/xerror.c
@ -30,13 +30,15 @@
 #include "xlib.h"
 #include <stdlib.h>
 static Object V_X_Error_Handler, V_X_Fatal_Error_Handler;
 /* Default error handlers of the Xlib */
 extern int _XDefaultIOError();
 extern int _XDefaultError();
-static X_Fatal_Error (d) Display *d; {
+static int X_Fatal_Error (Display *d) {
    Object args, fun;
    GC_Node;
@ -51,9 +53,10 @@ static X_Fatal_Error (d) Display *d; {
    _XDefaultIOError (d);
    exit (1);         /* In case the default handler doesn't exit() */
    /*NOTREACHED*/
    return 0;
 }
-static X_Error (d, ep) Display *d; XErrorEvent *ep; {
+static int X_Error (Display *d, XErrorEvent *ep) {
    Object args, a, fun;
    GC_Node;
@ -79,9 +82,10 @@ static X_Error (d, ep) Display *d; XErrorEvent *ep; {
        (void)Funcall (fun, args, 0);
    else
        _XDefaultError (d, ep);
    return 0;
 }
-static X_After_Function (d) Display *d; {
+static int X_After_Function (Display *d) {
    Object args;
    GC_Node;
@ -90,9 +94,10 @@ static X_After_Function (d) Display *d; {
    args = Cons (args, Null);
    GC_Unlink;
    (void)Funcall (DISPLAY(Car (args))->after, args, 0);
    return 0;
 }
-static Object P_Set_After_Function (d, f) Object d, f; {
+static Object P_Set_After_Function (Object d, Object f) {
    Object old;
    Check_Type (d, T_Display);
@ -107,12 +112,12 @@ static Object P_Set_After_Function (d, f) Object d, f; {
    return old;
 }
-static Object P_After_Function (d) Object d; {
+static Object P_After_Function (Object d) {
    Check_Type (d, T_Display);
    return DISPLAY(d)->after;
 }
-elk_init_xlib_error () {
+void elk_init_xlib_error () {
    Define_Variable (&V_X_Fatal_Error_Handler, "x-fatal-error-handler", Null);
    Define_Variable (&V_X_Error_Handler, "x-error-handler", Null);
    (void)XSetIOErrorHandler (X_Fatal_Error);
--- a/lib/xlib/xinit.c
+++ b/lib/xlib/xinit.c
@ -50,7 +50,7 @@ static Object P_Xlib_Release_6_Or_Laterp () {
 #endif
 }
-elk_init_xlib_init () {
+void elk_init_xlib_init () {
    Define_Primitive (P_Xlib_Release_4_Or_Laterp,
                        "xlib-release-4-or-later?",               0, 0, EVAL);
    Define_Primitive (P_Xlib_Release_5_Or_Laterp,
--- a/lib/xlib/xlib.h
+++ b/lib/xlib/xlib.h
@ -242,54 +242,54 @@ extern Object Sym_None, Sym_Now, Sym_Char_Info, Sym_Conf;
 *
 *   int T_Pixmap;
 *
- *   static Object P_Pixmapp (x) Object x; {
+ *   static Object P_Pixmapp (Object x) {
 *        return TYPE(x) == T_Pixmap ? True : False;
 *   }
 */
 #define Generic_Predicate(type) int conc(T_,type);\
 \
-static Object conc3(P_,type,p) (x) Object x; {\
+static Object conc3(P_,type,p) (Object x) {\
    return TYPE(x) == conc(T_,type) ? True : False;\
 }
 /* Generic_Equal (Pixmap, PIXMAP, pm) generates:
 *
- *    static Pixmap_Equal (x, y) Object x, y; {
+ *    static Pixmap_Equal (Object x, Object y) {
 *        return PIXMAP(x)->pm == PIXMAP(y)->field
 *            && !PIXMAP(x)->free && !PIXMAP(y)->free;
 *    }
 */
-#define Generic_Equal(type,cast,field) static conc(type,_Equal) (x, y)\
+#define Generic_Equal(type,cast,field) static int conc(type,_Equal)\
-        Object x, y; {\
+            (Object x, Object y) {\
    return cast(x)->field == cast(y)->field\
        && !cast(x)->free && !cast(y)->free;\
 }
 /* Same as above, but doesn't check for ->free:
 */
-#define Generic_Simple_Equal(type,cast,field) static conc(type,_Equal) (x, y)\
+#define Generic_Simple_Equal(type,cast,field) static int conc(type,_Equal)\
-        Object x, y; {\
+            (Object x, Object y) {\
    return cast(x)->field == cast(y)->field;\
 }
 /* Same as above, but also checks ->dpy
 */
-#define Generic_Equal_Dpy(type,cast,field) static conc(type,_Equal)\
+#define Generic_Equal_Dpy(type,cast,field) static int conc(type,_Equal)\
-            (x, y)\
+            (Object x, Object y) {\
        Object x, y; {\
    return cast(x)->field == cast(y)->field && cast(x)->dpy == cast(y)->dpy\
        && !cast(x)->free && !cast(y)->free;\
 }
 /* Generic_Print (Pixmap, "#[pixmap %u]", PIXMAP(x)->pm) generates:
 *
- *    static Pixmap_Print (x, port, raw, depth, len) Object x, port; {
+ *    static Pixmap_Print (Object x, Object port, int raw, int depth, int len) {
 *        Printf (port, "#[pixmap %u]", PIXMAP(x)->pm);
 *    }
 */
-#define Generic_Print(type,fmt,how) static conc(type,_Print)\
+#define Generic_Print(type,fmt,how) static int conc(type,_Print)\
-        (x, port, raw, depth, len) Object x, port; {\
+            (Object x, Object port, int raw, int depth, int len) {\
    Printf (port, fmt, (unsigned)how);\
    return 0;\
 }
 /* Generic_Define (Pixmap, "pixmap", "pixmap?") generates:
@ -305,13 +305,13 @@ static Object conc3(P_,type,p) (x) Object x; {\
 /* Generic_Get_Display (Pixmap, PIXMAP) generates:
 *
- *    static Object P_Pixmap_Display (x) Object x; {
+ *    static Object P_Pixmap_Display (Object x) {
 *        Check_Type (x, T_Pixmap);
 *        return Make_Display (PIXMAP(x)->dpy);
 *    }
 */
 #define Generic_Get_Display(type,cast) static Object conc3(P_,type,_Display)\
-        (x) Object x; {\
+            (Object x) {\
    Check_Type (x, conc(T_,type));\
    return Make_Display (0, cast(x)->dpy);\
 }
--- a/lib/xlib/xobjects.c
+++ b/lib/xlib/xobjects.c
@ -34,8 +34,8 @@
 Object Sym_None;
-int Match_X_Obj (x, v) Object x; va_list v; {
+int Match_X_Obj (Object x, va_list v) {
-    register type = TYPE(x);
+    register int type = TYPE(x);
    if (type == T_Display) {
        return 1;
@ -63,6 +63,6 @@ int Match_X_Obj (x, v) Object x; va_list v; {
    return 0;
 }
-elk_init_xlib_objects () {
+void elk_init_xlib_objects () {
    Define_Symbol (&Sym_None, "none");
 }