ncurses/llib-lncurses

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