ncurses/llib-lncursestw

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