ncurses/llib-lncursesw

   1 /****************************************************************************
   2  * Copyright (c) 2001-2010,2011 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 2001-2010,2011                                 *
  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_sp
  42 void    _nc_scroll_optimize_sp(
  43                 SCREEN  *sp)
  44                 { /* void */ }
  45
  46 #undef _nc_scroll_optimize
  47 void    _nc_scroll_optimize(void)
  48                 { /* void */ }
  49
  50 #undef _nc_linedump_sp
  51 void    _nc_linedump_sp(
  52                 SCREEN  *sp)
  53                 { /* void */ }
  54
  55 #undef _nc_linedump
  56 void    _nc_linedump(void)
  57                 { /* void */ }
  58
  59 /* ./tty/hashmap.c */
  60
  61 #undef _nc_hash_map_sp
  62 void    _nc_hash_map_sp(
  63                 SCREEN  *sp)
  64                 { /* void */ }
  65
  66 #undef _nc_hash_map
  67 void    _nc_hash_map(void)
  68                 { /* void */ }
  69
  70 #undef _nc_make_oldhash_sp
  71 void    _nc_make_oldhash_sp(
  72                 SCREEN  *sp,
  73                 int     i)
  74                 { /* void */ }
  75
  76 #undef _nc_make_oldhash
  77 void    _nc_make_oldhash(
  78                 int     i)
  79                 { /* void */ }
  80
  81 #undef _nc_scroll_oldhash_sp
  82 void    _nc_scroll_oldhash_sp(
  83                 SCREEN  *sp,
  84                 int     n,
  85                 int     top,
  86                 int     bot)
  87                 { /* void */ }
  88
  89 #undef _nc_scroll_oldhash
  90 void    _nc_scroll_oldhash(
  91                 int     n,
  92                 int     top,
  93                 int     bot)
  94                 { /* void */ }
  95
  96 /* ./base/lib_addch.c */
  97
  98 #include <ctype.h>
  99
 100 #undef _nc_render
 101 cchar_t _nc_render(
 102                 WINDOW  *win,
 103                 cchar_t ch)
 104                 { return(*(cchar_t *)0); }
 105
 106 #undef _nc_build_wch
 107 int     _nc_build_wch(
 108                 WINDOW  *win,
 109                 cchar_t *ch)
 110                 { return(*(int *)0); }
 111
 112 #undef _nc_waddch_nosync
 113 int     _nc_waddch_nosync(
 114                 WINDOW  *win,
 115                 const cchar_t c)
 116                 { return(*(int *)0); }
 117
 118 #undef waddch
 119 int     waddch(
 120                 WINDOW  *win,
 121                 const chtype ch)
 122                 { return(*(int *)0); }
 123
 124 #undef wechochar
 125 int     wechochar(
 126                 WINDOW  *win,
 127                 const chtype ch)
 128                 { return(*(int *)0); }
 129
 130 /* ./base/lib_addstr.c */
 131
 132 #undef waddnstr
 133 int     waddnstr(
 134                 WINDOW  *win,
 135                 const char *astr,
 136                 int     n)
 137                 { return(*(int *)0); }
 138
 139 #undef waddchnstr
 140 int     waddchnstr(
 141                 WINDOW  *win,
 142                 const chtype *astr,
 143                 int     n)
 144                 { return(*(int *)0); }
 145
 146 #undef _nc_wchstrlen
 147 int     _nc_wchstrlen(
 148                 const cchar_t *s)
 149                 { return(*(int *)0); }
 150
 151 #undef wadd_wchnstr
 152 int     wadd_wchnstr(
 153                 WINDOW  *win,
 154                 const cchar_t *astr,
 155                 int     n)
 156                 { return(*(int *)0); }
 157
 158 #undef waddnwstr
 159 int     waddnwstr(
 160                 WINDOW  *win,
 161                 const wchar_t *str,
 162                 int     n)
 163                 { return(*(int *)0); }
 164
 165 /* ./base/lib_beep.c */
 166
 167 #undef beep_sp
 168 int     beep_sp(
 169                 SCREEN  *sp)
 170                 { return(*(int *)0); }
 171
 172 #undef beep
 173 int     beep(void)
 174                 { return(*(int *)0); }
 175
 176 /* ./base/lib_bkgd.c */
 177
 178 #undef wbkgrndset
 179 void    wbkgrndset(
 180                 WINDOW  *win,
 181                 const cchar_t *ch)
 182                 { /* void */ }
 183
 184 #undef wbkgdset
 185 void    wbkgdset(
 186                 WINDOW  *win,
 187                 chtype  ch)
 188                 { /* void */ }
 189
 190 #undef wbkgrnd
 191 int     wbkgrnd(
 192                 WINDOW  *win,
 193                 const cchar_t *ch)
 194                 { return(*(int *)0); }
 195
 196 #undef wbkgd
 197 int     wbkgd(
 198                 WINDOW  *win,
 199                 chtype  ch)
 200                 { return(*(int *)0); }
 201
 202 /* ./base/lib_box.c */
 203
 204 #undef wborder
 205 int     wborder(
 206                 WINDOW  *win,
 207                 chtype  ls,
 208                 chtype  rs,
 209                 chtype  ts,
 210                 chtype  bs,
 211                 chtype  tl,
 212                 chtype  tr,
 213                 chtype  bl,
 214                 chtype  br)
 215                 { return(*(int *)0); }
 216
 217 /* ./base/lib_chgat.c */
 218
 219 #undef wchgat
 220 int     wchgat(
 221                 WINDOW  *win,
 222                 int     n,
 223                 attr_t  attr,
 224                 short   color,
 225                 const void *opts)
 226                 { return(*(int *)0); }
 227
 228 /* ./base/lib_clear.c */
 229
 230 #undef wclear
 231 int     wclear(
 232                 WINDOW  *win)
 233                 { return(*(int *)0); }
 234
 235 /* ./base/lib_clearok.c */
 236
 237 #undef clearok
 238 int     clearok(
 239                 WINDOW  *win,
 240                 NCURSES_BOOL flag)
 241                 { return(*(int *)0); }
 242
 243 /* ./base/lib_clrbot.c */
 244
 245 #undef wclrtobot
 246 int     wclrtobot(
 247                 WINDOW  *win)
 248                 { return(*(int *)0); }
 249
 250 /* ./base/lib_clreol.c */
 251
 252 #undef wclrtoeol
 253 int     wclrtoeol(
 254                 WINDOW  *win)
 255                 { return(*(int *)0); }
 256
 257 /* ./base/lib_color.c */
 258
 259 #include <tic.h>
 260
 261 #undef COLOR_PAIRS
 262 int     COLOR_PAIRS;
 263 #undef COLORS
 264 int     COLORS;
 265
 266 #undef _nc_reset_colors_sp
 267 NCURSES_BOOL _nc_reset_colors_sp(
 268                 SCREEN  *sp)
 269                 { return(*(NCURSES_BOOL *)0); }
 270
 271 #undef _nc_reset_colors
 272 NCURSES_BOOL _nc_reset_colors(void)
 273                 { return(*(NCURSES_BOOL *)0); }
 274
 275 #undef start_color_sp
 276 int     start_color_sp(
 277                 SCREEN  *sp)
 278                 { return(*(int *)0); }
 279
 280 #undef start_color
 281 int     start_color(void)
 282                 { return(*(int *)0); }
 283
 284 #undef init_pair_sp
 285 int     init_pair_sp(
 286                 SCREEN  *sp,
 287                 short   pair,
 288                 short   f,
 289                 short   b)
 290                 { return(*(int *)0); }
 291
 292 #undef init_pair
 293 int     init_pair(
 294                 short   pair,
 295                 short   f,
 296                 short   b)
 297                 { return(*(int *)0); }
 298
 299 #undef init_color_sp
 300 int     init_color_sp(
 301                 SCREEN  *sp,
 302                 short   color,
 303                 short   r,
 304                 short   g,
 305                 short   b)
 306                 { return(*(int *)0); }
 307
 308 #undef init_color
 309 int     init_color(
 310                 short   color,
 311                 short   r,
 312                 short   g,
 313                 short   b)
 314                 { return(*(int *)0); }
 315
 316 #undef can_change_color_sp
 317 NCURSES_BOOL can_change_color_sp(
 318                 SCREEN  *sp)
 319                 { return(*(NCURSES_BOOL *)0); }
 320
 321 #undef can_change_color
 322 NCURSES_BOOL can_change_color(void)
 323                 { return(*(NCURSES_BOOL *)0); }
 324
 325 #undef has_colors_sp
 326 NCURSES_BOOL has_colors_sp(
 327                 SCREEN  *sp)
 328                 { return(*(NCURSES_BOOL *)0); }
 329
 330 #undef has_colors
 331 NCURSES_BOOL has_colors(void)
 332                 { return(*(NCURSES_BOOL *)0); }
 333
 334 #undef color_content_sp
 335 int     color_content_sp(
 336                 SCREEN  *sp,
 337                 short   color,
 338                 short   *r,
 339                 short   *g,
 340                 short   *b)
 341                 { return(*(int *)0); }
 342
 343 #undef color_content
 344 int     color_content(
 345                 short   color,
 346                 short   *r,
 347                 short   *g,
 348                 short   *b)
 349                 { return(*(int *)0); }
 350
 351 #undef pair_content_sp
 352 int     pair_content_sp(
 353                 SCREEN  *sp,
 354                 short   pair,
 355                 short   *f,
 356                 short   *b)
 357                 { return(*(int *)0); }
 358
 359 #undef pair_content
 360 int     pair_content(
 361                 short   pair,
 362                 short   *f,
 363                 short   *b)
 364                 { return(*(int *)0); }
 365
 366 #undef _nc_do_color_sp
 367 void    _nc_do_color_sp(
 368                 SCREEN  *sp,
 369                 short   old_pair,
 370                 short   pair,
 371                 NCURSES_BOOL reverse,
 372                 NCURSES_OUTC_sp outc)
 373                 { /* void */ }
 374
 375 #undef _nc_do_color
 376 void    _nc_do_color(
 377                 short   old_pair,
 378                 short   pair,
 379                 NCURSES_BOOL reverse,
 380                 NCURSES_OUTC outc)
 381                 { /* void */ }
 382
 383 /* ./base/lib_colorset.c */
 384
 385 #undef wcolor_set
 386 int     wcolor_set(
 387                 WINDOW  *win,
 388                 short   color_pair_number,
 389                 void    *opts)
 390                 { return(*(int *)0); }
 391
 392 /* ./base/lib_delch.c */
 393
 394 #undef wdelch
 395 int     wdelch(
 396                 WINDOW  *win)
 397                 { return(*(int *)0); }
 398
 399 /* ./base/lib_delwin.c */
 400
 401 #undef delwin
 402 int     delwin(
 403                 WINDOW  *win)
 404                 { return(*(int *)0); }
 405
 406 /* ./base/lib_echo.c */
 407
 408 #undef echo_sp
 409 int     echo_sp(
 410                 SCREEN  *sp)
 411                 { return(*(int *)0); }
 412
 413 #undef echo
 414 int     echo(void)
 415                 { return(*(int *)0); }
 416
 417 #undef noecho_sp
 418 int     noecho_sp(
 419                 SCREEN  *sp)
 420                 { return(*(int *)0); }
 421
 422 #undef noecho
 423 int     noecho(void)
 424                 { return(*(int *)0); }
 425
 426 /* ./base/lib_endwin.c */
 427
 428 #undef endwin_sp
 429 int     endwin_sp(
 430                 SCREEN  *sp)
 431                 { return(*(int *)0); }
 432
 433 #undef endwin
 434 int     endwin(void)
 435                 { return(*(int *)0); }
 436
 437 /* ./base/lib_erase.c */
 438
 439 #undef werase
 440 int     werase(
 441                 WINDOW  *win)
 442                 { return(*(int *)0); }
 443
 444 /* ./base/lib_flash.c */
 445
 446 #undef flash_sp
 447 int     flash_sp(
 448                 SCREEN  *sp)
 449                 { return(*(int *)0); }
 450
 451 #undef flash
 452 int     flash(void)
 453                 { return(*(int *)0); }
 454
 455 /* ./lib_gen.c */
 456
 457 #undef addch
 458 int     addch(
 459                 const chtype z)
 460                 { return(*(int *)0); }
 461
 462 #undef addchnstr
 463 int     addchnstr(
 464                 const chtype *a1,
 465                 int     z)
 466                 { return(*(int *)0); }
 467
 468 #undef addchstr
 469 int     addchstr(
 470                 const chtype *z)
 471                 { return(*(int *)0); }
 472
 473 #undef addnstr
 474 int     addnstr(
 475                 const char *a1,
 476                 int     z)
 477                 { return(*(int *)0); }
 478
 479 #undef addstr
 480 int     addstr(
 481                 const char *z)
 482                 { return(*(int *)0); }
 483
 484 #undef attroff
 485 int     attroff(
 486                 NCURSES_ATTR_T  z)
 487                 { return(*(int *)0); }
 488
 489 #undef attron
 490 int     attron(
 491                 NCURSES_ATTR_T  z)
 492                 { return(*(int *)0); }
 493
 494 #undef attrset
 495 int     attrset(
 496                 NCURSES_ATTR_T  z)
 497                 { return(*(int *)0); }
 498
 499 #undef attr_get
 500 int     attr_get(
 501                 attr_t  *a1,
 502                 short   *a2,
 503                 void    *z)
 504                 { return(*(int *)0); }
 505
 506 #undef attr_off
 507 int     attr_off(
 508                 attr_t  a1,
 509                 void    *z)
 510                 { return(*(int *)0); }
 511
 512 #undef attr_on
 513 int     attr_on(
 514                 attr_t  a1,
 515                 void    *z)
 516                 { return(*(int *)0); }
 517
 518 #undef attr_set
 519 int     attr_set(
 520                 attr_t  a1,
 521                 short   a2,
 522                 void    *z)
 523                 { return(*(int *)0); }
 524
 525 #undef bkgd
 526 int     bkgd(
 527                 chtype  z)
 528                 { return(*(int *)0); }
 529
 530 #undef bkgdset
 531 void    bkgdset(
 532                 chtype  z)
 533                 { /* void */ }
 534
 535 #undef border
 536 int     border(
 537                 chtype  a1,
 538                 chtype  a2,
 539                 chtype  a3,
 540                 chtype  a4,
 541                 chtype  a5,
 542                 chtype  a6,
 543                 chtype  a7,
 544                 chtype  z)
 545                 { return(*(int *)0); }
 546
 547 #undef box
 548 int     box(
 549                 WINDOW  *a1,
 550                 chtype  a2,
 551                 chtype  z)
 552                 { return(*(int *)0); }
 553
 554 #undef chgat
 555 int     chgat(
 556                 int     a1,
 557                 attr_t  a2,
 558                 short   a3,
 559                 const void *z)
 560                 { return(*(int *)0); }
 561
 562 #undef clear
 563 int     clear(void)
 564                 { return(*(int *)0); }
 565
 566 #undef clrtobot
 567 int     clrtobot(void)
 568                 { return(*(int *)0); }
 569
 570 #undef clrtoeol
 571 int     clrtoeol(void)
 572                 { return(*(int *)0); }
 573
 574 #undef color_set
 575 int     color_set(
 576                 short   a1,
 577                 void    *z)
 578                 { return(*(int *)0); }
 579
 580 #undef COLOR_PAIR
 581 int     COLOR_PAIR(
 582                 int     z)
 583                 { return(*(int *)0); }
 584
 585 #undef delch
 586 int     delch(void)
 587                 { return(*(int *)0); }
 588
 589 #undef deleteln
 590 int     deleteln(void)
 591                 { return(*(int *)0); }
 592
 593 #undef echochar
 594 int     echochar(
 595                 const chtype z)
 596                 { return(*(int *)0); }
 597
 598 #undef erase
 599 int     erase(void)
 600                 { return(*(int *)0); }
 601
 602 #undef getbkgd
 603 chtype  getbkgd(
 604                 WINDOW  *z)
 605                 { return(*(chtype *)0); }
 606
 607 #undef getch
 608 int     getch(void)
 609                 { return(*(int *)0); }
 610
 611 #undef getnstr
 612 int     getnstr(
 613                 char    *a1,
 614                 int     z)
 615                 { return(*(int *)0); }
 616
 617 #undef getstr
 618 int     getstr(
 619                 char    *z)
 620                 { return(*(int *)0); }
 621
 622 #undef hline
 623 int     hline(
 624                 chtype  a1,
 625                 int     z)
 626                 { return(*(int *)0); }
 627
 628 #undef inch
 629 chtype  inch(void)
 630                 { return(*(chtype *)0); }
 631
 632 #undef inchnstr
 633 int     inchnstr(
 634                 chtype  *a1,
 635                 int     z)
 636                 { return(*(int *)0); }
 637
 638 #undef inchstr
 639 int     inchstr(
 640                 chtype  *z)
 641                 { return(*(int *)0); }
 642
 643 #undef innstr
 644 int     innstr(
 645                 char    *a1,
 646                 int     z)
 647                 { return(*(int *)0); }
 648
 649 #undef insch
 650 int     insch(
 651                 chtype  z)
 652                 { return(*(int *)0); }
 653
 654 #undef insdelln
 655 int     insdelln(
 656                 int     z)
 657                 { return(*(int *)0); }
 658
 659 #undef insertln
 660 int     insertln(void)
 661                 { return(*(int *)0); }
 662
 663 #undef insnstr
 664 int     insnstr(
 665                 const char *a1,
 666                 int     z)
 667                 { return(*(int *)0); }
 668
 669 #undef insstr
 670 int     insstr(
 671                 const char *z)
 672                 { return(*(int *)0); }
 673
 674 #undef instr
 675 int     instr(
 676                 char    *z)
 677                 { return(*(int *)0); }
 678
 679 #undef move
 680 int     move(
 681                 int     a1,
 682                 int     z)
 683                 { return(*(int *)0); }
 684
 685 #undef mvaddch
 686 int     mvaddch(
 687                 int     a1,
 688                 int     a2,
 689                 const chtype z)
 690                 { return(*(int *)0); }
 691
 692 #undef mvaddchnstr
 693 int     mvaddchnstr(
 694                 int     a1,
 695                 int     a2,
 696                 const chtype *a3,
 697                 int     z)
 698                 { return(*(int *)0); }
 699
 700 #undef mvaddchstr
 701 int     mvaddchstr(
 702                 int     a1,
 703                 int     a2,
 704                 const chtype *z)
 705                 { return(*(int *)0); }
 706
 707 #undef mvaddnstr
 708 int     mvaddnstr(
 709                 int     a1,
 710                 int     a2,
 711                 const char *a3,
 712                 int     z)
 713                 { return(*(int *)0); }
 714
 715 #undef mvaddstr
 716 int     mvaddstr(
 717                 int     a1,
 718                 int     a2,
 719                 const char *z)
 720                 { return(*(int *)0); }
 721
 722 #undef mvchgat
 723 int     mvchgat(
 724                 int     a1,
 725                 int     a2,
 726                 int     a3,
 727                 attr_t  a4,
 728                 short   a5,
 729                 const void *z)
 730                 { return(*(int *)0); }
 731
 732 #undef mvdelch
 733 int     mvdelch(
 734                 int     a1,
 735                 int     z)
 736                 { return(*(int *)0); }
 737
 738 #undef mvgetch
 739 int     mvgetch(
 740                 int     a1,
 741                 int     z)
 742                 { return(*(int *)0); }
 743
 744 #undef mvgetnstr
 745 int     mvgetnstr(
 746                 int     a1,
 747                 int     a2,
 748                 char    *a3,
 749                 int     z)
 750                 { return(*(int *)0); }
 751
 752 #undef mvgetstr
 753 int     mvgetstr(
 754                 int     a1,
 755                 int     a2,
 756                 char    *z)
 757                 { return(*(int *)0); }
 758
 759 #undef mvhline
 760 int     mvhline(
 761                 int     a1,
 762                 int     a2,
 763                 chtype  a3,
 764                 int     z)
 765                 { return(*(int *)0); }
 766
 767 #undef mvinch
 768 chtype  mvinch(
 769                 int     a1,
 770                 int     z)
 771                 { return(*(chtype *)0); }
 772
 773 #undef mvinchnstr
 774 int     mvinchnstr(
 775                 int     a1,
 776                 int     a2,
 777                 chtype  *a3,
 778                 int     z)
 779                 { return(*(int *)0); }
 780
 781 #undef mvinchstr
 782 int     mvinchstr(
 783                 int     a1,
 784                 int     a2,
 785                 chtype  *z)
 786                 { return(*(int *)0); }
 787
 788 #undef mvinnstr
 789 int     mvinnstr(
 790                 int     a1,
 791                 int     a2,
 792                 char    *a3,
 793                 int     z)
 794                 { return(*(int *)0); }
 795
 796 #undef mvinsch
 797 int     mvinsch(
 798                 int     a1,
 799                 int     a2,
 800                 chtype  z)
 801                 { return(*(int *)0); }
 802
 803 #undef mvinsnstr
 804 int     mvinsnstr(
 805                 int     a1,
 806                 int     a2,
 807                 const char *a3,
 808                 int     z)
 809                 { return(*(int *)0); }
 810
 811 #undef mvinsstr
 812 int     mvinsstr(
 813                 int     a1,
 814                 int     a2,
 815                 const char *z)
 816                 { return(*(int *)0); }
 817
 818 #undef mvinstr
 819 int     mvinstr(
 820                 int     a1,
 821                 int     a2,
 822                 char    *z)
 823                 { return(*(int *)0); }
 824
 825 #undef mvvline
 826 int     mvvline(
 827                 int     a1,
 828                 int     a2,
 829                 chtype  a3,
 830                 int     z)
 831                 { return(*(int *)0); }
 832
 833 #undef mvwaddch
 834 int     mvwaddch(
 835                 WINDOW  *a1,
 836                 int     a2,
 837                 int     a3,
 838                 const chtype z)
 839                 { return(*(int *)0); }
 840
 841 #undef mvwaddchnstr
 842 int     mvwaddchnstr(
 843                 WINDOW  *a1,
 844                 int     a2,
 845                 int     a3,
 846                 const chtype *a4,
 847                 int     z)
 848                 { return(*(int *)0); }
 849
 850 #undef mvwaddchstr
 851 int     mvwaddchstr(
 852                 WINDOW  *a1,
 853                 int     a2,
 854                 int     a3,
 855                 const chtype *z)
 856                 { return(*(int *)0); }
 857
 858 #undef mvwaddnstr
 859 int     mvwaddnstr(
 860                 WINDOW  *a1,
 861                 int     a2,
 862                 int     a3,
 863                 const char *a4,
 864                 int     z)
 865                 { return(*(int *)0); }
 866
 867 #undef mvwaddstr
 868 int     mvwaddstr(
 869                 WINDOW  *a1,
 870                 int     a2,
 871                 int     a3,
 872                 const char *z)
 873                 { return(*(int *)0); }
 874
 875 #undef mvwchgat
 876 int     mvwchgat(
 877                 WINDOW  *a1,
 878                 int     a2,
 879                 int     a3,
 880                 int     a4,
 881                 attr_t  a5,
 882                 short   a6,
 883                 const void *z)
 884                 { return(*(int *)0); }
 885
 886 #undef mvwdelch
 887 int     mvwdelch(
 888                 WINDOW  *a1,
 889                 int     a2,
 890                 int     z)
 891                 { return(*(int *)0); }
 892
 893 #undef mvwgetch
 894 int     mvwgetch(
 895                 WINDOW  *a1,
 896                 int     a2,
 897                 int     z)
 898                 { return(*(int *)0); }
 899
 900 #undef mvwgetnstr
 901 int     mvwgetnstr(
 902                 WINDOW  *a1,
 903                 int     a2,
 904                 int     a3,
 905                 char    *a4,
 906                 int     z)
 907                 { return(*(int *)0); }
 908
 909 #undef mvwgetstr
 910 int     mvwgetstr(
 911                 WINDOW  *a1,
 912                 int     a2,
 913                 int     a3,
 914                 char    *z)
 915                 { return(*(int *)0); }
 916
 917 #undef mvwhline
 918 int     mvwhline(
 919                 WINDOW  *a1,
 920                 int     a2,
 921                 int     a3,
 922                 chtype  a4,
 923                 int     z)
 924                 { return(*(int *)0); }
 925
 926 #undef mvwinch
 927 chtype  mvwinch(
 928                 WINDOW  *a1,
 929                 int     a2,
 930                 int     z)
 931                 { return(*(chtype *)0); }
 932
 933 #undef mvwinchnstr
 934 int     mvwinchnstr(
 935                 WINDOW  *a1,
 936                 int     a2,
 937                 int     a3,
 938                 chtype  *a4,
 939                 int     z)
 940                 { return(*(int *)0); }
 941
 942 #undef mvwinchstr
 943 int     mvwinchstr(
 944                 WINDOW  *a1,
 945                 int     a2,
 946                 int     a3,
 947                 chtype  *z)
 948                 { return(*(int *)0); }
 949
 950 #undef mvwinnstr
 951 int     mvwinnstr(
 952                 WINDOW  *a1,
 953                 int     a2,
 954                 int     a3,
 955                 char    *a4,
 956                 int     z)
 957                 { return(*(int *)0); }
 958
 959 #undef mvwinsch
 960 int     mvwinsch(
 961                 WINDOW  *a1,
 962                 int     a2,
 963                 int     a3,
 964                 chtype  z)
 965                 { return(*(int *)0); }
 966
 967 #undef mvwinsnstr
 968 int     mvwinsnstr(
 969                 WINDOW  *a1,
 970                 int     a2,
 971                 int     a3,
 972                 const char *a4,
 973                 int     z)
 974                 { return(*(int *)0); }
 975
 976 #undef mvwinsstr
 977 int     mvwinsstr(
 978                 WINDOW  *a1,
 979                 int     a2,
 980                 int     a3,
 981                 const char *z)
 982                 { return(*(int *)0); }
 983
 984 #undef mvwinstr
 985 int     mvwinstr(
 986                 WINDOW  *a1,
 987                 int     a2,
 988                 int     a3,
 989                 char    *z)
 990                 { return(*(int *)0); }
 991
 992 #undef mvwvline
 993 int     mvwvline(
 994                 WINDOW  *a1,
 995                 int     a2,
 996                 int     a3,
 997                 chtype  a4,
 998                 int     z)
 999                 { return(*(int *)0); }
