ncurses/llib-lncursesw

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