contrib/ncurses/ncurses/llib-lncurses

   1 /****************************************************************************
   2  * Copyright (c) 1998,1999,2000 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 <dickey@clark.net> 1996-2000                   *
  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 typedef struct
  54 {
  55     unsigned long       hashval;
  56     int         oldcount, newcount;
  57     int         oldindex, newindex;
  58 }
  59     sym;
  60
  61 #undef _nc_hash_map
  62 void    _nc_hash_map(void)
  63                 { /* void */ }
  64
  65 #undef _nc_make_oldhash
  66 void    _nc_make_oldhash(
  67                 int     i)
  68                 { /* void */ }
  69
  70 #undef _nc_scroll_oldhash
  71 void    _nc_scroll_oldhash(
  72                 int     n,
  73                 int     top,
  74                 int     bot)
  75                 { /* void */ }
  76
  77 /* ./base/lib_addch.c */
  78
  79 #include <ctype.h>
  80
  81 #undef _nc_background
  82 chtype  _nc_background(
  83                 WINDOW  *win)
  84                 { return(*(chtype *)0); }
  85
  86 #undef _nc_render
  87 chtype  _nc_render(
  88                 WINDOW  *win,
  89                 chtype  ch)
  90                 { return(*(chtype *)0); }
  91
  92 #undef _nc_waddch_nosync
  93 int     _nc_waddch_nosync(
  94                 WINDOW  *win,
  95                 const chtype c)
  96                 { return(*(int *)0); }
  97
  98 #undef waddch
  99 int     waddch(
 100                 WINDOW  *win,
 101                 const chtype ch)
 102                 { return(*(int *)0); }
 103
 104 #undef wechochar
 105 int     wechochar(
 106                 WINDOW  *win,
 107                 const chtype ch)
 108                 { return(*(int *)0); }
 109
 110 /* ./base/lib_addstr.c */
 111
 112 #undef waddnstr
 113 int     waddnstr(
 114                 WINDOW  *win,
 115                 const char *const astr,
 116                 int     n)
 117                 { return(*(int *)0); }
 118
 119 #undef waddchnstr
 120 int     waddchnstr(
 121                 WINDOW  *win,
 122                 const chtype *const astr,
 123                 int     n)
 124                 { return(*(int *)0); }
 125
 126 /* ./base/lib_beep.c */
 127
 128 #undef beep
 129 int     beep(void)
 130                 { return(*(int *)0); }
 131
 132 /* ./base/lib_bkgd.c */
 133
 134 #undef wbkgdset
 135 void    wbkgdset(
 136                 WINDOW  *win,
 137                 chtype  ch)
 138                 { /* void */ }
 139
 140 #undef wbkgd
 141 int     wbkgd(
 142                 WINDOW  *win,
 143                 const chtype ch)
 144                 { return(*(int *)0); }
 145
 146 /* ./base/lib_box.c */
 147
 148 #undef wborder
 149 int     wborder(
 150                 WINDOW  *win,
 151                 chtype  ls,
 152                 chtype  rs,
 153                 chtype  ts,
 154                 chtype  bs,
 155                 chtype  tl,
 156                 chtype  tr,
 157                 chtype  bl,
 158                 chtype  br)
 159                 { return(*(int *)0); }
 160
 161 /* ./base/lib_chgat.c */
 162
 163 #undef wchgat
 164 int     wchgat(
 165                 WINDOW  *win,
 166                 int     n,
 167                 attr_t  attr,
 168                 short   color,
 169                 const void *opts)
 170                 { return(*(int *)0); }
 171
 172 /* ./base/lib_clear.c */
 173
 174 #undef wclear
 175 int     wclear(
 176                 WINDOW  *win)
 177                 { return(*(int *)0); }
 178
 179 /* ./base/lib_clearok.c */
 180
 181 #undef clearok
 182 int     clearok(
 183                 WINDOW  *win,
 184                 bool    flag)
 185                 { return(*(int *)0); }
 186
 187 /* ./base/lib_clrbot.c */
 188
 189 #undef wclrtobot
 190 int     wclrtobot(
 191                 WINDOW  *win)
 192                 { return(*(int *)0); }
 193
 194 /* ./base/lib_clreol.c */
 195
 196 #undef wclrtoeol
 197 int     wclrtoeol(
 198                 WINDOW  *win)
 199                 { return(*(int *)0); }
 200
 201 /* ./base/lib_color.c */
 202
 203 #include <tic.h>
 204
 205 #undef COLOR_PAIRS
 206 int     COLOR_PAIRS;
 207 #undef COLORS
 208 int     COLORS;
 209
 210 #undef start_color
 211 int     start_color(void)
 212                 { return(*(int *)0); }
 213
 214 #undef init_pair
 215 int     init_pair(
 216                 short   pair,
 217                 short   f,
 218                 short   b)
 219                 { return(*(int *)0); }
 220
 221 #undef init_color
 222 int     init_color(
 223                 short   color,
 224                 short   r,
 225                 short   g,
 226                 short   b)
 227                 { return(*(int *)0); }
 228
 229 #undef can_change_color
 230 bool    can_change_color(void)
 231                 { return(*(bool *)0); }
 232
 233 #undef has_colors
 234 bool    has_colors(void)
 235                 { return(*(bool *)0); }
 236
 237 #undef color_content
 238 int     color_content(
 239                 short   color,
 240                 short   *r,
 241                 short   *g,
 242                 short   *b)
 243                 { return(*(int *)0); }
 244
 245 #undef pair_content
 246 int     pair_content(
 247                 short   pair,
 248                 short   *f,
 249                 short   *b)
 250                 { return(*(int *)0); }
 251
 252 #undef _nc_do_color
 253 void    _nc_do_color(
 254                 int     old_pair,
 255                 int     pair,
 256                 bool    reverse,
 257                 int     (*outc)(
 258                 int     p1))
 259                 { /* void */ }
 260
 261 /* ./base/lib_colorset.c */
 262
 263 #undef wcolor_set
 264 int     wcolor_set(
 265                 WINDOW  *win,
 266                 short   color_pair_number,
 267                 void    *opts)
 268                 { return(*(int *)0); }
 269
 270 /* ./base/lib_delch.c */
 271
 272 #undef wdelch
 273 int     wdelch(
 274                 WINDOW  *win)
 275                 { return(*(int *)0); }
 276
 277 /* ./base/lib_delwin.c */
 278
 279 #undef delwin
 280 int     delwin(
 281                 WINDOW  *win)
 282                 { return(*(int *)0); }
 283
 284 /* ./base/lib_echo.c */
 285
 286 #undef echo
 287 int     echo(void)
 288                 { return(*(int *)0); }
 289
 290 #undef noecho
 291 int     noecho(void)
 292                 { return(*(int *)0); }
 293
 294 /* ./base/lib_endwin.c */
 295
 296 #undef endwin
 297 int     endwin(void)
 298                 { return(*(int *)0); }
 299
 300 /* ./base/lib_erase.c */
 301
 302 #undef werase
 303 int     werase(
 304                 WINDOW  *win)
 305                 { return(*(int *)0); }
 306
 307 /* ./base/lib_flash.c */
 308
 309 #undef flash
 310 int     flash(void)
 311                 { return(*(int *)0); }
 312
 313 /* ./lib_gen.c */
 314
 315 #undef addch
 316 int     addch(
 317                 const chtype z)
 318                 { return(*(int *)0); }
 319
 320 #undef addchnstr
 321 int     addchnstr(
 322                 const chtype *a1,
 323                 int     z)
 324                 { return(*(int *)0); }
 325
 326 #undef addchstr
 327 int     addchstr(
 328                 const chtype *z)
 329                 { return(*(int *)0); }
 330
 331 #undef addnstr
 332 int     addnstr(
 333                 const char *a1,
 334                 int     z)
 335                 { return(*(int *)0); }
 336
 337 #undef addstr
 338 int     addstr(
 339                 const char *z)
 340                 { return(*(int *)0); }
 341
 342 #undef attroff
 343 int     attroff(
 344                 NCURSES_ATTR_T  z)
 345                 { return(*(int *)0); }
 346
 347 #undef attron
 348 int     attron(
 349                 NCURSES_ATTR_T  z)
 350                 { return(*(int *)0); }
 351
 352 #undef attrset
 353 int     attrset(
 354                 NCURSES_ATTR_T  z)
 355                 { return(*(int *)0); }
 356
 357 #undef attr_get
 358 int     attr_get(
 359                 attr_t  *a1,
 360                 short   *a2,
 361                 void    *z)
 362                 { return(*(int *)0); }
 363
 364 #undef attr_off
 365 int     attr_off(
 366                 attr_t  a1,
 367                 void    *z)
 368                 { return(*(int *)0); }
 369
 370 #undef attr_on
 371 int     attr_on(
 372                 attr_t  a1,
 373                 void    *z)
 374                 { return(*(int *)0); }
 375
 376 #undef attr_set
 377 int     attr_set(
 378                 attr_t  a1,
 379                 short   a2,
 380                 void    *z)
 381                 { return(*(int *)0); }
 382
 383 #undef bkgd
 384 int     bkgd(
 385                 chtype  z)
 386                 { return(*(int *)0); }
 387
 388 #undef bkgdset
 389 void    bkgdset(
 390                 chtype  z)
 391                 { /* void */ }
 392
 393 #undef border
 394 int     border(
 395                 chtype  a1,
 396                 chtype  a2,
 397                 chtype  a3,
 398                 chtype  a4,
 399                 chtype  a5,
 400                 chtype  a6,
 401                 chtype  a7,
 402                 chtype  z)
 403                 { return(*(int *)0); }
 404
 405 #undef box
 406 int     box(
 407                 WINDOW  *a1,
 408                 chtype  a2,
 409                 chtype  z)
 410                 { return(*(int *)0); }
 411
 412 #undef chgat
 413 int     chgat(
 414                 int     a1,
 415                 attr_t  a2,
 416                 short   a3,
 417                 const void *z)
 418                 { return(*(int *)0); }
 419
 420 #undef clear
 421 int     clear(void)
 422                 { return(*(int *)0); }
 423
 424 #undef clrtobot
 425 int     clrtobot(void)
 426                 { return(*(int *)0); }
 427
 428 #undef clrtoeol
 429 int     clrtoeol(void)
 430                 { return(*(int *)0); }
 431
 432 #undef color_set
 433 int     color_set(
 434                 short   a1,
 435                 void    *z)
 436                 { return(*(int *)0); }
 437
 438 #undef COLOR_PAIR
 439 int     COLOR_PAIR(
 440                 int     z)
 441                 { return(*(int *)0); }
 442
 443 #undef delch
 444 int     delch(void)
 445                 { return(*(int *)0); }
 446
 447 #undef deleteln
 448 int     deleteln(void)
 449                 { return(*(int *)0); }
 450
 451 #undef echochar
 452 int     echochar(
 453                 const chtype z)
 454                 { return(*(int *)0); }
 455
 456 #undef erase
 457 int     erase(void)
 458                 { return(*(int *)0); }
 459
 460 #undef getbkgd
 461 chtype  getbkgd(
 462                 WINDOW  *z)
 463                 { return(*(chtype *)0); }
 464
 465 #undef getch
 466 int     getch(void)
 467                 { return(*(int *)0); }
 468
 469 #undef getnstr
 470 int     getnstr(
 471                 char    *a1,
 472                 int     z)
 473                 { return(*(int *)0); }
 474
 475 #undef getstr
 476 int     getstr(
 477                 char    *z)
 478                 { return(*(int *)0); }
 479
 480 #undef hline
 481 int     hline(
 482                 chtype  a1,
 483                 int     z)
 484                 { return(*(int *)0); }
 485
 486 #undef inch
 487 chtype  inch(void)
 488                 { return(*(chtype *)0); }
 489
 490 #undef inchnstr
 491 int     inchnstr(
 492                 chtype  *a1,
 493                 int     z)
 494                 { return(*(int *)0); }
 495
 496 #undef inchstr
 497 int     inchstr(
 498                 chtype  *z)
 499                 { return(*(int *)0); }
 500
 501 #undef innstr
 502 int     innstr(
 503                 char    *a1,
 504                 int     z)
 505                 { return(*(int *)0); }
 506
 507 #undef insch
 508 int     insch(
 509                 chtype  z)
 510                 { return(*(int *)0); }
 511
 512 #undef insdelln
 513 int     insdelln(
 514                 int     z)
 515                 { return(*(int *)0); }
 516
 517 #undef insertln
 518 int     insertln(void)
 519                 { return(*(int *)0); }
 520
 521 #undef insnstr
 522 int     insnstr(
 523                 const char *a1,
 524                 int     z)
 525                 { return(*(int *)0); }
 526
 527 #undef insstr
 528 int     insstr(
 529                 const char *z)
 530                 { return(*(int *)0); }
 531
 532 #undef instr
 533 int     instr(
 534                 char    *z)
 535                 { return(*(int *)0); }
 536
 537 #undef move
 538 int     move(
 539                 int     a1,
 540                 int     z)
 541                 { return(*(int *)0); }
 542
 543 #undef mvaddch
 544 int     mvaddch(
 545                 int     a1,
 546                 int     a2,
 547                 const chtype z)
 548                 { return(*(int *)0); }
 549
 550 #undef mvaddchnstr
 551 int     mvaddchnstr(
 552                 int     a1,
 553                 int     a2,
 554                 const chtype *a3,
 555                 int     z)
 556                 { return(*(int *)0); }
 557
 558 #undef mvaddchstr
 559 int     mvaddchstr(
 560                 int     a1,
 561                 int     a2,
 562                 const chtype *z)
 563                 { return(*(int *)0); }
 564
 565 #undef mvaddnstr
 566 int     mvaddnstr(
 567                 int     a1,
 568                 int     a2,
 569                 const char *a3,
 570                 int     z)
 571                 { return(*(int *)0); }
 572
 573 #undef mvaddstr
 574 int     mvaddstr(
 575                 int     a1,
 576                 int     a2,
 577                 const char *z)
 578                 { return(*(int *)0); }
 579
 580 #undef mvchgat
 581 int     mvchgat(
 582                 int     a1,
 583                 int     a2,
 584                 int     a3,
 585                 attr_t  a4,
 586                 short   a5,
 587                 const void *z)
 588                 { return(*(int *)0); }
 589
 590 #undef mvdelch
 591 int     mvdelch(
 592                 int     a1,
 593                 int     z)
 594                 { return(*(int *)0); }
 595
 596 #undef mvgetch
 597 int     mvgetch(
 598                 int     a1,
 599                 int     z)
 600                 { return(*(int *)0); }
 601
 602 #undef mvgetnstr
 603 int     mvgetnstr(
 604                 int     a1,
 605                 int     a2,
 606                 char    *a3,
 607                 int     z)
 608                 { return(*(int *)0); }
 609
 610 #undef mvgetstr
 611 int     mvgetstr(
 612                 int     a1,
 613                 int     a2,
 614                 char    *z)
 615                 { return(*(int *)0); }
 616
 617 #undef mvhline
 618 int     mvhline(
 619                 int     a1,
 620                 int     a2,
 621                 chtype  a3,
 622                 int     z)
 623                 { return(*(int *)0); }
 624
 625 #undef mvinch
 626 chtype  mvinch(
 627                 int     a1,
 628                 int     z)
 629                 { return(*(chtype *)0); }
 630
 631 #undef mvinchnstr
 632 int     mvinchnstr(
 633                 int     a1,
 634                 int     a2,
 635                 chtype  *a3,
 636                 int     z)
 637                 { return(*(int *)0); }
 638
 639 #undef mvinchstr
 640 int     mvinchstr(
 641                 int     a1,
 642                 int     a2,
 643                 chtype  *z)
 644                 { return(*(int *)0); }
 645
 646 #undef mvinnstr
 647 int     mvinnstr(
 648                 int     a1,
 649                 int     a2,
 650                 char    *a3,
 651                 int     z)
 652                 { return(*(int *)0); }
 653
 654 #undef mvinsch
 655 int     mvinsch(
 656                 int     a1,
 657                 int     a2,
 658                 chtype  z)
 659                 { return(*(int *)0); }
 660
 661 #undef mvinsnstr
 662 int     mvinsnstr(
 663                 int     a1,
 664                 int     a2,
 665                 const char *a3,
 666                 int     z)
 667                 { return(*(int *)0); }
 668
 669 #undef mvinsstr
 670 int     mvinsstr(
 671                 int     a1,
 672                 int     a2,
 673                 const char *z)
 674                 { return(*(int *)0); }
 675
 676 #undef mvinstr
 677 int     mvinstr(
 678                 int     a1,
 679                 int     a2,
 680                 char    *z)
 681                 { return(*(int *)0); }
 682
 683 #undef mvvline
 684 int     mvvline(
 685                 int     a1,
 686                 int     a2,
 687                 chtype  a3,
 688                 int     z)
 689                 { return(*(int *)0); }
 690
 691 #undef mvwaddch
 692 int     mvwaddch(
 693                 WINDOW  *a1,
 694                 int     a2,
 695                 int     a3,
 696                 const chtype z)
 697                 { return(*(int *)0); }
 698
 699 #undef mvwaddchnstr
 700 int     mvwaddchnstr(
 701                 WINDOW  *a1,
 702                 int     a2,
 703                 int     a3,
 704                 const chtype *a4,
 705                 int     z)
 706                 { return(*(int *)0); }
 707
 708 #undef mvwaddchstr
 709 int     mvwaddchstr(
 710                 WINDOW  *a1,
 711                 int     a2,
 712                 int     a3,
 713                 const chtype *z)
 714                 { return(*(int *)0); }
 715
 716 #undef mvwaddnstr
 717 int     mvwaddnstr(
 718                 WINDOW  *a1,
 719                 int     a2,
 720                 int     a3,
 721                 const char *a4,
 722                 int     z)
 723                 { return(*(int *)0); }
 724
 725 #undef mvwaddstr
 726 int     mvwaddstr(
 727                 WINDOW  *a1,
 728                 int     a2,
 729                 int     a3,
 730                 const char *z)
 731                 { return(*(int *)0); }
 732
 733 #undef mvwchgat
 734 int     mvwchgat(
 735                 WINDOW  *a1,
 736                 int     a2,
 737                 int     a3,
 738                 int     a4,
 739                 attr_t  a5,
 740                 short   a6,
 741                 const void *z)
 742                 { return(*(int *)0); }
 743
 744 #undef mvwdelch
 745 int     mvwdelch(
 746                 WINDOW  *a1,
 747                 int     a2,
 748                 int     z)
 749                 { return(*(int *)0); }
 750
 751 #undef mvwgetch
 752 int     mvwgetch(
 753                 WINDOW  *a1,
 754                 int     a2,
 755                 int     z)
 756                 { return(*(int *)0); }
 757
 758 #undef mvwgetnstr
 759 int     mvwgetnstr(
 760                 WINDOW  *a1,
 761                 int     a2,
 762                 int     a3,
 763                 char    *a4,
 764                 int     z)
 765                 { return(*(int *)0); }
 766
 767 #undef mvwgetstr
 768 int     mvwgetstr(
 769                 WINDOW  *a1,
 770                 int     a2,
 771                 int     a3,
 772                 char    *z)
 773                 { return(*(int *)0); }
 774
 775 #undef mvwhline
 776 int     mvwhline(
 777                 WINDOW  *a1,
 778                 int     a2,
 779                 int     a3,
 780                 chtype  a4,
 781                 int     z)
 782                 { return(*(int *)0); }
 783
 784 #undef mvwinch
 785 chtype  mvwinch(
 786                 WINDOW  *a1,
 787                 int     a2,
 788                 int     z)
 789                 { return(*(chtype *)0); }
 790
 791 #undef mvwinchnstr
 792 int     mvwinchnstr(
 793                 WINDOW  *a1,
 794                 int     a2,
 795                 int     a3,
 796                 chtype  *a4,
 797                 int     z)
 798                 { return(*(int *)0); }
 799
 800 #undef mvwinchstr
 801 int     mvwinchstr(
 802                 WINDOW  *a1,
 803                 int     a2,
 804                 int     a3,
 805                 chtype  *z)
 806                 { return(*(int *)0); }
 807
 808 #undef mvwinnstr
 809 int     mvwinnstr(
 810                 WINDOW  *a1,
 811                 int     a2,
 812                 int     a3,
 813                 char    *a4,
 814                 int     z)
 815                 { return(*(int *)0); }
 816
 817 #undef mvwinsch
 818 int     mvwinsch(
 819                 WINDOW  *a1,
 820                 int     a2,
 821                 int     a3,
 822                 chtype  z)
 823                 { return(*(int *)0); }
 824
 825 #undef mvwinsnstr
 826 int     mvwinsnstr(
 827                 WINDOW  *a1,
 828                 int     a2,
 829                 int     a3,
 830                 const char *a4,
 831                 int     z)
 832                 { return(*(int *)0); }
 833
 834 #undef mvwinsstr
 835 int     mvwinsstr(
 836                 WINDOW  *a1,
 837                 int     a2,
 838                 int     a3,
 839                 const char *z)
 840                 { return(*(int *)0); }
 841
 842 #undef mvwinstr
 843 int     mvwinstr(
 844                 WINDOW  *a1,
 845                 int     a2,
 846                 int     a3,
 847                 char    *z)
 848                 { return(*(int *)0); }
 849
 850 #undef mvwvline
 851 int     mvwvline(
 852                 WINDOW  *a1,
 853                 int     a2,
 854                 int     a3,
 855                 chtype  a4,
 856                 int     z)
 857                 { return(*(int *)0); }
 858
 859 #undef PAIR_NUMBER
 860 int     PAIR_NUMBER(
 861                 int     z)
 862                 { return(*(int *)0); }
 863
 864 #undef redrawwin
 865 int     redrawwin(
 866                 WINDOW  *z)
 867                 { return(*(int *)0); }
 868
 869 #undef refresh
 870 int     refresh(void)
 871                 { return(*(int *)0); }
 872
 873 #undef scrl
 874 int     scrl(
 875                 int     z)
 876                 { return(*(int *)0); }
 877
 878 #undef scroll
 879 int     scroll(
 880                 WINDOW  *z)
 881                 { return(*(int *)0); }
 882
 883 #undef setscrreg
 884 int     setscrreg(
 885                 int     a1,
 886                 int     z)
 887                 { return(*(int *)0); }
 888
 889 #undef standout
 890 int     standout(void)
 891                 { return(*(int *)0); }
 892
 893 #undef standend
 894 int     standend(void)
 895                 { return(*(int *)0); }
 896
 897 #undef timeout
 898 void    timeout(
 899                 int     z)
 900                 { /* void */ }
 901
 902 #undef touchline
 903 int     touchline(
 904                 WINDOW  *a1,
 905                 int     a2,
 906                 int     z)
 907                 { return(*(int *)0); }
 908
 909 #undef touchwin
 910 int     touchwin(
 911                 WINDOW  *z)
 912                 { return(*(int *)0); }
 913
 914 #undef untouchwin
 915 int     untouchwin(
 916                 WINDOW  *z)
 917                 { return(*(int *)0); }
 918
 919 #undef vline
 920 int     vline(
 921                 chtype  a1,
 922                 int     z)
 923                 { return(*(int *)0); }
 924
 925 #undef vw_printw
 926 int     vw_printw(
 927                 WINDOW  *a1,
 928                 char    *a2,
 929                 va_list z)
 930                 { return(*(int *)0); }
 931
 932 #undef vw_scanw
 933 int     vw_scanw(
 934                 WINDOW  *a1,
 935                 char    *a2,
 936                 va_list z)
 937                 { return(*(int *)0); }
 938
 939 #undef waddchstr
 940 int     waddchstr(
 941                 WINDOW  *a1,
 942                 const chtype *z)
 943                 { return(*(int *)0); }
 944
 945 #undef waddstr
 946 int     waddstr(
 947                 WINDOW  *a1,
 948                 const char *z)
 949                 { return(*(int *)0); }
 950
 951 #undef wattron
 952 int     wattron(
 953                 WINDOW  *a1,
 954                 int     z)
 955                 { return(*(int *)0); }
 956
 957 #undef wattroff
 958 int     wattroff(
 959                 WINDOW  *a1,
 960                 int     z)
 961                 { return(*(int *)0); }
 962
 963 #undef wattrset
 964 int     wattrset(
 965                 WINDOW  *a1,
 966                 int     z)
 967                 { return(*(int *)0); }
 968
 969 #undef wattr_get
 970 int     wattr_get(
 971                 WINDOW  *a1,
 972                 attr_t  *a2,
 973                 short   *a3,
 974                 void    *z)
 975                 { return(*(int *)0); }
 976
 977 #undef wattr_set
 978 int     wattr_set(
 979                 WINDOW  *a1,
 980                 attr_t  a2,
 981                 short   a3,
 982                 void    *z)
 983                 { return(*(int *)0); }
 984
 985 #undef wdeleteln
 986 int     wdeleteln(
 987                 WINDOW  *z)
 988                 { return(*(int *)0); }
 989
 990 #undef wgetstr
 991 int     wgetstr(
 992                 WINDOW  *a1,
 993                 char    *z)
 994                 { return(*(int *)0); }
 995
 996 #undef winchstr
 997 int     winchstr(
 998                 WINDOW  *a1,
 999                 chtype  *z)
