ncurses/llib-lncursesw

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