ncurses/llib-lncursestw

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