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 */