1000
1001 #undef PAIR_NUMBER
1002 int     PAIR_NUMBER(
1003                 int     z)
1004                 { return(*(int *)0); }
1005
1006 #undef redrawwin
1007 int     redrawwin(
1008                 WINDOW  *z)
1009                 { return(*(int *)0); }
1010
1011 #undef refresh
1012 int     refresh(void)
1013                 { return(*(int *)0); }
1014
1015 #undef scrl
1016 int     scrl(
1017                 int     z)
1018                 { return(*(int *)0); }
1019
1020 #undef scroll
1021 int     scroll(
1022                 WINDOW  *z)
1023                 { return(*(int *)0); }
1024
1025 #undef setscrreg
1026 int     setscrreg(
1027                 int     a1,
1028                 int     z)
1029                 { return(*(int *)0); }
1030
1031 #undef slk_attr_off
1032 int     slk_attr_off(
1033                 const attr_t a1,
1034                 void    *z)
1035                 { return(*(int *)0); }
1036
1037 #undef slk_attr_on
1038 int     slk_attr_on(
1039                 attr_t  a1,
1040                 void    *z)
1041                 { return(*(int *)0); }
1042
1043 #undef standout
1044 int     standout(void)
1045                 { return(*(int *)0); }
1046
1047 #undef standend
1048 int     standend(void)
1049                 { return(*(int *)0); }
1050
1051 #undef timeout
1052 void    timeout(
1053                 int     z)
1054                 { /* void */ }
1055
1056 #undef touchline
1057 int     touchline(
1058                 WINDOW  *a1,
1059                 int     a2,
1060                 int     z)
1061                 { return(*(int *)0); }
1062
1063 #undef touchwin
1064 int     touchwin(
1065                 WINDOW  *z)
1066                 { return(*(int *)0); }
1067
1068 #undef untouchwin
1069 int     untouchwin(
1070                 WINDOW  *z)
1071                 { return(*(int *)0); }
1072
1073 #undef vline
1074 int     vline(
1075                 chtype  a1,
1076                 int     z)
1077                 { return(*(int *)0); }
1078
1079 #undef vw_printw
1080 int     vw_printw(
1081                 WINDOW  *a1,
1082                 const char *a2,
1083                 va_list z)
1084                 { return(*(int *)0); }
1085
1086 #undef vw_scanw
1087 int     vw_scanw(
1088                 WINDOW  *a1,
1089                 char    *a2,
1090                 va_list z)
1091                 { return(*(int *)0); }
1092
1093 #undef waddchstr
1094 int     waddchstr(
1095                 WINDOW  *a1,
1096                 const chtype *z)
1097                 { return(*(int *)0); }
1098
1099 #undef waddstr
1100 int     waddstr(
1101                 WINDOW  *a1,
1102                 const char *z)
1103                 { return(*(int *)0); }
1104
1105 #undef wattron
1106 int     wattron(
1107                 WINDOW  *a1,
1108                 int     z)
1109                 { return(*(int *)0); }
1110
1111 #undef wattroff
1112 int     wattroff(
1113                 WINDOW  *a1,
1114                 int     z)
1115                 { return(*(int *)0); }
1116
1117 #undef wattrset
1118 int     wattrset(
1119                 WINDOW  *a1,
1120                 int     z)
1121                 { return(*(int *)0); }
1122
1123 #undef wattr_get
1124 int     wattr_get(
1125                 WINDOW  *a1,
1126                 attr_t  *a2,
1127                 short   *a3,
1128                 void    *z)
1129                 { return(*(int *)0); }
1130
1131 #undef wattr_set
1132 int     wattr_set(
1133                 WINDOW  *a1,
1134                 attr_t  a2,
1135                 short   a3,
1136                 void    *z)
1137                 { return(*(int *)0); }
1138
1139 #undef wdeleteln
1140 int     wdeleteln(
1141                 WINDOW  *z)
1142                 { return(*(int *)0); }
1143
1144 #undef wgetstr
1145 int     wgetstr(
1146                 WINDOW  *a1,
1147                 char    *z)
1148                 { return(*(int *)0); }
1149
1150 #undef winchstr
1151 int     winchstr(
1152                 WINDOW  *a1,
1153                 chtype  *z)
1154                 { return(*(int *)0); }
1155
1156 #undef winsertln
1157 int     winsertln(
1158                 WINDOW  *z)
1159                 { return(*(int *)0); }
1160
1161 #undef winsstr
1162 int     winsstr(
1163                 WINDOW  *a1,
1164                 const char *z)
1165                 { return(*(int *)0); }
1166
1167 #undef winstr
1168 int     winstr(
1169                 WINDOW  *a1,
1170                 char    *z)
1171                 { return(*(int *)0); }
1172
1173 #undef wstandout
1174 int     wstandout(
1175                 WINDOW  *z)
1176                 { return(*(int *)0); }
1177
1178 #undef wstandend
1179 int     wstandend(
1180                 WINDOW  *z)
1181                 { return(*(int *)0); }
1182
1183 #undef getattrs
1184 int     getattrs(
1185                 const WINDOW *z)
1186                 { return(*(int *)0); }
1187
1188 #undef getcurx
1189 int     getcurx(
1190                 const WINDOW *z)
1191                 { return(*(int *)0); }
1192
1193 #undef getcury
1194 int     getcury(
1195                 const WINDOW *z)
1196                 { return(*(int *)0); }
1197
1198 #undef getbegx
1199 int     getbegx(
1200                 const WINDOW *z)
1201                 { return(*(int *)0); }
1202
1203 #undef getbegy
1204 int     getbegy(
1205                 const WINDOW *z)
1206                 { return(*(int *)0); }
1207
1208 #undef getmaxx
1209 int     getmaxx(
1210                 const WINDOW *z)
1211                 { return(*(int *)0); }
1212
1213 #undef getmaxy
1214 int     getmaxy(
1215                 const WINDOW *z)
1216                 { return(*(int *)0); }
1217
1218 #undef getparx
1219 int     getparx(
1220                 const WINDOW *z)
1221                 { return(*(int *)0); }
1222
1223 #undef getpary
1224 int     getpary(
1225                 const WINDOW *z)
1226                 { return(*(int *)0); }
1227
1228 #undef wgetparent
1229 WINDOW  *wgetparent(
1230                 const WINDOW *z)
1231                 { return(*(WINDOW **)0); }
1232
1233 #undef is_cleared
1234 NCURSES_BOOL is_cleared(
1235                 const WINDOW *z)
1236                 { return(*(NCURSES_BOOL *)0); }
1237
1238 #undef is_idcok
1239 NCURSES_BOOL is_idcok(
1240                 const WINDOW *z)
1241                 { return(*(NCURSES_BOOL *)0); }
1242
1243 #undef is_idlok
1244 NCURSES_BOOL is_idlok(
1245                 const WINDOW *z)
1246                 { return(*(NCURSES_BOOL *)0); }
1247
1248 #undef is_immedok
1249 NCURSES_BOOL is_immedok(
1250                 const WINDOW *z)
1251                 { return(*(NCURSES_BOOL *)0); }
1252
1253 #undef is_keypad
1254 NCURSES_BOOL is_keypad(
1255                 const WINDOW *z)
1256                 { return(*(NCURSES_BOOL *)0); }
1257
1258 #undef is_leaveok
1259 NCURSES_BOOL is_leaveok(
1260                 const WINDOW *z)
1261                 { return(*(NCURSES_BOOL *)0); }
1262
1263 #undef is_nodelay
1264 NCURSES_BOOL is_nodelay(
1265                 const WINDOW *z)
1266                 { return(*(NCURSES_BOOL *)0); }
1267
1268 #undef is_notimeout
1269 NCURSES_BOOL is_notimeout(
1270                 const WINDOW *z)
1271                 { return(*(NCURSES_BOOL *)0); }
1272
1273 #undef is_pad
1274 NCURSES_BOOL is_pad(
1275                 const WINDOW *z)
1276                 { return(*(NCURSES_BOOL *)0); }
1277
1278 #undef is_scrollok
1279 NCURSES_BOOL is_scrollok(
1280                 const WINDOW *z)
1281                 { return(*(NCURSES_BOOL *)0); }
1282
1283 #undef is_subwin
1284 NCURSES_BOOL is_subwin(
1285                 const WINDOW *z)
1286                 { return(*(NCURSES_BOOL *)0); }
1287
1288 #undef is_syncok
1289 NCURSES_BOOL is_syncok(
1290                 const WINDOW *z)
1291                 { return(*(NCURSES_BOOL *)0); }
1292
1293 #undef wgetscrreg
1294 int     wgetscrreg(
1295                 const WINDOW *a1,
1296                 int     *a2,
1297                 int     *z)
1298                 { return(*(int *)0); }
1299
1300 #undef add_wch
1301 int     add_wch(
1302                 const cchar_t *z)
1303                 { return(*(int *)0); }
1304
1305 #undef add_wchnstr
1306 int     add_wchnstr(
1307                 const cchar_t *a1,
1308                 int     z)
1309                 { return(*(int *)0); }
1310
1311 #undef add_wchstr
1312 int     add_wchstr(
1313                 const cchar_t *z)
1314                 { return(*(int *)0); }
1315
1316 #undef addnwstr
1317 int     addnwstr(
1318                 const wchar_t *a1,
1319                 int     z)
1320                 { return(*(int *)0); }
1321
1322 #undef addwstr
1323 int     addwstr(
1324                 const wchar_t *z)
1325                 { return(*(int *)0); }
1326
1327 #undef bkgrnd
1328 int     bkgrnd(
1329                 const cchar_t *z)
1330                 { return(*(int *)0); }
1331
1332 #undef bkgrndset
1333 void    bkgrndset(
1334                 const cchar_t *z)
1335                 { /* void */ }
1336
1337 #undef border_set
1338 int     border_set(
1339                 const cchar_t *a1,
1340                 const cchar_t *a2,
1341                 const cchar_t *a3,
1342                 const cchar_t *a4,
1343                 const cchar_t *a5,
1344                 const cchar_t *a6,
1345                 const cchar_t *a7,
1346                 const cchar_t *z)
1347                 { return(*(int *)0); }
1348
1349 #undef box_set
1350 int     box_set(
1351                 WINDOW  *a1,
1352                 const cchar_t *a2,
1353                 const cchar_t *z)
1354                 { return(*(int *)0); }
1355
1356 #undef echo_wchar
1357 int     echo_wchar(
1358                 const cchar_t *z)
1359                 { return(*(int *)0); }
1360
1361 #undef get_wch
1362 int     get_wch(
1363                 wint_t  *z)
1364                 { return(*(int *)0); }
1365
1366 #undef get_wstr
1367 int     get_wstr(
1368                 wint_t  *z)
1369                 { return(*(int *)0); }
1370
1371 #undef getbkgrnd
1372 int     getbkgrnd(
1373                 cchar_t *z)
1374                 { return(*(int *)0); }
1375
1376 #undef getn_wstr
1377 int     getn_wstr(
1378                 wint_t  *a1,
1379                 int     z)
1380                 { return(*(int *)0); }
1381
1382 #undef hline_set
1383 int     hline_set(
1384                 const cchar_t *a1,
1385                 int     z)
1386                 { return(*(int *)0); }
1387
1388 #undef in_wch
1389 int     in_wch(
1390                 cchar_t *z)
1391                 { return(*(int *)0); }
1392
1393 #undef in_wchnstr
1394 int     in_wchnstr(
1395                 cchar_t *a1,
1396                 int     z)
1397                 { return(*(int *)0); }
1398
1399 #undef in_wchstr
1400 int     in_wchstr(
1401                 cchar_t *z)
1402                 { return(*(int *)0); }
1403
1404 #undef innwstr
1405 int     innwstr(
1406                 wchar_t *a1,
1407                 int     z)
1408                 { return(*(int *)0); }
1409
1410 #undef ins_nwstr
1411 int     ins_nwstr(
1412                 const wchar_t *a1,
1413                 int     z)
1414                 { return(*(int *)0); }
1415
1416 #undef ins_wch
1417 int     ins_wch(
1418                 const cchar_t *z)
1419                 { return(*(int *)0); }
1420
1421 #undef ins_wstr
1422 int     ins_wstr(
1423                 const wchar_t *z)
1424                 { return(*(int *)0); }
1425
1426 #undef inwstr
1427 int     inwstr(
1428                 wchar_t *z)
1429                 { return(*(int *)0); }
1430
1431 #undef mvadd_wch
1432 int     mvadd_wch(
1433                 int     a1,
1434                 int     a2,
1435                 const cchar_t *z)
1436                 { return(*(int *)0); }
1437
1438 #undef mvadd_wchnstr
1439 int     mvadd_wchnstr(
1440                 int     a1,
1441                 int     a2,
1442                 const cchar_t *a3,
1443                 int     z)
1444                 { return(*(int *)0); }
1445
1446 #undef mvadd_wchstr
1447 int     mvadd_wchstr(
1448                 int     a1,
1449                 int     a2,
1450                 const cchar_t *z)
1451                 { return(*(int *)0); }
1452
1453 #undef mvaddnwstr
1454 int     mvaddnwstr(
1455                 int     a1,
1456                 int     a2,
1457                 const wchar_t *a3,
1458                 int     z)
1459                 { return(*(int *)0); }
1460
1461 #undef mvaddwstr
1462 int     mvaddwstr(
1463                 int     a1,
1464                 int     a2,
1465                 const wchar_t *z)
1466                 { return(*(int *)0); }
1467
1468 #undef mvget_wch
1469 int     mvget_wch(
1470                 int     a1,
1471                 int     a2,
1472                 wint_t  *z)
1473                 { return(*(int *)0); }
1474
1475 #undef mvget_wstr
1476 int     mvget_wstr(
1477                 int     a1,
1478                 int     a2,
1479                 wint_t  *z)
1480                 { return(*(int *)0); }
1481
1482 #undef mvgetn_wstr
1483 int     mvgetn_wstr(
1484                 int     a1,
1485                 int     a2,
1486                 wint_t  *a3,
1487                 int     z)
1488                 { return(*(int *)0); }
1489
1490 #undef mvhline_set
1491 int     mvhline_set(
1492                 int     a1,
1493                 int     a2,
1494                 const cchar_t *a3,
1495                 int     z)
1496                 { return(*(int *)0); }
1497
1498 #undef mvin_wch
1499 int     mvin_wch(
1500                 int     a1,
1501                 int     a2,
1502                 cchar_t *z)
1503                 { return(*(int *)0); }
1504
1505 #undef mvin_wchnstr
1506 int     mvin_wchnstr(
1507                 int     a1,
1508                 int     a2,
1509                 cchar_t *a3,
1510                 int     z)
1511                 { return(*(int *)0); }
1512
1513 #undef mvin_wchstr
1514 int     mvin_wchstr(
1515                 int     a1,
1516                 int     a2,
1517                 cchar_t *z)
1518                 { return(*(int *)0); }
1519
1520 #undef mvinnwstr
1521 int     mvinnwstr(
1522                 int     a1,
1523                 int     a2,
1524                 wchar_t *a3,
1525                 int     z)
1526                 { return(*(int *)0); }
1527
1528 #undef mvins_nwstr
1529 int     mvins_nwstr(
1530                 int     a1,
1531                 int     a2,
1532                 const wchar_t *a3,
1533                 int     z)
1534                 { return(*(int *)0); }
1535
1536 #undef mvins_wch
1537 int     mvins_wch(
1538                 int     a1,
1539                 int     a2,
1540                 const cchar_t *z)
1541                 { return(*(int *)0); }
1542
1543 #undef mvins_wstr
1544 int     mvins_wstr(
1545                 int     a1,
1546                 int     a2,
1547                 const wchar_t *z)
1548                 { return(*(int *)0); }
1549
1550 #undef mvinwstr
1551 int     mvinwstr(
1552                 int     a1,
1553                 int     a2,
1554                 wchar_t *z)
1555                 { return(*(int *)0); }
1556
1557 #undef mvvline_set
1558 int     mvvline_set(
1559                 int     a1,
1560                 int     a2,
1561                 const cchar_t *a3,
1562                 int     z)
1563                 { return(*(int *)0); }
1564
1565 #undef mvwadd_wch
1566 int     mvwadd_wch(
1567                 WINDOW  *a1,
1568                 int     a2,
1569                 int     a3,
1570                 const cchar_t *z)
1571                 { return(*(int *)0); }
1572
1573 #undef mvwadd_wchnstr
1574 int     mvwadd_wchnstr(
1575                 WINDOW  *a1,
1576                 int     a2,
1577                 int     a3,
1578                 const cchar_t *a4,
1579                 int     z)
1580                 { return(*(int *)0); }
1581
1582 #undef mvwadd_wchstr
1583 int     mvwadd_wchstr(
1584                 WINDOW  *a1,
1585                 int     a2,
1586                 int     a3,
1587                 const cchar_t *z)
1588                 { return(*(int *)0); }
1589
1590 #undef mvwaddnwstr
1591 int     mvwaddnwstr(
1592                 WINDOW  *a1,
1593                 int     a2,
1594                 int     a3,
1595                 const wchar_t *a4,
1596                 int     z)
1597                 { return(*(int *)0); }
1598
1599 #undef mvwaddwstr
1600 int     mvwaddwstr(
1601                 WINDOW  *a1,
1602                 int     a2,
1603                 int     a3,
1604                 const wchar_t *z)
1605                 { return(*(int *)0); }
1606
1607 #undef mvwget_wch
1608 int     mvwget_wch(
1609                 WINDOW  *a1,
1610                 int     a2,
1611                 int     a3,
1612                 wint_t  *z)
1613                 { return(*(int *)0); }
1614
1615 #undef mvwget_wstr
1616 int     mvwget_wstr(
1617                 WINDOW  *a1,
1618                 int     a2,
1619                 int     a3,
1620                 wint_t  *z)
1621                 { return(*(int *)0); }
1622
1623 #undef mvwgetn_wstr
1624 int     mvwgetn_wstr(
1625                 WINDOW  *a1,
1626                 int     a2,
1627                 int     a3,
1628                 wint_t  *a4,
1629                 int     z)
1630                 { return(*(int *)0); }
1631
1632 #undef mvwhline_set
1633 int     mvwhline_set(
1634                 WINDOW  *a1,
1635                 int     a2,
1636                 int     a3,
1637                 const cchar_t *a4,
1638                 int     z)
1639                 { return(*(int *)0); }
1640
1641 #undef mvwin_wch
1642 int     mvwin_wch(
1643                 WINDOW  *a1,
1644                 int     a2,
1645                 int     a3,
1646                 cchar_t *z)
1647                 { return(*(int *)0); }
1648
1649 #undef mvwin_wchnstr
1650 int     mvwin_wchnstr(
1651                 WINDOW  *a1,
1652                 int     a2,
1653                 int     a3,
1654                 cchar_t *a4,
1655                 int     z)
1656                 { return(*(int *)0); }
1657
1658 #undef mvwin_wchstr
1659 int     mvwin_wchstr(
1660                 WINDOW  *a1,
1661                 int     a2,
1662                 int     a3,
1663                 cchar_t *z)
1664                 { return(*(int *)0); }
1665
1666 #undef mvwinnwstr
1667 int     mvwinnwstr(
1668                 WINDOW  *a1,
1669                 int     a2,
1670                 int     a3,
1671                 wchar_t *a4,
1672                 int     z)
1673                 { return(*(int *)0); }
1674
1675 #undef mvwins_nwstr
1676 int     mvwins_nwstr(
1677                 WINDOW  *a1,
1678                 int     a2,
1679                 int     a3,
1680                 const wchar_t *a4,
1681                 int     z)
1682                 { return(*(int *)0); }
1683
1684 #undef mvwins_wch
1685 int     mvwins_wch(
1686                 WINDOW  *a1,
1687                 int     a2,
1688                 int     a3,
1689                 const cchar_t *z)
1690                 { return(*(int *)0); }
1691
1692 #undef mvwins_wstr
1693 int     mvwins_wstr(
1694                 WINDOW  *a1,
1695                 int     a2,
1696                 int     a3,
1697                 const wchar_t *z)
1698                 { return(*(int *)0); }
1699
1700 #undef mvwinwstr
1701 int     mvwinwstr(
1702                 WINDOW  *a1,
1703                 int     a2,
1704                 int     a3,
1705                 wchar_t *z)
1706                 { return(*(int *)0); }
1707
1708 #undef mvwvline_set
1709 int     mvwvline_set(
1710                 WINDOW  *a1,
1711                 int     a2,
1712                 int     a3,
1713                 const cchar_t *a4,
1714                 int     z)
1715                 { return(*(int *)0); }
1716
1717 #undef vline_set
1718 int     vline_set(
1719                 const cchar_t *a1,
1720                 int     z)
1721                 { return(*(int *)0); }
1722
1723 #undef wadd_wchstr
1724 int     wadd_wchstr(
1725                 WINDOW  *a1,
1726                 const cchar_t *z)
1727                 { return(*(int *)0); }
1728
1729 #undef waddwstr
1730 int     waddwstr(
1731                 WINDOW  *a1,
1732                 const wchar_t *z)
1733                 { return(*(int *)0); }
1734
1735 #undef wget_wstr
1736 int     wget_wstr(
1737                 WINDOW  *a1,
1738                 wint_t  *z)
1739                 { return(*(int *)0); }
1740
1741 #undef wgetbkgrnd
1742 int     wgetbkgrnd(
1743                 WINDOW  *a1,
1744                 cchar_t *z)
1745                 { return(*(int *)0); }
1746
1747 #undef win_wchstr
1748 int     win_wchstr(
1749                 WINDOW  *a1,
1750                 cchar_t *z)
1751                 { return(*(int *)0); }
1752
1753 #undef wins_wstr
1754 int     wins_wstr(
1755                 WINDOW  *a1,
1756                 const wchar_t *z)
1757                 { return(*(int *)0); }
1758
1759 #undef mouse_trafo
1760 NCURSES_BOOL mouse_trafo(
1761                 int     *a1,
1762                 int     *a2,
1763                 NCURSES_BOOL z)
1764                 { return(*(NCURSES_BOOL *)0); }
1765
1766 /* ./base/lib_getch.c */
1767
1768 #include <fifo_defs.h>
1769
1770 #undef ESCDELAY
1771 int     ESCDELAY;
1772
1773 #undef set_escdelay_sp
1774 int     set_escdelay_sp(
1775                 SCREEN  *sp,
1776                 int     value)
1777                 { return(*(int *)0); }
1778
1779 #undef set_escdelay
1780 int     set_escdelay(
1781                 int     value)
1782                 { return(*(int *)0); }
1783
1784 #undef get_escdelay_sp
1785 int     get_escdelay_sp(
1786                 SCREEN  *sp)
1787                 { return(*(int *)0); }
1788
1789 #undef get_escdelay
1790 int     get_escdelay(void)
1791                 { return(*(int *)0); }
1792
1793 #undef _nc_wgetch
1794 int     _nc_wgetch(
1795                 WINDOW  *win,
1796                 int     *result,
1797                 int     use_meta)
1798                 { return(*(int *)0); }
1799
1800 #undef wgetch
1801 int     wgetch(
1802                 WINDOW  *win)
1803                 { return(*(int *)0); }
1804
1805 /* ./base/lib_getstr.c */
1806
1807 #undef wgetnstr
1808 int     wgetnstr(
1809                 WINDOW  *win,
1810                 char    *str,
1811                 int     maxlen)
1812                 { return(*(int *)0); }
1813
1814 /* ./base/lib_hline.c */
1815
1816 #undef whline
1817 int     whline(
1818                 WINDOW  *win,
1819                 chtype  ch,
1820                 int     n)
1821                 { return(*(int *)0); }
1822
1823 /* ./base/lib_immedok.c */
1824
1825 #undef immedok
1826 void    immedok(
1827                 WINDOW  *win,
1828                 NCURSES_BOOL flag)
1829                 { /* void */ }
1830
1831 /* ./base/lib_inchstr.c */
1832
1833 #undef winchnstr
1834 int     winchnstr(
1835                 WINDOW  *win,
1836                 chtype  *str,
1837                 int     n)
1838                 { return(*(int *)0); }
1839
1840 /* ./base/lib_initscr.c */
1841
1842 #undef initscr
1843 WINDOW  *initscr(void)
1844                 { return(*(WINDOW **)0); }
1845
1846 /* ./base/lib_insch.c */
1847
1848 #undef _nc_insert_ch
1849 int     _nc_insert_ch(
1850                 SCREEN  *sp,
1851                 WINDOW  *win,
1852                 chtype  ch)
1853                 { return(*(int *)0); }
1854
1855 #undef winsch
1856 int     winsch(
1857                 WINDOW  *win,
1858                 chtype  c)
1859                 { return(*(int *)0); }
1860
1861 /* ./base/lib_insdel.c */
1862
1863 #undef winsdelln
1864 int     winsdelln(
1865                 WINDOW  *win,
1866                 int     n)
1867                 { return(*(int *)0); }
1868
1869 /* ./base/lib_insnstr.c */
1870
1871 #undef winsnstr
1872 int     winsnstr(
1873                 WINDOW  *win,
1874                 const char *s,
1875                 int     n)
1876                 { return(*(int *)0); }
1877
1878 /* ./base/lib_instr.c */
1879
1880 #undef winnstr
1881 int     winnstr(
1882                 WINDOW  *win,
1883                 char    *str,
1884                 int     n)
1885                 { return(*(int *)0); }
1886
1887 /* ./base/lib_isendwin.c */
1888
1889 #undef isendwin_sp
1890 NCURSES_BOOL isendwin_sp(
1891                 SCREEN  *sp)
1892                 { return(*(NCURSES_BOOL *)0); }
1893
1894 #undef isendwin
1895 NCURSES_BOOL isendwin(void)
1896                 { return(*(NCURSES_BOOL *)0); }
1897
1898 /* ./base/lib_leaveok.c */
1899
1900 #undef leaveok
1901 int     leaveok(
1902                 WINDOW  *win,
1903                 NCURSES_BOOL flag)
1904                 { return(*(int *)0); }
1905
1906 /* ./base/lib_mouse.c */
1907
1908 #undef getmouse_sp
1909 int     getmouse_sp(
1910                 SCREEN  *sp,
1911                 MEVENT  *aevent)
1912                 { return(*(int *)0); }
1913
1914 #undef getmouse
1915 int     getmouse(
1916                 MEVENT  *aevent)
1917                 { return(*(int *)0); }
1918
1919 #undef ungetmouse_sp
1920 int     ungetmouse_sp(
1921                 SCREEN  *sp,
1922                 MEVENT  *aevent)
1923                 { return(*(int *)0); }
1924
1925 #undef ungetmouse
1926 int     ungetmouse(
1927                 MEVENT  *aevent)
1928                 { return(*(int *)0); }
1929
1930 #undef mousemask_sp
1931 mmask_t mousemask_sp(
1932                 SCREEN  *sp,
1933                 mmask_t newmask,
1934                 mmask_t *oldmask)
1935                 { return(*(mmask_t *)0); }
1936
1937 #undef mousemask
1938 mmask_t mousemask(
1939                 mmask_t newmask,
1940                 mmask_t *oldmask)
1941                 { return(*(mmask_t *)0); }
1942
1943 #undef wenclose
1944 NCURSES_BOOL wenclose(
1945                 const WINDOW *win,
1946                 int     y,
1947                 int     x)
1948                 { return(*(NCURSES_BOOL *)0); }
1949
1950 #undef mouseinterval_sp
1951 int     mouseinterval_sp(
1952                 SCREEN  *sp,
1953                 int     maxclick)
1954                 { return(*(int *)0); }
1955
1956 #undef mouseinterval
1957 int     mouseinterval(
1958                 int     maxclick)
1959                 { return(*(int *)0); }
1960
1961 #undef _nc_has_mouse
1962 NCURSES_BOOL _nc_has_mouse(
1963                 SCREEN  *sp)
1964                 { return(*(NCURSES_BOOL *)0); }
1965
1966 #undef has_mouse_sp
1967 NCURSES_BOOL has_mouse_sp(
1968                 SCREEN  *sp)
1969                 { return(*(NCURSES_BOOL *)0); }
1970
1971 #undef has_mouse
1972 NCURSES_BOOL has_mouse(void)
1973                 { return(*(NCURSES_BOOL *)0); }
1974
1975 #undef wmouse_trafo
1976 NCURSES_BOOL wmouse_trafo(
1977                 const WINDOW *win,
1978                 int     *pY,
1979                 int     *pX,
1980                 NCURSES_BOOL to_screen)
1981                 { return(*(NCURSES_BOOL *)0); }
1982
1983 /* ./base/lib_move.c */
1984
1985 #undef wmove
1986 int     wmove(
1987                 WINDOW  *win,
1988                 int     y,
1989                 int     x)
1990                 { return(*(int *)0); }
1991
1992 /* ./tty/lib_mvcur.c */
1993
1994 #undef _nc_msec_cost_sp
1995 int     _nc_msec_cost_sp(
1996                 SCREEN  *sp,
1997                 const char *const cap,
1998                 int     affcnt)
1999                 { return(*(int *)0); }
2000
2001 #undef _nc_msec_cost
2002 int     _nc_msec_cost(
2003                 const char *const cap,
2004                 int     affcnt)
2005                 { return(*(int *)0); }
2006
2007 #undef _nc_mvcur_resume_sp
2008 void    _nc_mvcur_resume_sp(
2009                 SCREEN  *sp)
2010                 { /* void */ }
2011
2012 #undef _nc_mvcur_resume
2013 void    _nc_mvcur_resume(void)
2014                 { /* void */ }
2015
2016 #undef _nc_mvcur_init_sp
2017 void    _nc_mvcur_init_sp(
2018                 SCREEN  *sp)
2019                 { /* void */ }
2020
2021 #undef _nc_mvcur_init
2022 void    _nc_mvcur_init(void)
2023                 { /* void */ }
2024
2025 #undef _nc_mvcur_wrap_sp
2026 void    _nc_mvcur_wrap_sp(
2027                 SCREEN  *sp)
2028                 { /* void */ }
2029
2030 #undef _nc_mvcur_wrap
2031 void    _nc_mvcur_wrap(void)
2032                 { /* void */ }
2033
2034 #undef mvcur_sp
2035 int     mvcur_sp(
2036                 SCREEN  *sp,
2037                 int     yold,
2038                 int     xold,
2039                 int     ynew,
2040                 int     xnew)
2041                 { return(*(int *)0); }
2042
2043 #undef mvcur
2044 int     mvcur(
2045                 int     yold,
2046                 int     xold,
2047                 int     ynew,
2048                 int     xnew)
2049                 { return(*(int *)0); }
2050
2051 #undef _nc_optimize_enable
2052 int     _nc_optimize_enable;
2053
2054 /* ./base/lib_mvwin.c */
2055
2056 #undef mvwin
2057 int     mvwin(
2058                 WINDOW  *win,
2059                 int     by,
2060                 int     bx)
2061                 { return(*(int *)0); }
2062
2063 /* ./base/lib_newterm.c */
2064
2065 #undef filter_sp
2066 void    filter_sp(
2067                 SCREEN  *sp)
2068                 { /* void */ }
2069
2070 #undef filter
2071 void    filter(void)
2072                 { /* void */ }
2073
2074 #undef nofilter_sp
2075 void    nofilter_sp(
2076                 SCREEN  *sp)
2077                 { /* void */ }
2078
2079 #undef nofilter
2080 void    nofilter(void)
2081                 { /* void */ }
2082
2083 #undef newterm_sp
2084 SCREEN  *newterm_sp(
2085                 SCREEN  *sp,
2086                 char    *name,
2087                 FILE    *ofp,
2088                 FILE    *ifp)
2089                 { return(*(SCREEN **)0); }
2090
2091 #undef newterm
2092 SCREEN  *newterm(
2093                 char    *name,
2094                 FILE    *ofp,
2095                 FILE    *ifp)
2096                 { return(*(SCREEN **)0); }
2097
2098 /* ./base/lib_newwin.c */
2099
2100 #undef _nc_freewin
2101 int     _nc_freewin(
2102                 WINDOW  *win)
2103                 { return(*(int *)0); }
2104
2105 #undef newwin_sp
2106 WINDOW  *newwin_sp(
2107                 SCREEN  *sp,
2108                 int     num_lines,
2109                 int     num_columns,
2110                 int     begy,
2111                 int     begx)
2112                 { return(*(WINDOW **)0); }
2113
2114 #undef newwin
2115 WINDOW  *newwin(
2116                 int     num_lines,
2117                 int     num_columns,
2118                 int     begy,
2119                 int     begx)
2120                 { return(*(WINDOW **)0); }
2121
2122 #undef derwin
2123 WINDOW  *derwin(
2124                 WINDOW  *orig,
2125                 int     num_lines,
2126                 int     num_columns,
2127                 int     begy,
2128                 int     begx)
2129                 { return(*(WINDOW **)0); }
2130
2131 #undef subwin
2132 WINDOW  *subwin(
2133                 WINDOW  *w,
2134                 int     l,
2135                 int     c,
2136                 int     y,
2137                 int     x)
2138                 { return(*(WINDOW **)0); }
2139
2140 #undef _nc_makenew_sp
2141 WINDOW  *_nc_makenew_sp(
2142                 SCREEN  *sp,
2143                 int     num_lines,
2144                 int     num_columns,
2145                 int     begy,
2146                 int     begx,
2147                 int     flags)
2148                 { return(*(WINDOW **)0); }
2149
2150 #undef _nc_curscr_of
2151 WINDOW  *_nc_curscr_of(
2152                 SCREEN  *sp)
2153                 { return(*(WINDOW **)0); }
2154
2155 #undef _nc_newscr_of
2156 WINDOW  *_nc_newscr_of(
2157                 SCREEN  *sp)
2158                 { return(*(WINDOW **)0); }
2159
2160 #undef _nc_stdscr_of
2161 WINDOW  *_nc_stdscr_of(
2162                 SCREEN  *sp)
2163                 { return(*(WINDOW **)0); }
2164
2165 /* ./base/lib_nl.c */
2166
2167 #undef nl_sp
2168 int     nl_sp(
2169                 SCREEN  *sp)
2170                 { return(*(int *)0); }
2171
2172 #undef nl
2173 int     nl(void)
2174                 { return(*(int *)0); }
2175
2176 #undef nonl_sp
2177 int     nonl_sp(
2178                 SCREEN  *sp)
2179                 { return(*(int *)0); }
2180
2181 #undef nonl
2182 int     nonl(void)
2183                 { return(*(int *)0); }
2184
2185 /* ./base/lib_overlay.c */
2186
2187 #undef overlay
2188 int     overlay(
2189                 const WINDOW *win1,
2190                 WINDOW  *win2)
2191                 { return(*(int *)0); }
2192
2193 #undef overwrite
2194 int     overwrite(
2195                 const WINDOW *win1,
2196                 WINDOW  *win2)
2197                 { return(*(int *)0); }
2198
2199 #undef copywin
2200 int     copywin(
2201                 const WINDOW *src,
2202                 WINDOW  *dst,
2203                 int     sminrow,
2204                 int     smincol,
2205                 int     dminrow,
2206                 int     dmincol,
2207                 int     dmaxrow,
2208                 int     dmaxcol,
2209                 int     over)
2210                 { return(*(int *)0); }
2211
2212 /* ./base/lib_pad.c */
2213
2214 #undef newpad_sp
2215 WINDOW  *newpad_sp(
2216                 SCREEN  *sp,
2217                 int     l,
2218                 int     c)
2219                 { return(*(WINDOW **)0); }
2220
2221 #undef newpad
2222 WINDOW  *newpad(
2223                 int     l,
2224                 int     c)
2225                 { return(*(WINDOW **)0); }
2226
2227 #undef subpad
2228 WINDOW  *subpad(
2229                 WINDOW  *orig,
2230                 int     l,
2231                 int     c,
2232                 int     begy,
2233                 int     begx)
2234                 { return(*(WINDOW **)0); }
2235
2236 #undef prefresh
2237 int     prefresh(
2238                 WINDOW  *win,
2239                 int     pminrow,
2240                 int     pmincol,
2241                 int     sminrow,
2242                 int     smincol,
2243                 int     smaxrow,
2244                 int     smaxcol)
2245                 { return(*(int *)0); }
2246
2247 #undef pnoutrefresh
2248 int     pnoutrefresh(
2249                 WINDOW  *win,
2250                 int     pminrow,
2251                 int     pmincol,
2252                 int     sminrow,
2253                 int     smincol,
2254                 int     smaxrow,
2255                 int     smaxcol)
2256                 { return(*(int *)0); }
2257
2258 #undef pechochar
2259 int     pechochar(
2260                 WINDOW  *pad,
2261                 const chtype ch)
2262                 { return(*(int *)0); }
2263
2264 /* ./base/lib_printw.c */
2265
2266 #undef printw
2267 int     printw(
2268                 const char *fmt,
2269                 ...)
2270                 { return(*(int *)0); }
2271
2272 #undef wprintw
2273 int     wprintw(
2274                 WINDOW  *win,
2275                 const char *fmt,
2276                 ...)
2277                 { return(*(int *)0); }
2278
2279 #undef mvprintw
2280 int     mvprintw(
2281                 int     y,
2282                 int     x,
2283                 const char *fmt,
2284                 ...)
2285                 { return(*(int *)0); }
2286
2287 #undef mvwprintw
2288 int     mvwprintw(
2289                 WINDOW  *win,
2290                 int     y,
2291                 int     x,
2292                 const char *fmt,
2293                 ...)
2294                 { return(*(int *)0); }
2295
2296 #undef vwprintw
2297 int     vwprintw(
2298                 WINDOW  *win,
2299                 const char *fmt,
2300                 va_list argp)
2301                 { return(*(int *)0); }
2302
2303 /* ./base/lib_redrawln.c */
2304
2305 #undef wredrawln
2306 int     wredrawln(
2307                 WINDOW  *win,
2308                 int     beg,
2309                 int     num)
2310                 { return(*(int *)0); }
2311
2312 /* ./base/lib_refresh.c */
2313
2314 #undef wrefresh
2315 int     wrefresh(
2316                 WINDOW  *win)
2317                 { return(*(int *)0); }
2318
2319 #undef wnoutrefresh
2320 int     wnoutrefresh(
2321                 WINDOW  *win)
2322                 { return(*(int *)0); }
2323
2324 /* ./base/lib_restart.c */
2325
2326 #undef restartterm_sp
2327 int     restartterm_sp(
2328                 SCREEN  *sp,
2329                 char    *termp,
2330                 int     filenum,
2331                 int     *errret)
2332                 { return(*(int *)0); }
2333
2334 #undef restartterm
2335 int     restartterm(
2336                 char    *termp,
2337                 int     filenum,
2338                 int     *errret)
2339                 { return(*(int *)0); }
2340
2341 /* ./base/lib_scanw.c */
2342
2343 #undef vwscanw
2344 int     vwscanw(
2345                 WINDOW  *win,
2346                 char    *fmt,
2347                 va_list argp)
2348                 { return(*(int *)0); }
2349
2350 #undef scanw
2351 int     scanw(
2352                 char    *fmt,
2353                 ...)
2354                 { return(*(int *)0); }
2355
2356 #undef wscanw
2357 int     wscanw(
2358                 WINDOW  *win,
2359                 char    *fmt,
2360                 ...)
2361                 { return(*(int *)0); }
2362
2363 #undef mvscanw
2364 int     mvscanw(
2365                 int     y,
2366                 int     x,
2367                 char    *fmt,
2368                 ...)
2369                 { return(*(int *)0); }
2370
2371 #undef mvwscanw
2372 int     mvwscanw(
2373                 WINDOW  *win,
2374                 int     y,
2375                 int     x,
2376                 char    *fmt,
2377                 ...)
2378                 { return(*(int *)0); }
2379
2380 /* ./base/lib_screen.c */
2381
2382 #undef getwin_sp
2383 WINDOW  *getwin_sp(
2384                 SCREEN  *sp,
2385                 FILE    *filep)
2386                 { return(*(WINDOW **)0); }
2387
2388 #undef getwin
2389 WINDOW  *getwin(
2390                 FILE    *filep)
2391                 { return(*(WINDOW **)0); }
2392
2393 #undef putwin
2394 int     putwin(
2395                 WINDOW  *win,
2396                 FILE    *filep)
2397                 { return(*(int *)0); }
2398
2399 #undef scr_restore_sp
2400 int     scr_restore_sp(
2401                 SCREEN  *sp,
2402                 const char *file)
2403                 { return(*(int *)0); }
2404
2405 #undef scr_restore
2406 int     scr_restore(
2407                 const char *file)
2408                 { return(*(int *)0); }
2409
2410 #undef scr_dump
2411 int     scr_dump(
2412                 const char *file)
2413                 { return(*(int *)0); }
2414
2415 #undef scr_init_sp
2416 int     scr_init_sp(
2417                 SCREEN  *sp,
2418                 const char *file)
2419                 { return(*(int *)0); }
2420
2421 #undef scr_init
2422 int     scr_init(
2423                 const char *file)
2424                 { return(*(int *)0); }
2425
2426 #undef scr_set_sp
2427 int     scr_set_sp(
2428                 SCREEN  *sp,
2429                 const char *file)
2430                 { return(*(int *)0); }
2431
2432 #undef scr_set
2433 int     scr_set(
2434                 const char *file)
2435                 { return(*(int *)0); }
2436
2437 /* ./base/lib_scroll.c */
2438
2439 #undef _nc_scroll_window
2440 void    _nc_scroll_window(
2441                 WINDOW  *win,
2442                 int const n,
2443                 short const top,
2444                 short const bottom,
2445                 cchar_t blank)
2446                 { /* void */ }
2447
2448 #undef wscrl
2449 int     wscrl(
2450                 WINDOW  *win,
2451                 int     n)
2452                 { return(*(int *)0); }
2453
2454 /* ./base/lib_scrollok.c */
2455
2456 #undef scrollok
2457 int     scrollok(
2458                 WINDOW  *win,
2459                 NCURSES_BOOL flag)
2460                 { return(*(int *)0); }
2461
2462 /* ./base/lib_scrreg.c */
2463
2464 #undef wsetscrreg
2465 int     wsetscrreg(
2466                 WINDOW  *win,
2467                 int     top,
2468                 int     bottom)
2469                 { return(*(int *)0); }
2470
2471 /* ./base/lib_set_term.c */
2472
2473 #undef set_term
2474 SCREEN  *set_term(
2475                 SCREEN  *screenp)
2476                 { return(*(SCREEN **)0); }
2477
2478 #undef delscreen
2479 void    delscreen(
2480                 SCREEN  *sp)
2481                 { /* void */ }
2482
2483 #undef _nc_setupscreen_sp
2484 int     _nc_setupscreen_sp(
2485                 SCREEN  **spp,
2486                 int     slines,
2487                 int     scolumns,
2488                 FILE    *output,
2489                 NCURSES_BOOL filtered,
2490                 int     slk_format)
2491                 { return(*(int *)0); }
2492
2493 #undef _nc_setupscreen
2494 int     _nc_setupscreen(
2495                 int     slines,
2496                 int     scolumns,
2497                 FILE    *output,
2498                 NCURSES_BOOL filtered,
2499                 int     slk_format)
2500                 { return(*(int *)0); }
2501
2502 #undef _nc_ripoffline_sp
2503 int     _nc_ripoffline_sp(
2504                 SCREEN  *sp,
2505                 int     line,
2506                 int     (*init)(
2507                 WINDOW  *p1,
2508                 int     p2))
2509                 { return(*(int *)0); }
2510
2511 #undef _nc_ripoffline
2512 int     _nc_ripoffline(
2513                 int     line,
2514                 int     (*init)(
2515                 WINDOW  *p1,
2516                 int     p2))
2517                 { return(*(int *)0); }
2518
2519 #undef ripoffline_sp
2520 int     ripoffline_sp(
2521                 SCREEN  *sp,
2522                 int     line,
2523                 int     (*init)(
2524                 WINDOW  *p1,
2525                 int     p2))
2526                 { return(*(int *)0); }
2527
2528 #undef ripoffline
2529 int     ripoffline(
2530                 int     line,
2531                 int     (*init)(
2532                 WINDOW  *p1,
2533                 int     p2))
2534                 { return(*(int *)0); }
2535
2536 /* ./base/lib_slk.c */
2537
2538 #undef _nc_format_slks
2539 int     _nc_format_slks(
2540                 SCREEN  *sp,
2541                 int     cols)
2542                 { return(*(int *)0); }
2543
2544 #undef _nc_slk_initialize
2545 int     _nc_slk_initialize(
2546                 WINDOW  *stwin,
2547                 int     cols)
2548                 { return(*(int *)0); }
2549
2550 #undef slk_restore_sp
2551 int     slk_restore_sp(
2552                 SCREEN  *sp)
2553                 { return(*(int *)0); }
2554
2555 #undef slk_restore
2556 int     slk_restore(void)
2557                 { return(*(int *)0); }
2558
2559 /* ./base/lib_slkatr_set.c */
2560
2561 #undef slk_attr_set_sp
2562 int     slk_attr_set_sp(
2563                 SCREEN  *sp,
2564                 const attr_t attr,
2565                 short   color_pair_number,
2566                 void    *opts)
2567                 { return(*(int *)0); }
2568
2569 #undef slk_attr_set
2570 int     slk_attr_set(
2571                 const attr_t attr,
2572                 short   color_pair_number,
2573                 void    *opts)
2574                 { return(*(int *)0); }
2575
2576 /* ./base/lib_slkatrof.c */
2577
2578 #undef slk_attroff_sp
2579 int     slk_attroff_sp(
2580                 SCREEN  *sp,
2581                 const chtype attr)
2582                 { return(*(int *)0); }
2583
2584 #undef slk_attroff
2585 int     slk_attroff(
2586                 const chtype attr)
2587                 { return(*(int *)0); }
2588
2589 /* ./base/lib_slkatron.c */
2590
2591 #undef slk_attron_sp
2592 int     slk_attron_sp(
2593                 SCREEN  *sp,
2594                 const chtype attr)
2595                 { return(*(int *)0); }
2596
2597 #undef slk_attron
2598 int     slk_attron(
2599                 const chtype attr)
2600                 { return(*(int *)0); }
2601
2602 /* ./base/lib_slkatrset.c */
2603
2604 #undef slk_attrset_sp
2605 int     slk_attrset_sp(
2606                 SCREEN  *sp,
2607                 const chtype attr)
2608                 { return(*(int *)0); }
2609
2610 #undef slk_attrset
2611 int     slk_attrset(
2612                 const chtype attr)
2613                 { return(*(int *)0); }
2614
2615 /* ./base/lib_slkattr.c */
2616
2617 #undef slk_attr_sp
2618 attr_t  slk_attr_sp(
2619                 SCREEN  *sp)
2620                 { return(*(attr_t *)0); }
2621
2622 #undef slk_attr
2623 attr_t  slk_attr(void)
2624                 { return(*(attr_t *)0); }
2625
2626 /* ./base/lib_slkclear.c */
2627
2628 #undef slk_clear_sp
2629 int     slk_clear_sp(
2630                 SCREEN  *sp)
2631                 { return(*(int *)0); }
2632
2633 #undef slk_clear
2634 int     slk_clear(void)
2635                 { return(*(int *)0); }
2636
2637 /* ./base/lib_slkcolor.c */
2638
2639 #undef slk_color_sp
2640 int     slk_color_sp(
2641                 SCREEN  *sp,
2642                 short   color_pair_number)
2643                 { return(*(int *)0); }
2644
2645 #undef slk_color
2646 int     slk_color(
2647                 short   color_pair_number)
2648                 { return(*(int *)0); }
2649
2650 /* ./base/lib_slkinit.c */
2651
2652 #undef slk_init_sp
2653 int     slk_init_sp(
2654                 SCREEN  *sp,
2655                 int     format)
2656                 { return(*(int *)0); }
2657
2658 #undef slk_init
2659 int     slk_init(
2660                 int     format)
2661                 { return(*(int *)0); }
2662
2663 /* ./base/lib_slklab.c */
2664
2665 #undef slk_label_sp
2666 char    *slk_label_sp(
2667                 SCREEN  *sp,
2668                 int     n)
2669                 { return(*(char **)0); }
2670
2671 #undef slk_label
2672 char    *slk_label(
2673                 int     n)
2674                 { return(*(char **)0); }
2675
2676 /* ./base/lib_slkrefr.c */
2677
2678 #undef slk_noutrefresh_sp
2679 int     slk_noutrefresh_sp(
2680                 SCREEN  *sp)
2681                 { return(*(int *)0); }
2682
2683 #undef slk_noutrefresh
2684 int     slk_noutrefresh(void)
2685                 { return(*(int *)0); }
2686
2687 #undef slk_refresh_sp
2688 int     slk_refresh_sp(
2689                 SCREEN  *sp)
2690                 { return(*(int *)0); }
2691
2692 #undef slk_refresh
2693 int     slk_refresh(void)
2694                 { return(*(int *)0); }
2695
2696 /* ./base/lib_slkset.c */
2697
2698 #include <wctype.h>
2699
2700 #undef slk_set_sp
2701 int     slk_set_sp(
2702                 SCREEN  *sp,
2703                 int     i,
2704                 const char *astr,
2705                 int     format)
2706                 { return(*(int *)0); }
2707
2708 #undef slk_set
2709 int     slk_set(
2710                 int     i,
2711                 const char *astr,
2712                 int     format)
2713                 { return(*(int *)0); }
2714
2715 /* ./base/lib_slktouch.c */
2716
2717 #undef slk_touch_sp
2718 int     slk_touch_sp(
2719                 SCREEN  *sp)
2720                 { return(*(int *)0); }
2721
2722 #undef slk_touch
2723 int     slk_touch(void)
2724                 { return(*(int *)0); }
2725
2726 /* ./base/lib_touch.c */
2727
2728 #undef is_linetouched
2729 NCURSES_BOOL is_linetouched(
2730                 WINDOW  *win,
2731                 int     line)
2732                 { return(*(NCURSES_BOOL *)0); }
2733
2734 #undef is_wintouched
2735 NCURSES_BOOL is_wintouched(
2736                 WINDOW  *win)
2737                 { return(*(NCURSES_BOOL *)0); }
2738
2739 #undef wtouchln
2740 int     wtouchln(
2741                 WINDOW  *win,
2742                 int     y,
2743                 int     n,
2744                 int     changed)
2745                 { return(*(int *)0); }
2746
2747 /* ./trace/lib_tracedmp.c */
2748
2749 #undef _tracedump
2750 void    _tracedump(
2751                 const char *name,
2752                 WINDOW  *win)
2753                 { /* void */ }
2754
2755 /* ./trace/lib_tracemse.c */
2756
2757 #undef _nc_tracemouse
2758 char    *_nc_tracemouse(
2759                 SCREEN  *sp,
2760                 MEVENT const *ep)
2761                 { return(*(char **)0); }
2762
2763 #undef _nc_retrace_mmask_t
2764 mmask_t _nc_retrace_mmask_t(
2765                 SCREEN  *sp,
2766                 mmask_t code)
2767                 { return(*(mmask_t *)0); }
2768
2769 #undef _tracemouse
2770 char    *_tracemouse(
2771                 MEVENT const *ep)
2772                 { return(*(char **)0); }
2773
2774 /* ./tty/lib_tstp.c */
2775
2776 #include <SigAction.h>
2777
2778 #undef _nc_signal_handler
2779 void    _nc_signal_handler(
2780                 NCURSES_BOOL enable)
2781                 { /* void */ }
2782
2783 /* ./base/lib_ungetch.c */
2784
2785 #undef _nc_fifo_dump
2786 void    _nc_fifo_dump(
2787                 SCREEN  *sp)
2788                 { /* void */ }
2789
2790 #undef ungetch_sp
2791 int     ungetch_sp(
2792                 SCREEN  *sp,
2793                 int     ch)
2794                 { return(*(int *)0); }
2795
2796 #undef ungetch
2797 int     ungetch(
2798                 int     ch)
2799                 { return(*(int *)0); }
2800
2801 /* ./tty/lib_vidattr.c */
2802
2803 #undef vidputs_sp
2804 int     vidputs_sp(
2805                 SCREEN  *sp,
2806                 chtype  newmode,
2807                 NCURSES_OUTC_sp outc)
2808                 { return(*(int *)0); }
2809
2810 #undef vidputs
2811 int     vidputs(
2812                 chtype  newmode,
2813                 NCURSES_OUTC outc)
2814                 { return(*(int *)0); }
2815
2816 #undef vidattr_sp
2817 int     vidattr_sp(
2818                 SCREEN  *sp,
2819                 chtype  newmode)
2820                 { return(*(int *)0); }
2821
2822 #undef vidattr
2823 int     vidattr(
2824                 chtype  newmode)
2825                 { return(*(int *)0); }
2826
2827 #undef termattrs_sp
2828 chtype  termattrs_sp(
2829                 SCREEN  *sp)
2830                 { return(*(chtype *)0); }
2831
2832 #undef termattrs
2833 chtype  termattrs(void)
2834                 { return(*(chtype *)0); }
2835
2836 /* ./base/lib_vline.c */
2837
2838 #undef wvline
2839 int     wvline(
2840                 WINDOW  *win,
2841                 chtype  ch,
2842                 int     n)
2843                 { return(*(int *)0); }
2844
2845 /* ./base/lib_wattroff.c */
2846
2847 #undef wattr_off
2848 int     wattr_off(
2849                 WINDOW  *win,
2850                 attr_t  at,
2851                 void    *opts)
2852                 { return(*(int *)0); }
2853
2854 /* ./base/lib_wattron.c */
2855
2856 #undef wattr_on
2857 int     wattr_on(
2858                 WINDOW  *win,
2859                 attr_t  at,
2860                 void    *opts)
2861                 { return(*(int *)0); }
2862
2863 /* ./base/lib_winch.c */
2864
2865 #undef winch
2866 chtype  winch(
2867                 WINDOW  *win)
2868                 { return(*(chtype *)0); }
2869
2870 /* ./base/lib_window.c */
2871
2872 #undef _nc_synchook
2873 void    _nc_synchook(
2874                 WINDOW  *win)
2875                 { /* void */ }
2876
2877 #undef mvderwin
2878 int     mvderwin(
2879                 WINDOW  *win,
2880                 int     y,
2881                 int     x)
2882                 { return(*(int *)0); }
2883
2884 #undef syncok
2885 int     syncok(
2886                 WINDOW  *win,
2887                 NCURSES_BOOL bf)
2888                 { return(*(int *)0); }
2889
2890 #undef wsyncup
2891 void    wsyncup(
2892                 WINDOW  *win)
2893                 { /* void */ }
2894
2895 #undef wsyncdown
2896 void    wsyncdown(
2897                 WINDOW  *win)
2898                 { /* void */ }
2899
2900 #undef wcursyncup
2901 void    wcursyncup(
2902                 WINDOW  *win)
2903                 { /* void */ }
2904
2905 #undef dupwin
2906 WINDOW  *dupwin(
2907                 WINDOW  *win)
2908                 { return(*(WINDOW **)0); }
2909
2910 /* ./base/nc_panel.c */
2911
2912 #undef _nc_panelhook_sp
2913 struct panelhook *_nc_panelhook_sp(
2914                 SCREEN  *sp)
2915                 { return(*(struct panelhook **)0); }
2916
2917 #undef _nc_panelhook
2918 struct panelhook *_nc_panelhook(void)
2919                 { return(*(struct panelhook **)0); }
2920
2921 /* ./base/safe_sprintf.c */
2922
2923 #undef _nc_printf_string_sp
2924 char    *_nc_printf_string_sp(
2925                 SCREEN  *sp,
2926                 const char *fmt,
2927                 va_list ap)
2928                 { return(*(char **)0); }
2929
2930 #undef _nc_printf_string
2931 char    *_nc_printf_string(
2932                 const char *fmt,
2933                 va_list ap)
2934                 { return(*(char **)0); }
2935
2936 /* ./tty/tty_update.c */
2937
2938 #include <sys/time.h>
2939 #include <sys/times.h>
2940
2941 #undef doupdate_sp
2942 int     doupdate_sp(
2943                 SCREEN  *sp)
2944                 { return(*(int *)0); }
2945
2946 #undef doupdate
2947 int     doupdate(void)
2948                 { return(*(int *)0); }
2949
2950 #undef _nc_scrolln_sp
2951 int     _nc_scrolln_sp(
2952                 SCREEN  *sp,
2953                 int     n,
2954                 int     top,
2955                 int     bot,
2956                 int     maxy)
2957                 { return(*(int *)0); }
2958
2959 #undef _nc_scrolln
2960 int     _nc_scrolln(
2961                 int     n,
2962                 int     top,
2963                 int     bot,
2964                 int     maxy)
2965                 { return(*(int *)0); }
2966
2967 #undef _nc_screen_resume_sp
2968 void    _nc_screen_resume_sp(
2969                 SCREEN  *sp)
2970                 { /* void */ }
2971
2972 #undef _nc_screen_resume
2973 void    _nc_screen_resume(void)
2974                 { /* void */ }
2975
2976 #undef _nc_screen_init_sp
2977 void    _nc_screen_init_sp(
2978                 SCREEN  *sp)
2979                 { /* void */ }
2980
2981 #undef _nc_screen_init
2982 void    _nc_screen_init(void)
2983                 { /* void */ }
2984
2985 #undef _nc_screen_wrap_sp
2986 void    _nc_screen_wrap_sp(
2987                 SCREEN  *sp)
2988                 { /* void */ }
2989
2990 #undef _nc_screen_wrap
2991 void    _nc_screen_wrap(void)
2992                 { /* void */ }
2993
2994 #undef _nc_do_xmc_glitch_sp
2995 void    _nc_do_xmc_glitch_sp(
2996                 SCREEN  *sp,
2997                 attr_t  previous)
2998                 { /* void */ }
2999
3000 #undef _nc_do_xmc_glitch
3001 void    _nc_do_xmc_glitch(
3002                 attr_t  previous)
3003                 { /* void */ }
3004
3005 /* ./trace/varargs.c */
3006
3007 typedef enum {
3008     atUnknown = 0, atInteger, atFloat, atPoint, atString
3009 } ARGTYPE;
3010
3011 #undef _nc_varargs
3012 char    *_nc_varargs(
3013                 const char *fmt,
3014                 va_list ap)
3015                 { return(*(char **)0); }
3016
3017 /* ./base/memmove.c */
3018
3019 #undef _nc_memmove
3020 void    _nc_memmove(void)
3021                 { /* void */ }
3022
3023 /* ./base/vsscanf.c */
3024
3025 #undef _nc_vsscanf
3026 void    _nc_vsscanf(void)
3027                 { /* void */ }
3028
3029 /* ./base/lib_freeall.c */
3030
3031 #undef _nc_freeall
3032 void    _nc_freeall(void)
3033                 { /* void */ }
3034
3035 #undef _nc_free_and_exit_sp
3036 void    _nc_free_and_exit_sp(
3037                 SCREEN  *sp,
3038                 int     code)
3039                 { /* void */ }
3040
3041 #undef _nc_free_and_exit
3042 void    _nc_free_and_exit(
3043                 int     code)
3044                 { /* void */ }
3045
3046 /* ./widechar/charable.c */
3047
3048 #undef _nc_is_charable
3049 NCURSES_BOOL _nc_is_charable(
3050                 wchar_t ch)
3051                 { return(*(NCURSES_BOOL *)0); }
3052
3053 #undef _nc_to_char
3054 int     _nc_to_char(
3055                 wint_t  ch)
3056                 { return(*(int *)0); }
3057
3058 #undef _nc_to_widechar
3059 wint_t  _nc_to_widechar(
3060                 int     ch)
3061                 { return(*(wint_t *)0); }
3062
3063 /* ./widechar/lib_add_wch.c */
3064
3065 #undef wadd_wch
3066 int     wadd_wch(
3067                 WINDOW  *win,
3068                 const cchar_t *wch)
3069                 { return(*(int *)0); }
3070
3071 #undef wecho_wchar
3072 int     wecho_wchar(
3073                 WINDOW  *win,
3074                 const cchar_t *wch)
3075                 { return(*(int *)0); }
3076
3077 /* ./widechar/lib_box_set.c */
3078
3079 #undef wborder_set
3080 int     wborder_set(
3081                 WINDOW  *win,
3082                 const cchar_t *ls,
3083                 const cchar_t *rs,
3084                 const cchar_t *ts,
3085                 const cchar_t *bs,
3086                 const cchar_t *tl,
3087                 const cchar_t *tr,
3088                 const cchar_t *bl,
3089                 const cchar_t *br)
3090                 { return(*(int *)0); }
3091
3092 /* ./widechar/lib_cchar.c */
3093
3094 #undef setcchar
3095 int     setcchar(
3096                 cchar_t *wcval,
3097                 const wchar_t *wch,
3098                 const attr_t attrs,
3099                 short   color_pair,
3100                 const void *opts)
3101                 { return(*(int *)0); }
3102
3103 #undef getcchar
3104 int     getcchar(
3105                 const cchar_t *wcval,
3106                 wchar_t *wch,
3107                 attr_t  *attrs,
3108                 short   *color_pair,
3109                 void    *opts)
3110                 { return(*(int *)0); }
3111
3112 /* ./widechar/lib_erasewchar.c */
3113
3114 #undef erasewchar
3115 int     erasewchar(
3116                 wchar_t *wch)
3117                 { return(*(int *)0); }
3118
3119 #undef killwchar
3120 int     killwchar(
3121                 wchar_t *wch)
3122                 { return(*(int *)0); }
3123
3124 /* ./widechar/lib_get_wch.c */
3125
3126 #undef wget_wch
3127 int     wget_wch(
3128                 WINDOW  *win,
3129                 wint_t  *result)
3130                 { return(*(int *)0); }
3131
3132 /* ./widechar/lib_get_wstr.c */
3133
3134 #undef wgetn_wstr
3135 int     wgetn_wstr(
3136                 WINDOW  *win,
3137                 wint_t  *str,
3138                 int     maxlen)
3139                 { return(*(int *)0); }
3140
3141 /* ./widechar/lib_hline_set.c */
3142
3143 #undef whline_set
3144 int     whline_set(
3145                 WINDOW  *win,
3146                 const cchar_t *ch,
3147                 int     n)
3148                 { return(*(int *)0); }
3149
3150 /* ./widechar/lib_in_wch.c */
3151
3152 #undef win_wch
3153 int     win_wch(
3154                 WINDOW  *win,
3155                 cchar_t *wcval)
3156                 { return(*(int *)0); }
3157
3158 /* ./widechar/lib_in_wchnstr.c */
3159
3160 #undef win_wchnstr
3161 int     win_wchnstr(
3162                 WINDOW  *win,
3163                 cchar_t *wchstr,
3164                 int     n)
3165                 { return(*(int *)0); }
3166
3167 /* ./widechar/lib_ins_wch.c */
3168
3169 #undef _nc_insert_wch
3170 int     _nc_insert_wch(
3171                 WINDOW  *win,
3172                 const cchar_t *wch)
3173                 { return(*(int *)0); }
3174
3175 #undef wins_wch
3176 int     wins_wch(
3177                 WINDOW  *win,
3178                 const cchar_t *wch)
3179                 { return(*(int *)0); }
3180
3181 #undef wins_nwstr
3182 int     wins_nwstr(
3183                 WINDOW  *win,
3184                 const wchar_t *wstr,
3185                 int     n)
3186                 { return(*(int *)0); }
3187
3188 /* ./widechar/lib_inwstr.c */
3189
3190 #undef winnwstr
3191 int     winnwstr(
3192                 WINDOW  *win,
3193                 wchar_t *wstr,
3194                 int     n)
3195                 { return(*(int *)0); }
3196
3197 #undef winwstr
3198 int     winwstr(
3199                 WINDOW  *win,
3200                 wchar_t *wstr)
3201                 { return(*(int *)0); }
3202
3203 /* ./widechar/lib_key_name.c */
3204
3205 #undef key_name
3206 char    *key_name(
3207                 wchar_t c)
3208                 { return(*(char **)0); }
3209
3210 /* ./widechar/lib_pecho_wchar.c */
3211
3212 #undef pecho_wchar
3213 int     pecho_wchar(
3214                 WINDOW  *pad,
3215                 const cchar_t *wch)
3216                 { return(*(int *)0); }
3217
3218 /* ./widechar/lib_slk_wset.c */
3219
3220 #undef slk_wset
3221 int     slk_wset(
3222                 int     i,
3223                 const wchar_t *astr,
3224                 int     format)
3225                 { return(*(int *)0); }
3226
3227 /* ./widechar/lib_unget_wch.c */
3228
3229 #undef _nc_wcrtomb
3230 size_t  _nc_wcrtomb(
3231                 char    *target,
3232                 wchar_t source,
3233                 mbstate_t *state)
3234                 { return(*(size_t *)0); }
3235
3236 #undef unget_wch_sp
3237 int     unget_wch_sp(
3238                 SCREEN  *sp,
3239                 const wchar_t wch)
3240                 { return(*(int *)0); }
3241
3242 #undef unget_wch
3243 int     unget_wch(
3244                 const wchar_t wch)
3245                 { return(*(int *)0); }
3246
3247 /* ./widechar/lib_vid_attr.c */
3248
3249 #undef vid_puts_sp
3250 int     vid_puts_sp(
3251                 SCREEN  *sp,
3252                 attr_t  newmode,
3253                 short   pair,
3254                 void    *opts,
3255                 NCURSES_OUTC_sp outc)
3256                 { return(*(int *)0); }
3257
3258 #undef vid_puts
3259 int     vid_puts(
3260                 attr_t  newmode,
3261                 short   pair,
3262                 void    *opts,
3263                 NCURSES_OUTC outc)
3264                 { return(*(int *)0); }
3265
3266 #undef vid_attr_sp
3267 int     vid_attr_sp(
3268                 SCREEN  *sp,
3269                 attr_t  newmode,
3270                 short   pair,
3271                 void    *opts)
3272                 { return(*(int *)0); }
3273
3274 #undef vid_attr
3275 int     vid_attr(
3276                 attr_t  newmode,
3277                 short   pair,
3278                 void    *opts)
3279                 { return(*(int *)0); }
3280
3281 #undef term_attrs_sp
3282 attr_t  term_attrs_sp(
3283                 SCREEN  *sp)
3284                 { return(*(attr_t *)0); }
3285
3286 #undef term_attrs
3287 attr_t  term_attrs(void)
3288                 { return(*(attr_t *)0); }
3289
3290 /* ./widechar/lib_vline_set.c */
3291
3292 #undef wvline_set
3293 int     wvline_set(
3294                 WINDOW  *win,
3295                 const cchar_t *ch,
3296                 int     n)
3297                 { return(*(int *)0); }
3298
3299 /* ./widechar/lib_wacs.c */
3300
3301 #undef _nc_wacs
3302 cchar_t *_nc_wacs;
3303
3304 #undef _nc_init_wacs
3305 void    _nc_init_wacs(void)
3306                 { /* void */ }
3307
3308 /* ./widechar/lib_wunctrl.c */
3309
3310 #undef wunctrl_sp
3311 wchar_t *wunctrl_sp(
3312                 SCREEN  *sp,
3313                 cchar_t *wc)
3314                 { return(*(wchar_t **)0); }
3315
3316 #undef wunctrl
3317 wchar_t *wunctrl(
3318                 cchar_t *wc)
3319                 { return(*(wchar_t **)0); }
3320
3321 /* ./expanded.c */
3322
3323 #undef _nc_toggle_attr_on
3324 void    _nc_toggle_attr_on(
3325                 attr_t  *S,
3326                 attr_t  at)
3327                 { /* void */ }
3328
3329 #undef _nc_toggle_attr_off
3330 void    _nc_toggle_attr_off(
3331                 attr_t  *S,
3332                 attr_t  at)
3333                 { /* void */ }
3334
3335 #undef _nc_DelCharCost_sp
3336 int     _nc_DelCharCost_sp(
3337                 SCREEN  *sp,
3338                 int     count)
3339                 { return(*(int *)0); }
3340
3341 #undef _nc_InsCharCost_sp
3342 int     _nc_InsCharCost_sp(
3343                 SCREEN  *sp,
3344                 int     count)
3345                 { return(*(int *)0); }
3346
3347 #undef _nc_UpdateAttrs_sp
3348 void    _nc_UpdateAttrs_sp(
3349                 SCREEN  *sp,
3350                 const cchar_t *c)
3351                 { /* void */ }
3352
3353 #undef _nc_DelCharCost
3354 int     _nc_DelCharCost(
3355                 int     count)
3356                 { return(*(int *)0); }
3357
3358 #undef _nc_InsCharCost
3359 int     _nc_InsCharCost(
3360                 int     count)
3361                 { return(*(int *)0); }
3362
3363 #undef _nc_UpdateAttrs
3364 void    _nc_UpdateAttrs(
3365                 const cchar_t *c)
3366                 { /* void */ }
3367
3368 /* ./base/legacy_coding.c */
3369
3370 #undef use_legacy_coding_sp
3371 int     use_legacy_coding_sp(
3372                 SCREEN  *sp,
3373                 int     level)
3374                 { return(*(int *)0); }
3375
3376 #undef use_legacy_coding
3377 int     use_legacy_coding(
3378                 int     level)
3379                 { return(*(int *)0); }
3380
3381 /* ./base/lib_dft_fgbg.c */
3382
3383 #undef use_default_colors_sp
3384 int     use_default_colors_sp(
3385                 SCREEN  *sp)
3386                 { return(*(int *)0); }
3387
3388 #undef use_default_colors
3389 int     use_default_colors(void)
3390                 { return(*(int *)0); }
3391
3392 #undef assume_default_colors_sp
3393 int     assume_default_colors_sp(
3394                 SCREEN  *sp,
3395                 int     fg,
3396                 int     bg)
3397                 { return(*(int *)0); }
3398
3399 #undef assume_default_colors
3400 int     assume_default_colors(
3401                 int     fg,
3402                 int     bg)
3403                 { return(*(int *)0); }
3404
3405 /* ./tinfo/lib_print.c */
3406
3407 #undef mcprint_sp
3408 int     mcprint_sp(
3409                 SCREEN  *sp,
3410                 char    *data,
3411                 int     len)
3412                 { return(*(int *)0); }
3413
3414 #undef mcprint
3415 int     mcprint(
3416                 char    *data,
3417                 int     len)
3418                 { return(*(int *)0); }
3419
3420 /* ./base/resizeterm.c */
3421
3422 #undef is_term_resized_sp
3423 NCURSES_BOOL is_term_resized_sp(
3424                 SCREEN  *sp,
3425                 int     ToLines,
3426                 int     ToCols)
3427                 { return(*(NCURSES_BOOL *)0); }
3428
3429 #undef is_term_resized
3430 NCURSES_BOOL is_term_resized(
3431                 int     ToLines,
3432                 int     ToCols)
3433                 { return(*(NCURSES_BOOL *)0); }
3434
3435 #undef resize_term_sp
3436 int     resize_term_sp(
3437                 SCREEN  *sp,
3438                 int     ToLines,
3439                 int     ToCols)
3440                 { return(*(int *)0); }
3441
3442 #undef resize_term
3443 int     resize_term(
3444                 int     ToLines,
3445                 int     ToCols)
3446                 { return(*(int *)0); }
3447
3448 #undef resizeterm_sp
3449 int     resizeterm_sp(
3450                 SCREEN  *sp,
3451                 int     ToLines,
3452                 int     ToCols)
3453                 { return(*(int *)0); }
3454
3455 #undef resizeterm
3456 int     resizeterm(
3457                 int     ToLines,
3458                 int     ToCols)
3459                 { return(*(int *)0); }
3460
3461 /* ./trace/trace_xnames.c */
3462
3463 #undef _nc_trace_xnames
3464 void    _nc_trace_xnames(
3465                 TERMTYPE *tp)
3466                 { /* void */ }
3467
3468 /* ./tinfo/use_screen.c */
3469
3470 #undef use_screen
3471 int     use_screen(
3472                 SCREEN  *screen,
3473                 NCURSES_SCREEN_CB func,
3474                 void    *data)
3475                 { return(*(int *)0); }
3476
3477 /* ./base/use_window.c */
3478
3479 #undef use_window
3480 int     use_window(
3481                 WINDOW  *win,
3482                 NCURSES_WINDOW_CB func,
3483                 void    *data)
3484                 { return(*(int *)0); }
3485
3486 /* ./base/wresize.c */
3487
3488 #undef wresize
3489 int     wresize(
3490                 WINDOW  *win,
3491                 int     ToLines,
3492                 int     ToCols)
3493                 { return(*(int *)0); }
3494
3495 /* ./tinfo/access.c */
3496
3497 #undef _nc_rootname
3498 char    *_nc_rootname(
3499                 char    *path)
3500                 { return(*(char **)0); }
3501
3502 #undef _nc_is_abs_path
3503 NCURSES_BOOL _nc_is_abs_path(
3504                 const char *path)
3505                 { return(*(NCURSES_BOOL *)0); }
3506
3507 #undef _nc_pathlast
3508 unsigned _nc_pathlast(
3509                 const char *path)
3510                 { return(*(unsigned *)0); }
3511
3512 #undef _nc_basename
3513 char    *_nc_basename(
3514                 char    *path)
3515                 { return(*(char **)0); }
3516
3517 #undef _nc_access
3518 int     _nc_access(
3519                 const char *path,
3520                 int     mode)
3521                 { return(*(int *)0); }
3522
3523 #undef _nc_is_dir_path
3524 NCURSES_BOOL _nc_is_dir_path(
3525                 const char *path)
3526                 { return(*(NCURSES_BOOL *)0); }
3527
3528 #undef _nc_is_file_path
3529 NCURSES_BOOL _nc_is_file_path(
3530                 const char *path)
3531                 { return(*(NCURSES_BOOL *)0); }
3532
3533 #undef _nc_env_access
3534 int     _nc_env_access(void)
3535                 { return(*(int *)0); }
3536
3537 /* ./tinfo/add_tries.c */
3538
3539 #undef _nc_add_to_try
3540 int     _nc_add_to_try(
3541                 TRIES   **tree,
3542                 const char *str,
3543                 unsigned code)
3544                 { return(*(int *)0); }
3545
3546 /* ./tinfo/alloc_ttype.c */
3547
3548 #undef _nc_align_termtype
3549 void    _nc_align_termtype(
3550                 TERMTYPE *to,
3551                 TERMTYPE *from)
3552                 { /* void */ }
3553
3554 #undef _nc_copy_termtype
3555 void    _nc_copy_termtype(
3556                 TERMTYPE *dst,
3557                 TERMTYPE *src)
3558                 { /* void */ }
3559
3560 /* ./codes.c */
3561
3562 #undef boolcodes
3563 char    *const boolcodes[] = {0};
3564 #undef numcodes
3565 char    *const numcodes[] = {0};
3566 #undef strcodes
3567 char    *const strcodes[] = {0};
3568
3569 /* ./comp_captab.c */
3570
3571 #include <hashsize.h>
3572
3573 #undef _nc_get_table
3574 const struct name_table_entry *_nc_get_table(
3575                 NCURSES_BOOL termcap)
3576                 { return(*(const struct name_table_entry **)0); }
3577
3578 #undef _nc_get_hash_table
3579 const HashValue *_nc_get_hash_table(
3580                 NCURSES_BOOL termcap)
3581                 { return(*(const HashValue **)0); }
3582
3583 #undef _nc_get_alias_table
3584 const struct alias *_nc_get_alias_table(
3585                 NCURSES_BOOL termcap)
3586                 { return(*(const struct alias **)0); }
3587
3588 #undef _nc_get_hash_info
3589 const HashData *_nc_get_hash_info(
3590                 NCURSES_BOOL termcap)
3591                 { return(*(const HashData **)0); }
3592
3593 /* ./tinfo/comp_error.c */
3594
3595 #undef _nc_suppress_warnings
3596 NCURSES_BOOL _nc_suppress_warnings;
3597 #undef _nc_curr_line
3598 int     _nc_curr_line;
3599 #undef _nc_curr_col
3600 int     _nc_curr_col;
3601
3602 #undef _nc_get_source
3603 const char *_nc_get_source(void)
3604                 { return(*(const char **)0); }
3605
3606 #undef _nc_set_source
3607 void    _nc_set_source(
3608                 const char *const name)
3609                 { /* void */ }
3610
3611 #undef _nc_set_type
3612 void    _nc_set_type(
3613                 const char *const name)
3614                 { /* void */ }
3615
3616 #undef _nc_get_type
3617 void    _nc_get_type(
3618                 char    *name)
3619                 { /* void */ }
3620
3621 #undef _nc_warning
3622 void    _nc_warning(
3623                 const char *const fmt,
3624                 ...)
3625                 { /* void */ }
3626
3627 #undef _nc_err_abort
3628 void    _nc_err_abort(
3629                 const char *const fmt,
3630                 ...)
3631                 { /* void */ }
3632
3633 #undef _nc_syserr_abort
3634 void    _nc_syserr_abort(
3635                 const char *const fmt,
3636                 ...)
3637                 { /* void */ }
3638
3639 /* ./tinfo/comp_hash.c */
3640
3641 #undef _nc_find_entry
3642 struct name_table_entry const *_nc_find_entry(
3643                 const char *string,
3644                 const HashValue *hash_table)
3645                 { return(*(struct name_table_entry const **)0); }
3646
3647 #undef _nc_find_type_entry
3648 struct name_table_entry const *_nc_find_type_entry(
3649                 const char *string,
3650                 int     type,
3651                 NCURSES_BOOL termcap)
3652                 { return(*(struct name_table_entry const **)0); }
3653
3654 /* ./tinfo/db_iterator.c */
3655
3656 #undef _nc_tic_dir
3657 const char *_nc_tic_dir(
3658                 const char *path)
3659                 { return(*(const char **)0); }
3660
3661 #undef _nc_keep_tic_dir
3662 void    _nc_keep_tic_dir(
3663                 const char *path)
3664                 { /* void */ }
3665
3666 #undef _nc_last_db
3667 void    _nc_last_db(void)
3668                 { /* void */ }
3669
3670 #undef _nc_next_db
3671 const char *_nc_next_db(
3672                 DBDIRS  *state,
3673                 int     *offset)
3674                 { return(*(const char **)0); }
3675
3676 #undef _nc_first_db
3677 void    _nc_first_db(
3678                 DBDIRS  *state,
3679                 int     *offset)
3680                 { /* void */ }
3681
3682 /* ./tinfo/doalloc.c */
3683
3684 #undef _nc_doalloc
3685 void    *_nc_doalloc(
3686                 void    *oldp,
3687                 size_t  amount)
3688                 { return(*(void **)0); }
3689
3690 /* ./tinfo/entries.c */
3691
3692 #undef _nc_head
3693 ENTRY   *_nc_head;
3694 #undef _nc_tail
3695 ENTRY   *_nc_tail;
3696
3697 #undef _nc_free_entry
3698 void    _nc_free_entry(
3699                 ENTRY   *headp,
3700                 TERMTYPE *tterm)
3701                 { /* void */ }
3702
3703 #undef _nc_free_entries
3704 void    _nc_free_entries(
3705                 ENTRY   *headp)
3706                 { /* void */ }
3707
3708 #undef _nc_delink_entry
3709 ENTRY   *_nc_delink_entry(
3710                 ENTRY   *headp,
3711                 TERMTYPE *tterm)
3712                 { return(*(ENTRY **)0); }
3713
3714 #undef _nc_leaks_tinfo
3715 void    _nc_leaks_tinfo(void)
3716                 { /* void */ }
3717
3718 /* ./fallback.c */
3719
3720 #undef _nc_fallback
3721 const TERMTYPE *_nc_fallback(
3722                 const char *name)
3723                 { return(*(const TERMTYPE **)0); }
3724
3725 /* ./tinfo/free_ttype.c */
3726
3727 #undef _nc_free_termtype
3728 void    _nc_free_termtype(
3729                 TERMTYPE *ptr)
3730                 { /* void */ }
3731
3732 #undef _nc_user_definable
3733 NCURSES_BOOL _nc_user_definable;
3734
3735 #undef use_extended_names
3736 int     use_extended_names(
3737                 NCURSES_BOOL flag)
3738                 { return(*(int *)0); }
3739
3740 /* ./tinfo/getenv_num.c */
3741
3742 #undef _nc_getenv_num
3743 int     _nc_getenv_num(
3744                 const char *name)
3745                 { return(*(int *)0); }
3746
3747 /* ./tinfo/home_terminfo.c */
3748
3749 #undef _nc_home_terminfo
3750 char    *_nc_home_terminfo(void)
3751                 { return(*(char **)0); }
3752
3753 /* ./tinfo/init_keytry.c */
3754
3755 #if 0
3756
3757 #include <init_keytry.h>
3758
3759 #undef _nc_tinfo_fkeys
3760 const struct tinfo_fkeys _nc_tinfo_fkeys[] = {0};
3761
3762 #endif
3763
3764 #undef _nc_init_keytry
3765 void    _nc_init_keytry(
3766                 SCREEN  *sp)
3767                 { /* void */ }
3768
3769 /* ./tinfo/lib_acs.c */
3770
3771 #undef acs_map
3772 chtype  acs_map[128];
3773
3774 #undef _nc_init_acs_sp
3775 void    _nc_init_acs_sp(
3776                 SCREEN  *sp)
3777                 { /* void */ }
3778
3779 #undef _nc_init_acs
3780 void    _nc_init_acs(void)
3781                 { /* void */ }
3782
3783 /* ./tinfo/lib_baudrate.c */
3784
3785 #include <termcap.h>
3786
3787 struct speed {
3788     int s;
3789     int sp;
3790 };
3791
3792 #undef _nc_baudrate
3793 int     _nc_baudrate(
3794                 int     OSpeed)
3795                 { return(*(int *)0); }
3796
3797 #undef _nc_ospeed
3798 int     _nc_ospeed(
3799                 int     BaudRate)
3800                 { return(*(int *)0); }
3801
3802 #undef baudrate_sp
3803 int     baudrate_sp(
3804                 SCREEN  *sp)
3805                 { return(*(int *)0); }
3806
3807 #undef baudrate
3808 int     baudrate(void)
3809                 { return(*(int *)0); }
3810
3811 /* ./tinfo/lib_cur_term.c */
3812
3813 #undef cur_term
3814 TERMINAL *cur_term;
3815
3816 #undef set_curterm_sp
3817 TERMINAL *set_curterm_sp(
3818                 SCREEN  *sp,
3819                 TERMINAL *termp)
3820                 { return(*(TERMINAL **)0); }
3821
3822 #undef set_curterm
3823 TERMINAL *set_curterm(
3824                 TERMINAL *termp)
3825                 { return(*(TERMINAL **)0); }
3826
3827 #undef del_curterm_sp
3828 int     del_curterm_sp(
3829                 SCREEN  *sp,
3830                 TERMINAL *termp)
3831                 { return(*(int *)0); }
3832
3833 #undef del_curterm
3834 int     del_curterm(
3835                 TERMINAL *termp)
3836                 { return(*(int *)0); }
3837
3838 /* ./tinfo/lib_data.c */
3839
3840 #undef stdscr
3841 WINDOW  *stdscr;
3842 #undef curscr
3843 WINDOW  *curscr;
3844 #undef newscr
3845 WINDOW  *newscr;
3846 #undef _nc_screen_chain
3847 SCREEN  *_nc_screen_chain;
3848 #undef SP
3849 SCREEN  *SP;
3850 #undef _nc_globals
3851 NCURSES_GLOBALS _nc_globals;
3852 #undef _nc_prescreen
3853 NCURSES_PRESCREEN _nc_prescreen;
3854
3855 #undef _nc_screen_of
3856 SCREEN  *_nc_screen_of(
3857                 WINDOW  *win)
3858                 { return(*(SCREEN **)0); }
3859
3860 /* ./tinfo/lib_has_cap.c */
3861
3862 #undef has_ic_sp
3863 NCURSES_BOOL has_ic_sp(
3864                 SCREEN  *sp)
3865                 { return(*(NCURSES_BOOL *)0); }
3866
3867 #undef has_ic
3868 NCURSES_BOOL has_ic(void)
3869                 { return(*(NCURSES_BOOL *)0); }
3870
3871 #undef has_il_sp
3872 NCURSES_BOOL has_il_sp(
3873                 SCREEN  *sp)
3874                 { return(*(NCURSES_BOOL *)0); }
3875
3876 #undef has_il
3877 NCURSES_BOOL has_il(void)
3878                 { return(*(NCURSES_BOOL *)0); }
3879
3880 /* ./tinfo/lib_kernel.c */
3881
3882 #undef erasechar_sp
3883 char    erasechar_sp(
3884                 SCREEN  *sp)
3885                 { return(*(char *)0); }
3886
3887 #undef erasechar
3888 char    erasechar(void)
3889                 { return(*(char *)0); }
3890
3891 #undef killchar_sp
3892 char    killchar_sp(
3893                 SCREEN  *sp)
3894                 { return(*(char *)0); }
3895
3896 #undef killchar
3897 char    killchar(void)
3898                 { return(*(char *)0); }
3899
3900 #undef flushinp_sp
3901 int     flushinp_sp(
3902                 SCREEN  *sp)
3903                 { return(*(int *)0); }
3904
3905 #undef flushinp
3906 int     flushinp(void)
3907                 { return(*(int *)0); }
3908
3909 /* ./lib_keyname.c */
3910
3911 struct kn { short offset; int code; };
3912
3913 #undef keyname_sp
3914 char    *keyname_sp(
3915                 SCREEN  *sp,
3916                 int     c)
3917                 { return(*(char **)0); }
3918
3919 #undef keyname
3920 char    *keyname(
3921                 int     c)
3922                 { return(*(char **)0); }
3923
3924 /* ./tinfo/lib_longname.c */
3925
3926 #undef longname
3927 char    *longname(void)
3928                 { return(*(char **)0); }
3929
3930 /* ./tinfo/lib_napms.c */
3931
3932 #include <time.h>
3933
3934 #undef napms_sp
3935 int     napms_sp(
3936                 SCREEN  *sp,
3937                 int     ms)
3938                 { return(*(int *)0); }
3939
3940 #undef napms
3941 int     napms(
3942                 int     ms)
3943                 { return(*(int *)0); }
3944
3945 /* ./tinfo/lib_options.c */
3946
3947 #undef idlok
3948 int     idlok(
3949                 WINDOW  *win,
3950                 NCURSES_BOOL flag)
3951                 { return(*(int *)0); }
3952
3953 #undef idcok
3954 void    idcok(
3955                 WINDOW  *win,
3956                 NCURSES_BOOL flag)
3957                 { /* void */ }
3958
3959 #undef halfdelay_sp
3960 int     halfdelay_sp(
3961                 SCREEN  *sp,
3962                 int     t)
3963                 { return(*(int *)0); }
3964
3965 #undef halfdelay
3966 int     halfdelay(
3967                 int     t)
3968                 { return(*(int *)0); }
3969
3970 #undef nodelay
3971 int     nodelay(
3972                 WINDOW  *win,
3973                 NCURSES_BOOL flag)
3974                 { return(*(int *)0); }
3975
3976 #undef notimeout
3977 int     notimeout(
3978                 WINDOW  *win,
3979                 NCURSES_BOOL f)
3980                 { return(*(int *)0); }
3981
3982 #undef wtimeout
3983 void    wtimeout(
3984                 WINDOW  *win,
3985                 int     delay)
3986                 { /* void */ }
3987
3988 #undef keypad
3989 int     keypad(
3990                 WINDOW  *win,
3991                 NCURSES_BOOL flag)
3992                 { return(*(int *)0); }
3993
3994 #undef meta
3995 int     meta(
3996                 WINDOW  *win,
3997                 NCURSES_BOOL flag)
3998                 { return(*(int *)0); }
3999
4000 #undef curs_set_sp
4001 int     curs_set_sp(
4002                 SCREEN  *sp,
4003                 int     vis)
4004                 { return(*(int *)0); }
4005
4006 #undef curs_set
4007 int     curs_set(
4008                 int     vis)
4009                 { return(*(int *)0); }
4010
4011 #undef typeahead_sp
4012 int     typeahead_sp(
4013                 SCREEN  *sp,
4014                 int     fd)
4015                 { return(*(int *)0); }
4016
4017 #undef typeahead
4018 int     typeahead(
4019                 int     fd)
4020                 { return(*(int *)0); }
4021
4022 #undef has_key_sp
4023 int     has_key_sp(
4024                 SCREEN  *sp,
4025                 int     keycode)
4026                 { return(*(int *)0); }
4027
4028 #undef has_key
4029 int     has_key(
4030                 int     keycode)
4031                 { return(*(int *)0); }
4032
4033 #undef _nc_putp_flush_sp
4034 int     _nc_putp_flush_sp(
4035                 SCREEN  *sp,
4036                 const char *name,
4037                 const char *value)
4038                 { return(*(int *)0); }
4039
4040 #undef _nc_keypad
4041 int     _nc_keypad(
4042                 SCREEN  *sp,
4043                 NCURSES_BOOL flag)
4044                 { return(*(int *)0); }
4045
4046 /* ./tinfo/lib_raw.c */
4047
4048 #undef raw_sp
4049 int     raw_sp(
4050                 SCREEN  *sp)
4051                 { return(*(int *)0); }
4052
4053 #undef raw
4054 int     raw(void)
4055                 { return(*(int *)0); }
4056
4057 #undef cbreak_sp
4058 int     cbreak_sp(
4059                 SCREEN  *sp)
4060                 { return(*(int *)0); }
4061
4062 #undef cbreak
4063 int     cbreak(void)
4064                 { return(*(int *)0); }
4065
4066 #undef qiflush_sp
4067 void    qiflush_sp(
4068                 SCREEN  *sp)
4069                 { /* void */ }
4070
4071 #undef qiflush
4072 void    qiflush(void)
4073                 { /* void */ }
4074
4075 #undef noraw_sp
4076 int     noraw_sp(
4077                 SCREEN  *sp)
4078                 { return(*(int *)0); }
4079
4080 #undef noraw
4081 int     noraw(void)
4082                 { return(*(int *)0); }
4083
4084 #undef nocbreak_sp
4085 int     nocbreak_sp(
4086                 SCREEN  *sp)
4087                 { return(*(int *)0); }
4088
4089 #undef nocbreak
4090 int     nocbreak(void)
4091                 { return(*(int *)0); }
4092
4093 #undef noqiflush_sp
4094 void    noqiflush_sp(
4095                 SCREEN  *sp)
4096                 { /* void */ }
4097
4098 #undef noqiflush
4099 void    noqiflush(void)
4100                 { /* void */ }
4101
4102 #undef intrflush_sp
4103 int     intrflush_sp(
4104                 SCREEN  *sp,
4105                 WINDOW  *win,
4106                 NCURSES_BOOL flag)
4107                 { return(*(int *)0); }
4108
4109 #undef intrflush
4110 int     intrflush(
4111                 WINDOW  *win,
4112                 NCURSES_BOOL flag)
4113                 { return(*(int *)0); }
4114
4115 /* ./tinfo/lib_setup.c */
4116
4117 #include <locale.h>
4118 #include <sys/ioctl.h>
4119 #include <langinfo.h>
4120
4121 #undef ttytype
4122 char    ttytype[256];
4123 #undef LINES
4124 int     LINES;
4125 #undef COLS
4126 int     COLS;
4127 #undef TABSIZE
4128 int     TABSIZE;
4129
4130 #undef set_tabsize_sp
4131 int     set_tabsize_sp(
4132                 SCREEN  *sp,
4133                 int     value)
4134                 { return(*(int *)0); }
4135
4136 #undef set_tabsize
4137 int     set_tabsize(
4138                 int     value)
4139                 { return(*(int *)0); }
4140
4141 #undef _nc_handle_sigwinch
4142 int     _nc_handle_sigwinch(
4143                 SCREEN  *sp)
4144                 { return(*(int *)0); }
4145
4146 #undef use_env_sp
4147 void    use_env_sp(
4148                 SCREEN  *sp,
4149                 NCURSES_BOOL f)
4150                 { /* void */ }
4151
4152 #undef use_env
4153 void    use_env(
4154                 NCURSES_BOOL f)
4155                 { /* void */ }
4156
4157 #undef _nc_get_screensize
4158 void    _nc_get_screensize(
4159                 SCREEN  *sp,
4160                 int     *linep,
4161                 int     *colp)
4162                 { /* void */ }
4163
4164 #undef _nc_update_screensize
4165 void    _nc_update_screensize(
4166                 SCREEN  *sp)
4167                 { /* void */ }
4168
4169 #undef _nc_setup_tinfo
4170 int     _nc_setup_tinfo(
4171                 const char *const tn,
4172                 TERMTYPE *const tp)
4173                 { return(*(int *)0); }
4174
4175 #undef _nc_tinfo_cmdch
4176 void    _nc_tinfo_cmdch(
4177                 TERMINAL *termp,
4178                 char    proto)
4179                 { /* void */ }
4180
4181 #undef _nc_get_locale
4182 char    *_nc_get_locale(void)
4183                 { return(*(char **)0); }
4184
4185 #undef _nc_unicode_locale
4186 int     _nc_unicode_locale(void)
4187                 { return(*(int *)0); }
4188
4189 #undef _nc_locale_breaks_acs
4190 int     _nc_locale_breaks_acs(
4191                 TERMINAL *termp)
4192                 { return(*(int *)0); }
4193
4194 #undef _nc_setupterm
4195 int     _nc_setupterm(
4196                 char    *tname,
4197                 int     Filedes,
4198                 int     *errret,
4199                 NCURSES_BOOL reuse)
4200                 { return(*(int *)0); }
4201
4202 #undef new_prescr
4203 SCREEN  *new_prescr(void)
4204                 { return(*(SCREEN **)0); }
4205
4206 #undef setupterm
4207 int     setupterm(
4208                 char    *tname,
4209                 int     Filedes,
4210                 int     *errret)
4211                 { return(*(int *)0); }
4212
4213 /* ./tinfo/lib_termcap.c */
4214
4215 #undef UP
4216 char    *UP;
4217 #undef BC
4218 char    *BC;
4219
4220 #undef tgetent_sp
4221 int     tgetent_sp(
4222                 SCREEN  *sp,
4223                 char    *bufp,
4224                 const char *name)
4225                 { return(*(int *)0); }
4226
4227 #if 0
4228
4229 #include <capdefaults.c>
4230
4231 #endif
4232
4233 #undef tgetent
4234 int     tgetent(
4235                 char    *bufp,
4236                 const char *name)
4237                 { return(*(int *)0); }
4238
4239 #undef tgetflag_sp
4240 int     tgetflag_sp(
4241                 SCREEN  *sp,
4242                 char    *id)
4243                 { return(*(int *)0); }
4244
4245 #undef tgetflag
4246 int     tgetflag(
4247                 char    *id)
4248                 { return(*(int *)0); }
4249
4250 #undef tgetnum_sp
4251 int     tgetnum_sp(
4252                 SCREEN  *sp,
4253                 char    *id)
4254                 { return(*(int *)0); }
4255
4256 #undef tgetnum
4257 int     tgetnum(
4258                 char    *id)
4259                 { return(*(int *)0); }
4260
4261 #undef tgetstr_sp
4262 char    *tgetstr_sp(
4263                 SCREEN  *sp,
4264                 char    *id,
4265                 char    **area)
4266                 { return(*(char **)0); }
4267
4268 #undef tgetstr
4269 char    *tgetstr(
4270                 char    *id,
4271                 char    **area)
4272                 { return(*(char **)0); }
4273
4274 /* ./tinfo/lib_termname.c */
4275
4276 #undef termname_sp
4277 char    *termname_sp(
4278                 SCREEN  *sp)
4279                 { return(*(char **)0); }
4280
4281 #undef termname
4282 char    *termname(void)
4283                 { return(*(char **)0); }
4284
4285 /* ./tinfo/lib_tgoto.c */
4286
4287 #undef tgoto
4288 char    *tgoto(
4289                 const char *string,
4290                 int     x,
4291                 int     y)
4292                 { return(*(char **)0); }
4293
4294 /* ./tinfo/lib_ti.c */
4295
4296 #undef tigetflag_sp
4297 int     tigetflag_sp(
4298                 SCREEN  *sp,
4299                 char    *str)
4300                 { return(*(int *)0); }
4301
4302 #undef tigetflag
4303 int     tigetflag(
4304                 char    *str)
4305                 { return(*(int *)0); }
4306
4307 #undef tigetnum_sp
4308 int     tigetnum_sp(
4309                 SCREEN  *sp,
4310                 char    *str)
4311                 { return(*(int *)0); }
4312
4313 #undef tigetnum
4314 int     tigetnum(
4315                 char    *str)
4316                 { return(*(int *)0); }
4317
4318 #undef tigetstr_sp
4319 char    *tigetstr_sp(
4320                 SCREEN  *sp,
4321                 char    *str)
4322                 { return(*(char **)0); }
4323
4324 #undef tigetstr
4325 char    *tigetstr(
4326                 char    *str)
4327                 { return(*(char **)0); }
4328
4329 /* ./tinfo/lib_tparm.c */
4330
4331 #undef _nc_tparm_err
4332 int     _nc_tparm_err;
4333
4334 #undef _nc_tparm_analyze
4335 int     _nc_tparm_analyze(
4336                 const char *string,
4337                 char    *p_is_s[9],
4338                 int     *popcount)
4339                 { return(*(int *)0); }
4340
4341 #undef tparm
4342 char    *tparm(
4343                 char    *string,
4344                 ...)
4345                 { return(*(char **)0); }
4346
4347 #undef tiparm
4348 char    *tiparm(
4349                 const char *string,
4350                 ...)
4351                 { return(*(char **)0); }
4352
4353 /* ./tinfo/lib_tputs.c */
4354
4355 #undef PC
4356 char    PC;
4357 #undef ospeed
4358 NCURSES_OSPEED  ospeed;
4359 #undef _nc_nulls_sent
4360 int     _nc_nulls_sent;
4361
4362 #undef _nc_set_no_padding
4363 void    _nc_set_no_padding(
4364                 SCREEN  *sp)
4365                 { /* void */ }
4366
4367 #undef delay_output_sp
4368 int     delay_output_sp(
4369                 SCREEN  *sp,
4370                 int     ms)
4371                 { return(*(int *)0); }
4372
4373 #undef delay_output
4374 int     delay_output(
4375                 int     ms)
4376                 { return(*(int *)0); }
4377
4378 #undef _nc_flush_sp
4379 void    _nc_flush_sp(
4380                 SCREEN  *sp)
4381                 { /* void */ }
4382
4383 #undef _nc_flush
4384 void    _nc_flush(void)
4385                 { /* void */ }
4386
4387 #undef _nc_outch_sp
4388 int     _nc_outch_sp(
4389                 SCREEN  *sp,
4390                 int     ch)
4391                 { return(*(int *)0); }
4392
4393 #undef _nc_outch
4394 int     _nc_outch(
4395                 int     ch)
4396                 { return(*(int *)0); }
4397
4398 #undef putp_sp
4399 int     putp_sp(
4400                 SCREEN  *sp,
4401                 const char *string)
4402                 { return(*(int *)0); }
4403
4404 #undef _nc_putp_sp
4405 int     _nc_putp_sp(
4406                 SCREEN  *sp,
4407                 const char *name,
4408                 const char *string)
4409                 { return(*(int *)0); }
4410
4411 #undef putp
4412 int     putp(
4413                 const char *string)
4414                 { return(*(int *)0); }
4415
4416 #undef _nc_putp
4417 int     _nc_putp(
4418                 const char *name,
4419                 const char *string)
4420                 { return(*(int *)0); }
4421
4422 #undef tputs_sp
4423 int     tputs_sp(
4424                 SCREEN  *sp,
4425                 const char *string,
4426                 int     affcnt,
4427                 NCURSES_OUTC_sp outc)
4428                 { return(*(int *)0); }
4429
4430 #undef _nc_outc_wrapper
4431 int     _nc_outc_wrapper(
4432                 SCREEN  *sp,
4433                 int     c)
4434                 { return(*(int *)0); }
4435
4436 #undef tputs
4437 int     tputs(
4438                 const char *string,
4439                 int     affcnt,
4440                 int     (*outc)(
4441                 int     p1))
4442                 { return(*(int *)0); }
4443
4444 /* ./trace/lib_trace.c */
4445
4446 #undef _nc_tracing
4447 unsigned _nc_tracing;
4448 #undef _nc_tputs_trace
4449 const char *_nc_tputs_trace = {0};
4450 #undef _nc_outchars
4451 long    _nc_outchars;
4452
4453 #undef trace
4454 void    trace(
4455                 const unsigned int tracelevel)
4456                 { /* void */ }
4457
4458 #undef _tracef
4459 void    _tracef(
4460                 const char *fmt,
4461                 ...)
4462                 { /* void */ }
4463
4464 #undef _nc_retrace_bool
4465 NCURSES_BOOL _nc_retrace_bool(
4466                 NCURSES_BOOL code)
4467                 { return(*(NCURSES_BOOL *)0); }
4468
4469 #undef _nc_retrace_char
4470 char    _nc_retrace_char(
4471                 char    code)
4472                 { return(*(char *)0); }
4473
4474 #undef _nc_retrace_int
4475 int     _nc_retrace_int(
4476                 int     code)
4477                 { return(*(int *)0); }
4478
4479 #undef _nc_retrace_unsigned
4480 unsigned _nc_retrace_unsigned(
4481                 unsigned code)
4482                 { return(*(unsigned *)0); }
4483
4484 #undef _nc_retrace_ptr
4485 char    *_nc_retrace_ptr(
4486                 char    *code)
4487                 { return(*(char **)0); }
4488
4489 #undef _nc_retrace_cptr
4490 const char *_nc_retrace_cptr(
4491                 const char *code)
4492                 { return(*(const char **)0); }
4493
4494 #undef _nc_retrace_cvoid_ptr
4495 void    *_nc_retrace_cvoid_ptr(
4496                 void    *code)
4497                 { return(*(void **)0); }
4498
4499 #undef _nc_retrace_void_ptr
4500 void    *_nc_retrace_void_ptr(
4501                 void    *code)
4502                 { return(*(void **)0); }
4503
4504 #undef _nc_retrace_sp
4505 SCREEN  *_nc_retrace_sp(
4506                 SCREEN  *code)
4507                 { return(*(SCREEN **)0); }
4508
4509 #undef _nc_retrace_win
4510 WINDOW  *_nc_retrace_win(
4511                 WINDOW  *code)
4512                 { return(*(WINDOW **)0); }
4513
4514 /* ./trace/lib_traceatr.c */
4515
4516 #undef _traceattr2
4517 char    *_traceattr2(
4518                 int     bufnum,
4519                 chtype  newmode)
4520                 { return(*(char **)0); }
4521
4522 #undef _traceattr
4523 char    *_traceattr(
4524                 attr_t  newmode)
4525                 { return(*(char **)0); }
4526
4527 #undef _nc_retrace_int_attr_t
4528 int     _nc_retrace_int_attr_t(
4529                 attr_t  code)
4530                 { return(*(int *)0); }
4531
4532 #undef _nc_retrace_attr_t
4533 attr_t  _nc_retrace_attr_t(
4534                 attr_t  code)
4535                 { return(*(attr_t *)0); }
4536
4537 #undef _nc_altcharset_name
4538 const char *_nc_altcharset_name(
4539                 attr_t  attr,
4540                 chtype  ch)
4541                 { return(*(const char **)0); }
4542
4543 #undef _tracechtype2
4544 char    *_tracechtype2(
4545                 int     bufnum,
4546                 chtype  ch)
4547                 { return(*(char **)0); }
4548
4549 #undef _tracechtype
4550 char    *_tracechtype(
4551                 chtype  ch)
4552                 { return(*(char **)0); }
4553
4554 #undef _nc_retrace_chtype
4555 chtype  _nc_retrace_chtype(
4556                 chtype  code)
4557                 { return(*(chtype *)0); }
4558
4559 #undef _tracecchar_t2
4560 char    *_tracecchar_t2(
4561                 int     bufnum,
4562                 const cchar_t *ch)
4563                 { return(*(char **)0); }
4564
4565 #undef _tracecchar_t
4566 char    *_tracecchar_t(
4567                 const cchar_t *ch)
4568                 { return(*(char **)0); }
4569
4570 /* ./trace/lib_tracebits.c */
4571
4572 typedef struct {
4573     unsigned int val;
4574     const char *name;
4575 } BITNAMES;
4576
4577 #undef _nc_trace_ttymode
4578 char    *_nc_trace_ttymode(
4579                 struct termios *tty)
4580                 { return(*(char **)0); }
4581
4582 #undef _nc_tracebits
4583 char    *_nc_tracebits(void)
4584                 { return(*(char **)0); }
4585
4586 /* ./trace/lib_tracechr.c */
4587
4588 #undef _nc_tracechar
4589 char    *_nc_tracechar(
4590                 SCREEN  *sp,
4591                 int     ch)
4592                 { return(*(char **)0); }
4593
4594 #undef _tracechar
4595 char    *_tracechar(
4596                 int     ch)
4597                 { return(*(char **)0); }
4598
4599 /* ./tinfo/lib_ttyflags.c */
4600
4601 #undef _nc_get_tty_mode_sp
4602 int     _nc_get_tty_mode_sp(
4603                 SCREEN  *sp,
4604                 struct termios *buf)
4605                 { return(*(int *)0); }
4606
4607 #undef _nc_get_tty_mode
4608 int     _nc_get_tty_mode(
4609                 struct termios *buf)
4610                 { return(*(int *)0); }
4611
4612 #undef _nc_set_tty_mode_sp
4613 int     _nc_set_tty_mode_sp(
4614                 SCREEN  *sp,
4615                 struct termios *buf)
4616                 { return(*(int *)0); }
4617
4618 #undef _nc_set_tty_mode
4619 int     _nc_set_tty_mode(
4620                 struct termios *buf)
4621                 { return(*(int *)0); }
4622
4623 #undef def_shell_mode_sp
4624 int     def_shell_mode_sp(
4625                 SCREEN  *sp)
4626                 { return(*(int *)0); }
4627
4628 #undef def_shell_mode
4629 int     def_shell_mode(void)
4630                 { return(*(int *)0); }
4631
4632 #undef def_prog_mode_sp
4633 int     def_prog_mode_sp(
4634                 SCREEN  *sp)
4635                 { return(*(int *)0); }
4636
4637 #undef def_prog_mode
4638 int     def_prog_mode(void)
4639                 { return(*(int *)0); }
4640
4641 #undef reset_prog_mode_sp
4642 int     reset_prog_mode_sp(
4643                 SCREEN  *sp)
4644                 { return(*(int *)0); }
4645
4646 #undef reset_prog_mode
4647 int     reset_prog_mode(void)
4648                 { return(*(int *)0); }
4649
4650 #undef reset_shell_mode_sp
4651 int     reset_shell_mode_sp(
4652                 SCREEN  *sp)
4653                 { return(*(int *)0); }
4654
4655 #undef reset_shell_mode
4656 int     reset_shell_mode(void)
4657                 { return(*(int *)0); }
4658
4659 #undef savetty_sp
4660 int     savetty_sp(
4661                 SCREEN  *sp)
4662                 { return(*(int *)0); }
4663
4664 #undef savetty
4665 int     savetty(void)
4666                 { return(*(int *)0); }
4667
4668 #undef resetty_sp
4669 int     resetty_sp(
4670                 SCREEN  *sp)
4671                 { return(*(int *)0); }
4672
4673 #undef resetty
4674 int     resetty(void)
4675                 { return(*(int *)0); }
4676
4677 /* ./tty/lib_twait.c */
4678
4679 #undef _nc_timed_wait
4680 int     _nc_timed_wait(
4681                 SCREEN  *sp,
4682                 int     mode,
4683                 int     milliseconds,
4684                 int     *timeleft)
4685                 { return(*(int *)0); }
4686
4687 /* ./tinfo/name_match.c */
4688
4689 #undef _nc_first_name
4690 char    *_nc_first_name(
4691                 const char *const sp)
4692                 { return(*(char **)0); }
4693
4694 #undef _nc_name_match
4695 int     _nc_name_match(
4696                 const char *const namelst,
4697                 const char *const name,
4698                 const char *const delim)
4699                 { return(*(int *)0); }
4700
4701 /* ./names.c */
4702
4703 #undef boolnames
4704 char    *const boolnames[] = {0};
4705 #undef boolfnames
4706 char    *const boolfnames[] = {0};
4707 #undef numnames
4708 char    *const numnames[] = {0};
4709 #undef numfnames
4710 char    *const numfnames[] = {0};
4711 #undef strnames
4712 char    *const strnames[] = {0};
4713 #undef strfnames
4714 char    *const strfnames[] = {0};
4715
4716 /* ./tinfo/read_entry.c */
4717
4718 #include <hashed_db.h>
4719
4720 #undef _nc_read_termtype
4721 int     _nc_read_termtype(
4722                 TERMTYPE *ptr,
4723                 char    *buffer,
4724                 int     limit)
4725                 { return(*(int *)0); }
4726
4727 #undef _nc_read_file_entry
4728 int     _nc_read_file_entry(
4729                 const char *const filename,
4730                 TERMTYPE *ptr)
4731                 { return(*(int *)0); }
4732
4733 #undef _nc_read_entry
4734 int     _nc_read_entry(
4735                 const char *const name,
4736                 char    *const filename,
4737                 TERMTYPE *const tp)
4738                 { return(*(int *)0); }
4739
4740 /* ./tinfo/read_termcap.c */
4741
4742 #include <sys/types.h>
4743
4744 #undef _nc_read_termcap_entry
4745 int     _nc_read_termcap_entry(
4746                 const char *const tn,
4747                 TERMTYPE *const tp)
4748                 { return(*(int *)0); }
4749
4750 /* ./tinfo/setbuf.c */
4751
4752 #undef _nc_set_buffer_sp
4753 void    _nc_set_buffer_sp(
4754                 SCREEN  *sp,
4755                 FILE    *ofp,
4756                 NCURSES_BOOL buffered)
4757                 { /* void */ }
4758
4759 #undef _nc_set_buffer
4760 void    _nc_set_buffer(
4761                 FILE    *ofp,
4762                 NCURSES_BOOL buffered)
4763                 { /* void */ }
4764
4765 /* ./tinfo/strings.c */
4766
4767 #undef _nc_str_init
4768 string_desc *_nc_str_init(
4769                 string_desc *dst,
4770                 char    *src,
4771                 size_t  len)
4772                 { return(*(string_desc **)0); }
4773
4774 #undef _nc_str_null
4775 string_desc *_nc_str_null(
4776                 string_desc *dst,
4777                 size_t  len)
4778                 { return(*(string_desc **)0); }
4779
4780 #undef _nc_str_copy
4781 string_desc *_nc_str_copy(
4782                 string_desc *dst,
4783                 string_desc *src)
4784                 { return(*(string_desc **)0); }
4785
4786 #undef _nc_safe_strcat
4787 NCURSES_BOOL _nc_safe_strcat(
4788                 string_desc *dst,
4789                 const char *src)
4790                 { return(*(NCURSES_BOOL *)0); }
4791
4792 #undef _nc_safe_strcpy
4793 NCURSES_BOOL _nc_safe_strcpy(
4794                 string_desc *dst,
4795                 const char *src)
4796                 { return(*(NCURSES_BOOL *)0); }
4797
4798 /* ./trace/trace_buf.c */
4799
4800 #undef _nc_trace_buf
4801 char    *_nc_trace_buf(
4802                 int     bufnum,
4803                 size_t  want)
4804                 { return(*(char **)0); }
4805
4806 #undef _nc_trace_bufcat
4807 char    *_nc_trace_bufcat(
4808                 int     bufnum,
4809                 const char *value)
4810                 { return(*(char **)0); }
4811
4812 /* ./trace/trace_tries.c */
4813
4814 #undef _nc_trace_tries
4815 void    _nc_trace_tries(
4816                 TRIES   *tree)
4817                 { /* void */ }
4818
4819 /* ./base/tries.c */
4820
4821 #undef _nc_expand_try
4822 char    *_nc_expand_try(
4823                 TRIES   *tree,
4824                 unsigned code,
4825                 int     *count,
4826                 size_t  len)
4827                 { return(*(char **)0); }
4828
4829 #undef _nc_remove_key
4830 int     _nc_remove_key(
4831                 TRIES   **tree,
4832                 unsigned code)
4833                 { return(*(int *)0); }
4834
4835 #undef _nc_remove_string
4836 int     _nc_remove_string(
4837                 TRIES   **tree,
4838                 const char *string)
4839                 { return(*(int *)0); }
4840
4841 /* ./tinfo/trim_sgr0.c */
4842
4843 #undef _nc_trim_sgr0
4844 char    *_nc_trim_sgr0(
4845                 TERMTYPE *tp)
4846                 { return(*(char **)0); }
4847
4848 /* ./unctrl.c */
4849
4850 #undef unctrl_sp
4851 char    *unctrl_sp(
4852                 SCREEN  *sp,
4853                 chtype  ch)
4854                 { return(*(char **)0); }
4855
4856 #undef unctrl
4857 char    *unctrl(
4858                 chtype  ch)
4859                 { return(*(char **)0); }
4860
4861 /* ./trace/visbuf.c */
4862
4863 #undef _nc_visbuf2
4864 const char *_nc_visbuf2(
4865                 int     bufnum,
4866                 const char *buf)
4867                 { return(*(const char **)0); }
4868
4869 #undef _nc_visbuf
4870 const char *_nc_visbuf(
4871                 const char *buf)
4872                 { return(*(const char **)0); }
4873
4874 #undef _nc_visbufn
4875 const char *_nc_visbufn(
4876                 const char *buf,
4877                 int     len)
4878                 { return(*(const char **)0); }
4879
4880 #undef _nc_viswbuf2
4881 const char *_nc_viswbuf2(
4882                 int     bufnum,
4883                 const wchar_t *buf)
4884                 { return(*(const char **)0); }
4885
4886 #undef _nc_viswbuf
4887 const char *_nc_viswbuf(
4888                 const wchar_t *buf)
4889                 { return(*(const char **)0); }
4890
4891 #undef _nc_viswbufn
4892 const char *_nc_viswbufn(
4893                 const wchar_t *buf,
4894                 int     len)
4895                 { return(*(const char **)0); }
4896
4897 #undef _nc_viswibuf
4898 const char *_nc_viswibuf(
4899                 const wint_t *buf)
4900                 { return(*(const char **)0); }
4901
4902 #undef _nc_viscbuf2
4903 const char *_nc_viscbuf2(
4904                 int     bufnum,
4905                 const cchar_t *buf,
4906                 int     len)
4907                 { return(*(const char **)0); }
4908
4909 #undef _nc_viscbuf
4910 const char *_nc_viscbuf(
4911                 const cchar_t *buf,
4912                 int     len)
4913                 { return(*(const char **)0); }
4914
4915 /* ./tinfo/alloc_entry.c */
4916
4917 #undef _nc_init_entry
4918 void    _nc_init_entry(
4919                 TERMTYPE *const tp)
4920                 { /* void */ }
4921
4922 #undef _nc_copy_entry
4923 ENTRY   *_nc_copy_entry(
4924                 ENTRY   *oldp)
4925                 { return(*(ENTRY **)0); }
4926
4927 #undef _nc_save_str
4928 char    *_nc_save_str(
4929                 const char *const string)
4930                 { return(*(char **)0); }
4931
4932 #undef _nc_wrap_entry
4933 void    _nc_wrap_entry(
4934                 ENTRY   *const ep,
4935                 NCURSES_BOOL copy_strings)
4936                 { /* void */ }
4937
4938 #undef _nc_merge_entry
4939 void    _nc_merge_entry(
4940                 TERMTYPE *const to,
4941                 TERMTYPE *const from)
4942                 { /* void */ }
4943
4944 /* ./tinfo/captoinfo.c */
4945
4946 #undef _nc_captoinfo
4947 char    *_nc_captoinfo(
4948                 const char *cap,
4949                 const char *s,
4950                 int const parameterized)
4951                 { return(*(char **)0); }
4952
4953 #undef _nc_infotocap
4954 char    *_nc_infotocap(
4955                 const char *cap,
4956                 const char *str,
4957                 int const parameterized)
4958                 { return(*(char **)0); }
4959
4960 /* ./tinfo/comp_expand.c */
4961
4962 #undef _nc_tic_expand
4963 char    *_nc_tic_expand(
4964                 const char *srcp,
4965                 NCURSES_BOOL tic_format,
4966                 int     numbers)
4967                 { return(*(char **)0); }
4968
4969 /* ./tinfo/comp_parse.c */
4970
4971 #undef _nc_check_termtype2
4972 void    (*_nc_check_termtype2)(
4973                 TERMTYPE *p1,
4974                 NCURSES_BOOL p2);
4975 #undef _nc_check_termtype
4976 void    (*_nc_check_termtype)(
4977                 TERMTYPE *p1);
4978
4979 #undef _nc_entry_match
4980 NCURSES_BOOL _nc_entry_match(
4981                 char    *n1,
4982                 char    *n2)
4983                 { return(*(NCURSES_BOOL *)0); }
4984
4985 #undef _nc_read_entry_source
4986 void    _nc_read_entry_source(
4987                 FILE    *fp,
4988                 char    *buf,
4989                 int     literal,
4990                 NCURSES_BOOL silent,
4991                 NCURSES_BOOL (*hook)(
4992                 ENTRY   *p1))
4993                 { /* void */ }
4994
4995 #undef _nc_resolve_uses2
4996 int     _nc_resolve_uses2(
4997                 NCURSES_BOOL fullresolve,
4998                 NCURSES_BOOL literal)
4999                 { return(*(int *)0); }
5000
5001 #undef _nc_resolve_uses
5002 int     _nc_resolve_uses(
5003                 NCURSES_BOOL fullresolve)
5004                 { return(*(int *)0); }
5005
5006 /* ./tinfo/comp_scan.c */
5007
5008 #undef _nc_syntax
5009 int     _nc_syntax;
5010 #undef _nc_curr_file_pos
5011 long    _nc_curr_file_pos;
5012 #undef _nc_comment_start
5013 long    _nc_comment_start;
5014 #undef _nc_comment_end
5015 long    _nc_comment_end;
5016 #undef _nc_start_line
5017 long    _nc_start_line;
5018 #undef _nc_curr_token
5019 struct token _nc_curr_token;
5020 #undef _nc_disable_period
5021 NCURSES_BOOL _nc_disable_period;
5022
5023 #undef _nc_reset_input
5024 void    _nc_reset_input(
5025                 FILE    *fp,
5026                 char    *buf)
5027                 { /* void */ }
5028
5029 #undef _nc_get_token
5030 int     _nc_get_token(
5031                 NCURSES_BOOL silent)
5032                 { return(*(int *)0); }
5033
5034 #undef _nc_trans_string
5035 int     _nc_trans_string(
5036                 char    *ptr,
5037                 char    *last)
5038                 { return(*(int *)0); }
5039
5040 #undef _nc_push_token
5041 void    _nc_push_token(
5042                 int     tokclass)
5043                 { /* void */ }
5044
5045 #undef _nc_panic_mode
5046 void    _nc_panic_mode(
5047                 char    ch)
5048                 { /* void */ }
5049
5050 /* ./tinfo/parse_entry.c */
5051
5052 #undef _nc_parse_entry
5053 int     _nc_parse_entry(
5054                 struct entry *entryp,
5055                 int     literal,
5056                 NCURSES_BOOL silent)
5057                 { return(*(int *)0); }
5058
5059 #undef _nc_capcmp
5060 int     _nc_capcmp(
5061                 const char *s,
5062                 const char *t)
5063                 { return(*(int *)0); }
5064
5065 typedef struct {
5066     const char *from;
5067     const char *to;
5068 } assoc;
5069
5070 /* ./tinfo/write_entry.c */
5071
5072 #undef _nc_set_writedir
5073 void    _nc_set_writedir(
5074                 char    *dir)
5075                 { /* void */ }
5076
5077 #undef _nc_write_entry
5078 void    _nc_write_entry(
5079                 TERMTYPE *const tp)
5080                 { /* void */ }
5081
5082 #undef _nc_tic_written
5083 int     _nc_tic_written(void)
5084                 { return(*(int *)0); }
5085
5086 /* ./base/define_key.c */
5087
5088 #undef define_key_sp
5089 int     define_key_sp(
5090                 SCREEN  *sp,
5091                 const char *str,
5092                 int     keycode)
5093                 { return(*(int *)0); }
5094
5095 #undef define_key
5096 int     define_key(
5097                 const char *str,
5098                 int     keycode)
5099                 { return(*(int *)0); }
5100
5101 /* ./tinfo/hashed_db.c */
5102
5103 #undef _nc_hashed_db
5104 void    _nc_hashed_db(void)
5105                 { /* void */ }
5106
5107 /* ./base/key_defined.c */
5108
5109 #undef key_defined_sp
5110 int     key_defined_sp(
5111                 SCREEN  *sp,
5112                 const char *str)
5113                 { return(*(int *)0); }
5114
5115 #undef key_defined
5116 int     key_defined(
5117                 const char *str)
5118                 { return(*(int *)0); }
5119
5120 /* ./base/keybound.c */
5121
5122 #undef keybound_sp
5123 char    *keybound_sp(
5124                 SCREEN  *sp,
5125                 int     code,
5126                 int     count)
5127                 { return(*(char **)0); }
5128
5129 #undef keybound
5130 char    *keybound(
5131                 int     code,
5132                 int     count)
5133                 { return(*(char **)0); }
5134
5135 /* ./base/keyok.c */
5136
5137 #undef keyok_sp
5138 int     keyok_sp(
5139                 SCREEN  *sp,
5140                 int     c,
5141                 NCURSES_BOOL flag)
5142                 { return(*(int *)0); }
5143
5144 #undef keyok
5145 int     keyok(
5146                 int     c,
5147                 NCURSES_BOOL flag)
5148                 { return(*(int *)0); }
5149
5150 /* ./base/version.c */
5151
5152 #undef curses_version
5153 const char *curses_version(void)
5154                 { return(*(const char **)0); }