ncurses/llib-lncursesw

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