Mercurial > hg > xemacs-beta
changeset 647:b39c14581166
[xemacs-hg @ 2001-08-13 04:45:47 by ben]
removal of unsigned, size_t, etc.
line wrap: on
line diff
--- a/lib-src/ChangeLog Wed Aug 08 12:15:04 2001 +0000 +++ b/lib-src/ChangeLog Mon Aug 13 04:46:48 2001 +0000 @@ -1,3 +1,18 @@ +2001-06-24 Ben Wing <ben@xemacs.org> + + * gnuserv.c (permitted): + * gnuserv.c (setup_table): + * gnuslib.c (connect_to_internet_server): + * make-docfile.c (scan_c_file): + * mmencode.c (fromqp): + * movemail.c: + * movemail.c (main): + * movemail.c (xmalloc): + * ootags.c (prolog_pred): + * ootags.c (erlang_func): + * yow.c (yow): + Fix unsigned warnings. See src/ChangeLog for details. + 2001-07-28 Stephen J. Turnbull <stephen@xemacs.org> * XEmacs 21.5.2 "artichoke" is released.
--- a/lib-src/gnuserv.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lib-src/gnuserv.c Mon Aug 13 04:46:48 2001 +0000 @@ -485,17 +485,18 @@ * doing magic cookie auth */ - if (timed_read(fd, buf, 10, AUTH_TIMEOUT, 1) <= 0) + if (timed_read (fd, buf, 10, AUTH_TIMEOUT, 1) <= 0) return FALSE; - auth_data_len = atoi(buf); + auth_data_len = atoi (buf); - if (auth_data_len <= 0 || auth_data_len > sizeof(buf)) + if (auth_data_len <= 0 || auth_data_len > (int) sizeof (buf)) { return FALSE; } - if (timed_read(fd, buf, auth_data_len, AUTH_TIMEOUT, 0) != auth_data_len) + if (timed_read (fd, buf, auth_data_len, AUTH_TIMEOUT, 0) != + auth_data_len) return FALSE; #ifdef AUTH_MAGIC_COOKIE @@ -508,10 +509,12 @@ ( auth_data_len ^ server_xauth->data_length ); - for(auth_data_pos=0; auth_data_pos < auth_data_len; ++auth_data_pos) + for(auth_data_pos = 0; auth_data_pos < auth_data_len; + ++auth_data_pos) auth_mismatches |= ( buf[auth_data_pos] ^ - server_xauth->data[auth_data_pos % server_xauth->data_length]); + server_xauth->data[auth_data_pos % + server_xauth->data_length]); if (auth_mismatches == 0) return TRUE; @@ -604,7 +607,7 @@ gethostname(hostname,HOSTNAMSZ); - if ((host_addr = internet_addr(hostname)) == -1) + if ((host_addr = internet_addr (hostname)) == (unsigned int) -1) { fprintf(stderr,"%s: unable to find %s in /etc/hosts or from YP", progname,hostname); @@ -630,9 +633,10 @@ (host_file = fopen(file_name,"r")) != NULL)) /* opened ok */ { while ((fscanf(host_file,"%s",hostname) != EOF)) /* find a host */ - if ((host_addr = internet_addr(hostname)) != -1)/* get its addr */ + if ((host_addr = internet_addr(hostname)) != (unsigned int) -1) + /* get its addr */ { - add_host(host_addr); /* add the addr */ + add_host(host_addr); /* add the addr */ hosts++; } fclose(host_file);
--- a/lib-src/gnuslib.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lib-src/gnuslib.c Mon Aug 13 04:46:48 2001 +0000 @@ -327,11 +327,13 @@ peeraddr_in.sin_family = AF_INET; /* look up the server host's internet address */ - if ((peeraddr_in.sin_addr.s_addr = internet_addr(serverhost)) == -1) { - fprintf(stderr,"%s: unable to find %s in /etc/hosts or from YP\n", - progname,serverhost); - exit(1); - }; /* if */ + if ((peeraddr_in.sin_addr.s_addr = internet_addr (serverhost)) == + (unsigned int) -1) + { + fprintf (stderr, "%s: unable to find %s in /etc/hosts or from YP\n", + progname, serverhost); + exit(1); + } if (port == 0) { if ((sp = getservbyname ("gnuserv","tcp")) == NULL)
--- a/lib-src/make-docfile.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lib-src/make-docfile.c Mon Aug 13 04:46:48 2001 +0000 @@ -512,15 +512,15 @@ int l = strlen (filename); char f[MAXPATHLEN]; - if (l > sizeof (f)) - { + if (l > (int) sizeof (f)) + { #ifdef ENAMETOOLONG - errno = ENAMETOOLONG; + errno = ENAMETOOLONG; #else - errno = EINVAL; + errno = EINVAL; #endif - return (0); - } + return (0); + } strcpy (f, filename); if (f[l - 1] == 'o')
--- a/lib-src/mmencode.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lib-src/mmencode.c Mon Aug 13 04:46:48 2001 +0000 @@ -349,7 +349,7 @@ static void fromqp(FILE *infile, FILE *outfile, char **boundaries, int *boundaryct) { - unsigned int c1, c2; + int c1, c2; int sawnewline = 1, neednewline = 0; /* The neednewline hack is necessary because the newline leading into a multipart boundary is part of the boundary, not the data */
--- a/lib-src/movemail.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lib-src/movemail.c Mon Aug 13 04:46:48 2001 +0000 @@ -142,7 +142,7 @@ static void pfatal_with_name (char *); static void pfatal_and_delete (char *); static char *concat (char *, char *, char *); -static long *xmalloc (unsigned int); +static long *xmalloc (int); #ifdef MAIL_USE_POP static int popmail (char *, char *, char *); static int pop_retr (popserver server, int msgno, @@ -440,7 +440,7 @@ errno = saved_errno; pfatal_with_name (outname); } - if (nread < sizeof buf) + if (nread < (int) sizeof (buf)) break; } } @@ -699,7 +699,7 @@ /* Like malloc but get fatal error if memory is exhausted. */ static long * -xmalloc (unsigned int size) +xmalloc (int size) { long *result = (long *) malloc (size); if (!result)
--- a/lib-src/ootags.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lib-src/ootags.c Mon Aug 13 04:46:48 2001 +0000 @@ -4411,7 +4411,7 @@ /* Save only the first clause. */ if (last == NULL - || len != strlen (last) + || len != (int) strlen (last) || !strneq (s, last, len)) { pfnote ((CTAGS) ? savenstr (s, len) : NULL, TRUE, @@ -4565,7 +4565,7 @@ /* Save only the first clause. */ if (s[pos++] == '(' && (last == NULL - || len != strlen (last) + || len != (int) strlen (last) || !strneq (s, last, len))) { pfnote ((CTAGS) ? savenstr (s, len) : NULL, TRUE,
--- a/lib-src/yow.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lib-src/yow.c Mon Aug 13 04:46:48 2001 +0000 @@ -124,7 +124,7 @@ long offset; int c, i = 0; char *buf; - unsigned int bufsize; + int bufsize; offset = rand() % len + header_len; if (fseek(fp, offset, 0) == -1) {
--- a/lisp/ChangeLog Wed Aug 08 12:15:04 2001 +0000 +++ b/lisp/ChangeLog Mon Aug 13 04:46:48 2001 +0000 @@ -1,3 +1,25 @@ +2001-06-19 Ben Wing <ben@xemacs.org> + + * term\AT386.el: + * term\AT386.el (AT386-keypad-map): + * term\AT386.el (AT386-keypad-map)): New. + Fix warnings. + + * term\linux.el: + * term\lk201.el: + * term\news.el: + * term\news.el (news-fkey-prefix)): New. + * term\vt100.el: + * term\vt100.el (vt100-wide-mode): + Sync with FSF 21.0.103. + Fix warnings. + +2001-06-19 Ben Wing <ben@xemacs.org> + + * dialog-gtk.el (popup-builtin-open-dialog): Fix warning. + * hyper-apropos.el: Fix problem with undefined face. + * update-elc.el (update-elc-files-to-compile): Compile in proper order. + 2001-08-08 Didier Verna <didier@xemacs.org> * autoload.el (make-autoload): handle the case of
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lisp/auto-autoloads.el Mon Aug 13 04:46:48 2001 +0000 @@ -0,0 +1,2034 @@ +;;; DO NOT MODIFY THIS FILE +(if (featurep 'lisp-autoloads) (error "Already loaded")) + +;;;### (autoloads nil "abbrev" "lisp/abbrev.el") + +;;;*** + +;;;### (autoloads (about-xemacs) "about" "lisp/about.el") + +(autoload 'about-xemacs "about" "\ +Describe the True Editor and its minions." t nil) + +;;;*** + +;;;### (autoloads (set-modified-alist modify-alist remove-alist set-alist del-alist put-alist vassoc) "alist" "lisp/alist.el") + +(autoload 'vassoc "alist" "\ +Search VALIST for a vector whose first element is equal to KEY. +See also `assoc'." nil nil) + +(autoload 'put-alist "alist" "\ +Modify ALIST to set VALUE to ITEM. +If there is a pair whose car is ITEM, replace its cdr by VALUE. +If there is not such pair, create new pair (ITEM . VALUE) and +return new alist whose car is the new pair and cdr is ALIST. +[tomo's ELIS like function]" nil nil) + +(autoload 'del-alist "alist" "\ +If there is a pair whose key is ITEM, delete it from ALIST. +[tomo's ELIS emulating function]" nil nil) + +(autoload 'set-alist "alist" "\ +Modify a alist indicated by SYMBOL to set VALUE to ITEM." nil nil) + +(autoload 'remove-alist "alist" "\ +Remove ITEM from the alist indicated by SYMBOL." nil nil) + +(autoload 'modify-alist "alist" "\ +Modify alist DEFAULT into alist MODIFIER." nil nil) + +(autoload 'set-modified-alist "alist" "\ +Modify a value of a symbol SYM into alist MODIFIER. +The symbol SYM should be alist. If it is not bound, +its value regard as nil." nil nil) + +;;;*** + +;;;### (autoloads (apropos-documentation apropos-value apropos apropos-command) "apropos" "lisp/apropos.el") + +(fset 'command-apropos 'apropos-command) + +(autoload 'apropos-command "apropos" "\ +Shows commands (interactively callable functions) that match REGEXP. +With optional prefix ARG or if `apropos-do-all' is non-nil, also show +variables." t nil) + +(autoload 'apropos "apropos" "\ +Show all bound symbols whose names match REGEXP. +With optional prefix ARG or if `apropos-do-all' is non-nil, also show unbound +symbols and key bindings, which is a little more time-consuming. +Returns list of symbols and documentation found." t nil) + +(autoload 'apropos-value "apropos" "\ +Show all symbols whose value's printed image matches REGEXP. +With optional prefix ARG or if `apropos-do-all' is non-nil, also looks +at the function and at the names and values of properties. +Returns list of symbols and values found." t nil) + +(autoload 'apropos-documentation "apropos" "\ +Show symbols whose documentation contain matches for REGEXP. +With optional prefix ARG or if `apropos-do-all' is non-nil, also use +documentation that is not stored in the documentation file and show key +bindings. +Returns list of symbols and documentation found." t nil) + +;;;*** + +;;;### (autoloads (batch-force-update-one-directory batch-update-one-directory batch-update-directory batch-update-autoloads update-autoload-files update-autoloads-from-directory update-autoloads-here update-file-autoloads generate-file-autoloads) "autoload" "lisp/autoload.el") + +(autoload 'generate-file-autoloads "autoload" "\ +Insert at point a loaddefs autoload section for FILE. +autoloads are generated for defuns and defmacros in FILE +marked by `generate-autoload-cookie' (which see). +If FILE is being visited in a buffer, the contents of the buffer +are used." t nil) + +(autoload 'update-file-autoloads "autoload" "\ +Update the autoloads for FILE in `generated-autoload-file' +\(which FILE might bind in its local variables). +This function refuses to update autoloads files." t nil) + +(autoload 'update-autoloads-here "autoload" "\ +Update sections of the current buffer generated by `update-file-autoloads'." t nil) + +(autoload 'update-autoloads-from-directory "autoload" "\ +Update `generated-autoload-file' with all the current autoloads from DIR. +This runs `update-file-autoloads' on each .el file in DIR. +Obsolete autoload entries for files that no longer exist are deleted. +Note that, if this function is called from `batch-update-directory', +`generated-autoload-file' was rebound in that function. + +You don't really want to be calling this function. Try using +`update-autoload-files' instead." t nil) + +(autoload 'update-autoload-files "autoload" "\ +Update all the autoload files associated with FILES-OR-DIRS. +FILES-OR-DIRS should be a list of files or directories to be +processed. If ALL-INTO-ONE-FILE is not given, the appropriate +autoload file for each file or directory (located in that directory, +or in the directory of the specified file) will be updated with the +directory's or file's autoloads, some additional fixup text will be +added, and the files will be saved. If ALL-INTO-ONE-FILE is given, +`generated-autoload-file' should be set to the name of the autoload +file into which the autoloads will be generated, and the autoloads +for all files and directories will go into that same file. + +If FORCE is non-nil, always save out the autoload files even if unchanged." nil nil) + +(autoload 'batch-update-autoloads "autoload" "\ +Update the autoloads for the files or directories on the command line. +Runs `update-file-autoloads' on files and `update-directory-autoloads' +on directories. Must be used only with -batch, and kills Emacs on completion. +Each file will be processed even if an error occurred previously. +For example, invoke `xemacs -batch -f batch-update-autoloads *.el'. +The directory to which the auto-autoloads.el file must be the first parameter +on the command line." nil nil) + +(autoload 'batch-update-directory "autoload" "\ +Update the autoloads for the directories on the command line. +Runs `update-file-autoloads' on each file in the given directory, and must +be used only with -batch." nil nil) + +(autoload 'batch-update-one-directory "autoload" "\ +Update the autoloads for a single directory on the command line. +Runs `update-file-autoloads' on each file in the given directory, and must +be used only with -batch." nil nil) + +(autoload 'batch-force-update-one-directory "autoload" "\ +Update the autoloads for a single directory on the command line. +Runs `update-file-autoloads' on each file in the given directory, and must +be used only with -batch. Always rewrite the autoloads file, even if +unchanged." nil nil) + +;;;*** + +;;;### (autoloads nil "buff-menu" "lisp/buff-menu.el") + +(defvar list-buffers-directory nil) + +(make-variable-buffer-local 'list-buffers-directory) + +;;;*** + +;;;### (autoloads (build-report) "build-report" "lisp/build-report.el") + +(autoload 'build-report "build-report" "\ +Report build information including Installation and make output. + +Prompts for status (usually \"Success\" or \"Failure\"). Then uses +`compose-mail' to create a mail message. The Subject header contains +status and version information. Point is left at the beginning of the +mail text. Add some notes if you like, and send the report. + +Looks for Installation and the make output file (`beta.err' by +default, customizable via `build-report-make-output-files') in the +build directory of the running XEmacs by default (customizable via +`build-report-make-output-dir'). The output from make is filtered +through `build-report-keep-regexp' and `build-report-delete-regexp' +before including in the message. + +See also `mail-user-agent', `build-report-destination', and +`build-report-installation-file'." t nil) + +;;;*** + +;;;### (autoloads (batch-byte-recompile-directory batch-byte-recompile-directory-norecurse batch-byte-compile-one-file batch-byte-compile display-call-tree byte-compile-sexp byte-compile compile-defun byte-compile-buffer byte-compile-and-load-file byte-compile-file byte-recompile-file byte-recompile-directory byte-force-recompile) "bytecomp" "lisp/bytecomp.el") + +(autoload 'byte-force-recompile "bytecomp" "\ +Recompile every `.el' file in DIRECTORY that already has a `.elc' file. +Files in subdirectories of DIRECTORY are processed also." t nil) + +(autoload 'byte-recompile-directory "bytecomp" "\ +Recompile every `.el' file in DIRECTORY that needs recompilation. +This is if a `.elc' file exists but is older than the `.el' file. +Files in subdirectories of DIRECTORY are also processed unless +optional argument NORECURSION is non-nil. + +If the `.elc' file does not exist, normally the `.el' file is *not* compiled. +But a prefix argument (optional second arg) means ask user, +for each such `.el' file, whether to compile it. Prefix argument 0 means +don't ask and compile the file anyway. + +A nonzero prefix argument also means ask about each subdirectory. + +If the fourth optional argument FORCE is non-nil, +recompile every `.el' file that already has a `.elc' file." t nil) + +(autoload 'byte-recompile-file "bytecomp" "\ +Recompile a file of Lisp code named FILENAME if it needs recompilation. +This is if the `.elc' file exists but is older than the `.el' file. + +If the `.elc' file does not exist, normally the `.el' file is *not* +compiled. But a prefix argument (optional second arg) means ask user +whether to compile it. Prefix argument 0 don't ask and recompile anyway." t nil) + +(autoload 'byte-compile-file "bytecomp" "\ +Compile a file of Lisp code named FILENAME into a file of byte code. +The output file's name is made by appending `c' to the end of FILENAME. +With prefix arg (noninteractively: 2nd arg), load the file after compiling." t nil) + +(autoload 'byte-compile-and-load-file "bytecomp" "\ +Compile a file of Lisp code named FILENAME into a file of byte code, +and then load it. The output file's name is made by appending \"c\" to +the end of FILENAME." t nil) + +(autoload 'byte-compile-buffer "bytecomp" "\ +Byte-compile and evaluate contents of BUFFER (default: the current buffer)." t nil) + +(autoload 'compile-defun "bytecomp" "\ +Compile and evaluate the current top-level form. +Print the result in the minibuffer. +With argument, insert value in current buffer after the form." t nil) + +(autoload 'byte-compile "bytecomp" "\ +If FORM is a symbol, byte-compile its function definition. +If FORM is a lambda or a macro, byte-compile it as a function." nil nil) + +(autoload 'byte-compile-sexp "bytecomp" "\ +Compile and return SEXP." nil nil) + +(autoload 'display-call-tree "bytecomp" "\ +Display a call graph of a specified file. +This lists which functions have been called, what functions called +them, and what functions they call. The list includes all functions +whose definitions have been compiled in this Emacs session, as well as +all functions called by those functions. + +The call graph does not include macros, inline functions, or +primitives that the byte-code interpreter knows about directly (eq, +cons, etc.). + +The call tree also lists those functions which are not known to be called +\(that is, to which no calls have been compiled), and which cannot be +invoked interactively." t nil) + +(autoload 'batch-byte-compile "bytecomp" "\ +Run `byte-compile-file' on the files remaining on the command line. +Use this from the command line, with `-batch'; +it won't work in an interactive Emacs. +Each file is processed even if an error occurred previously. +For example, invoke \"xemacs -batch -f batch-byte-compile $emacs/ ~/*.el\"." nil nil) + +(autoload 'batch-byte-compile-one-file "bytecomp" "\ +Run `byte-compile-file' on a single file remaining on the command line. +Use this from the command line, with `-batch'; +it won't work in an interactive Emacs." nil nil) + +(autoload 'batch-byte-recompile-directory-norecurse "bytecomp" "\ +Same as `batch-byte-recompile-directory' but without recursion." nil nil) + +(autoload 'batch-byte-recompile-directory "bytecomp" "\ +Runs `byte-recompile-directory' on the dirs remaining on the command line. +Must be used only with `-batch', and kills Emacs on completion. +For example, invoke `xemacs -batch -f batch-byte-recompile-directory .'." nil nil) + +;;;*** + +;;;### (autoloads (compiler-macroexpand define-compiler-macro ignore-file-errors ignore-errors assert check-type typep deftype cl-struct-setf-expander defstruct define-modify-macro callf2 callf letf* letf rotatef shiftf remf cl-do-pop psetf setf get-setf-method defsetf define-setf-method declare the locally multiple-value-setq multiple-value-bind lexical-let* lexical-let symbol-macrolet macrolet labels flet progv psetq do-all-symbols do-symbols dotimes dolist do* do loop return-from return block etypecase typecase ecase case load-time-value eval-when destructuring-bind function* defmacro* defun* cl-compile-time-init) "cl-macs" "lisp/cl-macs.el") + +(autoload 'cl-compile-time-init "cl-macs" nil nil nil) + +(autoload 'defun* "cl-macs" "\ +(defun* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a function. +Like normal `defun', except ARGLIST allows full Common Lisp conventions, +and BODY is implicitly surrounded by (block NAME ...)." nil 'macro) + +(autoload 'defmacro* "cl-macs" "\ +(defmacro* NAME ARGLIST [DOCSTRING] BODY...): define NAME as a macro. +Like normal `defmacro', except ARGLIST allows full Common Lisp conventions, +and BODY is implicitly surrounded by (block NAME ...)." nil 'macro) + +(autoload 'function* "cl-macs" "\ +(function* SYMBOL-OR-LAMBDA): introduce a function. +Like normal `function', except that if argument is a lambda form, its +ARGLIST allows full Common Lisp conventions." nil 'macro) + +(autoload 'destructuring-bind "cl-macs" nil nil 'macro) + +(autoload 'eval-when "cl-macs" "\ +(eval-when (WHEN...) BODY...): control when BODY is evaluated. +If `compile' is in WHEN, BODY is evaluated when compiled at top-level. +If `load' is in WHEN, BODY is evaluated when loaded after top-level compile. +If `eval' is in WHEN, BODY is evaluated when interpreted or at non-top-level." nil 'macro) + +(autoload 'load-time-value "cl-macs" "\ +Like `progn', but evaluates the body at load time. +The result of the body appears to the compiler as a quoted constant." nil 'macro) + +(autoload 'case "cl-macs" "\ +(case EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value. +Each clause looks like (KEYLIST BODY...). EXPR is evaluated and compared +against each key in each KEYLIST; the corresponding BODY is evaluated. +If no clause succeeds, case returns nil. A single atom may be used in +place of a KEYLIST of one atom. A KEYLIST of `t' or `otherwise' is +allowed only in the final clause, and matches if no other keys match. +Key values are compared by `eql'." nil 'macro) + +(autoload 'ecase "cl-macs" "\ +(ecase EXPR CLAUSES...): like `case', but error if no case fits. +`otherwise'-clauses are not allowed." nil 'macro) + +(autoload 'typecase "cl-macs" "\ +(typecase EXPR CLAUSES...): evals EXPR, chooses from CLAUSES on that value. +Each clause looks like (TYPE BODY...). EXPR is evaluated and, if it +satisfies TYPE, the corresponding BODY is evaluated. If no clause succeeds, +typecase returns nil. A TYPE of `t' or `otherwise' is allowed only in the +final clause, and matches if no other keys match." nil 'macro) + +(autoload 'etypecase "cl-macs" "\ +(etypecase EXPR CLAUSES...): like `typecase', but error if no case fits. +`otherwise'-clauses are not allowed." nil 'macro) + +(autoload 'block "cl-macs" "\ +(block NAME BODY...): define a lexically-scoped block named NAME. +NAME may be any symbol. Code inside the BODY forms can call `return-from' +to jump prematurely out of the block. This differs from `catch' and `throw' +in two respects: First, the NAME is an unevaluated symbol rather than a +quoted symbol or other form; and second, NAME is lexically rather than +dynamically scoped: Only references to it within BODY will work. These +references may appear inside macro expansions, but not inside functions +called from BODY." nil 'macro) + +(autoload 'return "cl-macs" "\ +(return [RESULT]): return from the block named nil. +This is equivalent to `(return-from nil RESULT)'." nil 'macro) + +(autoload 'return-from "cl-macs" "\ +(return-from NAME [RESULT]): return from the block named NAME. +This jumps out to the innermost enclosing `(block NAME ...)' form, +returning RESULT from that form (or nil if RESULT is omitted). +This is compatible with Common Lisp, but note that `defun' and +`defmacro' do not create implicit blocks as they do in Common Lisp." nil 'macro) + +(autoload 'loop "cl-macs" "\ +(loop CLAUSE...): The Common Lisp `loop' macro. +Valid clauses are: + for VAR from/upfrom/downfrom NUM to/upto/downto/above/below NUM by NUM, + for VAR in LIST by FUNC, for VAR on LIST by FUNC, for VAR = INIT then EXPR, + for VAR across ARRAY, repeat NUM, with VAR = INIT, while COND, until COND, + always COND, never COND, thereis COND, collect EXPR into VAR, + append EXPR into VAR, nconc EXPR into VAR, sum EXPR into VAR, + count EXPR into VAR, maximize EXPR into VAR, minimize EXPR into VAR, + if COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...], + unless COND CLAUSE [and CLAUSE]... else CLAUSE [and CLAUSE...], + do EXPRS..., initially EXPRS..., finally EXPRS..., return EXPR, + finally return EXPR, named NAME." nil 'macro) + +(autoload 'do "cl-macs" "\ +The Common Lisp `do' loop. +Format is: (do ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro) + +(autoload 'do* "cl-macs" "\ +The Common Lisp `do*' loop. +Format is: (do* ((VAR INIT [STEP])...) (END-TEST [RESULT...]) BODY...)" nil 'macro) + +(autoload 'dolist "cl-macs" "\ +(dolist (VAR LIST [RESULT]) BODY...): loop over a list. +Evaluate BODY with VAR bound to each `car' from LIST, in turn. +Then evaluate RESULT to get return value, default nil." nil 'macro) + +(autoload 'dotimes "cl-macs" "\ +(dotimes (VAR COUNT [RESULT]) BODY...): loop a certain number of times. +Evaluate BODY with VAR bound to successive integers from 0, inclusive, +to COUNT, exclusive. Then evaluate RESULT to get return value, default +nil." nil 'macro) + +(autoload 'do-symbols "cl-macs" "\ +(dosymbols (VAR [OBARRAY [RESULT]]) BODY...): loop over all symbols. +Evaluate BODY with VAR bound to each interned symbol, or to each symbol +from OBARRAY." nil 'macro) + +(autoload 'do-all-symbols "cl-macs" nil nil 'macro) + +(autoload 'psetq "cl-macs" "\ +(psetq SYM VAL SYM VAL ...): set SYMs to the values VALs in parallel. +This is like `setq', except that all VAL forms are evaluated (in order) +before assigning any symbols SYM to the corresponding values." nil 'macro) + +(autoload 'progv "cl-macs" "\ +(progv SYMBOLS VALUES BODY...): bind SYMBOLS to VALUES dynamically in BODY. +The forms SYMBOLS and VALUES are evaluated, and must evaluate to lists. +Each SYMBOL in the first list is bound to the corresponding VALUE in the +second list (or made unbound if VALUES is shorter than SYMBOLS); then the +BODY forms are executed and their result is returned. This is much like +a `let' form, except that the list of symbols can be computed at run-time." nil 'macro) + +(autoload 'flet "cl-macs" "\ +(flet ((FUNC ARGLIST BODY...) ...) FORM...): make temporary function defns. +This is an analogue of `let' that operates on the function cell of FUNC +rather than its value cell. The FORMs are evaluated with the specified +function definitions in place, then the definitions are undone (the FUNCs +go back to their previous definitions, or lack thereof)." nil 'macro) + +(autoload 'labels "cl-macs" "\ +(labels ((FUNC ARGLIST BODY...) ...) FORM...): make temporary func bindings. +This is like `flet', except the bindings are lexical instead of dynamic. +Unlike `flet', this macro is fully compliant with the Common Lisp standard." nil 'macro) + +(autoload 'macrolet "cl-macs" "\ +(macrolet ((NAME ARGLIST BODY...) ...) FORM...): make temporary macro defns. +This is like `flet', but for macros instead of functions." nil 'macro) + +(autoload 'symbol-macrolet "cl-macs" "\ +(symbol-macrolet ((NAME EXPANSION) ...) FORM...): make symbol macro defns. +Within the body FORMs, references to the variable NAME will be replaced +by EXPANSION, and (setq NAME ...) will act like (setf EXPANSION ...)." nil 'macro) + +(autoload 'lexical-let "cl-macs" "\ +(lexical-let BINDINGS BODY...): like `let', but lexically scoped. +The main visible difference is that lambdas inside BODY will create +lexical closures as in Common Lisp." nil 'macro) + +(autoload 'lexical-let* "cl-macs" "\ +(lexical-let* BINDINGS BODY...): like `let*', but lexically scoped. +The main visible difference is that lambdas inside BODY will create +lexical closures as in Common Lisp." nil 'macro) + +(autoload 'multiple-value-bind "cl-macs" "\ +(multiple-value-bind (SYM SYM...) FORM BODY): collect multiple return values. +FORM must return a list; the BODY is then executed with the first N elements +of this list bound (`let'-style) to each of the symbols SYM in turn. This +is analogous to the Common Lisp `multiple-value-bind' macro, using lists to +simulate true multiple return values. For compatibility, (values A B C) is +a synonym for (list A B C)." nil 'macro) + +(autoload 'multiple-value-setq "cl-macs" "\ +(multiple-value-setq (SYM SYM...) FORM): collect multiple return values. +FORM must return a list; the first N elements of this list are stored in +each of the symbols SYM in turn. This is analogous to the Common Lisp +`multiple-value-setq' macro, using lists to simulate true multiple return +values. For compatibility, (values A B C) is a synonym for (list A B C)." nil 'macro) + +(autoload 'locally "cl-macs" nil nil 'macro) + +(autoload 'the "cl-macs" nil nil 'macro) + +(autoload 'declare "cl-macs" nil nil 'macro) + +(autoload 'define-setf-method "cl-macs" "\ +(define-setf-method NAME ARGLIST BODY...): define a `setf' method. +This method shows how to handle `setf's to places of the form (NAME ARGS...). +The argument forms ARGS are bound according to ARGLIST, as if NAME were +going to be expanded as a macro, then the BODY forms are executed and must +return a list of five elements: a temporary-variables list, a value-forms +list, a store-variables list (of length one), a store-form, and an access- +form. See `defsetf' for a simpler way to define most setf-methods." nil 'macro) + +(autoload 'defsetf "cl-macs" "\ +(defsetf NAME FUNC): define a `setf' method. +This macro is an easy-to-use substitute for `define-setf-method' that works +well for simple place forms. In the simple `defsetf' form, `setf's of +the form (setf (NAME ARGS...) VAL) are transformed to function or macro +calls of the form (FUNC ARGS... VAL). Example: (defsetf aref aset). +Alternate form: (defsetf NAME ARGLIST (STORE) BODY...). +Here, the above `setf' call is expanded by binding the argument forms ARGS +according to ARGLIST, binding the value form VAL to STORE, then executing +BODY, which must return a Lisp form that does the necessary `setf' operation. +Actually, ARGLIST and STORE may be bound to temporary variables which are +introduced automatically to preserve proper execution order of the arguments. +Example: (defsetf nth (n x) (v) (list 'setcar (list 'nthcdr n x) v))." nil 'macro) + +(autoload 'get-setf-method "cl-macs" "\ +Return a list of five values describing the setf-method for PLACE. +PLACE may be any Lisp form which can appear as the PLACE argument to +a macro like `setf' or `incf'." nil nil) + +(autoload 'setf "cl-macs" "\ +(setf PLACE VAL PLACE VAL ...): set each PLACE to the value of its VAL. +This is a generalized version of `setq'; the PLACEs may be symbolic +references such as (car x) or (aref x i), as well as plain symbols. +For example, (setf (cadar x) y) is equivalent to (setcar (cdar x) y). +The return value is the last VAL in the list." nil 'macro) + +(autoload 'psetf "cl-macs" "\ +(psetf PLACE VAL PLACE VAL ...): set PLACEs to the values VALs in parallel. +This is like `setf', except that all VAL forms are evaluated (in order) +before assigning any PLACEs to the corresponding values." nil 'macro) + +(autoload 'cl-do-pop "cl-macs" nil nil nil) + +(autoload 'remf "cl-macs" "\ +(remf PLACE TAG): remove TAG from property list PLACE. +PLACE may be a symbol, or any generalized variable allowed by `setf'. +The form returns true if TAG was found and removed, nil otherwise." nil 'macro) + +(autoload 'shiftf "cl-macs" "\ +(shiftf PLACE PLACE... VAL): shift left among PLACEs. +Example: (shiftf A B C) sets A to B, B to C, and returns the old A. +Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro) + +(autoload 'rotatef "cl-macs" "\ +(rotatef PLACE...): rotate left among PLACEs. +Example: (rotatef A B C) sets A to B, B to C, and C to A. It returns nil. +Each PLACE may be a symbol, or any generalized variable allowed by `setf'." nil 'macro) + +(autoload 'letf "cl-macs" "\ +(letf ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs. +This is the analogue of `let', but with generalized variables (in the +sense of `setf') for the PLACEs. Each PLACE is set to the corresponding +VALUE, then the BODY forms are executed. On exit, either normally or +because of a `throw' or error, the PLACEs are set back to their original +values. Note that this macro is *not* available in Common Lisp. +As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)', +the PLACE is not modified before executing BODY." nil 'macro) + +(autoload 'letf* "cl-macs" "\ +(letf* ((PLACE VALUE) ...) BODY...): temporarily bind to PLACEs. +This is the analogue of `let*', but with generalized variables (in the +sense of `setf') for the PLACEs. Each PLACE is set to the corresponding +VALUE, then the BODY forms are executed. On exit, either normally or +because of a `throw' or error, the PLACEs are set back to their original +values. Note that this macro is *not* available in Common Lisp. +As a special case, if `(PLACE)' is used instead of `(PLACE VALUE)', +the PLACE is not modified before executing BODY." nil 'macro) + +(autoload 'callf "cl-macs" "\ +(callf FUNC PLACE ARGS...): set PLACE to (FUNC PLACE ARGS...). +FUNC should be an unquoted function name. PLACE may be a symbol, +or any generalized variable allowed by `setf'." nil 'macro) + +(autoload 'callf2 "cl-macs" "\ +(callf2 FUNC ARG1 PLACE ARGS...): set PLACE to (FUNC ARG1 PLACE ARGS...). +Like `callf', but PLACE is the second argument of FUNC, not the first." nil 'macro) + +(autoload 'define-modify-macro "cl-macs" "\ +(define-modify-macro NAME ARGLIST FUNC): define a `setf'-like modify macro. +If NAME is called, it combines its PLACE argument with the other arguments +from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)" nil 'macro) + +(autoload 'defstruct "cl-macs" "\ +(defstruct (NAME OPTIONS...) (SLOT SLOT-OPTS...)...): define a struct type. +This macro defines a new Lisp data type called NAME, which contains data +stored in SLOTs. This defines a `make-NAME' constructor, a `copy-NAME' +copier, a `NAME-p' predicate, and setf-able `NAME-SLOT' accessors." nil 'macro) + +(autoload 'cl-struct-setf-expander "cl-macs" nil nil nil) + +(autoload 'deftype "cl-macs" "\ +(deftype NAME ARGLIST BODY...): define NAME as a new data type. +The type name can then be used in `typecase', `check-type', etc." nil 'macro) + +(autoload 'typep "cl-macs" "\ +Check that OBJECT is of type TYPE. +TYPE is a Common Lisp-style type specifier." nil nil) + +(autoload 'check-type "cl-macs" "\ +Verify that PLACE is of type TYPE; signal a continuable error if not. +STRING is an optional description of the desired type." nil 'macro) + +(autoload 'assert "cl-macs" "\ +Verify that FORM returns non-nil; signal an error if not. +Second arg SHOW-ARGS means to include arguments of FORM in message. +Other args STRING and ARGS... are arguments to be passed to `error'. +They are not evaluated unless the assertion fails. If STRING is +omitted, a default message listing FORM itself is used." nil 'macro) + +(autoload 'ignore-errors "cl-macs" "\ +Execute FORMS; if an error occurs, return nil. +Otherwise, return result of last FORM." nil 'macro) + +(autoload 'ignore-file-errors "cl-macs" "\ +Execute FORMS; if an error of type `file-error' occurs, return nil. +Otherwise, return result of last FORM." nil 'macro) + +(autoload 'define-compiler-macro "cl-macs" "\ +(define-compiler-macro FUNC ARGLIST BODY...): Define a compiler-only macro. +This is like `defmacro', but macro expansion occurs only if the call to +FUNC is compiled (i.e., not interpreted). Compiler macros should be used +for optimizing the way calls to FUNC are compiled; the form returned by +BODY should do the same thing as a call to the normal function called +FUNC, though possibly more efficiently. Note that, like regular macros, +compiler macros are expanded repeatedly until no further expansions are +possible. Unlike regular macros, BODY can decide to \"punt\" and leave the +original function call alone by declaring an initial `&whole foo' parameter +and then returning foo." nil 'macro) + +(autoload 'compiler-macroexpand "cl-macs" nil nil nil) + +;;;*** + +;;;### (autoloads (config-value config-value-hash-table) "config" "lisp/config.el") + +(autoload 'config-value-hash-table "config" "\ +Return hash table of configuration parameters and their values." nil nil) + +(autoload 'config-value "config" "\ +Return the value of the configuration parameter CONFIG_SYMBOL." nil nil) + +;;;*** + +;;;### (autoloads (Custom-make-dependencies) "cus-dep" "lisp/cus-dep.el") + +(autoload 'Custom-make-dependencies "cus-dep" "\ +Extract custom dependencies from .el files in SUBDIRS. +SUBDIRS is a list of directories. If it is nil, the command-line +arguments are used. If it is a string, only that directory is +processed. This function is especially useful in batch mode. + +Batch usage: xemacs -batch -l cus-dep.el -f Custom-make-dependencies DIRS" t nil) + +;;;*** + +;;;### (autoloads (custom-migrate-custom-file customize-menu-create custom-menu-create custom-save-all customize-save-customized customize-browse custom-buffer-create-other-window custom-buffer-create customize-apropos-groups customize-apropos-faces customize-apropos-options customize-apropos customize-saved customize-customized customize-face-other-window customize-face customize-option-other-window customize-changed-options customize-variable customize-other-window customize customize-save-variable customize-set-variable customize-set-value) "cus-edit" "lisp/cus-edit.el") + +(autoload 'customize-set-value "cus-edit" "\ +Set VARIABLE to VALUE. VALUE is a Lisp object. + +If VARIABLE has a `variable-interactive' property, that is used as if +it were the arg to `interactive' (which see) to interactively read the value. + +If VARIABLE has a `custom-type' property, it must be a widget and the +`:prompt-value' property of that widget will be used for reading the value. + +If given a prefix (or a COMMENT argument), also prompt for a comment." t nil) + +(autoload 'customize-set-variable "cus-edit" "\ +Set the default for VARIABLE to VALUE. VALUE is any Lisp object. + +If VARIABLE has a `custom-set' property, that is used for setting +VARIABLE, otherwise `set-default' is used. + +The `customized-value' property of the VARIABLE will be set to a list +with a quoted VALUE as its sole list member. + +If VARIABLE has a `variable-interactive' property, that is used as if +it were the arg to `interactive' (which see) to interactively read the value. + +If VARIABLE has a `custom-type' property, it must be a widget and the +`:prompt-value' property of that widget will be used for reading the value. + +If given a prefix (or a COMMENT argument), also prompt for a comment." t nil) + +(autoload 'customize-save-variable "cus-edit" "\ +Set the default for VARIABLE to VALUE, and save it for future sessions. +If VARIABLE has a `custom-set' property, that is used for setting +VARIABLE, otherwise `set-default' is used. + +The `customized-value' property of the VARIABLE will be set to a list +with a quoted VALUE as its sole list member. + +If VARIABLE has a `variable-interactive' property, that is used as if +it were the arg to `interactive' (which see) to interactively read the value. + +If VARIABLE has a `custom-type' property, it must be a widget and the +`:prompt-value' property of that widget will be used for reading the value. + +If given a prefix (or a COMMENT argument), also prompt for a comment." t nil) + +(autoload 'customize "cus-edit" "\ +Select a customization buffer which you can use to set user options. +User options are structured into \"groups\". +The default group is `Emacs'." t nil) + +(defalias 'customize-group 'customize) + +(autoload 'customize-other-window "cus-edit" "\ +Customize SYMBOL, which must be a customization group." t nil) + +(defalias 'customize-group-other-window 'customize-other-window) + +(defalias 'customize-option 'customize-variable) + +(autoload 'customize-variable "cus-edit" "\ +Customize SYMBOL, which must be a user option variable." t nil) + +(autoload 'customize-changed-options "cus-edit" "\ +Customize all user option variables whose default values changed recently. +This means, in other words, variables defined with a `:version' keyword." t nil) + +(defalias 'customize-variable-other-window 'customize-option-other-window) + +(autoload 'customize-option-other-window "cus-edit" "\ +Customize SYMBOL, which must be a user option variable. +Show the buffer in another window, but don't select it." t nil) + +(autoload 'customize-face "cus-edit" "\ +Customize SYMBOL, which should be a face name or nil. +If SYMBOL is nil, customize all faces." t nil) + +(autoload 'customize-face-other-window "cus-edit" "\ +Show customization buffer for FACE in other window." t nil) + +(autoload 'customize-customized "cus-edit" "\ +Customize all user options set since the last save in this session." t nil) + +(autoload 'customize-saved "cus-edit" "\ +Customize all already saved user options." t nil) + +(autoload 'customize-apropos "cus-edit" "\ +Customize all user options matching REGEXP. +If ALL is `options', include only options. +If ALL is `faces', include only faces. +If ALL is `groups', include only groups. +If ALL is t (interactively, with prefix arg), include options which are not +user-settable, as well as faces and groups." t nil) + +(autoload 'customize-apropos-options "cus-edit" "\ +Customize all user options matching REGEXP. +With prefix arg, include options which are not user-settable." t nil) + +(autoload 'customize-apropos-faces "cus-edit" "\ +Customize all user faces matching REGEXP." t nil) + +(autoload 'customize-apropos-groups "cus-edit" "\ +Customize all user groups matching REGEXP." t nil) + +(autoload 'custom-buffer-create "cus-edit" "\ +Create a buffer containing OPTIONS. +Optional NAME is the name of the buffer. +OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where +SYMBOL is a customization option, and WIDGET is a widget for editing +that option." nil nil) + +(autoload 'custom-buffer-create-other-window "cus-edit" "\ +Create a buffer containing OPTIONS. +Optional NAME is the name of the buffer. +OPTIONS should be an alist of the form ((SYMBOL WIDGET)...), where +SYMBOL is a customization option, and WIDGET is a widget for editing +that option." nil nil) + +(autoload 'customize-browse "cus-edit" "\ +Create a tree browser for the customize hierarchy." t nil) + +(autoload 'customize-save-customized "cus-edit" "\ +Save all user options which have been set in this session." t nil) + +(autoload 'custom-save-all "cus-edit" "\ +Save all customizations in `custom-file'." nil nil) + +(autoload 'custom-menu-create "cus-edit" "\ +Create menu for customization group SYMBOL. +The menu is in a format applicable to `easy-menu-define'." nil nil) + +(autoload 'customize-menu-create "cus-edit" "\ +Return a customize menu for customization group SYMBOL. +If optional NAME is given, use that as the name of the menu. +Otherwise the menu will be named `Customize'. +The format is suitable for use with `easy-menu-define'." nil nil) + +(autoload 'custom-migrate-custom-file "cus-edit" "\ +Migrate custom file from home directory." nil nil) + +;;;*** + +;;;### (autoloads (custom-reset-faces custom-theme-reset-faces custom-theme-face-value custom-theme-set-faces custom-set-faces custom-set-face-update-spec custom-declare-face) "cus-face" "lisp/cus-face.el") + +(autoload 'custom-declare-face "cus-face" "\ +Like `defface', but FACE is evaluated as a normal argument." nil nil) + +(autoload 'custom-set-face-update-spec "cus-face" "\ +Customize the FACE for display types matching DISPLAY, merging + in the new items from PLIST." nil nil) + +(autoload 'custom-set-faces "cus-face" "\ +Initialize faces according to user preferences. +This asociates the setting with the USER theme. +The arguments should be a list where each entry has the form: + + (FACE SPEC [NOW [COMMENT]]) + +SPEC will be stored as the saved value for FACE. If NOW is present +and non-nil, FACE will also be created according to SPEC. +COMMENT is a string comment about FACE. + +See `defface' for the format of SPEC." nil nil) + +(autoload 'custom-theme-set-faces "cus-face" "\ +Initialize faces according to settings specified by args. +Records the settings as belonging to THEME. + +See `custom-set-faces' for a description of the arguments ARGS." nil nil) + +(autoload 'custom-theme-face-value "cus-face" "\ +Return spec of FACE in THEME if the THEME modifies the +FACE. Nil otherwise." nil nil) + +(autoload 'custom-theme-reset-faces "cus-face" nil nil nil) + +(autoload 'custom-reset-faces "cus-face" "\ +Reset the value of the face to values previously defined. +Associate this setting with the 'user' theme. + +ARGS is defined as for `custom-theme-reset-faces'." nil nil) + +;;;*** + +;;;### (autoloads (make-custom-file-name) "cus-file" "lisp/cus-file.el") + +(defconst custom-file-base "custom.el" "\ +Base of file name for storing customization information.") + +(defvar custom-file nil "\ +File used for storing customization information. +If you change this from the default you need to +explicitly load that file for the settings to take effect.") + +(autoload 'make-custom-file-name "cus-file" "\ +Construct the default custom file name from the init file name. +If FORCE-NEW is non-nil, force post-migration location." nil nil) + +;;;*** + +;;;### (autoloads (disassemble) "disass" "lisp/disass.el") + +(autoload 'disassemble "disass" "\ +Print disassembled code for OBJECT in (optional) BUFFER. +OBJECT can be a symbol defined as a function, or a function itself +\(a lambda expression or a compiled-function object). +If OBJECT is not already compiled, we compile it, but do not +redefine OBJECT if it is a symbol." t nil) + +;;;*** + +;;;### (autoloads (standard-display-european standard-display-underline standard-display-graphic standard-display-g1 standard-display-ascii standard-display-default standard-display-8bit make-display-table describe-current-display-table) "disp-table" "lisp/disp-table.el") + +(autoload 'describe-current-display-table "disp-table" "\ +Describe the display table in use in the selected window and buffer." t nil) + +(autoload 'make-display-table "disp-table" "\ +Return a new, empty display table." nil nil) + +(autoload 'standard-display-8bit "disp-table" "\ +Display characters in the range L to H literally." nil nil) + +(autoload 'standard-display-default "disp-table" "\ +Display characters in the range L to H using the default notation." nil nil) + +(autoload 'standard-display-ascii "disp-table" "\ +Display character C using printable string S." nil nil) + +(autoload 'standard-display-g1 "disp-table" "\ +Display character C as character SC in the g1 character set. +This function assumes that your terminal uses the SO/SI characters; +it is meaningless for an X frame." nil nil) + +(autoload 'standard-display-graphic "disp-table" "\ +Display character C as character GC in graphics character set. +This function assumes VT100-compatible escapes; it is meaningless for an +X frame." nil nil) + +(autoload 'standard-display-underline "disp-table" "\ +Display character C as character UC plus underlining." nil nil) + +(autoload 'standard-display-european "disp-table" "\ +Toggle display of European characters encoded with ISO 8859. +When enabled, characters in the range of 160 to 255 display not +as octal escapes, but as accented characters. +With prefix argument, enable European character display iff arg is positive." t nil) + +;;;*** + +;;;### (autoloads nil "easymenu" "lisp/easymenu.el") + +;;;*** + +;;;### (autoloads (pop-tag-mark tags-apropos list-tags tags-query-replace tags-search tags-loop-continue next-file tag-complete-symbol find-tag-other-window find-tag find-tag-at-point visit-tags-table) "etags" "lisp/etags.el") + +(autoload 'visit-tags-table "etags" "\ +Tell tags commands to use tags table file FILE when all else fails. +FILE should be the name of a file created with the `etags' program. +A directory name is ok too; it means file TAGS in that directory." t nil) + +(autoload 'find-tag-at-point "etags" "\ +*Find tag whose name contains TAGNAME. +Identical to `find-tag' but does not prompt for tag when called interactively; +instead, uses tag around or before point." t nil) + +(autoload 'find-tag "etags" "\ +*Find tag whose name contains TAGNAME. + Selects the buffer that the tag is contained in +and puts point at its definition. + If TAGNAME is a null string, the expression in the buffer +around or before point is used as the tag name. + If called interactively with a numeric argument, searches for the next tag +in the tag table that matches the tagname used in the previous find-tag. + If second arg OTHER-WINDOW is non-nil, uses another window to display +the tag. + +This version of this function supports multiple active tags tables, +and completion. + +Variables of note: + + tag-table-alist controls which tables apply to which buffers + tags-file-name a default tags table + tags-build-completion-table controls completion behavior + buffer-tag-table another way of specifying a buffer-local table + make-tags-files-invisible whether tags tables should be very hidden + tag-mark-stack-max how many tags-based hops to remember" t nil) + +(autoload 'find-tag-other-window "etags" "\ +*Find tag whose name contains TAGNAME, in another window. + Selects the buffer that the tag is contained in in another window +and puts point at its definition. + If TAGNAME is a null string, the expression in the buffer +around or before point is used as the tag name. + If second arg NEXT is non-nil (interactively, with prefix arg), +searches for the next tag in the tag table +that matches the tagname used in the previous find-tag. + +This version of this function supports multiple active tags tables, +and completion. + +Variables of note: + + tag-table-alist controls which tables apply to which buffers + tags-file-name a default tags table + tags-build-completion-table controls completion behavior + buffer-tag-table another way of specifying a buffer-local table + make-tags-files-invisible whether tags tables should be very hidden + tag-mark-stack-max how many tags-based hops to remember" t nil) + +(autoload 'tag-complete-symbol "etags" "\ +The function used to do tags-completion (using 'tag-completion-predicate)." t nil) + +(autoload 'next-file "etags" "\ +Select next file among files in current tag table(s). + +A first argument of t (prefix arg, if interactive) initializes to the +beginning of the list of files in the (first) tags table. If the argument +is neither nil nor t, it is evalled to initialize the list of files. + +Non-nil second argument NOVISIT means use a temporary buffer +to save time and avoid uninteresting warnings. + +Value is nil if the file was already visited; +if the file was newly read in, the value is the filename." t nil) + +(autoload 'tags-loop-continue "etags" "\ +Continue last \\[tags-search] or \\[tags-query-replace] command. +Used noninteractively with non-nil argument to begin such a command (the +argument is passed to `next-file', which see). +Two variables control the processing we do on each file: +the value of `tags-loop-scan' is a form to be executed on each file +to see if it is interesting (it returns non-nil if so) +and `tags-loop-operate' is a form to execute to operate on an interesting file +If the latter returns non-nil, we exit; otherwise we scan the next file." t nil) + +(autoload 'tags-search "etags" "\ +Search through all files listed in tags table for match for REGEXP. +Stops when a match is found. +To continue searching for next match, use command \\[tags-loop-continue]. + +See documentation of variable `tag-table-alist'." t nil) + +(autoload 'tags-query-replace "etags" "\ +Query-replace-regexp FROM with TO through all files listed in tags table. +Third arg DELIMITED (prefix arg) means replace only word-delimited matches. +If you exit (\\[keyboard-quit] or ESC), you can resume the query-replace +with the command \\[tags-loop-continue]. + +See documentation of variable `tag-table-alist'." t nil) + +(autoload 'list-tags "etags" "\ +Display list of tags in FILE." t nil) + +(autoload 'tags-apropos "etags" "\ +Display list of all tags in tag table REGEXP matches." t nil) +(define-key esc-map "*" 'pop-tag-mark) + +(autoload 'pop-tag-mark "etags" "\ +Go to last tag position. +`find-tag' maintains a mark-stack seperate from the \\[set-mark-command] mark-stack. +This function pops (and moves to) the tag at the top of this stack." t nil) + +;;;*** + +;;;### (autoloads (finder-by-keyword finder-commentary) "finder" "lisp/finder.el") + +(autoload 'finder-commentary "finder" "\ +Display FILE's commentary section. +FILE should be in a form suitable for passing to `locate-library'." t nil) + +(autoload 'finder-by-keyword "finder" "\ +Find packages matching a given keyword." t nil) + +;;;*** + +;;;### (autoloads (font-lock-set-defaults-1 font-lock-fontify-buffer turn-off-font-lock turn-on-font-lock font-lock-mode) "font-lock" "lisp/font-lock.el") + +(defcustom font-lock-auto-fontify t "*Whether font-lock should automatically fontify files as they're loaded.\nThis will only happen if font-lock has fontifying keywords for the major\nmode of the file. You can get finer-grained control over auto-fontification\nby using this variable in combination with `font-lock-mode-enable-list' or\n`font-lock-mode-disable-list'." :type 'boolean :group 'font-lock) + +(defcustom font-lock-mode-enable-list nil "*List of modes to auto-fontify, if `font-lock-auto-fontify' is nil." :type '(repeat (symbol :tag "Mode")) :group 'font-lock) + +(defcustom font-lock-mode-disable-list nil "*List of modes not to auto-fontify, if `font-lock-auto-fontify' is t." :type '(repeat (symbol :tag "Mode")) :group 'font-lock) + +(defcustom font-lock-use-colors '(color) "*Specification for when Font Lock will set up color defaults.\nNormally this should be '(color), meaning that Font Lock will set up\ncolor defaults that are only used on color displays. Set this to nil\nif you don't want Font Lock to set up color defaults at all. This\nshould be one of\n\n-- a list of valid tags, meaning that the color defaults will be used\n when all of the tags apply. (e.g. '(color x))\n-- a list whose first element is 'or and whose remaining elements are\n lists of valid tags, meaning that the defaults will be used when\n any of the tag lists apply.\n-- nil, meaning that the defaults should not be set up at all.\n\n(If you specify face values in your init file, they will override any\nthat Font Lock specifies, regardless of whether you specify the face\nvalues before or after loading Font Lock.)\n\nSee also `font-lock-use-fonts'. If you want more control over the faces\nused for fontification, see the documentation of `font-lock-mode' for\nhow to do it." :type 'sexp :group 'font-lock) + +(defcustom font-lock-use-fonts '(or (mono) (grayscale)) "*Specification for when Font Lock will set up non-color defaults.\n\nNormally this should be '(or (mono) (grayscale)), meaning that Font\nLock will set up non-color defaults that are only used on either mono\nor grayscale displays. Set this to nil if you don't want Font Lock to\nset up non-color defaults at all. This should be one of\n\n-- a list of valid tags, meaning that the non-color defaults will be used\n when all of the tags apply. (e.g. '(grayscale x))\n-- a list whose first element is 'or and whose remaining elements are\n lists of valid tags, meaning that the defaults will be used when\n any of the tag lists apply.\n-- nil, meaning that the defaults should not be set up at all.\n\n(If you specify face values in your init file, they will override any\nthat Font Lock specifies, regardless of whether you specify the face\nvalues before or after loading Font Lock.)\n\nSee also `font-lock-use-colors'. If you want more control over the faces\nused for fontification, see the documentation of `font-lock-mode' for\nhow to do it." :type 'sexp :group 'font-lock) + +(defcustom font-lock-maximum-decoration t "*If non-nil, the maximum decoration level for fontifying.\nIf nil, use the minimum decoration (equivalent to level 0).\nIf t, use the maximum decoration available.\nIf a number, use that level of decoration (or if not available the maximum).\nIf a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL),\nwhere MAJOR-MODE is a symbol or t (meaning the default). For example:\n ((c++-mode . 2) (c-mode . t) (t . 1))\nmeans use level 2 decoration for buffers in `c++-mode', the maximum decoration\navailable for buffers in `c-mode', and level 1 decoration otherwise." :type '(choice (const :tag "default" nil) (const :tag "maximum" t) (integer :tag "level" 1) (repeat :menu-tag "mode specific" :tag "mode specific" :value ((t . t)) (cons :tag "Instance" (radio :tag "Mode" (const :tag "all" t) (symbol :tag "name")) (radio :tag "Decoration" (const :tag "default" nil) (const :tag "maximum" t) (integer :tag "level" 1))))) :group 'font-lock) + +(define-obsolete-variable-alias 'font-lock-use-maximal-decoration 'font-lock-maximum-decoration) + +(defcustom font-lock-maximum-size (* 250 1024) "*If non-nil, the maximum size for buffers for fontifying.\nOnly buffers less than this can be fontified when Font Lock mode is turned on.\nIf nil, means size is irrelevant.\nIf a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),\nwhere MAJOR-MODE is a symbol or t (meaning the default). For example:\n ((c++-mode . 256000) (c-mode . 256000) (rmail-mode . 1048576))\nmeans that the maximum size is 250K for buffers in `c++-mode' or `c-mode', one\nmegabyte for buffers in `rmail-mode', and size is irrelevant otherwise." :type '(choice (const :tag "none" nil) (integer :tag "size") (repeat :menu-tag "mode specific" :tag "mode specific" :value ((t)) (cons :tag "Instance" (radio :tag "Mode" (const :tag "all" t) (symbol :tag "name")) (radio :tag "Size" (const :tag "none" nil) (integer :tag "size"))))) :group 'font-lock) + +(defcustom font-lock-fontify-string-delimiters nil "*If non-nil, apply font-lock-string-face to string delimiters as well as\nstring text when fontifying." :type 'boolean :group 'font-lock) + +(defvar font-lock-keywords nil "\ +A list defining the keywords for `font-lock-mode' to highlight. + + FONT-LOCK-KEYWORDS := List of FONT-LOCK-FORM's. + + FONT-LOCK-FORM :== MATCHER + | (MATCHER . MATCH) + | (MATCHER . FACE-FORM) + | (MATCHER . HIGHLIGHT) + | (MATCHER HIGHLIGHT ...) + | (eval . FORM) + + MATCHER :== A string containing a regexp. + | A variable containing a regexp to search for. + | A function to call to make the search. + It is called with one arg, the limit of the search, + and should leave MATCH results in the XEmacs global + match data. + + MATCH :== An integer match subexpression number from MATCHER. + + FACE-FORM :== The symbol naming a defined face. + | Expression whos value is the face name to use. If you + want FACE-FORM to be a symbol that evaluates to a face, + use a form like \"(progn sym)\". + + HIGHLIGHT :== MATCH-HIGHLIGHT + | MATCH-ANCHORED + + FORM :== Expression returning a FONT-LOCK-FORM, evaluated when + the FONT-LOCK-FORM is first used in a buffer. This + feature can be used to provide a FONT-LOCK-FORM that + can only be generated when Font Lock mode is actually + turned on. + + MATCH-HIGHLIGHT :== (MATCH FACE-FORM OVERRIDE LAXMATCH) + + OVERRIDE :== t - overwrite existing fontification + | 'keep - only parts not already fontified are + highlighted. + | 'prepend - merge faces, this fontification has + precedence over existing + | 'append - merge faces, existing fontification has + precedence over + this face. + + LAXMATCH :== If non-nil, no error is signalled if there is no MATCH + in MATCHER. + + MATCH-ANCHORED :== (ANCHOR-MATCHER PRE-MATCH-FORM \\ + POST-MATCH-FORM MATCH-HIGHLIGHT ...) + + ANCHOR-MATCHER :== Like a MATCHER, except that the limit of the search + defaults to the end of the line after PRE-MATCH-FORM + is evaluated. However, if PRE-MATCH-FORM returns a + position greater than the end of the line, that + position is used as the limit of the search. It is + generally a bad idea to return a position greater than + the end of the line, i.e., cause the ANCHOR-MATCHER + search to span lines. + + PRE-MATCH-FORM :== Evaluated before the ANCHOR-MATCHER is used, therefore + can be used to initialize before, ANCHOR-MATCHER is + used. Typically, PRE-MATCH-FORM is used to move to + some position relative to the original MATCHER, before + starting with the ANCHOR-MATCHER. + + POST-MATCH-FORM :== Like PRE-MATCH-FORM, but used to clean up after the + ANCHOR-MATCHER. It might be used to move, before + resuming with MATCH-ANCHORED's parent's MATCHER. + +For example, an element of the first form highlights (if not already highlighted): + + \"\\\\\\=<foo\\\\\\=>\" Discrete occurrences of \"foo\" in the value + of the variable `font-lock-keyword-face'. + + (\"fu\\\\(bar\\\\)\" . 1) Substring \"bar\" within all occurrences of + \"fubar\" in the value of + `font-lock-keyword-face'. + + (\"fubar\" . fubar-face) Occurrences of \"fubar\" in the value of + `fubar-face'. + + (\"foo\\\\|bar\" 0 foo-bar-face t) Occurrences of either \"foo\" or \"bar\" in the + value of `foo-bar-face', even if already + highlighted. + + (fubar-match 1 fubar-face) The first subexpression within all + occurrences of whatever the function + `fubar-match' finds and matches in the value + of `fubar-face'. + + (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face))) + -------------- --------------- ------------ --- --- ------------- + | | | | | | + MATCHER | ANCHOR-MATCHER | +------+ MATCH-HIGHLIGHT + MATCH-HIGHLIGHT PRE-MATCH-FORM | + POST-MATCH-FORM + + Discrete occurrences of \"anchor\" in the value of `anchor-face', and + subsequent discrete occurrences of \"item\" (on the same line) in the value + of `item-face'. (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil. + Therefore \"item\" is initially searched for starting from the end of the + match of \"anchor\", and searching for subsequent instance of \"anchor\" + resumes from where searching for \"item\" concluded.) + +For highlighting single items, typically only MATCH-HIGHLIGHT is required. +However, if an item or (typically) several items are to be highlighted +following the instance of another item (the anchor) then MATCH-ANCHORED may be +required. + +These regular expressions should not match text which spans lines. While +\\[font-lock-fontify-buffer] handles multi-line patterns correctly, updating when you +edit the buffer does not, since it considers text one line at a time. + +Be very careful composing regexps for this list; the wrong pattern can +dramatically slow things down! +") + +(make-variable-buffer-local 'font-lock-keywords) + +(defvar font-lock-syntactic-keywords nil "\ +A list of the syntactic keywords to highlight. +Can be the list or the name of a function or variable whose value is the list. +See `font-lock-keywords' for a description of the form of this list; +the differences are listed below. MATCH-HIGHLIGHT should be of the form: + + (MATCH SYNTAX OVERRIDE LAXMATCH) + +where SYNTAX can be of the form (SYNTAX-CODE . MATCHING-CHAR), the name of a +syntax table, or an expression whose value is such a form or a syntax table. +OVERRIDE cannot be `prepend' or `append'. + +For example, an element of the form highlights syntactically: + + (\"\\\\$\\\\(#\\\\)\" 1 (1 . nil)) + + a hash character when following a dollar character, with a SYNTAX-CODE of + 1 (meaning punctuation syntax). Assuming that the buffer syntax table does + specify hash characters to have comment start syntax, the element will only + highlight hash characters that do not follow dollar characters as comments + syntactically. + + (\"\\\\('\\\\).\\\\('\\\\)\" + (1 (7 . ?')) + (2 (7 . ?'))) + + both single quotes which surround a single character, with a SYNTAX-CODE of + 7 (meaning string quote syntax) and a MATCHING-CHAR of a single quote (meaning + a single quote matches a single quote). Assuming that the buffer syntax table + does not specify single quotes to have quote syntax, the element will only + highlight single quotes of the form 'c' as strings syntactically. + Other forms, such as foo'bar or 'fubar', will not be highlighted as strings. + +This is normally set via `font-lock-defaults'.") + +(make-variable-buffer-local 'font-lock-syntactic-keywords) + +(defcustom font-lock-mode nil "Non nil means `font-lock-mode' is on" :group 'font-lock :type 'boolean :initialize 'custom-initialize-default :require 'font-lock :set (function (lambda (var val) (font-lock-mode (or val 0))))) + +(defvar font-lock-mode-hook nil "\ +Function or functions to run on entry to font-lock-mode.") + +(autoload 'font-lock-mode "font-lock" "\ +Toggle Font Lock Mode. +With arg, turn font-lock mode on if and only if arg is positive. + +When Font Lock mode is enabled, text is fontified as you type it: + + - Comments are displayed in `font-lock-comment-face'; + - Strings are displayed in `font-lock-string-face'; + - Documentation strings (in Lisp-like languages) are displayed in + `font-lock-doc-string-face'; + - Language keywords (\"reserved words\") are displayed in + `font-lock-keyword-face'; + - Function names in their defining form are displayed in + `font-lock-function-name-face'; + - Variable names in their defining form are displayed in + `font-lock-variable-name-face'; + - Type names are displayed in `font-lock-type-face'; + - References appearing in help files and the like are displayed + in `font-lock-reference-face'; + - Preprocessor declarations are displayed in + `font-lock-preprocessor-face'; + + and + + - Certain other expressions are displayed in other faces according + to the value of the variable `font-lock-keywords'. + +Where modes support different levels of fontification, you can use the variable +`font-lock-maximum-decoration' to specify which level you generally prefer. +When you turn Font Lock mode on/off the buffer is fontified/defontified, though +fontification occurs only if the buffer is less than `font-lock-maximum-size'. +To fontify a buffer without turning on Font Lock mode, and regardless of buffer +size, you can use \\[font-lock-fontify-buffer]. + +See the variable `font-lock-keywords' for customization." t nil) + +(autoload 'turn-on-font-lock "font-lock" "\ +Unconditionally turn on Font Lock mode." t nil) + +(autoload 'turn-off-font-lock "font-lock" "\ +Unconditionally turn off Font Lock mode." t nil) + +(autoload 'font-lock-fontify-buffer "font-lock" "\ +Fontify the current buffer the way `font-lock-mode' would. +See `font-lock-mode' for details. + +This can take a while for large buffers." t nil) + +(autoload 'font-lock-set-defaults-1 "font-lock" nil nil nil) + +(add-minor-mode 'font-lock-mode " Font") + +;;;*** + +;;;### (autoloads (font-menu-weight-constructor font-menu-size-constructor font-menu-family-constructor reset-device-font-menus) "font-menu" "lisp/font-menu.el") + +(defcustom font-menu-ignore-scaled-fonts nil "*If non-nil, then the font menu will try to show only bitmap fonts." :type 'boolean :group 'font-menu) + +(defcustom font-menu-this-frame-only-p nil "*If non-nil, then changing the default font from the font menu will only\naffect one frame instead of all frames." :type 'boolean :group 'font-menu) + +(fset 'install-font-menus 'reset-device-font-menus) + +(autoload 'reset-device-font-menus "font-menu" "\ +Generates the `Font', `Size', and `Weight' submenus for the Options menu. +This is run the first time that a font-menu is needed for each device. +If you don't like the lazy invocation of this function, you can add it to +`create-device-hook' and that will make the font menus respond more quickly +when they are selected for the first time. If you add fonts to your system, +or if you change your font path, you can call this to re-initialize the menus." nil nil) + +(autoload 'font-menu-family-constructor "font-menu" nil nil nil) + +(autoload 'font-menu-size-constructor "font-menu" nil nil nil) + +(autoload 'font-menu-weight-constructor "font-menu" nil nil nil) + +;;;*** + +;;;### (autoloads (x-font-build-cache font-default-size-for-device font-default-encoding-for-device font-default-registry-for-device font-default-family-for-device font-default-object-for-device font-default-font-for-device font-create-object) "font" "lisp/font.el") + +(autoload 'font-create-object "font" nil nil nil) + +(autoload 'font-default-font-for-device "font" nil nil nil) + +(autoload 'font-default-object-for-device "font" nil nil nil) + +(autoload 'font-default-family-for-device "font" nil nil nil) + +(autoload 'font-default-registry-for-device "font" nil nil nil) + +(autoload 'font-default-encoding-for-device "font" nil nil nil) + +(autoload 'font-default-size-for-device "font" nil nil nil) + +(autoload 'x-font-build-cache "font" nil nil nil) + +;;;*** + +;;;### (autoloads (gnuserv-start gnuserv-running-p) "gnuserv" "lisp/gnuserv.el") + +(defcustom gnuserv-frame nil "*The frame to be used to display all edited files.\nIf nil, then a new frame is created for each file edited.\nIf t, then the currently selected frame will be used.\nIf a function, then this will be called with a symbol `x' or `tty' as the\nonly argument, and its return value will be interpreted as above." :tag "Gnuserv Frame" :type '(radio (const :tag "Create new frame each time" nil) (const :tag "Use selected frame" t) (function-item :tag "Use main Emacs frame" gnuserv-main-frame-function) (function-item :tag "Use visible frame, otherwise create new" gnuserv-visible-frame-function) (function-item :tag "Create special Gnuserv frame and use it" gnuserv-special-frame-function) (function :tag "Other")) :group 'gnuserv :group 'frames) + +(autoload 'gnuserv-running-p "gnuserv" "\ +Return non-nil if a gnuserv process is running from this XEmacs session." nil nil) + +(autoload 'gnuserv-start "gnuserv" "\ +Allow this Emacs process to be a server for client processes. +This starts a gnuserv communications subprocess through which +client \"editors\" (gnuclient and gnudoit) can send editing commands to +this Emacs job. See the gnuserv(1) manual page for more details. + +Prefix arg means just kill any existing server communications subprocess." t nil) + +;;;*** + +;;;### (autoloads (gtk-reset-device-font-menus) "gtk-font-menu" "lisp/gtk-font-menu.el") + +(autoload 'gtk-reset-device-font-menus "gtk-font-menu" "\ +Generates the `Font', `Size', and `Weight' submenus for the Options menu. +This is run the first time that a font-menu is needed for each device. +If you don't like the lazy invocation of this function, you can add it to +`create-device-hook' and that will make the font menus respond more quickly +when they are selected for the first time. If you add fonts to your system, +or if you change your font path, you can call this to re-initialize the menus." nil nil) + +(defun* gtk-font-menu-font-data (face dcache) (defvar gtk-font-regexp) (defvar gtk-font-regexp-foundry-and-family) (let* ((case-fold-search t) (domain (if font-menu-this-frame-only-p (selected-frame) (selected-device))) (name (font-instance-name (face-font-instance face domain))) (truename (font-instance-truename (face-font-instance face domain (if (featurep 'mule) 'ascii)))) family size weight entry slant) (when (string-match gtk-font-regexp-foundry-and-family name) (setq family (capitalize (match-string 1 name))) (setq entry (vassoc family (aref dcache 0)))) (when (and (null entry) (string-match gtk-font-regexp-foundry-and-family truename)) (setq family (capitalize (match-string 1 truename))) (setq entry (vassoc family (aref dcache 0)))) (when (null entry) (return-from gtk-font-menu-font-data (make-vector 5 nil))) (when (string-match gtk-font-regexp name) (setq weight (capitalize (match-string 1 name))) (setq size (string-to-int (match-string 6 name)))) (when (string-match gtk-font-regexp truename) (when (not (member weight (aref entry 1))) (setq weight (capitalize (match-string 1 truename)))) (when (not (member size (aref entry 2))) (setq size (string-to-int (match-string 6 truename)))) (setq slant (capitalize (match-string 2 truename)))) (vector entry family size weight slant))) + +;;;*** + +;;;### (autoloads nil "help-macro" "lisp/help-macro.el") + +(defcustom three-step-help t "*Non-nil means give more info about Help command in three steps.\nThe three steps are simple prompt, prompt with all options,\nand window listing and describing the options.\nA value of nil means skip the middle step, so that\n\\[help-command] \\[help-command] gives the window that lists the options." :type 'boolean :group 'help-appearance) + +;;;*** + +;;;### (autoloads (hyper-apropos-popup-menu hyper-apropos-set-variable hyper-set-variable hyper-apropos-read-variable-symbol hyper-describe-function hyper-where-is hyper-describe-variable hyper-describe-face hyper-describe-key-briefly hyper-describe-key hyper-apropos command-hyper-apropos) "hyper-apropos" "lisp/hyper-apropos.el") + +(autoload 'command-hyper-apropos "hyper-apropos" "\ +Display lists of commands and user options matching REGEXP +in buffer \"*Hyper Apropos*\". See `hyper-apropos-mode' for a +description of the available commands in a Hyper-Apropos buffer." t nil) + +(autoload 'hyper-apropos "hyper-apropos" "\ +Display lists of functions and variables matching REGEXP +in buffer \"*Hyper Apropos*\". If optional prefix arg is given, then the +value of `hyper-apropos-programming-apropos' is toggled for this search. +See `hyper-apropos-mode' for a description of the available commands in +a Hyper-Apropos buffer." t nil) + +(autoload 'hyper-describe-key "hyper-apropos" nil t nil) + +(autoload 'hyper-describe-key-briefly "hyper-apropos" nil t nil) + +(autoload 'hyper-describe-face "hyper-apropos" "\ +Describe face.. +See also `hyper-apropos' and `hyper-describe-function'." t nil) + +(autoload 'hyper-describe-variable "hyper-apropos" "\ +Hypertext drop-in replacement for `describe-variable'. +See also `hyper-apropos' and `hyper-describe-function'." t nil) + +(autoload 'hyper-where-is "hyper-apropos" "\ +Print message listing key sequences that invoke specified command." t nil) + +(autoload 'hyper-describe-function "hyper-apropos" "\ +Hypertext replacement for `describe-function'. Unlike `describe-function' +in that the symbol under the cursor is the default if it is a function. +See also `hyper-apropos' and `hyper-describe-variable'." t nil) + +(autoload 'hyper-apropos-read-variable-symbol "hyper-apropos" "\ +Hypertext drop-in replacement for `describe-variable'. +See also `hyper-apropos' and `hyper-describe-function'." nil nil) + +(define-obsolete-function-alias 'hypropos-read-variable-symbol 'hyper-apropos-read-variable-symbol) + +(define-obsolete-function-alias 'hypropos-get-doc 'hyper-apropos-get-doc) + +(autoload 'hyper-set-variable "hyper-apropos" nil t nil) + +(autoload 'hyper-apropos-set-variable "hyper-apropos" "\ +Interactively set the variable on the current line." t nil) + +(define-obsolete-function-alias 'hypropos-set-variable 'hyper-apropos-set-variable) + +(autoload 'hyper-apropos-popup-menu "hyper-apropos" nil t nil) + +(define-obsolete-function-alias 'hypropos-popup-menu 'hyper-apropos-popup-menu) + +;;;*** + +;;;### (autoloads (Info-search-index-in-xemacs-and-lispref Info-search-index-in-lispref Info-search-text-in-xemacs Info-search-text-in-lispref Info-elisp-ref Info-emacs-key Info-goto-emacs-key-command-node Info-goto-emacs-command-node Info-emacs-command Info-search Info-visit-file Info-goto-node Info-batch-rebuild-dir Info-find-node Info-query info) "info" "lisp/info.el") + +(defvar Info-directory-list nil "\ +List of directories to search for Info documentation files. + +The first directory in this list, the \"dir\" file there will become +the (dir)Top node of the Info documentation tree. + +Note: DO NOT use the `customize' interface to change the value of this +variable. Its value is created dynamically on each startup, depending +on XEmacs packages installed on the system. If you want to change the +search path, make the needed modifications on the variable's value +from .emacs. For instance: + + (setq Info-directory-list (cons \"~/info\" Info-directory-list))") + +(autoload 'info "info" "\ +Enter Info, the documentation browser. +Optional argument FILE specifies the file to examine; +the default is the top-level directory of Info. + +In interactive use, a prefix argument directs this command +to read a file name from the minibuffer." t nil) + +(autoload 'Info-query "info" "\ +Enter Info, the documentation browser. Prompt for name of Info file." t nil) + +(autoload 'Info-find-node "info" "\ +Go to an info node specified as separate FILENAME and NODENAME. +Look for a plausible filename, or if not found then look for URL's and +dispatch to the appropriate fn. NO-GOING-BACK is non-nil if +recovering from an error in this function; it says do not attempt +further (recursive) error recovery. TRYFILE is ??" nil nil) + +(autoload 'Info-batch-rebuild-dir "info" "\ +(Re)build `dir' files in the directories remaining on the command line. +Use this from the command line, with `-batch', it won't work in an +interactive XEmacs. + +Each file is processed even if an error occurred previously. For example, +invoke \"xemacs -batch -f Info-batch-rebuild-dir /usr/local/info\"." nil nil) + +(autoload 'Info-goto-node "info" "\ +Go to info node named NAME. Give just NODENAME or (FILENAME)NODENAME. +Actually, the following interpretations of NAME are tried in order: + (FILENAME)NODENAME + (FILENAME) (using Top node) + NODENAME (in current file) + TAGNAME (see below) + FILENAME (using Top node) +where TAGNAME is a string that appears in quotes: \"TAGNAME\", in an +annotation for any node of any file. (See `a' and `x' commands.)" t nil) + +(autoload 'Info-visit-file "info" "\ +Directly visit an info file." t nil) + +(autoload 'Info-search "info" "\ +Search for REGEXP, starting from point, and select node it's found in." t nil) + +(autoload 'Info-emacs-command "info" "\ +Look up an Emacs command in the Emacs manual in the Info system. +This command is designed to be used whether you are already in Info or not." t nil) + +(autoload 'Info-goto-emacs-command-node "info" "\ +Look up an Emacs command in the Emacs manual in the Info system. +This command is designed to be used whether you are already in Info or not." t nil) + +(autoload 'Info-goto-emacs-key-command-node "info" "\ +Look up an Emacs key sequence in the Emacs manual in the Info system. +This command is designed to be used whether you are already in Info or not." t nil) + +(autoload 'Info-emacs-key "info" "\ +Look up an Emacs key sequence in the Emacs manual in the Info system. +This command is designed to be used whether you are already in Info or not." t nil) + +(autoload 'Info-elisp-ref "info" "\ +Look up an Emacs Lisp function in the Elisp manual in the Info system. +This command is designed to be used whether you are already in Info or not." t nil) + +(autoload 'Info-search-text-in-lispref "info" "\ +Search for REGEXP in Lispref text and select node it's found in." t nil) + +(autoload 'Info-search-text-in-xemacs "info" "\ +Search for REGEXP in User's Manual text and select node it's found in." t nil) + +(autoload 'Info-search-index-in-lispref "info" "\ +Search for REGEXP in Lispref index and select node it's found in." t nil) + +(autoload 'Info-search-index-in-xemacs-and-lispref "info" "\ +Search for REGEXP in both User's Manual and Lispref indices. +Select node it's found in." t nil) + +;;;*** + +;;;### (autoloads nil "itimer-autosave" "lisp/itimer-autosave.el") + +;;;*** + +;;;### (autoloads nil "loaddefs" "lisp/loaddefs.el") + +;;;*** + +;;;### (autoloads nil "loadhist" "lisp/loadhist.el") + +;;;*** + +;;;### (autoloads (mswindows-reset-device-font-menus) "msw-font-menu" "lisp/msw-font-menu.el") + +(autoload 'mswindows-reset-device-font-menus "msw-font-menu" "\ +Generates the `Font', `Size', and `Weight' submenus for the Options menu. +This is run the first time that a font-menu is needed for each device. +If you don't like the lazy invocation of this function, you can add it to +`create-device-hook' and that will make the font menus respond more quickly +when they are selected for the first time. If you add fonts to your system, +or if you change your font path, you can call this to re-initialize the menus." nil nil) + +(defun* mswindows-font-menu-font-data (face dcache) (let* ((case-fold-search t) (domain (if font-menu-this-frame-only-p (selected-frame) (selected-device))) (name (font-instance-name (face-font-instance face domain))) (truename (font-instance-truename (face-font-instance face domain (if (featurep 'mule) 'ascii)))) family size weight entry slant) (when (string-match mswindows-font-regexp name) (setq family (match-string 1 name)) (setq entry (vassoc family (aref dcache 0)))) (when (and (null entry) (string-match mswindows-font-regexp truename)) (setq family (match-string 1 truename)) (setq entry (vassoc family (aref dcache 0)))) (when (null entry) (return-from mswindows-font-menu-font-data (make-vector 5 nil))) (when (string-match mswindows-font-regexp name) (setq weight (match-string 2 name)) (setq size (string-to-int (match-string 4 name)))) (when (string-match mswindows-font-regexp truename) (when (not (member weight (aref entry 1))) (setq weight (match-string 2 truename))) (when (not (member size (aref entry 2))) (setq size (string-to-int (match-string 4 truename)))) (setq slant (match-string 5 truename))) (vector entry family size weight slant))) + +;;;*** + +;;;### (autoloads (mwheel-install) "mwheel" "lisp/mwheel.el") + +(autoload 'mwheel-install "mwheel" "\ +Enable mouse wheel support." t nil) + +;;;*** + +;;;### (autoloads (package-admin-add-binary-package package-admin-add-single-file-package) "package-admin" "lisp/package-admin.el") + +(autoload 'package-admin-add-single-file-package "package-admin" "\ +Install a single file Lisp package into XEmacs package hierarchy. +`file' should be the full path to the lisp file to install. +`destdir' should be a simple directory name. +The optional `pkg-dir' can be used to override the default package hierarchy +\(car (last late-packages))." t nil) + +(autoload 'package-admin-add-binary-package "package-admin" "\ +Install a pre-bytecompiled XEmacs package into package hierarchy." t nil) + +;;;*** + +;;;### (autoloads (package-get-custom package-get-package-provider package-get package-get-dependencies package-get-all package-get-update-all package-get-delete-package package-get-save-base package-get-update-base-from-buffer package-get-update-base package-get-update-base-entry package-get-require-base package-get-download-menu) "package-get" "lisp/package-get.el") + +(defvar package-get-base nil "\ +List of packages that are installed at this site. +For each element in the alist, car is the package name and the cdr is +a plist containing information about the package. Typical fields +kept in the plist are: + +version - version of this package +provides - list of symbols provided +requires - list of symbols that are required. + These in turn are provided by other packages. +filename - name of the file. +size - size of the file (aka the bundled package) +md5sum - computed md5 checksum +description - What this package is for. +type - Whether this is a 'binary (default) or 'single file package + +More fields may be added as needed. An example: + +'( + (name + (version \"<version 2>\" + file \"filename\" + description \"what this package is about.\" + provides (<list>) + requires (<list>) + size <integer-bytes> + md5sum \"<checksum\" + type single + ) + (version \"<version 1>\" + file \"filename\" + description \"what this package is about.\" + provides (<list>) + requires (<list>) + size <integer-bytes> + md5sum \"<checksum\" + type single + ) + ... + )) + +For version information, it is assumed things are listed in most +recent to least recent -- in other words, the version names don't have to +be lexically ordered. It is debatable if it makes sense to have more than +one version of a package available.") + +(defcustom package-get-download-sites '(("Pre-Releases" "ftp.xemacs.org" "pub/xemacs/beta/experimental/packages") ("xemacs.org" "ftp.xemacs.org" "pub/xemacs/packages") ("crc.ca (Canada)" "ftp.crc.ca" "pub/packages/editors/xemacs/packages") ("ualberta.ca (Canada)" "sunsite.ualberta.ca" "pub/Mirror/xemacs/packages") ("uiuc.edu (United States)" "uiarchive.uiuc.edu" "pub/packages/xemacs/packages") ("unc.edu (United States)" "metalab.unc.edu" "pub/packages/editors/xemacs/packages") ("utk.edu (United States)" "ftp.sunsite.utk.edu" "pub/xemacs/packages") ("unicamp.br (Brazil)" "ftp.unicamp.br" "pub/xemacs/packages") ("tuwien.ac.at (Austria)" "gd.tuwien.ac.at" "editors/xemacs/packages") ("auc.dk (Denmark)" "sunsite.auc.dk" "pub/emacs/xemacs/packages") ("doc.ic.ac.uk (England)" "sunsite.doc.ic.ac.uk" "packages/xemacs/packages") ("funet.fi (Finland)" "ftp.funet.fi" "pub/mirrors/ftp.xemacs.org/pub/tux/xemacs/packages") ("cenatls.cena.dgac.fr (France)" "ftp.cenatls.cena.dgac.fr" "Emacs/xemacs/packages") ("pasteur.fr (France)" "ftp.pasteur.fr" "pub/computing/xemacs/packages") ("tu-darmstadt.de (Germany)" "ftp.tu-darmstadt.de" "pub/editors/xemacs/packages") ("kfki.hu (Hungary)" "ftp.kfki.hu" "pub/packages/xemacs/packages") ("eunet.ie (Ireland)" "ftp.eunet.ie" "mirrors/ftp.xemacs.org/pub/xemacs/packages") ("uniroma2.it (Italy)" "ftp.uniroma2.it" "unix/misc/dist/XEMACS/packages") ("uio.no (Norway)" "sunsite.uio.no" "pub/xemacs/packages") ("icm.edu.pl (Poland)" "ftp.icm.edu.pl" "pub/unix/editors/xemacs/packages") ("srcc.msu.su (Russia)" "ftp.srcc.msu.su" "mirror/ftp.xemacs.org/packages") ("sunet.se (Sweden)" "ftp.sunet.se" "pub/gnu/xemacs/packages") ("cnlab-switch.ch (Switzerland)" "sunsite.cnlab-switch.ch" "mirror/xemacs/packages") ("aist.go.jp (Japan)" "ring.aist.go.jp" "pub/text/xemacs/packages") ("asahi-net.or.jp (Japan)" "ring.asahi-net.or.jp" "pub/text/xemacs/packages") ("dti.ad.jp (Japan)" "ftp.dti.ad.jp" "pub/unix/editor/xemacs/packages") ("jaist.ac.jp (Japan)" "ftp.jaist.ac.jp" "pub/GNU/xemacs/packages") ("nucba.ac.jp (Japan)" "mirror.nucba.ac.jp" "mirror/xemacs/packages") ("sut.ac.jp (Japan)" "sunsite.sut.ac.jp" "pub/archives/packages/xemacs/packages") ("tsukuba.ac.jp (Japan)" "ftp.netlab.is.tsukuba.ac.jp" "pub/GNU/xemacs/packages") ("kreonet.re.kr (Korea)" "ftp.kreonet.re.kr" "pub/tools/emacs/xemacs/packages") ("nctu.edu.tw (Taiwan)" "coda.nctu.edu.tw" "Editors/xemacs/packages") ("sun.ac.za (South Africa)" "ftp.sun.ac.za" "xemacs/packages") ("isu.net.sa (Saudi Arabia)" "ftp.isu.net.sa" "pub/mirrors/ftp.xemacs.org/packages") ("aarnet.edu.au (Australia)" "mirror.aarnet.edu.au" "pub/xemacs/packages")) "*List of remote sites available for downloading packages.\nList format is '(site-description site-name directory-on-site).\nSITE-DESCRIPTION is a textual description of the site. SITE-NAME\nis the internet address of the download site. DIRECTORY-ON-SITE\nis the directory on the site in which packages may be found.\nThis variable is used to initialize `package-get-remote', the\nvariable actually used to specify package download sites." :tag "Package download sites" :type '(repeat (list (string :tag "Name") host-name directory)) :group 'package-get) + +(autoload 'package-get-download-menu "package-get" "\ +Build the `Add Download Site' menu." nil nil) + +(autoload 'package-get-require-base "package-get" "\ +Require that a package-get database has been loaded. +If the optional FORCE-CURRENT argument or the value of +`package-get-always-update' is Non-nil, try to update the database +from a location in `package-get-remote'. Otherwise a local copy is used +if available and remote access is never done. + +Please use FORCE-CURRENT only when the user is explictly dealing with packages +and remote access is likely in the near future." nil nil) + +(autoload 'package-get-update-base-entry "package-get" "\ +Update an entry in `package-get-base'." nil nil) + +(autoload 'package-get-update-base "package-get" "\ +Update the package-get database file with entries from DB-FILE. +Unless FORCE-CURRENT is non-nil never try to update the database." t nil) + +(autoload 'package-get-update-base-from-buffer "package-get" "\ +Update the package-get database with entries from BUFFER. +BUFFER defaults to the current buffer. This command can be +used interactively, for example from a mail or news buffer." t nil) + +(autoload 'package-get-save-base "package-get" "\ +Write the package-get database to FILE. + +Note: This database will be unsigned of course." t nil) + +(autoload 'package-get-delete-package "package-get" "\ +Delete an installation of PACKAGE below directory PKG-TOPDIR. +PACKAGE is a symbol, not a string. +This is just an interactive wrapper for `package-admin-delete-binary-package'." t nil) + +(autoload 'package-get-update-all "package-get" "\ +Fetch and install the latest versions of all currently installed packages." t nil) + +(autoload 'package-get-all "package-get" "\ +Fetch PACKAGE with VERSION and all other required packages. +Uses `package-get-base' to determine just what is required and what +package provides that functionality. If VERSION is nil, retrieves +latest version. Optional argument FETCHED-PACKAGES is used to keep +track of packages already fetched. Optional argument INSTALL-DIR, +if non-nil, specifies the package directory where fetched packages +should be installed. + +Returns nil upon error." t nil) + +(autoload 'package-get-dependencies "package-get" "\ +Compute dependencies for PACKAGES. +Uses `package-get-base' to determine just what is required and what +package provides that functionality. Returns the list of packages +required by PACKAGES." nil nil) + +(autoload 'package-get "package-get" "\ +Fetch PACKAGE from remote site. +Optional arguments VERSION indicates which version to retrieve, nil +means most recent version. CONFLICT indicates what happens if the +package is already installed. Valid values for CONFLICT are: +'always always retrieve the package even if it is already installed +'never do not retrieve the package if it is installed. +INSTALL-DIR, if non-nil, specifies the package directory where +fetched packages should be installed. + +The value of `package-get-base' is used to determine what files should +be retrieved. The value of `package-get-remote' is used to determine +where a package should be retrieved from. The sites are tried in +order so one is better off listing easily reached sites first. + +Once the package is retrieved, its md5 checksum is computed. If that +sum does not match that stored in `package-get-base' for this version +of the package, an error is signalled. + +Returns `t' upon success, the symbol `error' if the package was +successfully installed but errors occurred during initialization, or +`nil' upon error." t nil) + +(autoload 'package-get-package-provider "package-get" "\ +Search for a package that provides SYM and return the name and + version. Searches in `package-get-base' for SYM. If SYM is a + consp, then it must match a corresponding (provide (SYM VERSION)) from + the package. + +If FORCE-CURRENT is non-nil make sure the database is up to date. This might +lead to Emacs accessing remote sites." t nil) + +(autoload 'package-get-custom "package-get" "\ +Fetch and install the latest versions of all customized packages." t nil) + +;;;*** + +;;;### (autoloads (package-net-update-installed-db package-net-setup-directory) "package-net" "lisp/package-net.el") + +(autoload 'package-net-setup-directory "package-net" nil nil nil) + +(autoload 'package-net-update-installed-db "package-net" "\ +Write out the installed package index in a net install suitable format. +If DESTDIR is non-nil then use that as the destination directory. +DESTDIR defaults to the value of `package-net-setup-directory'." nil nil) + +;;;*** + +;;;### (autoloads (pui-list-packages pui-add-install-directory package-ui-add-site) "package-ui" "lisp/package-ui.el") + +(autoload 'package-ui-add-site "package-ui" "\ +Add site to package-get-remote and possibly offer to update package list." nil nil) + +(autoload 'pui-add-install-directory "package-ui" "\ +Add a new package binary directory to the head of `package-get-remote'. +Note that no provision is made for saving any changes made by this function. +It exists mainly as a convenience for one-time package installations from +disk." t nil) + +(autoload 'pui-list-packages "package-ui" "\ +List all packages and package information. +The package name, version, and description are displayed. From the displayed +buffer, the user can see which packages are installed, which are not, and +which are out-of-date (a newer version is available). The user can then +select packages for installation via the keyboard or mouse." t nil) + +(defalias 'list-packages 'pui-list-packages) + +;;;*** + +;;;### (autoloads (picture-mode) "picture" "lisp/picture.el") + +(autoload 'picture-mode "picture" "\ +Switch to Picture mode, in which a quarter-plane screen model is used. +Printing characters replace instead of inserting themselves with motion +afterwards settable by these commands: + C-c < Move left after insertion. + C-c > Move right after insertion. + C-c ^ Move up after insertion. + C-c . Move down after insertion. + C-c ` Move northwest (nw) after insertion. + C-c ' Move northeast (ne) after insertion. + C-c / Move southwest (sw) after insertion. + C-c \\ Move southeast (se) after insertion. +The current direction is displayed in the modeline. The initial +direction is right. Whitespace is inserted and tabs are changed to +spaces when required by movement. You can move around in the buffer +with these commands: + \\[picture-move-down] Move vertically to SAME column in previous line. + \\[picture-move-up] Move vertically to SAME column in next line. + \\[picture-end-of-line] Move to column following last non-whitespace character. + \\[picture-forward-column] Move right inserting spaces if required. + \\[picture-backward-column] Move left changing tabs to spaces if required. + C-c C-f Move in direction of current picture motion. + C-c C-b Move in opposite direction of current picture motion. + Return Move to beginning of next line. +You can edit tabular text with these commands: + M-Tab Move to column beneath (or at) next interesting character. + `Indents' relative to a previous line. + Tab Move to next stop in tab stop list. + C-c Tab Set tab stops according to context of this line. + With ARG resets tab stops to default (global) value. + See also documentation of variable picture-tab-chars + which defines \"interesting character\". You can manually + change the tab stop list with command \\[edit-tab-stops]. +You can manipulate text with these commands: + C-d Clear (replace) ARG columns after point without moving. + C-c C-d Delete char at point - the command normally assigned to C-d. + \\[picture-backward-clear-column] Clear (replace) ARG columns before point, moving back over them. + \\[picture-clear-line] Clear ARG lines, advancing over them. The cleared + text is saved in the kill ring. + \\[picture-open-line] Open blank line(s) beneath current line. +You can manipulate rectangles with these commands: + C-c C-k Clear (or kill) a rectangle and save it. + C-c C-w Like C-c C-k except rectangle is saved in named register. + C-c C-y Overlay (or insert) currently saved rectangle at point. + C-c C-x Like C-c C-y except rectangle is taken from named register. + \\[copy-rectangle-to-register] Copies a rectangle to a register. + \\[advertised-undo] Can undo effects of rectangle overlay commands + commands if invoked soon enough. +You can return to the previous mode with: + C-c C-c Which also strips trailing whitespace from every line. + Stripping is suppressed by supplying an argument. + +Entry to this mode calls the value of picture-mode-hook if non-nil. + +Note that Picture mode commands will work outside of Picture mode, but +they are not defaultly assigned to keys." t nil) + +(defalias 'edit-picture 'picture-mode) + +;;;*** + +;;;### (autoloads (clear-rectangle string-rectangle open-rectangle insert-rectangle yank-rectangle kill-rectangle extract-rectangle delete-extract-rectangle delete-rectangle) "rect" "lisp/rect.el") + +(autoload 'delete-rectangle "rect" "\ +Delete the text in the region-rectangle without saving it. +The same range of columns is deleted in each line starting with the line +where the region begins and ending with the line where the region ends. + +When called from a program, the rectangle's corners are START and END. +With a prefix (or FILL) argument, also fill lines where nothing has to be +deleted." t nil) + +(autoload 'delete-extract-rectangle "rect" "\ +Delete the contents of the rectangle with corners at START and END, and +return it as a list of strings, one for each line of the rectangle. + +With an optional FILL argument, also fill lines where nothing has to be +deleted." nil nil) + +(autoload 'extract-rectangle "rect" "\ +Return the contents of the rectangle with corners at START and END, +as a list of strings, one for each line of the rectangle." nil nil) + +(defvar killed-rectangle nil "\ +Rectangle for `yank-rectangle' to insert.") + +(autoload 'kill-rectangle "rect" "\ +Delete the region-rectangle and save it as the last killed one. +You might prefer to use `delete-extract-rectangle' from a program. + +When called from a program, the rectangle's corners are START and END. +With a prefix (or FILL) argument, also fill lines where nothing has to be +deleted." t nil) + +(autoload 'yank-rectangle "rect" "\ +Yank the last killed rectangle with upper left corner at point." t nil) + +(autoload 'insert-rectangle "rect" "\ +Insert text of RECTANGLE with upper left corner at point. +RECTANGLE's first line is inserted at point, its second +line is inserted at a point vertically under point, etc. +RECTANGLE should be a list of strings. +After this command, the mark is at the upper left corner +and point is at the lower right corner." nil nil) + +(autoload 'open-rectangle "rect" "\ +Blank out the region-rectangle, shifting text right. + +When called from a program, the rectangle's corners are START and END. +With a prefix (or FILL) argument, fill with blanks even if there is no text +on the right side of the rectangle." t nil) + +(autoload 'string-rectangle "rect" "\ +Insert STRING on each line of the region-rectangle, shifting text right. +The left edge of the rectangle specifies the column for insertion. + +If `pending-delete-mode' is active the string replace the region. +Otherwise this command does not delete or overwrite any existing text. + +When called from a program, the rectangle's corners are START and END." t nil) + +(autoload 'clear-rectangle "rect" "\ +Blank out the region-rectangle. +The text previously in the region is overwritten with blanks. + +When called from a program, the rectangle's corners are START and END. +With a prefix (or FILL) argument, also fill with blanks the parts of the +rectangle which were empty." t nil) + +;;;*** + +;;;### (autoloads (list-load-path-shadows) "shadow" "lisp/shadow.el") + +(autoload 'list-load-path-shadows "shadow" "\ +Display a list of Emacs Lisp files that shadow other files. + +This function lists potential load-path problems. Directories in the +`load-path' variable are searched, in order, for Emacs Lisp +files. When a previously encountered file name is found again, a +message is displayed indicating that the later file is \"hidden\" by +the earlier. + +For example, suppose `load-path' is set to + +\(\"/usr/gnu/emacs/site-lisp\" \"/usr/gnu/emacs/share/emacs/19.30/lisp\") + +and that each of these directories contains a file called XXX.el. Then +XXX.el in the site-lisp directory is referred to by all of: +\(require 'XXX), (autoload .... \"XXX\"), (load-library \"XXX\") etc. + +The first XXX.el file prevents emacs from seeing the second (unless +the second is loaded explicitly via load-file). + +When not intended, such shadowings can be the source of subtle +problems. For example, the above situation may have arisen because the +XXX package was not distributed with versions of emacs prior to +19.30. An emacs maintainer downloaded XXX from elsewhere and installed +it. Later, XXX was updated and included in the emacs distribution. +Unless the emacs maintainer checks for this, the new version of XXX +will be hidden behind the old (which may no longer work with the new +emacs version). + +This function performs these checks and flags all possible +shadowings. Because a .el file may exist without a corresponding .elc +\(or vice-versa), these suffixes are essentially ignored. A file +XXX.elc in an early directory (that does not contain XXX.el) is +considered to shadow a later file XXX.el, and vice-versa. + +When run interactively, the shadowings (if any) are displayed in a +buffer called `*Shadows*'. Shadowings are located by calling the +\(non-interactive) companion function, `find-emacs-lisp-shadows'." t nil) + +;;;*** + +;;;### (autoloads (load-default-sounds load-sound-file) "sound" "lisp/sound.el") + +(or sound-alist (setq sound-alist '((ready nil) (warp nil)))) + +(autoload 'load-sound-file "sound" "\ +Read in an audio-file and add it to the sound-alist. + +FILENAME can either be absolute or relative, in which case the file will +be searched in the directories given by `default-sound-directory-list'. +When looking for the file, the extensions given by `sound-extension-list' are +also tried in the given order. + +You can only play sound files if you are running on display 0 of the +console of a machine with native sound support or running a NetAudio +or ESD server and XEmacs has the necessary sound support compiled in. + +The sound file must be in the Sun/NeXT U-LAW format, except on Linux +and MS Windows, where .wav files are also supported by the sound card +drivers." t nil) + +(autoload 'load-default-sounds "sound" "\ +Load and install some sound files as beep-types, using +`load-sound-file'. This only works if you're on display 0 of the +console of a machine with native sound support or running a NetAudio +server and XEmacs has the necessary sound support compiled in." t nil) + +;;;*** + +;;;### (autoloads (ask-user-about-supersession-threat ask-user-about-lock) "userlock" "lisp/userlock.el") + +(autoload 'ask-user-about-lock "userlock" "\ +Ask user wanting to edit FILENAME, locked by OTHER-USER, what to do. +This function has a choice of three things to do: + do (signal 'file-locked (list FILENAME OTHER-USER)) + to refrain from editing the file + return t (grab the lock on the file) + return nil (edit the file even though it is locked). +You can rewrite it to use any criteria you like to choose which one to do." nil nil) + +(autoload 'ask-user-about-supersession-threat "userlock" "\ +Ask user who is about to modify an obsolete buffer what to do. +This function has two choices: it can return, in which case the modification +of the buffer will proceed, or it can (signal 'file-supersession (FILENAME)), +in which case the proposed buffer modification will not be made. + +You can rewrite this to use any criteria you like to choose which one to do. +The buffer in question is current when this function is called." nil nil) + +;;;*** + +;;;### (autoloads (toggle-truncate-lines auto-view-mode view-major-mode view-mode view-minor-mode view-buffer-other-window view-file-other-window view-buffer view-file) "view-less" "lisp/view-less.el") + +(defvar view-minor-mode-map (let ((map (make-keymap))) (set-keymap-name map 'view-minor-mode-map) (suppress-keymap map) (define-key map "-" 'negative-argument) (define-key map " " 'scroll-up) (define-key map "f" 'scroll-up) (define-key map "b" 'scroll-down) (define-key map 'backspace 'scroll-down) (define-key map 'delete 'scroll-down) (define-key map " " 'view-scroll-lines-up) (define-key map "\n" 'view-scroll-lines-up) (define-key map "e" 'view-scroll-lines-up) (define-key map "j" 'view-scroll-lines-up) (define-key map "y" 'view-scroll-lines-down) (define-key map "k" 'view-scroll-lines-down) (define-key map "d" 'view-scroll-some-lines-up) (define-key map "u" 'view-scroll-some-lines-down) (define-key map "r" 'recenter) (define-key map "t" 'toggle-truncate-lines) (define-key map "N" 'view-buffer) (define-key map "E" 'view-file) (define-key map "P" 'view-buffer) (define-key map "!" 'shell-command) (define-key map "|" 'shell-command-on-region) (define-key map "=" 'what-line) (define-key map "?" 'view-search-backward) (define-key map "h" 'view-mode-describe) (define-key map "s" 'view-repeat-search) (define-key map "n" 'view-repeat-search) (define-key map "/" 'view-search-forward) (define-key map "\\" 'view-search-backward) (define-key map "g" 'view-goto-line) (define-key map "G" 'view-last-windowful) (define-key map "%" 'view-goto-percent) (define-key map "p" 'view-goto-percent) (define-key map "m" 'point-to-register) (define-key map "'" 'register-to-point) (define-key map "C" 'view-cleanup-backspaces) (define-key map "" 'view-quit) (define-key map "" 'view-quit-toggle-ro) (define-key map "q" 'view-quit) map)) + +(defvar view-mode-map (let ((map (copy-keymap view-minor-mode-map))) (set-keymap-name map 'view-mode-map) map)) + +(autoload 'view-file "view-less" "\ +Find FILENAME, enter view mode. With prefix arg OTHER-WINDOW-P, use other window." t nil) + +(autoload 'view-buffer "view-less" "\ +Switch to BUFFER, enter view mode. With prefix arg use other window." t nil) + +(autoload 'view-file-other-window "view-less" "\ +Find FILENAME in other window, and enter view mode." t nil) + +(autoload 'view-buffer-other-window "view-less" "\ +Switch to BUFFER in another window, and enter view mode." t nil) + +(autoload 'view-minor-mode "view-less" "\ +Minor mode for viewing text, with bindings like `less'. +Commands are: +\\<view-minor-mode-map> +0..9 prefix args +- prefix minus +\\[scroll-up] page forward +\\[scroll-down] page back +\\[view-scroll-lines-up] scroll prefix-arg lines forward, default 1. +\\[view-scroll-lines-down] scroll prefix-arg lines backward, default 1. +\\[view-scroll-some-lines-down] scroll prefix-arg lines backward, default 10. +\\[view-scroll-some-lines-up] scroll prefix-arg lines forward, default 10. +\\[what-line] print line number +\\[view-mode-describe] print this help message +\\[view-search-forward] regexp search, uses previous string if you just hit RET +\\[view-search-backward] as above but searches backward +\\[view-repeat-search] repeat last search +\\[view-goto-line] goto line prefix-arg, default 1 +\\[view-last-windowful] goto line prefix-arg, default last line +\\[view-goto-percent] goto a position by percentage +\\[toggle-truncate-lines] toggle truncate-lines +\\[view-file] view another file +\\[view-buffer] view another buffer +\\[view-cleanup-backspaces] cleanup backspace constructions +\\[shell-command] execute a shell command +\\[shell-command-on-region] execute a shell command with the region as input +\\[view-quit] exit view-mode, and bury the current buffer. + +If invoked with the optional (prefix) arg non-nil, view-mode cleans up +backspace constructions. + +More precisely: +\\{view-minor-mode-map}" t nil) + +(autoload 'view-mode "view-less" "\ +View the current buffer using view-minor-mode. This exists to be 99.9% +compatible with the implementations of `view-mode' in view.el and older +versions of view-less.el." t nil) + +(autoload 'view-major-mode "view-less" "\ +View the current buffer using view-mode, as a major mode. +This function has a nonstandard name because `view-mode' is wrongly +named but is like this for compatibility reasons." t nil) + +(autoload 'auto-view-mode "view-less" "\ +If the file of the current buffer is not writable, call view-mode. +This is meant to be added to `find-file-hooks'." nil nil) + +(autoload 'toggle-truncate-lines "view-less" "\ +Toggles the values of truncate-lines. +Positive prefix arg sets, negative disables." t nil) + +;;;*** + +;;;### (autoloads (widget-minor-mode widget-browse-other-window widget-browse widget-browse-at) "wid-browse" "lisp/wid-browse.el") + +(autoload 'widget-browse-at "wid-browse" "\ +Browse the widget under point." t nil) + +(autoload 'widget-browse "wid-browse" "\ +Create a widget browser for WIDGET." t nil) + +(autoload 'widget-browse-other-window "wid-browse" "\ +Show widget browser for WIDGET in other window." t nil) + +(autoload 'widget-minor-mode "wid-browse" "\ +Togle minor mode for traversing widgets. +With arg, turn widget mode on if and only if arg is positive." t nil) + +;;;*** + +;;;### (autoloads (widget-delete widget-create widget-prompt-value) "wid-edit" "lisp/wid-edit.el") + +(autoload 'widget-prompt-value "wid-edit" "\ +Prompt for a value matching WIDGET, using PROMPT. +The current value is assumed to be VALUE, unless UNBOUND is non-nil." nil nil) + +(autoload 'widget-create "wid-edit" "\ +Create widget of TYPE. +The optional ARGS are additional keyword arguments." nil nil) + +(autoload 'widget-delete "wid-edit" "\ +Delete WIDGET." nil nil) + +;;;*** + +;;;### (autoloads (x-font-menu-font-data x-reset-device-font-menus) "x-font-menu" "lisp/x-font-menu.el") + +(autoload 'x-reset-device-font-menus "x-font-menu" "\ +Generates the `Font', `Size', and `Weight' submenus for the Options menu. +This is run the first time that a font-menu is needed for each device. +If you don't like the lazy invocation of this function, you can add it to +`create-device-hook' and that will make the font menus respond more quickly +when they are selected for the first time. If you add fonts to your system, +or if you change your font path, you can call this to re-initialize the menus." nil nil) + +(autoload 'x-font-menu-font-data "x-font-menu" nil nil nil) + +;;;*** + +;;;### (autoloads (x-win-init-sun) "x-win-sun" "lisp/x-win-sun.el") + +(autoload 'x-win-init-sun "x-win-sun" nil nil nil) + +;;;*** + +;;;### (autoloads (x-win-init-xfree86) "x-win-xfree86" "lisp/x-win-xfree86.el") + +(autoload 'x-win-init-xfree86 "x-win-xfree86" nil nil nil) + +;;;*** + +(provide 'lisp-autoloads)
--- a/lwlib/ChangeLog Wed Aug 08 12:15:04 2001 +0000 +++ b/lwlib/ChangeLog Mon Aug 13 04:46:48 2001 +0000 @@ -1,3 +1,15 @@ +2001-06-24 Ben Wing <ben@xemacs.org> + + * lwlib-Xlw.c (xlw_update_tab_control): + * lwlib-utils.c (XtApplyUntilToWidgets): + * xlwgauge.c (XawGaugeSetValue): + * xlwgauge.c (GaugeMercury): + * xlwmenu.c (close_to_reference_time): + * xlwtabs.c (TabsSetValues): + * xlwtabs.c (TabsSelect): + * xlwtabs.c (DrawTabs): + Fix unsigned warnings. See src/ChangeLog for details. + 2001-07-28 Stephen J. Turnbull <stephen@xemacs.org> * XEmacs 21.5.2 "artichoke" is released.
--- a/lwlib/lwlib-Xlw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lwlib/lwlib-Xlw.c Mon Aug 13 04:46:48 2001 +0000 @@ -432,7 +432,7 @@ children = XtCompositeChildren (widget, &num_children); if (children) { - for (i = 0, cur = val->contents; i < num_children; i++) + for (i = 0, cur = val->contents; i < (int) num_children; i++) { if (!cur) abort ();
--- a/lwlib/lwlib-utils.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lwlib/lwlib-utils.c Mon Aug 13 04:46:48 2001 +0000 @@ -119,16 +119,17 @@ { CompositeWidget cw = (CompositeWidget)w; int i; - for (i = 0; i < cw->composite.num_children; i++) - if (XtIsWidget (cw->composite.children [i])){ - result = proc (cw->composite.children [i], arg); - if (result) - return result; - result = XtApplyUntilToWidgets (cw->composite.children [i], proc, - arg); - if (result) - return result; - } + for (i = 0; i < (int) cw->composite.num_children; i++) + if (XtIsWidget (cw->composite.children[i])) + { + result = proc (cw->composite.children[i], arg); + if (result) + return result; + result = XtApplyUntilToWidgets (cw->composite.children[i], proc, + arg); + if (result) + return result; + } } return NULL; }
--- a/lwlib/xlwgauge.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lwlib/xlwgauge.c Mon Aug 13 04:46:48 2001 +0000 @@ -837,8 +837,8 @@ } /* need to rescale? */ - if(( gw->gauge.autoScaleUp && value > gw->gauge.v1) || - (gw->gauge.autoScaleDown && value < gw->gauge.v1/3 )) + if(( gw->gauge.autoScaleUp && (int) value > gw->gauge.v1) || + (gw->gauge.autoScaleDown && (int) value < gw->gauge.v1/3 )) { XtVaSetValues(w, XtNvalue, value, 0) ; return ; @@ -895,10 +895,10 @@ if( vd <= 0 ) vd = 1 ; - if( val0 < v0 ) val0 = v0 ; - else if( val0 > v1 ) val0 = v1 ; - if( val1 < v0 ) val1 = v0 ; - else if( val1 > v1 ) val1 = v1 ; + if( (int) val0 < v0 ) val0 = v0 ; + else if( (int) val0 > v1 ) val0 = v1 ; + if( (int) val1 < v0 ) val1 = v0 ; + else if( (int) val1 > v1 ) val1 = v1 ; p0 = (val0-v0)*(e1-e0-1)/vd ; p1 = (val1-v0)*(e1-e0-1)/vd ;
--- a/lwlib/xlwmenu.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lwlib/xlwmenu.c Mon Aug 13 04:46:48 2001 +0000 @@ -348,7 +348,8 @@ { return reference_time && - (ev->xbutton.time - reference_time < XtGetMultiClickTime (XtDisplay (w))); + ((int) (ev->xbutton.time - reference_time) < + XtGetMultiClickTime (XtDisplay (w))); } /* Size code */
--- a/lwlib/xlwtabs.c Wed Aug 08 12:15:04 2001 +0000 +++ b/lwlib/xlwtabs.c Mon Aug 13 04:46:48 2001 +0000 @@ -626,7 +626,7 @@ /* Tab size has changed. Resize all tabs and request a new size */ for(i=0, childP=tw->composite.children; - i < tw->composite.num_children; + i < (int) tw->composite.num_children; ++i, ++childP) if( XtIsManaged(*childP) ) TabWidth(*childP) ; @@ -667,7 +667,7 @@ XtVaSetValues(w, XmNtraversalOn, True, 0) ; #endif - if( tab->tabs.row != tw->tabs.numRows-1 ) + if( tab->tabs.row != (int) tw->tabs.numRows-1 ) TabsShuffleRows(tw) ; needRedraw = True ; @@ -1066,7 +1066,7 @@ * widget to be top of stacking order with XawTabsSetTop(). */ for(i=0, childP=tw->composite.children; - i < TabsNumChildren (tw); + i < (int) TabsNumChildren (tw); ++i, ++childP) if( TabVisible(*childP) ) { @@ -1392,7 +1392,7 @@ */ y = tw->tabs.numRows == 1 ? TABDELTA : 0 ; - for(i=0; i<tw->tabs.numRows; ++i, y += th) + for(i=0; i < (int) tw->tabs.numRows; ++i, y += th) { for( j=TabsNumChildren (tw), childP=tw->composite.children; --j >= 0; ++childP ) @@ -1402,7 +1402,7 @@ if( tab->tabs.row == i && *childP != tw->tabs.topWidget ) DrawTab(tw, *childP, labels) ; } - if( i != tw->tabs.numRows -1 ) + if( i != (int) tw->tabs.numRows -1 ) DrawTrim(tw, 0,y+th, tw->core.width, th+s, False,False) ; }
--- a/man/xemacs-faq.texi Wed Aug 08 12:15:04 2001 +0000 +++ b/man/xemacs-faq.texi Mon Aug 13 04:46:48 2001 +0000 @@ -7,7 +7,7 @@ @finalout @titlepage @title XEmacs FAQ -@subtitle Frequently asked questions about XEmacs @* Last Modified: $Date: 2001/07/02 21:00:02 $ +@subtitle Frequently asked questions about XEmacs @* Last Modified: $Date: 2001/08/13 04:45:59 $ @sp 1 @author Tony Rossini <rossini@@biostat.washington.edu> @author Ben Wing <ben@@xemacs.org>
--- a/nt/ChangeLog Wed Aug 08 12:15:04 2001 +0000 +++ b/nt/ChangeLog Mon Aug 13 04:46:48 2001 +0000 @@ -1,3 +1,8 @@ +2001-06-24 Ben Wing <ben@xemacs.org> + + * config.h: + Turn sign-compare warnings back on. + 2001-07-28 Stephen J. Turnbull <stephen@xemacs.org> * XEmacs 21.5.2 "artichoke" is released.
--- a/nt/config.h Wed Aug 08 12:15:04 2001 +0000 +++ b/nt/config.h Mon Aug 13 04:46:48 2001 +0000 @@ -609,7 +609,7 @@ #if (_MSC_VER >= 800) /* 'expression' : signed/unsigned mismatch */ -#pragma warning ( disable : 4018 ) +/* #pragma warning ( disable : 4018 ) */ /* unnamed type definition in parentheses (Martin added a pedantically correct definition of ALIGNOF, which generates temporary anonymous structures, and MSVC complains) */
--- a/src/ChangeLog Wed Aug 08 12:15:04 2001 +0000 +++ b/src/ChangeLog Mon Aug 13 04:46:48 2001 +0000 @@ -1,3 +1,559 @@ +2001-06-24 Ben Wing <ben@xemacs.org> + + * EmacsFrame.c (EmacsFrameSetValues): + * alloc.c: + * alloc.c (xmalloc): + * alloc.c (xcalloc): + * alloc.c (xmalloc_and_zero): + * alloc.c (xrealloc): + * alloc.c (deadbeef_memory): + * alloc.c (allocate_lisp_storage): + * alloc.c (alloc_lcrecord): + * alloc.c (Fmake_list): + * alloc.c (size_vector): + * alloc.c (vector_hash): + * alloc.c (make_vector_internal): + * alloc.c (make_vector): + * alloc.c (make_bit_vector_internal): + * alloc.c (make_bit_vector): + * alloc.c (make_bit_vector_from_byte_vector): + * alloc.c (Fmake_string): + * alloc.c (make_lcrecord_list): + * alloc.c (GC_CHECK_LHEADER_INVARIANTS): + * alloc.c (tick_lcrecord_stats): + * alloc.c (sweep_strings): + * alloc.c (UNMARK_string): + * alloc.c (ADDITIONAL_FREE_string): + * alloc.c (garbage_collect_1): + * alloc.c (Fgarbage_collect): + * alloc.c (malloced_storage_size): + * alloc.c (fixed_type_block_overhead): + * backtrace.h: + * backtrace.h (SPECPDL_RESERVE): + * blocktype.c (Blocktype_newf): + * blocktype.h: + * blocktype.h (Blocktype_declare): + * buffer.c: + * buffer.c (compute_buffer_text_usage): + * buffer.c (DEFVAR_BUFFER_LOCAL_1): + * buffer.h (struct buffer_text): + * buffer.h (MAP_INDIRECT_BUFFERS): + * buffer.h (valid_char_p): + * buffer.h (union): + * buffer.h (bufbyte_memcmp): + * bytecode.c (optimize_byte_code): + * bytecode.c (compiled_function_hash): + * callproc.c (Fold_call_process_internal): + * chartab.c (char_table_entry_hash): + * chartab.c (char_table_hash): + * chartab.c (check_category_char): + * chartab.c (Fcheck_category_at): + * chartab.c (Fchar_in_category_p): + * chartab.h: + * console-x.c (x_semi_canonicalize_console_connection): + * console.h (struct console_methods): + * data.c (Faref): + * data.c (Faset): + * data.c (weak_list_hash): + * device-msw.c (msprinter_init_device): + * device-msw.c (Fmsprinter_select_settings): + * device-msw.c (hash_devmode): + * device-msw.c (Fmswindows_printer_list): + * device-x.c (validify_resource_component): + * device-x.c (Fx_put_resource): + * dialog-msw.c: + * dialog-msw.c (dialog_proc): + * dialog-msw.c (button_width): + * dialog-msw.c (ALIGN_TEMPLATE): + * dialog-msw.c (handle_question_dialog_box): + * dired.c (struct user_name): + * dired.c (user_name_completion): + * doc.c (get_doc_string): + * doc.c (Fsnarf_documentation): + * doprnt.c (parse_off_posnum): + * doprnt.c (emacs_doprnt_1): + * dumper.c: + * dumper.c (struct): + * dumper.c (dump_add_opaque): + * dumper.c (pdump_align_stream): + * dumper.c (pdump_size_to_align): + * dumper.c (pdump_entry_list_elt): + * dumper.c (pdump_add_entry): + * dumper.c (pdump_get_indirect_count): + * dumper.c (pdump_register_sub): + * dumper.c (pdump_dump_data): + * dumper.c (pdump_reloc_one): + * dumper.c (pdump_allocate_offset): + * dumper.c (pdump_dump_root_struct_ptrs): + * dumper.c (pdump_dump_root_objects): + * dumper.c (pdump_load_finish): + * dumper.c (pdump_resource_get): + * dumper.c (pdump_file_get): + * dynarr.c (Dynarr_memory_usage): + * editfns.c (Fformat_time_string): + * editfns.c (Fcurrent_time_string): + * eldap.c (Fldap_add): + * eldap.c (Fldap_modify): + * elhash.c: + * elhash.c (struct Lisp_Hash_Table): + * elhash.c (lisp_string_hash): + * elhash.c (lisp_object_eql_hash): + * elhash.c (lisp_object_equal_hash): + * elhash.c (hash_table_hash): + * elhash.c (print_hash_table): + * elhash.c (compute_hash_table_derived_values): + * elhash.c (make_standard_lisp_hash_table): + * elhash.c (make_general_lisp_hash_table): + * elhash.c (make_lisp_hash_table): + * elhash.c (decode_hash_table_size): + * elhash.c (resize_hash_table): + * elhash.c (enlarge_hash_table): + * elhash.c (remhash_1): + * elhash.c (internal_array_hash): + * elhash.c (internal_hash): + * elhash.h: + * emacs.c: + * eval.c (grow_specpdl): + * event-Xt.c (x_event_to_emacs_event): + * event-msw.c: + * event-msw.c (ntpipe_slurp_reader): + * event-msw.c (ntpipe_shove_writer): + * event-msw.c (struct winsock_stream): + * event-msw.c (winsock_reader): + * event-msw.c (winsock_writer): + * event-msw.c (mswindows_need_event): + * event-msw.c (assert): + * event-msw.c (mswindows_current_layout_has_AltGr): + * event-msw.c (debug_output_mswin_message): + * events.c (event_hash): + * extents.c (extent_list_locate): + * faces.c (face_hash): + * file-coding.c: + * file-coding.c (detect_eol_type): + * file-coding.c (detect_coding_type): + * file-coding.c (determine_real_coding_system): + * file-coding.c (Fdetect_coding_region): + * file-coding.c (decoding_reader): + * file-coding.c (decoding_writer): + * file-coding.c (mule_decode): + * file-coding.c (Fdecode_coding_region): + * file-coding.c (encoding_reader): + * file-coding.c (encoding_writer): + * file-coding.c (mule_encode): + * file-coding.c (Fencode_coding_region): + * file-coding.c (detect_coding_sjis): + * file-coding.c (decode_coding_sjis): + * file-coding.c (encode_coding_sjis): + * file-coding.c (DECODE_BIG5): + * file-coding.c (ENCODE_BIG5): + * file-coding.c (detect_coding_big5): + * file-coding.c (decode_coding_big5): + * file-coding.c (encode_coding_big5): + * file-coding.c (Fset_ucs_char): + * file-coding.c (detect_coding_ucs4): + * file-coding.c (decode_coding_ucs4): + * file-coding.c (encode_coding_ucs4): + * file-coding.c (detect_coding_utf8): + * file-coding.c (decode_coding_utf8): + * file-coding.c (encode_coding_utf8): + * file-coding.c (detect_coding_iso2022): + * file-coding.c (decode_coding_iso2022): + * file-coding.c (iso2022_designate): + * file-coding.c (encode_coding_iso2022): + * file-coding.c (decode_coding_no_conversion): + * file-coding.c (encode_coding_no_conversion): + * fileio.c (read_allowing_quit): + * fileio.c (write_allowing_quit): + * filelock.c (struct): + * filelock.c (LOCK_PID_MAX): + * filelock.c (fill_in_lock_file_name): + * filelock.c (lock_file_1): + * filelock.c (lock_file): + * floatfns.c (float_hash): + * fns.c (print_bit_vector): + * fns.c (bit_vector_hash): + * fns.c (size_bit_vector): + * fns.c (Flength): + * fns.c (Fsafe_length): + * fns.c (copy_list): + * fns.c (Fnthcdr): + * fns.c (Ffillarray): + * fns.c (bytecode_nconc2): + * fns.c (Fnconc): + * fns.c (mapcar1): + * fns.c (Fmapcar): + * fns.c (Fmapvector): + * fns.c (XMALLOC_OR_ALLOCA): + * font-lock.c: + * font-lock.c (SYNTAX_END_STYLE): + * font-lock.c (SINGLE_SYNTAX_STYLE): + * font-lock.c (find_context): + * frame-x.c (x_set_initial_frame_size): + * frame-x.c (Fcde_start_drag_internal): + * frame-x.c (Foffix_start_drag_internal): + * frame.h (struct frame): + * getloadavg.c: + * getloadavg.c (getloadavg): + * gif_io.c (GifStdRead): + * gif_io.c (GifStdWrite): + * gif_io.c (GifRead): + * gif_io.c (GifWrite): + * gifrlib.h: + * glyphs-eimage.c (message): + * glyphs-eimage.c (our_skip_input_data): + * glyphs-eimage.c (jpeg_memory_src): + * glyphs-eimage.c (gif_instantiate_unwind): + * glyphs-eimage.c (gif_read_from_memory): + * glyphs-eimage.c (gif_memory_close): + * glyphs-eimage.c (gif_error_func): + * glyphs-eimage.c (png_read_from_memory): + * glyphs-eimage.c (tiff_memory_read): + * glyphs-eimage.c (tiff_memory_write): + * glyphs-eimage.c (tiff_memory_seek): + * glyphs-eimage.c (tiff_memory_close): + * glyphs-eimage.c (tiff_map_noop): + * glyphs-eimage.c (tiff_unmap_noop): + * glyphs-eimage.c (tiff_memory_size): + * glyphs-eimage.c (tiff_error_func): + * glyphs-eimage.c (tiff_warning_func): + * glyphs-msw.c (xpm_to_eimage): + * glyphs-msw.c (mswindows_resource_instantiate): + * glyphs-msw.c (xbm_create_bitmap_from_data): + * glyphs-msw.c (mswindows_image_instance_hash): + * glyphs-shared.c (read_bitmap_data): + * glyphs-shared.c (read_bitmap_data_from_file): + * glyphs-x.c (x_image_instance_hash): + * glyphs-x.c (write_lisp_string_to_temp_file): + * glyphs-x.c (check_pointer_sizes): + * glyphs-x.c (x_xpm_instantiate): + * glyphs-x.c (x_subwindow_instantiate): + * glyphs.c (image_instance_hash): + * glyphs.c (bitmap_to_lisp_data): + * glyphs.c (instantiator_eq_hash): + * glyphs.c (glyph_hash): + * glyphs.h: + * glyphs.h (INITIALIZE_DEVICE_IIFORMAT): + * glyphs.h (struct Lisp_Image_Instance): + * glyphs.h (struct expose_ignore): + * gmalloc.c (_free_internal): + * gpmevent.c (tty_get_foreign_selection): + * gui-x.c (add_accel_and_to_external): + * gui.c (gui_item_display_flush_left): + * gui.c (gui_item_display_flush_right): + * gui.c (gui_item_hash): + * gui.h: + * hash.c: + * hash.c (memory_hash): + * hash.c (string_hash): + * hash.c (hash_table_size): + * hash.c (gethash): + * hash.c (make_hash_table): + * hash.c (make_general_hash_table): + * hash.c (grow_hash_table): + * hash.c (puthash): + * hash.c (rehash): + * hash.c (remhash): + * hash.h: + * hash.h (struct hash_table): + * hftctl.c (RD_BUF): + * imgproc.c (build_EImage_quantable): + * insdel.c (bytecount_to_charcount): + * keymap.c: + * keymap.c (make_keymap): + * keymap.c (relevant_map_push): + * line-number.c (insert_invalidate_line_number_cache): + * linuxplay.c (linux_play_data_or_file): + * lisp.h: + * lisp.h (DO_REALLOC): + * lisp.h (struct Lisp_Bit_Vector): + * lisp.h (bit_vector_bit): + * lisp.h (set_bit_vector_bit): + * lisp.h (struct lcrecord_list): + * lisp.h (struct overhead_stats): + * lrecord.h: + * lrecord.h (struct lrecord_implementation): + * lrecord.h (lrecord_description_type): + * lrecord.h (struct lrecord_description): + * lrecord.h (struct struct_description): + * lrecord.h (MAKE_EXTERNAL_LRECORD_IMPLEMENTATION): + * lrecord.h (RECORD_TYPEP): + * lrecord.h (DECLARE_EXTERNAL_LRECORD): + * lstream.c: + * lstream.c (aligned_sizeof_lstream): + * lstream.c (sizeof_lstream): + * lstream.c (Lstream_flush_out): + * lstream.c (Lstream_adding): + * lstream.c (Lstream_write_1): + * lstream.c (Lstream_write): + * lstream.c (Lstream_raw_read): + * lstream.c (Lstream_read_more): + * lstream.c (Lstream_read): + * lstream.c (Lstream_unread): + * lstream.c (Lstream_fputc): + * lstream.c (stdio_reader): + * lstream.c (stdio_writer): + * lstream.c (filedesc_reader): + * lstream.c (filedesc_writer): + * lstream.c (lisp_string_reader): + * lstream.c (struct fixed_buffer_stream): + * lstream.c (make_fixed_buffer_input_stream): + * lstream.c (make_fixed_buffer_output_stream): + * lstream.c (fixed_buffer_reader): + * lstream.c (fixed_buffer_writer): + * lstream.c (struct resizing_buffer_stream): + * lstream.c (resizing_buffer_writer): + * lstream.c (dynarr_writer): + * lstream.c (lisp_buffer_reader): + * lstream.c (lisp_buffer_writer): + * lstream.h: + * lstream.h (lstream_implementation): + * lstream.h (struct lstream): + * malloc.c: + * malloc.c (malloc): + * malloc.c (free): + * malloc.c (realloc): + * md5.c (Fmd5): + * menubar-msw.c (displayable_menu_item): + * mule-ccl.c (ccl_driver): + * mule-charset.c (non_ascii_charptr_copy_char): + * mule-charset.c (Lstream_get_emchar_1): + * mule-charset.h (struct Lisp_Charset): + * mule-charset.h (CHARSET_BY_ATTRIBUTES): + * mule-wnnfns.c (m2w): + * ntheap.c (recreate_heap): + * ntproc.c (find_child_pid): + * objects-msw.c (mswindows_string_to_color): + * objects-msw.c (mswindows_initialize_color_instance): + * objects-msw.c (mswindows_valid_color_name_p): + * objects-x.c (x_initialize_font_instance): + * objects-x.c (truename_via_FONT_prop): + * objects-x.c (x_font_instance_properties): + * offix.c (DndDragButtons): + * offix.h: + * opaque.c (aligned_sizeof_opaque): + * opaque.c (sizeof_opaque): + * opaque.c (make_opaque): + * opaque.c (equal_opaque): + * opaque.c (reinit_opaque_once_early): + * opaque.h: + * opaque.h (Lisp_Opaque): + * postgresql.h (message): + * process-nt.c (alloc_process_memory): + * process-nt.c (run_in_other_process): + * process-nt.c (nt_send_process): + * process-unix.c (unix_send_process): + * rangetab.c (get_range_table): + * redisplay-msw.c (mswindows_output_cursor): + * redisplay-x.c (x_output_string): + * redisplay-x.c (x_output_vertical_divider): + * redisplay.c (add_hscroll_rune): + * redisplay.c (add_octal_runes): + * redisplay.c (add_control_char_runes): + * redisplay.c (add_propagation_runes): + * redisplay.c (redisplay_window): + * redisplay.c (point_in_line_start_cache): + * redisplay.c (glyph_to_pixel_translation): + * regex.c: + * regex.c (init_syntax_once): + * regex.c (print_fastmap): + * regex.c (print_double_string): + * regex.c (struct): + * regex.c (PUSH_FAILURE_POINT): + * regex.c (POP_FAILURE_POINT): + * regex.c (union): + * regex.c (SET_REGS_MATCHED): + * regex.c (GET_BUFFER_SPACE): + * regex.c (regex_compile): + * regex.c (compile_range): + * regex.c (re_compile_fastmap): + * regex.c (re_set_registers): + * regex.c (re_search_2): + * regex.c (re_match_2_internal): + * regex.c (regcomp): + * regex.c (regexec): + * regex.c (regerror): + * regex.h: + * regex.h (Element_Count): + * regex.h (struct re_pattern_buffer): + * regex.h (struct re_registers): + * search.c (skip_chars): + * select-gtk.c: + * select-gtk.c (symbol_to_gtk_atom): + * select-gtk.c (atom_to_symbol): + * select-gtk.c (PROCESSING_GTK_CODE): + * select-gtk.c (emacs_gtk_selection_handle): + * select-gtk.c (gtk_get_window_property): + * select-gtk.c (receive_incremental_selection): + * select-gtk.c (gtk_get_window_property_as_lisp_data): + * select-x.c: + * select-x.c (symbol_to_x_atom): + * select-x.c (PROCESSING_X_CODE): + * select-x.c (x_reply_selection_request): + * select-x.c (x_handle_selection_request): + * select-x.c (copy_multiple_data): + * select-x.c (x_get_window_property): + * select-x.c (receive_incremental_selection): + * select-x.c (x_get_window_property_as_lisp_data): + * select-x.c (Fx_get_cutbuffer_internal): + * select-x.c (Fx_store_cutbuffer_internal): + * sheap.c (report_sheap_usage): + * specifier.c (aligned_sizeof_specifier): + * specifier.c (sizeof_specifier): + * specifier.c (make_specifier_internal): + * symbols.c (defsymbol_massage_name_1): + * symbols.c (defkeyword_massage_name): + * symbols.c (deferror_massage_name_and_message): + * sysdep.c (get_eof_char): + * sysdep.c (tty_init_sys_modes_on_device): + * sysdep.c (init_system_name): + * sysdir.h (select): + * tests.c (Ftest_data_format_conversion): + * tparam.c: + * unexaix.c (copy_sym): + * unexconvex.c (sptr;): + * unexconvex.c (copy_sym): + * unexcw.c: + * unexcw.c (unexec): + * unexcw.c (ALLOC_MASK): + * unexcw.c (CHECK_AOUT_POS): + * unexcw.c (get_section_info): + * unexcw.c (copy_executable_and_dump_data_section): + * unexcw.c (dup_file_area): + * unexcw.c (write_int_to_bss): + * unexec.c (make_hdr): + * unexec.c (copy_sym): + * window.c (struct window_config): + * window.c (mark_window_config): + * window.c (sizeof_window_config_for_n_windows): + * window.c (sizeof_window_config): + * window.c (window_config_equal): + * window.c (free_window_configuration): + * window.c (Fset_window_configuration): + * window.c (count_windows): + * window.c (Fcurrent_window_configuration): + * window.c (reinit_vars_of_window): + * xgccache.c (gc_cache_hash): + * xmu.c (XmuCursorNameToIndex): + Create types Memory_Count, Element_Count, Hash_Code. The first + two are EMACS_INT, the last EMACS_UINT. Use them to replace + size_t, and to replace int/unsigned int where appropriate + (there are probably more such places). + + Eliminate size_t and hashcode_t everywhere except in ancillary + code that is borrowed from elsewhere. (Use Memory_Count, + Element_Count, Hash_Code, Bytecount, Extcount, or EMACS_INT.) + Eliminate use of unsigned everywhere except in the same code, when + (a) it holds a simple count (rather than a bit flag and such); (b) + it refers to an int or long, not something smaller; (c) it's not + necessary specifically to call an external API with such a + parameter (we treat such parameters like Extbyte, and convert at + the point of entry/exit); and (d) there's no reasonable + possibility it will refer to a value greater than 2G, or if it + could, other things in XEmacs would break. + + Put parens around all sizeof args in case we decide to macro-ize + this. (I don't think it's necessary. Now that we've turned + sign-compare warnings back on, we will get warnings wherever the + unsigned return value of sizeof might cause problems. That's + what the warnings are for, after all.) + + Eliminate dumper type XD_SIZE_T and replace with XD_MEMORY_COUNT, + XD_ELEMENT_COUNT, XD_HASH_CODE. + + Rename Lstream_data_count to Lstream_Data_Count, following the + capitalization conventions used in other types. + + * elhash.c (hash_table_size): + Hash table sizes are signed now, so comment out the two highest + (post-2G) numbers in the primes list. + + * event-msw.c (mswindows_current_layout_has_AltGr): + Rewrite to be a bit more correct and fix unsigned problems. + + * extents.c (extent_hash): + * extents.c (set_extent_glyph): + * extents.c (Fset_extent_begin_glyph_layout): + * extents.c (Fset_extent_end_glyph_layout): + * extents.h: + * extents.h (set_extent_normal_field): + * extents.h (extent_begin_glyph_layout): + To eliminate warnings, create set functions for the enum fields + in struct extent. + + * filelock.c: Use pid_t instead of unsigned long to represent a pid. + (#### Perhaps a bad idea. Generally using unknown types of this + sort is bad.) + + * gif_io.c: + Include lisp.h. + + * glyphs-eimage.c (jpeg_instantiate): + * glyphs-eimage.c (gif_memory_storage): + * glyphs-eimage.c (gif_instantiate): + * glyphs-eimage.c (struct png_memory_storage): + * glyphs-eimage.c (png_instantiate): + * glyphs-eimage.c (tiff_memory_storage): + * glyphs-eimage.c (tiff_instantiate): + Replace Extbyte with more correct UChar_Binary, Extcount with + Memory_Count. + + * glyphs-shared.c (read_bitmap_data): + Replace char with Char_ASCII. + + * gui-x.c: + Replace unsigned int with more correct LWLIB_ID for lwlib_id_tick. + + * hftctl.c: + This was trying to include "lisp.h" to encapsulated file functions + (where they once were encapsulated, but no more); so include + sysfile.h. This only affects read(). + + * imgproc.c (get_histogram): + replace unsigned char with UChar_Binary. + + * lisp.h: + Move basic types to top of file since we need them in some + macros just below. + + * redisplay-x.c: + Convert various variables that were declared as unsigned due to + return values from X functions to be signed, and create "external" + versions of the variables to retrieve the unsigned value, which is + then immediately converted to signed. + + * tparam.c: + Eliminate useless non-#ifdef emacs code. + + * select-common.h: + * select-gtk.c: + * select-x.c: + Abstract out hairy and duplicated code from select-x/gtk.c and + put into select-common.h. Use ifdefs to handle the (small + number of) differences. + + * select-x.c (x_reply_selection_request): + * select-x.c (x_handle_selection_request): + * select-x.c (copy_multiple_data): + * select-x.c (x_get_window_property): + * select-x.c (receive_incremental_selection): + * select-x.c (x_get_window_property_as_lisp_data): + * select-x.c (Fx_get_cutbuffer_internal): + * select-x.c (Fx_store_cutbuffer_internal): + Replace uses of `unsigned char' and `Extbyte' with UChar_Binary. + + * sysdep.c (init_baud_rate): + Fix warning when HAVE_TTY not defined. + + * glyphs-eimage.c: + * postgresql.h: + * sysdir.h: + Do some hackery to avoid shadowing warnings. + + * s\esix.h: + * m\tad68k.h: + Comment out redefinition of select (we don't have our own version + anyway, and we play preprocessor games with select in sysdir.h). + 2001-08-04 Adrian Aichner <adrian@xemacs.org> * console.c: Fix of compile error on darwin, as suggested by Toby
--- a/src/EmacsFrame.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/EmacsFrame.c Mon Aug 13 04:46:48 2001 +0000 @@ -518,7 +518,7 @@ && cur->core.height == new->core.height) { int i; - for (i=0; i<*argc; i++) + for (i = 0; i < (int) *argc; i++) if (strcmp (argv[i].name, XtNwidth) == 0 || strcmp (argv[i].name, XtNheight) == 0) {
--- a/src/alloc.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/alloc.c Mon Aug 13 04:46:48 2001 +0000 @@ -243,7 +243,7 @@ #undef xmalloc void * -xmalloc (size_t size) +xmalloc (Memory_Count size) { void *val = malloc (size); @@ -253,7 +253,7 @@ #undef xcalloc static void * -xcalloc (size_t nelem, size_t elsize) +xcalloc (Element_Count nelem, Memory_Count elsize) { void *val = calloc (nelem, elsize); @@ -262,14 +262,14 @@ } void * -xmalloc_and_zero (size_t size) +xmalloc_and_zero (Memory_Count size) { return xcalloc (size, sizeof (char)); } #undef xrealloc void * -xrealloc (void *block, size_t size) +xrealloc (void *block, Memory_Count size) { block = realloc (block, size); @@ -307,10 +307,10 @@ #endif static void -deadbeef_memory (void *ptr, size_t size) +deadbeef_memory (void *ptr, Memory_Count size) { four_byte_t *ptr4 = (four_byte_t *) ptr; - size_t beefs = size >> 2; + Memory_Count beefs = size >> 2; /* In practice, size will always be a multiple of four. */ while (beefs--) @@ -345,7 +345,7 @@ static void * -allocate_lisp_storage (size_t size) +allocate_lisp_storage (Memory_Count size) { return xmalloc (size); } @@ -357,7 +357,7 @@ static struct lcrecord_header *all_lcrecords; void * -alloc_lcrecord (size_t size, const struct lrecord_implementation *implementation) +alloc_lcrecord (Memory_Count size, const struct lrecord_implementation *implementation) { struct lcrecord_header *lcheader; @@ -997,7 +997,7 @@ { Lisp_Object val = Qnil; - size_t size = XINT (length); + EMACS_INT size = XINT (length); while (size--) val = Fcons (object, val); @@ -1052,7 +1052,7 @@ return (len > 0) ? ptr->contents[len - 1] : Qnil; } -static size_t +static Memory_Count size_vector (const void *lheader) { return FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Vector, Lisp_Object, contents, @@ -1076,7 +1076,7 @@ return 1; } -static hashcode_t +static Hash_Code vector_hash (Lisp_Object obj, int depth) { return HASH2 (XVECTOR_LENGTH (obj), @@ -1100,10 +1100,10 @@ /* #### should allocate `small' vectors from a frob-block */ static Lisp_Vector * -make_vector_internal (size_t sizei) +make_vector_internal (Element_Count sizei) { /* no vector_next */ - size_t sizem = FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Vector, Lisp_Object, + Memory_Count sizem = FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Vector, Lisp_Object, contents, sizei); Lisp_Vector *p = (Lisp_Vector *) alloc_lcrecord (sizem, &lrecord_vector); @@ -1112,7 +1112,7 @@ } Lisp_Object -make_vector (size_t length, Lisp_Object object) +make_vector (Element_Count length, Lisp_Object object) { Lisp_Vector *vecp = make_vector_internal (length); Lisp_Object *p = vector_data (vecp); @@ -1264,11 +1264,12 @@ /* #### should allocate `small' bit vectors from a frob-block */ static Lisp_Bit_Vector * -make_bit_vector_internal (size_t sizei) +make_bit_vector_internal (Element_Count sizei) { - size_t num_longs = BIT_VECTOR_LONG_STORAGE (sizei); - size_t sizem = FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Bit_Vector, unsigned long, - bits, num_longs); + Element_Count num_longs = BIT_VECTOR_LONG_STORAGE (sizei); + Memory_Count sizem = FLEXIBLE_ARRAY_STRUCT_SIZEOF (Lisp_Bit_Vector, + unsigned long, + bits, num_longs); Lisp_Bit_Vector *p = (Lisp_Bit_Vector *) allocate_lisp_storage (sizem); set_lheader_implementation (&p->lheader, &lrecord_bit_vector); @@ -1284,10 +1285,10 @@ } Lisp_Object -make_bit_vector (size_t length, Lisp_Object bit) +make_bit_vector (Element_Count length, Lisp_Object bit) { Lisp_Bit_Vector *p = make_bit_vector_internal (length); - size_t num_longs = BIT_VECTOR_LONG_STORAGE (length); + Element_Count num_longs = BIT_VECTOR_LONG_STORAGE (length); CHECK_BIT (bit); @@ -1295,7 +1296,7 @@ memset (p->bits, 0, num_longs * sizeof (long)); else { - size_t bits_in_last = length & (LONGBITS_POWER_OF_2 - 1); + Element_Count bits_in_last = length & (LONGBITS_POWER_OF_2 - 1); memset (p->bits, ~0, num_longs * sizeof (long)); /* But we have to make sure that the unused bits in the last long are 0, so that equal/hash is easy. */ @@ -1311,9 +1312,9 @@ } Lisp_Object -make_bit_vector_from_byte_vector (unsigned char *bytevec, size_t length) +make_bit_vector_from_byte_vector (unsigned char *bytevec, Element_Count length) { - size_t i; + Element_Count i; Lisp_Bit_Vector *p = make_bit_vector_internal (length); for (i = 0; i < length; i++) @@ -2041,7 +2042,7 @@ memset (XSTRING_DATA (val), XCHAR (character), XSTRING_LENGTH (val)); else { - size_t i; + EMACS_INT i; Bufbyte *ptr = XSTRING_DATA (val); for (i = XINT (length); i; i--) @@ -2226,7 +2227,7 @@ mark_lcrecord_list, internal_object_printer, 0, 0, 0, 0, struct lcrecord_list); Lisp_Object -make_lcrecord_list (size_t size, +make_lcrecord_list (Element_Count size, const struct lrecord_implementation *implementation) { struct lcrecord_list *p = alloc_lcrecord_type (struct lcrecord_list, @@ -2326,8 +2327,8 @@ /* All the built-in lisp object types are enumerated in `enum lrecord_type'. Additional ones may be defined by a module (none yet). We leave some room in `lrecord_implementations_table' for such new lisp object types. */ -const struct lrecord_implementation *lrecord_implementations_table[(unsigned int)lrecord_type_last_built_in_type + MODULE_DEFINABLE_TYPE_COUNT]; -unsigned int lrecord_type_count = (unsigned int)lrecord_type_last_built_in_type; +const struct lrecord_implementation *lrecord_implementations_table[(int)lrecord_type_last_built_in_type + MODULE_DEFINABLE_TYPE_COUNT]; +int lrecord_type_count = lrecord_type_last_built_in_type; /* Object marker functions are in the lrecord_implementation structure. But copying them to a parallel array is much more cache-friendly. This hack speeds up (garbage-collect) by about 5%. */ @@ -2382,7 +2383,7 @@ #define GC_CHECK_LHEADER_INVARIANTS(lheader) do { \ struct lrecord_header * GCLI_lh = (lheader); \ assert (GCLI_lh != 0); \ - assert (GCLI_lh->type < lrecord_type_count); \ + assert (GCLI_lh->type < (unsigned int) lrecord_type_count); \ assert (! C_READONLY_RECORD_HEADER_P (GCLI_lh) || \ (MARKED_RECORD_HEADER_P (GCLI_lh) && \ LISP_READONLY_RECORD_HEADER_P (GCLI_lh))); \ @@ -2456,8 +2457,8 @@ static int gc_count_num_bit_vector_used, gc_count_bit_vector_total_size; static int gc_count_bit_vector_storage; static int gc_count_num_short_string_in_use; -static int gc_count_string_total_size; -static int gc_count_short_string_total_size; +static Bytecount gc_count_string_total_size; +static Bytecount gc_count_short_string_total_size; /* static int gc_count_total_records_used, gc_count_records_total_size; */ @@ -2476,7 +2477,7 @@ static void tick_lcrecord_stats (const struct lrecord_header *h, int free_p) { - unsigned int type_index = h->type; + int type_index = h->type; if (((struct lcrecord_header *) h)->free) { @@ -2488,7 +2489,7 @@ const struct lrecord_implementation *implementation = LHEADER_IMPLEMENTATION (h); - size_t sz = (implementation->size_in_bytes_method ? + Memory_Count sz = (implementation->size_in_bytes_method ? implementation->size_in_bytes_method (h) : implementation->static_size); if (free_p) @@ -3055,12 +3056,13 @@ static void sweep_strings (void) { - int num_small_used = 0, num_small_bytes = 0, num_bytes = 0; + int num_small_used = 0; + Bytecount num_small_bytes = 0, num_bytes = 0; int debug = debug_string_purity; #define UNMARK_string(ptr) do { \ Lisp_String *p = (ptr); \ - size_t size = string_length (p); \ + Bytecount size = string_length (p); \ UNMARK_RECORD_HEADER (&(p->lheader)); \ num_bytes += size; \ if (!BIG_STRING_SIZE_P (size)) \ @@ -3072,7 +3074,7 @@ debug_string_purity_print (p); \ } while (0) #define ADDITIONAL_FREE_string(ptr) do { \ - size_t size = string_length (ptr); \ + Bytecount size = string_length (ptr); \ if (BIG_STRING_SIZE_P (size)) \ xfree (ptr->data); \ } while (0) @@ -3394,10 +3396,10 @@ { /* Static buffer in which we save a copy of the C stack at each GC. */ static char *stack_copy; - static size_t stack_copy_size; + static Memory_Count stack_copy_size; ptrdiff_t stack_diff = &stack_top_variable - stack_bottom; - size_t stack_size = (stack_diff > 0 ? stack_diff : -stack_diff); + Memory_Count stack_size = (stack_diff > 0 ? stack_diff : -stack_diff); if (stack_size < MAX_SAVE_STACK) { if (stack_copy_size < stack_size) @@ -3422,14 +3424,14 @@ { /* staticpro() */ Lisp_Object **p = Dynarr_begin (staticpros); - size_t count; + Element_Count count; for (count = Dynarr_length (staticpros); count; count--) mark_object (**p++); } { /* staticpro_nodump() */ Lisp_Object **p = Dynarr_begin (staticpros_nodump); - size_t count; + Element_Count count; for (count = Dynarr_length (staticpros_nodump); count; count--) mark_object (**p++); } @@ -3587,7 +3589,7 @@ ()) { Lisp_Object pl = Qnil; - unsigned int i; + int i; int gc_count_vector_total_size = 0; garbage_collect_1 (); @@ -3762,15 +3764,14 @@ blocks are allocated in the minimum required size except that some minimum block size is imposed (e.g. 16 bytes). */ -size_t -malloced_storage_size (void *ptr, size_t claimed_size, +Memory_Count +malloced_storage_size (void *ptr, Memory_Count claimed_size, struct overhead_stats *stats) { - size_t orig_claimed_size = claimed_size; + Memory_Count orig_claimed_size = claimed_size; #ifdef GNU_MALLOC - - if (claimed_size < 2 * sizeof (void *)) + if (claimed_size < (Memory_Count) (2 * sizeof (void *))) claimed_size = 2 * sizeof (void *); # ifdef SUNOS_LOCALTIME_BUG if (claimed_size < 16) @@ -3795,7 +3796,7 @@ } /* We have to come up with some average about the amount of blocks used. */ - if ((size_t) (rand () & 4095) < claimed_size) + if ((Memory_Count) (rand () & 4095) < claimed_size) claimed_size += 3 * sizeof (void *); } else @@ -3846,12 +3847,12 @@ return claimed_size; } -size_t -fixed_type_block_overhead (size_t size) +Memory_Count +fixed_type_block_overhead (Memory_Count size) { - size_t per_block = TYPE_ALLOC_SIZE (cons, unsigned char); - size_t overhead = 0; - size_t storage_size = malloced_storage_size (0, per_block, 0); + Memory_Count per_block = TYPE_ALLOC_SIZE (cons, unsigned char); + Memory_Count overhead = 0; + Memory_Count storage_size = malloced_storage_size (0, per_block, 0); while (size >= per_block) { size -= per_block;
--- a/src/backtrace.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/backtrace.h Mon Aug 13 04:46:48 2001 +0000 @@ -151,7 +151,7 @@ /* Most callers should simply use specbind() and unbind_to(), but if speed is REALLY IMPORTANT, you can use the faster macros below */ void specbind_magic (Lisp_Object, Lisp_Object); -void grow_specpdl (size_t reserved); +void grow_specpdl (EMACS_INT reserved); void unbind_to_hairy (int); extern int specpdl_size; @@ -219,7 +219,7 @@ /* Request enough room for SIZE future entries on special binding stack */ #define SPECPDL_RESERVE(size) do { \ - size_t SR_size = (size); \ + EMACS_INT SR_size = (size); \ if (specpdl_depth() + SR_size >= specpdl_size) \ grow_specpdl (SR_size); \ } while (0)
--- a/src/blocktype.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/blocktype.c Mon Aug 13 04:46:48 2001 +0000 @@ -77,10 +77,10 @@ }; void * -Blocktype_newf (size_t elsize) +Blocktype_newf (Memory_Count elsize) { Blocktype *b = xnew (Blocktype); - b->elsize = max (elsize, sizeof (void *)); + b->elsize = max (elsize, (Memory_Count) sizeof (void *)); b->free = 0; return (void *) b; }
--- a/src/blocktype.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/blocktype.h Mon Aug 13 04:46:48 2001 +0000 @@ -31,10 +31,10 @@ #define Blocktype_declare(type) \ type *free; \ - int elsize; \ + Memory_Count elsize; \ type *tempel -void *Blocktype_newf (size_t elsize); +void *Blocktype_newf (Memory_Count elsize); void Blocktype_allocf (void *b); void Blocktype_free (void *bbb, void *el);
--- a/src/buffer.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/buffer.c Mon Aug 13 04:46:48 2001 +0000 @@ -1672,12 +1672,12 @@ int other; }; -static size_t +static Memory_Count compute_buffer_text_usage (struct buffer *b, struct overhead_stats *ovstats) { int was_requested = b->text->z - 1; - size_t gap = b->text->gap_size + b->text->end_gap_size; - size_t malloc_use = malloced_storage_size (b->text->beg, was_requested + gap, 0); + Memory_Count gap = b->text->gap_size + b->text->end_gap_size; + Memory_Count malloc_use = malloced_storage_size (b->text->beg, was_requested + gap, 0); ovstats->gap_overhead += gap; ovstats->was_requested += was_requested; @@ -1913,7 +1913,7 @@ while (1) { - Lstream_data_count size_in_bytes; + Lstream_Data_Count size_in_bytes; char tempbuf[1024]; /* some random amount */ size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf)); @@ -2051,7 +2051,7 @@ while (1) { - Lstream_data_count size_in_bytes; + Lstream_Data_Count size_in_bytes; char tempbuf[1024]; /* some random amount */ size_in_bytes = Lstream_read (reader, tempbuf, sizeof (tempbuf)); @@ -2321,35 +2321,35 @@ /* Renamed from DEFVAR_PER_BUFFER because FSFmacs D_P_B takes a bogus extra arg, which confuses an otherwise identical make-docfile.c */ -#define DEFVAR_BUFFER_LOCAL_1(lname, field_name, forward_type, magicfun) do { \ - static const struct symbol_value_forward I_hate_C = \ - { /* struct symbol_value_forward */ \ - { /* struct symbol_value_magic */ \ - { /* struct lcrecord_header */ \ - { /* struct lrecord_header */ \ - lrecord_type_symbol_value_forward, /* lrecord_type_index */ \ - 1, /* mark bit */ \ - 1, /* c_readonly bit */ \ - 1 /* lisp_readonly bit */ \ - }, \ - 0, /* next */ \ - 0, /* uid */ \ - 0 /* free */ \ - }, \ - &(buffer_local_flags.field_name), \ - forward_type \ - }, \ - magicfun \ - }; \ - \ - { \ - int offset = ((char *)symbol_value_forward_forward (&I_hate_C) - \ - (char *)&buffer_local_flags); \ - defvar_magic (lname, &I_hate_C); \ - \ - *((Lisp_Object *)(offset + (char *)XBUFFER (Vbuffer_local_symbols))) \ - = intern (lname); \ - } \ +#define DEFVAR_BUFFER_LOCAL_1(lname, field_name, forward_type, magicfun) do { \ + static const struct symbol_value_forward I_hate_C = \ + { /* struct symbol_value_forward */ \ + { /* struct symbol_value_magic */ \ + { /* struct lcrecord_header */ \ + { /* struct lrecord_header */ \ + lrecord_type_symbol_value_forward, /* lrecord_type_index */ \ + 1, /* mark bit */ \ + 1, /* c_readonly bit */ \ + 1 /* lisp_readonly bit */ \ + }, \ + 0, /* next */ \ + 0, /* uid */ \ + 0 /* free */ \ + }, \ + &(buffer_local_flags.field_name), \ + forward_type \ + }, \ + magicfun \ + }; \ + \ + { \ + int offset = ((char *)symbol_value_forward_forward (&I_hate_C) - \ + (char *)&buffer_local_flags); \ + defvar_magic (lname, &I_hate_C); \ + \ + *((Lisp_Object *)(offset + (char *)XBUFFER (Vbuffer_local_symbols))) \ + = intern (lname); \ + } \ } while (0) #define DEFVAR_BUFFER_LOCAL_MAGIC(lname, field_name, magicfun) \
--- a/src/buffer.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/buffer.h Mon Aug 13 04:46:48 2001 +0000 @@ -83,8 +83,8 @@ Bytind gpt; /* Index of gap in buffer. */ Bytind z; /* Index of end of buffer. */ Bufpos bufz; /* Equivalent as a Bufpos. */ - int gap_size; /* Size of buffer's gap */ - int end_gap_size; /* Size of buffer's end gap */ + Memory_Count gap_size;/* Size of buffer's gap */ + Memory_Count end_gap_size;/* Size of buffer's end gap */ long modiff; /* This counts buffer-modification events for this buffer. It is incremented for each such event, and never otherwise @@ -250,15 +250,15 @@ variable that gets the buffer values (beginning with the base buffer, then the children), and MPS_BUFCONS should be a temporary Lisp_Object variable. */ -#define MAP_INDIRECT_BUFFERS(mps_buf, mps_bufvar, mps_bufcons) \ -for (mps_bufcons = Qunbound, \ - mps_bufvar = BUFFER_BASE_BUFFER (mps_buf); \ - UNBOUNDP (mps_bufcons) ? \ - (mps_bufcons = mps_bufvar->indirect_children, \ - 1) \ - : (!NILP (mps_bufcons) \ - && (mps_bufvar = XBUFFER (XCAR (mps_bufcons)), 1) \ - && (mps_bufcons = XCDR (mps_bufcons), 1)); \ +#define MAP_INDIRECT_BUFFERS(mps_buf, mps_bufvar, mps_bufcons) \ +for (mps_bufcons = Qunbound, \ + mps_bufvar = BUFFER_BASE_BUFFER (mps_buf); \ + UNBOUNDP (mps_bufcons) ? \ + (mps_bufcons = mps_bufvar->indirect_children, \ + 1) \ + : (!NILP (mps_bufcons) \ + && (mps_bufvar = XBUFFER (XCAR (mps_bufcons)), 1) \ + && (mps_bufcons = XCDR (mps_bufcons), 1)); \ ) @@ -553,7 +553,7 @@ INLINE_HEADER int valid_char_p (Emchar ch) { - return ((unsigned int) (ch) <= 0xff) || non_ascii_valid_char_p (ch); + return ch <= 0xFF || non_ascii_valid_char_p (ch); } #else /* not MULE */ @@ -1169,7 +1169,7 @@ typedef union { - struct { const void *ptr; size_t len; } data; + struct { const void *ptr; Memory_Count len; } data; Lisp_Object lisp_object; } dfc_conversion_data; @@ -1802,9 +1802,9 @@ /* Like memcmp, except first arg points at internally formatted data, while the second points at a string of only ASCII chars. */ INLINE_HEADER int -bufbyte_memcmp (const Bufbyte *bp, const char *ascii_string, size_t len); +bufbyte_memcmp (const Bufbyte *bp, const char *ascii_string, Memory_Count len); INLINE_HEADER int -bufbyte_memcmp (const Bufbyte *bp, const char *ascii_string, size_t len) +bufbyte_memcmp (const Bufbyte *bp, const char *ascii_string, Memory_Count len) { #ifdef MULE while (len--)
--- a/src/bytecode.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/bytecode.c Mon Aug 13 04:46:48 2001 +0000 @@ -1599,8 +1599,8 @@ int * const program_length, int * const varbind_count) { - size_t instructions_length = XSTRING_LENGTH (instructions); - size_t comfy_size = 2 * instructions_length; + Bytecount instructions_length = XSTRING_LENGTH (instructions); + Element_Count comfy_size = (Element_Count) (2 * instructions_length); int * const icounts = alloca_array (int, comfy_size); int * icounts_ptr = icounts; @@ -1996,7 +1996,7 @@ f2->doc_and_interactive, depth + 1)); } -static unsigned long +static Hash_Code compiled_function_hash (Lisp_Object obj, int depth) { Lisp_Compiled_Function *f = XCOMPILED_FUNCTION (obj);
--- a/src/callproc.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/callproc.c Mon Aug 13 04:46:48 2001 +0000 @@ -478,7 +478,7 @@ nread = 0; while (nread < bufsize - 1024) { - Lstream_data_count this_read + Lstream_Data_Count this_read = Lstream_read (XLSTREAM (instream), bufptr + nread, bufsize - nread);
--- a/src/chartab.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/chartab.c Mon Aug 13 04:46:48 2001 +0000 @@ -121,7 +121,7 @@ return 1; } -static unsigned long +static Hash_Code char_table_entry_hash (Lisp_Object obj, int depth) { Lisp_Char_Table_Entry *cte = XCHAR_TABLE_ENTRY (obj); @@ -413,12 +413,12 @@ return 1; } -static unsigned long +static Hash_Code char_table_hash (Lisp_Object obj, int depth) { Lisp_Char_Table *ct = XCHAR_TABLE (obj); - unsigned long hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS, - depth); + Hash_Code hashval = internal_array_hash (ct->ascii, NUM_ASCII_CHARS, + depth); #ifdef MULE hashval = HASH2 (hashval, internal_array_hash (ct->level1, NUM_LEADING_BYTES, depth)); @@ -1612,7 +1612,7 @@ int check_category_char (Emchar ch, Lisp_Object table, - unsigned int designator, unsigned int not_p) + int designator, int not_p) { REGISTER Lisp_Object temp; Lisp_Char_Table *ctbl; @@ -1640,7 +1640,7 @@ { Lisp_Object ctbl; Emchar ch; - unsigned int des; + int des; struct buffer *buf = decode_buffer (buffer, 0); CHECK_INT (position); @@ -1660,7 +1660,7 @@ { Lisp_Object ctbl; Emchar ch; - unsigned int des; + int des; CHECK_CATEGORY_DESIGNATOR (designator); des = XCHAR (designator);
--- a/src/chartab.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/chartab.h Mon Aug 13 04:46:48 2001 +0000 @@ -203,7 +203,7 @@ #ifdef MULE int check_category_char(Emchar ch, Lisp_Object ctbl, - unsigned int designator, unsigned int not_p); + int designator, int not_p); extern Lisp_Object Vstandard_category_table;
--- a/src/console-x.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/console-x.c Mon Aug 13 04:46:48 2001 +0000 @@ -200,9 +200,9 @@ /* connection =~ s/^unix:/localhost:/; */ const Bufbyte *p = XSTRING_DATA (connection); const Bufbyte *end = XSTRING_DATA (connection) + XSTRING_LENGTH (connection); - size_t i; + int i; - for (i = 0; i < sizeof ("unix:") - 1; i++) + for (i = 0; i < (int) sizeof ("unix:") - 1; i++) { if (p == end || charptr_emchar (p) != "unix:"[i]) goto ok;
--- a/src/console.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/console.h Mon Aug 13 04:46:48 2001 +0000 @@ -219,8 +219,8 @@ int (*color_instance_equal_method) (Lisp_Color_Instance *, Lisp_Color_Instance *, int depth); - unsigned long (*color_instance_hash_method) (Lisp_Color_Instance *, - int depth); + Hash_Code (*color_instance_hash_method) (Lisp_Color_Instance *, + int depth); Lisp_Object (*color_instance_rgb_components_method) (Lisp_Color_Instance *); int (*valid_color_name_p_method) (struct device *, Lisp_Object color); @@ -264,8 +264,8 @@ int (*image_instance_equal_method) (Lisp_Image_Instance *, Lisp_Image_Instance *, int depth); - unsigned long (*image_instance_hash_method) (Lisp_Image_Instance *, - int depth); + Hash_Code (*image_instance_hash_method) (Lisp_Image_Instance *, + int depth); void (*init_image_instance_from_eimage_method) (Lisp_Image_Instance *ii, int width, int height, int slices,
--- a/src/data.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/data.c Mon Aug 13 04:46:48 2001 +0000 @@ -720,7 +720,8 @@ } else if (BIT_VECTORP (array)) { - if (idx >= bit_vector_length (XBIT_VECTOR (array))) goto range_error; + if (idx >= (EMACS_INT) bit_vector_length (XBIT_VECTOR (array))) + goto range_error; return make_int (bit_vector_bit (XBIT_VECTOR (array), idx)); } else if (STRINGP (array)) @@ -774,7 +775,8 @@ } else if (BIT_VECTORP (array)) { - if (idx >= bit_vector_length (XBIT_VECTOR (array))) goto range_error; + if (idx >= (EMACS_INT) bit_vector_length (XBIT_VECTOR (array))) + goto range_error; CHECK_BIT (newval); set_bit_vector_bit (XBIT_VECTOR (array), idx, !ZEROP (newval)); } @@ -1609,12 +1611,12 @@ internal_equal (w1->list, w2->list, depth + 1)); } -static unsigned long +static Hash_Code weak_list_hash (Lisp_Object obj, int depth) { struct weak_list *w = XWEAK_LIST (obj); - return HASH2 ((unsigned long) w->type, + return HASH2 ((Hash_Code) w->type, internal_hash (w->list, depth + 1)); }
--- a/src/depend Wed Aug 08 12:15:04 2001 +0000 +++ b/src/depend Mon Aug 13 04:46:48 2001 +0000 @@ -8,59 +8,59 @@ LISP_H=lisp.h config.h general-slots.h lrecord.h symeval.h symsinit.h $(LISP_UNION_H) #if defined(HAVE_MS_WINDOWS) console-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h events.h mule-charset.h opaque.h syscommctrl.h systime.h syswindows.h -device-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console-stream.h console.h device.h events.h faces.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects-msw.h objects.h redisplay.h scrollbar.h specifier.h syscommctrl.h sysdep.h systime.h syswindows.h toolbar.h window.h winslots.h -dialog-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h syscommctrl.h syswindows.h toolbar.h window.h winslots.h +device-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console-stream.h console.h device.h devslots.h events.h faces.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects-msw.h objects.h redisplay.h scrollbar.h specifier.h syscommctrl.h sysdep.h systime.h syswindows.h toolbar.h window.h winslots.h +dialog-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h syscommctrl.h syswindows.h toolbar.h window.h winslots.h dired-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h ndir.h nt.h regex.h sysdir.h sysfile.h sysfloat.h sysproc.h systime.h syswindows.h -event-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console-tty.h console.h device.h dragdrop.h events.h faces.h frame.h frameslots.h glyphs.h gui.h lstream.h menubar-msw.h menubar.h mule-charset.h objects-msw.h objects.h process.h redisplay.h scrollbar-msw.h scrollbar.h select.h specifier.h syscommctrl.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswait.h syswindows.h toolbar.h window.h winslots.h -frame-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h elhash.h events.h faces.h frame.h frameslots.h glyphs-msw.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h syscommctrl.h systime.h syswindows.h toolbar.h window.h winslots.h -glyphs-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h elhash.h faces.h file-coding.h frame.h frameslots.h glyphs-msw.h glyphs.h gui.h imgproc.h insdel.h lstream.h mule-charset.h objects-msw.h objects.h opaque.h redisplay.h scrollbar.h specifier.h syscommctrl.h sysdep.h sysfile.h syswindows.h toolbar.h window.h winslots.h -gui-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h elhash.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h syscommctrl.h systime.h syswindows.h toolbar.h window.h winslots.h -menubar-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-msw.h console.h device.h elhash.h events.h frame.h frameslots.h glyphs.h gui.h menubar-msw.h menubar.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h syscommctrl.h systime.h syswindows.h toolbar.h window.h winslots.h -objects-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h hash.h insdel.h mule-charset.h objects-msw.h objects.h specifier.h syscommctrl.h syswindows.h -redisplay-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h debug.h device.h events.h faces.h frame.h frameslots.h glyphs-msw.h glyphs.h gui.h gutter.h mule-ccl.h mule-charset.h objects-msw.h objects.h redisplay.h scrollbar.h specifier.h syscommctrl.h sysdep.h systime.h syswindows.h toolbar.h window.h winslots.h -scrollbar-msw.o: $(LISP_H) conslots.h console-msw.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar-msw.h scrollbar.h specifier.h syscommctrl.h systime.h syswindows.h toolbar.h window.h winslots.h -select-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h file-coding.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h select.h specifier.h syscommctrl.h syswindows.h toolbar.h window.h winslots.h -toolbar-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h elhash.h faces.h frame.h frameslots.h glyphs-msw.h glyphs.h gui.h mule-charset.h objects-msw.h objects.h redisplay.h scrollbar.h specifier.h syscommctrl.h syswindows.h toolbar.h window.h winslots.h +event-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console-tty.h console.h device.h devslots.h dragdrop.h events.h faces.h frame.h frameslots.h glyphs.h gui.h lstream.h menubar-msw.h menubar.h mule-charset.h objects-msw.h objects.h process.h redisplay.h scrollbar-msw.h scrollbar.h select.h specifier.h syscommctrl.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswait.h syswindows.h toolbar.h window.h winslots.h +frame-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h devslots.h elhash.h events.h faces.h frame.h frameslots.h glyphs-msw.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h syscommctrl.h systime.h syswindows.h toolbar.h window.h winslots.h +glyphs-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h devslots.h elhash.h faces.h file-coding.h frame.h frameslots.h glyphs-msw.h glyphs.h gui.h imgproc.h insdel.h lstream.h mule-charset.h objects-msw.h objects.h opaque.h redisplay.h scrollbar.h specifier.h syscommctrl.h sysdep.h sysfile.h syswindows.h toolbar.h window.h winslots.h +gui-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h devslots.h elhash.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h syscommctrl.h systime.h syswindows.h toolbar.h window.h winslots.h +menubar-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-msw.h console.h device.h devslots.h elhash.h events.h frame.h frameslots.h glyphs.h gui.h menubar-msw.h menubar.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h syscommctrl.h systime.h syswindows.h toolbar.h window.h winslots.h +objects-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h devslots.h hash.h insdel.h mule-charset.h objects-msw.h objects.h specifier.h syscommctrl.h syswindows.h +redisplay-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h debug.h device.h devslots.h events.h faces.h frame.h frameslots.h glyphs-msw.h glyphs.h gui.h gutter.h mule-ccl.h mule-charset.h objects-msw.h objects.h redisplay.h scrollbar.h specifier.h syscommctrl.h sysdep.h systime.h syswindows.h toolbar.h window.h winslots.h +scrollbar-msw.o: $(LISP_H) conslots.h console-msw.h console.h device.h devslots.h elhash.h events.h frame.h frameslots.h glyphs.h gui.h opaque.h redisplay.h scrollbar-msw.h scrollbar.h specifier.h syscommctrl.h systime.h syswindows.h toolbar.h window.h winslots.h +select-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h devslots.h file-coding.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h select.h specifier.h syscommctrl.h syswindows.h toolbar.h window.h winslots.h +toolbar-msw.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h device.h devslots.h elhash.h faces.h frame.h frameslots.h glyphs-msw.h glyphs.h gui.h mule-charset.h objects-msw.h objects.h redisplay.h scrollbar.h specifier.h syscommctrl.h syswindows.h toolbar.h window.h winslots.h #endif #if defined(HAVE_X_WINDOWS) -balloon-x.o: $(LISP_H) balloon_help.h conslots.h console-x.h console.h device.h xintrinsic.h +balloon-x.o: $(LISP_H) balloon_help.h conslots.h console-x.h console.h device.h devslots.h xintrinsic.h console-x.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h mule-charset.h process.h redisplay.h xintrinsic.h -device-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h elhash.h events.h faces.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h mule-charset.h objects-x.h objects.h offix-types.h offix.h redisplay.h scrollbar.h specifier.h sysdep.h sysdll.h sysfile.h systime.h toolbar.h window.h winslots.h xgccache.h xintrinsic.h xintrinsicp.h xmu.h -dialog-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-x.h console.h device.h events.h frame.h frameslots.h glyphs.h gui-x.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h -frame-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h EmacsManager.h EmacsShell.h ExternalShell.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h dragdrop.h events.h extents.h faces.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h gutter.h mule-charset.h objects-x.h objects.h offix-types.h offix.h redisplay.h scrollbar-x.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h xintrinsicp.h xmprimitivep.h xmu.h -glyphs-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h bitmaps.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h faces.h file-coding.h frame.h frameslots.h glyphs-x.h glyphs.h gui-x.h gui.h imgproc.h insdel.h lstream.h mule-charset.h objects-x.h objects.h opaque.h redisplay.h scrollbar.h specifier.h sysfile.h toolbar.h window.h winslots.h xintrinsic.h xmu.h -gui-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h events.h frame.h frameslots.h glyphs.h gui-x.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h -menubar-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-x.h console.h device.h events.h frame.h frameslots.h glyphs.h gui-x.h gui.h keymap.h menubar.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h -objects-x.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h insdel.h mule-charset.h objects-x.h objects.h specifier.h xintrinsic.h -redisplay-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h debug.h device.h faces.h file-coding.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h gutter.h mule-ccl.h mule-charset.h objects-x.h objects.h redisplay.h scrollbar.h specifier.h sysdep.h sysproc.h systime.h toolbar.h window.h winslots.h xgccache.h xintrinsic.h xintrinsicp.h xmprimitivep.h -scrollbar-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h conslots.h console-x.h console.h device.h frame.h frameslots.h glyphs-x.h glyphs.h gui-x.h gui.h redisplay.h scrollbar-x.h scrollbar.h specifier.h toolbar.h window.h winslots.h xintrinsic.h -select-x.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects-x.h objects.h opaque.h redisplay.h scrollbar.h select.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h -toolbar-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h faces.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h mule-charset.h objects-x.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h xintrinsic.h xintrinsicp.h xmprimitivep.h +device-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h elhash.h events.h faces.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h mule-charset.h objects-x.h objects.h offix-types.h offix.h redisplay.h scrollbar.h specifier.h sysdep.h sysdll.h sysfile.h systime.h toolbar.h window.h winslots.h xgccache.h xintrinsic.h xintrinsicp.h xmu.h +dialog-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-x.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui-x.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h +frame-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h EmacsManager.h EmacsShell.h ExternalShell.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h dragdrop.h events.h extents.h faces.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h gutter.h mule-charset.h objects-x.h objects.h offix-types.h offix.h redisplay.h scrollbar-x.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h xintrinsicp.h xmprimitivep.h xmu.h +glyphs-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h bitmaps.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h faces.h file-coding.h frame.h frameslots.h glyphs-x.h glyphs.h gui-x.h gui.h imgproc.h insdel.h lstream.h mule-charset.h objects-x.h objects.h opaque.h redisplay.h scrollbar.h specifier.h sysfile.h toolbar.h window.h winslots.h xintrinsic.h xmu.h +gui-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui-x.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h +menubar-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-x.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui-x.h gui.h keymap.h menubar.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h +objects-x.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h insdel.h mule-charset.h objects-x.h objects.h specifier.h xintrinsic.h +redisplay-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h debug.h device.h devslots.h faces.h file-coding.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h gutter.h mule-ccl.h mule-charset.h objects-x.h objects.h redisplay.h scrollbar.h specifier.h sysdep.h sysproc.h systime.h toolbar.h window.h winslots.h xgccache.h xintrinsic.h xintrinsicp.h xmprimitivep.h +scrollbar-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h conslots.h console-x.h console.h device.h devslots.h frame.h frameslots.h glyphs-x.h glyphs.h gui-x.h gui.h redisplay.h scrollbar-x.h scrollbar.h specifier.h toolbar.h window.h winslots.h xintrinsic.h +select-x.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects-x.h objects.h opaque.h redisplay.h scrollbar.h select-common.h select.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h +toolbar-x.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h faces.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h mule-charset.h objects-x.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h xintrinsic.h xintrinsicp.h xmprimitivep.h #endif #if defined(HAVE_TTY) -console-tty.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-stream.h console-tty.h console.h device.h faces.h file-coding.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systty.h toolbar.h window.h winslots.h -device-tty.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-stream.h console-tty.h console.h device.h events.h faces.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h -event-tty.o: $(LISP_H) conslots.h console-tty.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h process.h redisplay.h scrollbar.h specifier.h sysproc.h syssignal.h systime.h systty.h syswait.h toolbar.h window.h winslots.h -frame-tty.o: $(LISP_H) conslots.h console-tty.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h -objects-tty.o: $(LISP_H) conslots.h console-tty.h console.h device.h insdel.h mule-charset.h objects-tty.h objects.h specifier.h syssignal.h systty.h -redisplay-tty.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-tty.h console.h device.h events.h faces.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h objects-tty.h objects.h redisplay.h scrollbar.h specifier.h sysdep.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h +console-tty.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-stream.h console-tty.h console.h device.h devslots.h faces.h file-coding.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systty.h toolbar.h window.h winslots.h +device-tty.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-stream.h console-tty.h console.h device.h devslots.h events.h faces.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h +event-tty.o: $(LISP_H) conslots.h console-tty.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h process.h redisplay.h scrollbar.h specifier.h sysproc.h syssignal.h systime.h systty.h syswait.h toolbar.h window.h winslots.h +frame-tty.o: $(LISP_H) conslots.h console-tty.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h +objects-tty.o: $(LISP_H) conslots.h console-tty.h console.h device.h devslots.h insdel.h mule-charset.h objects-tty.h objects.h specifier.h syssignal.h systty.h +redisplay-tty.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-tty.h console.h device.h devslots.h events.h faces.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h objects-tty.h objects.h redisplay.h scrollbar.h specifier.h sysdep.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h #endif #if defined(HAVE_GTK) console-gtk.o: $(LISP_H) conslots.h console-gtk.h console.h process.h redisplay.h -device-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h elhash.h events.h faces.h frame.h frameslots.h gccache-gtk.h glyphs-gtk.h glyphs.h gtk-xemacs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h systime.h toolbar.h window.h winslots.h -dialog-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-gtk.h console.h device.h events.h frame.h frameslots.h glyphs.h gui-gtk.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h -event-gtk.o: $(LISP_H) blocktype.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-gtk.h console-tty.h console.h device.h dragdrop.h elhash.h events-mod.h events.h file-coding.h frame.h frameslots.h glyphs.h gtk-xemacs.h gui.h lstream.h mule-charset.h objects-gtk.h objects.h offix-types.h offix.h process.h redisplay.h scrollbar.h specifier.h sysproc.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h xintrinsic.h -frame-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h dragdrop.h events.h extents.h faces.h frame.h frameslots.h glyphs-gtk.h glyphs.h gtk-xemacs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar-gtk.h scrollbar.h specifier.h sysdll.h systime.h toolbar.h ui-gtk.h window.h winslots.h +device-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h elhash.h events.h faces.h frame.h frameslots.h gccache-gtk.h glyphs-gtk.h glyphs.h gtk-xemacs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h systime.h toolbar.h window.h winslots.h +dialog-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-gtk.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui-gtk.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h +event-gtk.o: $(LISP_H) blocktype.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-gtk.h console-tty.h console.h device.h devslots.h dragdrop.h elhash.h events-mod.h events.h file-coding.h frame.h frameslots.h glyphs.h gtk-xemacs.h gui.h lstream.h mule-charset.h objects-gtk.h objects.h offix-types.h offix.h process.h redisplay.h scrollbar.h specifier.h sysproc.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h xintrinsic.h +frame-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h dragdrop.h events.h extents.h faces.h frame.h frameslots.h glyphs-gtk.h glyphs.h gtk-xemacs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar-gtk.h scrollbar.h specifier.h sysdll.h systime.h toolbar.h ui-gtk.h window.h winslots.h gccache-gtk.o: $(LISP_H) gccache-gtk.h hash.h -glyphs-gtk.o: $(LISP_H) bitmaps.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h faces.h file-coding.h frame.h frameslots.h glyphs-gtk.h glyphs.h gui-gtk.h gui.h imgproc.h insdel.h lstream.h mule-charset.h objects-gtk.h objects.h opaque.h redisplay.h scrollbar.h specifier.h sysdll.h sysfile.h toolbar.h ui-gtk.h window.h winslots.h -gui-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h frame.h frameslots.h glyphs.h gui-gtk.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -menubar-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-gtk.h console.h device.h events.h frame.h frameslots.h glyphs.h gui-gtk.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h sysdll.h systime.h toolbar.h ui-gtk.h window.h winslots.h -objects-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h insdel.h mule-charset.h objects-gtk.h objects.h specifier.h -redisplay-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h debug.h device.h faces.h file-coding.h frame.h frameslots.h gccache-gtk.h glyphs-gtk.h glyphs.h gui.h gutter.h mule-ccl.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h sysdep.h sysproc.h systime.h toolbar.h window.h winslots.h -scrollbar-gtk.o: $(LISP_H) conslots.h console-gtk.h console.h device.h frame.h frameslots.h glyphs-gtk.h glyphs.h gui-gtk.h gui.h redisplay.h scrollbar-gtk.h scrollbar.h specifier.h toolbar.h window.h winslots.h -select-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h select.h specifier.h systime.h toolbar.h window.h winslots.h -toolbar-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h faces.h frame.h frameslots.h gccache-gtk.h glyphs-gtk.h glyphs.h gtk-xemacs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -ui-gtk.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h elhash.h emacs-marshals.c emacs-widget-accessors.c events.h faces.h glade.c glyphs-gtk.h glyphs.h gtk-glue.c gui-gtk.h gui.h hash.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h sysdll.h systime.h ui-byhand.c ui-gtk.h window.h winslots.h +glyphs-gtk.o: $(LISP_H) bitmaps.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h faces.h file-coding.h frame.h frameslots.h glyphs-gtk.h glyphs.h gui-gtk.h gui.h imgproc.h insdel.h lstream.h mule-charset.h objects-gtk.h objects.h opaque.h redisplay.h scrollbar.h specifier.h sysdll.h sysfile.h toolbar.h ui-gtk.h window.h winslots.h +gui-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui-gtk.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +menubar-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-gtk.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui-gtk.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h sysdll.h systime.h toolbar.h ui-gtk.h window.h winslots.h +objects-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h insdel.h mule-charset.h objects-gtk.h objects.h specifier.h +redisplay-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h debug.h device.h devslots.h faces.h file-coding.h frame.h frameslots.h gccache-gtk.h glyphs-gtk.h glyphs.h gui.h gutter.h mule-ccl.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h sysdep.h sysproc.h systime.h toolbar.h window.h winslots.h +scrollbar-gtk.o: $(LISP_H) conslots.h console-gtk.h console.h device.h devslots.h frame.h frameslots.h glyphs-gtk.h glyphs.h gui-gtk.h gui.h redisplay.h scrollbar-gtk.h scrollbar.h specifier.h toolbar.h window.h winslots.h +select-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h select-common.h select.h specifier.h systime.h toolbar.h window.h winslots.h +toolbar-gtk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h faces.h frame.h frameslots.h gccache-gtk.h glyphs-gtk.h glyphs.h gtk-xemacs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +ui-gtk.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h elhash.h emacs-marshals.c emacs-widget-accessors.c events.h faces.h glade.c glyphs-gtk.h glyphs.h gtk-glue.c gui-gtk.h gui.h hash.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h sysdll.h systime.h ui-byhand.c ui-gtk.h window.h winslots.h #endif #if defined(HAVE_DATABASE) database.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h database.h mule-charset.h sysfile.h @@ -68,7 +68,7 @@ #if defined(MULE) mule-canna.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h file-coding.h mule-charset.h mule-ccl.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h file-coding.h mule-ccl.h mule-charset.h -mule-charset.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h elhash.h faces.h lstream.h mule-ccl.h mule-charset.h +mule-charset.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h elhash.h faces.h lstream.h mule-ccl.h mule-charset.h mule-wnnfns.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h redisplay.h scrollbar.h sysdep.h window.h winslots.h mule.o: $(LISP_H) regex.h #endif @@ -79,130 +79,130 @@ extw-Xlib.o: config.h extw-Xlib.h extw-Xt.o: config.h extw-Xlib.h extw-Xt.h #endif -EmacsFrame.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h EmacsManager.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h faces.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h mule-charset.h objects-x.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h xintrinsic.h xintrinsicp.h xmprimitivep.h xmu.h +EmacsFrame.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h EmacsFrame.h EmacsFrameP.h EmacsManager.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h faces.h frame.h frameslots.h glyphs-x.h glyphs.h gui.h mule-charset.h objects-x.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h xintrinsic.h xintrinsicp.h xmprimitivep.h xmu.h EmacsManager.o: EmacsManager.h EmacsManagerP.h config.h xintrinsicp.h xmmanagerp.h EmacsShell-sub.o: EmacsShell.h EmacsShellP.h config.h xintrinsic.h xintrinsicp.h EmacsShell.o: EmacsShell.h ExternalShell.h config.h xintrinsicp.h abbrev.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h insdel.h mule-charset.h redisplay.h scrollbar.h syntax.h window.h winslots.h -alloc.o: $(LISP_H) backtrace.h buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console-stream.h console.h device.h dumper.h elhash.h events.h extents.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h systime.h toolbar.h window.h winslots.h +alloc.o: $(LISP_H) backtrace.h buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console-stream.h console.h device.h devslots.h dumper.h elhash.h events.h extents.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h systime.h toolbar.h window.h winslots.h alloca.o: config.h balloon_help.o: balloon_help.h config.h xintrinsic.h blocktype.o: $(LISP_H) blocktype.h -buffer.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h elhash.h extents.h faces.h file-coding.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h process.h redisplay.h scrollbar.h select.h specifier.h syntax.h sysdep.h sysfile.h toolbar.h window.h winslots.h +buffer.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h elhash.h extents.h faces.h file-coding.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h process.h redisplay.h scrollbar.h select.h specifier.h syntax.h sysdep.h sysfile.h toolbar.h window.h winslots.h bytecode.o: $(LISP_H) backtrace.h buffer.h bufslots.h bytecode.h casetab.h chartab.h mule-charset.h opaque.h syntax.h callint.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h commands.h events.h insdel.h mule-charset.h redisplay.h scrollbar.h systime.h window.h winslots.h callproc.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h file-coding.h insdel.h lstream.h mule-charset.h nt.h process.h redisplay.h scrollbar.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswindows.h window.h winslots.h casefiddle.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h insdel.h mule-charset.h syntax.h casetab.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h opaque.h chartab.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h syntax.h -cm.o: $(LISP_H) conslots.h console-tty.h console.h device.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h syssignal.h systty.h toolbar.h window.h winslots.h -cmdloop.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h +cm.o: $(LISP_H) conslots.h console-tty.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h syssignal.h systty.h toolbar.h window.h winslots.h +cmdloop.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h cmds.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h insdel.h mule-charset.h syntax.h -console-stream.o: $(LISP_H) conslots.h console-stream.h console-tty.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h -console.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-tty.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h +console-stream.o: $(LISP_H) conslots.h console-stream.h console-tty.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h +console.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-tty.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h data.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h mule-charset.h sysfloat.h syssignal.h debug.o: $(LISP_H) bytecode.h debug.h -device.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h elhash.h events.h faces.h frame.h frameslots.h glyphs.h gui.h keymap.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h syssignal.h systime.h toolbar.h window.h winslots.h +device.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h elhash.h events.h faces.h frame.h frameslots.h glyphs.h gui.h keymap.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h syssignal.h systime.h toolbar.h window.h winslots.h dgif_lib.o: $(LISP_H) gifrlib.h sysfile.h -dialog.o: $(LISP_H) conslots.h console.h device.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +dialog.o: $(LISP_H) conslots.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h dired.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h elhash.h mule-charset.h ndir.h opaque.h regex.h syntax.h sysdep.h sysdir.h sysfile.h syspwd.h systime.h syswindows.h doc.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h insdel.h keymap.h mule-charset.h sysfile.h doprnt.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h lstream.h mule-charset.h dragdrop.o: $(LISP_H) dragdrop.h -dumper.o: $(LISP_H) conslots.h console-stream.h console.h dumper.h elhash.h nt.h specifier.h sysfile.h syswindows.h +dumper.o: $(LISP_H) conslots.h console-stream.h console.h dumper.h elhash.h nt.h specifier.h sysfile.h systime.h syswindows.h dynarr.o: $(LISP_H) ecrt0.o: config.h -editfns.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h events.h extents.h frame.h frameslots.h glyphs.h gui.h insdel.h line-number.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syspwd.h systime.h toolbar.h window.h winslots.h +editfns.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h events.h extents.h frame.h frameslots.h glyphs.h gui.h insdel.h line-number.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syspwd.h systime.h toolbar.h window.h winslots.h eldap.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h eldap.h mule-charset.h opaque.h sysdep.h elhash.o: $(LISP_H) bytecode.h elhash.h opaque.h emacs-marshals.o: hash.h emacs-widget-accessors.o: -emacs.o: $(LISP_H) backtrace.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h dumper.h frame.h frameslots.h glyphs.h gui.h mule-charset.h nt.h paths.h process.h redisplay.h scrollbar.h specifier.h sysdep.h sysdll.h sysfile.h syssignal.h systime.h systty.h syswindows.h toolbar.h window.h winslots.h -emodules.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h emodules.h file-coding.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h sysdll.h toolbar.h window.h winslots.h +emacs.o: $(LISP_H) backtrace.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h dumper.h frame.h frameslots.h glyphs.h gui.h mule-charset.h nt.h paths.h process.h redisplay.h scrollbar.h specifier.h sysdep.h sysdll.h sysfile.h syssignal.h systime.h systty.h syswindows.h toolbar.h window.h winslots.h +emodules.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h emodules.h file-coding.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h sysdep.h sysdll.h toolbar.h window.h winslots.h esd.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h miscplay.h mule-charset.h sound.h sysfile.h eval.o: $(LISP_H) backtrace.h buffer.h bufslots.h bytecode.h casetab.h chartab.h commands.h conslots.h console.h mule-charset.h opaque.h -event-Xt.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h Emacs.ad.h EmacsFrame.h blocktype.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-tty.h console-x.h console.h device.h dragdrop.h elhash.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h objects-x.h objects.h offix-types.h offix.h process.h redisplay.h scrollbar.h specifier.h sysproc.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h xintrinsic.h xintrinsicp.h -event-stream.o: $(LISP_H) blocktype.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h elhash.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h insdel.h keymap.h lstream.h macros.h menubar.h mule-charset.h process.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systime.h toolbar.h window.h winslots.h -event-unixoid.o: $(LISP_H) conslots.h console-stream.h console-tty.h console.h device.h events.h lstream.h mule-charset.h process.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h systty.h -events.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console-tty.h console-x.h console.h device.h events.h extents.h frame.h frameslots.h glyphs.h gui.h keymap.h mule-charset.h redisplay.h scrollbar.h specifier.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h xintrinsic.h -extents.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h debug.h device.h elhash.h extents.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h insdel.h keymap.h mule-charset.h opaque.h process.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -faces.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h elhash.h extents.h faces.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +event-Xt.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h Emacs.ad.h EmacsFrame.h blocktype.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-tty.h console-x.h console.h device.h devslots.h dragdrop.h elhash.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h lstream.h mule-charset.h objects-x.h objects.h offix-types.h offix.h process.h redisplay.h scrollbar.h specifier.h sysproc.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h xintrinsic.h xintrinsicp.h +event-stream.o: $(LISP_H) blocktype.h buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h elhash.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h insdel.h keymap.h lstream.h macros.h menubar.h mule-charset.h process.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systime.h toolbar.h window.h winslots.h +event-unixoid.o: $(LISP_H) conslots.h console-stream.h console-tty.h console.h device.h devslots.h events.h lstream.h mule-charset.h process.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h systty.h +events.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console-tty.h console-x.h console.h device.h devslots.h events.h extents.h frame.h frameslots.h glyphs.h gui.h keymap.h mule-charset.h redisplay.h scrollbar.h specifier.h syssignal.h systime.h systty.h toolbar.h window.h winslots.h xintrinsic.h +extents.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h debug.h device.h devslots.h elhash.h extents.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h insdel.h keymap.h mule-charset.h opaque.h process.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +faces.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h elhash.h extents.h faces.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h file-coding.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h elhash.h file-coding.h insdel.h lstream.h mule-ccl.h mule-charset.h opaque.h -fileio.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h ndir.h redisplay.h scrollbar.h specifier.h sysdep.h sysdir.h sysfile.h sysproc.h syspwd.h systime.h toolbar.h window.h winslots.h +fileio.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h ndir.h nt.h redisplay.h scrollbar.h specifier.h sysdep.h sysdir.h sysfile.h sysproc.h syspwd.h systime.h syswindows.h toolbar.h window.h winslots.h filelock.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h ndir.h paths.h sysdir.h sysfile.h syspwd.h syssignal.h filemode.o: $(LISP_H) sysfile.h floatfns.o: $(LISP_H) sysfloat.h syssignal.h -fns.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console.h device.h events.h extents.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h sysfile.h systime.h toolbar.h window.h winslots.h +fns.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console.h device.h devslots.h events.h extents.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h sysfile.h systime.h toolbar.h window.h winslots.h font-lock.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h insdel.h mule-charset.h syntax.h -frame.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h events.h extents.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h menubar.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h +frame.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h events.h extents.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h menubar.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h free-hook.o: $(LISP_H) hash.h general.o: $(LISP_H) getloadavg.o: $(LISP_H) sysfile.h -gif_io.o: config.h gifrlib.h sysfile.h +gif_io.o: $(LISP_H) gifrlib.h sysfile.h glade.o: bytecode.h -glyphs-eimage.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h faces.h file-coding.h frame.h frameslots.h gifrlib.h glyphs.h gui.h lstream.h mule-charset.h objects.h opaque.h redisplay.h scrollbar.h specifier.h sysfile.h toolbar.h window.h winslots.h -glyphs-shared.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h elhash.h faces.h frame.h frameslots.h glyphs.h gui.h imgproc.h insdel.h lstream.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h toolbar.h window.h winslots.h -glyphs-widget.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console.h device.h faces.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h objects.h opaque.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -glyphs.o: $(LISP_H) blocktype.h buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h elhash.h faces.h frame.h frameslots.h glyphs.h gui.h insdel.h mule-charset.h objects.h opaque.h rangetab.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +glyphs-eimage.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h faces.h file-coding.h frame.h frameslots.h gifrlib.h glyphs.h gui.h lstream.h mule-charset.h objects.h opaque.h redisplay.h scrollbar.h specifier.h sysfile.h toolbar.h window.h winslots.h +glyphs-shared.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h elhash.h faces.h frame.h frameslots.h glyphs.h gui.h imgproc.h insdel.h lstream.h mule-charset.h opaque.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h toolbar.h window.h winslots.h +glyphs-widget.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console.h device.h devslots.h faces.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h objects.h opaque.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +glyphs.o: $(LISP_H) blocktype.h buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h elhash.h faces.h frame.h frameslots.h glyphs.h gui.h insdel.h mule-charset.h objects.h opaque.h rangetab.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h gmalloc.o: config.h getpagesize.h -gpmevent.o: $(LISP_H) commands.h conslots.h console-tty.h console.h device.h events.h gpmevent.h lstream.h mule-charset.h process.h sysdep.h sysproc.h syssignal.h systime.h systty.h +gpmevent.o: $(LISP_H) commands.h conslots.h console-tty.h console.h device.h devslots.h events.h gpmevent.h lstream.h mule-charset.h process.h sysdep.h sysproc.h syssignal.h systime.h systty.h gtk-glue.o: -gtk-xemacs.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h faces.h frame.h frameslots.h glyphs.h gtk-xemacs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +gtk-xemacs.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h faces.h frame.h frameslots.h glyphs.h gtk-xemacs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h gui.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h elhash.h gui.h mule-charset.h -gutter.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +gutter.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h hash.o: $(LISP_H) hash.h -hftctl.o: $(LISP_H) +hftctl.o: $(LISP_H) sysfile.h hpplay.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h sound.h imgproc.o: $(LISP_H) imgproc.h -indent.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h extents.h faces.h frame.h frameslots.h glyphs.h gui.h insdel.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -inline.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console-gtk.h console-msw.h console.h database.h device.h eldap.h elhash.h events.h extents.h faces.h file-coding.h frame.h frameslots.h glyphs-x.h glyphs.h gui-x.h gui.h keymap.h lstream.h mule-charset.h objects.h opaque.h postgresql.h process.h rangetab.h redisplay.h scrollbar.h specifier.h syntax.h syscommctrl.h sysdll.h systime.h syswindows.h toolbar.h tooltalk.h ui-gtk.h window.h winslots.h xintrinsic.h -input-method-motif.o: $(LISP_H) EmacsFrame.h conslots.h console-x.h console.h device.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h xintrinsic.h -input-method-xlib.o: $(LISP_H) EmacsFrame.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h -insdel.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h extents.h frame.h frameslots.h glyphs.h gui.h insdel.h line-number.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -intl.o: $(LISP_H) bytecode.h conslots.h console.h device.h -keymap.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console.h device.h elhash.h events.h frame.h frameslots.h glyphs.h gui.h insdel.h keymap.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h +indent.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h extents.h faces.h frame.h frameslots.h glyphs.h gui.h insdel.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +inline.o: $(LISP_H) $(LWLIB_SRCDIR)/lwlib.h buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console-gtk.h console-msw.h console.h database.h device.h devslots.h eldap.h elhash.h events.h extents.h faces.h file-coding.h frame.h frameslots.h glyphs-x.h glyphs.h gui-x.h gui.h keymap.h lstream.h mule-charset.h objects.h opaque.h postgresql.h process.h rangetab.h redisplay.h scrollbar.h specifier.h syntax.h syscommctrl.h sysdll.h systime.h syswindows.h toolbar.h tooltalk.h ui-gtk.h window.h winslots.h xintrinsic.h +input-method-motif.o: $(LISP_H) EmacsFrame.h conslots.h console-x.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h xintrinsic.h +input-method-xlib.o: $(LISP_H) EmacsFrame.h buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h xintrinsic.h +insdel.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h extents.h frame.h frameslots.h glyphs.h gui.h insdel.h line-number.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +intl.o: $(LISP_H) bytecode.h conslots.h console.h device.h devslots.h +keymap.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console.h device.h devslots.h elhash.h events.h frame.h frameslots.h glyphs.h gui.h insdel.h keymap.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h lastfile.o: config.h libsst.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h libsst.h mule-charset.h sound.h sysfile.h line-number.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h line-number.h mule-charset.h linuxplay.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h miscplay.h mule-charset.h sound.h sysfile.h syssignal.h systty.h lread.o: $(LISP_H) buffer.h bufslots.h bytecode.h casetab.h chartab.h elhash.h file-coding.h lstream.h mule-charset.h opaque.h sysfile.h sysfloat.h lstream.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h insdel.h lstream.h mule-charset.h sysfile.h -macros.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h keymap.h macros.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h +macros.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h keymap.h macros.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h malloc.o: config.h getpagesize.h marker.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h md5.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h file-coding.h lstream.h mule-charset.h -menubar.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h frame.h frameslots.h glyphs.h gui.h keymap.h menubar.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -minibuf.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-stream.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h insdel.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h +menubar.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h keymap.h menubar.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +minibuf.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-stream.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h insdel.h mule-charset.h redisplay.h scrollbar.h specifier.h systime.h toolbar.h window.h winslots.h miscplay.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h miscplay.h mule-charset.h sound.h sysfile.h syssignal.h nas.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h sound.h sysdep.h syssignal.h -native-gtk-toolbar.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h faces.h frame.h frameslots.h glyphs-gtk.h glyphs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -nt.o: $(LISP_H) ndir.h nt.h ntheap.h sysdir.h sysfile.h sysproc.h syspwd.h syssignal.h systime.h syswindows.h +native-gtk-toolbar.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-gtk.h console.h device.h devslots.h faces.h frame.h frameslots.h glyphs-gtk.h glyphs.h gui.h mule-charset.h objects-gtk.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +nt.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h ndir.h nt.h ntheap.h sysdir.h sysfile.h sysproc.h syspwd.h syssignal.h systime.h syswindows.h ntheap.o: $(LISP_H) ntheap.h syswindows.h -ntplay.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h nt.h sound.h sysfile.h syswindows.h +ntplay.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h nt.h sound.h sysfile.h systime.h syswindows.h ntproc.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h mule-charset.h nt.h ntheap.h process.h syscommctrl.h sysfile.h sysproc.h syssignal.h systime.h syswait.h syswindows.h -objects.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h elhash.h faces.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +objects.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h elhash.h faces.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h offix.o: offix-cursors.h offix-types.h offix.h xintrinsic.h opaque.o: $(LISP_H) opaque.h postgresql.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h postgresql.h sysdep.h -print.o: $(LISP_H) backtrace.h buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console-msw.h console-stream.h console-tty.h console.h device.h extents.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h syscommctrl.h sysfile.h syssignal.h systty.h syswindows.h toolbar.h window.h winslots.h +print.o: $(LISP_H) backtrace.h buffer.h bufslots.h bytecode.h casetab.h chartab.h conslots.h console-msw.h console-stream.h console-tty.h console.h device.h devslots.h extents.h frame.h frameslots.h glyphs.h gui.h insdel.h lstream.h mule-charset.h redisplay.h scrollbar.h specifier.h syscommctrl.h sysfile.h syssignal.h systty.h syswindows.h toolbar.h window.h winslots.h process-nt.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-msw.h console.h hash.h lstream.h mule-charset.h nt.h process.h procimpl.h syscommctrl.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h syswindows.h -process-unix.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h hash.h lstream.h mule-charset.h opaque.h process.h procimpl.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswait.h toolbar.h window.h winslots.h -process.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h hash.h insdel.h lstream.h mule-charset.h opaque.h process.h procimpl.h redisplay.h scrollbar.h specifier.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswait.h toolbar.h window.h winslots.h +process-unix.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h hash.h lstream.h mule-charset.h opaque.h process.h procimpl.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswait.h toolbar.h window.h winslots.h +process.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h events.h file-coding.h frame.h frameslots.h glyphs.h gui.h hash.h insdel.h lstream.h mule-charset.h opaque.h process.h procimpl.h redisplay.h scrollbar.h specifier.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswait.h toolbar.h window.h winslots.h profile.o: $(LISP_H) backtrace.h bytecode.h elhash.h hash.h syssignal.h systime.h ralloc.o: $(LISP_H) getpagesize.h rangetab.o: $(LISP_H) rangetab.h realpath.o: $(LISP_H) sysfile.h syswindows.h -redisplay-output.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h -redisplay.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-tty.h console.h debug.h device.h elhash.h extents.h faces.h file-coding.h frame.h frameslots.h glyphs.h gui.h gutter.h insdel.h line-number.h menubar.h mule-charset.h objects.h process.h redisplay.h scrollbar.h specifier.h sysfile.h syssignal.h systty.h toolbar.h window.h winslots.h +redisplay-output.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +redisplay.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console-tty.h console.h debug.h device.h devslots.h elhash.h extents.h faces.h file-coding.h frame.h frameslots.h glyphs.h gui.h gutter.h insdel.h line-number.h menubar.h mule-charset.h objects.h process.h redisplay.h scrollbar.h specifier.h sysfile.h syssignal.h systty.h toolbar.h window.h winslots.h regex.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h regex.h syntax.h -scrollbar.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h frame.h frameslots.h glyphs.h gui.h gutter.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +scrollbar.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h gutter.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h search.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h insdel.h mule-charset.h opaque.h regex.h syntax.h -select.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h extents.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects.h opaque.h redisplay.h scrollbar.h select.h specifier.h toolbar.h window.h winslots.h +select.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h extents.h frame.h frameslots.h glyphs.h gui.h mule-charset.h objects.h opaque.h redisplay.h scrollbar.h select.h specifier.h toolbar.h window.h winslots.h sgiplay.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h libst.h mule-charset.h sound.h sysfile.h sysproc.h systime.h sheap.o: $(LISP_H) sheap-adjust.h -signal.o: $(LISP_H) conslots.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systime.h toolbar.h window.h winslots.h -sound.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h mule-charset.h redisplay.h sound.h sysdep.h sysfile.h sysproc.h systime.h xintrinsic.h -specifier.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h rangetab.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +signal.o: $(LISP_H) conslots.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h process.h redisplay.h scrollbar.h specifier.h sysdep.h sysfile.h syssignal.h systime.h toolbar.h window.h winslots.h +sound.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-x.h console.h device.h devslots.h mule-charset.h redisplay.h sound.h sysdep.h sysfile.h sysproc.h systime.h xintrinsic.h +specifier.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h mule-charset.h opaque.h rangetab.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h strcat.o: config.h strcmp.o: config.h strcpy.o: config.h @@ -212,14 +212,14 @@ sunpro.o: $(LISP_H) symbols.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h elhash.h mule-charset.h syntax.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h extents.h mule-charset.h syntax.h -sysdep.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-stream.h console-tty.h console.h device.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h ndir.h nt.h ntheap.h process.h redisplay.h scrollbar.h specifier.h sysdep.h sysdir.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswait.h syswindows.h toolbar.h window.h winslots.h +sysdep.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console-stream.h console-tty.h console.h device.h devslots.h events.h frame.h frameslots.h glyphs.h gui.h mule-charset.h ndir.h nt.h ntheap.h process.h redisplay.h scrollbar.h specifier.h sysdep.h sysdir.h sysfile.h sysproc.h syssignal.h systime.h systty.h syswait.h syswindows.h toolbar.h window.h winslots.h sysdll.o: config.h sysdll.h -termcap.o: $(LISP_H) conslots.h console.h device.h +termcap.o: $(LISP_H) conslots.h console.h device.h devslots.h terminfo.o: config.h tests.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h elhash.h lstream.h mule-charset.h opaque.h -toolbar.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +toolbar.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h conslots.h console.h device.h devslots.h frame.h frameslots.h glyphs.h gui.h mule-charset.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h tooltalk.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h elhash.h mule-charset.h process.h syssignal.h tooltalk.h -tparam.o: config.h +tparam.o: $(LISP_H) ui-byhand.o: gui.h undo.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h extents.h mule-charset.h unexaix.o: $(LISP_H) getpagesize.h @@ -235,11 +235,11 @@ unexhp9k3.o: config.h sysdep.h unexhp9k800.o: $(LISP_H) unexmips.o: config.h getpagesize.h -unexnt.o: $(LISP_H) nt.h ntheap.h sysfile.h syswindows.h +unexnt.o: $(LISP_H) nt.h ntheap.h sysfile.h systime.h syswindows.h unexsunos4.o: config.h vm-limit.o: $(LISP_H) mem-limits.h widget.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h -win32.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h syswindows.h -window.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h elhash.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h mule-charset.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h +win32.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h mule-charset.h syssignal.h systime.h syswindows.h +window.o: $(LISP_H) buffer.h bufslots.h casetab.h chartab.h commands.h conslots.h console.h device.h devslots.h elhash.h faces.h frame.h frameslots.h glyphs.h gui.h gutter.h mule-charset.h objects.h redisplay.h scrollbar.h specifier.h toolbar.h window.h winslots.h xgccache.o: $(LISP_H) hash.h xgccache.h xmu.o: config.h
--- a/src/device-msw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/device-msw.c Mon Aug 13 04:46:48 2001 +0000 @@ -428,7 +428,7 @@ { char* printer_name; DEVMODE *pdm; - size_t dm_size; + LONG dm_size; d->device_data = xnew_and_zero (struct msprinter_device); @@ -932,7 +932,7 @@ printer name at all. */ if (ldm->printer_name == NULL) { - size_t dm_size = + LONG dm_size = DocumentProperties (NULL, DEVICE_MSPRINTER_HPRINTER(d), DEVICE_MSPRINTER_NAME(d), NULL, NULL, 0); if (dm_size <= 0) @@ -1089,7 +1089,7 @@ return stricmp (dm1->printer_name, dm2->printer_name) == 0; } -static unsigned long +static Hash_Code hash_devmode (Lisp_Object obj, int depth) { Lisp_Devmode *dm = XDEVMODE (obj); @@ -1201,7 +1201,7 @@ { int have_nt, ok; BYTE *data_buf, dummy_byte; - size_t enum_entry_size; + Memory_Count enum_entry_size; DWORD enum_flags, enum_level, bytes_needed, num_printers; struct gcpro gcpro1, gcpro2; Lisp_Object result = Qnil, def_printer = Qnil;
--- a/src/device-x.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/device-x.c Mon Aug 13 04:46:48 2001 +0000 @@ -307,8 +307,9 @@ static char valid_resource_char_p[256]; +/* #### not just char * here; may be fixed in my Mule ws */ static void -validify_resource_component (char *str, size_t len) +validify_resource_component (char *str, Memory_Count len) { for (; len; len--, str++) if (!valid_resource_char_p[(unsigned char) (*str)]) @@ -1582,11 +1583,11 @@ if (!(colon_pos = strchr (str, ':')) || strchr (str, '\n')) invalid: syntax_error ("Invalid resource line", resource_line); - if (strspn (str, - /* Only the following chars are allowed before the colon */ - " \t.*?abcdefghijklmnopqrstuvwxyz" - "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-") - != (size_t) (colon_pos - str)) + if ((int) strspn (str, + /* Only the following chars are allowed before the colon */ + " \t.*?abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-") + != colon_pos - str) goto invalid; if (DEVICE_X_P (d))
--- a/src/dialog-msw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/dialog-msw.c Mon Aug 13 04:46:48 2001 +0000 @@ -207,7 +207,7 @@ if (w_param != IDCANCEL) /* user pressed escape */ { assert (w_param >= ID_ITEM_BIAS - && w_param + && (EMACS_INT) w_param < XVECTOR_LENGTH (did->callbacks) + ID_ITEM_BIAS); get_gui_callback (XVECTOR_DATA (did->callbacks) @@ -270,10 +270,10 @@ } /* Given button TEXT, return button width in DLU */ -static unsigned int +static int button_width (Lisp_Object text) { - unsigned int width = X_DLU_PER_CHAR * XSTRING_CHAR_LENGTH (text); + int width = X_DLU_PER_CHAR * XSTRING_CHAR_LENGTH (text); return max (X_MIN_BUTTON, width); } @@ -286,16 +286,16 @@ } -#define ALIGN_TEMPLATE \ -{ \ - unsigned int slippage = Dynarr_length (template_) & 3; \ - if (slippage) \ - Dynarr_add_many (template_, &zeroes, slippage); \ +#define ALIGN_TEMPLATE \ +{ \ + int slippage = Dynarr_length (template_) & 3; \ + if (slippage) \ + Dynarr_add_many (template_, &zeroes, slippage); \ } static struct { - int errmess; + DWORD errmess; char *errname; } common_dialog_errors[] = { @@ -414,8 +414,8 @@ { Lisp_Object_dynarr *dialog_items = Dynarr_new (Lisp_Object); unsigned_char_dynarr *template_ = Dynarr_new (unsigned_char); - unsigned int button_row_width = 0; - unsigned int text_width, text_height; + int button_row_width = 0; + int text_width, text_height; Lisp_Object question = Qnil, title = Qnil; int unbind_count = specpdl_depth ();
--- a/src/dired.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/dired.c Mon Aug 13 04:46:48 2001 +0000 @@ -563,7 +563,7 @@ struct user_name { Bufbyte *ptr; - size_t len; + Bytecount len; }; struct user_cache @@ -675,7 +675,7 @@ status_status_statui_statum_statu != ERROR_MORE_DATA) invalid_operation ("Error enumerating users", make_int (GetLastError ())); - for (i = 0; i < entriesread; i++) + for (i = 0; i < (int) entriesread; i++) { int nout = WideCharToMultiByte (CP_ACP, WC_COMPOSITECHECK,
--- a/src/doc.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/doc.c Mon Aug 13 04:46:48 2001 +0000 @@ -196,7 +196,7 @@ tem = Ffile_name_absolute_p (file); if (NILP (tem)) { - size_t minsize; + Bytecount minsize; /* XEmacs: Move this check here. OK if called during loadup to load byte code instructions. */ if (!STRINGP (Vdoc_directory)) @@ -206,7 +206,8 @@ /* sizeof ("../lib-src/") == 12 */ if (minsize < 12) minsize = 12; - name_nonreloc = (char *) alloca (minsize + XSTRING_LENGTH (file) + 8); + name_nonreloc = + (char *) alloca (minsize + XSTRING_LENGTH (file) + 8); string_join (name_nonreloc, Vdoc_directory, file); } else @@ -453,7 +454,7 @@ while (1) { if (filled < 512) - filled += read (fd, &buf[filled], sizeof buf - 1 - filled); + filled += read (fd, &buf[filled], sizeof (buf) - 1 - filled); if (!filled) break;
--- a/src/doprnt.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/doprnt.c Mon Aug 13 04:46:48 2001 +0000 @@ -129,8 +129,8 @@ *returned_num = -1; while (start != end && isdigit (*start)) { - if ((size_t) (arg_ptr - arg_convert) >= sizeof (arg_convert) - 1) - syntax_error ("Format converter number too large", Qunbound); + if (arg_ptr - arg_convert >= (int) sizeof (arg_convert) - 1) + syntax_error ("Format converter number too large", Qunbound); *arg_ptr++ = *start++; } *arg_ptr = '\0'; @@ -598,7 +598,8 @@ char *text_to_print = alloca_array (char, 32 + max (spec->minwidth, - max (sizeof (double), sizeof (long)) * 3 + + (int) max (sizeof (double), + sizeof (long)) * 3 + max (spec->precision, 0))); char constructed_spec[100]; char *p = constructed_spec;
--- a/src/dumper.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/dumper.c Mon Aug 13 04:46:48 2001 +0000 @@ -45,7 +45,7 @@ typedef struct { const void *varaddress; - size_t size; + Memory_Count size; } pdump_opaque; typedef struct @@ -84,7 +84,7 @@ /* Mark SIZE bytes at non-heap address VARADDRESS for dumping as is, without any bit-twiddling. */ void -dump_add_opaque (const void *varaddress, size_t size) +dump_add_opaque (const void *varaddress, Memory_Count size) { pdump_opaque info; info.varaddress = varaddress; @@ -129,7 +129,7 @@ inline static void -pdump_align_stream (FILE *stream, size_t alignment) +pdump_align_stream (FILE *stream, Memory_Count alignment) { long offset = ftell (stream); long adjustment = ALIGN_SIZE (offset, alignment) - offset; @@ -215,7 +215,7 @@ char *pdump_start; char *pdump_end; -static size_t pdump_length; +static Memory_Count pdump_length; #ifdef WIN32_NATIVE /* Handle for the dump file */ @@ -234,8 +234,8 @@ 16, 1, 2, 1, 4, 1, 2, 1, 8, 1, 2, 1, 4, 1, 2, 1 }; -static inline unsigned int -pdump_size_to_align (size_t size) +static inline int +pdump_size_to_align (Memory_Count size) { return pdump_align_table[size % countof (pdump_align_table)]; } @@ -244,7 +244,7 @@ { struct pdump_entry_list_elt *next; const void *obj; - size_t size; + Memory_Count size; int count; EMACS_INT save_offset; } pdump_entry_list_elt; @@ -276,7 +276,7 @@ static int *pdump_alert_undump_object; static unsigned long cur_offset; -static size_t max_size; +static Memory_Count max_size; static int pdump_fd; static void *pdump_buf; static FILE *pdump_out; @@ -313,7 +313,7 @@ } static void -pdump_add_entry (pdump_entry_list *list, const void *obj, size_t size, +pdump_add_entry (pdump_entry_list *list, const void *obj, Memory_Count size, int count) { pdump_entry_list_elt *e; @@ -423,8 +423,14 @@ irdata = ((char *)idata) + idesc[line].offset; switch (idesc[line].type) { - case XD_SIZE_T: - count = *(size_t *)irdata; + case XD_MEMORY_COUNT: + count = *(Memory_Count *)irdata; + break; + case XD_ELEMENT_COUNT: + count = *(Element_Count *)irdata; + break; + case XD_HASH_CODE: + count = *(Hash_Code *)irdata; break; case XD_INT: count = *(int *)irdata; @@ -439,6 +445,7 @@ stderr_out ("Unsupported count type : %d (line = %d, code=%ld)\n", idesc[line].type, line, (long)code); pdump_backtrace (); + count = 0; /* warning suppression */ abort (); } count += delta; @@ -464,7 +471,9 @@ pos = 0; desc = ((const Lisp_Specifier *)data)->methods->extra_description; goto restart; - case XD_SIZE_T: + case XD_MEMORY_COUNT: + case XD_ELEMENT_COUNT: + case XD_HASH_CODE: case XD_INT: case XD_LONG: case XD_BYTECOUNT: @@ -625,7 +634,7 @@ pdump_dump_data (pdump_entry_list_elt *elt, const struct lrecord_description *desc) { - size_t size = elt->size; + Memory_Count size = elt->size; int count = elt->count; if (desc) { @@ -644,7 +653,9 @@ case XD_SPECIFIER_END: desc = ((const Lisp_Specifier *)(elt->obj))->methods->extra_description; goto restart; - case XD_SIZE_T: + case XD_MEMORY_COUNT: + case XD_ELEMENT_COUNT: + case XD_HASH_CODE: case XD_INT: case XD_LONG: case XD_BYTECOUNT: @@ -740,7 +751,9 @@ pos = 0; desc = ((const Lisp_Specifier *)data)->methods->extra_description; goto restart; - case XD_SIZE_T: + case XD_MEMORY_COUNT: + case XD_ELEMENT_COUNT: + case XD_HASH_CODE: case XD_INT: case XD_LONG: case XD_BYTECOUNT: @@ -803,7 +816,7 @@ pdump_allocate_offset (pdump_entry_list_elt *elt, const struct lrecord_description *desc) { - size_t size = elt->count * elt->size; + Memory_Count size = elt->count * elt->size; elt->save_offset = cur_offset; if (size>max_size) max_size = size; @@ -844,7 +857,7 @@ pdump_dump_root_struct_ptrs (void) { int i; - size_t count = Dynarr_length (pdump_root_struct_ptrs); + Element_Count count = Dynarr_length (pdump_root_struct_ptrs); pdump_static_pointer *data = alloca_array (pdump_static_pointer, count); for (i = 0; i < count; i++) { @@ -920,14 +933,14 @@ static void pdump_dump_root_objects (void) { - size_t count = (Dynarr_length (pdump_root_objects) + - Dynarr_length (pdump_weak_object_chains)); - size_t i; + Element_Count count = (Dynarr_length (pdump_root_objects) + + Dynarr_length (pdump_weak_object_chains)); + Element_Count i; - PDUMP_WRITE_ALIGNED (size_t, count); + PDUMP_WRITE_ALIGNED (Element_Count, count); PDUMP_ALIGN_OUTPUT (pdump_static_Lisp_Object); - for (i=0; i<Dynarr_length (pdump_root_objects); i++) + for (i = 0; i < Dynarr_length (pdump_root_objects); i++) { pdump_static_Lisp_Object obj; obj.address = Dynarr_at (pdump_root_objects, i); @@ -1142,7 +1155,7 @@ } /* Put the pdump_root_objects variables in place */ - i = PDUMP_READ_ALIGNED (p, size_t); + i = PDUMP_READ_ALIGNED (p, Element_Count); p = (char *) ALIGN_PTR (p, ALIGNOF (pdump_static_Lisp_Object)); while (i--) { @@ -1258,7 +1271,7 @@ pdump_free = pdump_resource_free; pdump_length = SizeofResource (NULL, hRes); - if (pdump_length <= sizeof (pdump_header)) + if (pdump_length <= (Memory_Count) sizeof (pdump_header)) { pdump_start = 0; return 0; @@ -1291,7 +1304,7 @@ return 0; pdump_length = lseek (fd, 0, SEEK_END); - if (pdump_length < sizeof (pdump_header)) + if (pdump_length < (Memory_Count) sizeof (pdump_header)) { close (fd); return 0;
--- a/src/dynarr.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/dynarr.c Mon Aug 13 04:46:48 2001 +0000 @@ -214,10 +214,10 @@ what was requested of it is returned in MALLOC_OVERHEAD in STATS. See the comment above the definition of this structure. */ -size_t +Memory_Count Dynarr_memory_usage (void *d, struct overhead_stats *stats) { - size_t total = 0; + Memory_Count total = 0; Dynarr *dy = (Dynarr *) d; /* We have to be a bit tricky here because not all of the @@ -226,7 +226,7 @@ if (dy->base) { - size_t malloc_used = malloced_storage_size (dy->base, + Memory_Count malloc_used = malloced_storage_size (dy->base, dy->elsize * dy->max, 0); /* #### This may or may not be correct. Some Dynarrs would prefer that we use dy->cur instead of dy->largest here. */
--- a/src/editfns.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/editfns.c Mon Aug 13 04:46:48 2001 +0000 @@ -1105,7 +1105,7 @@ (format_string, time_)) { time_t value; - size_t size; + Memory_Count size; CHECK_STRING (format_string); @@ -1268,7 +1268,8 @@ { time_t value; char *the_ctime; - size_t len; + EMACS_INT len; /* this is what make_ext_string() accepts; #### + should it be an Extcount? */ if (! lisp_to_time (specified_time, &value)) value = -1;
--- a/src/eldap.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/eldap.c Mon Aug 13 04:46:48 2001 +0000 @@ -601,7 +601,7 @@ struct berval *bervals; int rc; int i, j; - size_t len; + Element_Count len; Lisp_Object current = Qnil; Lisp_Object values = Qnil; @@ -622,7 +622,7 @@ invalid_operation ("Cannot add void entry", entry); /* Build the ldap_mods array */ - len = XINT (Flength (entry)); + len = (Element_Count) XINT (Flength (entry)); ldap_mods = alloca_array (LDAPMod, len); ldap_mods_ptrs = alloca_array (LDAPMod *, 1 + len); i = 0; @@ -637,7 +637,7 @@ values = XCDR (current); if (CONSP (values)) { - len = XINT (Flength (values)); + len = (Element_Count) XINT (Flength (values)); bervals = alloca_array (struct berval, len); ldap_mods[i].mod_vals.modv_bvals = alloca_array (struct berval *, 1 + len); @@ -695,7 +695,7 @@ struct berval *bervals; int i, j, rc; Lisp_Object mod_op; - size_t len; + Element_Count len; Lisp_Object current = Qnil; Lisp_Object values = Qnil; @@ -714,7 +714,7 @@ return Qnil; /* Build the ldap_mods array */ - len = XINT (Flength (mods)); + len = (Element_Count) XINT (Flength (mods)); ldap_mods = alloca_array (LDAPMod, len); ldap_mods_ptrs = alloca_array (LDAPMod *, 1 + len); i = 0; @@ -740,7 +740,7 @@ CHECK_STRING (XCAR (current)); LISP_STRING_TO_EXTERNAL (XCAR (current), ldap_mods[i].mod_type, Qnative); values = XCDR (current); - len = XINT (Flength (values)); + len = (Element_Count) XINT (Flength (values)); bervals = alloca_array (struct berval, len); ldap_mods[i].mod_vals.modv_bvals = alloca_array (struct berval *, 1 + len);
--- a/src/elhash.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/elhash.c Mon Aug 13 04:46:48 2001 +0000 @@ -82,12 +82,12 @@ struct Lisp_Hash_Table { struct lcrecord_header header; - size_t size; - size_t count; - size_t rehash_count; + Element_Count size; + Element_Count count; + Element_Count rehash_count; double rehash_size; double rehash_threshold; - size_t golden_ratio; + Element_Count golden_ratio; hash_table_hash_function_t hash_function; hash_table_test_function_t test_function; hentry *hentries; @@ -143,13 +143,13 @@ #endif /* Return a suitable size for a hash table, with at least SIZE slots. */ -static size_t -hash_table_size (size_t requested_size) +static Element_Count +hash_table_size (Element_Count requested_size) { /* Return some prime near, but greater than or equal to, SIZE. Decades from the time of writing, someone will have a system large enough that the list below will be too short... */ - static const size_t primes [] = + static const Element_Count primes [] = { 19, 29, 41, 59, 79, 107, 149, 197, 263, 347, 457, 599, 787, 1031, 1361, 1777, 2333, 3037, 3967, 5167, 6719, 8737, 11369, 14783, @@ -159,7 +159,7 @@ 10445899, 13579681, 17653589, 22949669, 29834603, 38784989, 50420551, 65546729, 85210757, 110774011, 144006217, 187208107, 243370577, 316381771, 411296309, 534685237, 695090819, 903618083, - 1174703521, 1527114613, 1985248999, 2580823717UL, 3355070839UL + 1174703521, 1527114613, 1985248999 /* , 2580823717UL, 3355070839UL */ }; /* We've heard of binary search. */ int low, high; @@ -188,7 +188,7 @@ return !strcmp ((char *) XSTRING_DATA (str1), (char *) XSTRING_DATA (str2)); } -static hashcode_t +static Hash_Code lisp_string_hash (Lisp_Object obj) { return hash_string (XSTRING_DATA (str), XSTRING_LENGTH (str)); @@ -202,7 +202,7 @@ return EQ (obj1, obj2) || (FLOATP (obj1) && internal_equal (obj1, obj2, 0)); } -static hashcode_t +static Hash_Code lisp_object_eql_hash (Lisp_Object obj) { return FLOATP (obj) ? internal_hash (obj, 0) : LISP_HASH (obj); @@ -214,7 +214,7 @@ return internal_equal (obj1, obj2, 0); } -static hashcode_t +static Hash_Code lisp_object_equal_hash (Lisp_Object obj) { return internal_hash (obj, 0); @@ -283,7 +283,7 @@ /* This is not a great hash function, but it _is_ correct and fast. Examining all entries is too expensive, and examining a random subset does not yield a correct hash function. */ -static hashcode_t +static Hash_Code hash_table_hash (Lisp_Object hash_table, int depth) { return XHASH_TABLE (hash_table)->count; @@ -367,11 +367,9 @@ if (ht->count || !print_readably) { if (print_readably) - sprintf (buf, " size %lu", (unsigned long) ht->count); + sprintf (buf, " size %ld", (long) ht->count); else - sprintf (buf, " size %lu/%lu", - (unsigned long) ht->count, - (unsigned long) ht->size); + sprintf (buf, " size %ld/%ld", (long) ht->count, (long) ht->size); write_c_string (buf, printcharfun); } @@ -436,7 +434,7 @@ }; const struct lrecord_description hash_table_description[] = { - { XD_SIZE_T, offsetof (Lisp_Hash_Table, size) }, + { XD_ELEMENT_COUNT, offsetof (Lisp_Hash_Table, size) }, { XD_STRUCT_PTR, offsetof (Lisp_Hash_Table, hentries), XD_INDIRECT(0, 1), &hentry_description }, { XD_LO_LINK, offsetof (Lisp_Hash_Table, next_weak) }, { XD_END } @@ -467,15 +465,15 @@ static void compute_hash_table_derived_values (Lisp_Hash_Table *ht) { - ht->rehash_count = (size_t) + ht->rehash_count = (Element_Count) ((double) ht->size * ht->rehash_threshold); - ht->golden_ratio = (size_t) + ht->golden_ratio = (Element_Count) ((double) ht->size * (.6180339887 / (double) sizeof (Lisp_Object))); } Lisp_Object make_standard_lisp_hash_table (enum hash_table_test test, - size_t size, + Element_Count size, double rehash_size, double rehash_threshold, enum hash_table_weakness weakness) @@ -512,7 +510,7 @@ Lisp_Object make_general_lisp_hash_table (hash_table_hash_function_t hash_function, hash_table_test_function_t test_function, - size_t size, + Element_Count size, double rehash_size, double rehash_threshold, enum hash_table_weakness weakness) @@ -533,7 +531,7 @@ if (size < HASH_TABLE_MIN_SIZE) size = HASH_TABLE_MIN_SIZE; - ht->size = hash_table_size ((size_t) (((double) size / ht->rehash_threshold) + ht->size = hash_table_size ((Element_Count) (((double) size / ht->rehash_threshold) + 1.0)); ht->count = 0; @@ -553,7 +551,7 @@ } Lisp_Object -make_lisp_hash_table (size_t size, +make_lisp_hash_table (Element_Count size, enum hash_table_weakness weakness, enum hash_table_test test) { @@ -583,7 +581,7 @@ return 0; } -static size_t +static Element_Count decode_hash_table_size (Lisp_Object obj) { return NILP (obj) ? HASH_TABLE_DEFAULT_SIZE : XINT (obj); @@ -958,10 +956,10 @@ } static void -resize_hash_table (Lisp_Hash_Table *ht, size_t new_size) +resize_hash_table (Lisp_Hash_Table *ht, Element_Count new_size) { hentry *old_entries, *new_entries, *sentinel, *e; - size_t old_size; + Element_Count old_size; old_size = ht->size; ht->size = new_size; @@ -1012,8 +1010,8 @@ static void enlarge_hash_table (Lisp_Hash_Table *ht) { - size_t new_size = - hash_table_size ((size_t) ((double) ht->size * ht->rehash_size)); + Element_Count new_size = + hash_table_size ((Element_Count) ((double) ht->size * ht->rehash_size)); resize_hash_table (ht, new_size); } @@ -1069,7 +1067,7 @@ static void remhash_1 (Lisp_Hash_Table *ht, hentry *entries, hentry *probe) { - size_t size = ht->size; + Element_Count size = ht->size; CLEAR_HENTRY (probe); probe++; ht->count--; @@ -1552,11 +1550,11 @@ /* Return a hash value for an array of Lisp_Objects of size SIZE. */ -hashcode_t +Hash_Code internal_array_hash (Lisp_Object *arr, int size, int depth) { int i; - hashcode_t hash = 0; + Hash_Code hash = 0; depth++; if (size <= 5) @@ -1587,7 +1585,7 @@ we could still take 5^5 time (a big big number) to compute a hash, but practically this won't ever happen. */ -hashcode_t +Hash_Code internal_hash (Lisp_Object obj, int depth) { if (depth > 5) @@ -1631,7 +1629,7 @@ (object)) { /* This function is pretty 32bit-centric. */ - hashcode_t hash = internal_hash (object, 0); + Hash_Code hash = internal_hash (object, 0); return Fcons (hash >> 16, hash & 0xffff); } #endif
--- a/src/elhash.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/elhash.h Mon Aug 13 04:46:48 2001 +0000 @@ -62,26 +62,25 @@ EXFUN (Fremhash, 2); EXFUN (Fclrhash, 1); -typedef unsigned long hashcode_t; typedef int (*hash_table_test_function_t) (Lisp_Object obj1, Lisp_Object obj2); typedef unsigned long (*hash_table_hash_function_t) (Lisp_Object obj); typedef int (*maphash_function_t) (Lisp_Object key, Lisp_Object value, void* extra_arg); Lisp_Object make_standard_lisp_hash_table (enum hash_table_test test, - size_t size, + Element_Count size, double rehash_size, double rehash_threshold, enum hash_table_weakness weakness); Lisp_Object make_general_lisp_hash_table (hash_table_hash_function_t hash_function, hash_table_test_function_t test_function, - size_t size, + Element_Count size, double rehash_size, double rehash_threshold, enum hash_table_weakness weakness); -Lisp_Object make_lisp_hash_table (size_t size, +Lisp_Object make_lisp_hash_table (Element_Count size, enum hash_table_weakness weakness, enum hash_table_test test);
--- a/src/emacs.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/emacs.c Mon Aug 13 04:46:48 2001 +0000 @@ -335,7 +335,8 @@ uintptr_t bss_end = 0; #endif -/* Number of bytes of writable memory we can expect to be able to get */ +/* Number of bytes of writable memory we can expect to be able to get: + Leave this as an unsigned int because it could potentially be 4G */ unsigned int lim_data; /* WARNING! @@ -463,8 +464,8 @@ static int run_temacs_argc; static Extbyte **run_temacs_argv; static Extbyte *run_temacs_args; -static size_t run_temacs_argv_size; -static size_t run_temacs_args_size; +static int run_temacs_argv_size; +static int run_temacs_args_size; static void shut_down_emacs (int sig, Lisp_Object stuff, int no_auto_save);
--- a/src/eval.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/eval.c Mon Aug 13 04:46:48 2001 +0000 @@ -4738,9 +4738,9 @@ #define min_max_specpdl_size 400 void -grow_specpdl (size_t reserved) -{ - size_t size_needed = specpdl_depth() + reserved; +grow_specpdl (EMACS_INT reserved) +{ + EMACS_INT size_needed = specpdl_depth() + reserved; if (size_needed >= max_specpdl_size) { if (max_specpdl_size < min_max_specpdl_size)
--- a/src/event-Xt.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/event-Xt.c Mon Aug 13 04:46:48 2001 +0000 @@ -1341,7 +1341,7 @@ { unsigned int state; int modifiers = 0; - unsigned int button=0; + int button = 0; struct frame *frame = x_any_window_to_frame (d, ev->window); Extbyte *data; unsigned long size, dtype;
--- a/src/event-msw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/event-msw.c Mon Aug 13 04:46:48 2001 +0000 @@ -367,9 +367,9 @@ return s->thread_data->hev_caller; } -static Lstream_data_count +static Lstream_Data_Count ntpipe_slurp_reader (Lstream *stream, unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { /* This function must be called from the main thread only */ struct ntpipe_slurp_stream_shared_data* s = @@ -429,7 +429,7 @@ so do not check for errors. ReadFile in the thread will fail if the next call fails. */ if (bytes_available) - ReadFile (s->hpipe, data, min (bytes_available, size), + ReadFile (s->hpipe, data, min (bytes_available, (DWORD) size), &bytes_read, NULL); } @@ -582,9 +582,9 @@ } #endif -static Lstream_data_count +static Lstream_Data_Count ntpipe_shove_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct ntpipe_shove_stream* s = NTPIPE_SHOVE_STREAM_DATA(stream); @@ -666,9 +666,9 @@ LPARAM user_data; /* Any user data stored in the stream object */ SOCKET s; /* Socket handle (which is a Win32 handle) */ OVERLAPPED ov; /* Overlapped I/O structure */ - void* buffer; /* Buffer. */ - unsigned long bufsize; /* Number of bytes last read */ - unsigned long bufpos; /* Position in buffer for next fetch */ + void *buffer; /* Buffer. */ + DWORD bufsize; /* Number of bytes last read */ + DWORD bufpos; /* Position in buffer for next fetch */ unsigned int error_p :1; /* I/O Error seen */ unsigned int eof_p :1; /* EOF Error seen */ unsigned int pending_p :1; /* There is a pending I/O operation */ @@ -700,8 +700,8 @@ str->eof_p = 1; } -static Lstream_data_count -winsock_reader (Lstream *stream, unsigned char *data, Lstream_data_count size) +static Lstream_Data_Count +winsock_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size) { struct winsock_stream *str = WINSOCK_STREAM_DATA (stream); @@ -735,7 +735,7 @@ return -1; /* Return as much of buffer as we have */ - size = min (size, (Lstream_data_count) (str->bufsize - str->bufpos)); + size = min (size, (Lstream_Data_Count) (str->bufsize - str->bufpos)); memcpy (data, (void*)((BYTE*)str->buffer + str->bufpos), size); str->bufpos += size; @@ -746,9 +746,9 @@ return size; } -static Lstream_data_count +static Lstream_Data_Count winsock_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct winsock_stream *str = WINSOCK_STREAM_DATA (stream); @@ -1386,13 +1386,12 @@ static void mswindows_need_event (int badly_p) { - int active; - while (NILP (mswindows_u_dispatch_event_queue) && NILP (mswindows_s_dispatch_event_queue)) { #ifdef HAVE_MSG_SELECT int i; + int active; SELECT_TYPE temp_mask = input_wait_mask; EMACS_TIME sometime; EMACS_SELECT_TIME select_time_to_block, *pointer_to_this; @@ -1487,8 +1486,9 @@ { assert(0); } -#else +#else /* not HAVE_MSG_SELECT */ /* Now try getting a message or process event */ + DWORD active; DWORD what_events; if (mswindows_in_modal_loop) /* In a modal loop, only look for timer events, and only if @@ -1570,7 +1570,7 @@ mswindows_enqueue_magic_event (NULL, XM_BUMPQUEUE); } } -#endif +#endif /* not HAVE_MSG_SELECT */ } /* while */ } @@ -2059,7 +2059,7 @@ Lisp_Event *event; struct frame *frame; - struct mswindows_frame* msframe; + struct mswindows_frame *msframe; /* If you hit this, rewrite the offending API call to occur after GC, using register_post_gc_action(). */ @@ -2250,7 +2250,7 @@ PM_REMOVE)) { int mods_with_quit = mods; - WPARAM ch = tranmsg.wParam; + Emchar ch = (Emchar) tranmsg.wParam; #ifdef DEBUG_XEMACS if (debug_mswindows_events) @@ -2552,18 +2552,17 @@ case WM_NOTIFY: { - LPNMHDR nmhdr = (LPNMHDR)lParam; - - if (nmhdr->code == TTN_NEEDTEXT) + LPNMHDR nmhdr = (LPNMHDR) lParam; + + if ((int) nmhdr->code == TTN_NEEDTEXT) { #ifdef HAVE_TOOLBARS - LPTOOLTIPTEXT tttext = (LPTOOLTIPTEXT)lParam; + LPTOOLTIPTEXT tttext = (LPTOOLTIPTEXT) lParam; Lisp_Object btext; /* find out which toolbar */ frame = XFRAME (mswindows_find_frame (hwnd)); - btext = mswindows_get_toolbar_button_text ( frame, - nmhdr->idFrom ); + btext = mswindows_get_toolbar_button_text (frame, nmhdr->idFrom); tttext->lpszText = NULL; tttext->hinst = NULL; @@ -2577,14 +2576,14 @@ #endif } /* handle tree view callbacks */ - else if (nmhdr->code == TVN_SELCHANGED) + else if ((int) nmhdr->code == TVN_SELCHANGED) { - NM_TREEVIEW* ptree = (NM_TREEVIEW*)lParam; + NM_TREEVIEW *ptree = (NM_TREEVIEW *) lParam; frame = XFRAME (mswindows_find_frame (hwnd)); mswindows_handle_gui_wm_command (frame, 0, ptree->itemNew.lParam); } /* handle tab control callbacks */ - else if (nmhdr->code == TCN_SELCHANGE) + else if ((int) nmhdr->code == TCN_SELCHANGE) { TC_ITEM item; int idx = SendMessage (nmhdr->hwndFrom, TCM_GETCURSEL, 0, 0); @@ -3092,13 +3091,17 @@ current_hkl = xGetKeyboardLayout (0); if (current_hkl != last_hkl) { - TCHAR c; + int c; last_hkl_has_AltGr = 0; /* In this loop, we query whether a character requires AltGr to be down to generate it. If at least such one found, this means that the layout does regard AltGr */ - for (c = ' '; c <= 0xFFU && c != 0 && !last_hkl_has_AltGr; ++c) - if (HIBYTE (VkKeyScan (c)) == 6) + for (c = ' '; c <= 255 && !last_hkl_has_AltGr; ++c) + /* #### This is not really such a good check. What about under + CJK locales? It may not matter there, though. We always + call VkKeyScanA so that we check the locale-specific characters + in non-Latin-1 locales, instead of just the Latin-1 characters. */ + if (HIBYTE (VkKeyScanA ((char) c)) == 6) last_hkl_has_AltGr = 1; last_hkl = current_hkl; } @@ -3958,7 +3961,7 @@ for (i = 0; i < countof (debug_mswin_messages); i++) { - if (debug_mswin_messages[i].mess == message_) + if (debug_mswin_messages[i].mess == (int) message_) { str = debug_mswin_messages[i].string; break;
--- a/src/events.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/events.c Mon Aug 13 04:46:48 2001 +0000 @@ -300,11 +300,11 @@ } } -static unsigned long +static Hash_Code event_hash (Lisp_Object obj, int depth) { Lisp_Event *e = XEVENT (obj); - unsigned long hash; + Hash_Code hash; hash = HASH2 (e->event_type, LISP_HASH (e->channel)); switch (e->event_type) @@ -338,7 +338,7 @@ case magic_eval_event: return HASH3 (hash, - (unsigned long) e->event.magic_eval.internal_function, + (Hash_Code) e->event.magic_eval.internal_function, internal_hash (e->event.magic_eval.object, depth + 1)); case magic_event:
--- a/src/extents.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/extents.c Mon Aug 13 04:46:48 2001 +0000 @@ -736,11 +736,11 @@ { /* RIGHT might not point to a valid extent (i.e. it's at the end of the list), so NEWPOS must round down. */ - unsigned int newpos = (left + right) >> 1; + int newpos = (left + right) >> 1; EXTENT e = EXTENT_GAP_ARRAY_AT (ga, (int) newpos); if (endp ? EXTENT_E_LESS (e, extent) : EXTENT_LESS (e, extent)) - left = newpos+1; + left = newpos + 1; else right = newpos; } @@ -3104,7 +3104,7 @@ depth)); } -static unsigned long +static Hash_Code extent_hash (Lisp_Object obj, int depth) { struct extent *e = XEXTENT (obj); @@ -5034,12 +5034,12 @@ if (!endp) { set_extent_begin_glyph (extent, glyph); - extent_begin_glyph_layout (extent) = layout; + set_extent_begin_glyph_layout (extent, layout); } else { set_extent_end_glyph (extent, glyph); - extent_end_glyph_layout (extent) = layout; + set_extent_end_glyph_layout (extent, layout); } extent_changed_for_redisplay (extent, 1, 0); @@ -5136,7 +5136,7 @@ { EXTENT e = decode_extent (extent, 0); e = extent_ancestor (e); - extent_begin_glyph_layout (e) = symbol_to_glyph_layout (layout); + set_extent_begin_glyph_layout (e, symbol_to_glyph_layout (layout)); extent_maybe_changed_for_redisplay (e, 1, 0); return layout; } @@ -5149,7 +5149,7 @@ { EXTENT e = decode_extent (extent, 0); e = extent_ancestor (e); - extent_end_glyph_layout (e) = symbol_to_glyph_layout (layout); + set_extent_end_glyph_layout (e, symbol_to_glyph_layout (layout)); extent_maybe_changed_for_redisplay (e, 1, 0); return layout; }
--- a/src/extents.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/extents.h Mon Aug 13 04:46:48 2001 +0000 @@ -211,7 +211,7 @@ set_extent_no_chase_aux_field (extent_ancestor (e), field, value) #define set_extent_normal_field(e, field, value) \ - set_extent_ancestor_normal_field (extent_no_chase (e), field, value) + set_extent_no_chase_normal_field (extent_ancestor (e), field, value) /* The `parent' and `children' fields are not affected by any parent links. We don't provide any settors for these fields @@ -252,8 +252,8 @@ set_extent_aux_field (e, after_change_functions, value) #define extent_face(e) extent_normal_field (e, face) -#define extent_begin_glyph_layout(e) extent_normal_field (e, begin_glyph_layout) -#define extent_end_glyph_layout(e) extent_normal_field (e, end_glyph_layout) +#define extent_begin_glyph_layout(e) ((enum glyph_layout) extent_normal_field (e, begin_glyph_layout)) +#define extent_end_glyph_layout(e) ((enum glyph_layout) extent_normal_field (e, end_glyph_layout)) #define extent_start_open_p(e) extent_normal_field (e, start_open) #define extent_end_open_p(e) extent_normal_field (e, end_open) #define extent_unique_p(e) extent_normal_field (e, unique) @@ -262,6 +262,27 @@ #define extent_internal_p(e) extent_normal_field (e, internal) #define extent_in_red_event_p(e) extent_normal_field (e, in_red_event) +#define set_extent_face(e, val) \ + set_extent_normal_field (e, face, val) +#define set_extent_begin_glyph_layout(e, val) \ + set_extent_normal_field (e, begin_glyph_layout, val) +#define set_extent_end_glyph_layout(e, val) \ + set_extent_normal_field (e, end_glyph_layout, val) +#define set_extent_start_open_p(e, val) \ + set_extent_normal_field (e, start_open, val) +#define set_extent_end_open_p(e, val) \ + set_extent_normal_field (e, end_open, val) +#define set_extent_unique_p(e, val) \ + set_extent_normal_field (e, unique, val) +#define set_extent_duplicable_p(e, val) \ + set_extent_normal_field (e, duplicable, val) +#define set_extent_detachable_p(e, val) \ + set_extent_normal_field (e, detachable, val) +#define set_extent_internal_p(e, val) \ + set_extent_normal_field (e, internal, val) +#define set_extent_in_red_event_p(e, val) \ + set_extent_normal_field (e, in_red_event, val) + INLINE_HEADER Lisp_Object * extent_no_chase_plist_addr (EXTENT e); INLINE_HEADER Lisp_Object * extent_no_chase_plist_addr (EXTENT e)
--- a/src/faces.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/faces.c Mon Aug 13 04:46:48 2001 +0000 @@ -150,7 +150,7 @@ ! plists_differ (f1->plist, f2->plist, 0, 0, depth + 1)); } -static unsigned long +static Hash_Code face_hash (Lisp_Object obj, int depth) { Lisp_Face *f = XFACE (obj);
--- a/src/file-coding.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/file-coding.c Mon Aug 13 04:46:48 2001 +0000 @@ -174,47 +174,47 @@ #ifdef MULE struct detection_state; static int detect_coding_sjis (struct detection_state *st, - const Extbyte *src, Lstream_data_count n); + const Extbyte *src, Lstream_Data_Count n); static void decode_coding_sjis (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static void encode_coding_sjis (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static int detect_coding_big5 (struct detection_state *st, - const Extbyte *src, Lstream_data_count n); + const Extbyte *src, Lstream_Data_Count n); static void decode_coding_big5 (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static void encode_coding_big5 (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static int detect_coding_ucs4 (struct detection_state *st, - const Extbyte *src, Lstream_data_count n); + const Extbyte *src, Lstream_Data_Count n); static void decode_coding_ucs4 (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static void encode_coding_ucs4 (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static int detect_coding_utf8 (struct detection_state *st, - const Extbyte *src, Lstream_data_count n); + const Extbyte *src, Lstream_Data_Count n); static void decode_coding_utf8 (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static void encode_coding_utf8 (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static int postprocess_iso2022_mask (int mask); static void reset_iso2022 (Lisp_Object coding_system, struct iso2022_decoder *iso); static int detect_coding_iso2022 (struct detection_state *st, - const Extbyte *src, Lstream_data_count n); + const Extbyte *src, Lstream_Data_Count n); static void decode_coding_iso2022 (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static void encode_coding_iso2022 (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); #endif /* MULE */ static void decode_coding_no_conversion (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static void encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static void mule_decode (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); static void mule_encode (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n); + unsigned_char_dynarr *dst, Lstream_Data_Count n); typedef struct codesys_prop codesys_prop; struct codesys_prop @@ -1617,7 +1617,7 @@ static eol_type_t detect_eol_type (struct detection_state *st, const Extbyte *src, - Lstream_data_count n) + Lstream_Data_Count n) { while (n--) { @@ -1660,7 +1660,7 @@ static int detect_coding_type (struct detection_state *st, const Extbyte *src, - Lstream_data_count n, int just_do_eol) + Lstream_Data_Count n, int just_do_eol) { if (st->eol_type == EOL_AUTODETECT) st->eol_type = detect_eol_type (st, src, n); @@ -1791,7 +1791,7 @@ Extbyte buf[4096]; Lisp_Object coding_system = Qnil; Extbyte *p; - Lstream_data_count nread = Lstream_read (stream, buf, sizeof (buf)); + Lstream_Data_Count nread = Lstream_read (stream, buf, sizeof (buf)); Extbyte *scan_end; /* Look for initial "-*-"; mode line prefix */ @@ -1925,7 +1925,7 @@ while (1) { Extbyte random_buffer[4096]; - Lstream_data_count nread = Lstream_read (istr, random_buffer, sizeof (random_buffer)); + Lstream_Data_Count nread = Lstream_read (istr, random_buffer, sizeof (random_buffer)); if (!nread) break; @@ -2092,10 +2092,10 @@ struct detection_state decst; }; -static Lstream_data_count decoding_reader (Lstream *stream, - unsigned char *data, Lstream_data_count size); -static Lstream_data_count decoding_writer (Lstream *stream, - const unsigned char *data, Lstream_data_count size); +static Lstream_Data_Count decoding_reader (Lstream *stream, + unsigned char *data, Lstream_Data_Count size); +static Lstream_Data_Count decoding_writer (Lstream *stream, + const unsigned char *data, Lstream_Data_Count size); static int decoding_rewinder (Lstream *stream); static int decoding_seekable_p (Lstream *stream); static int decoding_flusher (Lstream *stream); @@ -2127,12 +2127,12 @@ /* Read SIZE bytes of data and store it into DATA. We are a decoding stream so we read data from the other end, decode it, and store it into DATA. */ -static Lstream_data_count -decoding_reader (Lstream *stream, unsigned char *data, Lstream_data_count size) +static Lstream_Data_Count +decoding_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size) { struct decoding_stream *str = DECODING_STREAM_DATA (stream); unsigned char *orig_data = data; - Lstream_data_count read_size; + Lstream_Data_Count read_size; int error_occurred = 0; /* We need to interface to mule_decode(), which expects to take some @@ -2148,7 +2148,7 @@ most SIZE bytes, and delete the data from the runoff. */ if (Dynarr_length (str->runoff) > 0) { - Lstream_data_count chunk = min (size, (Lstream_data_count) Dynarr_length (str->runoff)); + Lstream_Data_Count chunk = min (size, (Lstream_Data_Count) Dynarr_length (str->runoff)); memcpy (data, Dynarr_atp (str->runoff, 0), chunk); Dynarr_delete_many (str->runoff, 0, chunk); data += chunk; @@ -2189,11 +2189,11 @@ return data - orig_data; } -static Lstream_data_count -decoding_writer (Lstream *stream, const unsigned char *data, Lstream_data_count size) +static Lstream_Data_Count +decoding_writer (Lstream *stream, const unsigned char *data, Lstream_Data_Count size) { struct decoding_stream *str = DECODING_STREAM_DATA (stream); - Lstream_data_count retval; + Lstream_Data_Count retval; /* Decode all our data into the runoff, and then attempt to write it all out to the other end. Remove whatever chunk we succeeded @@ -2351,7 +2351,7 @@ static void mule_decode (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); @@ -2473,7 +2473,7 @@ char tempbuf[1024]; /* some random amount */ Bufpos newpos, even_newer_pos; Bufpos oldpos = lisp_buffer_stream_startpos (istr); - Lstream_data_count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); + Lstream_Data_Count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); if (!size_in_bytes) break; @@ -2558,9 +2558,9 @@ #endif /* MULE */ }; -static Lstream_data_count encoding_reader (Lstream *stream, unsigned char *data, Lstream_data_count size); -static Lstream_data_count encoding_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size); +static Lstream_Data_Count encoding_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size); +static Lstream_Data_Count encoding_writer (Lstream *stream, const unsigned char *data, + Lstream_Data_Count size); static int encoding_rewinder (Lstream *stream); static int encoding_seekable_p (Lstream *stream); static int encoding_flusher (Lstream *stream); @@ -2592,12 +2592,12 @@ /* Read SIZE bytes of data and store it into DATA. We are a encoding stream so we read data from the other end, encode it, and store it into DATA. */ -static Lstream_data_count -encoding_reader (Lstream *stream, unsigned char *data, Lstream_data_count size) +static Lstream_Data_Count +encoding_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size) { struct encoding_stream *str = ENCODING_STREAM_DATA (stream); unsigned char *orig_data = data; - Lstream_data_count read_size; + Lstream_Data_Count read_size; int error_occurred = 0; /* We need to interface to mule_encode(), which expects to take some @@ -2654,11 +2654,11 @@ return data - orig_data; } -static Lstream_data_count -encoding_writer (Lstream *stream, const unsigned char *data, Lstream_data_count size) +static Lstream_Data_Count +encoding_writer (Lstream *stream, const unsigned char *data, Lstream_Data_Count size) { struct encoding_stream *str = ENCODING_STREAM_DATA (stream); - Lstream_data_count retval; + Lstream_Data_Count retval; /* Encode all our data into the runoff, and then attempt to write it all out to the other end. Remove whatever chunk we succeeded @@ -2798,7 +2798,7 @@ static void mule_encode (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); @@ -2884,7 +2884,7 @@ char tempbuf[1024]; /* some random amount */ Bufpos newpos, even_newer_pos; Bufpos oldpos = lisp_buffer_stream_startpos (istr); - Lstream_data_count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); + Lstream_Data_Count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); if (!size_in_bytes) break; @@ -2947,7 +2947,7 @@ ((c) >= 0xA1 && (c) <= 0xDF) static int -detect_coding_sjis (struct detection_state *st, const Extbyte *src, Lstream_data_count n) +detect_coding_sjis (struct detection_state *st, const Extbyte *src, Lstream_Data_Count n) { while (n--) { @@ -2970,7 +2970,7 @@ static void decode_coding_sjis (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; @@ -3026,7 +3026,7 @@ static void encode_coding_sjis (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); unsigned int flags = str->flags; @@ -3195,7 +3195,7 @@ #define DECODE_BIG5(b1, b2, lb, c1, c2) do \ { \ int B1 = b1, B2 = b2; \ - unsigned int I \ + int I \ = (B1 - 0xA1) * BIG5_SAME_ROW + B2 - (B2 < 0x7F ? 0x40 : 0x62); \ \ if (B1 < 0xC9) \ @@ -3216,7 +3216,7 @@ #define ENCODE_BIG5(lb, c1, c2, b1, b2) do \ { \ - unsigned int I = ((c1) - 0xA1) * (0xFF - 0xA1) + ((c2) - 0xA1); \ + int I = ((c1) - 0xA1) * (0xFF - 0xA1) + ((c2) - 0xA1); \ \ if (lb == LEADING_BYTE_CHINESE_BIG5_2) \ { \ @@ -3228,7 +3228,7 @@ } while (0) static int -detect_coding_big5 (struct detection_state *st, const Extbyte *src, Lstream_data_count n) +detect_coding_big5 (struct detection_state *st, const Extbyte *src, Lstream_Data_Count n) { while (n--) { @@ -3252,7 +3252,7 @@ static void decode_coding_big5 (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; @@ -3301,7 +3301,7 @@ static void encode_coding_big5 (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { unsigned char c; struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); @@ -3425,7 +3425,7 @@ */ (code, character)) { - size_t c; + EMACS_INT c; CHECK_CHAR (character); CHECK_NATNUM (code); @@ -3567,7 +3567,7 @@ } static int -detect_coding_ucs4 (struct detection_state *st, const Extbyte *src, Lstream_data_count n) +detect_coding_ucs4 (struct detection_state *st, const Extbyte *src, Lstream_Data_Count n) { while (n--) { @@ -3592,7 +3592,7 @@ static void decode_coding_ucs4 (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; @@ -3628,7 +3628,7 @@ static void encode_coding_ucs4 (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); unsigned int flags = str->flags; @@ -3639,7 +3639,7 @@ #ifdef ENABLE_COMPOSITE_CHARS /* flags for handling composite chars. We do a little switcharoo on the source while we're outputting the composite char. */ - unsigned int saved_n = 0; + Lstream_Data_Count saved_n = 0; const unsigned char *saved_src = NULL; int in_composite = 0; @@ -3766,7 +3766,7 @@ /************************************************************************/ static int -detect_coding_utf8 (struct detection_state *st, const Extbyte *src, Lstream_data_count n) +detect_coding_utf8 (struct detection_state *st, const Extbyte *src, Lstream_Data_Count n) { while (n--) { @@ -3801,7 +3801,7 @@ static void decode_coding_utf8 (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; @@ -3915,7 +3915,7 @@ static void encode_coding_utf8 (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); unsigned int flags = str->flags; @@ -3927,7 +3927,7 @@ #ifdef ENABLE_COMPOSITE_CHARS /* flags for handling composite chars. We do a little switcharoo on the source while we're outputting the composite char. */ - unsigned int saved_n = 0; + Lstream_Data_Count saved_n = 0; const unsigned char *saved_src = NULL; int in_composite = 0; @@ -4674,7 +4674,7 @@ } static int -detect_coding_iso2022 (struct detection_state *st, const Extbyte *src, Lstream_data_count n) +detect_coding_iso2022 (struct detection_state *st, const Extbyte *src, Lstream_Data_Count n) { int mask; @@ -4865,7 +4865,7 @@ static void decode_coding_iso2022 (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; @@ -5107,7 +5107,7 @@ { static const char inter94[] = "()*+"; static const char inter96[] = ",-./"; - unsigned int type; + int type; unsigned char final; Lisp_Object old_charset = str->iso2022.charset[reg]; @@ -5191,7 +5191,7 @@ static void encode_coding_iso2022 (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { unsigned char charmask, c; unsigned char char_boundary; @@ -5207,7 +5207,7 @@ #ifdef ENABLE_COMPOSITE_CHARS /* flags for handling composite chars. We do a little switcharoo on the source while we're outputting the composite char. */ - unsigned int saved_n = 0; + Lstream_Data_Count saved_n = 0; const unsigned char *saved_src = NULL; int in_composite = 0; #endif /* ENABLE_COMPOSITE_CHARS */ @@ -5500,7 +5500,7 @@ interpreted as being in any particular decoding. */ static void decode_coding_no_conversion (Lstream *decoding, const Extbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { struct decoding_stream *str = DECODING_STREAM_DATA (decoding); unsigned int flags = str->flags; @@ -5524,7 +5524,7 @@ static void encode_coding_no_conversion (Lstream *encoding, const Bufbyte *src, - unsigned_char_dynarr *dst, Lstream_data_count n) + unsigned_char_dynarr *dst, Lstream_Data_Count n) { unsigned char c; struct encoding_stream *str = ENCODING_STREAM_DATA (encoding); @@ -5849,12 +5849,12 @@ #ifdef MULE { - size_t i; + int i; for (i = 0; i < countof (fcd->ucs_to_mule_table); i++) fcd->ucs_to_mule_table[i] = Qnil; } staticpro (&mule_to_ucs_table); - mule_to_ucs_table = Fmake_char_table(Qgeneric); + mule_to_ucs_table = Fmake_char_table (Qgeneric); #endif /* MULE */ }
--- a/src/fileio.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/fileio.c Mon Aug 13 04:46:48 2001 +0000 @@ -208,15 +208,15 @@ (#### Actually, longjmp()ing out of the signal handler may not be as losing as I thought. See qxe_reliable_signal() in sysdep.c.) */ -ssize_t -read_allowing_quit (int fildes, void *buf, size_t size) +Memory_Count +read_allowing_quit (int fildes, void *buf, Memory_Count size) { QUIT; return sys_read_1 (fildes, buf, size, 1); } -ssize_t -write_allowing_quit (int fildes, const void *buf, size_t size) +Memory_Count +write_allowing_quit (int fildes, const void *buf, Memory_Count size) { QUIT; return sys_write_1 (fildes, buf, size, 1); @@ -2768,7 +2768,7 @@ { int nread; Bufpos bufpos; - nread = read_allowing_quit (fd, buffer, sizeof buffer); + nread = read_allowing_quit (fd, buffer, sizeof (buffer)); if (nread < 0) report_file_error ("Reading", filename); else if (nread == 0) @@ -2904,7 +2904,7 @@ occurs inside of the filedesc stream. */ while (1) { - Lstream_data_count this_len; + Lstream_Data_Count this_len; Charcount cc_inserted; QUIT;
--- a/src/filelock.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/filelock.c Mon Aug 13 04:46:48 2001 +0000 @@ -81,12 +81,12 @@ { char *user; char *host; - unsigned long pid; + pid_t pid; } lock_info_type; /* When we read the info back, we might need this much more, enough for decimal representation plus null. */ -#define LOCK_PID_MAX (4 * sizeof (unsigned long)) +#define LOCK_PID_MAX (4 * sizeof (pid_t)) /* Free the two dynamically-allocated pieces in PTR. */ #define FREE_LOCK_INFO(i) do { xfree ((i).user); xfree ((i).host); } while (0) @@ -102,7 +102,7 @@ { Bufbyte *file_name = XSTRING_DATA (fn); Bufbyte *p; - size_t dirlen; + Bytecount dirlen; for (p = file_name + XSTRING_LENGTH (fn) - 1; p > file_name && !IS_ANY_SEP (p[-1]); @@ -141,8 +141,7 @@ lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name) + LOCK_PID_MAX + 5); - sprintf (lock_info_str, "%s@%s.%lu", user_name, host_name, - (unsigned long) getpid ()); + sprintf (lock_info_str, "%s@%s.%d", user_name, host_name, getpid ()); err = symlink (lock_info_str, lfname); if (err != 0 && errno == EEXIST && force) @@ -349,7 +348,7 @@ /* Else consider breaking the lock */ locker = (char *) alloca (strlen (lock_info.user) + strlen (lock_info.host) + LOCK_PID_MAX + 9); - sprintf (locker, "%s@%s (pid %lu)", lock_info.user, lock_info.host, + sprintf (locker, "%s@%s (pid %d)", lock_info.user, lock_info.host, lock_info.pid); FREE_LOCK_INFO (lock_info);
--- a/src/floatfns.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/floatfns.c Mon Aug 13 04:46:48 2001 +0000 @@ -175,7 +175,7 @@ return (extract_float (obj1) == extract_float (obj2)); } -static unsigned long +static Hash_Code float_hash (Lisp_Object obj, int depth) { /* mod the value down to 32-bit range */
--- a/src/fns.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/fns.c Mon Aug 13 04:46:48 2001 +0000 @@ -69,10 +69,10 @@ static void print_bit_vector (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) { - size_t i; + Element_Count i; Lisp_Bit_Vector *v = XBIT_VECTOR (obj); - size_t len = bit_vector_length (v); - size_t last = len; + Element_Count len = bit_vector_length (v); + Element_Count last = len; if (INTP (Vprint_length)) last = min (len, XINT (Vprint_length)); @@ -101,7 +101,7 @@ sizeof (long))); } -static unsigned long +static Hash_Code bit_vector_hash (Lisp_Object obj, int depth) { Lisp_Bit_Vector *v = XBIT_VECTOR (obj); @@ -111,7 +111,7 @@ sizeof (long))); } -static size_t +static Memory_Count size_bit_vector (const void *lheader) { Lisp_Bit_Vector *v = (Lisp_Bit_Vector *) lheader; @@ -223,7 +223,7 @@ return make_int (XSTRING_CHAR_LENGTH (sequence)); else if (CONSP (sequence)) { - size_t len; + Element_Count len; GET_EXTERNAL_LIST_LENGTH (sequence, len); return make_int (len); } @@ -250,7 +250,7 @@ (list)) { Lisp_Object hare, tortoise; - size_t len; + Element_Count len; for (hare = tortoise = list, len = 0; CONSP (hare) && (! EQ (hare, tortoise) || len == 0); @@ -530,7 +530,7 @@ Lisp_Object list_copy = Fcons (XCAR (list), XCDR (list)); Lisp_Object last = list_copy; Lisp_Object hare, tortoise; - size_t len; + Element_Count len; for (tortoise = hare = XCDR (list), len = 1; CONSP (hare); @@ -1015,7 +1015,7 @@ */ (n, list)) { - REGISTER size_t i; + REGISTER EMACS_INT i; REGISTER Lisp_Object tail = list; CHECK_NATNUM (n); for (i = XINT (n); i; i--) @@ -2751,7 +2751,7 @@ else if (VECTORP (array)) { Lisp_Object *p = XVECTOR_DATA (array); - size_t len = XVECTOR_LENGTH (array); + Element_Count len = XVECTOR_LENGTH (array); CHECK_LISP_WRITEABLE (array); while (len--) *p++ = item; @@ -2759,7 +2759,7 @@ else if (BIT_VECTORP (array)) { Lisp_Bit_Vector *v = XBIT_VECTOR (array); - size_t len = bit_vector_length (v); + Element_Count len = bit_vector_length (v); int bit; CHECK_BIT (item); bit = XINT (item); @@ -2798,7 +2798,7 @@ { /* (setcdr (last args[0]) args[1]) */ Lisp_Object tortoise, hare; - size_t count; + Element_Count count; for (hare = tortoise = args[0], count = 0; CONSP (XCDR (hare)); @@ -2867,7 +2867,7 @@ if (CONSP (next) || argnum == nargs -1) { /* (setcdr (last val) next) */ - size_t count; + Element_Count count; for (count = 0; CONSP (XCDR (last_cons)); @@ -2916,7 +2916,7 @@ If VALS is a null pointer, do not accumulate the results. */ static void -mapcar1 (size_t leni, Lisp_Object *vals, +mapcar1 (Element_Count leni, Lisp_Object *vals, Lisp_Object function, Lisp_Object sequence) { Lisp_Object result; @@ -2950,7 +2950,7 @@ if (vals) { Lisp_Object *val = vals; - size_t i; + Element_Count i; LIST_LOOP_2 (elt, sequence) *val++ = elt; @@ -2985,7 +2985,7 @@ else if (VECTORP (sequence)) { Lisp_Object *objs = XVECTOR_DATA (sequence); - size_t i; + Element_Count i; for (i = 0; i < leni; i++) { args[1] = *objs++; @@ -3013,7 +3013,7 @@ else if (BIT_VECTORP (sequence)) { Lisp_Bit_Vector *v = XBIT_VECTOR (sequence); - size_t i; + Element_Count i; for (i = 0; i < leni; i++) { args[1] = make_int (bit_vector_bit (v, i)); @@ -3063,12 +3063,12 @@ */ (function, sequence)) { - size_t len = XINT (Flength (sequence)); + Element_Count len = XINT (Flength (sequence)); Lisp_Object *args = alloca_array (Lisp_Object, len); mapcar1 (len, args, function, sequence); - return Flist (len, args); + return Flist ((int) len, args); } DEFUN ("mapvector", Fmapvector, 2, 2, 0, /* @@ -3078,7 +3078,7 @@ */ (function, sequence)) { - size_t len = XINT (Flength (sequence)); + Element_Count len = XINT (Flength (sequence)); Lisp_Object result = make_vector (len, Qnil); struct gcpro gcpro1; @@ -3599,7 +3599,7 @@ ways these functions can blow up, and we don't want to have memory leaks in those cases. */ #define XMALLOC_OR_ALLOCA(ptr, len, type) do { \ - size_t XOA_len = (len); \ + Element_Count XOA_len = (len); \ if (XOA_len > MAX_ALLOCA) \ { \ ptr = xnew_array (type, XOA_len); \
--- a/src/font-lock.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/font-lock.c Mon Aug 13 04:46:48 2001 +0000 @@ -391,26 +391,32 @@ } } +/* You'd think it wouldn't be necessary to cast something to the type + it's already defined is, but if you're GCC, you apparently think + differently */ #define SYNTAX_START_STYLE(c1, c2) \ + ((enum comment_style) \ (SYNTAX_CODES_MATCH_START_P (c1, c2, SYNTAX_COMMENT_STYLE_A) ? \ comment_style_a : \ SYNTAX_CODES_MATCH_START_P (c1, c2, SYNTAX_COMMENT_STYLE_B) ? \ comment_style_b : \ - comment_style_none) + comment_style_none)) #define SYNTAX_END_STYLE(c1, c2) \ - (SYNTAX_CODES_MATCH_END_P (c1, c2, SYNTAX_COMMENT_STYLE_A) ? \ + ((enum comment_style) \ + (SYNTAX_CODES_MATCH_END_P (c1, c2, SYNTAX_COMMENT_STYLE_A) ? \ comment_style_a : \ SYNTAX_CODES_MATCH_END_P (c1, c2, SYNTAX_COMMENT_STYLE_B) ? \ comment_style_b : \ - comment_style_none) + comment_style_none)) #define SINGLE_SYNTAX_STYLE(c) \ - (SYNTAX_CODE_MATCHES_1CHAR_P (c, SYNTAX_COMMENT_STYLE_A) ? \ + ((enum comment_style) \ + (SYNTAX_CODE_MATCHES_1CHAR_P (c, SYNTAX_COMMENT_STYLE_A) ? \ comment_style_a : \ SYNTAX_CODE_MATCHES_1CHAR_P (c, SYNTAX_COMMENT_STYLE_B) ? \ comment_style_b : \ - comment_style_none) + comment_style_none)) /* Set up context_cache for position PT in BUF. */ @@ -615,8 +621,10 @@ } else if ((SYNTAX_CODE_COMMENT_BITS (syncode) & SYNTAX_SECOND_CHAR_END) && - context_cache.context == context_block_comment && - context_cache.ccontext == ccontext_end1 && + context_cache.context == + (enum syntactic_context) context_block_comment && + context_cache.ccontext == + (enum block_comment_context) ccontext_end1 && SYNTAX_CODES_END_P (prev_syncode, syncode) && /* the two chars match */ context_cache.style ==
--- a/src/frame-x.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/frame-x.c Mon Aug 13 04:46:48 2001 +0000 @@ -705,7 +705,7 @@ static void x_set_initial_frame_size (struct frame *f, int flags, int x, int y, - unsigned int w, unsigned int h) + int w, int h) { char shell_geom [255]; int xval, yval; @@ -1108,7 +1108,7 @@ struct device *d = get_device_from_display (display); struct x_device *xd = DEVICE_X_DATA (d); XWindowAttributes win_attrib; - unsigned int modifier = 0, state = 0; + int modifier = 0, state = 0; char *Ctext; int numItems = 0, textlen = 0, pos = 0; Lisp_Event *lisp_event = XEVENT (event); @@ -1334,9 +1334,9 @@ struct device *d = get_device_from_display (display); struct x_device *xd = DEVICE_X_DATA (d); XWindowAttributes win_attrib; - unsigned int modifier = 0, state = 0; + int modifier = 0, state = 0; char *dnd_data = NULL; - unsigned long dnd_len = 0; + long dnd_len = 0; int dnd_typ = DndText, dnd_dealloc = 0; Lisp_Event *lisp_event = XEVENT (event);
--- a/src/frame.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/frame.h Mon Aug 13 04:46:48 2001 +0000 @@ -105,13 +105,13 @@ /* Size of toolbars as seen by redisplay. This is used to determine whether to re-layout windows by a call to change_frame_size early in redisplay_frame. */ - unsigned int current_toolbar_size[4]; + int current_toolbar_size[4]; #endif /* Size of gutters as seen by redisplay. This is used to determine whether to re-layout windows by a call to change_frame_size early in redisplay_frame. */ - unsigned int current_gutter_bounds[4]; + int current_gutter_bounds[4]; /* Dynamic arrays of display lines for gutters */ display_line_dynarr *current_display_lines[4];
--- a/src/getloadavg.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/getloadavg.c Mon Aug 13 04:46:48 2001 +0000 @@ -674,7 +674,7 @@ desc.sd_subsys = SUBSYS_CPU; desc.sd_type = CPUTYPE_CONFIG; desc.sd_addr = (char *) &conf; - desc.sd_size = sizeof conf; + desc.sd_size = sizeof (conf); if (inq_stats (1, &desc)) return -1; @@ -683,12 +683,12 @@ for (i = 0; i < conf.config_maxclass; ++i) { struct class_stats stats; - memset ((char *) &stats, 0, sizeof stats); + memset ((char *) &stats, 0, sizeof (stats)); desc.sd_type = CPUTYPE_CLASS; desc.sd_objid = i; desc.sd_addr = (char *) &stats; - desc.sd_size = sizeof stats; + desc.sd_size = sizeof (stats); if (inq_stats (1, &desc)) return -1;
--- a/src/gif_io.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/gif_io.c Mon Aug 13 04:46:48 2001 +0000 @@ -1,13 +1,9 @@ #include <config.h> +#include "lisp.h" -#include <stdio.h> -#include <stdlib.h> -#include <string.h> -#ifdef HAVE_UNISTD_H -#include <unistd.h> -#endif +#include "sysfile.h" + #include "gifrlib.h" -#include "sysfile.h" /****************************************************************************** * Set up the GifFileType structure for use. This must be called first in any * @@ -102,13 +98,13 @@ GifSetCloseFunc(GifFile, GifStdFileClose, IOData); } -size_t GifStdRead(GifByteType *buf, size_t size, VoidPtr method_data) +Memory_Count GifStdRead(GifByteType *buf, Memory_Count size, VoidPtr method_data) { GifStdIODataType *IOtype = (GifStdIODataType*)method_data; return (fread(buf, 1, size, IOtype->File)); } -size_t GifStdWrite(GifByteType *buf, size_t size, VoidPtr method_data) +Memory_Count GifStdWrite(GifByteType *buf, Memory_Count size, VoidPtr method_data) { GifStdIODataType *IOtype = (GifStdIODataType*)method_data; return (fwrite(buf, 1, size, IOtype->File)); @@ -124,14 +120,14 @@ return ret; } -void GifRead(GifByteType *buf, size_t size, GifFileType *GifFile) +void GifRead(GifByteType *buf, Memory_Count size, GifFileType *GifFile) { GifIODataType *GifIO = (GifIODataType*)GifFile->GifIO; if ((*(GifIO->ReadFunc))(buf, size, GifIO->ReadFunc_data) != size) GifError(GifFile, "Read error!"); } -void GifWrite(GifByteType *buf, size_t size, GifFileType *GifFile) +void GifWrite(GifByteType *buf, Memory_Count size, GifFileType *GifFile) { GifIODataType *GifIO = (GifIODataType*)GifFile->GifIO; if ((*(GifIO->WriteFunc))(buf, size, GifIO->WriteFunc_data) != size)
--- a/src/gifrlib.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/gifrlib.h Mon Aug 13 04:46:48 2001 +0000 @@ -58,7 +58,7 @@ /* I/O operations. If you roll your own, they need to be semantically equivilent to fread/fwrite, with an additional paramater to hold data local to your method. */ -typedef size_t (*Gif_rw_func)(GifByteType *buffer, size_t size, VoidPtr method_data); +typedef Memory_Count (*Gif_rw_func)(GifByteType *buffer, Memory_Count size, VoidPtr method_data); /* Finish up stream. Non-zero return indicates failure */ typedef int (*Gif_close_func)(VoidPtr close_data); /* Error handling function */ @@ -252,13 +252,13 @@ void GifStdIOInit(GifFileType *GifFile, FILE *file, int filehandle); /* Error checking reads, writes and closes */ -void GifRead(GifByteType *buf, size_t size, GifFileType *GifFile); -void GifWrite(GifByteType *buf, size_t size, GifFileType *GifFile); +void GifRead(GifByteType *buf, Memory_Count size, GifFileType *GifFile); +void GifWrite(GifByteType *buf, Memory_Count size, GifFileType *GifFile); int GifClose(GifFileType *GifFile); /* The default Read and Write functions for files */ -size_t GifStdRead(GifByteType *buf, size_t size, VoidPtr method_data); -size_t GifStdWrite(GifByteType *buf, size_t size, VoidPtr method_data); +Memory_Count GifStdRead(GifByteType *buf, Memory_Count size, VoidPtr method_data); +Memory_Count GifStdWrite(GifByteType *buf, Memory_Count size, VoidPtr method_data); int GifStdFileClose(VoidPtr method_data); ColorMapObject *MakeMapObject(int ColorCount, GifColorType *ColorMap);
--- a/src/glyphs-eimage.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/glyphs-eimage.c Mon Aug 13 04:46:48 2001 +0000 @@ -64,7 +64,9 @@ #ifdef __cplusplus extern "C" { #endif +#define message message_ /* Yuck */ #include <png.h> +#undef message #ifdef __cplusplus } #endif @@ -232,13 +234,12 @@ src = (struct jpeg_source_mgr *) cinfo->src; if (!src) + return; + else if (num_bytes > (long) src->bytes_in_buffer) { - return; - } else if (num_bytes > src->bytes_in_buffer) - { - ERREXIT(cinfo, JERR_INPUT_EOF); - /*NOTREACHED*/ - } + ERREXIT (cinfo, JERR_INPUT_EOF); + /*NOTREACHED*/ + } src->bytes_in_buffer -= num_bytes; src->next_input_byte += num_bytes; @@ -259,7 +260,7 @@ } our_jpeg_source_mgr; static void -jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, unsigned int len) +jpeg_memory_src (j_decompress_ptr cinfo, JOCTET *data, Memory_Count len) { struct jpeg_source_mgr *src; @@ -374,8 +375,8 @@ { Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); - const Extbyte *bytes; - Extcount len; + const UChar_Binary *bytes; + Memory_Count len; /* #### This is a definite problem under Mule due to the amount of stack data it might allocate. Need to be able to convert and @@ -452,16 +453,16 @@ */ (void) jpeg_read_scanlines (&cinfo, row_buffer, 1); jp = row_buffer[0]; - for (i = 0; i < cinfo.output_width; i++) + for (i = 0; i < (int) cinfo.output_width; i++) { int clr; if (jpeg_gray) { unsigned char val; #if (BITS_IN_JSAMPLE == 8) - val = (unsigned char)*jp++; + val = (unsigned char) *jp++; #else /* other option is 12 */ - val = (unsigned char)(*jp++ >> 4); + val = (unsigned char) (*jp++ >> 4); #endif for (clr = 0; clr < 3; clr++) /* copy the same value into RGB */ *op++ = val; @@ -551,32 +552,33 @@ DGifCloseFile (data->giffile); GifFree(data->giffile); } - if (data->eimage) xfree(data->eimage); + if (data->eimage) + xfree (data->eimage); return Qnil; } typedef struct gif_memory_storage { - Extbyte *bytes; /* The data */ - Extcount len; /* How big is it? */ - int index; /* Where are we? */ + UChar_Binary *bytes; /* The data */ + Memory_Count len; /* How big is it? */ + Memory_Count index; /* Where are we? */ } gif_memory_storage; -static size_t -gif_read_from_memory(GifByteType *buf, size_t size, VoidPtr data) +static Memory_Count +gif_read_from_memory (GifByteType *buf, Memory_Count size, VoidPtr data) { - gif_memory_storage *mem = (gif_memory_storage*)data; + gif_memory_storage *mem = (gif_memory_storage *) data; if (size > (mem->len - mem->index)) - return (size_t) -1; - memcpy(buf, mem->bytes + mem->index, size); + return -1; + memcpy (buf, mem->bytes + mem->index, size); mem->index = mem->index + size; return size; } static int -gif_memory_close(VoidPtr data) +gif_memory_close (VoidPtr data) { return 0; } @@ -588,9 +590,9 @@ }; static void -gif_error_func(const char *err_str, VoidPtr error_ptr) +gif_error_func (const char *err_str, VoidPtr error_ptr) { - struct gif_error_struct *error_data = (struct gif_error_struct*)error_ptr; + struct gif_error_struct *error_data = (struct gif_error_struct *) error_ptr; /* return to setjmp point */ error_data->err_str = err_str; @@ -610,8 +612,8 @@ int speccount = specpdl_depth (); gif_memory_storage mem_struct; struct gif_error_struct gif_err; - Extbyte *bytes; - Extcount len; + UChar_Binary *bytes; + Memory_Count len; int height = 0; int width = 0; @@ -773,21 +775,21 @@ struct png_memory_storage { - const Extbyte *bytes; /* The data */ - Extcount len; /* How big is it? */ - int index; /* Where are we? */ + const UChar_Binary *bytes; /* The data */ + Memory_Count len; /* How big is it? */ + Memory_Count index; /* Where are we? */ }; static void -png_read_from_memory(png_structp png_ptr, png_bytep data, - png_size_t length) +png_read_from_memory (png_structp png_ptr, png_bytep data, + png_size_t length) { struct png_memory_storage *tbr = (struct png_memory_storage *) png_get_io_ptr (png_ptr); - if (length > (tbr->len - tbr->index)) + if ((Memory_Count) length > (tbr->len - tbr->index)) png_error (png_ptr, (png_const_charp) "Read Error"); - memcpy (data,tbr->bytes + tbr->index,length); + memcpy (data, tbr->bytes + tbr->index,length); tbr->index = tbr->index + length; } @@ -897,8 +899,8 @@ /* Initialize the IO layer and read in header information */ { Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); - const Extbyte *bytes; - Extcount len; + const UChar_Binary *bytes; + Memory_Count len; assert (!NILP (data)); @@ -1084,47 +1086,50 @@ typedef struct tiff_memory_storage { - Extbyte *bytes; /* The data */ - Extcount len; /* How big is it? */ - int index; /* Where are we? */ + UChar_Binary *bytes; /* The data */ + Memory_Count len; /* How big is it? */ + Memory_Count index; /* Where are we? */ } tiff_memory_storage; static size_t -tiff_memory_read(thandle_t data, tdata_t buf, tsize_t size) +tiff_memory_read (thandle_t data, tdata_t buf, tsize_t size) { - tiff_memory_storage *mem = (tiff_memory_storage*)data; + tiff_memory_storage *mem = (tiff_memory_storage *) data; - if (size > (mem->len - mem->index)) + if ((Memory_Count) size > (mem->len - mem->index)) return (size_t) -1; - memcpy(buf, mem->bytes + mem->index, size); + memcpy (buf, mem->bytes + mem->index, size); mem->index = mem->index + size; return size; } -static size_t tiff_memory_write(thandle_t data, tdata_t buf, tsize_t size) +static size_t +tiff_memory_write (thandle_t data, tdata_t buf, tsize_t size) { abort(); return 0; /* Shut up warnings. */ } -static toff_t tiff_memory_seek(thandle_t data, toff_t off, int whence) +static toff_t +tiff_memory_seek (thandle_t data, toff_t off, int whence) { - tiff_memory_storage *mem = (tiff_memory_storage*)data; + tiff_memory_storage *mem = (tiff_memory_storage *) data; int newidx; - switch(whence) { - case SEEK_SET: - newidx = off; - break; - case SEEK_END: - newidx = mem->len + off; - break; - case SEEK_CUR: - newidx = mem->index + off; - break; - default: - fprintf(stderr,"Eh? invalid seek mode in tiff_memory_seek\n"); - return (toff_t) -1; - } + switch(whence) + { + case SEEK_SET: + newidx = off; + break; + case SEEK_END: + newidx = mem->len + off; + break; + case SEEK_CUR: + newidx = mem->index + off; + break; + default: + fprintf (stderr, "Eh? invalid seek mode in tiff_memory_seek\n"); + return (toff_t) -1; + } if ((newidx > mem->len) || (newidx < 0)) return (toff_t) -1; @@ -1134,25 +1139,25 @@ } static int -tiff_memory_close(thandle_t data) +tiff_memory_close (thandle_t data) { return 0; } static int -tiff_map_noop(thandle_t data, tdata_t* pbase, toff_t* psize) +tiff_map_noop (thandle_t data, tdata_t* pbase, toff_t* psize) { return 0; } static void -tiff_unmap_noop(thandle_t data, tdata_t pbase, toff_t psize) +tiff_unmap_noop (thandle_t data, tdata_t pbase, toff_t psize) { return; } static toff_t -tiff_memory_size(thandle_t data) +tiff_memory_size (thandle_t data) { tiff_memory_storage *mem = (tiff_memory_storage*)data; return mem->len; @@ -1175,7 +1180,7 @@ static struct tiff_error_struct tiff_err_data; static void -tiff_error_func(const char *module, const char *fmt, ...) +tiff_error_func (const char *module, const char *fmt, ...) { va_list vargs; @@ -1192,7 +1197,7 @@ } static void -tiff_warning_func(const char *module, const char *fmt, ...) +tiff_warning_func (const char *module, const char *fmt, ...) { va_list vargs; #ifdef HAVE_VSNPRINTF @@ -1242,8 +1247,8 @@ TIFFSetWarningHandler ((TIFFErrorHandler)tiff_warning_func); { Lisp_Object data = find_keyword_in_vector (instantiator, Q_data); - Extbyte *bytes; - Extcount len; + UChar_Binary *bytes; + Memory_Count len; uint32 *raster; unsigned char *ep; @@ -1277,7 +1282,7 @@ raster = (uint32*) _TIFFmalloc (width * height * sizeof (uint32)); if (raster != NULL) { - int i,j; + int i, j; uint32 *rp; ep = unwind.eimage; rp = raster; @@ -1288,7 +1293,7 @@ /* This is to get around weirdness in the libtiff library where properly made TIFFs will come out upside down. libtiff bug or jhod-brainlock? */ rp = raster + (i * width); - for (j = 0; j < width; j++) + for (j = 0; j < (int) width; j++) { *ep++ = (unsigned char)TIFFGetR(*rp); *ep++ = (unsigned char)TIFFGetG(*rp);
--- a/src/glyphs-msw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/glyphs-msw.c Mon Aug 13 04:46:48 2001 +0000 @@ -853,7 +853,7 @@ return 0; } - for (i=0; i<xpmimage.ncolors; i++) + for (i=0; i<(int)xpmimage.ncolors; i++) { /* goto alert!!!! */ /* pick up symbolic colors in preference */ @@ -1217,7 +1217,7 @@ int dest_mask, Lisp_Object domain) { Lisp_Image_Instance *ii = XIMAGE_INSTANCE (image_instance); - unsigned int type = 0; + int type = 0; HANDLE himage = NULL; LPCTSTR resid=0; HINSTANCE hinst = NULL; @@ -1378,7 +1378,7 @@ black, 1 = white. */ static HBITMAP xbm_create_bitmap_from_data (HDC hdc, const UChar_Binary *data, - unsigned int width, unsigned int height, + int width, int height, int mask, COLORREF fg, COLORREF bg) { int old_width = (width + 7)/8; @@ -2151,7 +2151,7 @@ return 1; } -static unsigned long +static Hash_Code mswindows_image_instance_hash (Lisp_Image_Instance *p, int depth) { switch (IMAGE_INSTANCE_TYPE (p)) @@ -2159,7 +2159,7 @@ case IMAGE_MONO_PIXMAP: case IMAGE_COLOR_PIXMAP: case IMAGE_POINTER: - return (unsigned long) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p); + return (Hash_Code) IMAGE_INSTANCE_MSWINDOWS_BITMAP (p); default: return 0;
--- a/src/glyphs-shared.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/glyphs-shared.c Mon Aug 13 04:46:48 2001 +0000 @@ -188,21 +188,20 @@ * like the Xlib routine XReadBitmapfile as possible. */ static int -read_bitmap_data (FILE *fstream, unsigned int *width, - unsigned int *height, UChar_Binary **datap, +read_bitmap_data (FILE *fstream, int *width, int *height, UChar_Binary **datap, int *x_hot, int *y_hot) { UChar_Binary *data = NULL; /* working variable */ - char line[MAX_SIZE]; /* input line from file */ + Char_ASCII line[MAX_SIZE]; /* input line from file */ int size; /* number of bytes of data */ - char name_and_type[MAX_SIZE]; /* an input line */ - char *type; /* for parsing */ + Char_ASCII name_and_type[MAX_SIZE]; /* an input line */ + Char_ASCII *type; /* for parsing */ int value; /* from an input line */ int version10p; /* boolean, old format */ int padding; /* to handle alignment */ int bytes_per_line; /* per scanline of data */ - unsigned int ww = 0; /* width */ - unsigned int hh = 0; /* height */ + int ww = 0; /* width */ + int hh = 0; /* height */ int hx = -1; /* x hotspot */ int hy = -1; /* y hotspot */ @@ -227,9 +226,9 @@ type++; if (!strcmp("width", type)) - ww = (unsigned int) value; + ww = value; if (!strcmp("height", type)) - hh = (unsigned int) value; + hh = value; if (!strcmp("hot", type)) { if (type-- == name_and_type || type-- == name_and_type) continue; @@ -315,17 +314,16 @@ int read_bitmap_data_from_file (const char *filename, /* Remaining args are RETURNED */ - unsigned int *width, - unsigned int *height, + int *width, + int *height, UChar_Binary **datap, int *x_hot, int *y_hot) { FILE *fstream; int status; - if ((fstream = fopen (filename, "r")) == NULL) { - return BitmapOpenFailed; - } + if ((fstream = fopen (filename, "r")) == NULL) + return BitmapOpenFailed; status = read_bitmap_data (fstream, width, height, datap, x_hot, y_hot); fclose (fstream); return status;
--- a/src/glyphs-x.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/glyphs-x.c Mon Aug 13 04:46:48 2001 +0000 @@ -506,7 +506,7 @@ return 1; } -static unsigned long +static Hash_Code x_image_instance_hash (Lisp_Image_Instance *p, int depth) { switch (IMAGE_INSTANCE_TYPE (p)) @@ -704,7 +704,7 @@ /* Get the data while doing the conversion */ while (1) { - Lstream_data_count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); + Lstream_Data_Count size_in_bytes = Lstream_read (istr, tempbuf, sizeof (tempbuf)); if (!size_in_bytes) break; /* It does seem the flushes are necessary... */ @@ -756,7 +756,7 @@ message. */ static void -check_pointer_sizes (Screen *xs, unsigned int width, unsigned int height, +check_pointer_sizes (Screen *xs, int width, int height, Lisp_Object instantiator) { unsigned int best_width, best_height; @@ -766,7 +766,7 @@ these so they're not fatal). */ gui_error ("XQueryBestCursor() failed?", instantiator); - if (width > best_width || height > best_height) + if (width > (int) best_width || height > (int) best_height) signal_ferror_with_frob (Qgui_error, instantiator, "pointer too large (%dx%d): " "server requires %dx%d or smaller", @@ -1313,7 +1313,7 @@ Q_color_symbols); enum image_instance_type type; int force_mono; - unsigned int w, h; + int w, h; if (!DEVICE_X_P (XDEVICE (device))) gui_error ("Not an X device", device); @@ -2293,8 +2293,7 @@ Window pw, win; XSetWindowAttributes xswa; Mask valueMask = 0; - unsigned int w = IMAGE_INSTANCE_WIDTH (ii), - h = IMAGE_INSTANCE_HEIGHT (ii); + int w = IMAGE_INSTANCE_WIDTH (ii), h = IMAGE_INSTANCE_HEIGHT (ii); if (!DEVICE_X_P (XDEVICE (device))) gui_error ("Not an X device", device);
--- a/src/glyphs.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/glyphs.c Mon Aug 13 04:46:48 2001 +0000 @@ -1189,16 +1189,16 @@ return DOMAIN_LIVE_P (XIMAGE_INSTANCE_DOMAIN (instance)); } -static unsigned long +static Hash_Code image_instance_hash (Lisp_Object obj, int depth) { Lisp_Image_Instance *i = XIMAGE_INSTANCE (obj); - unsigned long hash = HASH5 (LISP_HASH (IMAGE_INSTANCE_DOMAIN (i)), - IMAGE_INSTANCE_WIDTH (i), - IMAGE_INSTANCE_MARGIN_WIDTH (i), - IMAGE_INSTANCE_HEIGHT (i), - internal_hash (IMAGE_INSTANCE_INSTANTIATOR (i), - depth + 1)); + Hash_Code hash = HASH5 (LISP_HASH (IMAGE_INSTANCE_DOMAIN (i)), + IMAGE_INSTANCE_WIDTH (i), + IMAGE_INSTANCE_MARGIN_WIDTH (i), + IMAGE_INSTANCE_HEIGHT (i), + internal_hash (IMAGE_INSTANCE_INSTANTIATOR (i), + depth + 1)); ERROR_CHECK_IMAGE_INSTANCE (obj); @@ -2586,7 +2586,7 @@ bitmap_to_lisp_data (Lisp_Object name, int *xhot, int *yhot, int ok_if_data_invalid) { - unsigned int w, h; + int w, h; Extbyte *data; int result; const char *filename_ext; @@ -3088,7 +3088,7 @@ return 0; } -static hashcode_t +static Hash_Code instantiator_eq_hash (Lisp_Object obj) { if (CONSP (obj)) @@ -3610,7 +3610,7 @@ !plists_differ (g1->plist, g2->plist, 0, 0, depth + 1)); } -static unsigned long +static Hash_Code glyph_hash (Lisp_Object obj, int depth) { depth++; @@ -4427,8 +4427,7 @@ } *the_expose_ignore_blocktype; int -check_for_ignored_expose (struct frame* f, unsigned int x, unsigned int y, - unsigned int width, unsigned int height) +check_for_ignored_expose (struct frame* f, int x, int y, int width, int height) { struct expose_ignore *ei, *prev; /* the ignore list is FIFO so we should generally get a match with @@ -4500,9 +4499,8 @@ See if there is a subwindow that completely encloses the requested area. ****************************************************************************/ -int find_matching_subwindow (struct frame* f, unsigned int x, - unsigned int y, unsigned int width, - unsigned int height) +int +find_matching_subwindow (struct frame* f, int x, int y, int width, int height) { Lisp_Object rest;
--- a/src/glyphs.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/glyphs.h Mon Aug 13 04:46:48 2001 +0000 @@ -300,19 +300,19 @@ DECLARE_IMAGE_INSTANTIATOR_FORMAT(format); \ struct image_instantiator_methods *type##_##format##_image_instantiator_methods -#define INITIALIZE_DEVICE_IIFORMAT(type, format) \ -do { \ - type##_##format##_image_instantiator_methods = \ - xnew_and_zero (struct image_instantiator_methods); \ - type##_##format##_image_instantiator_methods->symbol = Q##format; \ - type##_##format##_image_instantiator_methods->device = Q##type; \ - type##_##format##_image_instantiator_methods->keywords = \ - Dynarr_new (ii_keyword_entry); \ - add_entry_to_device_ii_format_list \ - (Q##type, Q##format, type##_##format##_image_instantiator_methods); \ - IIFORMAT_VALID_CONSOLE(type,format); \ - dump_add_root_struct_ptr (&type##_##format##_image_instantiator_methods, \ - &iim_description); \ +#define INITIALIZE_DEVICE_IIFORMAT(type, format) \ +do { \ + type##_##format##_image_instantiator_methods = \ + xnew_and_zero (struct image_instantiator_methods); \ + type##_##format##_image_instantiator_methods->symbol = Q##format; \ + type##_##format##_image_instantiator_methods->device = Q##type; \ + type##_##format##_image_instantiator_methods->keywords = \ + Dynarr_new (ii_keyword_entry); \ + add_entry_to_device_ii_format_list \ + (Q##type, Q##format, type##_##format##_image_instantiator_methods); \ + IIFORMAT_VALID_CONSOLE(type,format); \ + dump_add_root_struct_ptr (&type##_##format##_image_instantiator_methods, \ + &iim_description); \ } while (0) /* Declare that image-instantiator format FORMAT has method M; used in @@ -548,11 +548,11 @@ /* The instantiator from which we were instantiated. */ Lisp_Object instantiator; enum image_instance_type type; - unsigned int x_offset, y_offset; /* for layout purposes */ + int x_offset, y_offset; /* for layout purposes */ int width, height, margin_width; - unsigned long display_hash; /* Hash value representing the structure - of the image_instance when it was - last displayed. */ + Hash_Code display_hash; /* Hash value representing the structure + of the image_instance when it was + last displayed. */ unsigned int dirty : 1; unsigned int size_changed : 1; unsigned int text_changed : 1; @@ -565,13 +565,13 @@ { struct { - unsigned int descent; + int descent; Lisp_Object string; } text; struct { - unsigned int depth; - unsigned int slice, maxslice, timeout; + int depth; + int slice, maxslice, timeout; Lisp_Object hotspot_x, hotspot_y; /* integer or Qnil */ Lisp_Object filename; /* string or Qnil */ Lisp_Object mask_filename; /* string or Qnil */ @@ -588,8 +588,8 @@ struct { /* We need these so we can do without subwindow_cachel */ - unsigned int x, y; - unsigned int width, height; + int x, y; + int width, height; } display_data; unsigned int being_displayed : 1; /* used to detect when needs to be unmapped */ @@ -894,8 +894,8 @@ #ifdef HAVE_WINDOW_SYSTEM Lisp_Object bitmap_to_lisp_data (Lisp_Object name, int *xhot, int *yhot, int ok_if_data_invalid); -int read_bitmap_data_from_file (const char *filename, unsigned int *width, - unsigned int *height, unsigned char **datap, +int read_bitmap_data_from_file (const char *filename, int *width, + int *height, unsigned char **datap, int *x_hot, int *y_hot); Lisp_Object xbm_mask_file_munging (Lisp_Object alist, Lisp_Object file, Lisp_Object mask_file, @@ -1137,9 +1137,8 @@ void unmap_subwindow (Lisp_Object subwindow); void map_subwindow (Lisp_Object subwindow, int x, int y, struct display_glyph_area *dga); -int find_matching_subwindow (struct frame* f, - unsigned int x, unsigned int y, - unsigned int width, unsigned int height); +int find_matching_subwindow (struct frame* f, int x, int y, int width, + int height); void redisplay_widget (Lisp_Object widget); void update_widget_instances (Lisp_Object frame); void redisplay_subwindow (Lisp_Object subwindow); @@ -1152,14 +1151,13 @@ struct expose_ignore { - unsigned int x, y; - unsigned int width, height; + int x, y; + int width, height; struct expose_ignore *next; }; -int check_for_ignored_expose (struct frame* f, unsigned int x, - unsigned int y, unsigned int width, - unsigned int height); +int check_for_ignored_expose (struct frame* f, int x, int y, int width, + int height); extern int hold_ignored_expose_registration; #endif /* INCLUDED_glyphs_h_ */
--- a/src/gmalloc.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/gmalloc.c Mon Aug 13 04:46:48 2001 +0000 @@ -869,7 +869,8 @@ prev = (struct list *) ((char *) ADDRESS (block) + (_heapinfo[block].busy.info.frag.first << type)); - if (_heapinfo[block].busy.info.frag.nfree == (BLOCKSIZE >> type) - 1) + if (_heapinfo[block].busy.info.frag.nfree == + (__malloc_size_t) ((BLOCKSIZE >> type) - 1)) { /* If all fragments of this block are free, remove them from the fragment list and free the whole block. */
--- a/src/gpmevent.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/gpmevent.c Mon Aug 13 04:46:48 2001 +0000 @@ -267,8 +267,8 @@ while (1) { Bufbyte tempbuf[1024]; /* some random amount */ - Lstream_data_count i; - Lstream_data_count size_in_bytes = + Lstream_Data_Count i; + Lstream_Data_Count size_in_bytes = Lstream_read (XLSTREAM (terminal_stream), tempbuf, sizeof (tempbuf));
--- a/src/gui-x.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/gui-x.c Mon Aug 13 04:46:48 2001 +0000 @@ -43,7 +43,7 @@ #include "opaque.h" /* we need a unique id for each popup menu, dialog box, and scrollbar */ -static unsigned int lwlib_id_tick; +static LWLIB_ID lwlib_id_tick; LWLIB_ID new_lwlib_id (void) @@ -371,7 +371,7 @@ LISP_STRING_TO_EXTERNAL_MALLOC (string, retval, Qlwlib_encoding); else { - size_t namelen = XSTRING_LENGTH (string); + Bytecount namelen = XSTRING_LENGTH (string); Bufbyte *chars = (Bufbyte *) alloca (namelen + 3); chars[0] = '%'; chars[1] = '_';
--- a/src/gui.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/gui.c Mon Aug 13 04:46:48 2001 +0000 @@ -501,7 +501,7 @@ * Return value is the offset to the terminating null character into the * buffer. */ -unsigned int +Bytecount gui_item_display_flush_left (Lisp_Object gui_item, char *buf, Bytecount buf_len) { @@ -550,7 +550,7 @@ * Return value is the offset to the terminating null character into the * buffer. */ -unsigned int +Bytecount gui_item_display_flush_right (Lisp_Object gui_item, char *buf, Bytecount buf_len) { @@ -616,7 +616,7 @@ return Qnil; } -static unsigned long +static Hash_Code gui_item_hash (Lisp_Object obj, int depth) { Lisp_Gui_Item *p = XGUI_ITEM (obj);
--- a/src/gui.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/gui.h Mon Aug 13 04:46:48 2001 +0000 @@ -84,10 +84,10 @@ Lisp_Object gui_item_accelerator (Lisp_Object gui_item); Lisp_Object gui_name_accelerator (Lisp_Object name); int gui_item_id_hash (Lisp_Object, Lisp_Object gui_item, int); -unsigned int gui_item_display_flush_left (Lisp_Object pgui_item, - char* buf, Bytecount buf_len); -unsigned int gui_item_display_flush_right (Lisp_Object gui_item, - char* buf, Bytecount buf_len); +Bytecount gui_item_display_flush_left (Lisp_Object pgui_item, + char* buf, Bytecount buf_len); +Bytecount gui_item_display_flush_right (Lisp_Object gui_item, + char* buf, Bytecount buf_len); Lisp_Object allocate_gui_item (void); void gui_item_init (Lisp_Object gui_item);
--- a/src/hash.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/hash.c Mon Aug 13 04:46:48 2001 +0000 @@ -31,19 +31,19 @@ #define KEYS_DIFFER_P(old, new, testfun) \ (((old) != (new)) && (!(testfun) || !(testfun) ((old),(new)))) -static void rehash (hentry *harray, struct hash_table *ht, hash_size_t size); +static void rehash (hentry *harray, struct hash_table *ht, Element_Count size); -unsigned long -memory_hash (const void *xv, size_t size) +Hash_Code +memory_hash (const void *xv, Memory_Count size) { - unsigned int h = 0; + Hash_Code h = 0; unsigned const char *x = (unsigned const char *) xv; if (!x) return 0; while (size--) { - unsigned int g; + Hash_Code g; h = (h << 4) + *x++; if ((g = h & 0xf0000000) != 0) h = (h ^ (g >> 24)) ^ g; @@ -52,17 +52,17 @@ return h; } -unsigned long +Hash_Code string_hash (const char *xv) { - unsigned int h = 0; + Hash_Code h = 0; unsigned const char *x = (unsigned const char *) xv; if (!x) return 0; while (*x) { - unsigned int g; + Hash_Code g; h = (h << 4) + *x++; if ((g = h & 0xf0000000) != 0) h = (h ^ (g >> 24)) ^ g; @@ -72,13 +72,13 @@ } /* Return a suitable size for a hash table, with at least SIZE slots. */ -static size_t -hash_table_size (size_t requested_size) +static Element_Count +hash_table_size (Element_Count requested_size) { /* Return some prime near, but greater than or equal to, SIZE. Decades from the time of writing, someone will have a system large enough that the list below will be too short... */ - static const size_t primes [] = + static const Element_Count primes [] = { 19, 29, 41, 59, 79, 107, 149, 197, 263, 347, 457, 599, 787, 1031, 1361, 1777, 2333, 3037, 3967, 5167, 6719, 8737, 11369, 14783, @@ -88,7 +88,7 @@ 10445899, 13579681, 17653589, 22949669, 29834603, 38784989, 50420551, 65546729, 85210757, 110774011, 144006217, 187208107, 243370577, 316381771, 411296309, 534685237, 695090819, 903618083, - 1174703521, 1527114613, 1985248999, 2580823717UL, 3355070839UL + 1174703521, 1527114613, 1985248999 /* , 2580823717UL, 3355070839UL */ }; /* We've heard of binary search. */ int low, high; @@ -116,12 +116,12 @@ { hentry *harray = hash_table->harray; hash_table_test_function test_function = hash_table->test_function; - hash_size_t size = hash_table->size; - unsigned int hcode_initial = + Element_Count size = hash_table->size; + Hash_Code hcode_initial = hash_table->hash_function ? hash_table->hash_function (key) : - (unsigned long) key; - unsigned int hcode = hcode_initial % size; + (Hash_Code) key; + Element_Count hcode = (Element_Count) (hcode_initial % size); hentry *e = &harray [hcode]; const void *e_key = e->key; @@ -129,8 +129,8 @@ KEYS_DIFFER_P (e_key, key, test_function) : e->contents == NULL_ENTRY) { - size_t h2 = size - 2; - unsigned int incr = 1 + (hcode_initial % h2); + Element_Count h2 = size - 2; + Element_Count incr = (Element_Count) (1 + (hcode_initial % h2)); do { hcode += incr; if (hcode >= size) hcode -= size; @@ -164,7 +164,7 @@ } struct hash_table* -make_hash_table (hash_size_t size) +make_hash_table (Element_Count size) { struct hash_table *hash_table = xnew_and_zero (struct hash_table); hash_table->size = hash_table_size (COMFORTABLE_SIZE (size)); @@ -174,7 +174,7 @@ } struct hash_table * -make_general_hash_table (hash_size_t size, +make_general_hash_table (Element_Count size, hash_table_hash_function hash_function, hash_table_test_function test_function) { @@ -185,9 +185,9 @@ } static void -grow_hash_table (struct hash_table *hash_table, hash_size_t new_size) +grow_hash_table (struct hash_table *hash_table, Element_Count new_size) { - hash_size_t old_size = hash_table->size; + Element_Count old_size = hash_table->size; hentry *old_harray = hash_table->harray; hash_table->size = hash_table_size (new_size); @@ -217,15 +217,15 @@ else { hash_table_test_function test_function = hash_table->test_function; - hash_size_t size = hash_table->size; + Element_Count size = hash_table->size; hentry *harray = hash_table->harray; - unsigned int hcode_initial = + Hash_Code hcode_initial = hash_table->hash_function ? hash_table->hash_function (key) : - (unsigned long) key; - unsigned int hcode = hcode_initial % size; - size_t h2 = size - 2; - unsigned int incr = 1 + (hcode_initial % h2); + (Hash_Code) key; + Element_Count hcode = (Element_Count) (hcode_initial % size); + Element_Count h2 = size - 2; + Element_Count incr = (Element_Count) (1 + (hcode_initial % h2)); const void *e_key = harray [hcode].key; const void *oldcontents; @@ -268,7 +268,7 @@ /* only increment the fullness when we used up a new hentry */ if (!e_key || KEYS_DIFFER_P (e_key, key, test_function)) { - hash_size_t comfortable_size = COMFORTABLE_SIZE (++(hash_table->fullness)); + Element_Count comfortable_size = COMFORTABLE_SIZE (++(hash_table->fullness)); if (hash_table->size < comfortable_size) grow_hash_table (hash_table, comfortable_size + 1); } @@ -276,7 +276,7 @@ } static void -rehash (hentry *harray, struct hash_table *hash_table, hash_size_t size) +rehash (hentry *harray, struct hash_table *hash_table, Element_Count size) { hentry *limit = harray + size; hentry *e; @@ -299,12 +299,12 @@ { hentry *harray = hash_table->harray; hash_table_test_function test_function = hash_table->test_function; - hash_size_t size = hash_table->size; - unsigned int hcode_initial = + Element_Count size = hash_table->size; + Hash_Code hcode_initial = (hash_table->hash_function) ? (hash_table->hash_function (key)) : - ((unsigned long) key); - unsigned int hcode = hcode_initial % size; + ((Hash_Code) key); + Element_Count hcode = (Element_Count) (hcode_initial % size); hentry *e = &harray [hcode]; const void *e_key = e->key; @@ -312,8 +312,8 @@ KEYS_DIFFER_P (e_key, key, test_function) : e->contents == NULL_ENTRY) { - size_t h2 = size - 2; - unsigned int incr = 1 + (hcode_initial % h2); + Element_Count h2 = size - 2; + Element_Count incr = (Element_Count) (1 + (hcode_initial % h2)); do { hcode += incr; if (hcode >= size) hcode -= size;
--- a/src/hash.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/hash.h Mon Aug 13 04:46:48 2001 +0000 @@ -27,28 +27,27 @@ } hentry; typedef int (*hash_table_test_function) (const void *, const void *); -typedef unsigned long (*hash_table_hash_function) (const void *); -typedef size_t hash_size_t; +typedef Hash_Code (*hash_table_hash_function) (const void *); struct hash_table { hentry *harray; long zero_set; void *zero_entry; - hash_size_t size; /* size of the hasharray */ - hash_size_t fullness; /* number of entries in the hash table */ + Element_Count size; /* size of the hasharray */ + Element_Count fullness; /* number of entries in the hash table */ hash_table_hash_function hash_function; hash_table_test_function test_function; }; /* SIZE is the number of initial entries. The hash table will be grown automatically if the number of entries approaches the size */ -struct hash_table *make_hash_table (hash_size_t size); +struct hash_table *make_hash_table (Element_Count size); struct hash_table * -make_general_hash_table (hash_size_t size, - hash_table_hash_function hash_function, - hash_table_test_function test_function); +make_general_hash_table (Element_Count size, + hash_table_hash_function hash_function, + hash_table_test_function test_function); /* Clear HASH-TABLE. A freshly created hash table is already cleared up. */ void clrhash (struct hash_table *hash_table);
--- a/src/hftctl.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/hftctl.c Mon Aug 13 04:46:48 2001 +0000 @@ -44,7 +44,8 @@ /***************************************************************/ #include <config.h> -#include "lisp.h" /* encapsulated open, close, read, write */ +#include "lisp.h" +#include "sysfile.h" #include <sys/signal.h> #include <errno.h> @@ -104,7 +105,7 @@ /* read a buffer */ #define RD_BUF(f,p,l) \ while ((l)) \ - if ((j = read((f),(p),(l))) < 0) \ + if ((j = read ((f),(p),(l))) < 0) \ if (errno != EINTR) return (-1); \ else continue; \ else { (l) -= j; (p) += j; }
--- a/src/imgproc.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/imgproc.c Mon Aug 13 04:46:48 2001 +0000 @@ -45,12 +45,12 @@ #include "imgproc.h" static void -get_histogram(quant_table *qt, unsigned char *pic, +get_histogram(quant_table *qt, UChar_Binary *pic, int width, int height, Colorbox* box) { - register unsigned char *inptr; + register UChar_Binary *inptr; register int red, green, blue; - register unsigned int j, i; + register int j, i; box->rmin = box->gmin = box->bmin = 999; box->rmax = box->gmax = box->bmax = -1; @@ -472,7 +472,7 @@ } quant_table * -build_EImage_quantable(unsigned char *eimage, int width, int height, int num_colors) +build_EImage_quantable(UChar_Binary *eimage, int width, int height, int num_colors) { quant_table *qt; Colorbox *box_list, *ptr;
--- a/src/insdel.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/insdel.c Mon Aug 13 04:46:48 2001 +0000 @@ -355,7 +355,7 @@ { /* optimize for successive characters from the same charset */ Bufbyte leading_byte = *ptr; - size_t bytes = REP_BYTES_BY_FIRST_BYTE (leading_byte); + Memory_Count bytes = REP_BYTES_BY_FIRST_BYTE (leading_byte); while ((ptr < end) && (*ptr == leading_byte)) ptr += bytes, count++; }
--- a/src/keymap.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/keymap.c Mon Aug 13 04:46:48 2001 +0000 @@ -751,7 +751,7 @@ /************************************************************************/ static Lisp_Object -make_keymap (size_t size) +make_keymap (Element_Count size) { Lisp_Object result; Lisp_Keymap *keymap = alloc_lcrecord_type (Lisp_Keymap, &lrecord_keymap); @@ -773,7 +773,8 @@ /* Inverse table is often less dense because of duplicate key-bindings. If not, it will grow anyway. */ keymap->inverse_table = - make_lisp_hash_table (size * 3 / 4, HASH_TABLE_NON_WEAK, HASH_TABLE_EQ); + make_lisp_hash_table (size * 3 / 4, HASH_TABLE_NON_WEAK, + HASH_TABLE_EQ); } return result; } @@ -2242,7 +2243,7 @@ struct relevant_maps { int nmaps; - unsigned int max_maps; + int max_maps; Lisp_Object *maps; struct gcpro *gcpro; }; @@ -2257,7 +2258,7 @@ static void relevant_map_push (Lisp_Object map, struct relevant_maps *closure) { - unsigned int nmaps = closure->nmaps; + int nmaps = closure->nmaps; if (!KEYMAPP (map)) return;
--- a/src/line-number.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/line-number.c Mon Aug 13 04:46:48 2001 +0000 @@ -168,7 +168,7 @@ /* We could also count how many newlines there are in the string and update the cache accordingly, but it would be too much work for too little gain. */ - memchr ((void *)nonreloc, '\n', (size_t) length)) + memchr ((void *)nonreloc, '\n', length)) invalidate_line_number_cache (b, pos); }
--- a/src/linuxplay.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/linuxplay.c Mon Aug 13 04:46:48 2001 +0000 @@ -285,7 +285,7 @@ if (!data || length < HEADERSZ) { if (fd < 0) return 0; else { - length = read(fd,sndbuf,SNDBUFSZ); + length = read (fd,sndbuf,SNDBUFSZ); if (length < HEADERSZ) return 0; data = sndbuf;
--- a/src/lisp.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/lisp.h Mon Aug 13 04:46:48 2001 +0000 @@ -45,6 +45,124 @@ #include <sys/types.h> #include <limits.h> +/* ------------------------ definition of EMACS_INT ------------------- */ + +/* EMACS_INT is the underlying integral type into which a Lisp_Object must fit. + In particular, it must be large enough to contain a pointer. + config.h can override this, e.g. to use `long long' for bigger lisp ints. + + #### In point of fact, it would NOT be a good idea for config.h to mess + with EMACS_INT. A lot of code makes the basic assumption that EMACS_INT + is the size of a pointer. */ + +#ifndef SIZEOF_EMACS_INT +# define SIZEOF_EMACS_INT SIZEOF_VOID_P +#endif + +#ifndef EMACS_INT +# if SIZEOF_EMACS_INT == SIZEOF_LONG +# define EMACS_INT long +# elif SIZEOF_EMACS_INT == SIZEOF_INT +# define EMACS_INT int +# elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG +# define EMACS_INT long long +# else +# error Unable to determine suitable type for EMACS_INT +# endif +#endif + +#ifndef EMACS_UINT +# define EMACS_UINT unsigned EMACS_INT +#endif + +#define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR) + +/* ------------------------ basic char/int typedefs ------------------- */ + +/* The definitions we put here use typedefs to attribute specific meaning + to types that by themselves are pretty general. Stuff pointed to by a + char * or unsigned char * will nearly always be one of four types: + a) pointer to internally-formatted text; b) pointer to text in some + external format, which can be defined as all formats other than the + internal one; c) pure ASCII text; d) binary data that is not meant to + be interpreted as text. [A fifth possible type "e) a general pointer + to memory" should be replaced with void *.] Using these more specific + types rather than the general ones helps avoid the confusions that + occur when the semantics of a char * argument being studied are unclear. + + Note that these typedefs are purely for documentation purposes; from + the C code's perspective, they are exactly equivalent to `char *', + `unsigned char *', etc., so you can freely use them with library + functions declared as such. */ + +/* The data representing the text in a buffer is logically a set + of Bufbytes, declared as follows. */ + +typedef unsigned char Bufbyte; + +/* The following should be used when you are working with internal data + but for whatever reason need to have it declared a "char *". Examples + are function arguments whose values are most commonly literal strings, + or where you have to apply a stdlib string function to internal data. + + In general, you should avoid this where possible and use Bufbyte instead, + for consistency. For example, the new Mule workspace contains + Bufbyte versions of the stdlib string functions. */ + +typedef char CBufbyte; + +/* The data representing a string in "external" format (binary or any + external encoding) is logically a set of Extbytes, declared as + follows. Extbyte is guaranteed to be just a char, so for example + strlen (Extbyte *) is OK. Extbyte is only a documentation device + for referring to external text. */ + +typedef char Extbyte; + +/* A byte in a string in binary format: */ +typedef char Char_Binary; +typedef signed char SChar_Binary; +typedef unsigned char UChar_Binary; + +/* A byte in a string in entirely US-ASCII format: (Nothing outside + the range 00 - 7F) */ + +typedef char Char_ASCII; +typedef unsigned char UChar_ASCII; + + +/* To the user, a buffer is made up of characters, declared as follows. + In the non-Mule world, characters and Bufbytes are equivalent. + In the Mule world, a character requires (typically) 1 to 4 + Bufbytes for its representation in a buffer. */ + +typedef int Emchar; + +/* Different ways of referring to a position in a buffer. We use + the typedefs in preference to 'EMACS_INT' to make it clearer what + sort of position is being used. See extents.c for a description + of the different positions. We put them here instead of in + buffer.h (where they rightfully belong) to avoid syntax errors + in function prototypes. */ + +typedef EMACS_INT Bufpos; +typedef EMACS_INT Bytind; +typedef EMACS_INT Memind; + +/* Counts of bytes or chars */ + +typedef EMACS_INT Bytecount; +typedef EMACS_INT Charcount; + +/* Length in bytes of a string in external format */ +typedef EMACS_INT Extcount; + +/* General counts of bytes or elements */ +typedef EMACS_INT Memory_Count; +typedef EMACS_INT Element_Count; + +typedef unsigned long Hash_Code; + /* ------------------------ dynamic arrays ------------------- */ #define Dynarr_declare(type) \ @@ -98,7 +216,7 @@ #ifdef MEMORY_USAGE_STATS struct overhead_stats; -size_t Dynarr_memory_usage (void *d, struct overhead_stats *stats); +Memory_Count Dynarr_memory_usage (void *d, struct overhead_stats *stats); #endif /* Also define min() and max(). (Some compilers put them in strange @@ -114,9 +232,9 @@ /* Memory allocation */ void malloc_warning (const char *); -void *xmalloc (size_t size); -void *xmalloc_and_zero (size_t size); -void *xrealloc (void *, size_t size); +void *xmalloc (Memory_Count size); +void *xmalloc_and_zero (Memory_Count size); +void *xrealloc (void *, Memory_Count size); char *xstrdup (const char *); /* generally useful */ #define countof(x) ((int) (sizeof(x)/sizeof((x)[0]))) @@ -136,7 +254,7 @@ least NEEDED_SIZE objects. The reallocing is done by doubling, which ensures constant amortized time per element. */ #define DO_REALLOC(basevar, sizevar, needed_size, type) do { \ - size_t do_realloc_needed_size = (needed_size); \ + Memory_Count do_realloc_needed_size = (needed_size); \ if ((sizevar) < do_realloc_needed_size) \ { \ if ((sizevar) < 32) \ @@ -265,142 +383,28 @@ /*#endif*/ -/* EMACS_INT is the underlying integral type into which a Lisp_Object must fit. - In particular, it must be large enough to contain a pointer. - config.h can override this, e.g. to use `long long' for bigger lisp ints. - - #### In point of fact, it would NOT be a good idea for config.h to mess - with EMACS_INT. A lot of code makes the basic assumption that EMACS_INT - is the size of a pointer. */ - -#ifndef SIZEOF_EMACS_INT -# define SIZEOF_EMACS_INT SIZEOF_VOID_P -#endif - -#ifndef EMACS_INT -# if SIZEOF_EMACS_INT == SIZEOF_LONG -# define EMACS_INT long -# elif SIZEOF_EMACS_INT == SIZEOF_INT -# define EMACS_INT int -# elif SIZEOF_EMACS_INT == SIZEOF_LONG_LONG -# define EMACS_INT long long -# else -# error Unable to determine suitable type for EMACS_INT -# endif -#endif - -#ifndef EMACS_UINT -# define EMACS_UINT unsigned EMACS_INT -#endif - -#define BITS_PER_EMACS_INT (SIZEOF_EMACS_INT * BITS_PER_CHAR) - /************************************************************************/ /* typedefs */ /************************************************************************/ +/* Note that the simplest typedefs are near the top of this file. */ + /* We put typedefs here so that prototype declarations don't choke. Note that we don't actually declare the structures here (except maybe for simple structures like Dynarrs); that keeps them private to the routines that actually use them. */ -/* ------------------------------- */ -/* basic char/int typedefs */ -/* ------------------------------- */ - -/* The definitions we put here use typedefs to attribute specific meaning - to types that by themselves are pretty general. Stuff pointed to by a - char * or unsigned char * will nearly always be one of four types: - a) pointer to internally-formatted text; b) pointer to text in some - external format, which can be defined as all formats other than the - internal one; c) pure ASCII text; d) binary data that is not meant to - be interpreted as text. [A fifth possible type "e) a general pointer - to memory" should be replaced with void *.] Using these more specific - types rather than the general ones helps avoid the confusions that - occur when the semantics of a char * argument being studied are unclear. - - Note that these typedefs are purely for documentation purposes; from - the C code's perspective, they are exactly equivalent to `char *', - `unsigned char *', etc., so you can freely use them with library - functions declared as such. */ - -/* The data representing the text in a buffer is logically a set - of Bufbytes, declared as follows. */ - -typedef unsigned char Bufbyte; - -/* The following should be used when you are working with internal data - but for whatever reason need to have it declared a "char *". Examples - are function arguments whose values are most commonly literal strings, - or where you have to apply a stdlib string function to internal data. - - In general, you should avoid this where possible and use Bufbyte instead, - for consistency. For example, the new Mule workspace contains - Bufbyte versions of the stdlib string functions. */ - -typedef char CBufbyte; - -/* The data representing a string in "external" format (binary or any - external encoding) is logically a set of Extbytes, declared as - follows. Extbyte is guaranteed to be just a char, so for example - strlen (Extbyte *) is OK. Extbyte is only a documentation device - for referring to external text. */ - -typedef char Extbyte; - -/* A byte in a string in binary format: */ -typedef char Char_Binary; -typedef signed char SChar_Binary; -typedef unsigned char UChar_Binary; - -/* A byte in a string in entirely US-ASCII format: (Nothing outside - the range 00 - 7F) */ - -typedef char Char_ASCII; -typedef unsigned char UChar_ASCII; - - -/* To the user, a buffer is made up of characters, declared as follows. - In the non-Mule world, characters and Bufbytes are equivalent. - In the Mule world, a character requires (typically) 1 to 4 - Bufbytes for its representation in a buffer. */ - -typedef int Emchar; - -/* Different ways of referring to a position in a buffer. We use - the typedefs in preference to 'EMACS_INT' to make it clearer what - sort of position is being used. See extents.c for a description - of the different positions. We put them here instead of in - buffer.h (where they rightfully belong) to avoid syntax errors - in function prototypes. */ - -typedef EMACS_INT Bufpos; -typedef EMACS_INT Bytind; -typedef EMACS_INT Memind; - -/* Counts of bytes or chars */ - -typedef EMACS_INT Bytecount; -typedef EMACS_INT Charcount; - -/* Length in bytes of a string in external format */ -typedef EMACS_INT Extcount; - -/* ------------------------------- */ -/* structure/other typedefs */ -/* ------------------------------- */ - typedef struct lstream Lstream; -typedef unsigned int face_index; +typedef int face_index; typedef struct { Dynarr_declare (struct face_cachel); } face_cachel_dynarr; -typedef unsigned int glyph_index; +typedef int glyph_index; /* This is shared by process.h, events.h and others in future. See events.h for description */ @@ -1287,7 +1291,7 @@ { struct lrecord_header lheader; Lisp_Object next; - size_t size; + Element_Count size; unsigned long bits[1]; }; typedef struct Lisp_Bit_Vector Lisp_Bit_Vector; @@ -1315,17 +1319,17 @@ #define bit_vector_length(v) ((v)->size) #define bit_vector_next(v) ((v)->next) -INLINE_HEADER int bit_vector_bit (Lisp_Bit_Vector *v, size_t n); +INLINE_HEADER int bit_vector_bit (Lisp_Bit_Vector *v, Element_Count n); INLINE_HEADER int -bit_vector_bit (Lisp_Bit_Vector *v, size_t n) +bit_vector_bit (Lisp_Bit_Vector *v, Element_Count n) { return ((v->bits[n >> LONGBITS_LOG2] >> (n & (LONGBITS_POWER_OF_2 - 1))) & 1); } -INLINE_HEADER void set_bit_vector_bit (Lisp_Bit_Vector *v, size_t n, int value); +INLINE_HEADER void set_bit_vector_bit (Lisp_Bit_Vector *v, Element_Count n, int value); INLINE_HEADER void -set_bit_vector_bit (Lisp_Bit_Vector *v, size_t n, int value) +set_bit_vector_bit (Lisp_Bit_Vector *v, Element_Count n, int value) { if (value) v->bits[n >> LONGBITS_LOG2] |= (1UL << (n & (LONGBITS_POWER_OF_2 - 1))); @@ -1691,7 +1695,7 @@ { struct lcrecord_header header; Lisp_Object free; - size_t size; + Element_Count size; const struct lrecord_implementation *implementation; }; @@ -1704,7 +1708,7 @@ Lcrecord lists should never escape to the Lisp level, so functions should not be doing this. */ -Lisp_Object make_lcrecord_list (size_t size, +Lisp_Object make_lcrecord_list (Element_Count size, const struct lrecord_implementation *implementation); Lisp_Object allocate_managed_lcrecord (Lisp_Object lcrecord_list); @@ -1885,7 +1889,7 @@ #define LISP_HASH(obj) ((unsigned long) LISP_TO_VOID (obj)) unsigned long string_hash (const char *xv); -unsigned long memory_hash (const void *xv, size_t size); +unsigned long memory_hash (const void *xv, Memory_Count size); unsigned long internal_hash (Lisp_Object obj, int depth); unsigned long internal_array_hash (Lisp_Object *arr, int size, int depth); @@ -2186,7 +2190,7 @@ /* dump_add_opaque (&var, size) dumps the opaque static structure `var'. */ #ifdef PDUMP -void dump_add_opaque (const void *, size_t); +void dump_add_opaque (const void *, Memory_Count); #else #define dump_add_opaque(varaddr,size) DO_NOTHING #endif @@ -2254,10 +2258,10 @@ struct overhead_stats { - int was_requested; - int malloc_overhead; - int dynarr_overhead; - int gap_overhead; + Memory_Count was_requested; + Memory_Count malloc_overhead; + Memory_Count dynarr_overhead; + Memory_Count gap_overhead; }; #endif /* MEMORY_USAGE_STATS */ @@ -2319,12 +2323,12 @@ /* Defined in alloc.c */ void release_breathing_space (void); Lisp_Object noseeum_cons (Lisp_Object, Lisp_Object); -Lisp_Object make_vector (size_t, Lisp_Object); +Lisp_Object make_vector (Element_Count, Lisp_Object); Lisp_Object vector1 (Lisp_Object); Lisp_Object vector2 (Lisp_Object, Lisp_Object); Lisp_Object vector3 (Lisp_Object, Lisp_Object, Lisp_Object); -Lisp_Object make_bit_vector (size_t, Lisp_Object); -Lisp_Object make_bit_vector_from_byte_vector (unsigned char *, size_t); +Lisp_Object make_bit_vector (Element_Count, Lisp_Object); +Lisp_Object make_bit_vector_from_byte_vector (unsigned char *, Element_Count); Lisp_Object noseeum_make_marker (void); void garbage_collect_1 (void); Lisp_Object acons (Lisp_Object, Lisp_Object, Lisp_Object); @@ -2363,8 +2367,8 @@ int marked_p (Lisp_Object obj); #ifdef MEMORY_USAGE_STATS -size_t malloced_storage_size (void *, size_t, struct overhead_stats *); -size_t fixed_type_block_overhead (size_t); +Memory_Count malloced_storage_size (void *, Memory_Count, struct overhead_stats *); +Memory_Count fixed_type_block_overhead (Memory_Count); #endif #ifdef PDUMP void pdump (void); @@ -2702,8 +2706,9 @@ DECLARE_DOESNT_RETURN (report_file_error (const CBufbyte *, Lisp_Object)); Lisp_Object lisp_strerror (int); Lisp_Object expand_and_dir_to_file (Lisp_Object, Lisp_Object); -ssize_t read_allowing_quit (int, void *, size_t); -ssize_t write_allowing_quit (int, const void *, size_t); +Memory_Count read_allowing_quit (int fildes, void *buf, Memory_Count size); +Memory_Count write_allowing_quit (int fildes, const void *buf, + Memory_Count size); int internal_delete_file (Lisp_Object); /* Defined in filelock.c */
--- a/src/lrecord.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/lrecord.h Mon Aug 13 04:46:48 2001 +0000 @@ -199,7 +199,7 @@ lrecord_type_last_built_in_type /* must be last */ }; -extern unsigned int lrecord_type_count; +extern int lrecord_type_count; struct lrecord_implementation { @@ -256,8 +256,8 @@ /* Only one of `static_size' and `size_in_bytes_method' is non-0. If both are 0, this type is not instantiable by alloc_lcrecord(). */ - size_t static_size; - size_t (*size_in_bytes_method) (const void *header); + Memory_Count static_size; + Memory_Count (*size_in_bytes_method) (const void *header); /* The (constant) index into lrecord_implementations_table */ enum lrecord_type lrecord_type_index; @@ -275,7 +275,7 @@ room in `lrecord_implementations_table' for such new lisp object types. */ #define MODULE_DEFINABLE_TYPE_COUNT 32 -extern const struct lrecord_implementation *lrecord_implementations_table[(unsigned int)lrecord_type_last_built_in_type + MODULE_DEFINABLE_TYPE_COUNT]; +extern const struct lrecord_implementation *lrecord_implementations_table[lrecord_type_last_built_in_type + MODULE_DEFINABLE_TYPE_COUNT]; #define XRECORD_LHEADER_IMPLEMENTATION(obj) \ LHEADER_IMPLEMENTATION (XRECORD_LHEADER (obj)) @@ -360,8 +360,14 @@ An integer which will be reset to a given value in the dump file. - XD_SIZE_T - size_t value. Used for counts. + XD_ELEMENT_COUNT + Element_Count value. Used for counts. + + XD_MEMORY_COUNT + Memory_Count value. Used for counts. + + XD_HASH_CODE + Hash_Code value. Used for the results of hashing functions. XD_INT int value. Used for counts. @@ -387,7 +393,8 @@ starts at zero) and adds delta to it. */ -enum lrecord_description_type { +enum lrecord_description_type +{ XD_LISP_OBJECT_ARRAY, XD_LISP_OBJECT, XD_LO_LINK, @@ -397,7 +404,9 @@ XD_C_STRING, XD_DOC_STRING, XD_INT_RESET, - XD_SIZE_T, + XD_MEMORY_COUNT, + XD_ELEMENT_COUNT, + XD_HASH_CODE, XD_INT, XD_LONG, XD_BYTECOUNT, @@ -405,15 +414,17 @@ XD_SPECIFIER_END }; -struct lrecord_description { +struct lrecord_description +{ enum lrecord_description_type type; int offset; EMACS_INT data1; const struct struct_description *data2; }; -struct struct_description { - size_t size; +struct struct_description +{ + Memory_Count size; const struct lrecord_description *description; }; @@ -480,7 +491,7 @@ #define MAKE_EXTERNAL_LRECORD_IMPLEMENTATION(name,c_name,marker,printer,nuker,equal,hash,desc,getprop,putprop,remprop,plist,size,sizer,basic_p,structtype) \ DECLARE_ERROR_CHECK_TYPECHECK(c_name, structtype) \ -unsigned int lrecord_type_##c_name; \ +int lrecord_type_##c_name; \ struct lrecord_implementation lrecord_##c_name = \ { name, marker, printer, nuker, equal, hash, desc, \ getprop, putprop, remprop, plist, size, sizer, \ @@ -505,7 +516,7 @@ #define XRECORD_LHEADER(a) ((struct lrecord_header *) XPNTR (a)) #define RECORD_TYPEP(x, ty) \ - (LRECORDP (x) && (((unsigned int)(XRECORD_LHEADER (x)->type)) == ((unsigned int)(ty)))) + (LRECORDP (x) && (XRECORD_LHEADER (x)->type == (unsigned int) (ty))) /* Steps to create a new object: @@ -660,7 +671,7 @@ extern Lisp_Object Q##c_name##p # define DECLARE_EXTERNAL_LRECORD(c_name, structtype) \ -extern unsigned int lrecord_type_##c_name; \ +extern int lrecord_type_##c_name; \ extern struct lrecord_implementation lrecord_##c_name; \ INLINE_HEADER structtype * \ error_check_##c_name (Lisp_Object obj); \ @@ -711,7 +722,7 @@ extern const struct lrecord_implementation lrecord_##c_name # define DECLARE_EXTERNAL_LRECORD(c_name, structtype) \ extern Lisp_Object Q##c_name##p; \ -extern unsigned int lrecord_type_##c_name; \ +extern int lrecord_type_##c_name; \ extern struct lrecord_implementation lrecord_##c_name # define DECLARE_NONRECORD(c_name, type_enum, structtype) \ extern Lisp_Object Q##c_name##p @@ -767,7 +778,8 @@ dead_wrong_type_argument (predicate, x); \ } while (0) -void *alloc_lcrecord (size_t size, const struct lrecord_implementation *); +void *alloc_lcrecord (Memory_Count size, + const struct lrecord_implementation *); #define alloc_lcrecord_type(type, lrecord_implementation) \ ((type *) alloc_lcrecord (sizeof (type), lrecord_implementation))
--- a/src/lstream.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/lstream.c Mon Aug 13 04:46:48 2001 +0000 @@ -95,19 +95,19 @@ void Lstream_fungetc (Lstream *stream, int c) Function equivalents of the above macros. -Lstream_data_count Lstream_read (Lstream *stream, void *data, - Lstream_data_count size) +Lstream_Data_Count Lstream_read (Lstream *stream, void *data, + Lstream_Data_Count size) Read SIZE bytes of DATA from the stream. Return the number of bytes read. 0 means EOF. -1 means an error occurred and no bytes were read. -Lstream_data_count Lstream_write (Lstream *stream, void *data, - Lstream_data_count size) +Lstream_Data_Count Lstream_write (Lstream *stream, void *data, + Lstream_Data_Count size) Write SIZE bytes of DATA to the stream. Return the number of bytes written. -1 means an error occurred and no bytes were written. -void Lstream_unread (Lstream *stream, void *data, Lstream_data_count size) +void Lstream_unread (Lstream *stream, void *data, Lstream_Data_Count size) Push back SIZE bytes of DATA onto the input queue. The next call to Lstream_read() with the same size will read the same bytes back. Note that this will be the case even if @@ -181,14 +181,14 @@ } } -inline static size_t -aligned_sizeof_lstream (size_t lstream_type_specific_size) +inline static Memory_Count +aligned_sizeof_lstream (Memory_Count lstream_type_specific_size) { return ALIGN_SIZE (offsetof (Lstream, data) + lstream_type_specific_size, ALIGNOF (max_align_t)); } -static size_t +static Memory_Count sizeof_lstream (const void *header) { return aligned_sizeof_lstream (((const Lstream *) header)->imp->size); @@ -303,11 +303,11 @@ int Lstream_flush_out (Lstream *lstr) { - Lstream_data_count num_written; + Lstream_Data_Count num_written; while (lstr->out_buffer_ind > 0) { - Lstream_data_count size = lstr->out_buffer_ind; + Lstream_Data_Count size = lstr->out_buffer_ind; if (! (lstr->flags & LSTREAM_FL_IS_OPEN)) Lstream_internal_error ("lstream not open", lstr); if (! (lstr->flags & LSTREAM_FL_WRITE)) @@ -390,10 +390,10 @@ if it's getting EWOULDBLOCK errors. We have to keep stocking them up until they can be written, so as to avoid losing data. */ -static Lstream_data_count -Lstream_adding (Lstream *lstr, Lstream_data_count num, int force) +static Lstream_Data_Count +Lstream_adding (Lstream *lstr, Lstream_Data_Count num, int force) { - Lstream_data_count size = num + lstr->out_buffer_ind; + Lstream_Data_Count size = num + lstr->out_buffer_ind; if (size <= lstr->out_buffer_size) return num; @@ -415,11 +415,11 @@ /* Like Lstream_write(), but does not handle line-buffering correctly. */ -static Lstream_data_count -Lstream_write_1 (Lstream *lstr, const void *data, Lstream_data_count size) +static Lstream_Data_Count +Lstream_write_1 (Lstream *lstr, const void *data, Lstream_Data_Count size) { const unsigned char *p = (const unsigned char *) data; - Lstream_data_count off = 0; + Lstream_Data_Count off = 0; if (! (lstr->flags & LSTREAM_FL_IS_OPEN)) Lstream_internal_error ("lstream not open", lstr); if (! (lstr->flags & LSTREAM_FL_WRITE)) @@ -430,7 +430,7 @@ while (1) { /* Figure out how much we can add to the buffer */ - Lstream_data_count chunk = Lstream_adding (lstr, size, 0); + Lstream_Data_Count chunk = Lstream_adding (lstr, size, 0); if (chunk == 0) { if (couldnt_write_last_time) @@ -475,10 +475,10 @@ repeatedly call Lstream_putc(), which knows how to handle line buffering. Returns number of bytes written. */ -Lstream_data_count -Lstream_write (Lstream *lstr, const void *data, Lstream_data_count size) +Lstream_Data_Count +Lstream_write (Lstream *lstr, const void *data, Lstream_Data_Count size) { - Lstream_data_count i; + Lstream_Data_Count i; const unsigned char *p = (const unsigned char *) data; if (size == 0) @@ -499,9 +499,9 @@ return lstr->imp->was_blocked_p ? lstr->imp->was_blocked_p (lstr) : 0; } -static Lstream_data_count +static Lstream_Data_Count Lstream_raw_read (Lstream *lstr, unsigned char *buffer, - Lstream_data_count size) + Lstream_Data_Count size) { if (! (lstr->flags & LSTREAM_FL_IS_OPEN)) Lstream_internal_error ("lstream not open", lstr); @@ -515,18 +515,18 @@ /* Assuming the buffer is empty, fill it up again. */ -static Lstream_data_count +static Lstream_Data_Count Lstream_read_more (Lstream *lstr) { #if 0 - Lstream_data_count size_needed + Lstream_Data_Count size_needed = max (1, min (MAX_READ_SIZE, lstr->buffering_size)); #else /* If someone requested a larger buffer size, so be it! */ - Lstream_data_count size_needed = + Lstream_Data_Count size_needed = max (1, lstr->buffering_size); #endif - Lstream_data_count size_gotten; + Lstream_Data_Count size_gotten; DO_REALLOC (lstr->in_buffer, lstr->in_buffer_size, size_needed, unsigned char); @@ -536,12 +536,12 @@ return size_gotten < 0 ? -1 : size_gotten; } -Lstream_data_count -Lstream_read (Lstream *lstr, void *data, Lstream_data_count size) +Lstream_Data_Count +Lstream_read (Lstream *lstr, void *data, Lstream_Data_Count size) { unsigned char *p = (unsigned char *) data; - Lstream_data_count off = 0; - Lstream_data_count chunk; + Lstream_Data_Count off = 0; + Lstream_Data_Count chunk; int error_occurred = 0; if (size == 0) @@ -574,7 +574,7 @@ /* If we need some more, try to get some more from the stream's end */ if (size > 0) { - Lstream_data_count retval = Lstream_read_more (lstr); + Lstream_Data_Count retval = Lstream_read_more (lstr); if (retval < 0) error_occurred = 1; if (retval <= 0) @@ -598,7 +598,7 @@ VALIDATE_CHARPTR_BACKWARD (dataend); if (dataend + REP_BYTES_BY_FIRST_BYTE (*dataend) != p + off) { - Lstream_data_count newoff = dataend - p; + Lstream_Data_Count newoff = dataend - p; /* If not, chop the size down to ignore the last char and stash it away for next time. */ Lstream_unread (lstr, dataend, off - newoff); @@ -611,7 +611,7 @@ } void -Lstream_unread (Lstream *lstr, const void *data, Lstream_data_count size) +Lstream_unread (Lstream *lstr, const void *data, Lstream_Data_Count size) { const unsigned char *p = (const unsigned char *) data; @@ -730,7 +730,7 @@ Lstream_fputc (Lstream *lstr, int c) { unsigned char ch = (unsigned char) c; - Lstream_data_count retval = Lstream_write_1 (lstr, &ch, 1); + Lstream_Data_Count retval = Lstream_write_1 (lstr, &ch, 1); if (retval >= 0 && lstr->buffering == LSTREAM_LINE_BUFFERED && ch == '\n') return Lstream_flush_out (lstr); return retval < 0 ? -1 : 0; @@ -811,22 +811,22 @@ code (it could even be argued that the error might have fixed itself, so we should do the fread() again. */ -static Lstream_data_count -stdio_reader (Lstream *stream, unsigned char *data, Lstream_data_count size) +static Lstream_Data_Count +stdio_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size) { struct stdio_stream *str = STDIO_STREAM_DATA (stream); - Lstream_data_count val = fread (data, 1, size, str->file); + Lstream_Data_Count val = fread (data, 1, size, str->file); if (!val && ferror (str->file)) return -1; return val; } -static Lstream_data_count +static Lstream_Data_Count stdio_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct stdio_stream *str = STDIO_STREAM_DATA (stream); - Lstream_data_count val = fwrite (data, 1, size, str->file); + Lstream_Data_Count val = fwrite (data, 1, size, str->file); if (!val && ferror (str->file)) return -1; return val; @@ -937,13 +937,13 @@ return make_filedesc_stream_1 (filedesc, offset, count, flags, "w"); } -static Lstream_data_count -filedesc_reader (Lstream *stream, unsigned char *data, Lstream_data_count size) +static Lstream_Data_Count +filedesc_reader (Lstream *stream, unsigned char *data, Lstream_Data_Count size) { - Lstream_data_count nread; + Lstream_Data_Count nread; struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream); if (str->end_pos >= 0) - size = min (size, (Lstream_data_count) (str->end_pos - str->current_pos)); + size = min (size, (Lstream_Data_Count) (str->end_pos - str->current_pos)); nread = str->allow_quit ? read_allowing_quit (str->fd, data, size) : read (str->fd, data, size); @@ -966,12 +966,12 @@ return 0; } -static Lstream_data_count +static Lstream_Data_Count filedesc_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct filedesc_stream *str = FILEDESC_STREAM_DATA (stream); - Lstream_data_count retval; + Lstream_Data_Count retval; int need_newline = 0; /* This function would be simple if it were not for the blasted @@ -1025,7 +1025,7 @@ out for EWOULDBLOCK. */ if (str->chars_sans_newline >= str->pty_max_bytes) { - Lstream_data_count retval2 = str->allow_quit ? + Lstream_Data_Count retval2 = str->allow_quit ? write_allowing_quit (str->fd, &str->eof_char, 1) : write (str->fd, &str->eof_char, 1); @@ -1058,7 +1058,7 @@ if (need_newline) { Bufbyte nl = '\n'; - Lstream_data_count retval2 = str->allow_quit ? + Lstream_Data_Count retval2 = str->allow_quit ? write_allowing_quit (str->fd, &nl, 1) : write (str->fd, &nl, 1); @@ -1194,9 +1194,9 @@ return obj; } -static Lstream_data_count +static Lstream_Data_Count lisp_string_reader (Lstream *stream, unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct lisp_string_stream *str = LISP_STRING_STREAM_DATA (stream); /* Don't lose if the string shrank past us ... */ @@ -1211,7 +1211,7 @@ if (stream->flags & LSTREAM_FL_NO_PARTIAL_CHARS) VALIDATE_CHARPTR_BACKWARD (start); offset = start - strstart; - size = min (size, (Lstream_data_count) (str->end - offset)); + size = min (size, (Lstream_Data_Count) (str->end - offset)); memcpy (data, start, size); str->offset = offset + size; return size; @@ -1254,15 +1254,15 @@ { const unsigned char *inbuf; unsigned char *outbuf; - Lstream_data_count size; - Lstream_data_count offset; + Lstream_Data_Count size; + Lstream_Data_Count offset; }; DEFINE_LSTREAM_IMPLEMENTATION ("fixed-buffer", lstream_fixed_buffer, sizeof (struct fixed_buffer_stream)); Lisp_Object -make_fixed_buffer_input_stream (const void *buf, Lstream_data_count size) +make_fixed_buffer_input_stream (const void *buf, Lstream_Data_Count size) { Lisp_Object obj; Lstream *lstr = Lstream_new (lstream_fixed_buffer, "r"); @@ -1274,7 +1274,7 @@ } Lisp_Object -make_fixed_buffer_output_stream (void *buf, Lstream_data_count size) +make_fixed_buffer_output_stream (void *buf, Lstream_Data_Count size) { Lisp_Object obj; Lstream *lstr = Lstream_new (lstream_fixed_buffer, "w"); @@ -1285,9 +1285,9 @@ return obj; } -static Lstream_data_count +static Lstream_Data_Count fixed_buffer_reader (Lstream *stream, unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (stream); size = min (size, str->size - str->offset); @@ -1296,9 +1296,9 @@ return size; } -static Lstream_data_count +static Lstream_Data_Count fixed_buffer_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct fixed_buffer_stream *str = FIXED_BUFFER_STREAM_DATA (stream); if (str->offset == str->size) @@ -1343,7 +1343,7 @@ struct resizing_buffer_stream { unsigned char *buf; - Lstream_data_count allocked; + Lstream_Data_Count allocked; int max_stored; int stored; }; @@ -1359,9 +1359,9 @@ return obj; } -static Lstream_data_count +static Lstream_Data_Count resizing_buffer_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct resizing_buffer_stream *str = RESIZING_BUFFER_STREAM_DATA (stream); DO_REALLOC (str->buf, str->allocked, str->stored + size, unsigned char); @@ -1422,9 +1422,9 @@ return obj; } -static Lstream_data_count +static Lstream_Data_Count dynarr_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct dynarr_stream *str = DYNARR_STREAM_DATA (stream); Dynarr_add_many (str->dyn, data, size); @@ -1547,9 +1547,9 @@ return lstr; } -static Lstream_data_count +static Lstream_Data_Count lisp_buffer_reader (Lstream *stream, unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream); unsigned char *orig_data = data; @@ -1573,7 +1573,7 @@ BI_BUF_ZV (buf)); } - size = min (size, (Lstream_data_count) (end - start)); + size = min (size, (Lstream_Data_Count) (end - start)); end = start + size; /* We cannot return a partial character. */ VALIDATE_BYTIND_BACKWARD (buf, end); @@ -1606,9 +1606,9 @@ return data - orig_data; } -static Lstream_data_count +static Lstream_Data_Count lisp_buffer_writer (Lstream *stream, const unsigned char *data, - Lstream_data_count size) + Lstream_Data_Count size) { struct lisp_buffer_stream *str = LISP_BUFFER_STREAM_DATA (stream); Bufpos pos;
--- a/src/lstream.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/lstream.h Mon Aug 13 04:46:48 2001 +0000 @@ -61,7 +61,7 @@ with certain types of devices) will get completely screwed up. */ -typedef EMACS_INT Lstream_data_count; +typedef EMACS_INT Lstream_Data_Count; typedef enum lstream_buffering { @@ -96,7 +96,7 @@ typedef struct lstream_implementation { const char *name; - Lstream_data_count size; /* Number of additional bytes to be + Lstream_Data_Count size; /* Number of additional bytes to be allocated with this stream. Access this data using Lstream_data(). */ /* Read some data from the stream's end and store it into DATA, which @@ -117,8 +117,8 @@ /* The omniscient mly, blinded by the irresistible thrall of Common Lisp, thinks that it is bogus that the types and implementations of input and output streams are the same. */ - Lstream_data_count (*reader) (Lstream *stream, unsigned char *data, - Lstream_data_count size); + Lstream_Data_Count (*reader) (Lstream *stream, unsigned char *data, + Lstream_Data_Count size); /* Send some data to the stream's end. Data to be sent is in DATA and is SIZE bytes. Return the number of bytes sent. This function can send and return fewer bytes than is passed in; in @@ -129,8 +129,8 @@ data. (This is useful, e.g., of you're dealing with a non-blocking file descriptor and are getting EWOULDBLOCK errors.) This function can be NULL if the stream is input-only. */ - Lstream_data_count (*writer) (Lstream *stream, const unsigned char *data, - Lstream_data_count size); + Lstream_Data_Count (*writer) (Lstream *stream, const unsigned char *data, + Lstream_Data_Count size); /* Return non-zero if the last write operation on the stream resulted in an attempt to block (EWOULDBLOCK). If this method does not exists, the implementation returns 0 */ @@ -171,17 +171,17 @@ struct lcrecord_header header; const Lstream_implementation *imp; /* methods for this stream */ Lstream_buffering buffering; /* type of buffering in use */ - Lstream_data_count buffering_size; /* number of bytes buffered */ + Lstream_Data_Count buffering_size; /* number of bytes buffered */ unsigned char *in_buffer; /* holds characters read from stream end */ - Lstream_data_count in_buffer_size; /* allocated size of buffer */ - Lstream_data_count in_buffer_current; /* number of characters in buffer */ - Lstream_data_count in_buffer_ind; /* pointer to next character to + Lstream_Data_Count in_buffer_size; /* allocated size of buffer */ + Lstream_Data_Count in_buffer_current; /* number of characters in buffer */ + Lstream_Data_Count in_buffer_ind; /* pointer to next character to take from buffer */ unsigned char *out_buffer; /* holds characters to write to stream end */ - Lstream_data_count out_buffer_size; /* allocated size of buffer */ - Lstream_data_count out_buffer_ind; /* pointer to next buffer spot to + Lstream_Data_Count out_buffer_size; /* allocated size of buffer */ + Lstream_Data_Count out_buffer_ind; /* pointer to next buffer spot to write a character */ /* The unget buffer is more or less a stack -- things get pushed @@ -189,11 +189,11 @@ basically reads backwards from the end to get stuff; Lstream_unread() similarly has to push the data on backwards. */ unsigned char *unget_buffer; /* holds characters pushed back onto input */ - Lstream_data_count unget_buffer_size; /* allocated size of buffer */ - Lstream_data_count unget_buffer_ind; /* pointer to next buffer spot + Lstream_Data_Count unget_buffer_size; /* allocated size of buffer */ + Lstream_Data_Count unget_buffer_ind; /* pointer to next buffer spot to write a character */ - Lstream_data_count byte_count; + Lstream_Data_Count byte_count; int flags; max_align_t data[1]; }; @@ -236,12 +236,12 @@ int Lstream_fputc (Lstream *lstr, int c); int Lstream_fgetc (Lstream *lstr); void Lstream_fungetc (Lstream *lstr, int c); -Lstream_data_count Lstream_read (Lstream *lstr, void *data, - Lstream_data_count size); -Lstream_data_count Lstream_write (Lstream *lstr, const void *data, - Lstream_data_count size); +Lstream_Data_Count Lstream_read (Lstream *lstr, void *data, + Lstream_Data_Count size); +Lstream_Data_Count Lstream_write (Lstream *lstr, const void *data, + Lstream_Data_Count size); int Lstream_was_blocked_p (Lstream *lstr); -void Lstream_unread (Lstream *lstr, const void *data, Lstream_data_count size); +void Lstream_unread (Lstream *lstr, const void *data, Lstream_Data_Count size); int Lstream_rewind (Lstream *lstr); int Lstream_seekable_p (Lstream *lstr); int Lstream_close (Lstream *lstr); @@ -370,9 +370,9 @@ Bytecount offset, Bytecount len); Lisp_Object make_fixed_buffer_input_stream (const void *buf, - Lstream_data_count size); + Lstream_Data_Count size); Lisp_Object make_fixed_buffer_output_stream (void *buf, - Lstream_data_count size); + Lstream_Data_Count size); const unsigned char *fixed_buffer_input_stream_ptr (Lstream *stream); unsigned char *fixed_buffer_output_stream_ptr (Lstream *stream); Lisp_Object make_resizing_buffer_output_stream (void);
--- a/src/m/tad68k.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/m/tad68k.h Mon Aug 13 04:46:48 2001 +0000 @@ -72,5 +72,7 @@ /* omit next three lines if no TCP installed */ +#if 0 /* XEmacs */ #define select gnu_select /* avoid select() name clash */ +#endif #define LIBS_SYSTEM "-lsocket" /* get TCP networking functions */
--- a/src/malloc.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/malloc.c Mon Aug 13 04:46:48 2001 +0000 @@ -220,8 +220,8 @@ /* These two are for user programs to look at, when they are interested. */ -unsigned int malloc_sbrk_used; /* amount of data space used now */ -unsigned int malloc_sbrk_unused; /* amount more we can have */ +Memory_Count malloc_sbrk_used; /* amount of data space used now */ +Memory_Count malloc_sbrk_unused; /* amount more we can have */ /* start of data space; can be changed by calling init_malloc */ static char *data_space_start; @@ -489,7 +489,7 @@ multiple of 8, then figure out which nestf[] area to use. Both the beginning of the header and the beginning of the block should be on an eight byte boundary. */ - nbytes = (n + ((sizeof *p + 7) & ~7) + EXTRA + 7) & ~7; + nbytes = (n + ((sizeof (*p) + 7) & ~7) + EXTRA + 7) & ~7; { unsigned int shiftr = (nbytes - 1) >> 2; @@ -535,7 +535,7 @@ p -> mh_magic4 = MAGIC4; { /* Get the location n after the beginning of the user's space. */ - char *m = (char *) p + ((sizeof *p + 7) & ~7) + n; + char *m = (char *) p + ((sizeof (*p) + 7) & ~7) + n; *m++ = MAGIC1, *m++ = MAGIC1, *m++ = MAGIC1, *m = MAGIC1; } @@ -546,7 +546,7 @@ nmalloc[nunits]++; nmal++; #endif /* MSTATS */ - return (char *) p + ((sizeof *p + 7) & ~7); + return (char *) p + ((sizeof (*p) + 7) & ~7); } void @@ -560,11 +560,11 @@ if (ap == 0) return; - p = (struct mhead *) (ap - ((sizeof *p + 7) & ~7)); + p = (struct mhead *) (ap - ((sizeof (*p) + 7) & ~7)); if (p -> mh_alloc == ISMEMALIGN) { ap -= p->mh_size; - p = (struct mhead *) (ap - ((sizeof *p + 7) & ~7)); + p = (struct mhead *) (ap - ((sizeof (*p) + 7) & ~7)); } #ifndef rcheck @@ -618,7 +618,7 @@ if (mem == 0) return malloc (n); - p = (struct mhead *) (mem - ((sizeof *p + 7) & ~7)); + p = (struct mhead *) (mem - ((sizeof (*p) + 7) & ~7)); nunits = p -> mh_index; ASSERT (p -> mh_alloc == ISALLOC); #ifdef rcheck @@ -630,13 +630,13 @@ } #else /* not rcheck */ if (p -> mh_index >= 13) - tocopy = (1 << (p -> mh_index + 3)) - ((sizeof *p + 7) & ~7); + tocopy = (1 << (p -> mh_index + 3)) - ((sizeof (*p) + 7) & ~7); else tocopy = p -> mh_size; #endif /* not rcheck */ /* See if desired size rounds to same power of 2 as actual size. */ - nbytes = (n + ((sizeof *p + 7) & ~7) + EXTRA + 7) & ~7; + nbytes = (n + ((sizeof (*p) + 7) & ~7) + EXTRA + 7) & ~7; /* If ok, use the same block, just marking its size as changed. */ if (nbytes > (4 << nunits) && nbytes <= (8 << nunits))
--- a/src/md5.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/md5.c Mon Aug 13 04:46:48 2001 +0000 @@ -579,7 +579,7 @@ while (1) { Bufbyte tempbuf[1024]; /* some random amount */ - Lstream_data_count size_in_bytes = + Lstream_Data_Count size_in_bytes = Lstream_read (XLSTREAM (instream), tempbuf, sizeof (tempbuf)); if (!size_in_bytes) break;
--- a/src/menubar-msw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/menubar-msw.c Mon Aug 13 04:46:48 2001 +0000 @@ -219,7 +219,7 @@ static char* displayable_menu_item (Lisp_Object gui_item, int bar_p, Emchar *accel) { - unsigned int ll; + Bytecount ll; /* We construct the name in a static buffer. That's fine, because menu items longer than 128 chars are probably programming errors, @@ -237,7 +237,7 @@ /* Right flush part, unless we're at the top-level where it's not allowed */ if (!bar_p) { - unsigned int lr; + Bytecount lr; assert (MAX_MENUITEM_LENGTH > ll + 1); lr = gui_item_display_flush_right (gui_item, buf + ll + 1,
--- a/src/mule-ccl.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/mule-ccl.c Mon Aug 13 04:46:48 2001 +0000 @@ -971,7 +971,10 @@ case CCL_SetArray: /* CCCCCCCCCCCCCCCCCCCCRRRrrrXXXXX */ i = reg[RRR]; j = field1 >> 3; - if ((unsigned int) i < j) + /* #### it's non-obvious to me that we need these casts, + but the left one was already there so clearly the intention + was an unsigned comparison. --ben */ + if ((unsigned int) i < (unsigned int) j) reg[rrr] = XINT (ccl_prog[ic + i]); ic += j; break; @@ -1023,7 +1026,8 @@ case CCL_WriteArrayReadJump: /* A--D--D--R--E--S--S-rrrXXXXX */ i = reg[rrr]; j = XINT (ccl_prog[ic]); - if ((unsigned int) i < j) + /* #### see comment at CCL_SetArray */ + if ((unsigned int) i < (unsigned int) j) { i = XINT (ccl_prog[ic + 1 + i]); CCL_WRITE_CHAR (i); @@ -1042,7 +1046,8 @@ CCL_READ_CHAR (reg[rrr]); /* fall through ... */ case CCL_Branch: /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */ - if ((unsigned int) reg[rrr] < field1) + /* #### see comment at CCL_SetArray */ + if ((unsigned int) reg[rrr] < (unsigned int) field1) ic += XINT (ccl_prog[ic + reg[rrr]]); else ic += XINT (ccl_prog[ic + field1]); @@ -1137,7 +1142,8 @@ case CCL_WriteArray: /* CCCCCCCCCCCCCCCCCCCCrrrXXXXX */ i = reg[rrr]; - if ((unsigned int) i < field1) + /* #### see comment at CCL_SetArray */ + if ((unsigned int) i < (unsigned int) field1) { j = XINT (ccl_prog[ic + i]); CCL_WRITE_CHAR (j); @@ -1448,8 +1454,13 @@ else if (EQ (content, Qt)) { if (size != 4) continue; - if ((op >= XUINT (XVECTOR (map)->contents[2])) - && (op < XUINT (XVECTOR (map)->contents[3]))) + /* #### see comment at CCL_SetArray; in this + case the casts are added but the XUINT was + already present */ + if (((unsigned int) op >= + XUINT (XVECTOR (map)->contents[2])) + && ((unsigned int) op < + XUINT (XVECTOR (map)->contents[3]))) content = XVECTOR (map)->contents[1]; else continue; @@ -1622,8 +1633,13 @@ else if (EQ (content, Qt)) { if (size != 4) continue; - if ((op >= XUINT (XVECTOR (map)->contents[2])) && - (op < XUINT (XVECTOR (map)->contents[3]))) + /* #### see comment at CCL_SetArray; in this + case the casts are added but the XUINT was + already present */ + if (((unsigned int) op >= + XUINT (XVECTOR (map)->contents[2])) && + ((unsigned int) op < + XUINT (XVECTOR (map)->contents[3]))) content = XVECTOR (map)->contents[1]; else continue;
--- a/src/mule-charset.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/mule-charset.c Mon Aug 13 04:46:48 2001 +0000 @@ -329,8 +329,8 @@ Bytecount non_ascii_charptr_copy_char (const Bufbyte *src, Bufbyte *dst) { - unsigned int bytes = REP_BYTES_BY_FIRST_BYTE (*src); - unsigned int i; + Bytecount bytes = REP_BYTES_BY_FIRST_BYTE (*src); + Bytecount i; for (i = bytes; i; i--, dst++, src++) *dst = *src; return bytes; @@ -350,7 +350,7 @@ { Bufbyte str[MAX_EMCHAR_LEN]; Bufbyte *strptr = str; - unsigned int bytes; + Bytecount bytes; str[0] = (Bufbyte) ch;
--- a/src/mule-charset.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/mule-charset.h Mon Aug 13 04:46:48 2001 +0000 @@ -470,26 +470,26 @@ /* Number of bytes (1 - 4) required in the internal representation for characters in this character set. This is *not* the same as the dimension of the character set). */ - unsigned int rep_bytes; + int rep_bytes; /* Number of columns a character in this charset takes up, on TTY devices. Not used for X devices. */ - unsigned int columns; + int columns; /* Direction of this character set */ - unsigned int direction; + int direction; /* Type of this character set (94, 96, 94x94, 96x96) */ - unsigned int type; + int type; /* Number of bytes used in encoding of this character set (1 or 2) */ - unsigned int dimension; + int dimension; /* Number of chars in each dimension (usually 94 or 96) */ - unsigned int chars; + int chars; /* Which half of font to be used to display this character set */ - unsigned int graphic; + int graphic; }; typedef struct Lisp_Charset Lisp_Charset; @@ -577,9 +577,9 @@ } INLINE_HEADER Lisp_Object -CHARSET_BY_ATTRIBUTES (unsigned int type, unsigned char final, int dir); +CHARSET_BY_ATTRIBUTES (int type, unsigned char final, int dir); INLINE_HEADER Lisp_Object -CHARSET_BY_ATTRIBUTES (unsigned int type, unsigned char final, int dir) +CHARSET_BY_ATTRIBUTES (int type, unsigned char final, int dir) { extern struct charset_lookup *chlook;
--- a/src/mule-wnnfns.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/mule-wnnfns.c Mon Aug 13 04:46:48 2001 +0000 @@ -1978,7 +1978,7 @@ void m2w (unsigned char *mp, w_char *wp) { - unsigned int ch; + int ch; while ((ch = *mp++) != 0) {
--- a/src/ntheap.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/ntheap.c Mon Aug 13 04:46:48 2001 +0000 @@ -237,7 +237,7 @@ DWORD size; unsigned char* base = get_heap_end (); unsigned char* end = base + get_reserved_heap_size () - get_committed_heap_size (); - VirtualQuery (base, &info, sizeof info); + VirtualQuery (base, &info, sizeof (info)); if (info.State != MEM_FREE) { /* Oops, something has already reserved or commited it, nothing we can do but exit */ @@ -253,7 +253,7 @@ } /* Now try and reserve as much as possible */ - size = min (info.RegionSize, end - base); + size = min (info.RegionSize, (DWORD) (end - base)); tmp = VirtualAlloc (base, size, MEM_RESERVE, PAGE_NOACCESS); if (!tmp) {
--- a/src/ntproc.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/ntproc.c Mon Aug 13 04:46:48 2001 +0000 @@ -227,7 +227,7 @@ child_process *cp; for (cp = child_procs+(child_proc_count-1); cp >= child_procs; cp--) - if (CHILD_ACTIVE (cp) && pid == cp->pid) + if (CHILD_ACTIVE (cp) && pid == (DWORD) cp->pid) return cp; return NULL; }
--- a/src/objects-msw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/objects-msw.c Mon Aug 13 04:46:48 2001 +0000 @@ -806,7 +806,7 @@ or "rgb:rrrr/gggg/bbbb" */ unsigned int r, g, b; - for (i=1; i<strlen(name); i++) + for (i=1; i< (int) strlen(name); i++) { if (!isxdigit ((int)name[i])) return (COLORREF) -1; @@ -1169,7 +1169,7 @@ static int mswindows_initialize_color_instance (Lisp_Color_Instance *c, Lisp_Object name, - Lisp_Object device, Error_Behavior errb) + Lisp_Object device, Error_Behavior errb) { const char *extname; COLORREF color; @@ -1177,8 +1177,8 @@ TO_EXTERNAL_FORMAT (LISP_STRING, name, C_STRING_ALLOCA, extname, Qctext); - color = mswindows_string_to_color(extname); - if (color != -1) + color = mswindows_string_to_color (extname); + if (color != (COLORREF) -1) { c->data = xnew (struct mswindows_color_instance_data); COLOR_INSTANCE_MSWINDOWS_COLOR (c) = color; @@ -1249,7 +1249,7 @@ TO_EXTERNAL_FORMAT (LISP_STRING, color, C_STRING_ALLOCA, extname, Qctext); - return (mswindows_string_to_color(extname)!=-1); + return (mswindows_string_to_color (extname) != (COLORREF) -1); }
--- a/src/objects-x.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/objects-x.c Mon Aug 13 04:46:48 2001 +0000 @@ -399,8 +399,8 @@ f->height = xf->ascent + xf->descent; { /* following change suggested by Ted Phelps <phelps@dstc.edu.au> */ - unsigned int def_char = 'n'; /*xf->default_char;*/ - unsigned int byte1, byte2; + int def_char = 'n'; /*xf->default_char;*/ + int byte1, byte2; once_more: byte1 = def_char >> 8; @@ -410,10 +410,10 @@ { /* Old versions of the R5 font server have garbage (>63k) as def_char. 'n' might not be a valid character. */ - if (byte1 < xf->min_byte1 || - byte1 > xf->max_byte1 || - byte2 < xf->min_char_or_byte2 || - byte2 > xf->max_char_or_byte2) + if (byte1 < (int) xf->min_byte1 || + byte1 > (int) xf->max_byte1 || + byte2 < (int) xf->min_char_or_byte2 || + byte2 > (int) xf->max_char_or_byte2) f->width = 0; else f->width = xf->per_char[(byte1 - xf->min_byte1) * @@ -429,7 +429,7 @@ 0 width too (unlikely) then just use the max width. */ if (f->width == 0) { - if (def_char == xf->default_char) + if (def_char == (int) xf->default_char) f->width = xf->max_bounds.width; else { @@ -598,7 +598,7 @@ if (result) { /* Verify that result is an XLFD name (roughly...) */ - if (result [0] != '-' || strlen (result) < (unsigned int) 30) + if (result [0] != '-' || strlen (result) < 30) { XFree (result); result = 0; @@ -817,7 +817,7 @@ Lisp_Object name, value; Atom atom = props [i].name; Bufbyte *name_str = 0; - size_t name_len; + Bytecount name_len; Extbyte *namestrext = XGetAtomName (dpy, atom); if (namestrext)
--- a/src/offix.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/offix.c Mon Aug 13 04:46:48 2001 +0000 @@ -356,11 +356,11 @@ return Type; } -unsigned int +int DndDragButtons(XEvent *event) { if(!DndIsDropMessage(event)) return 0; - return (unsigned int)(event->xclient.data.l[1]); + return (int)(event->xclient.data.l[1]); } Window
--- a/src/offix.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/offix.h Mon Aug 13 04:46:48 2001 +0000 @@ -39,7 +39,7 @@ int DndIsIcon(Widget widget); int DndDataType(XEvent *event); -unsigned int DndDragButtons(XEvent *event); +int DndDragButtons(XEvent *event); Window DndSourceWindow(XEvent *event); void
--- a/src/opaque.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/opaque.c Mon Aug 13 04:46:48 2001 +0000 @@ -52,14 +52,14 @@ write_c_string (buf, printcharfun); } -inline static size_t -aligned_sizeof_opaque (size_t opaque_size) +inline static Memory_Count +aligned_sizeof_opaque (Memory_Count opaque_size) { return ALIGN_SIZE (offsetof (Lisp_Opaque, data) + opaque_size, ALIGNOF (max_align_t)); } -static size_t +static Memory_Count sizeof_opaque (const void *header) { return aligned_sizeof_opaque (((const Lisp_Opaque *) header)->size); @@ -70,7 +70,7 @@ If DATA is OPAQUE_UNINIT, the object's data is uninitialized. Else the object's data is initialized by copying from DATA. */ Lisp_Object -make_opaque (const void *data, size_t size) +make_opaque (const void *data, Memory_Count size) { Lisp_Opaque *p = (Lisp_Opaque *) alloc_lcrecord (aligned_sizeof_opaque (size), &lrecord_opaque); @@ -95,7 +95,7 @@ static int equal_opaque (Lisp_Object obj1, Lisp_Object obj2, int depth) { - size_t size; + Memory_Count size; return ((size = XOPAQUE_SIZE (obj1)) == XOPAQUE_SIZE (obj2) && !memcmp (XOPAQUE_DATA (obj1), XOPAQUE_DATA (obj2), size)); } @@ -172,7 +172,8 @@ void reinit_opaque_once_early (void) { - Vopaque_ptr_free_list = make_lcrecord_list (sizeof (Lisp_Opaque_Ptr), &lrecord_opaque_ptr); + Vopaque_ptr_free_list = make_lcrecord_list (sizeof (Lisp_Opaque_Ptr), + &lrecord_opaque_ptr); staticpro_nodump (&Vopaque_ptr_free_list); }
--- a/src/opaque.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/opaque.h Mon Aug 13 04:46:48 2001 +0000 @@ -29,7 +29,7 @@ typedef struct Lisp_Opaque { struct lcrecord_header header; - size_t size; + Memory_Count size; max_align_t data[1]; } Lisp_Opaque; @@ -53,7 +53,7 @@ #define XOPAQUE_DATA(op) OPAQUE_DATA (XOPAQUE (op)) #define XOPAQUE_MARKFUN(op) OPAQUE_MARKFUN (XOPAQUE (op)) -Lisp_Object make_opaque (const void *data, size_t size); +Lisp_Object make_opaque (const void *data, Memory_Count size); typedef struct Lisp_Opaque_Ptr {
--- a/src/postgresql.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/postgresql.h Mon Aug 13 04:46:48 2001 +0000 @@ -13,7 +13,9 @@ #ifndef INCLUDED_postgresql_h_ #define INCLUDED_postgresql_h_ 1 +#define message message_ /* Yuck */ #include LIBPQ_FE_H_FILE /* main PostgreSQL header file */ +#undef message #define BLCKSZ 8192 /* size of a default Postgres disk block */ /*
--- a/src/process-nt.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/process-nt.c Mon Aug 13 04:46:48 2001 +0000 @@ -117,7 +117,7 @@ */ static int -alloc_process_memory (HANDLE h_process, size_t size, +alloc_process_memory (HANDLE h_process, Memory_Count size, process_memory* pmc) { LPTHREAD_START_ROUTINE adr_ExitThread = @@ -189,12 +189,12 @@ static DWORD run_in_other_process (HANDLE h_process, LPTHREAD_START_ROUTINE routine, - LPVOID data, size_t data_size) + LPVOID data, Memory_Count data_size) { process_memory pm; - const size_t code_size = FRAGMENT_CODE_SIZE; + const Memory_Count code_size = FRAGMENT_CODE_SIZE; /* Need at most 3 extra bytes of memory, for data alignment */ - size_t total_size = code_size + data_size + 3; + Memory_Count total_size = code_size + data_size + 3; LPVOID remote_data; HANDLE h_thread; DWORD dw_unused; @@ -1058,7 +1058,7 @@ while (1) { - Lstream_data_count writeret; + Lstream_Data_Count writeret; chunklen = Lstream_read (lstream, chunkbuf, 512); if (chunklen <= 0)
--- a/src/process-unix.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/process-unix.c Mon Aug 13 04:46:48 2001 +0000 @@ -1280,7 +1280,7 @@ while (1) { - Lstream_data_count writeret; + Lstream_Data_Count writeret; chunklen = Lstream_read (lstream, chunkbuf, 512); if (chunklen <= 0)
--- a/src/rangetab.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/rangetab.c Mon Aug 13 04:46:48 2001 +0000 @@ -204,7 +204,7 @@ { /* RIGHT might not point to a valid entry (i.e. it's at the end of the list), so NEWPOS must round down. */ - unsigned int newpos = (left + right) >> 1; + int newpos = (left + right) >> 1; struct range_table_entry *entry = tab + newpos; if (pos > entry->last) left = newpos+1;
--- a/src/redisplay-msw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/redisplay-msw.c Mon Aug 13 04:46:48 2001 +0000 @@ -342,7 +342,7 @@ Lisp_Object font = Qnil; int focus = EQ (w->frame, DEVICE_FRAME_WITH_FOCUS_REAL (d)); HDC hdc = get_frame_dc (f, 1); - unsigned int local_face_index=0; + int local_face_index = 0; char *p_char = NULL; int n_char = 0; RECT rect = { xpos,
--- a/src/redisplay-x.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/redisplay-x.c Mon Aug 13 04:46:48 2001 +0000 @@ -971,14 +971,19 @@ /* We draw underlines in the same color as the text. */ if (cachel->underline) { - unsigned long upos, uthick; + int upos, uthick; + unsigned long upos_ext, uthick_ext; XFontStruct *xfont; xfont = FONT_INSTANCE_X_FONT (XFONT_INSTANCE (font)); - if (!XGetFontProperty (xfont, XA_UNDERLINE_POSITION, &upos)) + if (!XGetFontProperty (xfont, XA_UNDERLINE_POSITION, &upos_ext)) upos = dl->descent / 2; - if (!XGetFontProperty (xfont, XA_UNDERLINE_THICKNESS, &uthick)) + else + upos = (int) upos_ext; + if (!XGetFontProperty (xfont, XA_UNDERLINE_THICKNESS, &uthick_ext)) uthick = 1; + else + uthick = (int) uthick_ext; if (dl->ypos + upos < dl->ypos + dl->descent - dl->clip) { @@ -998,39 +1003,44 @@ } } - if (cachel->strikethru) { - unsigned long ascent,descent,upos, uthick; - XFontStruct *xfont; - - xfont = FONT_INSTANCE_X_FONT (XFONT_INSTANCE (font)); + if (cachel->strikethru) + { + int ascent, descent, upos, uthick; + unsigned long ascent_ext, descent_ext, uthick_ext; + XFontStruct *xfont; - if (!XGetFontProperty (xfont, XA_STRIKEOUT_ASCENT, &ascent)) - ascent = xfont->ascent; - if (!XGetFontProperty (xfont, XA_STRIKEOUT_DESCENT, &descent)) - descent = xfont->descent; - if (!XGetFontProperty (xfont, XA_UNDERLINE_THICKNESS, &uthick)) - uthick = 1; - - upos = ascent - ((ascent + descent) / 2) + 1; + xfont = FONT_INSTANCE_X_FONT (XFONT_INSTANCE (font)); + + if (!XGetFontProperty (xfont, XA_STRIKEOUT_ASCENT, &ascent_ext)) + ascent = xfont->ascent; + else + ascent = (int) ascent_ext; + if (!XGetFontProperty (xfont, XA_STRIKEOUT_DESCENT, &descent_ext)) + descent = xfont->descent; + else + descent = (int) descent_ext; + if (!XGetFontProperty (xfont, XA_UNDERLINE_THICKNESS, &uthick_ext)) + uthick = 1; + else + uthick = (int) uthick_ext; - /* Generally, upos will be positive (above the baseline),so subtract */ - if (dl->ypos - upos < dl->ypos + dl->descent - dl->clip) - { - if (dl->ypos - upos + uthick > dl->ypos + dl->descent - dl->clip) - uthick = dl->descent - dl->clip + upos; + upos = ascent - ((ascent + descent) / 2) + 1; - if (uthick == 1) - { + /* Generally, upos will be positive (above the baseline),so + subtract */ + if (dl->ypos - upos < dl->ypos + dl->descent - dl->clip) + { + if (dl->ypos - upos + uthick > dl->ypos + dl->descent - dl->clip) + uthick = dl->descent - dl->clip + upos; + + if (uthick == 1) XDrawLine (dpy, x_win, gc, xpos, dl->ypos - upos, xpos + this_width, dl->ypos - upos); - } - else if (uthick > 1) - { + else if (uthick > 1) XFillRectangle (dpy, x_win, gc, xpos, dl->ypos + upos, this_width, uthick); - } - } - } + } + } /* Restore the GC */ if (need_clipping) @@ -1301,7 +1311,8 @@ unsigned long mask; int x, y1, y2, width, shadow_thickness, spacing, line_width; - face_index div_face = get_builtin_face_cache_index (w, Vvertical_divider_face); + face_index div_face = + get_builtin_face_cache_index (w, Vvertical_divider_face); width = window_divider_width (w); shadow_thickness = XINT (w->vertical_divider_shadow_thickness);
--- a/src/redisplay.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/redisplay.c Mon Aug 13 04:46:48 2001 +0000 @@ -775,7 +775,7 @@ struct glyph_block gb; prop_block_dynarr *retval; Bytind bi_old_cursor_bufpos = data->bi_cursor_bufpos; - unsigned int old_cursor_type = data->cursor_type; + int old_cursor_type = data->cursor_type; Bytind bi_old_bufpos = data->bi_bufpos; if (data->cursor_type == CURSOR_ON @@ -1113,7 +1113,7 @@ { prop_block_dynarr *prop, *add_failed; Emchar orig_char = data->ch; - unsigned int orig_cursor_type = data->cursor_type; + int orig_cursor_type = data->cursor_type; /* Initialize */ prop = NULL; @@ -1190,7 +1190,7 @@ { prop_block_dynarr *prop; Emchar orig_char = data->ch; - unsigned int old_cursor_type = data->cursor_type; + int old_cursor_type = data->cursor_type; /* Initialize */ prop = NULL; @@ -1382,7 +1382,7 @@ int elt; prop_block_dynarr *add_failed; Bytind bi_old_cursor_bufpos = data->bi_cursor_bufpos; - unsigned int old_cursor_type = data->cursor_type; + int old_cursor_type = data->cursor_type; for (elt = 0; elt < Dynarr_length (*prop); elt++) { @@ -5953,7 +5953,7 @@ Fset_marker (w->start[DESIRED_DISP], make_int (startp), the_buffer); truncation_changed = (find_window_mirror (w)->truncate_win != - window_truncation_on (w)); + (unsigned int) window_truncation_on (w)); /* If w->force_start is set, then some function set w->start and we should display from there and change point, if necessary, to @@ -7246,7 +7246,7 @@ { struct buffer *b = XBUFFER (w->buffer); line_start_cache_dynarr *cache = w->line_start_cache; - unsigned int top, bottom, pos; + int top, bottom, pos; validate_line_start_cache (w); w->line_cache_validation_override++; @@ -7374,7 +7374,7 @@ while (1) { - unsigned int new_pos; + int new_pos; Bufpos start, end; pos = (bottom + top + 1) >> 1; @@ -8100,7 +8100,7 @@ struct display_block *db = get_display_block_from_line (dl, TEXT); *pix_y = (dl->ypos - dl->ascent + - ((unsigned int) (dl->ascent + dl->descent - dl->clip) >> 1)); + ((dl->ascent + dl->descent - dl->clip) >> 1)); if (char_x < Dynarr_length (db->runes)) {
--- a/src/regex.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/regex.c Mon Aug 13 04:46:48 2001 +0000 @@ -180,7 +180,7 @@ memset (re_syntax_table, 0, sizeof (re_syntax_table)); while (*word_syntax_chars) - re_syntax_table[(unsigned int)(*word_syntax_chars++)] = Sword; + re_syntax_table[(unsigned int) (*word_syntax_chars++)] = Sword; done = 1; } @@ -647,8 +647,8 @@ static void print_fastmap (char *fastmap) { - unsigned was_a_range = 0; - unsigned i = 0; + int was_a_range = 0; + int i = 0; while (i < (1 << BYTEWIDTH)) { @@ -1006,7 +1006,7 @@ printf ("(null)"); else { - unsigned int this_char; + int this_char; if (FIRST_STRING_P (where)) { @@ -1166,8 +1166,8 @@ typedef struct { fail_stack_elt_t *stack; - size_t size; - size_t avail; /* Offset of next open position. */ + Element_Count size; + Element_Count avail; /* Offset of next open position. */ } fail_stack_type; #define FAIL_STACK_EMPTY() (fail_stack.avail == 0) @@ -1291,11 +1291,11 @@ \ DEBUG_STATEMENT (failure_id++); \ DEBUG_STATEMENT (nfailure_points_pushed++); \ - DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%u:\n", failure_id); \ - DEBUG_PRINT2 (" Before push, next avail: %lu\n", \ - (unsigned long) (fail_stack).avail); \ - DEBUG_PRINT2 (" size: %lu\n", \ - (unsigned long) (fail_stack).size); \ + DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%d:\n", failure_id); \ + DEBUG_PRINT2 (" Before push, next avail: %ld\n", \ + (long) (fail_stack).avail); \ + DEBUG_PRINT2 (" size: %ld\n", \ + (long) (fail_stack).size); \ \ DEBUG_PRINT2 (" slots needed: %d\n", NUM_FAILURE_ITEMS); \ DEBUG_PRINT2 (" available: %ld\n", \ @@ -1307,8 +1307,8 @@ if (!DOUBLE_FAIL_STACK (fail_stack)) \ return failure_code; \ \ - DEBUG_PRINT2 ("\n Doubled stack; size now: %lu\n", \ - (unsigned long) (fail_stack).size); \ + DEBUG_PRINT2 ("\n Doubled stack; size now: %ld\n", \ + (long) (fail_stack).size); \ DEBUG_PRINT2 (" slots available: %ld\n", \ (long) REMAINING_AVAIL_SLOTS); \ } \ @@ -1410,16 +1410,16 @@ \ /* Remove failure points and point to how many regs pushed. */ \ DEBUG_PRINT1 ("POP_FAILURE_POINT:\n"); \ - DEBUG_PRINT2 (" Before pop, next avail: %lu\n", \ - (unsigned long) fail_stack.avail); \ - DEBUG_PRINT2 (" size: %lu\n", \ - (unsigned long) fail_stack.size); \ + DEBUG_PRINT2 (" Before pop, next avail: %ld\n", \ + (long) fail_stack.avail); \ + DEBUG_PRINT2 (" size: %ld\n", \ + (long) fail_stack.size); \ \ assert (fail_stack.avail >= NUM_NONREG_ITEMS); \ \ DEBUG_POP (&ffailure_id.integer); \ - DEBUG_PRINT2 (" Popping failure id: %u\n", \ - * (unsigned int *) &ffailure_id); \ + DEBUG_PRINT2 (" Popping failure id: %d\n", \ + * (int *) &ffailure_id); \ \ /* If the saved string location is NULL, it came from an \ on_failure_keep_string_jump opcode, and we want to throw away the \ @@ -1437,10 +1437,10 @@ DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \ \ /* Restore register info. */ \ - high_reg = (unsigned) POP_FAILURE_INT (); \ + high_reg = POP_FAILURE_INT (); \ DEBUG_PRINT2 (" Popping high active reg: %d\n", high_reg); \ \ - low_reg = (unsigned) POP_FAILURE_INT (); \ + low_reg = POP_FAILURE_INT (); \ DEBUG_PRINT2 (" Popping low active reg: %d\n", low_reg); \ \ for (this_reg = high_reg; this_reg >= low_reg; this_reg--) \ @@ -1483,10 +1483,10 @@ /* This field is one if this group can match the empty string, zero if not. If not yet determined, `MATCH_NULL_UNSET_VALUE'. */ #define MATCH_NULL_UNSET_VALUE 3 - unsigned match_null_string_p : 2; - unsigned is_active : 1; - unsigned matched_something : 1; - unsigned ever_matched_something : 1; + unsigned int match_null_string_p : 2; + unsigned int is_active : 1; + unsigned int matched_something : 1; + unsigned int ever_matched_something : 1; } bits; } register_info_type; @@ -1504,7 +1504,7 @@ { \ if (!set_regs_matched_done) \ { \ - unsigned r; \ + int r; \ set_regs_matched_done = 1; \ for (r = lowest_active_reg; r <= highest_active_reg; r++) \ { \ @@ -1617,7 +1617,7 @@ /* Make sure we have at least N more bytes of space in buffer. */ #define GET_BUFFER_SPACE(n) \ - while (buf_end - bufp->buffer + (n) > bufp->allocated) \ + while (buf_end - bufp->buffer + (n) > (ptrdiff_t) bufp->allocated) \ EXTEND_BUFFER () /* Make sure we have one more byte of buffer space and then add C to it. */ @@ -1713,7 +1713,7 @@ #### not true! groups past this will fail in lots of ways, if we ever have to backtrack. */ -typedef unsigned regnum_t; +typedef int regnum_t; #define INIT_REG_TRANSLATE_SIZE 5 @@ -1736,8 +1736,8 @@ typedef struct { compile_stack_elt_t *stack; - unsigned size; - unsigned avail; /* Offset of next open position. */ + int size; + int avail; /* Offset of next open position. */ } compile_stack_type; @@ -1971,7 +1971,7 @@ DEBUG_PRINT1 ("\nCompiling pattern: "); if (debug) { - unsigned debug_count; + int debug_count; for (debug_count = 0; debug_count < size; debug_count++) putchar (pattern[debug_count]); @@ -2901,7 +2901,7 @@ else { /* If the upper bound is > 1, we need to insert more at the end of the loop. */ - unsigned nbytes = 10 + (upper_bound > 1) * 10; + int nbytes = 10 + (upper_bound > 1) * 10; GET_BUFFER_SPACE (nbytes); @@ -3395,7 +3395,7 @@ compile_range (re_char **p_ptr, re_char *pend, RE_TRANSLATE_TYPE translate, reg_syntax_t syntax, unsigned char *buf_end) { - unsigned this_char; + Emchar this_char; re_char *p = *p_ptr; int range_start, range_end; @@ -3522,7 +3522,7 @@ REGISTER char *fastmap = bufp->fastmap; unsigned char *pattern = bufp->buffer; - unsigned long size = bufp->used; + long size = bufp->used; unsigned char *p = pattern; REGISTER unsigned char *pend = pattern + size; @@ -4000,7 +4000,7 @@ void re_set_registers (struct re_pattern_buffer *bufp, struct re_registers *regs, - unsigned num_regs, regoff_t *starts, regoff_t *ends) + int num_regs, regoff_t *starts, regoff_t *ends) { if (num_regs) { @@ -4127,7 +4127,7 @@ #ifdef REGEX_BEGLINE_CHECK { - int i = 0; + long i = 0; while (i < bufp->used) { @@ -4478,8 +4478,8 @@ fail_stack_type fail_stack; #endif #ifdef DEBUG - static unsigned failure_id; - unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0; + static int failure_id; + int nfailure_points_pushed = 0, nfailure_points_popped = 0; #endif #ifdef REL_ALLOC @@ -4491,11 +4491,11 @@ /* We fill all the registers internally, independent of what we return, for use in backreferences. The number here includes an element for register zero. */ - unsigned num_regs = bufp->re_ngroups + 1; + int num_regs = bufp->re_ngroups + 1; /* The currently active registers. */ - unsigned lowest_active_reg = NO_LOWEST_ACTIVE_REG; - unsigned highest_active_reg = NO_HIGHEST_ACTIVE_REG; + int lowest_active_reg = NO_LOWEST_ACTIVE_REG; + int highest_active_reg = NO_HIGHEST_ACTIVE_REG; /* Information on the contents of registers. These are pointers into the input strings; they record just what was matched (on this @@ -4531,7 +4531,7 @@ variables when we find a match better than any we've seen before. This happens as we backtrack through the failure points, which in turn happens only if we have not yet matched the entire string. */ - unsigned best_regs_set = false; + int best_regs_set = false; #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */ re_char **best_regstart, **best_regend; #endif @@ -4557,7 +4557,7 @@ #ifdef DEBUG /* Counts the total number of registers pushed. */ - unsigned num_regs_pushed = 0; + int num_regs_pushed = 0; #endif /* 1 if this match ends in the same string (string1 or string2) @@ -4937,9 +4937,9 @@ REGEX_PREFETCH (); c = TRANSLATE (*d); /* The character to match. */ - /* Cast to `unsigned' instead of `unsigned char' in case the + /* Cast to `unsigned int' instead of `unsigned char' in case the bit list is a full 32 bytes long. */ - if (c < (unsigned) (*p * BYTEWIDTH) + if (c < (unsigned int) (*p * BYTEWIDTH) && p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) not_p = !not_p; @@ -5146,7 +5146,7 @@ if (EVER_MATCHED_SOMETHING (reg_info[*p])) { - unsigned r; + int r; EVER_MATCHED_SOMETHING (reg_info[*p]) = 0; @@ -5535,7 +5535,7 @@ actual values. Otherwise, we will restore only one register from the stack, since lowest will == highest in `pop_failure_point'. */ - unsigned dummy_low_reg, dummy_high_reg; + int dummy_low_reg, dummy_high_reg; unsigned char *pdummy; re_char *sdummy = NULL; @@ -6362,7 +6362,7 @@ regcomp (regex_t *preg, const char *pattern, int cflags) { reg_errcode_t ret; - unsigned syntax + unsigned int syntax = (cflags & REG_EXTENDED) ? RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC; @@ -6379,7 +6379,7 @@ if (cflags & REG_ICASE) { - unsigned i; + int i; preg->translate = (char *) malloc (CHAR_SET_SIZE); if (preg->translate == NULL) @@ -6453,9 +6453,9 @@ if (want_reg_info) { - regs.num_regs = nmatch; - regs.start = TALLOC (nmatch, regoff_t); - regs.end = TALLOC (nmatch, regoff_t); + regs.num_regs = (int) nmatch; + regs.start = TALLOC ((int) nmatch, regoff_t); + regs.end = TALLOC ((int) nmatch, regoff_t); if (regs.start == NULL || regs.end == NULL) return (int) REG_NOMATCH; } @@ -6470,9 +6470,9 @@ { if (ret >= 0) { - unsigned r; - - for (r = 0; r < nmatch; r++) + int r; + + for (r = 0; r < (int) nmatch; r++) { pmatch[r].rm_so = regs.start[r]; pmatch[r].rm_eo = regs.end[r]; @@ -6493,13 +6493,15 @@ from either regcomp or regexec. We don't use PREG here. */ size_t -regerror (int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size) +regerror (int errcode, const regex_t *preg, char *errbuf, + size_t errbuf_size) { const char *msg; - size_t msg_size; + Memory_Count msg_size; if (errcode < 0 - || errcode >= (sizeof (re_error_msgid) / sizeof (re_error_msgid[0]))) + || errcode >= (int) (sizeof (re_error_msgid) / + sizeof (re_error_msgid[0]))) /* Only error codes returned by the rest of the code should be passed to this routine. If we are given anything else, or if other regex code generates an invalid error code, then the program has a bug. @@ -6512,7 +6514,7 @@ if (errbuf_size != 0) { - if (msg_size > errbuf_size) + if (msg_size > (Memory_Count) errbuf_size) { strncpy (errbuf, msg, errbuf_size - 1); errbuf[errbuf_size - 1] = 0; @@ -6521,7 +6523,7 @@ strcpy (errbuf, msg); } - return msg_size; + return (size_t) msg_size; }
--- a/src/regex.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/regex.h Mon Aug 13 04:46:48 2001 +0000 @@ -27,6 +27,8 @@ #define RE_TRANSLATE_TYPE Lisp_Object #else #define RE_TRANSLATE_TYPE char * +#define Element_Count ssize_t +#define Memory_Count ssize_t #endif /* emacs */ /* POSIX says that <sys/types.h> must be included (by the caller) before @@ -325,10 +327,10 @@ unsigned char *buffer; /* Number of bytes to which `buffer' points. */ - unsigned long allocated; + long allocated; /* Number of bytes actually used in `buffer'. */ - unsigned long used; + long used; /* Syntax setting with which the pattern was compiled. */ reg_syntax_t syntax; @@ -346,7 +348,7 @@ /* Number of returnable groups found by the compiler. (This does not count shy groups.) */ - size_t re_nsub; + int re_nsub; /* Total number of groups found by the compiler. (Including shy ones.) */ @@ -357,7 +359,7 @@ whether or not we should use the fastmap, so we don't set this absolutely perfectly; see `re_compile_fastmap' (the `duplicate' case). */ - unsigned can_be_null : 1; + unsigned int can_be_null : 1; /* If REGS_UNALLOCATED, allocate space in the `regs' structure for `max (RE_NREGS, re_nsub + 1)' groups. @@ -366,27 +368,27 @@ #define REGS_UNALLOCATED 0 #define REGS_REALLOCATE 1 #define REGS_FIXED 2 - unsigned regs_allocated : 2; + unsigned int regs_allocated : 2; /* Set to zero when `regex_compile' compiles a pattern; set to one by `re_compile_fastmap' if it updates the fastmap. */ - unsigned fastmap_accurate : 1; + unsigned int fastmap_accurate : 1; /* If set, `re_match_2' does not return information about subexpressions. */ - unsigned no_sub : 1; + unsigned int no_sub : 1; /* If set, a beginning-of-line anchor doesn't match at the beginning of the string. */ - unsigned not_bol : 1; + unsigned int not_bol : 1; /* Similarly for an end-of-line anchor. */ - unsigned not_eol : 1; + unsigned int not_eol : 1; /* If true, an anchor at a newline matches. */ - unsigned newline_anchor : 1; + unsigned int newline_anchor : 1; - unsigned warned_about_incompatible_back_references : 1; + unsigned int warned_about_incompatible_back_references : 1; /* Mapping between back references and groups (may not be equivalent with shy groups). */ @@ -407,7 +409,7 @@ regex.texinfo for a full description of what registers match. */ struct re_registers { - unsigned num_regs; + int num_regs; regoff_t *start; regoff_t *end; }; @@ -491,7 +493,7 @@ PATTERN_BUFFER will allocate its own register data, without freeing the old data. */ void re_set_registers (struct re_pattern_buffer *buffer, - struct re_registers *regs, unsigned num_regs, + struct re_registers *regs, int num_regs, regoff_t *starts, regoff_t *ends); #ifdef _REGEX_RE_COMP
--- a/src/s/esix.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/s/esix.h Mon Aug 13 04:46:48 2001 +0000 @@ -11,7 +11,9 @@ /* If using Roell's X server, define X11R4 */ #ifdef X11R4 /* Roell's X server */ +#if 0 /* XEmacs */ #define select sys_select /* Emacs select() not good enough? */ +#endif #endif /* X11R4 */ /* ESIX does not need <sys/sioctl.h>, but needs <sys/ptem.h> */
--- a/src/search.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/search.c Mon Aug 13 04:46:48 2001 +0000 @@ -876,7 +876,7 @@ in the comparisons below. */ if (negate) - for (i = 0; i < (int) (sizeof fastmap); i++) + for (i = 0; i < (int) (sizeof (fastmap)); i++) fastmap[i] ^= 1; {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/select-common.h Mon Aug 13 04:46:48 2001 +0000 @@ -0,0 +1,339 @@ +/* Selection processing for XEmacs -- common btwn select-x.c and select-gtk.c + Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. + +This file is part of XEmacs. + +XEmacs is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 2, or (at your option) any +later version. + +XEmacs is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. + +You should have received a copy of the GNU General Public License +along with XEmacs; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + +/* Synched up with: Not synched with FSF. */ + +#ifdef PROCESSING_X_CODE +#define XE_ATOM_TYPE Atom +#define XE_ATOM_TO_SYMBOL x_atom_to_symbol +#define XE_SYMBOL_TO_ATOM symbol_to_x_atom +#else +#define XE_ATOM_TYPE GdkAtom +#define XE_ATOM_TO_SYMBOL atom_to_symbol +#define XE_SYMBOL_TO_ATOM symbol_to_gtk_atom +#endif /* PROCESSING_X_CODE */ + +/* #### These are going to move into Lisp code(!) with the aid of + some new functions I'm working on - ajh */ + +/* These functions convert from the selection data read from the server into + something that we can use from elisp, and vice versa. + + Type: Format: Size: Elisp Type: + ----- ------- ----- ----------- + * 8 * String + ATOM 32 1 Symbol + ATOM 32 > 1 Vector of Symbols + * 16 1 Integer + * 16 > 1 Vector of Integers + * 32 1 if <=16 bits: Integer + if > 16 bits: Cons of top16, bot16 + * 32 > 1 Vector of the above + + When converting a Lisp number to C, it is assumed to be of format 16 if + it is an integer, and of format 32 if it is a cons of two integers. + + When converting a vector of numbers from Elisp to C, it is assumed to be + of format 16 if every element in the vector is an integer, and is assumed + to be of format 32 if any element is a cons of two integers. + + When converting an object to C, it may be of the form (SYMBOL . <data>) + where SYMBOL is what we should claim that the type is. Format and + representation are as above. + + NOTE: Under Mule, when someone shoves us a string without a type, we + set the type to 'COMPOUND_TEXT and automatically convert to Compound + Text. If the string has a type, we assume that the user wants the + data sent as-is so we just do "binary" conversion. + */ + + +static Lisp_Object +selection_data_to_lisp_data (struct device *d, + UChar_Binary *data, + Memory_Count size, + XE_ATOM_TYPE type, + int format) +{ +#ifdef PROCESSING_X_CODE + if (type == DEVICE_XATOM_NULL (d)) + return QNULL; + + /* Convert any 8-bit data to a string, for compactness. */ + else if (format == 8) + return make_ext_string ((Extbyte *) data, size, + type == DEVICE_XATOM_TEXT (d) || + type == DEVICE_XATOM_COMPOUND_TEXT (d) + ? Qctext : Qbinary); + + /* Convert a single atom to a Lisp Symbol. + Convert a set of atoms to a vector of symbols. */ + else if (type == XA_ATOM) +#else + if (type == gdk_atom_intern ("NULL", 0)) + return QNULL; + + /* Convert any 8-bit data to a string, for compactness. */ + else if (format == 8) + return make_ext_string ((Extbyte *) data, size, + ((type == gdk_atom_intern ("TEXT", FALSE)) || + (type == gdk_atom_intern ("COMPOUND_TEXT", FALSE))) + ? Qctext : Qbinary); + + /* Convert a single atom to a Lisp Symbol. + Convert a set of atoms to a vector of symbols. */ + else if (type == gdk_atom_intern ("ATOM", FALSE)) +#endif /* PROCESSING_X_CODE */ + { + if (size == sizeof (XE_ATOM_TYPE)) + return XE_ATOM_TO_SYMBOL (d, *((XE_ATOM_TYPE *) data)); + else + { + Element_Count i; + Element_Count len = size / sizeof (XE_ATOM_TYPE); + Lisp_Object v = Fmake_vector (make_int (len), Qzero); + for (i = 0; i < len; i++) + Faset (v, make_int (i), XE_ATOM_TO_SYMBOL (d, ((XE_ATOM_TYPE *) data) [i])); + return v; + } + } + + /* Convert a single 16 or small 32 bit number to a Lisp Int. + If the number is > 16 bits, convert it to a cons of integers, + 16 bits in each half. + */ + else if (format == 32 && size == sizeof (long)) + return word_to_lisp (((unsigned long *) data) [0]); + else if (format == 16 && size == sizeof (short)) + return make_int ((int) (((unsigned short *) data) [0])); + + /* Convert any other kind of data to a vector of numbers, represented + as above (as an integer, or a cons of two 16 bit integers). + + #### Perhaps we should return the actual type to lisp as well. + + (x-get-selection-internal 'PRIMARY 'LINE_NUMBER) + ==> [4 4] + + and perhaps it should be + + (x-get-selection-internal 'PRIMARY 'LINE_NUMBER) + ==> (SPAN . [4 4]) + + Right now the fact that the return type was SPAN is discarded before + lisp code gets to see it. + */ + else if (format == 16) + { + Element_Count i; + Lisp_Object v = make_vector (size / 4, Qzero); + for (i = 0; i < size / 4; i++) + { + int j = (int) ((unsigned short *) data) [i]; + Faset (v, make_int (i), make_int (j)); + } + return v; + } + else + { + Element_Count i; + Lisp_Object v = make_vector (size / 4, Qzero); + for (i = 0; i < size / 4; i++) + { + unsigned long j = ((unsigned long *) data) [i]; + Faset (v, make_int (i), word_to_lisp (j)); + } + return v; + } +} + + +static void +lisp_data_to_selection_data (struct device *d, + Lisp_Object obj, + UChar_Binary **data_ret, + XE_ATOM_TYPE *type_ret, + Memory_Count *size_ret, + int *format_ret) +{ + Lisp_Object type = Qnil; + + if (CONSP (obj) && SYMBOLP (XCAR (obj))) + { + type = XCAR (obj); + obj = XCDR (obj); + if (CONSP (obj) && NILP (XCDR (obj))) + obj = XCAR (obj); + } + + if (EQ (obj, QNULL) || (EQ (type, QNULL))) + { /* This is not the same as declining */ + *format_ret = 32; + *size_ret = 0; + *data_ret = 0; + type = QNULL; + } + else if (STRINGP (obj)) + { + const Extbyte *extval; + Extcount extvallen; + + TO_EXTERNAL_FORMAT (LISP_STRING, obj, + ALLOCA, (extval, extvallen), + (NILP (type) ? Qctext : Qbinary)); + *format_ret = 8; + *size_ret = extvallen; + *data_ret = (UChar_Binary *) xmalloc (*size_ret); + memcpy (*data_ret, extval, *size_ret); +#ifdef MULE + if (NILP (type)) type = QCOMPOUND_TEXT; +#else + if (NILP (type)) type = QSTRING; +#endif + } + else if (CHARP (obj)) + { + Bufbyte buf[MAX_EMCHAR_LEN]; + Bytecount len; + const Extbyte *extval; + Extcount extvallen; + + *format_ret = 8; + len = set_charptr_emchar (buf, XCHAR (obj)); + TO_EXTERNAL_FORMAT (DATA, (buf, len), + ALLOCA, (extval, extvallen), + Qctext); + *size_ret = extvallen; + *data_ret = (UChar_Binary *) xmalloc (*size_ret); + memcpy (*data_ret, extval, *size_ret); +#ifdef MULE + if (NILP (type)) type = QCOMPOUND_TEXT; +#else + if (NILP (type)) type = QSTRING; +#endif + } + else if (SYMBOLP (obj)) + { + *format_ret = 32; + *size_ret = 1; + *data_ret = (UChar_Binary *) xmalloc (sizeof (XE_ATOM_TYPE) + 1); + (*data_ret) [sizeof (XE_ATOM_TYPE)] = 0; + (*(XE_ATOM_TYPE **) data_ret) [0] = XE_SYMBOL_TO_ATOM (d, obj, 0); + if (NILP (type)) type = QATOM; + } + else if (INTP (obj) && + XINT (obj) <= 0x7FFF && + XINT (obj) >= -0x8000) + { + *format_ret = 16; + *size_ret = 1; + *data_ret = (UChar_Binary *) xmalloc (sizeof (short) + 1); + (*data_ret) [sizeof (short)] = 0; + (*(short **) data_ret) [0] = (short) XINT (obj); + if (NILP (type)) type = QINTEGER; + } + else if (INTP (obj) || CONSP (obj)) + { + *format_ret = 32; + *size_ret = 1; + *data_ret = (UChar_Binary *) xmalloc (sizeof (long) + 1); + (*data_ret) [sizeof (long)] = 0; + (*(unsigned long **) data_ret) [0] = lisp_to_word (obj); + if (NILP (type)) type = QINTEGER; + } + else if (VECTORP (obj)) + { + /* Lisp Vectors may represent a set of ATOMs; + a set of 16 or 32 bit INTEGERs; + or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...] + */ + Element_Count i; + + if (SYMBOLP (XVECTOR_DATA (obj) [0])) + /* This vector is an ATOM set */ + { + if (NILP (type)) type = QATOM; + *size_ret = XVECTOR_LENGTH (obj); + *format_ret = 32; + *data_ret = (UChar_Binary *) xmalloc ((*size_ret) * sizeof (XE_ATOM_TYPE)); + for (i = 0; i < *size_ret; i++) + if (SYMBOLP (XVECTOR_DATA (obj) [i])) + (*(XE_ATOM_TYPE **) data_ret) [i] = + XE_SYMBOL_TO_ATOM (d, XVECTOR_DATA (obj) [i], 0); + else + syntax_error + ("all elements of the vector must be of the same type", obj); + } +#if 0 /* #### MULTIPLE doesn't work yet */ + else if (VECTORP (XVECTOR_DATA (obj) [0])) + /* This vector is an ATOM_PAIR set */ + { + if (NILP (type)) type = QATOM_PAIR; + *size_ret = XVECTOR_LENGTH (obj); + *format_ret = 32; + *data_ret = (UChar_Binary *) + xmalloc ((*size_ret) * sizeof (XE_ATOM_TYPE) * 2); + for (i = 0; i < *size_ret; i++) + if (VECTORP (XVECTOR_DATA (obj) [i])) + { + Lisp_Object pair = XVECTOR_DATA (obj) [i]; + if (XVECTOR_LENGTH (pair) != 2) + syntax_error + ("elements of the vector must be vectors of exactly two elements", pair); + + (*(XE_ATOM_TYPE **) data_ret) [i * 2] = + XE_SYMBOL_TO_ATOM (d, XVECTOR_DATA (pair) [0], 0); + (*(XE_ATOM_TYPE **) data_ret) [(i * 2) + 1] = + XE_SYMBOL_TO_ATOM (d, XVECTOR_DATA (pair) [1], 0); + } + else + syntax_error + ("all elements of the vector must be of the same type", obj); + } +#endif + else + /* This vector is an INTEGER set, or something like it */ + { + *size_ret = XVECTOR_LENGTH (obj); + if (NILP (type)) type = QINTEGER; + *format_ret = 16; + for (i = 0; i < *size_ret; i++) + if (CONSP (XVECTOR_DATA (obj) [i])) + *format_ret = 32; + else if (!INTP (XVECTOR_DATA (obj) [i])) + syntax_error + ("all elements of the vector must be integers or conses of integers", obj); + + *data_ret = (UChar_Binary *) xmalloc (*size_ret * (*format_ret/8)); + for (i = 0; i < *size_ret; i++) + if (*format_ret == 32) + (*((unsigned long **) data_ret)) [i] = + lisp_to_word (XVECTOR_DATA (obj) [i]); + else + (*((unsigned short **) data_ret)) [i] = + (unsigned short) lisp_to_word (XVECTOR_DATA (obj) [i]); + } + } + else + invalid_argument ("unrecognized selection data", obj); + + *type_ret = XE_SYMBOL_TO_ATOM (d, type, 0); +} +
--- a/src/select-gtk.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/select-gtk.c Mon Aug 13 04:46:48 2001 +0000 @@ -42,21 +42,46 @@ static gboolean waiting_for_selection; Lisp_Object Vgtk_sent_selection_hooks; -static Lisp_Object atom_to_symbol (struct device *d, GdkAtom atom); -static GdkAtom symbol_to_gtk_atom (struct device *d, Lisp_Object sym, int only_if_exists); +static GdkAtom +symbol_to_gtk_atom (struct device *d, Lisp_Object sym, int only_if_exists) +{ + if (NILP (sym)) return GDK_SELECTION_PRIMARY; + if (EQ (sym, Qt)) return GDK_SELECTION_SECONDARY; + if (EQ (sym, QPRIMARY)) return GDK_SELECTION_PRIMARY; + if (EQ (sym, QSECONDARY)) return GDK_SELECTION_SECONDARY; + + { + const Extbyte *nameext; + LISP_STRING_TO_EXTERNAL (Fsymbol_name (sym), nameext, Qctext); + return gdk_atom_intern (nameext, only_if_exists ? TRUE : FALSE); + } +} -static void lisp_data_to_selection_data (struct device *, - Lisp_Object obj, - unsigned char **data_ret, - GdkAtom *type_ret, - unsigned int *size_ret, - int *format_ret); -static Lisp_Object selection_data_to_lisp_data (struct device *, - Extbyte *data, - size_t size, - GdkAtom type, - int format); +static Lisp_Object +atom_to_symbol (struct device *d, GdkAtom atom) +{ + if (atom == GDK_SELECTION_PRIMARY) return (QPRIMARY); + if (atom == GDK_SELECTION_SECONDARY) return (QSECONDARY); + + { + CBufbyte *intstr; + Extbyte *str = gdk_atom_name (atom); + + if (! str) return Qnil; + TO_INTERNAL_FORMAT (C_STRING, str, + C_STRING_ALLOCA, intstr, + Qctext); + g_free (str); + return intern (intstr); + } +} + +#define PROCESSING_GTK_CODE +#include "select-common.h" +#undef PROCESSING_GTK_CODE + + /* Set the selection data to GDK_NONE and NULL data, meaning we were ** unable to do what they wanted. */ @@ -170,14 +195,16 @@ make_opaque_ptr (cl)); { - unsigned char *data; - unsigned int size; + UChar_Binary *data; + Memory_Count size; int format; GdkAtom type; lisp_data_to_selection_data (d, converted_selection, &data, &type, &size, &format); - gtk_selection_data_set (selection_data, type, format, data, size); + gtk_selection_data_set (selection_data, type, format, data, + /* #### is this right? */ + (unsigned int) size); successful_p = Qt; /* Tell x_selection_request_lisp_error() it's cool. */ cl->successful = TRUE; @@ -306,66 +333,7 @@ GdkAtom *actual_type_ret, int *actual_format_ret, unsigned long *actual_size_ret, int delete_p) { - size_t total_size; - unsigned long bytes_remaining; - int offset = 0; - unsigned char *tmp_data = 0; - int result; - int buffer_size = SELECTION_QUANTUM (display); - if (buffer_size > MAX_SELECTION_QUANTUM) buffer_size = MAX_SELECTION_QUANTUM; - - /* First probe the thing to find out how big it is. */ - result = XGetWindowProperty (display, window, property, - 0, 0, False, AnyPropertyType, - actual_type_ret, actual_format_ret, - actual_size_ret, - &bytes_remaining, &tmp_data); - if (result != Success) - { - *data_ret = 0; - *bytes_ret = 0; - return; - } - XFree ((char *) tmp_data); - - if (*actual_type_ret == None || *actual_format_ret == 0) - { - if (delete_p) XDeleteProperty (display, window, property); - *data_ret = 0; - *bytes_ret = 0; - return; - } - - total_size = bytes_remaining + 1; - *data_ret = (Extbyte *) xmalloc (total_size); - - /* Now read, until we've gotten it all. */ - while (bytes_remaining) - { -#if 0 - int last = bytes_remaining; -#endif - result = - XGetWindowProperty (display, window, property, - offset/4, buffer_size/4, - (delete_p ? True : False), - AnyPropertyType, - actual_type_ret, actual_format_ret, - actual_size_ret, &bytes_remaining, &tmp_data); -#if 0 - stderr_out ("<< read %d\n", last-bytes_remaining); -#endif - /* If this doesn't return Success at this point, it means that - some clod deleted the selection while we were in the midst of - reading it. Deal with that, I guess.... - */ - if (result != Success) break; - *actual_size_ret *= *actual_format_ret / 8; - memcpy ((*data_ret) + offset, tmp_data, *actual_size_ret); - offset += *actual_size_ret; - XFree ((char *) tmp_data); - } - *bytes_ret = offset; + /* deleted */ } @@ -378,64 +346,7 @@ Atom *type_ret, int *format_ret, unsigned long *size_ret) { - /* This function can GC */ - int offset = 0; - int prop_id; - *size_bytes_ret = min_size_bytes; - *data_ret = (Extbyte *) xmalloc (*size_bytes_ret); -#if 0 - stderr_out ("\nread INCR %d\n", min_size_bytes); -#endif - /* At this point, we have read an INCR property, and deleted it (which - is how we ack its receipt: the sending window will be selecting - PropertyNotify events on our window to notice this). - - Now, we must loop, waiting for the sending window to put a value on - that property, then reading the property, then deleting it to ack. - We are done when the sender places a property of length 0. - */ - prop_id = expect_property_change (display, window, property, - PropertyNewValue); - while (1) - { - Extbyte *tmp_data; - int tmp_size_bytes; - wait_for_property_change (prop_id); - /* expect it again immediately, because x_get_window_property may - .. no it won't, I don't get it. - .. Ok, I get it now, the Xt code that implements INCR is broken. - */ - prop_id = expect_property_change (display, window, property, - PropertyNewValue); - x_get_window_property (display, window, property, - &tmp_data, &tmp_size_bytes, - type_ret, format_ret, size_ret, 1); - - if (tmp_size_bytes == 0) /* we're done */ - { -#if 0 - stderr_out (" read INCR done\n"); -#endif - unexpect_property_change (prop_id); - if (tmp_data) xfree (tmp_data); - break; - } -#if 0 - stderr_out (" read INCR %d\n", tmp_size_bytes); -#endif - if (*size_bytes_ret < offset + tmp_size_bytes) - { -#if 0 - stderr_out (" read INCR realloc %d -> %d\n", - *size_bytes_ret, offset + tmp_size_bytes); -#endif - *size_bytes_ret = offset + tmp_size_bytes; - *data_ret = (Extbyte *) xrealloc (*data_ret, *size_bytes_ret); - } - memcpy ((*data_ret) + offset, tmp_data, tmp_size_bytes); - offset += tmp_size_bytes; - xfree (tmp_data); - } + /* deleted */ } @@ -447,385 +358,11 @@ Lisp_Object target_type, GdkAtom selection_atom) { - /* This function can GC */ - Atom actual_type; - int actual_format; - unsigned long actual_size; - Extbyte *data = NULL; - int bytes = 0; - Lisp_Object val; - struct device *d = get_device_from_display (display); - - x_get_window_property (display, window, property, &data, &bytes, - &actual_type, &actual_format, &actual_size, 1); - if (! data) - { - if (XGetSelectionOwner (display, selection_atom)) - /* there is a selection owner */ - signal_error (Qselection_conversion_error, - "selection owner couldn't convert", - Fcons (Qunbound, - Fcons (x_atom_to_symbol (d, selection_atom), - actual_type ? - list2 (target_type, - x_atom_to_symbol (d, actual_type)) : - list1 (target_type)))); - else - signal_error (Qselection_conversion_error, - "no selection", - x_atom_to_symbol (d, selection_atom)); - } - - if (actual_type == DEVICE_XATOM_INCR (d)) - { - /* Ok, that data wasn't *the* data, it was just the beginning. */ - - unsigned int min_size_bytes = * ((unsigned int *) data); - xfree (data); - receive_incremental_selection (display, window, property, target_type, - min_size_bytes, &data, &bytes, - &actual_type, &actual_format, - &actual_size); - } - - /* It's been read. Now convert it to a lisp object in some semi-rational - manner. */ - val = selection_data_to_lisp_data (d, data, bytes, - actual_type, actual_format); - - xfree (data); - return val; + /* deleted */ } #endif -static GdkAtom -symbol_to_gtk_atom (struct device *d, Lisp_Object sym, int only_if_exists) -{ - if (NILP (sym)) return GDK_SELECTION_PRIMARY; - if (EQ (sym, Qt)) return GDK_SELECTION_SECONDARY; - if (EQ (sym, QPRIMARY)) return GDK_SELECTION_PRIMARY; - if (EQ (sym, QSECONDARY)) return GDK_SELECTION_SECONDARY; - - { - const char *nameext; - LISP_STRING_TO_EXTERNAL (Fsymbol_name (sym), nameext, Qctext); - return gdk_atom_intern (nameext, only_if_exists ? TRUE : FALSE); - } -} - -static Lisp_Object -atom_to_symbol (struct device *d, GdkAtom atom) -{ - if (atom == GDK_SELECTION_PRIMARY) return (QPRIMARY); - if (atom == GDK_SELECTION_SECONDARY) return (QSECONDARY); - - { - char *intstr; - char *str = gdk_atom_name (atom); - - if (! str) return Qnil; - - TO_INTERNAL_FORMAT (C_STRING, str, - C_STRING_ALLOCA, intstr, - Qctext); - g_free (str); - return intern (intstr); - } -} - -/* #### These are going to move into Lisp code(!) with the aid of - some new functions I'm working on - ajh */ - -/* These functions convert from the selection data read from the server into - something that we can use from elisp, and vice versa. - - Type: Format: Size: Elisp Type: - ----- ------- ----- ----------- - * 8 * String - ATOM 32 1 Symbol - ATOM 32 > 1 Vector of Symbols - * 16 1 Integer - * 16 > 1 Vector of Integers - * 32 1 if <=16 bits: Integer - if > 16 bits: Cons of top16, bot16 - * 32 > 1 Vector of the above - - When converting a Lisp number to C, it is assumed to be of format 16 if - it is an integer, and of format 32 if it is a cons of two integers. - - When converting a vector of numbers from Elisp to C, it is assumed to be - of format 16 if every element in the vector is an integer, and is assumed - to be of format 32 if any element is a cons of two integers. - - When converting an object to C, it may be of the form (SYMBOL . <data>) - where SYMBOL is what we should claim that the type is. Format and - representation are as above. - - NOTE: Under Mule, when someone shoves us a string without a type, we - set the type to 'COMPOUND_TEXT and automatically convert to Compound - Text. If the string has a type, we assume that the user wants the - data sent as-is so we just do "binary" conversion. - */ - - -static Lisp_Object -selection_data_to_lisp_data (struct device *d, - Extbyte *data, - size_t size, - GdkAtom type, - int format) -{ - if (type == gdk_atom_intern ("NULL", 0)) - return QNULL; - - /* Convert any 8-bit data to a string, for compactness. */ - else if (format == 8) - return make_ext_string (data, size, - ((type == gdk_atom_intern ("TEXT", FALSE)) || - (type == gdk_atom_intern ("COMPOUND_TEXT", FALSE))) - ? Qctext : Qbinary); - - /* Convert a single atom to a Lisp Symbol. - Convert a set of atoms to a vector of symbols. */ - else if (type == gdk_atom_intern ("ATOM", FALSE)) - { - if (size == sizeof (GdkAtom)) - return atom_to_symbol (d, *((GdkAtom *) data)); - else - { - int i; - int len = size / sizeof (GdkAtom); - Lisp_Object v = Fmake_vector (make_int (len), Qzero); - for (i = 0; i < len; i++) - Faset (v, make_int (i), atom_to_symbol (d, ((GdkAtom *) data) [i])); - return v; - } - } - - /* Convert a single 16 or small 32 bit number to a Lisp Int. - If the number is > 16 bits, convert it to a cons of integers, - 16 bits in each half. - */ - else if (format == 32 && size == sizeof (long)) - return word_to_lisp (((unsigned long *) data) [0]); - else if (format == 16 && size == sizeof (short)) - return make_int ((int) (((unsigned short *) data) [0])); - - /* Convert any other kind of data to a vector of numbers, represented - as above (as an integer, or a cons of two 16 bit integers). - - #### Perhaps we should return the actual type to lisp as well. - - (x-get-selection-internal 'PRIMARY 'LINE_NUMBER) - ==> [4 4] - - and perhaps it should be - - (x-get-selection-internal 'PRIMARY 'LINE_NUMBER) - ==> (SPAN . [4 4]) - - Right now the fact that the return type was SPAN is discarded before - lisp code gets to see it. - */ - else if (format == 16) - { - int i; - Lisp_Object v = make_vector (size / 4, Qzero); - for (i = 0; i < (int) size / 4; i++) - { - int j = (int) ((unsigned short *) data) [i]; - Faset (v, make_int (i), make_int (j)); - } - return v; - } - else - { - int i; - Lisp_Object v = make_vector (size / 4, Qzero); - for (i = 0; i < (int) size / 4; i++) - { - unsigned long j = ((unsigned long *) data) [i]; - Faset (v, make_int (i), word_to_lisp (j)); - } - return v; - } -} - - -static void -lisp_data_to_selection_data (struct device *d, - Lisp_Object obj, - unsigned char **data_ret, - GdkAtom *type_ret, - unsigned int *size_ret, - int *format_ret) -{ - Lisp_Object type = Qnil; - - if (CONSP (obj) && SYMBOLP (XCAR (obj))) - { - type = XCAR (obj); - obj = XCDR (obj); - if (CONSP (obj) && NILP (XCDR (obj))) - obj = XCAR (obj); - } - - if (EQ (obj, QNULL) || (EQ (type, QNULL))) - { /* This is not the same as declining */ - *format_ret = 32; - *size_ret = 0; - *data_ret = 0; - type = QNULL; - } - else if (STRINGP (obj)) - { - const Extbyte *extval; - Extcount extvallen; - - TO_EXTERNAL_FORMAT (LISP_STRING, obj, - ALLOCA, (extval, extvallen), - (NILP (type) ? Qctext : Qbinary)); - *format_ret = 8; - *size_ret = extvallen; - *data_ret = (unsigned char *) xmalloc (*size_ret); - memcpy (*data_ret, extval, *size_ret); -#ifdef MULE - if (NILP (type)) type = QCOMPOUND_TEXT; -#else - if (NILP (type)) type = QSTRING; -#endif - } - else if (CHARP (obj)) - { - Bufbyte buf[MAX_EMCHAR_LEN]; - Bytecount len; - const Extbyte *extval; - Extcount extvallen; - - *format_ret = 8; - len = set_charptr_emchar (buf, XCHAR (obj)); - TO_EXTERNAL_FORMAT (DATA, (buf, len), - ALLOCA, (extval, extvallen), - Qctext); - *size_ret = extvallen; - *data_ret = (unsigned char *) xmalloc (*size_ret); - memcpy (*data_ret, extval, *size_ret); -#ifdef MULE - if (NILP (type)) type = QCOMPOUND_TEXT; -#else - if (NILP (type)) type = QSTRING; -#endif - } - else if (SYMBOLP (obj)) - { - *format_ret = 32; - *size_ret = 1; - *data_ret = (unsigned char *) xmalloc (sizeof (GdkAtom) + 1); - (*data_ret) [sizeof (GdkAtom)] = 0; - (*(GdkAtom **) data_ret) [0] = symbol_to_gtk_atom (d, obj, 0); - if (NILP (type)) type = QATOM; - } - else if (INTP (obj) && - XINT (obj) <= 0x7FFF && - XINT (obj) >= -0x8000) - { - *format_ret = 16; - *size_ret = 1; - *data_ret = (unsigned char *) xmalloc (sizeof (short) + 1); - (*data_ret) [sizeof (short)] = 0; - (*(short **) data_ret) [0] = (short) XINT (obj); - if (NILP (type)) type = QINTEGER; - } - else if (INTP (obj) || CONSP (obj)) - { - *format_ret = 32; - *size_ret = 1; - *data_ret = (unsigned char *) xmalloc (sizeof (long) + 1); - (*data_ret) [sizeof (long)] = 0; - (*(unsigned long **) data_ret) [0] = lisp_to_word (obj); - if (NILP (type)) type = QINTEGER; - } - else if (VECTORP (obj)) - { - /* Lisp Vectors may represent a set of ATOMs; - a set of 16 or 32 bit INTEGERs; - or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...] - */ - int i; - - if (SYMBOLP (XVECTOR_DATA (obj) [0])) - /* This vector is an ATOM set */ - { - if (NILP (type)) type = QATOM; - *size_ret = XVECTOR_LENGTH (obj); - *format_ret = 32; - *data_ret = (unsigned char *) xmalloc ((*size_ret) * sizeof (GdkAtom)); - for (i = 0; i < (int) (*size_ret); i++) - if (SYMBOLP (XVECTOR_DATA (obj) [i])) - (*(GdkAtom **) data_ret) [i] = - symbol_to_gtk_atom (d, XVECTOR_DATA (obj) [i], 0); - else - syntax_error - ("all elements of the vector must be of the same type", obj); - } -#if 0 /* #### MULTIPLE doesn't work yet */ - else if (VECTORP (XVECTOR_DATA (obj) [0])) - /* This vector is an ATOM_PAIR set */ - { - if (NILP (type)) type = QATOM_PAIR; - *size_ret = XVECTOR_LENGTH (obj); - *format_ret = 32; - *data_ret = (unsigned char *) - xmalloc ((*size_ret) * sizeof (Atom) * 2); - for (i = 0; i < *size_ret; i++) - if (VECTORP (XVECTOR_DATA (obj) [i])) - { - Lisp_Object pair = XVECTOR_DATA (obj) [i]; - if (XVECTOR_LENGTH (pair) != 2) - syntax_error - ("elements of the vector must be vectors of exactly two elements", pair); - - (*(GdkAtom **) data_ret) [i * 2] = - symbol_to_gtk_atom (d, XVECTOR_DATA (pair) [0], 0); - (*(GdkAtom **) data_ret) [(i * 2) + 1] = - symbol_to_gtk_atom (d, XVECTOR_DATA (pair) [1], 0); - } - else - syntax_error - ("all elements of the vector must be of the same type", obj); - } -#endif - else - /* This vector is an INTEGER set, or something like it */ - { - *size_ret = XVECTOR_LENGTH (obj); - if (NILP (type)) type = QINTEGER; - *format_ret = 16; - for (i = 0; i < (int) (*size_ret); i++) - if (CONSP (XVECTOR_DATA (obj) [i])) - *format_ret = 32; - else if (!INTP (XVECTOR_DATA (obj) [i])) - syntax_error - ("all elements of the vector must be integers or conses of integers", obj); - - *data_ret = (unsigned char *) xmalloc (*size_ret * (*format_ret/8)); - for (i = 0; i < (int) (*size_ret); i++) - if (*format_ret == 32) - (*((unsigned long **) data_ret)) [i] = - lisp_to_word (XVECTOR_DATA (obj) [i]); - else - (*((unsigned short **) data_ret)) [i] = - (unsigned short) lisp_to_word (XVECTOR_DATA (obj) [i]); - } - } - else - invalid_argument ("unrecognized selection data", obj); - - *type_ret = symbol_to_gtk_atom (d, type, 0); -} - - static Lisp_Object gtk_own_selection (Lisp_Object selection_name, Lisp_Object selection_value,
--- a/src/select-x.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/select-x.c Mon Aug 13 04:46:48 2001 +0000 @@ -81,17 +81,6 @@ /* Utility functions */ -static void lisp_data_to_selection_data (struct device *, - Lisp_Object obj, - unsigned char **data_ret, - Atom *type_ret, - unsigned int *size_ret, - int *format_ret); -static Lisp_Object selection_data_to_lisp_data (struct device *, - Extbyte *data, - size_t size, - Atom type, - int format); static Lisp_Object x_get_window_property_as_lisp_data (Display *, Window, Atom property, @@ -142,7 +131,7 @@ #endif /* CUT_BUFFER_SUPPORT */ { - const char *nameext; + const Extbyte *nameext; LISP_STRING_TO_EXTERNAL (Fsymbol_name (sym), nameext, Qctext); return XInternAtom (display, nameext, only_if_exists ? True : False); } @@ -200,6 +189,9 @@ } } +#define PROCESSING_X_CODE +#include "select-common.h" +#undef PROCESSING_X_CODE /* Do protocol to assert ourself as a selection owner. */ @@ -469,16 +461,16 @@ */ static void x_reply_selection_request (XSelectionRequestEvent *event, int format, - unsigned char *data, int size, Atom type) + UChar_Binary *data, Memory_Count size, Atom type) { /* This function can GC */ XSelectionEvent reply; Display *display = event->display; struct device *d = get_device_from_display (display); Window window = event->requestor; - int bytes_remaining; + Memory_Count bytes_remaining; int format_bytes = format/8; - int max_bytes = SELECTION_QUANTUM (display); + Memory_Count max_bytes = SELECTION_QUANTUM (display); if (max_bytes > MAX_SELECTION_QUANTUM) max_bytes = MAX_SELECTION_QUANTUM; reply.type = SelectionNotify; @@ -521,7 +513,7 @@ PropertyDelete); XChangeProperty (display, window, reply.property, DEVICE_XATOM_INCR (d), - 32, PropModeReplace, (unsigned char *) + 32, PropModeReplace, (UChar_Binary *) &bytes_remaining, 1); XSelectInput (display, window, PropertyChangeMask); /* Tell 'em the INCR data is there... */ @@ -535,7 +527,7 @@ while (bytes_remaining) { - int i = ((bytes_remaining < max_bytes) + Memory_Count i = ((bytes_remaining < max_bytes) ? bytes_remaining : max_bytes); prop_id = expect_property_change (display, window, reply.property, @@ -632,8 +624,8 @@ make_opaque_ptr (event)); { - unsigned char *data; - unsigned int size; + UChar_Binary *data; + Memory_Count size; int format; Atom type; lisp_data_to_selection_data (d, converted_selection, @@ -848,8 +840,8 @@ copy_multiple_data (Lisp_Object obj) { Lisp_Object vec; - int i; - int len; + Element_Count i; + Element_Count len; if (CONSP (obj)) return Fcons (XCAR (obj), copy_multiple_data (XCDR (obj))); @@ -954,16 +946,16 @@ static void x_get_window_property (Display *display, Window window, Atom property, - Extbyte **data_ret, int *bytes_ret, + UChar_Binary **data_ret, Memory_Count *bytes_ret, Atom *actual_type_ret, int *actual_format_ret, unsigned long *actual_size_ret, int delete_p) { - size_t total_size; + Memory_Count total_size; unsigned long bytes_remaining; - int offset = 0; - unsigned char *tmp_data = 0; + Memory_Count offset = 0; + UChar_Binary *tmp_data = 0; int result; - int buffer_size = SELECTION_QUANTUM (display); + Memory_Count buffer_size = SELECTION_QUANTUM (display); if (buffer_size > MAX_SELECTION_QUANTUM) buffer_size = MAX_SELECTION_QUANTUM; /* First probe the thing to find out how big it is. */ @@ -989,13 +981,13 @@ } total_size = bytes_remaining + 1; - *data_ret = (Extbyte *) xmalloc (total_size); + *data_ret = (UChar_Binary *) xmalloc (total_size); /* Now read, until we've gotten it all. */ while (bytes_remaining) { #if 0 - int last = bytes_remaining; + Memory_Count last = bytes_remaining; #endif result = XGetWindowProperty (display, window, property, @@ -1025,16 +1017,17 @@ receive_incremental_selection (Display *display, Window window, Atom property, /* this one is for error messages only */ Lisp_Object target_type, - unsigned int min_size_bytes, - Extbyte **data_ret, int *size_bytes_ret, + Memory_Count min_size_bytes, + UChar_Binary **data_ret, + Memory_Count *size_bytes_ret, Atom *type_ret, int *format_ret, unsigned long *size_ret) { /* This function can GC */ - int offset = 0; + Memory_Count offset = 0; int prop_id; *size_bytes_ret = min_size_bytes; - *data_ret = (Extbyte *) xmalloc (*size_bytes_ret); + *data_ret = (UChar_Binary *) xmalloc (*size_bytes_ret); #if 0 stderr_out ("\nread INCR %d\n", min_size_bytes); #endif @@ -1050,8 +1043,8 @@ PropertyNewValue); while (1) { - Extbyte *tmp_data; - int tmp_size_bytes; + UChar_Binary *tmp_data; + Memory_Count tmp_size_bytes; wait_for_property_change (prop_id); /* expect it again immediately, because x_get_window_property may .. no it won't, I don't get it. @@ -1082,7 +1075,7 @@ *size_bytes_ret, offset + tmp_size_bytes); #endif *size_bytes_ret = offset + tmp_size_bytes; - *data_ret = (Extbyte *) xrealloc (*data_ret, *size_bytes_ret); + *data_ret = (UChar_Binary *) xrealloc (*data_ret, *size_bytes_ret); } memcpy ((*data_ret) + offset, tmp_data, tmp_size_bytes); offset += tmp_size_bytes; @@ -1103,8 +1096,8 @@ Atom actual_type; int actual_format; unsigned long actual_size; - Extbyte *data = NULL; - int bytes = 0; + UChar_Binary *data = NULL; + Memory_Count bytes = 0; Lisp_Object val; struct device *d = get_device_from_display (display); @@ -1132,7 +1125,9 @@ { /* Ok, that data wasn't *the* data, it was just the beginning. */ - unsigned int min_size_bytes = * ((unsigned int *) data); + Memory_Count min_size_bytes = + /* careful here. */ + (Memory_Count) (* ((unsigned int *) data)); xfree (data); receive_incremental_selection (display, window, property, target_type, min_size_bytes, &data, &bytes, @@ -1148,298 +1143,6 @@ xfree (data); return val; } - -/* #### These are going to move into Lisp code(!) with the aid of - some new functions I'm working on - ajh */ - -/* These functions convert from the selection data read from the server into - something that we can use from elisp, and vice versa. - - Type: Format: Size: Elisp Type: - ----- ------- ----- ----------- - * 8 * String - ATOM 32 1 Symbol - ATOM 32 > 1 Vector of Symbols - * 16 1 Integer - * 16 > 1 Vector of Integers - * 32 1 if <=16 bits: Integer - if > 16 bits: Cons of top16, bot16 - * 32 > 1 Vector of the above - - When converting a Lisp number to C, it is assumed to be of format 16 if - it is an integer, and of format 32 if it is a cons of two integers. - - When converting a vector of numbers from Elisp to C, it is assumed to be - of format 16 if every element in the vector is an integer, and is assumed - to be of format 32 if any element is a cons of two integers. - - When converting an object to C, it may be of the form (SYMBOL . <data>) - where SYMBOL is what we should claim that the type is. Format and - representation are as above. - - NOTE: Under Mule, when someone shoves us a string without a type, we - set the type to 'COMPOUND_TEXT and automatically convert to Compound - Text. If the string has a type, we assume that the user wants the - data sent as-is so we just do "binary" conversion. - */ - - -static Lisp_Object -selection_data_to_lisp_data (struct device *d, - Extbyte *data, - size_t size, - Atom type, - int format) -{ - if (type == DEVICE_XATOM_NULL (d)) - return QNULL; - - /* Convert any 8-bit data to a string, for compactness. */ - else if (format == 8) - return make_ext_string (data, size, - type == DEVICE_XATOM_TEXT (d) || - type == DEVICE_XATOM_COMPOUND_TEXT (d) - ? Qctext : Qbinary); - - /* Convert a single atom to a Lisp Symbol. - Convert a set of atoms to a vector of symbols. */ - else if (type == XA_ATOM) - { - if (size == sizeof (Atom)) - return x_atom_to_symbol (d, *((Atom *) data)); - else - { - int i; - int len = size / sizeof (Atom); - Lisp_Object v = Fmake_vector (make_int (len), Qzero); - for (i = 0; i < len; i++) - Faset (v, make_int (i), x_atom_to_symbol (d, ((Atom *) data) [i])); - return v; - } - } - - /* Convert a single 16 or small 32 bit number to a Lisp Int. - If the number is > 16 bits, convert it to a cons of integers, - 16 bits in each half. - */ - else if (format == 32 && size == sizeof (long)) - return word_to_lisp (((unsigned long *) data) [0]); - else if (format == 16 && size == sizeof (short)) - return make_int ((int) (((unsigned short *) data) [0])); - - /* Convert any other kind of data to a vector of numbers, represented - as above (as an integer, or a cons of two 16 bit integers). - - #### Perhaps we should return the actual type to lisp as well. - - (x-get-selection-internal 'PRIMARY 'LINE_NUMBER) - ==> [4 4] - - and perhaps it should be - - (x-get-selection-internal 'PRIMARY 'LINE_NUMBER) - ==> (SPAN . [4 4]) - - Right now the fact that the return type was SPAN is discarded before - lisp code gets to see it. - */ - else if (format == 16) - { - int i; - Lisp_Object v = make_vector (size / 4, Qzero); - for (i = 0; i < (int) size / 4; i++) - { - int j = (int) ((unsigned short *) data) [i]; - Faset (v, make_int (i), make_int (j)); - } - return v; - } - else - { - int i; - Lisp_Object v = make_vector (size / 4, Qzero); - for (i = 0; i < (int) size / 4; i++) - { - unsigned long j = ((unsigned long *) data) [i]; - Faset (v, make_int (i), word_to_lisp (j)); - } - return v; - } -} - - -static void -lisp_data_to_selection_data (struct device *d, - Lisp_Object obj, - unsigned char **data_ret, - Atom *type_ret, - unsigned int *size_ret, - int *format_ret) -{ - Lisp_Object type = Qnil; - - if (CONSP (obj) && SYMBOLP (XCAR (obj))) - { - type = XCAR (obj); - obj = XCDR (obj); - if (CONSP (obj) && NILP (XCDR (obj))) - obj = XCAR (obj); - } - - if (EQ (obj, QNULL) || (EQ (type, QNULL))) - { /* This is not the same as declining */ - *format_ret = 32; - *size_ret = 0; - *data_ret = 0; - type = QNULL; - } - else if (STRINGP (obj)) - { - const Extbyte *extval; - Extcount extvallen; - - TO_EXTERNAL_FORMAT (LISP_STRING, obj, - ALLOCA, (extval, extvallen), - (NILP (type) ? Qctext : Qbinary)); - *format_ret = 8; - *size_ret = extvallen; - *data_ret = (unsigned char *) xmalloc (*size_ret); - memcpy (*data_ret, extval, *size_ret); -#ifdef MULE - if (NILP (type)) type = QCOMPOUND_TEXT; -#else - if (NILP (type)) type = QSTRING; -#endif - } - else if (CHARP (obj)) - { - Bufbyte buf[MAX_EMCHAR_LEN]; - Bytecount len; - const Extbyte *extval; - Extcount extvallen; - - *format_ret = 8; - len = set_charptr_emchar (buf, XCHAR (obj)); - TO_EXTERNAL_FORMAT (DATA, (buf, len), - ALLOCA, (extval, extvallen), - Qctext); - *size_ret = extvallen; - *data_ret = (unsigned char *) xmalloc (*size_ret); - memcpy (*data_ret, extval, *size_ret); -#ifdef MULE - if (NILP (type)) type = QCOMPOUND_TEXT; -#else - if (NILP (type)) type = QSTRING; -#endif - } - else if (SYMBOLP (obj)) - { - *format_ret = 32; - *size_ret = 1; - *data_ret = (unsigned char *) xmalloc (sizeof (Atom) + 1); - (*data_ret) [sizeof (Atom)] = 0; - (*(Atom **) data_ret) [0] = symbol_to_x_atom (d, obj, 0); - if (NILP (type)) type = QATOM; - } - else if (INTP (obj) && - XINT (obj) <= 0x7FFF && - XINT (obj) >= -0x8000) - { - *format_ret = 16; - *size_ret = 1; - *data_ret = (unsigned char *) xmalloc (sizeof (short) + 1); - (*data_ret) [sizeof (short)] = 0; - (*(short **) data_ret) [0] = (short) XINT (obj); - if (NILP (type)) type = QINTEGER; - } - else if (INTP (obj) || CONSP (obj)) - { - *format_ret = 32; - *size_ret = 1; - *data_ret = (unsigned char *) xmalloc (sizeof (long) + 1); - (*data_ret) [sizeof (long)] = 0; - (*(unsigned long **) data_ret) [0] = lisp_to_word (obj); - if (NILP (type)) type = QINTEGER; - } - else if (VECTORP (obj)) - { - /* Lisp Vectors may represent a set of ATOMs; - a set of 16 or 32 bit INTEGERs; - or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...] - */ - int i; - - if (SYMBOLP (XVECTOR_DATA (obj) [0])) - /* This vector is an ATOM set */ - { - if (NILP (type)) type = QATOM; - *size_ret = XVECTOR_LENGTH (obj); - *format_ret = 32; - *data_ret = (unsigned char *) xmalloc ((*size_ret) * sizeof (Atom)); - for (i = 0; i < (int) (*size_ret); i++) - if (SYMBOLP (XVECTOR_DATA (obj) [i])) - (*(Atom **) data_ret) [i] = - symbol_to_x_atom (d, XVECTOR_DATA (obj) [i], 0); - else - syntax_error - ("all elements of the vector must be of the same type", obj); - } -#if 0 /* #### MULTIPLE doesn't work yet */ - else if (VECTORP (XVECTOR_DATA (obj) [0])) - /* This vector is an ATOM_PAIR set */ - { - if (NILP (type)) type = QATOM_PAIR; - *size_ret = XVECTOR_LENGTH (obj); - *format_ret = 32; - *data_ret = (unsigned char *) - xmalloc ((*size_ret) * sizeof (Atom) * 2); - for (i = 0; i < *size_ret; i++) - if (VECTORP (XVECTOR_DATA (obj) [i])) - { - Lisp_Object pair = XVECTOR_DATA (obj) [i]; - if (XVECTOR_LENGTH (pair) != 2) - syntax_error - ("elements of the vector must be vectors of exactly two elements", pair); - - (*(Atom **) data_ret) [i * 2] = - symbol_to_x_atom (d, XVECTOR_DATA (pair) [0], 0); - (*(Atom **) data_ret) [(i * 2) + 1] = - symbol_to_x_atom (d, XVECTOR_DATA (pair) [1], 0); - } - else - syntax_error - ("all elements of the vector must be of the same type", obj); - } -#endif - else - /* This vector is an INTEGER set, or something like it */ - { - *size_ret = XVECTOR_LENGTH (obj); - if (NILP (type)) type = QINTEGER; - *format_ret = 16; - for (i = 0; i < (int) (*size_ret); i++) - if (CONSP (XVECTOR_DATA (obj) [i])) - *format_ret = 32; - else if (!INTP (XVECTOR_DATA (obj) [i])) - syntax_error - ("all elements of the vector must be integers or conses of integers", obj); - - *data_ret = (unsigned char *) xmalloc (*size_ret * (*format_ret/8)); - for (i = 0; i < (int) (*size_ret); i++) - if (*format_ret == 32) - (*((unsigned long **) data_ret)) [i] = - lisp_to_word (XVECTOR_DATA (obj) [i]); - else - (*((unsigned short **) data_ret)) [i] = - (unsigned short) lisp_to_word (XVECTOR_DATA (obj) [i]); - } - } - else - invalid_argument ("unrecognized selection data", obj); - - *type_ret = symbol_to_x_atom (d, type, 0); -} - /* Called from the event loop to handle SelectionNotify events. @@ -1541,8 +1244,8 @@ Display *display = DEVICE_X_DISPLAY (d); Window window = RootWindow (display, 0); /* Cutbuffers are on frame 0 */ Atom cut_buffer_atom; - Extbyte *data; - int bytes; + UChar_Binary *data; + Memory_Count bytes; Atom type; int format; unsigned long size; @@ -1565,7 +1268,7 @@ COMPOUND_TEXT that we stored there ourselves earlier, in x-store-cutbuffer-internal */ ret = (bytes ? - make_ext_string (data, bytes, + make_ext_string ((Extbyte *) data, bytes, memchr (data, 0x1b, bytes) ? Qctext : Qbinary) : Qnil); @@ -1586,7 +1289,7 @@ const Bufbyte *data = XSTRING_DATA (string); Bytecount bytes = XSTRING_LENGTH (string); Bytecount bytes_remaining; - int max_bytes = SELECTION_QUANTUM (display); + Memory_Count max_bytes = SELECTION_QUANTUM (display); #ifdef MULE const Bufbyte *ptr, *end; enum { ASCII, LATIN_1, WORLD } chartypes = ASCII; @@ -1643,7 +1346,8 @@ while (bytes_remaining) { - int chunk = bytes_remaining < max_bytes ? bytes_remaining : max_bytes; + Memory_Count chunk = + bytes_remaining < max_bytes ? bytes_remaining : max_bytes; XChangeProperty (display, window, cut_buffer_atom, XA_STRING, 8, (bytes_remaining == bytes ? PropModeReplace : PropModeAppend),
--- a/src/sheap.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/sheap.c Mon Aug 13 04:46:48 2001 +0000 @@ -126,7 +126,7 @@ { int rc = 0; - size_t lost = (STATIC_HEAP_BASE + STATIC_HEAP_SLOP + SHEAP_ADJUSTMENT) + Memory_Count lost = (STATIC_HEAP_BASE + STATIC_HEAP_SLOP + SHEAP_ADJUSTMENT) - (static_heap_ptr - static_heap_buffer); char buf[200]; sprintf (buf, "Static heap usage: %ld of %ld",
--- a/src/specifier.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/specifier.c Mon Aug 13 04:46:48 2001 +0000 @@ -350,15 +350,15 @@ internal_hash (s->buffer_specs, depth + 1)); } -inline static size_t -aligned_sizeof_specifier (size_t specifier_type_specific_size) +inline static Memory_Count +aligned_sizeof_specifier (Memory_Count specifier_type_specific_size) { return ALIGN_SIZE (offsetof (Lisp_Specifier, data) + specifier_type_specific_size, ALIGNOF (max_align_t)); } -static size_t +static Memory_Count sizeof_specifier (const void *header) { const Lisp_Specifier *p = (const Lisp_Specifier *) header; @@ -473,7 +473,7 @@ static Lisp_Object make_specifier_internal (struct specifier_methods *spec_meths, - size_t data_size, int call_create_meth) + Memory_Count data_size, int call_create_meth) { Lisp_Object specifier; Lisp_Specifier *sp = (Lisp_Specifier *)
--- a/src/symbols.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/symbols.c Mon Aug 13 04:46:48 2001 +0000 @@ -3274,9 +3274,9 @@ int i; if (multiword_predicate_p) - assert (len + 1 < sizeof (temp)); + assert (len + 1 < (int) sizeof (temp)); else - assert (len < sizeof (temp)); + assert (len < (int) sizeof (temp)); strcpy (temp, name + 1); /* Remove initial Q */ if (multiword_predicate_p) { @@ -3349,7 +3349,7 @@ char temp[500]; int len = strlen (name); - assert (len < sizeof (temp)); + assert (len < (int) sizeof (temp)); strcpy (temp, name); temp[1] = ':'; /* it's an underscore in the C variable */ @@ -3485,7 +3485,7 @@ int i; int len = strlen (name) - 1; - assert (len < sizeof (temp)); + assert (len < (int) sizeof (temp)); strcpy (temp, name + 1); /* Remove initial Q */ temp[0] = toupper (temp[0]); for (i = 0; i < len; i++)
--- a/src/sysdep.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/sysdep.c Mon Aug 13 04:46:48 2001 +0000 @@ -818,7 +818,7 @@ tcgetattr (fd, &t); #if 0 /* What is the following line designed to do??? -mrb */ - if (strlen ((const char *) t.c_cc) < (unsigned int) (VEOF + 1)) + if ((int) strlen ((const char *) t.c_cc) < (VEOF + 1)) return ctrl_d; else return (Bufbyte) t.c_cc[VEOF]; @@ -841,7 +841,7 @@ { struct termio t; ioctl (fd, TCGETA, &t); - if (strlen ((const char *) t.c_cc) < (unsigned int) (VINTR + 1)) + if ((int) strlen ((const char *) t.c_cc) < (VINTR + 1)) return ctrl_d; else return (Bufbyte) t.c_cc[VINTR]; @@ -933,7 +933,6 @@ void init_baud_rate (struct device *d) { - struct console *con = XCONSOLE (DEVICE_CONSOLE (d)); if (DEVICE_WIN_P (d) || DEVICE_STREAM_P (d)) { DEVICE_BAUD_RATE (d) = 38400; @@ -943,6 +942,7 @@ #ifdef HAVE_TTY assert (DEVICE_TTY_P (d)); { + struct console *con = XCONSOLE (DEVICE_CONSOLE (d)); int input_fd = CONSOLE_TTY_DATA (con)->infd; #if defined (WIN32_NATIVE) DEVICE_TTY_DATA (d)->ospeed = 15; @@ -1767,7 +1767,8 @@ /* This symbol is defined on recent USG systems. Someone says without this call USG won't really buffer the file even with a call to setbuf. */ - setvbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf, _IOFBF, sizeof _sobuf); + setvbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf, _IOFBF, + sizeof (_sobuf)); #else setbuf (CONSOLE_TTY_DATA (con)->outfd, (char *) _sobuf); #endif @@ -2296,7 +2297,7 @@ { #if defined (WIN32_NATIVE) char hostname [MAX_COMPUTERNAME_LENGTH + 1]; - size_t size = sizeof (hostname); + DWORD size = sizeof (hostname); GetComputerName (hostname, &size); Vsystem_name = build_string (hostname); #elif !defined (HAVE_GETHOSTNAME) @@ -2304,7 +2305,7 @@ uname (&uts); Vsystem_name = build_string (uts.nodename); #else /* HAVE_GETHOSTNAME */ - unsigned int hostname_size = 256; + int hostname_size = 256; char *hostname = (char *) alloca (hostname_size); /* Try to get the host name; if the buffer is too short, try @@ -2317,7 +2318,7 @@ hostname[hostname_size - 1] = '\0'; /* Was the buffer large enough for the '\0'? */ - if (strlen (hostname) < (size_t) (hostname_size - 1)) + if ((int) strlen (hostname) < (hostname_size - 1)) break; hostname_size <<= 1;
--- a/src/sysdir.h Wed Aug 08 12:15:04 2001 +0000 +++ b/src/sysdir.h Mon Aug 13 04:46:48 2001 +0000 @@ -28,7 +28,9 @@ #endif #ifdef SYSV_SYSTEM_DIR +# define select select_ /* Shadowing yuck */ # include <dirent.h> +# undef select #elif defined (WIN32_NATIVE) # include <direct.h> # include "ndir.h"
--- a/src/tests.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/tests.c Mon Aug 13 04:46:48 2001 +0000 @@ -40,7 +40,7 @@ */ ()) { - void *ptr; size_t len; + void *ptr; Memory_Count len; Lisp_Object string, opaque; Bufbyte int_foo[] = "\n\nfoo\nbar";
--- a/src/tparam.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/tparam.c Mon Aug 13 04:46:48 2001 +0000 @@ -21,11 +21,8 @@ /* Synched up with: Not synched with FSF. */ /* config.h may rename various library functions such as malloc. */ -#ifdef emacs - #include <config.h> - -#include <string.h> +#include "lisp.h" #undef realloc #undef malloc @@ -33,15 +30,8 @@ #define realloc xrealloc #define malloc xmalloc #define free xfree -extern void *xmalloc (size_t size); -extern void *xrealloc (void *, size_t size); - -#else /* !emacs */ - -#include <stdlib.h> -#include <string.h> - -#endif /* !emacs */ +extern void *xmalloc (Memory_Count size); +extern void *xrealloc (void *, Memory_Count size); /* Assuming STRING is the value of a termcap string entry containing `%' constructs to expand parameters, @@ -271,21 +261,3 @@ strcat (op, left); return outstring; } - -#ifdef DEBUG - -main (argc, argv) - int argc; - char **argv; -{ - char buf[50]; - int args[3]; - args[0] = atoi (argv[2]); - args[1] = atoi (argv[3]); - args[2] = atoi (argv[4]); - tparam1 (argv[1], buf, "LEFT", "UP", args); - printf ("%s\n", buf); - return 0; -} - -#endif /* DEBUG */
--- a/src/unexaix.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/unexaix.c Mon Aug 13 04:46:48 2001 +0000 @@ -492,7 +492,7 @@ else lseek (a_out, orig_load_scnptr, SEEK_SET); /* Position a.out to symtab. */ - while ((n = read (a_out, page, sizeof page)) > 0) + while ((n = read (a_out, page, sizeof (page))) > 0) { if (write (new, page, n) != n) {
--- a/src/unexconvex.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/unexconvex.c Mon Aug 13 04:46:48 2001 +0000 @@ -493,7 +493,7 @@ if( lseek( new, (long) sptr->s_scnptr, 0 ) == -1 ) PERROR( "unexecing" ); - memset (zeros, 0, sizeof zeros); + memset (zeros, 0, sizeof (zeros)); ptr = (char *) sptr->s_vaddr; end = ptr + sptr->s_size; @@ -543,7 +543,7 @@ lseek (a_out, SYMS_START, 0); /* Position a.out to symtab. */ lseek( new, (long)f_ohdr.o_symptr, 0 ); - while ((n = read (a_out, page, sizeof page)) > 0) { + while ((n = read (a_out, page, sizeof (page))) > 0) { if (write (new, page, n) != n) { PERROR (new_name); }
--- a/src/unexcw.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/unexcw.c Mon Aug 13 04:46:48 2001 +0000 @@ -38,7 +38,7 @@ #if !defined (HAVE_A_OUT_H) && !defined (WIN32_NATIVE) unexec (char *, char *, void *, void *, void *) { - PERROR("cannot unexec() a.out.h not installed"); + PERROR ("cannot unexec() a.out.h not installed"); } #else @@ -49,9 +49,9 @@ #endif #define ALLOC_UNIT 0xFFFF -#define ALLOC_MASK ~((unsigned long)(ALLOC_UNIT)) +#define ALLOC_MASK ~((unsigned long) (ALLOC_UNIT)) #define ALIGN_ALLOC(addr) \ -((((unsigned long)addr) + ALLOC_UNIT) & ALLOC_MASK) +((((unsigned long) addr) + ALLOC_UNIT) & ALLOC_MASK) /* Note that all sections must be aligned on a 0x1000 boundary so this is the minimum size that our dummy bss can be. */ #ifndef NO_DEBUG @@ -67,30 +67,32 @@ static void get_section_info (int a_out, char* a_name); static void copy_executable_and_dump_data_section (int a_out, int a_new); -static void dup_file_area(int a_out, int a_new, long size); +static void dup_file_area (int a_out, int a_new, long size); #if 0 -static void write_int_to_bss(int a_out, int a_new, void* va, void* newval); +static void write_int_to_bss (int a_out, int a_new, void* va, void* newval); #endif /* Cached info about the .data section in the executable. */ -void* data_start_va = UNINIT_PTR; -unsigned long data_size = UNINIT_LONG; +void *data_start_va = UNINIT_PTR; +long data_size = UNINIT_LONG; /* Cached info about the .bss section in the executable. */ -void* bss_start = UNINIT_PTR; -unsigned long bss_size = UNINIT_LONG; +void *bss_start = UNINIT_PTR; +long bss_size = UNINIT_LONG; int sections_reversed = 0; FILHDR f_hdr; PEAOUTHDR f_ohdr; SCNHDR f_data, f_bss, f_text, f_nextdata; -#define CHECK_AOUT_POS(a) \ -if (lseek(a_out, 0, SEEK_CUR) != a) \ -{ \ - printf("we are at %lx, should be at %lx\n", \ - lseek(a_out, 0, SEEK_CUR), a); \ - exit(-1); \ -} +#define CHECK_AOUT_POS(a) \ +do { \ + if (lseek (a_out, 0, SEEK_CUR) != a) \ + { \ + printf ("we are at %lx, should be at %lx\n", \ + lseek (a_out, 0, SEEK_CUR), a); \ + exit (-1); \ + } \ +} while (0) /* Dump out .data and .bss sections into a new executable. */ int @@ -129,8 +131,8 @@ copy_executable_and_dump_data_section (a_out, a_new); - close(a_out); - close(a_new); + close (a_out); + close (a_new); return 0; } @@ -146,11 +148,11 @@ PERROR (a_name); if (f_hdr.e_magic != DOSMAGIC) - PERROR("unknown exe header"); + PERROR ("unknown exe header"); /* Check the NT header signature ... */ if (f_hdr.nt_signature != NT_SIGNATURE) - PERROR("invalid nt header"); + PERROR ("invalid nt header"); /* Flip through the sections for .data and .bss ... */ if (f_hdr.f_opthdr > 0) @@ -172,11 +174,11 @@ PERROR ("no .bss / .data section"); /* check for reversed .bss and .data */ - if (!strcmp(f_bss.s_name, ".data")) + if (!strcmp (f_bss.s_name, ".data")) { - printf(".data and .bss reversed\n"); + printf (".data and .bss reversed\n"); sections_reversed = 1; - memcpy(&f_data, &f_bss, sizeof(f_bss)); + memcpy (&f_data, &f_bss, sizeof (f_bss)); } /* The .data section. */ @@ -197,7 +199,7 @@ bss_size = (unsigned long)((char*)&my_ebss-(char*)bss_start); /* must keep bss data that we want to be blank as blank */ - printf("found bss - keeping %lx of %lx bytes\n", bss_size, f_ohdr.bsize); + printf ("found bss - keeping %lx of %lx bytes\n", bss_size, f_ohdr.bsize); /* The .data section. */ data_start_va = (void *) ((char*)f_ohdr.ImageBase + f_data.s_vaddr); @@ -207,12 +209,11 @@ then a dumped Emacs won't run on system versions other than the one Emacs was dumped on). */ data_size = (unsigned long)my_edata - (unsigned long)data_start_va; - printf("found data - keeping %lx of %lx bytes\n", data_size, f_ohdr.dsize); + printf ("found data - keeping %lx of %lx bytes\n", data_size, f_ohdr.dsize); /* The following data section - often .idata */ if (read (a_out, &f_nextdata, sizeof (f_nextdata)) != sizeof (f_nextdata) - && - strcmp (&f_nextdata.s_name[2], "data")) + && strcmp (&f_nextdata.s_name[2], "data")) PERROR ("no other data section"); } @@ -221,13 +222,17 @@ static void copy_executable_and_dump_data_section (int a_out, int a_new) { - long size=0; - unsigned long new_data_size, new_bss_size, - bss_padding, file_sz_change, data_padding=0, - f_data_s_vaddr = f_data.s_vaddr, - f_data_s_scnptr = f_data.s_scnptr, - f_bss_s_vaddr = f_bss.s_vaddr, - f_nextdata_s_scnptr = f_nextdata.s_scnptr; + long size = 0; + /* NOTE: Some of these were previously declared as unsigned long, + but the ones changed to long represent file sizes or pointers, + which can't reasonably get above 2G. (A 2G executable???) + Furthermore, some were even being compared as in if (x < 0) ... */ + long new_data_size, new_bss_size, bss_padding, file_sz_change; + long data_padding = 0; + long f_data_s_scnptr = f_data.s_scnptr; + long f_nextdata_s_scnptr = f_nextdata.s_scnptr; + unsigned long f_data_s_vaddr = f_data.s_vaddr; + unsigned long f_bss_s_vaddr = f_bss.s_vaddr; int i; void* empty_space; @@ -268,15 +273,15 @@ if ((new_bss_size - bss_size) < BSS_PAD_SIZE) PERROR (".bss free space too small"); - file_sz_change=(new_bss_size + data_padding) - BSS_PAD_SIZE; - new_data_size=f_ohdr.dsize + file_sz_change; + file_sz_change = (new_bss_size + data_padding) - BSS_PAD_SIZE; + new_data_size = f_ohdr.dsize + file_sz_change; if (!sections_reversed) f_data.s_vaddr = f_bss.s_vaddr; f_data.s_paddr += file_sz_change; #if 0 if (f_data.s_size + f_nextdata.s_size != f_ohdr.dsize) - printf("section size doesn't tally with dsize %lx != %lx\n", + printf ("section size doesn't tally with dsize %lx != %lx\n", f_data.s_size + f_nextdata.s_size, f_ohdr.dsize); #endif f_data.s_size += file_sz_change; @@ -287,24 +292,24 @@ f_hdr.f_nscns--; #endif - printf("writing file header\n"); - if (write(a_new, &f_hdr, sizeof(f_hdr)) != sizeof(f_hdr)) - PERROR("failed to write file header"); + printf ("writing file header\n"); + if (write (a_new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr)) + PERROR ("failed to write file header"); /* write optional header fixing dsize & bsize*/ - printf("writing optional header\n"); - printf("new data size is %lx, >= %lx\n", new_data_size, + printf ("writing optional header\n"); + printf ("new data size is %lx, >= %lx\n", new_data_size, f_ohdr.dsize + f_ohdr.bsize); - if (new_data_size < f_ohdr.dsize + f_ohdr.bsize ) - printf("warning: new data size is < approx\n"); + if (new_data_size < (long) (f_ohdr.dsize + f_ohdr.bsize)) + printf ("warning: new data size is < approx\n"); f_ohdr.dsize=new_data_size; f_ohdr.bsize=BSS_PAD_SIZE; - if (write(a_new, &f_ohdr, sizeof(f_ohdr)) != sizeof(f_ohdr)) - PERROR("failed to write optional header"); + if (write (a_new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr)) + PERROR ("failed to write optional header"); /* write text as is */ - printf("writing text header (unchanged)\n"); + printf ("writing text header (unchanged)\n"); - if (write(a_new, &f_text, sizeof(f_text)) != sizeof(f_text)) - PERROR("failed to write text header"); + if (write (a_new, &f_text, sizeof (f_text)) != sizeof (f_text)) + PERROR ("failed to write text header"); #ifndef NO_DEBUG /* Write small bss section. */ if (!sections_reversed) @@ -312,15 +317,15 @@ f_bss.s_size = BSS_PAD_SIZE; f_bss.s_paddr = BSS_PAD_SIZE; f_bss.s_vaddr = f_data.s_vaddr - BSS_PAD_SIZE; - if (write(a_new, &f_bss, sizeof(f_bss)) != sizeof(f_bss)) - PERROR("failed to write bss header"); + if (write (a_new, &f_bss, sizeof (f_bss)) != sizeof (f_bss)) + PERROR ("failed to write bss header"); } #endif /* write new data header */ - printf("writing .data header\n"); + printf ("writing .data header\n"); - if (write(a_new, &f_data, sizeof(f_data)) != sizeof(f_data)) - PERROR("failed to write data header"); + if (write (a_new, &f_data, sizeof (f_data)) != sizeof (f_data)) + PERROR ("failed to write data header"); #ifndef NO_DEBUG /* Write small bss section. */ if (sections_reversed) @@ -328,16 +333,16 @@ f_bss.s_size = BSS_PAD_SIZE; f_bss.s_paddr = BSS_PAD_SIZE; f_bss.s_vaddr = f_nextdata.s_vaddr - BSS_PAD_SIZE; - if (write(a_new, &f_bss, sizeof(f_bss)) != sizeof(f_bss)) - PERROR("failed to write bss header"); + if (write (a_new, &f_bss, sizeof (f_bss)) != sizeof (f_bss)) + PERROR ("failed to write bss header"); } #endif - printf("writing following data header\n"); + printf ("writing following data header\n"); f_nextdata.s_scnptr += file_sz_change; if (f_nextdata.s_lnnoptr != 0) f_nextdata.s_lnnoptr += file_sz_change; if (f_nextdata.s_relptr != 0) f_nextdata.s_relptr += file_sz_change; - if (write(a_new, &f_nextdata, sizeof(f_nextdata)) != sizeof(f_nextdata)) - PERROR("failed to write nextdata header"); + if (write (a_new, &f_nextdata, sizeof (f_nextdata)) != sizeof (f_nextdata)) + PERROR ("failed to write nextdata header"); /* copy other section headers adjusting the file offset */ for (i=0; i<(f_hdr.f_nscns-3); i++) @@ -349,140 +354,142 @@ if (section.s_lnnoptr != 0) section.s_lnnoptr += file_sz_change; if (section.s_relptr != 0) section.s_relptr += file_sz_change; - if (write(a_new, §ion, sizeof(section)) != sizeof(section)) - PERROR("failed to write data header"); + if (write (a_new, §ion, sizeof (section)) != sizeof (section)) + PERROR ("failed to write data header"); } #ifdef NO_DEBUG /* dump bss to maintain offsets */ - memset(&f_bss, 0, sizeof(f_bss)); - if (write(a_new, &f_bss, sizeof(f_bss)) != sizeof(f_bss)) - PERROR("failed to write bss header"); + memset (&f_bss, 0, sizeof (f_bss)); + if (write (a_new, &f_bss, sizeof (f_bss)) != sizeof (f_bss)) + PERROR ("failed to write bss header"); #endif - size=lseek(a_new, 0, SEEK_CUR); - CHECK_AOUT_POS(size); + size = lseek (a_new, 0, SEEK_CUR); + CHECK_AOUT_POS (size); /* copy eveything else until start of data */ size = f_data_s_scnptr - lseek (a_out, 0, SEEK_CUR); printf ("copying executable up to data section ... %lx bytes\n", size); - dup_file_area(a_out, a_new, size); + dup_file_area (a_out, a_new, size); - CHECK_AOUT_POS(f_data_s_scnptr); + CHECK_AOUT_POS (f_data_s_scnptr); if (!sections_reversed) { /* dump bss + padding between sections, sans small bss pad */ printf ("dumping .bss into executable... %lx bytes\n", bss_size); - if (write(a_new, bss_start, bss_size) != (int)bss_size) + if (write (a_new, bss_start, bss_size) != bss_size) { - PERROR("failed to write bss section"); + PERROR ("failed to write bss section"); } /* pad, needs to be zero */ bss_padding = (new_bss_size - bss_size) - BSS_PAD_SIZE; if (bss_padding < 0) - PERROR("padded .bss too small"); + PERROR ("padded .bss too small"); printf ("padding .bss ... %lx bytes\n", bss_padding); - empty_space = malloc(bss_padding); - memset(empty_space, 0, bss_padding); - if (write(a_new, empty_space, bss_padding) != (int)bss_padding) - PERROR("failed to write bss section"); - free(empty_space); + empty_space = malloc (bss_padding); + memset (empty_space, 0, bss_padding); + if (write (a_new, empty_space, bss_padding) != bss_padding) + PERROR ("failed to write bss section"); + free (empty_space); } /* tell dumped version not to free pure heap */ static_heap_dumped = 1; /* Get a pointer to the raw data in our address space. */ printf ("dumping .data section... %lx bytes\n", data_size); - if (write(a_new, data_start_va, data_size) != (int)data_size) - PERROR("failed to write data section"); + if (write (a_new, data_start_va, data_size) != data_size) + PERROR ("failed to write data section"); /* were going to use free again ... */ static_heap_dumped = 0; - size = lseek(a_out, f_data_s_scnptr + data_size, SEEK_SET); + size = lseek (a_out, f_data_s_scnptr + data_size, SEEK_SET); if (!sections_reversed) { size = f_nextdata_s_scnptr - size; - dup_file_area(a_out, a_new, size); + dup_file_area (a_out, a_new, size); } else { /* need to pad to bss with data in file */ printf ("padding .data ... %lx bytes\n", data_padding); size = (f_bss_s_vaddr - f_data_s_vaddr) - data_size; - dup_file_area(a_out, a_new, size); + dup_file_area (a_out, a_new, size); /* dump bss + padding between sections */ printf ("dumping .bss into executable... %lx bytes\n", bss_size); - if (write(a_new, bss_start, bss_size) != (int)bss_size) - PERROR("failed to write bss section"); + if (write (a_new, bss_start, bss_size) != bss_size) + PERROR ("failed to write bss section"); /* pad, needs to be zero */ bss_padding = (new_bss_size - bss_size) - BSS_PAD_SIZE; if (bss_padding < 0) - PERROR("padded .bss too small"); + PERROR ("padded .bss too small"); printf ("padding .bss ... %lx bytes\n", bss_padding); - empty_space = malloc(bss_padding); - memset(empty_space, 0, bss_padding); - if (write(a_new, empty_space, bss_padding) != (int)bss_padding) - PERROR("failed to write bss section"); - free(empty_space); - if (lseek(a_new, 0, SEEK_CUR) != f_nextdata.s_scnptr) + empty_space = malloc (bss_padding); + memset (empty_space, 0, bss_padding); + if (write (a_new, empty_space, bss_padding) != bss_padding) + PERROR ("failed to write bss section"); + free (empty_space); + if (lseek (a_new, 0, SEEK_CUR) != (long) f_nextdata.s_scnptr) { - printf("at %lx should be at %lx\n", - lseek(a_new, 0, SEEK_CUR), + printf ("at %lx should be at %lx\n", + lseek (a_new, 0, SEEK_CUR), f_nextdata.s_scnptr); - PERROR("file positioning error\n"); + PERROR ("file positioning error\n"); } - lseek(a_out, f_nextdata_s_scnptr, SEEK_SET); + lseek (a_out, f_nextdata_s_scnptr, SEEK_SET); } - CHECK_AOUT_POS(f_nextdata_s_scnptr); + CHECK_AOUT_POS (f_nextdata_s_scnptr); /* now dump - nextdata don't need to do this cygwin ds is in .data! */ printf ("dumping following data section... %lx bytes\n", f_nextdata.s_size); - dup_file_area(a_out,a_new,f_nextdata.s_size); + dup_file_area (a_out,a_new,f_nextdata.s_size); /* write rest of file */ printf ("writing rest of file\n"); - size = lseek(a_out, 0, SEEK_END); + size = lseek (a_out, 0, SEEK_END); size = size - (f_nextdata_s_scnptr + f_nextdata.s_size); /* length remaining in a_out */ - lseek(a_out, f_nextdata_s_scnptr + f_nextdata.s_size, SEEK_SET); + lseek (a_out, f_nextdata_s_scnptr + f_nextdata.s_size, SEEK_SET); - dup_file_area(a_out, a_new, size); + dup_file_area (a_out, a_new, size); } /* * copy from aout to anew */ -static void dup_file_area(int a_out, int a_new, long size) +static void +dup_file_area (int a_out, int a_new, long size) { char page[BUFSIZ]; long n; for (; size > 0; size -= sizeof (page)) { - n = size > sizeof (page) ? sizeof (page) : size; + n = size > (long) sizeof (page) ? sizeof (page) : size; if (read (a_out, page, n) != n || write (a_new, page, n) != n) PERROR ("dump_out()"); } } #if 0 -static void write_int_to_bss(int a_out, int a_new, void* va, void* newval) +static void +write_int_to_bss (int a_out, int a_new, void* va, void* newval) { int cpos; - cpos = lseek(a_new, 0, SEEK_CUR); + cpos = lseek (a_new, 0, SEEK_CUR); if (va < bss_start || va > bss_start + f_data.s_size) - PERROR("address not in data space\n"); - lseek(a_new, f_data.s_scnptr + ((unsigned long)va - + PERROR ("address not in data space\n"); + lseek (a_new, f_data.s_scnptr + ((unsigned long)va - (unsigned long)bss_start), SEEK_SET); - if (write(a_new, newval, sizeof(int)) != (int)sizeof(int)) - PERROR("failed to write int value"); - lseek(a_new, cpos, SEEK_SET); + if (write (a_new, newval, sizeof (int)) != (int) sizeof (int)) + PERROR ("failed to write int value"); + lseek (a_new, cpos, SEEK_SET); } #endif
--- a/src/unexec.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/unexec.c Mon Aug 13 04:46:48 2001 +0000 @@ -710,7 +710,7 @@ if (a_out >= 0) { #ifdef COFF_ENCAPSULATE - if (read (a_out, &coffheader, sizeof coffheader) != sizeof coffheader) + if (read (a_out, &coffheader, sizeof (coffheader)) != sizeof (coffheader)) { PERROR(a_name); } @@ -719,7 +719,7 @@ ERROR1("%s doesn't have legal coff magic number\n", a_name); } #endif - if (read (a_out, (char *) &ohdr, sizeof hdr) != sizeof hdr) + if (read (a_out, (char *) &ohdr, sizeof (hdr)) != sizeof (hdr)) { PERROR (a_name); } @@ -738,7 +738,7 @@ */ ERROR0 ("can't build a COFF file from scratch yet"); #else - memset ((void *)&hdr, 0, sizeof hdr); + memset ((void *)&hdr, 0, sizeof (hdr)); #endif } @@ -788,13 +788,13 @@ coffheader.text_start = tp->s_vaddr; coffheader.data_start = dp->s_vaddr; } - if (write (new, &coffheader, sizeof coffheader) != sizeof coffheader) + if (write (new, &coffheader, sizeof (coffheader)) != sizeof (coffheader)) { PERROR(new_name); } #endif /* COFF_ENCAPSULATE */ - if (write (new, (char *) &hdr, sizeof hdr) != sizeof hdr) + if (write (new, (char *) &hdr, sizeof (hdr)) != sizeof (hdr)) { PERROR (new_name); } @@ -1099,7 +1099,7 @@ #endif /* COFF */ lseek (a_out, SYMS_START, 0); /* Position a.out to symtab. */ - while ((n = read (a_out, page, sizeof page)) > 0) + while ((n = read (a_out, page, sizeof (page))) > 0) { if (write (new, page, n) != n) {
--- a/src/window.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/window.c Mon Aug 13 04:46:48 2001 +0000 @@ -5083,7 +5083,7 @@ /* Record the values of window-min-width and window-min-height so that window sizes remain consistent with them. */ int min_width, min_height; - unsigned int saved_windows_count; + int saved_windows_count; /* Zero-sized arrays aren't ANSI C */ struct saved_window saved_windows[1]; }; @@ -5099,7 +5099,7 @@ mark_window_config (Lisp_Object obj) { struct window_config *config = XWINDOW_CONFIGURATION (obj); - unsigned int i; + int i; mark_object (config->current_window); mark_object (config->current_buffer); mark_object (config->minibuffer_scroll_window); @@ -5129,14 +5129,14 @@ return Qnil; } -inline static size_t -sizeof_window_config_for_n_windows (unsigned int n) +inline static Memory_Count +sizeof_window_config_for_n_windows (int n) { return FLEXIBLE_ARRAY_STRUCT_SIZEOF (struct window_config, struct saved_window, saved_windows, n); } -static size_t +static Memory_Count sizeof_window_config (const void *h) { const struct window_config *c = (const struct window_config *) h; @@ -5199,7 +5199,7 @@ window_config_equal (Lisp_Object conf1, Lisp_Object conf2) { struct window_config *fig1, *fig2; - unsigned int i; + int i; /* First check if they are truly the same. */ if (EQ (conf1, conf2)) @@ -5254,7 +5254,7 @@ static Lisp_Object free_window_configuration (Lisp_Object window_config) { - unsigned int i; + int i; struct window_config *config = XWINDOW_CONFIGURATION (window_config); /* Free all the markers. It's not completely necessary that @@ -5306,7 +5306,7 @@ struct window_config *config; struct saved_window *p; Lisp_Object new_current_buffer; - unsigned int k; + int k; Lisp_Object frame; struct frame *f; struct gcpro gcpro1; @@ -5805,7 +5805,7 @@ } -static unsigned int +static int count_windows (struct window *window) { return 1 + @@ -5921,7 +5921,7 @@ Lisp_Object result; struct frame *f = decode_frame (frame); struct window_config *config; - unsigned int n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f))); + int n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f))); int minibuf_height; int real_font_height; @@ -6234,7 +6234,7 @@ void reinit_vars_of_window (void) { - unsigned int i; + int i; /* Make sure all windows get marked */ minibuf_window = Qnil; staticpro_nodump (&minibuf_window);
--- a/src/xgccache.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/xgccache.c Mon Aug 13 04:46:48 2001 +0000 @@ -104,7 +104,7 @@ every slot of the gcv when calling gc_cache_lookup. But we need the hash function to be as fast as possible; some timings should be done. */ - for (i = 0; i < (sizeof (XGCValues) / sizeof (unsigned long)); i++) + for (i = 0; i < (int) (sizeof (XGCValues) / sizeof (unsigned long)); i++) hash = (hash<<1) ^ *longs++; return hash; }
--- a/src/xmu.c Wed Aug 08 12:15:04 2001 +0000 +++ b/src/xmu.c Mon Aug 13 04:46:48 2001 +0000 @@ -141,7 +141,7 @@ int i; char tmp[40]; - if (strlen (name) >= sizeof tmp) return -1; + if (strlen (name) >= sizeof (tmp)) return -1; for (i=0; i<strlen(name); i++) if (isupper((unsigned char) name[i])) tmp[i] = tolower((unsigned char) name[i]);