ncurses/llib-lncursestw

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