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