ncurses/llib-lncurses

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