1000                 { return(*(int *)0); }
1001
1002 #undef winsertln
1003 int     winsertln(
1004                 WINDOW  *z)
1005                 { return(*(int *)0); }
1006
1007 #undef winsstr
1008 int     winsstr(
1009                 WINDOW  *a1,
1010                 const char *z)
1011                 { return(*(int *)0); }
1012
1013 #undef winstr
1014 int     winstr(
1015                 WINDOW  *a1,
1016                 char    *z)
1017                 { return(*(int *)0); }
1018
1019 #undef wstandout
1020 int     wstandout(
1021                 WINDOW  *z)
1022                 { return(*(int *)0); }
1023
1024 #undef wstandend
1025 int     wstandend(
1026                 WINDOW  *z)
1027                 { return(*(int *)0); }
1028
1029 #undef mouse_trafo
1030 bool    mouse_trafo(
1031                 int     *a1,
1032                 int     *a2,
1033                 bool    z)
1034                 { return(*(bool *)0); }
1035
1036 /* ./base/lib_getch.c */
1037
1038 #include <fifo_defs.h>
1039
1040 #undef ESCDELAY
1041 int     ESCDELAY;
1042
1043 #undef wgetch
1044 int     wgetch(
1045                 WINDOW  *win)
1046                 { return(*(int *)0); }
1047
1048 /* ./base/lib_getstr.c */
1049
1050 #undef wgetnstr
1051 int     wgetnstr(
1052                 WINDOW  *win,
1053                 char    *str,
1054                 int     maxlen)
1055                 { return(*(int *)0); }
1056
1057 /* ./base/lib_hline.c */
1058
1059 #undef whline
1060 int     whline(
1061                 WINDOW  *win,
1062                 chtype  ch,
1063                 int     n)
1064                 { return(*(int *)0); }
1065
1066 /* ./base/lib_immedok.c */
1067
1068 #undef immedok
1069 void    immedok(
1070                 WINDOW  *win,
1071                 bool    flag)
1072                 { /* void */ }
1073
1074 /* ./base/lib_inchstr.c */
1075
1076 #undef winchnstr
1077 int     winchnstr(
1078                 WINDOW  *win,
1079                 chtype  *str,
1080                 int     n)
1081                 { return(*(int *)0); }
1082
1083 /* ./base/lib_initscr.c */
1084
1085 #undef initscr
1086 WINDOW  *initscr(void)
1087                 { return(*(WINDOW **)0); }
1088
1089 /* ./base/lib_insch.c */
1090
1091 #undef winsch
1092 int     winsch(
1093                 WINDOW  *win,
1094                 chtype  c)
1095                 { return(*(int *)0); }
1096
1097 /* ./base/lib_insdel.c */
1098
1099 #undef winsdelln
1100 int     winsdelln(
1101                 WINDOW  *win,
1102                 int     n)
1103                 { return(*(int *)0); }
1104
1105 /* ./base/lib_insstr.c */
1106
1107 #undef winsnstr
1108 int     winsnstr(
1109                 WINDOW  *win,
1110                 const char *s,
1111                 int     n)
1112                 { return(*(int *)0); }
1113
1114 /* ./base/lib_instr.c */
1115
1116 #undef winnstr
1117 int     winnstr(
1118                 WINDOW  *win,
1119                 char    *str,
1120                 int     n)
1121                 { return(*(int *)0); }
1122
1123 /* ./base/lib_isendwin.c */
1124
1125 #undef isendwin
1126 bool    isendwin(void)
1127                 { return(*(bool *)0); }
1128
1129 /* ./base/lib_leaveok.c */
1130
1131 #undef leaveok
1132 int     leaveok(
1133                 WINDOW  *win,
1134                 bool    flag)
1135                 { return(*(int *)0); }
1136
1137 /* ./base/lib_mouse.c */
1138
1139 #undef getmouse
1140 int     getmouse(
1141                 MEVENT  *aevent)
1142                 { return(*(int *)0); }
1143
1144 #undef ungetmouse
1145 int     ungetmouse(
1146                 MEVENT  *aevent)
1147                 { return(*(int *)0); }
1148
1149 #undef mousemask
1150 mmask_t mousemask(
1151                 mmask_t newmask,
1152                 mmask_t *oldmask)
1153                 { return(*(mmask_t *)0); }
1154
1155 #undef wenclose
1156 bool    wenclose(
1157                 const WINDOW *win,
1158                 int     y,
1159                 int     x)
1160                 { return(*(bool *)0); }
1161
1162 #undef mouseinterval
1163 int     mouseinterval(
1164                 int     maxclick)
1165                 { return(*(int *)0); }
1166
1167 #undef _nc_has_mouse
1168 int     _nc_has_mouse(void)
1169                 { return(*(int *)0); }
1170
1171 #undef wmouse_trafo
1172 bool    wmouse_trafo(
1173                 const WINDOW *win,
1174                 int     *pY,
1175                 int     *pX,
1176                 bool    to_screen)
1177                 { return(*(bool *)0); }
1178
1179 /* ./base/lib_move.c */
1180
1181 #undef wmove
1182 int     wmove(
1183                 WINDOW  *win,
1184                 int     y,
1185                 int     x)
1186                 { return(*(int *)0); }
1187
1188 /* ./tty/lib_mvcur.c */
1189
1190 #undef _nc_msec_cost
1191 int     _nc_msec_cost(
1192                 const char *const cap,
1193                 int     affcnt)
1194                 { return(*(int *)0); }
1195
1196 #undef _nc_mvcur_resume
1197 void    _nc_mvcur_resume(void)
1198                 { /* void */ }
1199
1200 #undef _nc_mvcur_init
1201 void    _nc_mvcur_init(void)
1202                 { /* void */ }
1203
1204 #undef _nc_mvcur_wrap
1205 void    _nc_mvcur_wrap(void)
1206                 { /* void */ }
1207
1208 #undef mvcur
1209 int     mvcur(
1210                 int     yold,
1211                 int     xold,
1212                 int     ynew,
1213                 int     xnew)
1214                 { return(*(int *)0); }
1215
1216 #undef _nc_optimize_enable
1217 int     _nc_optimize_enable;
1218
1219 /* ./base/lib_mvwin.c */
1220
1221 #undef mvwin
1222 int     mvwin(
1223                 WINDOW  *win,
1224                 int     by,
1225                 int     bx)
1226                 { return(*(int *)0); }
1227
1228 /* ./base/lib_newterm.c */
1229
1230 #undef filter
1231 void    filter(void)
1232                 { /* void */ }
1233
1234 #undef newterm
1235 SCREEN  *newterm(
1236                 char    *name,
1237                 FILE    *ofp,
1238                 FILE    *ifp)
1239                 { return(*(SCREEN **)0); }
1240
1241 /* ./base/lib_newwin.c */
1242
1243 #undef _nc_freewin
1244 void    _nc_freewin(
1245                 WINDOW  *win)
1246                 { /* void */ }
1247
1248 #undef newwin
1249 WINDOW  *newwin(
1250                 int     num_lines,
1251                 int     num_columns,
1252                 int     begy,
1253                 int     begx)
1254                 { return(*(WINDOW **)0); }
1255
1256 #undef derwin
1257 WINDOW  *derwin(
1258                 WINDOW  *orig,
1259                 int     num_lines,
1260                 int     num_columns,
1261                 int     begy,
1262                 int     begx)
1263                 { return(*(WINDOW **)0); }
1264
1265 #undef subwin
1266 WINDOW  *subwin(
1267                 WINDOW  *w,
1268                 int     l,
1269                 int     c,
1270                 int     y,
1271                 int     x)
1272                 { return(*(WINDOW **)0); }
1273
1274 #undef _nc_makenew
1275 WINDOW  *_nc_makenew(
1276                 int     num_lines,
1277                 int     num_columns,
1278                 int     begy,
1279                 int     begx,
1280                 int     flags)
1281                 { return(*(WINDOW **)0); }
1282
1283 /* ./base/lib_nl.c */
1284
1285 #undef nl
1286 int     nl(void)
1287                 { return(*(int *)0); }
1288
1289 #undef nonl
1290 int     nonl(void)
1291                 { return(*(int *)0); }
1292
1293 /* ./base/lib_overlay.c */
1294
1295 #undef overlay
1296 int     overlay(
1297                 const WINDOW *win1,
1298                 WINDOW  *win2)
1299                 { return(*(int *)0); }
1300
1301 #undef overwrite
1302 int     overwrite(
1303                 const WINDOW *win1,
1304                 WINDOW  *win2)
1305                 { return(*(int *)0); }
1306
1307 #undef copywin
1308 int     copywin(
1309                 const WINDOW *src,
1310                 WINDOW  *dst,
1311                 int     sminrow,
1312                 int     smincol,
1313                 int     dminrow,
1314                 int     dmincol,
1315                 int     dmaxrow,
1316                 int     dmaxcol,
1317                 int     over)
1318                 { return(*(int *)0); }
1319
1320 /* ./base/lib_pad.c */
1321
1322 #undef newpad
1323 WINDOW  *newpad(
1324                 int     l,
1325                 int     c)
1326                 { return(*(WINDOW **)0); }
1327
1328 #undef subpad
1329 WINDOW  *subpad(
1330                 WINDOW  *orig,
1331                 int     l,
1332                 int     c,
1333                 int     begy,
1334                 int     begx)
1335                 { return(*(WINDOW **)0); }
1336
1337 #undef prefresh
1338 int     prefresh(
1339                 WINDOW  *win,
1340                 int     pminrow,
1341                 int     pmincol,
1342                 int     sminrow,
1343                 int     smincol,
1344                 int     smaxrow,
1345                 int     smaxcol)
1346                 { return(*(int *)0); }
1347
1348 #undef pnoutrefresh
1349 int     pnoutrefresh(
1350                 WINDOW  *win,
1351                 int     pminrow,
1352                 int     pmincol,
1353                 int     sminrow,
1354                 int     smincol,
1355                 int     smaxrow,
1356                 int     smaxcol)
1357                 { return(*(int *)0); }
1358
1359 #undef pechochar
1360 int     pechochar(
1361                 WINDOW  *pad,
1362                 const chtype ch)
1363                 { return(*(int *)0); }
1364
1365 /* ./base/lib_printw.c */
1366
1367 #undef printw
1368 int     printw(
1369                 char    *fmt,
1370                 ...)
1371                 { return(*(int *)0); }
1372
1373 #undef wprintw
1374 int     wprintw(
1375                 WINDOW  *win,
1376                 char    *fmt,
1377                 ...)
1378                 { return(*(int *)0); }
1379
1380 #undef mvprintw
1381 int     mvprintw(
1382                 int     y,
1383                 int     x,
1384                 char    *fmt,
1385                 ...)
1386                 { return(*(int *)0); }
1387
1388 #undef mvwprintw
1389 int     mvwprintw(
1390                 WINDOW  *win,
1391                 int     y,
1392                 int     x,
1393                 char    *fmt,
1394                 ...)
1395                 { return(*(int *)0); }
1396
1397 #undef vwprintw
1398 int     vwprintw(
1399                 WINDOW  *win,
1400                 char    *fmt,
1401                 va_list argp)
1402                 { return(*(int *)0); }
1403
1404 /* ./base/lib_redrawln.c */
1405
1406 #undef wredrawln
1407 int     wredrawln(
1408                 WINDOW  *win,
1409                 int     beg,
1410                 int     num)
1411                 { return(*(int *)0); }
1412
1413 /* ./base/lib_refresh.c */
1414
1415 #undef wrefresh
1416 int     wrefresh(
1417                 WINDOW  *win)
1418                 { return(*(int *)0); }
1419
1420 #undef wnoutrefresh
1421 int     wnoutrefresh(
1422                 WINDOW  *win)
1423                 { return(*(int *)0); }
1424
1425 /* ./base/lib_restart.c */
1426
1427 #undef restartterm
1428 int     restartterm(
1429                 char    *termp,
1430                 int     filenum,
1431                 int     *errret)
1432                 { return(*(int *)0); }
1433
1434 /* ./base/lib_scanw.c */
1435
1436 #undef vwscanw
1437 int     vwscanw(
1438                 WINDOW  *win,
1439                 char    *fmt,
1440                 va_list argp)
1441                 { return(*(int *)0); }
1442
1443 #undef scanw
1444 int     scanw(
1445                 char    *fmt,
1446                 ...)
1447                 { return(*(int *)0); }
1448
1449 #undef wscanw
1450 int     wscanw(
1451                 WINDOW  *win,
1452                 char    *fmt,
1453                 ...)
1454                 { return(*(int *)0); }
1455
1456 #undef mvscanw
1457 int     mvscanw(
1458                 int     y,
1459                 int     x,
1460                 char    *fmt,
1461                 ...)
1462                 { return(*(int *)0); }
1463
1464 #undef mvwscanw
1465 int     mvwscanw(
1466                 WINDOW  *win,
1467                 int     y,
1468                 int     x,
1469                 char    *fmt,
1470                 ...)
1471                 { return(*(int *)0); }
1472
1473 /* ./base/lib_screen.c */
1474
1475 #include <sys/stat.h>
1476 #include <time.h>
1477
1478 #undef getwin
1479 WINDOW  *getwin(
1480                 FILE    *filep)
1481                 { return(*(WINDOW **)0); }
1482
1483 #undef putwin
1484 int     putwin(
1485                 WINDOW  *win,
1486                 FILE    *filep)
1487                 { return(*(int *)0); }
1488
1489 #undef scr_restore
1490 int     scr_restore(
1491                 const char *file)
1492                 { return(*(int *)0); }
1493
1494 #undef scr_dump
1495 int     scr_dump(
1496                 const char *file)
1497                 { return(*(int *)0); }
1498
1499 #undef scr_init
1500 int     scr_init(
1501                 const char *file)
1502                 { return(*(int *)0); }
1503
1504 #undef scr_set
1505 int     scr_set(
1506                 const char *file)
1507                 { return(*(int *)0); }
1508
1509 /* ./base/lib_scroll.c */
1510
1511 #undef _nc_scroll_window
1512 void    _nc_scroll_window(
1513                 WINDOW  *win,
1514                 int const n,
1515                 short const top,
1516                 short const bottom,
1517                 chtype  blank)
1518                 { /* void */ }
1519
1520 #undef wscrl
1521 int     wscrl(
1522                 WINDOW  *win,
1523                 int     n)
1524                 { return(*(int *)0); }
1525
1526 /* ./base/lib_scrollok.c */
1527
1528 #undef scrollok
1529 int     scrollok(
1530                 WINDOW  *win,
1531                 bool    flag)
1532                 { return(*(int *)0); }
1533
1534 /* ./base/lib_scrreg.c */
1535
1536 #undef wsetscrreg
1537 int     wsetscrreg(
1538                 WINDOW  *win,
1539                 int     top,
1540                 int     bottom)
1541                 { return(*(int *)0); }
1542
1543 /* ./base/lib_set_term.c */
1544
1545 #undef set_term
1546 SCREEN  *set_term(
1547                 SCREEN  *screenp)
1548                 { return(*(SCREEN **)0); }
1549
1550 #undef delscreen
1551 void    delscreen(
1552                 SCREEN  *sp)
1553                 { /* void */ }
1554
1555 #undef _nc_setupscreen
1556 int     _nc_setupscreen(
1557                 short   slines,
1558                 short const scolumns,
1559                 FILE    *output)
1560                 { return(*(int *)0); }
1561
1562 #undef _nc_ripoffline
1563 int     _nc_ripoffline(
1564                 int     line,
1565                 int     (*init)(
1566                 WINDOW  *p1,
1567                 int     p2))
1568                 { return(*(int *)0); }
1569
1570 #undef ripoffline
1571 int     ripoffline(
1572                 int     line,
1573                 int     (*init)(
1574                 WINDOW  *p1,
1575                 int     p2))
1576                 { return(*(int *)0); }
1577
1578 /* ./base/lib_slk.c */
1579
1580 #undef _nc_slk_format
1581 int     _nc_slk_format;
1582
1583 #undef _nc_slk_initialize
1584 int     _nc_slk_initialize(
1585                 WINDOW  *stwin,
1586                 int     cols)
1587                 { return(*(int *)0); }
1588
1589 #undef slk_restore
1590 int     slk_restore(void)
1591                 { return(*(int *)0); }
1592
1593 /* ./base/lib_slkatr_set.c */
1594
1595 #undef slk_attr_set
1596 int     slk_attr_set(
1597                 const attr_t attr,
1598                 short   color_pair_number,
1599                 void    *opts)
1600                 { return(*(int *)0); }
1601
1602 /* ./base/lib_slkatrof.c */
1603
1604 #undef slk_attroff
1605 int     slk_attroff(
1606                 const chtype attr)
1607                 { return(*(int *)0); }
1608
1609 /* ./base/lib_slkatron.c */
1610
1611 #undef slk_attron
1612 int     slk_attron(
1613                 const chtype attr)
1614                 { return(*(int *)0); }
1615
1616 /* ./base/lib_slkatrset.c */
1617
1618 #undef slk_attrset
1619 int     slk_attrset(
1620                 const chtype attr)
1621                 { return(*(int *)0); }
1622
1623 /* ./base/lib_slkattr.c */
1624
1625 #undef slk_attr
1626 attr_t  slk_attr(void)
1627                 { return(*(attr_t *)0); }
1628
1629 /* ./base/lib_slkclear.c */
1630
1631 #undef slk_clear
1632 int     slk_clear(void)
1633                 { return(*(int *)0); }
1634
1635 /* ./base/lib_slkcolor.c */
1636
1637 #undef slk_color
1638 int     slk_color(
1639                 short   color_pair_number)
1640                 { return(*(int *)0); }
1641
1642 /* ./base/lib_slkinit.c */
1643
1644 #undef slk_init
1645 int     slk_init(
1646                 int     format)
1647                 { return(*(int *)0); }
1648
1649 /* ./base/lib_slklab.c */
1650
1651 #undef slk_label
1652 char    *slk_label(
1653                 int     n)
1654                 { return(*(char **)0); }
1655
1656 /* ./base/lib_slkrefr.c */
1657
1658 #undef slk_noutrefresh
1659 int     slk_noutrefresh(void)
1660                 { return(*(int *)0); }
1661
1662 #undef slk_refresh
1663 int     slk_refresh(void)
1664                 { return(*(int *)0); }
1665
1666 /* ./base/lib_slkset.c */
1667
1668 #undef slk_set
1669 int     slk_set(
1670                 int     i,
1671                 const char *astr,
1672                 int     format)
1673                 { return(*(int *)0); }
1674
1675 /* ./base/lib_slktouch.c */
1676
1677 #undef slk_touch
1678 int     slk_touch(void)
1679                 { return(*(int *)0); }
1680
1681 /* ./base/lib_touch.c */
1682
1683 #undef is_linetouched
1684 bool    is_linetouched(
1685                 WINDOW  *win,
1686                 int     line)
1687                 { return(*(bool *)0); }
1688
1689 #undef is_wintouched
1690 bool    is_wintouched(
1691                 WINDOW  *win)
1692                 { return(*(bool *)0); }
1693
1694 #undef wtouchln
1695 int     wtouchln(
1696                 WINDOW  *win,
1697                 int     y,
1698                 int     n,
1699                 int     changed)
1700                 { return(*(int *)0); }
1701
1702 /* ./trace/lib_traceatr.c */
1703
1704 #undef _traceattr2
1705 char    *_traceattr2(
1706                 int     bufnum,
1707                 attr_t  newmode)
1708                 { return(*(char **)0); }
1709
1710 #undef _traceattr
1711 char    *_traceattr(
1712                 attr_t  newmode)
1713                 { return(*(char **)0); }
1714
1715 #undef _nc_retrace_attr_t
1716 attr_t  _nc_retrace_attr_t(
1717                 attr_t  code)
1718                 { return(*(attr_t *)0); }
1719
1720 #undef _tracechtype2
1721 char    *_tracechtype2(
1722                 int     bufnum,
1723                 chtype  ch)
1724                 { return(*(char **)0); }
1725
1726 #undef _tracechtype
1727 char    *_tracechtype(
1728                 chtype  ch)
1729                 { return(*(char **)0); }
1730
1731 #undef _nc_retrace_chtype
1732 attr_t  _nc_retrace_chtype(
1733                 attr_t  code)
1734                 { return(*(attr_t *)0); }
1735
1736 /* ./trace/lib_tracedmp.c */
1737
1738 #undef _tracedump
1739 void    _tracedump(
1740                 const char *name,
1741                 WINDOW  *win)
1742                 { /* void */ }
1743
1744 /* ./trace/lib_tracemse.c */
1745
1746 #undef _tracemouse
1747 char    *_tracemouse(
1748                 MEVENT const *ep)
1749                 { return(*(char **)0); }
1750
1751 /* ./tty/lib_tstp.c */
1752
1753 #include <signal.h>
1754 #include <SigAction.h>
1755
1756 #undef _nc_signal_handler
1757 void    _nc_signal_handler(
1758                 bool    enable)
1759                 { /* void */ }
1760
1761 /* ./base/lib_ungetch.c */
1762
1763 #undef _nc_fifo_dump
1764 void    _nc_fifo_dump(void)
1765                 { /* void */ }
1766
1767 #undef ungetch
1768 int     ungetch(
1769                 int     ch)
1770                 { return(*(int *)0); }
1771
1772 /* ./tty/lib_vidattr.c */
1773
1774 #undef vidputs
1775 int     vidputs(
1776                 attr_t  newmode,
1777                 int     (*outc)(
1778                 int     p1))
1779                 { return(*(int *)0); }
1780
1781 #undef vidattr
1782 int     vidattr(
1783                 attr_t  newmode)
1784                 { return(*(int *)0); }
1785
1786 #undef termattrs
1787 chtype  termattrs(void)
1788                 { return(*(chtype *)0); }
1789
1790 /* ./base/lib_vline.c */
1791
1792 #undef wvline
1793 int     wvline(
1794                 WINDOW  *win,
1795                 chtype  ch,
1796                 int     n)
1797                 { return(*(int *)0); }
1798
1799 /* ./base/lib_wattroff.c */
1800
1801 #undef wattr_off
1802 int     wattr_off(
1803                 WINDOW  *win,
1804                 attr_t  at,
1805                 void    *opts)
1806                 { return(*(int *)0); }
1807
1808 /* ./base/lib_wattron.c */
1809
1810 #undef wattr_on
1811 int     wattr_on(
1812                 WINDOW  *win,
1813                 attr_t  at,
1814                 void    *opts)
1815                 { return(*(int *)0); }
1816
1817 /* ./base/lib_winch.c */
1818
1819 #undef winch
1820 chtype  winch(
1821                 WINDOW  *win)
1822                 { return(*(chtype *)0); }
1823
1824 /* ./base/lib_window.c */
1825
1826 #undef _nc_synchook
1827 void    _nc_synchook(
1828                 WINDOW  *win)
1829                 { /* void */ }
1830
1831 #undef mvderwin
1832 int     mvderwin(
1833                 WINDOW  *win,
1834                 int     y,
1835                 int     x)
1836                 { return(*(int *)0); }
1837
1838 #undef syncok
1839 int     syncok(
1840                 WINDOW  *win,
1841                 bool    bf)
1842                 { return(*(int *)0); }
1843
1844 #undef wsyncup
1845 void    wsyncup(
1846                 WINDOW  *win)
1847                 { /* void */ }
1848
1849 #undef wsyncdown
1850 void    wsyncdown(
1851                 WINDOW  *win)
1852                 { /* void */ }
1853
1854 #undef wcursyncup
1855 void    wcursyncup(
1856                 WINDOW  *win)
1857                 { /* void */ }
1858
1859 #undef dupwin
1860 WINDOW  *dupwin(
1861                 WINDOW  *win)
1862                 { return(*(WINDOW **)0); }
1863
1864 /* ./base/nc_panel.c */
1865
1866 #undef _nc_panelhook
1867 struct panelhook *_nc_panelhook(void)
1868                 { return(*(struct panelhook **)0); }
1869
1870 /* ./base/safe_sprintf.c */
1871
1872 #undef _nc_printf_string
1873 char    *_nc_printf_string(
1874                 const char *fmt,
1875                 va_list ap)
1876                 { return(*(char **)0); }
1877
1878 /* ./tty/tty_update.c */
1879
1880 #include <sys/time.h>
1881 #include <sys/times.h>
1882
1883 #undef doupdate
1884 int     doupdate(void)
1885                 { return(*(int *)0); }
1886
1887 #undef _nc_outstr
1888 void    _nc_outstr(
1889                 const char *str)
1890                 { /* void */ }
1891
1892 #undef _nc_scrolln
1893 int     _nc_scrolln(
1894                 int     n,
1895                 int     top,
1896                 int     bot,
1897                 int     maxy)
1898                 { return(*(int *)0); }
1899
1900 #undef _nc_screen_resume
1901 void    _nc_screen_resume(void)
1902                 { /* void */ }
1903
1904 #undef _nc_screen_init
1905 void    _nc_screen_init(void)
1906                 { /* void */ }
1907
1908 #undef _nc_screen_wrap
1909 void    _nc_screen_wrap(void)
1910                 { /* void */ }
1911
1912 #undef _nc_do_xmc_glitch
1913 void    _nc_do_xmc_glitch(
1914                 attr_t  previous)
1915                 { /* void */ }
1916
1917 /* ./base/memmove.c */
1918
1919 #undef _nc_memmove
1920 void    _nc_memmove(void)
1921                 { /* void */ }
1922
1923 /* ./base/sigaction.c */
1924
1925 #undef _nc_sigaction
1926 void    _nc_sigaction(void)
1927                 { /* void */ }
1928
1929 /* ./base/vsscanf.c */
1930
1931 #undef _nc_vsscanf
1932 void    _nc_vsscanf(void)
1933                 { /* void */ }
1934
1935 /* ./base/define_key.c */
1936
1937 #undef define_key
1938 int     define_key(
1939                 char    *str,
1940                 int     keycode)
1941                 { return(*(int *)0); }
1942
1943 /* ./expanded.c */
1944
1945 #undef _nc_toggle_attr_on
1946 void    _nc_toggle_attr_on(
1947                 attr_t  *S,
1948                 attr_t  at)
1949                 { /* void */ }
1950
1951 #undef _nc_toggle_attr_off
1952 void    _nc_toggle_attr_off(
1953                 attr_t  *S,
1954                 attr_t  at)
1955                 { /* void */ }
1956
1957 #undef _nc_DelCharCost
1958 int     _nc_DelCharCost(
1959                 int     count)
1960                 { return(*(int *)0); }
1961
1962 #undef _nc_InsCharCost
1963 int     _nc_InsCharCost(
1964                 int     count)
1965                 { return(*(int *)0); }
1966
1967 #undef _nc_UpdateAttrs
1968 void    _nc_UpdateAttrs(
1969                 chtype  c)
1970                 { /* void */ }
1971
1972 /* ./base/keybound.c */
1973
1974 #undef keybound
1975 char    *keybound(
1976                 int     code,
1977                 int     count)
1978                 { return(*(char **)0); }
1979
1980 /* ./base/keyok.c */
1981
1982 #undef keyok
1983 int     keyok(
1984                 int     c,
1985                 bool    flag)
1986                 { return(*(int *)0); }
1987
1988 /* ./base/lib_dft_fgbg.c */
1989
1990 #undef use_default_colors
1991 int     use_default_colors(void)
1992                 { return(*(int *)0); }
1993
1994 #undef assume_default_colors
1995 int     assume_default_colors(
1996                 int     fg,
1997                 int     bg)
1998                 { return(*(int *)0); }
1999
2000 /* ./base/lib_freeall.c */
2001
2002 #include <term_entry.h>
2003
2004 #undef _nc_freeall
2005 void    _nc_freeall(void)
2006                 { /* void */ }
2007
2008 /* ./tinfo/lib_print.c */
2009
2010 #undef mcprint
2011 int     mcprint(
2012                 char    *data,
2013                 int     len)
2014                 { return(*(int *)0); }
2015
2016 /* ./base/resizeterm.c */
2017
2018 #undef resizeterm
2019 int     resizeterm(
2020                 int     ToLines,
2021                 int     ToCols)
2022                 { return(*(int *)0); }
2023
2024 /* ./trace/trace_xnames.c */
2025
2026 #undef _nc_trace_xnames
2027 void    _nc_trace_xnames(
2028                 TERMTYPE *tp)
2029                 { /* void */ }
2030
2031 /* ./base/tries.c */
2032
2033 #undef _nc_expand_try
2034 char    *_nc_expand_try(
2035                 struct tries *tree,
2036                 unsigned short code,
2037                 int     *count,
2038                 size_t  len)
2039                 { return(*(char **)0); }
2040
2041 #undef _nc_remove_key
2042 int     _nc_remove_key(
2043                 struct tries **tree,
2044                 unsigned short code)
2045                 { return(*(int *)0); }
2046
2047 #undef _nc_remove_string
2048 int     _nc_remove_string(
2049                 struct tries **tree,
2050                 char    *string)
2051                 { return(*(int *)0); }
2052
2053 /* ./base/version.c */
2054
2055 #undef curses_version
2056 const char *curses_version(void)
2057                 { return(*(const char **)0); }
2058
2059 /* ./base/wresize.c */
2060
2061 #undef wresize
2062 int     wresize(
2063                 WINDOW  *win,
2064                 int     ToLines,
2065                 int     ToCols)
2066                 { return(*(int *)0); }
2067
2068 /* ./tinfo/access.c */
2069
2070 #undef _nc_basename
2071 char    *_nc_basename(
2072                 char    *path)
2073                 { return(*(char **)0); }
2074
2075 #undef _nc_access
2076 int     _nc_access(
2077                 const char *path,
2078                 int     mode)
2079                 { return(*(int *)0); }
2080
2081 #undef _nc_env_access
2082 int     _nc_env_access(void)
2083                 { return(*(int *)0); }
2084
2085 /* ./tinfo/add_tries.c */
2086
2087 #undef _nc_add_to_try
2088 void    _nc_add_to_try(
2089                 struct tries **tree,
2090                 const char *str,
2091                 unsigned short code)
2092                 { /* void */ }
2093
2094 /* ./tinfo/alloc_entry.c */
2095
2096 #undef _nc_init_entry
2097 void    _nc_init_entry(
2098                 TERMTYPE *const tp)
2099                 { /* void */ }
2100
2101 #undef _nc_copy_entry
2102 ENTRY   *_nc_copy_entry(
2103                 ENTRY   *oldp)
2104                 { return(*(ENTRY **)0); }
2105
2106 #undef _nc_save_str
2107 char    *_nc_save_str(
2108                 const char *const string)
2109                 { return(*(char **)0); }
2110
2111 #undef _nc_wrap_entry
2112 void    _nc_wrap_entry(
2113                 ENTRY   *const ep)
2114                 { /* void */ }
2115
2116 #undef _nc_merge_entry
2117 void    _nc_merge_entry(
2118                 TERMTYPE *const to,
2119                 TERMTYPE *const from)
2120                 { /* void */ }
2121
2122 /* ./tinfo/alloc_ttype.c */
2123
2124 #undef _nc_align_termtype
2125 void    _nc_align_termtype(
2126                 TERMTYPE *to,
2127                 TERMTYPE *from)
2128                 { /* void */ }
2129
2130 #undef _nc_copy_termtype
2131 void    _nc_copy_termtype(
2132                 TERMTYPE *dst,
2133                 TERMTYPE *src)
2134                 { /* void */ }
2135
2136 /* ./tinfo/captoinfo.c */
2137
2138 #undef _nc_captoinfo
2139 char    *_nc_captoinfo(
2140                  const char *cap,
2141                  const char *s,
2142                 int const parametrized)
2143                 { return(*(char **)0); }
2144
2145 #undef _nc_infotocap
2146 char    *_nc_infotocap(
2147                  const char *cap,
2148                  const char *str,
2149                 int const parametrized)
2150                 { return(*(char **)0); }
2151
2152 /* ./codes.c */
2153
2154 #undef boolcodes
2155 char    *const boolcodes[] = {0};
2156 #undef numcodes
2157 char    *const numcodes[] = {0};
2158 #undef strcodes
2159 char    *const strcodes[] = {0};
2160
2161 /* ./comp_captab.c */
2162
2163 #include <ncurses_cfg.h>
2164
2165 #undef _nc_info_hash_table
2166 const struct name_table_entry *const _nc_info_hash_table[995] = {0};
2167 #undef _nc_cap_hash_table
2168 const struct name_table_entry *const _nc_cap_hash_table[995] = {0};
2169 #undef _nc_capalias_table
2170 const struct alias _nc_capalias_table[] = {0};
2171 #undef _nc_infoalias_table
2172 const struct alias _nc_infoalias_table[] = {0};
2173
2174 #undef _nc_get_table
2175 const struct name_table_entry *_nc_get_table(
2176                 bool    termcap)
2177                 { return(*(const struct name_table_entry **)0); }
2178
2179 #undef _nc_get_hash_table
2180 const struct name_table_entry *const *_nc_get_hash_table(
2181                 bool    termcap)
2182                 { return(*(const struct name_table_entry **)0); }
2183
2184 /* ./tinfo/comp_error.c */
2185
2186 #undef _nc_suppress_warnings
2187 bool    _nc_suppress_warnings;
2188 #undef _nc_curr_line
2189 int     _nc_curr_line;
2190 #undef _nc_curr_col
2191 int     _nc_curr_col;
2192
2193 #undef _nc_set_source
2194 void    _nc_set_source(
2195                 const char *const name)
2196                 { /* void */ }
2197
2198 #undef _nc_set_type
2199 void    _nc_set_type(
2200                 const char *const name)
2201                 { /* void */ }
2202
2203 #undef _nc_get_type
2204 void    _nc_get_type(
2205                 char    *name)
2206                 { /* void */ }
2207
2208 #undef _nc_warning
2209 void    _nc_warning(
2210                 const char *const fmt,
2211                 ...)
2212                 { /* void */ }
2213
2214 #undef _nc_err_abort
2215 void    _nc_err_abort(
2216                 const char *const fmt,
2217                 ...)
2218                 { /* void */ }
2219
2220 #undef _nc_syserr_abort
2221 void    _nc_syserr_abort(
2222                 const char *const fmt,
2223                 ...)
2224                 { /* void */ }
2225
2226 /* ./tinfo/comp_expand.c */
2227
2228 #undef _nc_tic_expand
2229 char    *_nc_tic_expand(
2230                 const char *srcp,
2231                 bool    tic_format,
2232                 int     numbers)
2233                 { return(*(char **)0); }
2234
2235 /* ./tinfo/comp_hash.c */
2236
2237 #include <hashsize.h>
2238
2239 #undef _nc_find_entry
2240 struct name_table_entry const *_nc_find_entry(
2241                 const char *string,
2242                 const struct name_table_entry *const *hash_table)
2243                 { return(*(struct name_table_entry const **)0); }
2244
2245 #undef _nc_find_type_entry
2246 struct name_table_entry const *_nc_find_type_entry(
2247                 const char *string,
2248                 int     type,
2249                 const struct name_table_entry *table)
2250                 { return(*(struct name_table_entry const **)0); }
2251
2252 /* ./tinfo/comp_parse.c */
2253
2254 #undef _nc_check_termtype
2255 void    (*_nc_check_termtype)(
2256                 TERMTYPE *p1);
2257 #undef _nc_head
2258 ENTRY   *_nc_head;
2259 #undef _nc_tail
2260 ENTRY   *_nc_tail;
2261
2262 #undef _nc_free_entries
2263 void    _nc_free_entries(
2264                 ENTRY   *headp)
2265                 { /* void */ }
2266
2267 #undef _nc_entry_match
2268 bool    _nc_entry_match(
2269                 char    *n1,
2270                 char    *n2)
2271                 { return(*(bool *)0); }
2272
2273 #undef _nc_read_entry_source
2274 void    _nc_read_entry_source(
2275                 FILE    *fp,
2276                 char    *buf,
2277                 int     literal,
2278                 bool    silent,
2279                 bool    (*hook)(
2280                 ENTRY   *p1))
2281                 { /* void */ }
2282
2283 #undef _nc_resolve_uses
2284 int     _nc_resolve_uses(
2285                 bool    fullresolve)
2286                 { return(*(int *)0); }
2287
2288 /* ./tinfo/comp_scan.c */
2289
2290 #undef _nc_syntax
2291 int     _nc_syntax;
2292 #undef _nc_curr_file_pos
2293 long    _nc_curr_file_pos;
2294 #undef _nc_comment_start
2295 long    _nc_comment_start;
2296 #undef _nc_comment_end
2297 long    _nc_comment_end;
2298 #undef _nc_start_line
2299 long    _nc_start_line;
2300 #undef _nc_curr_token
2301 struct token _nc_curr_token;
2302 #undef _nc_disable_period
2303 bool    _nc_disable_period;
2304
2305 #undef _nc_get_token
2306 int     _nc_get_token(void)
2307                 { return(*(int *)0); }
2308
2309 #undef _nc_trans_string
2310 char    _nc_trans_string(
2311                 char    *ptr,
2312                 char    *last)
2313                 { return(*(char *)0); }
2314
2315 #undef _nc_push_token
2316 void    _nc_push_token(
2317                 int     tokclass)
2318                 { /* void */ }
2319
2320 #undef _nc_panic_mode
2321 void    _nc_panic_mode(
2322                 char    ch)
2323                 { /* void */ }
2324
2325 #undef _nc_reset_input
2326 void    _nc_reset_input(
2327                 FILE    *fp,
2328                 char    *buf)
2329                 { /* void */ }
2330
2331 /* ./tinfo/doalloc.c */
2332
2333 #undef _nc_doalloc
2334 void    *_nc_doalloc(
2335                 void    *oldp,
2336                 size_t  amount)
2337                 { return(*(void **)0); }
2338
2339 /* ./fallback.c */
2340
2341 #undef _nc_fallback
2342 const TERMTYPE *_nc_fallback(
2343                 const char *name)
2344                 { return(*(const TERMTYPE **)0); }
2345
2346 /* ./tinfo/free_ttype.c */
2347
2348 #undef _nc_free_termtype
2349 void    _nc_free_termtype(
2350                 TERMTYPE *ptr)
2351                 { /* void */ }
2352
2353 #undef _nc_user_definable
2354 bool    _nc_user_definable;
2355
2356 #undef use_extended_names
2357 int     use_extended_names(
2358                 bool    flag)
2359                 { return(*(int *)0); }
2360
2361 /* ./tinfo/getenv_num.c */
2362
2363 #undef _nc_getenv_num
2364 int     _nc_getenv_num(
2365                 const char *name)
2366                 { return(*(int *)0); }
2367
2368 /* ./tinfo/home_terminfo.c */
2369
2370 #undef _nc_home_terminfo
2371 char    *_nc_home_terminfo(void)
2372                 { return(*(char **)0); }
2373
2374 /* ./tinfo/init_keytry.c */
2375
2376 #if 0
2377
2378 #include <init_keytry.h>
2379
2380 #undef _nc_tinfo_fkeys
2381 struct tinfo_fkeys _nc_tinfo_fkeys[];
2382
2383 #endif
2384
2385 #undef _nc_init_keytry
2386 void    _nc_init_keytry(void)
2387                 { /* void */ }
2388
2389 /* ./tinfo/lib_acs.c */
2390
2391 #undef acs_map
2392 chtype  acs_map[128 ];
2393
2394 #undef _nc_init_acs
2395 void    _nc_init_acs(void)
2396                 { /* void */ }
2397
2398 /* ./tinfo/lib_baudrate.c */
2399
2400 #include <termcap.h>
2401
2402 struct speed {
2403     int s;
2404     int sp;
2405 };
2406
2407 #undef _nc_baudrate
2408 int     _nc_baudrate(
2409                 int     OSpeed)
2410                 { return(*(int *)0); }
2411
2412 #undef _nc_ospeed
2413 int     _nc_ospeed(
2414                 int     BaudRate)
2415                 { return(*(int *)0); }
2416
2417 #undef baudrate
2418 int     baudrate(void)
2419                 { return(*(int *)0); }
2420
2421 /* ./tinfo/lib_cur_term.c */
2422
2423 #undef cur_term
2424 TERMINAL *cur_term;
2425
2426 #undef set_curterm
2427 TERMINAL *set_curterm(
2428                 TERMINAL *termp)
2429                 { return(*(TERMINAL **)0); }
2430
2431 #undef del_curterm
2432 int     del_curterm(
2433                 TERMINAL *termp)
2434                 { return(*(int *)0); }
2435
2436 /* ./tinfo/lib_data.c */
2437
2438 #undef stdscr
2439 WINDOW  *stdscr;
2440 #undef curscr
2441 WINDOW  *curscr;
2442 #undef newscr
2443 WINDOW  *newscr;
2444 #undef _nc_screen_chain
2445 SCREEN  *_nc_screen_chain;
2446 #undef SP
2447 SCREEN  *SP;
2448
2449 /* ./tinfo/lib_has_cap.c */
2450
2451 #undef has_ic
2452 bool    has_ic(void)
2453                 { return(*(bool *)0); }
2454
2455 #undef has_il
2456 bool    has_il(void)
2457                 { return(*(bool *)0); }
2458
2459 /* ./tinfo/lib_kernel.c */
2460
2461 #undef erasechar
2462 char    erasechar(void)
2463                 { return(*(char *)0); }
2464
2465 #undef killchar
2466 char    killchar(void)
2467                 { return(*(char *)0); }
2468
2469 #undef flushinp
2470 int     flushinp(void)
2471                 { return(*(int *)0); }
2472
2473 /* ./lib_keyname.c */
2474
2475 #include <stdlib.h>
2476 #include <string.h>
2477 #include <curses.h>
2478
2479 #undef _nc_key_names
2480 const struct kn _nc_key_names[] = {0};
2481
2482 #undef keyname
2483 char    *keyname(
2484                 int     c)
2485                 { return(*(char **)0); }
2486
2487 /* ./tinfo/lib_longname.c */
2488
2489 #undef longname
2490 char    *longname(void)
2491                 { return(*(char **)0); }
2492
2493 /* ./tinfo/lib_napms.c */
2494
2495 #undef napms
2496 int     napms(
2497                 int     ms)
2498                 { return(*(int *)0); }
2499
2500 /* ./tinfo/lib_options.c */
2501
2502 #undef idlok
2503 int     idlok(
2504                 WINDOW  *win,
2505                 bool    flag)
2506                 { return(*(int *)0); }
2507
2508 #undef idcok
2509 void    idcok(
2510                 WINDOW  *win,
2511                 bool    flag)
2512                 { /* void */ }
2513
2514 #undef halfdelay
2515 int     halfdelay(
2516                 int     t)
2517                 { return(*(int *)0); }
2518
2519 #undef nodelay
2520 int     nodelay(
2521                 WINDOW  *win,
2522                 bool    flag)
2523                 { return(*(int *)0); }
2524
2525 #undef notimeout
2526 int     notimeout(
2527                 WINDOW  *win,
2528                 bool    f)
2529                 { return(*(int *)0); }
2530
2531 #undef wtimeout
2532 void    wtimeout(
2533                 WINDOW  *win,
2534                 int     delay)
2535                 { /* void */ }
2536
2537 #undef keypad
2538 int     keypad(
2539                 WINDOW  *win,
2540                 bool    flag)
2541                 { return(*(int *)0); }
2542
2543 #undef meta
2544 int     meta(
2545                 WINDOW  *win,
2546                 bool    flag)
2547                 { return(*(int *)0); }
2548
2549 #undef curs_set
2550 int     curs_set(
2551                 int     vis)
2552                 { return(*(int *)0); }
2553
2554 #undef typeahead
2555 int     typeahead(
2556                 int     fd)
2557                 { return(*(int *)0); }
2558
2559 #undef has_key
2560 int     has_key(
2561                 int     keycode)
2562                 { return(*(int *)0); }
2563
2564 #undef _nc_keypad
2565 int     _nc_keypad(
2566                 bool    flag)
2567                 { return(*(int *)0); }
2568
2569 /* ./tinfo/lib_raw.c */
2570
2571 #undef raw
2572 int     raw(void)
2573                 { return(*(int *)0); }
2574
2575 #undef cbreak
2576 int     cbreak(void)
2577                 { return(*(int *)0); }
2578
2579 #undef qiflush
2580 void    qiflush(void)
2581                 { /* void */ }
2582
2583 #undef noraw
2584 int     noraw(void)
2585                 { return(*(int *)0); }
2586
2587 #undef nocbreak
2588 int     nocbreak(void)
2589                 { return(*(int *)0); }
2590
2591 #undef noqiflush
2592 void    noqiflush(void)
2593                 { /* void */ }
2594
2595 #undef intrflush
2596 int     intrflush(
2597                 WINDOW  *win,
2598                 bool    flag)
2599                 { return(*(int *)0); }
2600
2601 /* ./tinfo/lib_setup.c */
2602
2603 #include <sys/ioctl.h>
2604
2605 #undef use_env
2606 void    use_env(
2607                 bool    f)
2608                 { /* void */ }
2609
2610 #undef LINES
2611 int     LINES;
2612 #undef COLS
2613 int     COLS;
2614 #undef TABSIZE
2615 int     TABSIZE;
2616
2617 #undef _nc_update_screensize
2618 void    _nc_update_screensize(void)
2619                 { /* void */ }
2620
2621 #undef ttytype
2622 char    ttytype[256 ];
2623
2624 #undef setupterm
2625 int     setupterm(
2626                 char    *tname,
2627                 int     Filedes,
2628                 int     *errret)
2629                 { return(*(int *)0); }
2630
2631 /* ./tinfo/lib_termcap.c */
2632
2633 #undef UP
2634 char    *UP;
2635 #undef BC
2636 char    *BC;
2637
2638 #undef tgetent
2639 int     tgetent(
2640                 char    *bufp,
2641                 const char *name)
2642                 { return(*(int *)0); }
2643
2644 #if 0
2645
2646 #include <capdefaults.c>
2647
2648 #endif
2649
2650 #undef tgetflag
2651 int     tgetflag(
2652                 char    *id)
2653                 { return(*(int *)0); }
2654
2655 #undef tgetnum
2656 int     tgetnum(
2657                 char    *id)
2658                 { return(*(int *)0); }
2659
2660 #undef tgetstr
2661 char    *tgetstr(
2662                 char    *id,
2663                 char    **area)
2664                 { return(*(char **)0); }
2665
2666 /* ./tinfo/lib_termname.c */
2667
2668 #undef termname
2669 char    *termname(void)
2670                 { return(*(char **)0); }
2671
2672 /* ./tinfo/lib_tgoto.c */
2673
2674 #undef tgoto
2675 char    *tgoto(
2676                 const char *string,
2677                 int     x,
2678                 int     y)
2679                 { return(*(char **)0); }
2680
2681 /* ./tinfo/lib_ti.c */
2682
2683 #undef tigetflag
2684 int     tigetflag(
2685                 char    *str)
2686                 { return(*(int *)0); }
2687
2688 #undef tigetnum
2689 int     tigetnum(
2690                 char    *str)
2691                 { return(*(int *)0); }
2692
2693 #undef tigetstr
2694 char    *tigetstr(
2695                 char    *str)
2696                 { return(*(char **)0); }
2697
2698 /* ./tinfo/lib_tparm.c */
2699
2700 typedef struct {
2701     union {
2702         unsigned int num;
2703         char *str;
2704     } data;
2705     bool num_type;
2706 } stack_frame;
2707
2708 #undef tparm
2709 char    *tparm(
2710                 char    *string,
2711                 ...)
2712                 { return(*(char **)0); }
2713
2714 /* ./tinfo/lib_tputs.c */
2715
2716 #undef PC
2717 char    PC;
2718 #undef ospeed
2719 short   ospeed;
2720 #undef _nc_nulls_sent
2721 int     _nc_nulls_sent;
2722
2723 #undef delay_output
2724 int     delay_output(
2725                 int     ms)
2726                 { return(*(int *)0); }
2727
2728 #undef _nc_flush
2729 void    _nc_flush(void)
2730                 { /* void */ }
2731
2732 #undef _nc_outch
2733 int     _nc_outch(
2734                 int     ch)
2735                 { return(*(int *)0); }
2736
2737 #undef putp
2738 int     putp(
2739                 const char *string)
2740                 { return(*(int *)0); }
2741
2742 #undef tputs
2743 int     tputs(
2744                 const char *string,
2745                 int     affcnt,
2746                 int     (*outc)(
2747                 int     p1))
2748                 { return(*(int *)0); }
2749
2750 /* ./trace/lib_trace.c */
2751
2752 #undef _nc_tracing
2753 unsigned _nc_tracing;
2754 #undef _nc_tputs_trace
2755 const char *_nc_tputs_trace = {0};
2756 #undef _nc_outchars
2757 long    _nc_outchars;
2758
2759 #undef trace
2760 void    trace(
2761                 const unsigned int tracelevel)
2762                 { /* void */ }
2763
2764 #undef _nc_visbuf2
2765 const char *_nc_visbuf2(
2766                 int     bufnum,
2767                 const char *buf)
2768                 { return(*(const char **)0); }
2769
2770 #undef _nc_visbuf
2771 const char *_nc_visbuf(
2772                 const char *buf)
2773                 { return(*(const char **)0); }
2774
2775 #undef _tracef
2776 void    _tracef(
2777                 const char *fmt,
2778                 ...)
2779                 { /* void */ }
2780
2781 #undef _nc_retrace_int
2782 int     _nc_retrace_int(
2783                 int     code)
2784                 { return(*(int *)0); }
2785
2786 #undef _nc_retrace_ptr
2787 char    *_nc_retrace_ptr(
2788                 char    *code)
2789                 { return(*(char **)0); }
2790
2791 #undef _nc_retrace_win
2792 WINDOW  *_nc_retrace_win(
2793                 WINDOW  *code)
2794                 { return(*(WINDOW **)0); }
2795
2796 /* ./trace/lib_tracebits.c */
2797
2798 typedef struct {
2799     unsigned int val;
2800     const char *name;
2801 } BITNAMES;
2802
2803 #undef _nc_tracebits
2804 char    *_nc_tracebits(void)
2805                 { return(*(char **)0); }
2806
2807 /* ./trace/lib_tracechr.c */
2808
2809 #undef _tracechar
2810 char    *_tracechar(
2811                 const unsigned char ch)
2812                 { return(*(char **)0); }
2813
2814 /* ./tinfo/lib_ttyflags.c */
2815
2816 #undef _nc_get_tty_mode
2817 int     _nc_get_tty_mode(
2818                 struct termios *buf)
2819                 { return(*(int *)0); }
2820
2821 #undef _nc_set_tty_mode
2822 int     _nc_set_tty_mode(
2823                 struct termios *buf)
2824                 { return(*(int *)0); }
2825
2826 #undef def_shell_mode
2827 int     def_shell_mode(void)
2828                 { return(*(int *)0); }
2829
2830 #undef def_prog_mode
2831 int     def_prog_mode(void)
2832                 { return(*(int *)0); }
2833
2834 #undef reset_prog_mode
2835 int     reset_prog_mode(void)
2836                 { return(*(int *)0); }
2837
2838 #undef reset_shell_mode
2839 int     reset_shell_mode(void)
2840                 { return(*(int *)0); }
2841
2842 #undef savetty
2843 int     savetty(void)
2844                 { return(*(int *)0); }
2845
2846 #undef resetty
2847 int     resetty(void)
2848                 { return(*(int *)0); }
2849
2850 /* ./tty/lib_twait.c */
2851
2852 #undef _nc_timed_wait
2853 int     _nc_timed_wait(
2854                 int     mode,
2855                 int     milliseconds,
2856                 int     *timeleft)
2857                 { return(*(int *)0); }
2858
2859 /* ./tinfo/name_match.c */
2860
2861 #undef _nc_first_name
2862 char    *_nc_first_name(
2863                 const char *const sp)
2864                 { return(*(char **)0); }
2865
2866 #undef _nc_name_match
2867 int     _nc_name_match(
2868                 const char *const namelst,
2869                 const char *const name,
2870                 const char *const delim)
2871                 { return(*(int *)0); }
2872
2873 /* ./names.c */
2874
2875 #undef boolnames
2876 char    *const boolnames[] = {0};
2877 #undef boolfnames
2878 char    *const boolfnames[] = {0};
2879 #undef numnames
2880 char    *const numnames[] = {0};
2881 #undef numfnames
2882 char    *const numfnames[] = {0};
2883 #undef strnames
2884 char    *const strnames[] = {0};
2885 #undef strfnames
2886 char    *const strfnames[] = {0};
2887
2888 /* ./tinfo/parse_entry.c */
2889
2890 #undef _nc_parse_entry
2891 int     _nc_parse_entry(
2892                 struct entry *entryp,
2893                 int     literal,
2894                 bool    silent)
2895                 { return(*(int *)0); }
2896
2897 #undef _nc_capcmp
2898 int     _nc_capcmp(
2899                 const char *s,
2900                 const char *t)
2901                 { return(*(int *)0); }
2902
2903 typedef struct {
2904     const char *from;
2905     const char *to;
2906 } assoc;
2907
2908 /* ./tinfo/read_entry.c */
2909
2910 #undef _nc_tic_dir
2911 const char *_nc_tic_dir(
2912                 const char *path)
2913                 { return(*(const char **)0); }
2914
2915 #undef _nc_keep_tic_dir
2916 void    _nc_keep_tic_dir(
2917                 const char *path)
2918                 { /* void */ }
2919
2920 #undef _nc_read_file_entry
2921 int     _nc_read_file_entry(
2922                 const char *const filename,
2923                 TERMTYPE *ptr)
2924                 { return(*(int *)0); }
2925
2926 #undef _nc_read_entry
2927 int     _nc_read_entry(
2928                 const char *const tn,
2929                 char    *const filename,
2930                 TERMTYPE *const tp)
2931                 { return(*(int *)0); }
2932
2933 /* ./tinfo/read_termcap.c */
2934
2935 #undef _nc_read_termcap
2936 void    _nc_read_termcap(void)
2937                 { /* void */ }
2938
2939 /* ./tinfo/setbuf.c */
2940
2941 #undef _nc_set_buffer
2942 void    _nc_set_buffer(
2943                 FILE    *ofp,
2944                 bool    buffered)
2945                 { /* void */ }
2946
2947 /* ./tinfo/strings.c */
2948
2949 #undef _nc_str_init
2950 string_desc *_nc_str_init(
2951                 string_desc *dst,
2952                 char    *src,
2953                 size_t  len)
2954                 { return(*(string_desc **)0); }
2955
2956 #undef _nc_str_null
2957 string_desc *_nc_str_null(
2958                 string_desc *dst,
2959                 size_t  len)
2960                 { return(*(string_desc **)0); }
2961
2962 #undef _nc_str_copy
2963 string_desc *_nc_str_copy(
2964                 string_desc *dst,
2965                 string_desc *src)
2966                 { return(*(string_desc **)0); }
2967
2968 #undef _nc_safe_strcat
2969 bool    _nc_safe_strcat(
2970                 string_desc *dst,
2971                 const char *src)
2972                 { return(*(bool *)0); }
2973
2974 #undef _nc_safe_strcpy
2975 bool    _nc_safe_strcpy(
2976                 string_desc *dst,
2977                 const char *src)
2978                 { return(*(bool *)0); }
2979
2980 /* ./trace/trace_buf.c */
2981
2982 typedef struct {
2983         char *text;
2984         size_t size;
2985 } LIST;
2986
2987 #undef _nc_trace_buf
2988 char    *_nc_trace_buf(
2989                 int     bufnum,
2990                 size_t  want)
2991                 { return(*(char **)0); }
2992
2993 /* ./trace/trace_tries.c */
2994
2995 #undef _nc_trace_tries
2996 void    _nc_trace_tries(
2997                 struct tries *tree)
2998                 { /* void */ }
2999
3000 /* ./unctrl.c */
3001
3002 #undef unctrl
3003 char    *unctrl(
3004                  chtype ch)
3005                 { return(*(char **)0); }
3006
3007 /* ./tinfo/write_entry.c */
3008
3009 #undef _nc_set_writedir
3010 void    _nc_set_writedir(
3011                 char    *dir)
3012                 { /* void */ }
3013
3014 #undef _nc_write_entry
3015 void    _nc_write_entry(
3016                 TERMTYPE *const tp)
3017                 { /* void */ }
3018
3019 #undef _nc_tic_written
3020 int     _nc_tic_written(void)
3021                 { return(*(int *)0); }