ncurses/llib-lncursestw

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