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