#ifndef X_DISPLAY_MISSING
+#include "new_string.h"
#include "X_driver.h"
#include <X11/Xresource.h>
#include "new_memory.h"
* returns -1.
*/
-static int convert_string_to_bool(text)
- string text;
+static int
+convert_string_to_bool(string text)
{
if (!strcasecmp("yes", text) || !strcasecmp("y", text) ||
!strcasecmp("true", text) || !strcasecmp("t", text) ||
*
*/
-char *get_string_resource(name, class)
- string name;
- string class;
+char *
+get_string_resource(string name,
+ string class)
{
string full_name, full_class;
int status;
*
*/
-int get_bool_resource(name, class, default_value)
- string name;
- string class;
- int default_value;
+int
+get_bool_resource(string name,
+ string class,
+ int default_value)
{
int result;
char *temp;
* trip each time.
*/
-unsigned long x_string_to_color(name,def)
- char *name;
- unsigned long def;
+unsigned long
+x_string_to_color(char *name,
+ unsigned long def)
{
unsigned_long_dictionary_binding *binding;
int exists;
*
*/
-int open_display_and_load_resources(pargc, argv)
- int *pargc;
- char **argv;
+int
+open_display_and_load_resources(int *pargc,
+ char **argv)
{
XrmDatabase temp_db1, temp_db2, temp_db3;
char *filename, *res, *xdef;
char dbasename[128];
- extern char *getenv();
/* Initialize X resource manager: */
XrmInitialize();
*
*/
-int X_driver_ioerror(display)
-Display *display;
+int
+X_driver_ioerror(Display *display)
{
- extern void finalize_zephyr();
-
ERROR2("X IO error on display '%s'--exiting\n", DisplayString(display));
finalize_zephyr();
exit(1);
/* */
/****************************************************************************/
-extern void x_get_input();
-
/*ARGSUSED*/
-int X_driver_init(drivername, notfirst, pargc, argv)
- char *drivername;
- char notfirst;
- int *pargc;
- char **argv;
+int
+X_driver_init(char *drivername,
+ char notfirst,
+ int *pargc,
+ char **argv)
{
string temp;
int sync;
x_gram_init(dpy);
xicccmInitAtoms(dpy);
- mux_add_input_source(ConnectionNumber(dpy), x_get_input, dpy);
+ mux_add_input_source(ConnectionNumber(dpy), (void(*)(void *))x_get_input, dpy);
return(0);
}
-void X_driver_reset()
+void
+X_driver_reset(void)
{
}
/* */
/****************************************************************************/
-char *X_driver(text)
- string text;
+char *
+X_driver(string text)
{
string text_copy;
desctype *desc;
#include <X11/Xlib.h>
+#include "new_string.h"
+
extern Display *dpy;
-extern char *get_string_resource();
-extern int get_bool_resource();
+extern char *get_string_resource(string, string);
+extern int get_bool_resource(string, string, int);
+extern unsigned long x_string_to_color(char *, unsigned long);
#endif
static string face_to_string[] = { "roman", "bold", "italic", "bolditalic" };
static string size_to_string[] = { "small", "medium", "large" };
-extern char *get_string_resources();
-
-static char *get_family(style,substyle)
- char *style;
- char *substyle;
+static char *
+get_family(char *style,
+ char *substyle)
{
char *desc;
pointer_dictionary_binding *binding;
}
}
-static char *get_specific_fontname(family,size,face)
- char *family;
- int size;
- int face;
+static char *
+get_specific_fontname(char *family,
+ int size,
+ int face)
{
char *desc;
pointer_dictionary_binding *binding;
* that I know that Font us really an unsigned long. */
static char hexdigits[] = {"0123456789ABCDEF"};
-static char *Font_to_hex(num)
- Font num;
+static char *
+Font_to_hex(Font num)
{
char *temp;
int i;
return(temp);
}
-void add_fid(font)
- XFontStruct *font;
+void
+add_fid(XFontStruct *font)
{
char *fidstr;
}
/* requires that the font already be cached. */
-XFontStruct *get_fontst_from_fid(fid)
- Font fid;
+XFontStruct *
+get_fontst_from_fid(Font fid)
{
char *fidstr;
pointer_dictionary_binding *binding;
#endif
}
-static XFontStruct *get_fontst(dpy,fontname)
- Display *dpy;
- char *fontname;
+static XFontStruct *
+get_fontst(Display *dpy,
+ char *fontname)
{
pointer_dictionary_binding *binding;
int exists;
}
}
-static char *get_fontname(family,size,face)
- char *family;
- int size;
- int face;
+static char *
+get_fontname(char *family,
+ int size,
+ int face)
{
char *fontname;
return(fontname);
}
-static XFontStruct *complete_get_fontst(dpy,style,substyle,size,face)
- Display *dpy;
- string style;
- string substyle;
- int size;
- int face;
+static XFontStruct *
+complete_get_fontst(Display *dpy,
+ string style,
+ string substyle,
+ int size,
+ int face)
{
char *family,*fontname;
XFontStruct *fontst;
* Effects: unknown
*/
-XFontStruct *get_font(dpy,style,substyle,size,face)
- Display *dpy;
- string style;
- string substyle;
- int size;
- int face;
+XFontStruct *
+get_font(Display *dpy,
+ string style,
+ string substyle,
+ int size,
+ int face)
{
char *family,*fontname;
XFontStruct *fontst;
* specified by default.medium.roman is used. <<<>>>
*/
-extern XFontStruct *get_font();
-extern XFontStruct *get_fontst_from_fid();
+extern XFontStruct *get_font(Display *, string, string, int, int);
+extern XFontStruct *get_fontst_from_fid(Font);
#endif
extern XContext desc_context;
extern char *app_instance;
-extern unsigned long x_string_to_color();
-extern char *getenv();
/*
*
*/
/*ARGSUSED*/
-void x_set_icccm_hints(dpy,w,name,icon_name,psizehints,pwmhints,main_window)
- Display *dpy;
- Window w;
- char *name;
- char *icon_name;
- XSizeHints *psizehints;
- XWMHints *pwmhints;
- Window main_window;
+void
+x_set_icccm_hints(Display *dpy,
+ Window w,
+ char *name,
+ char *icon_name,
+ XSizeHints *psizehints,
+ XWMHints *pwmhints,
+ Window main_window)
{
XStoreName(dpy,w,name);
XSetIconName(dpy,w,icon_name);
XSetWMProtocols(dpy,w,&XA_WM_DELETE_WINDOW,1);
}
-void x_gram_init(dpy)
- Display *dpy;
+void
+x_gram_init(Display *dpy)
{
char *temp;
XSizeHints sizehints;
}
}
-int x_calc_gravity(xalign, yalign)
- int xalign, yalign;
+int
+x_calc_gravity(int xalign,
+ int yalign)
{
if (yalign > 0) { /* North */
return (xalign > 0) ? NorthWestGravity
}
}
-void x_gram_create(dpy, gram, xalign, yalign, xpos, ypos, xsize, ysize,
- beepcount)
- Display *dpy;
- x_gram *gram;
- int xalign, yalign;
- int xpos, ypos;
- int xsize, ysize;
- int beepcount;
+void
+x_gram_create(Display *dpy,
+ x_gram *gram,
+ int xalign,
+ int yalign,
+ int xpos,
+ int ypos,
+ int xsize,
+ int ysize,
+ int beepcount)
{
Window w;
XSizeHints sizehints;
XWMHints wmhints;
XSetWindowAttributes attributes;
unsigned long all_desktops = 0xFFFFFFFF;
- extern void x_get_input();
/*
* Adjust xpos, ypos based on the alignments xalign, yalign and the sizes:
x_get_input(dpy);
}
-void x_gram_draw(dpy, w, gram, region)
- Display *dpy;
- Window w;
- x_gram *gram;
- Region region;
+void
+x_gram_draw(Display *dpy,
+ Window w,
+ x_gram *gram,
+ Region region)
{
int i;
GC gc;
XFreeGC(dpy,gc);
}
-void x_gram_expose(dpy,w,gram,event)
- Display *dpy;
- Window w;
- x_gram *gram;
- XExposeEvent *event;
+void
+x_gram_expose(Display *dpy,
+ Window w,
+ x_gram *gram,
+ XExposeEvent *event)
{
static Region region;
static int partregion;
#define x_gram_TYPE
#include <X11/Xlib.h>
+#include <X11/Xutil.h>
#include <sys/time.h>
+#include "formatter.h"
+
typedef struct _xblock {
unsigned long fgcolor;
Font fid;
#define CENTERALIGN 1
#define RIGHTALIGN 2
-extern void x_gram_init();
-extern void x_gram_create();
-extern void x_gram_expose();
-extern void xshow();
-extern void xcut();
+extern void x_gram_init(Display *);
+extern void x_gram_create(Display *, x_gram *, int, int, int, int, int, int, int);
+extern void x_gram_expose(Display *, Window, x_gram *, XExposeEvent *);
+extern void xshow(Display *, desctype *, int, int);
+extern void xcut(Display *, XEvent *, XContext);
+extern void x_get_input(Display *);
#endif
static char *buffer = 0;
-string buffer_to_string()
+string
+buffer_to_string(void)
{
return(buffer);
}
-void clear_buffer()
+void
+clear_buffer(void)
{
if (buffer)
free(buffer);
buffer = string_Copy("");
}
-void append_buffer(str)
- char *str;
+void
+append_buffer(char *str)
{
buffer = string_Concat2(buffer, str);
}
#include "new_string.h"
-extern string buffer_to_string();
-extern void clear_buffer();
-extern void append_buffer();
+extern string buffer_to_string(void);
+extern void clear_buffer(void);
+extern void append_buffer(char *);
#endif
static character_class cache;
/* character_class */
-char * string_to_character_class(str)
- string str;
+char *
+string_to_character_class(string str)
{
int i;
typedef char character_class[NUMBER_OF_CHARACTERS];
-extern /* character_class */ char * string_to_character_class();
+extern /* character_class */ char * string_to_character_class(string);
#endif
* that size is a prime number.
*/
-TYPE_T_dictionary TYPE_T_dictionary_Create(size)
- int size;
+TYPE_T_dictionary
+TYPE_T_dictionary_Create(int size)
{
int i;
TYPE_T_dictionary result;
* TYPE_T_dictionary_Enumerate.
*/
-void TYPE_T_dictionary_Destroy(d)
- TYPE_T_dictionary d;
+void
+TYPE_T_dictionary_Destroy(TYPE_T_dictionary d)
{
int i;
TYPE_T_dictionary_binding *binding_ptr, *new_binding_ptr;
* writable by proc.
*/
-void TYPE_T_dictionary_Enumerate(d, proc)
- TYPE_T_dictionary d;
- void (*proc)(/* TYPE_T_dictionary_binding *b */);
+void TYPE_T_dictionary_Enumerate(TYPE_T_dictionary d,
+ void (*proc)(TYPE_T_dictionary_binding *))
{
int i;
TYPE_T_dictionary_binding *binding_ptr;
* keys over the table's slots.
*/
-static unsigned int dictionary__hash(s)
- char *s;
+static unsigned int
+dictionary__hash(char *s)
{
unsigned int result = 0;
* Note the access restrictions on bindings...
*/
-TYPE_T_dictionary_binding *TYPE_T_dictionary_Lookup(d, key)
- TYPE_T_dictionary d;
- char *key;
+TYPE_T_dictionary_binding *
+TYPE_T_dictionary_Lookup(TYPE_T_dictionary d,
+ char *key)
{
TYPE_T_dictionary_binding *binding_ptr;
* in this case.
*/
-TYPE_T_dictionary_binding *TYPE_T_dictionary_Define(d, key, already_existed)
- TYPE_T_dictionary d;
- char *key;
- int *already_existed;
+TYPE_T_dictionary_binding *
+TYPE_T_dictionary_Define(TYPE_T_dictionary d,
+ char *key,
+ int *already_existed)
{
TYPE_T_dictionary_binding **ptr_to_the_slot, *binding_ptr;
* before making this call.
*/
-void TYPE_T_dictionary_Delete(d, b)
- TYPE_T_dictionary d;
- TYPE_T_dictionary_binding *b;
+void TYPE_T_dictionary_Delete(TYPE_T_dictionary d,
+ TYPE_T_dictionary_binding *b)
{
TYPE_T_dictionary_binding **ptr_to_binding_ptr;
* that size is a prime number.
*/
-extern TYPE_T_dictionary TYPE_T_dictionary_Create(/* int size */);
+extern TYPE_T_dictionary TYPE_T_dictionary_Create(int);
/*
* void TYPE_T_dictionary_Destroy(TYPE_T_dictionary d):
* TYPE_T_dictionary_Enumerate.
*/
-extern void TYPE_T_dictionary_Destroy(/* TYPE_T_dictionary d */);
+extern void TYPE_T_dictionary_Destroy(TYPE_T_dictionary);
/*
- * void TYPE_T_dictionary_Enumerate(TYPE_T_dictionary d; void (*proc)()):
+ * void TYPE_T_dictionary_Enumerate(TYPE_T_dictionary d;
+ * void (*proc)(TYPE_T_dictionary_binding *b)):
* Requires: proc is a void procedure taking 1 argument, a
* TYPE_T_dictionary_binding pointer, which does not
* make any calls using dictionary d.
* writable by proc.
*/
-extern void TYPE_T_dictionary_Enumerate(/* TYPE_T_dictionary d,
- void (*proc)() */);
+extern void TYPE_T_dictionary_Enumerate(TYPE_T_dictionary, void (*)(TYPE_T_dictionary_binding *));
/*
* TYPE_T_dictionary_binding *TYPE_T_dictionary_Lookup(TYPE_T_dictionary d,
* Note the access restrictions on bindings...
*/
-extern TYPE_T_dictionary_binding *TYPE_T_dictionary_Lookup(/* d, key */);
+extern TYPE_T_dictionary_binding *TYPE_T_dictionary_Lookup(TYPE_T_dictionary,
+ char *);
/*
* TYPE_T_dictionary_binding *TYPE_T_dictionary_Define(TYPE_T_dictionary d,
* in this case.
*/
-extern TYPE_T_dictionary_binding *TYPE_T_dictionary_Define();
+extern TYPE_T_dictionary_binding *TYPE_T_dictionary_Define(TYPE_T_dictionary,
+ char *, int *);
/*
* void TYPE_T_dictionary_Delete(TYPE_T_dictionary d,
* before making this call.
*/
-extern void TYPE_T_dictionary_Delete();
+extern void TYPE_T_dictionary_Delete(TYPE_T_dictionary,
+ TYPE_T_dictionary_binding *);
#endif
#include "port.h"
#include "buffer.h"
#include "regexp.h"
+#include "formatter.h"
#include "text_operations.h"
#include "zwgc.h"
#include "variables.h"
* eventually.
*/
-static string bool_to_string(bool)
- int bool;
+static string
+bool_to_string(int bool)
{
return(bool ? string_Copy("TRUE") : string_Copy("FALSE"));
}
* NULL is defined to have the boolean value true.
*/
-int eval_bool_expr(expr)
- Node *expr;
+int
+eval_bool_expr(Node *expr)
{
string temp;
int result;
* eventually.
*/
-string eval_expr(expr)
- Node *expr;
+string
+eval_expr(Node *expr)
{
int opcode = expr->opcode;
int bool_result;
string first, second;
char *result;
string *text_ptr;
- char *getenv(); /* UNIX get environment variable function */
/*
* Dispatch based on the opcode of the top node in the expression:
* eventually.
*/
-extern string eval_expr();
+extern string eval_expr(Node *);
/*
* int eval_bool_expr(Node *expr)
* NULL is defined to have the boolean value true.
*/
-extern int eval_bool_expr();
+extern int eval_bool_expr(Node *);
#endif
#include <zephyr/zephyr.h>
#include "new_memory.h"
+#include "node.h"
#include "exec.h"
#include "eval.h"
-#include "node.h"
#include "buffer.h"
#include "port.h"
#include "variables.h"
#include "notice.h"
-static int exec_subtree(), exec_fields();
+static int exec_subtree(Node *);
+static int exec_fields(Node *);
/****************************************************************************/
/* */
/* */
/****************************************************************************/
-static string eval_exprlist_to_string(exprlist)
- Node *exprlist;
+static string
+eval_exprlist_to_string(Node *exprlist)
{
string result = string_Copy("");
string temp;
return(result);
}
-static char **eval_exprlist_to_args(exprlist)
- Node *exprlist;
+static char **
+eval_exprlist_to_args(Node *exprlist)
{
char **result = (char **)malloc(sizeof(char *));
int argc = 0;
return(result);
}
-static void free_args(args)
- char **args;
+static void
+free_args(char **args)
{
char **p;
#define EXIT 2
/*ARGSUSED*/
-static int exec_noop(node)
- Node *node;
+static int
+exec_noop(Node *node)
{
return(NOBREAK);
}
/*ARGSUSED*/
-static int exec_break(node)
- Node *node;
+static int
+exec_break(Node *node)
{
return(BREAK);
}
/*ARGSUSED*/
-static int exec_exit(node)
- Node *node;
+static int
+exec_exit(Node *node)
{
return(EXIT);
}
-static int exec_set(node)
- Node *node;
+static int
+exec_set(Node *node)
{
var_set_variable_then_free_value(node->d.nodes.first->d.string_constant,
eval_expr(node->d.nodes.second));
return(NOBREAK);
}
-static int exec_execport(node)
- Node *node;
+static int
+exec_execport(Node *node)
{
string name = eval_expr(node->d.nodes.first);
char **argv = eval_exprlist_to_args(node->d.nodes.second);
return(NOBREAK);
}
-static int exec_appendport(node)
- Node *node;
+static int
+exec_appendport(Node *node)
{
string name, filename;
return(NOBREAK);
}
-static int exec_inputport(node)
- Node *node;
+static int
+exec_inputport(Node *node)
{
string name, filename;
return(NOBREAK);
}
-static int exec_outputport(node)
- Node *node;
+static int
+exec_outputport(Node *node)
{
string name, filename;
return(NOBREAK);
}
-static int exec_closeinput(node)
- Node *node;
+static int
+exec_closeinput(Node *node)
{
string name;
return(NOBREAK);
}
-static int exec_closeoutput(node)
- Node *node;
+static int
+exec_closeoutput(Node *node)
{
string name;
return(NOBREAK);
}
-static int exec_closeport(node)
- Node *node;
+static int
+exec_closeport(Node *node)
{
string name;
return(NOBREAK);
}
-static int exec_put(node)
- Node *node;
+static int
+exec_put(Node *node)
{
string name, temp;
return(NOBREAK);
}
-static int exec_print(node)
- Node *node;
+static int
+exec_print(Node *node)
{
string temp;
}
/*ARGSUSED*/
-static int exec_clearbuf(node)
- Node *node;
+static int
+exec_clearbuf(Node *node)
{
clear_buffer();
return(NOBREAK);
}
-static int exec_case(node)
- Node *node;
+static int
+exec_case(Node *node)
{
string constant,temp;
Node *match, *cond;
return(NOBREAK);
}
-static int exec_while(node)
- Node *node;
+static int
+exec_while(Node *node)
{
int continue_code = NOBREAK;
return(continue_code);
}
-static int exec_if(node)
- Node *node;
+static int
+exec_if(Node *node)
{
Node *conds;
return(NOBREAK);
}
-static int exec_exec(node)
- Node *node;
+static int
+exec_exec(Node *node)
{
int pid;
char **argv = eval_exprlist_to_args(node->d.nodes.first);
}
static struct _Opstuff {
- int (*exec)();
+ int (*exec)(Node *);
} const opstuff[] = {
{ exec_noop }, /* string_constant */
{ exec_noop }, /* varref */
{ exec_noop }, /* default */
};
-static int exec_subtree(node)
- Node *node;
+static int
+exec_subtree(Node *node)
{
int retval = NOBREAK;
static int notice_fields_length = 0;
static int number_of_fields = 0;
-static int exec_fields(node)
- Node *node;
+static int
+exec_fields(Node *node)
{
for (node=node->d.nodes.first; node; node=node->next) {
var_set_variable_then_free_value(node->d.string_constant,
return(NOBREAK);
}
-void exec_process_packet(program, notice)
- Node *program;
- ZNotice_t *notice;
+void
+exec_process_packet(Node *program,
+ ZNotice_t *notice)
{
notice_fields = notice->z_message;
notice_fields_length = notice->z_message_len;
#ifndef exec_MODULE
#define exec_MODULE
-extern void exec_process_packet();
+extern void exec_process_packet(Node *, ZNotice_t *);
#endif
* if necessary.
*/
-char *get_home_directory()
+char *get_home_directory(void)
{
char *result;
- char *getenv();
struct passwd *passwd_entry;
if (result = getenv("HOME"))
*
*/
-FILE *locate_file(override_filename, home_dir_filename, fallback_filename)
- char *override_filename;
- char *home_dir_filename;
- char *fallback_filename;
+FILE *locate_file(char *override_filename,
+ char *home_dir_filename,
+ char *fallback_filename)
{
char *filename;
FILE *result;
#include <stdio.h>
-extern FILE *locate_file();
+extern FILE *locate_file(char *, char *, char *);
#endif
#define const
#endif
-static int pure_text_length(), env_length();
+static int pure_text_length(char *, char);
+static int env_length(char *);
#ifdef notdef
static character_class atsign_set = { /* '@' = 0x40 */
static char *openbracket[]={"@<","@<","@[","@[","@{","@{","@(","@(","@("};
static char *closebracket[]={">",">","]","]","}","}",")",")",")"};
-static int not_contains(str, set)
- string str;
- const character_class set;
+static int
+not_contains(string str,
+ const character_class set)
{
while (*str && ! set[*str]) str++;
return (! *str);
}
-static int pure_text_length(text,terminator)
- char *text;
- char terminator;
+static int
+pure_text_length(char *text,
+ char terminator)
{
int len=0;
}
}
-static char otherside(opener)
-char opener;
+static char
+otherside(char opener)
{
switch (opener) {
case '(':
/* the char * that str points to is free'd by this function.
* if you want to keep it, save it yourself
*/
-string verbatim(str, bracketsonly)
- string str;
- int bracketsonly;
+string
+verbatim(string str, int bracketsonly)
{
char *temp,*temp2;
int bracketnum,len;
or the default terminator \0. The text will not be modified,
and @@ will be counted twice */
-string protect(str)
- string str;
+string
+protect(string str)
{
string temp,temp2,temp3;
int len,templen;
/* str points to a string. return value is another string
which is the original with all styles removed. */
-string stylestrip(str)
- string str;
+string
+stylestrip(string str)
{
int templen = 0, otherchar;
char *temp = (char *) malloc(string_Length(str) + 1);
return(temp);
}
-void free_desc(desc)
- desctype *desc;
+void
+free_desc(desctype *desc)
{
desctype *next_desc;
/* text points to beginning of possible env name. return value is
length of env name, not including @ or opener, or -1 if not a
possible env name. */
-static int env_length(text)
- char *text;
+static int
+env_length(char *text)
{
int len=0;
length of string, up to but not including the passed terminator
or the default terminators \0 \n @. This can modify text, and 0
is a valid return value. */
-static int text_length(text,terminator)
- char *text;
- char terminator;
+static int
+text_length(char *text,
+ char terminator)
{
int len=0;
/* parses str into a desc linked list. Returns number of strings and
newlines in *pstr and *pnl */
-desctype *disp_get_cmds(str,pstr,pnl)
-char *str;
-int *pstr,*pnl;
+desctype *
+disp_get_cmds(char *str,
+ int *pstr,
+ int *pnl)
{
desctype *desc,*here;
int len;
#include <zephyr/mit-copyright.h>
+#include "new_string.h"
+
#ifndef formatter_MODULE
#define formatter_MODULE
ENV, STR, END. Undefined for EOF */
} desctype;
-extern desctype *disp_get_cmds();
-extern void free_desc();
+extern desctype *disp_get_cmds(char *, int *, int *);
+extern void free_desc(desctype *);
+extern string protect(string);
+extern string verbatim(string, int);
+extern string stylestrip(string);
#endif
static int pushback = -1;
-static char input()
+static char
+input(void)
{
int c;
return(c);
}
-static void unput(c)
- int c;
+static void
+unput(int c)
{
#ifdef DEBUG
if (pushback != -1) {
* a file. Resets current line # to 1.
*/
-void lex_open(file)
- FILE *file;
+void
+lex_open(FILE *file)
{
/*
* Initialize I/O:
#define is_octal_digit(c) (((c)>='0') && ((c)<='7'))
-static char eat_escape_code()
+static char
+eat_escape_code(void)
{
int c, coded_char;
* string we are eating started on.
*/
-static char *eat_string(starting_line)
- int starting_line;
+static char *
+eat_string(int starting_line)
{
int c;
char buffer[500];
* instead of doing the above, we just eat the "endshow" & return 0.
*/
-static char *eat_show_line(test_for_endshow)
- int test_for_endshow;
+static char *
+eat_show_line(int test_for_endshow)
{
int c;
int saw_escape_code = 0;
* messages.
*/
-static char *eat_til_endshow(start_line_no)
- int start_line_no;
+static char *
+eat_til_endshow(int start_line_no)
{
register int c;
string text_so_far = string_Copy("");
* returned.
*/
-static int handle_show()
+static int
+handle_show(void)
{
int c;
int start_line_no = yylineno;
* yylex - performs as per. the yacc manual's requirements
*/
-int yylex()
+int yylex(void)
{
register int c, last_char;
register char *ptr;
* a file. Resets current line # to 1.
*/
-extern void lex_open(/* FILE *file */);
+extern void lex_open(FILE *);
/*
* yylex - performs as per. the yacc manual's requirements
*/
-extern int yylex();
+/* extern int yylex(); */
#endif
#include "variables.h"
#include "main.h"
-extern void notice_handler();
-static void process_notice(), setup_signals(), detach(), signal_exit();
+void notice_handler(ZNotice_t *);
+static void process_notice(ZNotice_t *, char *);
+static void setup_signals(int);
+static void detach(void);
+static void signal_exit(int);
#ifdef HAVE_ARES
-static void notice_callback();
+static void notice_callback(void *, int, struct hostent *);
#endif
/*
* <<<>>>
*/
-static void fake_startup_packet()
+static void
+fake_startup_packet(void)
{
ZNotice_t notice;
struct timezone tz;
notice.z_default_format = "Zwgc mark II version $version now running...\n";
notice.z_recipient = "";
notice.z_sender = "ZWGC";
- gettimeofday(¬ice.z_time,&tz);
+ Z_gettimeofday(¬ice.z_time, &tz);
notice.z_port = 0;
notice.z_kind = ACKED;
notice.z_auth = ZAUTH_YES;
process_notice(¬ice, NULL);
}
-static void read_in_description_file()
+static void
+read_in_description_file(void)
{
FILE *input_file;
char defdesc[128];
* program with error code 1.
*/
-void usage()
+void
+usage(void)
{
#ifdef DEBUG
fprintf(stderr, "\
* <<<>>>
*/
-static void run_initprogs()
+static void
+run_initprogs(void)
{
/*
* This code stolen from old zwgc: yuck. Clean up & fix. <<<>>>
* main -- the program entry point. Does parsing & top level control.
*/
-int main(argc, argv)
- int argc;
- char **argv;
+int
+main(int argc,
+ char **argv)
{
char **new;
register char **current;
#define USER_SUPPRESS "SUPPRESS"
#define USER_UNSUPPRESS "UNSUPPRESS"
-void notice_handler(notice)
- ZNotice_t *notice;
+void
+notice_handler(ZNotice_t *notice)
{
struct hostent *fromhost = NULL;
}
#ifdef HAVE_ARES
-static void notice_callback(arg, status, fromhost)
- void *arg;
- int status;
- struct hostent *fromhost;
+static void
+notice_callback(void *arg,
+ int status,
+ struct hostent *fromhost)
{
ZNotice_t *notice = (ZNotice_t *) arg;
}
#endif
-static void process_notice(notice, hostname)
- ZNotice_t *notice;
- char *hostname;
+static void
+process_notice(ZNotice_t *notice,
+ char *hostname)
{
char *control_opcode;
free(instance);
free(recipient);
} else if (!strcasecmp(control_opcode, USER_EXIT)) {
- signal_exit();
+ signal_exit(0);
} else
printf("zwgc: unknown control opcode %s.\n", control_opcode);
*
*/
-static void signal_exit()
+static void
+signal_exit(int ignored)
{
mux_end_loop_p = 1;
}
/* clean up ALL the waiting children, in case we get hit with
multiple SIGCHLD's at once, and don't process in time. */
-static RETSIGTYPE signal_child()
+static RETSIGTYPE
+signal_child(int ignored)
{
#ifdef HAVE_WAITPID
int status;
#else
union wait status;
#endif
- extern int errno;
int pid, old_errno = errno;
do {
}
/* rewrite the wgfile in case it has gone away */
-static RETSIGTYPE signal_usr1()
+static RETSIGTYPE
+signal_usr1(int ignored)
{
write_wgfile();
}
-static void setup_signals(dofork)
- int dofork;
+static void
+setup_signals(int dofork)
{
#ifdef _POSIX_VERSION
struct sigaction sa;
/* detach() taken from old zwgc, with lots of stuff ripped out */
-static void detach()
+static void
+detach(void)
{
/* detach from terminal and fork. */
register int i;
* program with error code 1.
*/
-extern void usage();
+extern void usage(void);
/* USRDESC points to a file (relative to user's homedir) which has a user's
description file */
*/
static fd_set input_sources;
-static void (*input_handler[MAX_SOURCES])();
+static void (*input_handler[MAX_SOURCES])(void *);
static pointer input_handler_arg[MAX_SOURCES];
-static int check_tty();
+static int check_tty(void);
/*
* void mux_init()
* any other mux call.
*/
-void mux_init()
+void
+mux_init(void)
{
int i;
* argument arg.
*/
-void mux_add_input_source(descriptor, handler, arg)
- int descriptor;
- void (*handler)();
- pointer arg;
+void
+mux_add_input_source(int descriptor,
+ void (*handler)(void *),
+ pointer arg)
{
#ifdef DEBUG
if(descriptor < 0 || descriptor >= MAX_SOURCES)
* true, we return.
*/
-void mux_loop()
+void
+mux_loop(void)
{
int i, nfds;
fd_set inputs, outputs;
}
}
-static int check_tty()
+static int
+check_tty(void)
{
register int result;
int pgrp;
* any other mux call.
*/
-extern void mux_init();
+extern void mux_init(void);
/*
* void mux_add_input_source(int descriptior; void (*handler)(); void *arg)
* argument arg.
*/
-extern void mux_add_input_source();
+extern void mux_add_input_source(int, void (*)(void *), void *);
/*
* void mux_loop()
* true, we return.
*/
-extern void mux_loop();
+extern void mux_loop(void);
#endif
* string_Copy("foo").
*/
-string string__CreateFromData(data, length)
- char *data;
- int length;
+string string__CreateFromData(char *data, int length)
{
string result;
* freed eventually.
*/
-string string__Copy(s)
- string s;
+string
+string__Copy(string s)
{
int length;
string result;
* returns string_Copy("abcdef").
*/
-string string__Concat(a, b)
- string a, b;
+string
+string__Concat(string a,
+ string b)
{
string result;
int a_length, b_size, result_size;
* only faster. I.e., uses realloc instead of malloc+memcpy.
*/
-string string__Concat2(a, b)
- string a, b;
+string
+string__Concat2(string a,
+ string b)
{
int a_length = string_Length(a);
int b_size = string_Length(b)+1;
* S is returned as a convenience.
*/
-string string_Downcase(s)
- string s;
+string
+string_Downcase(string s)
{
char *ptr;
* S is returned as a convenience.
*/
-string string_Upcase(s)
- string s;
+string
+string_Upcase(string s)
{
char *ptr;
* string_Copy("foo").
*/
-extern string string__CreateFromData();
+extern string string__CreateFromData(char *, int);
#ifdef DEBUG_MEMORY
#define string_CreateFromData(data,length) (set_module(__FILE__,__LINE__),\
string__CreateFromData(data,length))
* freed eventually.
*/
-extern string string__Copy(/* string s */);
+extern string string__Copy(string);
#ifdef DEBUG_MEMORY
#define string_Copy(data) (set_module(__FILE__,__LINE__),\
string__Copy(data))
* returns string_Copy("abcdef").
*/
-extern string string__Concat(/* string a, b */);
+extern string string__Concat(string, string);
#ifdef DEBUG_MEMORY
#define string_Concat(a,b) (set_module(__FILE__,__LINE__),\
string__Concat(a,b))
* only faster. I.e., uses realloc instead of malloc+bcopy.
*/
-extern string string__Concat2(/* string a, b */);
+extern string string__Concat2(string, string);
#ifdef DEBUG_MEMORY
#define string_Concat2(a,b) (set_module(__FILE__,__LINE__),\
string__Concat2(a,b))
* S is returned as a convenience.
*/
-extern string string_Downcase();
+extern string string_Downcase(string);
/*
* string string_Upcase(string s):
* S is returned as a convenience.
*/
-extern string string_Upcase();
+extern string string_Upcase(string);
#endif
* string on the heap when node_DestroyAllNodes is called.
*/
-static Node *node_create(opcode)
- int opcode;
+static Node *
+node_create(int opcode)
{
Node *result;
*
*/
-void node_DestroyAllNodes()
+void
+node_DestroyAllNodes(void)
{
struct _bunch_of_nodes *next_bunch;
int i, last_node_used_in_this_bunch;
/* */
/****************************************************************************/
-Node *node_create_string_constant(opcode, text)
- int opcode;
- string text;
+Node *
+node_create_string_constant(int opcode,
+ string text)
{
Node *n;
return(n);
}
-Node *node_create_noary(opcode)
- int opcode;
+Node *
+node_create_noary(int opcode)
{
Node *n;
return(n);
}
-Node *node_create_unary(opcode, arg)
- int opcode;
- Node *arg;
+Node *
+node_create_unary(int opcode,
+ Node *arg)
{
Node *n;
return(n);
}
-Node *node_create_binary(opcode, first_arg, second_arg)
- int opcode;
- Node *first_arg;
- Node *second_arg;
+Node *
+node_create_binary(int opcode,
+ Node *first_arg,
+ Node *second_arg)
{
Node *n;
* the address of the (previously) last node.
*/
-Node *reverse_list_of_nodes(list)
- Node *list;
+Node *
+reverse_list_of_nodes(Node *list)
{
Node *next_node;
Node *head = NULL;
#ifdef DEBUG
-static void print_stuff(node, format_string)
- Node *node;
- string format_string;
+static void
+print_stuff(Node *node,
+ string format_string)
{
char c;
"match %1\n%2",
"default\n%2" };
-void node_display(node)
- Node *node;
+void node_display(Node *node)
{
int opcode = LAST_EXPR_OPCODE + 1;
/* Function externs */
-extern void node_DestroyAllNodes();
+extern void node_DestroyAllNodes(void);
-extern Node *node_create_string_constant();
+extern Node *node_create_string_constant(int, string);
-extern Node *node_create_noary();
-extern Node *node_create_unary();
-extern Node *node_create_binary();
+extern Node *node_create_noary(int);
+extern Node *node_create_unary(int, Node *);
+extern Node *node_create_binary(int, Node *, Node *);
/*
* Node *reverse_list_of_nodes(Node *list)
* the address of the (previously) last node.
*/
-extern Node *reverse_list_of_nodes();
+extern Node *reverse_list_of_nodes(Node *);
#ifdef DEBUG
-extern void node_display();
+extern void node_display(Node *);
#endif
#endif
* Effects: Returns the # of nulls in data[0]..data[length-1]
*/
-int count_nulls(data, length)
- char *data;
- int length;
+int
+count_nulls(char *data,
+ int length)
{
int count = 0;
* remain. (this is the case when *length_p == 0)
*/
-string get_next_field(data_p, length_p)
- char **data_p;
- int *length_p;
+string
+get_next_field(char **data_p,
+ int *length_p)
{
char *data = *data_p;
int length = *length_p;
* "" is returned.
*/
-string get_field(data, length, num)
- char *data;
- int length;
- int num;
+string get_field(char *data,
+ int length,
+ int num)
{
/*
* While num>1 and there are fields left, skip a field & decrement num:
* be freed.
*/
-string convert_nulls_to_newlines(data, length)
- char *data;
- int length;
+string
+convert_nulls_to_newlines(char *data,
+ int length)
{
char *result, *ptr;
char c;
* eventually.
*/
-static string z_kind_to_ascii(z_kind)
- ZNotice_Kind_t z_kind;
+static string
+z_kind_to_ascii(ZNotice_Kind_t z_kind)
{
string result;
* eventually.
*/
-static string z_auth_to_ascii(z_auth)
- int z_auth;
+static string
+z_auth_to_ascii(int z_auth)
{
string result;
* Effects:
*/
-char *decode_notice(notice, hostname)
- ZNotice_t *notice;
- char *hostname;
+char *
+decode_notice(ZNotice_t *notice,
+ char *hostname)
{
char *temp;
string time, notyear, year, date_string, time_string;
#ifndef notice_MODULE
#define notice_MODULE
+#include <zephyr/zephyr.h>
#include "new_string.h"
/*
* Effects: Returns the # of nulls in data[0]..data[length-1]
*/
-extern int count_nulls();
+extern int count_nulls(char *, int);
/*
* string get_next_field(char **data_p, int *length_p)
* remain. (this is the case when *length_p == 0)
*/
-extern string get_next_field();
+extern string get_next_field(char **, int *);
/*
* string get_field(char *data, int length, int num)
* "" is returned.
*/
-extern string get_field();
+extern string get_field(char *, int, int);
/*
* string convert_nulls_to_newlines(data, length)
* be freed.
*/
-extern string convert_nulls_to_newlines();
+extern string convert_nulls_to_newlines(char *, int);
-extern char *decode_notice();
+extern char *decode_notice(ZNotice_t *, char *);
#endif
* is reported to the user via stderr.
*/
-extern void report_parse_error();
+extern void report_parse_error(char *, int);
/*
* struct _Node *parse_file(FILE *input_file)
* is closed before this routine returns.
*/
-extern struct _Node *parse_file();
+extern struct _Node *parse_file(FILE *);
#endif
#include "node.h"
#include "zwgc.h"
-static void yyerror();
+static void yyerror(char *);
/*
* the_program - local variable used to communicate the program's node
* is reported to the user via stderr.
*/
-void report_parse_error(error_message, line_number)
- char *error_message;
- int line_number;
+void
+report_parse_error(char *error_message,
+ int line_number)
{
if (error_occured)
return;
* stack overflow errors.
*/
-static void yyerror(message)
- char *message;
+static void yyerror(char *message)
{
report_parse_error(message, yylineno);
}
* is closed before this routine returns.
*/
-struct _Node *parse_file(input_file)
- FILE *input_file;
+struct _Node *
+parse_file(FILE *input_file)
{
the_program = NULL;
error_occured = 0;
/* */
/****************************************************************************/
-static string port_get(p)
- port *p;
+static string
+port_get(port *p)
{
- char *(*get_proc)();
+ char *(*get_proc)(port *, char **);
char *error = NULL;
char *result;
return(result);
}
-static void port_put(p, data, length)
- port *p;
- char *data;
- int length;
+static void
+port_put(port *p,
+ char *data,
+ int length)
{
- char *(*put_proc)();
+ char *(*put_proc)(port *, char *, int);
char *error;
if (p->status & OUTPUT_CLOSED) {
var_set_variable("error", error);
}
-static void port_close_input(p)
- port *p;
+static void
+port_close_input(port *p)
{
- char *(*close_input_proc)();
+ char *(*close_input_proc)(port *);
char *error;
if (p->status & INPUT_CLOSED)
var_set_variable("error", error);
}
-static void port_close_output(p)
- port *p;
+static void
+port_close_output(port *p)
{
- char *(*close_output_proc)();
+ char *(*close_output_proc)(port *);
char *error;
if (p->status & OUTPUT_CLOSED)
* any other port call is made.
*/
-static void close_port_from_binding(b)
- port_dictionary_binding *b;
+static void
+close_port_from_binding(port_dictionary_binding *b)
{
port_close_input(&(b->value));
port_close_output(&(b->value));
}
-void init_ports()
+void
+init_ports(void)
{
if (port_dict) {
port_dictionary_Enumerate(port_dict, close_port_from_binding);
* various fields correctly.
*/
-static port *create_named_port(name)
- string name;
+static port *
+create_named_port(string name)
{
int already_exists;
port_dictionary_binding *binding;
* it. Otherwise returns NULL.
*/
-static port *get_named_port(name)
- string name;
+static port *
+get_named_port(string name)
{
port_dictionary_binding *binding;
* on the heap & must be eventually freed.
*/
-string read_from_port(name)
- string name;
+string
+read_from_port(string name)
{
port *p;
* occurs, $error is set to the error message.
*/
-void write_on_port(name, text, length)
- string name;
- char *text;
- int length;
+void
+write_on_port(string name,
+ char *text,
+ int length)
{
port *p;
* occurs, $error is set to the error message.
*/
-void close_port_input(name)
- string name;
+void
+close_port_input(string name)
{
port_dictionary_binding *binding;
* occurs, $error is set to the error message.
*/
-void close_port_output(name)
- string name;
+void
+close_port_output(string name)
{
port_dictionary_binding *binding;
/* */
/****************************************************************************/
-static string get_file(p, error_p)
- port *p;
- char **error_p;
+static string
+get_file(port *p,
+ char **error_p)
{
char buffer[10000]; /* <<<>>> */
return(string_Copy(buffer));
}
-static char *put_file(p, text, length)
- port *p;
- string text;
- int length;
+static char *
+put_file(port *p,
+ string text,
+ int length)
{
if (!p->data.file.output_connector)
return(NULL);
return(NULL);
}
-static char *close_file_input(p)
- port *p;
+static char *
+close_file_input(port *p)
{
errno = 0;
if (p->data.file.input_connector) {
return(NULL);
}
-static char *close_file_output(p)
- port *p;
+static char *
+close_file_output(port *p)
{
errno = 0;
if (p->data.file.output_connector) {
return(NULL);
}
-void create_port_from_files(name, input, output)
- string name;
- FILE *input;
- FILE *output;
+void create_port_from_files(string name,
+ FILE *input,
+ FILE *output)
{
port *p = create_named_port(name);
/* */
/****************************************************************************/
-void create_subprocess_port(name, argv)
- string name;
- char **argv;
+void
+create_subprocess_port(string name,
+ char **argv)
{
int pid;
int to_child_descriptors[2];
create_port_from_files(name, in, out);
}
-void create_file_append_port(name, filename)
- string name;
- string filename;
+void
+create_file_append_port(string name,
+ string filename)
{
FILE *out;
int oumask;
create_port_from_files(name, 0, out);
}
-void create_file_input_port(name, filename)
- string name;
- string filename;
+void
+create_file_input_port(string name,
+ string filename)
{
FILE *in;
create_port_from_files(name, in, 0);
}
-void create_file_output_port(name, filename)
- string name;
- string filename;
+void
+create_file_output_port(string name,
+ string filename)
{
FILE *out;
int oumask;
/* */
/****************************************************************************/
-static string get_filter(p, error_p)
- port *p;
- char **error_p;
+static string
+get_filter(port *p,
+ char **error_p)
{
string result;
return(result);
}
-static char *put_filter(p, text, length)
- port *p;
- string text;
- int length;
+static char *
+put_filter(port *p,
+ string text,
+ int length)
{
string input;
string output;
return(NULL);
}
-static char *close_filter_input(p)
- port *p;
+static char *
+close_filter_input(port *p)
{
while (!string_stack_empty(p->data.filter.waiting_packets))
string_stack_pop(p->data.filter.waiting_packets);
}
/*ARGSUSED*/
-static char *close_filter_output(p)
- port *p;
+static char *
+close_filter_output(port *p)
{
return(NULL);
}
-void create_port_from_filter(name, filter)
- string name;
- string (*filter)();
+void
+create_port_from_filter(string name,
+ string (*filter)(string))
{
port *p = create_named_port(name);
/* */
/****************************************************************************/
-static char *put_output(p, text, length)
- port *p;
- string text;
- int length;
+static char *
+put_output(port *p,
+ string text,
+ int length)
{
string input;
char *error;
}
/*ARGSUSED*/
-static char *close_output(p)
- port *p;
+static char *
+close_output(port *p)
{
return(NULL);
}
-void create_port_from_output_proc(name, output)
- string name;
- char *(*output)();
+void
+create_port_from_output_proc(string name,
+ char *(*output)(string))
{
#ifdef SABER /* Yes, it's another ANSI incompatiblity */
port *p;
} file;
struct {
string_stack waiting_packets;
- string (*filter)();
+ string (*filter)(string);
} filter;
struct {
- char *(*output)();
+ char *(*output)(string);
} output;
};
-typedef struct { /* PRIVATE */
- char *(*get)();
- char *(*put)();
- char *(*close_input)();
- char *(*close_output)();
+typedef struct port__struct { /* PRIVATE */
+ char *(*get)(struct port__struct *, char **);
+ char *(*put)(struct port__struct *, char *, int);
+ char *(*close_input)(struct port__struct *);
+ char *(*close_output)(struct port__struct *);
#define INPUT_CLOSED 0x1
#define OUTPUT_CLOSED 0x2
#define PORT_CLOSED 0x3
* any other port call is made.
*/
-extern void init_ports();
+extern void init_ports(void);
/*
* string read_from_port(string name)
* on the heap & must be eventually freed.
*/
-extern string read_from_port();
+extern string read_from_port(string);
/*
* void write_on_port(string name, char *text, int length)
* occurs, $error is set to the error message.
*/
-extern void write_on_port();
+extern void write_on_port(string, char *, int);
/*
* void close_port_input(string name)
* occurs, $error is set to the error message.
*/
-extern void close_port_input();
+extern void close_port_input(string);
/*
* void close_port_output(string name)
* occurs, $error is set to the error message.
*/
-extern void close_port_output();
+extern void close_port_output(string);
-extern void create_subprocess_port();
-extern void create_file_append_port();
-extern void create_file_input_port();
-extern void create_file_output_port();
-extern void create_port_from_filter();
-extern void create_port_from_output_proc();
+extern void create_subprocess_port(string, char **);
+extern void create_file_append_port(string, string);
+extern void create_file_input_port(string, string);
+extern void create_file_output_port(string, string);
+extern void create_port_from_filter(string, string (*)(string));
+extern void create_port_from_output_proc(string, char *(*)(string));
-extern void init_standard_ports();
-extern void create_port_from_files();
+extern void init_standard_ports(int *, char **);
+extern void create_port_from_files(string, FILE *, FILE *);
#endif
#include "regexp.h"
-int ed_regexp_match_p(test_string, pattern)
- string test_string;
- string pattern;
+int
+ed_regexp_match_p(string test_string,
+ string pattern)
{
regex_t RE;
int retval;
#include "new_string.h"
-extern int ed_regexp_match_p();
+extern int ed_regexp_match_p(string, string);
#endif
#include "main.h"
#include <zephyr/zephyr.h>
-extern string tty_filter();
-extern int tty_filter_init();
+extern char *tty_filter(string, int);
+extern int tty_filter_init(char *, char, int *, char **);
#ifndef X_DISPLAY_MISSING
-extern char *X_driver();
-extern int X_driver_init();
+extern char *X_driver(string);
+extern int X_driver_init(char *, char, int *, char **);
#endif
-extern void usage();
+extern void usage(void);
/*
*
*/
-char *plain_driver(input)
- string input;
+char *
+plain_driver(string input)
{
string processed_input = tty_filter(input, 0);
*
*/
-char *tty_driver(input)
- string input;
+char *
+tty_driver(string input)
{
string processed_input = tty_filter(input, 1);
*
*/
-string noop_filter(input)
- string input;
+string
+noop_filter(string input)
{
return(input);
}
*
*/
-string plain_filter(input)
- string input;
+string
+plain_filter(string input)
{
return(tty_filter(input, 0));
}
*
*/
-string fancy_filter(input)
- string input;
+string
+fancy_filter(string input)
{
return(tty_filter(input, 1));
}
#define DISABLED 2
int port_setup_status;
- int (*port_init)();
+ int (*port_init)(char *, char, int *, char **);
#define INPUT_DESC 0
#define OUTPUT_DESC 1
#define FILTER 2
#define OUTPUT_PROC 3
int type;
- char *(*function)();
+ char *(*function)(string);
int setup_arg;
} standard_port_info_table[] = {
#ifndef X_DISPLAY_MISSING
* <<<>>>
*/
-static struct standard_port_info *get_standard_port_info(port_name)
- string port_name;
+static struct standard_port_info *
+get_standard_port_info(string port_name)
{
struct standard_port_info *p;
* returns -1.
*/
-static int boolean_value_of(text)
- string text;
+static int
+boolean_value_of(string text)
{
if (!text)
return(-1); /* not set */
*
*/
-void init_standard_ports(pargc, argv)
- int *pargc;
- char **argv;
+void init_standard_ports(int *pargc,
+ char **argv)
{
struct standard_port_info *p;
string first_working_port = "";
* heap.
*/
-void string__dictionary_Set(d, key, value)
- string_dictionary d;
- string key;
- string value;
+void
+string__dictionary_Set(string_dictionary d,
+ string key,
+ string value)
{
string_dictionary_binding *binding;
int already_exists;
* disappear later if key is rebound.
*/
-char *string_dictionary_Fetch(d, key)
- string_dictionary d;
- string key;
+char *
+string_dictionary_Fetch(string_dictionary d,
+ string key)
{
string_dictionary_binding *binding;
* all value's in the dictionary.
*/
-static void free_value_of_binding(b)
- string_dictionary_binding *b;
+static void
+free_value_of_binding(string_dictionary_binding *b)
{
free(b->value);
}
-void string_dictionary_SafeDestroy(d)
- string_dictionary d;
+void
+string_dictionary_SafeDestroy(string_dictionary d)
{
string_dictionary_Enumerate(d, free_value_of_binding);
string_dictionary_Destroy(d);
* heap.
*/
-extern void string__dictionary_Set();
+extern void string__dictionary_Set(string_dictionary, string, string);
#ifdef DEBUG_MEMORY
#define string_dictionary_Set(a,b,c) (set_module(__FILE__,__LINE__),\
string__dictionary_Set(a,b,c))
* disappear later if key is rebound.
*/
-extern char *string_dictionary_Fetch();
+extern char *string_dictionary_Fetch(string_dictionary,
+ string);
/*
* void string_dictionary_SafeDestroy(string_dictionary d)
* all value's in the dictionary.
*/
-extern void string_dictionary_SafeDestroy();
+extern void string_dictionary_SafeDestroy(string_dictionary);
#endif
*/
static int_dictionary puntable_addresses_dict = 0;
-static void init_puntable_dict()
+static void
+init_puntable_dict(void)
{
puntable_addresses_dict = int_dictionary_Create(33);
}
-static string address_to_string(class, instance, recipient)
- string class;
- string instance;
- string recipient;
+static string
+address_to_string(string class,
+ string instance,
+ string recipient)
{
string result;
return(result);
}
-int puntable_address_p(class, instance, recipient)
- string class;
- string instance;
- string recipient;
+int puntable_address_p(string class,
+ string instance,
+ string recipient)
{
string temp;
return(0);
}
-void punt(class, instance, recipient)
- string class;
- string instance;
- string recipient;
+void punt(string class,
+ string instance,
+ string recipient)
{
string temp;
free(temp);
}
-void unpunt(class, instance, recipient)
- string class;
- string instance;
- string recipient;
+void unpunt(string class,
+ string instance,
+ string recipient)
{
string temp;
int_dictionary_binding *binding;
static int unsubscription_list_size = 0;
static ZSubscription_t unsubscription_list[BATCH_SIZE];
-static void free_subscription_list(list, number_of_elements)
- ZSubscription_t *list;
- int number_of_elements;
+static void
+free_subscription_list(ZSubscription_t *list,
+ int number_of_elements)
{
int i;
}
}
-static void flush_subscriptions()
+static void
+flush_subscriptions(void)
{
TRAP(ZSubscribeTo(subscription_list,subscription_list_size, 0),
"while subscribing");
subscription_list_size = 0;
}
-static void flush_unsubscriptions()
+static void
+flush_unsubscriptions(void)
{
if (unsubscription_list_size)
TRAP(ZUnsubscribeTo(unsubscription_list, unsubscription_list_size, 0),
unsubscription_list_size = 0;
}
-static void subscribe(class, instance, recipient)
- string class;
- string instance;
- string recipient;
+static void
+subscribe(string class,
+ string instance,
+ string recipient)
{
subscription_list[subscription_list_size].zsub_class = string_Copy(class);
subscription_list[subscription_list_size].zsub_classinst= string_Copy(instance);
flush_subscriptions();
}
-static void unsubscribe(class, instance, recipient)
- string class;
- string instance;
- string recipient;
+static void
+unsubscribe(string class,
+ string instance,
+ string recipient)
{
unsubscription_list[unsubscription_list_size].zsub_class = string_Copy(class);
unsubscription_list[unsubscription_list_size].zsub_classinst
char ourhost[MAXHOSTNAMELEN],ourhostcanon[MAXHOSTNAMELEN];
-static void inithosts()
+static void
+inithosts(void)
{
struct hostent *hent;
if (gethostname(ourhost, sizeof(ourhost)-1) == -1) {
return;
}
-static void macro_sub(str)
- char *str;
+static void
+macro_sub(char *str)
{
static int initedhosts = 0;
#define UNSUBSCRIBE_CHARACTER '!'
#define PUNT_CHARACTER '-'
-static void load_subscriptions_from_file(file)
- FILE *file;
+static void
+load_subscriptions_from_file(FILE *file)
{
char line[BUFSIZ];
char class_buffer[BUFSIZ], instance[BUFSIZ], recipient[BUFSIZ];
#define DEFSUBS "/dev/null"
-static void load_subscriptions()
+static void
+load_subscriptions(void)
{
FILE *subscriptions_file;
static ZSubscription_t *saved_subscriptions = NULL;
static int number_of_saved_subscriptions;
-void zwgc_shutdown()
+void zwgc_shutdown(void)
{
if (!zwgc_active)
return;
zwgc_active = 0;
}
-void zwgc_startup()
+void zwgc_startup(void)
{
if (zwgc_active)
return;
extern int zwgc_active;
-extern int puntable_address_p(/* string class, instance, recipient */);
-extern void punt();
-extern void unpunt();
-extern void zwgc_shutdown();
-extern void zwgc_startup();
+extern int puntable_address_p(string, string, string);
+extern void punt(string, string, string);
+extern void unpunt(string, string, string);
+extern void zwgc_shutdown(void);
+extern void zwgc_startup(void);
#define USRSUBS ".zephyr.subs"
* The returned string must not be freed.
*/
-static string eat_dollar_sign_stuff(lookup, text_ptr)
- string (*lookup)();
- string *text_ptr; /* Input/Output parameter */
+static string
+eat_dollar_sign_stuff(string (*lookup)(string),
+ string *text_ptr) /* Input/Output parameter */
{
char c;
char closing_brace = 0;
* modified in any way or freed.
*/
-string substitute(lookup, text)
- string (*lookup)();
- string text;
+string
+substitute(string (*lookup)(string),
+ string text)
{
string result_so_far = string_Copy("");
char *p, *temp;
* modified in any way or freed.
*/
-extern string substitute();
+extern string substitute(string (*)(string), string);
#endif
#include "text_operations.h"
#include "char_stack.h"
-string lany(text_ptr, str)
- string *text_ptr;
- string str;
+string
+lany(string *text_ptr,
+ string str)
{
string result, whats_left;
char *p = *text_ptr;
return(result);
}
-string lbreak(text_ptr, set)
- string *text_ptr;
- character_class set;
+string
+lbreak(string *text_ptr,
+ const character_class set)
{
string result, whats_left;
char *p = *text_ptr;
return(result);
}
-string lspan(text_ptr, set)
- string *text_ptr;
- character_class set;
+string
+lspan(string *text_ptr,
+ character_class set)
{
string result, whats_left;
char *p = *text_ptr;
return(result);
}
-string rany(text_ptr, str)
- string *text_ptr;
- string str;
+string
+rany(string *text_ptr,
+ string str)
{
string result, whats_left;
string text = *text_ptr;
return(result);
}
-string rbreak(text_ptr, set)
- string *text_ptr;
- character_class set;
+string
+rbreak(string *text_ptr,
+ character_class set)
{
string result, whats_left;
string text = *text_ptr;
return(result);
}
-string rspan(text_ptr, set)
- string *text_ptr;
- character_class set;
+string
+rspan(string *text_ptr,
+ character_class set)
{
string result, whats_left;
string text = *text_ptr;
#include "character_class.h"
-extern string protect();
-extern string verbatim();
-extern string stylestrip();
-extern string lany();
-extern string lbreak();
-extern string lspan();
-extern string rany();
-extern string rbreak();
-extern string rspan();
+extern string lany(string *, string);
+extern string lbreak(string *, const character_class);
+extern string lspan(string *, character_class);
+extern string rany(string *, string);
+extern string rbreak(string *, character_class);
+extern string rspan(string *, character_class);
#endif
/* The tty & plain filters: */
/* */
/****************************************************************************/
+#define HAVE_TERMCAP_H
+#ifdef HAVE_TERMCAP_H
+#include <termcap.h>
+#endif
#include "new_memory.h"
#include "new_string.h"
#include "error.h"
/***************************************************************************/
-
+#ifndef HAVE_TERMCAP_H
extern int tgetent();
extern char *tgetstr(),*getenv();
#ifdef linux
extern short ospeed;
#endif
char PC;
+#endif
/* Dictionary naming convention:
*code_buf_pos++ = 0, TD_SET(k, code))
static int
-tty_outc(c)
- int c;
+tty_outc(int c)
{
*code_buf_pos++ = c;
return 0;
}
/* ARGSUSED */
-int tty_filter_init(drivername, notfirst, pargc, argv)
-char *drivername;
-char notfirst;
-int *pargc;
-char **argv;
+int
+tty_filter_init(char *drivername,
+ char notfirst,
+ int *pargc,
+ char **argv)
{
static char st_buf[128];
char tc_buf[1024], *p = st_buf, *tmp, *term;
-static int fixed_string_eq(pattern, text, text_length)
- string pattern;
- char *text;
- int text_length;
+static int
+fixed_string_eq(string pattern,
+ char *text,
+ int text_length)
{
while (*pattern && text_length>0 && *pattern == *text) {
pattern++;
unsigned int ignore: 1;
} tty_str_info;
-static void free_info(info)
- tty_str_info *info;
+static void
+free_info(tty_str_info *info)
{
tty_str_info *next_info;
}
}
-static int do_mode_change(current_mode_p, text, text_length)
- tty_str_info *current_mode_p;
- char *text;
- int text_length;
+static int
+do_mode_change(tty_str_info *current_mode_p,
+ char *text,
+ int text_length)
{
/* alignment commands: */
if (fixed_string_eq("left", text, text_length) ||
return 0;
}
-static tty_str_info *convert_desc_to_tty_str_info(desc)
- desctype *desc;
+static tty_str_info *
+convert_desc_to_tty_str_info(desctype *desc)
{
tty_str_info *temp;
tty_str_info *result = NULL;
#define max(a,b) ((a)>(b)?(a):(b))
-static int line_width(left_width, center_width, right_width)
- int left_width;
- int center_width;
- int right_width;
+static int
+line_width(int left_width,
+ int center_width,
+ int right_width)
{
if (center_width>0) {
if (left_width==0 && right_width==0)
}
}
-static int calc_max_line_width(info)
- tty_str_info *info;
+static int
+calc_max_line_width(tty_str_info *info)
{
int max_line_width = 0;
int left = 0;
return(max_line_width);
}
-string tty_filter(text, use_fonts)
- string text;
- int use_fonts;
+string
+tty_filter(string text,
+ int use_fonts)
{
string text_copy = string_Copy(text);
string result_so_far = string_Copy("");
* Effects: Returns true iff text matches [0-9]*. ("" matches...)
*/
-static int is_digits(text)
- string text;
+static int
+is_digits(string text)
{
for (; *text; text++)
if (!isdigit(*text))
* Effects: Sets all description langauge variables to "".
*/
-void var_clear_all_variables()
+void
+var_clear_all_variables(void)
{
if (non_number_variable_dict) {
string_dictionary_SafeDestroy(non_number_variable_dict);
* call. DO NOT FREE THIS STRING.
*/
-string var_get_variable(name)
- string name;
+string
+var_get_variable(string name)
{
char *result;
int field_to_get;
* to have the value value.
*/
-void var_set_variable(name, value)
- string name;
- string value;
+void
+var_set_variable(string name,
+ string value)
{
string_dictionary_Set(is_number_variable(name) ? number_variable_dict
: non_number_variable_dict, name, value);
* to have as its value number's ascii representation.
*/
-void var_set_variable_to_number(name, number)
- string name;
- int number;
+void
+var_set_variable_to_number(string name,
+ int number)
{
char buffer[20];
* convenience reasons.
*/
-void var_set_variable_then_free_value(name, value)
- string name;
- string value;
+void
+var_set_variable_then_free_value(string name,
+ string value)
{
string_dictionary_binding *binding;
int exists;
* data or var_clear_all_variables is called.
*/
-void var_set_number_variables_to_fields(data, length)
- char *data;
- int length;
+void
+var_set_number_variables_to_fields(char *data,
+ int length)
{
fields_data = data;
fields_data_length = length;
* Effects: Sets all description langauge variables to "".
*/
-extern void var_clear_all_variables();
+extern void var_clear_all_variables(void);
/*
* string var_get_variable(string name)
* call. DO NOT FREE THIS STRING.
*/
-extern string var_get_variable();
+extern string var_get_variable(string);
/*
* void var_set_variable(string name, value)
* to have the value value.
*/
-extern void var_set_variable();
+extern void var_set_variable(string, string);
/*
* void var_set_variable_to_number(string name; int number)
* to have as its value number's ascii representation.
*/
-extern void var_set_variable_to_number();
+extern void var_set_variable_to_number(string, int);
/*
* void var_set_variable_then_free_value(string name, value)
* convenience reasons.
*/
-extern void var_set_variable_then_free_value();
+extern void var_set_variable_then_free_value(string, string);
/*
* void var_set_number_variables_to_fields(char *data, int length)
* data or var_clear_all_variables is called.
*/
-extern void var_set_number_variables_to_fields();
+extern void var_set_number_variables_to_fields(char *, int);
#endif
*
*/
-extern char *xmarkGetText();
-
extern long ttl;
static char *selected_text=NULL;
static Window selecting_in = 0;
-char *getSelectedText()
+char *
+getSelectedText(void)
{
return(selected_text);
}
#ifdef notdef
-static string x_gram_to_string(gram)
- x_gram *gram;
+static string
+x_gram_to_string(x_gram *gram)
{
int i, index, len;
int last_y = -1;
*/
/*ARGSUSED*/
-Bool isShiftButton1(dpy,event,arg)
- Display *dpy;
- XEvent *event;
- char *arg;
+Bool
+isShiftButton1(Display *dpy,
+ XEvent *event,
+ char *arg)
{
return(event->xbutton.state & (ShiftMask|Button1Mask));
}
/*ARGSUSED*/
-Bool isShiftButton3(dpy,event,arg)
- Display *dpy;
- XEvent *event;
- char *arg;
+Bool
+isShiftButton3(Display *dpy,
+ XEvent *event,
+ char *arg)
{
return(event->xbutton.state & (ShiftMask|Button3Mask));
}
-void getLastEvent(dpy,state,event)
- Display *dpy;
- unsigned int state;
- XEvent *event;
+void
+getLastEvent(Display *dpy,
+ unsigned int state,
+ XEvent *event)
{
XEvent xev;
}
}
-void xunmark(dpy,w,gram,desc_context)
- Display *dpy;
- Window w;
- x_gram *gram;
- XContext desc_context;
+void
+xunmark(Display *dpy,
+ Window w,
+ x_gram *gram,
+ XContext desc_context)
{
if (gram == NULL)
if (XFindContext(dpy, w, desc_context, (caddr_t *) &gram))
static int current_pressop = PRESSOP_NONE;
-void xdestroygram(dpy,w,desc_context,gram)
- Display *dpy;
- Window w;
- XContext desc_context;
- x_gram *gram;
+void
+xdestroygram(Display *dpy,
+ Window w,
+ XContext desc_context,
+ x_gram *gram)
{
struct timeval now;
}
}
-void xcut(dpy,event,desc_context)
- Display *dpy;
- XEvent *event;
- XContext desc_context;
+void
+xcut(Display *dpy,
+ XEvent *event,
+ XContext desc_context)
{
x_gram *gram;
Window w = event->xany.window;
int xerror_happened;
/*ARGSUSED*/
-static int xerrortrap(dpy,xerrev)
- Display *dpy;
- XErrorEvent *xerrev;
+static int
+xerrortrap(Display *dpy,
+ XErrorEvent *xerrev)
{
xerror_happened = 1;
return 0;
}
/*ARGSUSED*/
-void begin_xerror_trap(dpy)
- Display *dpy;
+void
+begin_xerror_trap(Display *dpy)
{
xerror_happened = 0;
XSetErrorHandler(xerrortrap);
}
-void end_xerror_trap(dpy)
- Display *dpy;
+void
+end_xerror_trap(Display *dpy)
{
XSync(dpy,False);
XSetErrorHandler(NULL);
extern int xerror_happened;
-void begin_xerror_trap();
-void end_xerror_trap();
+void begin_xerror_trap(Display *);
+void end_xerror_trap(Display *);
#endif
(STARTCHAR != -1) && (ENDCHAR != -1) && \
(STARTPIXEL != -1) && (ENDPIXEL != -1))
-void xmarkSetBound(gram,x,y,which)
- x_gram *gram;
- int x,y;
- int which;
+void
+xmarkSetBound(x_gram *gram,
+ int x,
+ int y,
+ int which)
{
int i,xofs,yofs;
XFontStruct *font;
}
/* needs both bounds to be valid (!= -1) */
-static int xmarkNearest(x,y)
- int x,y;
+static int
+xmarkNearest(int x,
+ int y)
{
int middle;
}
}
-void xmarkExpose(dpy,w,gram,b1,p1,b2,p2)
- Display *dpy;
- Window w;
- x_gram *gram;
- unsigned int b1,p1,b2,p2;
+void
+xmarkExpose(Display *dpy,
+ Window w,
+ x_gram *gram,
+ unsigned int b1,
+ unsigned int p1,
+ unsigned int b2,
+ unsigned int p2)
{
#define swap(x,y) temp=(x); (x)=(y); (y)=temp
int i,temp;
/* Public functions: */
-void xmarkRedraw(dpy,w,gram,range)
- Display *dpy;
- Window w;
- x_gram *gram;
- int range;
+void
+xmarkRedraw(Display *dpy,
+ Window w,
+ x_gram *gram,
+ int range)
{
#define ob1 ((unsigned int) oldblock[XMARK_START_BOUND])
#define ob2 ((unsigned int) oldblock[XMARK_END_BOUND])
}
/* needs both bounds to be valid (!= -1) */
-int xmarkSecond()
+int
+xmarkSecond(void)
{
if (STARTBLOCK > ENDBLOCK)
return(XMARK_START_BOUND);
}
}
-void xmarkClear()
+void
+xmarkClear(void)
{
oldblock[0]=markblock[0];
oldblock[1]=markblock[1];
markgram=NULL;
}
-int xmarkExtendFromFirst(gram,x,y)
- x_gram *gram;
- int x,y;
+int
+xmarkExtendFromFirst(x_gram *gram,
+ int x,
+ int y)
{
if (markgram != gram) {
xmarkClear();
}
}
-int xmarkExtendFromNearest(gram,x,y)
- x_gram *gram;
- int x,y;
+int
+xmarkExtendFromNearest(x_gram *gram,
+ int x,
+ int y)
{
int bound;
}
}
-char *xmarkGetText()
+char *
+xmarkGetText(void)
{
int i, index, len;
int last_y = -1;
#define STARTPIXEL (markpixel[XMARK_START_BOUND])
#define ENDPIXEL (markpixel[XMARK_END_BOUND])
-extern void xmarkSetBound();
-extern int xmarkSecond();
-extern void xmarkRedraw();
-extern void xmarkClear();
-extern int xmarkExtendFromStart();
-extern int xmarkExtendFromNearest();
+extern void xmarkSetBound(x_gram *, int, int, int);
+extern int xmarkSecond(void);
+extern void xmarkRedraw(Display *, Window, x_gram *, int);
+extern void xmarkClear(void);
+extern int xmarkExtendFromFirst(x_gram *, int, int);
+extern int xmarkExtendFromNearest(x_gram *, int, int);
+extern char *xmarkGetText(void);
#endif
x_gram *unlinked = NULL;
int reverse_stack = 0;
-void add_to_bottom(gram)
- x_gram *gram;
+void
+add_to_bottom(x_gram *gram)
{
if (bottom_gram) {
bottom_gram->below = gram;
}
/*ARGSUSED*/
-void pull_to_top(gram)
- x_gram *gram;
-{}
+void
+pull_to_top(x_gram *gram)
+{
+}
/*ARGSUSED*/
-void push_to_bottom(gram)
- x_gram *gram;
-{}
+void
+push_to_bottom(x_gram *gram)
+{
+}
-void delete_gram(gram)
- x_gram *gram;
+void
+delete_gram(x_gram *gram)
{
if (gram == bottom_gram) {
if (gram->above) {
gram->above = gram;
}
-void unlink_gram(gram)
- x_gram *gram;
+void
+unlink_gram(x_gram *gram)
{
delete_gram(gram);
static x_gram *top_gram=NULL;
#ifdef DEBUG
-void print_gram_list(str)
-char *str;
+void
+print_gram_list(char *str)
{
x_gram *gram;
char buf[80];
}
#endif
-void pull_to_top(gram)
-x_gram *gram;
+void
+pull_to_top(x_gram *gram)
{
if (gram==top_gram) {
/* already here */
#endif
}
-void push_to_bottom(gram)
-x_gram *gram;
+void
+push_to_bottom(x_gram *gram)
{
if (gram==bottom_gram) {
/* already here */
#endif
}
-void unlink_gram(gram)
-x_gram *gram;
+void
+unlink_gram(x_gram *gram)
{
if (top_gram==bottom_gram) {
/* the only gram in the stack */
}
#ifdef notdef
-void add_to_top(gram)
-x_gram *gram;
+void
+add_to_top(x_gram *gram)
{
if (top_gram==NULL) {
gram->above=NULL;
}
#endif
-void add_to_bottom(gram)
-x_gram *gram;
+void
+add_to_bottom(x_gram *gram)
{
if (bottom_gram==NULL) {
gram->above=NULL;
extern x_gram *unlinked;
extern int reverse_stack; /* is reverse stack on? */
-extern void add_to_bottom(/* x_gram */);
-extern void delete_gram(/* x_gram */);
-extern void unlink_gram(/* x_gram */);
-extern void pull_to_top(/* x_gram */);
-extern void push_to_bottom(/* x_gram */);
+extern void add_to_bottom(x_gram *);
+extern void delete_gram(x_gram *);
+extern void unlink_gram(x_gram *);
+extern void pull_to_top(x_gram *);
+extern void push_to_bottom(x_gram *);
#endif /* _XREVSTACK_H_ */
#include "new_string.h"
#include "xselect.h"
-extern char *getSelectedText();
+extern char *getSelectedText(void);
static Time ownership_start = CurrentTime;
static Time ownership_end = CurrentTime;
/* internal static functions */
-static void xselNotify(dpy,selreq,property)
- Display *dpy;
- XSelectionRequestEvent *selreq;
- Atom property;
+static void
+xselNotify(Display *dpy,
+ XSelectionRequestEvent *selreq,
+ Atom property)
{
XSelectionEvent ev;
XChangeProperty(dpy,w,PROP(property,target),(type),(format), \
PropModeReplace, (unsigned char *) (data),(size))
-static void xselSetProperties(dpy,w,property,target,selreq)
- Display *dpy;
- Window w;
- Atom property,target;
- XSelectionRequestEvent *selreq;
+static void
+xselSetProperties(Display *dpy,
+ Window w,
+ Atom property,
+ Atom target,
+ XSelectionRequestEvent *selreq)
{
if (target==ZA_TARGETS) {
/* global functions */
-void xicccmInitAtoms(dpy)
- Display *dpy;
+void
+xicccmInitAtoms(Display *dpy)
{
int i;
RequestAtoms[i] = *(pRequestAtoms[i]);
}
-int xselGetOwnership(dpy,w,time)
- Display *dpy;
- Window w;
- Time time;
+int
+xselGetOwnership(Display *dpy,
+ Window w,
+ Time time)
{
int temp;
}
/* Get the selection. Return !0 if success, 0 if fail */
-int xselProcessSelection(dpy,w,event)
- Display *dpy;
- Window w;
- XEvent *event;
+int
+xselProcessSelection(Display *dpy,
+ Window w,
+ XEvent *event)
{
XSelectionRequestEvent *selreq = &(event->xselectionrequest);
return(1);
}
-void xselOwnershipLost(time)
- Time time;
+void
+xselOwnershipLost(Time time)
{
ownership_end = time;
}
/*ARGSUSED*/
-void xselGiveUpOwnership(dpy,w)
- Display *dpy;
- Window w;
+void
+xselGiveUpOwnership(Display *dpy,
+ Window w)
{
XSetSelectionOwner(dpy,XA_PRIMARY,None,ownership_start);
#ifndef _XSELECT_H_
#define _XSELECT_H_
-extern void xicccmInitAtoms();
-extern int xselGetOwnership();
-extern int xselProcessSelection();
-extern void xselOwnershipLost();
-extern void xselGiveUpOwnership();
+extern void xicccmInitAtoms(Display *);
+extern int xselGetOwnership(Display *, Window, Time);
+extern int xselProcessSelection(Display *, Window, XEvent *);
+extern void xselOwnershipLost(Time);
+extern void xselGiveUpOwnership(Display *, Window);
-extern int xwmprotoDelete();
-
-extern Atom XA_WM_PROTOCOLS,XA_WM_DELETE_WINDOW;
+extern Atom XA_WM_PROTOCOLS, XA_WM_DELETE_WINDOW;
#endif
#include <X11/Xresource.h>
#include "pointer_dictionary.h"
#include "new_memory.h"
+#include "new_string.h"
#include "formatter.h"
#include "variables.h"
#include "zwgc.h"
+#include "X_driver.h"
#include "X_fonts.h"
#include "X_gram.h"
#include "xmode_stack.h"
extern int internal_border_width;
extern unsigned long default_bgcolor;
extern unsigned long default_fgcolor;
-extern unsigned long x_string_to_color();
void
-xshowinit()
+xshowinit(void)
{
desc_context = XUniqueContext();
}
char * resclass;
};
-static char *xres_get_resource (restype, style)
- struct res_dict_type *restype;
- char *style;
+static char *
+xres_get_resource(struct res_dict_type *restype,
+ char *style)
{
char *desc;
pointer_dictionary_binding *binding;
};
/*ARGSUSED*/
-char *mode_to_colorname (dpy, style, mode)
- Display *dpy;
- char *style;
- xmode *mode;
+char *
+mode_to_colorname (Display *dpy,
+ char *style,
+ xmode *mode)
{
char *desc, *result;
return result;
}
-void fixup_and_draw(dpy, style, auxblocks, blocks, num, lines, numlines,
- beepcount)
- Display *dpy;
- char *style;
- xblock *blocks;
- xauxblock *auxblocks;
- int num;
- xlinedesc *lines;
- int numlines;
- int beepcount;
+void
+fixup_and_draw(Display *dpy,
+ char *style,
+ xauxblock *auxblocks,
+ xblock *blocks,
+ int num,
+ xlinedesc *lines,
+ int numlines,
+ int beepcount)
{
int gram_xalign = 1;
int gram_yalign = 1;
}
/* Silly almost-but-not-quite-useless helper function */
-char *no_dots_downcase_var(str)
- char *str;
+char *
+no_dots_downcase_var(char *str)
{
register char *var, *var2;
#define MODE_TO_FONT(dpy,style,mode) \
get_font((dpy),(style),(mode)->font?(mode)->font:(mode)->substyle, \
(mode)->size, (mode)->bold+(mode)->italic*2)
-void xshow(dpy, desc, numstr, numnl)
- Display *dpy;
- desctype *desc;
- int numstr;
- int numnl;
+void
+xshow(Display *dpy,
+ desctype *desc,
+ int numstr,
+ int numnl)
{
XFontStruct *font;
xmode_stack modes = xmode_stack_create();
free(style);
}
-static void xhandleevent(dpy, w, event)
- Display *dpy;
- Window w;
- XEvent *event;
+static void
+xhandleevent(Display *dpy,
+ Window w,
+ XEvent *event)
{
x_gram *gram;
XFlush(dpy);
}
-void x_get_input(dpy)
- Display *dpy;
+void
+x_get_input(Display *dpy)
{
XEvent event;
* modified in any way.
*/
-static string get_zwgc_port_number_filename()
+static string
+get_zwgc_port_number_filename(void)
{
static char buffer[40];
char *temp;
- char *getenv();
if (temp = getenv("WGFILE"))
return(temp);
* Write out the port number to the wg file.
*/
-void write_wgfile()
+void
+write_wgfile(void)
{
char *name = get_zwgc_port_number_filename();
FILE *port_file;
*
*/
-static void handle_zephyr_input(notice_handler)
- void (*notice_handler)();
+static void
+handle_zephyr_input(void (*notice_handler)(ZNotice_t *))
{
ZNotice_t *notice;
struct sockaddr_in from;
*
*/
-void zephyr_init(notice_handler)
- void (*notice_handler)();
+void zephyr_init(void (*notice_handler)(ZNotice_t *))
{
char *temp;
char *exposure;
/*
* <<<>>>
*/
- mux_add_input_source(ZGetFD(), (void (*)())handle_zephyr_input,
+ mux_add_input_source(ZGetFD(), (void (*)(void *))handle_zephyr_input,
notice_handler);
zephyr_inited = 1;
return;
*
*/
-void finalize_zephyr() /* <<<>>> */
+void finalize_zephyr(void) /* <<<>>> */
{
string temp;
#ifndef zephyr_MODULE
#define zephyr_MODULE
-extern void zephyr_init();
-extern void finalize_zephyr();
-extern void write_wgfile();
+extern void zephyr_init(void(*)(ZNotice_t *));
+extern void finalize_zephyr(void);
+extern void write_wgfile(void);
#endif
projects / 1ts-debian.git / commitdiff