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 #undef _nc_varargs
3032 char    *_nc_varargs(
3033                 const char *fmt,
3034                 va_list ap)
3035                 { return(*(char **)0); }
3036
3037 /* ./base/vsscanf.c */
3038
3039 #undef _nc_vsscanf
3040 void    _nc_vsscanf(void)
3041                 { /* void */ }
3042
3043 /* ./base/lib_freeall.c */
3044
3045 #undef _nc_freeall
3046 void    _nc_freeall(void)
3047                 { /* void */ }
3048
3049 #undef _nc_free_and_exit_sp
3050 void    _nc_free_and_exit_sp(
3051                 SCREEN  *sp,
3052                 int     code)
3053                 { /* void */ }
3054
3055 #undef _nc_free_and_exit
3056 void    _nc_free_and_exit(
3057                 int     code)
3058                 { /* void */ }
3059
3060 /* ./widechar/charable.c */
3061
3062 #undef _nc_is_charable
3063 NCURSES_BOOL _nc_is_charable(
3064                 wchar_t ch)
3065                 { return(*(NCURSES_BOOL *)0); }
3066
3067 #undef _nc_to_char
3068 int     _nc_to_char(
3069                 wint_t  ch)
3070                 { return(*(int *)0); }
3071
3072 #undef _nc_to_widechar
3073 wint_t  _nc_to_widechar(
3074                 int     ch)
3075                 { return(*(wint_t *)0); }
3076
3077 /* ./widechar/lib_add_wch.c */
3078
3079 #undef wadd_wch
3080 int     wadd_wch(
3081                 WINDOW  *win,
3082                 const cchar_t *wch)
3083                 { return(*(int *)0); }
3084
3085 #undef wecho_wchar
3086 int     wecho_wchar(
3087                 WINDOW  *win,
3088                 const cchar_t *wch)
3089                 { return(*(int *)0); }
3090
3091 /* ./widechar/lib_box_set.c */
3092
3093 #undef wborder_set
3094 int     wborder_set(
3095                 WINDOW  *win,
3096                 const cchar_t *ls,
3097                 const cchar_t *rs,
3098                 const cchar_t *ts,
3099                 const cchar_t *bs,
3100                 const cchar_t *tl,
3101                 const cchar_t *tr,
3102                 const cchar_t *bl,
3103                 const cchar_t *br)
3104                 { return(*(int *)0); }
3105
3106 /* ./widechar/lib_cchar.c */
3107
3108 #undef setcchar
3109 int     setcchar(
3110                 cchar_t *wcval,
3111                 const wchar_t *wch,
3112                 const attr_t attrs,
3113                 short   color_pair,
3114                 const void *opts)
3115                 { return(*(int *)0); }
3116
3117 #undef getcchar
3118 int     getcchar(
3119                 const cchar_t *wcval,
3120                 wchar_t *wch,
3121                 attr_t  *attrs,
3122                 short   *color_pair,
3123                 void    *opts)
3124                 { return(*(int *)0); }
3125
3126 /* ./widechar/lib_erasewchar.c */
3127
3128 #undef erasewchar
3129 int     erasewchar(
3130                 wchar_t *wch)
3131                 { return(*(int *)0); }
3132
3133 #undef killwchar
3134 int     killwchar(
3135                 wchar_t *wch)
3136                 { return(*(int *)0); }
3137
3138 /* ./widechar/lib_get_wch.c */
3139
3140 #undef wget_wch
3141 int     wget_wch(
3142                 WINDOW  *win,
3143                 wint_t  *result)
3144                 { return(*(int *)0); }
3145
3146 /* ./widechar/lib_get_wstr.c */
3147
3148 #undef wgetn_wstr
3149 int     wgetn_wstr(
3150                 WINDOW  *win,
3151                 wint_t  *str,
3152                 int     maxlen)
3153                 { return(*(int *)0); }
3154
3155 /* ./widechar/lib_hline_set.c */
3156
3157 #undef whline_set
3158 int     whline_set(
3159                 WINDOW  *win,
3160                 const cchar_t *ch,
3161                 int     n)
3162                 { return(*(int *)0); }
3163
3164 /* ./widechar/lib_in_wch.c */
3165
3166 #undef win_wch
3167 int     win_wch(
3168                 WINDOW  *win,
3169                 cchar_t *wcval)
3170                 { return(*(int *)0); }
3171
3172 /* ./widechar/lib_in_wchnstr.c */
3173
3174 #undef win_wchnstr
3175 int     win_wchnstr(
3176                 WINDOW  *win,
3177                 cchar_t *wchstr,
3178                 int     n)
3179                 { return(*(int *)0); }
3180
3181 /* ./widechar/lib_ins_wch.c */
3182
3183 #undef _nc_insert_wch
3184 int     _nc_insert_wch(
3185                 WINDOW  *win,
3186                 const cchar_t *wch)
3187                 { return(*(int *)0); }
3188
3189 #undef wins_wch
3190 int     wins_wch(
3191                 WINDOW  *win,
3192                 const cchar_t *wch)
3193                 { return(*(int *)0); }
3194
3195 #undef wins_nwstr
3196 int     wins_nwstr(
3197                 WINDOW  *win,
3198                 const wchar_t *wstr,
3199                 int     n)
3200                 { return(*(int *)0); }
3201
3202 /* ./widechar/lib_inwstr.c */
3203
3204 #undef winnwstr
3205 int     winnwstr(
3206                 WINDOW  *win,
3207                 wchar_t *wstr,
3208                 int     n)
3209                 { return(*(int *)0); }
3210
3211 #undef winwstr
3212 int     winwstr(
3213                 WINDOW  *win,
3214                 wchar_t *wstr)
3215                 { return(*(int *)0); }
3216
3217 /* ./widechar/lib_key_name.c */
3218
3219 #undef key_name
3220 const char *key_name(
3221                 wchar_t c)
3222                 { return(*(const char **)0); }
3223
3224 /* ./widechar/lib_pecho_wchar.c */
3225
3226 #undef pecho_wchar
3227 int     pecho_wchar(
3228                 WINDOW  *pad,
3229                 const cchar_t *wch)
3230                 { return(*(int *)0); }
3231
3232 /* ./widechar/lib_slk_wset.c */
3233
3234 #undef slk_wset
3235 int     slk_wset(
3236                 int     i,
3237                 const wchar_t *astr,
3238                 int     format)
3239                 { return(*(int *)0); }
3240
3241 /* ./widechar/lib_unget_wch.c */
3242
3243 #undef _nc_wcrtomb
3244 size_t  _nc_wcrtomb(
3245                 char    *target,
3246                 wchar_t source,
3247                 mbstate_t *state)
3248                 { return(*(size_t *)0); }
3249
3250 #undef unget_wch_sp
3251 int     unget_wch_sp(
3252                 SCREEN  *sp,
3253                 const wchar_t wch)
3254                 { return(*(int *)0); }
3255
3256 #undef unget_wch
3257 int     unget_wch(
3258                 const wchar_t wch)
3259                 { return(*(int *)0); }
3260
3261 /* ./widechar/lib_vid_attr.c */
3262
3263 #undef vid_puts_sp
3264 int     vid_puts_sp(
3265                 SCREEN  *sp,
3266                 attr_t  newmode,
3267                 short   pair,
3268                 void    *opts,
3269                 NCURSES_OUTC_sp outc)
3270                 { return(*(int *)0); }
3271
3272 #undef vid_puts
3273 int     vid_puts(
3274                 attr_t  newmode,
3275                 short   pair,
3276                 void    *opts,
3277                 NCURSES_OUTC outc)
3278                 { return(*(int *)0); }
3279
3280 #undef vid_attr_sp
3281 int     vid_attr_sp(
3282                 SCREEN  *sp,
3283                 attr_t  newmode,
3284                 short   pair,
3285                 void    *opts)
3286                 { return(*(int *)0); }
3287
3288 #undef vid_attr
3289 int     vid_attr(
3290                 attr_t  newmode,
3291                 short   pair,
3292                 void    *opts)
3293                 { return(*(int *)0); }
3294
3295 #undef term_attrs_sp
3296 attr_t  term_attrs_sp(
3297                 SCREEN  *sp)
3298                 { return(*(attr_t *)0); }
3299
3300 #undef term_attrs
3301 attr_t  term_attrs(void)
3302                 { return(*(attr_t *)0); }
3303
3304 /* ./widechar/lib_vline_set.c */
3305
3306 #undef wvline_set
3307 int     wvline_set(
3308                 WINDOW  *win,
3309                 const cchar_t *ch,
3310                 int     n)
3311                 { return(*(int *)0); }
3312
3313 /* ./widechar/lib_wacs.c */
3314
3315 #undef _nc_wacs
3316 cchar_t *_nc_wacs;
3317
3318 #undef _nc_init_wacs
3319 void    _nc_init_wacs(void)
3320                 { /* void */ }
3321
3322 /* ./widechar/lib_wunctrl.c */
3323
3324 #undef wunctrl_sp
3325 wchar_t *wunctrl_sp(
3326                 SCREEN  *sp,
3327                 cchar_t *wc)
3328                 { return(*(wchar_t **)0); }
3329
3330 #undef wunctrl
3331 wchar_t *wunctrl(
3332                 cchar_t *wc)
3333                 { return(*(wchar_t **)0); }
3334
3335 /* ./expanded.c */
3336
3337 #undef _nc_toggle_attr_on
3338 void    _nc_toggle_attr_on(
3339                 attr_t  *S,
3340                 attr_t  at)
3341                 { /* void */ }
3342
3343 #undef _nc_toggle_attr_off
3344 void    _nc_toggle_attr_off(
3345                 attr_t  *S,
3346                 attr_t  at)
3347                 { /* void */ }
3348
3349 #undef _nc_DelCharCost_sp
3350 int     _nc_DelCharCost_sp(
3351                 SCREEN  *sp,
3352                 int     count)
3353                 { return(*(int *)0); }
3354
3355 #undef _nc_InsCharCost_sp
3356 int     _nc_InsCharCost_sp(
3357                 SCREEN  *sp,
3358                 int     count)
3359                 { return(*(int *)0); }
3360
3361 #undef _nc_UpdateAttrs_sp
3362 void    _nc_UpdateAttrs_sp(
3363                 SCREEN  *sp,
3364                 const cchar_t *c)
3365                 { /* void */ }
3366
3367 #undef _nc_DelCharCost
3368 int     _nc_DelCharCost(
3369                 int     count)
3370                 { return(*(int *)0); }
3371
3372 #undef _nc_InsCharCost
3373 int     _nc_InsCharCost(
3374                 int     count)
3375                 { return(*(int *)0); }
3376
3377 #undef _nc_UpdateAttrs
3378 void    _nc_UpdateAttrs(
3379                 const cchar_t *c)
3380                 { /* void */ }
3381
3382 /* ./base/legacy_coding.c */
3383
3384 #undef use_legacy_coding_sp
3385 int     use_legacy_coding_sp(
3386                 SCREEN  *sp,
3387                 int     level)
3388                 { return(*(int *)0); }
3389
3390 #undef use_legacy_coding
3391 int     use_legacy_coding(
3392                 int     level)
3393                 { return(*(int *)0); }
3394
3395 /* ./base/lib_dft_fgbg.c */
3396
3397 #undef use_default_colors_sp
3398 int     use_default_colors_sp(
3399                 SCREEN  *sp)
3400                 { return(*(int *)0); }
3401
3402 #undef use_default_colors
3403 int     use_default_colors(void)
3404                 { return(*(int *)0); }
3405
3406 #undef assume_default_colors_sp
3407 int     assume_default_colors_sp(
3408                 SCREEN  *sp,
3409                 int     fg,
3410                 int     bg)
3411                 { return(*(int *)0); }
3412
3413 #undef assume_default_colors
3414 int     assume_default_colors(
3415                 int     fg,
3416                 int     bg)
3417                 { return(*(int *)0); }
3418
3419 /* ./tinfo/lib_print.c */
3420
3421 #undef mcprint_sp
3422 int     mcprint_sp(
3423                 SCREEN  *sp,
3424                 char    *data,
3425                 int     len)
3426                 { return(*(int *)0); }
3427
3428 #undef mcprint
3429 int     mcprint(
3430                 char    *data,
3431                 int     len)
3432                 { return(*(int *)0); }
3433
3434 /* ./base/resizeterm.c */
3435
3436 #undef is_term_resized_sp
3437 NCURSES_BOOL is_term_resized_sp(
3438                 SCREEN  *sp,
3439                 int     ToLines,
3440                 int     ToCols)
3441                 { return(*(NCURSES_BOOL *)0); }
3442
3443 #undef is_term_resized
3444 NCURSES_BOOL is_term_resized(
3445                 int     ToLines,
3446                 int     ToCols)
3447                 { return(*(NCURSES_BOOL *)0); }
3448
3449 #undef resize_term_sp
3450 int     resize_term_sp(
3451                 SCREEN  *sp,
3452                 int     ToLines,
3453                 int     ToCols)
3454                 { return(*(int *)0); }
3455
3456 #undef resize_term
3457 int     resize_term(
3458                 int     ToLines,
3459                 int     ToCols)
3460                 { return(*(int *)0); }
3461
3462 #undef resizeterm_sp
3463 int     resizeterm_sp(
3464                 SCREEN  *sp,
3465                 int     ToLines,
3466                 int     ToCols)
3467                 { return(*(int *)0); }
3468
3469 #undef resizeterm
3470 int     resizeterm(
3471                 int     ToLines,
3472                 int     ToCols)
3473                 { return(*(int *)0); }
3474
3475 /* ./trace/trace_xnames.c */
3476
3477 #undef _nc_trace_xnames
3478 void    _nc_trace_xnames(
3479                 TERMTYPE *tp)
3480                 { /* void */ }
3481
3482 /* ./tinfo/use_screen.c */
3483
3484 #undef use_screen
3485 int     use_screen(
3486                 SCREEN  *screen,
3487                 NCURSES_SCREEN_CB func,
3488                 void    *data)
3489                 { return(*(int *)0); }
3490
3491 /* ./base/use_window.c */
3492
3493 #undef use_window
3494 int     use_window(
3495                 WINDOW  *win,
3496                 NCURSES_WINDOW_CB func,
3497                 void    *data)
3498                 { return(*(int *)0); }
3499
3500 /* ./base/wresize.c */
3501
3502 #undef wresize
3503 int     wresize(
3504                 WINDOW  *win,
3505                 int     ToLines,
3506                 int     ToCols)
3507                 { return(*(int *)0); }
3508
3509 /* ./tinfo/access.c */
3510
3511 #undef _nc_rootname
3512 char    *_nc_rootname(
3513                 char    *path)
3514                 { return(*(char **)0); }
3515
3516 #undef _nc_is_abs_path
3517 NCURSES_BOOL _nc_is_abs_path(
3518                 const char *path)
3519                 { return(*(NCURSES_BOOL *)0); }
3520
3521 #undef _nc_pathlast
3522 unsigned _nc_pathlast(
3523                 const char *path)
3524                 { return(*(unsigned *)0); }
3525
3526 #undef _nc_basename
3527 char    *_nc_basename(
3528                 char    *path)
3529                 { return(*(char **)0); }
3530
3531 #undef _nc_access
3532 int     _nc_access(
3533                 const char *path,
3534                 int     mode)
3535                 { return(*(int *)0); }
3536
3537 #undef _nc_is_dir_path
3538 NCURSES_BOOL _nc_is_dir_path(
3539                 const char *path)
3540                 { return(*(NCURSES_BOOL *)0); }
3541
3542 #undef _nc_is_file_path
3543 NCURSES_BOOL _nc_is_file_path(
3544                 const char *path)
3545                 { return(*(NCURSES_BOOL *)0); }
3546
3547 #undef _nc_env_access
3548 int     _nc_env_access(void)
3549                 { return(*(int *)0); }
3550
3551 /* ./tinfo/add_tries.c */
3552
3553 #undef _nc_add_to_try
3554 int     _nc_add_to_try(
3555                 TRIES   **tree,
3556                 const char *str,
3557                 unsigned code)
3558                 { return(*(int *)0); }
3559
3560 /* ./tinfo/alloc_ttype.c */
3561
3562 #undef _nc_align_termtype
3563 void    _nc_align_termtype(
3564                 TERMTYPE *to,
3565                 TERMTYPE *from)
3566                 { /* void */ }
3567
3568 #undef _nc_copy_termtype
3569 void    _nc_copy_termtype(
3570                 TERMTYPE *dst,
3571                 const TERMTYPE *src)
3572                 { /* void */ }
3573
3574 /* ./codes.c */
3575
3576 #undef _nc_boolcodes
3577 const char *const *_nc_boolcodes(void)
3578                 { return(*(const char **)0); }
3579
3580 #undef _nc_numcodes
3581 const char *const *_nc_numcodes(void)
3582                 { return(*(const char **)0); }
3583
3584 #undef _nc_strcodes
3585 const char *const *_nc_strcodes(void)
3586                 { return(*(const char **)0); }
3587
3588 /* ./comp_captab.c */
3589
3590 #undef _nc_get_table
3591 const struct name_table_entry *_nc_get_table(
3592                 NCURSES_BOOL termcap)
3593                 { return(*(const struct name_table_entry **)0); }
3594
3595 #undef _nc_get_hash_table
3596 const HashValue *_nc_get_hash_table(
3597                 NCURSES_BOOL termcap)
3598                 { return(*(const HashValue **)0); }
3599
3600 #undef _nc_get_alias_table
3601 const struct alias *_nc_get_alias_table(
3602                 NCURSES_BOOL termcap)
3603                 { return(*(const struct alias **)0); }
3604
3605 #undef _nc_get_hash_info
3606 const HashData *_nc_get_hash_info(
3607                 NCURSES_BOOL termcap)
3608                 { return(*(const HashData **)0); }
3609
3610 /* ./tinfo/comp_error.c */
3611
3612 #undef _nc_suppress_warnings
3613 NCURSES_BOOL _nc_suppress_warnings;
3614 #undef _nc_curr_line
3615 int     _nc_curr_line;
3616 #undef _nc_curr_col
3617 int     _nc_curr_col;
3618
3619 #undef _nc_get_source
3620 const char *_nc_get_source(void)
3621                 { return(*(const char **)0); }
3622
3623 #undef _nc_set_source
3624 void    _nc_set_source(
3625                 const char *const name)
3626                 { /* void */ }
3627
3628 #undef _nc_set_type
3629 void    _nc_set_type(
3630                 const char *const name)
3631                 { /* void */ }
3632
3633 #undef _nc_get_type
3634 void    _nc_get_type(
3635                 char    *name)
3636                 { /* void */ }
3637
3638 #undef _nc_warning
3639 void    _nc_warning(
3640                 const char *const fmt,
3641                 ...)
3642                 { /* void */ }
3643
3644 #undef _nc_err_abort
3645 void    _nc_err_abort(
3646                 const char *const fmt,
3647                 ...)
3648                 { /* void */ }
3649
3650 #undef _nc_syserr_abort
3651 void    _nc_syserr_abort(
3652                 const char *const fmt,
3653                 ...)
3654                 { /* void */ }
3655
3656 /* ./tinfo/comp_hash.c */
3657
3658 #undef _nc_find_entry
3659 struct name_table_entry const *_nc_find_entry(
3660                 const char *string,
3661                 const HashValue *hash_table)
3662                 { return(*(struct name_table_entry const **)0); }
3663
3664 #undef _nc_find_type_entry
3665 struct name_table_entry const *_nc_find_type_entry(
3666                 const char *string,
3667                 int     type,
3668                 NCURSES_BOOL termcap)
3669                 { return(*(struct name_table_entry const **)0); }
3670
3671 /* ./tinfo/db_iterator.c */
3672
3673 #undef _nc_tic_dir
3674 const char *_nc_tic_dir(
3675                 const char *path)
3676                 { return(*(const char **)0); }
3677
3678 #undef _nc_keep_tic_dir
3679 void    _nc_keep_tic_dir(
3680                 const char *path)
3681                 { /* void */ }
3682
3683 #undef _nc_last_db
3684 void    _nc_last_db(void)
3685                 { /* void */ }
3686
3687 #undef _nc_next_db
3688 const char *_nc_next_db(
3689                 DBDIRS  *state,
3690                 int     *offset)
3691                 { return(*(const char **)0); }
3692
3693 #undef _nc_first_db
3694 void    _nc_first_db(
3695                 DBDIRS  *state,
3696                 int     *offset)
3697                 { /* void */ }
3698
3699 /* ./tinfo/doalloc.c */
3700
3701 #undef _nc_doalloc
3702 void    *_nc_doalloc(
3703                 void    *oldp,
3704                 size_t  amount)
3705                 { return(*(void **)0); }
3706
3707 /* ./tinfo/entries.c */
3708
3709 #undef _nc_head
3710 ENTRY   *_nc_head;
3711 #undef _nc_tail
3712 ENTRY   *_nc_tail;
3713
3714 #undef _nc_free_entry
3715 void    _nc_free_entry(
3716                 ENTRY   *headp,
3717                 TERMTYPE *tterm)
3718                 { /* void */ }
3719
3720 #undef _nc_free_entries
3721 void    _nc_free_entries(
3722                 ENTRY   *headp)
3723                 { /* void */ }
3724
3725 #undef _nc_delink_entry
3726 ENTRY   *_nc_delink_entry(
3727                 ENTRY   *headp,
3728                 TERMTYPE *tterm)
3729                 { return(*(ENTRY **)0); }
3730
3731 #undef _nc_leaks_tinfo
3732 void    _nc_leaks_tinfo(void)
3733                 { /* void */ }
3734
3735 /* ./fallback.c */
3736
3737 #undef _nc_fallback
3738 const TERMTYPE *_nc_fallback(
3739                 const char *name)
3740                 { return(*(const TERMTYPE **)0); }
3741
3742 /* ./tinfo/free_ttype.c */
3743
3744 #undef _nc_free_termtype
3745 void    _nc_free_termtype(
3746                 TERMTYPE *ptr)
3747                 { /* void */ }
3748
3749 #undef _nc_user_definable
3750 NCURSES_BOOL _nc_user_definable;
3751
3752 #undef use_extended_names
3753 int     use_extended_names(
3754                 NCURSES_BOOL flag)
3755                 { return(*(int *)0); }
3756
3757 /* ./tinfo/getenv_num.c */
3758
3759 #undef _nc_getenv_num
3760 int     _nc_getenv_num(
3761                 const char *name)
3762                 { return(*(int *)0); }
3763
3764 #undef _nc_setenv_num
3765 void    _nc_setenv_num(
3766                 const char *name,
3767                 int     value)
3768                 { /* void */ }
3769
3770 /* ./tinfo/home_terminfo.c */
3771
3772 #undef _nc_home_terminfo
3773 char    *_nc_home_terminfo(void)
3774                 { return(*(char **)0); }
3775
3776 /* ./tinfo/init_keytry.c */
3777
3778 #undef _nc_init_keytry
3779 void    _nc_init_keytry(
3780                 SCREEN  *sp)
3781                 { /* void */ }
3782
3783 /* ./tinfo/lib_acs.c */
3784
3785 #undef _nc_acs_map
3786 chtype  *_nc_acs_map(void)
3787                 { return(*(chtype **)0); }
3788
3789 #undef _nc_init_acs_sp
3790 void    _nc_init_acs_sp(
3791                 SCREEN  *sp)
3792                 { /* void */ }
3793
3794 #undef _nc_init_acs
3795 void    _nc_init_acs(void)
3796                 { /* void */ }
3797
3798 /* ./tinfo/lib_baudrate.c */
3799
3800 struct speed {
3801     short s;
3802     int sp;
3803 };
3804
3805 #undef _nc_baudrate
3806 int     _nc_baudrate(
3807                 int     OSpeed)
3808                 { return(*(int *)0); }
3809
3810 #undef _nc_ospeed
3811 int     _nc_ospeed(
3812                 int     BaudRate)
3813                 { return(*(int *)0); }
3814
3815 #undef baudrate_sp
3816 int     baudrate_sp(
3817                 SCREEN  *sp)
3818                 { return(*(int *)0); }
3819
3820 #undef baudrate
3821 int     baudrate(void)
3822                 { return(*(int *)0); }
3823
3824 /* ./tinfo/lib_cur_term.c */
3825
3826 #undef _nc_get_cur_term_sp
3827 TERMINAL *_nc_get_cur_term_sp(
3828                 SCREEN  *sp)
3829                 { return(*(TERMINAL **)0); }
3830
3831 #undef _nc_get_cur_term
3832 TERMINAL *_nc_get_cur_term(void)
3833                 { return(*(TERMINAL **)0); }
3834
3835 #undef _nc_cur_term
3836 TERMINAL *_nc_cur_term(void)
3837                 { return(*(TERMINAL **)0); }
3838
3839 #undef set_curterm_sp
3840 TERMINAL *set_curterm_sp(
3841                 SCREEN  *sp,
3842                 TERMINAL *termp)
3843                 { return(*(TERMINAL **)0); }
3844
3845 #undef set_curterm
3846 TERMINAL *set_curterm(
3847                 TERMINAL *termp)
3848                 { return(*(TERMINAL **)0); }
3849
3850 #undef del_curterm_sp
3851 int     del_curterm_sp(
3852                 SCREEN  *sp,
3853                 TERMINAL *termp)
3854                 { return(*(int *)0); }
3855
3856 #undef del_curterm
3857 int     del_curterm(
3858                 TERMINAL *termp)
3859                 { return(*(int *)0); }
3860
3861 /* ./tinfo/lib_data.c */
3862
3863 #undef _nc_stdscr
3864 WINDOW  *_nc_stdscr(void)
3865                 { return(*(WINDOW **)0); }
3866
3867 #undef _nc_curscr
3868 WINDOW  *_nc_curscr(void)
3869                 { return(*(WINDOW **)0); }
3870
3871 #undef _nc_newscr
3872 WINDOW  *_nc_newscr(void)
3873                 { return(*(WINDOW **)0); }
3874
3875 #undef _nc_screen_chain
3876 SCREEN  *_nc_screen_chain;
3877 #undef SP
3878 SCREEN  *SP;
3879 #undef _nc_globals
3880 NCURSES_GLOBALS _nc_globals;
3881 #undef _nc_prescreen
3882 NCURSES_PRESCREEN _nc_prescreen;
3883
3884 #undef _nc_screen_of
3885 SCREEN  *_nc_screen_of(
3886                 WINDOW  *win)
3887                 { return(*(SCREEN **)0); }
3888
3889 #undef _nc_init_pthreads
3890 void    _nc_init_pthreads(void)
3891                 { /* void */ }
3892
3893 #undef _nc_mutex_init
3894 void    _nc_mutex_init(
3895                 pthread_mutex_t *obj)
3896                 { /* void */ }
3897
3898 #undef _nc_mutex_lock
3899 int     _nc_mutex_lock(
3900                 pthread_mutex_t *obj)
3901                 { return(*(int *)0); }
3902
3903 #undef _nc_mutex_trylock
3904 int     _nc_mutex_trylock(
3905                 pthread_mutex_t *obj)
3906                 { return(*(int *)0); }
3907
3908 #undef _nc_mutex_unlock
3909 int     _nc_mutex_unlock(
3910                 pthread_mutex_t *obj)
3911                 { return(*(int *)0); }
3912
3913 /* ./tinfo/lib_has_cap.c */
3914
3915 #undef has_ic_sp
3916 NCURSES_BOOL has_ic_sp(
3917                 SCREEN  *sp)
3918                 { return(*(NCURSES_BOOL *)0); }
3919
3920 #undef has_ic
3921 NCURSES_BOOL has_ic(void)
3922                 { return(*(NCURSES_BOOL *)0); }
3923
3924 #undef has_il_sp
3925 NCURSES_BOOL has_il_sp(
3926                 SCREEN  *sp)
3927                 { return(*(NCURSES_BOOL *)0); }
3928
3929 #undef has_il
3930 NCURSES_BOOL has_il(void)
3931                 { return(*(NCURSES_BOOL *)0); }
3932
3933 /* ./tinfo/lib_kernel.c */
3934
3935 #undef erasechar_sp
3936 char    erasechar_sp(
3937                 SCREEN  *sp)
3938                 { return(*(char *)0); }
3939
3940 #undef erasechar
3941 char    erasechar(void)
3942                 { return(*(char *)0); }
3943
3944 #undef killchar_sp
3945 char    killchar_sp(
3946                 SCREEN  *sp)
3947                 { return(*(char *)0); }
3948
3949 #undef killchar
3950 char    killchar(void)
3951                 { return(*(char *)0); }
3952
3953 #undef flushinp_sp
3954 int     flushinp_sp(
3955                 SCREEN  *sp)
3956                 { return(*(int *)0); }
3957
3958 #undef flushinp
3959 int     flushinp(void)
3960                 { return(*(int *)0); }
3961
3962 /* ./lib_keyname.c */
3963
3964 struct kn { short offset; int code; };
3965
3966 #undef keyname_sp
3967 const char *keyname_sp(
3968                 SCREEN  *sp,
3969                 int     c)
3970                 { return(*(const char **)0); }
3971
3972 #undef keyname
3973 const char *keyname(
3974                 int     c)
3975                 { return(*(const char **)0); }
3976
3977 /* ./tinfo/lib_longname.c */
3978
3979 #undef longname_sp
3980 char    *longname_sp(
3981                 SCREEN  *sp)
3982                 { return(*(char **)0); }
3983
3984 #undef longname
3985 char    *longname(void)
3986                 { return(*(char **)0); }
3987
3988 /* ./tinfo/lib_napms.c */
3989
3990 #undef napms_sp
3991 int     napms_sp(
3992                 SCREEN  *sp,
3993                 int     ms)
3994                 { return(*(int *)0); }
3995
3996 #undef napms
3997 int     napms(
3998                 int     ms)
3999                 { return(*(int *)0); }
4000
4001 /* ./tinfo/lib_options.c */
4002
4003 #undef idlok
4004 int     idlok(
4005                 WINDOW  *win,
4006                 NCURSES_BOOL flag)
4007                 { return(*(int *)0); }
4008
4009 #undef idcok
4010 void    idcok(
4011                 WINDOW  *win,
4012                 NCURSES_BOOL flag)
4013                 { /* void */ }
4014
4015 #undef halfdelay_sp
4016 int     halfdelay_sp(
4017                 SCREEN  *sp,
4018                 int     t)
4019                 { return(*(int *)0); }
4020
4021 #undef halfdelay
4022 int     halfdelay(
4023                 int     t)
4024                 { return(*(int *)0); }
4025
4026 #undef nodelay
4027 int     nodelay(
4028                 WINDOW  *win,
4029                 NCURSES_BOOL flag)
4030                 { return(*(int *)0); }
4031
4032 #undef notimeout
4033 int     notimeout(
4034                 WINDOW  *win,
4035                 NCURSES_BOOL f)
4036                 { return(*(int *)0); }
4037
4038 #undef wtimeout
4039 void    wtimeout(
4040                 WINDOW  *win,
4041                 int     delay)
4042                 { /* void */ }
4043
4044 #undef keypad
4045 int     keypad(
4046                 WINDOW  *win,
4047                 NCURSES_BOOL flag)
4048                 { return(*(int *)0); }
4049
4050 #undef meta
4051 int     meta(
4052                 WINDOW  *win,
4053                 NCURSES_BOOL flag)
4054                 { return(*(int *)0); }
4055
4056 #undef curs_set_sp
4057 int     curs_set_sp(
4058                 SCREEN  *sp,
4059                 int     vis)
4060                 { return(*(int *)0); }
4061
4062 #undef curs_set
4063 int     curs_set(
4064                 int     vis)
4065                 { return(*(int *)0); }
4066
4067 #undef typeahead_sp
4068 int     typeahead_sp(
4069                 SCREEN  *sp,
4070                 int     fd)
4071                 { return(*(int *)0); }
4072
4073 #undef typeahead
4074 int     typeahead(
4075                 int     fd)
4076                 { return(*(int *)0); }
4077
4078 #undef has_key_sp
4079 int     has_key_sp(
4080                 SCREEN  *sp,
4081                 int     keycode)
4082                 { return(*(int *)0); }
4083
4084 #undef has_key
4085 int     has_key(
4086                 int     keycode)
4087                 { return(*(int *)0); }
4088
4089 #undef _nc_putp_flush_sp
4090 int     _nc_putp_flush_sp(
4091                 SCREEN  *sp,
4092                 const char *name,
4093                 const char *value)
4094                 { return(*(int *)0); }
4095
4096 #undef _nc_keypad
4097 int     _nc_keypad(
4098                 SCREEN  *sp,
4099                 int     flag)
4100                 { return(*(int *)0); }
4101
4102 /* ./tinfo/lib_raw.c */
4103
4104 #undef raw_sp
4105 int     raw_sp(
4106                 SCREEN  *sp)
4107                 { return(*(int *)0); }
4108
4109 #undef raw
4110 int     raw(void)
4111                 { return(*(int *)0); }
4112
4113 #undef cbreak_sp
4114 int     cbreak_sp(
4115                 SCREEN  *sp)
4116                 { return(*(int *)0); }
4117
4118 #undef cbreak
4119 int     cbreak(void)
4120                 { return(*(int *)0); }
4121
4122 #undef qiflush_sp
4123 void    qiflush_sp(
4124                 SCREEN  *sp)
4125                 { /* void */ }
4126
4127 #undef qiflush
4128 void    qiflush(void)
4129                 { /* void */ }
4130
4131 #undef noraw_sp
4132 int     noraw_sp(
4133                 SCREEN  *sp)
4134                 { return(*(int *)0); }
4135
4136 #undef noraw
4137 int     noraw(void)
4138                 { return(*(int *)0); }
4139
4140 #undef nocbreak_sp
4141 int     nocbreak_sp(
4142                 SCREEN  *sp)
4143                 { return(*(int *)0); }
4144
4145 #undef nocbreak
4146 int     nocbreak(void)
4147                 { return(*(int *)0); }
4148
4149 #undef noqiflush_sp
4150 void    noqiflush_sp(
4151                 SCREEN  *sp)
4152                 { /* void */ }
4153
4154 #undef noqiflush
4155 void    noqiflush(void)
4156                 { /* void */ }
4157
4158 #undef intrflush_sp
4159 int     intrflush_sp(
4160                 SCREEN  *sp,
4161                 WINDOW  *win,
4162                 NCURSES_BOOL flag)
4163                 { return(*(int *)0); }
4164
4165 #undef intrflush
4166 int     intrflush(
4167                 WINDOW  *win,
4168                 NCURSES_BOOL flag)
4169                 { return(*(int *)0); }
4170
4171 /* ./tinfo/lib_setup.c */
4172
4173 #undef _nc_ttytype
4174 char    *_nc_ttytype(void)
4175                 { return(*(char **)0); }
4176
4177 #undef _nc_ptr_Lines
4178 int     *_nc_ptr_Lines(
4179                 SCREEN  *sp)
4180                 { return(*(int **)0); }
4181
4182 #undef _nc_LINES
4183 int     _nc_LINES(void)
4184                 { return(*(int *)0); }
4185
4186 #undef _nc_ptr_Cols
4187 int     *_nc_ptr_Cols(
4188                 SCREEN  *sp)
4189                 { return(*(int **)0); }
4190
4191 #undef _nc_COLS
4192 int     _nc_COLS(void)
4193                 { return(*(int *)0); }
4194
4195 #undef _nc_ptr_Tabsize
4196 int     *_nc_ptr_Tabsize(
4197                 SCREEN  *sp)
4198                 { return(*(int **)0); }
4199
4200 #undef _nc_TABSIZE
4201 int     _nc_TABSIZE(void)
4202                 { return(*(int *)0); }
4203
4204 #undef set_tabsize_sp
4205 int     set_tabsize_sp(
4206                 SCREEN  *sp,
4207                 int     value)
4208                 { return(*(int *)0); }
4209
4210 #undef set_tabsize
4211 int     set_tabsize(
4212                 int     value)
4213                 { return(*(int *)0); }
4214
4215 #undef _nc_handle_sigwinch
4216 int     _nc_handle_sigwinch(
4217                 SCREEN  *sp)
4218                 { return(*(int *)0); }
4219
4220 #undef use_env_sp
4221 void    use_env_sp(
4222                 SCREEN  *sp,
4223                 NCURSES_BOOL f)
4224                 { /* void */ }
4225
4226 #undef use_tioctl_sp
4227 void    use_tioctl_sp(
4228                 SCREEN  *sp,
4229                 NCURSES_BOOL f)
4230                 { /* void */ }
4231
4232 #undef use_env
4233 void    use_env(
4234                 NCURSES_BOOL f)
4235                 { /* void */ }
4236
4237 #undef use_tioctl
4238 void    use_tioctl(
4239                 NCURSES_BOOL f)
4240                 { /* void */ }
4241
4242 #undef _nc_get_screensize
4243 void    _nc_get_screensize(
4244                 SCREEN  *sp,
4245                 int     *linep,
4246                 int     *colp)
4247                 { /* void */ }
4248
4249 #undef _nc_update_screensize
4250 void    _nc_update_screensize(
4251                 SCREEN  *sp)
4252                 { /* void */ }
4253
4254 #undef _nc_setup_tinfo
4255 int     _nc_setup_tinfo(
4256                 const char *const tn,
4257                 TERMTYPE *const tp)
4258                 { return(*(int *)0); }
4259
4260 #undef _nc_tinfo_cmdch
4261 void    _nc_tinfo_cmdch(
4262                 TERMINAL *termp,
4263                 int     proto)
4264                 { /* void */ }
4265
4266 #undef _nc_get_locale
4267 char    *_nc_get_locale(void)
4268                 { return(*(char **)0); }
4269
4270 #undef _nc_unicode_locale
4271 int     _nc_unicode_locale(void)
4272                 { return(*(int *)0); }
4273
4274 #undef _nc_locale_breaks_acs
4275 int     _nc_locale_breaks_acs(
4276                 TERMINAL *termp)
4277                 { return(*(int *)0); }
4278
4279 #undef _nc_setupterm
4280 int     _nc_setupterm(
4281                 const char *tname,
4282                 int     Filedes,
4283                 int     *errret,
4284                 int     reuse)
4285                 { return(*(int *)0); }
4286
4287 #undef new_prescr
4288 SCREEN  *new_prescr(void)
4289                 { return(*(SCREEN **)0); }
4290
4291 #undef setupterm
4292 int     setupterm(
4293                 const char *tname,
4294                 int     Filedes,
4295                 int     *errret)
4296                 { return(*(int *)0); }
4297
4298 /* ./tinfo/lib_termcap.c */
4299
4300 #undef UP
4301 char    *UP;
4302 #undef BC
4303 char    *BC;
4304
4305 #undef tgetent_sp
4306 int     tgetent_sp(
4307                 SCREEN  *sp,
4308                 char    *bufp,
4309                 const char *name)
4310                 { return(*(int *)0); }
4311
4312 #undef tgetent
4313 int     tgetent(
4314                 char    *bufp,
4315                 const char *name)
4316                 { return(*(int *)0); }
4317
4318 #undef tgetflag_sp
4319 int     tgetflag_sp(
4320                 SCREEN  *sp,
4321                 const char *id)
4322                 { return(*(int *)0); }
4323
4324 #undef tgetflag
4325 int     tgetflag(
4326                 const char *id)
4327                 { return(*(int *)0); }
4328
4329 #undef tgetnum_sp
4330 int     tgetnum_sp(
4331                 SCREEN  *sp,
4332                 const char *id)
4333                 { return(*(int *)0); }
4334
4335 #undef tgetnum
4336 int     tgetnum(
4337                 const char *id)
4338                 { return(*(int *)0); }
4339
4340 #undef tgetstr_sp
4341 char    *tgetstr_sp(
4342                 SCREEN  *sp,
4343                 const char *id,
4344                 char    **area)
4345                 { return(*(char **)0); }
4346
4347 #undef tgetstr
4348 char    *tgetstr(
4349                 const char *id,
4350                 char    **area)
4351                 { return(*(char **)0); }
4352
4353 /* ./tinfo/lib_termname.c */
4354
4355 #undef termname_sp
4356 char    *termname_sp(
4357                 SCREEN  *sp)
4358                 { return(*(char **)0); }
4359
4360 #undef termname
4361 char    *termname(void)
4362                 { return(*(char **)0); }
4363
4364 /* ./tinfo/lib_tgoto.c */
4365
4366 #undef tgoto
4367 char    *tgoto(
4368                 const char *string,
4369                 int     x,
4370                 int     y)
4371                 { return(*(char **)0); }
4372
4373 /* ./tinfo/lib_ti.c */
4374
4375 #undef tigetflag_sp
4376 int     tigetflag_sp(
4377                 SCREEN  *sp,
4378                 const char *str)
4379                 { return(*(int *)0); }
4380
4381 #undef tigetflag
4382 int     tigetflag(
4383                 const char *str)
4384                 { return(*(int *)0); }
4385
4386 #undef tigetnum_sp
4387 int     tigetnum_sp(
4388                 SCREEN  *sp,
4389                 const char *str)
4390                 { return(*(int *)0); }
4391
4392 #undef tigetnum
4393 int     tigetnum(
4394                 const char *str)
4395                 { return(*(int *)0); }
4396
4397 #undef tigetstr_sp
4398 char    *tigetstr_sp(
4399                 SCREEN  *sp,
4400                 const char *str)
4401                 { return(*(char **)0); }
4402
4403 #undef tigetstr
4404 char    *tigetstr(
4405                 const char *str)
4406                 { return(*(char **)0); }
4407
4408 /* ./tinfo/lib_tparm.c */
4409
4410 #undef _nc_tparm_err
4411 int     _nc_tparm_err;
4412
4413 #undef _nc_tparm_analyze
4414 int     _nc_tparm_analyze(
4415                 const char *string,
4416                 char    *p_is_s[9],
4417                 int     *_nc_popcount)
4418                 { return(*(int *)0); }
4419
4420 #undef tparm
4421 char    *tparm(
4422                 const char *string,
4423                 ...)
4424                 { return(*(char **)0); }
4425
4426 #undef tiparm
4427 char    *tiparm(
4428                 const char *string,
4429                 ...)
4430                 { return(*(char **)0); }
4431
4432 /* ./tinfo/lib_tputs.c */
4433
4434 #undef PC
4435 char    PC;
4436 #undef ospeed
4437 short   ospeed;
4438 #undef _nc_nulls_sent
4439 int     _nc_nulls_sent;
4440
4441 #undef _nc_set_no_padding
4442 void    _nc_set_no_padding(
4443                 SCREEN  *sp)
4444                 { /* void */ }
4445
4446 #undef delay_output_sp
4447 int     delay_output_sp(
4448                 SCREEN  *sp,
4449                 int     ms)
4450                 { return(*(int *)0); }
4451
4452 #undef delay_output
4453 int     delay_output(
4454                 int     ms)
4455                 { return(*(int *)0); }
4456
4457 #undef _nc_flush_sp
4458 void    _nc_flush_sp(
4459                 SCREEN  *sp)
4460                 { /* void */ }
4461
4462 #undef _nc_flush
4463 void    _nc_flush(void)
4464                 { /* void */ }
4465
4466 #undef _nc_outch_sp
4467 int     _nc_outch_sp(
4468                 SCREEN  *sp,
4469                 int     ch)
4470                 { return(*(int *)0); }
4471
4472 #undef _nc_outch
4473 int     _nc_outch(
4474                 int     ch)
4475                 { return(*(int *)0); }
4476
4477 #undef _nc_putchar_sp
4478 int     _nc_putchar_sp(
4479                 SCREEN  *sp,
4480                 int     ch)
4481                 { return(*(int *)0); }
4482
4483 #undef _nc_putchar
4484 int     _nc_putchar(
4485                 int     ch)
4486                 { return(*(int *)0); }
4487
4488 #undef putp_sp
4489 int     putp_sp(
4490                 SCREEN  *sp,
4491                 const char *string)
4492                 { return(*(int *)0); }
4493
4494 #undef putp
4495 int     putp(
4496                 const char *string)
4497                 { return(*(int *)0); }
4498
4499 #undef _nc_putp_sp
4500 int     _nc_putp_sp(
4501                 SCREEN  *sp,
4502                 const char *name,
4503                 const char *string)
4504                 { return(*(int *)0); }
4505
4506 #undef _nc_putp
4507 int     _nc_putp(
4508                 const char *name,
4509                 const char *string)
4510                 { return(*(int *)0); }
4511
4512 #undef tputs_sp
4513 int     tputs_sp(
4514                 SCREEN  *sp,
4515                 const char *string,
4516                 int     affcnt,
4517                 NCURSES_OUTC_sp outc)
4518                 { return(*(int *)0); }
4519
4520 #undef _nc_outc_wrapper
4521 int     _nc_outc_wrapper(
4522                 SCREEN  *sp,
4523                 int     c)
4524                 { return(*(int *)0); }
4525
4526 #undef tputs
4527 int     tputs(
4528                 const char *string,
4529                 int     affcnt,
4530                 int     (*outc)(
4531                 int     p1))
4532                 { return(*(int *)0); }
4533
4534 /* ./trace/lib_trace.c */
4535
4536 #undef _nc_tracing
4537 unsigned _nc_tracing;
4538
4539 #undef _nc__nc_tputs_trace
4540 const char *_nc__nc_tputs_trace(void)
4541                 { return(*(const char **)0); }
4542
4543 #undef _nc__nc_outchars
4544 long    _nc__nc_outchars(void)
4545                 { return(*(long *)0); }
4546
4547 #undef _nc_set_tputs_trace
4548 void    _nc_set_tputs_trace(
4549                 const char *s)
4550                 { /* void */ }
4551
4552 #undef _nc_count_outchars
4553 void    _nc_count_outchars(
4554                 long    increment)
4555                 { /* void */ }
4556
4557 #undef trace
4558 void    trace(
4559                 const unsigned int tracelevel)
4560                 { /* void */ }
4561
4562 #undef _tracef
4563 void    _tracef(
4564                 const char *fmt,
4565                 ...)
4566                 { /* void */ }
4567
4568 #undef _nc_retrace_bool
4569 NCURSES_BOOL _nc_retrace_bool(
4570                 int     code)
4571                 { return(*(NCURSES_BOOL *)0); }
4572
4573 #undef _nc_retrace_char
4574 char    _nc_retrace_char(
4575                 int     code)
4576                 { return(*(char *)0); }
4577
4578 #undef _nc_retrace_int
4579 int     _nc_retrace_int(
4580                 int     code)
4581                 { return(*(int *)0); }
4582
4583 #undef _nc_retrace_unsigned
4584 unsigned _nc_retrace_unsigned(
4585                 unsigned code)
4586                 { return(*(unsigned *)0); }
4587
4588 #undef _nc_retrace_ptr
4589 char    *_nc_retrace_ptr(
4590                 char    *code)
4591                 { return(*(char **)0); }
4592
4593 #undef _nc_retrace_cptr
4594 const char *_nc_retrace_cptr(
4595                 const char *code)
4596                 { return(*(const char **)0); }
4597
4598 #undef _nc_retrace_cvoid_ptr
4599 const void *_nc_retrace_cvoid_ptr(
4600                 const void *code)
4601                 { return(*(const void **)0); }
4602
4603 #undef _nc_retrace_void_ptr
4604 void    *_nc_retrace_void_ptr(
4605                 void    *code)
4606                 { return(*(void **)0); }
4607
4608 #undef _nc_retrace_sp
4609 SCREEN  *_nc_retrace_sp(
4610                 SCREEN  *code)
4611                 { return(*(SCREEN **)0); }
4612
4613 #undef _nc_retrace_win
4614 WINDOW  *_nc_retrace_win(
4615                 WINDOW  *code)
4616                 { return(*(WINDOW **)0); }
4617
4618 #undef _nc_use_tracef
4619 int     _nc_use_tracef(
4620                 unsigned mask)
4621                 { return(*(int *)0); }
4622
4623 #undef _nc_locked_tracef
4624 void    _nc_locked_tracef(
4625                 const char *fmt,
4626                 ...)
4627                 { /* void */ }
4628
4629 /* ./trace/lib_traceatr.c */
4630
4631 #undef _traceattr2
4632 char    *_traceattr2(
4633                 int     bufnum,
4634                 chtype  newmode)
4635                 { return(*(char **)0); }
4636
4637 #undef _traceattr
4638 char    *_traceattr(
4639                 attr_t  newmode)
4640                 { return(*(char **)0); }
4641
4642 #undef _nc_retrace_int_attr_t
4643 int     _nc_retrace_int_attr_t(
4644                 attr_t  code)
4645                 { return(*(int *)0); }
4646
4647 #undef _nc_retrace_attr_t
4648 attr_t  _nc_retrace_attr_t(
4649                 attr_t  code)
4650                 { return(*(attr_t *)0); }
4651
4652 #undef _nc_altcharset_name
4653 const char *_nc_altcharset_name(
4654                 attr_t  attr,
4655                 chtype  ch)
4656                 { return(*(const char **)0); }
4657
4658 #undef _tracechtype2
4659 char    *_tracechtype2(
4660                 int     bufnum,
4661                 chtype  ch)
4662                 { return(*(char **)0); }
4663
4664 #undef _tracechtype
4665 char    *_tracechtype(
4666                 chtype  ch)
4667                 { return(*(char **)0); }
4668
4669 #undef _nc_retrace_chtype
4670 chtype  _nc_retrace_chtype(
4671                 chtype  code)
4672                 { return(*(chtype *)0); }
4673
4674 #undef _tracecchar_t2
4675 char    *_tracecchar_t2(
4676                 int     bufnum,
4677                 const cchar_t *ch)
4678                 { return(*(char **)0); }
4679
4680 #undef _tracecchar_t
4681 char    *_tracecchar_t(
4682                 const cchar_t *ch)
4683                 { return(*(char **)0); }
4684
4685 /* ./trace/lib_tracebits.c */
4686
4687 #undef _nc_trace_ttymode
4688 char    *_nc_trace_ttymode(
4689                 struct termios *tty)
4690                 { return(*(char **)0); }
4691
4692 #undef _nc_tracebits
4693 char    *_nc_tracebits(void)
4694                 { return(*(char **)0); }
4695
4696 /* ./trace/lib_tracechr.c */
4697
4698 #undef _nc_tracechar
4699 char    *_nc_tracechar(
4700                 SCREEN  *sp,
4701                 int     ch)
4702                 { return(*(char **)0); }
4703
4704 #undef _tracechar
4705 char    *_tracechar(
4706                 int     ch)
4707                 { return(*(char **)0); }
4708
4709 /* ./tinfo/lib_ttyflags.c */
4710
4711 #undef _nc_get_tty_mode_sp
4712 int     _nc_get_tty_mode_sp(
4713                 SCREEN  *sp,
4714                 struct termios *buf)
4715                 { return(*(int *)0); }
4716
4717 #undef _nc_get_tty_mode
4718 int     _nc_get_tty_mode(
4719                 struct termios *buf)
4720                 { return(*(int *)0); }
4721
4722 #undef _nc_set_tty_mode_sp
4723 int     _nc_set_tty_mode_sp(
4724                 SCREEN  *sp,
4725                 struct termios *buf)
4726                 { return(*(int *)0); }
4727
4728 #undef _nc_set_tty_mode
4729 int     _nc_set_tty_mode(
4730                 struct termios *buf)
4731                 { return(*(int *)0); }
4732
4733 #undef def_shell_mode_sp
4734 int     def_shell_mode_sp(
4735                 SCREEN  *sp)
4736                 { return(*(int *)0); }
4737
4738 #undef def_shell_mode
4739 int     def_shell_mode(void)
4740                 { return(*(int *)0); }
4741
4742 #undef def_prog_mode_sp
4743 int     def_prog_mode_sp(
4744                 SCREEN  *sp)
4745                 { return(*(int *)0); }
4746
4747 #undef def_prog_mode
4748 int     def_prog_mode(void)
4749                 { return(*(int *)0); }
4750
4751 #undef reset_prog_mode_sp
4752 int     reset_prog_mode_sp(
4753                 SCREEN  *sp)
4754                 { return(*(int *)0); }
4755
4756 #undef reset_prog_mode
4757 int     reset_prog_mode(void)
4758                 { return(*(int *)0); }
4759
4760 #undef reset_shell_mode_sp
4761 int     reset_shell_mode_sp(
4762                 SCREEN  *sp)
4763                 { return(*(int *)0); }
4764
4765 #undef reset_shell_mode
4766 int     reset_shell_mode(void)
4767                 { return(*(int *)0); }
4768
4769 #undef savetty_sp
4770 int     savetty_sp(
4771                 SCREEN  *sp)
4772                 { return(*(int *)0); }
4773
4774 #undef savetty
4775 int     savetty(void)
4776                 { return(*(int *)0); }
4777
4778 #undef resetty_sp
4779 int     resetty_sp(
4780                 SCREEN  *sp)
4781                 { return(*(int *)0); }
4782
4783 #undef resetty
4784 int     resetty(void)
4785                 { return(*(int *)0); }
4786
4787 /* ./tty/lib_twait.c */
4788
4789 #undef _nc_timed_wait
4790 int     _nc_timed_wait(
4791                 SCREEN  *sp,
4792                 int     mode,
4793                 int     milliseconds,
4794                 int     *timeleft)
4795                 { return(*(int *)0); }
4796
4797 /* ./tinfo/name_match.c */
4798
4799 #undef _nc_first_name
4800 char    *_nc_first_name(
4801                 const char *const sp)
4802                 { return(*(char **)0); }
4803
4804 #undef _nc_name_match
4805 int     _nc_name_match(
4806                 const char *const namelst,
4807                 const char *const name,
4808                 const char *const delim)
4809                 { return(*(int *)0); }
4810
4811 /* ./names.c */
4812
4813 #undef _nc_boolnames
4814 const char *const *_nc_boolnames(void)
4815                 { return(*(const char **)0); }
4816
4817 #undef _nc_boolfnames
4818 const char *const *_nc_boolfnames(void)
4819                 { return(*(const char **)0); }
4820
4821 #undef _nc_numnames
4822 const char *const *_nc_numnames(void)
4823                 { return(*(const char **)0); }
4824
4825 #undef _nc_numfnames
4826 const char *const *_nc_numfnames(void)
4827                 { return(*(const char **)0); }
4828
4829 #undef _nc_strnames
4830 const char *const *_nc_strnames(void)
4831                 { return(*(const char **)0); }
4832
4833 #undef _nc_strfnames
4834 const char *const *_nc_strfnames(void)
4835                 { return(*(const char **)0); }
4836
4837 /* ./tinfo/obsolete.c */
4838
4839 #undef _nc_set_buffer_sp
4840 void    _nc_set_buffer_sp(
4841                 SCREEN  *sp,
4842                 FILE    *ofp,
4843                 int     buffered)
4844                 { /* void */ }
4845
4846 #undef _nc_set_buffer
4847 void    _nc_set_buffer(
4848                 FILE    *ofp,
4849                 int     buffered)
4850                 { /* void */ }
4851
4852 /* ./tinfo/read_entry.c */
4853
4854 #undef _nc_init_termtype
4855 void    _nc_init_termtype(
4856                 TERMTYPE *const tp)
4857                 { /* void */ }
4858
4859 #undef _nc_read_termtype
4860 int     _nc_read_termtype(
4861                 TERMTYPE *ptr,
4862                 char    *buffer,
4863                 int     limit)
4864                 { return(*(int *)0); }
4865
4866 #undef _nc_read_file_entry
4867 int     _nc_read_file_entry(
4868                 const char *const filename,
4869                 TERMTYPE *ptr)
4870                 { return(*(int *)0); }
4871
4872 #undef _nc_read_entry
4873 int     _nc_read_entry(
4874                 const char *const name,
4875                 char    *const filename,
4876                 TERMTYPE *const tp)
4877                 { return(*(int *)0); }
4878
4879 /* ./tinfo/read_termcap.c */
4880
4881 #undef _nc_read_termcap_entry
4882 int     _nc_read_termcap_entry(
4883                 const char *const tn,
4884                 TERMTYPE *const tp)
4885                 { return(*(int *)0); }
4886
4887 /* ./tinfo/strings.c */
4888
4889 #undef _nc_str_init
4890 string_desc *_nc_str_init(
4891                 string_desc *dst,
4892                 char    *src,
4893                 size_t  len)
4894                 { return(*(string_desc **)0); }
4895
4896 #undef _nc_str_null
4897 string_desc *_nc_str_null(
4898                 string_desc *dst,
4899                 size_t  len)
4900                 { return(*(string_desc **)0); }
4901
4902 #undef _nc_str_copy
4903 string_desc *_nc_str_copy(
4904                 string_desc *dst,
4905                 string_desc *src)
4906                 { return(*(string_desc **)0); }
4907
4908 #undef _nc_safe_strcat
4909 NCURSES_BOOL _nc_safe_strcat(
4910                 string_desc *dst,
4911                 const char *src)
4912                 { return(*(NCURSES_BOOL *)0); }
4913
4914 #undef _nc_safe_strcpy
4915 NCURSES_BOOL _nc_safe_strcpy(
4916                 string_desc *dst,
4917                 const char *src)
4918                 { return(*(NCURSES_BOOL *)0); }
4919
4920 /* ./trace/trace_buf.c */
4921
4922 #undef _nc_trace_buf
4923 char    *_nc_trace_buf(
4924                 int     bufnum,
4925                 size_t  want)
4926                 { return(*(char **)0); }
4927
4928 #undef _nc_trace_bufcat
4929 char    *_nc_trace_bufcat(
4930                 int     bufnum,
4931                 const char *value)
4932                 { return(*(char **)0); }
4933
4934 /* ./trace/trace_tries.c */
4935
4936 #undef _nc_trace_tries
4937 void    _nc_trace_tries(
4938                 TRIES   *tree)
4939                 { /* void */ }
4940
4941 /* ./base/tries.c */
4942
4943 #undef _nc_expand_try
4944 char    *_nc_expand_try(
4945                 TRIES   *tree,
4946                 unsigned code,
4947                 int     *count,
4948                 size_t  len)
4949                 { return(*(char **)0); }
4950
4951 #undef _nc_remove_key
4952 int     _nc_remove_key(
4953                 TRIES   **tree,
4954                 unsigned code)
4955                 { return(*(int *)0); }
4956
4957 #undef _nc_remove_string
4958 int     _nc_remove_string(
4959                 TRIES   **tree,
4960                 const char *string)
4961                 { return(*(int *)0); }
4962
4963 /* ./tinfo/trim_sgr0.c */
4964
4965 #undef _nc_trim_sgr0
4966 char    *_nc_trim_sgr0(
4967                 TERMTYPE *tp)
4968                 { return(*(char **)0); }
4969
4970 /* ./unctrl.c */
4971
4972 #undef unctrl_sp
4973 const char *unctrl_sp(
4974                 SCREEN  *sp,
4975                 chtype  ch)
4976                 { return(*(const char **)0); }
4977
4978 #undef unctrl
4979 const char *unctrl(
4980                 chtype  ch)
4981                 { return(*(const char **)0); }
4982
4983 /* ./trace/visbuf.c */
4984
4985 #undef _nc_visbuf2
4986 const char *_nc_visbuf2(
4987                 int     bufnum,
4988                 const char *buf)
4989                 { return(*(const char **)0); }
4990
4991 #undef _nc_visbuf
4992 const char *_nc_visbuf(
4993                 const char *buf)
4994                 { return(*(const char **)0); }
4995
4996 #undef _nc_visbufn
4997 const char *_nc_visbufn(
4998                 const char *buf,
4999                 int     len)
5000                 { return(*(const char **)0); }
5001
5002 #undef _nc_viswbuf2
5003 const char *_nc_viswbuf2(
5004                 int     bufnum,
5005                 const wchar_t *buf)
5006                 { return(*(const char **)0); }
5007
5008 #undef _nc_viswbuf
5009 const char *_nc_viswbuf(
5010                 const wchar_t *buf)
5011                 { return(*(const char **)0); }
5012
5013 #undef _nc_viswbufn
5014 const char *_nc_viswbufn(
5015                 const wchar_t *buf,
5016                 int     len)
5017                 { return(*(const char **)0); }
5018
5019 #undef _nc_viswibuf
5020 const char *_nc_viswibuf(
5021                 const wint_t *buf)
5022                 { return(*(const char **)0); }
5023
5024 #undef _nc_viscbuf2
5025 const char *_nc_viscbuf2(
5026                 int     bufnum,
5027                 const cchar_t *buf,
5028                 int     len)
5029                 { return(*(const char **)0); }
5030
5031 #undef _nc_viscbuf
5032 const char *_nc_viscbuf(
5033                 const cchar_t *buf,
5034                 int     len)
5035                 { return(*(const char **)0); }
5036
5037 /* ./tinfo/alloc_entry.c */
5038
5039 #undef _nc_init_entry
5040 void    _nc_init_entry(
5041                 TERMTYPE *const tp)
5042                 { /* void */ }
5043
5044 #undef _nc_copy_entry
5045 ENTRY   *_nc_copy_entry(
5046                 ENTRY   *oldp)
5047                 { return(*(ENTRY **)0); }
5048
5049 #undef _nc_save_str
5050 char    *_nc_save_str(
5051                 const char *const string)
5052                 { return(*(char **)0); }
5053
5054 #undef _nc_wrap_entry
5055 void    _nc_wrap_entry(
5056                 ENTRY   *const ep,
5057                 NCURSES_BOOL copy_strings)
5058                 { /* void */ }
5059
5060 #undef _nc_merge_entry
5061 void    _nc_merge_entry(
5062                 TERMTYPE *const to,
5063                 TERMTYPE *const from)
5064                 { /* void */ }
5065
5066 /* ./tinfo/captoinfo.c */
5067
5068 #undef _nc_captoinfo
5069 char    *_nc_captoinfo(
5070                 const char *cap,
5071                 const char *s,
5072                 int const parameterized)
5073                 { return(*(char **)0); }
5074
5075 #undef _nc_infotocap
5076 char    *_nc_infotocap(
5077                 const char *cap,
5078                 const char *str,
5079                 int const parameterized)
5080                 { return(*(char **)0); }
5081
5082 /* ./tinfo/comp_expand.c */
5083
5084 #undef _nc_tic_expand
5085 char    *_nc_tic_expand(
5086                 const char *srcp,
5087                 NCURSES_BOOL tic_format,
5088                 int     numbers)
5089                 { return(*(char **)0); }
5090
5091 /* ./tinfo/comp_parse.c */
5092
5093 #undef _nc_check_termtype2
5094 void    (*_nc_check_termtype2)(
5095                 TERMTYPE *p1,
5096                 NCURSES_BOOL p2);
5097 #undef _nc_check_termtype
5098 void    (*_nc_check_termtype)(
5099                 TERMTYPE *p1);
5100
5101 #undef _nc_entry_match
5102 NCURSES_BOOL _nc_entry_match(
5103                 char    *n1,
5104                 char    *n2)
5105                 { return(*(NCURSES_BOOL *)0); }
5106
5107 #undef _nc_read_entry_source
5108 void    _nc_read_entry_source(
5109                 FILE    *fp,
5110                 char    *buf,
5111                 int     literal,
5112                 NCURSES_BOOL silent,
5113                 NCURSES_BOOL (*hook)(
5114                 ENTRY   *p1))
5115                 { /* void */ }
5116
5117 #undef _nc_resolve_uses2
5118 int     _nc_resolve_uses2(
5119                 NCURSES_BOOL fullresolve,
5120                 NCURSES_BOOL literal)
5121                 { return(*(int *)0); }
5122
5123 #undef _nc_resolve_uses
5124 int     _nc_resolve_uses(
5125                 NCURSES_BOOL fullresolve)
5126                 { return(*(int *)0); }
5127
5128 /* ./tinfo/comp_scan.c */
5129
5130 #undef _nc_syntax
5131 int     _nc_syntax;
5132 #undef _nc_strict_bsd
5133 int     _nc_strict_bsd;
5134 #undef _nc_curr_file_pos
5135 long    _nc_curr_file_pos;
5136 #undef _nc_comment_start
5137 long    _nc_comment_start;
5138 #undef _nc_comment_end
5139 long    _nc_comment_end;
5140 #undef _nc_start_line
5141 long    _nc_start_line;
5142 #undef _nc_curr_token
5143 struct token _nc_curr_token;
5144 #undef _nc_disable_period
5145 NCURSES_BOOL _nc_disable_period;
5146
5147 #undef _nc_reset_input
5148 void    _nc_reset_input(
5149                 FILE    *fp,
5150                 char    *buf)
5151                 { /* void */ }
5152
5153 #undef _nc_get_token
5154 int     _nc_get_token(
5155                 NCURSES_BOOL silent)
5156                 { return(*(int *)0); }
5157
5158 #undef _nc_trans_string
5159 int     _nc_trans_string(
5160                 char    *ptr,
5161                 char    *last)
5162                 { return(*(int *)0); }
5163
5164 #undef _nc_push_token
5165 void    _nc_push_token(
5166                 int     tokclass)
5167                 { /* void */ }
5168
5169 #undef _nc_panic_mode
5170 void    _nc_panic_mode(
5171                 char    ch)
5172                 { /* void */ }
5173
5174 /* ./tinfo/parse_entry.c */
5175
5176 #undef _nc_parse_entry
5177 int     _nc_parse_entry(
5178                 struct entry *entryp,
5179                 int     literal,
5180                 NCURSES_BOOL silent)
5181                 { return(*(int *)0); }
5182
5183 #undef _nc_capcmp
5184 int     _nc_capcmp(
5185                 const char *s,
5186                 const char *t)
5187                 { return(*(int *)0); }
5188
5189 /* ./tinfo/write_entry.c */
5190
5191 #undef _nc_set_writedir
5192 void    _nc_set_writedir(
5193                 const char *dir)
5194                 { /* void */ }
5195
5196 #undef _nc_write_entry
5197 void    _nc_write_entry(
5198                 TERMTYPE *const tp)
5199                 { /* void */ }
5200
5201 #undef _nc_tic_written
5202 int     _nc_tic_written(void)
5203                 { return(*(int *)0); }
5204
5205 /* ./base/define_key.c */
5206
5207 #undef define_key_sp
5208 int     define_key_sp(
5209                 SCREEN  *sp,
5210                 const char *str,
5211                 int     keycode)
5212                 { return(*(int *)0); }
5213
5214 #undef define_key
5215 int     define_key(
5216                 const char *str,
5217                 int     keycode)
5218                 { return(*(int *)0); }
5219
5220 /* ./tinfo/hashed_db.c */
5221
5222 #undef _nc_hashed_db
5223 void    _nc_hashed_db(void)
5224                 { /* void */ }
5225
5226 /* ./base/key_defined.c */
5227
5228 #undef key_defined_sp
5229 int     key_defined_sp(
5230                 SCREEN  *sp,
5231                 const char *str)
5232                 { return(*(int *)0); }
5233
5234 #undef key_defined
5235 int     key_defined(
5236                 const char *str)
5237                 { return(*(int *)0); }
5238
5239 /* ./base/keybound.c */
5240
5241 #undef keybound_sp
5242 char    *keybound_sp(
5243                 SCREEN  *sp,
5244                 int     code,
5245                 int     count)
5246                 { return(*(char **)0); }
5247
5248 #undef keybound
5249 char    *keybound(
5250                 int     code,
5251                 int     count)
5252                 { return(*(char **)0); }
5253
5254 /* ./base/keyok.c */
5255
5256 #undef keyok_sp
5257 int     keyok_sp(
5258                 SCREEN  *sp,
5259                 int     c,
5260                 NCURSES_BOOL flag)
5261                 { return(*(int *)0); }
5262
5263 #undef keyok
5264 int     keyok(
5265                 int     c,
5266                 NCURSES_BOOL flag)
5267                 { return(*(int *)0); }
5268
5269 /* ./base/version.c */
5270
5271 #undef curses_version
5272 const char *curses_version(void)
5273                 { return(*(const char **)0); }