ncurses/llib-lncursestw

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