ncurses/llib-lncursesw

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