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