ncurses/llib-lncurses

   1 /****************************************************************************
   2  * Copyright (c) 1998-2013,2015 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                 const 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 wgetdelay
1241 int     (wgetdelay)(
1242                 const WINDOW *z)
1243                 { return(*(int *)0); }
1244
1245 #undef wgetscrreg
1246 int     (wgetscrreg)(
1247                 const WINDOW *a1,
1248                 int     *a2,
1249                 int     *z)
1250                 { return(*(int *)0); }
1251
1252 #undef mouse_trafo
1253 NCURSES_BOOL (mouse_trafo)(
1254                 int     *a1,
1255                 int     *a2,
1256                 NCURSES_BOOL z)
1257                 { return(*(NCURSES_BOOL *)0); }
1258
1259 /* ./base/lib_getch.c */
1260
1261 #undef ESCDELAY
1262 int     ESCDELAY;
1263
1264 #undef set_escdelay_sp
1265 int     set_escdelay_sp(
1266                 SCREEN  *sp,
1267                 int     value)
1268                 { return(*(int *)0); }
1269
1270 #undef set_escdelay
1271 int     set_escdelay(
1272                 int     value)
1273                 { return(*(int *)0); }
1274
1275 #undef get_escdelay_sp
1276 int     get_escdelay_sp(
1277                 SCREEN  *sp)
1278                 { return(*(int *)0); }
1279
1280 #undef get_escdelay
1281 int     get_escdelay(void)
1282                 { return(*(int *)0); }
1283
1284 #undef _nc_wgetch
1285 int     _nc_wgetch(
1286                 WINDOW  *win,
1287                 int     *result,
1288                 int     use_meta)
1289                 { return(*(int *)0); }
1290
1291 #undef wgetch
1292 int     wgetch(
1293                 WINDOW  *win)
1294                 { return(*(int *)0); }
1295
1296 /* ./base/lib_getstr.c */
1297
1298 #undef wgetnstr
1299 int     wgetnstr(
1300                 WINDOW  *win,
1301                 char    *str,
1302                 int     maxlen)
1303                 { return(*(int *)0); }
1304
1305 /* ./base/lib_hline.c */
1306
1307 #undef whline
1308 int     whline(
1309                 WINDOW  *win,
1310                 chtype  ch,
1311                 int     n)
1312                 { return(*(int *)0); }
1313
1314 /* ./base/lib_immedok.c */
1315
1316 #undef immedok
1317 void    immedok(
1318                 WINDOW  *win,
1319                 NCURSES_BOOL flag)
1320                 { /* void */ }
1321
1322 /* ./base/lib_inchstr.c */
1323
1324 #undef winchnstr
1325 int     winchnstr(
1326                 WINDOW  *win,
1327                 chtype  *str,
1328                 int     n)
1329                 { return(*(int *)0); }
1330
1331 /* ./base/lib_initscr.c */
1332
1333 #undef initscr
1334 WINDOW  *initscr(void)
1335                 { return(*(WINDOW **)0); }
1336
1337 /* ./base/lib_insch.c */
1338
1339 #undef _nc_insert_ch
1340 int     _nc_insert_ch(
1341                 SCREEN  *sp,
1342                 WINDOW  *win,
1343                 chtype  ch)
1344                 { return(*(int *)0); }
1345
1346 #undef winsch
1347 int     winsch(
1348                 WINDOW  *win,
1349                 chtype  c)
1350                 { return(*(int *)0); }
1351
1352 /* ./base/lib_insdel.c */
1353
1354 #undef winsdelln
1355 int     winsdelln(
1356                 WINDOW  *win,
1357                 int     n)
1358                 { return(*(int *)0); }
1359
1360 /* ./base/lib_insnstr.c */
1361
1362 #undef winsnstr
1363 int     winsnstr(
1364                 WINDOW  *win,
1365                 const char *s,
1366                 int     n)
1367                 { return(*(int *)0); }
1368
1369 /* ./base/lib_instr.c */
1370
1371 #undef winnstr
1372 int     winnstr(
1373                 WINDOW  *win,
1374                 char    *str,
1375                 int     n)
1376                 { return(*(int *)0); }
1377
1378 /* ./base/lib_isendwin.c */
1379
1380 #undef isendwin_sp
1381 NCURSES_BOOL isendwin_sp(
1382                 SCREEN  *sp)
1383                 { return(*(NCURSES_BOOL *)0); }
1384
1385 #undef isendwin
1386 NCURSES_BOOL isendwin(void)
1387                 { return(*(NCURSES_BOOL *)0); }
1388
1389 /* ./base/lib_leaveok.c */
1390
1391 #undef leaveok
1392 int     leaveok(
1393                 WINDOW  *win,
1394                 NCURSES_BOOL flag)
1395                 { return(*(int *)0); }
1396
1397 /* ./base/lib_mouse.c */
1398
1399 #undef getmouse_sp
1400 int     getmouse_sp(
1401                 SCREEN  *sp,
1402                 MEVENT  *aevent)
1403                 { return(*(int *)0); }
1404
1405 #undef getmouse
1406 int     getmouse(
1407                 MEVENT  *aevent)
1408                 { return(*(int *)0); }
1409
1410 #undef ungetmouse_sp
1411 int     ungetmouse_sp(
1412                 SCREEN  *sp,
1413                 MEVENT  *aevent)
1414                 { return(*(int *)0); }
1415
1416 #undef ungetmouse
1417 int     ungetmouse(
1418                 MEVENT  *aevent)
1419                 { return(*(int *)0); }
1420
1421 #undef mousemask_sp
1422 mmask_t mousemask_sp(
1423                 SCREEN  *sp,
1424                 mmask_t newmask,
1425                 mmask_t *oldmask)
1426                 { return(*(mmask_t *)0); }
1427
1428 #undef mousemask
1429 mmask_t mousemask(
1430                 mmask_t newmask,
1431                 mmask_t *oldmask)
1432                 { return(*(mmask_t *)0); }
1433
1434 #undef wenclose
1435 NCURSES_BOOL wenclose(
1436                 const WINDOW *win,
1437                 int     y,
1438                 int     x)
1439                 { return(*(NCURSES_BOOL *)0); }
1440
1441 #undef mouseinterval_sp
1442 int     mouseinterval_sp(
1443                 SCREEN  *sp,
1444                 int     maxclick)
1445                 { return(*(int *)0); }
1446
1447 #undef mouseinterval
1448 int     mouseinterval(
1449                 int     maxclick)
1450                 { return(*(int *)0); }
1451
1452 #undef _nc_has_mouse
1453 NCURSES_BOOL _nc_has_mouse(
1454                 SCREEN  *sp)
1455                 { return(*(NCURSES_BOOL *)0); }
1456
1457 #undef has_mouse_sp
1458 NCURSES_BOOL has_mouse_sp(
1459                 SCREEN  *sp)
1460                 { return(*(NCURSES_BOOL *)0); }
1461
1462 #undef has_mouse
1463 NCURSES_BOOL has_mouse(void)
1464                 { return(*(NCURSES_BOOL *)0); }
1465
1466 #undef wmouse_trafo
1467 NCURSES_BOOL wmouse_trafo(
1468                 const WINDOW *win,
1469                 int     *pY,
1470                 int     *pX,
1471                 NCURSES_BOOL to_screen)
1472                 { return(*(NCURSES_BOOL *)0); }
1473
1474 /* ./base/lib_move.c */
1475
1476 #undef wmove
1477 int     wmove(
1478                 WINDOW  *win,
1479                 int     y,
1480                 int     x)
1481                 { return(*(int *)0); }
1482
1483 /* ./tty/lib_mvcur.c */
1484
1485 #undef _nc_msec_cost_sp
1486 int     _nc_msec_cost_sp(
1487                 SCREEN  *sp,
1488                 const char *const cap,
1489                 int     affcnt)
1490                 { return(*(int *)0); }
1491
1492 #undef _nc_msec_cost
1493 int     _nc_msec_cost(
1494                 const char *const cap,
1495                 int     affcnt)
1496                 { return(*(int *)0); }
1497
1498 #undef _nc_mvcur_resume_sp
1499 void    _nc_mvcur_resume_sp(
1500                 SCREEN  *sp)
1501                 { /* void */ }
1502
1503 #undef _nc_mvcur_resume
1504 void    _nc_mvcur_resume(void)
1505                 { /* void */ }
1506
1507 #undef _nc_mvcur_init_sp
1508 void    _nc_mvcur_init_sp(
1509                 SCREEN  *sp)
1510                 { /* void */ }
1511
1512 #undef _nc_mvcur_init
1513 void    _nc_mvcur_init(void)
1514                 { /* void */ }
1515
1516 #undef _nc_mvcur_wrap_sp
1517 void    _nc_mvcur_wrap_sp(
1518                 SCREEN  *sp)
1519                 { /* void */ }
1520
1521 #undef _nc_mvcur_wrap
1522 void    _nc_mvcur_wrap(void)
1523                 { /* void */ }
1524
1525 #undef _nc_mvcur_sp
1526 int     _nc_mvcur_sp(
1527                 SCREEN  *sp,
1528                 int     yold,
1529                 int     xold,
1530                 int     ynew,
1531                 int     xnew)
1532                 { return(*(int *)0); }
1533
1534 #undef _nc_mvcur
1535 int     _nc_mvcur(
1536                 int     yold,
1537                 int     xold,
1538                 int     ynew,
1539                 int     xnew)
1540                 { return(*(int *)0); }
1541
1542 #undef mvcur_sp
1543 int     mvcur_sp(
1544                 SCREEN  *sp,
1545                 int     yold,
1546                 int     xold,
1547                 int     ynew,
1548                 int     xnew)
1549                 { return(*(int *)0); }
1550
1551 #undef mvcur
1552 int     mvcur(
1553                 int     yold,
1554                 int     xold,
1555                 int     ynew,
1556                 int     xnew)
1557                 { return(*(int *)0); }
1558
1559 #undef _nc_optimize_enable
1560 int     _nc_optimize_enable;
1561
1562 /* ./base/lib_mvwin.c */
1563
1564 #undef mvwin
1565 int     mvwin(
1566                 WINDOW  *win,
1567                 int     by,
1568                 int     bx)
1569                 { return(*(int *)0); }
1570
1571 /* ./base/lib_newterm.c */
1572
1573 #undef filter_sp
1574 void    filter_sp(
1575                 SCREEN  *sp)
1576                 { /* void */ }
1577
1578 #undef filter
1579 void    filter(void)
1580                 { /* void */ }
1581
1582 #undef nofilter_sp
1583 void    nofilter_sp(
1584                 SCREEN  *sp)
1585                 { /* void */ }
1586
1587 #undef nofilter
1588 void    nofilter(void)
1589                 { /* void */ }
1590
1591 #undef newterm_sp
1592 SCREEN  *newterm_sp(
1593                 SCREEN  *sp,
1594                 const char *name,
1595                 FILE    *ofp,
1596                 FILE    *ifp)
1597                 { return(*(SCREEN **)0); }
1598
1599 #undef newterm
1600 SCREEN  *newterm(
1601                 const char *name,
1602                 FILE    *ofp,
1603                 FILE    *ifp)
1604                 { return(*(SCREEN **)0); }
1605
1606 /* ./base/lib_newwin.c */
1607
1608 #undef _nc_freewin
1609 int     _nc_freewin(
1610                 WINDOW  *win)
1611                 { return(*(int *)0); }
1612
1613 #undef newwin_sp
1614 WINDOW  *newwin_sp(
1615                 SCREEN  *sp,
1616                 int     num_lines,
1617                 int     num_columns,
1618                 int     begy,
1619                 int     begx)
1620                 { return(*(WINDOW **)0); }
1621
1622 #undef newwin
1623 WINDOW  *newwin(
1624                 int     num_lines,
1625                 int     num_columns,
1626                 int     begy,
1627                 int     begx)
1628                 { return(*(WINDOW **)0); }
1629
1630 #undef derwin
1631 WINDOW  *derwin(
1632                 WINDOW  *orig,
1633                 int     num_lines,
1634                 int     num_columns,
1635                 int     begy,
1636                 int     begx)
1637                 { return(*(WINDOW **)0); }
1638
1639 #undef subwin
1640 WINDOW  *subwin(
1641                 WINDOW  *w,
1642                 int     l,
1643                 int     c,
1644                 int     y,
1645                 int     x)
1646                 { return(*(WINDOW **)0); }
1647
1648 #undef _nc_makenew_sp
1649 WINDOW  *_nc_makenew_sp(
1650                 SCREEN  *sp,
1651                 int     num_lines,
1652                 int     num_columns,
1653                 int     begy,
1654                 int     begx,
1655                 int     flags)
1656                 { return(*(WINDOW **)0); }
1657
1658 #undef _nc_curscr_of
1659 WINDOW  *_nc_curscr_of(
1660                 SCREEN  *sp)
1661                 { return(*(WINDOW **)0); }
1662
1663 #undef _nc_newscr_of
1664 WINDOW  *_nc_newscr_of(
1665                 SCREEN  *sp)
1666                 { return(*(WINDOW **)0); }
1667
1668 #undef _nc_stdscr_of
1669 WINDOW  *_nc_stdscr_of(
1670                 SCREEN  *sp)
1671                 { return(*(WINDOW **)0); }
1672
1673 /* ./base/lib_nl.c */
1674
1675 #undef nl_sp
1676 int     nl_sp(
1677                 SCREEN  *sp)
1678                 { return(*(int *)0); }
1679
1680 #undef nl
1681 int     nl(void)
1682                 { return(*(int *)0); }
1683
1684 #undef nonl_sp
1685 int     nonl_sp(
1686                 SCREEN  *sp)
1687                 { return(*(int *)0); }
1688
1689 #undef nonl
1690 int     nonl(void)
1691                 { return(*(int *)0); }
1692
1693 /* ./base/lib_overlay.c */
1694
1695 #undef overlay
1696 int     overlay(
1697                 const WINDOW *win1,
1698                 WINDOW  *win2)
1699                 { return(*(int *)0); }
1700
1701 #undef overwrite
1702 int     overwrite(
1703                 const WINDOW *win1,
1704                 WINDOW  *win2)
1705                 { return(*(int *)0); }
1706
1707 #undef copywin
1708 int     copywin(
1709                 const WINDOW *src,
1710                 WINDOW  *dst,
1711                 int     sminrow,
1712                 int     smincol,
1713                 int     dminrow,
1714                 int     dmincol,
1715                 int     dmaxrow,
1716                 int     dmaxcol,
1717                 int     over)
1718                 { return(*(int *)0); }
1719
1720 /* ./base/lib_pad.c */
1721
1722 #undef newpad_sp
1723 WINDOW  *newpad_sp(
1724                 SCREEN  *sp,
1725                 int     l,
1726                 int     c)
1727                 { return(*(WINDOW **)0); }
1728
1729 #undef newpad
1730 WINDOW  *newpad(
1731                 int     l,
1732                 int     c)
1733                 { return(*(WINDOW **)0); }
1734
1735 #undef subpad
1736 WINDOW  *subpad(
1737                 WINDOW  *orig,
1738                 int     l,
1739                 int     c,
1740                 int     begy,
1741                 int     begx)
1742                 { return(*(WINDOW **)0); }
1743
1744 #undef prefresh
1745 int     prefresh(
1746                 WINDOW  *win,
1747                 int     pminrow,
1748                 int     pmincol,
1749                 int     sminrow,
1750                 int     smincol,
1751                 int     smaxrow,
1752                 int     smaxcol)
1753                 { return(*(int *)0); }
1754
1755 #undef pnoutrefresh
1756 int     pnoutrefresh(
1757                 WINDOW  *win,
1758                 int     pminrow,
1759                 int     pmincol,
1760                 int     sminrow,
1761                 int     smincol,
1762                 int     smaxrow,
1763                 int     smaxcol)
1764                 { return(*(int *)0); }
1765
1766 #undef pechochar
1767 int     pechochar(
1768                 WINDOW  *pad,
1769                 const chtype ch)
1770                 { return(*(int *)0); }
1771
1772 /* ./base/lib_printw.c */
1773
1774 #undef printw
1775 int     printw(
1776                 const char *fmt,
1777                 ...)
1778                 { return(*(int *)0); }
1779
1780 #undef wprintw
1781 int     wprintw(
1782                 WINDOW  *win,
1783                 const char *fmt,
1784                 ...)
1785                 { return(*(int *)0); }
1786
1787 #undef mvprintw
1788 int     mvprintw(
1789                 int     y,
1790                 int     x,
1791                 const char *fmt,
1792                 ...)
1793                 { return(*(int *)0); }
1794
1795 #undef mvwprintw
1796 int     mvwprintw(
1797                 WINDOW  *win,
1798                 int     y,
1799                 int     x,
1800                 const char *fmt,
1801                 ...)
1802                 { return(*(int *)0); }
1803
1804 #undef vwprintw
1805 int     vwprintw(
1806                 WINDOW  *win,
1807                 const char *fmt,
1808                 va_list argp)
1809                 { return(*(int *)0); }
1810
1811 /* ./base/lib_redrawln.c */
1812
1813 #undef wredrawln
1814 int     wredrawln(
1815                 WINDOW  *win,
1816                 int     beg,
1817                 int     num)
1818                 { return(*(int *)0); }
1819
1820 /* ./base/lib_refresh.c */
1821
1822 #undef wrefresh
1823 int     wrefresh(
1824                 WINDOW  *win)
1825                 { return(*(int *)0); }
1826
1827 #undef wnoutrefresh
1828 int     wnoutrefresh(
1829                 WINDOW  *win)
1830                 { return(*(int *)0); }
1831
1832 /* ./base/lib_restart.c */
1833
1834 #undef restartterm_sp
1835 int     restartterm_sp(
1836                 SCREEN  *sp,
1837                 const char *termp,
1838                 int     filenum,
1839                 int     *errret)
1840                 { return(*(int *)0); }
1841
1842 #undef restartterm
1843 int     restartterm(
1844                 const char *termp,
1845                 int     filenum,
1846                 int     *errret)
1847                 { return(*(int *)0); }
1848
1849 /* ./base/lib_scanw.c */
1850
1851 #undef vwscanw
1852 int     vwscanw(
1853                 WINDOW  *win,
1854                 const char *fmt,
1855                 va_list argp)
1856                 { return(*(int *)0); }
1857
1858 #undef scanw
1859 int     scanw(
1860                 const char *fmt,
1861                 ...)
1862                 { return(*(int *)0); }
1863
1864 #undef wscanw
1865 int     wscanw(
1866                 WINDOW  *win,
1867                 const char *fmt,
1868                 ...)
1869                 { return(*(int *)0); }
1870
1871 #undef mvscanw
1872 int     mvscanw(
1873                 int     y,
1874                 int     x,
1875                 const char *fmt,
1876                 ...)
1877                 { return(*(int *)0); }
1878
1879 #undef mvwscanw
1880 int     mvwscanw(
1881                 WINDOW  *win,
1882                 int     y,
1883                 int     x,
1884                 const char *fmt,
1885                 ...)
1886                 { return(*(int *)0); }
1887
1888 /* ./base/lib_screen.c */
1889
1890 #undef getwin_sp
1891 WINDOW  *getwin_sp(
1892                 SCREEN  *sp,
1893                 FILE    *filep)
1894                 { return(*(WINDOW **)0); }
1895
1896 #undef getwin
1897 WINDOW  *getwin(
1898                 FILE    *filep)
1899                 { return(*(WINDOW **)0); }
1900
1901 #undef putwin
1902 int     putwin(
1903                 WINDOW  *win,
1904                 FILE    *filep)
1905                 { return(*(int *)0); }
1906
1907 #undef scr_restore_sp
1908 int     scr_restore_sp(
1909                 SCREEN  *sp,
1910                 const char *file)
1911                 { return(*(int *)0); }
1912
1913 #undef scr_restore
1914 int     scr_restore(
1915                 const char *file)
1916                 { return(*(int *)0); }
1917
1918 #undef scr_dump
1919 int     scr_dump(
1920                 const char *file)
1921                 { return(*(int *)0); }
1922
1923 #undef scr_init_sp
1924 int     scr_init_sp(
1925                 SCREEN  *sp,
1926                 const char *file)
1927                 { return(*(int *)0); }
1928
1929 #undef scr_init
1930 int     scr_init(
1931                 const char *file)
1932                 { return(*(int *)0); }
1933
1934 #undef scr_set_sp
1935 int     scr_set_sp(
1936                 SCREEN  *sp,
1937                 const char *file)
1938                 { return(*(int *)0); }
1939
1940 #undef scr_set
1941 int     scr_set(
1942                 const char *file)
1943                 { return(*(int *)0); }
1944
1945 /* ./base/lib_scroll.c */
1946
1947 #undef _nc_scroll_window
1948 void    _nc_scroll_window(
1949                 WINDOW  *win,
1950                 int const n,
1951                 int const top,
1952                 int const bottom,
1953                 chtype  blank)
1954                 { /* void */ }
1955
1956 #undef wscrl
1957 int     wscrl(
1958                 WINDOW  *win,
1959                 int     n)
1960                 { return(*(int *)0); }
1961
1962 /* ./base/lib_scrollok.c */
1963
1964 #undef scrollok
1965 int     scrollok(
1966                 WINDOW  *win,
1967                 NCURSES_BOOL flag)
1968                 { return(*(int *)0); }
1969
1970 /* ./base/lib_scrreg.c */
1971
1972 #undef wsetscrreg
1973 int     wsetscrreg(
1974                 WINDOW  *win,
1975                 int     top,
1976                 int     bottom)
1977                 { return(*(int *)0); }
1978
1979 /* ./base/lib_set_term.c */
1980
1981 #undef set_term
1982 SCREEN  *set_term(
1983                 SCREEN  *screenp)
1984                 { return(*(SCREEN **)0); }
1985
1986 #undef delscreen
1987 void    delscreen(
1988                 SCREEN  *sp)
1989                 { /* void */ }
1990
1991 #undef _nc_setupscreen_sp
1992 int     _nc_setupscreen_sp(
1993                 SCREEN  **spp,
1994                 int     slines,
1995                 int     scolumns,
1996                 FILE    *output,
1997                 int     filtered,
1998                 int     slk_format)
1999                 { return(*(int *)0); }
2000
2001 #undef _nc_setupscreen
2002 int     _nc_setupscreen(
2003                 int     slines,
2004                 int     scolumns,
2005                 FILE    *output,
2006                 int     filtered,
2007                 int     slk_format)
2008                 { return(*(int *)0); }
2009
2010 #undef _nc_ripoffline_sp
2011 int     _nc_ripoffline_sp(
2012                 SCREEN  *sp,
2013                 int     line,
2014                 int     (*init)(
2015                 WINDOW  *p1,
2016                 int     p2))
2017                 { return(*(int *)0); }
2018
2019 #undef _nc_ripoffline
2020 int     _nc_ripoffline(
2021                 int     line,
2022                 int     (*init)(
2023                 WINDOW  *p1,
2024                 int     p2))
2025                 { return(*(int *)0); }
2026
2027 #undef ripoffline_sp
2028 int     ripoffline_sp(
2029                 SCREEN  *sp,
2030                 int     line,
2031                 int     (*init)(
2032                 WINDOW  *p1,
2033                 int     p2))
2034                 { return(*(int *)0); }
2035
2036 #undef ripoffline
2037 int     ripoffline(
2038                 int     line,
2039                 int     (*init)(
2040                 WINDOW  *p1,
2041                 int     p2))
2042                 { return(*(int *)0); }
2043
2044 /* ./base/lib_slk.c */
2045
2046 #undef _nc_format_slks
2047 int     _nc_format_slks(
2048                 SCREEN  *sp,
2049                 int     cols)
2050                 { return(*(int *)0); }
2051
2052 #undef _nc_slk_initialize
2053 int     _nc_slk_initialize(
2054                 WINDOW  *stwin,
2055                 int     cols)
2056                 { return(*(int *)0); }
2057
2058 #undef slk_restore_sp
2059 int     slk_restore_sp(
2060                 SCREEN  *sp)
2061                 { return(*(int *)0); }
2062
2063 #undef slk_restore
2064 int     slk_restore(void)
2065                 { return(*(int *)0); }
2066
2067 /* ./base/lib_slkatr_set.c */
2068
2069 #undef slk_attr_set_sp
2070 int     slk_attr_set_sp(
2071                 SCREEN  *sp,
2072                 const attr_t attr,
2073                 short   color_pair_number,
2074                 void    *opts)
2075                 { return(*(int *)0); }
2076
2077 #undef slk_attr_set
2078 int     slk_attr_set(
2079                 const attr_t attr,
2080                 short   color_pair_number,
2081                 void    *opts)
2082                 { return(*(int *)0); }
2083
2084 /* ./base/lib_slkatrof.c */
2085
2086 #undef slk_attroff_sp
2087 int     slk_attroff_sp(
2088                 SCREEN  *sp,
2089                 const chtype attr)
2090                 { return(*(int *)0); }
2091
2092 #undef slk_attroff
2093 int     slk_attroff(
2094                 const chtype attr)
2095                 { return(*(int *)0); }
2096
2097 /* ./base/lib_slkatron.c */
2098
2099 #undef slk_attron_sp
2100 int     slk_attron_sp(
2101                 SCREEN  *sp,
2102                 const chtype attr)
2103                 { return(*(int *)0); }
2104
2105 #undef slk_attron
2106 int     slk_attron(
2107                 const chtype attr)
2108                 { return(*(int *)0); }
2109
2110 /* ./base/lib_slkatrset.c */
2111
2112 #undef slk_attrset_sp
2113 int     slk_attrset_sp(
2114                 SCREEN  *sp,
2115                 const chtype attr)
2116                 { return(*(int *)0); }
2117
2118 #undef slk_attrset
2119 int     slk_attrset(
2120                 const chtype attr)
2121                 { return(*(int *)0); }
2122
2123 /* ./base/lib_slkattr.c */
2124
2125 #undef slk_attr_sp
2126 attr_t  slk_attr_sp(
2127                 SCREEN  *sp)
2128                 { return(*(attr_t *)0); }
2129
2130 #undef slk_attr
2131 attr_t  slk_attr(void)
2132                 { return(*(attr_t *)0); }
2133
2134 /* ./base/lib_slkclear.c */
2135
2136 #undef slk_clear_sp
2137 int     slk_clear_sp(
2138                 SCREEN  *sp)
2139                 { return(*(int *)0); }
2140
2141 #undef slk_clear
2142 int     slk_clear(void)
2143                 { return(*(int *)0); }
2144
2145 /* ./base/lib_slkcolor.c */
2146
2147 #undef slk_color_sp
2148 int     slk_color_sp(
2149                 SCREEN  *sp,
2150                 short   color_pair_number)
2151                 { return(*(int *)0); }
2152
2153 #undef slk_color
2154 int     slk_color(
2155                 short   color_pair_number)
2156                 { return(*(int *)0); }
2157
2158 /* ./base/lib_slkinit.c */
2159
2160 #undef slk_init_sp
2161 int     slk_init_sp(
2162                 SCREEN  *sp,
2163                 int     format)
2164                 { return(*(int *)0); }
2165
2166 #undef slk_init
2167 int     slk_init(
2168                 int     format)
2169                 { return(*(int *)0); }
2170
2171 /* ./base/lib_slklab.c */
2172
2173 #undef slk_label_sp
2174 char    *slk_label_sp(
2175                 SCREEN  *sp,
2176                 int     n)
2177                 { return(*(char **)0); }
2178
2179 #undef slk_label
2180 char    *slk_label(
2181                 int     n)
2182                 { return(*(char **)0); }
2183
2184 /* ./base/lib_slkrefr.c */
2185
2186 #undef slk_noutrefresh_sp
2187 int     slk_noutrefresh_sp(
2188                 SCREEN  *sp)
2189                 { return(*(int *)0); }
2190
2191 #undef slk_noutrefresh
2192 int     slk_noutrefresh(void)
2193                 { return(*(int *)0); }
2194
2195 #undef slk_refresh_sp
2196 int     slk_refresh_sp(
2197                 SCREEN  *sp)
2198                 { return(*(int *)0); }
2199
2200 #undef slk_refresh
2201 int     slk_refresh(void)
2202                 { return(*(int *)0); }
2203
2204 /* ./base/lib_slkset.c */
2205
2206 #undef slk_set_sp
2207 int     slk_set_sp(
2208                 SCREEN  *sp,
2209                 int     i,
2210                 const char *astr,
2211                 int     format)
2212                 { return(*(int *)0); }
2213
2214 #undef slk_set
2215 int     slk_set(
2216                 int     i,
2217                 const char *astr,
2218                 int     format)
2219                 { return(*(int *)0); }
2220
2221 /* ./base/lib_slktouch.c */
2222
2223 #undef slk_touch_sp
2224 int     slk_touch_sp(
2225                 SCREEN  *sp)
2226                 { return(*(int *)0); }
2227
2228 #undef slk_touch
2229 int     slk_touch(void)
2230                 { return(*(int *)0); }
2231
2232 /* ./base/lib_touch.c */
2233
2234 #undef is_linetouched
2235 NCURSES_BOOL is_linetouched(
2236                 WINDOW  *win,
2237                 int     line)
2238                 { return(*(NCURSES_BOOL *)0); }
2239
2240 #undef is_wintouched
2241 NCURSES_BOOL is_wintouched(
2242                 WINDOW  *win)
2243                 { return(*(NCURSES_BOOL *)0); }
2244
2245 #undef wtouchln
2246 int     wtouchln(
2247                 WINDOW  *win,
2248                 int     y,
2249                 int     n,
2250                 int     changed)
2251                 { return(*(int *)0); }
2252
2253 /* ./trace/lib_tracedmp.c */
2254
2255 #undef _tracedump
2256 void    _tracedump(
2257                 const char *name,
2258                 WINDOW  *win)
2259                 { /* void */ }
2260
2261 /* ./trace/lib_tracemse.c */
2262
2263 #undef _nc_trace_mmask_t
2264 char    *_nc_trace_mmask_t(
2265                 SCREEN  *sp,
2266                 mmask_t code)
2267                 { return(*(char **)0); }
2268
2269 #undef _nc_tracemouse
2270 char    *_nc_tracemouse(
2271                 SCREEN  *sp,
2272                 MEVENT const *ep)
2273                 { return(*(char **)0); }
2274
2275 #undef _nc_retrace_mmask_t
2276 mmask_t _nc_retrace_mmask_t(
2277                 SCREEN  *sp,
2278                 mmask_t code)
2279                 { return(*(mmask_t *)0); }
2280
2281 #undef _tracemouse
2282 char    *_tracemouse(
2283                 MEVENT const *ep)
2284                 { return(*(char **)0); }
2285
2286 /* ./tty/lib_tstp.c */
2287
2288 #undef _nc_signal_handler
2289 void    _nc_signal_handler(
2290                 int     enable)
2291                 { /* void */ }
2292
2293 /* ./base/lib_ungetch.c */
2294
2295 #undef _nc_fifo_dump
2296 void    _nc_fifo_dump(
2297                 SCREEN  *sp)
2298                 { /* void */ }
2299
2300 #undef ungetch_sp
2301 int     ungetch_sp(
2302                 SCREEN  *sp,
2303                 int     ch)
2304                 { return(*(int *)0); }
2305
2306 #undef ungetch
2307 int     ungetch(
2308                 int     ch)
2309                 { return(*(int *)0); }
2310
2311 /* ./tty/lib_vidattr.c */
2312
2313 #undef vidputs_sp
2314 int     vidputs_sp(
2315                 SCREEN  *sp,
2316                 chtype  newmode,
2317                 NCURSES_OUTC_sp outc)
2318                 { return(*(int *)0); }
2319
2320 #undef vidputs
2321 int     vidputs(
2322                 chtype  newmode,
2323                 NCURSES_OUTC outc)
2324                 { return(*(int *)0); }
2325
2326 #undef vidattr_sp
2327 int     vidattr_sp(
2328                 SCREEN  *sp,
2329                 chtype  newmode)
2330                 { return(*(int *)0); }
2331
2332 #undef vidattr
2333 int     vidattr(
2334                 chtype  newmode)
2335                 { return(*(int *)0); }
2336
2337 #undef termattrs_sp
2338 chtype  termattrs_sp(
2339                 SCREEN  *sp)
2340                 { return(*(chtype *)0); }
2341
2342 #undef termattrs
2343 chtype  termattrs(void)
2344                 { return(*(chtype *)0); }
2345
2346 /* ./base/lib_vline.c */
2347
2348 #undef wvline
2349 int     wvline(
2350                 WINDOW  *win,
2351                 chtype  ch,
2352                 int     n)
2353                 { return(*(int *)0); }
2354
2355 /* ./base/lib_wattroff.c */
2356
2357 #undef wattr_off
2358 int     wattr_off(
2359                 WINDOW  *win,
2360                 attr_t  at,
2361                 void    *opts)
2362                 { return(*(int *)0); }
2363
2364 /* ./base/lib_wattron.c */
2365
2366 #undef wattr_on
2367 int     wattr_on(
2368                 WINDOW  *win,
2369                 attr_t  at,
2370                 void    *opts)
2371                 { return(*(int *)0); }
2372
2373 /* ./base/lib_winch.c */
2374
2375 #undef winch
2376 chtype  winch(
2377                 WINDOW  *win)
2378                 { return(*(chtype *)0); }
2379
2380 /* ./base/lib_window.c */
2381
2382 #undef _nc_synchook
2383 void    _nc_synchook(
2384                 WINDOW  *win)
2385                 { /* void */ }
2386
2387 #undef mvderwin
2388 int     mvderwin(
2389                 WINDOW  *win,
2390                 int     y,
2391                 int     x)
2392                 { return(*(int *)0); }
2393
2394 #undef syncok
2395 int     syncok(
2396                 WINDOW  *win,
2397                 NCURSES_BOOL bf)
2398                 { return(*(int *)0); }
2399
2400 #undef wsyncup
2401 void    wsyncup(
2402                 WINDOW  *win)
2403                 { /* void */ }
2404
2405 #undef wsyncdown
2406 void    wsyncdown(
2407                 WINDOW  *win)
2408                 { /* void */ }
2409
2410 #undef wcursyncup
2411 void    wcursyncup(
2412                 WINDOW  *win)
2413                 { /* void */ }
2414
2415 #undef dupwin
2416 WINDOW  *dupwin(
2417                 WINDOW  *win)
2418                 { return(*(WINDOW **)0); }
2419
2420 /* ./base/nc_panel.c */
2421
2422 #undef _nc_panelhook_sp
2423 struct panelhook *_nc_panelhook_sp(
2424                 SCREEN  *sp)
2425                 { return(*(struct panelhook **)0); }
2426
2427 #undef _nc_panelhook
2428 struct panelhook *_nc_panelhook(void)
2429                 { return(*(struct panelhook **)0); }
2430
2431 /* ./base/safe_sprintf.c */
2432
2433 #undef _nc_printf_string_sp
2434 char    *_nc_printf_string_sp(
2435                 SCREEN  *sp,
2436                 const char *fmt,
2437                 va_list ap)
2438                 { return(*(char **)0); }
2439
2440 #undef _nc_printf_string
2441 char    *_nc_printf_string(
2442                 const char *fmt,
2443                 va_list ap)
2444                 { return(*(char **)0); }
2445
2446 /* ./tty/tty_update.c */
2447
2448 #undef doupdate_sp
2449 int     doupdate_sp(
2450                 SCREEN  *sp)
2451                 { return(*(int *)0); }
2452
2453 #undef doupdate
2454 int     doupdate(void)
2455                 { return(*(int *)0); }
2456
2457 #undef _nc_scrolln_sp
2458 int     _nc_scrolln_sp(
2459                 SCREEN  *sp,
2460                 int     n,
2461                 int     top,
2462                 int     bot,
2463                 int     maxy)
2464                 { return(*(int *)0); }
2465
2466 #undef _nc_scrolln
2467 int     _nc_scrolln(
2468                 int     n,
2469                 int     top,
2470                 int     bot,
2471                 int     maxy)
2472                 { return(*(int *)0); }
2473
2474 #undef _nc_screen_resume_sp
2475 void    _nc_screen_resume_sp(
2476                 SCREEN  *sp)
2477                 { /* void */ }
2478
2479 #undef _nc_screen_resume
2480 void    _nc_screen_resume(void)
2481                 { /* void */ }
2482
2483 #undef _nc_screen_init_sp
2484 void    _nc_screen_init_sp(
2485                 SCREEN  *sp)
2486                 { /* void */ }
2487
2488 #undef _nc_screen_init
2489 void    _nc_screen_init(void)
2490                 { /* void */ }
2491
2492 #undef _nc_screen_wrap_sp
2493 void    _nc_screen_wrap_sp(
2494                 SCREEN  *sp)
2495                 { /* void */ }
2496
2497 #undef _nc_screen_wrap
2498 void    _nc_screen_wrap(void)
2499                 { /* void */ }
2500
2501 #undef _nc_do_xmc_glitch_sp
2502 void    _nc_do_xmc_glitch_sp(
2503                 SCREEN  *sp,
2504                 attr_t  previous)
2505                 { /* void */ }
2506
2507 #undef _nc_do_xmc_glitch
2508 void    _nc_do_xmc_glitch(
2509                 attr_t  previous)
2510                 { /* void */ }
2511
2512 /* ./trace/varargs.c */
2513
2514 typedef enum {
2515     atUnknown = 0, atInteger, atFloat, atPoint, atString
2516 } ARGTYPE;
2517
2518 #undef _nc_varargs
2519 char    *_nc_varargs(
2520                 const char *fmt,
2521                 va_list ap)
2522                 { return(*(char **)0); }
2523
2524 /* ./base/vsscanf.c */
2525
2526 #undef _nc_vsscanf
2527 void    _nc_vsscanf(void)
2528                 { /* void */ }
2529
2530 /* ./base/lib_freeall.c */
2531
2532 #undef _nc_freeall
2533 void    _nc_freeall(void)
2534                 { /* void */ }
2535
2536 #undef _nc_free_and_exit_sp
2537 void    _nc_free_and_exit_sp(
2538                 SCREEN  *sp,
2539                 int     code)
2540                 { /* void */ }
2541
2542 #undef _nc_free_and_exit
2543 void    _nc_free_and_exit(
2544                 int     code)
2545                 { /* void */ }
2546
2547 /* ./expanded.c */
2548
2549 #undef _nc_toggle_attr_on
2550 void    _nc_toggle_attr_on(
2551                 attr_t  *S,
2552                 attr_t  at)
2553                 { /* void */ }
2554
2555 #undef _nc_toggle_attr_off
2556 void    _nc_toggle_attr_off(
2557                 attr_t  *S,
2558                 attr_t  at)
2559                 { /* void */ }
2560
2561 #undef _nc_DelCharCost_sp
2562 int     _nc_DelCharCost_sp(
2563                 SCREEN  *sp,
2564                 int     count)
2565                 { return(*(int *)0); }
2566
2567 #undef _nc_InsCharCost_sp
2568 int     _nc_InsCharCost_sp(
2569                 SCREEN  *sp,
2570                 int     count)
2571                 { return(*(int *)0); }
2572
2573 #undef _nc_UpdateAttrs_sp
2574 void    _nc_UpdateAttrs_sp(
2575                 SCREEN  *sp,
2576                 chtype  c)
2577                 { /* void */ }
2578
2579 #undef _nc_DelCharCost
2580 int     _nc_DelCharCost(
2581                 int     count)
2582                 { return(*(int *)0); }
2583
2584 #undef _nc_InsCharCost
2585 int     _nc_InsCharCost(
2586                 int     count)
2587                 { return(*(int *)0); }
2588
2589 #undef _nc_UpdateAttrs
2590 void    _nc_UpdateAttrs(
2591                 chtype  c)
2592                 { /* void */ }
2593
2594 /* ./base/legacy_coding.c */
2595
2596 #undef use_legacy_coding_sp
2597 int     use_legacy_coding_sp(
2598                 SCREEN  *sp,
2599                 int     level)
2600                 { return(*(int *)0); }
2601
2602 #undef use_legacy_coding
2603 int     use_legacy_coding(
2604                 int     level)
2605                 { return(*(int *)0); }
2606
2607 /* ./base/lib_dft_fgbg.c */
2608
2609 #undef use_default_colors_sp
2610 int     use_default_colors_sp(
2611                 SCREEN  *sp)
2612                 { return(*(int *)0); }
2613
2614 #undef use_default_colors
2615 int     use_default_colors(void)
2616                 { return(*(int *)0); }
2617
2618 #undef assume_default_colors_sp
2619 int     assume_default_colors_sp(
2620                 SCREEN  *sp,
2621                 int     fg,
2622                 int     bg)
2623                 { return(*(int *)0); }
2624
2625 #undef assume_default_colors
2626 int     assume_default_colors(
2627                 int     fg,
2628                 int     bg)
2629                 { return(*(int *)0); }
2630
2631 /* ./tinfo/lib_print.c */
2632
2633 #undef mcprint_sp
2634 int     mcprint_sp(
2635                 SCREEN  *sp,
2636                 char    *data,
2637                 int     len)
2638                 { return(*(int *)0); }
2639
2640 #undef mcprint
2641 int     mcprint(
2642                 char    *data,
2643                 int     len)
2644                 { return(*(int *)0); }
2645
2646 /* ./base/resizeterm.c */
2647
2648 #undef is_term_resized_sp
2649 NCURSES_BOOL is_term_resized_sp(
2650                 SCREEN  *sp,
2651                 int     ToLines,
2652                 int     ToCols)
2653                 { return(*(NCURSES_BOOL *)0); }
2654
2655 #undef is_term_resized
2656 NCURSES_BOOL is_term_resized(
2657                 int     ToLines,
2658                 int     ToCols)
2659                 { return(*(NCURSES_BOOL *)0); }
2660
2661 #undef resize_term_sp
2662 int     resize_term_sp(
2663                 SCREEN  *sp,
2664                 int     ToLines,
2665                 int     ToCols)
2666                 { return(*(int *)0); }
2667
2668 #undef resize_term
2669 int     resize_term(
2670                 int     ToLines,
2671                 int     ToCols)
2672                 { return(*(int *)0); }
2673
2674 #undef resizeterm_sp
2675 int     resizeterm_sp(
2676                 SCREEN  *sp,
2677                 int     ToLines,
2678                 int     ToCols)
2679                 { return(*(int *)0); }
2680
2681 #undef resizeterm
2682 int     resizeterm(
2683                 int     ToLines,
2684                 int     ToCols)
2685                 { return(*(int *)0); }
2686
2687 /* ./trace/trace_xnames.c */
2688
2689 #undef _nc_trace_xnames
2690 void    _nc_trace_xnames(
2691                 TERMTYPE *tp)
2692                 { /* void */ }
2693
2694 /* ./tinfo/use_screen.c */
2695
2696 #undef use_screen
2697 int     use_screen(
2698                 SCREEN  *screen,
2699                 NCURSES_SCREEN_CB func,
2700                 void    *data)
2701                 { return(*(int *)0); }
2702
2703 /* ./base/use_window.c */
2704
2705 #undef use_window
2706 int     use_window(
2707                 WINDOW  *win,
2708                 NCURSES_WINDOW_CB func,
2709                 void    *data)
2710                 { return(*(int *)0); }
2711
2712 /* ./base/wresize.c */
2713
2714 #undef wresize
2715 int     wresize(
2716                 WINDOW  *win,
2717                 int     ToLines,
2718                 int     ToCols)
2719                 { return(*(int *)0); }
2720
2721 /* ./tinfo/access.c */
2722
2723 #undef _nc_rootname
2724 char    *_nc_rootname(
2725                 char    *path)
2726                 { return(*(char **)0); }
2727
2728 #undef _nc_is_abs_path
2729 NCURSES_BOOL _nc_is_abs_path(
2730                 const char *path)
2731                 { return(*(NCURSES_BOOL *)0); }
2732
2733 #undef _nc_pathlast
2734 unsigned _nc_pathlast(
2735                 const char *path)
2736                 { return(*(unsigned *)0); }
2737
2738 #undef _nc_basename
2739 char    *_nc_basename(
2740                 char    *path)
2741                 { return(*(char **)0); }
2742
2743 #undef _nc_access
2744 int     _nc_access(
2745                 const char *path,
2746                 int     mode)
2747                 { return(*(int *)0); }
2748
2749 #undef _nc_is_dir_path
2750 NCURSES_BOOL _nc_is_dir_path(
2751                 const char *path)
2752                 { return(*(NCURSES_BOOL *)0); }
2753
2754 #undef _nc_is_file_path
2755 NCURSES_BOOL _nc_is_file_path(
2756                 const char *path)
2757                 { return(*(NCURSES_BOOL *)0); }
2758
2759 #undef _nc_env_access
2760 int     _nc_env_access(void)
2761                 { return(*(int *)0); }
2762
2763 /* ./tinfo/add_tries.c */
2764
2765 #undef _nc_add_to_try
2766 int     _nc_add_to_try(
2767                 TRIES   **tree,
2768                 const char *str,
2769                 unsigned code)
2770                 { return(*(int *)0); }
2771
2772 /* ./tinfo/alloc_ttype.c */
2773
2774 #undef _nc_align_termtype
2775 void    _nc_align_termtype(
2776                 TERMTYPE *to,
2777                 TERMTYPE *from)
2778                 { /* void */ }
2779
2780 #undef _nc_copy_termtype
2781 void    _nc_copy_termtype(
2782                 TERMTYPE *dst,
2783                 const TERMTYPE *src)
2784                 { /* void */ }
2785
2786 /* ./codes.c */
2787
2788 #undef boolcodes
2789 const char *const boolcodes[] = {0};
2790 #undef numcodes
2791 const char *const numcodes[] = {0};
2792 #undef strcodes
2793 const char *const strcodes[] = {0};
2794
2795 /* ./comp_captab.c */
2796
2797 #undef _nc_get_table
2798 const struct name_table_entry *_nc_get_table(
2799                 NCURSES_BOOL termcap)
2800                 { return(*(const struct name_table_entry **)0); }
2801
2802 #undef _nc_get_hash_table
2803 const HashValue *_nc_get_hash_table(
2804                 NCURSES_BOOL termcap)
2805                 { return(*(const HashValue **)0); }
2806
2807 #undef _nc_get_alias_table
2808 const struct alias *_nc_get_alias_table(
2809                 NCURSES_BOOL termcap)
2810                 { return(*(const struct alias **)0); }
2811
2812 #undef _nc_get_hash_info
2813 const HashData *_nc_get_hash_info(
2814                 NCURSES_BOOL termcap)
2815                 { return(*(const HashData **)0); }
2816
2817 /* ./tinfo/comp_error.c */
2818
2819 #undef _nc_suppress_warnings
2820 NCURSES_BOOL _nc_suppress_warnings;
2821 #undef _nc_curr_line
2822 int     _nc_curr_line;
2823 #undef _nc_curr_col
2824 int     _nc_curr_col;
2825
2826 #undef _nc_get_source
2827 const char *_nc_get_source(void)
2828                 { return(*(const char **)0); }
2829
2830 #undef _nc_set_source
2831 void    _nc_set_source(
2832                 const char *const name)
2833                 { /* void */ }
2834
2835 #undef _nc_set_type
2836 void    _nc_set_type(
2837                 const char *const name)
2838                 { /* void */ }
2839
2840 #undef _nc_get_type
2841 void    _nc_get_type(
2842                 char    *name)
2843                 { /* void */ }
2844
2845 #undef _nc_warning
2846 void    _nc_warning(
2847                 const char *const fmt,
2848                 ...)
2849                 { /* void */ }
2850
2851 #undef _nc_err_abort
2852 void    _nc_err_abort(
2853                 const char *const fmt,
2854                 ...)
2855                 { /* void */ }
2856
2857 #undef _nc_syserr_abort
2858 void    _nc_syserr_abort(
2859                 const char *const fmt,
2860                 ...)
2861                 { /* void */ }
2862
2863 /* ./tinfo/comp_hash.c */
2864
2865 #undef _nc_find_entry
2866 struct name_table_entry const *_nc_find_entry(
2867                 const char *string,
2868                 const HashValue *hash_table)
2869                 { return(*(struct name_table_entry const **)0); }
2870
2871 #undef _nc_find_type_entry
2872 struct name_table_entry const *_nc_find_type_entry(
2873                 const char *string,
2874                 int     type,
2875                 NCURSES_BOOL termcap)
2876                 { return(*(struct name_table_entry const **)0); }
2877
2878 /* ./tinfo/db_iterator.c */
2879
2880 #undef _nc_tic_dir
2881 const char *_nc_tic_dir(
2882                 const char *path)
2883                 { return(*(const char **)0); }
2884
2885 #undef _nc_keep_tic_dir
2886 void    _nc_keep_tic_dir(
2887                 const char *path)
2888                 { /* void */ }
2889
2890 #undef _nc_last_db
2891 void    _nc_last_db(void)
2892                 { /* void */ }
2893
2894 #undef _nc_next_db
2895 const char *_nc_next_db(
2896                 DBDIRS  *state,
2897                 int     *offset)
2898                 { return(*(const char **)0); }
2899
2900 #undef _nc_first_db
2901 void    _nc_first_db(
2902                 DBDIRS  *state,
2903                 int     *offset)
2904                 { /* void */ }
2905
2906 /* ./tinfo/doalloc.c */
2907
2908 #undef _nc_doalloc
2909 void    *_nc_doalloc(
2910                 void    *oldp,
2911                 size_t  amount)
2912                 { return(*(void **)0); }
2913
2914 /* ./tinfo/entries.c */
2915
2916 #undef _nc_head
2917 ENTRY   *_nc_head;
2918 #undef _nc_tail
2919 ENTRY   *_nc_tail;
2920
2921 #undef _nc_free_entry
2922 void    _nc_free_entry(
2923                 ENTRY   *headp,
2924                 TERMTYPE *tterm)
2925                 { /* void */ }
2926
2927 #undef _nc_free_entries
2928 void    _nc_free_entries(
2929                 ENTRY   *headp)
2930                 { /* void */ }
2931
2932 #undef _nc_delink_entry
2933 ENTRY   *_nc_delink_entry(
2934                 ENTRY   *headp,
2935                 TERMTYPE *tterm)
2936                 { return(*(ENTRY **)0); }
2937
2938 #undef _nc_leaks_tinfo
2939 void    _nc_leaks_tinfo(void)
2940                 { /* void */ }
2941
2942 /* ./fallback.c */
2943
2944 #undef _nc_fallback
2945 const TERMTYPE *_nc_fallback(
2946                 const char *name)
2947                 { return(*(const TERMTYPE **)0); }
2948
2949 /* ./tinfo/free_ttype.c */
2950
2951 #undef _nc_free_termtype
2952 void    _nc_free_termtype(
2953                 TERMTYPE *ptr)
2954                 { /* void */ }
2955
2956 #undef _nc_user_definable
2957 NCURSES_BOOL _nc_user_definable;
2958
2959 #undef use_extended_names
2960 int     use_extended_names(
2961                 NCURSES_BOOL flag)
2962                 { return(*(int *)0); }
2963
2964 /* ./tinfo/getenv_num.c */
2965
2966 #undef _nc_getenv_num
2967 int     _nc_getenv_num(
2968                 const char *name)
2969                 { return(*(int *)0); }
2970
2971 #undef _nc_setenv_num
2972 void    _nc_setenv_num(
2973                 const char *name,
2974                 int     value)
2975                 { /* void */ }
2976
2977 /* ./tinfo/home_terminfo.c */
2978
2979 #undef _nc_home_terminfo
2980 char    *_nc_home_terminfo(void)
2981                 { return(*(char **)0); }
2982
2983 /* ./tinfo/init_keytry.c */
2984
2985 #undef _nc_init_keytry
2986 void    _nc_init_keytry(
2987                 SCREEN  *sp)
2988                 { /* void */ }
2989
2990 /* ./tinfo/lib_acs.c */
2991
2992 #undef acs_map
2993 chtype  acs_map[128];
2994
2995 #undef _nc_init_acs_sp
2996 void    _nc_init_acs_sp(
2997                 SCREEN  *sp)
2998                 { /* void */ }
2999
3000 #undef _nc_init_acs
3001 void    _nc_init_acs(void)
3002                 { /* void */ }
3003
3004 /* ./tinfo/lib_baudrate.c */
3005
3006 struct speed {
3007     short s;
3008     int sp;
3009 };
3010
3011 #undef _nc_baudrate
3012 int     _nc_baudrate(
3013                 int     OSpeed)
3014                 { return(*(int *)0); }
3015
3016 #undef _nc_ospeed
3017 int     _nc_ospeed(
3018                 int     BaudRate)
3019                 { return(*(int *)0); }
3020
3021 #undef baudrate_sp
3022 int     baudrate_sp(
3023                 SCREEN  *sp)
3024                 { return(*(int *)0); }
3025
3026 #undef baudrate
3027 int     baudrate(void)
3028                 { return(*(int *)0); }
3029
3030 /* ./tinfo/lib_cur_term.c */
3031
3032 #undef cur_term
3033 TERMINAL *cur_term;
3034
3035 #undef set_curterm_sp
3036 TERMINAL *set_curterm_sp(
3037                 SCREEN  *sp,
3038                 TERMINAL *termp)
3039                 { return(*(TERMINAL **)0); }
3040
3041 #undef set_curterm
3042 TERMINAL *set_curterm(
3043                 TERMINAL *termp)
3044                 { return(*(TERMINAL **)0); }
3045
3046 #undef del_curterm_sp
3047 int     del_curterm_sp(
3048                 SCREEN  *sp,
3049                 TERMINAL *termp)
3050                 { return(*(int *)0); }
3051
3052 #undef del_curterm
3053 int     del_curterm(
3054                 TERMINAL *termp)
3055                 { return(*(int *)0); }
3056
3057 /* ./tinfo/lib_data.c */
3058
3059 #undef stdscr
3060 WINDOW  *stdscr;
3061 #undef curscr
3062 WINDOW  *curscr;
3063 #undef newscr
3064 WINDOW  *newscr;
3065 #undef _nc_screen_chain
3066 SCREEN  *_nc_screen_chain;
3067 #undef SP
3068 SCREEN  *SP;
3069 #undef _nc_globals
3070 NCURSES_GLOBALS _nc_globals;
3071 #undef _nc_prescreen
3072 NCURSES_PRESCREEN _nc_prescreen;
3073
3074 #undef _nc_screen_of
3075 SCREEN  *_nc_screen_of(
3076                 WINDOW  *win)
3077                 { return(*(SCREEN **)0); }
3078
3079 /* ./tinfo/lib_has_cap.c */
3080
3081 #undef has_ic_sp
3082 NCURSES_BOOL has_ic_sp(
3083                 SCREEN  *sp)
3084                 { return(*(NCURSES_BOOL *)0); }
3085
3086 #undef has_ic
3087 NCURSES_BOOL has_ic(void)
3088                 { return(*(NCURSES_BOOL *)0); }
3089
3090 #undef has_il_sp
3091 NCURSES_BOOL has_il_sp(
3092                 SCREEN  *sp)
3093                 { return(*(NCURSES_BOOL *)0); }
3094
3095 #undef has_il
3096 NCURSES_BOOL has_il(void)
3097                 { return(*(NCURSES_BOOL *)0); }
3098
3099 /* ./tinfo/lib_kernel.c */
3100
3101 #undef erasechar_sp
3102 char    erasechar_sp(
3103                 SCREEN  *sp)
3104                 { return(*(char *)0); }
3105
3106 #undef erasechar
3107 char    erasechar(void)
3108                 { return(*(char *)0); }
3109
3110 #undef killchar_sp
3111 char    killchar_sp(
3112                 SCREEN  *sp)
3113                 { return(*(char *)0); }
3114
3115 #undef killchar
3116 char    killchar(void)
3117                 { return(*(char *)0); }
3118
3119 #undef flushinp_sp
3120 int     flushinp_sp(
3121                 SCREEN  *sp)
3122                 { return(*(int *)0); }
3123
3124 #undef flushinp
3125 int     flushinp(void)
3126                 { return(*(int *)0); }
3127
3128 /* ./lib_keyname.c */
3129
3130 struct kn { short offset; int code; };
3131
3132 #undef keyname_sp
3133 const char *keyname_sp(
3134                 SCREEN  *sp,
3135                 int     c)
3136                 { return(*(const char **)0); }
3137
3138 #undef keyname
3139 const char *keyname(
3140                 int     c)
3141                 { return(*(const char **)0); }
3142
3143 /* ./tinfo/lib_longname.c */
3144
3145 #undef longname_sp
3146 char    *longname_sp(
3147                 SCREEN  *sp)
3148                 { return(*(char **)0); }
3149
3150 #undef longname
3151 char    *longname(void)
3152                 { return(*(char **)0); }
3153
3154 /* ./tinfo/lib_napms.c */
3155
3156 #undef napms_sp
3157 int     napms_sp(
3158                 SCREEN  *sp,
3159                 int     ms)
3160                 { return(*(int *)0); }
3161
3162 #undef napms
3163 int     napms(
3164                 int     ms)
3165                 { return(*(int *)0); }
3166
3167 /* ./tinfo/lib_options.c */
3168
3169 #undef idlok
3170 int     idlok(
3171                 WINDOW  *win,
3172                 NCURSES_BOOL flag)
3173                 { return(*(int *)0); }
3174
3175 #undef idcok
3176 void    idcok(
3177                 WINDOW  *win,
3178                 NCURSES_BOOL flag)
3179                 { /* void */ }
3180
3181 #undef halfdelay_sp
3182 int     halfdelay_sp(
3183                 SCREEN  *sp,
3184                 int     t)
3185                 { return(*(int *)0); }
3186
3187 #undef halfdelay
3188 int     halfdelay(
3189                 int     t)
3190                 { return(*(int *)0); }
3191
3192 #undef nodelay
3193 int     nodelay(
3194                 WINDOW  *win,
3195                 NCURSES_BOOL flag)
3196                 { return(*(int *)0); }
3197
3198 #undef notimeout
3199 int     notimeout(
3200                 WINDOW  *win,
3201                 NCURSES_BOOL f)
3202                 { return(*(int *)0); }
3203
3204 #undef wtimeout
3205 void    wtimeout(
3206                 WINDOW  *win,
3207                 int     delay)
3208                 { /* void */ }
3209
3210 #undef keypad
3211 int     keypad(
3212                 WINDOW  *win,
3213                 NCURSES_BOOL flag)
3214                 { return(*(int *)0); }
3215
3216 #undef meta
3217 int     meta(
3218                 WINDOW  *win,
3219                 NCURSES_BOOL flag)
3220                 { return(*(int *)0); }
3221
3222 #undef curs_set_sp
3223 int     curs_set_sp(
3224                 SCREEN  *sp,
3225                 int     vis)
3226                 { return(*(int *)0); }
3227
3228 #undef curs_set
3229 int     curs_set(
3230                 int     vis)
3231                 { return(*(int *)0); }
3232
3233 #undef typeahead_sp
3234 int     typeahead_sp(
3235                 SCREEN  *sp,
3236                 int     fd)
3237                 { return(*(int *)0); }
3238
3239 #undef typeahead
3240 int     typeahead(
3241                 int     fd)
3242                 { return(*(int *)0); }
3243
3244 #undef has_key_sp
3245 int     has_key_sp(
3246                 SCREEN  *sp,
3247                 int     keycode)
3248                 { return(*(int *)0); }
3249
3250 #undef has_key
3251 int     has_key(
3252                 int     keycode)
3253                 { return(*(int *)0); }
3254
3255 #undef _nc_putp_flush_sp
3256 int     _nc_putp_flush_sp(
3257                 SCREEN  *sp,
3258                 const char *name,
3259                 const char *value)
3260                 { return(*(int *)0); }
3261
3262 #undef _nc_keypad
3263 int     _nc_keypad(
3264                 SCREEN  *sp,
3265                 int     flag)
3266                 { return(*(int *)0); }
3267
3268 /* ./tinfo/lib_raw.c */
3269
3270 #undef raw_sp
3271 int     raw_sp(
3272                 SCREEN  *sp)
3273                 { return(*(int *)0); }
3274
3275 #undef raw
3276 int     raw(void)
3277                 { return(*(int *)0); }
3278
3279 #undef cbreak_sp
3280 int     cbreak_sp(
3281                 SCREEN  *sp)
3282                 { return(*(int *)0); }
3283
3284 #undef cbreak
3285 int     cbreak(void)
3286                 { return(*(int *)0); }
3287
3288 #undef qiflush_sp
3289 void    qiflush_sp(
3290                 SCREEN  *sp)
3291                 { /* void */ }
3292
3293 #undef qiflush
3294 void    qiflush(void)
3295                 { /* void */ }
3296
3297 #undef noraw_sp
3298 int     noraw_sp(
3299                 SCREEN  *sp)
3300                 { return(*(int *)0); }
3301
3302 #undef noraw
3303 int     noraw(void)
3304                 { return(*(int *)0); }
3305
3306 #undef nocbreak_sp
3307 int     nocbreak_sp(
3308                 SCREEN  *sp)
3309                 { return(*(int *)0); }
3310
3311 #undef nocbreak
3312 int     nocbreak(void)
3313                 { return(*(int *)0); }
3314
3315 #undef noqiflush_sp
3316 void    noqiflush_sp(
3317                 SCREEN  *sp)
3318                 { /* void */ }
3319
3320 #undef noqiflush
3321 void    noqiflush(void)
3322                 { /* void */ }
3323
3324 #undef intrflush_sp
3325 int     intrflush_sp(
3326                 SCREEN  *sp,
3327                 WINDOW  *win,
3328                 NCURSES_BOOL flag)
3329                 { return(*(int *)0); }
3330
3331 #undef intrflush
3332 int     intrflush(
3333                 WINDOW  *win,
3334                 NCURSES_BOOL flag)
3335                 { return(*(int *)0); }
3336
3337 /* ./tinfo/lib_setup.c */
3338
3339 #undef ttytype
3340 char    ttytype[256];
3341 #undef LINES
3342 int     LINES;
3343 #undef COLS
3344 int     COLS;
3345 #undef TABSIZE
3346 int     TABSIZE;
3347
3348 #undef set_tabsize_sp
3349 int     set_tabsize_sp(
3350                 SCREEN  *sp,
3351                 int     value)
3352                 { return(*(int *)0); }
3353
3354 #undef set_tabsize
3355 int     set_tabsize(
3356                 int     value)
3357                 { return(*(int *)0); }
3358
3359 #undef _nc_handle_sigwinch
3360 int     _nc_handle_sigwinch(
3361                 SCREEN  *sp)
3362                 { return(*(int *)0); }
3363
3364 #undef use_env_sp
3365 void    use_env_sp(
3366                 SCREEN  *sp,
3367                 NCURSES_BOOL f)
3368                 { /* void */ }
3369
3370 #undef use_tioctl_sp
3371 void    use_tioctl_sp(
3372                 SCREEN  *sp,
3373                 NCURSES_BOOL f)
3374                 { /* void */ }
3375
3376 #undef use_env
3377 void    use_env(
3378                 NCURSES_BOOL f)
3379                 { /* void */ }
3380
3381 #undef use_tioctl
3382 void    use_tioctl(
3383                 NCURSES_BOOL f)
3384                 { /* void */ }
3385
3386 #undef _nc_get_screensize
3387 void    _nc_get_screensize(
3388                 SCREEN  *sp,
3389                 int     *linep,
3390                 int     *colp)
3391                 { /* void */ }
3392
3393 #undef _nc_update_screensize
3394 void    _nc_update_screensize(
3395                 SCREEN  *sp)
3396                 { /* void */ }
3397
3398 #undef _nc_setup_tinfo
3399 int     _nc_setup_tinfo(
3400                 const char *const tn,
3401                 TERMTYPE *const tp)
3402                 { return(*(int *)0); }
3403
3404 #undef _nc_tinfo_cmdch
3405 void    _nc_tinfo_cmdch(
3406                 TERMINAL *termp,
3407                 int     proto)
3408                 { /* void */ }
3409
3410 #undef _nc_get_locale
3411 char    *_nc_get_locale(void)
3412                 { return(*(char **)0); }
3413
3414 #undef _nc_unicode_locale
3415 int     _nc_unicode_locale(void)
3416                 { return(*(int *)0); }
3417
3418 #undef _nc_locale_breaks_acs
3419 int     _nc_locale_breaks_acs(
3420                 TERMINAL *termp)
3421                 { return(*(int *)0); }
3422
3423 #undef _nc_setupterm
3424 int     _nc_setupterm(
3425                 const char *tname,
3426                 int     Filedes,
3427                 int     *errret,
3428                 int     reuse)
3429                 { return(*(int *)0); }
3430
3431 #undef new_prescr
3432 SCREEN  *new_prescr(void)
3433                 { return(*(SCREEN **)0); }
3434
3435 #undef setupterm
3436 int     setupterm(
3437                 const char *tname,
3438                 int     Filedes,
3439                 int     *errret)
3440                 { return(*(int *)0); }
3441
3442 /* ./tinfo/lib_termcap.c */
3443
3444 #undef UP
3445 char    *UP;
3446 #undef BC
3447 char    *BC;
3448
3449 #undef tgetent_sp
3450 int     tgetent_sp(
3451                 SCREEN  *sp,
3452                 char    *bufp,
3453                 const char *name)
3454                 { return(*(int *)0); }
3455
3456 #undef tgetent
3457 int     tgetent(
3458                 char    *bufp,
3459                 const char *name)
3460                 { return(*(int *)0); }
3461
3462 #undef tgetflag_sp
3463 int     tgetflag_sp(
3464                 SCREEN  *sp,
3465                 const char *id)
3466                 { return(*(int *)0); }
3467
3468 #undef tgetflag
3469 int     tgetflag(
3470                 const char *id)
3471                 { return(*(int *)0); }
3472
3473 #undef tgetnum_sp
3474 int     tgetnum_sp(
3475                 SCREEN  *sp,
3476                 const char *id)
3477                 { return(*(int *)0); }
3478
3479 #undef tgetnum
3480 int     tgetnum(
3481                 const char *id)
3482                 { return(*(int *)0); }
3483
3484 #undef tgetstr_sp
3485 char    *tgetstr_sp(
3486                 SCREEN  *sp,
3487                 const char *id,
3488                 char    **area)
3489                 { return(*(char **)0); }
3490
3491 #undef tgetstr
3492 char    *tgetstr(
3493                 const char *id,
3494                 char    **area)
3495                 { return(*(char **)0); }
3496
3497 /* ./tinfo/lib_termname.c */
3498
3499 #undef termname_sp
3500 char    *termname_sp(
3501                 SCREEN  *sp)
3502                 { return(*(char **)0); }
3503
3504 #undef termname
3505 char    *termname(void)
3506                 { return(*(char **)0); }
3507
3508 /* ./tinfo/lib_tgoto.c */
3509
3510 #undef tgoto
3511 char    *tgoto(
3512                 const char *string,
3513                 int     x,
3514                 int     y)
3515                 { return(*(char **)0); }
3516
3517 /* ./tinfo/lib_ti.c */
3518
3519 #undef tigetflag_sp
3520 int     tigetflag_sp(
3521                 SCREEN  *sp,
3522                 const char *str)
3523                 { return(*(int *)0); }
3524
3525 #undef tigetflag
3526 int     tigetflag(
3527                 const char *str)
3528                 { return(*(int *)0); }
3529
3530 #undef tigetnum_sp
3531 int     tigetnum_sp(
3532                 SCREEN  *sp,
3533                 const char *str)
3534                 { return(*(int *)0); }
3535
3536 #undef tigetnum
3537 int     tigetnum(
3538                 const char *str)
3539                 { return(*(int *)0); }
3540
3541 #undef tigetstr_sp
3542 char    *tigetstr_sp(
3543                 SCREEN  *sp,
3544                 const char *str)
3545                 { return(*(char **)0); }
3546
3547 #undef tigetstr
3548 char    *tigetstr(
3549                 const char *str)
3550                 { return(*(char **)0); }
3551
3552 /* ./tinfo/lib_tparm.c */
3553
3554 #undef _nc_tparm_err
3555 int     _nc_tparm_err;
3556
3557 #undef _nc_tparm_analyze
3558 int     _nc_tparm_analyze(
3559                 const char *string,
3560                 char    *p_is_s[9],
3561                 int     *_nc_popcount)
3562                 { return(*(int *)0); }
3563
3564 #undef tparm
3565 char    *tparm(
3566                 const char *string,
3567                 ...)
3568                 { return(*(char **)0); }
3569
3570 #undef tiparm
3571 char    *tiparm(
3572                 const char *string,
3573                 ...)
3574                 { return(*(char **)0); }
3575
3576 /* ./tinfo/lib_tputs.c */
3577
3578 #undef PC
3579 char    PC;
3580 #undef ospeed
3581 short   ospeed;
3582 #undef _nc_nulls_sent
3583 int     _nc_nulls_sent;
3584
3585 #undef _nc_set_no_padding
3586 void    _nc_set_no_padding(
3587                 SCREEN  *sp)
3588                 { /* void */ }
3589
3590 #undef delay_output_sp
3591 int     delay_output_sp(
3592                 SCREEN  *sp,
3593                 int     ms)
3594                 { return(*(int *)0); }
3595
3596 #undef delay_output
3597 int     delay_output(
3598                 int     ms)
3599                 { return(*(int *)0); }
3600
3601 #undef _nc_flush_sp
3602 void    _nc_flush_sp(
3603                 SCREEN  *sp)
3604                 { /* void */ }
3605
3606 #undef _nc_flush
3607 void    _nc_flush(void)
3608                 { /* void */ }
3609
3610 #undef _nc_outch_sp
3611 int     _nc_outch_sp(
3612                 SCREEN  *sp,
3613                 int     ch)
3614                 { return(*(int *)0); }
3615
3616 #undef _nc_outch
3617 int     _nc_outch(
3618                 int     ch)
3619                 { return(*(int *)0); }
3620
3621 #undef _nc_putchar_sp
3622 int     _nc_putchar_sp(
3623                 SCREEN  *sp,
3624                 int     ch)
3625                 { return(*(int *)0); }
3626
3627 #undef _nc_putchar
3628 int     _nc_putchar(
3629                 int     ch)
3630                 { return(*(int *)0); }
3631
3632 #undef putp_sp
3633 int     putp_sp(
3634                 SCREEN  *sp,
3635                 const char *string)
3636                 { return(*(int *)0); }
3637
3638 #undef putp
3639 int     putp(
3640                 const char *string)
3641                 { return(*(int *)0); }
3642
3643 #undef _nc_putp_sp
3644 int     _nc_putp_sp(
3645                 SCREEN  *sp,
3646                 const char *name,
3647                 const char *string)
3648                 { return(*(int *)0); }
3649
3650 #undef _nc_putp
3651 int     _nc_putp(
3652                 const char *name,
3653                 const char *string)
3654                 { return(*(int *)0); }
3655
3656 #undef tputs_sp
3657 int     tputs_sp(
3658                 SCREEN  *sp,
3659                 const char *string,
3660                 int     affcnt,
3661                 NCURSES_OUTC_sp outc)
3662                 { return(*(int *)0); }
3663
3664 #undef _nc_outc_wrapper
3665 int     _nc_outc_wrapper(
3666                 SCREEN  *sp,
3667                 int     c)
3668                 { return(*(int *)0); }
3669
3670 #undef tputs
3671 int     tputs(
3672                 const char *string,
3673                 int     affcnt,
3674                 int     (*outc)(
3675                 int     p1))
3676                 { return(*(int *)0); }
3677
3678 /* ./trace/lib_trace.c */
3679
3680 #undef _nc_tracing
3681 unsigned _nc_tracing;
3682 #undef _nc_tputs_trace
3683 const char *_nc_tputs_trace = {0};
3684 #undef _nc_outchars
3685 long    _nc_outchars;
3686
3687 #undef trace
3688 void    trace(
3689                 const unsigned int tracelevel)
3690                 { /* void */ }
3691
3692 #undef _tracef
3693 void    _tracef(
3694                 const char *fmt,
3695                 ...)
3696                 { /* void */ }
3697
3698 #undef _nc_retrace_bool
3699 NCURSES_BOOL _nc_retrace_bool(
3700                 int     code)
3701                 { return(*(NCURSES_BOOL *)0); }
3702
3703 #undef _nc_retrace_char
3704 char    _nc_retrace_char(
3705                 int     code)
3706                 { return(*(char *)0); }
3707
3708 #undef _nc_retrace_int
3709 int     _nc_retrace_int(
3710                 int     code)
3711                 { return(*(int *)0); }
3712
3713 #undef _nc_retrace_unsigned
3714 unsigned _nc_retrace_unsigned(
3715                 unsigned code)
3716                 { return(*(unsigned *)0); }
3717
3718 #undef _nc_retrace_ptr
3719 char    *_nc_retrace_ptr(
3720                 char    *code)
3721                 { return(*(char **)0); }
3722
3723 #undef _nc_retrace_cptr
3724 const char *_nc_retrace_cptr(
3725                 const char *code)
3726                 { return(*(const char **)0); }
3727
3728 #undef _nc_retrace_cvoid_ptr
3729 const void *_nc_retrace_cvoid_ptr(
3730                 const void *code)
3731                 { return(*(const void **)0); }
3732
3733 #undef _nc_retrace_void_ptr
3734 void    *_nc_retrace_void_ptr(
3735                 void    *code)
3736                 { return(*(void **)0); }
3737
3738 #undef _nc_retrace_sp
3739 SCREEN  *_nc_retrace_sp(
3740                 SCREEN  *code)
3741                 { return(*(SCREEN **)0); }
3742
3743 #undef _nc_retrace_win
3744 WINDOW  *_nc_retrace_win(
3745                 WINDOW  *code)
3746                 { return(*(WINDOW **)0); }
3747
3748 /* ./trace/lib_traceatr.c */
3749
3750 #undef _traceattr2
3751 char    *_traceattr2(
3752                 int     bufnum,
3753                 chtype  newmode)
3754                 { return(*(char **)0); }
3755
3756 #undef _traceattr
3757 char    *_traceattr(
3758                 attr_t  newmode)
3759                 { return(*(char **)0); }
3760
3761 #undef _nc_retrace_int_attr_t
3762 int     _nc_retrace_int_attr_t(
3763                 attr_t  code)
3764                 { return(*(int *)0); }
3765
3766 #undef _nc_retrace_attr_t
3767 attr_t  _nc_retrace_attr_t(
3768                 attr_t  code)
3769                 { return(*(attr_t *)0); }
3770
3771 #undef _nc_altcharset_name
3772 const char *_nc_altcharset_name(
3773                 attr_t  attr,
3774                 chtype  ch)
3775                 { return(*(const char **)0); }
3776
3777 #undef _tracechtype2
3778 char    *_tracechtype2(
3779                 int     bufnum,
3780                 chtype  ch)
3781                 { return(*(char **)0); }
3782
3783 #undef _tracechtype
3784 char    *_tracechtype(
3785                 chtype  ch)
3786                 { return(*(char **)0); }
3787
3788 #undef _nc_retrace_chtype
3789 chtype  _nc_retrace_chtype(
3790                 chtype  code)
3791                 { return(*(chtype *)0); }
3792
3793 /* ./trace/lib_tracebits.c */
3794
3795 typedef struct {
3796     unsigned int val;
3797     const char name[8];
3798 } BITNAMES;
3799
3800 #undef _nc_trace_ttymode
3801 char    *_nc_trace_ttymode(
3802                 struct termios *tty)
3803                 { return(*(char **)0); }
3804
3805 #undef _nc_tracebits
3806 char    *_nc_tracebits(void)
3807                 { return(*(char **)0); }
3808
3809 /* ./trace/lib_tracechr.c */
3810
3811 #undef _nc_tracechar
3812 char    *_nc_tracechar(
3813                 SCREEN  *sp,
3814                 int     ch)
3815                 { return(*(char **)0); }
3816
3817 #undef _tracechar
3818 char    *_tracechar(
3819                 int     ch)
3820                 { return(*(char **)0); }
3821
3822 /* ./tinfo/lib_ttyflags.c */
3823
3824 #undef _nc_get_tty_mode_sp
3825 int     _nc_get_tty_mode_sp(
3826                 SCREEN  *sp,
3827                 struct termios *buf)
3828                 { return(*(int *)0); }
3829
3830 #undef _nc_get_tty_mode
3831 int     _nc_get_tty_mode(
3832                 struct termios *buf)
3833                 { return(*(int *)0); }
3834
3835 #undef _nc_set_tty_mode_sp
3836 int     _nc_set_tty_mode_sp(
3837                 SCREEN  *sp,
3838                 struct termios *buf)
3839                 { return(*(int *)0); }
3840
3841 #undef _nc_set_tty_mode
3842 int     _nc_set_tty_mode(
3843                 struct termios *buf)
3844                 { return(*(int *)0); }
3845
3846 #undef def_shell_mode_sp
3847 int     def_shell_mode_sp(
3848                 SCREEN  *sp)
3849                 { return(*(int *)0); }
3850
3851 #undef def_shell_mode
3852 int     def_shell_mode(void)
3853                 { return(*(int *)0); }
3854
3855 #undef def_prog_mode_sp
3856 int     def_prog_mode_sp(
3857                 SCREEN  *sp)
3858                 { return(*(int *)0); }
3859
3860 #undef def_prog_mode
3861 int     def_prog_mode(void)
3862                 { return(*(int *)0); }
3863
3864 #undef reset_prog_mode_sp
3865 int     reset_prog_mode_sp(
3866                 SCREEN  *sp)
3867                 { return(*(int *)0); }
3868
3869 #undef reset_prog_mode
3870 int     reset_prog_mode(void)
3871                 { return(*(int *)0); }
3872
3873 #undef reset_shell_mode_sp
3874 int     reset_shell_mode_sp(
3875                 SCREEN  *sp)
3876                 { return(*(int *)0); }
3877
3878 #undef reset_shell_mode
3879 int     reset_shell_mode(void)
3880                 { return(*(int *)0); }
3881
3882 #undef savetty_sp
3883 int     savetty_sp(
3884                 SCREEN  *sp)
3885                 { return(*(int *)0); }
3886
3887 #undef savetty
3888 int     savetty(void)
3889                 { return(*(int *)0); }
3890
3891 #undef resetty_sp
3892 int     resetty_sp(
3893                 SCREEN  *sp)
3894                 { return(*(int *)0); }
3895
3896 #undef resetty
3897 int     resetty(void)
3898                 { return(*(int *)0); }
3899
3900 /* ./tty/lib_twait.c */
3901
3902 #undef _nc_timed_wait
3903 int     _nc_timed_wait(
3904                 SCREEN  *sp,
3905                 int     mode,
3906                 int     milliseconds,
3907                 int     *timeleft)
3908                 { return(*(int *)0); }
3909
3910 /* ./tinfo/name_match.c */
3911
3912 #undef _nc_first_name
3913 char    *_nc_first_name(
3914                 const char *const sp)
3915                 { return(*(char **)0); }
3916
3917 #undef _nc_name_match
3918 int     _nc_name_match(
3919                 const char *const namelst,
3920                 const char *const name,
3921                 const char *const delim)
3922                 { return(*(int *)0); }
3923
3924 /* ./names.c */
3925
3926 #undef boolnames
3927 const char *const boolnames[] = {0};
3928 #undef boolfnames
3929 const char *const boolfnames[] = {0};
3930 #undef numnames
3931 const char *const numnames[] = {0};
3932 #undef numfnames
3933 const char *const numfnames[] = {0};
3934 #undef strnames
3935 const char *const strnames[] = {0};
3936 #undef strfnames
3937 const char *const strfnames[] = {0};
3938
3939 /* ./tinfo/obsolete.c */
3940
3941 #undef _nc_set_buffer_sp
3942 void    _nc_set_buffer_sp(
3943                 SCREEN  *sp,
3944                 FILE    *ofp,
3945                 int     buffered)
3946                 { /* void */ }
3947
3948 #undef _nc_set_buffer
3949 void    _nc_set_buffer(
3950                 FILE    *ofp,
3951                 int     buffered)
3952                 { /* void */ }
3953
3954 /* ./tinfo/read_entry.c */
3955
3956 #undef _nc_init_termtype
3957 void    _nc_init_termtype(
3958                 TERMTYPE *const tp)
3959                 { /* void */ }
3960
3961 #undef _nc_read_termtype
3962 int     _nc_read_termtype(
3963                 TERMTYPE *ptr,
3964                 char    *buffer,
3965                 int     limit)
3966                 { return(*(int *)0); }
3967
3968 #undef _nc_read_file_entry
3969 int     _nc_read_file_entry(
3970                 const char *const filename,
3971                 TERMTYPE *ptr)
3972                 { return(*(int *)0); }
3973
3974 #undef _nc_read_entry
3975 int     _nc_read_entry(
3976                 const char *const name,
3977                 char    *const filename,
3978                 TERMTYPE *const tp)
3979                 { return(*(int *)0); }
3980
3981 /* ./tinfo/read_termcap.c */
3982
3983 #undef _nc_read_termcap
3984 void    _nc_read_termcap(void)
3985                 { /* void */ }
3986
3987 /* ./tinfo/strings.c */
3988
3989 #undef _nc_str_init
3990 string_desc *_nc_str_init(
3991                 string_desc *dst,
3992                 char    *src,
3993                 size_t  len)
3994                 { return(*(string_desc **)0); }
3995
3996 #undef _nc_str_null
3997 string_desc *_nc_str_null(
3998                 string_desc *dst,
3999                 size_t  len)
4000                 { return(*(string_desc **)0); }
4001
4002 #undef _nc_str_copy
4003 string_desc *_nc_str_copy(
4004                 string_desc *dst,
4005                 string_desc *src)
4006                 { return(*(string_desc **)0); }
4007
4008 #undef _nc_safe_strcat
4009 NCURSES_BOOL _nc_safe_strcat(
4010                 string_desc *dst,
4011                 const char *src)
4012                 { return(*(NCURSES_BOOL *)0); }
4013
4014 #undef _nc_safe_strcpy
4015 NCURSES_BOOL _nc_safe_strcpy(
4016                 string_desc *dst,
4017                 const char *src)
4018                 { return(*(NCURSES_BOOL *)0); }
4019
4020 /* ./trace/trace_buf.c */
4021
4022 #undef _nc_trace_buf
4023 char    *_nc_trace_buf(
4024                 int     bufnum,
4025                 size_t  want)
4026                 { return(*(char **)0); }
4027
4028 #undef _nc_trace_bufcat
4029 char    *_nc_trace_bufcat(
4030                 int     bufnum,
4031                 const char *value)
4032                 { return(*(char **)0); }
4033
4034 /* ./trace/trace_tries.c */
4035
4036 #undef _nc_trace_tries
4037 void    _nc_trace_tries(
4038                 TRIES   *tree)
4039                 { /* void */ }
4040
4041 /* ./base/tries.c */
4042
4043 #undef _nc_expand_try
4044 char    *_nc_expand_try(
4045                 TRIES   *tree,
4046                 unsigned code,
4047                 int     *count,
4048                 size_t  len)
4049                 { return(*(char **)0); }
4050
4051 #undef _nc_remove_key
4052 int     _nc_remove_key(
4053                 TRIES   **tree,
4054                 unsigned code)
4055                 { return(*(int *)0); }
4056
4057 #undef _nc_remove_string
4058 int     _nc_remove_string(
4059                 TRIES   **tree,
4060                 const char *string)
4061                 { return(*(int *)0); }
4062
4063 /* ./tinfo/trim_sgr0.c */
4064
4065 #undef _nc_trim_sgr0
4066 char    *_nc_trim_sgr0(
4067                 TERMTYPE *tp)
4068                 { return(*(char **)0); }
4069
4070 /* ./unctrl.c */
4071
4072 #undef unctrl_sp
4073 const char *unctrl_sp(
4074                 SCREEN  *sp,
4075                 chtype  ch)
4076                 { return(*(const char **)0); }
4077
4078 #undef unctrl
4079 const char *unctrl(
4080                 chtype  ch)
4081                 { return(*(const char **)0); }
4082
4083 /* ./trace/visbuf.c */
4084
4085 #undef _nc_visbuf2
4086 const char *_nc_visbuf2(
4087                 int     bufnum,
4088                 const char *buf)
4089                 { return(*(const char **)0); }
4090
4091 #undef _nc_visbuf
4092 const char *_nc_visbuf(
4093                 const char *buf)
4094                 { return(*(const char **)0); }
4095
4096 #undef _nc_visbufn
4097 const char *_nc_visbufn(
4098                 const char *buf,
4099                 int     len)
4100                 { return(*(const char **)0); }
4101
4102 #undef _nc_viscbuf2
4103 const char *_nc_viscbuf2(
4104                 int     bufnum,
4105                 const chtype *buf,
4106                 int     len)
4107                 { return(*(const char **)0); }
4108
4109 #undef _nc_viscbuf
4110 const char *_nc_viscbuf(
4111                 const chtype *buf,
4112                 int     len)
4113                 { return(*(const char **)0); }
4114
4115 /* ./tinfo/alloc_entry.c */
4116
4117 #undef _nc_init_entry
4118 void    _nc_init_entry(
4119                 TERMTYPE *const tp)
4120                 { /* void */ }
4121
4122 #undef _nc_copy_entry
4123 ENTRY   *_nc_copy_entry(
4124                 ENTRY   *oldp)
4125                 { return(*(ENTRY **)0); }
4126
4127 #undef _nc_save_str
4128 char    *_nc_save_str(
4129                 const char *const string)
4130                 { return(*(char **)0); }
4131
4132 #undef _nc_wrap_entry
4133 void    _nc_wrap_entry(
4134                 ENTRY   *const ep,
4135                 NCURSES_BOOL copy_strings)
4136                 { /* void */ }
4137
4138 #undef _nc_merge_entry
4139 void    _nc_merge_entry(
4140                 TERMTYPE *const to,
4141                 TERMTYPE *const from)
4142                 { /* void */ }
4143
4144 /* ./tinfo/captoinfo.c */
4145
4146 #undef _nc_captoinfo
4147 char    *_nc_captoinfo(
4148                 const char *cap,
4149                 const char *s,
4150                 int const parameterized)
4151                 { return(*(char **)0); }
4152
4153 #undef _nc_infotocap
4154 char    *_nc_infotocap(
4155                 const char *cap,
4156                 const char *str,
4157                 int const parameterized)
4158                 { return(*(char **)0); }
4159
4160 /* ./tinfo/comp_expand.c */
4161
4162 #undef _nc_tic_expand
4163 char    *_nc_tic_expand(
4164                 const char *srcp,
4165                 NCURSES_BOOL tic_format,
4166                 int     numbers)
4167                 { return(*(char **)0); }
4168
4169 /* ./tinfo/comp_parse.c */
4170
4171 #undef _nc_check_termtype2
4172 void    (*_nc_check_termtype2)(
4173                 TERMTYPE *p1,
4174                 NCURSES_BOOL p2);
4175 #undef _nc_check_termtype
4176 void    (*_nc_check_termtype)(
4177                 TERMTYPE *p1);
4178
4179 #undef _nc_entry_match
4180 NCURSES_BOOL _nc_entry_match(
4181                 char    *n1,
4182                 char    *n2)
4183                 { return(*(NCURSES_BOOL *)0); }
4184
4185 #undef _nc_read_entry_source
4186 void    _nc_read_entry_source(
4187                 FILE    *fp,
4188                 char    *buf,
4189                 int     literal,
4190                 NCURSES_BOOL silent,
4191                 NCURSES_BOOL (*hook)(
4192                 ENTRY   *p1))
4193                 { /* void */ }
4194
4195 #undef _nc_resolve_uses2
4196 int     _nc_resolve_uses2(
4197                 NCURSES_BOOL fullresolve,
4198                 NCURSES_BOOL literal)
4199                 { return(*(int *)0); }
4200
4201 #undef _nc_resolve_uses
4202 int     _nc_resolve_uses(
4203                 NCURSES_BOOL fullresolve)
4204                 { return(*(int *)0); }
4205
4206 /* ./tinfo/comp_scan.c */
4207
4208 #undef _nc_syntax
4209 int     _nc_syntax;
4210 #undef _nc_strict_bsd
4211 int     _nc_strict_bsd;
4212 #undef _nc_curr_file_pos
4213 long    _nc_curr_file_pos;
4214 #undef _nc_comment_start
4215 long    _nc_comment_start;
4216 #undef _nc_comment_end
4217 long    _nc_comment_end;
4218 #undef _nc_start_line
4219 long    _nc_start_line;
4220 #undef _nc_curr_token
4221 struct token _nc_curr_token;
4222 #undef _nc_disable_period
4223 NCURSES_BOOL _nc_disable_period;
4224
4225 #undef _nc_reset_input
4226 void    _nc_reset_input(
4227                 FILE    *fp,
4228                 char    *buf)
4229                 { /* void */ }
4230
4231 #undef _nc_get_token
4232 int     _nc_get_token(
4233                 NCURSES_BOOL silent)
4234                 { return(*(int *)0); }
4235
4236 #undef _nc_trans_string
4237 int     _nc_trans_string(
4238                 char    *ptr,
4239                 char    *last)
4240                 { return(*(int *)0); }
4241
4242 #undef _nc_push_token
4243 void    _nc_push_token(
4244                 int     tokclass)
4245                 { /* void */ }
4246
4247 #undef _nc_panic_mode
4248 void    _nc_panic_mode(
4249                 char    ch)
4250                 { /* void */ }
4251
4252 /* ./tinfo/parse_entry.c */
4253
4254 #undef _nc_parse_entry
4255 int     _nc_parse_entry(
4256                 struct entry *entryp,
4257                 int     literal,
4258                 NCURSES_BOOL silent)
4259                 { return(*(int *)0); }
4260
4261 #undef _nc_capcmp
4262 int     _nc_capcmp(
4263                 const char *s,
4264                 const char *t)
4265                 { return(*(int *)0); }
4266
4267 typedef struct {
4268     const char from[3];
4269     const char to[6];
4270 } assoc;
4271
4272 /* ./tinfo/write_entry.c */
4273
4274 #undef _nc_set_writedir
4275 void    _nc_set_writedir(
4276                 const char *dir)
4277                 { /* void */ }
4278
4279 #undef _nc_write_entry
4280 void    _nc_write_entry(
4281                 TERMTYPE *const tp)
4282                 { /* void */ }
4283
4284 #undef _nc_tic_written
4285 int     _nc_tic_written(void)
4286                 { return(*(int *)0); }
4287
4288 /* ./base/define_key.c */
4289
4290 #undef define_key_sp
4291 int     define_key_sp(
4292                 SCREEN  *sp,
4293                 const char *str,
4294                 int     keycode)
4295                 { return(*(int *)0); }
4296
4297 #undef define_key
4298 int     define_key(
4299                 const char *str,
4300                 int     keycode)
4301                 { return(*(int *)0); }
4302
4303 /* ./tinfo/hashed_db.c */
4304
4305 #undef _nc_hashed_db
4306 void    _nc_hashed_db(void)
4307                 { /* void */ }
4308
4309 /* ./base/key_defined.c */
4310
4311 #undef key_defined_sp
4312 int     key_defined_sp(
4313                 SCREEN  *sp,
4314                 const char *str)
4315                 { return(*(int *)0); }
4316
4317 #undef key_defined
4318 int     key_defined(
4319                 const char *str)
4320                 { return(*(int *)0); }
4321
4322 /* ./base/keybound.c */
4323
4324 #undef keybound_sp
4325 char    *keybound_sp(
4326                 SCREEN  *sp,
4327                 int     code,
4328                 int     count)
4329                 { return(*(char **)0); }
4330
4331 #undef keybound
4332 char    *keybound(
4333                 int     code,
4334                 int     count)
4335                 { return(*(char **)0); }
4336
4337 /* ./base/keyok.c */
4338
4339 #undef keyok_sp
4340 int     keyok_sp(
4341                 SCREEN  *sp,
4342                 int     c,
4343                 NCURSES_BOOL flag)
4344                 { return(*(int *)0); }
4345
4346 #undef keyok
4347 int     keyok(
4348                 int     c,
4349                 NCURSES_BOOL flag)
4350                 { return(*(int *)0); }
4351
4352 /* ./base/version.c */
4353
4354 #undef curses_version
4355 const char *curses_version(void)
4356                 { return(*(const char **)0); }