ncurses/llib-lncursest

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