ncurses/llib-lncursest

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