Mercurial > hg > xemacs-beta
annotate src/termcap.c @ 4976:16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-02-04 Ben Wing <ben@xemacs.org>
* alloc.c (release_breathing_space):
* alloc.c (resize_string):
* alloc.c (sweep_lcrecords_1):
* alloc.c (SWEEP_FIXED_TYPE_BLOCK_1):
* alloc.c (ADDITIONAL_FREE_compiled_function):
* alloc.c (compact_string_chars):
* alloc.c (ADDITIONAL_FREE_string):
* alloc.c (sweep_strings):
* alloca.c (xemacs_c_alloca):
* alsaplay.c (alsa_play_sound_file):
* buffer.c (init_initial_directory):
* buffer.h:
* buffer.h (BUFFER_FREE):
* console-stream.c (stream_delete_console):
* console-tty.c (free_tty_console_struct):
* data.c (Fnumber_to_string):
* device-gtk.c (gtk_init_device):
* device-gtk.c (free_gtk_device_struct):
* device-gtk.c (gtk_delete_device):
* device-msw.c (mswindows_delete_device):
* device-msw.c (msprinter_delete_device):
* device-tty.c (free_tty_device_struct):
* device-tty.c (tty_delete_device):
* device-x.c (x_init_device):
* device-x.c (free_x_device_struct):
* device-x.c (x_delete_device):
* dialog-msw.c (handle_directory_dialog_box):
* dialog-x.c (dbox_descriptor_to_widget_value):
* dired-msw.c (Fmswindows_insert_directory):
* dired.c (free_user_cache):
* dired.c (user_name_completion_unwind):
* doc.c (unparesseuxify_doc_string):
* doc.c (Fsubstitute_command_keys):
* doprnt.c (emacs_doprnt_1):
* dumper.c (pdump_load_finish):
* dumper.c (pdump_file_free):
* dumper.c (pdump_file_unmap):
* dynarr.c:
* dynarr.c (Dynarr_free):
* editfns.c (uncache_home_directory):
* editfns.c (Fset_time_zone_rule):
* elhash.c:
* elhash.c (pdump_reorganize_hash_table):
* elhash.c (maphash_unwind):
* emacs.c (make_arg_list_1):
* emacs.c (free_argc_argv):
* emacs.c (sort_args):
* emacs.c (Frunning_temacs_p):
* emodules.c (attempt_module_delete):
* eval.c (free_pointer):
* event-Xt.c (unselect_filedesc):
* event-Xt.c (emacs_Xt_select_process):
* event-gtk.c (unselect_filedesc):
* event-gtk.c (dragndrop_data_received):
* event-msw.c (winsock_closer):
* event-msw.c (mswindows_dde_callback):
* event-msw.c (mswindows_wnd_proc):
* event-stream.c (finalize_command_builder):
* event-stream.c (free_command_builder):
* extents.c (free_gap_array):
* extents.c (free_extent_list):
* extents.c (free_soe):
* extents.c (extent_fragment_delete):
* extents.c (extent_priority_sort_function):
* file-coding.c (make_coding_system_1):
* file-coding.c (coding_finalizer):
* file-coding.c (set_coding_stream_coding_system):
* file-coding.c (chain_finalize_coding_stream_1):
* file-coding.c (chain_finalize):
* file-coding.c (free_detection_state):
* file-coding.c (coding_category_symbol_to_id):
* fileio.c:
* fileio.c (Ffile_name_directory):
* fileio.c (if):
* fileio.c (Ffile_symlink_p):
* filelock.c (FREE_LOCK_INFO):
* filelock.c (current_lock_owner):
* font-mgr.c (Ffc_name_unparse):
* font-mgr.c (Ffc_pattern_duplicate):
* frame-gtk.c (gtk_delete_frame):
* frame-msw.c (mswindows_delete_frame):
* frame-msw.c (msprinter_delete_frame):
* frame-x.c (x_cde_destroy_callback):
* frame-x.c (Fcde_start_drag_internal):
* frame-x.c (x_cde_transfer_callback):
* frame-x.c (x_delete_frame):
* frame.c (update_frame_title):
* frame.c (Fset_frame_pointer):
* gc.c (register_for_finalization):
* gccache-gtk.c (free_gc_cache):
* gccache-gtk.c (gc_cache_lookup):
* gccache-x.c (free_gc_cache):
* gccache-x.c (gc_cache_lookup):
* glyphs-eimage.c:
* glyphs-eimage.c (jpeg_instantiate_unwind):
* glyphs-eimage.c (gif_instantiate_unwind):
* glyphs-eimage.c (png_instantiate_unwind):
* glyphs-eimage.c (png_instantiate):
* glyphs-eimage.c (tiff_instantiate_unwind):
* glyphs-gtk.c (convert_EImage_to_GDKImage):
* glyphs-gtk.c (gtk_finalize_image_instance):
* glyphs-gtk.c (gtk_init_image_instance_from_eimage):
* glyphs-gtk.c (gtk_xpm_instantiate):
* glyphs-msw.c (convert_EImage_to_DIBitmap):
* glyphs-msw.c (mswindows_init_image_instance_from_eimage):
* glyphs-msw.c (mswindows_initialize_image_instance_mask):
* glyphs-msw.c (xpm_to_eimage):
* glyphs-msw.c (mswindows_xpm_instantiate):
* glyphs-msw.c (xbm_create_bitmap_from_data):
* glyphs-msw.c (mswindows_finalize_image_instance):
* glyphs-x.c (convert_EImage_to_XImage):
* glyphs-x.c (x_finalize_image_instance):
* glyphs-x.c (x_init_image_instance_from_eimage):
* glyphs-x.c (x_xpm_instantiate):
* gui-x.c (free_popup_widget_value_tree):
* hash.c (free_hash_table):
* hash.c (grow_hash_table):
* hash.c (pregrow_hash_table_if_necessary):
* imgproc.c (build_EImage_quantable):
* insdel.c (uninit_buffer_text):
* intl-win32.c (convert_multibyte_to_internal_malloc):
* intl.c:
* intl.c (Fset_current_locale):
* keymap.c:
* keymap.c (where_is_recursive_mapper):
* keymap.c (where_is_internal):
* lisp.h:
* lisp.h (xfree):
* lstream.c (Lstream_close):
* lstream.c (resizing_buffer_closer):
* mule-coding.c:
* mule-coding.c (iso2022_finalize_detection_state):
* nt.c:
* nt.c (mswindows_get_long_filename):
* nt.c (nt_get_resource):
* nt.c (init_mswindows_environment):
* nt.c (get_cached_volume_information):
* nt.c (mswindows_opendir):
* nt.c (mswindows_closedir):
* nt.c (mswindows_readdir):
* nt.c (mswindows_stat):
* nt.c (mswindows_getdcwd):
* nt.c (Fmswindows_long_file_name):
* ntplay.c (nt_play_sound_file):
* ntplay.c (play_sound_data_1):
* number-gmp.c (gmp_free):
* number-gmp.c (init_number_gmp):
* number-mp.c (bignum_to_string):
* number-mp.c (BIGNUM_TO_TYPE):
* number.c (bignum_print):
* number.c (bignum_convfree):
* number.c (ratio_print):
* number.c (bigfloat_print):
* number.c (bigfloat_finalize):
* objects-gtk.c (gtk_finalize_color_instance):
* objects-gtk.c (gtk_finalize_font_instance):
* objects-msw.c (mswindows_finalize_color_instance):
* objects-msw.c (mswindows_finalize_font_instance):
* objects-tty.c (tty_finalize_color_instance):
* objects-tty.c (tty_finalize_font_instance):
* objects-tty.c (tty_font_list):
* objects-x.c (x_finalize_color_instance):
* objects-x.c (x_finalize_font_instance):
* process.c:
* process.c (finalize_process):
* realpath.c:
* redisplay.c (add_propagation_runes):
* regex.c:
* regex.c (xfree):
* regex.c (REGEX_FREE_STACK):
* regex.c (FREE_STACK_RETURN):
* regex.c (regex_compile):
* regex.c (regexec):
* regex.c (regfree):
* scrollbar-gtk.c (gtk_free_scrollbar_instance):
* scrollbar-gtk.c (gtk_release_scrollbar_instance):
* scrollbar-msw.c (mswindows_free_scrollbar_instance):
* scrollbar-msw.c (unshow_that_mofo):
* scrollbar-x.c (x_free_scrollbar_instance):
* scrollbar-x.c (x_release_scrollbar_instance):
* select-gtk.c (emacs_gtk_selection_handle):
* select-msw.c (mswindows_own_selection):
* select-x.c:
* select-x.c (x_handle_selection_request):
* select-x.c (unexpect_property_change):
* select-x.c (x_handle_property_notify):
* select-x.c (receive_incremental_selection):
* select-x.c (x_get_window_property_as_lisp_data):
* select-x.c (Fx_get_cutbuffer_internal):
* specifier.c (finalize_specifier):
* syntax.c (uninit_buffer_syntax_cache):
* sysdep.c (qxe_allocating_getcwd):
* sysdep.c (qxe_lstat):
* sysdep.c (copy_in_passwd):
* sysdep.c (qxe_ctime):
* sysdep.c (closedir):
* sysdep.c (DIRSIZ):
* termcap.c (tgetent):
* termcap.c (tprint):
* tests.c (Ftest_data_format_conversion):
* text.c (new_dfc_convert_copy_data):
* text.h (eifree):
* text.h (eito_alloca):
* text.h (eito_external):
* toolbar-msw.c (mswindows_output_toolbar):
* ui-gtk.c (CONVERT_RETVAL):
* ui-gtk.c (__allocate_object_storage):
* unicode.c (free_from_unicode_table):
* unicode.c (free_to_unicode_table):
* unicode.c (free_charset_unicode_tables):
* win32.c (mswindows_read_link_1):
Rename: xfree(VAL, TYPE)->xfree(VAL)
Command used:
gr 'xfree *\((.*),.*\);' 'xfree (\1);' *.[ch]
Followed by grepping for 'xfree.*,' and fixing anything left.
Rationale: Having to specify the TYPE argument is annoying and
error-prone. It was originally put in to work around warnings
due to strict aliasing but years and years ago I rewrote it
in a way that doesn't use the TYPE argument at all and no one
has complained since then. (And anyway, XEmacs is far from
ever being in compliance with strict aliasing and would require
far-reaching changes to get that way.)
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Thu, 04 Feb 2010 07:28:14 -0600 |
| parents | a8d8f419b459 |
| children | dd2976af8783 |
| rev | line source |
|---|---|
| 428 | 1 /* Work-alike for termcap, plus extra features. |
| 2 Copyright (C) 1985, 1986, 1993 Free Software Foundation, Inc. | |
| 771 | 3 Copyright (C) 2001 Ben Wing. |
| 428 | 4 |
| 5 This file is part of XEmacs. | |
| 6 | |
| 7 XEmacs is free software; you can redistribute it and/or modify it | |
| 8 under the terms of the GNU General Public License as published by the | |
| 9 Free Software Foundation; either version 2, or (at your option) any | |
| 10 later version. | |
| 11 | |
| 12 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with XEmacs; see the file COPYING. If not, write to | |
| 19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 20 Boston, MA 02111-1307, USA. */ | |
| 21 | |
| 22 /* Synched up with: Not synched with FSF. */ | |
| 23 | |
| 24 /* config.h may rename various library functions such as malloc. */ | |
| 25 #ifdef emacs | |
| 26 #include <config.h> | |
| 27 #include "lisp.h" /* For encapsulated open, close, read */ | |
| 28 #include "device.h" /* For DEVICE_BAUD_RATE */ | |
| 29 #else /* not emacs */ | |
| 30 | |
| 31 #include <stdlib.h> | |
| 32 #include <string.h> | |
| 33 | |
| 34 #ifdef HAVE_UNISTD_H | |
| 35 #include <unistd.h> | |
| 36 #endif | |
| 37 #ifdef _POSIX_VERSION | |
| 38 #include <fcntl.h> | |
| 39 #endif | |
| 40 | |
| 41 #endif /* not emacs */ | |
| 42 | |
| 43 /* BUFSIZE is the initial size allocated for the buffer | |
| 44 for reading the termcap file. | |
| 45 It is not a limit. | |
| 46 Make it large normally for speed. | |
| 47 Make it variable when debugging, so can exercise | |
| 48 increasing the space dynamically. */ | |
| 49 | |
| 50 #ifndef BUFSIZE | |
| 51 #ifdef DEBUG | |
| 52 #define BUFSIZE bufsize | |
| 53 | |
| 54 int bufsize = 128; | |
| 55 #else | |
| 56 #define BUFSIZE 2048 | |
| 57 #endif | |
| 58 #endif | |
| 59 | |
| 60 #ifndef emacs | |
| 61 static void | |
| 62 memory_out () | |
| 63 { | |
| 771 | 64 retry_write (2, "virtual memory exhausted\n", 25); |
| 428 | 65 exit (1); |
| 66 } | |
| 67 | |
| 68 static char * | |
| 69 xmalloc (size) | |
| 70 unsigned int size; | |
| 71 { | |
| 72 char *tem = malloc (size); | |
| 73 | |
| 74 if (!tem) | |
| 75 memory_out (); | |
| 76 return tem; | |
| 77 } | |
| 78 | |
| 79 static char * | |
| 80 xrealloc (ptr, size) | |
| 81 char *ptr; | |
| 82 unsigned size; | |
| 83 { | |
| 84 char *tem = realloc (ptr, size); | |
| 85 | |
| 86 if (!tem) | |
| 87 memory_out (); | |
| 88 return tem; | |
| 89 } | |
| 90 #endif /* not emacs */ | |
| 91 | |
| 92 /* Looking up capabilities in the entry already found. */ | |
| 93 | |
| 94 /* The pointer to the data made by tgetent is left here | |
| 95 for tgetnum, tgetflag and tgetstr to find. */ | |
| 96 static char *term_entry; | |
| 97 | |
| 442 | 98 static const char *tgetst1 (const char *ptr, char **area); |
| 428 | 99 |
| 100 /* Search entry BP for capability CAP. | |
| 101 Return a pointer to the capability (in BP) if found, | |
| 102 0 if not found. */ | |
| 103 | |
| 442 | 104 static const char * |
| 428 | 105 find_capability (bp, cap) |
| 442 | 106 const char *bp; |
| 107 const char *cap; | |
| 428 | 108 { |
| 109 for (; *bp; bp++) | |
| 110 if (bp[0] == ':' | |
| 111 && bp[1] == cap[0] | |
| 112 && bp[2] == cap[1]) | |
| 113 return &bp[4]; | |
| 114 return 0; | |
| 115 } | |
| 116 | |
| 117 int | |
| 118 tgetnum (cap) | |
| 442 | 119 const char *cap; |
| 428 | 120 { |
| 442 | 121 const char *ptr = find_capability (term_entry, cap); |
| 428 | 122 if (!ptr || ptr[-1] != '#') |
| 123 return -1; | |
| 124 return atoi (ptr); | |
| 125 } | |
| 126 | |
| 127 int | |
| 128 tgetflag (cap) | |
| 442 | 129 const char *cap; |
| 428 | 130 { |
| 442 | 131 const char *ptr = find_capability (term_entry, cap); |
| 428 | 132 return 0 != ptr && ptr[-1] == ':'; |
| 133 } | |
| 134 | |
| 135 /* Look up a string-valued capability CAP. | |
| 136 If AREA is nonzero, it points to a pointer to a block in which | |
| 137 to store the string. That pointer is advanced over the space used. | |
| 138 If AREA is zero, space is allocated with `malloc'. */ | |
| 139 | |
| 442 | 140 const char * |
| 428 | 141 tgetstr (cap, area) |
| 442 | 142 const char *cap; |
| 428 | 143 char **area; |
| 144 { | |
| 442 | 145 const char *ptr = find_capability (term_entry, cap); |
| 428 | 146 if (!ptr || (ptr[-1] != '=' && ptr[-1] != '~')) |
| 147 return 0; | |
| 148 return tgetst1 (ptr, area); | |
| 149 } | |
| 150 | |
| 151 /* Table, indexed by a character in range 0100 to 0140 with 0100 subtracted, | |
| 152 gives meaning of character following \, or a space if no special meaning. | |
| 153 Eight characters per line within the string. */ | |
| 154 | |
| 155 static char esctab[] | |
| 156 = " \007\010 \033\014 " | |
| 157 " \012 " | |
| 158 " \015 \011 \013 " | |
| 159 " "; | |
| 160 | |
| 161 /* PTR points to a string value inside a termcap entry. | |
| 162 Copy that value, processing \ and ^ abbreviations, | |
| 163 into the block that *AREA points to, | |
| 164 or to newly allocated storage if AREA is 0. */ | |
| 165 | |
| 442 | 166 static const char * |
| 428 | 167 tgetst1 (ptr, area) |
| 442 | 168 const char *ptr; |
| 428 | 169 char **area; |
| 170 { | |
| 442 | 171 const char *p; |
| 428 | 172 char *r; |
| 173 int c; | |
| 174 int size; | |
| 175 char *ret; | |
| 176 int c1; | |
| 177 | |
| 178 if (!ptr) | |
| 179 return 0; | |
| 180 | |
| 181 /* `ret' gets address of where to store the string. */ | |
| 182 if (!area) | |
| 183 { | |
| 184 /* Compute size of block needed (may overestimate). */ | |
| 185 p = ptr; | |
| 186 while ((c = *p++) && c != ':' && c != '\n') | |
| 187 ; | |
| 188 ret = (char *) xmalloc (p - ptr + 1); | |
| 189 } | |
| 190 else | |
| 191 ret = *area; | |
| 192 | |
| 193 /* Copy the string value, stopping at null or colon. | |
| 194 Also process ^ and \ abbreviations. */ | |
| 195 p = ptr; | |
| 196 r = ret; | |
| 197 while ((c = *p++) && c != ':' && c != '\n') | |
| 198 { | |
| 199 if (c == '^') | |
| 200 c = *p++ & 037; | |
| 201 else if (c == '\\') | |
| 202 { | |
| 203 c = *p++; | |
| 204 if (c >= '0' && c <= '7') | |
| 205 { | |
| 206 c -= '0'; | |
| 207 size = 0; | |
| 208 | |
| 209 while (++size < 3 && (c1 = *p) >= '0' && c1 <= '7') | |
| 210 { | |
| 211 c *= 8; | |
| 212 c += c1 - '0'; | |
| 213 p++; | |
| 214 } | |
| 215 } | |
| 216 else if (c >= 0100 && c < 0200) | |
| 217 { | |
| 218 c1 = esctab[(c & ~040) - 0100]; | |
| 219 if (c1 != ' ') | |
| 220 c = c1; | |
| 221 } | |
| 222 } | |
| 223 *r++ = c; | |
| 224 } | |
| 225 *r = 0; | |
| 226 /* Update *AREA. */ | |
| 227 if (area) | |
| 228 *area = r + 1; | |
| 229 return ret; | |
| 230 } | |
| 231 | |
| 232 /* Outputting a string with padding. */ | |
| 233 | |
| 234 #ifdef LINUX | |
| 235 speed_t ospeed; | |
| 236 #else | |
| 237 short ospeed; | |
| 238 #endif | |
| 239 /* If `ospeed' is 0, we use `tputs_baud_rate' as the actual baud rate. */ | |
| 240 int tputs_baud_rate; | |
| 241 char PC; | |
| 242 | |
| 243 /* Actual baud rate if positive; | |
| 244 - baud rate / 100 if negative. */ | |
| 245 | |
| 246 static short speeds[] = | |
| 247 { | |
| 248 0, 50, 75, 110, 135, 150, -2, -3, -6, -12, | |
| 249 -18, -24, -48, -96, -192, -288, -384, -576, -1152 | |
| 250 }; | |
| 251 | |
| 252 void | |
| 253 tputs (string, nlines, outfun) | |
| 442 | 254 const char *string; |
| 428 | 255 int nlines; |
| 256 void (*outfun) (int); | |
| 257 { | |
| 258 int padcount = 0; | |
| 259 int speed; | |
| 260 | |
| 261 #ifdef emacs | |
| 262 speed = DEVICE_BAUD_RATE (XDEVICE (Fselected_device (Qnil))); | |
| 263 #else | |
| 264 if (ospeed == 0) | |
| 265 speed = tputs_baud_rate; | |
| 266 else | |
| 267 speed = speeds[ospeed]; | |
| 268 #endif | |
| 269 | |
| 270 if (string == (char *) 0) | |
| 271 return; | |
| 272 | |
| 442 | 273 while (isdigit (* (const unsigned char *) string)) |
| 428 | 274 { |
| 275 padcount += *string++ - '0'; | |
| 276 padcount *= 10; | |
| 277 } | |
| 278 if (*string == '.') | |
| 279 { | |
| 280 string++; | |
| 281 padcount += *string++ - '0'; | |
| 282 } | |
| 283 if (*string == '*') | |
| 284 { | |
| 285 string++; | |
| 286 padcount *= nlines; | |
| 287 } | |
| 288 while (*string) | |
| 289 (*outfun) (*string++); | |
| 290 | |
| 291 /* padcount is now in units of tenths of msec. */ | |
| 292 padcount *= speeds[ospeed]; | |
| 293 padcount += 500; | |
| 294 padcount /= 1000; | |
| 295 if (speeds[ospeed] < 0) | |
| 296 padcount = -padcount; | |
| 297 else | |
| 298 { | |
| 299 padcount += 50; | |
| 300 padcount /= 100; | |
| 301 } | |
| 302 | |
| 303 while (padcount-- > 0) | |
| 304 (*outfun) (PC); | |
| 305 } | |
| 306 | |
| 307 /* Finding the termcap entry in the termcap data base. */ | |
| 308 | |
| 309 struct buffer | |
| 310 { | |
| 311 char *beg; | |
| 312 int size; | |
| 313 char *ptr; | |
| 314 int ateof; | |
| 315 int full; | |
| 316 }; | |
| 317 | |
| 318 /* Forward declarations of static functions. */ | |
| 319 | |
| 320 static int scan_file (); | |
| 321 static char *gobble_line (); | |
| 322 static int compare_contin (); | |
| 323 static int name_match (); | |
| 324 | |
| 325 | |
| 326 /* Find the termcap entry data for terminal type NAME | |
| 327 and store it in the block that BP points to. | |
| 328 Record its address for future use. | |
| 329 | |
| 330 If BP is zero, space is dynamically allocated. */ | |
| 331 | |
| 332 int | |
| 333 tgetent (bp, name) | |
| 334 char *bp; | |
| 442 | 335 const char *name; |
| 428 | 336 { |
| 337 char *tem; | |
| 338 int fd; | |
| 339 struct buffer buf; | |
| 340 char *bp1; | |
| 341 char *bp2; | |
| 442 | 342 const char *term; |
| 428 | 343 int malloc_size = 0; |
| 344 int c; | |
| 442 | 345 char *tcenv; /* TERMCAP value, if it contains :tc=. */ |
| 346 const char *indirect = 0; /* Terminal type in :tc= in TERMCAP value. */ | |
| 428 | 347 |
| 771 | 348 tem = egetenv ("TERMCAP"); |
| 428 | 349 if (tem && *tem == 0) tem = 0; |
| 350 | |
| 351 | |
| 352 /* If tem is non-null and starts with / (in the un*x case, that is), | |
| 353 it is a file name to use instead of /etc/termcap. | |
| 354 If it is non-null and does not start with /, | |
| 355 it is the entry itself, but only if | |
| 356 the name the caller requested matches the TERM variable. */ | |
| 357 | |
| 771 | 358 if (tem && !IS_DIRECTORY_SEP (*tem) && !strcmp (name, egetenv ("TERM"))) |
| 428 | 359 { |
| 360 indirect = tgetst1 (find_capability (tem, "tc"), 0); | |
| 361 if (!indirect) | |
| 362 { | |
| 363 if (!bp) | |
| 364 bp = tem; | |
| 365 else | |
| 366 strcpy (bp, tem); | |
| 367 goto ret; | |
| 368 } | |
| 369 else | |
| 370 { /* We will need to read /etc/termcap. */ | |
| 371 tcenv = tem; | |
| 372 tem = 0; | |
| 373 } | |
| 374 } | |
| 375 else | |
| 376 indirect = (char *) 0; | |
| 377 | |
| 378 if (!tem) | |
| 379 tem = "/etc/termcap"; | |
| 380 | |
| 381 /* Here we know we must search a file and tem has its name. */ | |
| 382 | |
| 867 | 383 fd = qxe_open ((Ibyte *) tem, 0, 0); |
| 428 | 384 if (fd < 0) |
| 385 return -1; | |
| 386 | |
| 387 buf.size = BUFSIZE; | |
| 388 /* Add 1 to size to ensure room for terminating null. */ | |
| 389 buf.beg = (char *) xmalloc (buf.size + 1); | |
| 390 term = indirect ? indirect : name; | |
| 391 | |
| 392 if (!bp) | |
| 393 { | |
| 394 malloc_size = indirect ? strlen (tcenv) + 1 : buf.size; | |
| 395 bp = (char *) xmalloc (malloc_size); | |
| 396 } | |
| 397 bp1 = bp; | |
| 398 | |
| 399 if (indirect) | |
| 400 /* Copy the data from the environment variable. */ | |
| 401 { | |
| 402 strcpy (bp, tcenv); | |
| 403 bp1 += strlen (tcenv); | |
| 404 } | |
| 405 | |
| 406 while (term) | |
| 407 { | |
| 408 /* Scan the file, reading it via buf, till find start of main entry. */ | |
| 409 if (scan_file (term, fd, &buf) == 0) | |
| 410 return 0; | |
| 411 | |
| 412 /* Free old `term' if appropriate. */ | |
| 413 if (term != name) | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
1726
diff
changeset
|
414 xfree (term); |
| 428 | 415 |
| 416 /* If BP is malloc'd by us, make sure it is big enough. */ | |
| 417 if (malloc_size) | |
| 418 { | |
| 419 malloc_size = bp1 - bp + buf.size; | |
| 420 tem = (char *) xrealloc (bp, malloc_size); | |
| 421 bp1 += tem - bp; | |
| 422 bp = tem; | |
| 423 } | |
| 424 | |
| 425 bp2 = bp1; | |
| 426 | |
| 427 /* Copy the line of the entry from buf into bp. */ | |
| 428 tem = buf.ptr; | |
| 429 while ((*bp1++ = c = *tem++) && c != '\n') | |
| 430 /* Drop out any \ newline sequence. */ | |
| 431 if (c == '\\' && *tem == '\n') | |
| 432 { | |
| 433 bp1--; | |
| 434 tem++; | |
| 435 } | |
| 436 *bp1 = 0; | |
| 437 | |
| 438 /* Does this entry refer to another terminal type's entry? | |
| 439 If something is found, copy it into heap and null-terminate it. */ | |
| 440 term = tgetst1 (find_capability (bp2, "tc"), 0); | |
| 441 } | |
| 442 | |
| 771 | 443 retry_close (fd); |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
1726
diff
changeset
|
444 xfree (buf.beg); |
| 428 | 445 |
| 446 if (malloc_size) | |
| 447 { | |
| 448 bp = (char *) xrealloc (bp, bp1 - bp + 1); | |
| 449 } | |
| 450 | |
| 451 ret: | |
| 452 term_entry = bp; | |
| 453 if (malloc_size) | |
| 454 /* #### yuck, why the hell are we casting a pointer to an int? */ | |
| 455 return (int) (long) bp; | |
| 456 return 1; | |
| 457 } | |
| 458 | |
| 459 /* Given file open on FD and buffer BUFP, | |
| 460 scan the file from the beginning until a line is found | |
| 461 that starts the entry for terminal type STRING. | |
| 462 Returns 1 if successful, with that line in BUFP, | |
| 463 or returns 0 if no entry found in the file. */ | |
| 464 | |
| 465 static int | |
| 466 scan_file (string, fd, bufp) | |
| 467 char *string; | |
| 468 int fd; | |
| 469 struct buffer *bufp; | |
| 470 { | |
| 471 char *end; | |
| 472 | |
| 473 bufp->ptr = bufp->beg; | |
| 474 bufp->full = 0; | |
| 475 bufp->ateof = 0; | |
| 476 *bufp->ptr = 0; | |
| 477 | |
| 478 lseek (fd, 0L, 0); | |
| 479 | |
| 480 while (!bufp->ateof) | |
| 481 { | |
| 482 /* Read a line into the buffer. */ | |
| 483 end = 0; | |
| 484 do | |
| 485 { | |
| 486 /* if it is continued, append another line to it, | |
| 487 until a non-continued line ends. */ | |
| 488 end = gobble_line (fd, bufp, end); | |
| 489 } | |
| 490 while (!bufp->ateof && end[-2] == '\\'); | |
| 491 | |
| 492 if (*bufp->ptr != '#' | |
| 493 && name_match (bufp->ptr, string)) | |
| 494 return 1; | |
| 495 | |
| 496 /* Discard the line just processed. */ | |
| 497 bufp->ptr = end; | |
| 498 } | |
| 499 return 0; | |
| 500 } | |
| 501 | |
| 502 /* Return nonzero if NAME is one of the names specified | |
| 503 by termcap entry LINE. */ | |
| 504 | |
| 505 static int | |
| 506 name_match (line, name) | |
| 507 char *line, *name; | |
| 508 { | |
| 509 char *tem; | |
| 510 | |
| 511 if (!compare_contin (line, name)) | |
| 512 return 1; | |
| 513 /* This line starts an entry. Is it the right one? */ | |
| 514 for (tem = line; *tem && *tem != '\n' && *tem != ':'; tem++) | |
| 515 if (*tem == '|' && !compare_contin (tem + 1, name)) | |
| 516 return 1; | |
| 517 | |
| 518 return 0; | |
| 519 } | |
| 520 | |
| 521 static int | |
| 522 compare_contin (str1, str2) | |
| 523 char *str1, *str2; | |
| 524 { | |
| 525 int c1, c2; | |
| 526 while (1) | |
| 527 { | |
| 528 c1 = *str1++; | |
| 529 c2 = *str2++; | |
| 530 while (c1 == '\\' && *str1 == '\n') | |
| 531 { | |
| 532 str1++; | |
| 533 while ((c1 = *str1++) == ' ' || c1 == '\t'); | |
| 534 } | |
| 535 if (c2 == '\0') | |
| 536 { | |
| 537 /* End of type being looked up. */ | |
| 538 if (c1 == '|' || c1 == ':') | |
| 539 /* If end of name in data base, we win. */ | |
| 540 return 0; | |
| 541 else | |
| 542 return 1; | |
| 543 } | |
| 544 else if (c1 != c2) | |
| 545 return 1; | |
| 546 } | |
| 547 } | |
| 548 | |
| 549 /* Make sure that the buffer <- BUFP contains a full line | |
| 550 of the file open on FD, starting at the place BUFP->ptr | |
| 551 points to. Can read more of the file, discard stuff before | |
| 552 BUFP->ptr, or make the buffer bigger. | |
| 553 | |
| 554 Returns the pointer to after the newline ending the line, | |
| 555 or to the end of the file, if there is no newline to end it. | |
| 556 | |
| 557 Can also merge on continuation lines. If APPEND_END is | |
| 558 nonzero, it points past the newline of a line that is | |
| 559 continued; we add another line onto it and regard the whole | |
| 560 thing as one line. The caller decides when a line is continued. */ | |
| 561 | |
| 562 static char * | |
| 563 gobble_line (fd, bufp, append_end) | |
| 564 int fd; | |
| 565 struct buffer *bufp; | |
| 566 char *append_end; | |
| 567 { | |
| 568 char *end; | |
| 569 int nread; | |
| 570 char *buf = bufp->beg; | |
| 571 char *tem; | |
| 572 | |
| 573 if (append_end == 0) | |
| 574 append_end = bufp->ptr; | |
| 575 | |
| 576 while (1) | |
| 577 { | |
| 578 end = append_end; | |
| 579 while (*end && *end != '\n') end++; | |
| 580 if (*end) | |
| 581 break; | |
| 582 if (bufp->ateof) | |
| 583 return buf + bufp->full; | |
| 584 if (bufp->ptr == buf) | |
| 585 { | |
| 586 if (bufp->full == bufp->size) | |
| 587 { | |
| 588 bufp->size *= 2; | |
| 589 /* Add 1 to size to ensure room for terminating null. */ | |
| 590 tem = (char *) xrealloc (buf, bufp->size + 1); | |
| 591 bufp->ptr = (bufp->ptr - buf) + tem; | |
| 592 append_end = (append_end - buf) + tem; | |
| 593 bufp->beg = buf = tem; | |
| 594 } | |
| 595 } | |
| 596 else | |
| 597 { | |
| 598 append_end -= bufp->ptr - buf; | |
| 599 memcpy (buf, bufp->ptr, bufp->full -= bufp->ptr - buf); | |
| 600 bufp->ptr = buf; | |
| 601 } | |
| 771 | 602 if (!(nread = retry_read (fd, buf + bufp->full, bufp->size - bufp->full))) |
| 428 | 603 bufp->ateof = 1; |
| 604 bufp->full += nread; | |
| 605 buf[bufp->full] = 0; | |
| 606 } | |
| 607 return end + 1; | |
| 608 } | |
| 609 | |
| 610 #ifdef TEST | |
| 611 | |
| 612 #include <stdio.h> | |
| 613 | |
| 614 main (argc, argv) | |
| 615 int argc; | |
| 616 char **argv; | |
| 617 { | |
| 618 char *term; | |
| 619 char *buf; | |
| 620 | |
| 621 term = argv[1]; | |
| 622 printf ("TERM: %s\n", term); | |
| 623 | |
| 624 buf = (char *) tgetent (0, term); | |
| 625 if ((int) buf <= 0) | |
| 626 { | |
| 627 printf ("No entry.\n"); | |
| 628 return 0; | |
| 629 } | |
| 630 | |
| 631 printf ("Entry: %s\n", buf); | |
| 632 | |
| 633 tprint ("cm"); | |
| 634 tprint ("AL"); | |
| 635 | |
| 636 printf ("co: %d\n", tgetnum ("co")); | |
| 637 printf ("am: %d\n", tgetflag ("am")); | |
| 638 } | |
| 639 | |
| 640 tprint (cap) | |
| 442 | 641 const char *cap; |
| 428 | 642 { |
| 643 char *x = tgetstr (cap, 0); | |
| 644 char *y; | |
| 645 | |
| 646 printf ("%s: ", cap); | |
| 647 if (x) | |
| 648 { | |
| 649 for (y = x; *y; y++) | |
| 650 if (*y <= ' ' || *y == 0177) | |
| 651 printf ("\\%0o", *y); | |
| 652 else | |
| 653 putchar (*y); | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
1726
diff
changeset
|
654 xfree (x); |
| 428 | 655 } |
| 656 else | |
| 657 printf ("none"); | |
| 658 putchar ('\n'); | |
| 659 } | |
| 660 | |
| 661 #endif /* TEST */ | |
| 662 |