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