ncurses/llib-lncurses

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