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                 TERMTYPE *to,
3714                 TERMTYPE *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 /* ./codes.c */
3724
3725 #undef boolcodes
3726 const char *const boolcodes[] = {0};
3727 #undef numcodes
3728 const char *const numcodes[] = {0};
3729 #undef strcodes
3730 const char *const strcodes[] = {0};
3731
3732 /* ./comp_captab.c */
3733
3734 #undef _nc_get_table
3735 const struct name_table_entry *_nc_get_table(
3736                 NCURSES_BOOL termcap)
3737                 { return(*(const struct name_table_entry **)0); }
3738
3739 #undef _nc_get_hash_table
3740 const HashValue *_nc_get_hash_table(
3741                 NCURSES_BOOL termcap)
3742                 { return(*(const HashValue **)0); }
3743
3744 #undef _nc_get_alias_table
3745 const struct alias *_nc_get_alias_table(
3746                 NCURSES_BOOL termcap)
3747                 { return(*(const struct alias **)0); }
3748
3749 #undef _nc_get_hash_info
3750 const HashData *_nc_get_hash_info(
3751                 NCURSES_BOOL termcap)
3752                 { return(*(const HashData **)0); }
3753
3754 /* ./tinfo/comp_error.c */
3755
3756 #undef _nc_suppress_warnings
3757 NCURSES_BOOL _nc_suppress_warnings;
3758 #undef _nc_curr_line
3759 int     _nc_curr_line;
3760 #undef _nc_curr_col
3761 int     _nc_curr_col;
3762
3763 #undef _nc_get_source
3764 const char *_nc_get_source(void)
3765                 { return(*(const char **)0); }
3766
3767 #undef _nc_set_source
3768 void    _nc_set_source(
3769                 const char *const name)
3770                 { /* void */ }
3771
3772 #undef _nc_set_type
3773 void    _nc_set_type(
3774                 const char *const name)
3775                 { /* void */ }
3776
3777 #undef _nc_get_type
3778 void    _nc_get_type(
3779                 char    *name)
3780                 { /* void */ }
3781
3782 #undef _nc_warning
3783 void    _nc_warning(
3784                 const char *const fmt,
3785                 ...)
3786                 { /* void */ }
3787
3788 #undef _nc_err_abort
3789 void    _nc_err_abort(
3790                 const char *const fmt,
3791                 ...)
3792                 { /* void */ }
3793
3794 #undef _nc_syserr_abort
3795 void    _nc_syserr_abort(
3796                 const char *const fmt,
3797                 ...)
3798                 { /* void */ }
3799
3800 /* ./tinfo/comp_hash.c */
3801
3802 #undef _nc_find_entry
3803 struct name_table_entry const *_nc_find_entry(
3804                 const char *string,
3805                 const HashValue *hash_table)
3806                 { return(*(struct name_table_entry const **)0); }
3807
3808 #undef _nc_find_type_entry
3809 struct name_table_entry const *_nc_find_type_entry(
3810                 const char *string,
3811                 int     type,
3812                 NCURSES_BOOL termcap)
3813                 { return(*(struct name_table_entry const **)0); }
3814
3815 /* ./tinfo/db_iterator.c */
3816
3817 #undef _nc_tic_dir
3818 const char *_nc_tic_dir(
3819                 const char *path)
3820                 { return(*(const char **)0); }
3821
3822 #undef _nc_keep_tic_dir
3823 void    _nc_keep_tic_dir(
3824                 const char *path)
3825                 { /* void */ }
3826
3827 #undef _nc_last_db
3828 void    _nc_last_db(void)
3829                 { /* void */ }
3830
3831 #undef _nc_next_db
3832 const char *_nc_next_db(
3833                 DBDIRS  *state,
3834                 int     *offset)
3835                 { return(*(const char **)0); }
3836
3837 #undef _nc_first_db
3838 void    _nc_first_db(
3839                 DBDIRS  *state,
3840                 int     *offset)
3841                 { /* void */ }
3842
3843 /* ./tinfo/doalloc.c */
3844
3845 #undef _nc_doalloc
3846 void    *_nc_doalloc(
3847                 void    *oldp,
3848                 size_t  amount)
3849                 { return(*(void **)0); }
3850
3851 /* ./tinfo/entries.c */
3852
3853 #undef _nc_head
3854 ENTRY   *_nc_head;
3855 #undef _nc_tail
3856 ENTRY   *_nc_tail;
3857
3858 #undef _nc_free_entry
3859 void    _nc_free_entry(
3860                 ENTRY   *headp,
3861                 TERMTYPE *tterm)
3862                 { /* void */ }
3863
3864 #undef _nc_free_entries
3865 void    _nc_free_entries(
3866                 ENTRY   *headp)
3867                 { /* void */ }
3868
3869 #undef _nc_delink_entry
3870 ENTRY   *_nc_delink_entry(
3871                 ENTRY   *headp,
3872                 TERMTYPE *tterm)
3873                 { return(*(ENTRY **)0); }
3874
3875 #undef _nc_leaks_tinfo
3876 void    _nc_leaks_tinfo(void)
3877                 { /* void */ }
3878
3879 /* ./fallback.c */
3880
3881 #undef _nc_fallback
3882 const TERMTYPE *_nc_fallback(
3883                 const char *name)
3884                 { return(*(const TERMTYPE **)0); }
3885
3886 /* ./tinfo/free_ttype.c */
3887
3888 #undef _nc_free_termtype
3889 void    _nc_free_termtype(
3890                 TERMTYPE *ptr)
3891                 { /* void */ }
3892
3893 #undef _nc_user_definable
3894 NCURSES_BOOL _nc_user_definable;
3895
3896 #undef use_extended_names
3897 int     use_extended_names(
3898                 NCURSES_BOOL flag)
3899                 { return(*(int *)0); }
3900
3901 /* ./tinfo/getenv_num.c */
3902
3903 #undef _nc_getenv_num
3904 int     _nc_getenv_num(
3905                 const char *name)
3906                 { return(*(int *)0); }
3907
3908 #undef _nc_setenv_num
3909 void    _nc_setenv_num(
3910                 const char *name,
3911                 int     value)
3912                 { /* void */ }
3913
3914 /* ./tinfo/home_terminfo.c */
3915
3916 #undef _nc_home_terminfo
3917 char    *_nc_home_terminfo(void)
3918                 { return(*(char **)0); }
3919
3920 /* ./tinfo/init_keytry.c */
3921
3922 #undef _nc_init_keytry
3923 void    _nc_init_keytry(
3924                 SCREEN  *sp)
3925                 { /* void */ }
3926
3927 /* ./tinfo/lib_acs.c */
3928
3929 #undef acs_map
3930 chtype  acs_map[128];
3931
3932 #undef _nc_init_acs_sp
3933 void    _nc_init_acs_sp(
3934                 SCREEN  *sp)
3935                 { /* void */ }
3936
3937 #undef _nc_init_acs
3938 void    _nc_init_acs(void)
3939                 { /* void */ }
3940
3941 /* ./tinfo/lib_baudrate.c */
3942
3943 struct speed {
3944     int given_speed;
3945     int actual_speed;
3946 };
3947
3948 #undef _nc_baudrate
3949 int     _nc_baudrate(
3950                 int     OSpeed)
3951                 { return(*(int *)0); }
3952
3953 #undef _nc_ospeed
3954 int     _nc_ospeed(
3955                 int     BaudRate)
3956                 { return(*(int *)0); }
3957
3958 #undef baudrate_sp
3959 int     baudrate_sp(
3960                 SCREEN  *sp)
3961                 { return(*(int *)0); }
3962
3963 #undef baudrate
3964 int     baudrate(void)
3965                 { return(*(int *)0); }
3966
3967 /* ./tinfo/lib_cur_term.c */
3968
3969 #undef cur_term
3970 TERMINAL *cur_term;
3971
3972 #undef set_curterm_sp
3973 TERMINAL *set_curterm_sp(
3974                 SCREEN  *sp,
3975                 TERMINAL *termp)
3976                 { return(*(TERMINAL **)0); }
3977
3978 #undef set_curterm
3979 TERMINAL *set_curterm(
3980                 TERMINAL *termp)
3981                 { return(*(TERMINAL **)0); }
3982
3983 #undef del_curterm_sp
3984 int     del_curterm_sp(
3985                 SCREEN  *sp,
3986                 TERMINAL *termp)
3987                 { return(*(int *)0); }
3988
3989 #undef del_curterm
3990 int     del_curterm(
3991                 TERMINAL *termp)
3992                 { return(*(int *)0); }
3993
3994 /* ./tinfo/lib_data.c */
3995
3996 #undef stdscr
3997 WINDOW  *stdscr;
3998 #undef curscr
3999 WINDOW  *curscr;
4000 #undef newscr
4001 WINDOW  *newscr;
4002 #undef _nc_screen_chain
4003 SCREEN  *_nc_screen_chain;
4004 #undef SP
4005 SCREEN  *SP;
4006 #undef _nc_globals
4007 NCURSES_GLOBALS _nc_globals;
4008 #undef _nc_prescreen
4009 NCURSES_PRESCREEN _nc_prescreen;
4010
4011 #undef _nc_screen_of
4012 SCREEN  *_nc_screen_of(
4013                 WINDOW  *win)
4014                 { return(*(SCREEN **)0); }
4015
4016 /* ./tinfo/lib_has_cap.c */
4017
4018 #undef has_ic_sp
4019 NCURSES_BOOL has_ic_sp(
4020                 SCREEN  *sp)
4021                 { return(*(NCURSES_BOOL *)0); }
4022
4023 #undef has_ic
4024 NCURSES_BOOL has_ic(void)
4025                 { return(*(NCURSES_BOOL *)0); }
4026
4027 #undef has_il_sp
4028 NCURSES_BOOL has_il_sp(
4029                 SCREEN  *sp)
4030                 { return(*(NCURSES_BOOL *)0); }
4031
4032 #undef has_il
4033 NCURSES_BOOL has_il(void)
4034                 { return(*(NCURSES_BOOL *)0); }
4035
4036 /* ./tinfo/lib_kernel.c */
4037
4038 #undef erasechar_sp
4039 char    erasechar_sp(
4040                 SCREEN  *sp)
4041                 { return(*(char *)0); }
4042
4043 #undef erasechar
4044 char    erasechar(void)
4045                 { return(*(char *)0); }
4046
4047 #undef killchar_sp
4048 char    killchar_sp(
4049                 SCREEN  *sp)
4050                 { return(*(char *)0); }
4051
4052 #undef killchar
4053 char    killchar(void)
4054                 { return(*(char *)0); }
4055
4056 #undef flushinp_sp
4057 int     flushinp_sp(
4058                 SCREEN  *sp)
4059                 { return(*(int *)0); }
4060
4061 #undef flushinp
4062 int     flushinp(void)
4063                 { return(*(int *)0); }
4064
4065 /* ./lib_keyname.c */
4066
4067 struct kn { short offset; int code; };
4068
4069 #undef keyname_sp
4070 const char *keyname_sp(
4071                 SCREEN  *sp,
4072                 int     c)
4073                 { return(*(const char **)0); }
4074
4075 #undef keyname
4076 const char *keyname(
4077                 int     c)
4078                 { return(*(const char **)0); }
4079
4080 /* ./tinfo/lib_longname.c */
4081
4082 #undef longname_sp
4083 char    *longname_sp(
4084                 SCREEN  *sp)
4085                 { return(*(char **)0); }
4086
4087 #undef longname
4088 char    *longname(void)
4089                 { return(*(char **)0); }
4090
4091 /* ./tinfo/lib_napms.c */
4092
4093 #undef napms_sp
4094 int     napms_sp(
4095                 SCREEN  *sp,
4096                 int     ms)
4097                 { return(*(int *)0); }
4098
4099 #undef napms
4100 int     napms(
4101                 int     ms)
4102                 { return(*(int *)0); }
4103
4104 /* ./tinfo/lib_options.c */
4105
4106 #undef idlok
4107 int     idlok(
4108                 WINDOW  *win,
4109                 NCURSES_BOOL flag)
4110                 { return(*(int *)0); }
4111
4112 #undef idcok
4113 void    idcok(
4114                 WINDOW  *win,
4115                 NCURSES_BOOL flag)
4116                 { /* void */ }
4117
4118 #undef halfdelay_sp
4119 int     halfdelay_sp(
4120                 SCREEN  *sp,
4121                 int     t)
4122                 { return(*(int *)0); }
4123
4124 #undef halfdelay
4125 int     halfdelay(
4126                 int     t)
4127                 { return(*(int *)0); }
4128
4129 #undef nodelay
4130 int     nodelay(
4131                 WINDOW  *win,
4132                 NCURSES_BOOL flag)
4133                 { return(*(int *)0); }
4134
4135 #undef notimeout
4136 int     notimeout(
4137                 WINDOW  *win,
4138                 NCURSES_BOOL f)
4139                 { return(*(int *)0); }
4140
4141 #undef wtimeout
4142 void    wtimeout(
4143                 WINDOW  *win,
4144                 int     delay)
4145                 { /* void */ }
4146
4147 #undef keypad
4148 int     keypad(
4149                 WINDOW  *win,
4150                 NCURSES_BOOL flag)
4151                 { return(*(int *)0); }
4152
4153 #undef meta
4154 int     meta(
4155                 WINDOW  *win,
4156                 NCURSES_BOOL flag)
4157                 { return(*(int *)0); }
4158
4159 #undef curs_set_sp
4160 int     curs_set_sp(
4161                 SCREEN  *sp,
4162                 int     vis)
4163                 { return(*(int *)0); }
4164
4165 #undef curs_set
4166 int     curs_set(
4167                 int     vis)
4168                 { return(*(int *)0); }
4169
4170 #undef typeahead_sp
4171 int     typeahead_sp(
4172                 SCREEN  *sp,
4173                 int     fd)
4174                 { return(*(int *)0); }
4175
4176 #undef typeahead
4177 int     typeahead(
4178                 int     fd)
4179                 { return(*(int *)0); }
4180
4181 #undef has_key_sp
4182 int     has_key_sp(
4183                 SCREEN  *sp,
4184                 int     keycode)
4185                 { return(*(int *)0); }
4186
4187 #undef has_key
4188 int     has_key(
4189                 int     keycode)
4190                 { return(*(int *)0); }
4191
4192 #undef _nc_putp_flush_sp
4193 int     _nc_putp_flush_sp(
4194                 SCREEN  *sp,
4195                 const char *name,
4196                 const char *value)
4197                 { return(*(int *)0); }
4198
4199 #undef _nc_keypad
4200 int     _nc_keypad(
4201                 SCREEN  *sp,
4202                 int     flag)
4203                 { return(*(int *)0); }
4204
4205 /* ./tinfo/lib_raw.c */
4206
4207 #undef raw_sp
4208 int     raw_sp(
4209                 SCREEN  *sp)
4210                 { return(*(int *)0); }
4211
4212 #undef raw
4213 int     raw(void)
4214                 { return(*(int *)0); }
4215
4216 #undef cbreak_sp
4217 int     cbreak_sp(
4218                 SCREEN  *sp)
4219                 { return(*(int *)0); }
4220
4221 #undef cbreak
4222 int     cbreak(void)
4223                 { return(*(int *)0); }
4224
4225 #undef qiflush_sp
4226 void    qiflush_sp(
4227                 SCREEN  *sp)
4228                 { /* void */ }
4229
4230 #undef qiflush
4231 void    qiflush(void)
4232                 { /* void */ }
4233
4234 #undef noraw_sp
4235 int     noraw_sp(
4236                 SCREEN  *sp)
4237                 { return(*(int *)0); }
4238
4239 #undef noraw
4240 int     noraw(void)
4241                 { return(*(int *)0); }
4242
4243 #undef nocbreak_sp
4244 int     nocbreak_sp(
4245                 SCREEN  *sp)
4246                 { return(*(int *)0); }
4247
4248 #undef nocbreak
4249 int     nocbreak(void)
4250                 { return(*(int *)0); }
4251
4252 #undef noqiflush_sp
4253 void    noqiflush_sp(
4254                 SCREEN  *sp)
4255                 { /* void */ }
4256
4257 #undef noqiflush
4258 void    noqiflush(void)
4259                 { /* void */ }
4260
4261 #undef intrflush_sp
4262 int     intrflush_sp(
4263                 SCREEN  *sp,
4264                 WINDOW  *win,
4265                 NCURSES_BOOL flag)
4266                 { return(*(int *)0); }
4267
4268 #undef intrflush
4269 int     intrflush(
4270                 WINDOW  *win,
4271                 NCURSES_BOOL flag)
4272                 { return(*(int *)0); }
4273
4274 /* ./tinfo/lib_setup.c */
4275
4276 #undef ttytype
4277 char    ttytype[256];
4278 #undef LINES
4279 int     LINES;
4280 #undef COLS
4281 int     COLS;
4282 #undef TABSIZE
4283 int     TABSIZE;
4284
4285 #undef set_tabsize_sp
4286 int     set_tabsize_sp(
4287                 SCREEN  *sp,
4288                 int     value)
4289                 { return(*(int *)0); }
4290
4291 #undef set_tabsize
4292 int     set_tabsize(
4293                 int     value)
4294                 { return(*(int *)0); }
4295
4296 #undef _nc_handle_sigwinch
4297 int     _nc_handle_sigwinch(
4298                 SCREEN  *sp)
4299                 { return(*(int *)0); }
4300
4301 #undef use_env_sp
4302 void    use_env_sp(
4303                 SCREEN  *sp,
4304                 NCURSES_BOOL f)
4305                 { /* void */ }
4306
4307 #undef use_tioctl_sp
4308 void    use_tioctl_sp(
4309                 SCREEN  *sp,
4310                 NCURSES_BOOL f)
4311                 { /* void */ }
4312
4313 #undef use_env
4314 void    use_env(
4315                 NCURSES_BOOL f)
4316                 { /* void */ }
4317
4318 #undef use_tioctl
4319 void    use_tioctl(
4320                 NCURSES_BOOL f)
4321                 { /* void */ }
4322
4323 #undef _nc_get_screensize
4324 void    _nc_get_screensize(
4325                 SCREEN  *sp,
4326                 int     *linep,
4327                 int     *colp)
4328                 { /* void */ }
4329
4330 #undef _nc_update_screensize
4331 void    _nc_update_screensize(
4332                 SCREEN  *sp)
4333                 { /* void */ }
4334
4335 #undef _nc_setup_tinfo
4336 int     _nc_setup_tinfo(
4337                 const char *const tn,
4338                 TERMTYPE *const tp)
4339                 { return(*(int *)0); }
4340
4341 #undef _nc_tinfo_cmdch
4342 void    _nc_tinfo_cmdch(
4343                 TERMINAL *termp,
4344                 int     proto)
4345                 { /* void */ }
4346
4347 #undef _nc_get_locale
4348 char    *_nc_get_locale(void)
4349                 { return(*(char **)0); }
4350
4351 #undef _nc_unicode_locale
4352 int     _nc_unicode_locale(void)
4353                 { return(*(int *)0); }
4354
4355 #undef _nc_locale_breaks_acs
4356 int     _nc_locale_breaks_acs(
4357                 TERMINAL *termp)
4358                 { return(*(int *)0); }
4359
4360 #undef _nc_setupterm
4361 int     _nc_setupterm(
4362                 const char *tname,
4363                 int     Filedes,
4364                 int     *errret,
4365                 int     reuse)
4366                 { return(*(int *)0); }
4367
4368 #undef new_prescr
4369 SCREEN  *new_prescr(void)
4370                 { return(*(SCREEN **)0); }
4371
4372 #undef setupterm
4373 int     setupterm(
4374                 const char *tname,
4375                 int     Filedes,
4376                 int     *errret)
4377                 { return(*(int *)0); }
4378
4379 /* ./tinfo/lib_termcap.c */
4380
4381 #undef UP
4382 char    *UP;
4383 #undef BC
4384 char    *BC;
4385
4386 #undef tgetent_sp
4387 int     tgetent_sp(
4388                 SCREEN  *sp,
4389                 char    *bufp,
4390                 const char *name)
4391                 { return(*(int *)0); }
4392
4393 #undef tgetent
4394 int     tgetent(
4395                 char    *bufp,
4396                 const char *name)
4397                 { return(*(int *)0); }
4398
4399 #undef tgetflag_sp
4400 int     tgetflag_sp(
4401                 SCREEN  *sp,
4402                 const char *id)
4403                 { return(*(int *)0); }
4404
4405 #undef tgetflag
4406 int     tgetflag(
4407                 const char *id)
4408                 { return(*(int *)0); }
4409
4410 #undef tgetnum_sp
4411 int     tgetnum_sp(
4412                 SCREEN  *sp,
4413                 const char *id)
4414                 { return(*(int *)0); }
4415
4416 #undef tgetnum
4417 int     tgetnum(
4418                 const char *id)
4419                 { return(*(int *)0); }
4420
4421 #undef tgetstr_sp
4422 char    *tgetstr_sp(
4423                 SCREEN  *sp,
4424                 const char *id,
4425                 char    **area)
4426                 { return(*(char **)0); }
4427
4428 #undef tgetstr
4429 char    *tgetstr(
4430                 const char *id,
4431                 char    **area)
4432                 { return(*(char **)0); }
4433
4434 /* ./tinfo/lib_termname.c */
4435
4436 #undef termname_sp
4437 char    *termname_sp(
4438                 SCREEN  *sp)
4439                 { return(*(char **)0); }
4440
4441 #undef termname
4442 char    *termname(void)
4443                 { return(*(char **)0); }
4444
4445 /* ./tinfo/lib_tgoto.c */
4446
4447 #undef tgoto
4448 char    *tgoto(
4449                 const char *string,
4450                 int     x,
4451                 int     y)
4452                 { return(*(char **)0); }
4453
4454 /* ./tinfo/lib_ti.c */
4455
4456 #undef tigetflag_sp
4457 int     tigetflag_sp(
4458                 SCREEN  *sp,
4459                 const char *str)
4460                 { return(*(int *)0); }
4461
4462 #undef tigetflag
4463 int     tigetflag(
4464                 const char *str)
4465                 { return(*(int *)0); }
4466
4467 #undef tigetnum_sp
4468 int     tigetnum_sp(
4469                 SCREEN  *sp,
4470                 const char *str)
4471                 { return(*(int *)0); }
4472
4473 #undef tigetnum
4474 int     tigetnum(
4475                 const char *str)
4476                 { return(*(int *)0); }
4477
4478 #undef tigetstr_sp
4479 char    *tigetstr_sp(
4480                 SCREEN  *sp,
4481                 const char *str)
4482                 { return(*(char **)0); }
4483
4484 #undef tigetstr
4485 char    *tigetstr(
4486                 const char *str)
4487                 { return(*(char **)0); }
4488
4489 /* ./tinfo/lib_tparm.c */
4490
4491 #undef _nc_tparm_err
4492 int     _nc_tparm_err;
4493
4494 #undef _nc_tparm_analyze
4495 int     _nc_tparm_analyze(
4496                 const char *string,
4497                 char    *p_is_s[9],
4498                 int     *_nc_popcount)
4499                 { return(*(int *)0); }
4500
4501 #undef tparm
4502 char    *tparm(
4503                 const char *string,
4504                 ...)
4505                 { return(*(char **)0); }
4506
4507 #undef tiparm
4508 char    *tiparm(
4509                 const char *string,
4510                 ...)
4511                 { return(*(char **)0); }
4512
4513 /* ./tinfo/lib_tputs.c */
4514
4515 #undef PC
4516 char    PC;
4517 #undef ospeed
4518 short   ospeed;
4519 #undef _nc_nulls_sent
4520 int     _nc_nulls_sent;
4521
4522 #undef _nc_set_no_padding
4523 void    _nc_set_no_padding(
4524                 SCREEN  *sp)
4525                 { /* void */ }
4526
4527 #undef delay_output_sp
4528 int     delay_output_sp(
4529                 SCREEN  *sp,
4530                 int     ms)
4531                 { return(*(int *)0); }
4532
4533 #undef delay_output
4534 int     delay_output(
4535                 int     ms)
4536                 { return(*(int *)0); }
4537
4538 #undef _nc_flush_sp
4539 void    _nc_flush_sp(
4540                 SCREEN  *sp)
4541                 { /* void */ }
4542
4543 #undef _nc_flush
4544 void    _nc_flush(void)
4545                 { /* void */ }
4546
4547 #undef _nc_outch_sp
4548 int     _nc_outch_sp(
4549                 SCREEN  *sp,
4550                 int     ch)
4551                 { return(*(int *)0); }
4552
4553 #undef _nc_outch
4554 int     _nc_outch(
4555                 int     ch)
4556                 { return(*(int *)0); }
4557
4558 #undef _nc_putchar_sp
4559 int     _nc_putchar_sp(
4560                 SCREEN  *sp,
4561                 int     ch)
4562                 { return(*(int *)0); }
4563
4564 #undef _nc_putchar
4565 int     _nc_putchar(
4566                 int     ch)
4567                 { return(*(int *)0); }
4568
4569 #undef putp_sp
4570 int     putp_sp(
4571                 SCREEN  *sp,
4572                 const char *string)
4573                 { return(*(int *)0); }
4574
4575 #undef putp
4576 int     putp(
4577                 const char *string)
4578                 { return(*(int *)0); }
4579
4580 #undef _nc_putp_sp
4581 int     _nc_putp_sp(
4582                 SCREEN  *sp,
4583                 const char *name,
4584                 const char *string)
4585                 { return(*(int *)0); }
4586
4587 #undef _nc_putp
4588 int     _nc_putp(
4589                 const char *name,
4590                 const char *string)
4591                 { return(*(int *)0); }
4592
4593 #undef tputs_sp
4594 int     tputs_sp(
4595                 SCREEN  *sp,
4596                 const char *string,
4597                 int     affcnt,
4598                 NCURSES_OUTC_sp outc)
4599                 { return(*(int *)0); }
4600
4601 #undef _nc_outc_wrapper
4602 int     _nc_outc_wrapper(
4603                 SCREEN  *sp,
4604                 int     c)
4605                 { return(*(int *)0); }
4606
4607 #undef tputs
4608 int     tputs(
4609                 const char *string,
4610                 int     affcnt,
4611                 int     (*outc)(
4612                 int     p1))
4613                 { return(*(int *)0); }
4614
4615 /* ./trace/lib_trace.c */
4616
4617 #undef _nc_tracing
4618 unsigned _nc_tracing;
4619 #undef _nc_tputs_trace
4620 const char *_nc_tputs_trace = {0};
4621 #undef _nc_outchars
4622 long    _nc_outchars;
4623
4624 #undef trace
4625 void    trace(
4626                 const unsigned int tracelevel)
4627                 { /* void */ }
4628
4629 #undef _tracef
4630 void    _tracef(
4631                 const char *fmt,
4632                 ...)
4633                 { /* void */ }
4634
4635 #undef _nc_retrace_bool
4636 NCURSES_BOOL _nc_retrace_bool(
4637                 int     code)
4638                 { return(*(NCURSES_BOOL *)0); }
4639
4640 #undef _nc_retrace_char
4641 char    _nc_retrace_char(
4642                 int     code)
4643                 { return(*(char *)0); }
4644
4645 #undef _nc_retrace_int
4646 int     _nc_retrace_int(
4647                 int     code)
4648                 { return(*(int *)0); }
4649
4650 #undef _nc_retrace_unsigned
4651 unsigned _nc_retrace_unsigned(
4652                 unsigned code)
4653                 { return(*(unsigned *)0); }
4654
4655 #undef _nc_retrace_ptr
4656 char    *_nc_retrace_ptr(
4657                 char    *code)
4658                 { return(*(char **)0); }
4659
4660 #undef _nc_retrace_cptr
4661 const char *_nc_retrace_cptr(
4662                 const char *code)
4663                 { return(*(const char **)0); }
4664
4665 #undef _nc_retrace_cvoid_ptr
4666 const void *_nc_retrace_cvoid_ptr(
4667                 const void *code)
4668                 { return(*(const void **)0); }
4669
4670 #undef _nc_retrace_void_ptr
4671 void    *_nc_retrace_void_ptr(
4672                 void    *code)
4673                 { return(*(void **)0); }
4674
4675 #undef _nc_retrace_sp
4676 SCREEN  *_nc_retrace_sp(
4677                 SCREEN  *code)
4678                 { return(*(SCREEN **)0); }
4679
4680 #undef _nc_retrace_win
4681 WINDOW  *_nc_retrace_win(
4682                 WINDOW  *code)
4683                 { return(*(WINDOW **)0); }
4684
4685 /* ./trace/lib_traceatr.c */
4686
4687 #undef _traceattr2
4688 char    *_traceattr2(
4689                 int     bufnum,
4690                 chtype  newmode)
4691                 { return(*(char **)0); }
4692
4693 #undef _traceattr
4694 char    *_traceattr(
4695                 attr_t  newmode)
4696                 { return(*(char **)0); }
4697
4698 #undef _nc_retrace_int_attr_t
4699 int     _nc_retrace_int_attr_t(
4700                 attr_t  code)
4701                 { return(*(int *)0); }
4702
4703 #undef _nc_retrace_attr_t
4704 attr_t  _nc_retrace_attr_t(
4705                 attr_t  code)
4706                 { return(*(attr_t *)0); }
4707
4708 #undef _nc_altcharset_name
4709 const char *_nc_altcharset_name(
4710                 attr_t  attr,
4711                 chtype  ch)
4712                 { return(*(const char **)0); }
4713
4714 #undef _tracechtype2
4715 char    *_tracechtype2(
4716                 int     bufnum,
4717                 chtype  ch)
4718                 { return(*(char **)0); }
4719
4720 #undef _tracechtype
4721 char    *_tracechtype(
4722                 chtype  ch)
4723                 { return(*(char **)0); }
4724
4725 #undef _nc_retrace_chtype
4726 chtype  _nc_retrace_chtype(
4727                 chtype  code)
4728                 { return(*(chtype *)0); }
4729
4730 #undef _tracecchar_t2
4731 char    *_tracecchar_t2(
4732                 int     bufnum,
4733                 const cchar_t *ch)
4734                 { return(*(char **)0); }
4735
4736 #undef _tracecchar_t
4737 char    *_tracecchar_t(
4738                 const cchar_t *ch)
4739                 { return(*(char **)0); }
4740
4741 /* ./trace/lib_tracebits.c */
4742
4743 #undef _nc_trace_ttymode
4744 char    *_nc_trace_ttymode(
4745                 struct termios *tty)
4746                 { return(*(char **)0); }
4747
4748 #undef _nc_tracebits
4749 char    *_nc_tracebits(void)
4750                 { return(*(char **)0); }
4751
4752 /* ./trace/lib_tracechr.c */
4753
4754 #undef _nc_tracechar
4755 char    *_nc_tracechar(
4756                 SCREEN  *sp,
4757                 int     ch)
4758                 { return(*(char **)0); }
4759
4760 #undef _tracechar
4761 char    *_tracechar(
4762                 int     ch)
4763                 { return(*(char **)0); }
4764
4765 /* ./tinfo/lib_ttyflags.c */
4766
4767 #undef _nc_get_tty_mode_sp
4768 int     _nc_get_tty_mode_sp(
4769                 SCREEN  *sp,
4770                 struct termios *buf)
4771                 { return(*(int *)0); }
4772
4773 #undef _nc_get_tty_mode
4774 int     _nc_get_tty_mode(
4775                 struct termios *buf)
4776                 { return(*(int *)0); }
4777
4778 #undef _nc_set_tty_mode_sp
4779 int     _nc_set_tty_mode_sp(
4780                 SCREEN  *sp,
4781                 struct termios *buf)
4782                 { return(*(int *)0); }
4783
4784 #undef _nc_set_tty_mode
4785 int     _nc_set_tty_mode(
4786                 struct termios *buf)
4787                 { return(*(int *)0); }
4788
4789 #undef def_shell_mode_sp
4790 int     def_shell_mode_sp(
4791                 SCREEN  *sp)
4792                 { return(*(int *)0); }
4793
4794 #undef def_shell_mode
4795 int     def_shell_mode(void)
4796                 { return(*(int *)0); }
4797
4798 #undef def_prog_mode_sp
4799 int     def_prog_mode_sp(
4800                 SCREEN  *sp)
4801                 { return(*(int *)0); }
4802
4803 #undef def_prog_mode
4804 int     def_prog_mode(void)
4805                 { return(*(int *)0); }
4806
4807 #undef reset_prog_mode_sp
4808 int     reset_prog_mode_sp(
4809                 SCREEN  *sp)
4810                 { return(*(int *)0); }
4811
4812 #undef reset_prog_mode
4813 int     reset_prog_mode(void)
4814                 { return(*(int *)0); }
4815
4816 #undef reset_shell_mode_sp
4817 int     reset_shell_mode_sp(
4818                 SCREEN  *sp)
4819                 { return(*(int *)0); }
4820
4821 #undef reset_shell_mode
4822 int     reset_shell_mode(void)
4823                 { return(*(int *)0); }
4824
4825 #undef savetty_sp
4826 int     savetty_sp(
4827                 SCREEN  *sp)
4828                 { return(*(int *)0); }
4829
4830 #undef savetty
4831 int     savetty(void)
4832                 { return(*(int *)0); }
4833
4834 #undef resetty_sp
4835 int     resetty_sp(
4836                 SCREEN  *sp)
4837                 { return(*(int *)0); }
4838
4839 #undef resetty
4840 int     resetty(void)
4841                 { return(*(int *)0); }
4842
4843 /* ./tty/lib_twait.c */
4844
4845 #undef _nc_timed_wait
4846 int     _nc_timed_wait(
4847                 SCREEN  *sp,
4848                 int     mode,
4849                 int     milliseconds,
4850                 int     *timeleft)
4851                 { return(*(int *)0); }
4852
4853 /* ./tinfo/name_match.c */
4854
4855 #undef _nc_first_name
4856 char    *_nc_first_name(
4857                 const char *const sp)
4858                 { return(*(char **)0); }
4859
4860 #undef _nc_name_match
4861 int     _nc_name_match(
4862                 const char *const namelst,
4863                 const char *const name,
4864                 const char *const delim)
4865                 { return(*(int *)0); }
4866
4867 /* ./names.c */
4868
4869 #undef boolnames
4870 const char *const boolnames[] = {0};
4871 #undef boolfnames
4872 const char *const boolfnames[] = {0};
4873 #undef numnames
4874 const char *const numnames[] = {0};
4875 #undef numfnames
4876 const char *const numfnames[] = {0};
4877 #undef strnames
4878 const char *const strnames[] = {0};
4879 #undef strfnames
4880 const char *const strfnames[] = {0};
4881
4882 /* ./tinfo/obsolete.c */
4883
4884 #undef _nc_set_buffer_sp
4885 void    _nc_set_buffer_sp(
4886                 SCREEN  *sp,
4887                 FILE    *ofp,
4888                 int     buffered)
4889                 { /* void */ }
4890
4891 #undef _nc_set_buffer
4892 void    _nc_set_buffer(
4893                 FILE    *ofp,
4894                 int     buffered)
4895                 { /* void */ }
4896
4897 /* ./tinfo/read_entry.c */
4898
4899 #undef _nc_init_termtype
4900 void    _nc_init_termtype(
4901                 TERMTYPE *const tp)
4902                 { /* void */ }
4903
4904 #undef _nc_read_termtype
4905 int     _nc_read_termtype(
4906                 TERMTYPE *ptr,
4907                 char    *buffer,
4908                 int     limit)
4909                 { return(*(int *)0); }
4910
4911 #undef _nc_read_file_entry
4912 int     _nc_read_file_entry(
4913                 const char *const filename,
4914                 TERMTYPE *ptr)
4915                 { return(*(int *)0); }
4916
4917 #undef _nc_read_entry
4918 int     _nc_read_entry(
4919                 const char *const name,
4920                 char    *const filename,
4921                 TERMTYPE *const tp)
4922                 { return(*(int *)0); }
4923
4924 /* ./tinfo/read_termcap.c */
4925
4926 #undef _nc_read_termcap_entry
4927 int     _nc_read_termcap_entry(
4928                 const char *const tn,
4929                 TERMTYPE *const tp)
4930                 { return(*(int *)0); }
4931
4932 /* ./tinfo/strings.c */
4933
4934 #undef _nc_str_init
4935 string_desc *_nc_str_init(
4936                 string_desc *dst,
4937                 char    *src,
4938                 size_t  len)
4939                 { return(*(string_desc **)0); }
4940
4941 #undef _nc_str_null
4942 string_desc *_nc_str_null(
4943                 string_desc *dst,
4944                 size_t  len)
4945                 { return(*(string_desc **)0); }
4946
4947 #undef _nc_str_copy
4948 string_desc *_nc_str_copy(
4949                 string_desc *dst,
4950                 string_desc *src)
4951                 { return(*(string_desc **)0); }
4952
4953 #undef _nc_safe_strcat
4954 NCURSES_BOOL _nc_safe_strcat(
4955                 string_desc *dst,
4956                 const char *src)
4957                 { return(*(NCURSES_BOOL *)0); }
4958
4959 #undef _nc_safe_strcpy
4960 NCURSES_BOOL _nc_safe_strcpy(
4961                 string_desc *dst,
4962                 const char *src)
4963                 { return(*(NCURSES_BOOL *)0); }
4964
4965 /* ./trace/trace_buf.c */
4966
4967 #undef _nc_trace_buf
4968 char    *_nc_trace_buf(
4969                 int     bufnum,
4970                 size_t  want)
4971                 { return(*(char **)0); }
4972
4973 #undef _nc_trace_bufcat
4974 char    *_nc_trace_bufcat(
4975                 int     bufnum,
4976                 const char *value)
4977                 { return(*(char **)0); }
4978
4979 /* ./trace/trace_tries.c */
4980
4981 #undef _nc_trace_tries
4982 void    _nc_trace_tries(
4983                 TRIES   *tree)
4984                 { /* void */ }
4985
4986 /* ./base/tries.c */
4987
4988 #undef _nc_expand_try
4989 char    *_nc_expand_try(
4990                 TRIES   *tree,
4991                 unsigned code,
4992                 int     *count,
4993                 size_t  len)
4994                 { return(*(char **)0); }
4995
4996 #undef _nc_remove_key
4997 int     _nc_remove_key(
4998                 TRIES   **tree,
4999                 unsigned code)
5000                 { return(*(int *)0); }
5001
5002 #undef _nc_remove_string
5003 int     _nc_remove_string(
5004                 TRIES   **tree,
5005                 const char *string)
5006                 { return(*(int *)0); }
5007
5008 /* ./tinfo/trim_sgr0.c */
5009
5010 #undef _nc_trim_sgr0
5011 char    *_nc_trim_sgr0(
5012                 TERMTYPE *tp)
5013                 { return(*(char **)0); }
5014
5015 /* ./unctrl.c */
5016
5017 #undef unctrl_sp
5018 const char *unctrl_sp(
5019                 SCREEN  *sp,
5020                 chtype  ch)
5021                 { return(*(const char **)0); }
5022
5023 #undef unctrl
5024 const char *unctrl(
5025                 chtype  ch)
5026                 { return(*(const char **)0); }
5027
5028 /* ./trace/visbuf.c */
5029
5030 #undef _nc_visbuf2
5031 const char *_nc_visbuf2(
5032                 int     bufnum,
5033                 const char *buf)
5034                 { return(*(const char **)0); }
5035
5036 #undef _nc_visbuf
5037 const char *_nc_visbuf(
5038                 const char *buf)
5039                 { return(*(const char **)0); }
5040
5041 #undef _nc_visbufn
5042 const char *_nc_visbufn(
5043                 const char *buf,
5044                 int     len)
5045                 { return(*(const char **)0); }
5046
5047 #undef _nc_viswbuf2
5048 const char *_nc_viswbuf2(
5049                 int     bufnum,
5050                 const wchar_t *buf)
5051                 { return(*(const char **)0); }
5052
5053 #undef _nc_viswbuf
5054 const char *_nc_viswbuf(
5055                 const wchar_t *buf)
5056                 { return(*(const char **)0); }
5057
5058 #undef _nc_viswbufn
5059 const char *_nc_viswbufn(
5060                 const wchar_t *buf,
5061                 int     len)
5062                 { return(*(const char **)0); }
5063
5064 #undef _nc_viswibuf
5065 const char *_nc_viswibuf(
5066                 const wint_t *buf)
5067                 { return(*(const char **)0); }
5068
5069 #undef _nc_viscbuf2
5070 const char *_nc_viscbuf2(
5071                 int     bufnum,
5072                 const cchar_t *buf,
5073                 int     len)
5074                 { return(*(const char **)0); }
5075
5076 #undef _nc_viscbuf
5077 const char *_nc_viscbuf(
5078                 const cchar_t *buf,
5079                 int     len)
5080                 { return(*(const char **)0); }
5081
5082 /* ./tinfo/alloc_entry.c */
5083
5084 #undef _nc_init_entry
5085 void    _nc_init_entry(
5086                 TERMTYPE *const tp)
5087                 { /* void */ }
5088
5089 #undef _nc_copy_entry
5090 ENTRY   *_nc_copy_entry(
5091                 ENTRY   *oldp)
5092                 { return(*(ENTRY **)0); }
5093
5094 #undef _nc_save_str
5095 char    *_nc_save_str(
5096                 const char *const string)
5097                 { return(*(char **)0); }
5098
5099 #undef _nc_wrap_entry
5100 void    _nc_wrap_entry(
5101                 ENTRY   *const ep,
5102                 NCURSES_BOOL copy_strings)
5103                 { /* void */ }
5104
5105 #undef _nc_merge_entry
5106 void    _nc_merge_entry(
5107                 TERMTYPE *const to,
5108                 TERMTYPE *const from)
5109                 { /* void */ }
5110
5111 /* ./tinfo/captoinfo.c */
5112
5113 #undef _nc_captoinfo
5114 char    *_nc_captoinfo(
5115                 const char *cap,
5116                 const char *s,
5117                 int const parameterized)
5118                 { return(*(char **)0); }
5119
5120 #undef _nc_infotocap
5121 char    *_nc_infotocap(
5122                 const char *cap,
5123                 const char *str,
5124                 int const parameterized)
5125                 { return(*(char **)0); }
5126
5127 /* ./tinfo/comp_expand.c */
5128
5129 #undef _nc_tic_expand
5130 char    *_nc_tic_expand(
5131                 const char *srcp,
5132                 NCURSES_BOOL tic_format,
5133                 int     numbers)
5134                 { return(*(char **)0); }
5135
5136 /* ./tinfo/comp_parse.c */
5137
5138 #undef _nc_check_termtype2
5139 void    (*_nc_check_termtype2)(
5140                 TERMTYPE *p1,
5141                 NCURSES_BOOL p2);
5142 #undef _nc_check_termtype
5143 void    (*_nc_check_termtype)(
5144                 TERMTYPE *p1);
5145
5146 #undef _nc_entry_match
5147 NCURSES_BOOL _nc_entry_match(
5148                 char    *n1,
5149                 char    *n2)
5150                 { return(*(NCURSES_BOOL *)0); }
5151
5152 #undef _nc_read_entry_source
5153 void    _nc_read_entry_source(
5154                 FILE    *fp,
5155                 char    *buf,
5156                 int     literal,
5157                 NCURSES_BOOL silent,
5158                 NCURSES_BOOL (*hook)(
5159                 ENTRY   *p1))
5160                 { /* void */ }
5161
5162 #undef _nc_resolve_uses2
5163 int     _nc_resolve_uses2(
5164                 NCURSES_BOOL fullresolve,
5165                 NCURSES_BOOL literal)
5166                 { return(*(int *)0); }
5167
5168 #undef _nc_resolve_uses
5169 int     _nc_resolve_uses(
5170                 NCURSES_BOOL fullresolve)
5171                 { return(*(int *)0); }
5172
5173 /* ./tinfo/comp_scan.c */
5174
5175 #undef _nc_syntax
5176 int     _nc_syntax;
5177 #undef _nc_strict_bsd
5178 int     _nc_strict_bsd;
5179 #undef _nc_curr_file_pos
5180 long    _nc_curr_file_pos;
5181 #undef _nc_comment_start
5182 long    _nc_comment_start;
5183 #undef _nc_comment_end
5184 long    _nc_comment_end;
5185 #undef _nc_start_line
5186 long    _nc_start_line;
5187 #undef _nc_curr_token
5188 struct token _nc_curr_token;
5189 #undef _nc_disable_period
5190 NCURSES_BOOL _nc_disable_period;
5191
5192 #undef _nc_reset_input
5193 void    _nc_reset_input(
5194                 FILE    *fp,
5195                 char    *buf)
5196                 { /* void */ }
5197
5198 #undef _nc_get_token
5199 int     _nc_get_token(
5200                 NCURSES_BOOL silent)
5201                 { return(*(int *)0); }
5202
5203 #undef _nc_trans_string
5204 int     _nc_trans_string(
5205                 char    *ptr,
5206                 char    *last)
5207                 { return(*(int *)0); }
5208
5209 #undef _nc_push_token
5210 void    _nc_push_token(
5211                 int     tokclass)
5212                 { /* void */ }
5213
5214 #undef _nc_panic_mode
5215 void    _nc_panic_mode(
5216                 char    ch)
5217                 { /* void */ }
5218
5219 /* ./tinfo/parse_entry.c */
5220
5221 #undef _nc_parse_entry
5222 int     _nc_parse_entry(
5223                 struct entry *entryp,
5224                 int     literal,
5225                 NCURSES_BOOL silent)
5226                 { return(*(int *)0); }
5227
5228 #undef _nc_capcmp
5229 int     _nc_capcmp(
5230                 const char *s,
5231                 const char *t)
5232                 { return(*(int *)0); }
5233
5234 /* ./tinfo/write_entry.c */
5235
5236 #undef _nc_set_writedir
5237 void    _nc_set_writedir(
5238                 const char *dir)
5239                 { /* void */ }
5240
5241 #undef _nc_write_entry
5242 void    _nc_write_entry(
5243                 TERMTYPE *const tp)
5244                 { /* void */ }
5245
5246 #undef _nc_write_object
5247 int     _nc_write_object(
5248                 TERMTYPE *tp,
5249                 char    *buffer,
5250                 unsigned *offset,
5251                 unsigned limit)
5252                 { return(*(int *)0); }
5253
5254 #undef _nc_tic_written
5255 int     _nc_tic_written(void)
5256                 { return(*(int *)0); }
5257
5258 /* ./base/define_key.c */
5259
5260 #undef define_key_sp
5261 int     define_key_sp(
5262                 SCREEN  *sp,
5263                 const char *str,
5264                 int     keycode)
5265                 { return(*(int *)0); }
5266
5267 #undef define_key
5268 int     define_key(
5269                 const char *str,
5270                 int     keycode)
5271                 { return(*(int *)0); }
5272
5273 /* ./tinfo/hashed_db.c */
5274
5275 #undef _nc_hashed_db
5276 void    _nc_hashed_db(void)
5277                 { /* void */ }
5278
5279 /* ./base/key_defined.c */
5280
5281 #undef key_defined_sp
5282 int     key_defined_sp(
5283                 SCREEN  *sp,
5284                 const char *str)
5285                 { return(*(int *)0); }
5286
5287 #undef key_defined
5288 int     key_defined(
5289                 const char *str)
5290                 { return(*(int *)0); }
5291
5292 /* ./base/keybound.c */
5293
5294 #undef keybound_sp
5295 char    *keybound_sp(
5296                 SCREEN  *sp,
5297                 int     code,
5298                 int     count)
5299                 { return(*(char **)0); }
5300
5301 #undef keybound
5302 char    *keybound(
5303                 int     code,
5304                 int     count)
5305                 { return(*(char **)0); }
5306
5307 /* ./base/keyok.c */
5308
5309 #undef keyok_sp
5310 int     keyok_sp(
5311                 SCREEN  *sp,
5312                 int     c,
5313                 NCURSES_BOOL flag)
5314                 { return(*(int *)0); }
5315
5316 #undef keyok
5317 int     keyok(
5318                 int     c,
5319                 NCURSES_BOOL flag)
5320                 { return(*(int *)0); }
5321
5322 /* ./base/version.c */
5323
5324 #undef curses_version
5325 const char *curses_version(void)
5326                 { return(*(const char **)0); }