ncurses/llib-lncursestw

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