ncurses/llib-lncursestw

   1 /****************************************************************************
   2  * Copyright 2018-2020,2021 Thomas E. Dickey                                *
   3  * Copyright 2009-2016,2017 Free Software Foundation, Inc.                  *
   4  *                                                                          *
   5  * Permission is hereby granted, free of charge, to any person obtaining a  *
   6  * copy of this software and associated documentation files (the            *
   7  * "Software"), to deal in the Software without restriction, including      *
   8  * without limitation the rights to use, copy, modify, merge, publish,      *
   9  * distribute, distribute with modifications, sublicense, and/or sell       *
  10  * copies of the Software, and to permit persons to whom the Software is    *
  11  * furnished to do so, subject to the following conditions:                 *
  12  *                                                                          *
  13  * The above copyright notice and this permission notice shall be included  *
  14  * in all copies or substantial portions of the Software.                   *
  15  *                                                                          *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23  *                                                                          *
  24  * Except as contained in this notice, the name(s) of the above copyright   *
  25  * holders shall not be used in advertising or otherwise to promote the     *
  26  * sale, use or other dealings in this Software without prior written       *
  27  * authorization.                                                           *
  28  ****************************************************************************/
  29
  30 /****************************************************************************
  31  *  Author: Thomas E. Dickey       2009-on                                  *
  32  ****************************************************************************/
  33 /* LINTLIBRARY */
  34
  35 /* ./tty/hardscroll.c */
  36
  37 #include <curses.priv.h>
  38
  39 #undef _nc_oldnums
  40 int     *_nc_oldnums;
  41
  42 #undef _nc_scroll_optimize_sp
  43 void    _nc_scroll_optimize_sp(
  44                 SCREEN  *sp)
  45                 { /* void */ }
  46
  47 #undef _nc_scroll_optimize
  48 void    _nc_scroll_optimize(void)
  49                 { /* void */ }
  50
  51 #undef _nc_linedump_sp
  52 void    _nc_linedump_sp(
  53                 SCREEN  *sp)
  54                 { /* void */ }
  55
  56 #undef _nc_linedump
  57 void    _nc_linedump(void)
  58                 { /* void */ }
  59
  60 /* ./tty/hashmap.c */
  61
  62 #undef _nc_hash_map_sp
  63 void    _nc_hash_map_sp(
  64                 SCREEN  *sp)
  65                 { /* void */ }
  66
  67 #undef _nc_hash_map
  68 void    _nc_hash_map(void)
  69                 { /* void */ }
  70
  71 #undef _nc_make_oldhash_sp
  72 void    _nc_make_oldhash_sp(
  73                 SCREEN  *sp,
  74                 int     i)
  75                 { /* void */ }
  76
  77 #undef _nc_make_oldhash
  78 void    _nc_make_oldhash(
  79                 int     i)
  80                 { /* void */ }
  81
  82 #undef _nc_scroll_oldhash_sp
  83 void    _nc_scroll_oldhash_sp(
  84                 SCREEN  *sp,
  85                 int     n,
  86                 int     top,
  87                 int     bot)
  88                 { /* void */ }
  89
  90 #undef _nc_scroll_oldhash
  91 void    _nc_scroll_oldhash(
  92                 int     n,
  93                 int     top,
  94                 int     bot)
  95                 { /* void */ }
  96
  97 /* ./base/lib_addch.c */
  98
  99 #undef _nc_render
 100 cchar_t _nc_render(
 101                 WINDOW  *win,
 102                 cchar_t ch)
 103                 { return(*(cchar_t *)0); }
 104
 105 #undef _nc_build_wch
 106 int     _nc_build_wch(
 107                 WINDOW  *win,
 108                 cchar_t *ch)
 109                 { return(*(int *)0); }
 110
 111 #undef _nc_waddch_nosync
 112 int     _nc_waddch_nosync(
 113                 WINDOW  *win,
 114                 const cchar_t c)
 115                 { return(*(int *)0); }
 116
 117 #undef waddch
 118 int     waddch(
 119                 WINDOW  *win,
 120                 const chtype ch)
 121                 { return(*(int *)0); }
 122
 123 #undef wechochar
 124 int     wechochar(
 125                 WINDOW  *win,
 126                 const chtype ch)
 127                 { return(*(int *)0); }
 128
 129 /* ./base/lib_addstr.c */
 130
 131 #undef waddnstr
 132 int     waddnstr(
 133                 WINDOW  *win,
 134                 const char *astr,
 135                 int     n)
 136                 { return(*(int *)0); }
 137
 138 #undef waddchnstr
 139 int     waddchnstr(
 140                 WINDOW  *win,
 141                 const chtype *astr,
 142                 int     n)
 143                 { return(*(int *)0); }
 144
 145 #undef _nc_wchstrlen
 146 int     _nc_wchstrlen(
 147                 const cchar_t *s)
 148                 { return(*(int *)0); }
 149
 150 #undef wadd_wchnstr
 151 int     wadd_wchnstr(
 152                 WINDOW  *win,
 153                 const cchar_t *astr,
 154                 int     n)
 155                 { return(*(int *)0); }
 156
 157 #undef waddnwstr
 158 int     waddnwstr(
 159                 WINDOW  *win,
 160                 const wchar_t *str,
 161                 int     n)
 162                 { return(*(int *)0); }
 163
 164 /* ./base/lib_beep.c */
 165
 166 #undef beep_sp
 167 int     beep_sp(
 168                 SCREEN  *sp)
 169                 { return(*(int *)0); }
 170
 171 #undef beep
 172 int     beep(void)
 173                 { return(*(int *)0); }
 174
 175 /* ./base/lib_bkgd.c */
 176
 177 #undef wbkgrndset
 178 void    wbkgrndset(
 179                 WINDOW  *win,
 180                 const cchar_t *ch)
 181                 { /* void */ }
 182
 183 #undef wbkgdset
 184 void    wbkgdset(
 185                 WINDOW  *win,
 186                 chtype  ch)
 187                 { /* void */ }
 188
 189 #undef wbkgrnd
 190 int     wbkgrnd(
 191                 WINDOW  *win,
 192                 const cchar_t *ch)
 193                 { return(*(int *)0); }
 194
 195 #undef wbkgd
 196 int     wbkgd(
 197                 WINDOW  *win,
 198                 chtype  ch)
 199                 { return(*(int *)0); }
 200
 201 /* ./base/lib_box.c */
 202
 203 #undef wborder
 204 int     wborder(
 205                 WINDOW  *win,
 206                 chtype  ls,
 207                 chtype  rs,
 208                 chtype  ts,
 209                 chtype  bs,
 210                 chtype  tl,
 211                 chtype  tr,
 212                 chtype  bl,
 213                 chtype  br)
 214                 { return(*(int *)0); }
 215
 216 /* ./base/lib_chgat.c */
 217
 218 #undef wchgat
 219 int     wchgat(
 220                 WINDOW  *win,
 221                 int     n,
 222                 attr_t  attr,
 223                 short   pair_arg,
 224                 const void *opts)
 225                 { return(*(int *)0); }
 226
 227 /* ./base/lib_clear.c */
 228
 229 #undef wclear
 230 int     wclear(
 231                 WINDOW  *win)
 232                 { return(*(int *)0); }
 233
 234 /* ./base/lib_clearok.c */
 235
 236 #undef clearok
 237 int     clearok(
 238                 WINDOW  *win,
 239                 NCURSES_BOOL flag)
 240                 { return(*(int *)0); }
 241
 242 /* ./base/lib_clrbot.c */
 243
 244 #undef wclrtobot
 245 int     wclrtobot(
 246                 WINDOW  *win)
 247                 { return(*(int *)0); }
 248
 249 /* ./base/lib_clreol.c */
 250
 251 #undef wclrtoeol
 252 int     wclrtoeol(
 253                 WINDOW  *win)
 254                 { return(*(int *)0); }
 255
 256 /* ./base/lib_color.c */
 257
 258 #undef _nc_COLOR_PAIRS
 259 int     _nc_COLOR_PAIRS(void)
 260                 { return(*(int *)0); }
 261
 262 #undef _nc_COLORS
 263 int     _nc_COLORS(void)
 264                 { return(*(int *)0); }
 265
 266 #undef _nc_reset_colors_sp
 267 NCURSES_BOOL _nc_reset_colors_sp(
 268                 SCREEN  *sp)
 269                 { return(*(NCURSES_BOOL *)0); }
 270
 271 #undef _nc_reset_colors
 272 NCURSES_BOOL _nc_reset_colors(void)
 273                 { return(*(NCURSES_BOOL *)0); }
 274
 275 #undef start_color_sp
 276 int     start_color_sp(
 277                 SCREEN  *sp)
 278                 { return(*(int *)0); }
 279
 280 #undef start_color
 281 int     start_color(void)
 282                 { return(*(int *)0); }
 283
 284 #undef _nc_change_pair
 285 void    _nc_change_pair(
 286                 SCREEN  *sp,
 287                 int     pair)
 288                 { /* void */ }
 289
 290 #undef _nc_reserve_pairs
 291 void    _nc_reserve_pairs(
 292                 SCREEN  *sp,
 293                 int     want)
 294                 { /* void */ }
 295
 296 #undef _nc_init_pair
 297 int     _nc_init_pair(
 298                 SCREEN  *sp,
 299                 int     pair,
 300                 int     f,
 301                 int     b)
 302                 { return(*(int *)0); }
 303
 304 #undef init_pair_sp
 305 int     init_pair_sp(
 306                 SCREEN  *sp,
 307                 short   pair,
 308                 short   f,
 309                 short   b)
 310                 { return(*(int *)0); }
 311
 312 #undef init_pair
 313 int     init_pair(
 314                 short   pair,
 315                 short   f,
 316                 short   b)
 317                 { return(*(int *)0); }
 318
 319 #undef _nc_init_color
 320 int     _nc_init_color(
 321                 SCREEN  *sp,
 322                 int     color,
 323                 int     r,
 324                 int     g,
 325                 int     b)
 326                 { return(*(int *)0); }
 327
 328 #undef init_color_sp
 329 int     init_color_sp(
 330                 SCREEN  *sp,
 331                 short   color,
 332                 short   r,
 333                 short   g,
 334                 short   b)
 335                 { return(*(int *)0); }
 336
 337 #undef init_color
 338 int     init_color(
 339                 short   color,
 340                 short   r,
 341                 short   g,
 342                 short   b)
 343                 { return(*(int *)0); }
 344
 345 #undef can_change_color_sp
 346 NCURSES_BOOL can_change_color_sp(
 347                 SCREEN  *sp)
 348                 { return(*(NCURSES_BOOL *)0); }
 349
 350 #undef can_change_color
 351 NCURSES_BOOL can_change_color(void)
 352                 { return(*(NCURSES_BOOL *)0); }
 353
 354 #undef has_colors_sp
 355 NCURSES_BOOL has_colors_sp(
 356                 SCREEN  *sp)
 357                 { return(*(NCURSES_BOOL *)0); }
 358
 359 #undef has_colors
 360 NCURSES_BOOL has_colors(void)
 361                 { return(*(NCURSES_BOOL *)0); }
 362
 363 #undef color_content_sp
 364 int     color_content_sp(
 365                 SCREEN  *sp,
 366                 short   color,
 367                 short   *r,
 368                 short   *g,
 369                 short   *b)
 370                 { return(*(int *)0); }
 371
 372 #undef color_content
 373 int     color_content(
 374                 short   color,
 375                 short   *r,
 376                 short   *g,
 377                 short   *b)
 378                 { return(*(int *)0); }
 379
 380 #undef _nc_pair_content
 381 int     _nc_pair_content(
 382                 SCREEN  *sp,
 383                 int     pair,
 384                 int     *f,
 385                 int     *b)
 386                 { return(*(int *)0); }
 387
 388 #undef pair_content_sp
 389 int     pair_content_sp(
 390                 SCREEN  *sp,
 391                 short   pair,
 392                 short   *f,
 393                 short   *b)
 394                 { return(*(int *)0); }
 395
 396 #undef pair_content
 397 int     pair_content(
 398                 short   pair,
 399                 short   *f,
 400                 short   *b)
 401                 { return(*(int *)0); }
 402
 403 #undef _nc_do_color_sp
 404 void    _nc_do_color_sp(
 405                 SCREEN  *sp,
 406                 int     old_pair,
 407                 int     pair,
 408                 int     reverse,
 409                 NCURSES_OUTC_sp outc)
 410                 { /* void */ }
 411
 412 #undef _nc_do_color
 413 void    _nc_do_color(
 414                 int     old_pair,
 415                 int     pair,
 416                 int     reverse,
 417                 NCURSES_OUTC outc)
 418                 { /* void */ }
 419
 420 #undef init_extended_pair_sp
 421 int     init_extended_pair_sp(
 422                 SCREEN  *sp,
 423                 int     pair,
 424                 int     f,
 425                 int     b)
 426                 { return(*(int *)0); }
 427
 428 #undef init_extended_color_sp
 429 int     init_extended_color_sp(
 430                 SCREEN  *sp,
 431                 int     color,
 432                 int     r,
 433                 int     g,
 434                 int     b)
 435                 { return(*(int *)0); }
 436
 437 #undef extended_color_content_sp
 438 int     extended_color_content_sp(
 439                 SCREEN  *sp,
 440                 int     color,
 441                 int     *r,
 442                 int     *g,
 443                 int     *b)
 444                 { return(*(int *)0); }
 445
 446 #undef extended_pair_content_sp
 447 int     extended_pair_content_sp(
 448                 SCREEN  *sp,
 449                 int     pair,
 450                 int     *f,
 451                 int     *b)
 452                 { return(*(int *)0); }
 453
 454 #undef reset_color_pairs_sp
 455 void    reset_color_pairs_sp(
 456                 SCREEN  *sp)
 457                 { /* void */ }
 458
 459 #undef init_extended_pair
 460 int     init_extended_pair(
 461                 int     pair,
 462                 int     f,
 463                 int     b)
 464                 { return(*(int *)0); }
 465
 466 #undef init_extended_color
 467 int     init_extended_color(
 468                 int     color,
 469                 int     r,
 470                 int     g,
 471                 int     b)
 472                 { return(*(int *)0); }
 473
 474 #undef extended_color_content
 475 int     extended_color_content(
 476                 int     color,
 477                 int     *r,
 478                 int     *g,
 479                 int     *b)
 480                 { return(*(int *)0); }
 481
 482 #undef extended_pair_content
 483 int     extended_pair_content(
 484                 int     pair,
 485                 int     *f,
 486                 int     *b)
 487                 { return(*(int *)0); }
 488
 489 #undef reset_color_pairs
 490 void    reset_color_pairs(void)
 491                 { /* void */ }
 492
 493 /* ./base/lib_colorset.c */
 494
 495 #undef wcolor_set
 496 int     wcolor_set(
 497                 WINDOW  *win,
 498                 short   pair_arg,
 499                 void    *opts)
 500                 { return(*(int *)0); }
 501
 502 /* ./base/lib_delch.c */
 503
 504 #undef wdelch
 505 int     wdelch(
 506                 WINDOW  *win)
 507                 { return(*(int *)0); }
 508
 509 /* ./base/lib_delwin.c */
 510
 511 #undef delwin
 512 int     delwin(
 513                 WINDOW  *win)
 514                 { return(*(int *)0); }
 515
 516 /* ./base/lib_echo.c */
 517
 518 #undef echo_sp
 519 int     echo_sp(
 520                 SCREEN  *sp)
 521                 { return(*(int *)0); }
 522
 523 #undef echo
 524 int     echo(void)
 525                 { return(*(int *)0); }
 526
 527 #undef noecho_sp
 528 int     noecho_sp(
 529                 SCREEN  *sp)
 530                 { return(*(int *)0); }
 531
 532 #undef noecho
 533 int     noecho(void)
 534                 { return(*(int *)0); }
 535
 536 /* ./base/lib_endwin.c */
 537
 538 #undef endwin_sp
 539 int     endwin_sp(
 540                 SCREEN  *sp)
 541                 { return(*(int *)0); }
 542
 543 #undef endwin
 544 int     endwin(void)
 545                 { return(*(int *)0); }
 546
 547 /* ./base/lib_erase.c */
 548
 549 #undef werase
 550 int     werase(
 551                 WINDOW  *win)
 552                 { return(*(int *)0); }
 553
 554 /* ./base/lib_flash.c */
 555
 556 #undef flash_sp
 557 int     flash_sp(
 558                 SCREEN  *sp)
 559                 { return(*(int *)0); }
 560
 561 #undef flash
 562 int     flash(void)
 563                 { return(*(int *)0); }
 564
 565 /* ./lib_gen.c */
 566
 567 #undef addch
 568 int     addch(
 569                 const chtype z)
 570                 { return(*(int *)0); }
 571
 572 #undef addchnstr
 573 int     addchnstr(
 574                 const chtype *a1,
 575                 int     z)
 576                 { return(*(int *)0); }
 577
 578 #undef addchstr
 579 int     addchstr(
 580                 const chtype *z)
 581                 { return(*(int *)0); }
 582
 583 #undef addnstr
 584 int     addnstr(
 585                 const char *a1,
 586                 int     z)
 587                 { return(*(int *)0); }
 588
 589 #undef addstr
 590 int     addstr(
 591                 const char *z)
 592                 { return(*(int *)0); }
 593
 594 #undef attroff
 595 int     attroff(
 596                 int     z)
 597                 { return(*(int *)0); }
 598
 599 #undef attron
 600 int     attron(
 601                 int     z)
 602                 { return(*(int *)0); }
 603
 604 #undef attrset
 605 int     attrset(
 606                 int     z)
 607                 { return(*(int *)0); }
 608
 609 #undef attr_get
 610 int     attr_get(
 611                 attr_t  *a1,
 612                 short   *a2,
 613                 void    *z)
 614                 { return(*(int *)0); }
 615
 616 #undef attr_off
 617 int     attr_off(
 618                 attr_t  a1,
 619                 void    *z)
 620                 { return(*(int *)0); }
 621
 622 #undef attr_on
 623 int     attr_on(
 624                 attr_t  a1,
 625                 void    *z)
 626                 { return(*(int *)0); }
 627
 628 #undef attr_set
 629 int     attr_set(
 630                 attr_t  a1,
 631                 short   a2,
 632                 void    *z)
 633                 { return(*(int *)0); }
 634
 635 #undef bkgd
 636 int     bkgd(
 637                 chtype  z)
 638                 { return(*(int *)0); }
 639
 640 #undef bkgdset
 641 void    bkgdset(
 642                 chtype  z)
 643                 { /* void */ }
 644
 645 #undef border
 646 int     border(
 647                 chtype  a1,
 648                 chtype  a2,
 649                 chtype  a3,
 650                 chtype  a4,
 651                 chtype  a5,
 652                 chtype  a6,
 653                 chtype  a7,
 654                 chtype  z)
 655                 { return(*(int *)0); }
 656
 657 #undef box
 658 int     box(
 659                 WINDOW  *a1,
 660                 chtype  a2,
 661                 chtype  z)
 662                 { return(*(int *)0); }
 663
 664 #undef chgat
 665 int     chgat(
 666                 int     a1,
 667                 attr_t  a2,
 668                 short   a3,
 669                 const void *z)
 670                 { return(*(int *)0); }
 671
 672 #undef clear
 673 int     clear(void)
 674                 { return(*(int *)0); }
 675
 676 #undef clrtobot
 677 int     clrtobot(void)
 678                 { return(*(int *)0); }
 679
 680 #undef clrtoeol
 681 int     clrtoeol(void)
 682                 { return(*(int *)0); }
 683
 684 #undef color_set
 685 int     color_set(
 686                 short   a1,
 687                 void    *z)
 688                 { return(*(int *)0); }
 689
 690 #undef COLOR_PAIR
 691 int     COLOR_PAIR(
 692                 int     z)
 693                 { return(*(int *)0); }
 694
 695 #undef delch
 696 int     delch(void)
 697                 { return(*(int *)0); }
 698
 699 #undef deleteln
 700 int     deleteln(void)
 701                 { return(*(int *)0); }
 702
 703 #undef echochar
 704 int     echochar(
 705                 const chtype z)
 706                 { return(*(int *)0); }
 707
 708 #undef erase
 709 int     erase(void)
 710                 { return(*(int *)0); }
 711
 712 #undef getbkgd
 713 chtype  getbkgd(
 714                 WINDOW  *z)
 715                 { return(*(chtype *)0); }
 716
 717 #undef getch
 718 int     getch(void)
 719                 { return(*(int *)0); }
 720
 721 #undef getnstr
 722 int     getnstr(
 723                 char    *a1,
 724                 int     z)
 725                 { return(*(int *)0); }
 726
 727 #undef getstr
 728 int     getstr(
 729                 char    *z)
 730                 { return(*(int *)0); }
 731
 732 #undef hline
 733 int     hline(
 734                 chtype  a1,
 735                 int     z)
 736                 { return(*(int *)0); }
 737
 738 #undef inch
 739 chtype  inch(void)
 740                 { return(*(chtype *)0); }
 741
 742 #undef inchnstr
 743 int     inchnstr(
 744                 chtype  *a1,
 745                 int     z)
 746                 { return(*(int *)0); }
 747
 748 #undef inchstr
 749 int     inchstr(
 750                 chtype  *z)
 751                 { return(*(int *)0); }
 752
 753 #undef innstr
 754 int     innstr(
 755                 char    *a1,
 756                 int     z)
 757                 { return(*(int *)0); }
 758
 759 #undef insch
 760 int     insch(
 761                 chtype  z)
 762                 { return(*(int *)0); }
 763
 764 #undef insdelln
 765 int     insdelln(
 766                 int     z)
 767                 { return(*(int *)0); }
 768
 769 #undef insertln
 770 int     insertln(void)
 771                 { return(*(int *)0); }
 772
 773 #undef insnstr
 774 int     insnstr(
 775                 const char *a1,
 776                 int     z)
 777                 { return(*(int *)0); }
 778
 779 #undef insstr
 780 int     insstr(
 781                 const char *z)
 782                 { return(*(int *)0); }
 783
 784 #undef instr
 785 int     instr(
 786                 char    *z)
 787                 { return(*(int *)0); }
 788
 789 #undef move
 790 int     move(
 791                 int     a1,
 792                 int     z)
 793                 { return(*(int *)0); }
 794
 795 #undef mvaddch
 796 int     mvaddch(
 797                 int     a1,
 798                 int     a2,
 799                 const chtype z)
 800                 { return(*(int *)0); }
 801
 802 #undef mvaddchnstr
 803 int     mvaddchnstr(
 804                 int     a1,
 805                 int     a2,
 806                 const chtype *a3,
 807                 int     z)
 808                 { return(*(int *)0); }
 809
 810 #undef mvaddchstr
 811 int     mvaddchstr(
 812                 int     a1,
 813                 int     a2,
 814                 const chtype *z)
 815                 { return(*(int *)0); }
 816
 817 #undef mvaddnstr
 818 int     mvaddnstr(
 819                 int     a1,
 820                 int     a2,
 821                 const char *a3,
 822                 int     z)
 823                 { return(*(int *)0); }
 824
 825 #undef mvaddstr
 826 int     mvaddstr(
 827                 int     a1,
 828                 int     a2,
 829                 const char *z)
 830                 { return(*(int *)0); }
 831
 832 #undef mvchgat
 833 int     mvchgat(
 834                 int     a1,
 835                 int     a2,
 836                 int     a3,
 837                 attr_t  a4,
 838                 short   a5,
 839                 const void *z)
 840                 { return(*(int *)0); }
 841
 842 #undef mvdelch
 843 int     mvdelch(
 844                 int     a1,
 845                 int     z)
 846                 { return(*(int *)0); }
 847
 848 #undef mvgetch
 849 int     mvgetch(
 850                 int     a1,
 851                 int     z)
 852                 { return(*(int *)0); }
 853
 854 #undef mvgetnstr
 855 int     mvgetnstr(
 856                 int     a1,
 857                 int     a2,
 858                 char    *a3,
 859                 int     z)
 860                 { return(*(int *)0); }
 861
 862 #undef mvgetstr
 863 int     mvgetstr(
 864                 int     a1,
 865                 int     a2,
 866                 char    *z)
 867                 { return(*(int *)0); }
 868
 869 #undef mvhline
 870 int     mvhline(
 871                 int     a1,
 872                 int     a2,
 873                 chtype  a3,
 874                 int     z)
 875                 { return(*(int *)0); }
 876
 877 #undef mvinch
 878 chtype  mvinch(
 879                 int     a1,
 880                 int     z)
 881                 { return(*(chtype *)0); }
 882
 883 #undef mvinchnstr
 884 int     mvinchnstr(
 885                 int     a1,
 886                 int     a2,
 887                 chtype  *a3,
 888                 int     z)
 889                 { return(*(int *)0); }
 890
 891 #undef mvinchstr
 892 int     mvinchstr(
 893                 int     a1,
 894                 int     a2,
 895                 chtype  *z)
 896                 { return(*(int *)0); }
 897
 898 #undef mvinnstr
 899 int     mvinnstr(
 900                 int     a1,
 901                 int     a2,
 902                 char    *a3,
 903                 int     z)
 904                 { return(*(int *)0); }
 905
 906 #undef mvinsch
 907 int     mvinsch(
 908                 int     a1,
 909                 int     a2,
 910                 chtype  z)
 911                 { return(*(int *)0); }
 912
 913 #undef mvinsnstr
 914 int     mvinsnstr(
 915                 int     a1,
 916                 int     a2,
 917                 const char *a3,
 918                 int     z)
 919                 { return(*(int *)0); }
 920
 921 #undef mvinsstr
 922 int     mvinsstr(
 923                 int     a1,
 924                 int     a2,
 925                 const char *z)
 926                 { return(*(int *)0); }
 927
 928 #undef mvinstr
 929 int     mvinstr(
 930                 int     a1,
 931                 int     a2,
 932                 char    *z)
 933                 { return(*(int *)0); }
 934
 935 #undef mvvline
 936 int     mvvline(
 937                 int     a1,
 938                 int     a2,
 939                 chtype  a3,
 940                 int     z)
 941                 { return(*(int *)0); }
 942
 943 #undef mvwaddch
 944 int     mvwaddch(
 945                 WINDOW  *a1,
 946                 int     a2,
 947                 int     a3,
 948                 const chtype z)
 949                 { return(*(int *)0); }
 950
 951 #undef mvwaddchnstr
 952 int     mvwaddchnstr(
 953                 WINDOW  *a1,
 954                 int     a2,
 955                 int     a3,
 956                 const chtype *a4,
 957                 int     z)
 958                 { return(*(int *)0); }
 959
 960 #undef mvwaddchstr
 961 int     mvwaddchstr(
 962                 WINDOW  *a1,
 963                 int     a2,
 964                 int     a3,
 965                 const chtype *z)
 966                 { return(*(int *)0); }
 967
 968 #undef mvwaddnstr
 969 int     mvwaddnstr(
 970                 WINDOW  *a1,
 971                 int     a2,
 972                 int     a3,
 973                 const char *a4,
 974                 int     z)
 975                 { return(*(int *)0); }
 976
 977 #undef mvwaddstr
 978 int     mvwaddstr(
 979                 WINDOW  *a1,
 980                 int     a2,
 981                 int     a3,
 982                 const char *z)
 983                 { return(*(int *)0); }
 984
 985 #undef mvwchgat
 986 int     mvwchgat(
 987                 WINDOW  *a1,
 988                 int     a2,
 989                 int     a3,
 990                 int     a4,
 991                 attr_t  a5,
 992                 short   a6,
 993                 const void *z)
 994                 { return(*(int *)0); }
 995
 996 #undef mvwdelch
 997 int     mvwdelch(
 998                 WINDOW  *a1,
 999                 int     a2,
1000                 int     z)
1001                 { return(*(int *)0); }
1002
1003 #undef mvwgetch
1004 int     mvwgetch(
1005                 WINDOW  *a1,
1006                 int     a2,
1007                 int     z)
1008                 { return(*(int *)0); }
1009
1010 #undef mvwgetnstr
1011 int     mvwgetnstr(
1012                 WINDOW  *a1,
1013                 int     a2,
1014                 int     a3,
1015                 char    *a4,
1016                 int     z)
1017                 { return(*(int *)0); }
1018
1019 #undef mvwgetstr
1020 int     mvwgetstr(
1021                 WINDOW  *a1,
1022                 int     a2,
1023                 int     a3,
1024                 char    *z)
1025                 { return(*(int *)0); }
1026
1027 #undef mvwhline
1028 int     mvwhline(
1029                 WINDOW  *a1,
1030                 int     a2,
1031                 int     a3,
1032                 chtype  a4,
1033                 int     z)
1034                 { return(*(int *)0); }
1035
1036 #undef mvwinch
1037 chtype  mvwinch(
1038                 WINDOW  *a1,
1039                 int     a2,
1040                 int     z)
1041                 { return(*(chtype *)0); }
1042
1043 #undef mvwinchnstr
1044 int     mvwinchnstr(
1045                 WINDOW  *a1,
1046                 int     a2,
1047                 int     a3,
1048                 chtype  *a4,
1049                 int     z)
1050                 { return(*(int *)0); }
1051
1052 #undef mvwinchstr
1053 int     mvwinchstr(
1054                 WINDOW  *a1,
1055                 int     a2,
1056                 int     a3,
1057                 chtype  *z)
1058                 { return(*(int *)0); }
1059
1060 #undef mvwinnstr
1061 int     mvwinnstr(
1062                 WINDOW  *a1,
1063                 int     a2,
1064                 int     a3,
1065                 char    *a4,
1066                 int     z)
1067                 { return(*(int *)0); }
1068
1069 #undef mvwinsch
1070 int     mvwinsch(
1071                 WINDOW  *a1,
1072                 int     a2,
1073                 int     a3,
1074                 chtype  z)
1075                 { return(*(int *)0); }
1076
1077 #undef mvwinsnstr
1078 int     mvwinsnstr(
1079                 WINDOW  *a1,
1080                 int     a2,
1081                 int     a3,
1082                 const char *a4,
1083                 int     z)
1084                 { return(*(int *)0); }
1085
1086 #undef mvwinsstr
1087 int     mvwinsstr(
1088                 WINDOW  *a1,
1089                 int     a2,
1090                 int     a3,
1091                 const char *z)
1092                 { return(*(int *)0); }
1093
1094 #undef mvwinstr
1095 int     mvwinstr(
1096                 WINDOW  *a1,
1097                 int     a2,
1098                 int     a3,
1099                 char    *z)
1100                 { return(*(int *)0); }
1101
1102 #undef mvwvline
1103 int     mvwvline(
1104                 WINDOW  *a1,
1105                 int     a2,
1106                 int     a3,
1107                 chtype  a4,
1108                 int     z)
1109                 { return(*(int *)0); }
1110
1111 #undef PAIR_NUMBER
1112 int     PAIR_NUMBER(
1113                 int     z)
1114                 { return(*(int *)0); }
1115
1116 #undef redrawwin
1117 int     redrawwin(
1118                 WINDOW  *z)
1119                 { return(*(int *)0); }
1120
1121 #undef refresh
1122 int     refresh(void)
1123                 { return(*(int *)0); }
1124
1125 #undef scrl
1126 int     scrl(
1127                 int     z)
1128                 { return(*(int *)0); }
1129
1130 #undef scroll
1131 int     scroll(
1132                 WINDOW  *z)
1133                 { return(*(int *)0); }
1134
1135 #undef setscrreg
1136 int     setscrreg(
1137                 int     a1,
1138                 int     z)
1139                 { return(*(int *)0); }
1140
1141 #undef slk_attr_off
1142 int     slk_attr_off(
1143                 const attr_t a1,
1144                 void    *z)
1145                 { return(*(int *)0); }
1146
1147 #undef slk_attr_on
1148 int     slk_attr_on(
1149                 attr_t  a1,
1150                 void    *z)
1151                 { return(*(int *)0); }
1152
1153 #undef standout
1154 int     standout(void)
1155                 { return(*(int *)0); }
1156
1157 #undef standend
1158 int     standend(void)
1159                 { return(*(int *)0); }
1160
1161 #undef timeout
1162 void    timeout(
1163                 int     z)
1164                 { /* void */ }
1165
1166 #undef touchline
1167 int     touchline(
1168                 WINDOW  *a1,
1169                 int     a2,
1170                 int     z)
1171                 { return(*(int *)0); }
1172
1173 #undef touchwin
1174 int     touchwin(
1175                 WINDOW  *z)
1176                 { return(*(int *)0); }
1177
1178 #undef untouchwin
1179 int     untouchwin(
1180                 WINDOW  *z)
1181                 { return(*(int *)0); }
1182
1183 #undef vline
1184 int     vline(
1185                 chtype  a1,
1186                 int     z)
1187                 { return(*(int *)0); }
1188
1189 #undef waddchstr
1190 int     waddchstr(
1191                 WINDOW  *a1,
1192                 const chtype *z)
1193                 { return(*(int *)0); }
1194
1195 #undef waddstr
1196 int     waddstr(
1197                 WINDOW  *a1,
1198                 const char *z)
1199                 { return(*(int *)0); }
1200
1201 #undef wattron
1202 int     wattron(
1203                 WINDOW  *a1,
1204                 int     z)
1205                 { return(*(int *)0); }
1206
1207 #undef wattroff
1208 int     wattroff(
1209                 WINDOW  *a1,
1210                 int     z)
1211                 { return(*(int *)0); }
1212
1213 #undef wattrset
1214 int     wattrset(
1215                 WINDOW  *a1,
1216                 int     z)
1217                 { return(*(int *)0); }
1218
1219 #undef wattr_get
1220 int     wattr_get(
1221                 WINDOW  *a1,
1222                 attr_t  *a2,
1223                 short   *a3,
1224                 void    *z)
1225                 { return(*(int *)0); }
1226
1227 #undef wattr_set
1228 int     wattr_set(
1229                 WINDOW  *a1,
1230                 attr_t  a2,
1231                 short   a3,
1232                 void    *z)
1233                 { return(*(int *)0); }
1234
1235 #undef wdeleteln
1236 int     wdeleteln(
1237                 WINDOW  *z)
1238                 { return(*(int *)0); }
1239
1240 #undef wgetstr
1241 int     wgetstr(
1242                 WINDOW  *a1,
1243                 char    *z)
1244                 { return(*(int *)0); }
1245
1246 #undef winchstr
1247 int     winchstr(
1248                 WINDOW  *a1,
1249                 chtype  *z)
1250                 { return(*(int *)0); }
1251
1252 #undef winsertln
1253 int     winsertln(
1254                 WINDOW  *z)
1255                 { return(*(int *)0); }
1256
1257 #undef winsstr
1258 int     winsstr(
1259                 WINDOW  *a1,
1260                 const char *z)
1261                 { return(*(int *)0); }
1262
1263 #undef winstr
1264 int     winstr(
1265                 WINDOW  *a1,
1266                 char    *z)
1267                 { return(*(int *)0); }
1268
1269 #undef wstandout
1270 int     wstandout(
1271                 WINDOW  *z)
1272                 { return(*(int *)0); }
1273
1274 #undef wstandend
1275 int     wstandend(
1276                 WINDOW  *z)
1277                 { return(*(int *)0); }
1278
1279 #undef getattrs
1280 int     getattrs(
1281                 const WINDOW *z)
1282                 { return(*(int *)0); }
1283
1284 #undef getcurx
1285 int     getcurx(
1286                 const WINDOW *z)
1287                 { return(*(int *)0); }
1288
1289 #undef getcury
1290 int     getcury(
1291                 const WINDOW *z)
1292                 { return(*(int *)0); }
1293
1294 #undef getbegx
1295 int     getbegx(
1296                 const WINDOW *z)
1297                 { return(*(int *)0); }
1298
1299 #undef getbegy
1300 int     getbegy(
1301                 const WINDOW *z)
1302                 { return(*(int *)0); }
1303
1304 #undef getmaxx
1305 int     getmaxx(
1306                 const WINDOW *z)
1307                 { return(*(int *)0); }
1308
1309 #undef getmaxy
1310 int     getmaxy(
1311                 const WINDOW *z)
1312                 { return(*(int *)0); }
1313
1314 #undef getparx
1315 int     getparx(
1316                 const WINDOW *z)
1317                 { return(*(int *)0); }
1318
1319 #undef getpary
1320 int     getpary(
1321                 const WINDOW *z)
1322                 { return(*(int *)0); }
1323
1324 #undef wgetparent
1325 WINDOW  *wgetparent(
1326                 const WINDOW *z)
1327                 { return(*(WINDOW **)0); }
1328
1329 #undef is_cleared
1330 NCURSES_BOOL is_cleared(
1331                 const WINDOW *z)
1332                 { return(*(NCURSES_BOOL *)0); }
1333
1334 #undef is_idcok
1335 NCURSES_BOOL is_idcok(
1336                 const WINDOW *z)
1337                 { return(*(NCURSES_BOOL *)0); }
1338
1339 #undef is_idlok
1340 NCURSES_BOOL is_idlok(
1341                 const WINDOW *z)
1342                 { return(*(NCURSES_BOOL *)0); }
1343
1344 #undef is_immedok
1345 NCURSES_BOOL is_immedok(
1346                 const WINDOW *z)
1347                 { return(*(NCURSES_BOOL *)0); }
1348
1349 #undef is_keypad
1350 NCURSES_BOOL is_keypad(
1351                 const WINDOW *z)
1352                 { return(*(NCURSES_BOOL *)0); }
1353
1354 #undef is_leaveok
1355 NCURSES_BOOL is_leaveok(
1356                 const WINDOW *z)
1357                 { return(*(NCURSES_BOOL *)0); }
1358
1359 #undef is_nodelay
1360 NCURSES_BOOL is_nodelay(
1361                 const WINDOW *z)
1362                 { return(*(NCURSES_BOOL *)0); }
1363
1364 #undef is_notimeout
1365 NCURSES_BOOL is_notimeout(
1366                 const WINDOW *z)
1367                 { return(*(NCURSES_BOOL *)0); }
1368
1369 #undef is_pad
1370 NCURSES_BOOL is_pad(
1371                 const WINDOW *z)
1372                 { return(*(NCURSES_BOOL *)0); }
1373
1374 #undef is_scrollok
1375 NCURSES_BOOL is_scrollok(
1376                 const WINDOW *z)
1377                 { return(*(NCURSES_BOOL *)0); }
1378
1379 #undef is_subwin
1380 NCURSES_BOOL is_subwin(
1381                 const WINDOW *z)
1382                 { return(*(NCURSES_BOOL *)0); }
1383
1384 #undef is_syncok
1385 NCURSES_BOOL is_syncok(
1386                 const WINDOW *z)
1387                 { return(*(NCURSES_BOOL *)0); }
1388
1389 #undef wgetdelay
1390 int     wgetdelay(
1391                 const WINDOW *z)
1392                 { return(*(int *)0); }
1393
1394 #undef wgetscrreg
1395 int     wgetscrreg(
1396                 const WINDOW *a1,
1397                 int     *a2,
1398                 int     *z)
1399                 { return(*(int *)0); }
1400
1401 #undef add_wch
1402 int     add_wch(
1403                 const cchar_t *z)
1404                 { return(*(int *)0); }
1405
1406 #undef add_wchnstr
1407 int     add_wchnstr(
1408                 const cchar_t *a1,
1409                 int     z)
1410                 { return(*(int *)0); }
1411
1412 #undef add_wchstr
1413 int     add_wchstr(
1414                 const cchar_t *z)
1415                 { return(*(int *)0); }
1416
1417 #undef addnwstr
1418 int     addnwstr(
1419                 const wchar_t *a1,
1420                 int     z)
1421                 { return(*(int *)0); }
1422
1423 #undef addwstr
1424 int     addwstr(
1425                 const wchar_t *z)
1426                 { return(*(int *)0); }
1427
1428 #undef bkgrnd
1429 int     bkgrnd(
1430                 const cchar_t *z)
1431                 { return(*(int *)0); }
1432
1433 #undef bkgrndset
1434 void    bkgrndset(
1435                 const cchar_t *z)
1436                 { /* void */ }
1437
1438 #undef border_set
1439 int     border_set(
1440                 const cchar_t *a1,
1441                 const cchar_t *a2,
1442                 const cchar_t *a3,
1443                 const cchar_t *a4,
1444                 const cchar_t *a5,
1445                 const cchar_t *a6,
1446                 const cchar_t *a7,
1447                 const cchar_t *z)
1448                 { return(*(int *)0); }
1449
1450 #undef box_set
1451 int     box_set(
1452                 WINDOW  *a1,
1453                 const cchar_t *a2,
1454                 const cchar_t *z)
1455                 { return(*(int *)0); }
1456
1457 #undef echo_wchar
1458 int     echo_wchar(
1459                 const cchar_t *z)
1460                 { return(*(int *)0); }
1461
1462 #undef get_wch
1463 int     get_wch(
1464                 wint_t  *z)
1465                 { return(*(int *)0); }
1466
1467 #undef get_wstr
1468 int     get_wstr(
1469                 wint_t  *z)
1470                 { return(*(int *)0); }
1471
1472 #undef getbkgrnd
1473 int     getbkgrnd(
1474                 cchar_t *z)
1475                 { return(*(int *)0); }
1476
1477 #undef getn_wstr
1478 int     getn_wstr(
1479                 wint_t  *a1,
1480                 int     z)
1481                 { return(*(int *)0); }
1482
1483 #undef hline_set
1484 int     hline_set(
1485                 const cchar_t *a1,
1486                 int     z)
1487                 { return(*(int *)0); }
1488
1489 #undef in_wch
1490 int     in_wch(
1491                 cchar_t *z)
1492                 { return(*(int *)0); }
1493
1494 #undef in_wchnstr
1495 int     in_wchnstr(
1496                 cchar_t *a1,
1497                 int     z)
1498                 { return(*(int *)0); }
1499
1500 #undef in_wchstr
1501 int     in_wchstr(
1502                 cchar_t *z)
1503                 { return(*(int *)0); }
1504
1505 #undef innwstr
1506 int     innwstr(
1507                 wchar_t *a1,
1508                 int     z)
1509                 { return(*(int *)0); }
1510
1511 #undef ins_nwstr
1512 int     ins_nwstr(
1513                 const wchar_t *a1,
1514                 int     z)
1515                 { return(*(int *)0); }
1516
1517 #undef ins_wch
1518 int     ins_wch(
1519                 const cchar_t *z)
1520                 { return(*(int *)0); }
1521
1522 #undef ins_wstr
1523 int     ins_wstr(
1524                 const wchar_t *z)
1525                 { return(*(int *)0); }
1526
1527 #undef inwstr
1528 int     inwstr(
1529                 wchar_t *z)
1530                 { return(*(int *)0); }
1531
1532 #undef mvadd_wch
1533 int     mvadd_wch(
1534                 int     a1,
1535                 int     a2,
1536                 const cchar_t *z)
1537                 { return(*(int *)0); }
1538
1539 #undef mvadd_wchnstr
1540 int     mvadd_wchnstr(
1541                 int     a1,
1542                 int     a2,
1543                 const cchar_t *a3,
1544                 int     z)
1545                 { return(*(int *)0); }
1546
1547 #undef mvadd_wchstr
1548 int     mvadd_wchstr(
1549                 int     a1,
1550                 int     a2,
1551                 const cchar_t *z)
1552                 { return(*(int *)0); }
1553
1554 #undef mvaddnwstr
1555 int     mvaddnwstr(
1556                 int     a1,
1557                 int     a2,
1558                 const wchar_t *a3,
1559                 int     z)
1560                 { return(*(int *)0); }
1561
1562 #undef mvaddwstr
1563 int     mvaddwstr(
1564                 int     a1,
1565                 int     a2,
1566                 const wchar_t *z)
1567                 { return(*(int *)0); }
1568
1569 #undef mvget_wch
1570 int     mvget_wch(
1571                 int     a1,
1572                 int     a2,
1573                 wint_t  *z)
1574                 { return(*(int *)0); }
1575
1576 #undef mvget_wstr
1577 int     mvget_wstr(
1578                 int     a1,
1579                 int     a2,
1580                 wint_t  *z)
1581                 { return(*(int *)0); }
1582
1583 #undef mvgetn_wstr
1584 int     mvgetn_wstr(
1585                 int     a1,
1586                 int     a2,
1587                 wint_t  *a3,
1588                 int     z)
1589                 { return(*(int *)0); }
1590
1591 #undef mvhline_set
1592 int     mvhline_set(
1593                 int     a1,
1594                 int     a2,
1595                 const cchar_t *a3,
1596                 int     z)
1597                 { return(*(int *)0); }
1598
1599 #undef mvin_wch
1600 int     mvin_wch(
1601                 int     a1,
1602                 int     a2,
1603                 cchar_t *z)
1604                 { return(*(int *)0); }
1605
1606 #undef mvin_wchnstr
1607 int     mvin_wchnstr(
1608                 int     a1,
1609                 int     a2,
1610                 cchar_t *a3,
1611                 int     z)
1612                 { return(*(int *)0); }
1613
1614 #undef mvin_wchstr
1615 int     mvin_wchstr(
1616                 int     a1,
1617                 int     a2,
1618                 cchar_t *z)
1619                 { return(*(int *)0); }
1620
1621 #undef mvinnwstr
1622 int     mvinnwstr(
1623                 int     a1,
1624                 int     a2,
1625                 wchar_t *a3,
1626                 int     z)
1627                 { return(*(int *)0); }
1628
1629 #undef mvins_nwstr
1630 int     mvins_nwstr(
1631                 int     a1,
1632                 int     a2,
1633                 const wchar_t *a3,
1634                 int     z)
1635                 { return(*(int *)0); }
1636
1637 #undef mvins_wch
1638 int     mvins_wch(
1639                 int     a1,
1640                 int     a2,
1641                 const cchar_t *z)
1642                 { return(*(int *)0); }
1643
1644 #undef mvins_wstr
1645 int     mvins_wstr(
1646                 int     a1,
1647                 int     a2,
1648                 const wchar_t *z)
1649                 { return(*(int *)0); }
1650
1651 #undef mvinwstr
1652 int     mvinwstr(
1653                 int     a1,
1654                 int     a2,
1655                 wchar_t *z)
1656                 { return(*(int *)0); }
1657
1658 #undef mvvline_set
1659 int     mvvline_set(
1660                 int     a1,
1661                 int     a2,
1662                 const cchar_t *a3,
1663                 int     z)
1664                 { return(*(int *)0); }
1665
1666 #undef mvwadd_wch
1667 int     mvwadd_wch(
1668                 WINDOW  *a1,
1669                 int     a2,
1670                 int     a3,
1671                 const cchar_t *z)
1672                 { return(*(int *)0); }
1673
1674 #undef mvwadd_wchnstr
1675 int     mvwadd_wchnstr(
1676                 WINDOW  *a1,
1677                 int     a2,
1678                 int     a3,
1679                 const cchar_t *a4,
1680                 int     z)
1681                 { return(*(int *)0); }
1682
1683 #undef mvwadd_wchstr
1684 int     mvwadd_wchstr(
1685                 WINDOW  *a1,
1686                 int     a2,
1687                 int     a3,
1688                 const cchar_t *z)
1689                 { return(*(int *)0); }
1690
1691 #undef mvwaddnwstr
1692 int     mvwaddnwstr(
1693                 WINDOW  *a1,
1694                 int     a2,
1695                 int     a3,
1696                 const wchar_t *a4,
1697                 int     z)
1698                 { return(*(int *)0); }
1699
1700 #undef mvwaddwstr
1701 int     mvwaddwstr(
1702                 WINDOW  *a1,
1703                 int     a2,
1704                 int     a3,
1705                 const wchar_t *z)
1706                 { return(*(int *)0); }
1707
1708 #undef mvwget_wch
1709 int     mvwget_wch(
1710                 WINDOW  *a1,
1711                 int     a2,
1712                 int     a3,
1713                 wint_t  *z)
1714                 { return(*(int *)0); }
1715
1716 #undef mvwget_wstr
1717 int     mvwget_wstr(
1718                 WINDOW  *a1,
1719                 int     a2,
1720                 int     a3,
1721                 wint_t  *z)
1722                 { return(*(int *)0); }
1723
1724 #undef mvwgetn_wstr
1725 int     mvwgetn_wstr(
1726                 WINDOW  *a1,
1727                 int     a2,
1728                 int     a3,
1729                 wint_t  *a4,
1730                 int     z)
1731                 { return(*(int *)0); }
1732
1733 #undef mvwhline_set
1734 int     mvwhline_set(
1735                 WINDOW  *a1,
1736                 int     a2,
1737                 int     a3,
1738                 const cchar_t *a4,
1739                 int     z)
1740                 { return(*(int *)0); }
1741
1742 #undef mvwin_wch
1743 int     mvwin_wch(
1744                 WINDOW  *a1,
1745                 int     a2,
1746                 int     a3,
1747                 cchar_t *z)
1748                 { return(*(int *)0); }
1749
1750 #undef mvwin_wchnstr
1751 int     mvwin_wchnstr(
1752                 WINDOW  *a1,
1753                 int     a2,
1754                 int     a3,
1755                 cchar_t *a4,
1756                 int     z)
1757                 { return(*(int *)0); }
1758
1759 #undef mvwin_wchstr
1760 int     mvwin_wchstr(
1761                 WINDOW  *a1,
1762                 int     a2,
1763                 int     a3,
1764                 cchar_t *z)
1765                 { return(*(int *)0); }
1766
1767 #undef mvwinnwstr
1768 int     mvwinnwstr(
1769                 WINDOW  *a1,
1770                 int     a2,
1771                 int     a3,
1772                 wchar_t *a4,
1773                 int     z)
1774                 { return(*(int *)0); }
1775
1776 #undef mvwins_nwstr
1777 int     mvwins_nwstr(
1778                 WINDOW  *a1,
1779                 int     a2,
1780                 int     a3,
1781                 const wchar_t *a4,
1782                 int     z)
1783                 { return(*(int *)0); }
1784
1785 #undef mvwins_wch
1786 int     mvwins_wch(
1787                 WINDOW  *a1,
1788                 int     a2,
1789                 int     a3,
1790                 const cchar_t *z)
1791                 { return(*(int *)0); }
1792
1793 #undef mvwins_wstr
1794 int     mvwins_wstr(
1795                 WINDOW  *a1,
1796                 int     a2,
1797                 int     a3,
1798                 const wchar_t *z)
1799                 { return(*(int *)0); }
1800
1801 #undef mvwinwstr
1802 int     mvwinwstr(
1803                 WINDOW  *a1,
1804                 int     a2,
1805                 int     a3,
1806                 wchar_t *z)
1807                 { return(*(int *)0); }
1808
1809 #undef mvwvline_set
1810 int     mvwvline_set(
1811                 WINDOW  *a1,
1812                 int     a2,
1813                 int     a3,
1814                 const cchar_t *a4,
1815                 int     z)
1816                 { return(*(int *)0); }
1817
1818 #undef vline_set
1819 int     vline_set(
1820                 const cchar_t *a1,
1821                 int     z)
1822                 { return(*(int *)0); }
1823
1824 #undef wadd_wchstr
1825 int     wadd_wchstr(
1826                 WINDOW  *a1,
1827                 const cchar_t *z)
1828                 { return(*(int *)0); }
1829
1830 #undef waddwstr
1831 int     waddwstr(
1832                 WINDOW  *a1,
1833                 const wchar_t *z)
1834                 { return(*(int *)0); }
1835
1836 #undef wget_wstr
1837 int     wget_wstr(
1838                 WINDOW  *a1,
1839                 wint_t  *z)
1840                 { return(*(int *)0); }
1841
1842 #undef wgetbkgrnd
1843 int     wgetbkgrnd(
1844                 WINDOW  *a1,
1845                 cchar_t *z)
1846                 { return(*(int *)0); }
1847
1848 #undef win_wchstr
1849 int     win_wchstr(
1850                 WINDOW  *a1,
1851                 cchar_t *z)
1852                 { return(*(int *)0); }
1853
1854 #undef wins_wstr
1855 int     wins_wstr(
1856                 WINDOW  *a1,
1857                 const wchar_t *z)
1858                 { return(*(int *)0); }
1859
1860 #undef mouse_trafo
1861 NCURSES_BOOL mouse_trafo(
1862                 int     *a1,
1863                 int     *a2,
1864                 NCURSES_BOOL z)
1865                 { return(*(NCURSES_BOOL *)0); }
1866
1867 /* ./base/lib_getch.c */
1868
1869 #undef _nc_ESCDELAY
1870 int     _nc_ESCDELAY(void)
1871                 { return(*(int *)0); }
1872
1873 #undef _nc_ptr_Escdelay
1874 int     *_nc_ptr_Escdelay(
1875                 SCREEN  *sp)
1876                 { return(*(int **)0); }
1877
1878 #undef set_escdelay_sp
1879 int     set_escdelay_sp(
1880                 SCREEN  *sp,
1881                 int     value)
1882                 { return(*(int *)0); }
1883
1884 #undef set_escdelay
1885 int     set_escdelay(
1886                 int     value)
1887                 { return(*(int *)0); }
1888
1889 #undef get_escdelay_sp
1890 int     get_escdelay_sp(
1891                 SCREEN  *sp)
1892                 { return(*(int *)0); }
1893
1894 #undef get_escdelay
1895 int     get_escdelay(void)
1896                 { return(*(int *)0); }
1897
1898 #undef _nc_wgetch
1899 int     _nc_wgetch(
1900                 WINDOW  *win,
1901                 int     *result,
1902                 int     use_meta)
1903                 { return(*(int *)0); }
1904
1905 #undef wgetch
1906 int     wgetch(
1907                 WINDOW  *win)
1908                 { return(*(int *)0); }
1909
1910 /* ./base/lib_getstr.c */
1911
1912 #undef wgetnstr
1913 int     wgetnstr(
1914                 WINDOW  *win,
1915                 char    *str,
1916                 int     maxlen)
1917                 { return(*(int *)0); }
1918
1919 /* ./base/lib_hline.c */
1920
1921 #undef whline
1922 int     whline(
1923                 WINDOW  *win,
1924                 chtype  ch,
1925                 int     n)
1926                 { return(*(int *)0); }
1927
1928 /* ./base/lib_immedok.c */
1929
1930 #undef immedok
1931 void    immedok(
1932                 WINDOW  *win,
1933                 NCURSES_BOOL flag)
1934                 { /* void */ }
1935
1936 /* ./base/lib_inchstr.c */
1937
1938 #undef winchnstr
1939 int     winchnstr(
1940                 WINDOW  *win,
1941                 chtype  *str,
1942                 int     n)
1943                 { return(*(int *)0); }
1944
1945 /* ./base/lib_initscr.c */
1946
1947 #undef initscr
1948 WINDOW  *initscr(void)
1949                 { return(*(WINDOW **)0); }
1950
1951 /* ./base/lib_insch.c */
1952
1953 #undef _nc_insert_ch
1954 int     _nc_insert_ch(
1955                 SCREEN  *sp,
1956                 WINDOW  *win,
1957                 chtype  ch)
1958                 { return(*(int *)0); }
1959
1960 #undef winsch
1961 int     winsch(
1962                 WINDOW  *win,
1963                 chtype  c)
1964                 { return(*(int *)0); }
1965
1966 /* ./base/lib_insdel.c */
1967
1968 #undef winsdelln
1969 int     winsdelln(
1970                 WINDOW  *win,
1971                 int     n)
1972                 { return(*(int *)0); }
1973
1974 /* ./base/lib_insnstr.c */
1975
1976 #undef winsnstr
1977 int     winsnstr(
1978                 WINDOW  *win,
1979                 const char *s,
1980                 int     n)
1981                 { return(*(int *)0); }
1982
1983 /* ./base/lib_instr.c */
1984
1985 #undef winnstr
1986 int     winnstr(
1987                 WINDOW  *win,
1988                 char    *str,
1989                 int     n)
1990                 { return(*(int *)0); }
1991
1992 /* ./base/lib_isendwin.c */
1993
1994 #undef isendwin_sp
1995 NCURSES_BOOL isendwin_sp(
1996                 SCREEN  *sp)
1997                 { return(*(NCURSES_BOOL *)0); }
1998
1999 #undef isendwin
2000 NCURSES_BOOL isendwin(void)
2001                 { return(*(NCURSES_BOOL *)0); }
2002
2003 /* ./base/lib_leaveok.c */
2004
2005 #undef leaveok
2006 int     leaveok(
2007                 WINDOW  *win,
2008                 NCURSES_BOOL flag)
2009                 { return(*(int *)0); }
2010
2011 /* ./base/lib_mouse.c */
2012
2013 #undef getmouse_sp
2014 int     getmouse_sp(
2015                 SCREEN  *sp,
2016                 MEVENT  *aevent)
2017                 { return(*(int *)0); }
2018
2019 #undef getmouse
2020 int     getmouse(
2021                 MEVENT  *aevent)
2022                 { return(*(int *)0); }
2023
2024 #undef ungetmouse_sp
2025 int     ungetmouse_sp(
2026                 SCREEN  *sp,
2027                 MEVENT  *aevent)
2028                 { return(*(int *)0); }
2029
2030 #undef ungetmouse
2031 int     ungetmouse(
2032                 MEVENT  *aevent)
2033                 { return(*(int *)0); }
2034
2035 #undef mousemask_sp
2036 mmask_t mousemask_sp(
2037                 SCREEN  *sp,
2038                 mmask_t newmask,
2039                 mmask_t *oldmask)
2040                 { return(*(mmask_t *)0); }
2041
2042 #undef mousemask
2043 mmask_t mousemask(
2044                 mmask_t newmask,
2045                 mmask_t *oldmask)
2046                 { return(*(mmask_t *)0); }
2047
2048 #undef wenclose
2049 NCURSES_BOOL wenclose(
2050                 const WINDOW *win,
2051                 int     y,
2052                 int     x)
2053                 { return(*(NCURSES_BOOL *)0); }
2054
2055 #undef mouseinterval_sp
2056 int     mouseinterval_sp(
2057                 SCREEN  *sp,
2058                 int     maxclick)
2059                 { return(*(int *)0); }
2060
2061 #undef mouseinterval
2062 int     mouseinterval(
2063                 int     maxclick)
2064                 { return(*(int *)0); }
2065
2066 #undef _nc_has_mouse
2067 NCURSES_BOOL _nc_has_mouse(
2068                 SCREEN  *sp)
2069                 { return(*(NCURSES_BOOL *)0); }
2070
2071 #undef has_mouse_sp
2072 NCURSES_BOOL has_mouse_sp(
2073                 SCREEN  *sp)
2074                 { return(*(NCURSES_BOOL *)0); }
2075
2076 #undef has_mouse
2077 NCURSES_BOOL has_mouse(void)
2078                 { return(*(NCURSES_BOOL *)0); }
2079
2080 #undef wmouse_trafo
2081 NCURSES_BOOL wmouse_trafo(
2082                 const WINDOW *win,
2083                 int     *pY,
2084                 int     *pX,
2085                 NCURSES_BOOL to_screen)
2086                 { return(*(NCURSES_BOOL *)0); }
2087
2088 /* ./base/lib_move.c */
2089
2090 #undef wmove
2091 int     wmove(
2092                 WINDOW  *win,
2093                 int     y,
2094                 int     x)
2095                 { return(*(int *)0); }
2096
2097 /* ./tty/lib_mvcur.c */
2098
2099 #undef _nc_msec_cost_sp
2100 int     _nc_msec_cost_sp(
2101                 SCREEN  *sp,
2102                 const char *const cap,
2103                 int     affcnt)
2104                 { return(*(int *)0); }
2105
2106 #undef _nc_msec_cost
2107 int     _nc_msec_cost(
2108                 const char *const cap,
2109                 int     affcnt)
2110                 { return(*(int *)0); }
2111
2112 #undef _nc_mvcur_resume_sp
2113 void    _nc_mvcur_resume_sp(
2114                 SCREEN  *sp)
2115                 { /* void */ }
2116
2117 #undef _nc_mvcur_resume
2118 void    _nc_mvcur_resume(void)
2119                 { /* void */ }
2120
2121 #undef _nc_mvcur_init_sp
2122 void    _nc_mvcur_init_sp(
2123                 SCREEN  *sp)
2124                 { /* void */ }
2125
2126 #undef _nc_mvcur_init
2127 void    _nc_mvcur_init(void)
2128                 { /* void */ }
2129
2130 #undef _nc_mvcur_wrap_sp
2131 void    _nc_mvcur_wrap_sp(
2132                 SCREEN  *sp)
2133                 { /* void */ }
2134
2135 #undef _nc_mvcur_wrap
2136 void    _nc_mvcur_wrap(void)
2137                 { /* void */ }
2138
2139 #undef _nc_mvcur_sp
2140 int     _nc_mvcur_sp(
2141                 SCREEN  *sp,
2142                 int     yold,
2143                 int     xold,
2144                 int     ynew,
2145                 int     xnew)
2146                 { return(*(int *)0); }
2147
2148 #undef _nc_mvcur
2149 int     _nc_mvcur(
2150                 int     yold,
2151                 int     xold,
2152                 int     ynew,
2153                 int     xnew)
2154                 { return(*(int *)0); }
2155
2156 #undef mvcur_sp
2157 int     mvcur_sp(
2158                 SCREEN  *sp,
2159                 int     yold,
2160                 int     xold,
2161                 int     ynew,
2162                 int     xnew)
2163                 { return(*(int *)0); }
2164
2165 #undef mvcur
2166 int     mvcur(
2167                 int     yold,
2168                 int     xold,
2169                 int     ynew,
2170                 int     xnew)
2171                 { return(*(int *)0); }
2172
2173 #undef _nc_optimize_enable
2174 int     _nc_optimize_enable;
2175
2176 /* ./base/lib_mvwin.c */
2177
2178 #undef mvwin
2179 int     mvwin(
2180                 WINDOW  *win,
2181                 int     by,
2182                 int     bx)
2183                 { return(*(int *)0); }
2184
2185 /* ./base/lib_newterm.c */
2186
2187 #undef filter_sp
2188 void    filter_sp(
2189                 SCREEN  *sp)
2190                 { /* void */ }
2191
2192 #undef filter
2193 void    filter(void)
2194                 { /* void */ }
2195
2196 #undef nofilter_sp
2197 void    nofilter_sp(
2198                 SCREEN  *sp)
2199                 { /* void */ }
2200
2201 #undef nofilter
2202 void    nofilter(void)
2203                 { /* void */ }
2204
2205 #undef newterm_sp
2206 SCREEN  *newterm_sp(
2207                 SCREEN  *sp,
2208                 const char *name,
2209                 FILE    *ofp,
2210                 FILE    *ifp)
2211                 { return(*(SCREEN **)0); }
2212
2213 #undef newterm
2214 SCREEN  *newterm(
2215                 const char *name,
2216                 FILE    *ofp,
2217                 FILE    *ifp)
2218                 { return(*(SCREEN **)0); }
2219
2220 /* ./base/lib_newwin.c */
2221
2222 #undef _nc_freewin
2223 int     _nc_freewin(
2224                 WINDOW  *win)
2225                 { return(*(int *)0); }
2226
2227 #undef newwin_sp
2228 WINDOW  *newwin_sp(
2229                 SCREEN  *sp,
2230                 int     num_lines,
2231                 int     num_columns,
2232                 int     begy,
2233                 int     begx)
2234                 { return(*(WINDOW **)0); }
2235
2236 #undef newwin
2237 WINDOW  *newwin(
2238                 int     num_lines,
2239                 int     num_columns,
2240                 int     begy,
2241                 int     begx)
2242                 { return(*(WINDOW **)0); }
2243
2244 #undef derwin
2245 WINDOW  *derwin(
2246                 WINDOW  *orig,
2247                 int     num_lines,
2248                 int     num_columns,
2249                 int     begy,
2250                 int     begx)
2251                 { return(*(WINDOW **)0); }
2252
2253 #undef subwin
2254 WINDOW  *subwin(
2255                 WINDOW  *w,
2256                 int     l,
2257                 int     c,
2258                 int     y,
2259                 int     x)
2260                 { return(*(WINDOW **)0); }
2261
2262 #undef _nc_makenew_sp
2263 WINDOW  *_nc_makenew_sp(
2264                 SCREEN  *sp,
2265                 int     num_lines,
2266                 int     num_columns,
2267                 int     begy,
2268                 int     begx,
2269                 int     flags)
2270                 { return(*(WINDOW **)0); }
2271
2272 #undef _nc_curscr_of
2273 WINDOW  *_nc_curscr_of(
2274                 SCREEN  *sp)
2275                 { return(*(WINDOW **)0); }
2276
2277 #undef _nc_newscr_of
2278 WINDOW  *_nc_newscr_of(
2279                 SCREEN  *sp)
2280                 { return(*(WINDOW **)0); }
2281
2282 #undef _nc_stdscr_of
2283 WINDOW  *_nc_stdscr_of(
2284                 SCREEN  *sp)
2285                 { return(*(WINDOW **)0); }
2286
2287 /* ./base/lib_nl.c */
2288
2289 #undef nl_sp
2290 int     nl_sp(
2291                 SCREEN  *sp)
2292                 { return(*(int *)0); }
2293
2294 #undef nl
2295 int     nl(void)
2296                 { return(*(int *)0); }
2297
2298 #undef nonl_sp
2299 int     nonl_sp(
2300                 SCREEN  *sp)
2301                 { return(*(int *)0); }
2302
2303 #undef nonl
2304 int     nonl(void)
2305                 { return(*(int *)0); }
2306
2307 /* ./base/lib_overlay.c */
2308
2309 #undef overlay
2310 int     overlay(
2311                 const WINDOW *win1,
2312                 WINDOW  *win2)
2313                 { return(*(int *)0); }
2314
2315 #undef overwrite
2316 int     overwrite(
2317                 const WINDOW *win1,
2318                 WINDOW  *win2)
2319                 { return(*(int *)0); }
2320
2321 #undef copywin
2322 int     copywin(
2323                 const WINDOW *src,
2324                 WINDOW  *dst,
2325                 int     sminrow,
2326                 int     smincol,
2327                 int     dminrow,
2328                 int     dmincol,
2329                 int     dmaxrow,
2330                 int     dmaxcol,
2331                 int     over)
2332                 { return(*(int *)0); }
2333
2334 /* ./base/lib_pad.c */
2335
2336 #undef newpad_sp
2337 WINDOW  *newpad_sp(
2338                 SCREEN  *sp,
2339                 int     l,
2340                 int     c)
2341                 { return(*(WINDOW **)0); }
2342
2343 #undef newpad
2344 WINDOW  *newpad(
2345                 int     l,
2346                 int     c)
2347                 { return(*(WINDOW **)0); }
2348
2349 #undef subpad
2350 WINDOW  *subpad(
2351                 WINDOW  *orig,
2352                 int     l,
2353                 int     c,
2354                 int     begy,
2355                 int     begx)
2356                 { return(*(WINDOW **)0); }
2357
2358 #undef prefresh
2359 int     prefresh(
2360                 WINDOW  *win,
2361                 int     pminrow,
2362                 int     pmincol,
2363                 int     sminrow,
2364                 int     smincol,
2365                 int     smaxrow,
2366                 int     smaxcol)
2367                 { return(*(int *)0); }
2368
2369 #undef pnoutrefresh
2370 int     pnoutrefresh(
2371                 WINDOW  *win,
2372                 int     pminrow,
2373                 int     pmincol,
2374                 int     sminrow,
2375                 int     smincol,
2376                 int     smaxrow,
2377                 int     smaxcol)
2378                 { return(*(int *)0); }
2379
2380 #undef pechochar
2381 int     pechochar(
2382                 WINDOW  *pad,
2383                 const chtype ch)
2384                 { return(*(int *)0); }
2385
2386 /* ./base/lib_printw.c */
2387
2388 #undef printw
2389 int     printw(
2390                 const char *fmt,
2391                 ...)
2392                 { return(*(int *)0); }
2393
2394 #undef wprintw
2395 int     wprintw(
2396                 WINDOW  *win,
2397                 const char *fmt,
2398                 ...)
2399                 { return(*(int *)0); }
2400
2401 #undef mvprintw
2402 int     mvprintw(
2403                 int     y,
2404                 int     x,
2405                 const char *fmt,
2406                 ...)
2407                 { return(*(int *)0); }
2408
2409 #undef mvwprintw
2410 int     mvwprintw(
2411                 WINDOW  *win,
2412                 int     y,
2413                 int     x,
2414                 const char *fmt,
2415                 ...)
2416                 { return(*(int *)0); }
2417
2418 #undef vwprintw
2419 int     vwprintw(
2420                 WINDOW  *win,
2421                 const char *fmt,
2422                 va_list argp)
2423                 { return(*(int *)0); }
2424
2425 #undef vw_printw
2426 int     vw_printw(
2427                 WINDOW  *win,
2428                 const char *fmt,
2429                 va_list argp)
2430                 { return(*(int *)0); }
2431
2432 /* ./base/lib_redrawln.c */
2433
2434 #undef wredrawln
2435 int     wredrawln(
2436                 WINDOW  *win,
2437                 int     beg,
2438                 int     num)
2439                 { return(*(int *)0); }
2440
2441 /* ./base/lib_refresh.c */
2442
2443 #undef wrefresh
2444 int     wrefresh(
2445                 WINDOW  *win)
2446                 { return(*(int *)0); }
2447
2448 #undef wnoutrefresh
2449 int     wnoutrefresh(
2450                 WINDOW  *win)
2451                 { return(*(int *)0); }
2452
2453 /* ./base/lib_restart.c */
2454
2455 #undef restartterm_sp
2456 int     restartterm_sp(
2457                 SCREEN  *sp,
2458                 const char *termp,
2459                 int     filenum,
2460                 int     *errret)
2461                 { return(*(int *)0); }
2462
2463 #undef restartterm
2464 int     restartterm(
2465                 const char *termp,
2466                 int     filenum,
2467                 int     *errret)
2468                 { return(*(int *)0); }
2469
2470 /* ./base/lib_scanw.c */
2471
2472 #undef vwscanw
2473 int     vwscanw(
2474                 WINDOW  *win,
2475                 const char *fmt,
2476                 va_list argp)
2477                 { return(*(int *)0); }
2478
2479 #undef vw_scanw
2480 int     vw_scanw(
2481                 WINDOW  *win,
2482                 const char *fmt,
2483                 va_list argp)
2484                 { return(*(int *)0); }
2485
2486 #undef scanw
2487 int     scanw(
2488                 const char *fmt,
2489                 ...)
2490                 { return(*(int *)0); }
2491
2492 #undef wscanw
2493 int     wscanw(
2494                 WINDOW  *win,
2495                 const char *fmt,
2496                 ...)
2497                 { return(*(int *)0); }
2498
2499 #undef mvscanw
2500 int     mvscanw(
2501                 int     y,
2502                 int     x,
2503                 const char *fmt,
2504                 ...)
2505                 { return(*(int *)0); }
2506
2507 #undef mvwscanw
2508 int     mvwscanw(
2509                 WINDOW  *win,
2510                 int     y,
2511                 int     x,
2512                 const char *fmt,
2513                 ...)
2514                 { return(*(int *)0); }
2515
2516 /* ./base/lib_screen.c */
2517
2518 #undef getwin_sp
2519 WINDOW  *getwin_sp(
2520                 SCREEN  *sp,
2521                 FILE    *filep)
2522                 { return(*(WINDOW **)0); }
2523
2524 #undef getwin
2525 WINDOW  *getwin(
2526                 FILE    *filep)
2527                 { return(*(WINDOW **)0); }
2528
2529 #undef putwin
2530 int     putwin(
2531                 WINDOW  *win,
2532                 FILE    *filep)
2533                 { return(*(int *)0); }
2534
2535 #undef scr_restore_sp
2536 int     scr_restore_sp(
2537                 SCREEN  *sp,
2538                 const char *file)
2539                 { return(*(int *)0); }
2540
2541 #undef scr_restore
2542 int     scr_restore(
2543                 const char *file)
2544                 { return(*(int *)0); }
2545
2546 #undef scr_dump
2547 int     scr_dump(
2548                 const char *file)
2549                 { return(*(int *)0); }
2550
2551 #undef scr_init_sp
2552 int     scr_init_sp(
2553                 SCREEN  *sp,
2554                 const char *file)
2555                 { return(*(int *)0); }
2556
2557 #undef scr_init
2558 int     scr_init(
2559                 const char *file)
2560                 { return(*(int *)0); }
2561
2562 #undef scr_set_sp
2563 int     scr_set_sp(
2564                 SCREEN  *sp,
2565                 const char *file)
2566                 { return(*(int *)0); }
2567
2568 #undef scr_set
2569 int     scr_set(
2570                 const char *file)
2571                 { return(*(int *)0); }
2572
2573 /* ./base/lib_scroll.c */
2574
2575 #undef _nc_scroll_window
2576 void    _nc_scroll_window(
2577                 WINDOW  *win,
2578                 int const n,
2579                 int const top,
2580                 int const bottom,
2581                 cchar_t blank)
2582                 { /* void */ }
2583
2584 #undef wscrl
2585 int     wscrl(
2586                 WINDOW  *win,
2587                 int     n)
2588                 { return(*(int *)0); }
2589
2590 /* ./base/lib_scrollok.c */
2591
2592 #undef scrollok
2593 int     scrollok(
2594                 WINDOW  *win,
2595                 NCURSES_BOOL flag)
2596                 { return(*(int *)0); }
2597
2598 /* ./base/lib_scrreg.c */
2599
2600 #undef wsetscrreg
2601 int     wsetscrreg(
2602                 WINDOW  *win,
2603                 int     top,
2604                 int     bottom)
2605                 { return(*(int *)0); }
2606
2607 /* ./base/lib_set_term.c */
2608
2609 #undef set_term
2610 SCREEN  *set_term(
2611                 SCREEN  *screenp)
2612                 { return(*(SCREEN **)0); }
2613
2614 #undef delscreen
2615 void    delscreen(
2616                 SCREEN  *sp)
2617                 { /* void */ }
2618
2619 #undef _nc_setupscreen_sp
2620 int     _nc_setupscreen_sp(
2621                 SCREEN  **spp,
2622                 int     slines,
2623                 int     scolumns,
2624                 FILE    *output,
2625                 int     filtered,
2626                 int     slk_format)
2627                 { return(*(int *)0); }
2628
2629 #undef _nc_setupscreen
2630 int     _nc_setupscreen(
2631                 int     slines,
2632                 int     scolumns,
2633                 FILE    *output,
2634                 int     filtered,
2635                 int     slk_format)
2636                 { return(*(int *)0); }
2637
2638 #undef _nc_ripoffline_sp
2639 int     _nc_ripoffline_sp(
2640                 SCREEN  *sp,
2641                 int     line,
2642                 int     (*init)(
2643                 WINDOW  *p1,
2644                 int     p2))
2645                 { return(*(int *)0); }
2646
2647 #undef _nc_ripoffline
2648 int     _nc_ripoffline(
2649                 int     line,
2650                 int     (*init)(
2651                 WINDOW  *p1,
2652                 int     p2))
2653                 { return(*(int *)0); }
2654
2655 #undef ripoffline_sp
2656 int     ripoffline_sp(
2657                 SCREEN  *sp,
2658                 int     line,
2659                 int     (*init)(
2660                 WINDOW  *p1,
2661                 int     p2))
2662                 { return(*(int *)0); }
2663
2664 #undef ripoffline
2665 int     ripoffline(
2666                 int     line,
2667                 int     (*init)(
2668                 WINDOW  *p1,
2669                 int     p2))
2670                 { return(*(int *)0); }
2671
2672 /* ./base/lib_slk.c */
2673
2674 #undef _nc_format_slks
2675 int     _nc_format_slks(
2676                 SCREEN  *sp,
2677                 int     cols)
2678                 { return(*(int *)0); }
2679
2680 #undef _nc_slk_initialize
2681 int     _nc_slk_initialize(
2682                 WINDOW  *stwin,
2683                 int     cols)
2684                 { return(*(int *)0); }
2685
2686 #undef slk_restore_sp
2687 int     slk_restore_sp(
2688                 SCREEN  *sp)
2689                 { return(*(int *)0); }
2690
2691 #undef slk_restore
2692 int     slk_restore(void)
2693                 { return(*(int *)0); }
2694
2695 /* ./base/lib_slkatr_set.c */
2696
2697 #undef slk_attr_set_sp
2698 int     slk_attr_set_sp(
2699                 SCREEN  *sp,
2700                 const attr_t attr,
2701                 short   pair_arg,
2702                 void    *opts)
2703                 { return(*(int *)0); }
2704
2705 #undef slk_attr_set
2706 int     slk_attr_set(
2707                 const attr_t attr,
2708                 short   pair_arg,
2709                 void    *opts)
2710                 { return(*(int *)0); }
2711
2712 /* ./base/lib_slkatrof.c */
2713
2714 #undef slk_attroff_sp
2715 int     slk_attroff_sp(
2716                 SCREEN  *sp,
2717                 const chtype attr)
2718                 { return(*(int *)0); }
2719
2720 #undef slk_attroff
2721 int     slk_attroff(
2722                 const chtype attr)
2723                 { return(*(int *)0); }
2724
2725 /* ./base/lib_slkatron.c */
2726
2727 #undef slk_attron_sp
2728 int     slk_attron_sp(
2729                 SCREEN  *sp,
2730                 const chtype attr)
2731                 { return(*(int *)0); }
2732
2733 #undef slk_attron
2734 int     slk_attron(
2735                 const chtype attr)
2736                 { return(*(int *)0); }
2737
2738 /* ./base/lib_slkatrset.c */
2739
2740 #undef slk_attrset_sp
2741 int     slk_attrset_sp(
2742                 SCREEN  *sp,
2743                 const chtype attr)
2744                 { return(*(int *)0); }
2745
2746 #undef slk_attrset
2747 int     slk_attrset(
2748                 const chtype attr)
2749                 { return(*(int *)0); }
2750
2751 /* ./base/lib_slkattr.c */
2752
2753 #undef slk_attr_sp
2754 attr_t  slk_attr_sp(
2755                 SCREEN  *sp)
2756                 { return(*(attr_t *)0); }
2757
2758 #undef slk_attr
2759 attr_t  slk_attr(void)
2760                 { return(*(attr_t *)0); }
2761
2762 /* ./base/lib_slkclear.c */
2763
2764 #undef slk_clear_sp
2765 int     slk_clear_sp(
2766                 SCREEN  *sp)
2767                 { return(*(int *)0); }
2768
2769 #undef slk_clear
2770 int     slk_clear(void)
2771                 { return(*(int *)0); }
2772
2773 /* ./base/lib_slkcolor.c */
2774
2775 #undef slk_color_sp
2776 int     slk_color_sp(
2777                 SCREEN  *sp,
2778                 short   pair_arg)
2779                 { return(*(int *)0); }
2780
2781 #undef slk_color
2782 int     slk_color(
2783                 short   pair_arg)
2784                 { return(*(int *)0); }
2785
2786 #undef extended_slk_color_sp
2787 int     extended_slk_color_sp(
2788                 SCREEN  *sp,
2789                 int     pair_arg)
2790                 { return(*(int *)0); }
2791
2792 #undef extended_slk_color
2793 int     extended_slk_color(
2794                 int     pair_arg)
2795                 { return(*(int *)0); }
2796
2797 /* ./base/lib_slkinit.c */
2798
2799 #undef slk_init_sp
2800 int     slk_init_sp(
2801                 SCREEN  *sp,
2802                 int     format)
2803                 { return(*(int *)0); }
2804
2805 #undef slk_init
2806 int     slk_init(
2807                 int     format)
2808                 { return(*(int *)0); }
2809
2810 /* ./base/lib_slklab.c */
2811
2812 #undef slk_label_sp
2813 char    *slk_label_sp(
2814                 SCREEN  *sp,
2815                 int     n)
2816                 { return(*(char **)0); }
2817
2818 #undef slk_label
2819 char    *slk_label(
2820                 int     n)
2821                 { return(*(char **)0); }
2822
2823 /* ./base/lib_slkrefr.c */
2824
2825 #undef slk_noutrefresh_sp
2826 int     slk_noutrefresh_sp(
2827                 SCREEN  *sp)
2828                 { return(*(int *)0); }
2829
2830 #undef slk_noutrefresh
2831 int     slk_noutrefresh(void)
2832                 { return(*(int *)0); }
2833
2834 #undef slk_refresh_sp
2835 int     slk_refresh_sp(
2836                 SCREEN  *sp)
2837                 { return(*(int *)0); }
2838
2839 #undef slk_refresh
2840 int     slk_refresh(void)
2841                 { return(*(int *)0); }
2842
2843 /* ./base/lib_slkset.c */
2844
2845 #undef slk_set_sp
2846 int     slk_set_sp(
2847                 SCREEN  *sp,
2848                 int     i,
2849                 const char *astr,
2850                 int     format)
2851                 { return(*(int *)0); }
2852
2853 #undef slk_set
2854 int     slk_set(
2855                 int     i,
2856                 const char *astr,
2857                 int     format)
2858                 { return(*(int *)0); }
2859
2860 /* ./base/lib_slktouch.c */
2861
2862 #undef slk_touch_sp
2863 int     slk_touch_sp(
2864                 SCREEN  *sp)
2865                 { return(*(int *)0); }
2866
2867 #undef slk_touch
2868 int     slk_touch(void)
2869                 { return(*(int *)0); }
2870
2871 /* ./base/lib_touch.c */
2872
2873 #undef is_linetouched
2874 NCURSES_BOOL is_linetouched(
2875                 WINDOW  *win,
2876                 int     line)
2877                 { return(*(NCURSES_BOOL *)0); }
2878
2879 #undef is_wintouched
2880 NCURSES_BOOL is_wintouched(
2881                 WINDOW  *win)
2882                 { return(*(NCURSES_BOOL *)0); }
2883
2884 #undef wtouchln
2885 int     wtouchln(
2886                 WINDOW  *win,
2887                 int     y,
2888                 int     n,
2889                 int     changed)
2890                 { return(*(int *)0); }
2891
2892 /* ./trace/lib_tracedmp.c */
2893
2894 #undef _tracedump
2895 void    _tracedump(
2896                 const char *name,
2897                 WINDOW  *win)
2898                 { /* void */ }
2899
2900 /* ./trace/lib_tracemse.c */
2901
2902 #undef _nc_trace_mmask_t
2903 char    *_nc_trace_mmask_t(
2904                 SCREEN  *sp,
2905                 mmask_t code)
2906                 { return(*(char **)0); }
2907
2908 #undef _nc_tracemouse
2909 char    *_nc_tracemouse(
2910                 SCREEN  *sp,
2911                 MEVENT const *ep)
2912                 { return(*(char **)0); }
2913
2914 #undef _nc_retrace_mmask_t
2915 mmask_t _nc_retrace_mmask_t(
2916                 SCREEN  *sp,
2917                 mmask_t code)
2918                 { return(*(mmask_t *)0); }
2919
2920 #undef _tracemouse
2921 char    *_tracemouse(
2922                 MEVENT const *ep)
2923                 { return(*(char **)0); }
2924
2925 /* ./tty/lib_tstp.c */
2926
2927 #undef _nc_signal_handler
2928 void    _nc_signal_handler(
2929                 int     enable)
2930                 { /* void */ }
2931
2932 /* ./base/lib_ungetch.c */
2933
2934 #undef _nc_fifo_dump
2935 void    _nc_fifo_dump(
2936                 SCREEN  *sp)
2937                 { /* void */ }
2938
2939 #undef ungetch_sp
2940 int     ungetch_sp(
2941                 SCREEN  *sp,
2942                 int     ch)
2943                 { return(*(int *)0); }
2944
2945 #undef ungetch
2946 int     ungetch(
2947                 int     ch)
2948                 { return(*(int *)0); }
2949
2950 /* ./tty/lib_vidattr.c */
2951
2952 #undef vidputs_sp
2953 int     vidputs_sp(
2954                 SCREEN  *sp,
2955                 chtype  newmode,
2956                 NCURSES_OUTC_sp outc)
2957                 { return(*(int *)0); }
2958
2959 #undef vidputs
2960 int     vidputs(
2961                 chtype  newmode,
2962                 NCURSES_OUTC outc)
2963                 { return(*(int *)0); }
2964
2965 #undef vidattr_sp
2966 int     vidattr_sp(
2967                 SCREEN  *sp,
2968                 chtype  newmode)
2969                 { return(*(int *)0); }
2970
2971 #undef vidattr
2972 int     vidattr(
2973                 chtype  newmode)
2974                 { return(*(int *)0); }
2975
2976 #undef termattrs_sp
2977 chtype  termattrs_sp(
2978                 SCREEN  *sp)
2979                 { return(*(chtype *)0); }
2980
2981 #undef termattrs
2982 chtype  termattrs(void)
2983                 { return(*(chtype *)0); }
2984
2985 /* ./base/lib_vline.c */
2986
2987 #undef wvline
2988 int     wvline(
2989                 WINDOW  *win,
2990                 chtype  ch,
2991                 int     n)
2992                 { return(*(int *)0); }
2993
2994 /* ./base/lib_wattroff.c */
2995
2996 #undef wattr_off
2997 int     wattr_off(
2998                 WINDOW  *win,
2999                 attr_t  at,
3000                 void    *opts)
3001                 { return(*(int *)0); }
3002
3003 /* ./base/lib_wattron.c */
3004
3005 #undef wattr_on
3006 int     wattr_on(
3007                 WINDOW  *win,
3008                 attr_t  at,
3009                 void    *opts)
3010                 { return(*(int *)0); }
3011
3012 /* ./base/lib_winch.c */
3013
3014 #undef winch
3015 chtype  winch(
3016                 WINDOW  *win)
3017                 { return(*(chtype *)0); }
3018
3019 /* ./base/lib_window.c */
3020
3021 #undef _nc_synchook
3022 void    _nc_synchook(
3023                 WINDOW  *win)
3024                 { /* void */ }
3025
3026 #undef mvderwin
3027 int     mvderwin(
3028                 WINDOW  *win,
3029                 int     y,
3030                 int     x)
3031                 { return(*(int *)0); }
3032
3033 #undef syncok
3034 int     syncok(
3035                 WINDOW  *win,
3036                 NCURSES_BOOL bf)
3037                 { return(*(int *)0); }
3038
3039 #undef wsyncup
3040 void    wsyncup(
3041                 WINDOW  *win)
3042                 { /* void */ }
3043
3044 #undef wsyncdown
3045 void    wsyncdown(
3046                 WINDOW  *win)
3047                 { /* void */ }
3048
3049 #undef wcursyncup
3050 void    wcursyncup(
3051                 WINDOW  *win)
3052                 { /* void */ }
3053
3054 #undef dupwin
3055 WINDOW  *dupwin(
3056                 WINDOW  *win)
3057                 { return(*(WINDOW **)0); }
3058
3059 /* ./base/nc_panel.c */
3060
3061 #undef _nc_panelhook_sp
3062 struct panelhook *_nc_panelhook_sp(
3063                 SCREEN  *sp)
3064                 { return(*(struct panelhook **)0); }
3065
3066 #undef _nc_panelhook
3067 struct panelhook *_nc_panelhook(void)
3068                 { return(*(struct panelhook **)0); }
3069
3070 /* ./base/safe_sprintf.c */
3071
3072 #undef _nc_printf_string_sp
3073 char    *_nc_printf_string_sp(
3074                 SCREEN  *sp,
3075                 const char *fmt,
3076                 va_list ap)
3077                 { return(*(char **)0); }
3078
3079 #undef _nc_printf_string
3080 char    *_nc_printf_string(
3081                 const char *fmt,
3082                 va_list ap)
3083                 { return(*(char **)0); }
3084
3085 /* ./tty/tty_update.c */
3086
3087 #undef doupdate_sp
3088 int     doupdate_sp(
3089                 SCREEN  *sp)
3090                 { return(*(int *)0); }
3091
3092 #undef doupdate
3093 int     doupdate(void)
3094                 { return(*(int *)0); }
3095
3096 #undef _nc_scrolln_sp
3097 int     _nc_scrolln_sp(
3098                 SCREEN  *sp,
3099                 int     n,
3100                 int     top,
3101                 int     bot,
3102                 int     maxy)
3103                 { return(*(int *)0); }
3104
3105 #undef _nc_scrolln
3106 int     _nc_scrolln(
3107                 int     n,
3108                 int     top,
3109                 int     bot,
3110                 int     maxy)
3111                 { return(*(int *)0); }
3112
3113 #undef _nc_screen_resume_sp
3114 void    _nc_screen_resume_sp(
3115                 SCREEN  *sp)
3116                 { /* void */ }
3117
3118 #undef _nc_screen_resume
3119 void    _nc_screen_resume(void)
3120                 { /* void */ }
3121
3122 #undef _nc_screen_init_sp
3123 void    _nc_screen_init_sp(
3124                 SCREEN  *sp)
3125                 { /* void */ }
3126
3127 #undef _nc_screen_init
3128 void    _nc_screen_init(void)
3129                 { /* void */ }
3130
3131 #undef _nc_screen_wrap_sp
3132 void    _nc_screen_wrap_sp(
3133                 SCREEN  *sp)
3134                 { /* void */ }
3135
3136 #undef _nc_screen_wrap
3137 void    _nc_screen_wrap(void)
3138                 { /* void */ }
3139
3140 #undef _nc_do_xmc_glitch_sp
3141 void    _nc_do_xmc_glitch_sp(
3142                 SCREEN  *sp,
3143                 attr_t  previous)
3144                 { /* void */ }
3145
3146 #undef _nc_do_xmc_glitch
3147 void    _nc_do_xmc_glitch(
3148                 attr_t  previous)
3149                 { /* void */ }
3150
3151 /* ./trace/varargs.c */
3152
3153 #undef _nc_varargs
3154 char    *_nc_varargs(
3155                 const char *fmt,
3156                 va_list ap)
3157                 { return(*(char **)0); }
3158
3159 /* ./base/vsscanf.c */
3160
3161 #undef _nc_vsscanf
3162 void    _nc_vsscanf(void)
3163                 { /* void */ }
3164
3165 /* ./base/lib_freeall.c */
3166
3167 #undef _nc_freeall
3168 void    _nc_freeall(void)
3169                 { /* void */ }
3170
3171 #undef _nc_free_and_exit_sp
3172 void    _nc_free_and_exit_sp(
3173                 SCREEN  *sp,
3174                 int     code)
3175                 { /* void */ }
3176
3177 #undef _nc_free_and_exit
3178 void    _nc_free_and_exit(
3179                 int     code)
3180                 { /* void */ }
3181
3182 #undef exit_curses
3183 void    exit_curses(
3184                 int     code)
3185                 { /* void */ }
3186
3187 /* ./widechar/charable.c */
3188
3189 #undef _nc_is_charable
3190 NCURSES_BOOL _nc_is_charable(
3191                 wchar_t ch)
3192                 { return(*(NCURSES_BOOL *)0); }
3193
3194 #undef _nc_to_char
3195 int     _nc_to_char(
3196                 wint_t  ch)
3197                 { return(*(int *)0); }
3198
3199 #undef _nc_to_widechar
3200 wint_t  _nc_to_widechar(
3201                 int     ch)
3202                 { return(*(wint_t *)0); }
3203
3204 /* ./widechar/lib_add_wch.c */
3205
3206 #undef wadd_wch
3207 int     wadd_wch(
3208                 WINDOW  *win,
3209                 const cchar_t *wch)
3210                 { return(*(int *)0); }
3211
3212 #undef wecho_wchar
3213 int     wecho_wchar(
3214                 WINDOW  *win,
3215                 const cchar_t *wch)
3216                 { return(*(int *)0); }
3217
3218 /* ./widechar/lib_box_set.c */
3219
3220 #undef wborder_set
3221 int     wborder_set(
3222                 WINDOW  *win,
3223                 const cchar_t *ls,
3224                 const cchar_t *rs,
3225                 const cchar_t *ts,
3226                 const cchar_t *bs,
3227                 const cchar_t *tl,
3228                 const cchar_t *tr,
3229                 const cchar_t *bl,
3230                 const cchar_t *br)
3231                 { return(*(int *)0); }
3232
3233 /* ./widechar/lib_cchar.c */
3234
3235 #undef setcchar
3236 int     setcchar(
3237                 cchar_t *wcval,
3238                 const wchar_t *wch,
3239                 const attr_t attrs,
3240                 short   pair_arg,
3241                 const void *opts)
3242                 { return(*(int *)0); }
3243
3244 #undef getcchar
3245 int     getcchar(
3246                 const cchar_t *wcval,
3247                 wchar_t *wch,
3248                 attr_t  *attrs,
3249                 short   *pair_arg,
3250                 void    *opts)
3251                 { return(*(int *)0); }
3252
3253 /* ./widechar/lib_erasewchar.c */
3254
3255 #undef erasewchar_sp
3256 int     erasewchar_sp(
3257                 SCREEN  *sp,
3258                 wchar_t *wch)
3259                 { return(*(int *)0); }
3260
3261 #undef erasewchar
3262 int     erasewchar(
3263                 wchar_t *wch)
3264                 { return(*(int *)0); }
3265
3266 #undef killwchar_sp
3267 int     killwchar_sp(
3268                 SCREEN  *sp,
3269                 wchar_t *wch)
3270                 { return(*(int *)0); }
3271
3272 #undef killwchar
3273 int     killwchar(
3274                 wchar_t *wch)
3275                 { return(*(int *)0); }
3276
3277 /* ./widechar/lib_get_wch.c */
3278
3279 #undef wget_wch
3280 int     wget_wch(
3281                 WINDOW  *win,
3282                 wint_t  *result)
3283                 { return(*(int *)0); }
3284
3285 /* ./widechar/lib_get_wstr.c */
3286
3287 #undef wgetn_wstr
3288 int     wgetn_wstr(
3289                 WINDOW  *win,
3290                 wint_t  *str,
3291                 int     maxlen)
3292                 { return(*(int *)0); }
3293
3294 /* ./widechar/lib_hline_set.c */
3295
3296 #undef whline_set
3297 int     whline_set(
3298                 WINDOW  *win,
3299                 const cchar_t *ch,
3300                 int     n)
3301                 { return(*(int *)0); }
3302
3303 /* ./widechar/lib_in_wch.c */
3304
3305 #undef win_wch
3306 int     win_wch(
3307                 WINDOW  *win,
3308                 cchar_t *wcval)
3309                 { return(*(int *)0); }
3310
3311 /* ./widechar/lib_in_wchnstr.c */
3312
3313 #undef win_wchnstr
3314 int     win_wchnstr(
3315                 WINDOW  *win,
3316                 cchar_t *wchstr,
3317                 int     n)
3318                 { return(*(int *)0); }
3319
3320 /* ./widechar/lib_ins_wch.c */
3321
3322 #undef _nc_insert_wch
3323 int     _nc_insert_wch(
3324                 WINDOW  *win,
3325                 const cchar_t *wch)
3326                 { return(*(int *)0); }
3327
3328 #undef wins_wch
3329 int     wins_wch(
3330                 WINDOW  *win,
3331                 const cchar_t *wch)
3332                 { return(*(int *)0); }
3333
3334 #undef wins_nwstr
3335 int     wins_nwstr(
3336                 WINDOW  *win,
3337                 const wchar_t *wstr,
3338                 int     n)
3339                 { return(*(int *)0); }
3340
3341 /* ./widechar/lib_inwstr.c */
3342
3343 #undef winnwstr
3344 int     winnwstr(
3345                 WINDOW  *win,
3346                 wchar_t *wstr,
3347                 int     n)
3348                 { return(*(int *)0); }
3349
3350 #undef winwstr
3351 int     winwstr(
3352                 WINDOW  *win,
3353                 wchar_t *wstr)
3354                 { return(*(int *)0); }
3355
3356 /* ./widechar/lib_key_name.c */
3357
3358 #undef key_name
3359 const char *key_name(
3360                 wchar_t c)
3361                 { return(*(const char **)0); }
3362
3363 /* ./widechar/lib_pecho_wchar.c */
3364
3365 #undef pecho_wchar
3366 int     pecho_wchar(
3367                 WINDOW  *pad,
3368                 const cchar_t *wch)
3369                 { return(*(int *)0); }
3370
3371 /* ./widechar/lib_slk_wset.c */
3372
3373 #undef slk_wset
3374 int     slk_wset(
3375                 int     i,
3376                 const wchar_t *astr,
3377                 int     format)
3378                 { return(*(int *)0); }
3379
3380 /* ./widechar/lib_unget_wch.c */
3381
3382 #undef _nc_wcrtomb
3383 size_t  _nc_wcrtomb(
3384                 char    *target,
3385                 wchar_t source,
3386                 mbstate_t *state)
3387                 { return(*(size_t *)0); }
3388
3389 #undef unget_wch_sp
3390 int     unget_wch_sp(
3391                 SCREEN  *sp,
3392                 const wchar_t wch)
3393                 { return(*(int *)0); }
3394
3395 #undef unget_wch
3396 int     unget_wch(
3397                 const wchar_t wch)
3398                 { return(*(int *)0); }
3399
3400 /* ./widechar/lib_vid_attr.c */
3401
3402 #undef vid_puts_sp
3403 int     vid_puts_sp(
3404                 SCREEN  *sp,
3405                 attr_t  newmode,
3406                 short   pair_arg,
3407                 void    *opts,
3408                 NCURSES_OUTC_sp outc)
3409                 { return(*(int *)0); }
3410
3411 #undef vid_puts
3412 int     vid_puts(
3413                 attr_t  newmode,
3414                 short   pair_arg,
3415                 void    *opts,
3416                 NCURSES_OUTC outc)
3417                 { return(*(int *)0); }
3418
3419 #undef vid_attr_sp
3420 int     vid_attr_sp(
3421                 SCREEN  *sp,
3422                 attr_t  newmode,
3423                 short   pair_arg,
3424                 void    *opts)
3425                 { return(*(int *)0); }
3426
3427 #undef vid_attr
3428 int     vid_attr(
3429                 attr_t  newmode,
3430                 short   pair_arg,
3431                 void    *opts)
3432                 { return(*(int *)0); }
3433
3434 #undef term_attrs_sp
3435 attr_t  term_attrs_sp(
3436                 SCREEN  *sp)
3437                 { return(*(attr_t *)0); }
3438
3439 #undef term_attrs
3440 attr_t  term_attrs(void)
3441                 { return(*(attr_t *)0); }
3442
3443 /* ./widechar/lib_vline_set.c */
3444
3445 #undef wvline_set
3446 int     wvline_set(
3447                 WINDOW  *win,
3448                 const cchar_t *ch,
3449                 int     n)
3450                 { return(*(int *)0); }
3451
3452 /* ./widechar/lib_wacs.c */
3453
3454 #undef _nc_wacs
3455 cchar_t *_nc_wacs;
3456
3457 #undef _nc_init_wacs
3458 void    _nc_init_wacs(void)
3459                 { /* void */ }
3460
3461 /* ./widechar/lib_wunctrl.c */
3462
3463 #undef wunctrl_sp
3464 wchar_t *wunctrl_sp(
3465                 SCREEN  *sp,
3466                 cchar_t *wc)
3467                 { return(*(wchar_t **)0); }
3468
3469 #undef wunctrl
3470 wchar_t *wunctrl(
3471                 cchar_t *wc)
3472                 { return(*(wchar_t **)0); }
3473
3474 /* ./expanded.c */
3475
3476 #undef _nc_toggle_attr_on
3477 void    _nc_toggle_attr_on(
3478                 attr_t  *S,
3479                 attr_t  at)
3480                 { /* void */ }
3481
3482 #undef _nc_toggle_attr_off
3483 void    _nc_toggle_attr_off(
3484                 attr_t  *S,
3485                 attr_t  at)
3486                 { /* void */ }
3487
3488 #undef _nc_DelCharCost_sp
3489 int     _nc_DelCharCost_sp(
3490                 SCREEN  *sp,
3491                 int     count)
3492                 { return(*(int *)0); }
3493
3494 #undef _nc_InsCharCost_sp
3495 int     _nc_InsCharCost_sp(
3496                 SCREEN  *sp,
3497                 int     count)
3498                 { return(*(int *)0); }
3499
3500 #undef _nc_UpdateAttrs_sp
3501 void    _nc_UpdateAttrs_sp(
3502                 SCREEN  *sp,
3503                 const cchar_t *c)
3504                 { /* void */ }
3505
3506 #undef _nc_DelCharCost
3507 int     _nc_DelCharCost(
3508                 int     count)
3509                 { return(*(int *)0); }
3510
3511 #undef _nc_InsCharCost
3512 int     _nc_InsCharCost(
3513                 int     count)
3514                 { return(*(int *)0); }
3515
3516 #undef _nc_UpdateAttrs
3517 void    _nc_UpdateAttrs(
3518                 const cchar_t *c)
3519                 { /* void */ }
3520
3521 /* ./base/legacy_coding.c */
3522
3523 #undef use_legacy_coding_sp
3524 int     use_legacy_coding_sp(
3525                 SCREEN  *sp,
3526                 int     level)
3527                 { return(*(int *)0); }
3528
3529 #undef use_legacy_coding
3530 int     use_legacy_coding(
3531                 int     level)
3532                 { return(*(int *)0); }
3533
3534 /* ./base/lib_dft_fgbg.c */
3535
3536 #undef use_default_colors_sp
3537 int     use_default_colors_sp(
3538                 SCREEN  *sp)
3539                 { return(*(int *)0); }
3540
3541 #undef use_default_colors
3542 int     use_default_colors(void)
3543                 { return(*(int *)0); }
3544
3545 #undef assume_default_colors_sp
3546 int     assume_default_colors_sp(
3547                 SCREEN  *sp,
3548                 int     fg,
3549                 int     bg)
3550                 { return(*(int *)0); }
3551
3552 #undef assume_default_colors
3553 int     assume_default_colors(
3554                 int     fg,
3555                 int     bg)
3556                 { return(*(int *)0); }
3557
3558 /* ./tinfo/lib_print.c */
3559
3560 #undef mcprint_sp
3561 int     mcprint_sp(
3562                 SCREEN  *sp,
3563                 char    *data,
3564                 int     len)
3565                 { return(*(int *)0); }
3566
3567 #undef mcprint
3568 int     mcprint(
3569                 char    *data,
3570                 int     len)
3571                 { return(*(int *)0); }
3572
3573 /* ./base/new_pair.c */
3574
3575 #undef _nc_free_ordered_pairs
3576 void    _nc_free_ordered_pairs(
3577                 SCREEN  *sp)
3578                 { /* void */ }
3579
3580 #undef _nc_reset_color_pair
3581 void    _nc_reset_color_pair(
3582                 SCREEN  *sp,
3583                 int     pair,
3584                 colorpair_t *next)
3585                 { /* void */ }
3586
3587 #undef _nc_set_color_pair
3588 void    _nc_set_color_pair(
3589                 SCREEN  *sp,
3590                 int     pair,
3591                 int     mode)
3592                 { /* void */ }
3593
3594 #undef _nc_copy_pairs
3595 void    _nc_copy_pairs(
3596                 SCREEN  *sp,
3597                 colorpair_t *target,
3598                 colorpair_t *source,
3599                 int     length)
3600                 { /* void */ }
3601
3602 #undef alloc_pair_sp
3603 int     alloc_pair_sp(
3604                 SCREEN  *sp,
3605                 int     fg,
3606                 int     bg)
3607                 { return(*(int *)0); }
3608
3609 #undef find_pair_sp
3610 int     find_pair_sp(
3611                 SCREEN  *sp,
3612                 int     fg,
3613                 int     bg)
3614                 { return(*(int *)0); }
3615
3616 #undef free_pair_sp
3617 int     free_pair_sp(
3618                 SCREEN  *sp,
3619                 int     pair)
3620                 { return(*(int *)0); }
3621
3622 #undef alloc_pair
3623 int     alloc_pair(
3624                 int     f,
3625                 int     b)
3626                 { return(*(int *)0); }
3627
3628 #undef find_pair
3629 int     find_pair(
3630                 int     f,
3631                 int     b)
3632                 { return(*(int *)0); }
3633
3634 #undef free_pair
3635 int     free_pair(
3636                 int     pair)
3637                 { return(*(int *)0); }
3638
3639 /* ./base/resizeterm.c */
3640
3641 #undef is_term_resized_sp
3642 NCURSES_BOOL is_term_resized_sp(
3643                 SCREEN  *sp,
3644                 int     ToLines,
3645                 int     ToCols)
3646                 { return(*(NCURSES_BOOL *)0); }
3647
3648 #undef is_term_resized
3649 NCURSES_BOOL is_term_resized(
3650                 int     ToLines,
3651                 int     ToCols)
3652                 { return(*(NCURSES_BOOL *)0); }
3653
3654 #undef resize_term_sp
3655 int     resize_term_sp(
3656                 SCREEN  *sp,
3657                 int     ToLines,
3658                 int     ToCols)
3659                 { return(*(int *)0); }
3660
3661 #undef resize_term
3662 int     resize_term(
3663                 int     ToLines,
3664                 int     ToCols)
3665                 { return(*(int *)0); }
3666
3667 #undef resizeterm_sp
3668 int     resizeterm_sp(
3669                 SCREEN  *sp,
3670                 int     ToLines,
3671                 int     ToCols)
3672                 { return(*(int *)0); }
3673
3674 #undef resizeterm
3675 int     resizeterm(
3676                 int &n