ncurses/llib-lncurses

   1 /******************************************************************************
   2  * Copyright 1996,1997 by Thomas E. Dickey <dickey@clark.net>                 *
   3  * All Rights Reserved.                                                       *
   4  *                                                                            *
   5  * Permission to use, copy, modify, and distribute this software and its      *
   6  * documentation for any purpose and without fee is hereby granted, provided  *
   7  * that the above copyright notice appear in all copies and that both that    *
   8  * copyright notice and this permission notice appear in supporting           *
   9  * documentation, and that the name of the above listed copyright holder(s)   *
  10  * not be used in advertising or publicity pertaining to distribution of the  *
  11  * software without specific, written prior permission. THE ABOVE LISTED      *
  12  * COPYRIGHT HOLDER(S) DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,  *
  13  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO     *
  14  * EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY         *
  15  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER       *
  16  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF       *
  17  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN        *
  18  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.                   *
  19  ******************************************************************************/
  20 /* LINTLIBRARY */
  21
  22 /* ./fallback.c */
  23
  24 #include <curses.priv.h>
  25 #include <term.h>
  26
  27 #undef _nc_fallback
  28 const TERMTYPE *_nc_fallback(
  29                 const char *name)
  30                 { return(*(const TERMTYPE **)0); }
  31
  32 /* ./hashmap.c */
  33
  34 #undef _nc_hash_map
  35 void    _nc_hash_map(void)
  36                 { /* void */ }
  37
  38 /* ./hardscroll.c */
  39
  40 #undef _nc_scroll_optimize
  41 void    _nc_scroll_optimize(void)
  42                 { /* void */ }
  43
  44 /* ./lib_acs.c */
  45
  46 #undef acs_map
  47 chtype  acs_map[128];
  48
  49 #undef init_acs
  50 void    init_acs(void)
  51                 { /* void */ }
  52
  53 /* ./lib_addch.c */
  54
  55 #include <ctype.h>
  56
  57 #undef wattr_on
  58 int     wattr_on(
  59                 WINDOW  *win,
  60                 const attr_t at)
  61                 { return(*(int *)0); }
  62
  63 #undef wattr_off
  64 int     wattr_off(
  65                 WINDOW  *win,
  66                 const attr_t at)
  67                 { return(*(int *)0); }
  68
  69 #undef wchgat
  70 int     wchgat(
  71                 WINDOW  *win,
  72                 int     n,
  73                 attr_t  attr,
  74                 short   color,
  75                 const void *opts)
  76                 { return(*(int *)0); }
  77
  78 #undef _nc_background
  79 chtype  _nc_background(
  80                 WINDOW  *win)
  81                 { return(*(chtype *)0); }
  82
  83 #undef _nc_render
  84 chtype  _nc_render(
  85                 WINDOW  *win,
  86                 chtype  ch)
  87                 { return(*(chtype *)0); }
  88
  89 #undef _nc_waddch_nosync
  90 int     _nc_waddch_nosync(
  91                 WINDOW  *win,
  92                 const chtype c)
  93                 { return(*(int *)0); }
  94
  95 #undef waddch
  96 int     waddch(
  97                 WINDOW  *win,
  98                 const chtype ch)
  99                 { return(*(int *)0); }
 100
 101 #undef wechochar
 102 int     wechochar(
 103                 WINDOW  *win,
 104                 const chtype ch)
 105                 { return(*(int *)0); }
 106
 107 /* ./lib_addstr.c */
 108
 109 #undef waddnstr
 110 int     waddnstr(
 111                 WINDOW  *win,
 112                 const char *const astr,
 113                 int     n)
 114                 { return(*(int *)0); }
 115
 116 #undef waddchnstr
 117 int     waddchnstr(
 118                 WINDOW  *win,
 119                 const chtype *const astr,
 120                 int     n)
 121                 { return(*(int *)0); }
 122
 123 /* ./lib_beep.c */
 124
 125 #undef beep
 126 int     beep(void)
 127                 { return(*(int *)0); }
 128
 129 #undef flash
 130 int     flash(void)
 131                 { return(*(int *)0); }
 132
 133 /* ./lib_bkgd.c */
 134
 135 #undef wbkgd
 136 int     wbkgd(
 137                 WINDOW  *win,
 138                 const chtype ch)
 139                 { return(*(int *)0); }
 140
 141 /* ./lib_baudrate.c */
 142
 143 struct speed {
 144         speed_t s;
 145         int sp;
 146 };
 147
 148 #undef baudrate
 149 int     baudrate(void)
 150                 { return(*(int *)0); }
 151
 152 /* ./lib_box.c */
 153
 154 #undef wborder
 155 int     wborder(
 156                 WINDOW  *win,
 157                 chtype  ls,
 158                 chtype  rs,
 159                 chtype  ts,
 160                 chtype  bs,
 161                 chtype  tl,
 162                 chtype  tr,
 163                 chtype  bl,
 164                 chtype  br)
 165                 { return(*(int *)0); }
 166
 167 #undef whline
 168 int     whline(
 169                 WINDOW  *win,
 170                 chtype  ch,
 171                 int     n)
 172                 { return(*(int *)0); }
 173
 174 #undef wvline
 175 int     wvline(
 176                 WINDOW  *win,
 177                 chtype  ch,
 178                 int     n)
 179                 { return(*(int *)0); }
 180
 181 /* ./lib_clear.c */
 182
 183 #undef wclear
 184 int     wclear(
 185                 WINDOW  *win)
 186                 { return(*(int *)0); }
 187
 188 /* ./lib_clrbot.c */
 189
 190 #undef wclrtobot
 191 int     wclrtobot(
 192                 WINDOW  *win)
 193                 { return(*(int *)0); }
 194
 195 /* ./lib_clreol.c */
 196
 197 #undef wclrtoeol
 198 int     wclrtoeol(
 199                 WINDOW  *win)
 200                 { return(*(int *)0); }
 201
 202 /* ./lib_color.c */
 203
 204 #undef COLOR_PAIRS
 205 int     COLOR_PAIRS;
 206 #undef COLORS
 207 int     COLORS;
 208
 209 #undef start_color
 210 int     start_color(void)
 211                 { return(*(int *)0); }
 212
 213 #undef init_pair
 214 int     init_pair(
 215                 short   pair,
 216                 short   f,
 217                 short   b)
 218                 { return(*(int *)0); }
 219
 220 #undef init_color
 221 int     init_color(
 222                 short   color,
 223                 short   r,
 224                 short   g,
 225                 short   b)
 226                 { return(*(int *)0); }
 227
 228 #undef can_change_color
 229 bool    can_change_color(void)
 230                 { return(*(bool *)0); }
 231
 232 #undef has_colors
 233 bool    has_colors(void)
 234                 { return(*(bool *)0); }
 235
 236 #undef color_content
 237 int     color_content(
 238                 short   color,
 239                 short   *r,
 240                 short   *g,
 241                 short   *b)
 242                 { return(*(int *)0); }
 243
 244 #undef pair_content
 245 int     pair_content(
 246                 short   pair,
 247                 short   *f,
 248                 short   *b)
 249                 { return(*(int *)0); }
 250
 251 #undef _nc_do_color
 252 void    _nc_do_color(
 253                 int     pair,
 254                 int     (*outc)(
 255                 int     p1))
 256                 { /* void */ }
 257
 258 /* ./lib_data.c */
 259
 260 #undef stdscr
 261 WINDOW  *stdscr;
 262 #undef curscr
 263 WINDOW  *curscr;
 264 #undef newscr
 265 WINDOW  *newscr;
 266 #undef _nc_windows
 267 struct _win_list *_nc_windows;
 268 #undef _nc_idcok
 269 bool    _nc_idcok;
 270 #undef _nc_idlok
 271 bool    _nc_idlok;
 272 #undef SP
 273 SCREEN  *SP;
 274
 275 /* ./lib_delch.c */
 276
 277 #undef wdelch
 278 int     wdelch(
 279                 WINDOW  *win)
 280                 { return(*(int *)0); }
 281
 282 /* ./lib_delwin.c */
 283
 284 #undef delwin
 285 int     delwin(
 286                 WINDOW  *win)
 287                 { return(*(int *)0); }
 288
 289 /* ./lib_doupdate.c */
 290
 291 #include <sys/time.h>
 292
 293 #undef doupdate
 294 int     doupdate(void)
 295                 { return(*(int *)0); }
 296
 297 #undef _nc_outstr
 298 void    _nc_outstr(
 299                 const char *str)
 300                 { /* void */ }
 301
 302 /* ./lib_endwin.c */
 303
 304 #undef endwin
 305 int     endwin(void)
 306                 { return(*(int *)0); }
 307
 308 /* ./lib_erase.c */
 309
 310 #undef werase
 311 int     werase(
 312                 WINDOW  *win)
 313                 { return(*(int *)0); }
 314
 315 /* ./lib_gen.c */
 316
 317 #include <curses.h>
 318
 319 #undef addch
 320 int     addch(
 321                 const chtype z)
 322                 { return(*(int *)0); }
 323
 324 #undef addchnstr
 325 int     addchnstr(
 326                 const chtype *a1,
 327                 int     z)
 328                 { return(*(int *)0); }
 329
 330 #undef addchstr
 331 int     addchstr(
 332                 const chtype *z)
 333                 { return(*(int *)0); }
 334
 335 #undef addnstr
 336 int     addnstr(
 337                 const char *a1,
 338                 int     z)
 339                 { return(*(int *)0); }
 340
 341 #undef addstr
 342 int     addstr(
 343                 const char *z)
 344                 { return(*(int *)0); }
 345
 346 #undef attroff
 347 int     attroff(
 348                 int     z)
 349                 { return(*(int *)0); }
 350
 351 #undef attron
 352 int     attron(
 353                 int     z)
 354                 { return(*(int *)0); }
 355
 356 #undef attrset
 357 int     attrset(
 358                 int     z)
 359                 { return(*(int *)0); }
 360
 361 #undef attr_get
 362 int     attr_get(void)
 363                 { return(*(int *)0); }
 364
 365 #undef attr_off
 366 int     attr_off(
 367                 int     z)
 368                 { return(*(int *)0); }
 369
 370 #undef attr_on
 371 int     attr_on(
 372                 int     z)
 373                 { return(*(int *)0); }
 374
 375 #undef attr_set
 376 int     attr_set(
 377                 int     z)
 378                 { return(*(int *)0); }
 379
 380 #undef bkgd
 381 int     bkgd(
 382                 chtype  z)
 383                 { return(*(int *)0); }
 384
 385 #undef bkgdset
 386 void    bkgdset(
 387                 chtype  z)
 388                 { /* void */ }
 389
 390 #undef border
 391 int     border(
 392                 chtype  a1,
 393                 chtype  a2,
 394                 chtype  a3,
 395                 chtype  a4,
 396                 chtype  a5,
 397                 chtype  a6,
 398                 chtype  a7,
 399                 chtype  z)
 400                 { return(*(int *)0); }
 401
 402 #undef box
 403 int     box(
 404                 WINDOW  *a1,
 405                 chtype  a2,
 406                 chtype  z)
 407                 { return(*(int *)0); }
 408
 409 #undef chgat
 410 int     chgat(
 411                 int     a1,
 412                 attr_t  a2,
 413                 short   a3,
 414                 const void *z)
 415                 { return(*(int *)0); }
 416
 417 #undef clear
 418 int     clear(void)
 419                 { return(*(int *)0); }
 420
 421 #undef clrtobot
 422 int     clrtobot(void)
 423                 { return(*(int *)0); }
 424
 425 #undef clrtoeol
 426 int     clrtoeol(void)
 427                 { return(*(int *)0); }
 428
 429 #undef COLOR_PAIR
 430 int     COLOR_PAIR(
 431                 int     z)
 432                 { return(*(int *)0); }
 433
 434 #undef delch
 435 int     delch(void)
 436                 { return(*(int *)0); }
 437
 438 #undef deleteln
 439 int     deleteln(void)
 440                 { return(*(int *)0); }
 441
 442 #undef echochar
 443 int     echochar(
 444                 const chtype z)
 445                 { return(*(int *)0); }
 446
 447 #undef getbkgd
 448 chtype  getbkgd(
 449                 WINDOW  *z)
 450                 { return(*(chtype *)0); }
 451
 452 #undef getch
 453 int     getch(void)
 454                 { return(*(int *)0); }
 455
 456 #undef getnstr
 457 int     getnstr(
 458                 char    *a1,
 459                 int     z)
 460                 { return(*(int *)0); }
 461
 462 #undef getstr
 463 int     getstr(
 464                 char    *z)
 465                 { return(*(int *)0); }
 466
 467 #undef hline
 468 int     hline(
 469                 chtype  a1,
 470                 int     z)
 471                 { return(*(int *)0); }
 472
 473 #undef inch
 474 chtype  inch(void)
 475                 { return(*(chtype *)0); }
 476
 477 #undef inchnstr
 478 int     inchnstr(
 479                 chtype  *a1,
 480                 int     z)
 481                 { return(*(int *)0); }
 482
 483 #undef inchstr
 484 int     inchstr(
 485                 chtype  *z)
 486                 { return(*(int *)0); }
 487
 488 #undef innstr
 489 int     innstr(
 490                 char    *a1,
 491                 int     z)
 492                 { return(*(int *)0); }
 493
 494 #undef insch
 495 int     insch(
 496                 chtype  z)
 497                 { return(*(int *)0); }
 498
 499 #undef insdelln
 500 int     insdelln(
 501                 int     z)
 502                 { return(*(int *)0); }
 503
 504 #undef insertln
 505 int     insertln(void)
 506                 { return(*(int *)0); }
 507
 508 #undef insnstr
 509 int     insnstr(
 510                 const char *a1,
 511                 int     z)
 512                 { return(*(int *)0); }
 513
 514 #undef insstr
 515 int     insstr(
 516                 const char *z)
 517                 { return(*(int *)0); }
 518
 519 #undef instr
 520 int     instr(
 521                 char    *z)
 522                 { return(*(int *)0); }
 523
 524 #undef move
 525 int     move(
 526                 int     a1,
 527                 int     z)
 528                 { return(*(int *)0); }
 529
 530 #undef mvaddch
 531 int     mvaddch(
 532                 int     a1,
 533                 int     a2,
 534                 const chtype z)
 535                 { return(*(int *)0); }
 536
 537 #undef mvaddchnstr
 538 int     mvaddchnstr(
 539                 int     a1,
 540                 int     a2,
 541                 const chtype *a3,
 542                 int     z)
 543                 { return(*(int *)0); }
 544
 545 #undef mvaddchstr
 546 int     mvaddchstr(
 547                 int     a1,
 548                 int     a2,
 549                 const chtype *z)
 550                 { return(*(int *)0); }
 551
 552 #undef mvaddnstr
 553 int     mvaddnstr(
 554                 int     a1,
 555                 int     a2,
 556                 const char *a3,
 557                 int     z)
 558                 { return(*(int *)0); }
 559
 560 #undef mvaddstr
 561 int     mvaddstr(
 562                 int     a1,
 563                 int     a2,
 564                 const char *z)
 565                 { return(*(int *)0); }
 566
 567 #undef mvchgat
 568 int     mvchgat(
 569                 int     a1,
 570                 int     a2,
 571                 int     a3,
 572                 attr_t  a4,
 573                 short   a5,
 574                 const void *z)
 575                 { return(*(int *)0); }
 576
 577 #undef mvdelch
 578 int     mvdelch(
 579                 int     a1,
 580                 int     z)
 581                 { return(*(int *)0); }
 582
 583 #undef mvgetch
 584 int     mvgetch(
 585                 int     a1,
 586                 int     z)
 587                 { return(*(int *)0); }
 588
 589 #undef mvgetnstr
 590 int     mvgetnstr(
 591                 int     a1,
 592                 int     a2,
 593                 char    *a3,
 594                 int     z)
 595                 { return(*(int *)0); }
 596
 597 #undef mvgetstr
 598 int     mvgetstr(
 599                 int     a1,
 600                 int     a2,
 601                 char    *z)
 602                 { return(*(int *)0); }
 603
 604 #undef mvhline
 605 int     mvhline(
 606                 int     a1,
 607                 int     a2,
 608                 chtype  a3,
 609                 int     z)
 610                 { return(*(int *)0); }
 611
 612 #undef mvinch
 613 chtype  mvinch(
 614                 int     a1,
 615                 int     z)
 616                 { return(*(chtype *)0); }
 617
 618 #undef mvinchnstr
 619 int     mvinchnstr(
 620                 int     a1,
 621                 int     a2,
 622                 chtype  *a3,
 623                 int     z)
 624                 { return(*(int *)0); }
 625
 626 #undef mvinchstr
 627 int     mvinchstr(
 628                 int     a1,
 629                 int     a2,
 630                 chtype  *z)
 631                 { return(*(int *)0); }
 632
 633 #undef mvinnstr
 634 int     mvinnstr(
 635                 int     a1,
 636                 int     a2,
 637                 char    *a3,
 638                 int     z)
 639                 { return(*(int *)0); }
 640
 641 #undef mvinsch
 642 int     mvinsch(
 643                 int     a1,
 644                 int     a2,
 645                 chtype  z)
 646                 { return(*(int *)0); }
 647
 648 #undef mvinsnstr
 649 int     mvinsnstr(
 650                 int     a1,
 651                 int     a2,
 652                 const char *a3,
 653                 int     z)
 654                 { return(*(int *)0); }
 655
 656 #undef mvinsstr
 657 int     mvinsstr(
 658                 int     a1,
 659                 int     a2,
 660                 const char *z)
 661                 { return(*(int *)0); }
 662
 663 #undef mvinstr
 664 int     mvinstr(
 665                 int     a1,
 666                 int     a2,
 667                 char    *z)
 668                 { return(*(int *)0); }
 669
 670 #undef mvvline
 671 int     mvvline(
 672                 int     a1,
 673                 int     a2,
 674                 chtype  a3,
 675                 int     z)
 676                 { return(*(int *)0); }
 677
 678 #undef mvwaddch
 679 int     mvwaddch(
 680                 WINDOW  *a1,
 681                 int     a2,
 682                 int     a3,
 683                 const chtype z)
 684                 { return(*(int *)0); }
 685
 686 #undef mvwaddchnstr
 687 int     mvwaddchnstr(
 688                 WINDOW  *a1,
 689                 int     a2,
 690                 int     a3,
 691                 const chtype *a4,
 692                 int     z)
 693                 { return(*(int *)0); }
 694
 695 #undef mvwaddchstr
 696 int     mvwaddchstr(
 697                 WINDOW  *a1,
 698                 int     a2,
 699                 int     a3,
 700                 const chtype *z)
 701                 { return(*(int *)0); }
 702
 703 #undef mvwaddnstr
 704 int     mvwaddnstr(
 705                 WINDOW  *a1,
 706                 int     a2,
 707                 int     a3,
 708                 const char *a4,
 709                 int     z)
 710                 { return(*(int *)0); }
 711
 712 #undef mvwaddstr
 713 int     mvwaddstr(
 714                 WINDOW  *a1,
 715                 int     a2,
 716                 int     a3,
 717                 const char *z)
 718                 { return(*(int *)0); }
 719
 720 #undef mvwchgat
 721 int     mvwchgat(
 722                 WINDOW  *a1,
 723                 int     a2,
 724                 int     a3,
 725                 int     a4,
 726                 attr_t  a5,
 727                 short   a6,
 728                 const void *z)
 729                 { return(*(int *)0); }
 730
 731 #undef mvwdelch
 732 int     mvwdelch(
 733                 WINDOW  *a1,
 734                 int     a2,
 735                 int     z)
 736                 { return(*(int *)0); }
 737
 738 #undef mvwgetch
 739 int     mvwgetch(
 740                 WINDOW  *a1,
 741                 int     a2,
 742                 int     z)
 743                 { return(*(int *)0); }
 744
 745 #undef mvwgetnstr
 746 int     mvwgetnstr(
 747                 WINDOW  *a1,
 748                 int     a2,
 749                 int     a3,
 750                 char    *a4,
 751                 int     z)
 752                 { return(*(int *)0); }
 753
 754 #undef mvwgetstr
 755 int     mvwgetstr(
 756                 WINDOW  *a1,
 757                 int     a2,
 758                 int     a3,
 759                 char    *z)
 760                 { return(*(int *)0); }
 761
 762 #undef mvwhline
 763 int     mvwhline(
 764                 WINDOW  *a1,
 765                 int     a2,
 766                 int     a3,
 767                 chtype  a4,
 768                 int     z)
 769                 { return(*(int *)0); }
 770
 771 #undef mvwinch
 772 chtype  mvwinch(
 773                 WINDOW  *a1,
 774                 int     a2,
 775                 int     z)
 776                 { return(*(chtype *)0); }
 777
 778 #undef mvwinchnstr
 779 int     mvwinchnstr(
 780                 WINDOW  *a1,
 781                 int     a2,
 782                 int     a3,
 783                 chtype  *a4,
 784                 int     z)
 785                 { return(*(int *)0); }
 786
 787 #undef mvwinchstr
 788 int     mvwinchstr(
 789                 WINDOW  *a1,
 790                 int     a2,
 791                 int     a3,
 792                 chtype  *z)
 793                 { return(*(int *)0); }
 794
 795 #undef mvwinnstr
 796 int     mvwinnstr(
 797                 WINDOW  *a1,
 798                 int     a2,
 799                 int     a3,
 800                 char    *a4,
 801                 int     z)
 802                 { return(*(int *)0); }
 803
 804 #undef mvwinsch
 805 int     mvwinsch(
 806                 WINDOW  *a1,
 807                 int     a2,
 808                 int     a3,
 809                 chtype  z)
 810                 { return(*(int *)0); }
 811
 812 #undef mvwinsnstr
 813 int     mvwinsnstr(
 814                 WINDOW  *a1,
 815                 int     a2,
 816                 int     a3,
 817                 const char *a4,
 818                 int     z)
 819                 { return(*(int *)0); }
 820
 821 #undef mvwinsstr
 822 int     mvwinsstr(
 823                 WINDOW  *a1,
 824                 int     a2,
 825                 int     a3,
 826                 const char *z)
 827                 { return(*(int *)0); }
 828
 829 #undef mvwinstr
 830 int     mvwinstr(
 831                 WINDOW  *a1,
 832                 int     a2,
 833                 int     a3,
 834                 char    *z)
 835                 { return(*(int *)0); }
 836
 837 #undef mvwvline
 838 int     mvwvline(
 839                 WINDOW  *a1,
 840                 int     a2,
 841                 int     a3,
 842                 chtype  a4,
 843                 int     z)
 844                 { return(*(int *)0); }
 845
 846 #undef PAIR_NUMBER
 847 int     PAIR_NUMBER(
 848                 int     z)
 849                 { return(*(int *)0); }
 850
 851 #undef redrawwin
 852 int     redrawwin(
 853                 WINDOW  *z)
 854                 { return(*(int *)0); }
 855
 856 #undef refresh
 857 int     refresh(void)
 858                 { return(*(int *)0); }
 859
 860 #undef scrl
 861 int     scrl(
 862                 int     z)
 863                 { return(*(int *)0); }
 864
 865 #undef scroll
 866 int     scroll(
 867                 WINDOW  *z)
 868                 { return(*(int *)0); }
 869
 870 #undef setscrreg
 871 int     setscrreg(
 872                 int     a1,
 873                 int     z)
 874                 { return(*(int *)0); }
 875
 876 #undef standout
 877 int     standout(void)
 878                 { return(*(int *)0); }
 879
 880 #undef standend
 881 int     standend(void)
 882                 { return(*(int *)0); }
 883
 884 #undef timeout
 885 int     timeout(
 886                 int     z)
 887                 { return(*(int *)0); }
 888
 889 #undef untouchwin
 890 int     untouchwin(
 891                 WINDOW  *z)
 892                 { return(*(int *)0); }
 893
 894 #undef vline
 895 int     vline(
 896                 chtype  a1,
 897                 int     z)
 898                 { return(*(int *)0); }
 899
 900 #undef vw_printw
 901 int     vw_printw(
 902                 WINDOW  *a1,
 903                 const char *a2,
 904                 va_list z)
 905                 { return(*(int *)0); }
 906
 907 #undef vw_scanw
 908 int     vw_scanw(
 909                 WINDOW  *a1,
 910                 const char *a2,
 911                 va_list z)
 912                 { return(*(int *)0); }
 913
 914 #undef waddchstr
 915 int     waddchstr(
 916                 WINDOW  *a1,
 917                 const chtype *z)
 918                 { return(*(int *)0); }
 919
 920 #undef waddstr
 921 int     waddstr(
 922                 WINDOW  *a1,
 923                 const char *z)
 924                 { return(*(int *)0); }
 925
 926 #undef wattron
 927 int     wattron(
 928                 WINDOW  *a1,
 929                 int     z)
 930                 { return(*(int *)0); }
 931
 932 #undef wattroff
 933 int     wattroff(
 934                 WINDOW  *a1,
 935                 int     z)
 936                 { return(*(int *)0); }
 937
 938 #undef wattrset
 939 int     wattrset(
 940                 WINDOW  *a1,
 941                 int     z)
 942                 { return(*(int *)0); }
 943
 944 #undef wattr_get
 945 attr_t  wattr_get(
 946                 WINDOW  *z)
 947                 { return(*(attr_t *)0); }
 948
 949 #undef wattr_set
 950 int     wattr_set(
 951                 WINDOW  *a1,
 952                 attr_t  z)
 953                 { return(*(int *)0); }
 954
 955 #undef wbkgdset
 956 void    wbkgdset(
 957                 WINDOW  *a1,
 958                 chtype  z)
 959                 { /* void */ }
 960
 961 #undef wdeleteln
 962 int     wdeleteln(
 963                 WINDOW  *z)
 964                 { return(*(int *)0); }
 965
 966 #undef wgetstr
 967 int     wgetstr(
 968                 WINDOW  *a1,
 969                 char    *z)
 970                 { return(*(int *)0); }
 971
 972 #undef winch
 973 chtype  winch(
 974                 WINDOW  *z)
 975                 { return(*(chtype *)0); }
 976
 977 #undef winchstr
 978 int     winchstr(
 979                 WINDOW  *a1,
 980                 chtype  *z)
 981                 { return(*(int *)0); }
 982
 983 #undef winsertln
 984 int     winsertln(
 985                 WINDOW  *z)
 986                 { return(*(int *)0); }
 987
 988 #undef winsstr
 989 int     winsstr(
 990                 WINDOW  *a1,
 991                 const char *z)
 992                 { return(*(int *)0); }
 993
 994 #undef winstr
 995 int     winstr(
 996                 WINDOW  *a1,
 997                 char    *z)
 998                 { return(*(int *)0); }
 999
