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 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/* ./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/* ./tinfo/lib_tputs.c */ 3721 3722#undef PC 3723char PC; 3724#undef ospeed 3725short ospeed; 3726#undef _nc_nulls_sent 3727int _nc_nulls_sent; 3728 3729#undef _nc_set_no_padding 3730void _nc_set_no_padding( 3731 SCREEN *sp) 3732 { /* void */ } 3733 3734#undef delay_output_sp 3735int delay_output_sp( 3736 SCREEN *sp, 3737 int ms) 3738 { return(*(int *)0); } 3739 3740#undef delay_output 3741int delay_output( 3742 int ms) 3743 { return(*(int *)0); } 3744 3745#undef _nc_flush_sp 3746void _nc_flush_sp( 3747 SCREEN *sp) 3748 { /* void */ } 3749 3750#undef _nc_flush 3751void _nc_flush(void) 3752 { /* void */ } 3753 3754#undef _nc_outch_sp 3755int _nc_outch_sp( 3756 SCREEN *sp, 3757 int ch) 3758 { return(*(int *)0); } 3759 3760#undef _nc_outch 3761int _nc_outch( 3762 int ch) 3763 { return(*(int *)0); } 3764 3765#undef _nc_putchar_sp 3766int _nc_putchar_sp( 3767 SCREEN *sp, 3768 int ch) 3769 { return(*(int *)0); } 3770 3771#undef _nc_putchar 3772int _nc_putchar( 3773 int ch) 3774 { return(*(int *)0); } 3775 3776#undef putp_sp 3777int putp_sp( 3778 SCREEN *sp, 3779 const char *string) 3780 { return(*(int *)0); } 3781 3782#undef putp 3783int putp( 3784 const char *string) 3785 { return(*(int *)0); } 3786 3787#undef _nc_putp_sp 3788int _nc_putp_sp( 3789 SCREEN *sp, 3790 const char *name, 3791 const char *string) 3792 { return(*(int *)0); } 3793 3794#undef _nc_putp 3795int _nc_putp( 3796 const char *name, 3797 const char *string) 3798 { return(*(int *)0); } 3799 3800#undef tputs_sp 3801int tputs_sp( 3802 SCREEN *sp, 3803 const char *string, 3804 int affcnt, 3805 NCURSES_OUTC_sp outc) 3806 { return(*(int *)0); } 3807 3808#undef _nc_outc_wrapper 3809int _nc_outc_wrapper( 3810 SCREEN *sp, 3811 int c) 3812 { return(*(int *)0); } 3813 3814#undef tputs 3815int tputs( 3816 const char *string, 3817 int affcnt, 3818 int (*outc)( 3819 int p1)) 3820 { return(*(int *)0); } 3821 3822/* ./trace/lib_trace.c */ 3823 3824#undef _nc_tracing 3825unsigned _nc_tracing; 3826 3827#undef _nc__nc_tputs_trace 3828const char *_nc__nc_tputs_trace(void) 3829 { return(*(const char **)0); } 3830 3831#undef _nc__nc_outchars 3832long _nc__nc_outchars(void) 3833 { return(*(long *)0); } 3834 3835#undef _nc_set_tputs_trace 3836void _nc_set_tputs_trace( 3837 const char *s) 3838 { /* void */ } 3839 3840#undef _nc_count_outchars 3841void _nc_count_outchars( 3842 long increment) 3843 { /* void */ } 3844 3845#undef curses_trace 3846unsigned curses_trace( 3847 unsigned tracelevel) 3848 { return(*(unsigned *)0); } 3849 3850#undef trace 3851void trace( 3852 const unsigned int tracelevel) 3853 { /* void */ } 3854 3855#undef _tracef 3856void _tracef( 3857 const char *fmt, 3858 ...) 3859 { /* void */ } 3860 3861#undef _nc_retrace_bool 3862NCURSES_BOOL _nc_retrace_bool( 3863 int code) 3864 { return(*(NCURSES_BOOL *)0); } 3865 3866#undef _nc_retrace_char 3867char _nc_retrace_char( 3868 int code) 3869 { return(*(char *)0); } 3870 3871#undef _nc_retrace_int 3872int _nc_retrace_int( 3873 int code) 3874 { return(*(int *)0); } 3875 3876#undef _nc_retrace_unsigned 3877unsigned _nc_retrace_unsigned( 3878 unsigned code) 3879 { return(*(unsigned *)0); } 3880 3881#undef _nc_retrace_ptr 3882char *_nc_retrace_ptr( 3883 char *code) 3884 { return(*(char **)0); } 3885 3886#undef _nc_retrace_cptr 3887const char *_nc_retrace_cptr( 3888 const char *code) 3889 { return(*(const char **)0); } 3890 3891#undef _nc_retrace_cvoid_ptr 3892const void *_nc_retrace_cvoid_ptr( 3893 const void *code) 3894 { return(*(const void **)0); } 3895 3896#undef _nc_retrace_void_ptr 3897void *_nc_retrace_void_ptr( 3898 void *code) 3899 { return(*(void **)0); } 3900 3901#undef _nc_retrace_sp 3902SCREEN *_nc_retrace_sp( 3903 SCREEN *code) 3904 { return(*(SCREEN **)0); } 3905 3906#undef _nc_retrace_win 3907WINDOW *_nc_retrace_win( 3908 WINDOW *code) 3909 { return(*(WINDOW **)0); } 3910 3911#undef _nc_fmt_funcptr 3912char *_nc_fmt_funcptr( 3913 char *target, 3914 const char *source, 3915 size_t size) 3916 { return(*(char **)0); } 3917 3918#undef _nc_use_tracef 3919int _nc_use_tracef( 3920 unsigned mask) 3921 { return(*(int *)0); } 3922 3923#undef _nc_locked_tracef 3924void _nc_locked_tracef( 3925 const char *fmt, 3926 ...) 3927 { /* void */ } 3928 3929/* ./trace/lib_traceatr.c */ 3930 3931#undef _traceattr2 3932char *_traceattr2( 3933 int bufnum, 3934 chtype newmode) 3935 { return(*(char **)0); } 3936 3937#undef _traceattr 3938char *_traceattr( 3939 attr_t newmode) 3940 { return(*(char **)0); } 3941 3942#undef _nc_retrace_int_attr_t 3943int _nc_retrace_int_attr_t( 3944 attr_t code) 3945 { return(*(int *)0); } 3946 3947#undef _nc_retrace_attr_t 3948attr_t _nc_retrace_attr_t( 3949 attr_t code) 3950 { return(*(attr_t *)0); } 3951 3952#undef _nc_altcharset_name 3953const char *_nc_altcharset_name( 3954 attr_t attr, 3955 chtype ch) 3956 { return(*(const char **)0); } 3957 3958#undef _tracechtype2 3959char *_tracechtype2( 3960 int bufnum, 3961 chtype ch) 3962 { return(*(char **)0); } 3963 3964#undef _tracechtype 3965char *_tracechtype( 3966 chtype ch) 3967 { return(*(char **)0); } 3968 3969#undef _nc_retrace_chtype 3970chtype _nc_retrace_chtype( 3971 chtype code) 3972 { return(*(chtype *)0); } 3973 3974/* ./trace/lib_tracebits.c */ 3975 3976#undef _nc_trace_ttymode 3977char *_nc_trace_ttymode( 3978 struct termios *tty) 3979 { return(*(char **)0); } 3980 3981#undef _nc_tracebits 3982char *_nc_tracebits(void) 3983 { return(*(char **)0); } 3984 3985/* ./trace/lib_tracechr.c */ 3986 3987#undef _nc_tracechar 3988char *_nc_tracechar( 3989 SCREEN *sp, 3990 int ch) 3991 { return(*(char **)0); } 3992 3993#undef _tracechar 3994char *_tracechar( 3995 int ch) 3996 { return(*(char **)0); } 3997 3998/* ./tinfo/lib_ttyflags.c */ 3999 4000#undef _nc_get_tty_mode_sp 4001int _nc_get_tty_mode_sp( 4002 SCREEN *sp, 4003 struct termios *buf) 4004 { return(*(int *)0); } 4005 4006#undef _nc_get_tty_mode 4007int _nc_get_tty_mode( 4008 struct termios *buf) 4009 { return(*(int *)0); } 4010 4011#undef _nc_set_tty_mode_sp 4012int _nc_set_tty_mode_sp( 4013 SCREEN *sp, 4014 struct termios *buf) 4015 { return(*(int *)0); } 4016 4017#undef _nc_set_tty_mode 4018int _nc_set_tty_mode( 4019 struct termios *buf) 4020 { return(*(int *)0); } 4021 4022#undef def_shell_mode_sp 4023int def_shell_mode_sp( 4024 SCREEN *sp) 4025 { return(*(int *)0); } 4026 4027#undef def_shell_mode 4028int def_shell_mode(void) 4029 { return(*(int *)0); } 4030 4031#undef def_prog_mode_sp 4032int def_prog_mode_sp( 4033 SCREEN *sp) 4034 { return(*(int *)0); } 4035 4036#undef def_prog_mode 4037int def_prog_mode(void) 4038 { return(*(int *)0); } 4039 4040#undef reset_prog_mode_sp 4041int reset_prog_mode_sp( 4042 SCREEN *sp) 4043 { return(*(int *)0); } 4044 4045#undef reset_prog_mode 4046int reset_prog_mode(void) 4047 { return(*(int *)0); } 4048 4049#undef reset_shell_mode_sp 4050int reset_shell_mode_sp( 4051 SCREEN *sp) 4052 { return(*(int *)0); } 4053 4054#undef reset_shell_mode 4055int reset_shell_mode(void) 4056 { return(*(int *)0); } 4057 4058#undef savetty_sp 4059int savetty_sp( 4060 SCREEN *sp) 4061 { return(*(int *)0); } 4062 4063#undef savetty 4064int savetty(void) 4065 { return(*(int *)0); } 4066 4067#undef resetty_sp 4068int resetty_sp( 4069 SCREEN *sp) 4070 { return(*(int *)0); } 4071 4072#undef resetty 4073int resetty(void) 4074 { return(*(int *)0); } 4075 4076/* ./tty/lib_twait.c */ 4077 4078#undef _nc_timed_wait 4079int _nc_timed_wait( 4080 SCREEN *sp, 4081 int mode, 4082 int milliseconds, 4083 int *timeleft) 4084 { return(*(int *)0); } 4085 4086/* ./tinfo/name_match.c */ 4087 4088#undef _nc_first_name 4089char *_nc_first_name( 4090 const char *const sp) 4091 { return(*(char **)0); } 4092 4093#undef _nc_name_match 4094int _nc_name_match( 4095 const char *const namelst, 4096 const char *const name, 4097 const char *const delim) 4098 { return(*(int *)0); } 4099 4100/* ./names.c */ 4101 4102#undef _nc_boolnames 4103const char *const *_nc_boolnames(void) 4104 { return(*(const char **)0); } 4105 4106#undef _nc_boolfnames 4107const char *const *_nc_boolfnames(void) 4108 { return(*(const char **)0); } 4109 4110#undef _nc_numnames 4111const char *const *_nc_numnames(void) 4112 { return(*(const char **)0); } 4113 4114#undef _nc_numfnames 4115const char *const *_nc_numfnames(void) 4116 { return(*(const char **)0); } 4117 4118#undef _nc_strnames 4119const char *const *_nc_strnames(void) 4120 { return(*(const char **)0); } 4121 4122#undef _nc_strfnames 4123const char *const *_nc_strfnames(void) 4124 { return(*(const char **)0); } 4125 4126/* ./tinfo/obsolete.c */ 4127 4128#undef _nc_set_buffer_sp 4129void _nc_set_buffer_sp( 4130 SCREEN *sp, 4131 FILE *ofp, 4132 int buffered) 4133 { /* void */ } 4134 4135#undef _nc_set_buffer 4136void _nc_set_buffer( 4137 FILE *ofp, 4138 int buffered) 4139 { /* void */ } 4140 4141/* ./tinfo/read_entry.c */ 4142 4143#undef _nc_init_termtype 4144void _nc_init_termtype( 4145 TERMTYPE2 *const tp) 4146 { /* void */ } 4147 4148#undef _nc_read_termtype 4149int _nc_read_termtype( 4150 TERMTYPE2 *ptr, 4151 char *buffer, 4152 int limit) 4153 { return(*(int *)0); } 4154 4155#undef _nc_read_file_entry 4156int _nc_read_file_entry( 4157 const char *const filename, 4158 TERMTYPE2 *ptr) 4159 { return(*(int *)0); } 4160 4161#undef _nc_read_entry 4162int _nc_read_entry( 4163 const char *const name, 4164 char *const filename, 4165 TERMTYPE2 *const tp) 4166 { return(*(int *)0); } 4167 4168/* ./tinfo/read_termcap.c */ 4169 4170#undef _nc_read_termcap_entry 4171int _nc_read_termcap_entry( 4172 const char *const tn, 4173 TERMTYPE2 *const tp) 4174 { return(*(int *)0); } 4175 4176/* ./tinfo/strings.c */ 4177 4178#undef _nc_str_init 4179string_desc *_nc_str_init( 4180 string_desc *dst, 4181 char *src, 4182 size_t len) 4183 { return(*(string_desc **)0); } 4184 4185#undef _nc_str_null 4186string_desc *_nc_str_null( 4187 string_desc *dst, 4188 size_t len) 4189 { return(*(string_desc **)0); } 4190 4191#undef _nc_str_copy 4192string_desc *_nc_str_copy( 4193 string_desc *dst, 4194 string_desc *src) 4195 { return(*(string_desc **)0); } 4196 4197#undef _nc_safe_strcat 4198NCURSES_BOOL _nc_safe_strcat( 4199 string_desc *dst, 4200 const char *src) 4201 { return(*(NCURSES_BOOL *)0); } 4202 4203#undef _nc_safe_strcpy 4204NCURSES_BOOL _nc_safe_strcpy( 4205 string_desc *dst, 4206 const char *src) 4207 { return(*(NCURSES_BOOL *)0); } 4208 4209/* ./trace/trace_buf.c */ 4210 4211#undef _nc_trace_buf 4212char *_nc_trace_buf( 4213 int bufnum, 4214 size_t want) 4215 { return(*(char **)0); } 4216 4217#undef _nc_trace_bufcat 4218char *_nc_trace_bufcat( 4219 int bufnum, 4220 const char *value) 4221 { return(*(char **)0); } 4222 4223/* ./trace/trace_tries.c */ 4224 4225#undef _nc_trace_tries 4226void _nc_trace_tries( 4227 TRIES *tree) 4228 { /* void */ } 4229 4230/* ./base/tries.c */ 4231 4232#undef _nc_expand_try 4233char *_nc_expand_try( 4234 TRIES *tree, 4235 unsigned code, 4236 int *count, 4237 size_t len) 4238 { return(*(char **)0); } 4239 4240#undef _nc_remove_key 4241int _nc_remove_key( 4242 TRIES **tree, 4243 unsigned code) 4244 { return(*(int *)0); } 4245 4246#undef _nc_remove_string 4247int _nc_remove_string( 4248 TRIES **tree, 4249 const char *string) 4250 { return(*(int *)0); } 4251 4252/* ./tinfo/trim_sgr0.c */ 4253 4254#undef _nc_trim_sgr0 4255char *_nc_trim_sgr0( 4256 TERMTYPE2 *tp) 4257 { return(*(char **)0); } 4258 4259/* ./unctrl.c */ 4260 4261#undef unctrl_sp 4262const char *unctrl_sp( 4263 SCREEN *sp, 4264 chtype ch) 4265 { return(*(const char **)0); } 4266 4267#undef unctrl 4268const char *unctrl( 4269 chtype ch) 4270 { return(*(const char **)0); } 4271 4272/* ./trace/visbuf.c */ 4273 4274#undef _nc_visbuf2 4275const char *_nc_visbuf2( 4276 int bufnum, 4277 const char *buf) 4278 { return(*(const char **)0); } 4279 4280#undef _nc_visbuf 4281const char *_nc_visbuf( 4282 const char *buf) 4283 { return(*(const char **)0); } 4284 4285#undef _nc_visbufn 4286const char *_nc_visbufn( 4287 const char *buf, 4288 int len) 4289 { return(*(const char **)0); } 4290 4291#undef _nc_viscbuf2 4292const char *_nc_viscbuf2( 4293 int bufnum, 4294 const chtype *buf, 4295 int len) 4296 { return(*(const char **)0); } 4297 4298#undef _nc_viscbuf 4299const char *_nc_viscbuf( 4300 const chtype *buf, 4301 int len) 4302 { return(*(const char **)0); } 4303 4304/* ./tinfo/alloc_entry.c */ 4305 4306#undef _nc_init_entry 4307void _nc_init_entry( 4308 ENTRY *const tp) 4309 { /* void */ } 4310 4311#undef _nc_copy_entry 4312ENTRY *_nc_copy_entry( 4313 ENTRY *oldp) 4314 { return(*(ENTRY **)0); } 4315 4316#undef _nc_save_str 4317char *_nc_save_str( 4318 const char *const string) 4319 { return(*(char **)0); } 4320 4321#undef _nc_wrap_entry 4322void _nc_wrap_entry( 4323 ENTRY *const ep, 4324 NCURSES_BOOL copy_strings) 4325 { /* void */ } 4326 4327#undef _nc_merge_entry 4328void _nc_merge_entry( 4329 ENTRY *const target, 4330 ENTRY *const source) 4331 { /* void */ } 4332 4333/* ./tinfo/captoinfo.c */ 4334 4335#undef _nc_captoinfo 4336char *_nc_captoinfo( 4337 const char *cap, 4338 const char *s, 4339 int const parameterized) 4340 { return(*(char **)0); } 4341 4342#undef _nc_infotocap 4343char *_nc_infotocap( 4344 const char *cap, 4345 const char *str, 4346 int const parameterized) 4347 { return(*(char **)0); } 4348 4349/* ./tinfo/comp_expand.c */ 4350 4351#undef _nc_tic_expand 4352char *_nc_tic_expand( 4353 const char *srcp, 4354 NCURSES_BOOL tic_format, 4355 int numbers) 4356 { return(*(char **)0); } 4357 4358/* ./tinfo/comp_parse.c */ 4359 4360#undef _nc_check_termtype2 4361void (*_nc_check_termtype2)( 4362 TERMTYPE2 *p1, 4363 NCURSES_BOOL p2); 4364 4365#undef _nc_entry_match 4366NCURSES_BOOL _nc_entry_match( 4367 char *n1, 4368 char *n2) 4369 { return(*(NCURSES_BOOL *)0); } 4370 4371#undef _nc_read_entry_source 4372void _nc_read_entry_source( 4373 FILE *fp, 4374 char *buf, 4375 int literal, 4376 NCURSES_BOOL silent, 4377 NCURSES_BOOL (*hook)( 4378 ENTRY *p1)) 4379 { /* void */ } 4380 4381#undef _nc_resolve_uses2 4382int _nc_resolve_uses2( 4383 NCURSES_BOOL fullresolve, 4384 NCURSES_BOOL literal) 4385 { return(*(int *)0); } 4386 4387/* ./tinfo/comp_scan.c */ 4388 4389#undef _nc_syntax 4390int _nc_syntax; 4391#undef _nc_strict_bsd 4392int _nc_strict_bsd; 4393#undef _nc_curr_file_pos 4394long _nc_curr_file_pos; 4395#undef _nc_comment_start 4396long _nc_comment_start; 4397#undef _nc_comment_end 4398long _nc_comment_end; 4399#undef _nc_start_line 4400long _nc_start_line; 4401#undef _nc_curr_token 4402struct token _nc_curr_token; 4403#undef _nc_disable_period 4404NCURSES_BOOL _nc_disable_period; 4405 4406#undef _nc_reset_input 4407void _nc_reset_input( 4408 FILE *fp, 4409 char *buf) 4410 { /* void */ } 4411 4412#undef _nc_get_token 4413int _nc_get_token( 4414 NCURSES_BOOL silent) 4415 { return(*(int *)0); } 4416 4417#undef _nc_trans_string 4418int _nc_trans_string( 4419 char *ptr, 4420 char *last) 4421 { return(*(int *)0); } 4422 4423#undef _nc_push_token 4424void _nc_push_token( 4425 int tokclass) 4426 { /* void */ } 4427 4428#undef _nc_panic_mode 4429void _nc_panic_mode( 4430 char ch) 4431 { /* void */ } 4432 4433/* ./tinfo/parse_entry.c */ 4434 4435#undef _nc_parse_entry 4436int _nc_parse_entry( 4437 ENTRY *entryp, 4438 int literal, 4439 NCURSES_BOOL silent) 4440 { return(*(int *)0); } 4441 4442#undef _nc_capcmp 4443int _nc_capcmp( 4444 const char *s, 4445 const char *t) 4446 { return(*(int *)0); } 4447 4448/* ./tinfo/write_entry.c */ 4449 4450#undef _nc_set_writedir 4451void _nc_set_writedir( 4452 const char *dir) 4453 { /* void */ } 4454 4455#undef _nc_write_entry 4456void _nc_write_entry( 4457 TERMTYPE2 *const tp) 4458 { /* void */ } 4459 4460#undef _nc_write_object 4461int _nc_write_object( 4462 TERMTYPE2 *tp, 4463 char *buffer, 4464 unsigned *offset, 4465 unsigned limit) 4466 { return(*(int *)0); } 4467 4468#undef _nc_tic_written 4469int _nc_tic_written(void) 4470 { return(*(int *)0); } 4471 4472/* ./base/define_key.c */ 4473 4474#undef define_key_sp 4475int define_key_sp( 4476 SCREEN *sp, 4477 const char *str, 4478 int keycode) 4479 { return(*(int *)0); } 4480 4481#undef define_key 4482int define_key( 4483 const char *str, 4484 int keycode) 4485 { return(*(int *)0); } 4486 4487/* ./tinfo/hashed_db.c */ 4488 4489#undef _nc_hashed_db 4490void _nc_hashed_db(void) 4491 { /* void */ } 4492 4493/* ./base/key_defined.c */ 4494 4495#undef key_defined_sp 4496int key_defined_sp( 4497 SCREEN *sp, 4498 const char *str) 4499 { return(*(int *)0); } 4500 4501#undef key_defined 4502int key_defined( 4503 const char *str) 4504 { return(*(int *)0); } 4505 4506/* ./base/keybound.c */ 4507 4508#undef keybound_sp 4509char *keybound_sp( 4510 SCREEN *sp, 4511 int code, 4512 int count) 4513 { return(*(char **)0); } 4514 4515#undef keybound 4516char *keybound( 4517 int code, 4518 int count) 4519 { return(*(char **)0); } 4520 4521/* ./base/keyok.c */ 4522 4523#undef keyok_sp 4524int keyok_sp( 4525 SCREEN *sp, 4526 int c, 4527 NCURSES_BOOL flag) 4528 { return(*(int *)0); } 4529 4530#undef keyok 4531int keyok( 4532 int c, 4533 NCURSES_BOOL flag) 4534 { return(*(int *)0); } 4535 4536/* ./base/version.c */ 4537 4538#undef curses_version 4539const char *curses_version(void) 4540 { return(*(const char **)0); } 4541