ncurses/llib-lncursestw

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