ncurses/llib-lncursesw

   1 /****************************************************************************
   2  * Copyright (c) 2001-2004,2005 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-2005                                      *
  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
  42 void    _nc_scroll_optimize(void)
  43                 { /* void */ }
  44
  45 #undef _nc_linedump
  46 void    _nc_linedump(void)
  47                 { /* void */ }
  48
  49 /* ./tty/hashmap.c */
  50
  51 #include <term.h>
  52
  53 #undef _nc_hash_map
  54 void    _nc_hash_map(void)
  55                 { /* void */ }
  56
  57 #undef _nc_make_oldhash
  58 void    _nc_make_oldhash(
  59                 int     i)
  60                 { /* void */ }
  61
  62 #undef _nc_scroll_oldhash
  63 void    _nc_scroll_oldhash(
  64                 int     n,
  65                 int     top,
  66                 int     bot)
  67                 { /* void */ }
  68
  69 /* ./base/lib_addch.c */
  70
  71 #include <ctype.h>
  72
  73 #undef _nc_render
  74 cchar_t _nc_render(
  75                 WINDOW  *win,
  76                 cchar_t ch)
  77                 { return(*(cchar_t *)0); }
  78
  79 #undef _nc_build_wch
  80 int     _nc_build_wch(
  81                 WINDOW  *win,
  82                 cchar_t *ch)
  83                 { return(*(int *)0); }
  84
  85 #undef _nc_waddch_nosync
  86 int     _nc_waddch_nosync(
  87                 WINDOW  *win,
  88                 const cchar_t c)
  89                 { return(*(int *)0); }
  90
  91 #undef waddch
  92 int     waddch(
  93                 WINDOW  *win,
  94                 const chtype ch)
  95                 { return(*(int *)0); }
  96
  97 #undef wechochar
  98 int     wechochar(
  99                 WINDOW  *win,
 100                 const chtype ch)
 101                 { return(*(int *)0); }
 102
 103 /* ./base/lib_addstr.c */
 104
 105 #undef waddnstr
 106 int     waddnstr(
 107                 WINDOW  *win,
 108                 const char *astr,
 109                 int     n)
 110                 { return(*(int *)0); }
 111
 112 #undef waddchnstr
 113 int     waddchnstr(
 114                 WINDOW  *win,
 115                 const chtype *astr,
 116                 int     n)
 117                 { return(*(int *)0); }
 118
 119 #undef _nc_wchstrlen
 120 int     _nc_wchstrlen(
 121                 const cchar_t *s)
 122                 { return(*(int *)0); }
 123
 124 #undef wadd_wchnstr
 125 int     wadd_wchnstr(
 126                 WINDOW  *win,
 127                 const cchar_t *astr,
 128                 int     n)
 129                 { return(*(int *)0); }
 130
 131 #undef waddnwstr
 132 int     waddnwstr(
 133                 WINDOW  *win,
 134                 const wchar_t *str,
 135                 int     n)
 136                 { return(*(int *)0); }
 137
 138 /* ./base/lib_beep.c */
 139
 140 #undef beep
 141 int     beep(void)
 142                 { return(*(int *)0); }
 143
 144 /* ./base/lib_bkgd.c */
 145
 146 #undef wbkgrndset
 147 void    wbkgrndset(
 148                 WINDOW  *win,
 149                 const cchar_t *ch)
 150                 { /* void */ }
 151
 152 #undef wbkgdset
 153 void    wbkgdset(
 154                 WINDOW  *win,
 155                 chtype  ch)
 156                 { /* void */ }
 157
 158 #undef wbkgrnd
 159 int     wbkgrnd(
 160                 WINDOW  *win,
 161                 const cchar_t *ch)
 162                 { return(*(int *)0); }
 163
 164 #undef wbkgd
 165 int     wbkgd(
 166                 WINDOW  *win,
 167                 chtype  ch)
 168                 { return(*(int *)0); }
 169
 170 /* ./base/lib_box.c */
 171
 172 #undef wborder
 173 int     wborder(
 174                 WINDOW  *win,
 175                 chtype  ls,
 176                 chtype  rs,
 177                 chtype  ts,
 178                 chtype  bs,
 179                 chtype  tl,
 180                 chtype  tr,
 181                 chtype  bl,
 182                 chtype  br)
 183                 { return(*(int *)0); }
 184
 185 /* ./base/lib_chgat.c */
 186
 187 #undef wchgat
 188 int     wchgat(
 189                 WINDOW  *win,
 190                 int     n,
 191                 attr_t  attr,
 192                 short   color,
 193                 const void *opts)
 194                 { return(*(int *)0); }
 195
 196 /* ./base/lib_clear.c */
 197
 198 #undef wclear
 199 int     wclear(
 200                 WINDOW  *win)
 201                 { return(*(int *)0); }
 202
 203 /* ./base/lib_clearok.c */
 204
 205 #undef clearok
 206 int     clearok(
 207                 WINDOW  *win,
 208                 NCURSES_BOOL flag)
 209                 { return(*(int *)0); }
 210
 211 /* ./base/lib_clrbot.c */
 212
 213 #undef wclrtobot
 214 int     wclrtobot(
 215                 WINDOW  *win)
 216                 { return(*(int *)0); }
 217
 218 /* ./base/lib_clreol.c */
 219
 220 #undef wclrtoeol
 221 int     wclrtoeol(
 222                 WINDOW  *win)
 223                 { return(*(int *)0); }
 224
 225 /* ./base/lib_color.c */
 226
 227 #include <tic.h>
 228
 229 #undef COLOR_PAIRS
 230 int     COLOR_PAIRS;
 231 #undef COLORS
 232 int     COLORS;
 233
 234 #undef _nc_reset_colors
 235 NCURSES_BOOL _nc_reset_colors(void)
 236                 { return(*(NCURSES_BOOL *)0); }
 237
 238 #undef start_color
 239 int     start_color(void)
 240                 { return(*(int *)0); }
 241
 242 #undef init_pair
 243 int     init_pair(
 244                 short   pair,
 245                 short   f,
 246                 short   b)
 247                 { return(*(int *)0); }
 248
 249 #undef init_color
 250 int     init_color(
 251                 short   color,
 252                 short   r,
 253                 short   g,
 254                 short   b)
 255                 { return(*(int *)0); }
 256
 257 #undef can_change_color
 258 NCURSES_BOOL can_change_color(void)
 259                 { return(*(NCURSES_BOOL *)0); }
 260
 261 #undef has_colors
 262 NCURSES_BOOL has_colors(void)
 263                 { return(*(NCURSES_BOOL *)0); }
 264
 265 #undef color_content
 266 int     color_content(
 267                 short   color,
 268                 short   *r,
 269                 short   *g,
 270                 short   *b)
 271                 { return(*(int *)0); }
 272
 273 #undef pair_content
 274 int     pair_content(
 275                 short   pair,
 276                 short   *f,
 277                 short   *b)
 278                 { return(*(int *)0); }
 279
 280 #undef _nc_do_color
 281 void    _nc_do_color(
 282                 int     old_pair,
 283                 int     pair,
 284                 NCURSES_BOOL reverse,
 285                 int     (*outc)(
 286                 int     p1))
 287                 { /* void */ }
 288
 289 /* ./base/lib_colorset.c */
 290
 291 #undef wcolor_set
 292 int     wcolor_set(
 293                 WINDOW  *win,
 294                 short   color_pair_number,
 295                 void    *opts)
 296                 { return(*(int *)0); }
 297
 298 /* ./base/lib_delch.c */
 299
 300 #undef wdelch
 301 int     wdelch(
 302                 WINDOW  *win)
 303                 { return(*(int *)0); }
 304
 305 /* ./base/lib_delwin.c */
 306
 307 #undef delwin
 308 int     delwin(
 309                 WINDOW  *win)
 310                 { return(*(int *)0); }
 311
 312 /* ./base/lib_echo.c */
 313
 314 #undef echo
 315 int     echo(void)
 316                 { return(*(int *)0); }
 317
 318 #undef noecho
 319 int     noecho(void)
 320                 { return(*(int *)0); }
 321
 322 /* ./base/lib_endwin.c */
 323
 324 #undef endwin
 325 int     endwin(void)
 326                 { return(*(int *)0); }
 327
 328 /* ./base/lib_erase.c */
 329
 330 #undef werase
 331 int     werase(
 332                 WINDOW  *win)
 333                 { return(*(int *)0); }
 334
 335 /* ./base/lib_flash.c */
 336
 337 #undef flash
 338 int     flash(void)
 339                 { return(*(int *)0); }
 340
 341 /* ./lib_gen.c */
 342
 343 #undef addch
 344 int     addch(
 345                 const chtype z)
 346                 { return(*(int *)0); }
 347
 348 #undef addchnstr
 349 int     addchnstr(
 350                 const chtype *a1,
 351                 int     z)
 352                 { return(*(int *)0); }
 353
 354 #undef addchstr
 355 int     addchstr(
 356                 const chtype *z)
 357                 { return(*(int *)0); }
 358
 359 #undef addnstr
 360 int     addnstr(
 361                 const char *a1,
 362                 int     z)
 363                 { return(*(int *)0); }
 364
 365 #undef addstr
 366 int     addstr(
 367                 const char *z)
 368                 { return(*(int *)0); }
 369
 370 #undef attroff
 371 int     attroff(
 372                 NCURSES_ATTR_T  z)
 373                 { return(*(int *)0); }
 374
 375 #undef attron
 376 int     attron(
 377                 NCURSES_ATTR_T  z)
 378                 { return(*(int *)0); }
 379
 380 #undef attrset
 381 int     attrset(
 382                 NCURSES_ATTR_T  z)
 383                 { return(*(int *)0); }
 384
 385 #undef attr_get
 386 int     attr_get(
 387                 attr_t  *a1,
 388                 short   *a2,
 389                 void    *z)
 390                 { return(*(int *)0); }
 391
 392 #undef attr_off
 393 int     attr_off(
 394                 attr_t  a1,
 395                 void    *z)
 396                 { return(*(int *)0); }
 397
 398 #undef attr_on
 399 int     attr_on(
 400                 attr_t  a1,
 401                 void    *z)
 402                 { return(*(int *)0); }
 403
 404 #undef attr_set
 405 int     attr_set(
 406                 attr_t  a1,
 407                 short   a2,
 408                 void    *z)
 409                 { return(*(int *)0); }
 410
 411 #undef bkgd
 412 int     bkgd(
 413                 chtype  z)
 414                 { return(*(int *)0); }
 415
 416 #undef bkgdset
 417 void    bkgdset(
 418                 chtype  z)
 419                 { /* void */ }
 420
 421 #undef border
 422 int     border(
 423                 chtype  a1,
 424                 chtype  a2,
 425                 chtype  a3,
 426                 chtype  a4,
 427                 chtype  a5,
 428                 chtype  a6,
 429                 chtype  a7,
 430                 chtype  z)
 431                 { return(*(int *)0); }
 432
 433 #undef box
 434 int     box(
 435                 WINDOW  *a1,
 436                 chtype  a2,
 437                 chtype  z)
 438                 { return(*(int *)0); }
 439
 440 #undef chgat
 441 int     chgat(
 442                 int     a1,
 443                 attr_t  a2,
 444                 short   a3,
 445                 const void *z)
 446                 { return(*(int *)0); }
 447
 448 #undef clear
 449 int     clear(void)
 450                 { return(*(int *)0); }
 451
 452 #undef clrtobot
 453 int     clrtobot(void)
 454                 { return(*(int *)0); }
 455
 456 #undef clrtoeol
 457 int     clrtoeol(void)
 458                 { return(*(int *)0); }
 459
 460 #undef color_set
 461 int     color_set(
 462                 short   a1,
 463                 void    *z)
 464                 { return(*(int *)0); }
 465
 466 #undef COLOR_PAIR
 467 int     COLOR_PAIR(
 468                 int     z)
 469                 { return(*(int *)0); }
 470
 471 #undef delch
 472 int     delch(void)
 473                 { return(*(int *)0); }
 474
 475 #undef deleteln
 476 int     deleteln(void)
 477                 { return(*(int *)0); }
 478
 479 #undef echochar
 480 int     echochar(
 481                 const chtype z)
 482                 { return(*(int *)0); }
 483
 484 #undef erase
 485 int     erase(void)
 486                 { return(*(int *)0); }
 487
 488 #undef getbkgd
 489 chtype  getbkgd(
 490                 WINDOW  *z)
 491                 { return(*(chtype *)0); }
 492
 493 #undef getch
 494 int     getch(void)
 495                 { return(*(int *)0); }
 496
 497 #undef getnstr
 498 int     getnstr(
 499                 char    *a1,
 500                 int     z)
 501                 { return(*(int *)0); }
 502
 503 #undef getstr
 504 int     getstr(
 505                 char    *z)
 506                 { return(*(int *)0); }
 507
 508 #undef hline
 509 int     hline(
 510                 chtype  a1,
 511                 int     z)
 512                 { return(*(int *)0); }
 513
 514 #undef inch
 515 chtype  inch(void)
 516                 { return(*(chtype *)0); }
 517
 518 #undef inchnstr
 519 int     inchnstr(
 520                 chtype  *a1,
 521                 int     z)
 522                 { return(*(int *)0); }
 523
 524 #undef inchstr
 525 int     inchstr(
 526                 chtype  *z)
 527                 { return(*(int *)0); }
 528
 529 #undef innstr
 530 int     innstr(
 531                 char    *a1,
 532                 int     z)
 533                 { return(*(int *)0); }
 534
 535 #undef insch
 536 int     insch(
 537                 chtype  z)
 538                 { return(*(int *)0); }
 539
 540 #undef insdelln
 541 int     insdelln(
 542                 int     z)
 543                 { return(*(int *)0); }
 544
 545 #undef insertln
 546 int     insertln(void)
 547                 { return(*(int *)0); }
 548
 549 #undef insnstr
 550 int     insnstr(
 551                 const char *a1,
 552                 int     z)
 553                 { return(*(int *)0); }
 554
 555 #undef insstr
 556 int     insstr(
 557                 const char *z)
 558                 { return(*(int *)0); }
 559
 560 #undef instr
 561 int     instr(
 562                 char    *z)
 563                 { return(*(int *)0); }
 564
 565 #undef move
 566 int     move(
 567                 int     a1,
 568                 int     z)
 569                 { return(*(int *)0); }
 570
 571 #undef mvaddch
 572 int     mvaddch(
 573                 int     a1,
 574                 int     a2,
 575                 const chtype z)
 576                 { return(*(int *)0); }
 577
 578 #undef mvaddchnstr
 579 int     mvaddchnstr(
 580                 int     a1,
 581                 int     a2,
 582                 const chtype *a3,
 583                 int     z)
 584                 { return(*(int *)0); }
 585
 586 #undef mvaddchstr
 587 int     mvaddchstr(
 588                 int     a1,
 589                 int     a2,
 590                 const chtype *z)
 591                 { return(*(int *)0); }
 592
 593 #undef mvaddnstr
 594 int     mvaddnstr(
 595                 int     a1,
 596                 int     a2,
 597                 const char *a3,
 598                 int     z)
 599                 { return(*(int *)0); }
 600
 601 #undef mvaddstr
 602 int     mvaddstr(
 603                 int     a1,
 604                 int     a2,
 605                 const char *z)
 606                 { return(*(int *)0); }
 607
 608 #undef mvchgat
 609 int     mvchgat(
 610                 int     a1,
 611                 int     a2,
 612                 int     a3,
 613                 attr_t  a4,
 614                 short   a5,
 615                 const void *z)
 616                 { return(*(int *)0); }
 617
 618 #undef mvdelch
 619 int     mvdelch(
 620                 int     a1,
 621                 int     z)
 622                 { return(*(int *)0); }
 623
 624 #undef mvgetch
 625 int     mvgetch(
 626                 int     a1,
 627                 int     z)
 628                 { return(*(int *)0); }
 629
 630 #undef mvgetnstr
 631 int     mvgetnstr(
 632                 int     a1,
 633                 int     a2,
 634                 char    *a3,
 635                 int     z)
 636                 { return(*(int *)0); }
 637
 638 #undef mvgetstr
 639 int     mvgetstr(
 640                 int     a1,
 641                 int     a2,
 642                 char    *z)
 643                 { return(*(int *)0); }
 644
 645 #undef mvhline
 646 int     mvhline(
 647                 int     a1,
 648                 int     a2,
 649                 chtype  a3,
 650                 int     z)
 651                 { return(*(int *)0); }
 652
 653 #undef mvinch
 654 chtype  mvinch(
 655                 int     a1,
 656                 int     z)
 657                 { return(*(chtype *)0); }
 658
 659 #undef mvinchnstr
 660 int     mvinchnstr(
 661                 int     a1,
 662                 int     a2,
 663                 chtype  *a3,
 664                 int     z)
 665                 { return(*(int *)0); }
 666
 667 #undef mvinchstr
 668 int     mvinchstr(
 669                 int     a1,
 670                 int     a2,
 671                 chtype  *z)
 672                 { return(*(int *)0); }
 673
 674 #undef mvinnstr
 675 int     mvinnstr(
 676                 int     a1,
 677                 int     a2,
 678                 char    *a3,
 679                 int     z)
 680                 { return(*(int *)0); }
 681
 682 #undef mvinsch
 683 int     mvinsch(
 684                 int     a1,
 685                 int     a2,
 686                 chtype  z)
 687                 { return(*(int *)0); }
 688
 689 #undef mvinsnstr
 690 int     mvinsnstr(
 691                 int     a1,
 692                 int     a2,
 693                 const char *a3,
 694                 int     z)
 695                 { return(*(int *)0); }
 696
 697 #undef mvinsstr
 698 int     mvinsstr(
 699                 int     a1,
 700                 int     a2,
 701                 const char *z)
 702                 { return(*(int *)0); }
 703
 704 #undef mvinstr
 705 int     mvinstr(
 706                 int     a1,
 707                 int     a2,
 708                 char    *z)
 709                 { return(*(int *)0); }
 710
 711 #undef mvvline
 712 int     mvvline(
 713                 int     a1,
 714                 int     a2,
 715                 chtype  a3,
 716                 int     z)
 717                 { return(*(int *)0); }
 718
 719 #undef mvwaddch
 720 int     mvwaddch(
 721                 WINDOW  *a1,
 722                 int     a2,
 723                 int     a3,
 724                 const chtype z)
 725                 { return(*(int *)0); }
 726
 727 #undef mvwaddchnstr
 728 int     mvwaddchnstr(
 729                 WINDOW  *a1,
 730                 int     a2,
 731                 int     a3,
 732                 const chtype *a4,
 733                 int     z)
 734                 { return(*(int *)0); }
 735
 736 #undef mvwaddchstr
 737 int     mvwaddchstr(
 738                 WINDOW  *a1,
 739                 int     a2,
 740                 int     a3,
 741                 const chtype *z)
 742                 { return(*(int *)0); }
 743
 744 #undef mvwaddnstr
 745 int     mvwaddnstr(
 746                 WINDOW  *a1,
 747                 int     a2,
 748                 int     a3,
 749                 const char *a4,
 750                 int     z)
 751                 { return(*(int *)0); }
 752
 753 #undef mvwaddstr
 754 int     mvwaddstr(
 755                 WINDOW  *a1,
 756                 int     a2,
 757                 int     a3,
 758                 const char *z)
 759                 { return(*(int *)0); }
 760
 761 #undef mvwchgat
 762 int     mvwchgat(
 763                 WINDOW  *a1,
 764                 int     a2,
 765                 int     a3,
 766                 int     a4,
 767                 attr_t  a5,
 768                 short   a6,
 769                 const void *z)
 770                 { return(*(int *)0); }
 771
 772 #undef mvwdelch
 773 int     mvwdelch(
 774                 WINDOW  *a1,
 775                 int     a2,
 776                 int     z)
 777                 { return(*(int *)0); }
 778
 779 #undef mvwgetch
 780 int     mvwgetch(
 781                 WINDOW  *a1,
 782                 int     a2,
 783                 int     z)
 784                 { return(*(int *)0); }
 785
 786 #undef mvwgetnstr
 787 int     mvwgetnstr(
 788                 WINDOW  *a1,
 789                 int     a2,
 790                 int     a3,
 791                 char    *a4,
 792                 int     z)
 793                 { return(*(int *)0); }
 794
 795 #undef mvwgetstr
 796 int     mvwgetstr(
 797                 WINDOW  *a1,
 798                 int     a2,
 799                 int     a3,
 800                 char    *z)
 801                 { return(*(int *)0); }
 802
 803 #undef mvwhline
 804 int     mvwhline(
 805                 WINDOW  *a1,
 806                 int     a2,
 807                 int     a3,
 808                 chtype  a4,
 809                 int     z)
 810                 { return(*(int *)0); }
 811
 812 #undef mvwinch
 813 chtype  mvwinch(
 814                 WINDOW  *a1,
 815                 int     a2,
 816                 int     z)
 817                 { return(*(chtype *)0); }
 818
 819 #undef mvwinchnstr
 820 int     mvwinchnstr(
 821                 WINDOW  *a1,
 822                 int     a2,
 823                 int     a3,
 824                 chtype  *a4,
 825                 int     z)
 826                 { return(*(int *)0); }
 827
 828 #undef mvwinchstr
 829 int     mvwinchstr(
 830                 WINDOW  *a1,
 831                 int     a2,
 832                 int     a3,
 833                 chtype  *z)
 834                 { return(*(int *)0); }
 835
 836 #undef mvwinnstr
 837 int     mvwinnstr(
 838                 WINDOW  *a1,
 839                 int     a2,
 840                 int     a3,
 841                 char    *a4,
 842                 int     z)
 843                 { return(*(int *)0); }
 844
 845 #undef mvwinsch
 846 int     mvwinsch(
 847                 WINDOW  *a1,
 848                 int     a2,
 849                 int     a3,
 850                 chtype  z)
 851                 { return(*(int *)0); }
 852
 853 #undef mvwinsnstr
 854 int     mvwinsnstr(
 855                 WINDOW  *a1,
 856                 int     a2,
 857                 int     a3,
 858                 const char *a4,
 859                 int     z)
 860                 { return(*(int *)0); }
 861
 862 #undef mvwinsstr
 863 int     mvwinsstr(
 864                 WINDOW  *a1,
 865                 int     a2,
 866                 int     a3,
 867                 const char *z)
 868                 { return(*(int *)0); }
 869
 870 #undef mvwinstr
 871 int     mvwinstr(
 872                 WINDOW  *a1,
 873                 int     a2,
 874                 int     a3,
 875                 char    *z)
 876                 { return(*(int *)0); }
 877
 878 #undef mvwvline
 879 int     mvwvline(
 880                 WINDOW  *a1,
 881                 int     a2,
 882                 int     a3,
 883                 chtype  a4,
 884                 int     z)
 885                 { return(*(int *)0); }
 886
 887 #undef PAIR_NUMBER
 888 int     PAIR_NUMBER(
 889                 int     z)
 890                 { return(*(int *)0); }
 891
 892 #undef redrawwin
 893 int     redrawwin(
 894                 WINDOW  *z)
 895                 { return(*(int *)0); }
 896
 897 #undef refresh
 898 int     refresh(void)
 899                 { return(*(int *)0); }
 900
 901 #undef scrl
 902 int     scrl(
 903                 int     z)
 904                 { return(*(int *)0); }
 905
 906 #undef scroll
 907 int     scroll(
 908                 WINDOW  *z)
 909                 { return(*(int *)0); }
 910
 911 #undef setscrreg
 912 int     setscrreg(
 913                 int     a1,
 914                 int     z)
 915                 { return(*(int *)0); }
 916
 917 #undef slk_attr_off
 918 int     slk_attr_off(
 919                 const attr_t a1,
 920                 void    *z)
 921                 { return(*(int *)0); }
 922
 923 #undef slk_attr_on
 924 int     slk_attr_on(
 925                 attr_t  a1,
 926                 void    *z)
 927                 { return(*(int *)0); }
 928
 929 #undef standout
 930 int     standout(void)
 931                 { return(*(int *)0); }
 932
 933 #undef standend
 934 int     standend(void)
 935                 { return(*(int *)0); }
 936
 937 #undef timeout
 938 void    timeout(
 939                 int     z)
 940                 { /* void */ }
 941
 942 #undef touchline
 943 int     touchline(
 944                 WINDOW  *a1,
 945                 int     a2,
 946                 int     z)
 947                 { return(*(int *)0); }
 948
 949 #undef touchwin
 950 int     touchwin(
 951                 WINDOW  *z)
 952                 { return(*(int *)0); }
 953
 954 #undef untouchwin
 955 int     untouchwin(
 956                 WINDOW  *z)
 957                 { return(*(int *)0); }
 958
 959 #undef vline
 960 int     vline(
 961                 chtype  a1,
 962                 int     z)
 963                 { return(*(int *)0); }
 964
 965 #undef vw_printw
 966 int     vw_printw(
 967                 WINDOW  *a1,
 968                 const char *a2,
 969                 va_list z)
 970                 { return(*(int *)0); }
 971
 972 #undef vw_scanw
 973 int     vw_scanw(
 974                 WINDOW  *a1,
 975                 char    *a2,
 976                 va_list z)
 977                 { return(*(int *)0); }
 978
 979 #undef waddchstr
 980 int     waddchstr(
 981                 WINDOW  *a1,
 982                 const chtype *z)
 983                 { return(*(int *)0); }
 984
 985 #undef waddstr
 986 int     waddstr(
 987                 WINDOW  *a1,
 988                 const char *z)
 989                 { return(*(int *)0); }
 990
 991 #undef wattron
 992 int     wattron(
 993                 WINDOW  *a1,
 994                 int     z)
 995                 { return(*(int *)0); }
 996
 997 #undef wattroff
 998 int     wattroff(
 999                 WINDOW  *a1,
1000                 int     z)
1001                 { return(*(int *)0); }
1002
1003 #undef wattrset
1004 int     wattrset(
1005                 WINDOW  *a1,
1006                 int     z)
1007                 { return(*(int *)0); }
1008
1009 #undef wattr_get
1010 int     wattr_get(
1011                 WINDOW  *a1,
1012                 attr_t  *a2,
1013                 short   *a3,
1014                 void    *z)
1015                 { return(*(int *)0); }
1016
1017 #undef wattr_set
1018 int     wattr_set(
1019                 WINDOW  *a1,
1020                 attr_t  a2,
1021                 short   a3,
1022                 void    *z)
1023                 { return(*(int *)0); }
1024
1025 #undef wdeleteln
1026 int     wdeleteln(
1027                 WINDOW  *z)
1028                 { return(*(int *)0); }
1029
1030 #undef wgetstr
1031 int     wgetstr(
1032                 WINDOW  *a1,
1033                 char    *z)
1034                 { return(*(int *)0); }
1035
1036 #undef winchstr
1037 int     winchstr(
1038                 WINDOW  *a1,
1039                 chtype  *z)
1040                 { return(*(int *)0); }
1041
1042 #undef winsertln
1043 int     winsertln(
1044                 WINDOW  *z)
1045                 { return(*(int *)0); }
1046
1047 #undef winsstr
1048 int     winsstr(
1049                 WINDOW  *a1,
1050                 const char *z)
1051                 { return(*(int *)0); }
1052
1053 #undef winstr
1054 int     winstr(
1055                 WINDOW  *a1,
1056                 char    *z)
1057                 { return(*(int *)0); }
1058
1059 #undef wstandout
1060 int     wstandout(
1061                 WINDOW  *z)
1062                 { return(*(int *)0); }
1063
1064 #undef wstandend
1065 int     wstandend(
1066                 WINDOW  *z)
1067                 { return(*(int *)0); }
1068
1069 #undef add_wch
1070 int     add_wch(
1071                 const cchar_t *z)
1072                 { return(*(int *)0); }
1073
1074 #undef add_wchnstr
1075 int     add_wchnstr(
1076                 const cchar_t *a1,
1077                 int     z)
1078                 { return(*(int *)0); }
1079
1080 #undef add_wchstr
1081 int     add_wchstr(
1082                 const cchar_t *z)
1083                 { return(*(int *)0); }
1084
1085 #undef addnwstr
1086 int     addnwstr(
1087                 const wchar_t *a1,
1088                 int     z)
1089                 { return(*(int *)0); }
1090
1091 #undef addwstr
1092 int     addwstr(
1093                 const wchar_t *z)
1094                 { return(*(int *)0); }
1095
1096 #undef bkgrnd
1097 int     bkgrnd(
1098                 const cchar_t *z)
1099                 { return(*(int *)0); }
1100
1101 #undef bkgrndset
1102 void    bkgrndset(
1103                 const cchar_t *z)
1104                 { /* void */ }
1105
1106 #undef border_set
1107 int     border_set(
1108                 const cchar_t *a1,
1109                 const cchar_t *a2,
1110                 const cchar_t *a3,
1111                 const cchar_t *a4,
1112                 const cchar_t *a5,
1113                 const cchar_t *a6,
1114                 const cchar_t *a7,
1115                 const cchar_t *z)
1116                 { return(*(int *)0); }
1117
1118 #undef box_set
1119 int     box_set(
1120                 WINDOW  *a1,
1121                 const cchar_t *a2,
1122                 const cchar_t *z)
1123                 { return(*(int *)0); }
1124
1125 #undef echo_wchar
1126 int     echo_wchar(
1127                 const cchar_t *z)
1128                 { return(*(int *)0); }
1129
1130 #undef get_wch
1131 int     get_wch(
1132                 wint_t  *z)
1133                 { return(*(int *)0); }
1134
1135 #undef get_wstr
1136 int     get_wstr(
1137                 wint_t  *z)
1138                 { return(*(int *)0); }
1139
1140 #undef getbkgrnd
1141 int     getbkgrnd(
1142                 cchar_t *z)
1143                 { return(*(int *)0); }
1144
1145 #undef getn_wstr
1146 int     getn_wstr(
1147                 wint_t  *a1,
1148                 int     z)
1149                 { return(*(int *)0); }
1150
1151 #undef hline_set
1152 int     hline_set(
1153                 const cchar_t *a1,
1154                 int     z)
1155                 { return(*(int *)0); }
1156
1157 #undef in_wch
1158 int     in_wch(
1159                 cchar_t *z)
1160                 { return(*(int *)0); }
1161
1162 #undef in_wchnstr
1163 int     in_wchnstr(
1164                 cchar_t *a1,
1165                 int     z)
1166                 { return(*(int *)0); }
1167
1168 #undef in_wchstr
1169 int     in_wchstr(
1170                 cchar_t *z)
1171                 { return(*(int *)0); }
1172
1173 #undef innwstr
1174 int     innwstr(
1175                 wchar_t *a1,
1176                 int     z)
1177                 { return(*(int *)0); }
1178
1179 #undef ins_nwstr
1180 int     ins_nwstr(
1181                 const wchar_t *a1,
1182                 int     z)
1183                 { return(*(int *)0); }
1184
1185 #undef ins_wch
1186 int     ins_wch(
1187                 const cchar_t *z)
1188                 { return(*(int *)0); }
1189
1190 #undef ins_wstr
1191 int     ins_wstr(
1192                 const wchar_t *z)
1193                 { return(*(int *)0); }
1194
1195 #undef inwstr
1196 int     inwstr(
1197                 wchar_t *z)
1198                 { return(*(int *)0); }
1199
1200 #undef mvadd_wch
1201 int     mvadd_wch(
1202                 int     a1,
1203                 int     a2,
1204                 const cchar_t *z)
1205                 { return(*(int *)0); }
1206
1207 #undef mvadd_wchnstr
1208 int     mvadd_wchnstr(
1209                 int     a1,
1210                 int     a2,
1211                 const cchar_t *a3,
1212                 int     z)
1213                 { return(*(int *)0); }
1214
1215 #undef mvadd_wchstr
1216 int     mvadd_wchstr(
1217                 int     a1,
1218                 int     a2,
1219                 const cchar_t *z)
1220                 { return(*(int *)0); }
1221
1222 #undef mvaddnwstr
1223 int     mvaddnwstr(
1224                 int     a1,
1225                 int     a2,
1226                 const wchar_t *a3,
1227                 int     z)
1228                 { return(*(int *)0); }
1229
1230 #undef mvaddwstr
1231 int     mvaddwstr(
1232                 int     a1,
1233                 int     a2,
1234                 const wchar_t *z)
1235                 { return(*(int *)0); }
1236
1237 #undef mvget_wch
1238 int     mvget_wch(
1239                 int     a1,
1240                 int     a2,
1241                 wint_t  *z)
1242                 { return(*(int *)0); }
1243
1244 #undef mvget_wstr
1245 int     mvget_wstr(
1246                 int     a1,
1247                 int     a2,
1248                 wint_t  *z)
1249                 { return(*(int *)0); }
1250
1251 #undef mvgetn_wstr
1252 int     mvgetn_wstr(
1253                 int     a1,
1254                 int     a2,
1255                 wint_t  *a3,
1256                 int     z)
1257                 { return(*(int *)0); }
1258
1259 #undef mvhline_set
1260 int     mvhline_set(
1261                 int     a1,
1262                 int     a2,
1263                 const cchar_t *a3,
1264                 int     z)
1265                 { return(*(int *)0); }
1266
1267 #undef mvin_wch
1268 int     mvin_wch(
1269                 int     a1,
1270                 int     a2,
1271                 cchar_t *z)
1272                 { return(*(int *)0); }
1273
1274 #undef mvin_wchnstr
1275 int     mvin_wchnstr(
1276                 int     a1,
1277                 int     a2,
1278                 cchar_t *a3,
1279                 int     z)
1280                 { return(*(int *)0); }
1281
1282 #undef mvin_wchstr
1283 int     mvin_wchstr(
1284                 int     a1,
1285                 int     a2,
1286                 cchar_t *z)
1287                 { return(*(int *)0); }
1288
1289 #undef mvinnwstr
1290 int     mvinnwstr(
1291                 int     a1,
1292                 int     a2,
1293                 wchar_t *a3,
1294                 int     z)
1295                 { return(*(int *)0); }
1296
1297 #undef mvins_nwstr
1298 int     mvins_nwstr(
1299                 int     a1,
1300                 int     a2,
1301                 const wchar_t *a3,
1302                 int     z)
1303                 { return(*(int *)0); }
1304
1305 #undef mvins_wch
1306 int     mvins_wch(
1307                 int     a1,
1308                 int     a2,
1309                 const cchar_t *z)
1310                 { return(*(int *)0); }
1311
1312 #undef mvins_wstr
1313 int     mvins_wstr(
1314                 int     a1,
1315                 int     a2,
1316                 const wchar_t *z)
1317                 { return(*(int *)0); }
1318
1319 #undef mvinwstr
1320 int     mvinwstr(
1321                 int     a1,
1322                 int     a2,
1323                 wchar_t *z)
1324                 { return(*(int *)0); }
1325
1326 #undef mvvline_set
1327 int     mvvline_set(
1328                 int     a1,
1329                 int     a2,
1330                 const cchar_t *a3,
1331                 int     z)
1332                 { return(*(int *)0); }
1333
1334 #undef mvwadd_wch
1335 int     mvwadd_wch(
1336                 WINDOW  *a1,
1337                 int     a2,
1338                 int     a3,
1339                 const cchar_t *z)
1340                 { return(*(int *)0); }
1341
1342 #undef mvwadd_wchnstr
1343 int     mvwadd_wchnstr(
1344                 WINDOW  *a1,
1345                 int     a2,
1346                 int     a3,
1347                 const cchar_t *a4,
1348                 int     z)
1349                 { return(*(int *)0); }
1350
1351 #undef mvwadd_wchstr
1352 int     mvwadd_wchstr(
1353                 WINDOW  *a1,
1354                 int     a2,
1355                 int     a3,
1356                 const cchar_t *z)
1357                 { return(*(int *)0); }
1358
1359 #undef mvwaddnwstr
1360 int     mvwaddnwstr(
1361                 WINDOW  *a1,
1362                 int     a2,
1363                 int     a3,
1364                 const wchar_t *a4,
1365                 int     z)
1366                 { return(*(int *)0); }
1367
1368 #undef mvwaddwstr
1369 int     mvwaddwstr(
1370                 WINDOW  *a1,
1371                 int     a2,
1372                 int     a3,
1373                 const wchar_t *z)
1374                 { return(*(int *)0); }
1375
1376 #undef mvwget_wch
1377 int     mvwget_wch(
1378                 WINDOW  *a1,
1379                 int     a2,
1380                 int     a3,
1381                 wint_t  *z)
1382                 { return(*(int *)0); }
1383
1384 #undef mvwget_wstr
1385 int     mvwget_wstr(
1386                 WINDOW  *a1,
1387                 int     a2,
1388                 int     a3,
1389                 wint_t  *z)
1390                 { return(*(int *)0); }
1391
1392 #undef mvwgetn_wstr
1393 int     mvwgetn_wstr(
1394                 WINDOW  *a1,
1395                 int     a2,
1396                 int     a3,
1397                 wint_t  *a4,
1398                 int     z)
1399                 { return(*(int *)0); }
1400
1401 #undef mvwhline_set
1402 int     mvwhline_set(
1403                 WINDOW  *a1,
1404                 int     a2,
1405                 int     a3,
1406                 const cchar_t *a4,
1407                 int     z)
1408                 { return(*(int *)0); }
1409
1410 #undef mvwin_wch
1411 int     mvwin_wch(
1412                 WINDOW  *a1,
1413                 int     a2,
1414                 int     a3,
1415                 cchar_t *z)
1416                 { return(*(int *)0); }
1417
1418 #undef mvwin_wchnstr
1419 int     mvwin_wchnstr(
1420                 WINDOW  *a1,
1421                 int     a2,
1422                 int     a3,
1423                 cchar_t *a4,
1424                 int     z)
1425                 { return(*(int *)0); }
1426
1427 #undef mvwin_wchstr
1428 int     mvwin_wchstr(
1429                 WINDOW  *a1,
1430                 int     a2,
1431                 int     a3,
1432                 cchar_t *z)
1433                 { return(*(int *)0); }
1434
1435 #undef mvwinnwstr
1436 int     mvwinnwstr(
1437                 WINDOW  *a1,
1438                 int     a2,
1439                 int     a3,
1440                 wchar_t *a4,
1441                 int     z)
1442                 { return(*(int *)0); }
1443
1444 #undef mvwins_nwstr
1445 int     mvwins_nwstr(
1446                 WINDOW  *a1,
1447                 int     a2,
1448                 int     a3,
1449                 const wchar_t *a4,
1450                 int     z)
1451                 { return(*(int *)0); }
1452
1453 #undef mvwins_wch
1454 int     mvwins_wch(
1455                 WINDOW  *a1,
1456                 int     a2,
1457                 int     a3,
1458                 const cchar_t *z)
1459                 { return(*(int *)0); }
1460
1461 #undef mvwins_wstr
1462 int     mvwins_wstr(
1463                 WINDOW  *a1,
1464                 int     a2,
1465                 int     a3,
1466                 const wchar_t *z)
1467                 { return(*(int *)0); }
1468
1469 #undef mvwinwstr
1470 int     mvwinwstr(
1471                 WINDOW  *a1,
1472                 int     a2,
1473                 int     a3,
1474                 wchar_t *z)
1475                 { return(*(int *)0); }
1476
1477 #undef mvwvline_set
1478 int     mvwvline_set(
1479                 WINDOW  *a1,
1480                 int     a2,
1481                 int     a3,
1482                 const cchar_t *a4,
1483                 int     z)
1484                 { return(*(int *)0); }
1485
1486 #undef vline_set
1487 int     vline_set(
1488                 const cchar_t *a1,
1489                 int     z)
1490                 { return(*(int *)0); }
1491
1492 #undef wadd_wchstr
1493 int     wadd_wchstr(
1494                 WINDOW  *a1,
1495                 const cchar_t *z)
1496                 { return(*(int *)0); }
1497
1498 #undef waddwstr
1499 int     waddwstr(
1500                 WINDOW  *a1,
1501                 const wchar_t *z)
1502                 { return(*(int *)0); }
1503
1504 #undef wget_wstr
1505 int     wget_wstr(
1506                 WINDOW  *a1,
1507                 wint_t  *z)
1508                 { return(*(int *)0); }
1509
1510 #undef win_wchstr
1511 int     win_wchstr(
1512                 WINDOW  *a1,
1513                 cchar_t *z)
1514                 { return(*(int *)0); }
1515
1516 #undef wins_wstr
1517 int     wins_wstr(
1518                 WINDOW  *a1,
1519                 const wchar_t *z)
1520                 { return(*(int *)0); }
1521
1522 #undef mouse_trafo
1523 NCURSES_BOOL    mouse_trafo(
1524                 int     *a1,
1525                 int     *a2,
1526                 NCURSES_BOOL    z)
1527                 { return(*(NCURSES_BOOL *)0); }
1528
1529 /* ./base/lib_getch.c */
1530
1531 #include <fifo_defs.h>
1532
1533 #undef ESCDELAY
1534 int     ESCDELAY;
1535
1536 #undef _nc_wgetch
1537 int     _nc_wgetch(
1538                 WINDOW  *win,
1539                 unsigned long *result,
1540                 int     use_meta)
1541                 { return(*(int *)0); }
1542
1543 #undef wgetch
1544 int     wgetch(
1545                 WINDOW  *win)
1546                 { return(*(int *)0); }
1547
1548 /* ./base/lib_getstr.c */
1549
1550 #undef wgetnstr
1551 int     wgetnstr(
1552                 WINDOW  *win,
1553                 char    *str,
1554                 int     maxlen)
1555                 { return(*(int *)0); }
1556
1557 /* ./base/lib_hline.c */
1558
1559 #undef whline
1560 int     whline(
1561                 WINDOW  *win,
1562                 chtype  ch,
1563                 int     n)
1564                 { return(*(int *)0); }
1565
1566 /* ./base/lib_immedok.c */
1567
1568 #undef immedok
1569 void    immedok(
1570                 WINDOW  *win,
1571                 NCURSES_BOOL flag)
1572                 { /* void */ }
1573
1574 /* ./base/lib_inchstr.c */
1575
1576 #undef winchnstr
1577 int     winchnstr(
1578                 WINDOW  *win,
1579                 chtype  *str,
1580                 int     n)
1581                 { return(*(int *)0); }
1582
1583 /* ./base/lib_initscr.c */
1584
1585 #undef initscr
1586 WINDOW  *initscr(void)
1587                 { return(*(WINDOW **)0); }
1588
1589 /* ./base/lib_insch.c */
1590
1591 #undef _nc_insert_ch
1592 int     _nc_insert_ch(
1593                 WINDOW  *win,
1594                 chtype  ch)
1595                 { return(*(int *)0); }
1596
1597 #undef winsch
1598 int     winsch(
1599                 WINDOW  *win,
1600                 chtype  c)
1601                 { return(*(int *)0); }
1602
1603 /* ./base/lib_insdel.c */
1604
1605 #undef winsdelln
1606 int     winsdelln(
1607                 WINDOW  *win,
1608                 int     n)
1609                 { return(*(int *)0); }
1610
1611 /* ./base/lib_insnstr.c */
1612
1613 #undef winsnstr
1614 int     winsnstr(
1615                 WINDOW  *win,
1616                 const char *s,
1617                 int     n)
1618                 { return(*(int *)0); }
1619
1620 /* ./base/lib_instr.c */
1621
1622 #undef winnstr
1623 int     winnstr(
1624                 WINDOW  *win,
1625                 char    *str,
1626                 int     n)
1627                 { return(*(int *)0); }
1628
1629 /* ./base/lib_isendwin.c */
1630
1631 #undef isendwin
1632 NCURSES_BOOL isendwin(void)
1633                 { return(*(NCURSES_BOOL *)0); }
1634
1635 /* ./base/lib_leaveok.c */
1636
1637 #undef leaveok
1638 int     leaveok(
1639                 WINDOW  *win,
1640                 NCURSES_BOOL flag)
1641                 { return(*(int *)0); }
1642
1643 /* ./base/lib_mouse.c */
1644
1645 #undef getmouse
1646 int     getmouse(
1647                 MEVENT  *aevent)
1648                 { return(*(int *)0); }
1649
1650 #undef ungetmouse
1651 int     ungetmouse(
1652                 MEVENT  *aevent)
1653                 { return(*(int *)0); }
1654
1655 #undef mousemask
1656 mmask_t mousemask(
1657                 mmask_t newmask,
1658                 mmask_t *oldmask)
1659                 { return(*(mmask_t *)0); }
1660
1661 #undef wenclose
1662 NCURSES_BOOL wenclose(
1663                 const WINDOW *win,
1664                 int     y,
1665                 int     x)
1666                 { return(*(NCURSES_BOOL *)0); }
1667
1668 #undef mouseinterval
1669 int     mouseinterval(
1670                 int     maxclick)
1671                 { return(*(int *)0); }
1672
1673 #undef _nc_has_mouse
1674 int     _nc_has_mouse(void)
1675                 { return(*(int *)0); }
1676
1677 #undef wmouse_trafo
1678 NCURSES_BOOL wmouse_trafo(
1679                 const WINDOW *win,
1680                 int     *pY,
1681                 int     *pX,
1682                 NCURSES_BOOL to_screen)
1683                 { return(*(NCURSES_BOOL *)0); }
1684
1685 /* ./base/lib_move.c */
1686
1687 #undef wmove
1688 int     wmove(
1689                 WINDOW  *win,
1690                 int     y,
1691                 int     x)
1692                 { return(*(int *)0); }
1693
1694 /* ./tty/lib_mvcur.c */
1695
1696 #undef _nc_msec_cost
1697 int     _nc_msec_cost(
1698                 const char *const cap,
1699                 int     affcnt)
1700                 { return(*(int *)0); }
1701
1702 #undef _nc_mvcur_resume
1703 void    _nc_mvcur_resume(void)
1704                 { /* void */ }
1705
1706 #undef _nc_mvcur_init
1707 void    _nc_mvcur_init(void)
1708                 { /* void */ }
1709
1710 #undef _nc_mvcur_wrap
1711 void    _nc_mvcur_wrap(void)
1712                 { /* void */ }
1713
1714 #undef mvcur
1715 int     mvcur(
1716                 int     yold,
1717                 int     xold,
1718                 int     ynew,
1719                 int     xnew)
1720                 { return(*(int *)0); }
1721
1722 #undef _nc_optimize_enable
1723 int     _nc_optimize_enable;
1724
1725 /* ./base/lib_mvwin.c */
1726
1727 #undef mvwin
1728 int     mvwin(
1729                 WINDOW  *win,
1730                 int     by,
1731                 int     bx)
1732                 { return(*(int *)0); }
1733
1734 /* ./base/lib_newterm.c */
1735
1736 #undef filter
1737 void    filter(void)
1738                 { /* void */ }
1739
1740 #undef newterm
1741 SCREEN  *newterm(
1742                 char    *name,
1743                 FILE    *ofp,
1744                 FILE    *ifp)
1745                 { return(*(SCREEN **)0); }
1746
1747 /* ./base/lib_newwin.c */
1748
1749 #undef _nc_freewin
1750 int     _nc_freewin(
1751                 WINDOW  *win)
1752                 { return(*(int *)0); }
1753
1754 #undef newwin
1755 WINDOW  *newwin(
1756                 int     num_lines,
1757                 int     num_columns,
1758                 int     begy,
1759                 int     begx)
1760                 { return(*(WINDOW **)0); }
1761
1762 #undef derwin
1763 WINDOW  *derwin(
1764                 WINDOW  *orig,
1765                 int     num_lines,
1766                 int     num_columns,
1767                 int     begy,
1768                 int     begx)
1769                 { return(*(WINDOW **)0); }
1770
1771 #undef subwin
1772 WINDOW  *subwin(
1773                 WINDOW  *w,
1774                 int     l,
1775                 int     c,
1776                 int     y,
1777                 int     x)
1778                 { return(*(WINDOW **)0); }
1779
1780 #undef _nc_makenew
1781 WINDOW  *_nc_makenew(
1782                 int     num_lines,
1783                 int     num_columns,
1784                 int     begy,
1785                 int     begx,
1786                 int     flags)
1787                 { return(*(WINDOW **)0); }
1788
1789 /* ./base/lib_nl.c */
1790
1791 #undef nl
1792 int     nl(void)
1793                 { return(*(int *)0); }
1794
1795 #undef nonl
1796 int     nonl(void)
1797                 { return(*(int *)0); }
1798
1799 /* ./base/lib_overlay.c */
1800
1801 #undef overlay
1802 int     overlay(
1803                 const WINDOW *win1,
1804                 WINDOW  *win2)
1805                 { return(*(int *)0); }
1806
1807 #undef overwrite
1808 int     overwrite(
1809                 const WINDOW *win1,
1810                 WINDOW  *win2)
1811                 { return(*(int *)0); }
1812
1813 #undef copywin
1814 int     copywin(
1815                 const WINDOW *src,
1816                 WINDOW  *dst,
1817                 int     sminrow,
1818                 int     smincol,
1819                 int     dminrow,
1820                 int     dmincol,
1821                 int     dmaxrow,
1822                 int     dmaxcol,
1823                 int     over)
1824                 { return(*(int *)0); }
1825
1826 /* ./base/lib_pad.c */
1827
1828 #undef newpad
1829 WINDOW  *newpad(
1830                 int     l,
1831                 int     c)
1832                 { return(*(WINDOW **)0); }
1833
1834 #undef subpad
1835 WINDOW  *subpad(
1836                 WINDOW  *orig,
1837                 int     l,
1838                 int     c,
1839                 int     begy,
1840                 int     begx)
1841                 { return(*(WINDOW **)0); }
1842
1843 #undef prefresh
1844 int     prefresh(
1845                 WINDOW  *win,
1846                 int     pminrow,
1847                 int     pmincol,
1848                 int     sminrow,
1849                 int     smincol,
1850                 int     smaxrow,
1851                 int     smaxcol)
1852                 { return(*(int *)0); }
1853
1854 #undef pnoutrefresh
1855 int     pnoutrefresh(
1856                 WINDOW  *win,
1857                 int     pminrow,
1858                 int     pmincol,
1859                 int     sminrow,
1860                 int     smincol,
1861                 int     smaxrow,
1862                 int     smaxcol)
1863                 { return(*(int *)0); }
1864
1865 #undef pechochar
1866 int     pechochar(
1867                 WINDOW  *pad,
1868                 const chtype ch)
1869                 { return(*(int *)0); }
1870
1871 /* ./base/lib_printw.c */
1872
1873 #undef printw
1874 int     printw(
1875                 const char *fmt,
1876                 ...)
1877                 { return(*(int *)0); }
1878
1879 #undef wprintw
1880 int     wprintw(
1881                 WINDOW  *win,
1882                 const char *fmt,
1883                 ...)
1884                 { return(*(int *)0); }
1885
1886 #undef mvprintw
1887 int     mvprintw(
1888                 int     y,
1889                 int     x,
1890                 const char *fmt,
1891                 ...)
1892                 { return(*(int *)0); }
1893
1894 #undef mvwprintw
1895 int     mvwprintw(
1896                 WINDOW  *win,
1897                 int     y,
1898                 int     x,
1899                 const char *fmt,
1900                 ...)
1901                 { return(*(int *)0); }
1902
1903 #undef vwprintw
1904 int     vwprintw(
1905                 WINDOW  *win,
1906                 const char *fmt,
1907                 va_list argp)
1908                 { return(*(int *)0); }
1909
1910 /* ./base/lib_redrawln.c */
1911
1912 #undef wredrawln
1913 int     wredrawln(
1914                 WINDOW  *win,
1915                 int     beg,
1916                 int     num)
1917                 { return(*(int *)0); }
1918
1919 /* ./base/lib_refresh.c */
1920
1921 #undef wrefresh
1922 int     wrefresh(
1923                 WINDOW  *win)
1924                 { return(*(int *)0); }
1925
1926 #undef wnoutrefresh
1927 int     wnoutrefresh(
1928                 WINDOW  *win)
1929                 { return(*(int *)0); }
1930
1931 /* ./base/lib_restart.c */
1932
1933 #undef restartterm
1934 int     restartterm(
1935                 char    *termp,
1936                 int     filenum,
1937                 int     *errret)
1938                 { return(*(int *)0); }
1939
1940 /* ./base/lib_scanw.c */
1941
1942 #undef vwscanw
1943 int     vwscanw(
1944                 WINDOW  *win,
1945                 char    *fmt,
1946                 va_list argp)
1947                 { return(*(int *)0); }
1948
1949 #undef scanw
1950 int     scanw(
1951                 char    *fmt,
1952                 ...)
1953                 { return(*(int *)0); }
1954
1955 #undef wscanw
1956 int     wscanw(
1957                 WINDOW  *win,
1958                 char    *fmt,
1959                 ...)
1960                 { return(*(int *)0); }
1961
1962 #undef mvscanw
1963 int     mvscanw(
1964                 int     y,
1965                 int     x,
1966                 char    *fmt,
1967                 ...)
1968                 { return(*(int *)0); }
1969
1970 #undef mvwscanw
1971 int     mvwscanw(
1972                 WINDOW  *win,
1973                 int     y,
1974                 int     x,
1975                 char    *fmt,
1976                 ...)
1977                 { return(*(int *)0); }
1978
1979 /* ./base/lib_screen.c */
1980
1981 #undef getwin
1982 WINDOW  *getwin(
1983                 FILE    *filep)
1984                 { return(*(WINDOW **)0); }
1985
1986 #undef putwin
1987 int     putwin(
1988                 WINDOW  *win,
1989                 FILE    *filep)
1990                 { return(*(int *)0); }
1991
1992 #undef scr_restore
1993 int     scr_restore(
1994                 const char *file)
1995                 { return(*(int *)0); }
1996
1997 #undef scr_dump
1998 int     scr_dump(
1999                 const char *file)
2000                 { return(*(int *)0); }
2001
2002 #undef scr_init
2003 int     scr_init(
2004                 const char *file)
2005                 { return(*(int *)0); }
2006
2007 #undef scr_set
2008 int     scr_set(
2009                 const char *file)
2010                 { return(*(int *)0); }
2011
2012 /* ./base/lib_scroll.c */
2013
2014 #undef _nc_scroll_window
2015 void    _nc_scroll_window(
2016                 WINDOW  *win,
2017                 int const n,
2018                 short const top,
2019                 short const bottom,
2020                 cchar_t blank)
2021                 { /* void */ }
2022
2023 #undef wscrl
2024 int     wscrl(
2025                 WINDOW  *win,
2026                 int     n)
2027                 { return(*(int *)0); }
2028
2029 /* ./base/lib_scrollok.c */
2030
2031 #undef scrollok
2032 int     scrollok(
2033                 WINDOW  *win,
2034                 NCURSES_BOOL flag)
2035                 { return(*(int *)0); }
2036
2037 /* ./base/lib_scrreg.c */
2038
2039 #undef wsetscrreg
2040 int     wsetscrreg(
2041                 WINDOW  *win,
2042                 int     top,
2043                 int     bottom)
2044                 { return(*(int *)0); }
2045
2046 /* ./base/lib_set_term.c */
2047
2048 #undef set_term
2049 SCREEN  *set_term(
2050                 SCREEN  *screenp)
2051                 { return(*(SCREEN **)0); }
2052
2053 #undef delscreen
2054 void    delscreen(
2055                 SCREEN  *sp)
2056                 { /* void */ }
2057
2058 #undef _nc_setupscreen
2059 int     _nc_setupscreen(
2060                 short   slines,
2061                 short const scolumns,
2062                 FILE    *output)
2063                 { return(*(int *)0); }
2064
2065 #undef _nc_ripoffline
2066 int     _nc_ripoffline(
2067                 int     line,
2068                 int     (*init)(
2069                 WINDOW  *p1,
2070                 int     p2))
2071                 { return(*(int *)0); }
2072
2073 #undef ripoffline
2074 int     ripoffline(
2075                 int     line,
2076                 int     (*init)(
2077                 WINDOW  *p1,
2078                 int     p2))
2079                 { return(*(int *)0); }
2080
2081 /* ./base/lib_slk.c */
2082
2083 #undef _nc_slk_format
2084 int     _nc_slk_format;
2085
2086 #undef _nc_slk_initialize
2087 int     _nc_slk_initialize(
2088                 WINDOW  *stwin,
2089                 int     cols)
2090                 { return(*(int *)0); }
2091
2092 #undef slk_restore
2093 int     slk_restore(void)
2094                 { return(*(int *)0); }
2095
2096 /* ./base/lib_slkatr_set.c */
2097
2098 #undef slk_attr_set
2099 int     slk_attr_set(
2100                 const attr_t attr,
2101                 short   color_pair_number,
2102                 void    *opts)
2103                 { return(*(int *)0); }
2104
2105 /* ./base/lib_slkatrof.c */
2106
2107 #undef slk_attroff
2108 int     slk_attroff(
2109                 const chtype attr)
2110                 { return(*(int *)0); }
2111
2112 /* ./base/lib_slkatron.c */
2113
2114 #undef slk_attron
2115 int     slk_attron(
2116                 const chtype attr)
2117                 { return(*(int *)0); }
2118
2119 /* ./base/lib_slkatrset.c */
2120
2121 #undef slk_attrset
2122 int     slk_attrset(
2123                 const chtype attr)
2124                 { return(*(int *)0); }
2125
2126 /* ./base/lib_slkattr.c */
2127
2128 #undef slk_attr
2129 attr_t  slk_attr(void)
2130                 { return(*(attr_t *)0); }
2131
2132 /* ./base/lib_slkclear.c */
2133
2134 #undef slk_clear
2135 int     slk_clear(void)
2136                 { return(*(int *)0); }
2137
2138 /* ./base/lib_slkcolor.c */
2139
2140 #undef slk_color
2141 int     slk_color(
2142                 short   color_pair_number)
2143                 { return(*(int *)0); }
2144
2145 /* ./base/lib_slkinit.c */
2146
2147 #undef slk_init
2148 int     slk_init(
2149                 int     format)
2150                 { return(*(int *)0); }
2151
2152 /* ./base/lib_slklab.c */
2153
2154 #undef slk_label
2155 char    *slk_label(
2156                 int     n)
2157                 { return(*(char **)0); }
2158
2159 /* ./base/lib_slkrefr.c */
2160
2161 #undef slk_noutrefresh
2162 int     slk_noutrefresh(void)
2163                 { return(*(int *)0); }
2164
2165 #undef slk_refresh
2166 int     slk_refresh(void)
2167                 { return(*(int *)0); }
2168
2169 /* ./base/lib_slkset.c */
2170
2171 #include <wctype.h>
2172
2173 #undef slk_set
2174 int     slk_set(
2175                 int     i,
2176                 const char *astr,
2177                 int     format)
2178                 { return(*(int *)0); }
2179
2180 /* ./base/lib_slktouch.c */
2181
2182 #undef slk_touch
2183 int     slk_touch(void)
2184                 { return(*(int *)0); }
2185
2186 /* ./base/lib_touch.c */
2187
2188 #undef is_linetouched
2189 NCURSES_BOOL is_linetouched(
2190                 WINDOW  *win,
2191                 int     line)
2192                 { return(*(NCURSES_BOOL *)0); }
2193
2194 #undef is_wintouched
2195 NCURSES_BOOL is_wintouched(
2196                 WINDOW  *win)
2197                 { return(*(NCURSES_BOOL *)0); }
2198
2199 #undef wtouchln
2200 int     wtouchln(
2201                 WINDOW  *win,
2202                 int     y,
2203                 int     n,
2204                 int     changed)
2205                 { return(*(int *)0); }
2206
2207 /* ./trace/lib_traceatr.c */
2208
2209 #undef _traceattr2
2210 char    *_traceattr2(
2211                 int     bufnum,
2212                 attr_t  newmode)
2213                 { return(*(char **)0); }
2214
2215 #undef _traceattr
2216 char    *_traceattr(
2217                 attr_t  newmode)
2218                 { return(*(char **)0); }
2219
2220 #undef _nc_retrace_attr_t
2221 attr_t  _nc_retrace_attr_t(
2222                 attr_t  code)
2223                 { return(*(attr_t *)0); }
2224
2225 #undef _nc_altcharset_name
2226 const char *_nc_altcharset_name(
2227                 attr_t  attr,
2228                 chtype  ch)
2229                 { return(*(const char **)0); }
2230
2231 #undef _tracechtype2
2232 char    *_tracechtype2(
2233                 int     bufnum,
2234                 chtype  ch)
2235                 { return(*(char **)0); }
2236
2237 #undef _tracechtype
2238 char    *_tracechtype(
2239                 chtype  ch)
2240                 { return(*(char **)0); }
2241
2242 #undef _nc_retrace_chtype
2243 chtype  _nc_retrace_chtype(
2244                 chtype  code)
2245                 { return(*(chtype *)0); }
2246
2247 #undef _tracecchar_t2
2248 char    *_tracecchar_t2(
2249                 int     bufnum,
2250                 const cchar_t *ch)
2251                 { return(*(char **)0); }
2252
2253 #undef _tracecchar_t
2254 char    *_tracecchar_t(
2255                 const cchar_t *ch)
2256                 { return(*(char **)0); }
2257
2258 /* ./trace/lib_tracedmp.c */
2259
2260 #undef _tracedump
2261 void    _tracedump(
2262                 const char *name,
2263                 WINDOW  *win)
2264                 { /* void */ }
2265
2266 /* ./trace/lib_tracemse.c */
2267
2268 #undef _tracemouse
2269 char    *_tracemouse(
2270                 MEVENT const *ep)
2271                 { return(*(char **)0); }
2272
2273 /* ./tty/lib_tstp.c */
2274
2275 #include <SigAction.h>
2276
2277 #undef _nc_signal_handler
2278 void    _nc_signal_handler(
2279                 NCURSES_BOOL enable)
2280                 { /* void */ }
2281
2282 /* ./base/lib_ungetch.c */
2283
2284 #undef _nc_fifo_dump
2285 void    _nc_fifo_dump(void)
2286                 { /* void */ }
2287
2288 #undef ungetch
2289 int     ungetch(
2290                 int     ch)
2291                 { return(*(int *)0); }
2292
2293 /* ./tty/lib_vidattr.c */
2294
2295 #undef vidputs
2296 int     vidputs(
2297                 chtype  newmode,
2298                 int     (*outc)(
2299                 int     p1))
2300                 { return(*(int *)0); }
2301
2302 #undef vidattr
2303 int     vidattr(
2304                 chtype  newmode)
2305                 { return(*(int *)0); }
2306
2307 #undef termattrs
2308 chtype  termattrs(void)
2309                 { return(*(chtype *)0); }
2310
2311 /* ./base/lib_vline.c */
2312
2313 #undef wvline
2314 int     wvline(
2315                 WINDOW  *win,
2316                 chtype  ch,
2317                 int     n)
2318                 { return(*(int *)0); }
2319
2320 /* ./base/lib_wattroff.c */
2321
2322 #undef wattr_off
2323 int     wattr_off(
2324                 WINDOW  *win,
2325                 attr_t  at,
2326                 void    *opts)
2327                 { return(*(int *)0); }
2328
2329 /* ./base/lib_wattron.c */
2330
2331 #undef wattr_on
2332 int     wattr_on(
2333                 WINDOW  *win,
2334                 attr_t  at,
2335                 void    *opts)
2336                 { return(*(int *)0); }
2337
2338 /* ./base/lib_winch.c */
2339
2340 #undef winch
2341 chtype  winch(
2342                 WINDOW  *win)
2343                 { return(*(chtype *)0); }
2344
2345 /* ./base/lib_window.c */
2346
2347 #undef _nc_synchook
2348 void    _nc_synchook(
2349                 WINDOW  *win)
2350                 { /* void */ }
2351
2352 #undef mvderwin
2353 int     mvderwin(
2354                 WINDOW  *win,
2355                 int     y,
2356                 int     x)
2357                 { return(*(int *)0); }
2358
2359 #undef syncok
2360 int     syncok(
2361                 WINDOW  *win,
2362                 NCURSES_BOOL bf)
2363                 { return(*(int *)0); }
2364
2365 #undef wsyncup
2366 void    wsyncup(
2367                 WINDOW  *win)
2368                 { /* void */ }
2369
2370 #undef wsyncdown
2371 void    wsyncdown(
2372                 WINDOW  *win)
2373                 { /* void */ }
2374
2375 #undef wcursyncup
2376 void    wcursyncup(
2377                 WINDOW  *win)
2378                 { /* void */ }
2379
2380 #undef dupwin
2381 WINDOW  *dupwin(
2382                 WINDOW  *win)
2383                 { return(*(WINDOW **)0); }
2384
2385 /* ./base/nc_panel.c */
2386
2387 #undef _nc_panelhook
2388 struct panelhook *_nc_panelhook(void)
2389                 { return(*(struct panelhook **)0); }
2390
2391 /* ./base/safe_sprintf.c */
2392
2393 #undef _nc_printf_string
2394 char    *_nc_printf_string(
2395                 const char *fmt,
2396                 va_list ap)
2397                 { return(*(char **)0); }
2398
2399 /* ./tty/tty_update.c */
2400
2401 #include <sys/time.h>
2402 #include <sys/times.h>
2403
2404 #undef doupdate
2405 int     doupdate(void)
2406                 { return(*(int *)0); }
2407
2408 #undef _nc_scrolln
2409 int     _nc_scrolln(
2410                 int     n,
2411                 int     top,
2412                 int     bot,
2413                 int     maxy)
2414                 { return(*(int *)0); }
2415
2416 #undef _nc_screen_resume
2417 void    _nc_screen_resume(void)
2418                 { /* void */ }
2419
2420 #undef _nc_screen_init
2421 void    _nc_screen_init(void)
2422                 { /* void */ }
2423
2424 #undef _nc_screen_wrap
2425 void    _nc_screen_wrap(void)
2426                 { /* void */ }
2427
2428 #undef _nc_do_xmc_glitch
2429 void    _nc_do_xmc_glitch(
2430                 attr_t  previous)
2431                 { /* void */ }
2432
2433 /* ./trace/varargs.c */
2434
2435 typedef enum {
2436     atUnknown = 0, atInteger, atFloat, atPoint, atString
2437 } ARGTYPE;
2438
2439 #undef _nc_varargs
2440 char    *_nc_varargs(
2441                 const char *fmt,
2442                 va_list ap)
2443                 { return(*(char **)0); }
2444
2445 /* ./base/memmove.c */
2446
2447 #undef _nc_memmove
2448 void    _nc_memmove(void)
2449                 { /* void */ }
2450
2451 /* ./base/vsscanf.c */
2452
2453 #undef _nc_vsscanf
2454 void    _nc_vsscanf(void)
2455                 { /* void */ }
2456
2457 /* ./base/lib_freeall.c */
2458
2459 #include <term_entry.h>
2460
2461 #undef _nc_freeall
2462 void    _nc_freeall(void)
2463                 { /* void */ }
2464
2465 /* ./widechar/charable.c */
2466
2467 #undef _nc_is_charable
2468 NCURSES_BOOL _nc_is_charable(
2469                 wchar_t ch)
2470                 { return(*(NCURSES_BOOL *)0); }
2471
2472 #undef _nc_to_char
2473 int     _nc_to_char(
2474                 wint_t  ch)
2475                 { return(*(int *)0); }
2476
2477 #undef _nc_to_widechar
2478 wint_t  _nc_to_widechar(
2479                 int     ch)
2480                 { return(*(wint_t *)0); }
2481
2482 /* ./widechar/lib_add_wch.c */
2483
2484 #undef wadd_wch
2485 int     wadd_wch(
2486                 WINDOW  *win,
2487                 const cchar_t *wch)
2488                 { return(*(int *)0); }
2489
2490 #undef wecho_wchar
2491 int     wecho_wchar(
2492                 WINDOW  *win,
2493                 const cchar_t *wch)
2494                 { return(*(int *)0); }
2495
2496 /* ./widechar/lib_box_set.c */
2497
2498 #undef wborder_set
2499 int     wborder_set(
2500                 WINDOW  *win,
2501                 const cchar_t *ls,
2502                 const cchar_t *rs,
2503                 const cchar_t *ts,
2504                 const cchar_t *bs,
2505                 const cchar_t *tl,
2506                 const cchar_t *tr,
2507                 const cchar_t *bl,
2508                 const cchar_t *br)
2509                 { return(*(int *)0); }
2510
2511 /* ./widechar/lib_cchar.c */
2512
2513 #undef setcchar
2514 int     setcchar(
2515                 cchar_t *wcval,
2516                 const wchar_t *wch,
2517                 const attr_t attrs,
2518                 short   color_pair,
2519                 const void *opts)
2520                 { return(*(int *)0); }
2521
2522 #undef getcchar
2523 int     getcchar(
2524                 const cchar_t *wcval,
2525                 wchar_t *wch,
2526                 attr_t  *attrs,
2527                 short   *color_pair,
2528                 void    *opts)
2529                 { return(*(int *)0); }
2530
2531 /* ./widechar/lib_get_wch.c */
2532
2533 #undef wget_wch
2534 int     wget_wch(
2535                 WINDOW  *win,
2536                 wint_t  *result)
2537                 { return(*(int *)0); }
2538
2539 /* ./widechar/lib_erasewchar.c */
2540
2541 #undef erasewchar
2542 int     erasewchar(
2543                 wchar_t *wch)
2544                 { return(*(int *)0); }
2545
2546 #undef killwchar
2547 int     killwchar(
2548                 wchar_t *wch)
2549                 { return(*(int *)0); }
2550
2551 /* ./widechar/lib_get_wstr.c */
2552
2553 #undef wgetn_wstr
2554 int     wgetn_wstr(
2555                 WINDOW  *win,
2556                 wint_t  *str,
2557                 int     maxlen)
2558                 { return(*(int *)0); }
2559
2560 /* ./widechar/lib_hline_set.c */
2561
2562 #undef whline_set
2563 int     whline_set(
2564                 WINDOW  *win,
2565                 const cchar_t *ch,
2566                 int     n)
2567                 { return(*(int *)0); }
2568
2569 /* ./widechar/lib_in_wch.c */
2570
2571 #undef win_wch
2572 int     win_wch(
2573                 WINDOW  *win,
2574                 cchar_t *wcval)
2575                 { return(*(int *)0); }
2576
2577 /* ./widechar/lib_in_wchnstr.c */
2578
2579 #undef win_wchnstr
2580 int     win_wchnstr(
2581                 WINDOW  *win,
2582                 cchar_t *wchstr,
2583                 int     n)
2584                 { return(*(int *)0); }
2585
2586 /* ./widechar/lib_ins_wch.c */
2587
2588 #undef wins_wch
2589 int     wins_wch(
2590                 WINDOW  *win,
2591                 const cchar_t *wch)
2592                 { return(*(int *)0); }
2593
2594 #undef wins_nwstr
2595 int     wins_nwstr(
2596                 WINDOW  *win,
2597                 const wchar_t *wstr,
2598                 int     n)
2599                 { return(*(int *)0); }
2600
2601 /* ./widechar/lib_inwstr.c */
2602
2603 #undef winnwstr
2604 int     winnwstr(
2605                 WINDOW  *win,
2606                 wchar_t *wstr,
2607                 int     n)
2608                 { return(*(int *)0); }
2609
2610 #undef winwstr
2611 int     winwstr(
2612                 WINDOW  *win,
2613                 wchar_t *wstr)
2614                 { return(*(int *)0); }
2615
2616 /* ./widechar/lib_pecho_wchar.c */
2617
2618 #undef pecho_wchar
2619 int     pecho_wchar(
2620                 WINDOW  *pad,
2621                 const cchar_t *wch)
2622                 { return(*(int *)0); }
2623
2624 /* ./widechar/lib_slk_wset.c */
2625
2626 #undef slk_wset
2627 int     slk_wset(
2628                 int     i,
2629                 const wchar_t *astr,
2630                 int     format)
2631                 { return(*(int *)0); }
2632
2633 /* ./widechar/lib_unget_wch.c */
2634
2635 #undef _nc_wcrtomb
2636 size_t  _nc_wcrtomb(
2637                 char    *target,
2638                 wchar_t source,
2639                 mbstate_t *state)
2640                 { return(*(size_t *)0); }
2641
2642 #undef unget_wch
2643 int     unget_wch(
2644                 const wchar_t wch)
2645                 { return(*(int *)0); }
2646
2647 /* ./widechar/lib_vid_attr.c */
2648
2649 #undef vid_puts
2650 int     vid_puts(
2651                 attr_t  newmode,
2652                 short   pair,
2653                 void    *opts,
2654                 int     (*outc)(
2655                 int     p1))
2656                 { return(*(int *)0); }
2657
2658 #undef vid_attr
2659 int     vid_attr(
2660                 attr_t  newmode,
2661                 short   pair,
2662                 void    *opts)
2663                 { return(*(int *)0); }
2664
2665 #undef term_attrs
2666 attr_t  term_attrs(void)
2667                 { return(*(attr_t *)0); }
2668
2669 /* ./widechar/lib_vline_set.c */
2670
2671 #undef wvline_set
2672 int     wvline_set(
2673                 WINDOW  *win,
2674                 const cchar_t *ch,
2675                 int     n)
2676                 { return(*(int *)0); }
2677
2678 /* ./widechar/lib_wacs.c */
2679
2680 #undef _nc_wacs
2681 cchar_t *_nc_wacs;
2682
2683 #undef _nc_init_wacs
2684 void    _nc_init_wacs(void)
2685                 { /* void */ }
2686
2687 /* ./widechar/lib_wunctrl.c */
2688
2689 #undef wunctrl
2690 wchar_t *wunctrl(
2691                 cchar_t *wc)
2692                 { return(*(wchar_t **)0); }
2693
2694 /* ./expanded.c */
2695
2696 #undef _nc_toggle_attr_on
2697 void    _nc_toggle_attr_on(
2698                 attr_t  *S,
2699                 attr_t  at)
2700                 { /* void */ }
2701
2702 #undef _nc_toggle_attr_off
2703 void    _nc_toggle_attr_off(
2704                 attr_t  *S,
2705                 attr_t  at)
2706                 { /* void */ }
2707
2708 #undef _nc_DelCharCost
2709 int     _nc_DelCharCost(
2710                 int     count)
2711                 { return(*(int *)0); }
2712
2713 #undef _nc_InsCharCost
2714 int     _nc_InsCharCost(
2715                 int     count)
2716                 { return(*(int *)0); }
2717
2718 #undef _nc_UpdateAttrs
2719 void    _nc_UpdateAttrs(
2720                 cchar_t c)
2721                 { /* void */ }
2722
2723 /* ./base/lib_dft_fgbg.c */
2724
2725 #undef use_default_colors
2726 int     use_default_colors(void)
2727                 { return(*(int *)0); }
2728
2729 #undef assume_default_colors
2730 int     assume_default_colors(
2731                 int     fg,
2732                 int     bg)
2733                 { return(*(int *)0); }
2734
2735 /* ./tinfo/lib_print.c */
2736
2737 #undef mcprint
2738 int     mcprint(
2739                 char    *data,
2740                 int     len)
2741                 { return(*(int *)0); }
2742
2743 /* ./base/resizeterm.c */
2744
2745 #undef is_term_resized
2746 NCURSES_BOOL is_term_resized(
2747                 int     ToLines,
2748                 int     ToCols)
2749                 { return(*(NCURSES_BOOL *)0); }
2750
2751 #undef resize_term
2752 int     resize_term(
2753                 int     ToLines,
2754                 int     ToCols)
2755                 { return(*(int *)0); }
2756
2757 #undef resizeterm
2758 int     resizeterm(
2759                 int     ToLines,
2760                 int     ToCols)
2761                 { return(*(int *)0); }
2762
2763 /* ./trace/trace_xnames.c */
2764
2765 #undef _nc_trace_xnames
2766 void    _nc_trace_xnames(
2767                 TERMTYPE *tp)
2768                 { /* void */ }
2769
2770 /* ./base/wresize.c */
2771
2772 #undef wresize
2773 int     wresize(
2774                 WINDOW  *win,
2775                 int     ToLines,
2776                 int     ToCols)
2777                 { return(*(int *)0); }
2778
2779 /* ./tinfo/access.c */
2780
2781 #include <nc_alloc.h>
2782
2783 #undef _nc_rootname
2784 char    *_nc_rootname(
2785                 char    *path)
2786                 { return(*(char **)0); }
2787
2788 #undef _nc_pathlast
2789 unsigned _nc_pathlast(
2790                 const char *path)
2791                 { return(*(unsigned *)0); }
2792
2793 #undef _nc_basename
2794 char    *_nc_basename(
2795                 char    *path)
2796                 { return(*(char **)0); }
2797
2798 #undef _nc_access
2799 int     _nc_access(
2800                 const char *path,
2801                 int     mode)
2802                 { return(*(int *)0); }
2803
2804 #undef _nc_env_access
2805 int     _nc_env_access(void)
2806                 { return(*(int *)0); }
2807
2808 /* ./tinfo/add_tries.c */
2809
2810 #undef _nc_add_to_try
2811 void    _nc_add_to_try(
2812                 struct tries **tree,
2813                 const char *str,
2814                 unsigned short code)
2815                 { /* void */ }
2816
2817 /* ./tinfo/alloc_entry.c */
2818
2819 #undef _nc_init_entry
2820 void    _nc_init_entry(
2821                 TERMTYPE *const tp)
2822                 { /* void */ }
2823
2824 #undef _nc_copy_entry
2825 ENTRY   *_nc_copy_entry(
2826                 ENTRY   *oldp)
2827                 { return(*(ENTRY **)0); }
2828
2829 #undef _nc_save_str
2830 char    *_nc_save_str(
2831                 const char *const string)
2832                 { return(*(char **)0); }
2833
2834 #undef _nc_wrap_entry
2835 void    _nc_wrap_entry(
2836                 ENTRY   *const ep,
2837                 NCURSES_BOOL copy_strings)
2838                 { /* void */ }
2839
2840 #undef _nc_merge_entry
2841 void    _nc_merge_entry(
2842                 TERMTYPE *const to,
2843                 TERMTYPE *const from)
2844                 { /* void */ }
2845
2846 /* ./tinfo/alloc_ttype.c */
2847
2848 #undef _nc_align_termtype
2849 void    _nc_align_termtype(
2850                 TERMTYPE *to,
2851                 TERMTYPE *from)
2852                 { /* void */ }
2853
2854 #undef _nc_copy_termtype
2855 void    _nc_copy_termtype(
2856                 TERMTYPE *dst,
2857                 TERMTYPE *src)
2858                 { /* void */ }
2859
2860 /* ./tinfo/captoinfo.c */
2861
2862 #undef _nc_captoinfo
2863 char    *_nc_captoinfo(
2864                 const char *cap,
2865                 const char *s,
2866                 int const parameterized)
2867                 { return(*(char **)0); }
2868
2869 #undef _nc_infotocap
2870 char    *_nc_infotocap(
2871                 const char *cap,
2872                 const char *str,
2873                 int const parameterized)
2874                 { return(*(char **)0); }
2875
2876 /* ./codes.c */
2877
2878 #undef boolcodes
2879 char    *const boolcodes[] = {0};
2880 #undef numcodes
2881 char    *const numcodes[] = {0};
2882 #undef strcodes
2883 char    *const strcodes[] = {0};
2884
2885 /* ./comp_captab.c */
2886
2887 #include <ncurses_cfg.h>
2888
2889 #undef _nc_info_hash_table
2890 const struct name_table_entry *const _nc_info_hash_table[995] = {0};
2891 #undef _nc_cap_hash_table
2892 const struct name_table_entry *const _nc_cap_hash_table[995] = {0};
2893 #undef _nc_capalias_table
2894 const struct alias _nc_capalias_table[] = {0};
2895 #undef _nc_infoalias_table
2896 const struct alias _nc_infoalias_table[] = {0};
2897
2898 #undef _nc_get_table
2899 const struct name_table_entry *_nc_get_table(
2900                 NCURSES_BOOL termcap)
2901                 { return(*(const struct name_table_entry **)0); }
2902
2903 #undef _nc_get_hash_table
2904 const struct name_table_entry *const *_nc_get_hash_table(
2905                 NCURSES_BOOL termcap)
2906                 { return(*(const struct name_table_entry **)0); }
2907
2908 /* ./tinfo/comp_error.c */
2909
2910 #undef _nc_suppress_warnings
2911 NCURSES_BOOL _nc_suppress_warnings;
2912 #undef _nc_curr_line
2913 int     _nc_curr_line;
2914 #undef _nc_curr_col
2915 int     _nc_curr_col;
2916
2917 #undef _nc_set_source
2918 void    _nc_set_source(
2919                 const char *const name)
2920                 { /* void */ }
2921
2922 #undef _nc_set_type
2923 void    _nc_set_type(
2924                 const char *const name)
2925                 { /* void */ }
2926
2927 #undef _nc_get_type
2928 void    _nc_get_type(
2929                 char    *name)
2930                 { /* void */ }
2931
2932 #undef _nc_warning
2933 void    _nc_warning(
2934                 const char *const fmt,
2935                 ...)
2936                 { /* void */ }
2937
2938 #undef _nc_err_abort
2939 void    _nc_err_abort(
2940                 const char *const fmt,
2941                 ...)
2942                 { /* void */ }
2943
2944 #undef _nc_syserr_abort
2945 void    _nc_syserr_abort(
2946                 const char *const fmt,
2947                 ...)
2948                 { /* void */ }
2949
2950 /* ./tinfo/comp_expand.c */
2951
2952 #undef _nc_tic_expand
2953 char    *_nc_tic_expand(
2954                 const char *srcp,
2955                 NCURSES_BOOL tic_format,
2956                 int     numbers)
2957                 { return(*(char **)0); }
2958
2959 /* ./tinfo/comp_hash.c */
2960
2961 #include <hashsize.h>
2962
2963 #undef _nc_find_entry
2964 struct name_table_entry const *_nc_find_entry(
2965                 const char *string,
2966                 const struct name_table_entry *const *hash_table)
2967                 { return(*(struct name_table_entry const **)0); }
2968
2969 #undef _nc_find_type_entry
2970 struct name_table_entry const *_nc_find_type_entry(
2971                 const char *string,
2972                 int     type,
2973                 const struct name_table_entry *table)
2974                 { return(*(struct name_table_entry const **)0); }
2975
2976 /* ./tinfo/comp_parse.c */
2977
2978 #undef _nc_check_termtype2
2979 void    (*_nc_check_termtype2)(
2980                 TERMTYPE *p1,
2981                 NCURSES_BOOL p2);
2982 #undef _nc_check_termtype
2983 void    (*_nc_check_termtype)(
2984                 TERMTYPE *p1);
2985 #undef _nc_head
2986 ENTRY   *_nc_head;
2987 #undef _nc_tail
2988 ENTRY   *_nc_tail;
2989
2990 #undef _nc_free_entries
2991 void    _nc_free_entries(
2992                 ENTRY   *headp)
2993                 { /* void */ }
2994
2995 #undef _nc_delink_entry
2996 ENTRY   *_nc_delink_entry(
2997                 ENTRY   *headp,
2998                 TERMTYPE *tterm)
2999                 { return(*(ENTRY **)0); }
3000
3001 #undef _nc_free_entry
3002 void    _nc_free_entry(
3003                 ENTRY   *headp,
3004                 TERMTYPE *tterm)
3005                 { /* void */ }
3006
3007 #undef _nc_entry_match
3008 NCURSES_BOOL _nc_entry_match(
3009                 char    *n1,
3010                 char    *n2)
3011                 { return(*(NCURSES_BOOL *)0); }
3012
3013 #undef _nc_read_entry_source
3014 void    _nc_read_entry_source(
3015                 FILE    *fp,
3016                 char    *buf,
3017                 int     literal,
3018                 NCURSES_BOOL silent,
3019                 NCURSES_BOOL (*hook)(
3020                 ENTRY   *p1))
3021                 { /* void */ }
3022
3023 #undef _nc_resolve_uses2
3024 int     _nc_resolve_uses2(
3025                 NCURSES_BOOL fullresolve,
3026                 NCURSES_BOOL literal)
3027                 { return(*(int *)0); }
3028
3029 #undef _nc_resolve_uses
3030 int     _nc_resolve_uses(
3031                 NCURSES_BOOL fullresolve)
3032                 { return(*(int *)0); }
3033
3034 /* ./tinfo/comp_scan.c */
3035
3036 #undef _nc_syntax
3037 int     _nc_syntax;
3038 #undef _nc_curr_file_pos
3039 long    _nc_curr_file_pos;
3040 #undef _nc_comment_start
3041 long    _nc_comment_start;
3042 #undef _nc_comment_end
3043 long    _nc_comment_end;
3044 #undef _nc_start_line
3045 long    _nc_start_line;
3046 #undef _nc_curr_token
3047 struct token _nc_curr_token;
3048 #undef _nc_disable_period
3049 NCURSES_BOOL _nc_disable_period;
3050
3051 #undef _nc_reset_input
3052 void    _nc_reset_input(
3053                 FILE    *fp,
3054                 char    *buf)
3055                 { /* void */ }
3056
3057 #undef _nc_get_token
3058 int     _nc_get_token(
3059                 NCURSES_BOOL silent)
3060                 { return(*(int *)0); }
3061
3062 #undef _nc_trans_string
3063 int     _nc_trans_string(
3064                 char    *ptr,
3065                 char    *last)
3066                 { return(*(int *)0); }
3067
3068 #undef _nc_push_token
3069 void    _nc_push_token(
3070                 int     tokclass)
3071                 { /* void */ }
3072
3073 #undef _nc_panic_mode
3074 void    _nc_panic_mode(
3075                 char    ch)
3076                 { /* void */ }
3077
3078 /* ./tinfo/doalloc.c */
3079
3080 #undef _nc_doalloc
3081 void    *_nc_doalloc(
3082                 void    *oldp,
3083                 size_t  amount)
3084                 { return(*(void **)0); }
3085
3086 /* ./fallback.c */
3087
3088 #undef _nc_fallback
3089 const TERMTYPE *_nc_fallback(
3090                 const char *name)
3091                 { return(*(const TERMTYPE **)0); }
3092
3093 /* ./tinfo/free_ttype.c */
3094
3095 #undef _nc_free_termtype
3096 void    _nc_free_termtype(
3097                 TERMTYPE *ptr)
3098                 { /* void */ }
3099
3100 #undef _nc_user_definable
3101 NCURSES_BOOL _nc_user_definable;
3102
3103 #undef use_extended_names
3104 int     use_extended_names(
3105                 NCURSES_BOOL flag)
3106                 { return(*(int *)0); }
3107
3108 /* ./tinfo/getenv_num.c */
3109
3110 #undef _nc_getenv_num
3111 int     _nc_getenv_num(
3112                 const char *name)
3113                 { return(*(int *)0); }
3114
3115 /* ./tinfo/home_terminfo.c */
3116
3117 #undef _nc_home_terminfo
3118 char    *_nc_home_terminfo(void)
3119                 { return(*(char **)0); }
3120
3121 /* ./tinfo/init_keytry.c */
3122
3123 #if 0
3124
3125 #include <init_keytry.h>
3126
3127 #undef _nc_tinfo_fkeys
3128 struct tinfo_fkeys _nc_tinfo_fkeys[];
3129
3130 #endif
3131
3132 #undef _nc_init_keytry
3133 void    _nc_init_keytry(void)
3134                 { /* void */ }
3135
3136 /* ./tinfo/lib_acs.c */
3137
3138 #undef acs_map
3139 chtype  acs_map[128];
3140
3141 #undef _nc_init_acs
3142 void    _nc_init_acs(void)
3143                 { /* void */ }
3144
3145 /* ./tinfo/lib_baudrate.c */
3146
3147 #include <termcap.h>
3148
3149 struct speed {
3150     int s;
3151     int sp;
3152 };
3153
3154 #undef _nc_baudrate
3155 int     _nc_baudrate(
3156                 int     OSpeed)
3157                 { return(*(int *)0); }
3158
3159 #undef _nc_ospeed
3160 int     _nc_ospeed(
3161                 int     BaudRate)
3162                 { return(*(int *)0); }
3163
3164 #undef baudrate
3165 int     baudrate(void)
3166                 { return(*(int *)0); }
3167
3168 /* ./tinfo/lib_cur_term.c */
3169
3170 #undef cur_term
3171 TERMINAL *cur_term;
3172
3173 #undef set_curterm
3174 TERMINAL *set_curterm(
3175                 TERMINAL *termp)
3176                 { return(*(TERMINAL **)0); }
3177
3178 #undef del_curterm
3179 int     del_curterm(
3180                 TERMINAL *termp)
3181                 { return(*(int *)0); }
3182
3183 /* ./tinfo/lib_data.c */
3184
3185 #undef stdscr
3186 WINDOW  *stdscr;
3187 #undef curscr
3188 WINDOW  *curscr;
3189 #undef newscr
3190 WINDOW  *newscr;
3191 #undef _nc_screen_chain
3192 SCREEN  *_nc_screen_chain;
3193 #undef SP
3194 SCREEN  *SP;
3195
3196 /* ./tinfo/lib_has_cap.c */
3197
3198 #undef has_ic
3199 NCURSES_BOOL has_ic(void)
3200                 { return(*(NCURSES_BOOL *)0); }
3201
3202 #undef has_il
3203 NCURSES_BOOL has_il(void)
3204                 { return(*(NCURSES_BOOL *)0); }
3205
3206 /* ./tinfo/lib_kernel.c */
3207
3208 #undef erasechar
3209 char    erasechar(void)
3210                 { return(*(char *)0); }
3211
3212 #undef killchar
3213 char    killchar(void)
3214                 { return(*(char *)0); }
3215
3216 #undef flushinp
3217 int     flushinp(void)
3218                 { return(*(int *)0); }
3219
3220 /* ./lib_keyname.c */
3221
3222 #undef _nc_key_names
3223 const struct kn _nc_key_names[] = {0};
3224
3225 #undef keyname
3226 char    *keyname(
3227                 int     c)
3228                 { return(*(char **)0); }
3229
3230 #undef key_name
3231 char    *key_name(
3232                 wchar_t c)
3233                 { return(*(char **)0); }
3234
3235 /* ./tinfo/lib_longname.c */
3236
3237 #undef longname
3238 char    *longname(void)
3239                 { return(*(char **)0); }
3240
3241 /* ./tinfo/lib_napms.c */
3242
3243 #include <time.h>
3244
3245 #undef napms
3246 int     napms(
3247                 int     ms)
3248                 { return(*(int *)0); }
3249
3250 /* ./tinfo/lib_options.c */
3251
3252 #undef idlok
3253 int     idlok(
3254                 WINDOW  *win,
3255                 NCURSES_BOOL flag)
3256                 { return(*(int *)0); }
3257
3258 #undef idcok
3259 void    idcok(
3260                 WINDOW  *win,
3261                 NCURSES_BOOL flag)
3262                 { /* void */ }
3263
3264 #undef halfdelay
3265 int     halfdelay(
3266                 int     t)
3267                 { return(*(int *)0); }
3268
3269 #undef nodelay
3270 int     nodelay(
3271                 WINDOW  *win,
3272                 NCURSES_BOOL flag)
3273                 { return(*(int *)0); }
3274
3275 #undef notimeout
3276 int     notimeout(
3277                 WINDOW  *win,
3278                 NCURSES_BOOL f)
3279                 { return(*(int *)0); }
3280
3281 #undef wtimeout
3282 void    wtimeout(
3283                 WINDOW  *win,
3284                 int     delay)
3285                 { /* void */ }
3286
3287 #undef keypad
3288 int     keypad(
3289                 WINDOW  *win,
3290                 NCURSES_BOOL flag)
3291                 { return(*(int *)0); }
3292
3293 #undef meta
3294 int     meta(
3295                 WINDOW  *win,
3296                 NCURSES_BOOL flag)
3297                 { return(*(int *)0); }
3298
3299 #undef curs_set
3300 int     curs_set(
3301                 int     vis)
3302                 { return(*(int *)0); }
3303
3304 #undef typeahead
3305 int     typeahead(
3306                 int     fd)
3307                 { return(*(int *)0); }
3308
3309 #undef has_key
3310 int     has_key(
3311                 int     keycode)
3312                 { return(*(int *)0); }
3313
3314 #undef _nc_keypad
3315 int     _nc_keypad(
3316                 NCURSES_BOOL flag)
3317                 { return(*(int *)0); }
3318
3319 /* ./tinfo/lib_raw.c */
3320
3321 #undef raw
3322 int     raw(void)
3323                 { return(*(int *)0); }
3324
3325 #undef cbreak
3326 int     cbreak(void)
3327                 { return(*(int *)0); }
3328
3329 #undef qiflush
3330 void    qiflush(void)
3331                 { /* void */ }
3332
3333 #undef noraw
3334 int     noraw(void)
3335                 { return(*(int *)0); }
3336
3337 #undef nocbreak
3338 int     nocbreak(void)
3339                 { return(*(int *)0); }
3340
3341 #undef noqiflush
3342 void    noqiflush(void)
3343                 { /* void */ }
3344
3345 #undef intrflush
3346 int     intrflush(
3347                 WINDOW  *win,
3348                 NCURSES_BOOL flag)
3349                 { return(*(int *)0); }
3350
3351 /* ./tinfo/lib_setup.c */
3352
3353 #include <locale.h>
3354 #include <sys/ioctl.h>
3355 #include <langinfo.h>
3356
3357 #undef ttytype
3358 char    ttytype[256];
3359 #undef LINES
3360 int     LINES;
3361 #undef COLS
3362 int     COLS;
3363 #undef TABSIZE
3364 int     TABSIZE;
3365
3366 #undef use_env
3367 void    use_env(
3368                 NCURSES_BOOL f)
3369                 { /* void */ }
3370
3371 #undef _nc_update_screensize
3372 void    _nc_update_screensize(void)
3373                 { /* void */ }
3374
3375 #undef _nc_get_locale
3376 char    *_nc_get_locale(void)
3377                 { return(*(char **)0); }
3378
3379 #undef _nc_unicode_locale
3380 int     _nc_unicode_locale(void)
3381                 { return(*(int *)0); }
3382
3383 #undef _nc_locale_breaks_acs
3384 int     _nc_locale_breaks_acs(void)
3385                 { return(*(int *)0); }
3386
3387 #undef _nc_setupterm
3388 int     _nc_setupterm(
3389                 char    *tname,
3390                 int     Filedes,
3391                 int     *errret,
3392                 NCURSES_BOOL reuse)
3393                 { return(*(int *)0); }
3394
3395 #undef setupterm
3396 int     setupterm(
3397                 char    *tname,
3398                 int     Filedes,
3399                 int     *errret)
3400                 { return(*(int *)0); }
3401
3402 /* ./tinfo/lib_termcap.c */
3403
3404 #undef UP
3405 char    *UP;
3406 #undef BC
3407 char    *BC;
3408
3409 #undef tgetent
3410 int     tgetent(
3411                 char    *bufp,
3412                 const char *name)
3413                 { return(*(int *)0); }
3414
3415 #if 0
3416
3417 #include <capdefaults.c>
3418
3419 #endif
3420
3421 #undef tgetflag
3422 int     tgetflag(
3423                 char    *id)
3424                 { return(*(int *)0); }
3425
3426 #undef tgetnum
3427 int     tgetnum(
3428                 char    *id)
3429                 { return(*(int *)0); }
3430
3431 #undef tgetstr
3432 char    *tgetstr(
3433                 char    *id,
3434                 char    **area)
3435                 { return(*(char **)0); }
3436
3437 /* ./tinfo/lib_termname.c */
3438
3439 #undef termname
3440 char    *termname(void)
3441                 { return(*(char **)0); }
3442
3443 /* ./tinfo/lib_tgoto.c */
3444
3445 #undef tgoto
3446 char    *tgoto(
3447                 const char *string,
3448                 int     x,
3449                 int     y)
3450                 { return(*(char **)0); }
3451
3452 /* ./tinfo/lib_ti.c */
3453
3454 #undef tigetflag
3455 int     tigetflag(
3456                 char    *str)
3457                 { return(*(int *)0); }
3458
3459 #undef tigetnum
3460 int     tigetnum(
3461                 char    *str)
3462                 { return(*(int *)0); }
3463
3464 #undef tigetstr
3465 char    *tigetstr(
3466                 char    *str)
3467                 { return(*(char **)0); }
3468
3469 /* ./tinfo/lib_tparm.c */
3470
3471 typedef struct {
3472     union {
3473         int num;
3474         char *str;
3475     } data;
3476     NCURSES_BOOL num_type;
3477 } stack_frame;
3478
3479 #undef _nc_tparm_err
3480 int     _nc_tparm_err;
3481
3482 #undef _nc_tparm_analyze
3483 int     _nc_tparm_analyze(
3484                 const char *string,
3485                 char    *p_is_s[9],
3486                 int     *popcount)
3487                 { return(*(int *)0); }
3488
3489 #undef tparm
3490 char    *tparm(
3491                 char    *string,
3492                 ...)
3493                 { return(*(char **)0); }
3494
3495 /* ./tinfo/lib_tputs.c */
3496
3497 #undef PC
3498 char    PC;
3499 #undef ospeed
3500 NCURSES_OSPEED  ospeed;
3501 #undef _nc_nulls_sent
3502 int     _nc_nulls_sent;
3503
3504 #undef delay_output
3505 int     delay_output(
3506                 int     ms)
3507                 { return(*(int *)0); }
3508
3509 #undef _nc_flush
3510 void    _nc_flush(void)
3511                 { /* void */ }
3512
3513 #undef _nc_outch
3514 int     _nc_outch(
3515                 int     ch)
3516                 { return(*(int *)0); }
3517
3518 #undef putp
3519 int     putp(
3520                 const char *string)
3521                 { return(*(int *)0); }
3522
3523 #undef tputs
3524 int     tputs(
3525                 const char *string,
3526                 int     affcnt,
3527                 int     (*outc)(
3528                 int     p1))
3529                 { return(*(int *)0); }
3530
3531 /* ./trace/lib_trace.c */
3532
3533 #undef _nc_tracing
3534 unsigned _nc_tracing;
3535 #undef _nc_tputs_trace
3536 const char *_nc_tputs_trace = {0};
3537 #undef _nc_outchars
3538 long    _nc_outchars;
3539
3540 #undef trace
3541 void    trace(
3542                 const unsigned int tracelevel)
3543                 { /* void */ }
3544
3545 #undef _tracef
3546 void    _tracef(
3547                 const char *fmt,
3548                 ...)
3549                 { /* void */ }
3550
3551 #undef _nc_retrace_bool
3552 NCURSES_BOOL _nc_retrace_bool(
3553                 NCURSES_BOOL code)
3554                 { return(*(NCURSES_BOOL *)0); }
3555
3556 #undef _nc_retrace_int
3557 int     _nc_retrace_int(
3558                 int     code)
3559                 { return(*(int *)0); }
3560
3561 #undef _nc_retrace_unsigned
3562 unsigned _nc_retrace_unsigned(
3563                 unsigned code)
3564                 { return(*(unsigned *)0); }
3565
3566 #undef _nc_retrace_ptr
3567 char    *_nc_retrace_ptr(
3568                 char    *code)
3569                 { return(*(char **)0); }
3570
3571 #undef _nc_retrace_cptr
3572 const char *_nc_retrace_cptr(
3573                 const char *code)
3574                 { return(*(const char **)0); }
3575
3576 #undef _nc_retrace_cvoid_ptr
3577 void    *_nc_retrace_cvoid_ptr(
3578                 void    *code)
3579                 { return(*(void **)0); }
3580
3581 #undef _nc_retrace_void_ptr
3582 void    *_nc_retrace_void_ptr(
3583                 void    *code)
3584                 { return(*(void **)0); }
3585
3586 #undef _nc_retrace_sp
3587 SCREEN  *_nc_retrace_sp(
3588                 SCREEN  *code)
3589                 { return(*(SCREEN **)0); }
3590
3591 #undef _nc_retrace_win
3592 WINDOW  *_nc_retrace_win(
3593                 WINDOW  *code)
3594                 { return(*(WINDOW **)0); }
3595
3596 /* ./trace/lib_tracebits.c */
3597
3598 typedef struct {
3599     unsigned int val;
3600     const char *name;
3601 } BITNAMES;
3602
3603 #undef _nc_trace_ttymode
3604 char    *_nc_trace_ttymode(
3605                 struct termios *tty)
3606                 { return(*(char **)0); }
3607
3608 #undef _nc_tracebits
3609 char    *_nc_tracebits(void)
3610                 { return(*(char **)0); }
3611
3612 /* ./trace/lib_tracechr.c */
3613
3614 #undef _tracechar
3615 char    *_tracechar(
3616                 int     ch)
3617                 { return(*(char **)0); }
3618
3619 /* ./tinfo/lib_ttyflags.c */
3620
3621 #undef _nc_get_tty_mode
3622 int     _nc_get_tty_mode(
3623                 struct termios *buf)
3624                 { return(*(int *)0); }
3625
3626 #undef _nc_set_tty_mode
3627 int     _nc_set_tty_mode(
3628                 struct termios *buf)
3629                 { return(*(int *)0); }
3630
3631 #undef def_shell_mode
3632 int     def_shell_mode(void)
3633                 { return(*(int *)0); }
3634
3635 #undef def_prog_mode
3636 int     def_prog_mode(void)
3637                 { return(*(int *)0); }
3638
3639 #undef reset_prog_mode
3640 int     reset_prog_mode(void)
3641                 { return(*(int *)0); }
3642
3643 #undef reset_shell_mode
3644 int     reset_shell_mode(void)
3645                 { return(*(int *)0); }
3646
3647 #undef savetty
3648 int     savetty(void)
3649                 { return(*(int *)0); }
3650
3651 #undef resetty
3652 int     resetty(void)
3653                 { return(*(int *)0); }
3654
3655 /* ./tty/lib_twait.c */
3656
3657 #undef _nc_timed_wait
3658 int     _nc_timed_wait(
3659                 int     mode,
3660                 int     milliseconds,
3661                 int     *timeleft)
3662                 { return(*(int *)0); }
3663
3664 /* ./tinfo/name_match.c */
3665
3666 #undef _nc_first_name
3667 char    *_nc_first_name(
3668                 const char *const sp)
3669                 { return(*(char **)0); }
3670
3671 #undef _nc_name_match
3672 int     _nc_name_match(
3673                 const char *const namelst,
3674                 const char *const name,
3675                 const char *const delim)
3676                 { return(*(int *)0); }
3677
3678 /* ./names.c */
3679
3680 #undef boolnames
3681 char    *const boolnames[] = {0};
3682 #undef boolfnames
3683 char    *const boolfnames[] = {0};
3684 #undef numnames
3685 char    *const numnames[] = {0};
3686 #undef numfnames
3687 char    *const numfnames[] = {0};
3688 #undef strnames
3689 char    *const strnames[] = {0};
3690 #undef strfnames
3691 char    *const strfnames[] = {0};
3692
3693 /* ./tinfo/parse_entry.c */
3694
3695 #undef _nc_parse_entry
3696 int     _nc_parse_entry(
3697                 struct entry *entryp,
3698                 int     literal,
3699                 NCURSES_BOOL silent)
3700                 { return(*(int *)0); }
3701
3702 #undef _nc_capcmp
3703 int     _nc_capcmp(
3704                 const char *s,
3705                 const char *t)
3706                 { return(*(int *)0); }
3707
3708 typedef struct {
3709     const char *from;
3710     const char *to;
3711 } assoc;
3712
3713 /* ./tinfo/read_entry.c */
3714
3715 #undef _nc_tic_dir
3716 const char *_nc_tic_dir(
3717                 const char *path)
3718                 { return(*(const char **)0); }
3719
3720 #undef _nc_keep_tic_dir
3721 void    _nc_keep_tic_dir(
3722                 const char *path)
3723                 { /* void */ }
3724
3725 #undef _nc_read_file_entry
3726 int     _nc_read_file_entry(
3727                 const char *const filename,
3728                 TERMTYPE *ptr)
3729                 { return(*(int *)0); }
3730
3731 #undef _nc_read_entry
3732 int     _nc_read_entry(
3733                 const char *const tn,
3734                 char    *const filename,
3735                 TERMTYPE *const tp)
3736                 { return(*(int *)0); }
3737
3738 /* ./tinfo/read_termcap.c */
3739
3740 #include <sys/types.h>
3741 #include <sys/stat.h>
3742
3743 #undef _nc_read_termcap_entry
3744 int     _nc_read_termcap_entry(
3745                 const char *const tn,
3746                 TERMTYPE *const tp)
3747                 { return(*(int *)0); }
3748
3749 /* ./tinfo/setbuf.c */
3750
3751 #undef _nc_set_buffer
3752 void    _nc_set_buffer(
3753                 FILE    *ofp,
3754                 NCURSES_BOOL buffered)
3755                 { /* void */ }
3756
3757 /* ./tinfo/strings.c */
3758
3759 #undef _nc_str_init
3760 string_desc *_nc_str_init(
3761                 string_desc *dst,
3762                 char    *src,
3763                 size_t  len)
3764                 { return(*(string_desc **)0); }
3765
3766 #undef _nc_str_null
3767 string_desc *_nc_str_null(
3768                 string_desc *dst,
3769                 size_t  len)
3770                 { return(*(string_desc **)0); }
3771
3772 #undef _nc_str_copy
3773 string_desc *_nc_str_copy(
3774                 string_desc *dst,
3775                 string_desc *src)
3776                 { return(*(string_desc **)0); }
3777
3778 #undef _nc_safe_strcat
3779 NCURSES_BOOL _nc_safe_strcat(
3780                 string_desc *dst,
3781                 const char *src)
3782                 { return(*(NCURSES_BOOL *)0); }
3783
3784 #undef _nc_safe_strcpy
3785 NCURSES_BOOL _nc_safe_strcpy(
3786                 string_desc *dst,
3787                 const char *src)
3788                 { return(*(NCURSES_BOOL *)0); }
3789
3790 /* ./trace/trace_buf.c */
3791
3792 typedef struct {
3793     char *text;
3794     size_t size;
3795 } LIST;
3796
3797 #undef _nc_trace_buf
3798 char    *_nc_trace_buf(
3799                 int     bufnum,
3800                 size_t  want)
3801                 { return(*(char **)0); }
3802
3803 #undef _nc_trace_bufcat
3804 char    *_nc_trace_bufcat(
3805                 int     bufnum,
3806                 const char *value)
3807                 { return(*(char **)0); }
3808
3809 /* ./trace/trace_tries.c */
3810
3811 #undef _nc_trace_tries
3812 void    _nc_trace_tries(
3813                 struct tries *tree)
3814                 { /* void */ }
3815
3816 /* ./base/tries.c */
3817
3818 #undef _nc_expand_try
3819 char    *_nc_expand_try(
3820                 struct tries *tree,
3821                 unsigned short code,
3822                 int     *count,
3823                 size_t  len)
3824                 { return(*(char **)0); }
3825
3826 #undef _nc_remove_key
3827 int     _nc_remove_key(
3828                 struct tries **tree,
3829                 unsigned short code)
3830                 { return(*(int *)0); }
3831
3832 #undef _nc_remove_string
3833 int     _nc_remove_string(
3834                 struct tries **tree,
3835                 const char *string)
3836                 { return(*(int *)0); }
3837
3838 /* ./tinfo/trim_sgr0.c */
3839
3840 #undef _nc_trim_sgr0
3841 char    *_nc_trim_sgr0(
3842                 TERMTYPE *tp)
3843                 { return(*(char **)0); }
3844
3845 /* ./unctrl.c */
3846
3847 #undef unctrl
3848 char    *unctrl(
3849                  chtype ch)
3850                 { return(*(char **)0); }
3851
3852 /* ./trace/visbuf.c */
3853
3854 #undef _nc_visbuf2
3855 const char *_nc_visbuf2(
3856                 int     bufnum,
3857                 const char *buf)
3858                 { return(*(const char **)0); }
3859
3860 #undef _nc_visbuf
3861 const char *_nc_visbuf(
3862                 const char *buf)
3863                 { return(*(const char **)0); }
3864
3865 #undef _nc_visbufn
3866 const char *_nc_visbufn(
3867                 const char *buf,
3868                 int     len)
3869                 { return(*(const char **)0); }
3870
3871 #undef _nc_viswbuf2
3872 const char *_nc_viswbuf2(
3873                 int     bufnum,
3874                 const wchar_t *buf)
3875                 { return(*(const char **)0); }
3876
3877 #undef _nc_viswbuf
3878 const char *_nc_viswbuf(
3879                 const wchar_t *buf)
3880                 { return(*(const char **)0); }
3881
3882 #undef _nc_viswbufn
3883 const char *_nc_viswbufn(
3884                 const wchar_t *buf,
3885                 int     len)
3886                 { return(*(const char **)0); }
3887
3888 #undef _nc_viswibuf
3889 const char *_nc_viswibuf(
3890                 const wint_t *buf)
3891                 { return(*(const char **)0); }
3892
3893 #undef _nc_viscbuf2
3894 const char *_nc_viscbuf2(
3895                 int     bufnum,
3896                 const cchar_t *buf,
3897                 int     len)
3898                 { return(*(const char **)0); }
3899
3900 #undef _nc_viscbuf
3901 const char *_nc_viscbuf(
3902                 const cchar_t *buf,
3903                 int     len)
3904                 { return(*(const char **)0); }
3905
3906 /* ./tinfo/write_entry.c */
3907
3908 #undef _nc_set_writedir
3909 void    _nc_set_writedir(
3910                 char    *dir)
3911                 { /* void */ }
3912
3913 #undef _nc_write_entry
3914 void    _nc_write_entry(
3915                 TERMTYPE *const tp)
3916                 { /* void */ }
3917
3918 #undef _nc_tic_written
3919 int     _nc_tic_written(void)
3920                 { return(*(int *)0); }
3921
3922 /* ./base/define_key.c */
3923
3924 #undef define_key
3925 int     define_key(
3926                 const char *str,
3927                 int     keycode)
3928                 { return(*(int *)0); }
3929
3930 /* ./base/key_defined.c */
3931
3932 #undef key_defined
3933 int     key_defined(
3934                 const char *str)
3935                 { return(*(int *)0); }
3936
3937 /* ./base/keybound.c */
3938
3939 #undef keybound
3940 char    *keybound(
3941                 int     code,
3942                 int     count)
3943                 { return(*(char **)0); }
3944
3945 /* ./base/keyok.c */
3946
3947 #undef keyok
3948 int     keyok(
3949                 int     c,
3950                 NCURSES_BOOL flag)
3951                 { return(*(int *)0); }
3952
3953 /* ./base/version.c */
3954
3955 #undef curses_version
3956 const char *curses_version(void)
3957                 { return(*(const char **)0); }