ncurses/llib-lncursestw

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