ncurses/llib-lncurses

   1 /****************************************************************************
   2  * Copyright (c) 1998,1999 Free Software Foundation, Inc.                   *
   3  *                                                                          *
   4  * Permission is hereby granted, free of charge, to any person obtaining a  *
   5  * copy of this software and associated documentation files (the            *
   6  * "Software"), to deal in the Software without restriction, including      *
   7  * without limitation the rights to use, copy, modify, merge, publish,      *
   8  * distribute, distribute with modifications, sublicense, and/or sell       *
   9  * copies of the Software, and to permit persons to whom the Software is    *
  10  * furnished to do so, subject to the following conditions:                 *
  11  *                                                                          *
  12  * The above copyright notice and this permission notice shall be included  *
  13  * in all copies or substantial portions of the Software.                   *
  14  *                                                                          *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  22  *                                                                          *
  23  * Except as contained in this notice, the name(s) of the above copyright   *
  24  * holders shall not be used in advertising or otherwise to promote the     *
  25  * sale, use or other dealings in this Software without prior written       *
  26  * authorization.                                                           *
  27  ****************************************************************************/
  28
  29 /****************************************************************************
  30  *  Author: Thomas E. Dickey <dickey@clark.net> 1996,1997,1998,1999         *
  31  ****************************************************************************/
  32 /* LINTLIBRARY */
  33
  34 /* ./tty/hardscroll.c */
  35
  36 #include <curses.priv.h>
  37
  38 #undef _nc_oldnums
  39 int     *_nc_oldnums;
  40
  41 #undef _nc_scroll_optimize
  42 void    _nc_scroll_optimize(void)
  43                 { /* void */ }
  44
  45 /* ./tty/hashmap.c */
  46
  47 #include <term.h>
  48
  49 typedef struct
  50 {
  51     unsigned long       hashval;
  52     int         oldcount, newcount;
  53     int         oldindex, newindex;
  54 }
  55     sym;
  56
  57 #undef _nc_hash_map
  58 void    _nc_hash_map(void)
  59                 { /* void */ }
  60
  61 #undef _nc_make_oldhash
  62 void    _nc_make_oldhash(
  63                 int     i)
  64                 { /* void */ }
  65
  66 #undef _nc_scroll_oldhash
  67 void    _nc_scroll_oldhash(
  68                 int     n,
  69                 int     top,
  70                 int     bot)
  71                 { /* void */ }
  72
  73 /* ./base/lib_addch.c */
  74
  75 #include <ctype.h>
  76
  77 #undef _nc_background
  78 chtype  _nc_background(
  79                 WINDOW  *win)
  80                 { return(*(chtype *)0); }
  81
  82 #undef _nc_render
  83 chtype  _nc_render(
  84                 WINDOW  *win,
  85                 chtype  ch)
  86                 { return(*(chtype *)0); }
  87
  88 #undef _nc_waddch_nosync
  89 int     _nc_waddch_nosync(
  90                 WINDOW  *win,
  91                 const chtype c)
  92                 { return(*(int *)0); }
  93
  94 #undef waddch
  95 int     waddch(
  96                 WINDOW  *win,
  97                 const chtype ch)
  98                 { return(*(int *)0); }
  99
 100 #undef wechochar
 101 int     wechochar(
 102                 WINDOW  *win,
 103                 const chtype ch)
 104                 { return(*(int *)0); }
 105
 106 /* ./base/lib_addstr.c */
 107
 108 #undef waddnstr
 109 int     waddnstr(
 110                 WINDOW  *win,
 111                 const char *const astr,
 112                 int     n)
 113                 { return(*(int *)0); }
 114
 115 #undef waddchnstr
 116 int     waddchnstr(
 117                 WINDOW  *win,
 118                 const chtype *const astr,
 119                 int     n)
 120                 { return(*(int *)0); }
 121
 122 /* ./base/lib_beep.c */
 123
 124 #undef beep
 125 int     beep(void)
 126                 { return(*(int *)0); }
 127
 128 /* ./base/lib_bkgd.c */
 129
 130 #undef wbkgdset
 131 void    wbkgdset(
 132                 WINDOW  *win,
 133                 chtype  ch)
 134                 { /* void */ }
 135
 136 #undef wbkgd
 137 int     wbkgd(
 138                 WINDOW  *win,
 139                 const chtype ch)
 140                 { return(*(int *)0); }
 141
 142 /* ./base/lib_box.c */
 143
 144 #undef wborder
 145 int     wborder(
 146                 WINDOW  *win,
 147                 chtype  ls,
 148                 chtype  rs,
 149                 chtype  ts,
 150                 chtype  bs,
 151                 chtype  tl,
 152                 chtype  tr,
 153                 chtype  bl,
 154                 chtype  br)
 155                 { return(*(int *)0); }
 156
 157 /* ./base/lib_chgat.c */
 158
 159 #undef wchgat
 160 int     wchgat(
 161                 WINDOW  *win,
 162                 int     n,
 163                 attr_t  attr,
 164                 short   color,
 165                 const void *opts)
 166                 { return(*(int *)0); }
 167
 168 /* ./base/lib_clear.c */
 169
 170 #undef wclear
 171 int     wclear(
 172                 WINDOW  *win)
 173                 { return(*(int *)0); }
 174
 175 /* ./base/lib_clearok.c */
 176
 177 #undef clearok
 178 int     clearok(
 179                 WINDOW  *win,
 180                 bool    flag)
 181                 { return(*(int *)0); }
 182
 183 /* ./base/lib_clrbot.c */
 184
 185 #undef wclrtobot
 186 int     wclrtobot(
 187                 WINDOW  *win)
 188                 { return(*(int *)0); }
 189
 190 /* ./base/lib_clreol.c */
 191
 192 #undef wclrtoeol
 193 int     wclrtoeol(
 194                 WINDOW  *win)
 195                 { return(*(int *)0); }
 196
 197 /* ./base/lib_color.c */
 198
 199 #undef COLOR_PAIRS
 200 int     COLOR_PAIRS;
 201 #undef COLORS
 202 int     COLORS;
 203
 204 #undef start_color
 205 int     start_color(void)
 206                 { return(*(int *)0); }
 207
 208 #undef init_pair
 209 int     init_pair(
 210                 short   pair,
 211                 short   f,
 212                 short   b)
 213                 { return(*(int *)0); }
 214
 215 #undef init_color
 216 int     init_color(
 217                 short   color,
 218                 short   r,
 219                 short   g,
 220                 short   b)
 221                 { return(*(int *)0); }
 222
 223 #undef can_change_color
 224 bool    can_change_color(void)
 225                 { return(*(bool *)0); }
 226
 227 #undef has_colors
 228 bool    has_colors(void)
 229                 { return(*(bool *)0); }
 230
 231 #undef color_content
 232 int     color_content(
 233                 short   color,
 234                 short   *r,
 235                 short   *g,
 236                 short   *b)
 237                 { return(*(int *)0); }
 238
 239 #undef pair_content
 240 int     pair_content(
 241                 short   pair,
 242                 short   *f,
 243                 short   *b)
 244                 { return(*(int *)0); }
 245
 246 #undef _nc_do_color
 247 void    _nc_do_color(
 248                 int     pair,
 249                 bool    reverse,
 250                 int     (*outc)(
 251                 int     p1))
 252                 { /* void */ }
 253
 254 /* ./base/lib_colorset.c */
 255
 256 #undef wcolor_set
 257 int     wcolor_set(
 258                 WINDOW  *win,
 259                 short   color_pair_number,
 260                 void    *opts)
 261                 { return(*(int *)0); }
 262
 263 /* ./base/lib_delch.c */
 264
 265 #undef wdelch
 266 int     wdelch(
 267                 WINDOW  *win)
 268                 { return(*(int *)0); }
 269
 270 /* ./base/lib_delwin.c */
 271
 272 #undef delwin
 273 int     delwin(
 274                 WINDOW  *win)
 275                 { return(*(int *)0); }
 276
 277 /* ./base/lib_echo.c */
 278
 279 #undef echo
 280 int     echo(void)
 281                 { return(*(int *)0); }
 282
 283 #undef noecho
 284 int     noecho(void)
 285                 { return(*(int *)0); }
 286
 287 /* ./base/lib_endwin.c */
 288
 289 #undef endwin
 290 int     endwin(void)
 291                 { return(*(int *)0); }
 292
 293 /* ./base/lib_erase.c */
 294
 295 #undef werase
 296 int     werase(
 297                 WINDOW  *win)
 298                 { return(*(int *)0); }
 299
 300 /* ./base/lib_flash.c */
 301
 302 #undef flash
 303 int     flash(void)
 304                 { return(*(int *)0); }
 305
 306 /* ./lib_gen.c */
 307
 308 #undef addch
 309 int     addch(
 310                 const chtype z)
 311                 { return(*(int *)0); }
 312
 313 #undef addchnstr
 314 int     addchnstr(
 315                 const chtype *a1,
 316                 int     z)
 317                 { return(*(int *)0); }
 318
 319 #undef addchstr
 320 int     addchstr(
 321                 const chtype *z)
 322                 { return(*(int *)0); }
 323
 324 #undef addnstr
 325 int     addnstr(
 326                 const char *a1,
 327                 int     z)
 328                 { return(*(int *)0); }
 329
 330 #undef addstr
 331 int     addstr(
 332                 const char *z)
 333                 { return(*(int *)0); }
 334
 335 #undef attroff
 336 int     attroff(
 337                 NCURSES_ATTR_T  z)
 338                 { return(*(int *)0); }
 339
 340 #undef attron
 341 int     attron(
 342                 NCURSES_ATTR_T  z)
 343                 { return(*(int *)0); }
 344
 345 #undef attrset
 346 int     attrset(
 347                 NCURSES_ATTR_T  z)
 348                 { return(*(int *)0); }
 349
 350 #undef attr_get
 351 int     attr_get(
 352                 attr_t  *a1,
 353                 short   *a2,
 354                 void    *z)
 355                 { return(*(int *)0); }
 356
 357 #undef attr_off
 358 int     attr_off(
 359                 attr_t  a1,
 360                 void    *z)
 361                 { return(*(int *)0); }
 362
 363 #undef attr_on
 364 int     attr_on(
 365                 attr_t  a1,
 366                 void    *z)
 367                 { return(*(int *)0); }
 368
 369 #undef attr_set
 370 int     attr_set(
 371                 attr_t  a1,
 372                 short   a2,
 373                 void    *z)
 374                 { return(*(int *)0); }
 375
 376 #undef bkgd
 377 int     bkgd(
 378                 chtype  z)
 379                 { return(*(int *)0); }
 380
 381 #undef bkgdset
 382 void    bkgdset(
 383                 chtype  z)
 384                 { /* void */ }
 385
 386 #undef border
 387 int     border(
 388                 chtype  a1,
 389                 chtype  a2,
 390                 chtype  a3,
 391                 chtype  a4,
 392                 chtype  a5,
 393                 chtype  a6,
 394                 chtype  a7,
 395                 chtype  z)
 396                 { return(*(int *)0); }
 397
 398 #undef box
 399 int     box(
 400                 WINDOW  *a1,
 401                 chtype  a2,
 402                 chtype  z)
 403                 { return(*(int *)0); }
 404
 405 #undef chgat
 406 int     chgat(
 407                 int     a1,
 408                 attr_t  a2,
 409                 short   a3,
 410                 const void *z)
 411                 { return(*(int *)0); }
 412
 413 #undef clear
 414 int     clear(void)
 415                 { return(*(int *)0); }
 416
 417 #undef clrtobot
 418 int     clrtobot(void)
 419                 { return(*(int *)0); }
 420
 421 #undef clrtoeol
 422 int     clrtoeol(void)
 423                 { return(*(int *)0); }
 424
 425 #undef color_set
 426 int     color_set(
 427                 short   a1,
 428                 void    *z)
 429                 { return(*(int *)0); }
 430
 431 #undef COLOR_PAIR
 432 int     COLOR_PAIR(
 433                 int     z)
 434                 { return(*(int *)0); }
 435
 436 #undef delch
 437 int     delch(void)
 438                 { return(*(int *)0); }
 439
 440 #undef deleteln
 441 int     deleteln(void)
 442                 { return(*(int *)0); }
 443
 444 #undef echochar
 445 int     echochar(
 446                 const chtype z)
 447                 { return(*(int *)0); }
 448
 449 #undef getbkgd
 450 chtype  getbkgd(
 451                 WINDOW  *z)
 452                 { return(*(chtype *)0); }
 453
 454 #undef getch
 455 int     getch(void)
 456                 { return(*(int *)0); }
 457
 458 #undef getnstr
 459 int     getnstr(
 460                 char    *a1,
 461                 int     z)
 462                 { return(*(int *)0); }
 463
 464 #undef getstr
 465 int     getstr(
 466                 char    *z)
 467                 { return(*(int *)0); }
 468
 469 #undef hline
 470 int     hline(
 471                 chtype  a1,
 472                 int     z)
 473                 { return(*(int *)0); }
 474
 475 #undef inch
 476 chtype  inch(void)
 477                 { return(*(chtype *)0); }
 478
 479 #undef inchnstr
 480 int     inchnstr(
 481                 chtype  *a1,
 482                 int     z)
 483                 { return(*(int *)0); }
 484
 485 #undef inchstr
 486 int     inchstr(
 487                 chtype  *z)
 488                 { return(*(int *)0); }
 489
 490 #undef innstr
 491 int     innstr(
 492                 char    *a1,
 493                 int     z)
 494                 { return(*(int *)0); }
 495
 496 #undef insch
 497 int     insch(
 498                 chtype  z)
 499                 { return(*(int *)0); }
 500
 501 #undef insdelln
 502 int     insdelln(
 503                 int     z)
 504                 { return(*(int *)0); }
 505
 506 #undef insertln
 507 int     insertln(void)
 508                 { return(*(int *)0); }
 509
 510 #undef insnstr
 511 int     insnstr(
 512                 const char *a1,
 513                 int     z)
 514                 { return(*(int *)0); }
 515
 516 #undef insstr
 517 int     insstr(
 518                 const char *z)
 519                 { return(*(int *)0); }
 520
 521 #undef instr
 522 int     instr(
 523                 char    *z)
 524                 { return(*(int *)0); }
 525
 526 #undef move
 527 int     move(
 528                 int     a1,
 529                 int     z)
 530                 { return(*(int *)0); }
 531
 532 #undef mvaddch
 533 int     mvaddch(
 534                 int     a1,
 535                 int     a2,
 536                 const chtype z)
 537                 { return(*(int *)0); }
 538
 539 #undef mvaddchnstr
 540 int     mvaddchnstr(
 541                 int     a1,
 542                 int     a2,
 543                 const chtype *a3,
 544                 int     z)
 545                 { return(*(int *)0); }
 546
 547 #undef mvaddchstr
 548 int     mvaddchstr(
 549                 int     a1,
 550                 int     a2,
 551                 const chtype *z)
 552                 { return(*(int *)0); }
 553
 554 #undef mvaddnstr
 555 int     mvaddnstr(
 556                 int     a1,
 557                 int     a2,
 558                 const char *a3,
 559                 int     z)
 560                 { return(*(int *)0); }
 561
 562 #undef mvaddstr
 563 int     mvaddstr(
 564                 int     a1,
 565                 int     a2,
 566                 const char *z)
 567                 { return(*(int *)0); }
 568
 569 #undef mvchgat
 570 int     mvchgat(
 571                 int     a1,
 572                 int     a2,
 573                 int     a3,
 574                 attr_t  a4,
 575                 short   a5,
 576                 const void *z)
 577                 { return(*(int *)0); }
 578
 579 #undef mvdelch
 580 int     mvdelch(
 581                 int     a1,
 582                 int     z)
 583                 { return(*(int *)0); }
 584
 585 #undef mvgetch
 586 int     mvgetch(
 587                 int     a1,
 588                 int     z)
 589                 { return(*(int *)0); }
 590
 591 #undef mvgetnstr
 592 int     mvgetnstr(
 593                 int     a1,
 594                 int     a2,
 595                 char    *a3,
 596                 int     z)
 597                 { return(*(int *)0); }
 598
 599 #undef mvgetstr
 600 int     mvgetstr(
 601                 int     a1,
 602                 int     a2,
 603                 char    *z)
 604                 { return(*(int *)0); }
 605
 606 #undef mvhline
 607 int     mvhline(
 608                 int     a1,
 609                 int     a2,
 610                 chtype  a3,
 611                 int     z)
 612                 { return(*(int *)0); }
 613
 614 #undef mvinch
 615 chtype  mvinch(
 616                 int     a1,
 617                 int     z)
 618                 { return(*(chtype *)0); }
 619
 620 #undef mvinchnstr
 621 int     mvinchnstr(
 622                 int     a1,
 623                 int     a2,
 624                 chtype  *a3,
 625                 int     z)
 626                 { return(*(int *)0); }
 627
 628 #undef mvinchstr
 629 int     mvinchstr(
 630                 int     a1,
 631                 int     a2,
 632                 chtype  *z)
 633                 { return(*(int *)0); }
 634
 635 #undef mvinnstr
 636 int     mvinnstr(
 637                 int     a1,
 638                 int     a2,
 639                 char    *a3,
 640                 int     z)
 641                 { return(*(int *)0); }
 642
 643 #undef mvinsch
 644 int     mvinsch(
 645                 int     a1,
 646                 int     a2,
 647                 chtype  z)
 648                 { return(*(int *)0); }
 649
 650 #undef mvinsnstr
 651 int     mvinsnstr(
 652                 int     a1,
 653                 int     a2,
 654                 const char *a3,
 655                 int     z)
 656                 { return(*(int *)0); }
 657
 658 #undef mvinsstr
 659 int     mvinsstr(
 660                 int     a1,
 661                 int     a2,
 662                 const char *z)
 663                 { return(*(int *)0); }
 664
 665 #undef mvinstr
 666 int     mvinstr(
 667                 int     a1,
 668                 int     a2,
 669                 char    *z)
 670                 { return(*(int *)0); }
 671
 672 #undef mvvline
 673 int     mvvline(
 674                 int     a1,
 675                 int     a2,
 676                 chtype  a3,
 677                 int     z)
 678                 { return(*(int *)0); }
 679
 680 #undef mvwaddch
 681 int     mvwaddch(
 682                 WINDOW  *a1,
 683                 int     a2,
 684                 int     a3,
 685                 const chtype z)
 686                 { return(*(int *)0); }
 687
 688 #undef mvwaddchnstr
 689 int     mvwaddchnstr(
 690                 WINDOW  *a1,
 691                 int     a2,
 692                 int     a3,
 693                 const chtype *a4,
 694                 int     z)
 695                 { return(*(int *)0); }
 696
 697 #undef mvwaddchstr
 698 int     mvwaddchstr(
 699                 WINDOW  *a1,
 700                 int     a2,
 701                 int     a3,
 702                 const chtype *z)
 703                 { return(*(int *)0); }
 704
 705 #undef mvwaddnstr
 706 int     mvwaddnstr(
 707                 WINDOW  *a1,
 708                 int     a2,
 709                 int     a3,
 710                 const char *a4,
 711                 int     z)
 712                 { return(*(int *)0); }
 713
 714 #undef mvwaddstr
 715 int     mvwaddstr(
 716                 WINDOW  *a1,
 717                 int     a2,
 718                 int     a3,
 719                 const char *z)
 720                 { return(*(int *)0); }
 721
 722 #undef mvwchgat
 723 int     mvwchgat(
 724                 WINDOW  *a1,
 725                 int     a2,
 726                 int     a3,
 727                 int     a4,
 728                 attr_t  a5,
 729                 short   a6,
 730                 const void *z)
 731                 { return(*(int *)0); }
 732
 733 #undef mvwdelch
 734 int     mvwdelch(
 735                 WINDOW  *a1,
 736                 int     a2,
 737                 int     z)
 738                 { return(*(int *)0); }
 739
 740 #undef mvwgetch
 741 int     mvwgetch(
 742                 WINDOW  *a1,
 743                 int     a2,
 744                 int     z)
 745                 { return(*(int *)0); }
 746
 747 #undef mvwgetnstr
 748 int     mvwgetnstr(
 749                 WINDOW  *a1,
 750                 int     a2,
 751                 int     a3,
 752                 char    *a4,
 753                 int     z)
 754                 { return(*(int *)0); }
 755
 756 #undef mvwgetstr
 757 int     mvwgetstr(
 758                 WINDOW  *a1,
 759                 int     a2,
 760                 int     a3,
 761                 char    *z)
 762                 { return(*(int *)0); }
 763
 764 #undef mvwhline
 765 int     mvwhline(
 766                 WINDOW  *a1,
 767                 int     a2,
 768                 int     a3,
 769                 chtype  a4,
 770                 int     z)
 771                 { return(*(int *)0); }
 772
 773 #undef mvwinch
 774 chtype  mvwinch(
 775                 WINDOW  *a1,
 776                 int     a2,
 777                 int     z)
 778                 { return(*(chtype *)0); }
 779
 780 #undef mvwinchnstr
 781 int     mvwinchnstr(
 782                 WINDOW  *a1,
 783                 int     a2,
 784                 int     a3,
 785                 chtype  *a4,
 786                 int     z)
 787                 { return(*(int *)0); }
 788
 789 #undef mvwinchstr
 790 int     mvwinchstr(
 791                 WINDOW  *a1,
 792                 int     a2,
 793                 int     a3,
 794                 chtype  *z)
 795                 { return(*(int *)0); }
 796
 797 #undef mvwinnstr
 798 int     mvwinnstr(
 799                 WINDOW  *a1,
 800                 int     a2,
 801                 int     a3,
 802                 char    *a4,
 803                 int     z)
 804                 { return(*(int *)0); }
 805
 806 #undef mvwinsch
 807 int     mvwinsch(
 808                 WINDOW  *a1,
 809                 int     a2,
 810                 int     a3,
 811                 chtype  z)
 812                 { return(*(int *)0); }
 813
 814 #undef mvwinsnstr
 815 int     mvwinsnstr(
 816                 WINDOW  *a1,
 817                 int     a2,
 818                 int     a3,
 819                 const char *a4,
 820                 int     z)
 821                 { return(*(int *)0); }
 822
 823 #undef mvwinsstr
 824 int     mvwinsstr(
 825                 WINDOW  *a1,
 826                 int     a2,
 827                 int     a3,
 828                 const char *z)
 829                 { return(*(int *)0); }
 830
 831 #undef mvwinstr
 832 int     mvwinstr(
 833                 WINDOW  *a1,
 834                 int     a2,
 835                 int     a3,
 836                 char    *z)
 837                 { return(*(int *)0); }
 838
 839 #undef mvwvline
 840 int     mvwvline(
 841                 WINDOW  *a1,
 842                 int     a2,
 843                 int     a3,
 844                 chtype  a4,
 845                 int     z)
 846                 { return(*(int *)0); }
 847
 848 #undef PAIR_NUMBER
 849 int     PAIR_NUMBER(
 850                 int     z)
 851                 { return(*(int *)0); }
 852
 853 #undef redrawwin
 854 int     redrawwin(
 855                 WINDOW  *z)
 856                 { return(*(int *)0); }
 857
 858 #undef refresh
 859 int     refresh(void)
 860                 { return(*(int *)0); }
 861
 862 #undef scrl
 863 int     scrl(
 864                 int     z)
 865                 { return(*(int *)0); }
 866
 867 #undef scroll
 868 int     scroll(
 869                 WINDOW  *z)
 870                 { return(*(int *)0); }
 871
 872 #undef setscrreg
 873 int     setscrreg(
 874                 int     a1,
 875                 int     z)
 876                 { return(*(int *)0); }
 877
 878 #undef standout
 879 int     standout(void)
 880                 { return(*(int *)0); }
 881
 882 #undef standend
 883 int     standend(void)
 884                 { return(*(int *)0); }
 885
 886 #undef timeout
 887 void    timeout(
 888                 int     z)
 889                 { /* void */ }
 890
 891 #undef untouchwin
 892 int     untouchwin(
 893                 WINDOW  *z)
 894                 { return(*(int *)0); }
 895
 896 #undef vline
 897 int     vline(
 898                 chtype  a1,
 899                 int     z)
 900                 { return(*(int *)0); }
 901
 902 #undef vw_printw
 903 int     vw_printw(
 904                 WINDOW  *a1,
 905                 char    *a2,
 906                 va_list z)
 907                 { return(*(int *)0); }
 908
 909 #undef vw_scanw
 910 int     vw_scanw(
 911                 WINDOW  *a1,
 912                 char    *a2,
 913                 va_list z)
 914                 { return(*(int *)0); }
 915
 916 #undef waddchstr
 917 int     waddchstr(
 918                 WINDOW  *a1,
 919                 const chtype *z)
 920                 { return(*(int *)0); }
 921
 922 #undef waddstr
 923 int     waddstr(
 924                 WINDOW  *a1,
 925                 const char *z)
 926                 { return(*(int *)0); }
 927
 928 #undef wattron
 929 int     wattron(
 930                 WINDOW  *a1,
 931                 int     z)
 932                 { return(*(int *)0); }
 933
 934 #undef wattroff
 935 int     wattroff(
 936                 WINDOW  *a1,
 937                 int     z)
 938                 { return(*(int *)0); }
 939
 940 #undef wattrset
 941 int     wattrset(
 942                 WINDOW  *a1,
 943                 int     z)
 944                 { return(*(int *)0); }
 945
 946 #undef wattr_get
 947 int     wattr_get(
 948                 WINDOW  *a1,
 949                 attr_t  *a2,
 950                 short   *a3,
 951                 void    *z)
 952                 { return(*(int *)0); }
 953
 954 #undef wattr_set
 955 int     wattr_set(
 956                 WINDOW  *a1,
 957                 attr_t  a2,
 958                 short   a3,
 959                 void    *z)
 960                 { return(*(int *)0); }
 961
 962 #undef wdeleteln
 963 int     wdeleteln(
 964                 WINDOW  *z)
 965                 { return(*(int *)0); }
 966
 967 #undef wgetstr
 968 int     wgetstr(
 969                 WINDOW  *a1,
 970                 char    *z)
 971                 { return(*(int *)0); }
 972
 973 #undef winchstr
 974 int     winchstr(
 975                 WINDOW  *a1,
 976                 chtype  *z)
 977                 { return(*(int *)0); }
 978
 979 #undef winsertln
 980 int     winsertln(
 981                 WINDOW  *z)
 982                 { return(*(int *)0); }
 983
 984 #undef winsstr
 985 int     winsstr(
 986                 WINDOW  *a1,
 987                 const char *z)
 988                 { return(*(int *)0); }
 989
 990 #undef winstr
 991 int     winstr(
 992                 WINDOW  *a1,
 993                 char    *z)
 994                 { return(*(int *)0); }
 995
 996 #undef wstandout
 997 int     wstandout(
 998                 WINDOW  *z)
 999                 { return(*(int *)0); }
