ncurses/llib-lncursestw

   1 /****************************************************************************
   2  * Copyright 2018-2020,2021 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                 int     z)
 597                 { return(*(int *)0); }
 598
 599 #undef attron
 600 int     attron(
 601                 int     z)
 602                 { return(*(int *)0); }
 603
 604 #undef attrset
 605 int     attrset(
 606                 int     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 /* ./tinfo/add_tries.c */
3757
3758 #undef _nc_add_to_try
3759 int     _nc_add_to_try(
3760                 TRIES   **tree,
3761                 const char *str,
3762                 unsigned code)
3763                 { return(*(int *)0); }
3764
3765 /* ./tinfo/alloc_ttype.c */
3766
3767 #undef _nc_align_termtype
3768 void    _nc_align_termtype(
3769                 TERMTYPE2 *to,
3770                 TERMTYPE2 *from)
3771                 { /* void */ }
3772
3773 #undef _nc_copy_termtype
3774 void    _nc_copy_termtype(
3775                 TERMTYPE *dst,
3776                 const TERMTYPE *src)
3777                 { /* void */ }
3778
3779 #undef _nc_copy_termtype2
3780 void    _nc_copy_termtype2(
3781                 TERMTYPE2 *dst,
3782                 const TERMTYPE2 *src)
3783                 { /* void */ }
3784
3785 #undef _nc_export_termtype2
3786 void    _nc_export_termtype2(
3787                 TERMTYPE *dst,
3788                 const TERMTYPE2 *src)
3789                 { /* void */ }
3790
3791 /* ./codes.c */
3792
3793 #undef _nc_boolcodes
3794 const char *const *_nc_boolcodes(void)
3795                 { return(*(const char **)0); }
3796
3797 #undef _nc_numcodes
3798 const char *const *_nc_numcodes(void)
3799                 { return(*(const char **)0); }
3800
3801 #undef _nc_strcodes
3802 const char *const *_nc_strcodes(void)
3803                 { return(*(const char **)0); }
3804
3805 /* ./comp_captab.c */
3806
3807 #undef _nc_get_table
3808 const struct name_table_entry *_nc_get_table(
3809                 NCURSES_BOOL termcap)
3810                 { return(*(const struct name_table_entry **)0); }
3811
3812 #undef _nc_get_hash_table
3813 const HashValue *_nc_get_hash_table(
3814                 NCURSES_BOOL termcap)
3815                 { return(*(const HashValue **)0); }
3816
3817 #undef _nc_get_alias_table
3818 const struct alias *_nc_get_alias_table(
3819                 NCURSES_BOOL termcap)
3820                 { return(*(const struct alias **)0); }
3821
3822 #undef _nc_get_hash_info
3823 const HashData *_nc_get_hash_info(
3824                 NCURSES_BOOL termcap)
3825                 { return(*(const HashData **)0); }
3826
3827 /* ./tinfo/comp_error.c */
3828
3829 #undef _nc_suppress_warnings
3830 NCURSES_BOOL _nc_suppress_warnings;
3831 #undef _nc_curr_line
3832 int     _nc_curr_line;
3833 #undef _nc_curr_col
3834 int     _nc_curr_col;
3835
3836 #undef _nc_get_source
3837 const char *_nc_get_source(void)
3838                 { return(*(const char **)0); }
3839
3840 #undef _nc_set_source
3841 void    _nc_set_source(
3842                 const char *const name)
3843                 { /* void */ }
3844
3845 #undef _nc_set_type
3846 void    _nc_set_type(
3847                 const char *const name)
3848                 { /* void */ }
3849
3850 #undef _nc_get_type
3851 void    _nc_get_type(
3852                 char    *name)
3853                 { /* void */ }
3854
3855 #undef _nc_warning
3856 void    _nc_warning(
3857                 const char *const fmt,
3858                 ...)
3859                 { /* void */ }
3860
3861 #undef _nc_err_abort
3862 void    _nc_err_abort(
3863                 const char *const fmt,
3864                 ...)
3865                 { /* void */ }
3866
3867 #undef _nc_syserr_abort
3868 void    _nc_syserr_abort(
3869                 const char *const fmt,
3870                 ...)
3871                 { /* void */ }
3872
3873 /* ./tinfo/comp_hash.c */
3874
3875 #undef _nc_find_entry
3876 struct name_table_entry const *_nc_find_entry(
3877                 const char *string,
3878                 const HashValue *hash_table)
3879                 { return(*(struct name_table_entry const **)0); }
3880
3881 #undef _nc_find_type_entry
3882 struct name_table_entry const *_nc_find_type_entry(
3883                 const char *string,
3884                 int     type,
3885                 NCURSES_BOOL termcap)
3886                 { return(*(struct name_table_entry const **)0); }
3887
3888 #undef _nc_find_user_entry
3889 struct user_table_entry const *_nc_find_user_entry(
3890                 const char *string)
3891                 { return(*(struct user_table_entry const **)0); }
3892
3893 /* ./comp_userdefs.c */
3894
3895 #undef _nc_get_userdefs_table
3896 const struct user_table_entry *_nc_get_userdefs_table(void)
3897                 { return(*(const struct user_table_entry **)0); }
3898
3899 #undef _nc_get_hash_user
3900 const HashData *_nc_get_hash_user(void)
3901                 { return(*(const HashData **)0); }
3902
3903 /* ./tinfo/db_iterator.c */
3904
3905 #undef _nc_tic_dir
3906 const char *_nc_tic_dir(
3907                 const char *path)
3908                 { return(*(const char **)0); }
3909
3910 #undef _nc_keep_tic_dir
3911 void    _nc_keep_tic_dir(
3912                 const char *path)
3913                 { /* void */ }
3914
3915 #undef _nc_last_db
3916 void    _nc_last_db(void)
3917                 { /* void */ }
3918
3919 #undef _nc_next_db
3920 const char *_nc_next_db(
3921                 DBDIRS  *state,
3922                 int     *offset)
3923                 { return(*(const char **)0); }
3924
3925 #undef _nc_first_db
3926 void    _nc_first_db(
3927                 DBDIRS  *state,
3928                 int     *offset)
3929                 { /* void */ }
3930
3931 /* ./tinfo/doalloc.c */
3932
3933 #undef _nc_doalloc
3934 void    *_nc_doalloc(
3935                 void    *oldp,
3936                 size_t  amount)
3937                 { return(*(void **)0); }
3938
3939 /* ./tinfo/entries.c */
3940
3941 #undef _nc_head
3942 ENTRY   *_nc_head;
3943 #undef _nc_tail
3944 ENTRY   *_nc_tail;
3945
3946 #undef _nc_free_entry
3947 void    _nc_free_entry(
3948                 ENTRY   *headp,
3949                 TERMTYPE2 *tterm)
3950                 { /* void */ }
3951
3952 #undef _nc_free_entries
3953 void    _nc_free_entries(
3954                 ENTRY   *headp)
3955                 { /* void */ }
3956
3957 #undef _nc_leaks_tinfo
3958 void    _nc_leaks_tinfo(void)
3959                 { /* void */ }
3960
3961 #undef exit_terminfo
3962 void    exit_terminfo(
3963                 int     code)
3964                 { /* void */ }
3965
3966 /* ./fallback.c */
3967
3968 #undef _nc_fallback2
3969 const TERMTYPE2 *_nc_fallback2(
3970                 const char *name)
3971                 { return(*(const TERMTYPE2 **)0); }
3972
3973 #undef _nc_fallback
3974 const TERMTYPE *_nc_fallback(
3975                 const char *name)
3976                 { return(*(const TERMTYPE **)0); }
3977
3978 /* ./tinfo/free_ttype.c */
3979
3980 #undef _nc_free_termtype
3981 void    _nc_free_termtype(
3982                 TERMTYPE *ptr)
3983                 { /* void */ }
3984
3985 #undef _nc_free_termtype2
3986 void    _nc_free_termtype2(
3987                 TERMTYPE2 *ptr)
3988                 { /* void */ }
3989
3990 #undef _nc_user_definable
3991 NCURSES_BOOL _nc_user_definable;
3992
3993 #undef use_extended_names
3994 int     use_extended_names(
3995                 NCURSES_BOOL flag)
3996                 { return(*(int *)0); }
3997
3998 /* ./tinfo/getenv_num.c */
3999
4000 #undef _nc_getenv_num
4001 int     _nc_getenv_num(
4002                 const char *name)
4003                 { return(*(int *)0); }
4004
4005 #undef _nc_setenv_num
4006 void    _nc_setenv_num(
4007                 const char *name,
4008                 int     value)
4009                 { /* void */ }
4010
4011 /* ./tinfo/home_terminfo.c */
4012
4013 #undef _nc_home_terminfo
4014 char    *_nc_home_terminfo(void)
4015                 { return(*(char **)0); }
4016
4017 /* ./tinfo/init_keytry.c */
4018
4019 #undef _nc_init_keytry
4020 void    _nc_init_keytry(
4021                 SCREEN  *sp)
4022                 { /* void */ }
4023
4024 /* ./tinfo/lib_acs.c */
4025
4026 #undef _nc_acs_map
4027 chtype  *_nc_acs_map(void)
4028                 { return(*(chtype **)0); }
4029
4030 #undef _nc_init_acs_sp
4031 void    _nc_init_acs_sp(
4032                 SCREEN  *sp)
4033                 { /* void */ }
4034
4035 #undef _nc_init_acs
4036 void    _nc_init_acs(void)
4037                 { /* void */ }
4038
4039 /* ./tinfo/lib_baudrate.c */
4040
4041 struct speed {
4042     int given_speed;
4043     int actual_speed;
4044 };
4045
4046 #undef _nc_baudrate
4047 int     _nc_baudrate(
4048                 int     OSpeed)
4049                 { return(*(int *)0); }
4050
4051 #undef _nc_ospeed
4052 int     _nc_ospeed(
4053                 int     BaudRate)
4054                 { return(*(int *)0); }
4055
4056 #undef baudrate_sp
4057 int     baudrate_sp(
4058                 SCREEN  *sp)
4059                 { return(*(int *)0); }
4060
4061 #undef baudrate
4062 int     baudrate(void)
4063                 { return(*(int *)0); }
4064
4065 /* ./tinfo/lib_cur_term.c */
4066
4067 #undef _nc_get_cur_term_sp
4068 TERMINAL *_nc_get_cur_term_sp(
4069                 SCREEN  *sp)
4070                 { return(*(TERMINAL **)0); }
4071
4072 #undef _nc_get_cur_term
4073 TERMINAL *_nc_get_cur_term(void)
4074                 { return(*(TERMINAL **)0); }
4075
4076 #undef _nc_cur_term
4077 TERMINAL *_nc_cur_term(void)
4078                 { return(*(TERMINAL **)0); }
4079
4080 #undef set_curterm_sp
4081 TERMINAL *set_curterm_sp(
4082                 SCREEN  *sp,
4083                 TERMINAL *termp)
4084                 { return(*(TERMINAL **)0); }
4085
4086 #undef set_curterm
4087 TERMINAL *set_curterm(
4088                 TERMINAL *termp)
4089                 { return(*(TERMINAL **)0); }
4090
4091 #undef del_curterm_sp
4092 int     del_curterm_sp(
4093                 SCREEN  *sp,
4094                 TERMINAL *termp)
4095                 { return(*(int *)0); }
4096
4097 #undef del_curterm
4098 int     del_curterm(
4099                 TERMINAL *termp)
4100                 { return(*(int *)0); }
4101
4102 /* ./tinfo/lib_data.c */
4103
4104 #undef _nc_stdscr
4105 WINDOW  *_nc_stdscr(void)
4106                 { return(*(WINDOW **)0); }
4107
4108 #undef _nc_curscr
4109 WINDOW  *_nc_curscr(void)
4110                 { return(*(WINDOW **)0); }
4111
4112 #undef _nc_newscr
4113 WINDOW  *_nc_newscr(void)
4114                 { return(*(WINDOW **)0); }
4115
4116 #undef _nc_screen_chain
4117 SCREEN  *_nc_screen_chain;
4118 #undef SP
4119 SCREEN  *SP;
4120 #undef _nc_globals
4121 NCURSES_GLOBALS _nc_globals;
4122 #undef _nc_prescreen
4123 NCURSES_PRESCREEN _nc_prescreen;
4124
4125 #undef _nc_screen_of
4126 SCREEN  *_nc_screen_of(
4127                 WINDOW  *win)
4128                 { return(*(SCREEN **)0); }
4129
4130 #undef _nc_init_pthreads
4131 void    _nc_init_pthreads(void)
4132                 { /* void */ }
4133
4134 #undef _nc_mutex_init
4135 void    _nc_mutex_init(
4136                 pthread_mutex_t *obj)
4137                 { /* void */ }
4138
4139 #undef _nc_mutex_lock
4140 int     _nc_mutex_lock(
4141                 pthread_mutex_t *obj)
4142                 { return(*(int *)0); }
4143
4144 #undef _nc_mutex_trylock
4145 int     _nc_mutex_trylock(
4146                 pthread_mutex_t *obj)
4147                 { return(*(int *)0); }
4148
4149 #undef _nc_mutex_unlock
4150 int     _nc_mutex_unlock(
4151                 pthread_mutex_t *obj)
4152                 { return(*(int *)0); }
4153
4154 /* ./tinfo/lib_has_cap.c */
4155
4156 #undef has_ic_sp
4157 NCURSES_BOOL has_ic_sp(
4158                 SCREEN  *sp)
4159                 { return(*(NCURSES_BOOL *)0); }
4160
4161 #undef has_ic
4162 NCURSES_BOOL has_ic(void)
4163                 { return(*(NCURSES_BOOL *)0); }
4164
4165 #undef has_il_sp
4166 NCURSES_BOOL has_il_sp(
4167                 SCREEN  *sp)
4168                 { return(*(NCURSES_BOOL *)0); }
4169
4170 #undef has_il
4171 NCURSES_BOOL has_il(void)
4172                 { return(*(NCURSES_BOOL *)0); }
4173
4174 /* ./tinfo/lib_kernel.c */
4175
4176 #undef erasechar_sp
4177 char    erasechar_sp(
4178                 SCREEN  *sp)
4179                 { return(*(char *)0); }
4180
4181 #undef erasechar
4182 char    erasechar(void)
4183                 { return(*(char *)0); }
4184
4185 #undef killchar_sp
4186 char    killchar_sp(
4187                 SCREEN  *sp)
4188                 { return(*(char *)0); }
4189
4190 #undef killchar
4191 char    killchar(void)
4192                 { return(*(char *)0); }
4193
4194 #undef flushinp_sp
4195 int     flushinp_sp(
4196                 SCREEN  *sp)
4197                 { return(*(int *)0); }
4198
4199 #undef flushinp
4200 int     flushinp(void)
4201                 { return(*(int *)0); }
4202
4203 /* ./lib_keyname.c */
4204
4205 struct kn { short offset; int code; };
4206
4207 #undef keyname_sp
4208 const char *keyname_sp(
4209                 SCREEN  *sp,
4210                 int     c)
4211                 { return(*(const char **)0); }
4212
4213 #undef keyname
4214 const char *keyname(
4215                 int     c)
4216                 { return(*(const char **)0); }
4217
4218 /* ./tinfo/lib_longname.c */
4219
4220 #undef longname_sp
4221 char    *longname_sp(
4222                 SCREEN  *sp)
4223                 { return(*(char **)0); }
4224
4225 #undef longname
4226 char    *longname(void)
4227                 { return(*(char **)0); }
4228
4229 /* ./tinfo/lib_napms.c */
4230
4231 #undef napms_sp
4232 int     napms_sp(
4233                 SCREEN  *sp,
4234                 int     ms)
4235                 { return(*(int *)0); }
4236
4237 #undef napms
4238 int     napms(
4239                 int     ms)
4240                 { return(*(int *)0); }
4241
4242 /* ./tinfo/lib_options.c */
4243
4244 #undef idlok
4245 int     idlok(
4246                 WINDOW  *win,
4247                 NCURSES_BOOL flag)
4248                 { return(*(int *)0); }
4249
4250 #undef idcok
4251 void    idcok(
4252                 WINDOW  *win,
4253                 NCURSES_BOOL flag)
4254                 { /* void */ }
4255
4256 #undef halfdelay_sp
4257 int     halfdelay_sp(
4258                 SCREEN  *sp,
4259                 int     t)
4260                 { return(*(int *)0); }
4261
4262 #undef halfdelay
4263 int     halfdelay(
4264                 int     t)
4265                 { return(*(int *)0); }
4266
4267 #undef nodelay
4268 int     nodelay(
4269                 WINDOW  *win,
4270                 NCURSES_BOOL flag)
4271                 { return(*(int *)0); }
4272
4273 #undef notimeout
4274 int     notimeout(
4275                 WINDOW  *win,
4276                 NCURSES_BOOL f)
4277                 { return(*(int *)0); }
4278
4279 #undef wtimeout
4280 void    wtimeout(
4281                 WINDOW  *win,
4282                 int     delay)
4283                 { /* void */ }
4284
4285 #undef keypad
4286 int     keypad(
4287                 WINDOW  *win,
4288                 NCURSES_BOOL flag)
4289                 { return(*(int *)0); }
4290
4291 #undef meta
4292 int     meta(
4293                 WINDOW  *win,
4294                 NCURSES_BOOL flag)
4295                 { return(*(int *)0); }
4296
4297 #undef curs_set_sp
4298 int     curs_set_sp(
4299                 SCREEN  *sp,
4300                 int     vis)
4301                 { return(*(int *)0); }
4302
4303 #undef curs_set
4304 int     curs_set(
4305                 int     vis)
4306                 { return(*(int *)0); }
4307
4308 #undef typeahead_sp
4309 int     typeahead_sp(
4310                 SCREEN  *sp,
4311                 int     fd)
4312                 { return(*(int *)0); }
4313
4314 #undef typeahead
4315 int     typeahead(
4316                 int     fd)
4317                 { return(*(int *)0); }
4318
4319 #undef has_key_sp
4320 int     has_key_sp(
4321                 SCREEN  *sp,
4322                 int     keycode)
4323                 { return(*(int *)0); }
4324
4325 #undef has_key
4326 int     has_key(
4327                 int     keycode)
4328                 { return(*(int *)0); }
4329
4330 #undef _nc_putp_flush_sp
4331 int     _nc_putp_flush_sp(
4332                 SCREEN  *sp,
4333                 const char *name,
4334                 const char *value)
4335                 { return(*(int *)0); }
4336
4337 #undef _nc_keypad
4338 int     _nc_keypad(
4339                 SCREEN  *sp,
4340                 int     flag)
4341                 { return(*(int *)0); }
4342
4343 /* ./tinfo/lib_raw.c */
4344
4345 #undef raw_sp
4346 int     raw_sp(
4347                 SCREEN  *sp)
4348                 { return(*(int *)0); }
4349
4350 #undef raw
4351 int     raw(void)
4352                 { return(*(int *)0); }
4353
4354 #undef cbreak_sp
4355 int     cbreak_sp(
4356                 SCREEN  *sp)
4357                 { return(*(int *)0); }
4358
4359 #undef cbreak
4360 int     cbreak(void)
4361                 { return(*(int *)0); }
4362
4363 #undef qiflush_sp
4364 void    qiflush_sp(
4365                 SCREEN  *sp)
4366                 { /* void */ }
4367
4368 #undef qiflush
4369 void    qiflush(void)
4370                 { /* void */ }
4371
4372 #undef noraw_sp
4373 int     noraw_sp(
4374                 SCREEN  *sp)
4375                 { return(*(int *)0); }
4376
4377 #undef noraw
4378 int     noraw(void)
4379                 { return(*(int *)0); }
4380
4381 #undef nocbreak_sp
4382 int     nocbreak_sp(
4383                 SCREEN  *sp)
4384                 { return(*(int *)0); }
4385
4386 #undef nocbreak
4387 int     nocbreak(void)
4388                 { return(*(int *)0); }
4389
4390 #undef noqiflush_sp
4391 void    noqiflush_sp(
4392                 SCREEN  *sp)
4393                 { /* void */ }
4394
4395 #undef noqiflush
4396 void    noqiflush(void)
4397                 { /* void */ }
4398
4399 #undef intrflush_sp
4400 int     intrflush_sp(
4401                 SCREEN  *sp,
4402                 WINDOW  *win,
4403                 NCURSES_BOOL flag)
4404                 { return(*(int *)0); }
4405
4406 #undef intrflush
4407 int     intrflush(
4408                 WINDOW  *win,
4409                 NCURSES_BOOL flag)
4410                 { return(*(int *)0); }
4411
4412 /* ./tinfo/lib_setup.c */
4413
4414 #undef _nc_ttytype
4415 char    *_nc_ttytype(void)
4416                 { return(*(char **)0); }
4417
4418 #undef _nc_ptr_Lines
4419 int     *_nc_ptr_Lines(
4420                 SCREEN  *sp)
4421                 { return(*(int **)0); }
4422
4423 #undef _nc_LINES
4424 int     _nc_LINES(void)
4425                 { return(*(int *)0); }
4426
4427 #undef _nc_ptr_Cols
4428 int     *_nc_ptr_Cols(
4429                 SCREEN  *sp)
4430                 { return(*(int **)0); }
4431
4432 #undef _nc_COLS
4433 int     _nc_COLS(void)
4434                 { return(*(int *)0); }
4435
4436 #undef _nc_ptr_Tabsize
4437 int     *_nc_ptr_Tabsize(
4438                 SCREEN  *sp)
4439                 { return(*(int **)0); }
4440
4441 #undef _nc_TABSIZE
4442 int     _nc_TABSIZE(void)
4443                 { return(*(int *)0); }
4444
4445 #undef set_tabsize_sp
4446 int     set_tabsize_sp(
4447                 SCREEN  *sp,
4448                 int     value)
4449                 { return(*(int *)0); }
4450
4451 #undef set_tabsize
4452 int     set_tabsize(
4453                 int     value)
4454                 { return(*(int *)0); }
4455
4456 #undef _nc_handle_sigwinch
4457 int     _nc_handle_sigwinch(
4458                 SCREEN  *sp)
4459                 { return(*(int *)0); }
4460
4461 #undef use_env_sp
4462 void    use_env_sp(
4463                 SCREEN  *sp,
4464                 NCURSES_BOOL f)
4465                 { /* void */ }
4466
4467 #undef use_tioctl_sp
4468 void    use_tioctl_sp(
4469                 SCREEN  *sp,
4470                 NCURSES_BOOL f)
4471                 { /* void */ }
4472
4473 #undef use_env
4474 void    use_env(
4475                 NCURSES_BOOL f)
4476                 { /* void */ }
4477
4478 #undef use_tioctl
4479 void    use_tioctl(
4480                 NCURSES_BOOL f)
4481                 { /* void */ }
4482
4483 #undef _nc_get_screensize
4484 void    _nc_get_screensize(
4485                 SCREEN  *sp,
4486                 int     *linep,
4487                 int     *colp)
4488                 { /* void */ }
4489
4490 #undef _nc_update_screensize
4491 void    _nc_update_screensize(
4492                 SCREEN  *sp)
4493                 { /* void */ }
4494
4495 #undef _nc_setup_tinfo
4496 int     _nc_setup_tinfo(
4497                 const char *const tn,
4498                 TERMTYPE2 *const tp)
4499                 { return(*(int *)0); }
4500
4501 #undef _nc_tinfo_cmdch
4502 void    _nc_tinfo_cmdch(
4503                 TERMINAL *termp,
4504                 int     proto)
4505                 { /* void */ }
4506
4507 #undef _nc_get_locale
4508 char    *_nc_get_locale(void)
4509                 { return(*(char **)0); }
4510
4511 #undef _nc_unicode_locale
4512 int     _nc_unicode_locale(void)
4513                 { return(*(int *)0); }
4514
4515 #undef _nc_locale_breaks_acs
4516 int     _nc_locale_breaks_acs(
4517                 TERMINAL *termp)
4518                 { return(*(int *)0); }
4519
4520 #undef _nc_setupterm
4521 int     _nc_setupterm(
4522                 const char *tname,
4523                 int     Filedes,
4524                 int     *errret,
4525                 int     reuse)
4526                 { return(*(int *)0); }
4527
4528 #undef _nc_find_prescr
4529 SCREEN  *_nc_find_prescr(void)
4530                 { return(*(SCREEN **)0); }
4531
4532 #undef _nc_forget_prescr
4533 void    _nc_forget_prescr(void)
4534                 { /* void */ }
4535
4536 #undef new_prescr
4537 SCREEN  *new_prescr(void)
4538                 { return(*(SCREEN **)0); }
4539
4540 #undef setupterm
4541 int     setupterm(
4542                 const char *tname,
4543                 int     Filedes,
4544                 int     *errret)
4545                 { return(*(int *)0); }
4546
4547 /* ./tinfo/lib_termcap.c */
4548
4549 #undef UP
4550 char    *UP;
4551 #undef BC
4552 char    *BC;
4553
4554 #undef tgetent_sp
4555 int     tgetent_sp(
4556                 SCREEN  *sp,
4557                 char    *bufp,
4558                 const char *name)
4559                 { return(*(int *)0); }
4560
4561 #undef tgetent
4562 int     tgetent(
4563                 char    *bufp,
4564                 const char *name)
4565                 { return(*(int *)0); }
4566
4567 #undef tgetflag_sp
4568 int     tgetflag_sp(
4569                 SCREEN  *sp,
4570                 const char *id)
4571                 { return(*(int *)0); }
4572
4573 #undef tgetflag
4574 int     tgetflag(
4575                 const char *id)
4576                 { return(*(int *)0); }
4577
4578 #undef tgetnum_sp
4579 int     tgetnum_sp(
4580                 SCREEN  *sp,
4581                 const char *id)
4582                 { return(*(int *)0); }
4583
4584 #undef tgetnum
4585 int     tgetnum(
4586                 const char *id)
4587                 { return(*(int *)0); }
4588
4589 #undef tgetstr_sp
4590 char    *tgetstr_sp(
4591                 SCREEN  *sp,
4592                 const char *id,
4593                 char    **area)
4594                 { return(*(char **)0); }
4595
4596 #undef tgetstr
4597 char    *tgetstr(
4598                 const char *id,
4599                 char    **area)
4600                 { return(*(char **)0); }
4601
4602 /* ./tinfo/lib_termname.c */
4603
4604 #undef termname_sp
4605 char    *termname_sp(
4606                 SCREEN  *sp)
4607                 { return(*(char **)0); }
4608
4609 #undef termname
4610 char    *termname(void)
4611                 { return(*(char **)0); }
4612
4613 /* ./tinfo/lib_tgoto.c */
4614
4615 #undef tgoto
4616 char    *tgoto(
4617                 const char *string,
4618                 int     x,
4619                 int     y)
4620                 { return(*(char **)0); }
4621
4622 /* ./tinfo/lib_ti.c */
4623
4624 #undef tigetflag_sp
4625 int     tigetflag_sp(
4626                 SCREEN  *sp,
4627                 const char *str)
4628                 { return(*(int *)0); }
4629
4630 #undef tigetflag
4631 int     tigetflag(
4632                 const char *str)
4633                 { return(*(int *)0); }
4634
4635 #undef tigetnum_sp
4636 int     tigetnum_sp(
4637                 SCREEN  *sp,
4638                 const char *str)
4639                 { return(*(int *)0); }
4640
4641 #undef tigetnum
4642 int     tigetnum(
4643                 const char *str)
4644                 { return(*(int *)0); }
4645
4646 #undef tigetstr_sp
4647 char    *tigetstr_sp(
4648                 SCREEN  *sp,
4649                 const char *str)
4650                 { return(*(char **)0); }
4651
4652 #undef tigetstr
4653 char    *tigetstr(
4654                 const char *str)
4655                 { return(*(char **)0); }
4656
4657 /* ./tinfo/lib_tparm.c */
4658
4659 #undef _nc_tparm_err
4660 int     _nc_tparm_err;
4661
4662 #undef _nc_tparm_analyze
4663 int     _nc_tparm_analyze(
4664                 const char *string,
4665                 char    **p_is_s,
4666                 int     *_nc_popcount)
4667                 { return(*(int *)0); }
4668
4669 #undef tparm
4670 char    *tparm(
4671                 const char *string,
4672                 ...)
4673                 { return(*(char **)0); }
4674
4675 #undef tiparm
4676 char    *tiparm(
4677                 const char *string,
4678                 ...)
4679                 { return(*(char **)0); }
4680
4681 #undef _nc_tiparm
4682 char    *_nc_tiparm(
4683                 int     expected,
4684                 const char *string,
4685                 ...)
4686                 { return(*(char **)0); }
4687
4688 /* ./tinfo/lib_tputs.c */
4689
4690 #undef PC
4691 char    PC;
4692 #undef ospeed
4693 short   ospeed;
4694 #undef _nc_nulls_sent
4695 int     _nc_nulls_sent;
4696
4697 #undef _nc_set_no_padding
4698 void    _nc_set_no_padding(
4699                 SCREEN  *sp)
4700                 { /* void */ }
4701
4702 #undef delay_output_sp
4703 int     delay_output_sp(
4704                 SCREEN  *sp,
4705                 int     ms)
4706                 { return(*(int *)0); }
4707
4708 #undef delay_output
4709 int     delay_output(
4710                 int     ms)
4711                 { return(*(int *)0); }
4712
4713 #undef _nc_flush_sp
4714 void    _nc_flush_sp(
4715                 SCREEN  *sp)
4716                 { /* void */ }
4717
4718 #undef _nc_flush
4719 void    _nc_flush(void)
4720                 { /* void */ }
4721
4722 #undef _nc_outch_sp
4723 int     _nc_outch_sp(
4724                 SCREEN  *sp,
4725                 int     ch)
4726                 { return(*(int *)0); }
4727
4728 #undef _nc_outch
4729 int     _nc_outch(
4730                 int     ch)
4731                 { return(*(int *)0); }
4732
4733 #undef _nc_putchar_sp
4734 int     _nc_putchar_sp(
4735                 SCREEN  *sp,
4736                 int     ch)
4737                 { return(*(int *)0); }
4738
4739 #undef _nc_putchar
4740 int     _nc_putchar(
4741                 int     ch)
4742                 { return(*(int *)0); }
4743
4744 #undef putp_sp
4745 int     putp_sp(
4746                 SCREEN  *sp,
4747                 const char *string)
4748                 { return(*(int *)0); }
4749
4750 #undef putp
4751 int     putp(
4752                 const char *string)
4753                 { return(*(int *)0); }
4754
4755 #undef _nc_putp_sp
4756 int     _nc_putp_sp(
4757                 SCREEN  *sp,
4758                 const char *name,
4759                 const char *string)
4760                 { return(*(int *)0); }
4761
4762 #undef _nc_putp
4763 int     _nc_putp(
4764                 const char *name,
4765                 const char *string)
4766                 { return(*(int *)0); }
4767
4768 #undef tputs_sp
4769 int     tputs_sp(
4770                 SCREEN  *sp,
4771                 const char *string,
4772                 int     affcnt,
4773                 NCURSES_OUTC_sp outc)
4774                 { return(*(int *)0); }
4775
4776 #undef _nc_outc_wrapper
4777 int     _nc_outc_wrapper(
4778                 SCREEN  *sp,
4779                 int     c)
4780                 { return(*(int *)0); }
4781
4782 #undef tputs
4783 int     tputs(
4784                 const char *string,
4785                 int     affcnt,
4786                 int     (*outc)(
4787                 int     p1))
4788                 { return(*(int *)0); }
4789
4790 /* ./trace/lib_trace.c */
4791
4792 #undef _nc_tracing
4793 unsigned _nc_tracing;
4794
4795 #undef _nc__nc_tputs_trace
4796 const char *_nc__nc_tputs_trace(void)
4797                 { return(*(const char **)0); }
4798
4799 #undef _nc__nc_outchars
4800 long    _nc__nc_outchars(void)
4801                 { return(*(long *)0); }
4802
4803 #undef _nc_set_tputs_trace
4804 void    _nc_set_tputs_trace(
4805                 const char *s)
4806                 { /* void */ }
4807
4808 #undef _nc_count_outchars
4809 void    _nc_count_outchars(
4810                 long    increment)
4811                 { /* void */ }
4812
4813 #undef curses_trace
4814 unsigned curses_trace(
4815                 unsigned tracelevel)
4816                 { return(*(unsigned *)0); }
4817
4818 #undef trace
4819 void    trace(
4820                 const unsigned int tracelevel)
4821                 { /* void */ }
4822
4823 #undef _tracef
4824 void    _tracef(
4825                 const char *fmt,
4826                 ...)
4827                 { /* void */ }
4828
4829 #undef _nc_retrace_bool
4830 NCURSES_BOOL _nc_retrace_bool(
4831                 int     code)
4832                 { return(*(NCURSES_BOOL *)0); }
4833
4834 #undef _nc_retrace_char
4835 char    _nc_retrace_char(
4836                 int     code)
4837                 { return(*(char *)0); }
4838
4839 #undef _nc_retrace_int
4840 int     _nc_retrace_int(
4841                 int     code)
4842                 { return(*(int *)0); }
4843
4844 #undef _nc_retrace_unsigned
4845 unsigned _nc_retrace_unsigned(
4846                 unsigned code)
4847                 { return(*(unsigned *)0); }
4848
4849 #undef _nc_retrace_ptr
4850 char    *_nc_retrace_ptr(
4851                 char    *code)
4852                 { return(*(char **)0); }
4853
4854 #undef _nc_retrace_cptr
4855 const char *_nc_retrace_cptr(
4856                 const char *code)
4857                 { return(*(const char **)0); }
4858
4859 #undef _nc_retrace_cvoid_ptr
4860 const void *_nc_retrace_cvoid_ptr(
4861                 const void *code)
4862                 { return(*(const void **)0); }
4863
4864 #undef _nc_retrace_void_ptr
4865 void    *_nc_retrace_void_ptr(
4866                 void    *code)
4867                 { return(*(void **)0); }
4868
4869 #undef _nc_retrace_sp
4870 SCREEN  *_nc_retrace_sp(
4871                 SCREEN  *code)
4872                 { return(*(SCREEN **)0); }
4873
4874 #undef _nc_retrace_win
4875 WINDOW  *_nc_retrace_win(
4876                 WINDOW  *code)
4877                 { return(*(WINDOW **)0); }
4878
4879 #undef _nc_fmt_funcptr
4880 char    *_nc_fmt_funcptr(
4881                 char    *target,
4882                 const char *source,
4883                 size_t  size)
4884                 { return(*(char **)0); }
4885
4886 #undef _nc_use_tracef
4887 int     _nc_use_tracef(
4888                 unsigned mask)
4889                 { return(*(int *)0); }
4890
4891 #undef _nc_locked_tracef
4892 void    _nc_locked_tracef(
4893                 const char *fmt,
4894                 ...)
4895                 { /* void */ }
4896
4897 /* ./trace/lib_traceatr.c */
4898
4899 #undef _traceattr2
4900 char    *_traceattr2(
4901                 int     bufnum,
4902                 chtype  newmode)
4903                 { return(*(char **)0); }
4904
4905 #undef _traceattr
4906 char    *_traceattr(
4907                 attr_t  newmode)
4908                 { return(*(char **)0); }
4909
4910 #undef _nc_retrace_int_attr_t
4911 int     _nc_retrace_int_attr_t(
4912                 attr_t  code)
4913                 { return(*(int *)0); }
4914
4915 #undef _nc_retrace_attr_t
4916 attr_t  _nc_retrace_attr_t(
4917                 attr_t  code)
4918                 { return(*(attr_t *)0); }
4919
4920 #undef _nc_altcharset_name
4921 const char *_nc_altcharset_name(
4922                 attr_t  attr,
4923                 chtype  ch)
4924                 { return(*(const char **)0); }
4925
4926 #undef _tracechtype2
4927 char    *_tracechtype2(
4928                 int     bufnum,
4929                 chtype  ch)
4930                 { return(*(char **)0); }
4931
4932 #undef _tracechtype
4933 char    *_tracechtype(
4934                 chtype  ch)
4935                 { return(*(char **)0); }
4936
4937 #undef _nc_retrace_chtype
4938 chtype  _nc_retrace_chtype(
4939                 chtype  code)
4940                 { return(*(chtype *)0); }
4941
4942 #undef _tracecchar_t2
4943 char    *_tracecchar_t2(
4944                 int     bufnum,
4945                 const cchar_t *ch)
4946                 { return(*(char **)0); }
4947
4948 #undef _tracecchar_t
4949 char    *_tracecchar_t(
4950                 const cchar_t *ch)
4951                 { return(*(char **)0); }
4952
4953 /* ./trace/lib_tracebits.c */
4954
4955 #undef _nc_trace_ttymode
4956 char    *_nc_trace_ttymode(
4957                 const struct termios *tty)
4958                 { return(*(char **)0); }
4959
4960 #undef _nc_tracebits
4961 char    *_nc_tracebits(void)
4962                 { return(*(char **)0); }
4963
4964 /* ./trace/lib_tracechr.c */
4965
4966 #undef _nc_tracechar
4967 char    *_nc_tracechar(
4968                 SCREEN  *sp,
4969                 int     ch)
4970                 { return(*(char **)0); }
4971
4972 #undef _tracechar
4973 char    *_tracechar(
4974                 int     ch)
4975                 { return(*(char **)0); }
4976
4977 /* ./tinfo/lib_ttyflags.c */
4978
4979 #undef _nc_get_tty_mode_sp
4980 int     _nc_get_tty_mode_sp(
4981                 SCREEN  *sp,
4982                 struct termios *buf)
4983                 { return(*(int *)0); }
4984
4985 #undef _nc_get_tty_mode
4986 int     _nc_get_tty_mode(
4987                 struct termios *buf)
4988                 { return(*(int *)0); }
4989
4990 #undef _nc_set_tty_mode_sp
4991 int     _nc_set_tty_mode_sp(
4992                 SCREEN  *sp,
4993                 struct termios *buf)
4994                 { return(*(int *)0); }
4995
4996 #undef _nc_set_tty_mode
4997 int     _nc_set_tty_mode(
4998                 struct termios *buf)
4999                 { return(*(int *)0); }
5000
5001 #undef def_shell_mode_sp
5002 int     def_shell_mode_sp(
5003                 SCREEN  *sp)
5004                 { return(*(int *)0); }
5005
5006 #undef def_shell_mode
5007 int     def_shell_mode(void)
5008                 { return(*(int *)0); }
5009
5010 #undef def_prog_mode_sp
5011 int     def_prog_mode_sp(
5012                 SCREEN  *sp)
5013                 { return(*(int *)0); }
5014
5015 #undef def_prog_mode
5016 int     def_prog_mode(void)
5017                 { return(*(int *)0); }
5018
5019 #undef reset_prog_mode_sp
5020 int     reset_prog_mode_sp(
5021                 SCREEN  *sp)
5022                 { return(*(int *)0); }
5023
5024 #undef reset_prog_mode
5025 int     reset_prog_mode(void)
5026                 { return(*(int *)0); }
5027
5028 #undef reset_shell_mode_sp
5029 int     reset_shell_mode_sp(
5030                 SCREEN  *sp)
5031                 { return(*(int *)0); }
5032
5033 #undef reset_shell_mode
5034 int     reset_shell_mode(void)
5035                 { return(*(int *)0); }
5036
5037 #undef savetty_sp
5038 int     savetty_sp(
5039                 SCREEN  *sp)
5040                 { return(*(int *)0); }
5041
5042 #undef savetty
5043 int     savetty(void)
5044                 { return(*(int *)0); }
5045
5046 #undef resetty_sp
5047 int     resetty_sp(
5048                 SCREEN  *sp)
5049                 { return(*(int *)0); }
5050
5051 #undef resetty
5052 int     resetty(void)
5053                 { return(*(int *)0); }
5054
5055 /* ./tty/lib_twait.c */
5056
5057 #undef _nc_timed_wait
5058 int     _nc_timed_wait(
5059                 SCREEN  *sp,
5060                 int     mode,
5061                 int     milliseconds,
5062                 int     *timeleft)
5063                 { return(*(int *)0); }
5064
5065 /* ./tinfo/name_match.c */
5066
5067 #undef _nc_first_name
5068 char    *_nc_first_name(
5069                 const char *const sp)
5070                 { return(*(char **)0); }
5071
5072 #undef _nc_name_match
5073 int     _nc_name_match(
5074                 const char *const namelst,
5075                 const char *const name,
5076                 const char *const delim)
5077                 { return(*(int *)0); }
5078
5079 /* ./names.c */
5080
5081 #undef _nc_boolnames
5082 const char *const *_nc_boolnames(void)
5083                 { return(*(const char **)0); }
5084
5085 #undef _nc_boolfnames
5086 const char *const *_nc_boolfnames(void)
5087                 { return(*(const char **)0); }
5088
5089 #undef _nc_numnames
5090 const char *const *_nc_numnames(void)
5091                 { return(*(const char **)0); }
5092
5093 #undef _nc_numfnames
5094 const char *const *_nc_numfnames(void)
5095                 { return(*(const char **)0); }
5096
5097 #undef _nc_strnames
5098 const char *const *_nc_strnames(void)
5099                 { return(*(const char **)0); }
5100
5101 #undef _nc_strfnames
5102 const char *const *_nc_strfnames(void)
5103                 { return(*(const char **)0); }
5104
5105 /* ./tinfo/obsolete.c */
5106
5107 #undef _nc_set_buffer_sp
5108 void    _nc_set_buffer_sp(
5109                 SCREEN  *sp,
5110                 FILE    *ofp,
5111                 int     buffered)
5112                 { /* void */ }
5113
5114 #undef _nc_set_buffer
5115 void    _nc_set_buffer(
5116                 FILE    *ofp,
5117                 int     buffered)
5118                 { /* void */ }
5119
5120 /* ./tinfo/read_entry.c */
5121
5122 #undef _nc_init_termtype
5123 void    _nc_init_termtype(
5124                 TERMTYPE2 *const tp)
5125                 { /* void */ }
5126
5127 #undef _nc_read_termtype
5128 int     _nc_read_termtype(
5129                 TERMTYPE2 *ptr,
5130                 char    *buffer,
5131                 int     limit)
5132                 { return(*(int *)0); }
5133
5134 #undef _nc_read_file_entry
5135 int     _nc_read_file_entry(
5136                 const char *const filename,
5137                 TERMTYPE2 *ptr)
5138                 { return(*(int *)0); }
5139
5140 #undef _nc_read_entry2
5141 int     _nc_read_entry2(
5142                 const char *const name,
5143                 char    *const filename,
5144                 TERMTYPE2 *const tp)
5145                 { return(*(int *)0); }
5146
5147 #undef _nc_read_entry
5148 int     _nc_read_entry(
5149                 const char *const name,
5150                 char    *const filename,
5151                 TERMTYPE *const tp)
5152                 { return(*(int *)0); }
5153
5154 /* ./tinfo/read_termcap.c */
5155
5156 #undef _nc_read_termcap_entry
5157 int     _nc_read_termcap_entry(
5158                 const char *const tn,
5159                 TERMTYPE2 *const tp)
5160                 { return(*(int *)0); }
5161
5162 /* ./tinfo/strings.c */
5163
5164 #undef _nc_str_init
5165 string_desc *_nc_str_init(
5166                 string_desc *dst,
5167                 char    *src,
5168                 size_t  len)
5169                 { return(*(string_desc **)0); }
5170
5171 #undef _nc_str_null
5172 string_desc *_nc_str_null(
5173                 string_desc *dst,
5174                 size_t  len)
5175                 { return(*(string_desc **)0); }
5176
5177 #undef _nc_str_copy
5178 string_desc *_nc_str_copy(
5179                 string_desc *dst,
5180                 string_desc *src)
5181                 { return(*(string_desc **)0); }
5182
5183 #undef _nc_safe_strcat
5184 NCURSES_BOOL _nc_safe_strcat(
5185                 string_desc *dst,
5186                 const char *src)
5187                 { return(*(NCURSES_BOOL *)0); }
5188
5189 #undef _nc_safe_strcpy
5190 NCURSES_BOOL _nc_safe_strcpy(
5191                 string_desc *dst,
5192                 const char *src)
5193                 { return(*(NCURSES_BOOL *)0); }
5194
5195 /* ./trace/trace_buf.c */
5196
5197 #undef _nc_trace_buf
5198 char    *_nc_trace_buf(
5199                 int     bufnum,
5200                 size_t  want)
5201                 { return(*(char **)0); }
5202
5203 #undef _nc_trace_bufcat
5204 char    *_nc_trace_bufcat(
5205                 int     bufnum,
5206                 const char *value)
5207                 { return(*(char **)0); }
5208
5209 /* ./trace/trace_tries.c */
5210
5211 #undef _nc_trace_tries
5212 void    _nc_trace_tries(
5213                 TRIES   *tree)
5214                 { /* void */ }
5215
5216 /* ./base/tries.c */
5217
5218 #undef _nc_expand_try
5219 char    *_nc_expand_try(
5220                 TRIES   *tree,
5221                 unsigned code,
5222                 int     *count,
5223                 size_t  len)
5224                 { return(*(char **)0); }
5225
5226 #undef _nc_remove_key
5227 int     _nc_remove_key(
5228                 TRIES   **tree,
5229                 unsigned code)
5230                 { return(*(int *)0); }
5231
5232 #undef _nc_remove_string
5233 int     _nc_remove_string(
5234                 TRIES   **tree,
5235                 const char *string)
5236                 { return(*(int *)0); }
5237
5238 /* ./tinfo/trim_sgr0.c */
5239
5240 #undef _nc_trim_sgr0
5241 char    *_nc_trim_sgr0(
5242                 TERMTYPE2 *tp)
5243                 { return(*(char **)0); }
5244
5245 /* ./unctrl.c */
5246
5247 #undef unctrl_sp
5248 const char *unctrl_sp(
5249                 SCREEN  *sp,
5250                 chtype  ch)
5251                 { return(*(const char **)0); }
5252
5253 #undef unctrl
5254 const char *unctrl(
5255                 chtype  ch)
5256                 { return(*(const char **)0); }
5257
5258 /* ./trace/visbuf.c */
5259
5260 #undef _nc_visbuf2
5261 const char *_nc_visbuf2(
5262                 int     bufnum,
5263                 const char *buf)
5264                 { return(*(const char **)0); }
5265
5266 #undef _nc_visbuf
5267 const char *_nc_visbuf(
5268                 const char *buf)
5269                 { return(*(const char **)0); }
5270
5271 #undef _nc_visbufn
5272 const char *_nc_visbufn(
5273                 const char *buf,
5274                 int     len)
5275                 { return(*(const char **)0); }
5276
5277 #undef _nc_viswbuf2
5278 const char *_nc_viswbuf2(
5279                 int     bufnum,
5280                 const wchar_t *buf)
5281                 { return(*(const char **)0); }
5282
5283 #undef _nc_viswbuf
5284 const char *_nc_viswbuf(
5285                 const wchar_t *buf)
5286                 { return(*(const char **)0); }
5287
5288 #undef _nc_viswbufn
5289 const char *_nc_viswbufn(
5290                 const wchar_t *buf,
5291                 int     len)
5292                 { return(*(const char **)0); }
5293
5294 #undef _nc_viswibuf
5295 const char *_nc_viswibuf(
5296                 const wint_t *buf)
5297                 { return(*(const char **)0); }
5298
5299 #undef _nc_viscbuf2
5300 const char *_nc_viscbuf2(
5301                 int     bufnum,
5302                 const cchar_t *buf,
5303                 int     len)
5304                 { return(*(const char **)0); }
5305
5306 #undef _nc_viscbuf
5307 const char *_nc_viscbuf(
5308                 const cchar_t *buf,
5309                 int     len)
5310                 { return(*(const char **)0); }
5311
5312 /* ./tinfo/alloc_entry.c */
5313
5314 #undef _nc_init_entry
5315 void    _nc_init_entry(
5316                 ENTRY   *const tp)
5317                 { /* void */ }
5318
5319 #undef _nc_copy_entry
5320 ENTRY   *_nc_copy_entry(
5321                 ENTRY   *oldp)
5322                 { return(*(ENTRY **)0); }
5323
5324 #undef _nc_save_str
5325 char    *_nc_save_str(
5326                 const char *const string)
5327                 { return(*(char **)0); }
5328
5329 #undef _nc_wrap_entry
5330 void    _nc_wrap_entry(
5331                 ENTRY   *const ep,
5332                 NCURSES_BOOL copy_strings)
5333                 { /* void */ }
5334
5335 #undef _nc_merge_entry
5336 void    _nc_merge_entry(
5337                 ENTRY   *const target,
5338                 ENTRY   *const source)
5339                 { /* void */ }
5340
5341 /* ./tinfo/captoinfo.c */
5342
5343 #undef _nc_captoinfo
5344 char    *_nc_captoinfo(
5345                 const char *cap,
5346                 const char *s,
5347                 int const parameterized)
5348                 { return(*(char **)0); }
5349
5350 #undef _nc_infotocap
5351 char    *_nc_infotocap(
5352                 const char *cap,
5353                 const char *str,
5354                 int const parameterized)
5355                 { return(*(char **)0); }
5356
5357 /* ./tinfo/comp_expand.c */
5358
5359 #undef _nc_tic_expand
5360 char    *_nc_tic_expand(
5361                 const char *srcp,
5362                 NCURSES_BOOL tic_format,
5363                 int     numbers)
5364                 { return(*(char **)0); }
5365
5366 /* ./tinfo/comp_parse.c */
5367
5368 #undef _nc_check_termtype2
5369 void    (*_nc_check_termtype2)(
5370                 TERMTYPE2 *p1,
5371                 NCURSES_BOOL p2);
5372
5373 #undef _nc_entry_match
5374 NCURSES_BOOL _nc_entry_match(
5375                 char    *n1,
5376                 char    *n2)
5377                 { return(*(NCURSES_BOOL *)0); }
5378
5379 #undef _nc_read_entry_source
5380 void    _nc_read_entry_source(
5381                 FILE    *fp,
5382                 char    *buf,
5383                 int     literal,
5384                 NCURSES_BOOL silent,
5385                 NCURSES_BOOL (*hook)(
5386                 ENTRY   *p1))
5387                 { /* void */ }
5388
5389 #undef _nc_resolve_uses2
5390 int     _nc_resolve_uses2(
5391                 NCURSES_BOOL fullresolve,
5392                 NCURSES_BOOL literal)
5393                 { return(*(int *)0); }
5394
5395 /* ./tinfo/comp_scan.c */
5396
5397 #undef _nc_syntax
5398 int     _nc_syntax;
5399 #undef _nc_strict_bsd
5400 int     _nc_strict_bsd;
5401 #undef _nc_curr_file_pos
5402 long    _nc_curr_file_pos;
5403 #undef _nc_comment_start
5404 long    _nc_comment_start;
5405 #undef _nc_comment_end
5406 long    _nc_comment_end;
5407 #undef _nc_start_line
5408 long    _nc_start_line;
5409 #undef _nc_curr_token
5410 struct token _nc_curr_token;
5411 #undef _nc_disable_period
5412 NCURSES_BOOL _nc_disable_period;
5413
5414 #undef _nc_reset_input
5415 void    _nc_reset_input(
5416                 FILE    *fp,
5417                 char    *buf)
5418                 { /* void */ }
5419
5420 #undef _nc_get_token
5421 int     _nc_get_token(
5422                 NCURSES_BOOL silent)
5423                 { return(*(int *)0); }
5424
5425 #undef _nc_trans_string
5426 int     _nc_trans_string(
5427                 char    *ptr,
5428                 char    *last)
5429                 { return(*(int *)0); }
5430
5431 #undef _nc_push_token
5432 void    _nc_push_token(
5433                 int     tokclass)
5434                 { /* void */ }
5435
5436 #undef _nc_panic_mode
5437 void    _nc_panic_mode(
5438                 char    ch)
5439                 { /* void */ }
5440
5441 /* ./tinfo/parse_entry.c */
5442
5443 #undef _nc_parse_entry
5444 int     _nc_parse_entry(
5445                 ENTRY   *entryp,
5446                 int     literal,
5447                 NCURSES_BOOL silent)
5448                 { return(*(int *)0); }
5449
5450 #undef _nc_capcmp
5451 int     _nc_capcmp(
5452                 const char *s,
5453                 const char *t)
5454                 { return(*(int *)0); }
5455
5456 /* ./tinfo/write_entry.c */
5457
5458 #undef _nc_set_writedir
5459 void    _nc_set_writedir(
5460                 const char *dir)
5461                 { /* void */ }
5462
5463 #undef _nc_write_entry
5464 void    _nc_write_entry(
5465                 TERMTYPE2 *const tp)
5466                 { /* void */ }
5467
5468 #undef _nc_write_object
5469 int     _nc_write_object(
5470                 TERMTYPE2 *tp,
5471                 char    *buffer,
5472                 unsigned *offset,
5473                 unsigned limit)
5474                 { return(*(int *)0); }
5475
5476 #undef _nc_tic_written
5477 int     _nc_tic_written(void)
5478                 { return(*(int *)0); }
5479
5480 /* ./base/define_key.c */
5481
5482 #undef define_key_sp
5483 int     define_key_sp(
5484                 SCREEN  *sp,
5485                 const char *str,
5486                 int     keycode)
5487                 { return(*(int *)0); }
5488
5489 #undef define_key
5490 int     define_key(
5491                 const char *str,
5492                 int     keycode)
5493                 { return(*(int *)0); }
5494
5495 /* ./tinfo/hashed_db.c */
5496
5497 #undef _nc_hashed_db
5498 void    _nc_hashed_db(void)
5499                 { /* void */ }
5500
5501 /* ./base/key_defined.c */
5502
5503 #undef key_defined_sp
5504 int     key_defined_sp(
5505                 SCREEN  *sp,
5506                 const char *str)
5507                 { return(*(int *)0); }
5508
5509 #undef key_defined
5510 int     key_defined(
5511                 const char *str)
5512                 { return(*(int *)0); }
5513
5514 /* ./base/keybound.c */
5515
5516 #undef keybound_sp
5517 char    *keybound_sp(
5518                 SCREEN  *sp,
5519                 int     code,
5520                 int     count)
5521                 { return(*(char **)0); }
5522
5523 #undef keybound
5524 char    *keybound(
5525                 int     code,
5526                 int     count)
5527                 { return(*(char **)0); }
5528
5529 /* ./base/keyok.c */
5530
5531 #undef keyok_sp
5532 int     keyok_sp(
5533                 SCREEN  *sp,
5534                 int     c,
5535                 NCURSES_BOOL flag)
5536                 { return(*(int *)0); }
5537
5538 #undef keyok
5539 int     keyok(
5540                 int     c,
5541                 NCURSES_BOOL flag)
5542                 { return(*(int *)0); }
5543
5544 /* ./base/version.c */
5545
5546 #undef curses_version
5547 const char *curses_version(void)
5548                 { return(*(const char **)0); }