llib-lncursestw

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