1000
1001 #undef wstandend
1002 int     wstandend(
1003                 WINDOW  *z)
1004                 { return(*(int *)0); }
1005
1006 #undef mouse_trafo
1007 bool    mouse_trafo(
1008                 int     *a1,
1009                 int     *a2,
1010                 bool    z)
1011                 { return(*(bool *)0); }
1012
1013 /* ./base/lib_getch.c */
1014
1015 #include <fifo_defs.h>
1016
1017 #undef ESCDELAY
1018 int     ESCDELAY;
1019
1020 #undef wgetch
1021 int     wgetch(
1022                 WINDOW  *win)
1023                 { return(*(int *)0); }
1024
1025 /* ./base/lib_getstr.c */
1026
1027 #undef wgetnstr
1028 int     wgetnstr(
1029                 WINDOW  *win,
1030                 char    *str,
1031                 int     maxlen)
1032                 { return(*(int *)0); }
1033
1034 /* ./base/lib_hline.c */
1035
1036 #undef whline
1037 int     whline(
1038                 WINDOW  *win,
1039                 chtype  ch,
1040                 int     n)
1041                 { return(*(int *)0); }
1042
1043 /* ./base/lib_immedok.c */
1044
1045 #undef immedok
1046 void    immedok(
1047                 WINDOW  *win,
1048                 bool    flag)
1049                 { /* void */ }
1050
1051 /* ./base/lib_inchstr.c */
1052
1053 #undef winchnstr
1054 int     winchnstr(
1055                 WINDOW  *win,
1056                 chtype  *str,
1057                 int     n)
1058                 { return(*(int *)0); }
1059
1060 /* ./base/lib_initscr.c */
1061
1062 #include <tic.h>
1063
1064 #undef initscr
1065 WINDOW  *initscr(void)
1066                 { return(*(WINDOW **)0); }
1067
1068 /* ./base/lib_insch.c */
1069
1070 #undef winsch
1071 int     winsch(
1072                 WINDOW  *win,
1073                 chtype  c)
1074                 { return(*(int *)0); }
1075
1076 /* ./base/lib_insdel.c */
1077
1078 #undef winsdelln
1079 int     winsdelln(
1080                 WINDOW  *win,
1081                 int     n)
1082                 { return(*(int *)0); }
1083
1084 /* ./base/lib_insstr.c */
1085
1086 #undef winsnstr
1087 int     winsnstr(
1088                 WINDOW  *win,
1089                 const char *s,
1090                 int     n)
1091                 { return(*(int *)0); }
1092
1093 /* ./base/lib_instr.c */
1094
1095 #undef winnstr
1096 int     winnstr(
1097                 WINDOW  *win,
1098                 char    *str,
1099                 int     n)
1100                 { return(*(int *)0); }
1101
1102 /* ./base/lib_isendwin.c */
1103
1104 #undef isendwin
1105 bool    isendwin(void)
1106                 { return(*(bool *)0); }
1107
1108 /* ./base/lib_leaveok.c */
1109
1110 #undef leaveok
1111 int     leaveok(
1112                 WINDOW  *win,
1113                 bool    flag)
1114                 { return(*(int *)0); }
1115
1116 /* ./base/lib_mouse.c */
1117
1118 #undef getmouse
1119 int     getmouse(
1120                 MEVENT  *aevent)
1121                 { return(*(int *)0); }
1122
1123 #undef ungetmouse
1124 int     ungetmouse(
1125                 MEVENT  *aevent)
1126                 { return(*(int *)0); }
1127
1128 #undef mousemask
1129 mmask_t mousemask(
1130                 mmask_t newmask,
1131                 mmask_t *oldmask)
1132                 { return(*(mmask_t *)0); }
1133
1134 #undef wenclose
1135 bool    wenclose(
1136                 const WINDOW *win,
1137                 int     y,
1138                 int     x)
1139                 { return(*(bool *)0); }
1140
1141 #undef mouseinterval
1142 int     mouseinterval(
1143                 int     maxclick)
1144                 { return(*(int *)0); }
1145
1146 #undef _nc_has_mouse
1147 int     _nc_has_mouse(void)
1148                 { return(*(int *)0); }
1149
1150 #undef wmouse_trafo
1151 bool    wmouse_trafo(
1152                 const WINDOW *win,
1153                 int     *pY,
1154                 int     *pX,
1155                 bool    to_screen)
1156                 { return(*(bool *)0); }
1157
1158 /* ./base/lib_move.c */
1159
1160 #undef wmove
1161 int     wmove(
1162                 WINDOW  *win,
1163                 int     y,
1164                 int     x)
1165                 { return(*(int *)0); }
1166
1167 /* ./tty/lib_mvcur.c */
1168
1169 #undef _nc_msec_cost
1170 int     _nc_msec_cost(
1171                 const char *const cap,
1172                 int     affcnt)
1173                 { return(*(int *)0); }
1174
1175 #undef _nc_mvcur_resume
1176 void    _nc_mvcur_resume(void)
1177                 { /* void */ }
1178
1179 #undef _nc_mvcur_init
1180 void    _nc_mvcur_init(void)
1181                 { /* void */ }
1182
1183 #undef _nc_mvcur_wrap
1184 void    _nc_mvcur_wrap(void)
1185                 { /* void */ }
1186
1187 #undef mvcur
1188 int     mvcur(
1189                 int     yold,
1190                 int     xold,
1191                 int     ynew,
1192                 int     xnew)
1193                 { return(*(int *)0); }
1194
1195 /* ./base/lib_mvwin.c */
1196
1197 #undef mvwin
1198 int     mvwin(
1199                 WINDOW  *win,
1200                 int     by,
1201                 int     bx)
1202                 { return(*(int *)0); }
1203
1204 /* ./base/lib_newterm.c */
1205
1206 #undef filter
1207 void    filter(void)
1208                 { /* void */ }
1209
1210 #undef newterm
1211 SCREEN  *newterm(
1212                 char    *name,
1213                 FILE    *ofp,
1214                 FILE    *ifp)
1215                 { return(*(SCREEN **)0); }
1216
1217 /* ./base/lib_newwin.c */
1218
1219 #undef _nc_freewin
1220 void    _nc_freewin(
1221                 WINDOW  *win)
1222                 { /* void */ }
1223
1224 #undef newwin
1225 WINDOW  *newwin(
1226                 int     num_lines,
1227                 int     num_columns,
1228                 int     begy,
1229                 int     begx)
1230                 { return(*(WINDOW **)0); }
1231
1232 #undef derwin
1233 WINDOW  *derwin(
1234                 WINDOW  *orig,
1235                 int     num_lines,
1236                 int     num_columns,
1237                 int     begy,
1238                 int     begx)
1239                 { return(*(WINDOW **)0); }
1240
1241 #undef subwin
1242 WINDOW  *subwin(
1243                 WINDOW  *w,
1244                 int     l,
1245                 int     c,
1246                 int     y,
1247                 int     x)
1248                 { return(*(WINDOW **)0); }
1249
1250 #undef _nc_makenew
1251 WINDOW  *_nc_makenew(
1252                 int     num_lines,
1253                 int     num_columns,
1254                 int     begy,
1255                 int     begx,
1256                 int     flags)
1257                 { return(*(WINDOW **)0); }
1258
1259 /* ./base/lib_nl.c */
1260
1261 #undef nl
1262 int     nl(void)
1263                 { return(*(int *)0); }
1264
1265 #undef nonl
1266 int     nonl(void)
1267                 { return(*(int *)0); }
1268
1269 /* ./base/lib_overlay.c */
1270
1271 #undef overlay
1272 int     overlay(
1273                 const WINDOW *win1,
1274                 WINDOW  *win2)
1275                 { return(*(int *)0); }
1276
1277 #undef overwrite
1278 int     overwrite(
1279                 const WINDOW *win1,
1280                 WINDOW  *win2)
1281                 { return(*(int *)0); }
1282
1283 #undef copywin
1284 int     copywin(
1285                 const WINDOW *src,
1286                 WINDOW  *dst,
1287                 int     sminrow,
1288                 int     smincol,
1289                 int     dminrow,
1290                 int     dmincol,
1291                 int     dmaxrow,
1292                 int     dmaxcol,
1293                 int     over)
1294                 { return(*(int *)0); }
1295
1296 /* ./base/lib_pad.c */
1297
1298 #undef newpad
1299 WINDOW  *newpad(
1300                 int     l,
1301                 int     c)
1302                 { return(*(WINDOW **)0); }
1303
1304 #undef subpad
1305 WINDOW  *subpad(
1306                 WINDOW  *orig,
1307                 int     l,
1308                 int     c,
1309                 int     begy,
1310                 int     begx)
1311                 { return(*(WINDOW **)0); }
1312
1313 #undef prefresh
1314 int     prefresh(
1315                 WINDOW  *win,
1316                 int     pminrow,
1317                 int     pmincol,
1318                 int     sminrow,
1319                 int     smincol,
1320                 int     smaxrow,
1321                 int     smaxcol)
1322                 { return(*(int *)0); }
1323
1324 #undef pnoutrefresh
1325 int     pnoutrefresh(
1326                 WINDOW  *win,
1327                 int     pminrow,
1328                 int     pmincol,
1329                 int     sminrow,
1330                 int     smincol,
1331                 int     smaxrow,
1332                 int     smaxcol)
1333                 { return(*(int *)0); }
1334
1335 #undef pechochar
1336 int     pechochar(
1337                 WINDOW  *pad,
1338                 const chtype ch)
1339                 { return(*(int *)0); }
1340
1341 /* ./base/lib_printw.c */
1342
1343 #undef printw
1344 int     printw(
1345                 char    *fmt,
1346                 ...)
1347                 { return(*(int *)0); }
1348
1349 #undef wprintw
1350 int     wprintw(
1351                 WINDOW  *win,
1352                 char    *fmt,
1353                 ...)
1354                 { return(*(int *)0); }
1355
1356 #undef mvprintw
1357 int     mvprintw(
1358                 int     y,
1359                 int     x,
1360                 char    *fmt,
1361                 ...)
1362                 { return(*(int *)0); }
1363
1364 #undef mvwprintw
1365 int     mvwprintw(
1366                 WINDOW  *win,
1367                 int     y,
1368                 int     x,
1369                 char    *fmt,
1370                 ...)
1371                 { return(*(int *)0); }
1372
1373 #undef vwprintw
1374 int     vwprintw(
1375                 WINDOW  *win,
1376                 char    *fmt,
1377                 va_list argp)
1378                 { return(*(int *)0); }
1379
1380 /* ./base/lib_redrawln.c */
1381
1382 #undef wredrawln
1383 int     wredrawln(
1384                 WINDOW  *win,
1385                 int     beg,
1386                 int     num)
1387                 { return(*(int *)0); }
1388
1389 /* ./base/lib_refresh.c */
1390
1391 #undef wrefresh
1392 int     wrefresh(
1393                 WINDOW  *win)
1394                 { return(*(int *)0); }
1395
1396 #undef wnoutrefresh
1397 int     wnoutrefresh(
1398                 WINDOW  *win)
1399                 { return(*(int *)0); }
1400
1401 /* ./base/lib_restart.c */
1402
1403 #undef restartterm
1404 int     restartterm(
1405                 char    *termp,
1406                 int     filenum,
1407                 int     *errret)
1408                 { return(*(int *)0); }
1409
1410 /* ./base/lib_scanw.c */
1411
1412 #undef vwscanw
1413 int     vwscanw(
1414                 WINDOW  *win,
1415                 char    *fmt,
1416                 va_list argp)
1417                 { return(*(int *)0); }
1418
1419 #undef scanw
1420 int     scanw(
1421                 char    *fmt,
1422                 ...)
1423                 { return(*(int *)0); }
1424
1425 #undef wscanw
1426 int     wscanw(
1427                 WINDOW  *win,
1428                 char    *fmt,
1429                 ...)
1430                 { return(*(int *)0); }
1431
1432 #undef mvscanw
1433 int     mvscanw(
1434                 int     y,
1435                 int     x,
1436                 char    *fmt,
1437                 ...)
1438                 { return(*(int *)0); }
1439
1440 #undef mvwscanw
1441 int     mvwscanw(
1442                 WINDOW  *win,
1443                 int     y,
1444                 int     x,
1445                 char    *fmt,
1446                 ...)
1447                 { return(*(int *)0); }
1448
1449 /* ./base/lib_screen.c */
1450
1451 #include <sys/stat.h>
1452 #include <time.h>
1453
1454 #undef getwin
1455 WINDOW  *getwin(
1456                 FILE    *filep)
1457                 { return(*(WINDOW **)0); }
1458
1459 #undef putwin
1460 int     putwin(
1461                 WINDOW  *win,
1462                 FILE    *filep)
1463                 { return(*(int *)0); }
1464
1465 #undef scr_restore
1466 int     scr_restore(
1467                 const char *file)
1468                 { return(*(int *)0); }
1469
1470 #undef scr_dump
1471 int     scr_dump(
1472                 const char *file)
1473                 { return(*(int *)0); }
1474
1475 #undef scr_init
1476 int     scr_init(
1477                 const char *file)
1478                 { return(*(int *)0); }
1479
1480 #undef scr_set
1481 int     scr_set(
1482                 const char *file)
1483                 { return(*(int *)0); }
1484
1485 /* ./base/lib_scroll.c */
1486
1487 #undef _nc_scroll_window
1488 void    _nc_scroll_window(
1489                 WINDOW  *win,
1490                 int const n,
1491                 short const top,
1492                 short const bottom,
1493                 chtype  blank)
1494                 { /* void */ }
1495
1496 #undef wscrl
1497 int     wscrl(
1498                 WINDOW  *win,
1499                 int     n)
1500                 { return(*(int *)0); }
1501
1502 /* ./base/lib_scrollok.c */
1503
1504 #undef scrollok
1505 int     scrollok(
1506                 WINDOW  *win,
1507                 bool    flag)
1508                 { return(*(int *)0); }
1509
1510 /* ./base/lib_scrreg.c */
1511
1512 #undef wsetscrreg
1513 int     wsetscrreg(
1514                 WINDOW  *win,
1515                 int     top,
1516                 int     bottom)
1517                 { return(*(int *)0); }
1518
1519 /* ./base/lib_set_term.c */
1520
1521 #undef set_term
1522 SCREEN  *set_term(
1523                 SCREEN  *screenp)
1524                 { return(*(SCREEN **)0); }
1525
1526 #undef delscreen
1527 void    delscreen(
1528                 SCREEN  *sp)
1529                 { /* void */ }
1530
1531 #undef _nc_setupscreen
1532 int     _nc_setupscreen(
1533                 short   slines,
1534                 short const scolumns,
1535                 FILE    *output)
1536                 { return(*(int *)0); }
1537
1538 #undef _nc_ripoffline
1539 int     _nc_ripoffline(
1540                 int     line,
1541                 int     (*init)(
1542                 WINDOW  *p1,
1543                 int     p2))
1544                 { return(*(int *)0); }
1545
1546 #undef ripoffline
1547 int     ripoffline(
1548                 int     line,
1549                 int     (*init)(
1550                 WINDOW  *p1,
1551                 int     p2))
1552                 { return(*(int *)0); }
1553
1554 /* ./base/lib_slk.c */
1555
1556 #undef _nc_slk_format
1557 int     _nc_slk_format;
1558
1559 #undef _nc_slk_initialize
1560 int     _nc_slk_initialize(
1561                 WINDOW  *stwin,
1562                 int     cols)
1563                 { return(*(int *)0); }
1564
1565 #undef slk_restore
1566 int     slk_restore(void)
1567                 { return(*(int *)0); }
1568
1569 /* ./base/lib_slkatr_set.c */
1570
1571 #undef slk_attr_set
1572 int     slk_attr_set(
1573                 const attr_t attr,
1574                 short   color_pair_number,
1575                 void    *opts)
1576                 { return(*(int *)0); }
1577
1578 /* ./base/lib_slkatrof.c */
1579
1580 #undef slk_attroff
1581 int     slk_attroff(
1582                 const chtype attr)
1583                 { return(*(int *)0); }
1584
1585 /* ./base/lib_slkatron.c */
1586
1587 #undef slk_attron
1588 int     slk_attron(
1589                 const chtype attr)
1590                 { return(*(int *)0); }
1591
1592 /* ./base/lib_slkatrset.c */
1593
1594 #undef slk_attrset
1595 int     slk_attrset(
1596                 const chtype attr)
1597                 { return(*(int *)0); }
1598
1599 /* ./base/lib_slkattr.c */
1600
1601 #undef slk_attr
1602 attr_t  slk_attr(void)
1603                 { return(*(attr_t *)0); }
1604
1605 /* ./base/lib_slkclear.c */
1606
1607 #undef slk_clear
1608 int     slk_clear(void)
1609                 { return(*(int *)0); }
1610
1611 /* ./base/lib_slkcolor.c */
1612
1613 #undef slk_color
1614 int     slk_color(
1615                 short   color_pair_number)
1616                 { return(*(int *)0); }
1617
1618 /* ./base/lib_slkinit.c */
1619
1620 #undef slk_init
1621 int     slk_init(
1622                 int     format)
1623                 { return(*(int *)0); }
1624
1625 /* ./base/lib_slklab.c */
1626
1627 #undef slk_label
1628 char    *slk_label(
1629                 int     n)
1630                 { return(*(char **)0); }
1631
1632 /* ./base/lib_slkrefr.c */
1633
1634 #undef slk_noutrefresh
1635 int     slk_noutrefresh(void)
1636                 { return(*(int *)0); }
1637
1638 #undef slk_refresh
1639 int     slk_refresh(void)
1640                 { return(*(int *)0); }
1641
1642 /* ./base/lib_slkset.c */
1643
1644 #undef slk_set
1645 int     slk_set(
1646                 int     i,
1647                 const char *astr,
1648                 int     format)
1649                 { return(*(int *)0); }
1650
1651 /* ./base/lib_slktouch.c */
1652
1653 #undef slk_touch
1654 int     slk_touch(void)
1655                 { return(*(int *)0); }
1656
1657 /* ./base/lib_touch.c */
1658
1659 #undef is_linetouched
1660 bool    is_linetouched(
1661                 WINDOW  *win,
1662                 int     line)
1663                 { return(*(bool *)0); }
1664
1665 #undef is_wintouched
1666 bool    is_wintouched(
1667                 WINDOW  *win)
1668                 { return(*(bool *)0); }
1669
1670 #undef wtouchln
1671 int     wtouchln(
1672                 WINDOW  *win,
1673                 int     y,
1674                 int     n,
1675                 int     changed)
1676                 { return(*(int *)0); }
1677
1678 /* ./trace/lib_traceatr.c */
1679
1680 #undef _nc_lib_traceatr
1681 void    _nc_lib_traceatr(void)
1682                 { /* void */ }
1683
1684 /* ./trace/lib_tracedmp.c */
1685
1686 #undef _nc_lib_tracedmp
1687 void    _nc_lib_tracedmp(void)
1688                 { /* void */ }
1689
1690 /* ./trace/lib_tracemse.c */
1691
1692 #undef _nc_lib_tracemouse
1693 void    _nc_lib_tracemouse(void)
1694                 { /* void */ }
1695
1696 /* ./tty/lib_tstp.c */
1697
1698 #include <signal.h>
1699 #include <SigAction.h>
1700
1701 #undef _nc_signal_handler
1702 void    _nc_signal_handler(
1703                 bool    enable)
1704                 { /* void */ }
1705
1706 /* ./base/lib_ungetch.c */
1707
1708 #undef ungetch
1709 int     ungetch(
1710                 int     ch)
1711                 { return(*(int *)0); }
1712
1713 /* ./tty/lib_vidattr.c */
1714
1715 #undef vidputs
1716 int     vidputs(
1717                 attr_t  newmode,
1718                 int     (*outc)(
1719                 int     p1))
1720                 { return(*(int *)0); }
1721
1722 #undef vidattr
1723 int     vidattr(
1724                 attr_t  newmode)
1725                 { return(*(int *)0); }
1726
1727 #undef termattrs
1728 chtype  termattrs(void)
1729                 { return(*(chtype *)0); }
1730
1731 /* ./base/lib_vline.c */
1732
1733 #undef wvline
1734 int     wvline(
1735                 WINDOW  *win,
1736                 chtype  ch,
1737                 int     n)
1738                 { return(*(int *)0); }
1739
1740 /* ./base/lib_wattroff.c */
1741
1742 #undef wattr_off
1743 int     wattr_off(
1744                 WINDOW  *win,
1745                 attr_t  at,
1746                 void    *opts)
1747                 { return(*(int *)0); }
1748
1749 /* ./base/lib_wattron.c */
1750
1751 #undef wattr_on
1752 int     wattr_on(
1753                 WINDOW  *win,
1754                 attr_t  at,
1755                 void    *opts)
1756                 { return(*(int *)0); }
1757
1758 /* ./base/lib_winch.c */
1759
1760 #undef winch
1761 chtype  winch(
1762                 WINDOW  *win)
1763                 { return(*(chtype *)0); }
1764
1765 /* ./base/lib_window.c */
1766
1767 #undef _nc_synchook
1768 void    _nc_synchook(
1769                 WINDOW  *win)
1770                 { /* void */ }
1771
1772 #undef mvderwin
1773 int     mvderwin(
1774                 WINDOW  *win,
1775                 int     y,
1776                 int     x)
1777                 { return(*(int *)0); }
1778
1779 #undef syncok
1780 int     syncok(
1781                 WINDOW  *win,
1782                 bool    bf)
1783                 { return(*(int *)0); }
1784
1785 #undef wsyncup
1786 void    wsyncup(
1787                 WINDOW  *win)
1788                 { /* void */ }
1789
1790 #undef wsyncdown
1791 void    wsyncdown(
1792                 WINDOW  *win)
1793                 { /* void */ }
1794
1795 #undef wcursyncup
1796 void    wcursyncup(
1797                 WINDOW  *win)
1798                 { /* void */ }
1799
1800 #undef dupwin
1801 WINDOW  *dupwin(
1802                 WINDOW  *win)
1803                 { return(*(WINDOW **)0); }
1804
1805 /* ./base/nc_panel.c */
1806
1807 #undef _nc_panelhook
1808 struct panelhook *_nc_panelhook(void)
1809                 { return(*(struct panelhook **)0); }
1810
1811 /* ./base/safe_sprintf.c */
1812
1813 #undef _nc_printf_string
1814 char    *_nc_printf_string(
1815                 const char *fmt,
1816                 va_list ap)
1817                 { return(*(char **)0); }
1818
1819 /* ./tty/tty_update.c */
1820
1821 #include <sys/time.h>
1822
1823 #undef doupdate
1824 int     doupdate(void)
1825                 { return(*(int *)0); }
1826
1827 #undef _nc_outstr
1828 void    _nc_outstr(
1829                 const char *str)
1830                 { /* void */ }
1831
1832 #undef _nc_scrolln
1833 int     _nc_scrolln(
1834                 int     n,
1835                 int     top,
1836                 int     bot,
1837                 int     maxy)
1838                 { return(*(int *)0); }
1839
1840 #undef _nc_screen_resume
1841 void    _nc_screen_resume(void)
1842                 { /* void */ }
1843
1844 #undef _nc_screen_init
1845 void    _nc_screen_init(void)
1846                 { /* void */ }
1847
1848 #undef _nc_screen_wrap
1849 void    _nc_screen_wrap(void)
1850                 { /* void */ }
1851
1852 #undef _nc_do_xmc_glitch
1853 void    _nc_do_xmc_glitch(
1854                 attr_t  previous)
1855                 { /* void */ }
1856
1857 /* ./base/memmove.c */
1858
1859 #undef _nc_memmove
1860 void    _nc_memmove(void)
1861                 { /* void */ }
1862
1863 /* ./base/sigaction.c */
1864
1865 #undef _nc_sigaction
1866 void    _nc_sigaction(void)
1867                 { /* void */ }
1868
1869 /* ./base/vsscanf.c */
1870
1871 #undef _nc_vsscanf
1872 void    _nc_vsscanf(void)
1873                 { /* void */ }
1874
1875 /* ./base/define_key.c */
1876
1877 #undef define_key
1878 int     define_key(
1879                 char    *str,
1880                 int     keycode)
1881                 { return(*(int *)0); }
1882
1883 /* ./expanded.c */
1884
1885 #undef _nc_toggle_attr_on
1886 void    _nc_toggle_attr_on(
1887                 attr_t  *S,
1888                 attr_t  at)
1889                 { /* void */ }
1890
1891 #undef _nc_toggle_attr_off
1892 void    _nc_toggle_attr_off(
1893                 attr_t  *S,
1894                 attr_t  at)
1895                 { /* void */ }
1896
1897 #undef _nc_can_clear_with
1898 int     _nc_can_clear_with(
1899                 chtype  ch)
1900                 { return(*(int *)0); }
1901
1902 #undef _nc_DelCharCost
1903 int     _nc_DelCharCost(
1904                 int     count)
1905                 { return(*(int *)0); }
1906
1907 #undef _nc_InsCharCost
1908 int     _nc_InsCharCost(
1909                 int     count)
1910                 { return(*(int *)0); }
1911
1912 #undef _nc_UpdateAttrs
1913 void    _nc_UpdateAttrs(
1914                 chtype  c)
1915                 { /* void */ }
1916
1917 /* ./base/keybound.c */
1918
1919 #undef keybound
1920 char    *keybound(
1921                 int     code,
1922                 int     count)
1923                 { return(*(char **)0); }
1924
1925 /* ./base/keyok.c */
1926
1927 #undef keyok
1928 int     keyok(
1929                 int     c,
1930                 bool    flag)
1931                 { return(*(int *)0); }
1932
1933 /* ./base/lib_dft_fgbg.c */
1934
1935 #undef use_default_colors
1936 int     use_default_colors(void)
1937                 { return(*(int *)0); }
1938
1939 /* ./base/lib_freeall.c */
1940
1941 #include <term_entry.h>
1942
1943 #undef _nc_freeall
1944 void    _nc_freeall(void)
1945                 { /* void */ }
1946
1947 /* ./tinfo/lib_print.c */
1948
1949 #undef mcprint
1950 int     mcprint(
1951                 char    *data,
1952                 int     len)
1953                 { return(*(int *)0); }
1954
1955 /* ./base/resizeterm.c */
1956
1957 #undef resizeterm
1958 int     resizeterm(
1959                 int     ToLines,
1960                 int     ToCols)
1961                 { return(*(int *)0); }
1962
1963 /* ./trace/trace_xnames.c */
1964
1965 #undef _nc_trace_xnames
1966 void    _nc_trace_xnames(
1967                 TERMTYPE *tp)
1968                 { /* void */ }
1969
1970 /* ./base/tries.c */
1971
1972 #undef _nc_expand_try
1973 char    *_nc_expand_try(
1974                 struct tries *tree,
1975                 unsigned short code,
1976                 int     *count,
1977                 size_t  len)
1978                 { return(*(char **)0); }
1979
1980 #undef _nc_remove_key
1981 int     _nc_remove_key(
1982                 struct tries **tree,
1983                 unsigned short code)
1984                 { return(*(int *)0); }
1985
1986 #undef _nc_remove_string
1987 int     _nc_remove_string(
1988                 struct tries **tree,
1989                 char    *string)
1990                 { return(*(int *)0); }
1991
1992 /* ./base/version.c */
1993
1994 #undef curses_version
1995 const char *curses_version(void)
1996                 { return(*(const char **)0); }
1997
1998 /* ./base/wresize.c */
1999
2000 #undef wresize
2001 int     wresize(
2002                 WINDOW  *win,
2003                 int     ToLines,
2004                 int     ToCols)
2005                 { return(*(int *)0); }
2006
2007 /* ./tinfo/access.c */
2008
2009 #undef _nc_access
2010 int     _nc_access(
2011                 const char *path,
2012                 int     mode)
2013                 { return(*(int *)0); }
2014
2015 /* ./tinfo/add_tries.c */
2016
2017 #undef _nc_add_to_try
2018 void    _nc_add_to_try(
2019                 struct tries **tree,
2020                 char    *str,
2021                 unsigned short code)
2022                 { /* void */ }
2023
2024 /* ./tinfo/alloc_entry.c */
2025
2026 #undef _nc_init_entry
2027 void    _nc_init_entry(
2028                 TERMTYPE *const tp)
2029                 { /* void */ }
2030
2031 #undef _nc_copy_entry
2032 ENTRY   *_nc_copy_entry(
2033                 ENTRY   *oldp)
2034                 { return(*(ENTRY **)0); }
2035
2036 #undef _nc_save_str
2037 char    *_nc_save_str(
2038                 const char *const string)
2039                 { return(*(char **)0); }
2040
2041 #undef _nc_wrap_entry
2042 void    _nc_wrap_entry(
2043                 ENTRY   *const ep)
2044                 { /* void */ }
2045
2046 #undef _nc_merge_entry
2047 void    _nc_merge_entry(
2048                 TERMTYPE *const to,
2049                 TERMTYPE *const from)
2050                 { /* void */ }
2051
2052 /* ./tinfo/alloc_ttype.c */
2053
2054 #undef _nc_align_termtype
2055 void    _nc_align_termtype(
2056                 TERMTYPE *to,
2057                 TERMTYPE *from)
2058                 { /* void */ }
2059
2060 #undef _nc_copy_termtype
2061 void    _nc_copy_termtype(
2062                 TERMTYPE *dst,
2063                 TERMTYPE *src)
2064                 { /* void */ }
2065
2066 /* ./tinfo/captoinfo.c */
2067
2068 #undef _nc_captoinfo
2069 char    *_nc_captoinfo(
2070                  const char *cap,
2071                  const char *s,
2072                 int const parametrized)
2073                 { return(*(char **)0); }
2074
2075 #undef _nc_infotocap
2076 char    *_nc_infotocap(
2077                  const char *cap,
2078                  const char *str,
2079                 int const parametrized)
2080                 { return(*(char **)0); }
2081
2082 /* ./codes.c */
2083
2084 #undef boolcodes
2085 char    *const boolcodes[] = {0};
2086 #undef numcodes
2087 char    *const numcodes[] = {0};
2088 #undef strcodes
2089 char    *const strcodes[] = {0};
2090
2091 /* ./comp_captab.c */
2092
2093 #include <ncurses_cfg.h>
2094
2095 #undef _nc_info_hash_table
2096 const struct name_table_entry *const _nc_info_hash_table[995] = {0};
2097 #undef _nc_cap_hash_table
2098 const struct name_table_entry *const _nc_cap_hash_table[995] = {0};
2099 #undef _nc_capalias_table
2100 const struct alias _nc_capalias_table[] = {0};
2101 #undef _nc_infoalias_table
2102 const struct alias _nc_infoalias_table[] = {0};
2103
2104 #undef _nc_get_table
2105 const struct name_table_entry *_nc_get_table(
2106                 bool    termcap)
2107                 { return(*(const struct name_table_entry **)0); }
2108
2109 #undef _nc_get_hash_table
2110 const struct name_table_entry *const *_nc_get_hash_table(
2111                 bool    termcap)
2112                 { return(*(const struct name_table_entry **)0); }
2113
2114 /* ./tinfo/comp_error.c */
2115
2116 #undef _nc_suppress_warnings
2117 bool    _nc_suppress_warnings;
2118 #undef _nc_curr_line
2119 int     _nc_curr_line;
2120 #undef _nc_curr_col
2121 int     _nc_curr_col;
2122
2123 #undef _nc_set_source
2124 void    _nc_set_source(
2125                 const char *const name)
2126                 { /* void */ }
2127
2128 #undef _nc_set_type
2129 void    _nc_set_type(
2130                 const char *const name)
2131                 { /* void */ }
2132
2133 #undef _nc_get_type
2134 void    _nc_get_type(
2135                 char    *name)
2136                 { /* void */ }
2137
2138 #undef _nc_warning
2139 void    _nc_warning(
2140                 const char *const fmt,
2141                 ...)
2142                 { /* void */ }
2143
2144 #undef _nc_err_abort
2145 void    _nc_err_abort(
2146                 const char *const fmt,
2147                 ...)
2148                 { /* void */ }
2149
2150 #undef _nc_syserr_abort
2151 void    _nc_syserr_abort(
2152                 const char *const fmt,
2153                 ...)
2154                 { /* void */ }
2155
2156 /* ./tinfo/comp_expand.c */
2157
2158 #undef _nc_tic_expand
2159 char    *_nc_tic_expand(
2160                 const char *srcp,
2161                 bool    tic_format,
2162                 int     numbers)
2163                 { return(*(char **)0); }
2164
2165 /* ./tinfo/comp_hash.c */
2166
2167 #include <hashsize.h>
2168
2169 #undef _nc_find_entry
2170 struct name_table_entry const *_nc_find_entry(
2171                 const char *string,
2172                 const struct name_table_entry *const *hash_table)
2173                 { return(*(struct name_table_entry const **)0); }
2174
2175 #undef _nc_find_type_entry
2176 struct name_table_entry const *_nc_find_type_entry(
2177                 const char *string,
2178                 int     type,
2179                 const struct name_table_entry *table)
2180                 { return(*(struct name_table_entry const **)0); }
2181
2182 /* ./tinfo/comp_parse.c */
2183
2184 #undef _nc_check_termtype
2185 void    (*_nc_check_termtype)(
2186                 TERMTYPE *p1);
2187 #undef _nc_head
2188 ENTRY   *_nc_head;
2189 #undef _nc_tail
2190 ENTRY   *_nc_tail;
2191
2192 #undef _nc_free_entries
2193 void    _nc_free_entries(
2194                 ENTRY   *head)
2195                 { /* void */ }
2196
2197 #undef _nc_entry_match
2198 bool    _nc_entry_match(
2199                 char    *n1,
2200                 char    *n2)
2201                 { return(*(bool *)0); }
2202
2203 #undef _nc_read_entry_source
2204 void    _nc_read_entry_source(
2205                 FILE    *fp,
2206                 char    *buf,
2207                 int     literal,
2208                 bool    silent,
2209                 bool    (*hook)(
2210                 ENTRY   *p1))
2211                 { /* void */ }
2212
2213 #undef _nc_resolve_uses
2214 int     _nc_resolve_uses(void)
2215                 { return(*(int *)0); }
2216
2217 /* ./tinfo/comp_scan.c */
2218
2219 #undef _nc_syntax
2220 int     _nc_syntax;
2221 #undef _nc_curr_file_pos
2222 long    _nc_curr_file_pos;
2223 #undef _nc_comment_start
2224 long    _nc_comment_start;
2225 #undef _nc_comment_end
2226 long    _nc_comment_end;
2227 #undef _nc_start_line
2228 long    _nc_start_line;
2229
2230 #undef _nc_get_token
2231 int     _nc_get_token(void)
2232                 { return(*(int *)0); }
2233
2234 #undef _nc_trans_string
2235 char    _nc_trans_string(
2236                 char    *ptr)
2237                 { return(*(char *)0); }
2238
2239 #undef _nc_push_token
2240 void    _nc_push_token(
2241                 int     tokclass)
2242                 { /* void */ }
2243
2244 #undef _nc_panic_mode
2245 void    _nc_panic_mode(
2246                 char    ch)
2247                 { /* void */ }
2248
2249 #undef _nc_reset_input
2250 void    _nc_reset_input(
2251                 FILE    *fp,
2252                 char    *buf)
2253                 { /* void */ }
2254
2255 /* ./tinfo/doalloc.c */
2256
2257 #undef _nc_doalloc
2258 void    *_nc_doalloc(
2259                 void    *oldp,
2260                 size_t  amount)
2261                 { return(*(void **)0); }
2262
2263 /* ./fallback.c */
2264
2265 #undef _nc_fallback
2266 const TERMTYPE *_nc_fallback(
2267                 const char *name)
2268                 { return(*(const TERMTYPE **)0); }
2269
2270 /* ./tinfo/free_ttype.c */
2271
2272 #undef _nc_free_termtype
2273 void    _nc_free_termtype(
2274                 TERMTYPE *ptr)
2275                 { /* void */ }
2276
2277 #undef _nc_user_definable
2278 bool    _nc_user_definable;
2279
2280 #undef use_extended_names
2281 int     use_extended_names(
2282                 bool    flag)
2283                 { return(*(int *)0); }
2284
2285 /* ./tinfo/getenv_num.c */
2286
2287 #undef _nc_getenv_num
2288 int     _nc_getenv_num(
2289                 const char *name)
2290                 { return(*(int *)0); }
2291
2292 /* ./tinfo/home_terminfo.c */
2293
2294 #undef _nc_home_terminfo
2295 char    *_nc_home_terminfo(void)
2296                 { return(*(char **)0); }
2297
2298 /* ./tinfo/init_keytry.c */
2299
2300 #if 0
2301
2302 #include <init_keytry.h>
2303
2304 #endif
2305
2306 #undef _nc_tinfo_fkeysf
2307 struct tinfo_fkeys *_nc_tinfo_fkeysf(void)
2308                 { return(*(struct tinfo_fkeys **)0); }
2309
2310 #undef _nc_init_keytry
2311 void    _nc_init_keytry(void)
2312                 { /* void */ }
2313
2314 /* ./tinfo/lib_acs.c */
2315
2316 #undef acs_map
2317 chtype  acs_map[128 ];
2318
2319 #undef _nc_init_acs
2320 void    _nc_init_acs(void)
2321                 { /* void */ }
2322
2323 /* ./tinfo/lib_baudrate.c */
2324
2325 #include <termcap.h>
2326
2327 struct speed {
2328         speed_t s;
2329         int sp;
2330 };
2331
2332 #undef _nc_baudrate
2333 int     _nc_baudrate(
2334                 int     OSpeed)
2335                 { return(*(int *)0); }
2336
2337 #undef _nc_ospeed
2338 int     _nc_ospeed(
2339                 int     BaudRate)
2340                 { return(*(int *)0); }
2341
2342 #undef baudrate
2343 int     baudrate(void)
2344                 { return(*(int *)0); }
2345
2346 /* ./tinfo/lib_cur_term.c */
2347
2348 #undef cur_term
2349 TERMINAL *cur_term;
2350
2351 #undef set_curterm
2352 TERMINAL *set_curterm(
2353                 TERMINAL *termp)
2354                 { return(*(TERMINAL **)0); }
2355
2356 #undef del_curterm
2357 int     del_curterm(
2358                 TERMINAL *termp)
2359                 { return(*(int *)0); }
2360
2361 /* ./tinfo/lib_data.c */
2362
2363 #undef stdscr
2364 WINDOW  *stdscr;
2365 #undef curscr
2366 WINDOW  *curscr;
2367 #undef newscr
2368 WINDOW  *newscr;
2369 #undef _nc_screen_chain
2370 SCREEN  *_nc_screen_chain;
2371 #undef SP
2372 SCREEN  *SP;
2373
2374 /* ./tinfo/lib_has_cap.c */
2375
2376 #undef has_ic
2377 bool    has_ic(void)
2378                 { return(*(bool *)0); }
2379
2380 #undef has_il
2381 bool    has_il(void)
2382                 { return(*(bool *)0); }
2383
2384 /* ./tinfo/lib_kernel.c */
2385
2386 #undef erasechar
2387 char    erasechar(void)
2388                 { return(*(char *)0); }
2389
2390 #undef killchar
2391 char    killchar(void)
2392                 { return(*(char *)0); }
2393
2394 #undef flushinp
2395 int     flushinp(void)
2396                 { return(*(int *)0); }
2397
2398 /* ./lib_keyname.c */
2399
2400 #include <stdlib.h>
2401 #include <string.h>
2402 #include <curses.h>
2403
2404 #undef _nc_key_names
2405 const struct kn _nc_key_names[] = {0};
2406
2407 #undef keyname
2408 char    *keyname(
2409                 int     c)
2410                 { return(*(char **)0); }
2411
2412 /* ./tinfo/lib_longname.c */
2413
2414 #undef longname
2415 char    *longname(void)
2416                 { return(*(char **)0); }
2417
2418 /* ./tinfo/lib_napms.c */
2419
2420 #undef napms
2421 int     napms(
2422                 int     ms)
2423                 { return(*(int *)0); }
2424
2425 /* ./tinfo/lib_options.c */
2426
2427 #undef idlok
2428 int     idlok(
2429                 WINDOW  *win,
2430                 bool    flag)
2431                 { return(*(int *)0); }
2432
2433 #undef idcok
2434 void    idcok(
2435                 WINDOW  *win,
2436                 bool    flag)
2437                 { /* void */ }
2438
2439 #undef halfdelay
2440 int     halfdelay(
2441                 int     t)
2442                 { return(*(int *)0); }
2443
2444 #undef nodelay
2445 int     nodelay(
2446                 WINDOW  *win,
2447                 bool    flag)
2448                 { return(*(int *)0); }
2449
2450 #undef notimeout
2451 int     notimeout(
2452                 WINDOW  *win,
2453                 bool    f)
2454                 { return(*(int *)0); }
2455
2456 #undef wtimeout
2457 void    wtimeout(
2458                 WINDOW  *win,
2459                 int     delay)
2460                 { /* void */ }
2461
2462 #undef keypad
2463 int     keypad(
2464                 WINDOW  *win,
2465                 bool    flag)
2466                 { return(*(int *)0); }
2467
2468 #undef meta
2469 int     meta(
2470                 WINDOW  *win,
2471                 bool    flag)
2472                 { return(*(int *)0); }
2473
2474 #undef curs_set
2475 int     curs_set(
2476                 int     vis)
2477                 { return(*(int *)0); }
2478
2479 #undef typeahead
2480 int     typeahead(
2481                 int     fd)
2482                 { return(*(int *)0); }
2483
2484 #undef has_key
2485 int     has_key(
2486                 int     keycode)
2487                 { return(*(int *)0); }
2488
2489 #undef _nc_keypad
2490 int     _nc_keypad(
2491                 bool    flag)
2492                 { return(*(int *)0); }
2493
2494 /* ./tinfo/lib_raw.c */
2495
2496 #undef raw
2497 int     raw(void)
2498                 { return(*(int *)0); }
2499
2500 #undef cbreak
2501 int     cbreak(void)
2502                 { return(*(int *)0); }
2503
2504 #undef qiflush
2505 void    qiflush(void)
2506                 { /* void */ }
2507
2508 #undef noraw
2509 int     noraw(void)
2510                 { return(*(int *)0); }
2511
2512 #undef nocbreak
2513 int     nocbreak(void)
2514                 { return(*(int *)0); }
2515
2516 #undef noqiflush
2517 void    noqiflush(void)
2518                 { /* void */ }
2519
2520 #undef intrflush
2521 int     intrflush(
2522                 WINDOW  *win,
2523                 bool    flag)
2524                 { return(*(int *)0); }
2525
2526 /* ./tinfo/lib_setup.c */
2527
2528 #include <sys/ioctl.h>
2529
2530 #undef use_env
2531 void    use_env(
2532                 bool    f)
2533                 { /* void */ }
2534
2535 #undef LINES
2536 int     LINES;
2537 #undef COLS
2538 int     COLS;
2539 #undef TABSIZE
2540 int     TABSIZE;
2541
2542 #undef _nc_update_screensize
2543 void    _nc_update_screensize(void)
2544                 { /* void */ }
2545
2546 #undef ttytype
2547 char    ttytype[256 ];
2548
2549 #undef setupterm
2550 int     setupterm(
2551                 char    *tname,
2552                 int     Filedes,
2553                 int     *errret)
2554                 { return(*(int *)0); }
2555
2556 /* ./tinfo/lib_termcap.c */
2557
2558 #undef UP
2559 char    *UP;
2560 #undef BC
2561 char    *BC;
2562
2563 #undef tgetent
2564 int     tgetent(
2565                 char    *bufp,
2566                 const char *name)
2567                 { return(*(int *)0); }
2568
2569 #if 0
2570
2571 #include <capdefaults.c>
2572
2573 #endif
2574
2575 #undef tgetflag
2576 int     tgetflag(
2577                 char    *id)
2578                 { return(*(int *)0); }
2579
2580 #undef tgetnum
2581 int     tgetnum(
2582                 char    *id)
2583                 { return(*(int *)0); }
2584
2585 #undef tgetstr
2586 char    *tgetstr(
2587                 char    *id,
2588                 char    **area)
2589                 { return(*(char **)0); }
2590
2591 #undef tgoto
2592 char    *tgoto(
2593                 const char *string,
2594                 int     x,
2595                 int     y)
2596                 { return(*(char **)0); }
2597
2598 /* ./tinfo/lib_termname.c */
2599
2600 #undef termname
2601 char    *termname(void)
2602                 { return(*(char **)0); }
2603
2604 /* ./tinfo/lib_ti.c */
2605
2606 #undef tigetflag
2607 int     tigetflag(
2608                 char    *str)
2609                 { return(*(int *)0); }
2610
2611 #undef tigetnum
2612 int     tigetnum(
2613                 char    *str)
2614                 { return(*(int *)0); }
2615
2616 #undef tigetstr
2617 char    *tigetstr(
2618                 char    *str)
2619                 { return(*(char **)0); }
2620
2621 /* ./tinfo/lib_tparm.c */
2622
2623 typedef union {
2624         unsigned int    num;
2625         char           *str;
2626 } stack_frame;
2627
2628 #undef tparm
2629 char    *tparm(
2630                 char    *string,
2631                 ...)
2632                 { return(*(char **)0); }
2633
2634 /* ./tinfo/lib_tputs.c */
2635
2636 #undef PC
2637 char    PC;
2638 #undef ospeed
2639 speed_t ospeed;
2640 #undef _nc_nulls_sent
2641 int     _nc_nulls_sent;
2642
2643 #undef delay_output
2644 int     delay_output(
2645                 int     ms)
2646                 { return(*(int *)0); }
2647
2648 #undef _nc_outch
2649 int     _nc_outch(
2650                 int     ch)
2651                 { return(*(int *)0); }
2652
2653 #undef putp
2654 int     putp(
2655                 const char *string)
2656                 { return(*(int *)0); }
2657
2658 #undef tputs
2659 int     tputs(
2660                 const char *string,
2661                 int     affcnt,
2662                 int     (*outc)(
2663                 int     p1))
2664                 { return(*(int *)0); }
2665
2666 /* ./trace/lib_trace.c */
2667
2668 #include <fcntl.h>
2669
2670 #undef _nc_tracing
2671 unsigned _nc_tracing;
2672
2673 #undef trace
2674 void    trace(
2675                 const unsigned int tracelevel)
2676                 { /* void */ }
2677
2678 #undef _nc_visbuf2
2679 const char *_nc_visbuf2(
2680                 int     bufnum,
2681                 const char *buf)
2682                 { return(*(const char **)0); }
2683
2684 #undef _nc_visbuf
2685 const char *_nc_visbuf(
2686                 const char *buf)
2687                 { return(*(const char **)0); }
2688
2689 /* ./trace/lib_tracebits.c */
2690
2691 #undef _nc_tracebits
2692 char    *_nc_tracebits(void)
2693                 { return(*(char **)0); }
2694
2695 /* ./trace/lib_tracechr.c */
2696
2697 #undef _tracechar
2698 char    *_tracechar(
2699                 const unsigned char ch)
2700                 { return(*(char **)0); }
2701
2702 /* ./tinfo/lib_ttyflags.c */
2703
2704 #undef _nc_get_tty_mode
2705 int     _nc_get_tty_mode(
2706                 struct termios *buf)
2707                 { return(*(int *)0); }
2708
2709 #undef _nc_set_tty_mode
2710 int     _nc_set_tty_mode(
2711                 struct termios *buf)
2712                 { return(*(int *)0); }
2713
2714 #undef def_shell_mode
2715 int     def_shell_mode(void)
2716                 { return(*(int *)0); }
2717
2718 #undef def_prog_mode
2719 int     def_prog_mode(void)
2720                 { return(*(int *)0); }
2721
2722 #undef reset_prog_mode
2723 int     reset_prog_mode(void)
2724                 { return(*(int *)0); }
2725
2726 #undef reset_shell_mode
2727 int     reset_shell_mode(void)
2728                 { return(*(int *)0); }
2729
2730 #undef savetty
2731 int     savetty(void)
2732                 { return(*(int *)0); }
2733
2734 #undef resetty
2735 int     resetty(void)
2736                 { return(*(int *)0); }
2737
2738 /* ./tty/lib_twait.c */
2739
2740 #undef _nc_timed_wait
2741 int     _nc_timed_wait(
2742                 int     mode,
2743                 int     milliseconds,
2744                 int     *timeleft)
2745                 { return(*(int *)0); }
2746
2747 /* ./tinfo/name_match.c */
2748
2749 #undef _nc_first_name
2750 char    *_nc_first_name(
2751                 const char *const sp)
2752                 { return(*(char **)0); }
2753
2754 #undef _nc_name_match
2755 int     _nc_name_match(
2756                 const char *const namelst,
2757                 const char *const name,
2758                 const char *const delim)
2759                 { return(*(int *)0); }
2760
2761 /* ./names.c */
2762
2763 #undef boolnames
2764 char    *const boolnames[] = {0};
2765 #undef boolfnames
2766 char    *const boolfnames[] = {0};
2767 #undef numnames
2768 char    *const numnames[] = {0};
2769 #undef numfnames
2770 char    *const numfnames[] = {0};
2771 #undef strnames
2772 char    *const strnames[] = {0};
2773 #undef strfnames
2774 char    *const strfnames[] = {0};
2775
2776 /* ./tinfo/parse_entry.c */
2777 #undef _nc_curr_token
2778 struct token _nc_curr_token;
2779
2780 #undef _nc_parse_entry
2781 int     _nc_parse_entry(
2782                 struct entry *entryp,
2783                 int     literal,
2784                 bool    silent)
2785                 { return(*(int *)0); }
2786
2787 #undef _nc_capcmp
2788 int     _nc_capcmp(
2789                 const char *s,
2790                 const char *t)
2791                 { return(*(int *)0); }
2792
2793 typedef struct {const char *from; const char *to;} assoc;
2794
2795 /* ./tinfo/read_entry.c */
2796
2797 #undef _nc_tic_dir
2798 const char *_nc_tic_dir(
2799                 const char *path)
2800                 { return(*(const char **)0); }
2801
2802 #undef _nc_keep_tic_dir
2803 void    _nc_keep_tic_dir(
2804                 const char *path)
2805                 { /* void */ }
2806
2807 #undef _nc_read_file_entry
2808 int     _nc_read_file_entry(
2809                 const char *const filename,
2810                 TERMTYPE *ptr)
2811                 { return(*(int *)0); }
2812
2813 #undef _nc_read_entry
2814 int     _nc_read_entry(
2815                 const char *const tn,
2816                 char    *const filename,
2817                 TERMTYPE *const tp)
2818                 { return(*(int *)0); }
2819
2820 /* ./tinfo/read_termcap.c */
2821
2822 #undef _nc_read_termcap
2823 void    _nc_read_termcap(void)
2824                 { /* void */ }
2825
2826 /* ./tinfo/setbuf.c */
2827
2828 #undef _nc_set_buffer
2829 void    _nc_set_buffer(
2830                 FILE    *ofp,
2831                 bool    buffered)
2832                 { /* void */ }
2833
2834 /* ./trace/trace_buf.c */
2835
2836 typedef struct {
2837         char *text;
2838         size_t size;
2839 } LIST;
2840
2841 #undef _nc_trace_buf
2842 char    *_nc_trace_buf(
2843                 int     bufnum,
2844                 size_t  want)
2845                 { return(*(char **)0); }
2846
2847 /* ./trace/trace_tries.c */
2848
2849 #undef _nc_trace_tries
2850 void    _nc_trace_tries(
2851                 struct tries *tree)
2852                 { /* void */ }
2853
2854 /* ./unctrl.c */
2855
2856 #undef unctrl
2857 char    *unctrl(
2858                  chtype ch)
2859                 { return(*(char **)0); }
2860
2861 /* ./tinfo/write_entry.c */
2862
2863 #undef _nc_set_writedir
2864 void    _nc_set_writedir(
2865                 char    *dir)
2866                 { /* void */ }
2867
2868 #undef _nc_write_entry
2869 void    _nc_write_entry(
2870                 TERMTYPE *const tp)
2871                 { /* void */ }
2872
2873 #undef _nc_tic_written
2874 int     _nc_tic_written(void)
2875                 { return(*(int *)0); }