ncurses/llib-lncursesw

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