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