ncurses/llib-lncurses

   1 /****************************************************************************
   2  * Copyright (c) 1998-2003,2004 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 1996-2003,2004                                 *
  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 #undef _nc_linedump
  46 void    _nc_linedump(void)
  47                 { /* void */ }
  48
  49 /* ./tty/hashmap.c */
  50
  51 #undef _nc_hash_map
  52 void    _nc_hash_map(void)
  53                 { /* void */ }
  54
  55 #undef _nc_make_oldhash
  56 void    _nc_make_oldhash(
  57                 int     i)
  58                 { /* void */ }
  59
  60 #undef _nc_scroll_oldhash
  61 void    _nc_scroll_oldhash(
  62                 int     n,
  63                 int     top,
  64                 int     bot)
  65                 { /* void */ }
  66
  67 /* ./base/lib_addch.c */
  68
  69 #include <ctype.h>
  70
  71 #undef _nc_render
  72 chtype  _nc_render(
  73                 WINDOW  *win,
  74                 chtype  ch)
  75                 { return(*(chtype *)0); }
  76
  77 #undef _nc_waddch_nosync
  78 int     _nc_waddch_nosync(
  79                 WINDOW  *win,
  80                 const chtype c)
  81                 { return(*(int *)0); }
  82
  83 #undef waddch
  84 int     waddch(
  85                 WINDOW  *win,
  86                 const chtype ch)
  87                 { return(*(int *)0); }
  88
  89 #undef wechochar
  90 int     wechochar(
  91                 WINDOW  *win,
  92                 const chtype ch)
  93                 { return(*(int *)0); }
  94
  95 /* ./base/lib_addstr.c */
  96
  97 #undef waddnstr
  98 int     waddnstr(
  99                 WINDOW  *win,
 100                 const char *astr,
 101                 int     n)
 102                 { return(*(int *)0); }
 103
 104 #undef waddchnstr
 105 int     waddchnstr(
 106                 WINDOW  *win,
 107                 const chtype *astr,
 108                 int     n)
 109                 { return(*(int *)0); }
 110
 111 /* ./base/lib_beep.c */
 112
 113 #undef beep
 114 int     beep(void)
 115                 { return(*(int *)0); }
 116
 117 /* ./base/lib_bkgd.c */
 118
 119 #undef wbkgdset
 120 void    wbkgdset(
 121                 WINDOW  *win,
 122                 chtype  ch)
 123                 { /* void */ }
 124
 125 #undef wbkgd
 126 int     wbkgd(
 127                 WINDOW  *win,
 128                 chtype  ch)
 129                 { return(*(int *)0); }
 130
 131 /* ./base/lib_box.c */
 132
 133 #undef wborder
 134 int     wborder(
 135                 WINDOW  *win,
 136                 chtype  ls,
 137                 chtype  rs,
 138                 chtype  ts,
 139                 chtype  bs,
 140                 chtype  tl,
 141                 chtype  tr,
 142                 chtype  bl,
 143                 chtype  br)
 144                 { return(*(int *)0); }
 145
 146 /* ./base/lib_chgat.c */
 147
 148 #undef wchgat
 149 int     wchgat(
 150                 WINDOW  *win,
 151                 int     n,
 152                 attr_t  attr,
 153                 short   color,
 154                 const void *opts)
 155                 { return(*(int *)0); }
 156
 157 /* ./base/lib_clear.c */
 158
 159 #undef wclear
 160 int     wclear(
 161                 WINDOW  *win)
 162                 { return(*(int *)0); }
 163
 164 /* ./base/lib_clearok.c */
 165
 166 #undef clearok
 167 int     clearok(
 168                 WINDOW  *win,
 169                 NCURSES_BOOL flag)
 170                 { return(*(int *)0); }
 171
 172 /* ./base/lib_clrbot.c */
 173
 174 #undef wclrtobot
 175 int     wclrtobot(
 176                 WINDOW  *win)
 177                 { return(*(int *)0); }
 178
 179 /* ./base/lib_clreol.c */
 180
 181 #undef wclrtoeol
 182 int     wclrtoeol(
 183                 WINDOW  *win)
 184                 { return(*(int *)0); }
 185
 186 /* ./base/lib_color.c */
 187
 188 #include <tic.h>
 189
 190 #undef COLOR_PAIRS
 191 int     COLOR_PAIRS;
 192 #undef COLORS
 193 int     COLORS;
 194
 195 #undef _nc_reset_colors
 196 NCURSES_BOOL _nc_reset_colors(void)
 197                 { return(*(NCURSES_BOOL *)0); }
 198
 199 #undef start_color
 200 int     start_color(void)
 201                 { return(*(int *)0); }
 202
 203 #undef init_pair
 204 int     init_pair(
 205                 short   pair,
 206                 short   f,
 207                 short   b)
 208                 { return(*(int *)0); }
 209
 210 #undef init_color
 211 int     init_color(
 212                 short   color,
 213                 short   r,
 214                 short   g,
 215                 short   b)
 216                 { return(*(int *)0); }
 217
 218 #undef can_change_color
 219 NCURSES_BOOL can_change_color(void)
 220                 { return(*(NCURSES_BOOL *)0); }
 221
 222 #undef has_colors
 223 NCURSES_BOOL has_colors(void)
 224                 { return(*(NCURSES_BOOL *)0); }
 225
 226 #undef color_content
 227 int     color_content(
 228                 short   color,
 229                 short   *r,
 230                 short   *g,
 231                 short   *b)
 232                 { return(*(int *)0); }
 233
 234 #undef pair_content
 235 int     pair_content(
 236                 short   pair,
 237                 short   *f,
 238                 short   *b)
 239                 { return(*(int *)0); }
 240
 241 #undef _nc_do_color
 242 void    _nc_do_color(
 243                 int     old_pair,
 244                 int     pair,
 245                 NCURSES_BOOL reverse,
 246                 int     (*outc)(
 247                 int     p1))
 248                 { /* void */ }
 249
 250 /* ./base/lib_colorset.c */
 251
 252 #undef wcolor_set
 253 int     wcolor_set(
 254                 WINDOW  *win,
 255                 short   color_pair_number,
 256                 void    *opts)
 257                 { return(*(int *)0); }
 258
 259 /* ./base/lib_delch.c */
 260
 261 #undef wdelch
 262 int     wdelch(
 263                 WINDOW  *win)
 264                 { return(*(int *)0); }
 265
 266 /* ./base/lib_delwin.c */
 267
 268 #undef delwin
 269 int     delwin(
 270                 WINDOW  *win)
 271                 { return(*(int *)0); }
 272
 273 /* ./base/lib_echo.c */
 274
 275 #undef echo
 276 int     echo(void)
 277                 { return(*(int *)0); }
 278
 279 #undef noecho
 280 int     noecho(void)
 281                 { return(*(int *)0); }
 282
 283 /* ./base/lib_endwin.c */
 284
 285 #undef endwin
 286 int     endwin(void)
 287                 { return(*(int *)0); }
 288
 289 /* ./base/lib_erase.c */
 290
 291 #undef werase
 292 int     werase(
 293                 WINDOW  *win)
 294                 { return(*(int *)0); }
 295
 296 /* ./base/lib_flash.c */
 297
 298 #undef flash
 299 int     flash(void)
 300                 { return(*(int *)0); }
 301
 302 /* ./lib_gen.c */
 303
 304 #undef addch
 305 int     addch(
 306                 const chtype z)
 307                 { return(*(int *)0); }
 308
 309 #undef addchnstr
 310 int     addchnstr(
 311                 const chtype *a1,
 312                 int     z)
 313                 { return(*(int *)0); }
 314
 315 #undef addchstr
 316 int     addchstr(
 317                 const chtype *z)
 318                 { return(*(int *)0); }
 319
 320 #undef addnstr
 321 int     addnstr(
 322                 const char *a1,
 323                 int     z)
 324                 { return(*(int *)0); }
 325
 326 #undef addstr
 327 int     addstr(
 328                 const char *z)
 329                 { return(*(int *)0); }
 330
 331 #undef attroff
 332 int     attroff(
 333                 NCURSES_ATTR_T  z)
 334                 { return(*(int *)0); }
 335
 336 #undef attron
 337 int     attron(
 338                 NCURSES_ATTR_T  z)
 339                 { return(*(int *)0); }
 340
 341 #undef attrset
 342 int     attrset(
 343                 NCURSES_ATTR_T  z)
 344                 { return(*(int *)0); }
 345
 346 #undef attr_get
 347 int     attr_get(
 348                 attr_t  *a1,
 349                 short   *a2,
 350                 void    *z)
 351                 { return(*(int *)0); }
 352
 353 #undef attr_off
 354 int     attr_off(
 355                 attr_t  a1,
 356                 void    *z)
 357                 { return(*(int *)0); }
 358
 359 #undef attr_on
 360 int     attr_on(
 361                 attr_t  a1,
 362                 void    *z)
 363                 { return(*(int *)0); }
 364
 365 #undef attr_set
 366 int     attr_set(
 367                 attr_t  a1,
 368                 short   a2,
 369                 void    *z)
 370                 { return(*(int *)0); }
 371
 372 #undef bkgd
 373 int     bkgd(
 374                 chtype  z)
 375                 { return(*(int *)0); }
 376
 377 #undef bkgdset
 378 void    bkgdset(
 379                 chtype  z)
 380                 { /* void */ }
 381
 382 #undef border
 383 int     border(
 384                 chtype  a1,
 385                 chtype  a2,
 386                 chtype  a3,
 387                 chtype  a4,
 388                 chtype  a5,
 389                 chtype  a6,
 390                 chtype  a7,
 391                 chtype  z)
 392                 { return(*(int *)0); }
 393
 394 #undef box
 395 int     box(
 396                 WINDOW  *a1,
 397                 chtype  a2,
 398                 chtype  z)
 399                 { return(*(int *)0); }
 400
 401 #undef chgat
 402 int     chgat(
 403                 int     a1,
 404                 attr_t  a2,
 405                 short   a3,
 406                 const void *z)
 407                 { return(*(int *)0); }
 408
 409 #undef clear
 410 int     clear(void)
 411                 { return(*(int *)0); }
 412
 413 #undef clrtobot
 414 int     clrtobot(void)
 415                 { return(*(int *)0); }
 416
 417 #undef clrtoeol
 418 int     clrtoeol(void)
 419                 { return(*(int *)0); }
 420
 421 #undef color_set
 422 int     color_set(
 423                 short   a1,
 424                 void    *z)
 425                 { return(*(int *)0); }
 426
 427 #undef COLOR_PAIR
 428 int     COLOR_PAIR(
 429                 int     z)
 430                 { return(*(int *)0); }
 431
 432 #undef delch
 433 int     delch(void)
 434                 { return(*(int *)0); }
 435
 436 #undef deleteln
 437 int     deleteln(void)
 438                 { return(*(int *)0); }
 439
 440 #undef echochar
 441 int     echochar(
 442                 const chtype z)
 443                 { return(*(int *)0); }
 444
 445 #undef erase
 446 int     erase(void)
 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 touchline
 892 int     touchline(
 893                 WINDOW  *a1,
 894                 int     a2,
 895                 int     z)
 896                 { return(*(int *)0); }
 897
 898 #undef touchwin
 899 int     touchwin(
 900                 WINDOW  *z)
 901                 { return(*(int *)0); }
 902
 903 #undef untouchwin
 904 int     untouchwin(
 905                 WINDOW  *z)
 906                 { return(*(int *)0); }
 907
 908 #undef vline
 909 int     vline(
 910                 chtype  a1,
 911                 int     z)
 912                 { return(*(int *)0); }
 913
 914 #undef vw_printw
 915 int     vw_printw(
 916                 WINDOW  *a1,
 917                 const char *a2,
 918                 va_list z)
 919                 { return(*(int *)0); }
 920
 921 #undef vw_scanw
 922 int     vw_scanw(
 923                 WINDOW  *a1,
 924                 char    *a2,
 925                 va_list z)
 926                 { return(*(int *)0); }
 927
 928 #undef waddchstr
 929 int     waddchstr(
 930                 WINDOW  *a1,
 931                 const chtype *z)
 932                 { return(*(int *)0); }
 933
 934 #undef waddstr
 935 int     waddstr(
 936                 WINDOW  *a1,
 937                 const char *z)
 938                 { return(*(int *)0); }
 939
 940 #undef wattron
 941 int     wattron(
 942                 WINDOW  *a1,
 943                 int     z)
 944                 { return(*(int *)0); }
 945
 946 #undef wattroff
 947 int     wattroff(
 948                 WINDOW  *a1,
 949                 int     z)
 950                 { return(*(int *)0); }
 951
 952 #undef wattrset
 953 int     wattrset(
 954                 WINDOW  *a1,
 955                 int     z)
 956                 { return(*(int *)0); }
 957
 958 #undef wattr_get
 959 int     wattr_get(
 960                 WINDOW  *a1,
 961                 attr_t  *a2,
 962                 short   *a3,
 963                 void    *z)
 964                 { return(*(int *)0); }
 965
 966 #undef wattr_set
 967 int     wattr_set(
 968                 WINDOW  *a1,
 969                 attr_t  a2,
 970                 short   a3,
 971                 void    *z)
 972                 { return(*(int *)0); }
 973
 974 #undef wdeleteln
 975 int     wdeleteln(
 976                 WINDOW  *z)
 977                 { return(*(int *)0); }
 978
 979 #undef wgetstr
 980 int     wgetstr(
 981                 WINDOW  *a1,
 982                 char    *z)
 983                 { return(*(int *)0); }
 984
 985 #undef winchstr
 986 int     winchstr(
 987                 WINDOW  *a1,
 988                 chtype  *z)
 989                 { return(*(int *)0); }
 990
 991 #undef winsertln
 992 int     winsertln(
 993                 WINDOW  *z)
 994                 { return(*(int *)0); }
 995
 996 #undef winsstr
 997 int     winsstr(
 998                 WINDOW  *a1,
 999                 const char *z)
