ncurses/llib-lncursestw

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