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 #undef _nc_varargs
2524 char    *_nc_varargs(
2525                 const char *fmt,
2526                 va_list ap)
2527                 { return(*(char **)0); }
2528
2529 /* ./base/vsscanf.c */
2530
2531 #undef _nc_vsscanf
2532 void    _nc_vsscanf(void)
2533                 { /* void */ }
2534
2535 /* ./base/lib_freeall.c */
2536
2537 #undef _nc_freeall
2538 void    _nc_freeall(void)
2539                 { /* void */ }
2540
2541 #undef _nc_free_and_exit_sp
2542 void    _nc_free_and_exit_sp(
2543                 SCREEN  *sp,
2544                 int     code)
2545                 { /* void */ }
2546
2547 #undef _nc_free_and_exit
2548 void    _nc_free_and_exit(
2549                 int     code)
2550                 { /* void */ }
2551
2552 /* ./expanded.c */
2553
2554 #undef _nc_toggle_attr_on
2555 void    _nc_toggle_attr_on(
2556                 attr_t  *S,
2557                 attr_t  at)
2558                 { /* void */ }
2559
2560 #undef _nc_toggle_attr_off
2561 void    _nc_toggle_attr_off(
2562                 attr_t  *S,
2563                 attr_t  at)
2564                 { /* void */ }
2565
2566 #undef _nc_DelCharCost_sp
2567 int     _nc_DelCharCost_sp(
2568                 SCREEN  *sp,
2569                 int     count)
2570                 { return(*(int *)0); }
2571
2572 #undef _nc_InsCharCost_sp
2573 int     _nc_InsCharCost_sp(
2574                 SCREEN  *sp,
2575                 int     count)
2576                 { return(*(int *)0); }
2577
2578 #undef _nc_UpdateAttrs_sp
2579 void    _nc_UpdateAttrs_sp(
2580                 SCREEN  *sp,
2581                 chtype  c)
2582                 { /* void */ }
2583
2584 #undef _nc_DelCharCost
2585 int     _nc_DelCharCost(
2586                 int     count)
2587                 { return(*(int *)0); }
2588
2589 #undef _nc_InsCharCost
2590 int     _nc_InsCharCost(
2591                 int     count)
2592                 { return(*(int *)0); }
2593
2594 #undef _nc_UpdateAttrs
2595 void    _nc_UpdateAttrs(
2596                 chtype  c)
2597                 { /* void */ }
2598
2599 /* ./base/legacy_coding.c */
2600
2601 #undef use_legacy_coding_sp
2602 int     use_legacy_coding_sp(
2603                 SCREEN  *sp,
2604                 int     level)
2605                 { return(*(int *)0); }
2606
2607 #undef use_legacy_coding
2608 int     use_legacy_coding(
2609                 int     level)
2610                 { return(*(int *)0); }
2611
2612 /* ./base/lib_dft_fgbg.c */
2613
2614 #undef use_default_colors_sp
2615 int     use_default_colors_sp(
2616                 SCREEN  *sp)
2617                 { return(*(int *)0); }
2618
2619 #undef use_default_colors
2620 int     use_default_colors(void)
2621                 { return(*(int *)0); }
2622
2623 #undef assume_default_colors_sp
2624 int     assume_default_colors_sp(
2625                 SCREEN  *sp,
2626                 int     fg,
2627                 int     bg)
2628                 { return(*(int *)0); }
2629
2630 #undef assume_default_colors
2631 int     assume_default_colors(
2632                 int     fg,
2633                 int     bg)
2634                 { return(*(int *)0); }
2635
2636 /* ./tinfo/lib_print.c */
2637
2638 #undef mcprint_sp
2639 int     mcprint_sp(
2640                 SCREEN  *sp,
2641                 char    *data,
2642                 int     len)
2643                 { return(*(int *)0); }
2644
2645 #undef mcprint
2646 int     mcprint(
2647                 char    *data,
2648                 int     len)
2649                 { return(*(int *)0); }
2650
2651 /* ./base/resizeterm.c */
2652
2653 #undef is_term_resized_sp
2654 NCURSES_BOOL is_term_resized_sp(
2655                 SCREEN  *sp,
2656                 int     ToLines,
2657                 int     ToCols)
2658                 { return(*(NCURSES_BOOL *)0); }
2659
2660 #undef is_term_resized
2661 NCURSES_BOOL is_term_resized(
2662                 int     ToLines,
2663                 int     ToCols)
2664                 { return(*(NCURSES_BOOL *)0); }
2665
2666 #undef resize_term_sp
2667 int     resize_term_sp(
2668                 SCREEN  *sp,
2669                 int     ToLines,
2670                 int     ToCols)
2671                 { return(*(int *)0); }
2672
2673 #undef resize_term
2674 int     resize_term(
2675                 int     ToLines,
2676                 int     ToCols)
2677                 { return(*(int *)0); }
2678
2679 #undef resizeterm_sp
2680 int     resizeterm_sp(
2681                 SCREEN  *sp,
2682                 int     ToLines,
2683                 int     ToCols)
2684                 { return(*(int *)0); }
2685
2686 #undef resizeterm
2687 int     resizeterm(
2688                 int     ToLines,
2689                 int     ToCols)
2690                 { return(*(int *)0); }
2691
2692 /* ./trace/trace_xnames.c */
2693
2694 #undef _nc_trace_xnames
2695 void    _nc_trace_xnames(
2696                 TERMTYPE *tp)
2697                 { /* void */ }
2698
2699 /* ./tinfo/use_screen.c */
2700
2701 #undef use_screen
2702 int     use_screen(
2703                 SCREEN  *screen,
2704                 NCURSES_SCREEN_CB func,
2705                 void    *data)
2706                 { return(*(int *)0); }
2707
2708 /* ./base/use_window.c */
2709
2710 #undef use_window
2711 int     use_window(
2712                 WINDOW  *win,
2713                 NCURSES_WINDOW_CB func,
2714                 void    *data)
2715                 { return(*(int *)0); }
2716
2717 /* ./base/wresize.c */
2718
2719 #undef wresize
2720 int     wresize(
2721                 WINDOW  *win,
2722                 int     ToLines,
2723                 int     ToCols)
2724                 { return(*(int *)0); }
2725
2726 /* ./tinfo/access.c */
2727
2728 #undef _nc_rootname
2729 char    *_nc_rootname(
2730                 char    *path)
2731                 { return(*(char **)0); }
2732
2733 #undef _nc_is_abs_path
2734 NCURSES_BOOL _nc_is_abs_path(
2735                 const char *path)
2736                 { return(*(NCURSES_BOOL *)0); }
2737
2738 #undef _nc_pathlast
2739 unsigned _nc_pathlast(
2740                 const char *path)
2741                 { return(*(unsigned *)0); }
2742
2743 #undef _nc_basename
2744 char    *_nc_basename(
2745                 char    *path)
2746                 { return(*(char **)0); }
2747
2748 #undef _nc_access
2749 int     _nc_access(
2750                 const char *path,
2751                 int     mode)
2752                 { return(*(int *)0); }
2753
2754 #undef _nc_is_dir_path
2755 NCURSES_BOOL _nc_is_dir_path(
2756                 const char *path)
2757                 { return(*(NCURSES_BOOL *)0); }
2758
2759 #undef _nc_is_file_path
2760 NCURSES_BOOL _nc_is_file_path(
2761                 const char *path)
2762                 { return(*(NCURSES_BOOL *)0); }
2763
2764 #undef _nc_env_access
2765 int     _nc_env_access(void)
2766                 { return(*(int *)0); }
2767
2768 /* ./tinfo/add_tries.c */
2769
2770 #undef _nc_add_to_try
2771 int     _nc_add_to_try(
2772                 TRIES   **tree,
2773                 const char *str,
2774                 unsigned code)
2775                 { return(*(int *)0); }
2776
2777 /* ./tinfo/alloc_ttype.c */
2778
2779 #undef _nc_align_termtype
2780 void    _nc_align_termtype(
2781                 TERMTYPE *to,
2782                 TERMTYPE *from)
2783                 { /* void */ }
2784
2785 #undef _nc_copy_termtype
2786 void    _nc_copy_termtype(
2787                 TERMTYPE *dst,
2788                 const TERMTYPE *src)
2789                 { /* void */ }
2790
2791 /* ./codes.c */
2792
2793 #undef _nc_boolcodes
2794 const char *const *_nc_boolcodes(void)
2795                 { return(*(const char **)0); }
2796
2797 #undef _nc_numcodes
2798 const char *const *_nc_numcodes(void)
2799                 { return(*(const char **)0); }
2800
2801 #undef _nc_strcodes
2802 const char *const *_nc_strcodes(void)
2803                 { return(*(const char **)0); }
2804
2805 /* ./comp_captab.c */
2806
2807 #undef _nc_get_table
2808 const struct name_table_entry *_nc_get_table(
2809                 NCURSES_BOOL termcap)
2810                 { return(*(const struct name_table_entry **)0); }
2811
2812 #undef _nc_get_hash_table
2813 const HashValue *_nc_get_hash_table(
2814                 NCURSES_BOOL termcap)
2815                 { return(*(const HashValue **)0); }
2816
2817 #undef _nc_get_alias_table
2818 const struct alias *_nc_get_alias_table(
2819                 NCURSES_BOOL termcap)
2820                 { return(*(const struct alias **)0); }
2821
2822 #undef _nc_get_hash_info
2823 const HashData *_nc_get_hash_info(
2824                 NCURSES_BOOL termcap)
2825                 { return(*(const HashData **)0); }
2826
2827 /* ./tinfo/comp_error.c */
2828
2829 #undef _nc_suppress_warnings
2830 NCURSES_BOOL _nc_suppress_warnings;
2831 #undef _nc_curr_line
2832 int     _nc_curr_line;
2833 #undef _nc_curr_col
2834 int     _nc_curr_col;
2835
2836 #undef _nc_get_source
2837 const char *_nc_get_source(void)
2838                 { return(*(const char **)0); }
2839
2840 #undef _nc_set_source
2841 void    _nc_set_source(
2842                 const char *const name)
2843                 { /* void */ }
2844
2845 #undef _nc_set_type
2846 void    _nc_set_type(
2847                 const char *const name)
2848                 { /* void */ }
2849
2850 #undef _nc_get_type
2851 void    _nc_get_type(
2852                 char    *name)
2853                 { /* void */ }
2854
2855 #undef _nc_warning
2856 void    _nc_warning(
2857                 const char *const fmt,
2858                 ...)
2859                 { /* void */ }
2860
2861 #undef _nc_err_abort
2862 void    _nc_err_abort(
2863                 const char *const fmt,
2864                 ...)
2865                 { /* void */ }
2866
2867 #undef _nc_syserr_abort
2868 void    _nc_syserr_abort(
2869                 const char *const fmt,
2870                 ...)
2871                 { /* void */ }
2872
2873 /* ./tinfo/comp_hash.c */
2874
2875 #undef _nc_find_entry
2876 struct name_table_entry const *_nc_find_entry(
2877                 const char *string,
2878                 const HashValue *hash_table)
2879                 { return(*(struct name_table_entry const **)0); }
2880
2881 #undef _nc_find_type_entry
2882 struct name_table_entry const *_nc_find_type_entry(
2883                 const char *string,
2884                 int     type,
2885                 NCURSES_BOOL termcap)
2886                 { return(*(struct name_table_entry const **)0); }
2887
2888 /* ./tinfo/db_iterator.c */
2889
2890 #undef _nc_tic_dir
2891 const char *_nc_tic_dir(
2892                 const char *path)
2893                 { return(*(const char **)0); }
2894
2895 #undef _nc_keep_tic_dir
2896 void    _nc_keep_tic_dir(
2897                 const char *path)
2898                 { /* void */ }
2899
2900 #undef _nc_last_db
2901 void    _nc_last_db(void)
2902                 { /* void */ }
2903
2904 #undef _nc_next_db
2905 const char *_nc_next_db(
2906                 DBDIRS  *state,
2907                 int     *offset)
2908                 { return(*(const char **)0); }
2909
2910 #undef _nc_first_db
2911 void    _nc_first_db(
2912                 DBDIRS  *state,
2913                 int     *offset)
2914                 { /* void */ }
2915
2916 /* ./tinfo/doalloc.c */
2917
2918 #undef _nc_doalloc
2919 void    *_nc_doalloc(
2920                 void    *oldp,
2921                 size_t  amount)
2922                 { return(*(void **)0); }
2923
2924 /* ./tinfo/entries.c */
2925
2926 #undef _nc_head
2927 ENTRY   *_nc_head;
2928 #undef _nc_tail
2929 ENTRY   *_nc_tail;
2930
2931 #undef _nc_free_entry
2932 void    _nc_free_entry(
2933                 ENTRY   *headp,
2934                 TERMTYPE *tterm)
2935                 { /* void */ }
2936
2937 #undef _nc_free_entries
2938 void    _nc_free_entries(
2939                 ENTRY   *headp)
2940                 { /* void */ }
2941
2942 #undef _nc_delink_entry
2943 ENTRY   *_nc_delink_entry(
2944                 ENTRY   *headp,
2945                 TERMTYPE *tterm)
2946                 { return(*(ENTRY **)0); }
2947
2948 #undef _nc_leaks_tinfo
2949 void    _nc_leaks_tinfo(void)
2950                 { /* void */ }
2951
2952 /* ./fallback.c */
2953
2954 #undef _nc_fallback
2955 const TERMTYPE *_nc_fallback(
2956                 const char *name)
2957                 { return(*(const TERMTYPE **)0); }
2958
2959 /* ./tinfo/free_ttype.c */
2960
2961 #undef _nc_free_termtype
2962 void    _nc_free_termtype(
2963                 TERMTYPE *ptr)
2964                 { /* void */ }
2965
2966 #undef _nc_user_definable
2967 NCURSES_BOOL _nc_user_definable;
2968
2969 #undef use_extended_names
2970 int     use_extended_names(
2971                 NCURSES_BOOL flag)
2972                 { return(*(int *)0); }
2973
2974 /* ./tinfo/getenv_num.c */
2975
2976 #undef _nc_getenv_num
2977 int     _nc_getenv_num(
2978                 const char *name)
2979                 { return(*(int *)0); }
2980
2981 #undef _nc_setenv_num
2982 void    _nc_setenv_num(
2983                 const char *name,
2984                 int     value)
2985                 { /* void */ }
2986
2987 /* ./tinfo/home_terminfo.c */
2988
2989 #undef _nc_home_terminfo
2990 char    *_nc_home_terminfo(void)
2991                 { return(*(char **)0); }
2992
2993 /* ./tinfo/init_keytry.c */
2994
2995 #undef _nc_init_keytry
2996 void    _nc_init_keytry(
2997                 SCREEN  *sp)
2998                 { /* void */ }
2999
3000 /* ./tinfo/lib_acs.c */
3001
3002 #undef _nc_acs_map
3003 chtype  *_nc_acs_map(void)
3004                 { return(*(chtype **)0); }
3005
3006 #undef _nc_init_acs_sp
3007 void    _nc_init_acs_sp(
3008                 SCREEN  *sp)
3009                 { /* void */ }
3010
3011 #undef _nc_init_acs
3012 void    _nc_init_acs(void)
3013                 { /* void */ }
3014
3015 /* ./tinfo/lib_baudrate.c */
3016
3017 struct speed {
3018     short s;
3019     int sp;
3020 };
3021
3022 #undef _nc_baudrate
3023 int     _nc_baudrate(
3024                 int     OSpeed)
3025                 { return(*(int *)0); }
3026
3027 #undef _nc_ospeed
3028 int     _nc_ospeed(
3029                 int     BaudRate)
3030                 { return(*(int *)0); }
3031
3032 #undef baudrate_sp
3033 int     baudrate_sp(
3034                 SCREEN  *sp)
3035                 { return(*(int *)0); }
3036
3037 #undef baudrate
3038 int     baudrate(void)
3039                 { return(*(int *)0); }
3040
3041 /* ./tinfo/lib_cur_term.c */
3042
3043 #undef _nc_get_cur_term_sp
3044 TERMINAL *_nc_get_cur_term_sp(
3045                 SCREEN  *sp)
3046                 { return(*(TERMINAL **)0); }
3047
3048 #undef _nc_get_cur_term
3049 TERMINAL *_nc_get_cur_term(void)
3050                 { return(*(TERMINAL **)0); }
3051
3052 #undef _nc_cur_term
3053 TERMINAL *_nc_cur_term(void)
3054                 { return(*(TERMINAL **)0); }
3055
3056 #undef set_curterm_sp
3057 TERMINAL *set_curterm_sp(
3058                 SCREEN  *sp,
3059                 TERMINAL *termp)
3060                 { return(*(TERMINAL **)0); }
3061
3062 #undef set_curterm
3063 TERMINAL *set_curterm(
3064                 TERMINAL *termp)
3065                 { return(*(TERMINAL **)0); }
3066
3067 #undef del_curterm_sp
3068 int     del_curterm_sp(
3069                 SCREEN  *sp,
3070                 TERMINAL *termp)
3071                 { return(*(int *)0); }
3072
3073 #undef del_curterm
3074 int     del_curterm(
3075                 TERMINAL *termp)
3076                 { return(*(int *)0); }
3077
3078 /* ./tinfo/lib_data.c */
3079
3080 #undef _nc_stdscr
3081 WINDOW  *_nc_stdscr(void)
3082                 { return(*(WINDOW **)0); }
3083
3084 #undef _nc_curscr
3085 WINDOW  *_nc_curscr(void)
3086                 { return(*(WINDOW **)0); }
3087
3088 #undef _nc_newscr
3089 WINDOW  *_nc_newscr(void)
3090                 { return(*(WINDOW **)0); }
3091
3092 #undef _nc_screen_chain
3093 SCREEN  *_nc_screen_chain;
3094 #undef SP
3095 SCREEN  *SP;
3096 #undef _nc_globals
3097 NCURSES_GLOBALS _nc_globals;
3098 #undef _nc_prescreen
3099 NCURSES_PRESCREEN _nc_prescreen;
3100
3101 #undef _nc_screen_of
3102 SCREEN  *_nc_screen_of(
3103                 WINDOW  *win)
3104                 { return(*(SCREEN **)0); }
3105
3106 #undef _nc_init_pthreads
3107 void    _nc_init_pthreads(void)
3108                 { /* void */ }
3109
3110 #undef _nc_mutex_init
3111 void    _nc_mutex_init(
3112                 pthread_mutex_t *obj)
3113                 { /* void */ }
3114
3115 #undef _nc_mutex_lock
3116 int     _nc_mutex_lock(
3117                 pthread_mutex_t *obj)
3118                 { return(*(int *)0); }
3119
3120 #undef _nc_mutex_trylock
3121 int     _nc_mutex_trylock(
3122                 pthread_mutex_t *obj)
3123                 { return(*(int *)0); }
3124
3125 #undef _nc_mutex_unlock
3126 int     _nc_mutex_unlock(
3127                 pthread_mutex_t *obj)
3128                 { return(*(int *)0); }
3129
3130 /* ./tinfo/lib_has_cap.c */
3131
3132 #undef has_ic_sp
3133 NCURSES_BOOL has_ic_sp(
3134                 SCREEN  *sp)
3135                 { return(*(NCURSES_BOOL *)0); }
3136
3137 #undef has_ic
3138 NCURSES_BOOL has_ic(void)
3139                 { return(*(NCURSES_BOOL *)0); }
3140
3141 #undef has_il_sp
3142 NCURSES_BOOL has_il_sp(
3143                 SCREEN  *sp)
3144                 { return(*(NCURSES_BOOL *)0); }
3145
3146 #undef has_il
3147 NCURSES_BOOL has_il(void)
3148                 { return(*(NCURSES_BOOL *)0); }
3149
3150 /* ./tinfo/lib_kernel.c */
3151
3152 #undef erasechar_sp
3153 char    erasechar_sp(
3154                 SCREEN  *sp)
3155                 { return(*(char *)0); }
3156
3157 #undef erasechar
3158 char    erasechar(void)
3159                 { return(*(char *)0); }
3160
3161 #undef killchar_sp
3162 char    killchar_sp(
3163                 SCREEN  *sp)
3164                 { return(*(char *)0); }
3165
3166 #undef killchar
3167 char    killchar(void)
3168                 { return(*(char *)0); }
3169
3170 #undef flushinp_sp
3171 int     flushinp_sp(
3172                 SCREEN  *sp)
3173                 { return(*(int *)0); }
3174
3175 #undef flushinp
3176 int     flushinp(void)
3177                 { return(*(int *)0); }
3178
3179 /* ./lib_keyname.c */
3180
3181 struct kn { short offset; int code; };
3182
3183 #undef keyname_sp
3184 const char *keyname_sp(
3185                 SCREEN  *sp,
3186                 int     c)
3187                 { return(*(const char **)0); }
3188
3189 #undef keyname
3190 const char *keyname(
3191                 int     c)
3192                 { return(*(const char **)0); }
3193
3194 /* ./tinfo/lib_longname.c */
3195
3196 #undef longname_sp
3197 char    *longname_sp(
3198                 SCREEN  *sp)
3199                 { return(*(char **)0); }
3200
3201 #undef longname
3202 char    *longname(void)
3203                 { return(*(char **)0); }
3204
3205 /* ./tinfo/lib_napms.c */
3206
3207 #undef napms_sp
3208 int     napms_sp(
3209                 SCREEN  *sp,
3210                 int     ms)
3211                 { return(*(int *)0); }
3212
3213 #undef napms
3214 int     napms(
3215                 int     ms)
3216                 { return(*(int *)0); }
3217
3218 /* ./tinfo/lib_options.c */
3219
3220 #undef idlok
3221 int     idlok(
3222                 WINDOW  *win,
3223                 NCURSES_BOOL flag)
3224                 { return(*(int *)0); }
3225
3226 #undef idcok
3227 void    idcok(
3228                 WINDOW  *win,
3229                 NCURSES_BOOL flag)
3230                 { /* void */ }
3231
3232 #undef halfdelay_sp
3233 int     halfdelay_sp(
3234                 SCREEN  *sp,
3235                 int     t)
3236                 { return(*(int *)0); }
3237
3238 #undef halfdelay
3239 int     halfdelay(
3240                 int     t)
3241                 { return(*(int *)0); }
3242
3243 #undef nodelay
3244 int     nodelay(
3245                 WINDOW  *win,
3246                 NCURSES_BOOL flag)
3247                 { return(*(int *)0); }
3248
3249 #undef notimeout
3250 int     notimeout(
3251                 WINDOW  *win,
3252                 NCURSES_BOOL f)
3253                 { return(*(int *)0); }
3254
3255 #undef wtimeout
3256 void    wtimeout(
3257                 WINDOW  *win,
3258                 int     delay)
3259                 { /* void */ }
3260
3261 #undef keypad
3262 int     keypad(
3263                 WINDOW  *win,
3264                 NCURSES_BOOL flag)
3265                 { return(*(int *)0); }
3266
3267 #undef meta
3268 int     meta(
3269                 WINDOW  *win,
3270                 NCURSES_BOOL flag)
3271                 { return(*(int *)0); }
3272
3273 #undef curs_set_sp
3274 int     curs_set_sp(
3275                 SCREEN  *sp,
3276                 int     vis)
3277                 { return(*(int *)0); }
3278
3279 #undef curs_set
3280 int     curs_set(
3281                 int     vis)
3282                 { return(*(int *)0); }
3283
3284 #undef typeahead_sp
3285 int     typeahead_sp(
3286                 SCREEN  *sp,
3287                 int     fd)
3288                 { return(*(int *)0); }
3289
3290 #undef typeahead
3291 int     typeahead(
3292                 int     fd)
3293                 { return(*(int *)0); }
3294
3295 #undef has_key_sp
3296 int     has_key_sp(
3297                 SCREEN  *sp,
3298                 int     keycode)
3299                 { return(*(int *)0); }
3300
3301 #undef has_key
3302 int     has_key(
3303                 int     keycode)
3304                 { return(*(int *)0); }
3305
3306 #undef _nc_putp_flush_sp
3307 int     _nc_putp_flush_sp(
3308                 SCREEN  *sp,
3309                 const char *name,
3310                 const char *value)
3311                 { return(*(int *)0); }
3312
3313 #undef _nc_keypad
3314 int     _nc_keypad(
3315                 SCREEN  *sp,
3316                 int     flag)
3317                 { return(*(int *)0); }
3318
3319 /* ./tinfo/lib_raw.c */
3320
3321 #undef raw_sp
3322 int     raw_sp(
3323                 SCREEN  *sp)
3324                 { return(*(int *)0); }
3325
3326 #undef raw
3327 int     raw(void)
3328                 { return(*(int *)0); }
3329
3330 #undef cbreak_sp
3331 int     cbreak_sp(
3332                 SCREEN  *sp)
3333                 { return(*(int *)0); }
3334
3335 #undef cbreak
3336 int     cbreak(void)
3337                 { return(*(int *)0); }
3338
3339 #undef qiflush_sp
3340 void    qiflush_sp(
3341                 SCREEN  *sp)
3342                 { /* void */ }
3343
3344 #undef qiflush
3345 void    qiflush(void)
3346                 { /* void */ }
3347
3348 #undef noraw_sp
3349 int     noraw_sp(
3350                 SCREEN  *sp)
3351                 { return(*(int *)0); }
3352
3353 #undef noraw
3354 int     noraw(void)
3355                 { return(*(int *)0); }
3356
3357 #undef nocbreak_sp
3358 int     nocbreak_sp(
3359                 SCREEN  *sp)
3360                 { return(*(int *)0); }
3361
3362 #undef nocbreak
3363 int     nocbreak(void)
3364                 { return(*(int *)0); }
3365
3366 #undef noqiflush_sp
3367 void    noqiflush_sp(
3368                 SCREEN  *sp)
3369                 { /* void */ }
3370
3371 #undef noqiflush
3372 void    noqiflush(void)
3373                 { /* void */ }
3374
3375 #undef intrflush_sp
3376 int     intrflush_sp(
3377                 SCREEN  *sp,
3378                 WINDOW  *win,
3379                 NCURSES_BOOL flag)
3380                 { return(*(int *)0); }
3381
3382 #undef intrflush
3383 int     intrflush(
3384                 WINDOW  *win,
3385                 NCURSES_BOOL flag)
3386                 { return(*(int *)0); }
3387
3388 /* ./tinfo/lib_setup.c */
3389
3390 #undef _nc_ttytype
3391 char    *_nc_ttytype(void)
3392                 { return(*(char **)0); }
3393
3394 #undef _nc_ptr_Lines
3395 int     *_nc_ptr_Lines(
3396                 SCREEN  *sp)
3397                 { return(*(int **)0); }
3398
3399 #undef _nc_LINES
3400 int     _nc_LINES(void)
3401                 { return(*(int *)0); }
3402
3403 #undef _nc_ptr_Cols
3404 int     *_nc_ptr_Cols(
3405                 SCREEN  *sp)
3406                 { return(*(int **)0); }
3407
3408 #undef _nc_COLS
3409 int     _nc_COLS(void)
3410                 { return(*(int *)0); }
3411
3412 #undef _nc_ptr_Tabsize
3413 int     *_nc_ptr_Tabsize(
3414                 SCREEN  *sp)
3415                 { return(*(int **)0); }
3416
3417 #undef _nc_TABSIZE
3418 int     _nc_TABSIZE(void)
3419                 { return(*(int *)0); }
3420
3421 #undef set_tabsize_sp
3422 int     set_tabsize_sp(
3423                 SCREEN  *sp,
3424                 int     value)
3425                 { return(*(int *)0); }
3426
3427 #undef set_tabsize
3428 int     set_tabsize(
3429                 int     value)
3430                 { return(*(int *)0); }
3431
3432 #undef _nc_handle_sigwinch
3433 int     _nc_handle_sigwinch(
3434                 SCREEN  *sp)
3435                 { return(*(int *)0); }
3436
3437 #undef use_env_sp
3438 void    use_env_sp(
3439                 SCREEN  *sp,
3440                 NCURSES_BOOL f)
3441                 { /* void */ }
3442
3443 #undef use_tioctl_sp
3444 void    use_tioctl_sp(
3445                 SCREEN  *sp,
3446                 NCURSES_BOOL f)
3447                 { /* void */ }
3448
3449 #undef use_env
3450 void    use_env(
3451                 NCURSES_BOOL f)
3452                 { /* void */ }
3453
3454 #undef use_tioctl
3455 void    use_tioctl(
3456                 NCURSES_BOOL f)
3457                 { /* void */ }
3458
3459 #undef _nc_get_screensize
3460 void    _nc_get_screensize(
3461                 SCREEN  *sp,
3462                 int     *linep,
3463                 int     *colp)
3464                 { /* void */ }
3465
3466 #undef _nc_update_screensize
3467 void    _nc_update_screensize(
3468                 SCREEN  *sp)
3469                 { /* void */ }
3470
3471 #undef _nc_setup_tinfo
3472 int     _nc_setup_tinfo(
3473                 const char *const tn,
3474                 TERMTYPE *const tp)
3475                 { return(*(int *)0); }
3476
3477 #undef _nc_tinfo_cmdch
3478 void    _nc_tinfo_cmdch(
3479                 TERMINAL *termp,
3480                 int     proto)
3481                 { /* void */ }
3482
3483 #undef _nc_get_locale
3484 char    *_nc_get_locale(void)
3485                 { return(*(char **)0); }
3486
3487 #undef _nc_unicode_locale
3488 int     _nc_unicode_locale(void)
3489                 { return(*(int *)0); }
3490
3491 #undef _nc_locale_breaks_acs
3492 int     _nc_locale_breaks_acs(
3493                 TERMINAL *termp)
3494                 { return(*(int *)0); }
3495
3496 #undef _nc_setupterm
3497 int     _nc_setupterm(
3498                 const char *tname,
3499                 int     Filedes,
3500                 int     *errret,
3501                 int     reuse)
3502                 { return(*(int *)0); }
3503
3504 #undef new_prescr
3505 SCREEN  *new_prescr(void)
3506                 { return(*(SCREEN **)0); }
3507
3508 #undef setupterm
3509 int     setupterm(
3510                 const char *tname,
3511                 int     Filedes,
3512                 int     *errret)
3513                 { return(*(int *)0); }
3514
3515 /* ./tinfo/lib_termcap.c */
3516
3517 #undef UP
3518 char    *UP;
3519 #undef BC
3520 char    *BC;
3521
3522 #undef tgetent_sp
3523 int     tgetent_sp(
3524                 SCREEN  *sp,
3525                 char    *bufp,
3526                 const char *name)
3527                 { return(*(int *)0); }
3528
3529 #undef tgetent
3530 int     tgetent(
3531                 char    *bufp,
3532                 const char *name)
3533                 { return(*(int *)0); }
3534
3535 #undef tgetflag_sp
3536 int     tgetflag_sp(
3537                 SCREEN  *sp,
3538                 const char *id)
3539                 { return(*(int *)0); }
3540
3541 #undef tgetflag
3542 int     tgetflag(
3543                 const char *id)
3544                 { return(*(int *)0); }
3545
3546 #undef tgetnum_sp
3547 int     tgetnum_sp(
3548                 SCREEN  *sp,
3549                 const char *id)
3550                 { return(*(int *)0); }
3551
3552 #undef tgetnum
3553 int     tgetnum(
3554                 const char *id)
3555                 { return(*(int *)0); }
3556
3557 #undef tgetstr_sp
3558 char    *tgetstr_sp(
3559                 SCREEN  *sp,
3560                 const char *id,
3561                 char    **area)
3562                 { return(*(char **)0); }
3563
3564 #undef tgetstr
3565 char    *tgetstr(
3566                 const char *id,
3567                 char    **area)
3568                 { return(*(char **)0); }
3569
3570 /* ./tinfo/lib_termname.c */
3571
3572 #undef termname_sp
3573 char    *termname_sp(
3574                 SCREEN  *sp)
3575                 { return(*(char **)0); }
3576
3577 #undef termname
3578 char    *termname(void)
3579                 { return(*(char **)0); }
3580
3581 /* ./tinfo/lib_tgoto.c */
3582
3583 #undef tgoto
3584 char    *tgoto(
3585                 const char *string,
3586                 int     x,
3587                 int     y)
3588                 { return(*(char **)0); }
3589
3590 /* ./tinfo/lib_ti.c */
3591
3592 #undef tigetflag_sp
3593 int     tigetflag_sp(
3594                 SCREEN  *sp,
3595                 const char *str)
3596                 { return(*(int *)0); }
3597
3598 #undef tigetflag
3599 int     tigetflag(
3600                 const char *str)
3601                 { return(*(int *)0); }
3602
3603 #undef tigetnum_sp
3604 int     tigetnum_sp(
3605                 SCREEN  *sp,
3606                 const char *str)
3607                 { return(*(int *)0); }
3608
3609 #undef tigetnum
3610 int     tigetnum(
3611                 const char *str)
3612                 { return(*(int *)0); }
3613
3614 #undef tigetstr_sp
3615 char    *tigetstr_sp(
3616                 SCREEN  *sp,
3617                 const char *str)
3618                 { return(*(char **)0); }
3619
3620 #undef tigetstr
3621 char    *tigetstr(
3622                 const char *str)
3623                 { return(*(char **)0); }
3624
3625 /* ./tinfo/lib_tparm.c */
3626
3627 #undef _nc_tparm_err
3628 int     _nc_tparm_err;
3629
3630 #undef _nc_tparm_analyze
3631 int     _nc_tparm_analyze(
3632                 const char *string,
3633                 char    *p_is_s[9],
3634                 int     *_nc_popcount)
3635                 { return(*(int *)0); }
3636
3637 #undef tparm
3638 char    *tparm(
3639                 const char *string,
3640                 ...)
3641                 { return(*(char **)0); }
3642
3643 #undef tiparm
3644 char    *tiparm(
3645                 const char *string,
3646                 ...)
3647                 { return(*(char **)0); }
3648
3649 /* ./tinfo/lib_tputs.c */
3650
3651 #undef PC
3652 char    PC;
3653 #undef ospeed
3654 short   ospeed;
3655 #undef _nc_nulls_sent
3656 int     _nc_nulls_sent;
3657
3658 #undef _nc_set_no_padding
3659 void    _nc_set_no_padding(
3660                 SCREEN  *sp)
3661                 { /* void */ }
3662
3663 #undef delay_output_sp
3664 int     delay_output_sp(
3665                 SCREEN  *sp,
3666                 int     ms)
3667                 { return(*(int *)0); }
3668
3669 #undef delay_output
3670 int     delay_output(
3671                 int     ms)
3672                 { return(*(int *)0); }
3673
3674 #undef _nc_flush_sp
3675 void    _nc_flush_sp(
3676                 SCREEN  *sp)
3677                 { /* void */ }
3678
3679 #undef _nc_flush
3680 void    _nc_flush(void)
3681                 { /* void */ }
3682
3683 #undef _nc_outch_sp
3684 int     _nc_outch_sp(
3685                 SCREEN  *sp,
3686                 int     ch)
3687                 { return(*(int *)0); }
3688
3689 #undef _nc_outch
3690 int     _nc_outch(
3691                 int     ch)
3692                 { return(*(int *)0); }
3693
3694 #undef _nc_putchar_sp
3695 int     _nc_putchar_sp(
3696                 SCREEN  *sp,
3697                 int     ch)
3698                 { return(*(int *)0); }
3699
3700 #undef _nc_putchar
3701 int     _nc_putchar(
3702                 int     ch)
3703                 { return(*(int *)0); }
3704
3705 #undef putp_sp
3706 int     putp_sp(
3707                 SCREEN  *sp,
3708                 const char *string)
3709                 { return(*(int *)0); }
3710
3711 #undef putp
3712 int     putp(
3713                 const char *string)
3714                 { return(*(int *)0); }
3715
3716 #undef _nc_putp_sp
3717 int     _nc_putp_sp(
3718                 SCREEN  *sp,
3719                 const char *name,
3720                 const char *string)
3721                 { return(*(int *)0); }
3722
3723 #undef _nc_putp
3724 int     _nc_putp(
3725                 const char *name,
3726                 const char *string)
3727                 { return(*(int *)0); }
3728
3729 #undef tputs_sp
3730 int     tputs_sp(
3731                 SCREEN  *sp,
3732                 const char *string,
3733                 int     affcnt,
3734                 NCURSES_OUTC_sp outc)
3735                 { return(*(int *)0); }
3736
3737 #undef _nc_outc_wrapper
3738 int     _nc_outc_wrapper(
3739                 SCREEN  *sp,
3740                 int     c)
3741                 { return(*(int *)0); }
3742
3743 #undef tputs
3744 int     tputs(
3745                 const char *string,
3746                 int     affcnt,
3747                 int     (*outc)(
3748                 int     p1))
3749                 { return(*(int *)0); }
3750
3751 /* ./trace/lib_trace.c */
3752
3753 #undef _nc_tracing
3754 unsigned _nc_tracing;
3755
3756 #undef _nc__nc_tputs_trace
3757 const char *_nc__nc_tputs_trace(void)
3758                 { return(*(const char **)0); }
3759
3760 #undef _nc__nc_outchars
3761 long    _nc__nc_outchars(void)
3762                 { return(*(long *)0); }
3763
3764 #undef _nc_set_tputs_trace
3765 void    _nc_set_tputs_trace(
3766                 const char *s)
3767                 { /* void */ }
3768
3769 #undef _nc_count_outchars
3770 void    _nc_count_outchars(
3771                 long    increment)
3772                 { /* void */ }
3773
3774 #undef trace
3775 void    trace(
3776                 const unsigned int tracelevel)
3777                 { /* void */ }
3778
3779 #undef _tracef
3780 void    _tracef(
3781                 const char *fmt,
3782                 ...)
3783                 { /* void */ }
3784
3785 #undef _nc_retrace_bool
3786 NCURSES_BOOL _nc_retrace_bool(
3787                 int     code)
3788                 { return(*(NCURSES_BOOL *)0); }
3789
3790 #undef _nc_retrace_char
3791 char    _nc_retrace_char(
3792                 int     code)
3793                 { return(*(char *)0); }
3794
3795 #undef _nc_retrace_int
3796 int     _nc_retrace_int(
3797                 int     code)
3798                 { return(*(int *)0); }
3799
3800 #undef _nc_retrace_unsigned
3801 unsigned _nc_retrace_unsigned(
3802                 unsigned code)
3803                 { return(*(unsigned *)0); }
3804
3805 #undef _nc_retrace_ptr
3806 char    *_nc_retrace_ptr(
3807                 char    *code)
3808                 { return(*(char **)0); }
3809
3810 #undef _nc_retrace_cptr
3811 const char *_nc_retrace_cptr(
3812                 const char *code)
3813                 { return(*(const char **)0); }
3814
3815 #undef _nc_retrace_cvoid_ptr
3816 const void *_nc_retrace_cvoid_ptr(
3817                 const void *code)
3818                 { return(*(const void **)0); }
3819
3820 #undef _nc_retrace_void_ptr
3821 void    *_nc_retrace_void_ptr(
3822                 void    *code)
3823                 { return(*(void **)0); }
3824
3825 #undef _nc_retrace_sp
3826 SCREEN  *_nc_retrace_sp(
3827                 SCREEN  *code)
3828                 { return(*(SCREEN **)0); }
3829
3830 #undef _nc_retrace_win
3831 WINDOW  *_nc_retrace_win(
3832                 WINDOW  *code)
3833                 { return(*(WINDOW **)0); }
3834
3835 #undef _nc_use_tracef
3836 int     _nc_use_tracef(
3837                 unsigned mask)
3838                 { return(*(int *)0); }
3839
3840 #undef _nc_locked_tracef
3841 void    _nc_locked_tracef(
3842                 const char *fmt,
3843                 ...)
3844                 { /* void */ }
3845
3846 /* ./trace/lib_traceatr.c */
3847
3848 #undef _traceattr2
3849 char    *_traceattr2(
3850                 int     bufnum,
3851                 chtype  newmode)
3852                 { return(*(char **)0); }
3853
3854 #undef _traceattr
3855 char    *_traceattr(
3856                 attr_t  newmode)
3857                 { return(*(char **)0); }
3858
3859 #undef _nc_retrace_int_attr_t
3860 int     _nc_retrace_int_attr_t(
3861                 attr_t  code)
3862                 { return(*(int *)0); }
3863
3864 #undef _nc_retrace_attr_t
3865 attr_t  _nc_retrace_attr_t(
3866                 attr_t  code)
3867                 { return(*(attr_t *)0); }
3868
3869 #undef _nc_altcharset_name
3870 const char *_nc_altcharset_name(
3871                 attr_t  attr,
3872                 chtype  ch)
3873                 { return(*(const char **)0); }
3874
3875 #undef _tracechtype2
3876 char    *_tracechtype2(
3877                 int     bufnum,
3878                 chtype  ch)
3879                 { return(*(char **)0); }
3880
3881 #undef _tracechtype
3882 char    *_tracechtype(
3883                 chtype  ch)
3884                 { return(*(char **)0); }
3885
3886 #undef _nc_retrace_chtype
3887 chtype  _nc_retrace_chtype(
3888                 chtype  code)
3889                 { return(*(chtype *)0); }
3890
3891 /* ./trace/lib_tracebits.c */
3892
3893 #undef _nc_trace_ttymode
3894 char    *_nc_trace_ttymode(
3895                 struct termios *tty)
3896                 { return(*(char **)0); }
3897
3898 #undef _nc_tracebits
3899 char    *_nc_tracebits(void)
3900                 { return(*(char **)0); }
3901
3902 /* ./trace/lib_tracechr.c */
3903
3904 #undef _nc_tracechar
3905 char    *_nc_tracechar(
3906                 SCREEN  *sp,
3907                 int     ch)
3908                 { return(*(char **)0); }
3909
3910 #undef _tracechar
3911 char    *_tracechar(
3912                 int     ch)
3913                 { return(*(char **)0); }
3914
3915 /* ./tinfo/lib_ttyflags.c */
3916
3917 #undef _nc_get_tty_mode_sp
3918 int     _nc_get_tty_mode_sp(
3919                 SCREEN  *sp,
3920                 struct termios *buf)
3921                 { return(*(int *)0); }
3922
3923 #undef _nc_get_tty_mode
3924 int     _nc_get_tty_mode(
3925                 struct termios *buf)
3926                 { return(*(int *)0); }
3927
3928 #undef _nc_set_tty_mode_sp
3929 int     _nc_set_tty_mode_sp(
3930                 SCREEN  *sp,
3931                 struct termios *buf)
3932                 { return(*(int *)0); }
3933
3934 #undef _nc_set_tty_mode
3935 int     _nc_set_tty_mode(
3936                 struct termios *buf)
3937                 { return(*(int *)0); }
3938
3939 #undef def_shell_mode_sp
3940 int     def_shell_mode_sp(
3941                 SCREEN  *sp)
3942                 { return(*(int *)0); }
3943
3944 #undef def_shell_mode
3945 int     def_shell_mode(void)
3946                 { return(*(int *)0); }
3947
3948 #undef def_prog_mode_sp
3949 int     def_prog_mode_sp(
3950                 SCREEN  *sp)
3951                 { return(*(int *)0); }
3952
3953 #undef def_prog_mode
3954 int     def_prog_mode(void)
3955                 { return(*(int *)0); }
3956
3957 #undef reset_prog_mode_sp
3958 int     reset_prog_mode_sp(
3959                 SCREEN  *sp)
3960                 { return(*(int *)0); }
3961
3962 #undef reset_prog_mode
3963 int     reset_prog_mode(void)
3964                 { return(*(int *)0); }
3965
3966 #undef reset_shell_mode_sp
3967 int     reset_shell_mode_sp(
3968                 SCREEN  *sp)
3969                 { return(*(int *)0); }
3970
3971 #undef reset_shell_mode
3972 int     reset_shell_mode(void)
3973                 { return(*(int *)0); }
3974
3975 #undef savetty_sp
3976 int     savetty_sp(
3977                 SCREEN  *sp)
3978                 { return(*(int *)0); }
3979
3980 #undef savetty
3981 int     savetty(void)
3982                 { return(*(int *)0); }
3983
3984 #undef resetty_sp
3985 int     resetty_sp(
3986                 SCREEN  *sp)
3987                 { return(*(int *)0); }
3988
3989 #undef resetty
3990 int     resetty(void)
3991                 { return(*(int *)0); }
3992
3993 /* ./tty/lib_twait.c */
3994
3995 #undef _nc_timed_wait
3996 int     _nc_timed_wait(
3997                 SCREEN  *sp,
3998                 int     mode,
3999                 int     milliseconds,
4000                 int     *timeleft)
4001                 { return(*(int *)0); }
4002
4003 /* ./tinfo/name_match.c */
4004
4005 #undef _nc_first_name
4006 char    *_nc_first_name(
4007                 const char *const sp)
4008                 { return(*(char **)0); }
4009
4010 #undef _nc_name_match
4011 int     _nc_name_match(
4012                 const char *const namelst,
4013                 const char *const name,
4014                 const char *const delim)
4015                 { return(*(int *)0); }
4016
4017 /* ./names.c */
4018
4019 #undef _nc_boolnames
4020 const char *const *_nc_boolnames(void)
4021                 { return(*(const char **)0); }
4022
4023 #undef _nc_boolfnames
4024 const char *const *_nc_boolfnames(void)
4025                 { return(*(const char **)0); }
4026
4027 #undef _nc_numnames
4028 const char *const *_nc_numnames(void)
4029                 { return(*(const char **)0); }
4030
4031 #undef _nc_numfnames
4032 const char *const *_nc_numfnames(void)
4033                 { return(*(const char **)0); }
4034
4035 #undef _nc_strnames
4036 const char *const *_nc_strnames(void)
4037                 { return(*(const char **)0); }
4038
4039 #undef _nc_strfnames
4040 const char *const *_nc_strfnames(void)
4041                 { return(*(const char **)0); }
4042
4043 /* ./tinfo/obsolete.c */
4044
4045 #undef _nc_set_buffer_sp
4046 void    _nc_set_buffer_sp(
4047                 SCREEN  *sp,
4048                 FILE    *ofp,
4049                 int     buffered)
4050                 { /* void */ }
4051
4052 #undef _nc_set_buffer
4053 void    _nc_set_buffer(
4054                 FILE    *ofp,
4055                 int     buffered)
4056                 { /* void */ }
4057
4058 /* ./tinfo/read_entry.c */
4059
4060 #undef _nc_init_termtype
4061 void    _nc_init_termtype(
4062                 TERMTYPE *const tp)
4063                 { /* void */ }
4064
4065 #undef _nc_read_termtype
4066 int     _nc_read_termtype(
4067                 TERMTYPE *ptr,
4068                 char    *buffer,
4069                 int     limit)
4070                 { return(*(int *)0); }
4071
4072 #undef _nc_read_file_entry
4073 int     _nc_read_file_entry(
4074                 const char *const filename,
4075                 TERMTYPE *ptr)
4076                 { return(*(int *)0); }
4077
4078 #undef _nc_read_entry
4079 int     _nc_read_entry(
4080                 const char *const name,
4081                 char    *const filename,
4082                 TERMTYPE *const tp)
4083                 { return(*(int *)0); }
4084
4085 /* ./tinfo/read_termcap.c */
4086
4087 #undef _nc_read_termcap_entry
4088 int     _nc_read_termcap_entry(
4089                 const char *const tn,
4090                 TERMTYPE *const tp)
4091                 { return(*(int *)0); }
4092
4093 /* ./tinfo/strings.c */
4094
4095 #undef _nc_str_init
4096 string_desc *_nc_str_init(
4097                 string_desc *dst,
4098                 char    *src,
4099                 size_t  len)
4100                 { return(*(string_desc **)0); }
4101
4102 #undef _nc_str_null
4103 string_desc *_nc_str_null(
4104                 string_desc *dst,
4105                 size_t  len)
4106                 { return(*(string_desc **)0); }
4107
4108 #undef _nc_str_copy
4109 string_desc *_nc_str_copy(
4110                 string_desc *dst,
4111                 string_desc *src)
4112                 { return(*(string_desc **)0); }
4113
4114 #undef _nc_safe_strcat
4115 NCURSES_BOOL _nc_safe_strcat(
4116                 string_desc *dst,
4117                 const char *src)
4118                 { return(*(NCURSES_BOOL *)0); }
4119
4120 #undef _nc_safe_strcpy
4121 NCURSES_BOOL _nc_safe_strcpy(
4122                 string_desc *dst,
4123                 const char *src)
4124                 { return(*(NCURSES_BOOL *)0); }
4125
4126 /* ./trace/trace_buf.c */
4127
4128 #undef _nc_trace_buf
4129 char    *_nc_trace_buf(
4130                 int     bufnum,
4131                 size_t  want)
4132                 { return(*(char **)0); }
4133
4134 #undef _nc_trace_bufcat
4135 char    *_nc_trace_bufcat(
4136                 int     bufnum,
4137                 const char *value)
4138                 { return(*(char **)0); }
4139
4140 /* ./trace/trace_tries.c */
4141
4142 #undef _nc_trace_tries
4143 void    _nc_trace_tries(
4144                 TRIES   *tree)
4145                 { /* void */ }
4146
4147 /* ./base/tries.c */
4148
4149 #undef _nc_expand_try
4150 char    *_nc_expand_try(
4151                 TRIES   *tree,
4152                 unsigned code,
4153                 int     *count,
4154                 size_t  len)
4155                 { return(*(char **)0); }
4156
4157 #undef _nc_remove_key
4158 int     _nc_remove_key(
4159                 TRIES   **tree,
4160                 unsigned code)
4161                 { return(*(int *)0); }
4162
4163 #undef _nc_remove_string
4164 int     _nc_remove_string(
4165                 TRIES   **tree,
4166                 const char *string)
4167                 { return(*(int *)0); }
4168
4169 /* ./tinfo/trim_sgr0.c */
4170
4171 #undef _nc_trim_sgr0
4172 char    *_nc_trim_sgr0(
4173                 TERMTYPE *tp)
4174                 { return(*(char **)0); }
4175
4176 /* ./unctrl.c */
4177
4178 #undef unctrl_sp
4179 const char *unctrl_sp(
4180                 SCREEN  *sp,
4181                 chtype  ch)
4182                 { return(*(const char **)0); }
4183
4184 #undef unctrl
4185 const char *unctrl(
4186                 chtype  ch)
4187                 { return(*(const char **)0); }
4188
4189 /* ./trace/visbuf.c */
4190
4191 #undef _nc_visbuf2
4192 const char *_nc_visbuf2(
4193                 int     bufnum,
4194                 const char *buf)
4195                 { return(*(const char **)0); }
4196
4197 #undef _nc_visbuf
4198 const char *_nc_visbuf(
4199                 const char *buf)
4200                 { return(*(const char **)0); }
4201
4202 #undef _nc_visbufn
4203 const char *_nc_visbufn(
4204                 const char *buf,
4205                 int     len)
4206                 { return(*(const char **)0); }
4207
4208 #undef _nc_viscbuf2
4209 const char *_nc_viscbuf2(
4210                 int     bufnum,
4211                 const chtype *buf,
4212                 int     len)
4213                 { return(*(const char **)0); }
4214
4215 #undef _nc_viscbuf
4216 const char *_nc_viscbuf(
4217                 const chtype *buf,
4218                 int     len)
4219                 { return(*(const char **)0); }
4220
4221 /* ./tinfo/alloc_entry.c */
4222
4223 #undef _nc_init_entry
4224 void    _nc_init_entry(
4225                 TERMTYPE *const tp)
4226                 { /* void */ }
4227
4228 #undef _nc_copy_entry
4229 ENTRY   *_nc_copy_entry(
4230                 ENTRY   *oldp)
4231                 { return(*(ENTRY **)0); }
4232
4233 #undef _nc_save_str
4234 char    *_nc_save_str(
4235                 const char *const string)
4236                 { return(*(char **)0); }
4237
4238 #undef _nc_wrap_entry
4239 void    _nc_wrap_entry(
4240                 ENTRY   *const ep,
4241                 NCURSES_BOOL copy_strings)
4242                 { /* void */ }
4243
4244 #undef _nc_merge_entry
4245 void    _nc_merge_entry(
4246                 TERMTYPE *const to,
4247                 TERMTYPE *const from)
4248                 { /* void */ }
4249
4250 /* ./tinfo/captoinfo.c */
4251
4252 #undef _nc_captoinfo
4253 char    *_nc_captoinfo(
4254                 const char *cap,
4255                 const char *s,
4256                 int const parameterized)
4257                 { return(*(char **)0); }
4258
4259 #undef _nc_infotocap
4260 char    *_nc_infotocap(
4261                 const char *cap,
4262                 const char *str,
4263                 int const parameterized)
4264                 { return(*(char **)0); }
4265
4266 /* ./tinfo/comp_expand.c */
4267
4268 #undef _nc_tic_expand
4269 char    *_nc_tic_expand(
4270                 const char *srcp,
4271                 NCURSES_BOOL tic_format,
4272                 int     numbers)
4273                 { return(*(char **)0); }
4274
4275 /* ./tinfo/comp_parse.c */
4276
4277 #undef _nc_check_termtype2
4278 void    (*_nc_check_termtype2)(
4279                 TERMTYPE *p1,
4280                 NCURSES_BOOL p2);
4281 #undef _nc_check_termtype
4282 void    (*_nc_check_termtype)(
4283                 TERMTYPE *p1);
4284
4285 #undef _nc_entry_match
4286 NCURSES_BOOL _nc_entry_match(
4287                 char    *n1,
4288                 char    *n2)
4289                 { return(*(NCURSES_BOOL *)0); }
4290
4291 #undef _nc_read_entry_source
4292 void    _nc_read_entry_source(
4293                 FILE    *fp,
4294                 char    *buf,
4295                 int     literal,
4296                 NCURSES_BOOL silent,
4297                 NCURSES_BOOL (*hook)(
4298                 ENTRY   *p1))
4299                 { /* void */ }
4300
4301 #undef _nc_resolve_uses2
4302 int     _nc_resolve_uses2(
4303                 NCURSES_BOOL fullresolve,
4304                 NCURSES_BOOL literal)
4305                 { return(*(int *)0); }
4306
4307 #undef _nc_resolve_uses
4308 int     _nc_resolve_uses(
4309                 NCURSES_BOOL fullresolve)
4310                 { return(*(int *)0); }
4311
4312 /* ./tinfo/comp_scan.c */
4313
4314 #undef _nc_syntax
4315 int     _nc_syntax;
4316 #undef _nc_strict_bsd
4317 int     _nc_strict_bsd;
4318 #undef _nc_curr_file_pos
4319 long    _nc_curr_file_pos;
4320 #undef _nc_comment_start
4321 long    _nc_comment_start;
4322 #undef _nc_comment_end
4323 long    _nc_comment_end;
4324 #undef _nc_start_line
4325 long    _nc_start_line;
4326 #undef _nc_curr_token
4327 struct token _nc_curr_token;
4328 #undef _nc_disable_period
4329 NCURSES_BOOL _nc_disable_period;
4330
4331 #undef _nc_reset_input
4332 void    _nc_reset_input(
4333                 FILE    *fp,
4334                 char    *buf)
4335                 { /* void */ }
4336
4337 #undef _nc_get_token
4338 int     _nc_get_token(
4339                 NCURSES_BOOL silent)
4340                 { return(*(int *)0); }
4341
4342 #undef _nc_trans_string
4343 int     _nc_trans_string(
4344                 char    *ptr,
4345                 char    *last)
4346                 { return(*(int *)0); }
4347
4348 #undef _nc_push_token
4349 void    _nc_push_token(
4350                 int     tokclass)
4351                 { /* void */ }
4352
4353 #undef _nc_panic_mode
4354 void    _nc_panic_mode(
4355                 char    ch)
4356                 { /* void */ }
4357
4358 /* ./tinfo/parse_entry.c */
4359
4360 #undef _nc_parse_entry
4361 int     _nc_parse_entry(
4362                 struct entry *entryp,
4363                 int     literal,
4364                 NCURSES_BOOL silent)
4365                 { return(*(int *)0); }
4366
4367 #undef _nc_capcmp
4368 int     _nc_capcmp(
4369                 const char *s,
4370                 const char *t)
4371                 { return(*(int *)0); }
4372
4373 /* ./tinfo/write_entry.c */
4374
4375 #undef _nc_set_writedir
4376 void    _nc_set_writedir(
4377                 const char *dir)
4378                 { /* void */ }
4379
4380 #undef _nc_write_entry
4381 void    _nc_write_entry(
4382                 TERMTYPE *const tp)
4383                 { /* void */ }
4384
4385 #undef _nc_tic_written
4386 int     _nc_tic_written(void)
4387                 { return(*(int *)0); }
4388
4389 /* ./base/define_key.c */
4390
4391 #undef define_key_sp
4392 int     define_key_sp(
4393                 SCREEN  *sp,
4394                 const char *str,
4395                 int     keycode)
4396                 { return(*(int *)0); }
4397
4398 #undef define_key
4399 int     define_key(
4400                 const char *str,
4401                 int     keycode)
4402                 { return(*(int *)0); }
4403
4404 /* ./tinfo/hashed_db.c */
4405
4406 #undef _nc_hashed_db
4407 void    _nc_hashed_db(void)
4408                 { /* void */ }
4409
4410 /* ./base/key_defined.c */
4411
4412 #undef key_defined_sp
4413 int     key_defined_sp(
4414                 SCREEN  *sp,
4415                 const char *str)
4416                 { return(*(int *)0); }
4417
4418 #undef key_defined
4419 int     key_defined(
4420                 const char *str)
4421                 { return(*(int *)0); }
4422
4423 /* ./base/keybound.c */
4424
4425 #undef keybound_sp
4426 char    *keybound_sp(
4427                 SCREEN  *sp,
4428                 int     code,
4429                 int     count)
4430                 { return(*(char **)0); }
4431
4432 #undef keybound
4433 char    *keybound(
4434                 int     code,
4435                 int     count)
4436                 { return(*(char **)0); }
4437
4438 /* ./base/keyok.c */
4439
4440 #undef keyok_sp
4441 int     keyok_sp(
4442                 SCREEN  *sp,
4443                 int     c,
4444                 NCURSES_BOOL flag)
4445                 { return(*(int *)0); }
4446
4447 #undef keyok
4448 int     keyok(
4449                 int     c,
4450                 NCURSES_BOOL flag)
4451                 { return(*(int *)0); }
4452
4453 /* ./base/version.c */
4454
4455 #undef curses_version
4456 const char *curses_version(void)
4457                 { return(*(const char **)0); }