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