1000 #undef wstandout
1001 int     wstandout(
1002                 WINDOW  *z)
1003                 { return(*(int *)0); }
1004
1005 #undef wstandend
1006 int     wstandend(
1007                 WINDOW  *z)
1008                 { return(*(int *)0); }
1009
1010 /* ./lib_getch.c */
1011
1012 #undef ESCDELAY
1013 int     ESCDELAY;
1014
1015 #undef ungetch
1016 int     ungetch(
1017                 int     ch)
1018                 { return(*(int *)0); }
1019
1020 #undef _nc_backspace
1021 void    _nc_backspace(
1022                 WINDOW  *win)
1023                 { /* void */ }
1024
1025 #undef wgetch
1026 int     wgetch(
1027                 WINDOW  *win)
1028                 { return(*(int *)0); }
1029
1030 /* ./lib_getstr.c */
1031
1032 #undef wgetnstr
1033 int     wgetnstr(
1034                 WINDOW  *win,
1035                 char    *str,
1036                 int     maxlen)
1037                 { return(*(int *)0); }
1038
1039 /* ./lib_inchstr.c */
1040
1041 #undef winchnstr
1042 int     winchnstr(
1043                 WINDOW  *win,
1044                 chtype  *str,
1045                 int     n)
1046                 { return(*(int *)0); }
1047
1048 /* ./lib_initscr.c */
1049
1050 #undef _nc_initscr
1051 int     _nc_initscr(void)
1052                 { return(*(int *)0); }
1053
1054 #undef initscr
1055 WINDOW  *initscr(void)
1056                 { return(*(WINDOW **)0); }
1057
1058 #undef termname
1059 char    *termname(void)
1060                 { return(*(char **)0); }
1061
1062 /* ./lib_insch.c */
1063
1064 #undef winsch
1065 int     winsch(
1066                 WINDOW  *win,
1067                 chtype  c)
1068                 { return(*(int *)0); }
1069
1070 /* ./lib_insdel.c */
1071
1072 #undef winsdelln
1073 int     winsdelln(
1074                 WINDOW  *win,
1075                 int     n)
1076                 { return(*(int *)0); }
1077
1078 /* ./lib_insstr.c */
1079
1080 #undef winsnstr
1081 int     winsnstr(
1082                 WINDOW  *win,
1083                 const char *str,
1084                 int     n)
1085                 { return(*(int *)0); }
1086
1087 /* ./lib_instr.c */
1088
1089 #undef winnstr
1090 int     winnstr(
1091                 WINDOW  *win,
1092                 char    *str,
1093                 int     n)
1094                 { return(*(int *)0); }
1095
1096 /* ./lib_isendwin.c */
1097
1098 #undef isendwin
1099 int     isendwin(void)
1100                 { return(*(int *)0); }
1101
1102 /* ./lib_kernel.c */
1103
1104 #undef napms
1105 int     napms(
1106                 int     ms)
1107                 { return(*(int *)0); }
1108
1109 #undef reset_prog_mode
1110 int     reset_prog_mode(void)
1111                 { return(*(int *)0); }
1112
1113 #undef reset_shell_mode
1114 int     reset_shell_mode(void)
1115                 { return(*(int *)0); }
1116
1117 #undef erasechar
1118 char    erasechar(void)
1119                 { return(*(char *)0); }
1120
1121 #undef killchar
1122 char    killchar(void)
1123                 { return(*(char *)0); }
1124
1125 #undef flushinp
1126 int     flushinp(void)
1127                 { return(*(int *)0); }
1128
1129 #undef savetty
1130 int     savetty(void)
1131                 { return(*(int *)0); }
1132
1133 #undef resetty
1134 int     resetty(void)
1135                 { return(*(int *)0); }
1136
1137 /* ./lib_keyname.c */
1138
1139 #include <ncurses_cfg.h>
1140 #include <stdlib.h>
1141
1142 struct kn {
1143         const char *name;
1144         int code;
1145 };
1146
1147 #undef key_names
1148 const struct kn key_names[] = {0};
1149
1150 #undef keyname
1151 const char *keyname(
1152                 int     c)
1153                 { return(*(const char **)0); }
1154
1155 /* ./lib_longname.c */
1156
1157 #undef longname
1158 char    *longname(void)
1159                 { return(*(char **)0); }
1160
1161 /* ./lib_mouse.c */
1162
1163 #undef _nc_max_click_interval
1164 int     _nc_max_click_interval;
1165
1166 #undef _nc_mouse_init
1167 void    _nc_mouse_init(
1168                 SCREEN  *sp)
1169                 { /* void */ }
1170
1171 #undef _nc_mouse_fd
1172 int     _nc_mouse_fd(void)
1173                 { return(*(int *)0); }
1174
1175 #undef _nc_mouse_event
1176 bool    _nc_mouse_event(
1177                 SCREEN  *sp)
1178                 { return(*(bool *)0); }
1179
1180 #undef _nc_mouse_inline
1181 bool    _nc_mouse_inline(
1182                 SCREEN  *sp)
1183                 { return(*(bool *)0); }
1184
1185 #undef _nc_mouse_parse
1186 bool    _nc_mouse_parse(
1187                 int     runcount)
1188                 { return(*(bool *)0); }
1189
1190 #undef _nc_mouse_wrap
1191 void    _nc_mouse_wrap(
1192                 SCREEN  *sp)
1193                 { /* void */ }
1194
1195 #undef _nc_mouse_resume
1196 void    _nc_mouse_resume(
1197                 SCREEN  *sp)
1198                 { /* void */ }
1199
1200 #undef getmouse
1201 int     getmouse(
1202                 MEVENT  *aevent)
1203                 { return(*(int *)0); }
1204
1205 #undef ungetmouse
1206 int     ungetmouse(
1207                 MEVENT  *aevent)
1208                 { return(*(int *)0); }
1209
1210 #undef mousemask
1211 mmask_t mousemask(
1212                 mmask_t newmask,
1213                 mmask_t *oldmask)
1214                 { return(*(mmask_t *)0); }
1215
1216 #undef wenclose
1217 bool    wenclose(
1218                 WINDOW  *win,
1219                 int     y,
1220                 int     x)
1221                 { return(*(bool *)0); }
1222
1223 #undef mouseinterval
1224 int     mouseinterval(
1225                 int     maxclick)
1226                 { return(*(int *)0); }
1227
1228 /* ./lib_move.c */
1229
1230 #undef wmove
1231 int     wmove(
1232                 WINDOW  *win,
1233                 int     y,
1234                 int     x)
1235                 { return(*(int *)0); }
1236
1237 /* ./lib_mvcur.c */
1238
1239 #undef _nc_mvcur_resume
1240 void    _nc_mvcur_resume(void)
1241                 { /* void */ }
1242
1243 #undef _nc_mvcur_init
1244 void    _nc_mvcur_init(void)
1245                 { /* void */ }
1246
1247 #undef _nc_mvcur_wrap
1248 void    _nc_mvcur_wrap(void)
1249                 { /* void */ }
1250
1251 #undef mvcur
1252 int     mvcur(
1253                 int     yold,
1254                 int     xold,
1255                 int     ynew,
1256                 int     xnew)
1257                 { return(*(int *)0); }
1258
1259 #undef _nc_mvcur_scrolln
1260 int     _nc_mvcur_scrolln(
1261                 int     n,
1262                 int     top,
1263                 int     bot,
1264                 int     maxy)
1265                 { return(*(int *)0); }
1266
1267 /* ./lib_mvwin.c */
1268
1269 #undef mvwin
1270 int     mvwin(
1271                 WINDOW  *win,
1272                 int     by,
1273                 int     bx)
1274                 { return(*(int *)0); }
1275
1276 /* ./lib_newterm.c */
1277
1278 #undef filter
1279 void    filter(void)
1280                 { /* void */ }
1281
1282 #undef newterm
1283 SCREEN  *newterm(
1284                 const char *term,
1285                 FILE    *ofp,
1286                 FILE    *ifp)
1287                 { return(*(SCREEN **)0); }
1288
1289 /* ./lib_newwin.c */
1290
1291 #undef _nc_freewin
1292 void    _nc_freewin(
1293                 WINDOW  *win)
1294                 { /* void */ }
1295
1296 #undef newwin
1297 WINDOW  *newwin(
1298                 int     num_lines,
1299                 int     num_columns,
1300                 int     begy,
1301                 int     begx)
1302                 { return(*(WINDOW **)0); }
1303
1304 #undef derwin
1305 WINDOW  *derwin(
1306                 WINDOW  *orig,
1307                 int     num_lines,
1308                 int     num_columns,
1309                 int     begy,
1310                 int     begx)
1311                 { return(*(WINDOW **)0); }
1312
1313 #undef subwin
1314 WINDOW  *subwin(
1315                 WINDOW  *w,
1316                 int     l,
1317                 int     c,
1318                 int     y,
1319                 int     x)
1320                 { return(*(WINDOW **)0); }
1321
1322 #undef _nc_makenew
1323 WINDOW  *_nc_makenew(
1324                 int     num_lines,
1325                 int     num_columns,
1326                 int     begy,
1327                 int     begx,
1328                 int     flags)
1329                 { return(*(WINDOW **)0); }
1330
1331 /* ./lib_options.c */
1332
1333 #undef has_ic
1334 int     has_ic(void)
1335                 { return(*(int *)0); }
1336
1337 #undef has_il
1338 int     has_il(void)
1339                 { return(*(int *)0); }
1340
1341 #undef idlok
1342 int     idlok(
1343                 WINDOW  *win,
1344                 bool    flag)
1345                 { return(*(int *)0); }
1346
1347 #undef idcok
1348 void    idcok(
1349                 WINDOW  *win,
1350                 bool    flag)
1351                 { /* void */ }
1352
1353 #undef clearok
1354 int     clearok(
1355                 WINDOW  *win,
1356                 bool    flag)
1357                 { return(*(int *)0); }
1358
1359 #undef immedok
1360 void    immedok(
1361                 WINDOW  *win,
1362                 bool    flag)
1363                 { /* void */ }
1364
1365 #undef leaveok
1366 int     leaveok(
1367                 WINDOW  *win,
1368                 bool    flag)
1369                 { return(*(int *)0); }
1370
1371 #undef scrollok
1372 int     scrollok(
1373                 WINDOW  *win,
1374                 bool    flag)
1375                 { return(*(int *)0); }
1376
1377 #undef halfdelay
1378 int     halfdelay(
1379                 int     t)
1380                 { return(*(int *)0); }
1381
1382 #undef nodelay
1383 int     nodelay(
1384                 WINDOW  *win,
1385                 bool    flag)
1386                 { return(*(int *)0); }
1387
1388 #undef notimeout
1389 int     notimeout(
1390                 WINDOW  *win,
1391                 bool    f)
1392                 { return(*(int *)0); }
1393
1394 #undef wtimeout
1395 int     wtimeout(
1396                 WINDOW  *win,
1397                 int     delay)
1398                 { return(*(int *)0); }
1399
1400 #undef _nc_keypad
1401 int     _nc_keypad(
1402                 bool    flag)
1403                 { return(*(int *)0); }
1404
1405 #undef keypad
1406 int     keypad(
1407                 WINDOW  *win,
1408                 bool    flag)
1409                 { return(*(int *)0); }
1410
1411 #undef meta
1412 int     meta(
1413                 WINDOW  *win,
1414                 bool    flag)
1415                 { return(*(int *)0); }
1416
1417 #undef curs_set
1418 int     curs_set(
1419                 int     vis)
1420                 { return(*(int *)0); }
1421
1422 #if 0
1423
1424 #include <keys.tries>
1425
1426 #endif
1427
1428 #undef typeahead
1429 int     typeahead(
1430                 int     fd)
1431                 { return(*(int *)0); }
1432
1433 #undef has_key
1434 int     has_key(
1435                 int     keycode)
1436                 { return(*(int *)0); }
1437
1438 /* ./lib_overlay.c */
1439
1440 #undef overlay
1441 int     overlay(
1442                 const WINDOW *win1,
1443                 WINDOW  *win2)
1444                 { return(*(int *)0); }
1445
1446 #undef overwrite
1447 int     overwrite(
1448                 const WINDOW *win1,
1449                 WINDOW  *win2)
1450                 { return(*(int *)0); }
1451
1452 #undef copywin
1453 int     copywin(
1454                 const WINDOW *src,
1455                 WINDOW  *dst,
1456                 int     sminrow,
1457                 int     smincol,
1458                 int     dminrow,
1459                 int     dmincol,
1460                 int     dmaxrow,
1461                 int     dmaxcol,
1462                 int     over)
1463                 { return(*(int *)0); }
1464
1465 /* ./lib_pad.c */
1466
1467 #undef newpad
1468 WINDOW  *newpad(
1469                 int     l,
1470                 int     c)
1471                 { return(*(WINDOW **)0); }
1472
1473 #undef subpad
1474 WINDOW  *subpad(
1475                 WINDOW  *orig,
1476                 int     l,
1477                 int     c,
1478                 int     begy,
1479                 int     begx)
1480                 { return(*(WINDOW **)0); }
1481
1482 #undef prefresh
1483 int     prefresh(
1484                 WINDOW  *win,
1485                 int     pminrow,
1486                 int     pmincol,
1487                 int     sminrow,
1488                 int     smincol,
1489                 int     smaxrow,
1490                 int     smaxcol)
1491                 { return(*(int *)0); }
1492
1493 #undef pnoutrefresh
1494 int     pnoutrefresh(
1495                 WINDOW  *win,
1496                 int     pminrow,
1497                 int     pmincol,
1498                 int     sminrow,
1499                 int     smincol,
1500                 int     smaxrow,
1501                 int     smaxcol)
1502                 { return(*(int *)0); }
1503
1504 #undef pechochar
1505 int     pechochar(
1506                 WINDOW  *pad,
1507                 chtype  ch)
1508                 { return(*(int *)0); }
1509
1510 /* ./lib_print.c */
1511
1512 #undef mcprint
1513 int     mcprint(
1514                 char    *data,
1515                 int     len)
1516                 { return(*(int *)0); }
1517
1518 /* ./lib_printw.c */
1519
1520 #undef printw
1521 int     printw(
1522                 const char *fmt,
1523                 ...)
1524                 { return(*(int *)0); }
1525
1526 #undef wprintw
1527 int     wprintw(
1528                 WINDOW  *win,
1529                 const char *fmt,
1530                 ...)
1531                 { return(*(int *)0); }
1532
1533 #undef mvprintw
1534 int     mvprintw(
1535                 int     y,
1536                 int     x,
1537                 const char *fmt,
1538                 ...)
1539                 { return(*(int *)0); }
1540
1541 #undef mvwprintw
1542 int     mvwprintw(
1543                 WINDOW  *win,
1544                 int     y,
1545                 int     x,
1546                 const char *fmt,
1547                 ...)
1548                 { return(*(int *)0); }
1549
1550 #undef vwprintw
1551 int     vwprintw(
1552                 WINDOW  *win,
1553                 const char *fmt,
1554                 va_list argp)
1555                 { return(*(int *)0); }
1556
1557 /* ./lib_raw.c */
1558
1559 #undef raw
1560 int     raw(void)
1561                 { return(*(int *)0); }
1562
1563 #undef cbreak
1564 int     cbreak(void)
1565                 { return(*(int *)0); }
1566
1567 #undef echo
1568 int     echo(void)
1569                 { return(*(int *)0); }
1570
1571 #undef nl
1572 int     nl(void)
1573                 { return(*(int *)0); }
1574
1575 #undef qiflush
1576 int     qiflush(void)
1577                 { return(*(int *)0); }
1578
1579 #undef noraw
1580 int     noraw(void)
1581                 { return(*(int *)0); }
1582
1583 #undef nocbreak
1584 int     nocbreak(void)
1585                 { return(*(int *)0); }
1586
1587 #undef noecho
1588 int     noecho(void)
1589                 { return(*(int *)0); }
1590
1591 #undef nonl
1592 int     nonl(void)
1593                 { return(*(int *)0); }
1594
1595 #undef noqiflush
1596 int     noqiflush(void)
1597                 { return(*(int *)0); }
1598
1599 #undef intrflush
1600 int     intrflush(
1601                 WINDOW  *win,
1602                 bool    flag)
1603                 { return(*(int *)0); }
1604
1605 /* ./lib_refresh.c */
1606
1607 #undef wredrawln
1608 int     wredrawln(
1609                 WINDOW  *win,
1610                 int     beg,
1611                 int     num)
1612                 { return(*(int *)0); }
1613
1614 #undef wrefresh
1615 int     wrefresh(
1616                 WINDOW  *win)
1617                 { return(*(int *)0); }
1618
1619 #undef wnoutrefresh
1620 int     wnoutrefresh(
1621                 WINDOW  *win)
1622                 { return(*(int *)0); }
1623
1624 /* ./lib_restart.c */
1625
1626 #undef def_shell_mode
1627 int     def_shell_mode(void)
1628                 { return(*(int *)0); }
1629
1630 #undef def_prog_mode
1631 int     def_prog_mode(void)
1632                 { return(*(int *)0); }
1633
1634 #undef restartterm
1635 int     restartterm(
1636                 const char *term,
1637                 int     filenum,
1638                 int     *errret)
1639                 { return(*(int *)0); }
1640
1641 #undef set_curterm
1642 TERMINAL *set_curterm(
1643                 TERMINAL *term)
1644                 { return(*(TERMINAL **)0); }
1645
1646 #undef del_curterm
1647 int     del_curterm(
1648                 TERMINAL *term)
1649                 { return(*(int *)0); }
1650
1651 /* ./lib_scanw.c */
1652
1653 #undef vwscanw
1654 int     vwscanw(
1655                 WINDOW  *win,
1656                 const char *fmt,
1657                 va_list argp)
1658                 { return(*(int *)0); }
1659
1660 #undef scanw
1661 int     scanw(
1662                 const char *fmt,
1663                 ...)
1664                 { return(*(int *)0); }
1665
1666 #undef wscanw
1667 int     wscanw(
1668                 WINDOW  *win,
1669                 const char *fmt,
1670                 ...)
1671                 { return(*(int *)0); }
1672
1673 #undef mvscanw
1674 int     mvscanw(
1675                 int     y,
1676                 int     x,
1677                 const char *fmt,
1678                 ...)
1679                 { return(*(int *)0); }
1680
1681 #undef mvwscanw
1682 int     mvwscanw(
1683                 WINDOW  *win,
1684                 int     y,
1685                 int     x,
1686                 const char *fmt,
1687                 ...)
1688                 { return(*(int *)0); }
1689
1690 /* ./lib_screen.c */
1691
1692 #include <sys/stat.h>
1693 #include <time.h>
1694
1695 #undef getwin
1696 WINDOW  *getwin(
1697                 FILE    *filep)
1698                 { return(*(WINDOW **)0); }
1699
1700 #undef putwin
1701 int     putwin(
1702                 WINDOW  *win,
1703                 FILE    *filep)
1704                 { return(*(int *)0); }
1705
1706 #undef scr_restore
1707 int     scr_restore(
1708                 const char *file)
1709                 { return(*(int *)0); }
1710
1711 #undef scr_dump
1712 int     scr_dump(
1713                 const char *file)
1714                 { return(*(int *)0); }
1715
1716 #undef scr_init
1717 int     scr_init(
1718                 const char *file)
1719                 { return(*(int *)0); }
1720
1721 #undef scr_set
1722 int     scr_set(
1723                 const char *file)
1724                 { return(*(int *)0); }
1725
1726 /* ./lib_scroll.c */
1727
1728 #undef _nc_scroll_window
1729 void    _nc_scroll_window(
1730                 WINDOW  *win,
1731                 int const n,
1732                 short const top,
1733                 short const bottom)
1734                 { /* void */ }
1735
1736 #undef wscrl
1737 int     wscrl(
1738                 WINDOW  *win,
1739                 int     n)
1740                 { return(*(int *)0); }
1741
1742 /* ./lib_scrreg.c */
1743
1744 #undef wsetscrreg
1745 int     wsetscrreg(
1746                 WINDOW  *win,
1747                 int     top,
1748                 int     bottom)
1749                 { return(*(int *)0); }
1750
1751 /* ./lib_set_term.c */
1752
1753 #undef _nc_set_buffer
1754 void    _nc_set_buffer(
1755                 FILE    *ofp,
1756                 bool    buffered)
1757                 { /* void */ }
1758
1759 #undef set_term
1760 SCREEN  *set_term(
1761                 SCREEN  *screen)
1762                 { return(*(SCREEN **)0); }
1763
1764 #undef delscreen
1765 void    delscreen(
1766                 SCREEN  *sp)
1767                 { /* void */ }
1768
1769 #undef rippedoff
1770 ripoff_t rippedoff[5];
1771 #undef rsp
1772 ripoff_t *rsp;
1773
1774 #undef _nc_setupscreen
1775 int     _nc_setupscreen(
1776                 short   slines,
1777                 short const scolumns,
1778                 FILE    *output)
1779                 { return(*(int *)0); }
1780
1781 #undef _nc_ripoffline
1782 int     _nc_ripoffline(
1783                 int     line,
1784                 int     (*init)(
1785                 WINDOW  *p1,
1786                 int     p2))
1787                 { return(*(int *)0); }
1788
1789 #undef ripoffline
1790 int     ripoffline(
1791                 int     line,
1792                 int     (*init)(
1793                 WINDOW  *p1,
1794                 int     p2))
1795                 { return(*(int *)0); }
1796
1797 /* ./lib_setup.c */
1798
1799 #include <sys/ioctl.h>
1800
1801 #undef use_env
1802 void    use_env(
1803                 bool    f)
1804                 { /* void */ }
1805
1806 #undef LINES
1807 int     LINES;
1808 #undef COLS
1809 int     COLS;
1810 #undef TABSIZE
1811 int     TABSIZE;
1812
1813 #undef _nc_get_screensize
1814 void    _nc_get_screensize(void)
1815                 { /* void */ }
1816
1817 #undef ttytype
1818 char    ttytype[256 ];
1819
1820 #undef setupterm
1821 int     setupterm(
1822                 const char *tname,
1823                 int     Filedes,
1824                 int     *errret)
1825                 { return(*(int *)0); }
1826
1827 /* ./lib_slk.c */
1828
1829 #undef _nc_slk_format
1830 int     _nc_slk_format;
1831
1832 #undef slk_label
1833 char    *slk_label(
1834                 int     n)
1835                 { return(*(char **)0); }
1836
1837 #undef slk_noutrefresh
1838 int     slk_noutrefresh(void)
1839                 { return(*(int *)0); }
1840
1841 #undef slk_refresh
1842 int     slk_refresh(void)
1843                 { return(*(int *)0); }
1844
1845 #undef slk_restore
1846 int     slk_restore(void)
1847                 { return(*(int *)0); }
1848
1849 #undef slk_set
1850 int     slk_set(
1851                 int     i,
1852                 const char *astr,
1853                 int     format)
1854                 { return(*(int *)0); }
1855
1856 #undef slk_touch
1857 int     slk_touch(void)
1858                 { return(*(int *)0); }
1859
1860 #undef slk_clear
1861 int     slk_clear(void)
1862                 { return(*(int *)0); }
1863
1864 #undef _nc_slk_initialize
1865 int     _nc_slk_initialize(
1866                 WINDOW  *stwin,
1867                 int     cols)
1868                 { return(*(int *)0); }
1869
1870 #undef slk_init
1871 int     slk_init(
1872                 int     format)
1873                 { return(*(int *)0); }
1874
1875 #undef slk_attrset
1876 int     slk_attrset(
1877                 const attr_t attr)
1878                 { return(*(int *)0); }
1879
1880 #undef slk_attron
1881 int     slk_attron(
1882                 const attr_t attr)
1883                 { return(*(int *)0); }
1884
1885 #undef slk_attroff
1886 int     slk_attroff(
1887                 const attr_t attr)
1888                 { return(*(int *)0); }
1889
1890 #undef slk_attr
1891 attr_t  slk_attr(void)
1892                 { return(*(attr_t *)0); }
1893
1894 /* ./lib_termcap.c */
1895
1896 #include <termcap.h>
1897 #include <tic.h>
1898
1899 #undef PC
1900 char    PC;
1901 #undef UP
1902 char    *UP;
1903 #undef BC
1904 char    *BC;
1905 #undef ospeed
1906 short   ospeed;
1907
1908 #undef tgetent
1909 int     tgetent(
1910                 char    *bufp,
1911                 const char *name)
1912                 { return(*(int *)0); }
1913
1914 #if 0
1915
1916 #include <capdefaults.c>
1917
1918 #endif
1919
1920 #undef tgetflag
1921 int     tgetflag(
1922                 const char *id)
1923                 { return(*(int *)0); }
1924
1925 #undef tgetnum
1926 int     tgetnum(
1927                 const char *id)
1928                 { return(*(int *)0); }
1929
1930 #undef tgetstr
1931 char    *tgetstr(
1932                 const char *id,
1933                 char    **area)
1934                 { return(*(char **)0); }
1935
1936 #undef tgoto
1937 char    *tgoto(
1938                 const char *string,
1939                 int     x,
1940                 int     y)
1941                 { return(*(char **)0); }
1942
1943 /* ./lib_ti.c */
1944
1945 #undef tigetflag
1946 int     tigetflag(
1947                 const char *str)
1948                 { return(*(int *)0); }
1949
1950 #undef tigetnum
1951 int     tigetnum(
1952                 const char *str)
1953                 { return(*(int *)0); }
1954
1955 #undef tigetstr
1956 char    *tigetstr(
1957                 const char *str)
1958                 { return(*(char **)0); }
1959
1960 /* ./lib_touch.c */
1961
1962 #undef is_linetouched
1963 int     is_linetouched(
1964                 WINDOW  *win,
1965                 int     line)
1966                 { return(*(int *)0); }
1967
1968 #undef is_wintouched
1969 int     is_wintouched(
1970                 WINDOW  *win)
1971                 { return(*(int *)0); }
1972
1973 #undef wtouchln
1974 int     wtouchln(
1975                 WINDOW  *win,
1976                 int     y,
1977                 int     n,
1978                 int     changed)
1979                 { return(*(int *)0); }
1980
1981 /* ./lib_tparm.c */
1982
1983 typedef union {
1984         unsigned int    num;
1985         char           *str;
1986 } stack_frame;
1987
1988 #undef tparm
1989 char    *tparm(
1990                 const char *string,
1991                 ...)
1992                 { return(*(char **)0); }
1993
1994 /* ./lib_tputs.c */
1995
1996 #undef delay_output
1997 int     delay_output(
1998                 int     ms)
1999                 { return(*(int *)0); }
2000
2001 #undef _nc_outch
2002 int     _nc_outch(
2003                 int     ch)
2004                 { return(*(int *)0); }
2005
2006 #undef putp
2007 int     putp(
2008                 const char *string)
2009                 { return(*(int *)0); }
2010
2011 #undef tputs
2012 int     tputs(
2013                 const char *string,
2014                 int     affcnt,
2015                 int     (*outc)(
2016                 int     p1))
2017                 { return(*(int *)0); }
2018
2019 /* ./lib_trace.c */
2020
2021 #include <fcntl.h>
2022
2023 #undef _nc_tracing
2024 unsigned _nc_tracing;
2025 #undef _nc_tputs_trace
2026 const char *_nc_tputs_trace = {0};
2027 #undef _nc_outchars
2028 long    _nc_outchars;
2029 #undef _nc_optimize_enable
2030 int     _nc_optimize_enable;
2031
2032 #undef trace
2033 void    trace(
2034                 const unsigned int tracelevel)
2035                 { /* void */ }
2036
2037 #undef _nc_visbuf
2038 const char *_nc_visbuf(
2039                 const char *buf)
2040                 { return(*(const char **)0); }
2041
2042 #undef _tracef
2043 void    _tracef(
2044                 const char *fmt,
2045                 ...)
2046                 { /* void */ }
2047
2048 /* ./lib_traceatr.c */
2049
2050 #undef _traceattr
2051 char    *_traceattr(
2052                 attr_t  newmode)
2053                 { return(*(char **)0); }
2054
2055 #undef _tracechtype
2056 char    *_tracechtype(
2057                 chtype  ch)
2058                 { return(*(char **)0); }
2059
2060 /* ./lib_tracechr.c */
2061
2062 #undef _tracechar
2063 char    *_tracechar(
2064                 const unsigned char ch)
2065                 { return(*(char **)0); }
2066
2067 /* ./lib_tracedmp.c */
2068
2069 #undef _tracedump
2070 void    _tracedump(
2071                 const char *name,
2072                 WINDOW  *win)
2073                 { /* void */ }
2074
2075 /* ./lib_tracemse.c */
2076
2077 #undef _tracemouse
2078 char    *_tracemouse(
2079                 MEVENT const *ep)
2080                 { return(*(char **)0); }
2081
2082 /* ./lib_tstp.c */
2083
2084 #include <signal.h>
2085
2086 typedef struct sigaction sigaction_t;
2087
2088 #undef _nc_signal_handler
2089 void    _nc_signal_handler(
2090                 bool    enable)
2091                 { /* void */ }
2092
2093 /* ./lib_twait.c */
2094
2095 #undef _nc_timed_wait
2096 int     _nc_timed_wait(
2097                 int     mode,
2098                 int     milliseconds,
2099                 int     *timeleft)
2100                 { return(*(int *)0); }
2101
2102 /* ./lib_unctrl.c */
2103
2104 #undef unctrl
2105 char    *unctrl(
2106                  chtype uch)
2107                 { return(*(char **)0); }
2108
2109 /* ./lib_vidattr.c */
2110
2111 #undef vidputs
2112 int     vidputs(
2113                 attr_t  newmode,
2114                 int     (*outc)(
2115                 int     p1))
2116                 { return(*(int *)0); }
2117
2118 #undef vidattr
2119 int     vidattr(
2120                 attr_t  newmode)
2121                 { return(*(int *)0); }
2122
2123 #undef termattrs
2124 attr_t  termattrs(void)
2125                 { return(*(attr_t *)0); }
2126
2127 /* ./lib_window.c */
2128
2129 #undef _nc_synchook
2130 void    _nc_synchook(
2131                 WINDOW  *win)
2132                 { /* void */ }
2133
2134 #undef mvderwin
2135 int     mvderwin(
2136                 WINDOW  *win,
2137                 int     y,
2138                 int     x)
2139                 { return(*(int *)0); }
2140
2141 #undef syncok
2142 int     syncok(
2143                 WINDOW  *win,
2144                 bool    bf)
2145                 { return(*(int *)0); }
2146
2147 #undef wsyncup
2148 void    wsyncup(
2149                 WINDOW  *win)
2150                 { /* void */ }
2151
2152 #undef wsyncdown
2153 void    wsyncdown(
2154                 WINDOW  *win)
2155                 { /* void */ }
2156
2157 #undef wcursyncup
2158 void    wcursyncup(
2159                 WINDOW  *win)
2160                 { /* void */ }
2161
2162 #undef dupwin
2163 WINDOW  *dupwin(
2164                 WINDOW  *win)
2165                 { return(*(WINDOW **)0); }
2166
2167 /* ./names.c */
2168
2169 #undef boolnames
2170 char    *const boolnames[] = {0};
2171 #undef boolfnames
2172 char    *const boolfnames[] = {0};
2173 #undef numnames
2174 char    *const numnames[] = {0};
2175 #undef numfnames
2176 char    *const numfnames[] = {0};
2177 #undef strnames
2178 char    *const strnames[] = {0};
2179 #undef strfnames
2180 char    *const strfnames[] = {0};
2181
2182 /* ./codes.c */
2183 #undef boolcodes
2184 char    *const boolcodes[] = {0};
2185 #undef numcodes
2186 char    *const numcodes[] = {0};
2187 #undef strcodes
2188 char    *const strcodes[] = {0};
2189
2190 /* ./read_entry.c */
2191 #undef cur_term
2192 TERMINAL *cur_term;
2193
2194 #undef _nc_tic_dir
2195 char    *_nc_tic_dir(
2196                 char    *path)
2197                 { return(*(char **)0); }
2198
2199 #undef _nc_read_file_entry
2200 int     _nc_read_file_entry(
2201                 const char *const filename,
2202                 TERMTYPE *ptr)
2203                 { return(*(int *)0); }
2204
2205 #undef _nc_read_entry
2206 int     _nc_read_entry(
2207                 const char *const tn,
2208                 char    *const filename,
2209                 TERMTYPE *const tp)
2210                 { return(*(int *)0); }
2211
2212 #undef _nc_first_name
2213 char    *_nc_first_name(
2214                 const char *const sp)
2215                 { return(*(char **)0); }
2216
2217 #undef _nc_name_match
2218 int     _nc_name_match(
2219                 const char *const namelst,
2220                 const char *const name,
2221                 const char *const delim)
2222                 { return(*(int *)0); }
2223
2224 /* ./read_termcap.c */
2225
2226 #include <term_entry.h>
2227
2228 #undef _nc_read_termcap_entry
2229 int     _nc_read_termcap_entry(
2230                 const char *const tn,
2231                 TERMTYPE *const tp)
2232                 { return(*(int *)0); }
2233
2234 /* ./write_entry.c */
2235
2236 #undef _nc_set_writedir
2237 void    _nc_set_writedir(
2238                 char    *dir)
2239                 { /* void */ }
2240
2241 #undef _nc_write_entry
2242 void    _nc_write_entry(
2243                 TERMTYPE *const tp)
2244                 { /* void */ }
2245
2246 #undef _nc_tic_written
2247 int     _nc_tic_written(void)
2248                 { return(*(int *)0); }
2249
2250 /* ./sigaction.c */
2251
2252 #undef _nc_sigaction
2253 void    _nc_sigaction(void)
2254                 { /* void */ }
2255
2256 /* ./vsscanf.c */
2257
2258 #undef _nc_vsscanf
2259 void    _nc_vsscanf(void)
2260                 { /* void */ }
2261
2262 /* ./alloc_entry.c */
2263
2264 #undef _nc_init_entry
2265 void    _nc_init_entry(
2266                 TERMTYPE *const tp)
2267                 { /* void */ }
2268
2269 #undef _nc_save_str
2270 char    *_nc_save_str(
2271                 const char *const string)
2272                 { return(*(char **)0); }
2273
2274 #undef _nc_wrap_entry
2275 void    _nc_wrap_entry(
2276                 ENTRY   *const ep)
2277                 { /* void */ }
2278
2279 #undef _nc_merge_entry
2280 void    _nc_merge_entry(
2281                 TERMTYPE *const to,
2282                 TERMTYPE *const from)
2283                 { /* void */ }
2284
2285 /* ./captoinfo.c */
2286
2287 #undef _nc_captoinfo
2288 char    *_nc_captoinfo(
2289                  char   *const cap,
2290                  char   *s,
2291                 int const parametrized)
2292                 { return(*(char **)0); }
2293
2294 #undef _nc_infotocap
2295 char    *_nc_infotocap(
2296                  char   *const cap,
2297                  char   *str,
2298                 int const parametrized)
2299                 { return(*(char **)0); }
2300
2301 /* ./comp_captab.c */
2302
2303 #include <hashsize.h>
2304
2305 #undef _nc_info_hash_table
2306 const struct name_table_entry *const _nc_info_hash_table[991] = {0};
2307 #undef _nc_cap_hash_table
2308 const struct name_table_entry *const _nc_cap_hash_table[991] = {0};
2309 #undef _nc_capalias_table
2310 const struct alias _nc_capalias_table[] = {0};
2311 #undef _nc_infoalias_table
2312 const struct alias _nc_infoalias_table[] = {0};
2313
2314 #undef _nc_get_table
2315 const struct name_table_entry *_nc_get_table(
2316                 bool    termcap)
2317                 { return(*(const struct name_table_entry **)0); }
2318
2319 /* ./comp_error.c */
2320
2321 #undef _nc_suppress_warnings
2322 bool    _nc_suppress_warnings;
2323
2324 #undef _nc_set_source
2325 void    _nc_set_source(
2326                 const char *const name)
2327                 { /* void */ }
2328
2329 #undef _nc_set_type
2330 void    _nc_set_type(
2331                 const char *const name)
2332                 { /* void */ }
2333
2334 #undef _nc_get_type
2335 void    _nc_get_type(
2336                 char    *name)
2337                 { /* void */ }
2338
2339 #undef _nc_warning
2340 void    _nc_warning(
2341                 const char *const fmt,
2342                 ...)
2343                 { /* void */ }
2344
2345 #undef _nc_err_abort
2346 void    _nc_err_abort(
2347                 const char *const fmt,
2348                 ...)
2349                 { /* void */ }
2350
2351 #undef _nc_syserr_abort
2352 void    _nc_syserr_abort(
2353                 const char *const fmt,
2354                 ...)
2355                 { /* void */ }
2356
2357 /* ./comp_hash.c */
2358
2359 #undef _nc_find_entry
2360 struct name_table_entry const *_nc_find_entry(
2361                 const char *string,
2362                 const struct name_table_entry *const *hash_table)
2363                 { return(*(struct name_table_entry const **)0); }
2364
2365 #undef _nc_find_type_entry
2366 struct name_table_entry const *_nc_find_type_entry(
2367                 const char *string,
2368                 int     type,
2369                 const struct name_table_entry *table)
2370                 { return(*(struct name_table_entry const **)0); }
2371
2372 /* ./comp_parse.c */
2373
2374 #undef _nc_head
2375 ENTRY   *_nc_head;
2376 #undef _nc_tail
2377 ENTRY   *_nc_tail;
2378
2379 #undef _nc_free_entries
2380 void    _nc_free_entries(
2381                 ENTRY   *head)
2382                 { /* void */ }
2383
2384 #undef _nc_entry_match
2385 bool    _nc_entry_match(
2386                 char    *n1,
2387                 char    *n2)
2388                 { return(*(bool *)0); }
2389
2390 #undef _nc_read_entry_source
2391 void    _nc_read_entry_source(
2392                 FILE    *fp,
2393                 char    *buf,
2394                 int     literal,
2395                 bool    silent,
2396                 bool    (*hook)(
2397                 ENTRY   *p1))
2398                 { /* void */ }
2399
2400 #undef _nc_resolve_uses
2401 int     _nc_resolve_uses(void)
2402                 { return(*(int *)0); }
2403
2404 /* ./comp_scan.c */
2405
2406 #undef _nc_syntax
2407 int     _nc_syntax;
2408 #undef _nc_curr_line
2409 int     _nc_curr_line;
2410 #undef _nc_curr_col
2411 int     _nc_curr_col;
2412 #undef _nc_curr_file_pos
2413 long    _nc_curr_file_pos;
2414 #undef _nc_comment_start
2415 long    _nc_comment_start;
2416 #undef _nc_comment_end
2417 long    _nc_comment_end;
2418 #undef _nc_start_line
2419 long    _nc_start_line;
2420
2421 #undef _nc_get_token
2422 int     _nc_get_token(void)
2423                 { return(*(int *)0); }
2424
2425 #undef _nc_push_token
2426 void    _nc_push_token(
2427                 int     class)
2428                 { /* void */ }
2429
2430 #undef _nc_panic_mode
2431 void    _nc_panic_mode(
2432                 char    ch)
2433                 { /* void */ }
2434
2435 #undef _nc_reset_input
2436 void    _nc_reset_input(
2437                 FILE    *fp,
2438                 char    *buf)
2439                 { /* void */ }
2440
2441 /* ./parse_entry.c */
2442
2443 #undef _nc_curr_token
2444 struct token _nc_curr_token;
2445
2446 #undef _nc_parse_entry
2447 int     _nc_parse_entry(
2448                 struct entry *entryp,
2449                 int     literal,
2450                 bool    silent)
2451                 { return(*(int *)0); }
2452
2453 #undef _nc_capcmp
2454 int     _nc_capcmp(
2455                 const char *s,
2456                 const char *t)
2457                 { return(*(int *)0); }
2458
2459 typedef struct {const char *from; const char *to;} assoc;
2460
2461 /* ./lib_dft_fgbg.c */
2462
2463 #undef use_default_colors
2464 int     use_default_colors(void)
2465                 { return(*(int *)0); }
2466
2467 /* ./lib_freeall.c */
2468
2469 #undef _nc_free_termtype
2470 void    _nc_free_termtype(
2471                 struct termtype *p,
2472                 int     base)
2473                 { /* void */ }
2474
2475 #undef _nc_freeall
2476 void    _nc_freeall(void)
2477                 { /* void */ }
2478
2479 #undef _nc_free_and_exit
2480 void    _nc_free_and_exit(
2481                 int     code)
2482                 { /* void */ }
2483
2484 /* ./resizeterm.c */
2485
2486 #undef resizeterm
2487 int     resizeterm(
2488                 int     ToLines,
2489                 int     ToCols)
2490                 { return(*(int *)0); }
2491
2492 /* ./wresize.c */
2493
2494 #undef wresize
2495 int     wresize(
2496                 WINDOW  *win,
2497                 int     ToLines,
2498                 int     ToCols)
2499                 { return(*(int *)0); }
2500
2501 /* ./lib_adabind.c */
2502
2503 #undef _nc_ada_getmaxyx
2504 int     _nc_ada_getmaxyx(
2505                 WINDOW  *win,
2506                 int     *y,
2507                 int     *x)
2508                 { return(*(int *)0); }
2509
2510 #undef _nc_ada_getbegyx
2511 int     _nc_ada_getbegyx(
2512                 WINDOW  *win,
2513                 int     *y,
2514                 int     *x)
2515                 { return(*(int *)0); }
2516
2517 #undef _nc_ada_getyx
2518 int     _nc_ada_getyx(
2519                 WINDOW  *win,
2520                 int     *y,
2521                 int     *x)
2522                 { return(*(int *)0); }
2523
2524 #undef _nc_ada_getparyx
2525 int     _nc_ada_getparyx(
2526                 WINDOW  *win,
2527                 int     *y,
2528                 int     *x)
2529                 { return(*(int *)0); }
2530
2531 #undef _nc_ada_isscroll
2532 int     _nc_ada_isscroll(
2533                 WINDOW  *win)
2534                 { return(*(int *)0); }
2535
2536 #undef _nc_ada_coord_transform
2537 int     _nc_ada_coord_transform(
2538                 WINDOW  *win,
2539                 int     *Y,
2540                 int     *X,
2541                 int     dir)
2542                 { return(*(int *)0); }
2543
2544 #undef _nc_ada_mouse_event
2545 void    _nc_ada_mouse_event(
2546                 mmask_t m,
2547                 int     *b,
2548                 int     *s)
2549                 { /* void */ }
2550
2551 #undef _nc_ada_mouse_mask
2552 int     _nc_ada_mouse_mask(
2553                 int     button,
2554                 int     state,
2555                 mmask_t *mask)
2556                 { return(*(int *)0); }
2557
2558 #undef _nc_ada_unregister_mouse
2559 void    _nc_ada_unregister_mouse(void)
2560                 { /* void */ }