ncurses/llib-lncursesw

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