1/**************************************************************************** 2 * Copyright 2019,2020,2021 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 NCURSES_ATTR_T z) 487 { return(*(int *)0); } 488 489#undef attron 490int attron( 491 NCURSES_ATTR_T z) 492 { return(*(int *)0); } 493 494#undef attrset 495int attrset( 496 NCURSES_ATTR_T 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#undef _nc_safe_fopen 2818FILE *_nc_safe_fopen( 2819 const char *path, 2820 const char *mode) 2821 { return(*(FILE **)0); } 2822 2823#undef _nc_safe_open3 2824int _nc_safe_open3( 2825 const char *path, 2826 int flags, 2827 mode_t mode) 2828 { return(*(int *)0); } 2829 2830/* ./tinfo/add_tries.c */ 2831 2832#undef _nc_add_to_try 2833int _nc_add_to_try( 2834 TRIES **tree, 2835 const char *str, 2836 unsigned code) 2837 { return(*(int *)0); } 2838 2839/* ./tinfo/alloc_ttype.c */ 2840 2841#undef _nc_align_termtype 2842void _nc_align_termtype( 2843 TERMTYPE *to, 2844 TERMTYPE *from) 2845 { /* void */ } 2846 2847#undef _nc_copy_termtype 2848void _nc_copy_termtype( 2849 TERMTYPE *dst, 2850 const TERMTYPE *src) 2851 { /* void */ } 2852 2853/* ./codes.c */ 2854 2855#undef _nc_boolcodes 2856const char *const *_nc_boolcodes(void) 2857 { return(*(const char **)0); } 2858 2859#undef _nc_numcodes 2860const char *const *_nc_numcodes(void) 2861 { return(*(const char **)0); } 2862 2863#undef _nc_strcodes 2864const char *const *_nc_strcodes(void) 2865 { return(*(const char **)0); } 2866 2867/* ./comp_captab.c */ 2868 2869#undef _nc_get_table 2870const struct name_table_entry *_nc_get_table( 2871 NCURSES_BOOL termcap) 2872 { return(*(const struct name_table_entry **)0); } 2873 2874#undef _nc_get_hash_table 2875const HashValue *_nc_get_hash_table( 2876 NCURSES_BOOL termcap) 2877 { return(*(const HashValue **)0); } 2878 2879#undef _nc_get_alias_table 2880const struct alias *_nc_get_alias_table( 2881 NCURSES_BOOL termcap) 2882 { return(*(const struct alias **)0); } 2883 2884#undef _nc_get_hash_info 2885const HashData *_nc_get_hash_info( 2886 NCURSES_BOOL termcap) 2887 { return(*(const HashData **)0); } 2888 2889/* ./tinfo/comp_error.c */ 2890 2891#undef _nc_suppress_warnings 2892NCURSES_BOOL _nc_suppress_warnings; 2893#undef _nc_curr_line 2894int _nc_curr_line; 2895#undef _nc_curr_col 2896int _nc_curr_col; 2897 2898#undef _nc_get_source 2899const char *_nc_get_source(void) 2900 { return(*(const char **)0); } 2901 2902#undef _nc_set_source 2903void _nc_set_source( 2904 const char *const name) 2905 { /* void */ } 2906 2907#undef _nc_set_type 2908void _nc_set_type( 2909 const char *const name) 2910 { /* void */ } 2911 2912#undef _nc_get_type 2913void _nc_get_type( 2914 char *name) 2915 { /* void */ } 2916 2917#undef _nc_warning 2918void _nc_warning( 2919 const char *const fmt, 2920 ...) 2921 { /* void */ } 2922 2923#undef _nc_err_abort 2924void _nc_err_abort( 2925 const char *const fmt, 2926 ...) 2927 { /* void */ } 2928 2929#undef _nc_syserr_abort 2930void _nc_syserr_abort( 2931 const char *const fmt, 2932 ...) 2933 { /* void */ } 2934 2935/* ./tinfo/comp_hash.c */ 2936 2937#undef _nc_find_entry 2938struct name_table_entry const *_nc_find_entry( 2939 const char *string, 2940 const HashValue *hash_table) 2941 { return(*(struct name_table_entry const **)0); } 2942 2943#undef _nc_find_type_entry 2944struct name_table_entry const *_nc_find_type_entry( 2945 const char *string, 2946 int type, 2947 NCURSES_BOOL termcap) 2948 { return(*(struct name_table_entry const **)0); } 2949 2950#undef _nc_find_user_entry 2951struct user_table_entry const *_nc_find_user_entry( 2952 const char *string) 2953 { return(*(struct user_table_entry const **)0); } 2954 2955/* ./comp_userdefs.c */ 2956 2957#undef _nc_get_userdefs_table 2958const struct user_table_entry *_nc_get_userdefs_table(void) 2959 { return(*(const struct user_table_entry **)0); } 2960 2961#undef _nc_get_hash_user 2962const HashData *_nc_get_hash_user(void) 2963 { return(*(const HashData **)0); } 2964 2965/* ./tinfo/db_iterator.c */ 2966 2967#undef _nc_tic_dir 2968const char *_nc_tic_dir( 2969 const char *path) 2970 { return(*(const char **)0); } 2971 2972#undef _nc_keep_tic_dir 2973void _nc_keep_tic_dir( 2974 const char *path) 2975 { /* void */ } 2976 2977#undef _nc_last_db 2978void _nc_last_db(void) 2979 { /* void */ } 2980 2981#undef _nc_next_db 2982const char *_nc_next_db( 2983 DBDIRS *state, 2984 int *offset) 2985 { return(*(const char **)0); } 2986 2987#undef _nc_first_db 2988void _nc_first_db( 2989 DBDIRS *state, 2990 int *offset) 2991 { /* void */ } 2992 2993/* ./tinfo/doalloc.c */ 2994 2995#undef _nc_doalloc 2996void *_nc_doalloc( 2997 void *oldp, 2998 size_t amount) 2999 { return(*(void **)0); } 3000 3001/* ./tinfo/entries.c */ 3002 3003#undef _nc_head 3004ENTRY *_nc_head; 3005#undef _nc_tail 3006ENTRY *_nc_tail; 3007 3008#undef _nc_free_entry 3009void _nc_free_entry( 3010 ENTRY *headp, 3011 TERMTYPE *tterm) 3012 { /* void */ } 3013 3014#undef _nc_free_entries 3015void _nc_free_entries( 3016 ENTRY *headp) 3017 { /* void */ } 3018 3019#undef _nc_leaks_tinfo 3020void _nc_leaks_tinfo(void) 3021 { /* void */ } 3022 3023#undef exit_terminfo 3024void exit_terminfo( 3025 int code) 3026 { /* void */ } 3027 3028/* ./fallback.c */ 3029 3030#undef _nc_fallback 3031const TERMTYPE *_nc_fallback( 3032 const char *name) 3033 { return(*(const TERMTYPE **)0); } 3034 3035/* ./tinfo/free_ttype.c */ 3036 3037#undef _nc_free_termtype 3038void _nc_free_termtype( 3039 TERMTYPE *ptr) 3040 { /* void */ } 3041 3042#undef _nc_user_definable 3043NCURSES_BOOL _nc_user_definable; 3044 3045#undef use_extended_names 3046int use_extended_names( 3047 NCURSES_BOOL flag) 3048 { return(*(int *)0); } 3049 3050/* ./tinfo/getenv_num.c */ 3051 3052#undef _nc_getenv_num 3053int _nc_getenv_num( 3054 const char *name) 3055 { return(*(int *)0); } 3056 3057#undef _nc_setenv_num 3058void _nc_setenv_num( 3059 const char *name, 3060 int value) 3061 { /* void */ } 3062 3063/* ./tinfo/home_terminfo.c */ 3064 3065#undef _nc_home_terminfo 3066char *_nc_home_terminfo(void) 3067 { return(*(char **)0); } 3068 3069/* ./tinfo/init_keytry.c */ 3070 3071#undef _nc_init_keytry 3072void _nc_init_keytry( 3073 SCREEN *sp) 3074 { /* void */ } 3075 3076/* ./tinfo/lib_acs.c */ 3077 3078#undef _nc_acs_map 3079chtype *_nc_acs_map(void) 3080 { return(*(chtype **)0); } 3081 3082#undef _nc_init_acs_sp 3083void _nc_init_acs_sp( 3084 SCREEN *sp) 3085 { /* void */ } 3086 3087#undef _nc_init_acs 3088void _nc_init_acs(void) 3089 { /* void */ } 3090 3091/* ./tinfo/lib_baudrate.c */ 3092 3093struct speed { 3094 int given_speed; 3095 int actual_speed; 3096}; 3097 3098#undef _nc_baudrate 3099int _nc_baudrate( 3100 int OSpeed) 3101 { return(*(int *)0); } 3102 3103#undef _nc_ospeed 3104int _nc_ospeed( 3105 int BaudRate) 3106 { return(*(int *)0); } 3107 3108#undef baudrate_sp 3109int baudrate_sp( 3110 SCREEN *sp) 3111 { return(*(int *)0); } 3112 3113#undef baudrate 3114int baudrate(void) 3115 { return(*(int *)0); } 3116 3117/* ./tinfo/lib_cur_term.c */ 3118 3119#undef _nc_get_cur_term_sp 3120TERMINAL *_nc_get_cur_term_sp( 3121 SCREEN *sp) 3122 { return(*(TERMINAL **)0); } 3123 3124#undef _nc_get_cur_term 3125TERMINAL *_nc_get_cur_term(void) 3126 { return(*(TERMINAL **)0); } 3127 3128#undef _nc_cur_term 3129TERMINAL *_nc_cur_term(void) 3130 { return(*(TERMINAL **)0); } 3131 3132#undef set_curterm_sp 3133TERMINAL *set_curterm_sp( 3134 SCREEN *sp, 3135 TERMINAL *termp) 3136 { return(*(TERMINAL **)0); } 3137 3138#undef set_curterm 3139TERMINAL *set_curterm( 3140 TERMINAL *termp) 3141 { return(*(TERMINAL **)0); } 3142 3143#undef del_curterm_sp 3144int del_curterm_sp( 3145 SCREEN *sp, 3146 TERMINAL *termp) 3147 { return(*(int *)0); } 3148 3149#undef del_curterm 3150int del_curterm( 3151 TERMINAL *termp) 3152 { return(*(int *)0); } 3153 3154/* ./tinfo/lib_data.c */ 3155 3156#undef _nc_stdscr 3157WINDOW *_nc_stdscr(void) 3158 { return(*(WINDOW **)0); } 3159 3160#undef _nc_curscr 3161WINDOW *_nc_curscr(void) 3162 { return(*(WINDOW **)0); } 3163 3164#undef _nc_newscr 3165WINDOW *_nc_newscr(void) 3166 { return(*(WINDOW **)0); } 3167 3168#undef _nc_screen_chain 3169SCREEN *_nc_screen_chain; 3170#undef SP 3171SCREEN *SP; 3172#undef _nc_globals 3173NCURSES_GLOBALS _nc_globals; 3174#undef _nc_prescreen 3175NCURSES_PRESCREEN _nc_prescreen; 3176 3177#undef _nc_screen_of 3178SCREEN *_nc_screen_of( 3179 WINDOW *win) 3180 { return(*(SCREEN **)0); } 3181 3182#undef _nc_init_pthreads 3183void _nc_init_pthreads(void) 3184 { /* void */ } 3185 3186#undef _nc_mutex_init 3187void _nc_mutex_init( 3188 pthread_mutex_t *obj) 3189 { /* void */ } 3190 3191#undef _nc_mutex_lock 3192int _nc_mutex_lock( 3193 pthread_mutex_t *obj) 3194 { return(*(int *)0); } 3195 3196#undef _nc_mutex_trylock 3197int _nc_mutex_trylock( 3198 pthread_mutex_t *obj) 3199 { return(*(int *)0); } 3200 3201#undef _nc_mutex_unlock 3202int _nc_mutex_unlock( 3203 pthread_mutex_t *obj) 3204 { return(*(int *)0); } 3205 3206/* ./tinfo/lib_has_cap.c */ 3207 3208#undef has_ic_sp 3209NCURSES_BOOL has_ic_sp( 3210 SCREEN *sp) 3211 { return(*(NCURSES_BOOL *)0); } 3212 3213#undef has_ic 3214NCURSES_BOOL has_ic(void) 3215 { return(*(NCURSES_BOOL *)0); } 3216 3217#undef has_il_sp 3218NCURSES_BOOL has_il_sp( 3219 SCREEN *sp) 3220 { return(*(NCURSES_BOOL *)0); } 3221 3222#undef has_il 3223NCURSES_BOOL has_il(void) 3224 { return(*(NCURSES_BOOL *)0); } 3225 3226/* ./tinfo/lib_kernel.c */ 3227 3228#undef erasechar_sp 3229char erasechar_sp( 3230 SCREEN *sp) 3231 { return(*(char *)0); } 3232 3233#undef erasechar 3234char erasechar(void) 3235 { return(*(char *)0); } 3236 3237#undef killchar_sp 3238char killchar_sp( 3239 SCREEN *sp) 3240 { return(*(char *)0); } 3241 3242#undef killchar 3243char killchar(void) 3244 { return(*(char *)0); } 3245 3246#undef flushinp_sp 3247int flushinp_sp( 3248 SCREEN *sp) 3249 { return(*(int *)0); } 3250 3251#undef flushinp 3252int flushinp(void) 3253 { return(*(int *)0); } 3254 3255/* ./lib_keyname.c */ 3256 3257struct kn { short offset; int code; }; 3258 3259#undef keyname_sp 3260const char *keyname_sp( 3261 SCREEN *sp, 3262 int c) 3263 { return(*(const char **)0); } 3264 3265#undef keyname 3266const char *keyname( 3267 int c) 3268 { return(*(const char **)0); } 3269 3270/* ./tinfo/lib_longname.c */ 3271 3272#undef longname_sp 3273char *longname_sp( 3274 SCREEN *sp) 3275 { return(*(char **)0); } 3276 3277#undef longname 3278char *longname(void) 3279 { return(*(char **)0); } 3280 3281/* ./tinfo/lib_napms.c */ 3282 3283#undef napms_sp 3284int napms_sp( 3285 SCREEN *sp, 3286 int ms) 3287 { return(*(int *)0); } 3288 3289#undef napms 3290int napms( 3291 int ms) 3292 { return(*(int *)0); } 3293 3294/* ./tinfo/lib_options.c */ 3295 3296#undef idlok 3297int idlok( 3298 WINDOW *win, 3299 NCURSES_BOOL flag) 3300 { return(*(int *)0); } 3301 3302#undef idcok 3303void idcok( 3304 WINDOW *win, 3305 NCURSES_BOOL flag) 3306 { /* void */ } 3307 3308#undef halfdelay_sp 3309int halfdelay_sp( 3310 SCREEN *sp, 3311 int t) 3312 { return(*(int *)0); } 3313 3314#undef halfdelay 3315int halfdelay( 3316 int t) 3317 { return(*(int *)0); } 3318 3319#undef nodelay 3320int nodelay( 3321 WINDOW *win, 3322 NCURSES_BOOL flag) 3323 { return(*(int *)0); } 3324 3325#undef notimeout 3326int notimeout( 3327 WINDOW *win, 3328 NCURSES_BOOL f) 3329 { return(*(int *)0); } 3330 3331#undef wtimeout 3332void wtimeout( 3333 WINDOW *win, 3334 int delay) 3335 { /* void */ } 3336 3337#undef keypad 3338int keypad( 3339 WINDOW *win, 3340 NCURSES_BOOL flag) 3341 { return(*(int *)0); } 3342 3343#undef meta 3344int meta( 3345 WINDOW *win, 3346 NCURSES_BOOL flag) 3347 { return(*(int *)0); } 3348 3349#undef curs_set_sp 3350int curs_set_sp( 3351 SCREEN *sp, 3352 int vis) 3353 { return(*(int *)0); } 3354 3355#undef curs_set 3356int curs_set( 3357 int vis) 3358 { return(*(int *)0); } 3359 3360#undef typeahead_sp 3361int typeahead_sp( 3362 SCREEN *sp, 3363 int fd) 3364 { return(*(int *)0); } 3365 3366#undef typeahead 3367int typeahead( 3368 int fd) 3369 { return(*(int *)0); } 3370 3371#undef has_key_sp 3372int has_key_sp( 3373 SCREEN *sp, 3374 int keycode) 3375 { return(*(int *)0); } 3376 3377#undef has_key 3378int has_key( 3379 int keycode) 3380 { return(*(int *)0); } 3381 3382#undef _nc_putp_flush_sp 3383int _nc_putp_flush_sp( 3384 SCREEN *sp, 3385 const char *name, 3386 const char *value) 3387 { return(*(int *)0); } 3388 3389#undef _nc_keypad 3390int _nc_keypad( 3391 SCREEN *sp, 3392 int flag) 3393 { return(*(int *)0); } 3394 3395/* ./tinfo/lib_raw.c */ 3396 3397#undef raw_sp 3398int raw_sp( 3399 SCREEN *sp) 3400 { return(*(int *)0); } 3401 3402#undef raw 3403int raw(void) 3404 { return(*(int *)0); } 3405 3406#undef cbreak_sp 3407int cbreak_sp( 3408 SCREEN *sp) 3409 { return(*(int *)0); } 3410 3411#undef cbreak 3412int cbreak(void) 3413 { return(*(int *)0); } 3414 3415#undef qiflush_sp 3416void qiflush_sp( 3417 SCREEN *sp) 3418 { /* void */ } 3419 3420#undef qiflush 3421void qiflush(void) 3422 { /* void */ } 3423 3424#undef noraw_sp 3425int noraw_sp( 3426 SCREEN *sp) 3427 { return(*(int *)0); } 3428 3429#undef noraw 3430int noraw(void) 3431 { return(*(int *)0); } 3432 3433#undef nocbreak_sp 3434int nocbreak_sp( 3435 SCREEN *sp) 3436 { return(*(int *)0); } 3437 3438#undef nocbreak 3439int nocbreak(void) 3440 { return(*(int *)0); } 3441 3442#undef noqiflush_sp 3443void noqiflush_sp( 3444 SCREEN *sp) 3445 { /* void */ } 3446 3447#undef noqiflush 3448void noqiflush(void) 3449 { /* void */ } 3450 3451#undef intrflush_sp 3452int intrflush_sp( 3453 SCREEN *sp, 3454 WINDOW *win, 3455 NCURSES_BOOL flag) 3456 { return(*(int *)0); } 3457 3458#undef intrflush 3459int intrflush( 3460 WINDOW *win, 3461 NCURSES_BOOL flag) 3462 { return(*(int *)0); } 3463 3464/* ./tinfo/lib_setup.c */ 3465 3466#undef _nc_ttytype 3467char *_nc_ttytype(void) 3468 { return(*(char **)0); } 3469 3470#undef _nc_ptr_Lines 3471int *_nc_ptr_Lines( 3472 SCREEN *sp) 3473 { return(*(int **)0); } 3474 3475#undef _nc_LINES 3476int _nc_LINES(void) 3477 { return(*(int *)0); } 3478 3479#undef _nc_ptr_Cols 3480int *_nc_ptr_Cols( 3481 SCREEN *sp) 3482 { return(*(int **)0); } 3483 3484#undef _nc_COLS 3485int _nc_COLS(void) 3486 { return(*(int *)0); } 3487 3488#undef _nc_ptr_Tabsize 3489int *_nc_ptr_Tabsize( 3490 SCREEN *sp) 3491 { return(*(int **)0); } 3492 3493#undef _nc_TABSIZE 3494int _nc_TABSIZE(void) 3495 { return(*(int *)0); } 3496 3497#undef set_tabsize_sp 3498int set_tabsize_sp( 3499 SCREEN *sp, 3500 int value) 3501 { return(*(int *)0); } 3502 3503#undef set_tabsize 3504int set_tabsize( 3505 int value) 3506 { return(*(int *)0); } 3507 3508#undef _nc_handle_sigwinch 3509int _nc_handle_sigwinch( 3510 SCREEN *sp) 3511 { return(*(int *)0); } 3512 3513#undef use_env_sp 3514void use_env_sp( 3515 SCREEN *sp, 3516 NCURSES_BOOL f) 3517 { /* void */ } 3518 3519#undef use_tioctl_sp 3520void use_tioctl_sp( 3521 SCREEN *sp, 3522 NCURSES_BOOL f) 3523 { /* void */ } 3524 3525#undef use_env 3526void use_env( 3527 NCURSES_BOOL f) 3528 { /* void */ } 3529 3530#undef use_tioctl 3531void use_tioctl( 3532 NCURSES_BOOL f) 3533 { /* void */ } 3534 3535#undef _nc_get_screensize 3536void _nc_get_screensize( 3537 SCREEN *sp, 3538 int *linep, 3539 int *colp) 3540 { /* void */ } 3541 3542#undef _nc_update_screensize 3543void _nc_update_screensize( 3544 SCREEN *sp) 3545 { /* void */ } 3546 3547#undef _nc_setup_tinfo 3548int _nc_setup_tinfo( 3549 const char *const tn, 3550 TERMTYPE *const tp) 3551 { return(*(int *)0); } 3552 3553#undef _nc_tinfo_cmdch 3554void _nc_tinfo_cmdch( 3555 TERMINAL *termp, 3556 int proto) 3557 { /* void */ } 3558 3559#undef _nc_get_locale 3560char *_nc_get_locale(void) 3561 { return(*(char **)0); } 3562 3563#undef _nc_unicode_locale 3564int _nc_unicode_locale(void) 3565 { return(*(int *)0); } 3566 3567#undef _nc_locale_breaks_acs 3568int _nc_locale_breaks_acs( 3569 TERMINAL *termp) 3570 { return(*(int *)0); } 3571 3572#undef _nc_setupterm 3573int _nc_setupterm( 3574 const char *tname, 3575 int Filedes, 3576 int *errret, 3577 int reuse) 3578 { return(*(int *)0); } 3579 3580#undef _nc_find_prescr 3581SCREEN *_nc_find_prescr(void) 3582 { return(*(SCREEN **)0); } 3583 3584#undef _nc_forget_prescr 3585void _nc_forget_prescr(void) 3586 { /* void */ } 3587 3588#undef new_prescr 3589SCREEN *new_prescr(void) 3590 { return(*(SCREEN **)0); } 3591 3592#undef setupterm 3593int setupterm( 3594 const char *tname, 3595 int Filedes, 3596 int *errret) 3597 { return(*(int *)0); } 3598 3599/* ./tinfo/lib_termcap.c */ 3600 3601#undef UP 3602char *UP; 3603#undef BC 3604char *BC; 3605 3606#undef tgetent_sp 3607int tgetent_sp( 3608 SCREEN *sp, 3609 char *bufp, 3610 const char *name) 3611 { return(*(int *)0); } 3612 3613#undef tgetent 3614int tgetent( 3615 char *bufp, 3616 const char *name) 3617 { return(*(int *)0); } 3618 3619#undef tgetflag_sp 3620int tgetflag_sp( 3621 SCREEN *sp, 3622 const char *id) 3623 { return(*(int *)0); } 3624 3625#undef tgetflag 3626int tgetflag( 3627 const char *id) 3628 { return(*(int *)0); } 3629 3630#undef tgetnum_sp 3631int tgetnum_sp( 3632 SCREEN *sp, 3633 const char *id) 3634 { return(*(int *)0); } 3635 3636#undef tgetnum 3637int tgetnum( 3638 const char *id) 3639 { return(*(int *)0); } 3640 3641#undef tgetstr_sp 3642char *tgetstr_sp( 3643 SCREEN *sp, 3644 const char *id, 3645 char **area) 3646 { return(*(char **)0); } 3647 3648#undef tgetstr 3649char *tgetstr( 3650 const char *id, 3651 char **area) 3652 { return(*(char **)0); } 3653 3654/* ./tinfo/lib_termname.c */ 3655 3656#undef termname_sp 3657char *termname_sp( 3658 SCREEN *sp) 3659 { return(*(char **)0); } 3660 3661#undef termname 3662char *termname(void) 3663 { return(*(char **)0); } 3664 3665/* ./tinfo/lib_tgoto.c */ 3666 3667#undef tgoto 3668char *tgoto( 3669 const char *string, 3670 int x, 3671 int y) 3672 { return(*(char **)0); } 3673 3674/* ./tinfo/lib_ti.c */ 3675 3676#undef tigetflag_sp 3677int tigetflag_sp( 3678 SCREEN *sp, 3679 const char *str) 3680 { return(*(int *)0); } 3681 3682#undef tigetflag 3683int tigetflag( 3684 const char *str) 3685 { return(*(int *)0); } 3686 3687#undef tigetnum_sp 3688int tigetnum_sp( 3689 SCREEN *sp, 3690 const char *str) 3691 { return(*(int *)0); } 3692 3693#undef tigetnum 3694int tigetnum( 3695 const char *str) 3696 { return(*(int *)0); } 3697 3698#undef tigetstr_sp 3699char *tigetstr_sp( 3700 SCREEN *sp, 3701 const char *str) 3702 { return(*(char **)0); } 3703 3704#undef tigetstr 3705char *tigetstr( 3706 const char *str) 3707 { return(*(char **)0); } 3708 3709/* ./tinfo/lib_tparm.c */ 3710 3711#undef _nc_tparm_err 3712int _nc_tparm_err; 3713 3714#undef _nc_tparm_analyze 3715int _nc_tparm_analyze( 3716 TERMINAL *term, 3717 const char *string, 3718 char **p_is_s, 3719 int *_nc_popcount) 3720 { return(*(int *)0); } 3721 3722#undef tparm 3723char *tparm( 3724 const char *string, 3725 ...) 3726 { return(*(char **)0); } 3727 3728#undef tiparm 3729char *tiparm( 3730 const char *string, 3731 ...) 3732 { return(*(char **)0); } 3733 3734#undef _nc_tiparm 3735char *_nc_tiparm( 3736 int expected, 3737 const char *string, 3738 ...) 3739 { return(*(char **)0); } 3740 3741#undef _nc_reset_tparm 3742void _nc_reset_tparm( 3743 TERMINAL *term) 3744 { /* void */ } 3745 3746/* ./tinfo/lib_tputs.c */ 3747 3748#undef PC 3749char PC; 3750#undef ospeed 3751short ospeed; 3752#undef _nc_nulls_sent 3753int _nc_nulls_sent; 3754 3755#undef _nc_set_no_padding 3756void _nc_set_no_padding( 3757 SCREEN *sp) 3758 { /* void */ } 3759 3760#undef delay_output_sp 3761int delay_output_sp( 3762 SCREEN *sp, 3763 int ms) 3764 { return(*(int *)0); } 3765 3766#undef delay_output 3767int delay_output( 3768 int ms) 3769 { return(*(int *)0); } 3770 3771#undef _nc_flush_sp 3772void _nc_flush_sp( 3773 SCREEN *sp) 3774 { /* void */ } 3775 3776#undef _nc_flush 3777void _nc_flush(void) 3778 { /* void */ } 3779 3780#undef _nc_outch_sp 3781int _nc_outch_sp( 3782 SCREEN *sp, 3783 int ch) 3784 { return(*(int *)0); } 3785 3786#undef _nc_outch 3787int _nc_outch( 3788 int ch) 3789 { return(*(int *)0); } 3790 3791#undef _nc_putchar_sp 3792int _nc_putchar_sp( 3793 SCREEN *sp, 3794 int ch) 3795 { return(*(int *)0); } 3796 3797#undef _nc_putchar 3798int _nc_putchar( 3799 int ch) 3800 { return(*(int *)0); } 3801 3802#undef putp_sp 3803int putp_sp( 3804 SCREEN *sp, 3805 const char *string) 3806 { return(*(int *)0); } 3807 3808#undef putp 3809int putp( 3810 const char *string) 3811 { return(*(int *)0); } 3812 3813#undef _nc_putp_sp 3814int _nc_putp_sp( 3815 SCREEN *sp, 3816 const char *name, 3817 const char *string) 3818 { return(*(int *)0); } 3819 3820#undef _nc_putp 3821int _nc_putp( 3822 const char *name, 3823 const char *string) 3824 { return(*(int *)0); } 3825 3826#undef tputs_sp 3827int tputs_sp( 3828 SCREEN *sp, 3829 const char *string, 3830 int affcnt, 3831 NCURSES_OUTC_sp outc) 3832 { return(*(int *)0); } 3833 3834#undef _nc_outc_wrapper 3835int _nc_outc_wrapper( 3836 SCREEN *sp, 3837 int c) 3838 { return(*(int *)0); } 3839 3840#undef tputs 3841int tputs( 3842 const char *string, 3843 int affcnt, 3844 int (*outc)( 3845 int p1)) 3846 { return(*(int *)0); } 3847 3848/* ./trace/lib_trace.c */ 3849 3850#undef _nc_tracing 3851unsigned _nc_tracing; 3852 3853#undef _nc__nc_tputs_trace 3854const char *_nc__nc_tputs_trace(void) 3855 { return(*(const char **)0); } 3856 3857#undef _nc__nc_outchars 3858long _nc__nc_outchars(void) 3859 { return(*(long *)0); } 3860 3861#undef _nc_set_tputs_trace 3862void _nc_set_tputs_trace( 3863 const char *s) 3864 { /* void */ } 3865 3866#undef _nc_count_outchars 3867void _nc_count_outchars( 3868 long increment) 3869 { /* void */ } 3870 3871#undef curses_trace 3872unsigned curses_trace( 3873 unsigned tracelevel) 3874 { return(*(unsigned *)0); } 3875 3876#undef trace 3877void trace( 3878 const unsigned int tracelevel) 3879 { /* void */ } 3880 3881#undef _tracef 3882void _tracef( 3883 const char *fmt, 3884 ...) 3885 { /* void */ } 3886 3887#undef _nc_retrace_bool 3888NCURSES_BOOL _nc_retrace_bool( 3889 int code) 3890 { return(*(NCURSES_BOOL *)0); } 3891 3892#undef _nc_retrace_char 3893char _nc_retrace_char( 3894 int code) 3895 { return(*(char *)0); } 3896 3897#undef _nc_retrace_int 3898int _nc_retrace_int( 3899 int code) 3900 { return(*(int *)0); } 3901 3902#undef _nc_retrace_unsigned 3903unsigned _nc_retrace_unsigned( 3904 unsigned code) 3905 { return(*(unsigned *)0); } 3906 3907#undef _nc_retrace_ptr 3908char *_nc_retrace_ptr( 3909 char *code) 3910 { return(*(char **)0); } 3911 3912#undef _nc_retrace_cptr 3913const char *_nc_retrace_cptr( 3914 const char *code) 3915 { return(*(const char **)0); } 3916 3917#undef _nc_retrace_cvoid_ptr 3918const void *_nc_retrace_cvoid_ptr( 3919 const void *code) 3920 { return(*(const void **)0); } 3921 3922#undef _nc_retrace_void_ptr 3923void *_nc_retrace_void_ptr( 3924 void *code) 3925 { return(*(void **)0); } 3926 3927#undef _nc_retrace_sp 3928SCREEN *_nc_retrace_sp( 3929 SCREEN *code) 3930 { return(*(SCREEN **)0); } 3931 3932#undef _nc_retrace_win 3933WINDOW *_nc_retrace_win( 3934 WINDOW *code) 3935 { return(*(WINDOW **)0); } 3936 3937#undef _nc_fmt_funcptr 3938char *_nc_fmt_funcptr( 3939 char *target, 3940 const char *source, 3941 size_t size) 3942 { return(*(char **)0); } 3943 3944#undef _nc_use_tracef 3945int _nc_use_tracef( 3946 unsigned mask) 3947 { return(*(int *)0); } 3948 3949#undef _nc_locked_tracef 3950void _nc_locked_tracef( 3951 const char *fmt, 3952 ...) 3953 { /* void */ } 3954 3955/* ./trace/lib_traceatr.c */ 3956 3957#undef _traceattr2 3958char *_traceattr2( 3959 int bufnum, 3960 chtype newmode) 3961 { return(*(char **)0); } 3962 3963#undef _traceattr 3964char *_traceattr( 3965 attr_t newmode) 3966 { return(*(char **)0); } 3967 3968#undef _nc_retrace_int_attr_t 3969int _nc_retrace_int_attr_t( 3970 attr_t code) 3971 { return(*(int *)0); } 3972 3973#undef _nc_retrace_attr_t 3974attr_t _nc_retrace_attr_t( 3975 attr_t code) 3976 { return(*(attr_t *)0); } 3977 3978#undef _nc_altcharset_name 3979const char *_nc_altcharset_name( 3980 attr_t attr, 3981 chtype ch) 3982 { return(*(const char **)0); } 3983 3984#undef _tracechtype2 3985char *_tracechtype2( 3986 int bufnum, 3987 chtype ch) 3988 { return(*(char **)0); } 3989 3990#undef _tracechtype 3991char *_tracechtype( 3992 chtype ch) 3993 { return(*(char **)0); } 3994 3995#undef _nc_retrace_chtype 3996chtype _nc_retrace_chtype( 3997 chtype code) 3998 { return(*(chtype *)0); } 3999 4000/* ./trace/lib_tracebits.c */ 4001 4002#undef _nc_trace_ttymode 4003char *_nc_trace_ttymode( 4004 const struct termios *tty) 4005 { return(*(char **)0); } 4006 4007#undef _nc_tracebits 4008char *_nc_tracebits(void) 4009 { return(*(char **)0); } 4010 4011/* ./trace/lib_tracechr.c */ 4012 4013#undef _nc_tracechar 4014char *_nc_tracechar( 4015 SCREEN *sp, 4016 int ch) 4017 { return(*(char **)0); } 4018 4019#undef _tracechar 4020char *_tracechar( 4021 int ch) 4022 { return(*(char **)0); } 4023 4024/* ./tinfo/lib_ttyflags.c */ 4025 4026#undef _nc_get_tty_mode_sp 4027int _nc_get_tty_mode_sp( 4028 SCREEN *sp, 4029 struct termios *buf) 4030 { return(*(int *)0); } 4031 4032#undef _nc_get_tty_mode 4033int _nc_get_tty_mode( 4034 struct termios *buf) 4035 { return(*(int *)0); } 4036 4037#undef _nc_set_tty_mode_sp 4038int _nc_set_tty_mode_sp( 4039 SCREEN *sp, 4040 struct termios *buf) 4041 { return(*(int *)0); } 4042 4043#undef _nc_set_tty_mode 4044int _nc_set_tty_mode( 4045 struct termios *buf) 4046 { return(*(int *)0); } 4047 4048#undef def_shell_mode_sp 4049int def_shell_mode_sp( 4050 SCREEN *sp) 4051 { return(*(int *)0); } 4052 4053#undef def_shell_mode 4054int def_shell_mode(void) 4055 { return(*(int *)0); } 4056 4057#undef def_prog_mode_sp 4058int def_prog_mode_sp( 4059 SCREEN *sp) 4060 { return(*(int *)0); } 4061 4062#undef def_prog_mode 4063int def_prog_mode(void) 4064 { return(*(int *)0); } 4065 4066#undef reset_prog_mode_sp 4067int reset_prog_mode_sp( 4068 SCREEN *sp) 4069 { return(*(int *)0); } 4070 4071#undef reset_prog_mode 4072int reset_prog_mode(void) 4073 { return(*(int *)0); } 4074 4075#undef reset_shell_mode_sp 4076int reset_shell_mode_sp( 4077 SCREEN *sp) 4078 { return(*(int *)0); } 4079 4080#undef reset_shell_mode 4081int reset_shell_mode(void) 4082 { return(*(int *)0); } 4083 4084#undef savetty_sp 4085int savetty_sp( 4086 SCREEN *sp) 4087 { return(*(int *)0); } 4088 4089#undef savetty 4090int savetty(void) 4091 { return(*(int *)0); } 4092 4093#undef resetty_sp 4094int resetty_sp( 4095 SCREEN *sp) 4096 { return(*(int *)0); } 4097 4098#undef resetty 4099int resetty(void) 4100 { return(*(int *)0); } 4101 4102/* ./tty/lib_twait.c */ 4103 4104#undef _nc_timed_wait 4105int _nc_timed_wait( 4106 SCREEN *sp, 4107 int mode, 4108 int milliseconds, 4109 int *timeleft) 4110 { return(*(int *)0); } 4111 4112/* ./tinfo/name_match.c */ 4113 4114#undef _nc_first_name 4115char *_nc_first_name( 4116 const char *const sp) 4117 { return(*(char **)0); } 4118 4119#undef _nc_name_match 4120int _nc_name_match( 4121 const char *const namelst, 4122 const char *const name, 4123 const char *const delim) 4124 { return(*(int *)0); } 4125 4126/* ./names.c */ 4127 4128#undef _nc_boolnames 4129const char *const *_nc_boolnames(void) 4130 { return(*(const char **)0); } 4131 4132#undef _nc_boolfnames 4133const char *const *_nc_boolfnames(void) 4134 { return(*(const char **)0); } 4135 4136#undef _nc_numnames 4137const char *const *_nc_numnames(void) 4138 { return(*(const char **)0); } 4139 4140#undef _nc_numfnames 4141const char *const *_nc_numfnames(void) 4142 { return(*(const char **)0); } 4143 4144#undef _nc_strnames 4145const char *const *_nc_strnames(void) 4146 { return(*(const char **)0); } 4147 4148#undef _nc_strfnames 4149const char *const *_nc_strfnames(void) 4150 { return(*(const char **)0); } 4151 4152/* ./tinfo/obsolete.c */ 4153 4154#undef _nc_set_buffer_sp 4155void _nc_set_buffer_sp( 4156 SCREEN *sp, 4157 FILE *ofp, 4158 int buffered) 4159 { /* void */ } 4160 4161#undef _nc_set_buffer 4162void _nc_set_buffer( 4163 FILE *ofp, 4164 int buffered) 4165 { /* void */ } 4166 4167/* ./tinfo/read_entry.c */ 4168 4169#undef _nc_init_termtype 4170void _nc_init_termtype( 4171 TERMTYPE *const tp) 4172 { /* void */ } 4173 4174#undef _nc_read_termtype 4175int _nc_read_termtype( 4176 TERMTYPE *ptr, 4177 char *buffer, 4178 int limit) 4179 { return(*(int *)0); } 4180 4181#undef _nc_read_file_entry 4182int _nc_read_file_entry( 4183 const char *const filename, 4184 TERMTYPE *ptr) 4185 { return(*(int *)0); } 4186 4187#undef _nc_read_entry 4188int _nc_read_entry( 4189 const char *const name, 4190 char *const filename, 4191 TERMTYPE *const tp) 4192 { return(*(int *)0); } 4193 4194/* ./tinfo/read_termcap.c */ 4195 4196#undef _nc_read_termcap_entry 4197int _nc_read_termcap_entry( 4198 const char *const tn, 4199 TERMTYPE *const tp) 4200 { return(*(int *)0); } 4201 4202/* ./tinfo/strings.c */ 4203 4204#undef _nc_str_init 4205string_desc *_nc_str_init( 4206 string_desc *dst, 4207 char *src, 4208 size_t len) 4209 { return(*(string_desc **)0); } 4210 4211#undef _nc_str_null 4212string_desc *_nc_str_null( 4213 string_desc *dst, 4214 size_t len) 4215 { return(*(string_desc **)0); } 4216 4217#undef _nc_str_copy 4218string_desc *_nc_str_copy( 4219 string_desc *dst, 4220 string_desc *src) 4221 { return(*(string_desc **)0); } 4222 4223#undef _nc_safe_strcat 4224NCURSES_BOOL _nc_safe_strcat( 4225 string_desc *dst, 4226 const char *src) 4227 { return(*(NCURSES_BOOL *)0); } 4228 4229#undef _nc_safe_strcpy 4230NCURSES_BOOL _nc_safe_strcpy( 4231 string_desc *dst, 4232 const char *src) 4233 { return(*(NCURSES_BOOL *)0); } 4234 4235/* ./trace/trace_buf.c */ 4236 4237#undef _nc_trace_buf 4238char *_nc_trace_buf( 4239 int bufnum, 4240 size_t want) 4241 { return(*(char **)0); } 4242 4243#undef _nc_trace_bufcat 4244char *_nc_trace_bufcat( 4245 int bufnum, 4246 const char *value) 4247 { return(*(char **)0); } 4248 4249/* ./trace/trace_tries.c */ 4250 4251#undef _nc_trace_tries 4252void _nc_trace_tries( 4253 TRIES *tree) 4254 { /* void */ } 4255 4256/* ./base/tries.c */ 4257 4258#undef _nc_expand_try 4259char *_nc_expand_try( 4260 TRIES *tree, 4261 unsigned code, 4262 int *count, 4263 size_t len) 4264 { return(*(char **)0); } 4265 4266#undef _nc_remove_key 4267int _nc_remove_key( 4268 TRIES **tree, 4269 unsigned code) 4270 { return(*(int *)0); } 4271 4272#undef _nc_remove_string 4273int _nc_remove_string( 4274 TRIES **tree, 4275 const char *string) 4276 { return(*(int *)0); } 4277 4278/* ./tinfo/trim_sgr0.c */ 4279 4280#undef _nc_trim_sgr0 4281char *_nc_trim_sgr0( 4282 TERMTYPE *tp) 4283 { return(*(char **)0); } 4284 4285/* ./unctrl.c */ 4286 4287#undef unctrl_sp 4288const char *unctrl_sp( 4289 SCREEN *sp, 4290 chtype ch) 4291 { return(*(const char **)0); } 4292 4293#undef unctrl 4294const char *unctrl( 4295 chtype ch) 4296 { return(*(const char **)0); } 4297 4298/* ./trace/visbuf.c */ 4299 4300#undef _nc_visbuf2 4301const char *_nc_visbuf2( 4302 int bufnum, 4303 const char *buf) 4304 { return(*(const char **)0); } 4305 4306#undef _nc_visbuf 4307const char *_nc_visbuf( 4308 const char *buf) 4309 { return(*(const char **)0); } 4310 4311#undef _nc_visbufn 4312const char *_nc_visbufn( 4313 const char *buf, 4314 int len) 4315 { return(*(const char **)0); } 4316 4317#undef _nc_viscbuf2 4318const char *_nc_viscbuf2( 4319 int bufnum, 4320 const chtype *buf, 4321 int len) 4322 { return(*(const char **)0); } 4323 4324#undef _nc_viscbuf 4325const char *_nc_viscbuf( 4326 const chtype *buf, 4327 int len) 4328 { return(*(const char **)0); } 4329 4330/* ./tinfo/alloc_entry.c */ 4331 4332#undef _nc_init_entry 4333void _nc_init_entry( 4334 ENTRY *const tp) 4335 { /* void */ } 4336 4337#undef _nc_copy_entry 4338ENTRY *_nc_copy_entry( 4339 ENTRY *oldp) 4340 { return(*(ENTRY **)0); } 4341 4342#undef _nc_save_str 4343char *_nc_save_str( 4344 const char *string) 4345 { return(*(char **)0); } 4346 4347#undef _nc_wrap_entry 4348void _nc_wrap_entry( 4349 ENTRY *const ep, 4350 NCURSES_BOOL copy_strings) 4351 { /* void */ } 4352 4353#undef _nc_merge_entry 4354void _nc_merge_entry( 4355 ENTRY *const target, 4356 ENTRY *const source) 4357 { /* void */ } 4358 4359/* ./tinfo/captoinfo.c */ 4360 4361#undef _nc_captoinfo 4362char *_nc_captoinfo( 4363 const char *cap, 4364 const char *s, 4365 int const parameterized) 4366 { return(*(char **)0); } 4367 4368#undef _nc_infotocap 4369char *_nc_infotocap( 4370 const char *cap, 4371 const char *str, 4372 int const parameterized) 4373 { return(*(char **)0); } 4374 4375/* ./tinfo/comp_expand.c */ 4376 4377#undef _nc_tic_expand 4378char *_nc_tic_expand( 4379 const char *srcp, 4380 NCURSES_BOOL tic_format, 4381 int numbers) 4382 { return(*(char **)0); } 4383 4384/* ./tinfo/comp_parse.c */ 4385 4386#undef _nc_check_termtype2 4387void (*_nc_check_termtype2)( 4388 TERMTYPE *p1, 4389 NCURSES_BOOL p2); 4390 4391#undef _nc_entry_match 4392NCURSES_BOOL _nc_entry_match( 4393 char *n1, 4394 char *n2) 4395 { return(*(NCURSES_BOOL *)0); } 4396 4397#undef _nc_read_entry_source 4398void _nc_read_entry_source( 4399 FILE *fp, 4400 char *buf, 4401 int literal, 4402 NCURSES_BOOL silent, 4403 NCURSES_BOOL (*hook)( 4404 ENTRY *p1)) 4405 { /* void */ } 4406 4407#undef _nc_resolve_uses2 4408int _nc_resolve_uses2( 4409 NCURSES_BOOL fullresolve, 4410 NCURSES_BOOL literal) 4411 { return(*(int *)0); } 4412 4413/* ./tinfo/comp_scan.c */ 4414 4415#undef _nc_syntax 4416int _nc_syntax; 4417#undef _nc_strict_bsd 4418int _nc_strict_bsd; 4419#undef _nc_curr_file_pos 4420long _nc_curr_file_pos; 4421#undef _nc_comment_start 4422long _nc_comment_start; 4423#undef _nc_comment_end 4424long _nc_comment_end; 4425#undef _nc_start_line 4426long _nc_start_line; 4427#undef _nc_curr_token 4428struct token _nc_curr_token; 4429#undef _nc_disable_period 4430NCURSES_BOOL _nc_disable_period; 4431 4432#undef _nc_reset_input 4433void _nc_reset_input( 4434 FILE *fp, 4435 char *buf) 4436 { /* void */ } 4437 4438#undef _nc_get_token 4439int _nc_get_token( 4440 NCURSES_BOOL silent) 4441 { return(*(int *)0); } 4442 4443#undef _nc_trans_string 4444int _nc_trans_string( 4445 char *ptr, 4446 char *last) 4447 { return(*(int *)0); } 4448 4449#undef _nc_push_token 4450void _nc_push_token( 4451 int tokclass) 4452 { /* void */ } 4453 4454#undef _nc_panic_mode 4455void _nc_panic_mode( 4456 char ch) 4457 { /* void */ } 4458 4459/* ./tinfo/parse_entry.c */ 4460 4461#undef _nc_parse_entry 4462int _nc_parse_entry( 4463 ENTRY *entryp, 4464 int literal, 4465 NCURSES_BOOL silent) 4466 { return(*(int *)0); } 4467 4468#undef _nc_capcmp 4469int _nc_capcmp( 4470 const char *s, 4471 const char *t) 4472 { return(*(int *)0); } 4473 4474/* ./tinfo/write_entry.c */ 4475 4476#undef _nc_set_writedir 4477void _nc_set_writedir( 4478 const char *dir) 4479 { /* void */ } 4480 4481#undef _nc_write_entry 4482void _nc_write_entry( 4483 TERMTYPE *const tp) 4484 { /* void */ } 4485 4486#undef _nc_write_object 4487int _nc_write_object( 4488 TERMTYPE *tp, 4489 char *buffer, 4490 unsigned *offset, 4491 unsigned limit) 4492 { return(*(int *)0); } 4493 4494#undef _nc_tic_written 4495int _nc_tic_written(void) 4496 { return(*(int *)0); } 4497 4498/* ./base/define_key.c */ 4499 4500#undef define_key_sp 4501int define_key_sp( 4502 SCREEN *sp, 4503 const char *str, 4504 int keycode) 4505 { return(*(int *)0); } 4506 4507#undef define_key 4508int define_key( 4509 const char *str, 4510 int keycode) 4511 { return(*(int *)0); } 4512 4513/* ./tinfo/hashed_db.c */ 4514 4515#undef _nc_hashed_db 4516void _nc_hashed_db(void) 4517 { /* void */ } 4518 4519/* ./base/key_defined.c */ 4520 4521#undef key_defined_sp 4522int key_defined_sp( 4523 SCREEN *sp, 4524 const char *str) 4525 { return(*(int *)0); } 4526 4527#undef key_defined 4528int key_defined( 4529 const char *str) 4530 { return(*(int *)0); } 4531 4532/* ./base/keybound.c */ 4533 4534#undef keybound_sp 4535char *keybound_sp( 4536 SCREEN *sp, 4537 int code, 4538 int count) 4539 { return(*(char **)0); } 4540 4541#undef keybound 4542char *keybound( 4543 int code, 4544 int count) 4545 { return(*(char **)0); } 4546 4547/* ./base/keyok.c */ 4548 4549#undef keyok_sp 4550int keyok_sp( 4551 SCREEN *sp, 4552 int c, 4553 NCURSES_BOOL flag) 4554 { return(*(int *)0); } 4555 4556#undef keyok 4557int keyok( 4558 int c, 4559 NCURSES_BOOL flag) 4560 { return(*(int *)0); } 4561 4562/* ./base/version.c */ 4563 4564#undef curses_version 4565const char *curses_version(void) 4566 { return(*(const char **)0); } 4567