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