1000                 { return(*(int *)0); }
1001
1002 #undef winstr
1003 int     winstr(
1004                 WINDOW  *a1,
1005                 char    *z)
1006                 { return(*(int *)0); }
1007
1008 #undef wstandout
1009 int     wstandout(
1010                 WINDOW  *z)
1011                 { return(*(int *)0); }
1012
1013 #undef wstandend
1014 int     wstandend(
1015                 WINDOW  *z)
1016                 { return(*(int *)0); }
1017
1018 #undef mouse_trafo
1019 NCURSES_BOOL mouse_trafo(
1020                 int     *a1,
1021                 int     *a2,
1022                 NCURSES_BOOL z)
1023                 { return(*(NCURSES_BOOL *)0); }
1024
1025 /* ./base/lib_getch.c */
1026
1027 #include <fifo_defs.h>
1028
1029 #undef ESCDELAY
1030 int     ESCDELAY;
1031
1032 #undef _nc_wgetch
1033 int     _nc_wgetch(
1034                 WINDOW  *win,
1035                 unsigned long *result,
1036                 int     use_meta)
1037                 { return(*(int *)0); }
1038
1039 #undef wgetch
1040 int     wgetch(
1041                 WINDOW  *win)
1042                 { return(*(int *)0); }
1043
1044 /* ./base/lib_getstr.c */
1045
1046 #undef wgetnstr
1047 int     wgetnstr(
1048                 WINDOW  *win,
1049                 char    *str,
1050                 int     maxlen)
1051                 { return(*(int *)0); }
1052
1053 /* ./base/lib_hline.c */
1054
1055 #undef whline
1056 int     whline(
1057                 WINDOW  *win,
1058                 chtype  ch,
1059                 int     n)
1060                 { return(*(int *)0); }
1061
1062 /* ./base/lib_immedok.c */
1063
1064 #undef immedok
1065 void    immedok(
1066                 WINDOW  *win,
1067                 NCURSES_BOOL flag)
1068                 { /* void */ }
1069
1070 /* ./base/lib_inchstr.c */
1071
1072 #undef winchnstr
1073 int     winchnstr(
1074                 WINDOW  *win,
1075                 chtype  *str,
1076                 int     n)
1077                 { return(*(int *)0); }
1078
1079 /* ./base/lib_initscr.c */
1080
1081 #undef initscr
1082 WINDOW  *initscr(void)
1083                 { return(*(WINDOW **)0); }
1084
1085 /* ./base/lib_insch.c */
1086
1087 #undef _nc_insert_ch
1088 void    _nc_insert_ch(
1089                 WINDOW  *win,
1090                 chtype  ch)
1091                 { /* void */ }
1092
1093 #undef winsch
1094 int     winsch(
1095                 WINDOW  *win,
1096                 chtype  c)
1097                 { return(*(int *)0); }
1098
1099 #undef winsnstr
1100 int     winsnstr(
1101                 WINDOW  *win,
1102                 const char *s,
1103                 int     n)
1104                 { return(*(int *)0); }
1105
1106 /* ./base/lib_insdel.c */
1107
1108 #undef winsdelln
1109 int     winsdelln(
1110                 WINDOW  *win,
1111                 int     n)
1112                 { return(*(int *)0); }
1113
1114 /* ./base/lib_instr.c */
1115
1116 #undef winnstr
1117 int     winnstr(
1118                 WINDOW  *win,
1119                 char    *str,
1120                 int     n)
1121                 { return(*(int *)0); }
1122
1123 /* ./base/lib_isendwin.c */
1124
1125 #undef isendwin
1126 NCURSES_BOOL isendwin(void)
1127                 { return(*(NCURSES_BOOL *)0); }
1128
1129 /* ./base/lib_leaveok.c */
1130
1131 #undef leaveok
1132 int     leaveok(
1133                 WINDOW  *win,
1134                 NCURSES_BOOL flag)
1135                 { return(*(int *)0); }
1136
1137 /* ./base/lib_mouse.c */
1138
1139 #undef getmouse
1140 int     getmouse(
1141                 MEVENT  *aevent)
1142                 { return(*(int *)0); }
1143
1144 #undef ungetmouse
1145 int     ungetmouse(
1146                 MEVENT  *aevent)
1147                 { return(*(int *)0); }
1148
1149 #undef mousemask
1150 mmask_t mousemask(
1151                 mmask_t newmask,
1152                 mmask_t *oldmask)
1153                 { return(*(mmask_t *)0); }
1154
1155 #undef wenclose
1156 NCURSES_BOOL wenclose(
1157                 const WINDOW *win,
1158                 int     y,
1159                 int     x)
1160                 { return(*(NCURSES_BOOL *)0); }
1161
1162 #undef mouseinterval
1163 int     mouseinterval(
1164                 int     maxclick)
1165                 { return(*(int *)0); }
1166
1167 #undef _nc_has_mouse
1168 int     _nc_has_mouse(void)
1169                 { return(*(int *)0); }
1170
1171 #undef wmouse_trafo
1172 NCURSES_BOOL wmouse_trafo(
1173                 const WINDOW *win,
1174                 int     *pY,
1175                 int     *pX,
1176                 NCURSES_BOOL to_screen)
1177                 { return(*(NCURSES_BOOL *)0); }
1178
1179 /* ./base/lib_move.c */
1180
1181 #undef wmove
1182 int     wmove(
1183                 WINDOW  *win,
1184                 int     y,
1185                 int     x)
1186                 { return(*(int *)0); }
1187
1188 /* ./tty/lib_mvcur.c */
1189
1190 #undef _nc_msec_cost
1191 int     _nc_msec_cost(
1192                 const char *const cap,
1193                 int     affcnt)
1194                 { return(*(int *)0); }
1195
1196 #undef _nc_mvcur_resume
1197 void    _nc_mvcur_resume(void)
1198                 { /* void */ }
1199
1200 #undef _nc_mvcur_init
1201 void    _nc_mvcur_init(void)
1202                 { /* void */ }
1203
1204 #undef _nc_mvcur_wrap
1205 void    _nc_mvcur_wrap(void)
1206                 { /* void */ }
1207
1208 #undef mvcur
1209 int     mvcur(
1210                 int     yold,
1211                 int     xold,
1212                 int     ynew,
1213                 int     xnew)
1214                 { return(*(int *)0); }
1215
1216 #undef _nc_optimize_enable
1217 int     _nc_optimize_enable;
1218
1219 /* ./base/lib_mvwin.c */
1220
1221 #undef mvwin
1222 int     mvwin(
1223                 WINDOW  *win,
1224                 int     by,
1225                 int     bx)
1226                 { return(*(int *)0); }
1227
1228 /* ./base/lib_newterm.c */
1229
1230 #undef filter
1231 void    filter(void)
1232                 { /* void */ }
1233
1234 #undef newterm
1235 SCREEN  *newterm(
1236                 char    *name,
1237                 FILE    *ofp,
1238                 FILE    *ifp)
1239                 { return(*(SCREEN **)0); }
1240
1241 /* ./base/lib_newwin.c */
1242
1243 #undef _nc_freewin
1244 int     _nc_freewin(
1245                 WINDOW  *win)
1246                 { return(*(int *)0); }
1247
1248 #undef newwin
1249 WINDOW  *newwin(
1250                 int     num_lines,
1251                 int     num_columns,
1252                 int     begy,
1253                 int     begx)
1254                 { return(*(WINDOW **)0); }
1255
1256 #undef derwin
1257 WINDOW  *derwin(
1258                 WINDOW  *orig,
1259                 int     num_lines,
1260                 int     num_columns,
1261                 int     begy,
1262                 int     begx)
1263                 { return(*(WINDOW **)0); }
1264
1265 #undef subwin
1266 WINDOW  *subwin(
1267                 WINDOW  *w,
1268                 int     l,
1269                 int     c,
1270                 int     y,
1271                 int     x)
1272                 { return(*(WINDOW **)0); }
1273
1274 #undef _nc_makenew
1275 WINDOW  *_nc_makenew(
1276                 int     num_lines,
1277                 int     num_columns,
1278                 int     begy,
1279                 int     begx,
1280                 int     flags)
1281                 { return(*(WINDOW **)0); }
1282
1283 /* ./base/lib_nl.c */
1284
1285 #undef nl
1286 int     nl(void)
1287                 { return(*(int *)0); }
1288
1289 #undef nonl
1290 int     nonl(void)
1291                 { return(*(int *)0); }
1292
1293 /* ./base/lib_overlay.c */
1294
1295 #undef overlay
1296 int     overlay(
1297                 const WINDOW *win1,
1298                 WINDOW  *win2)
1299                 { return(*(int *)0); }
1300
1301 #undef overwrite
1302 int     overwrite(
1303                 const WINDOW *win1,
1304                 WINDOW  *win2)
1305                 { return(*(int *)0); }
1306
1307 #undef copywin
1308 int     copywin(
1309                 const WINDOW *src,
1310                 WINDOW  *dst,
1311                 int     sminrow,
1312                 int     smincol,
1313                 int     dminrow,
1314                 int     dmincol,
1315                 int     dmaxrow,
1316                 int     dmaxcol,
1317                 int     over)
1318                 { return(*(int *)0); }
1319
1320 /* ./base/lib_pad.c */
1321
1322 #undef newpad
1323 WINDOW  *newpad(
1324                 int     l,
1325                 int     c)
1326                 { return(*(WINDOW **)0); }
1327
1328 #undef subpad
1329 WINDOW  *subpad(
1330                 WINDOW  *orig,
1331                 int     l,
1332                 int     c,
1333                 int     begy,
1334                 int     begx)
1335                 { return(*(WINDOW **)0); }
1336
1337 #undef prefresh
1338 int     prefresh(
1339                 WINDOW  *win,
1340                 int     pminrow,
1341                 int     pmincol,
1342                 int     sminrow,
1343                 int     smincol,
1344                 int     smaxrow,
1345                 int     smaxcol)
1346                 { return(*(int *)0); }
1347
1348 #undef pnoutrefresh
1349 int     pnoutrefresh(
1350                 WINDOW  *win,
1351                 int     pminrow,
1352                 int     pmincol,
1353                 int     sminrow,
1354                 int     smincol,
1355                 int     smaxrow,
1356                 int     smaxcol)
1357                 { return(*(int *)0); }
1358
1359 #undef pechochar
1360 int     pechochar(
1361                 WINDOW  *pad,
1362                 const chtype ch)
1363                 { return(*(int *)0); }
1364
1365 /* ./base/lib_printw.c */
1366
1367 #undef printw
1368 int     printw(
1369                 const char *fmt,
1370                 ...)
1371                 { return(*(int *)0); }
1372
1373 #undef wprintw
1374 int     wprintw(
1375                 WINDOW  *win,
1376                 const char *fmt,
1377                 ...)
1378                 { return(*(int *)0); }
1379
1380 #undef mvprintw
1381 int     mvprintw(
1382                 int     y,
1383                 int     x,
1384                 const char *fmt,
1385                 ...)
1386                 { return(*(int *)0); }
1387
1388 #undef mvwprintw
1389 int     mvwprintw(
1390                 WINDOW  *win,
1391                 int     y,
1392                 int     x,
1393                 const char *fmt,
1394                 ...)
1395                 { return(*(int *)0); }
1396
1397 #undef vwprintw
1398 int     vwprintw(
1399                 WINDOW  *win,
1400                 const char *fmt,
1401                 va_list argp)
1402                 { return(*(int *)0); }
1403
1404 /* ./base/lib_redrawln.c */
1405
1406 #undef wredrawln
1407 int     wredrawln(
1408                 WINDOW  *win,
1409                 int     beg,
1410                 int     num)
1411                 { return(*(int *)0); }
1412
1413 /* ./base/lib_refresh.c */
1414
1415 #undef wrefresh
1416 int     wrefresh(
1417                 WINDOW  *win)
1418                 { return(*(int *)0); }
1419
1420 #undef wnoutrefresh
1421 int     wnoutrefresh(
1422                 WINDOW  *win)
1423                 { return(*(int *)0); }
1424
1425 /* ./base/lib_restart.c */
1426
1427 #undef restartterm
1428 int     restartterm(
1429                 char    *termp,
1430                 int     filenum,
1431                 int     *errret)
1432                 { return(*(int *)0); }
1433
1434 /* ./base/lib_scanw.c */
1435
1436 #undef vwscanw
1437 int     vwscanw(
1438                 WINDOW  *win,
1439                 char    *fmt,
1440                 va_list argp)
1441                 { return(*(int *)0); }
1442
1443 #undef scanw
1444 int     scanw(
1445                 char    *fmt,
1446                 ...)
1447                 { return(*(int *)0); }
1448
1449 #undef wscanw
1450 int     wscanw(
1451                 WINDOW  *win,
1452                 char    *fmt,
1453                 ...)
1454                 { return(*(int *)0); }
1455
1456 #undef mvscanw
1457 int     mvscanw(
1458                 int     y,
1459                 int     x,
1460                 char    *fmt,
1461                 ...)
1462                 { return(*(int *)0); }
1463
1464 #undef mvwscanw
1465 int     mvwscanw(
1466                 WINDOW  *win,
1467                 int     y,
1468                 int     x,
1469                 char    *fmt,
1470                 ...)
1471                 { return(*(int *)0); }
1472
1473 /* ./base/lib_screen.c */
1474
1475 #undef getwin
1476 WINDOW  *getwin(
1477                 FILE    *filep)
1478                 { return(*(WINDOW **)0); }
1479
1480 #undef putwin
1481 int     putwin(
1482                 WINDOW  *win,
1483                 FILE    *filep)
1484                 { return(*(int *)0); }
1485
1486 #undef scr_restore
1487 int     scr_restore(
1488                 const char *file)
1489                 { return(*(int *)0); }
1490
1491 #undef scr_dump
1492 int     scr_dump(
1493                 const char *file)
1494                 { return(*(int *)0); }
1495
1496 #undef scr_init
1497 int     scr_init(
1498                 const char *file)
1499                 { return(*(int *)0); }
1500
1501 #undef scr_set
1502 int     scr_set(
1503                 const char *file)
1504                 { return(*(int *)0); }
1505
1506 /* ./base/lib_scroll.c */
1507
1508 #undef _nc_scroll_window
1509 void    _nc_scroll_window(
1510                 WINDOW  *win,
1511                 int const n,
1512                 short const top,
1513                 short const bottom,
1514                 chtype  blank)
1515                 { /* void */ }
1516
1517 #undef wscrl
1518 int     wscrl(
1519                 WINDOW  *win,
1520                 int     n)
1521                 { return(*(int *)0); }
1522
1523 /* ./base/lib_scrollok.c */
1524
1525 #undef scrollok
1526 int     scrollok(
1527                 WINDOW  *win,
1528                 NCURSES_BOOL flag)
1529                 { return(*(int *)0); }
1530
1531 /* ./base/lib_scrreg.c */
1532
1533 #undef wsetscrreg
1534 int     wsetscrreg(
1535                 WINDOW  *win,
1536                 int     top,
1537                 int     bottom)
1538                 { return(*(int *)0); }
1539
1540 /* ./base/lib_set_term.c */
1541
1542 #undef set_term
1543 SCREEN  *set_term(
1544                 SCREEN  *screenp)
1545                 { return(*(SCREEN **)0); }
1546
1547 #undef delscreen
1548 void    delscreen(
1549                 SCREEN  *sp)
1550                 { /* void */ }
1551
1552 #undef _nc_setupscreen
1553 int     _nc_setupscreen(
1554                 short   slines,
1555                 short const scolumns,
1556                 FILE    *output)
1557                 { return(*(int *)0); }
1558
1559 #undef _nc_ripoffline
1560 int     _nc_ripoffline(
1561                 int     line,
1562                 int     (*init)(
1563                 WINDOW  *p1,
1564                 int     p2))
1565                 { return(*(int *)0); }
1566
1567 #undef ripoffline
1568 int     ripoffline(
1569                 int     line,
1570                 int     (*init)(
1571                 WINDOW  *p1,
1572                 int     p2))
1573                 { return(*(int *)0); }
1574
1575 /* ./base/lib_slk.c */
1576
1577 #undef _nc_slk_format
1578 int     _nc_slk_format;
1579
1580 #undef _nc_slk_initialize
1581 int     _nc_slk_initialize(
1582                 WINDOW  *stwin,
1583                 int     cols)
1584                 { return(*(int *)0); }
1585
1586 #undef slk_restore
1587 int     slk_restore(void)
1588                 { return(*(int *)0); }
1589
1590 /* ./base/lib_slkatr_set.c */
1591
1592 #undef slk_attr_set
1593 int     slk_attr_set(
1594                 const attr_t attr,
1595                 short   color_pair_number,
1596                 void    *opts)
1597                 { return(*(int *)0); }
1598
1599 /* ./base/lib_slkatrof.c */
1600
1601 #undef slk_attroff
1602 int     slk_attroff(
1603                 const chtype attr)
1604                 { return(*(int *)0); }
1605
1606 /* ./base/lib_slkatron.c */
1607
1608 #undef slk_attron
1609 int     slk_attron(
1610                 const chtype attr)
1611                 { return(*(int *)0); }
1612
1613 /* ./base/lib_slkatrset.c */
1614
1615 #undef slk_attrset
1616 int     slk_attrset(
1617                 const chtype attr)
1618                 { return(*(int *)0); }
1619
1620 /* ./base/lib_slkattr.c */
1621
1622 #undef slk_attr
1623 attr_t  slk_attr(void)
1624                 { return(*(attr_t *)0); }
1625
1626 /* ./base/lib_slkclear.c */
1627
1628 #undef slk_clear
1629 int     slk_clear(void)
1630                 { return(*(int *)0); }
1631
1632 /* ./base/lib_slkcolor.c */
1633
1634 #undef slk_color
1635 int     slk_color(
1636                 short   color_pair_number)
1637                 { return(*(int *)0); }
1638
1639 /* ./base/lib_slkinit.c */
1640
1641 #undef slk_init
1642 int     slk_init(
1643                 int     format)
1644                 { return(*(int *)0); }
1645
1646 /* ./base/lib_slklab.c */
1647
1648 #undef slk_label
1649 char    *slk_label(
1650                 int     n)
1651                 { return(*(char **)0); }
1652
1653 /* ./base/lib_slkrefr.c */
1654
1655 #undef slk_noutrefresh
1656 int     slk_noutrefresh(void)
1657                 { return(*(int *)0); }
1658
1659 #undef slk_refresh
1660 int     slk_refresh(void)
1661                 { return(*(int *)0); }
1662
1663 /* ./base/lib_slkset.c */
1664
1665 #undef slk_set
1666 int     slk_set(
1667                 int     i,
1668                 const char *astr,
1669                 int     format)
1670                 { return(*(int *)0); }
1671
1672 /* ./base/lib_slktouch.c */
1673
1674 #undef slk_touch
1675 int     slk_touch(void)
1676                 { return(*(int *)0); }
1677
1678 /* ./base/lib_touch.c */
1679
1680 #undef is_linetouched
1681 NCURSES_BOOL is_linetouched(
1682                 WINDOW  *win,
1683                 int     line)
1684                 { return(*(NCURSES_BOOL *)0); }
1685
1686 #undef is_wintouched
1687 NCURSES_BOOL is_wintouched(
1688                 WINDOW  *win)
1689                 { return(*(NCURSES_BOOL *)0); }
1690
1691 #undef wtouchln
1692 int     wtouchln(
1693                 WINDOW  *win,
1694                 int     y,
1695                 int     n,
1696                 int     changed)
1697                 { return(*(int *)0); }
1698
1699 /* ./trace/lib_traceatr.c */
1700
1701 #undef _traceattr2
1702 char    *_traceattr2(
1703                 int     bufnum,
1704                 attr_t  newmode)
1705                 { return(*(char **)0); }
1706
1707 #undef _traceattr
1708 char    *_traceattr(
1709                 attr_t  newmode)
1710                 { return(*(char **)0); }
1711
1712 #undef _nc_retrace_attr_t
1713 attr_t  _nc_retrace_attr_t(
1714                 attr_t  code)
1715                 { return(*(attr_t *)0); }
1716
1717 #undef _nc_altcharset_name
1718 const char *_nc_altcharset_name(
1719                 attr_t  attr,
1720                 chtype  ch)
1721                 { return(*(const char **)0); }
1722
1723 #undef _tracechtype2
1724 char    *_tracechtype2(
1725                 int     bufnum,
1726                 chtype  ch)
1727                 { return(*(char **)0); }
1728
1729 #undef _tracechtype
1730 char    *_tracechtype(
1731                 chtype  ch)
1732                 { return(*(char **)0); }
1733
1734 #undef _nc_retrace_chtype
1735 chtype  _nc_retrace_chtype(
1736                 chtype  code)
1737                 { return(*(chtype *)0); }
1738
1739 /* ./trace/lib_tracedmp.c */
1740
1741 #undef _tracedump
1742 void    _tracedump(
1743                 const char *name,
1744                 WINDOW  *win)
1745                 { /* void */ }
1746
1747 /* ./trace/lib_tracemse.c */
1748
1749 #undef _tracemouse
1750 char    *_tracemouse(
1751                 MEVENT const *ep)
1752                 { return(*(char **)0); }
1753
1754 /* ./tty/lib_tstp.c */
1755
1756 #include <SigAction.h>
1757
1758 #undef _nc_signal_handler
1759 void    _nc_signal_handler(
1760                 NCURSES_BOOL enable)
1761                 { /* void */ }
1762
1763 /* ./base/lib_ungetch.c */
1764
1765 #undef _nc_fifo_dump
1766 void    _nc_fifo_dump(void)
1767                 { /* void */ }
1768
1769 #undef ungetch
1770 int     ungetch(
1771                 int     ch)
1772                 { return(*(int *)0); }
1773
1774 /* ./tty/lib_vidattr.c */
1775
1776 #undef vidputs
1777 int     vidputs(
1778                 chtype  newmode,
1779                 int     (*outc)(
1780                 int     p1))
1781                 { return(*(int *)0); }
1782
1783 #undef vidattr
1784 int     vidattr(
1785                 chtype  newmode)
1786                 { return(*(int *)0); }
1787
1788 #undef termattrs
1789 chtype  termattrs(void)
1790                 { return(*(chtype *)0); }
1791
1792 /* ./base/lib_vline.c */
1793
1794 #undef wvline
1795 int     wvline(
1796                 WINDOW  *win,
1797                 chtype  ch,
1798                 int     n)
1799                 { return(*(int *)0); }
1800
1801 /* ./base/lib_wattroff.c */
1802
1803 #undef wattr_off
1804 int     wattr_off(
1805                 WINDOW  *win,
1806                 attr_t  at,
1807                 void    *opts)
1808                 { return(*(int *)0); }
1809
1810 /* ./base/lib_wattron.c */
1811
1812 #undef wattr_on
1813 int     wattr_on(
1814                 WINDOW  *win,
1815                 attr_t  at,
1816                 void    *opts)
1817                 { return(*(int *)0); }
1818
1819 /* ./base/lib_winch.c */
1820
1821 #undef winch
1822 chtype  winch(
1823                 WINDOW  *win)
1824                 { return(*(chtype *)0); }
1825
1826 /* ./base/lib_window.c */
1827
1828 #undef _nc_synchook
1829 void    _nc_synchook(
1830                 WINDOW  *win)
1831                 { /* void */ }
1832
1833 #undef mvderwin
1834 int     mvderwin(
1835                 WINDOW  *win,
1836                 int     y,
1837                 int     x)
1838                 { return(*(int *)0); }
1839
1840 #undef syncok
1841 int     syncok(
1842                 WINDOW  *win,
1843                 NCURSES_BOOL bf)
1844                 { return(*(int *)0); }
1845
1846 #undef wsyncup
1847 void    wsyncup(
1848                 WINDOW  *win)
1849                 { /* void */ }
1850
1851 #undef wsyncdown
1852 void    wsyncdown(
1853                 WINDOW  *win)
1854                 { /* void */ }
1855
1856 #undef wcursyncup
1857 void    wcursyncup(
1858                 WINDOW  *win)
1859                 { /* void */ }
1860
1861 #undef dupwin
1862 WINDOW  *dupwin(
1863                 WINDOW  *win)
1864                 { return(*(WINDOW **)0); }
1865
1866 /* ./base/nc_panel.c */
1867
1868 #undef _nc_panelhook
1869 struct panelhook *_nc_panelhook(void)
1870                 { return(*(struct panelhook **)0); }
1871
1872 /* ./base/safe_sprintf.c */
1873
1874 #undef _nc_printf_string
1875 char    *_nc_printf_string(
1876                 const char *fmt,
1877                 va_list ap)
1878                 { return(*(char **)0); }
1879
1880 /* ./tty/tty_update.c */
1881
1882 #include <sys/time.h>
1883 #include <sys/times.h>
1884
1885 #undef doupdate
1886 int     doupdate(void)
1887                 { return(*(int *)0); }
1888
1889 #undef _nc_scrolln
1890 int     _nc_scrolln(
1891                 int     n,
1892                 int     top,
1893                 int     bot,
1894                 int     maxy)
1895                 { return(*(int *)0); }
1896
1897 #undef _nc_screen_resume
1898 void    _nc_screen_resume(void)
1899                 { /* void */ }
1900
1901 #undef _nc_screen_init
1902 void    _nc_screen_init(void)
1903                 { /* void */ }
1904
1905 #undef _nc_screen_wrap
1906 void    _nc_screen_wrap(void)
1907                 { /* void */ }
1908
1909 #undef _nc_do_xmc_glitch
1910 void    _nc_do_xmc_glitch(
1911                 attr_t  previous)
1912                 { /* void */ }
1913
1914 /* ./trace/varargs.c */
1915
1916 #undef _nc_varargs
1917 char    *_nc_varargs(
1918                 const char *fmt,
1919                 va_list ap)
1920                 { return(*(char **)0); }
1921
1922 /* ./base/memmove.c */
1923
1924 #undef _nc_memmove
1925 void    _nc_memmove(void)
1926                 { /* void */ }
1927
1928 /* ./base/vsscanf.c */
1929
1930 #undef _nc_vsscanf
1931 void    _nc_vsscanf(void)
1932                 { /* void */ }
1933
1934 /* ./base/lib_freeall.c */
1935
1936 #include <term_entry.h>
1937
1938 #undef _nc_freeall
1939 void    _nc_freeall(void)
1940                 { /* void */ }
1941
1942 /* ./base/define_key.c */
1943
1944 #undef define_key
1945 int     define_key(
1946                 const char *str,
1947                 int     keycode)
1948                 { return(*(int *)0); }
1949
1950 /* ./expanded.c */
1951
1952 #undef _nc_toggle_attr_on
1953 void    _nc_toggle_attr_on(
1954                 attr_t  *S,
1955                 attr_t  at)
1956                 { /* void */ }
1957
1958 #undef _nc_toggle_attr_off
1959 void    _nc_toggle_attr_off(
1960                 attr_t  *S,
1961                 attr_t  at)
1962                 { /* void */ }
1963
1964 #undef _nc_DelCharCost
1965 int     _nc_DelCharCost(
1966                 int     count)
1967                 { return(*(int *)0); }
1968
1969 #undef _nc_InsCharCost
1970 int     _nc_InsCharCost(
1971                 int     count)
1972                 { return(*(int *)0); }
1973
1974 #undef _nc_UpdateAttrs
1975 void    _nc_UpdateAttrs(
1976                 chtype  c)
1977                 { /* void */ }
1978
1979 /* ./base/key_defined.c */
1980
1981 #undef key_defined
1982 int     key_defined(
1983                 const char *str)
1984                 { return(*(int *)0); }
1985
1986 /* ./base/keybound.c */
1987
1988 #undef keybound
1989 char    *keybound(
1990                 int     code,
1991                 int     count)
1992                 { return(*(char **)0); }
1993
1994 /* ./base/keyok.c */
1995
1996 #undef keyok
1997 int     keyok(
1998                 int     c,
1999                 NCURSES_BOOL flag)
2000                 { return(*(int *)0); }
2001
2002 /* ./base/lib_dft_fgbg.c */
2003
2004 #undef use_default_colors
2005 int     use_default_colors(void)
2006                 { return(*(int *)0); }
2007
2008 #undef assume_default_colors
2009 int     assume_default_colors(
2010                 int     fg,
2011                 int     bg)
2012                 { return(*(int *)0); }
2013
2014 /* ./tinfo/lib_print.c */
2015
2016 #undef mcprint
2017 int     mcprint(
2018                 char    *data,
2019                 int     len)
2020                 { return(*(int *)0); }
2021
2022 /* ./base/resizeterm.c */
2023
2024 #undef is_term_resized
2025 NCURSES_BOOL is_term_resized(
2026                 int     ToLines,
2027                 int     ToCols)
2028                 { return(*(NCURSES_BOOL *)0); }
2029
2030 #undef resize_term
2031 int     resize_term(
2032                 int     ToLines,
2033                 int     ToCols)
2034                 { return(*(int *)0); }
2035
2036 #undef resizeterm
2037 int     resizeterm(
2038                 int     ToLines,
2039                 int     ToCols)
2040                 { return(*(int *)0); }
2041
2042 /* ./trace/trace_xnames.c */
2043
2044 #undef _nc_trace_xnames
2045 void    _nc_trace_xnames(
2046                 TERMTYPE *tp)
2047                 { /* void */ }
2048
2049 /* ./base/tries.c */
2050
2051 #undef _nc_expand_try
2052 char    *_nc_expand_try(
2053                 struct tries *tree,
2054                 unsigned short code,
2055                 int     *count,
2056                 size_t  len)
2057                 { return(*(char **)0); }
2058
2059 #undef _nc_remove_key
2060 int     _nc_remove_key(
2061                 struct tries **tree,
2062                 unsigned short code)
2063                 { return(*(int *)0); }
2064
2065 #undef _nc_remove_string
2066 int     _nc_remove_string(
2067                 struct tries **tree,
2068                 const char *string)
2069                 { return(*(int *)0); }
2070
2071 /* ./base/version.c */
2072
2073 #undef curses_version
2074 const char *curses_version(void)
2075                 { return(*(const char **)0); }
2076
2077 /* ./base/wresize.c */
2078
2079 #undef wresize
2080 int     wresize(
2081                 WINDOW  *win,
2082                 int     ToLines,
2083                 int     ToCols)
2084                 { return(*(int *)0); }
2085
2086 /* ./tinfo/access.c */
2087
2088 #undef _nc_rootname
2089 char    *_nc_rootname(
2090                 char    *path)
2091                 { return(*(char **)0); }
2092
2093 #undef _nc_pathlast
2094 unsigned _nc_pathlast(
2095                 const char *path)
2096                 { return(*(unsigned *)0); }
2097
2098 #undef _nc_basename
2099 char    *_nc_basename(
2100                 char    *path)
2101                 { return(*(char **)0); }
2102
2103 #undef _nc_access
2104 int     _nc_access(
2105                 const char *path,
2106                 int     mode)
2107                 { return(*(int *)0); }
2108
2109 #undef _nc_env_access
2110 int     _nc_env_access(void)
2111                 { return(*(int *)0); }
2112
2113 /* ./tinfo/add_tries.c */
2114
2115 #undef _nc_add_to_try
2116 void    _nc_add_to_try(
2117                 struct tries **tree,
2118                 const char *str,
2119                 unsigned short code)
2120                 { /* void */ }
2121
2122 /* ./tinfo/alloc_entry.c */
2123
2124 #undef _nc_init_entry
2125 void    _nc_init_entry(
2126                 TERMTYPE *const tp)
2127                 { /* void */ }
2128
2129 #undef _nc_copy_entry
2130 ENTRY   *_nc_copy_entry(
2131                 ENTRY   *oldp)
2132                 { return(*(ENTRY **)0); }
2133
2134 #undef _nc_save_str
2135 char    *_nc_save_str(
2136                 const char *const string)
2137                 { return(*(char **)0); }
2138
2139 #undef _nc_wrap_entry
2140 void    _nc_wrap_entry(
2141                 ENTRY   *const ep,
2142                 NCURSES_BOOL copy_strings)
2143                 { /* void */ }
2144
2145 #undef _nc_merge_entry
2146 void    _nc_merge_entry(
2147                 TERMTYPE *const to,
2148                 TERMTYPE *const from)
2149                 { /* void */ }
2150
2151 /* ./tinfo/alloc_ttype.c */
2152
2153 #undef _nc_align_termtype
2154 void    _nc_align_termtype(
2155                 TERMTYPE *to,
2156                 TERMTYPE *from)
2157                 { /* void */ }
2158
2159 #undef _nc_copy_termtype
2160 void    _nc_copy_termtype(
2161                 TERMTYPE *dst,
2162                 TERMTYPE *src)
2163                 { /* void */ }
2164
2165 /* ./tinfo/captoinfo.c */
2166
2167 #undef _nc_captoinfo
2168 char    *_nc_captoinfo(
2169                 const char *cap,
2170                 const char *s,
2171                 int const parameterized)
2172                 { return(*(char **)0); }
2173
2174 #undef _nc_infotocap
2175 char    *_nc_infotocap(
2176                 const char *cap,
2177                 const char *str,
2178                 int const parameterized)
2179                 { return(*(char **)0); }
2180
2181 /* ./codes.c */
2182
2183 #undef boolcodes
2184 char    *const boolcodes[] = {0};
2185 #undef numcodes
2186 char    *const numcodes[] = {0};
2187 #undef strcodes
2188 char    *const strcodes[] = {0};
2189
2190 /* ./comp_captab.c */
2191
2192 #include <ncurses_cfg.h>
2193
2194 #undef _nc_info_hash_table
2195 const struct name_table_entry *const _nc_info_hash_table[995] = {0};
2196 #undef _nc_cap_hash_table
2197 const struct name_table_entry *const _nc_cap_hash_table[995] = {0};
2198 #undef _nc_capalias_table
2199 const struct alias _nc_capalias_table[] = {0};
2200 #undef _nc_infoalias_table
2201 const struct alias _nc_infoalias_table[] = {0};
2202
2203 #undef _nc_get_table
2204 const struct name_table_entry *_nc_get_table(
2205                 NCURSES_BOOL termcap)
2206                 { return(*(const struct name_table_entry **)0); }
2207
2208 #undef _nc_get_hash_table
2209 const struct name_table_entry *const *_nc_get_hash_table(
2210                 NCURSES_BOOL termcap)
2211                 { return(*(const struct name_table_entry **)0); }
2212
2213 /* ./tinfo/comp_error.c */
2214
2215 #undef _nc_suppress_warnings
2216 NCURSES_BOOL _nc_suppress_warnings;
2217 #undef _nc_curr_line
2218 int     _nc_curr_line;
2219 #undef _nc_curr_col
2220 int     _nc_curr_col;
2221
2222 #undef _nc_set_source
2223 void    _nc_set_source(
2224                 const char *const name)
2225                 { /* void */ }
2226
2227 #undef _nc_set_type
2228 void    _nc_set_type(
2229                 const char *const name)
2230                 { /* void */ }
2231
2232 #undef _nc_get_type
2233 void    _nc_get_type(
2234                 char    *name)
2235                 { /* void */ }
2236
2237 #undef _nc_warning
2238 void    _nc_warning(
2239                 const char *const fmt,
2240                 ...)
2241                 { /* void */ }
2242
2243 #undef _nc_err_abort
2244 void    _nc_err_abort(
2245                 const char *const fmt,
2246                 ...)
2247                 { /* void */ }
2248
2249 #undef _nc_syserr_abort
2250 void    _nc_syserr_abort(
2251                 const char *const fmt,
2252                 ...)
2253                 { /* void */ }
2254
2255 /* ./tinfo/comp_expand.c */
2256
2257 #undef _nc_tic_expand
2258 char    *_nc_tic_expand(
2259                 const char *srcp,
2260                 NCURSES_BOOL tic_format,
2261                 int     numbers)
2262                 { return(*(char **)0); }
2263
2264 /* ./tinfo/comp_hash.c */
2265
2266 #include <hashsize.h>
2267
2268 #undef _nc_find_entry
2269 struct name_table_entry const *_nc_find_entry(
2270                 const char *string,
2271                 const struct name_table_entry *const *hash_table)
2272                 { return(*(struct name_table_entry const **)0); }
2273
2274 #undef _nc_find_type_entry
2275 struct name_table_entry const *_nc_find_type_entry(
2276                 const char *string,
2277                 int     type,
2278                 const struct name_table_entry *table)
2279                 { return(*(struct name_table_entry const **)0); }
2280
2281 /* ./tinfo/comp_parse.c */
2282
2283 #undef _nc_check_termtype
2284 void    (*_nc_check_termtype)(
2285                 TERMTYPE *p1);
2286 #undef _nc_head
2287 ENTRY   *_nc_head;
2288 #undef _nc_tail
2289 ENTRY   *_nc_tail;
2290
2291 #undef _nc_free_entries
2292 void    _nc_free_entries(
2293                 ENTRY   *headp)
2294                 { /* void */ }
2295
2296 #undef _nc_entry_match
2297 NCURSES_BOOL _nc_entry_match(
2298                 char    *n1,
2299                 char    *n2)
2300                 { return(*(NCURSES_BOOL *)0); }
2301
2302 #undef _nc_read_entry_source
2303 void    _nc_read_entry_source(
2304                 FILE    *fp,
2305                 char    *buf,
2306                 int     literal,
2307                 NCURSES_BOOL silent,
2308                 NCURSES_BOOL (*hook)(
2309                 ENTRY   *p1))
2310                 { /* void */ }
2311
2312 #undef _nc_resolve_uses
2313 int     _nc_resolve_uses(
2314                 NCURSES_BOOL fullresolve)
2315                 { return(*(int *)0); }
2316
2317 /* ./tinfo/comp_scan.c */
2318
2319 #undef _nc_syntax
2320 int     _nc_syntax;
2321 #undef _nc_curr_file_pos
2322 long    _nc_curr_file_pos;
2323 #undef _nc_comment_start
2324 long    _nc_comment_start;
2325 #undef _nc_comment_end
2326 long    _nc_comment_end;
2327 #undef _nc_start_line
2328 long    _nc_start_line;
2329 #undef _nc_curr_token
2330 struct token _nc_curr_token;
2331 #undef _nc_disable_period
2332 NCURSES_BOOL _nc_disable_period;
2333
2334 #undef _nc_get_token
2335 int     _nc_get_token(
2336                 NCURSES_BOOL silent)
2337                 { return(*(int *)0); }
2338
2339 #undef _nc_trans_string
2340 char    _nc_trans_string(
2341                 char    *ptr,
2342                 char    *last)
2343                 { return(*(char *)0); }
2344
2345 #undef _nc_push_token
2346 void    _nc_push_token(
2347                 int     tokclass)
2348                 { /* void */ }
2349
2350 #undef _nc_panic_mode
2351 void    _nc_panic_mode(
2352                 char    ch)
2353                 { /* void */ }
2354
2355 #undef _nc_reset_input
2356 void    _nc_reset_input(
2357                 FILE    *fp,
2358                 char    *buf)
2359                 { /* void */ }
2360
2361 /* ./tinfo/doalloc.c */
2362
2363 #undef _nc_doalloc
2364 void    *_nc_doalloc(
2365                 void    *oldp,
2366                 size_t  amount)
2367                 { return(*(void **)0); }
2368
2369 /* ./fallback.c */
2370
2371 #undef _nc_fallback
2372 const TERMTYPE *_nc_fallback(
2373                 const char *name)
2374                 { return(*(const TERMTYPE **)0); }
2375
2376 /* ./tinfo/free_ttype.c */
2377
2378 #undef _nc_free_termtype
2379 void    _nc_free_termtype(
2380                 TERMTYPE *ptr)
2381                 { /* void */ }
2382
2383 #undef _nc_user_definable
2384 NCURSES_BOOL _nc_user_definable;
2385
2386 #undef use_extended_names
2387 int     use_extended_names(
2388                 NCURSES_BOOL flag)
2389                 { return(*(int *)0); }
2390
2391 /* ./tinfo/getenv_num.c */
2392
2393 #undef _nc_getenv_num
2394 int     _nc_getenv_num(
2395                 const char *name)
2396                 { return(*(int *)0); }
2397
2398 /* ./tinfo/home_terminfo.c */
2399
2400 #undef _nc_home_terminfo
2401 char    *_nc_home_terminfo(void)
2402                 { return(*(char **)0); }
2403
2404 /* ./tinfo/init_keytry.c */
2405
2406 #if 0
2407
2408 #include <init_keytry.h>
2409
2410 #undef _nc_tinfo_fkeys
2411 struct tinfo_fkeys _nc_tinfo_fkeys[];
2412
2413 #endif
2414
2415 #undef _nc_init_keytry
2416 void    _nc_init_keytry(void)
2417                 { /* void */ }
2418
2419 /* ./tinfo/lib_acs.c */
2420
2421 #undef acs_map
2422 chtype  acs_map[128];
2423
2424 #undef _nc_init_acs
2425 void    _nc_init_acs(void)
2426                 { /* void */ }
2427
2428 /* ./tinfo/lib_baudrate.c */
2429
2430 #include <termcap.h>
2431
2432 #undef _nc_baudrate
2433 int     _nc_baudrate(
2434                 int     OSpeed)
2435                 { return(*(int *)0); }
2436
2437 #undef _nc_ospeed
2438 int     _nc_ospeed(
2439                 int     BaudRate)
2440                 { return(*(int *)0); }
2441
2442 #undef baudrate
2443 int     baudrate(void)
2444                 { return(*(int *)0); }
2445
2446 /* ./tinfo/lib_cur_term.c */
2447
2448 #undef cur_term
2449 TERMINAL *cur_term;
2450
2451 #undef set_curterm
2452 TERMINAL *set_curterm(
2453                 TERMINAL *termp)
2454                 { return(*(TERMINAL **)0); }
2455
2456 #undef del_curterm
2457 int     del_curterm(
2458                 TERMINAL *termp)
2459                 { return(*(int *)0); }
2460
2461 /* ./tinfo/lib_data.c */
2462
2463 #undef stdscr
2464 WINDOW  *stdscr;
2465 #undef curscr
2466 WINDOW  *curscr;
2467 #undef newscr
2468 WINDOW  *newscr;
2469 #undef _nc_screen_chain
2470 SCREEN  *_nc_screen_chain;
2471 #undef SP
2472 SCREEN  *SP;
2473
2474 /* ./tinfo/lib_has_cap.c */
2475
2476 #undef has_ic
2477 NCURSES_BOOL has_ic(void)
2478                 { return(*(NCURSES_BOOL *)0); }
2479
2480 #undef has_il
2481 NCURSES_BOOL has_il(void)
2482                 { return(*(NCURSES_BOOL *)0); }
2483
2484 /* ./tinfo/lib_kernel.c */
2485
2486 #undef erasechar
2487 char    erasechar(void)
2488                 { return(*(char *)0); }
2489
2490 #undef killchar
2491 char    killchar(void)
2492                 { return(*(char *)0); }
2493
2494 #undef flushinp
2495 int     flushinp(void)
2496                 { return(*(int *)0); }
2497
2498 /* ./lib_keyname.c */
2499
2500 #undef _nc_key_names
2501 const struct kn _nc_key_names[] = {0};
2502
2503 #undef keyname
2504 char    *keyname(
2505                 int     c)
2506                 { return(*(char **)0); }
2507
2508 /* ./tinfo/lib_longname.c */
2509
2510 #undef longname
2511 char    *longname(void)
2512                 { return(*(char **)0); }
2513
2514 /* ./tinfo/lib_napms.c */
2515
2516 #include <time.h>
2517
2518 #undef napms
2519 int     napms(
2520                 int     ms)
2521                 { return(*(int *)0); }
2522
2523 /* ./tinfo/lib_options.c */
2524
2525 #undef idlok
2526 int     idlok(
2527                 WINDOW  *win,
2528                 NCURSES_BOOL flag)
2529                 { return(*(int *)0); }
2530
2531 #undef idcok
2532 void    idcok(
2533                 WINDOW  *win,
2534                 NCURSES_BOOL flag)
2535                 { /* void */ }
2536
2537 #undef halfdelay
2538 int     halfdelay(
2539                 int     t)
2540                 { return(*(int *)0); }
2541
2542 #undef nodelay
2543 int     nodelay(
2544                 WINDOW  *win,
2545                 NCURSES_BOOL flag)
2546                 { return(*(int *)0); }
2547
2548 #undef notimeout
2549 int     notimeout(
2550                 WINDOW  *win,
2551                 NCURSES_BOOL f)
2552                 { return(*(int *)0); }
2553
2554 #undef wtimeout
2555 void    wtimeout(
2556                 WINDOW  *win,
2557                 int     delay)
2558                 { /* void */ }
2559
2560 #undef keypad
2561 int     keypad(
2562                 WINDOW  *win,
2563                 NCURSES_BOOL flag)
2564                 { return(*(int *)0); }
2565
2566 #undef meta
2567 int     meta(
2568                 WINDOW  *win,
2569                 NCURSES_BOOL flag)
2570                 { return(*(int *)0); }
2571
2572 #undef curs_set
2573 int     curs_set(
2574                 int     vis)
2575                 { return(*(int *)0); }
2576
2577 #undef typeahead
2578 int     typeahead(
2579                 int     fd)
2580                 { return(*(int *)0); }
2581
2582 #undef has_key
2583 int     has_key(
2584                 int     keycode)
2585                 { return(*(int *)0); }
2586
2587 #undef _nc_keypad
2588 int     _nc_keypad(
2589                 NCURSES_BOOL flag)
2590                 { return(*(int *)0); }
2591
2592 /* ./tinfo/lib_raw.c */
2593
2594 #undef raw
2595 int     raw(void)
2596                 { return(*(int *)0); }
2597
2598 #undef cbreak
2599 int     cbreak(void)
2600                 { return(*(int *)0); }
2601
2602 #undef qiflush
2603 void    qiflush(void)
2604                 { /* void */ }
2605
2606 #undef noraw
2607 int     noraw(void)
2608                 { return(*(int *)0); }
2609
2610 #undef nocbreak
2611 int     nocbreak(void)
2612                 { return(*(int *)0); }
2613
2614 #undef noqiflush
2615 void    noqiflush(void)
2616                 { /* void */ }
2617
2618 #undef intrflush
2619 int     intrflush(
2620                 WINDOW  *win,
2621                 NCURSES_BOOL flag)
2622                 { return(*(int *)0); }
2623
2624 /* ./tinfo/lib_setup.c */
2625
2626 #include <sys/ioctl.h>
2627
2628 #undef ttytype
2629 char    ttytype[256];
2630 #undef LINES
2631 int     LINES;
2632 #undef COLS
2633 int     COLS;
2634 #undef TABSIZE
2635 int     TABSIZE;
2636
2637 #undef use_env
2638 void    use_env(
2639                 NCURSES_BOOL f)
2640                 { /* void */ }
2641
2642 #undef _nc_update_screensize
2643 void    _nc_update_screensize(void)
2644                 { /* void */ }
2645
2646 #undef _nc_get_locale
2647 char    *_nc_get_locale(void)
2648                 { return(*(char **)0); }
2649
2650 #undef _nc_unicode_locale
2651 int     _nc_unicode_locale(void)
2652                 { return(*(int *)0); }
2653
2654 #undef _nc_locale_breaks_acs
2655 int     _nc_locale_breaks_acs(void)
2656                 { return(*(int *)0); }
2657
2658 #undef setupterm
2659 int     setupterm(
2660                 char    *tname,
2661                 int     Filedes,
2662                 int     *errret)
2663                 { return(*(int *)0); }
2664
2665 /* ./tinfo/lib_termcap.c */
2666
2667 #undef UP
2668 char    *UP;
2669 #undef BC
2670 char    *BC;
2671
2672 #undef tgetent
2673 int     tgetent(
2674                 char    *bufp,
2675                 const char *name)
2676                 { return(*(int *)0); }
2677
2678 #if 0
2679
2680 #include <capdefaults.c>
2681
2682 #endif
2683
2684 #undef tgetflag
2685 int     tgetflag(
2686                 char    *id)
2687                 { return(*(int *)0); }
2688
2689 #undef tgetnum
2690 int     tgetnum(
2691                 char    *id)
2692                 { return(*(int *)0); }
2693
2694 #undef tgetstr
2695 char    *tgetstr(
2696                 char    *id,
2697                 char    **area)
2698                 { return(*(char **)0); }
2699
2700 /* ./tinfo/lib_termname.c */
2701
2702 #undef termname
2703 char    *termname(void)
2704                 { return(*(char **)0); }
2705
2706 /* ./tinfo/lib_tgoto.c */
2707
2708 #undef tgoto
2709 char    *tgoto(
2710                 const char *string,
2711                 int     x,
2712                 int     y)
2713                 { return(*(char **)0); }
2714
2715 /* ./tinfo/lib_ti.c */
2716
2717 #undef tigetflag
2718 int     tigetflag(
2719                 char    *str)
2720                 { return(*(int *)0); }
2721
2722 #undef tigetnum
2723 int     tigetnum(
2724                 char    *str)
2725                 { return(*(int *)0); }
2726
2727 #undef tigetstr
2728 char    *tigetstr(
2729                 char    *str)
2730                 { return(*(char **)0); }
2731
2732 /* ./tinfo/lib_tparm.c */
2733
2734 #undef _nc_tparm_err
2735 int     _nc_tparm_err;
2736
2737 #undef _nc_tparm_analyze
2738 int     _nc_tparm_analyze(
2739                 const char *string,
2740                 char    *p_is_s[9],
2741                 int     *popcount)
2742                 { return(*(int *)0); }
2743
2744 #undef tparm
2745 char    *tparm(
2746                 char    *string,
2747                 ...)
2748                 { return(*(char **)0); }
2749
2750 /* ./tinfo/lib_tputs.c */
2751
2752 #undef PC
2753 char    PC;
2754 #undef ospeed
2755 NCURSES_OSPEED  ospeed;
2756 #undef _nc_nulls_sent
2757 int     _nc_nulls_sent;
2758
2759 #undef delay_output
2760 int     delay_output(
2761                 int     ms)
2762                 { return(*(int *)0); }
2763
2764 #undef _nc_flush
2765 void    _nc_flush(void)
2766                 { /* void */ }
2767
2768 #undef _nc_outch
2769 int     _nc_outch(
2770                 int     ch)
2771                 { return(*(int *)0); }
2772
2773 #undef putp
2774 int     putp(
2775                 const char *string)
2776                 { return(*(int *)0); }
2777
2778 #undef tputs
2779 int     tputs(
2780                 const char *string,
2781                 int     affcnt,
2782                 int     (*outc)(
2783                 int     p1))
2784                 { return(*(int *)0); }
2785
2786 /* ./trace/lib_trace.c */
2787
2788 #undef _nc_tracing
2789 unsigned _nc_tracing;
2790 #undef _nc_tputs_trace
2791 const char *_nc_tputs_trace = {0};
2792 #undef _nc_outchars
2793 long    _nc_outchars;
2794
2795 #undef trace
2796 void    trace(
2797                 const unsigned int tracelevel)
2798                 { /* void */ }
2799
2800 #undef _tracef
2801 void    _tracef(
2802                 const char *fmt,
2803                 ...)
2804                 { /* void */ }
2805
2806 #undef _nc_retrace_bool
2807 NCURSES_BOOL _nc_retrace_bool(
2808                 NCURSES_BOOL code)
2809                 { return(*(NCURSES_BOOL *)0); }
2810
2811 #undef _nc_retrace_int
2812 int     _nc_retrace_int(
2813                 int     code)
2814                 { return(*(int *)0); }
2815
2816 #undef _nc_retrace_unsigned
2817 unsigned _nc_retrace_unsigned(
2818                 unsigned code)
2819                 { return(*(unsigned *)0); }
2820
2821 #undef _nc_retrace_ptr
2822 char    *_nc_retrace_ptr(
2823                 char    *code)
2824                 { return(*(char **)0); }
2825
2826 #undef _nc_retrace_sp
2827 SCREEN  *_nc_retrace_sp(
2828                 SCREEN  *code)
2829                 { return(*(SCREEN **)0); }
2830
2831 #undef _nc_retrace_win
2832 WINDOW  *_nc_retrace_win(
2833                 WINDOW  *code)
2834                 { return(*(WINDOW **)0); }
2835
2836 /* ./trace/lib_tracebits.c */
2837
2838 #undef _nc_trace_ttymode
2839 char    *_nc_trace_ttymode(
2840                 struct termios *tty)
2841                 { return(*(char **)0); }
2842
2843 #undef _nc_tracebits
2844 char    *_nc_tracebits(void)
2845                 { return(*(char **)0); }
2846
2847 /* ./trace/lib_tracechr.c */
2848
2849 #undef _tracechar
2850 char    *_tracechar(
2851                 int     ch)
2852                 { return(*(char **)0); }
2853
2854 /* ./tinfo/lib_ttyflags.c */
2855
2856 #undef _nc_get_tty_mode
2857 int     _nc_get_tty_mode(
2858                 struct termios *buf)
2859                 { return(*(int *)0); }
2860
2861 #undef _nc_set_tty_mode
2862 int     _nc_set_tty_mode(
2863                 struct termios *buf)
2864                 { return(*(int *)0); }
2865
2866 #undef def_shell_mode
2867 int     def_shell_mode(void)
2868                 { return(*(int *)0); }
2869
2870 #undef def_prog_mode
2871 int     def_prog_mode(void)
2872                 { return(*(int *)0); }
2873
2874 #undef reset_prog_mode
2875 int     reset_prog_mode(void)
2876                 { return(*(int *)0); }
2877
2878 #undef reset_shell_mode
2879 int     reset_shell_mode(void)
2880                 { return(*(int *)0); }
2881
2882 #undef savetty
2883 int     savetty(void)
2884                 { return(*(int *)0); }
2885
2886 #undef resetty
2887 int     resetty(void)
2888                 { return(*(int *)0); }
2889
2890 /* ./tty/lib_twait.c */
2891
2892 #undef _nc_timed_wait
2893 int     _nc_timed_wait(
2894                 int     mode,
2895                 int     milliseconds,
2896                 int     *timeleft)
2897                 { return(*(int *)0); }
2898
2899 /* ./tinfo/name_match.c */
2900
2901 #undef _nc_first_name
2902 char    *_nc_first_name(
2903                 const char *const sp)
2904                 { return(*(char **)0); }
2905
2906 #undef _nc_name_match
2907 int     _nc_name_match(
2908                 const char *const namelst,
2909                 const char *const name,
2910                 const char *const delim)
2911                 { return(*(int *)0); }
2912
2913 /* ./names.c */
2914
2915 #undef boolnames
2916 char    *const boolnames[] = {0};
2917 #undef boolfnames
2918 char    *const boolfnames[] = {0};
2919 #undef numnames
2920 char    *const numnames[] = {0};
2921 #undef numfnames
2922 char    *const numfnames[] = {0};
2923 #undef strnames
2924 char    *const strnames[] = {0};
2925 #undef strfnames
2926 char    *const strfnames[] = {0};
2927
2928 /* ./tinfo/parse_entry.c */
2929
2930 #undef _nc_parse_entry
2931 int     _nc_parse_entry(
2932                 struct entry *entryp,
2933                 int     literal,
2934                 NCURSES_BOOL silent)
2935                 { return(*(int *)0); }
2936
2937 #undef _nc_capcmp
2938 int     _nc_capcmp(
2939                 const char *s,
2940                 const char *t)
2941                 { return(*(int *)0); }
2942
2943 /* ./tinfo/read_entry.c */
2944
2945 #undef _nc_tic_dir
2946 const char *_nc_tic_dir(
2947                 const char *path)
2948                 { return(*(const char **)0); }
2949
2950 #undef _nc_keep_tic_dir
2951 void    _nc_keep_tic_dir(
2952                 const char *path)
2953                 { /* void */ }
2954
2955 #undef _nc_read_file_entry
2956 int     _nc_read_file_entry(
2957                 const char *const filename,
2958                 TERMTYPE *ptr)
2959                 { return(*(int *)0); }
2960
2961 #undef _nc_read_entry
2962 int     _nc_read_entry(
2963                 const char *const tn,
2964                 char    *const filename,
2965                 TERMTYPE *const tp)
2966                 { return(*(int *)0); }
2967
2968 /* ./tinfo/read_termcap.c */
2969
2970 #undef _nc_read_termcap_entry
2971 int     _nc_read_termcap_entry(
2972                 const char *const tn,
2973                 TERMTYPE *const tp)
2974                 { return(*(int *)0); }
2975
2976 /* ./tinfo/setbuf.c */
2977
2978 #undef _nc_set_buffer
2979 void    _nc_set_buffer(
2980                 FILE    *ofp,
2981                 NCURSES_BOOL buffered)
2982                 { /* void */ }
2983
2984 /* ./tinfo/strings.c */
2985
2986 #undef _nc_str_init
2987 string_desc *_nc_str_init(
2988                 string_desc *dst,
2989                 char    *src,
2990                 size_t  len)
2991                 { return(*(string_desc **)0); }
2992
2993 #undef _nc_str_null
2994 string_desc *_nc_str_null(
2995                 string_desc *dst,
2996                 size_t  len)
2997                 { return(*(string_desc **)0); }
2998
2999 #undef _nc_str_copy
3000 string_desc *_nc_str_copy(
3001                 string_desc *dst,
3002                 string_desc *src)
3003                 { return(*(string_desc **)0); }
3004
3005 #undef _nc_safe_strcat
3006 NCURSES_BOOL _nc_safe_strcat(
3007                 string_desc *dst,
3008                 const char *src)
3009                 { return(*(NCURSES_BOOL *)0); }
3010
3011 #undef _nc_safe_strcpy
3012 NCURSES_BOOL _nc_safe_strcpy(
3013                 string_desc *dst,
3014                 const char *src)
3015                 { return(*(NCURSES_BOOL *)0); }
3016
3017 /* ./trace/trace_buf.c */
3018
3019 #undef _nc_trace_buf
3020 char    *_nc_trace_buf(
3021                 int     bufnum,
3022                 size_t  want)
3023                 { return(*(char **)0); }
3024
3025 #undef _nc_trace_bufcat
3026 char    *_nc_trace_bufcat(
3027                 int     bufnum,
3028                 const char *value)
3029                 { return(*(char **)0); }
3030
3031 /* ./trace/trace_tries.c */
3032
3033 #undef _nc_trace_tries
3034 void    _nc_trace_tries(
3035                 struct tries *tree)
3036                 { /* void */ }
3037
3038 /* ./unctrl.c */
3039
3040 #undef unctrl
3041 char    *unctrl(
3042                  chtype ch)
3043                 { return(*(char **)0); }
3044
3045 /* ./trace/visbuf.c */
3046
3047 #undef _nc_visbuf2
3048 const char *_nc_visbuf2(
3049                 int     bufnum,
3050                 const char *buf)
3051                 { return(*(const char **)0); }
3052
3053 #undef _nc_visbuf
3054 const char *_nc_visbuf(
3055                 const char *buf)
3056                 { return(*(const char **)0); }
3057
3058 #undef _nc_visbufn
3059 const char *_nc_visbufn(
3060                 const char *buf,
3061                 int     len)
3062                 { return(*(const char **)0); }
3063
3064 /* ./tinfo/write_entry.c */
3065
3066 #undef _nc_set_writedir
3067 void    _nc_set_writedir(
3068                 char    *dir)
3069                 { /* void */ }
3070
3071 #undef _nc_write_entry
3072 void    _nc_write_entry(
3073                 TERMTYPE *const tp)
3074                 { /* void */ }
3075
3076 #undef _nc_tic_written
3077 int     _nc_tic_written(void)
3078                 { return(*(int *)0); }