src/main.C

   1 /*--------------------------------*-C-*---------------------------------*;
   2  * File:        main.c
   3  *----------------------------------------------------------------------*
   4  *
   5  * All portions of code are copyright by their respective author/s.
   6  * Copyright (c) 1992      John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>
   7  *                              - original version
   8  * Copyright (c) 1994      Robert Nation <nation@rocket.sanders.lockheed.com>
   9  *                              - extensive modifications
  10  * Copyright (c) 1995      Garrett D'Amore <garrett@netcom.com>
  11  * Copyright (c) 1997      mj olesen <olesen@me.QueensU.CA>
  12  *                              - extensive modifications
  13  * Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
  14  * Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
  15  *                              - extensive modifications
  16  * Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
  17  *
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 2 of the License, or
  21  * (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31  *---------------------------------------------------------------------*/
  32
  33 #include "../config.h"          /* NECESSARY */
  34 #include "rxvt.h"               /* NECESSARY */
  35 #include "main.intpro"          /* PROTOS for internal routines */
  36
  37 #include <signal.h>
  38
  39 #ifdef TTY_GID_SUPPORT
  40 # include <grp.h>
  41 #endif
  42
  43 #ifdef HAVE_TERMIOS_H
  44 # include <termios.h>
  45 #endif
  46
  47 #include <cstring>
  48
  49 static char curlocale[128];
  50
  51 void
  52 rxvt_set_locale (const char *locale)
  53 {
  54   if (locale && STRNCMP (locale, curlocale, 128))
  55     {
  56       STRNCPY (curlocale, locale, 128);
  57       setlocale (LC_CTYPE, curlocale);
  58     }
  59 }
  60
  61 void *
  62 rxvt_term::operator new (size_t s)
  63 {
  64   void *p = malloc (s);
  65
  66   MEMSET (p, 0, s);
  67   return p;
  68 }
  69
  70 void
  71 rxvt_term::operator delete (void *p, size_t s)
  72 {
  73   free (p);
  74 }
  75
  76 rxvt_term::rxvt_term ()
  77     :
  78     rootwin_ev (this, &rxvt_term::rootwin_cb),
  79     termwin_ev (this, &rxvt_term::x_cb),
  80     vt_ev (this, &rxvt_term::x_cb),
  81 #ifdef HAVE_SCROLLBARS
  82     scrollbar_ev (this, &rxvt_term::x_cb),
  83 #endif
  84 #ifdef MENUBAR
  85     menubar_ev (this, &rxvt_term::x_cb),
  86 #endif
  87 #ifdef CURSOR_BLINK
  88     cursor_blink_ev (this, &rxvt_term::cursor_blink_cb),
  89 #endif
  90 #ifdef TEXT_BLINK
  91     text_blink_ev (this, &rxvt_term::text_blink_cb),
  92 #endif
  93 #ifdef POINTER_BLANK
  94     pointer_ev (this, &rxvt_term::pointer_cb),
  95 #endif
  96 #ifdef USE_XIM
  97     im_ev (this, &rxvt_term::im_cb),
  98 #endif
  99     check_ev (this, &rxvt_term::check_cb),
 100     destroy_ev (this, &rxvt_term::destroy_cb),
 101     pty_ev (this, &rxvt_term::pty_cb),
 102     incr_ev (this, &rxvt_term::incr_cb)
 103 {
 104   cmdbuf_ptr = cmdbuf_endp = cmdbuf_base;
 105 }
 106
 107 rxvt_term::~rxvt_term ()
 108 {
 109   if (cmd_fd >= 0)
 110     close (cmd_fd);
 111
 112 #ifndef NO_SETOWNER_TTYDEV
 113   privileged_ttydev (RESTORE);
 114 #endif
 115 #ifdef UTMP_SUPPORT
 116   privileged_utmp (RESTORE);
 117 #endif
 118
 119   delete TermWin.fontset;
 120
 121   if (display)
 122     {
 123 #if defined(MENUBAR) && (MENUBAR_MAX > 1)
 124       delete menuBar.drawable;
 125       //if (menuBar.win)
 126       //  XDestroyWindow (display->display, menuBar.win);
 127 #endif
 128       delete TermWin.drawable;
 129       // destroy all windows
 130       if (TermWin.parent[0])
 131         XDestroyWindow (display->display, TermWin.parent[0]);
 132     }
 133
 134   // TODO: free pixcolours, colours should become part of rxvt_display
 135
 136   delete PixColors;
 137
 138   displays.put (display);
 139
 140   scr_release ();
 141
 142   free (env_windowid);
 143   free (env_display);
 144   free (env_term);
 145   free (env_colorfgbg);
 146   free (locale);
 147   free (codeset);
 148
 149   delete envv;
 150   delete argv;
 151 }
 152
 153 void
 154 rxvt_term::destroy ()
 155 {
 156   if (display)
 157     {
 158       rootwin_ev.stop (display);
 159       termwin_ev.stop (display);
 160       vt_ev.stop (display);
 161 #ifdef USE_XIM
 162       im_destroy ();
 163       im_ev.stop (display);
 164 #endif
 165 #ifdef HAVE_SCROLLBARS
 166       scrollbar_ev.stop (display);
 167 #endif
 168 #ifdef MENUBAR
 169       menubar_ev.stop (display);
 170 #endif
 171     }
 172
 173   check_ev.stop ();
 174   pty_ev.stop ();
 175 #ifdef CURSOR_BLINK
 176   cursor_blink_ev.stop ();
 177 #endif
 178 #ifdef TEXT_BLINK
 179   text_blink_ev.stop ();
 180 #endif
 181 #ifdef POINTER_BLANK
 182   pointer_ev.stop ();
 183 #endif
 184
 185   destroy_ev.start (0);
 186 }
 187
 188 void
 189 rxvt_term::destroy_cb (time_watcher &w)
 190 {
 191   SET_R (this);
 192
 193   delete this;
 194 }
 195
 196 /*----------------------------------------------------------------------*/
 197 /* rxvt_init () */
 198 /* LIBPROTO */
 199 rxvt_t
 200 rxvt_init (int argc, const char *const *argv)
 201 {
 202   SET_R (new rxvt_term);
 203
 204   if (!GET_R->init_vars () || !GET_R->init (argc, argv))
 205     {
 206       delete GET_R;
 207       SET_R (0);
 208     }
 209
 210   return GET_R;
 211 }
 212
 213 static int (*old_xerror_handler) (Display *dpy, XErrorEvent *event);
 214
 215 void
 216 rxvt_init_signals ()
 217 {
 218   /* install exit handler for cleanup */
 219 #if 0
 220 #ifdef HAVE_ATEXIT
 221   atexit (rxvt_clean_exit);
 222 #else
 223 #endif
 224 #endif
 225
 226   struct sigaction sa;
 227
 228   sigfillset (&sa.sa_mask);
 229   sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
 230   sa.sa_handler = SIG_IGN;           sigaction (SIGHUP , &sa, 0);
 231   sa.sa_handler = SIG_IGN;           sigaction (SIGPIPE, &sa, 0);
 232   sa.sa_handler = rxvt_Exit_signal;  sigaction (SIGINT , &sa, 0);
 233   sa.sa_handler = rxvt_Exit_signal;  sigaction (SIGQUIT, &sa, 0);
 234   sa.sa_handler = rxvt_Exit_signal;  sigaction (SIGTERM, &sa, 0);
 235   sa.sa_handler = rxvt_Child_signal; sigaction (SIGCHLD, &sa, 0);
 236
 237   /* need to trap SIGURG for SVR4 (Unixware) rlogin */
 238   /* signal (SIGURG, SIG_DFL); */
 239
 240   old_xerror_handler = XSetErrorHandler ((XErrorHandler) rxvt_xerror_handler);
 241   //XSetIOErrorHandler ((XErrorHandler) rxvt_xioerror_handler);
 242 }
 243
 244 bool
 245 rxvt_term::init (int argc, const char *const *argv)
 246 {
 247   /*
 248    * Save and then give up any super-user privileges
 249    * If we need privileges in any area then we must specifically request it.
 250    * We should only need to be root in these cases:
 251    *  1.  write utmp entries on some systems
 252    *  2.  chown tty on some systems
 253    */
 254   privileges (SAVE);
 255   privileges (IGNORE);
 256
 257   init_secondary ();
 258
 259   const char **cmd_argv = init_resources (argc, argv);
 260
 261   set_locale ("");
 262
 263 #if MENUBAR_MAX
 264   menubar_read (rs[Rs_menu]);
 265 #endif
 266 #ifdef HAVE_SCROLLBARS
 267   if (Options & Opt_scrollBar)
 268     scrollBar.setIdle ();    /* set existence for size calculations */
 269 #endif
 270
 271   create_windows (argc, argv);
 272
 273   init_xlocale ();
 274
 275   scr_reset ();         /* initialize screen */
 276
 277 #if 0
 278   XSynchronize (display->display, True);
 279 #endif
 280
 281 #ifdef HAVE_SCROLLBARS
 282   if (Options & Opt_scrollBar)
 283     resize_scrollbar ();      /* create and map scrollbar */
 284 #endif
 285 #if (MENUBAR_MAX)
 286   if (menubar_visible ())
 287     XMapWindow (display->display, menuBar.win);
 288 #endif
 289 #ifdef TRANSPARENT
 290   if (Options & Opt_transparent)
 291     {
 292       XSelectInput (display->display, display->root, PropertyChangeMask);
 293       check_our_parents ();
 294     }
 295 #endif
 296
 297   rootwin_ev.start (display, display->root);
 298
 299   XMapWindow (display->display, TermWin.vt);
 300   XMapWindow (display->display, TermWin.parent[0]);
 301
 302   init_command (cmd_argv);
 303
 304   pty_ev.start (cmd_fd, EVENT_READ);
 305
 306   check_ev.start ();
 307
 308   return true;
 309 }
 310
 311 /* ------------------------------------------------------------------------- *
 312  *                       SIGNAL HANDLING & EXIT HANDLER                      *
 313  * ------------------------------------------------------------------------- */
 314 /*
 315  * Catch a SIGCHLD signal and exit if the direct child has died
 316  */
 317 /* ARGSUSED */
 318 /* EXTPROTO */
 319 RETSIGTYPE
 320 rxvt_Child_signal (int sig __attribute__ ((unused)))
 321 {
 322   int pid, save_errno = errno;
 323   while ((pid = waitpid (-1, NULL, WNOHANG)) == -1 && errno == EINTR)
 324     ;
 325   errno = save_errno;
 326
 327 #if 0
 328   if (pid == cmd_pid)
 329     exit (EXIT_SUCCESS);
 330 #endif
 331 }
 332
 333 /*
 334  * Catch a fatal signal and tidy up before quitting
 335  */
 336 /* EXTPROTO */
 337 RETSIGTYPE
 338 rxvt_Exit_signal (int sig)
 339 {
 340   signal (sig, SIG_DFL);
 341 #ifdef DEBUG_CMD
 342   rxvt_print_error ("signal %d", sig);
 343 #endif
 344   rxvt_clean_exit ();
 345   kill (getpid (), sig);
 346 }
 347
 348 /* INTPROTO */
 349 int
 350 rxvt_xerror_handler (Display *display, XErrorEvent *event)
 351 {
 352   if (GET_R->allowedxerror == -1)
 353     GET_R->allowedxerror = event->error_code;
 354   else
 355     {
 356       old_xerror_handler (display, event);
 357       GET_R->destroy ();
 358     }
 359
 360   return 0;
 361 }
 362
 363 /*----------------------------------------------------------------------*/
 364 /*
 365  * Exit gracefully, clearing the utmp entry and restoring tty attributes
 366  * TODO: if debugging, this should free up any known resources if we can
 367  */
 368 /* EXTPROTO */
 369 void
 370 rxvt_clean_exit ()
 371 {
 372   // TODO: rxvtd should clean up all ressources
 373   if (GET_R)
 374     GET_R->destroy ();
 375 }
 376
 377 /* ------------------------------------------------------------------------- *
 378  *                         MEMORY ALLOCATION WRAPPERS                        *
 379  * ------------------------------------------------------------------------- */
 380 /* EXTPROTO */
 381 void           *
 382 rxvt_malloc (size_t size)
 383 {
 384   void           *p;
 385
 386   p = malloc (size);
 387   if (p)
 388     return p;
 389
 390   fprintf (stderr, APL_NAME ": memory allocation failure.  Aborting");
 391   rxvt_clean_exit ();
 392   exit (EXIT_FAILURE);
 393   /* NOTREACHED */
 394 }
 395
 396 /* EXTPROTO */
 397 void           *
 398 rxvt_calloc (size_t number, size_t size)
 399 {
 400   void           *p;
 401
 402   p = calloc (number, size);
 403   if (p)
 404     return p;
 405
 406   fprintf (stderr, APL_NAME ": memory allocation failure.  Aborting");
 407   rxvt_clean_exit ();
 408   exit (EXIT_FAILURE);
 409   /* NOTREACHED */
 410 }
 411
 412 /* EXTPROTO */
 413 void           *
 414 rxvt_realloc (void *ptr, size_t size)
 415 {
 416   void           *p;
 417
 418   if (ptr)
 419     p = realloc (ptr, size);
 420   else
 421     p = malloc (size);
 422   if (p)
 423     return p;
 424
 425   fprintf (stderr, APL_NAME ": memory allocation failure.  Aborting");
 426   rxvt_clean_exit ();
 427   exit (EXIT_FAILURE);
 428   /* NOTREACHED */
 429 }
 430
 431 /* ------------------------------------------------------------------------- *
 432  *                            PRIVILEGED OPERATIONS                          *
 433  * ------------------------------------------------------------------------- */
 434 /* take care of suid/sgid super-user (root) privileges */
 435 void
 436 rxvt_term::privileges (int mode)
 437 {
 438 #if ! defined(__CYGWIN32__)
 439 # if !defined(HAVE_SETEUID) && defined(HAVE_SETREUID)
 440   /* setreuid () is the poor man's setuid (), seteuid () */
 441 #  define seteuid(a)    setreuid(-1, (a))
 442 #  define setegid(a)    setregid(-1, (a))
 443 #  define HAVE_SETEUID
 444 # endif
 445 # ifdef HAVE_SETEUID
 446   switch (mode)
 447     {
 448       case IGNORE:
 449         /*
 450          * change effective uid/gid - not real uid/gid - so we can switch
 451          * back to root later, as required
 452          */
 453         seteuid (getuid ());
 454         setegid (getgid ());
 455         break;
 456       case SAVE:
 457         euid = geteuid ();
 458         egid = getegid ();
 459         break;
 460       case RESTORE:
 461         seteuid (euid);
 462         setegid (egid);
 463         break;
 464     }
 465 # else
 466   switch (mode)
 467     {
 468       case IGNORE:
 469         setuid (getuid ());
 470         setgid (getgid ());
 471         /* FALLTHROUGH */
 472       case SAVE:
 473         /* FALLTHROUGH */
 474       case RESTORE:
 475         break;
 476     }
 477 # endif
 478 #endif
 479 }
 480
 481 #ifdef UTMP_SUPPORT
 482 void
 483 rxvt_term::privileged_utmp (char action)
 484 {
 485   D_MAIN ((stderr, "rxvt_privileged_utmp (%c); waiting for: %c (pid: %d)",
 486           action, next_utmp_action, getpid ()));
 487   if (next_utmp_action != action || (action != SAVE && action != RESTORE)
 488       || (Options & Opt_utmpInhibit)
 489       || ttydev == NULL || *ttydev == '\0')
 490     return;
 491
 492   privileges (RESTORE);
 493   if (action == SAVE)
 494     {
 495       next_utmp_action = RESTORE;
 496       makeutent (ttydev, rs[Rs_display_name]);
 497     }
 498   else
 499     {                    /* action == RESTORE */
 500       next_utmp_action = IGNORE;
 501       cleanutent ();
 502     }
 503   privileges (IGNORE);
 504 }
 505 #endif
 506
 507 #ifndef NO_SETOWNER_TTYDEV
 508 void
 509 rxvt_term::privileged_ttydev (char action)
 510 {
 511   D_MAIN ((stderr,
 512           "privileged_ttydev (%c); waiting for: %c (pid: %d)",
 513           action, next_tty_action, getpid ()));
 514   if (next_tty_action != action || (action != SAVE && action != RESTORE)
 515       || ttydev == NULL || *ttydev == '\0')
 516     return;
 517
 518   privileges (RESTORE);
 519
 520   if (action == SAVE)
 521     {
 522       next_tty_action = RESTORE;
 523 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 524       /* store original tty status for restoration rxvt_clean_exit () -- rgg 04/12/95 */
 525       if (lstat (ttydev, &ttyfd_stat) < 0)       /* you lose out */
 526         next_tty_action = IGNORE;
 527       else
 528 # endif
 529
 530         {
 531           chown (ttydev, getuid (), ttygid);      /* fail silently */
 532           chmod (ttydev, ttymode);
 533 # ifdef HAVE_REVOKE
 534           revoke (ttydev);
 535 # endif
 536
 537         }
 538     }
 539   else
 540     {                    /* action == RESTORE */
 541       next_tty_action = IGNORE;
 542 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 543       chmod (ttydev, ttyfd_stat.st_mode);
 544       chown (ttydev, ttyfd_stat.st_uid, ttyfd_stat.st_gid);
 545 # else
 546       chmod (ttydev,
 547             (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH));
 548       chown (ttydev, 0, 0);
 549 # endif
 550
 551     }
 552
 553   privileges (IGNORE);
 554
 555 # ifndef RESET_TTY_TO_COMMON_DEFAULTS
 556   D_MAIN ((stderr, "%s \"%s\": mode %03o, uid %d, gid %d",
 557           action == RESTORE ? "Restoring" : (action ==
 558                                              SAVE ? "Saving" :
 559                                              "UNKNOWN ERROR for"), ttydev,
 560           ttyfd_stat.st_mode, ttyfd_stat.st_uid,
 561           ttyfd_stat.st_gid));
 562 # endif
 563 }
 564 #endif
 565
 566 /*----------------------------------------------------------------------*/
 567 /*
 568  * window size/position calculcations for XSizeHint and other storage.
 569  * if width/height are non-zero then override calculated width/height
 570  */
 571 void
 572 rxvt_term::window_calc (unsigned int width, unsigned int height)
 573 {
 574   short           recalc_x, recalc_y;
 575   int             x, y, sb_w, mb_h, flags;
 576   unsigned int    w, h;
 577   unsigned int    max_width, max_height;
 578
 579   D_SIZE ((stderr, "< Cols/Rows: %3d x %3d ; Width/Height: %4d x %4d",
 580           TermWin.ncol, TermWin.nrow, szHint.width,
 581           szHint.height));
 582   szHint.flags = PMinSize | PResizeInc | PBaseSize | PWinGravity;
 583   szHint.win_gravity = NorthWestGravity;
 584   /* szHint.min_aspect.x = szHint.min_aspect.y = 1; */
 585
 586   recalc_x = recalc_y = 0;
 587   flags = 0;
 588   if (!parsed_geometry)
 589     {
 590       parsed_geometry = 1;
 591       if (rs[Rs_geometry])
 592         flags = XParseGeometry (rs[Rs_geometry], &x, &y, &w, &h);
 593       if (flags & WidthValue)
 594         {
 595           TermWin.ncol = BOUND_POSITIVE_INT16 (w);
 596           szHint.flags |= USSize;
 597         }
 598       if (flags & HeightValue)
 599         {
 600           TermWin.nrow = BOUND_POSITIVE_INT16 (h);
 601           szHint.flags |= USSize;
 602         }
 603       if (flags & XValue)
 604         {
 605           szHint.x = x;
 606           szHint.flags |= USPosition;
 607           if (flags & XNegative)
 608             {
 609               recalc_x = 1;
 610               szHint.win_gravity = NorthEastGravity;
 611             }
 612         }
 613       if (flags & YValue)
 614         {
 615           szHint.y = y;
 616           szHint.flags |= USPosition;
 617           if (flags & YNegative)
 618             {
 619               recalc_y = 1;
 620               if (szHint.win_gravity == NorthEastGravity)
 621                 szHint.win_gravity = SouthEastGravity;
 622               else
 623                 szHint.win_gravity = SouthWestGravity;
 624             }
 625         }
 626     }
 627   /* TODO: BOUNDS */
 628   TermWin.width = TermWin.ncol * TermWin.fwidth;
 629   TermWin.height = TermWin.nrow * TermWin.fheight;
 630   max_width = MAX_COLS * TermWin.fwidth;
 631   max_height = MAX_ROWS * TermWin.fheight;
 632
 633   szHint.base_width = szHint.base_height = 2 * TermWin.int_bwidth;
 634
 635   sb_w = mb_h = 0;
 636   window_vt_x = window_vt_y = 0;
 637   if (scrollbar_visible ())
 638     {
 639       sb_w = scrollbar_TotalWidth ();
 640       szHint.base_width += sb_w;
 641       if (! (Options & Opt_scrollBar_right))
 642         window_vt_x = sb_w;
 643     }
 644   if (menubar_visible ())
 645     {
 646       mb_h = menuBar_TotalHeight ();
 647       szHint.base_height += mb_h;
 648       window_vt_y = mb_h;
 649     }
 650   szHint.width_inc = TermWin.fwidth;
 651   szHint.height_inc = TermWin.fheight;
 652   szHint.min_width = szHint.base_width + szHint.width_inc;
 653   szHint.min_height = szHint.base_height + szHint.height_inc;
 654
 655   if (width && width - szHint.base_width < max_width)
 656     {
 657       szHint.width = width;
 658       TermWin.width = width - szHint.base_width;
 659     }
 660   else
 661     {
 662       MIN_IT (TermWin.width, max_width);
 663       szHint.width = szHint.base_width + TermWin.width;
 664     }
 665   if (height && height - szHint.base_height < max_height)
 666     {
 667       szHint.height = height;
 668       TermWin.height = height - szHint.base_height;
 669     }
 670   else
 671     {
 672       MIN_IT (TermWin.height, max_height);
 673       szHint.height = szHint.base_height + TermWin.height;
 674     }
 675   if (scrollbar_visible () && (Options & Opt_scrollBar_right))
 676     window_sb_x = szHint.width - sb_w;
 677
 678   if (recalc_x)
 679     szHint.x += (DisplayWidth (display->display, DefaultScreen (display->display))
 680                  - szHint.width - 2 * TermWin.ext_bwidth);
 681   if (recalc_y)
 682     szHint.y += (DisplayHeight (display->display, DefaultScreen (display->display))
 683                  - szHint.height - 2 * TermWin.ext_bwidth);
 684
 685   TermWin.ncol = TermWin.width / TermWin.fwidth;
 686   TermWin.nrow = TermWin.height / TermWin.fheight;
 687   D_SIZE ((stderr, "> Cols/Rows: %3d x %3d ; Width/Height: %4d x %4d",
 688           TermWin.ncol, TermWin.nrow, szHint.width,
 689           szHint.height));
 690   return;
 691 }
 692
 693 /*----------------------------------------------------------------------*/
 694 /*
 695  * Tell the teletype handler what size the window is.
 696  * Called after a window size change.
 697  */
 698 void
 699 rxvt_term::tt_winch ()
 700 {
 701   struct winsize ws;
 702
 703   if (cmd_fd < 0)
 704     return;
 705
 706   ws.ws_col = TermWin.ncol;
 707   ws.ws_row = TermWin.nrow;
 708   ws.ws_xpixel = ws.ws_ypixel = 0;
 709 #ifndef DEBUG_SIZE
 710   (void)ioctl (cmd_fd, TIOCSWINSZ, &ws);
 711 #else
 712   if (ioctl (cmd_fd, TIOCSWINSZ, &ws) < 0)
 713     D_SIZE ((stderr, "Failed to send TIOCSWINSZ to fd %d", fd));
 714 # ifdef SIGWINCH
 715   else if (cmd_pid)               /* force through to the command */
 716     kill (cmd_pid, SIGWINCH);
 717 # endif
 718 #endif
 719 }
 720
 721 /*----------------------------------------------------------------------*/
 722 /* rxvt_change_font () - Switch to a new font */
 723 /*
 724  * init = 1   - initialize
 725  *
 726  * fontname == FONT_UP  - switch to bigger font
 727  * fontname == FONT_DN  - switch to smaller font
 728  */
 729 bool
 730 rxvt_term::change_font (const char *fontname)
 731 {
 732   if (fontname == FONT_UP)
 733     {
 734       // TODO
 735     }
 736   else if (fontname == FONT_DN)
 737     {
 738       // TODO
 739     }
 740   else
 741     {
 742       rxvt_fontset *fs = new rxvt_fontset (this);
 743
 744       if (fs && fs->populate (fontname ? fontname : "fixed"))
 745         {
 746           delete TermWin.fontset;
 747           TermWin.fontset = fs;
 748           TermWin.fwidth  = fs->base_font ()->width;
 749           TermWin.fheight = fs->base_font ()->height;
 750           TermWin.fbase   = fs->base_font ()->ascent;
 751
 752           if (TermWin.parent[0])
 753             {
 754               resize_all_windows (0, 0, 0);
 755               scr_remap_chars ();
 756               scr_touch (true);
 757             }
 758
 759           return true;
 760         }
 761     }
 762
 763   return false;
 764 }
 765
 766 bool
 767 rxvt_term::font_up_down (int n, int direction)
 768 {
 769   return false;
 770 }
 771
 772 /*----------------------------------------------------------------------*/
 773 /*----------------------------------------------------------------------*/
 774 /* xterm sequences - title, iconName, color (exptl) */
 775 void
 776 rxvt_term::set_title (const char *str)
 777 {
 778 #ifndef SMART_WINDOW_TITLE
 779   XStoreName (display->display, TermWin.parent[0], str);
 780 #else
 781   char *name;
 782
 783   if (XFetchName (display->display, TermWin.parent[0], &name) == 0)
 784     name = NULL;
 785   if (name == NULL || STRCMP (name, str))
 786     XStoreName (display->display, TermWin.parent[0], str);
 787   if (name)
 788     XFree (name);
 789 #endif
 790 }
 791
 792 void
 793 rxvt_term::set_iconName (const char *str)
 794 {
 795 #ifndef SMART_WINDOW_TITLE
 796   XSetIconName (display->display, TermWin.parent[0], str);
 797 #else
 798   char *name;
 799
 800   if (XGetIconName (display->display, TermWin.parent[0], &name))
 801     name = NULL;
 802   if (name == NULL || STRCMP (name, str))
 803     XSetIconName (display->display, TermWin.parent[0], str);
 804   if (name)
 805     XFree (name);
 806 #endif
 807 }
 808
 809 #ifdef XTERM_COLOR_CHANGE
 810 void
 811 rxvt_term::set_window_color (int idx, const char *color)
 812 {
 813   rxvt_color xcol;
 814   int i;
 815
 816   if (color == NULL || *color == '\0')
 817     return;
 818
 819   /* handle color aliases */
 820   if (isdigit (*color))
 821     {
 822       i = atoi (color);
 823       if (i >= 8 && i <= 15)
 824         {        /* bright colors */
 825           i -= 8;
 826 # ifndef NO_BRIGHTCOLOR
 827           PixColors[idx] = PixColors[minBrightCOLOR + i];
 828           SET_PIXCOLOR (idx);
 829           goto Done;
 830 # endif
 831
 832         }
 833       if (i >= 0 && i <= 7)
 834         { /* normal colors */
 835           PixColors[idx] = PixColors[minCOLOR + i];
 836           SET_PIXCOLOR (idx);
 837           goto Done;
 838         }
 839     }
 840   if (!rXParseAllocColor (& xcol, color))
 841     return;
 842   /* XStoreColor (display->display, XCMAP, XColor*); */
 843
 844   /*
 845    * FIXME: should free colors here, but no idea how to do it so instead,
 846    * so just keep gobbling up the colormap
 847    */
 848 # if 0
 849   for (i = Color_Black; i <= Color_White; i++)
 850     if (PixColors[idx] == PixColors[i])
 851       break;
 852   if (i > Color_White)
 853     {
 854       /* fprintf (stderr, "XFreeColors: PixColors [%d] = %lu\n", idx, PixColors [idx]); */
 855       XFreeColors (display->display, XCMAP, (PixColors + idx), 1,
 856                   DisplayPlanes (display->display, display->screen));
 857     }
 858 # endif
 859
 860   PixColors[idx] = xcol;
 861   SET_PIXCOLOR (idx);
 862
 863   /* XSetWindowAttributes attr; */
 864   /* Cursor cursor; */
 865 Done:
 866   if (idx == Color_bg && ! (Options & Opt_transparent))
 867     XSetWindowBackground (display->display, TermWin.vt,
 868                          PixColors[Color_bg]);
 869
 870   /* handle Color_BD, scrollbar background, etc. */
 871
 872   set_colorfgbg ();
 873   recolour_cursor ();
 874   /* the only reasonable way to enforce a clean update */
 875   scr_poweron ();
 876 }
 877
 878 #else
 879 # define set_window_color (idx,color)   ((void)0)
 880 #endif                          /* XTERM_COLOR_CHANGE */
 881
 882 void
 883 rxvt_term::recolour_cursor ()
 884 {
 885 #if TODO
 886   rxvt_color xcol[2];
 887
 888   xcol[0] = PixColors[Color_pointer];
 889   xcol[1] = PixColors[Color_bg];
 890   XQueryColors (display->display, XCMAP, xcol, 2);
 891   XRecolorCursor (display->display, TermWin_cursor, & (xcol[0]), & (xcol[1]));
 892 #endif
 893 }
 894
 895 /*----------------------------------------------------------------------*/
 896 /*
 897  * find if fg/bg matches any of the normal (low-intensity) colors
 898  */
 899 void
 900 rxvt_term::set_colorfgbg ()
 901 {
 902   unsigned int    i;
 903   const char     *xpmb = "\0";
 904   char            fstr[sizeof ("default") + 1], bstr[sizeof ("default") + 1];
 905
 906   env_colorfgbg =
 907     (char *)rxvt_malloc (sizeof ("COLORFGBG=default;default;bg") + 1);
 908   STRCPY (fstr, "default");
 909   STRCPY (bstr, "default");
 910   for (i = Color_Black; i <= Color_White; i++)
 911     if (PixColors[Color_fg] == PixColors[i])
 912       {
 913         sprintf (fstr, "%d", (i - Color_Black));
 914         break;
 915       }
 916   for (i = Color_Black; i <= Color_White; i++)
 917     if (PixColors[Color_bg] == PixColors[i])
 918       {
 919         sprintf (bstr, "%d", (i - Color_Black));
 920 #ifdef XPM_BACKGROUND
 921         xpmb = "default;";
 922 #endif
 923         break;
 924       }
 925
 926   sprintf (env_colorfgbg, "COLORFGBG=%s;%s%s", fstr, xpmb, bstr);
 927
 928 #ifndef NO_BRIGHTCOLOR
 929   colorfgbg = DEFAULT_RSTYLE;
 930   for (i = minCOLOR; i <= maxCOLOR; i++)
 931     {
 932       if (PixColors[Color_fg] == PixColors[i])
 933         colorfgbg = SET_FGCOLOR (colorfgbg, i);
 934       if (PixColors[Color_bg] == PixColors[i])
 935         colorfgbg = SET_BGCOLOR (colorfgbg, i);
 936     }
 937 #endif
 938 }
 939
 940 /*----------------------------------------------------------------------*/
 941 /*
 942  * Colour determination for low colour displays, routine from
 943  *     Hans de Goede <hans@highrise.nl>
 944  */
 945
 946 int
 947 rxvt_term::rXParseAllocColor (rxvt_color *screen_in_out, const char *colour)
 948 {
 949   if (!screen_in_out->set (display, colour))
 950     {
 951       rxvt_print_error ("can't allocate colour: %s", colour);
 952       return false;
 953     }
 954
 955   return true;
 956 }
 957
 958 /* -------------------------------------------------------------------- *
 959  * -                         WINDOW RESIZING                          - *
 960  * -------------------------------------------------------------------- */
 961 void
 962 rxvt_term::resize_all_windows (unsigned int width, unsigned int height, int ignoreparent)
 963 {
 964   int fix_screen;
 965
 966 #ifdef SMART_RESIZE
 967   int old_width = szHint.width, old_height = szHint.height;
 968 #endif
 969
 970   window_calc (width, height);
 971   XSetWMNormalHints (display->display, TermWin.parent[0], &szHint);
 972   if (!ignoreparent)
 973     {
 974 #ifdef SMART_RESIZE
 975       /*
 976        * resize by Marius Gedminas <marius.gedminas@uosis.mif.vu.lt>
 977        * reposition window on resize depending on placement on screen
 978        */
 979       int x, y, x1, y1;
 980       int dx, dy;
 981       unsigned int unused_w1, unused_h1, unused_b1, unused_d1;
 982       Window unused_cr;
 983
 984       XTranslateCoordinates (display->display, TermWin.parent[0], display->root,
 985                              0, 0, &x, &y, &unused_cr);
 986       XGetGeometry (display->display, TermWin.parent[0], &unused_cr, &x1, &y1,
 987                     &unused_w1, &unused_h1, &unused_b1, &unused_d1);
 988       /*
 989        * if display->root isn't the parent window, a WM will probably have offset
 990        * our position for handles and decorations.  Counter it
 991        */
 992       if (x1 != x || y1 != y)
 993         {
 994           x -= x1;
 995           y -= y1;
 996         }
 997
 998       x1 = (DisplayWidth (display->display, display->screen) - old_width) / 2;
 999       y1 = (DisplayHeight (display->display, display->screen) - old_height) / 2;
1000       dx = old_width - szHint.width;
1001       dy = old_height - szHint.height;
1002
1003       /* Check position of the center of the window */
1004       if (x < x1)             /* left half */
1005         dx = 0;
1006       else if (x == x1)       /* exact center */
1007         dx /= 2;
1008       if (y < y1)             /* top half */
1009         dy = 0;
1010       else if (y == y1)       /* exact center */
1011         dy /= 2;
1012
1013       XMoveResizeWindow (display->display, TermWin.parent[0], x + dx, y + dy,
1014                          szHint.width, szHint.height);
1015 #else
1016       XResizeWindow (display->display, TermWin.parent[0], szHint.width,
1017                      szHint.height);
1018 #endif
1019
1020     }
1021
1022   fix_screen = (TermWin.ncol != prev_ncol
1023                 || TermWin.nrow != prev_nrow);
1024
1025   if (fix_screen || width != old_width || height != old_height)
1026     {
1027       if (scrollbar_visible ())
1028         {
1029           XMoveResizeWindow (display->display, scrollBar.win, window_sb_x,
1030                              0, scrollbar_TotalWidth (), szHint.height);
1031           resize_scrollbar ();
1032         }
1033
1034       if (menubar_visible ())
1035         XMoveResizeWindow (display->display, menuBar.win, window_vt_x,
1036                            0, TermWin_TotalWidth (), menuBar_TotalHeight ());
1037
1038       XMoveResizeWindow (display->display, TermWin.vt, window_vt_x,
1039                          window_vt_y, TermWin_TotalWidth (),
1040                          TermWin_TotalHeight ());
1041       scr_clear ();
1042 #ifdef XPM_BACKGROUND
1043       resize_pixmap ();
1044 #endif
1045
1046     }
1047
1048   if (fix_screen || old_height == 0)
1049     {
1050       int curr_screen = -1;
1051       int old_ncol = prev_ncol;
1052
1053       /* scr_reset only works on the primary screen */
1054       if (old_height)      /* this is not the first time through */
1055         {
1056           unsigned int ncol = TermWin.ncol;
1057           TermWin.ncol = prev_ncol; // save b/c scr_blank_screen_mem uses this
1058           curr_screen = scr_change_screen (PRIMARY);
1059           TermWin.ncol = ncol;
1060         }
1061
1062       scr_reset ();
1063
1064       if (curr_screen >= 0) /* this is not the first time through */
1065         {
1066           scr_change_screen (curr_screen);
1067           selection_check (old_ncol != TermWin.ncol ? 4 : 0);
1068         }
1069     }
1070
1071   old_width = szHint.width;
1072   old_height = szHint.height;
1073
1074 #ifdef USE_XIM
1075   IMSetStatusPosition ();
1076 #endif
1077 }
1078
1079 /*
1080  * Set the width/height of the vt window in characters.  Units are pixels.
1081  * good for toggling 80/132 columns
1082  */
1083 void
1084 rxvt_term::set_widthheight (unsigned int width, unsigned int height)
1085 {
1086   XWindowAttributes wattr;
1087
1088   if (width == 0 || height == 0)
1089     {
1090       XGetWindowAttributes (display->display, display->root, &wattr);
1091       if (width == 0)
1092         width = wattr.width - szHint.base_width;
1093       if (height == 0)
1094         height = wattr.height - szHint.base_height;
1095     }
1096   if (width != TermWin.width || height != TermWin.height)
1097     {
1098       width += szHint.base_width;
1099       height += szHint.base_height;
1100       resize_all_windows (width, height, 0);
1101     }
1102 }
1103
1104 /* -------------------------------------------------------------------- *
1105  * -                      X INPUT METHOD ROUTINES                     - *
1106  * -------------------------------------------------------------------- */
1107 #ifdef USE_XIM
1108
1109 void
1110 rxvt_term::im_set_size (XRectangle *size)
1111 {
1112   size->x = TermWin.int_bwidth;
1113   size->y = TermWin.int_bwidth;
1114   size->width = Width2Pixel (TermWin.ncol);
1115   size->height = Height2Pixel (TermWin.nrow);
1116 }
1117
1118 void
1119 rxvt_term::im_set_color (unsigned long *fg, unsigned long *bg)
1120 {
1121   *fg = PixColors[Color_fg];
1122   *bg = PixColors[Color_bg];
1123 }
1124
1125 /* Checking whether input method is running. */
1126 bool
1127 rxvt_term::IMisRunning ()
1128 {
1129   char           *p;
1130   Atom            atom;
1131   Window          win;
1132   char            server[IMBUFSIZ];
1133
1134   /* get current locale modifier */
1135   if ((p = XSetLocaleModifiers (NULL)) != NULL)
1136     {
1137       STRCPY (server, "@server=");
1138       STRNCAT (server, & (p[4]), IMBUFSIZ - 9); /* skip "@im=" */
1139       if ((p = STRCHR (server + 1, '@')) != NULL)      /* first one only */
1140         *p = '\0';
1141
1142       atom = XInternAtom (display->display, server, False);
1143       win = XGetSelectionOwner (display->display, atom);
1144       if (win != None)
1145         return True;
1146     }
1147   return False;
1148 }
1149
1150 void
1151 rxvt_term::IMSendSpot ()
1152 {
1153   XPoint          spot;
1154   XVaNestedList   preedit_attr;
1155
1156   if (Input_Context == NULL
1157       || !TermWin.focus || ! (input_style & XIMPreeditPosition)
1158       || ! (event_type == KeyPress
1159            || event_type == Expose
1160            || event_type == NoExpose
1161            || event_type == SelectionNotify
1162            || event_type == ButtonRelease || event_type == FocusIn)
1163       || !IMisRunning ())
1164     return;
1165
1166   im_set_position (&spot);
1167
1168   preedit_attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
1169   XSetICValues (Input_Context, XNPreeditAttributes, preedit_attr, NULL);
1170   XFree (preedit_attr);
1171 }
1172
1173 void
1174 rxvt_term::im_set_preedit_area (XRectangle * preedit_rect, XRectangle * status_rect,
1175                                 XRectangle * needed_rect)
1176 {
1177   int mbh, vtx = 0;
1178
1179   if (scrollbar_visible () && ! (Options & Opt_scrollBar_right))
1180     vtx = scrollbar_TotalWidth ();
1181
1182   mbh = menubar_visible () ? menuBar_TotalHeight () : 0;
1183   mbh -= TermWin.lineSpace;
1184
1185   preedit_rect->x = needed_rect->width + vtx;
1186   preedit_rect->y = Height2Pixel (TermWin.nrow - 1) + mbh;
1187
1188   preedit_rect->width = Width2Pixel (TermWin.ncol + 1) - needed_rect->width + vtx;
1189   preedit_rect->height = Height2Pixel (1);
1190
1191   status_rect->x = vtx;
1192   status_rect->y = Height2Pixel (TermWin.nrow - 1) + mbh;
1193
1194   status_rect->width = needed_rect->width ? needed_rect->width : Width2Pixel (TermWin.ncol + 1);
1195   status_rect->height = Height2Pixel (1);
1196 }
1197
1198 void
1199 rxvt_term::im_destroy ()
1200 {
1201   if (Input_Context)
1202     {
1203       XDestroyIC (Input_Context);
1204       Input_Context = NULL;
1205     }
1206
1207   if (input_method)
1208     {
1209       display->put_xim (input_method);
1210       input_method = 0;
1211     }
1212 }
1213
1214 /*
1215  * Try to open a XIM with the current modifiers, then see if we can
1216  * open a suitable preedit type
1217  */
1218 bool
1219 rxvt_term::IM_get_IC (const char *modifiers)
1220 {
1221   int             i, j, found;
1222   XIM             xim;
1223   XPoint          spot;
1224   XRectangle      rect, status_rect, needed_rect;
1225   unsigned long   fg, bg;
1226   const char     *p;
1227   char          **s;
1228   XIMStyles      *xim_styles;
1229   XVaNestedList   preedit_attr, status_attr;
1230
1231   if (! ((p = XSetLocaleModifiers (modifiers)) && *p))
1232     return false;
1233
1234   D_MAIN ((stderr, "rxvt_IM_get_IC ()"));
1235   input_method = display->get_xim (locale, modifiers);
1236   if (input_method == NULL)
1237     return false;
1238
1239   xim = input_method->xim;
1240
1241   xim_styles = NULL;
1242   if (XGetIMValues (xim, XNQueryInputStyle, &xim_styles, NULL)
1243       || !xim_styles || !xim_styles->count_styles)
1244     {
1245       display->put_xim (input_method);
1246       return false;
1247     }
1248
1249   p = rs[Rs_preeditType] ? rs[Rs_preeditType] : "OverTheSpot,OffTheSpot,Root";
1250   s = rxvt_splitcommastring (p);
1251   for (i = found = 0; !found && s[i]; i++)
1252     {
1253       if (!STRCMP (s[i], "OverTheSpot"))
1254         input_style = (XIMPreeditPosition | XIMStatusNothing);
1255       else if (!STRCMP (s[i], "OffTheSpot"))
1256         input_style = (XIMPreeditArea | XIMStatusArea);
1257       else if (!STRCMP (s[i], "Root"))
1258         input_style = (XIMPreeditNothing | XIMStatusNothing);
1259
1260       for (j = 0; j < xim_styles->count_styles; j++)
1261         if (input_style == xim_styles->supported_styles[j])
1262           {
1263             found = 1;
1264             break;
1265           }
1266     }
1267
1268   for (i = 0; s[i]; i++)
1269     free (s[i]);
1270
1271   free (s);
1272   XFree (xim_styles);
1273
1274   if (!found)
1275     {
1276       display->put_xim (input_method);
1277       return false;
1278     }
1279
1280   preedit_attr = status_attr = NULL;
1281
1282   if (input_style & XIMPreeditPosition)
1283     {
1284       im_set_size (&rect);
1285       im_set_position (&spot);
1286       im_set_color (&fg, &bg);
1287
1288       preedit_attr = XVaCreateNestedList (0, XNArea, &rect,
1289                                          XNSpotLocation, &spot,
1290                                          XNForeground, fg, XNBackground, bg,
1291                                          //XNFontSet, TermWin.fontset,
1292                                          NULL);
1293     }
1294   else if (input_style & XIMPreeditArea)
1295     {
1296       im_set_color (&fg, &bg);
1297
1298       /*
1299        * The necessary width of preedit area is unknown
1300        * until create input context.
1301        */
1302       needed_rect.width = 0;
1303
1304       im_set_preedit_area (&rect, &status_rect, &needed_rect);
1305
1306       preedit_attr = XVaCreateNestedList (0, XNArea, &rect,
1307                                          XNForeground, fg, XNBackground, bg,
1308                                          //XNFontSet, TermWin.fontset,
1309                                          NULL);
1310       status_attr = XVaCreateNestedList (0, XNArea, &status_rect,
1311                                         XNForeground, fg, XNBackground, bg,
1312                                         //XNFontSet, TermWin.fontset,
1313                                         NULL);
1314     }
1315
1316   Input_Context = XCreateIC (xim, XNInputStyle, input_style,
1317                             XNClientWindow, TermWin.parent[0],
1318                             XNFocusWindow, TermWin.parent[0],
1319                             preedit_attr ? XNPreeditAttributes : NULL,
1320                             preedit_attr,
1321                             status_attr ? XNStatusAttributes : NULL,
1322                             status_attr, NULL);
1323   if (preedit_attr) XFree (preedit_attr);
1324   if (status_attr) XFree (status_attr);
1325
1326   if (Input_Context == NULL)
1327     {
1328       rxvt_print_error ("failed to create input context");
1329       display->put_xim (input_method);
1330       return false;
1331     }
1332
1333   if (input_style & XIMPreeditArea)
1334     IMSetStatusPosition ();
1335
1336   D_MAIN ((stderr, "rxvt_IM_get_IC () - successful connection"));
1337   return true;
1338 }
1339
1340 void
1341 rxvt_term::im_cb ()
1342 {
1343   int i, found, had_im;
1344   const char *p;
1345   char **s;
1346   char buf[IMBUFSIZ];
1347
1348   im_destroy ();
1349
1350   D_MAIN ((stderr, "rxvt_IMInstantiateCallback ()"));
1351   if (Input_Context)
1352     return;
1353
1354 #if defined(HAVE_XSETLOCALE) || defined(HAVE_SETLOCALE)
1355   if (rs[Rs_imLocale])
1356     SET_LOCALE (rs[Rs_imLocale]);
1357 #endif
1358
1359   p = rs[Rs_inputMethod];
1360   if (p && *p)
1361     {
1362       bool found = false;
1363
1364       s = rxvt_splitcommastring (p);
1365       for (i = 0; s[i]; i++)
1366         {
1367           if (*s[i])
1368             {
1369               STRCPY (buf, "@im=");
1370               STRNCAT (buf, s[i], IMBUFSIZ - 5);
1371               if (IM_get_IC (buf))
1372                 {
1373                   found = true;
1374                   break;
1375                 }
1376             }
1377         }
1378       for (i = 0; s[i]; i++)
1379         free (s[i]);
1380       free (s);
1381
1382       if (found)
1383         goto done;
1384     }
1385
1386   /* try with XMODIFIERS env. var. */
1387   if (IM_get_IC (""))
1388     goto done;
1389
1390   /* try with no modifiers base IF the user didn't specify an IM */
1391   if (IM_get_IC ("@im=none"))
1392     goto done;
1393
1394 done:
1395 #if defined(HAVE_XSETLOCALE) || defined(HAVE_SETLOCALE)
1396   if (rs[Rs_imLocale])
1397     SET_LOCALE (locale);
1398 #endif
1399 }
1400
1401 void
1402 rxvt_term::IMSetStatusPosition ()
1403 {
1404   XRectangle      preedit_rect, status_rect, *needed_rect;
1405   XVaNestedList   preedit_attr, status_attr;
1406
1407   if (Input_Context == NULL
1408       || !TermWin.focus || ! (input_style & XIMPreeditArea)
1409       || !IMisRunning ())
1410     return;
1411
1412   /* Getting the necessary width of preedit area */
1413   status_attr = XVaCreateNestedList (0, XNAreaNeeded, &needed_rect, NULL);
1414   XGetICValues (Input_Context, XNStatusAttributes, status_attr, NULL);
1415   XFree (status_attr);
1416
1417   im_set_preedit_area (&preedit_rect, &status_rect, needed_rect);
1418
1419   preedit_attr = XVaCreateNestedList (0, XNArea, &preedit_rect, NULL);
1420   status_attr = XVaCreateNestedList (0, XNArea, &status_rect, NULL);
1421
1422   XSetICValues (Input_Context,
1423                XNPreeditAttributes, preedit_attr,
1424                XNStatusAttributes, status_attr, NULL);
1425
1426   XFree (preedit_attr);
1427   XFree (status_attr);
1428 }
1429 #endif                          /* USE_XIM */
1430
1431 /*----------------------------------------------------------------------*/
1432 rxvt_t          rxvt_current_term;
1433
1434 /*----------------------- end-of-file (C source) -----------------------*/