ncurses/llib-lncursestw

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