ncurses/llib-lncurses

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