ncurses/llib-lncursestw

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