ncurses/llib-lncursesw

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