ncurses/llib-lncursest

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