ncurses/llib-lncursesw

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