/**************************************************************************** * Copyright 2020 Thomas E. Dickey * * Copyright 1998-2014,2016 Free Software Foundation, Inc. * * * * Permission is hereby granted, free of charge, to any person obtaining a * * copy of this software and associated documentation files (the * * "Software"), to deal in the Software without restriction, including * * without limitation the rights to use, copy, modify, merge, publish, * * distribute, distribute with modifications, sublicense, and/or sell * * copies of the Software, and to permit persons to whom the Software is * * furnished to do so, subject to the following conditions: * * * * The above copyright notice and this permission notice shall be included * * in all copies or substantial portions of the Software. * * * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * * * * Except as contained in this notice, the name(s) of the above copyright * * holders shall not be used in advertising or otherwise to promote the * * sale, use or other dealings in this Software without prior written * * authorization. * ****************************************************************************/ /**************************************************************************** * Author: Juergen Pfeifer, 1996 * * and: Thomas E. Dickey, 1998 * * and: Nicolas Boulenguez, 2011 * ****************************************************************************/ /* Version Control $Id: gen.c,v 1.77 2020/08/16 18:05:05 tom Exp $ --------------------------------------------------------------------------*/ /* This program prints on its standard output the source for the Terminal_Interface.Curses_Constants Ada package specification. This pure package only exports C constants to the Ada compiler. */ #ifdef HAVE_CONFIG_H #include #else #include #endif #include #include #include #include #undef UCHAR #undef UINT #undef ULONG typedef unsigned char UCHAR; typedef unsigned int UINT; typedef unsigned long ULONG; /* These global variables will be set by main () */ static int little_endian; static const char *my_program_invocation_name = NULL; static void my_error(const char *message) { fprintf(stderr, "%s: %s\n", my_program_invocation_name, message); exit(EXIT_FAILURE); } static void print_constant(FILE * fp, const char *name, UINT value) { fprintf(fp, " %-28s : constant := %u;\n", name, value); } static void print_long_val(FILE * fp, const char *name, long value) { fprintf(fp, " %-28s : constant := %ld;\n", name, value); } static void print_size_of(FILE * fp, const char *name, size_t value) { fprintf(fp, " %-28s : constant := %lu;\n", name, value); } #define PRINT_NAMED_CONSTANT(name) \ print_long_val (fp, #name, name) static void print_comment(FILE * fp, const char *message) { fprintf(fp, "\n -- %s\n\n", message); } /* * Make sure that KEY_MIN and KEY_MAX are defined. * main () will protest if KEY_MIN == 256 */ #ifndef KEY_MAX # define KEY_MAX 0777 #endif #ifndef KEY_MIN # define KEY_MIN 0401 #endif static UCHAR bit_is_set(const UCHAR * const data, const UINT offset) { const UCHAR byte = data[offset >> 3]; UINT bit; if (little_endian) bit = offset; /* offset */ else /* or */ bit = ~offset; /* 7 - offset */ bit &= 7; /* modulo 8 */ return (UCHAR) (byte & (1 << bit)); } /* Find lowest and highest used offset in a byte array. */ /* Returns 0 if and only if all bits are unset. */ static int find_pos(const UCHAR * const data, const UINT sizeof_data, UINT * const low, UINT * const high) { const UINT last = (sizeof_data << 3) - 1; UINT offset; for (offset = last; !bit_is_set(data, offset); offset--) if (!offset) /* All bits are 0. */ return 0; *high = offset; for (offset = 0; !bit_is_set(data, offset); offset++) { } *low = offset; return -1; } #define PRINT_BITMASK(c_type, ada_name, mask_macro) \ { \ UINT first, last; \ c_type mask = (mask_macro); \ if (!find_pos ((UCHAR *)&mask, sizeof (mask), &first, &last)) \ my_error ("failed to locate " ada_name); \ print_constant (fp, ada_name "_First", first); \ print_constant (fp, ada_name "_Last", last); \ } #define PRINT_NAMED_BITMASK(c_type, mask_macro) \ PRINT_BITMASK (c_type, #mask_macro, mask_macro) #define STRUCT_OFFSET(record, field) \ { \ UINT first, last; \ record mask; \ memset (&mask, 0, sizeof (mask)); \ memset (&mask.field, 0xff, sizeof(mask.field)); \ if (!find_pos ((UCHAR *)&mask, sizeof (mask), &first, &last)) \ my_error ("failed to locate" #record "_" #field); \ print_constant (fp, #record "_" #field "_First", first); \ print_constant (fp, #record "_" #field "_Last", last); \ } /*--------------------*/ /* Start of main (). */ /*--------------------*/ int main(int argc, const char *argv[]) { FILE *fp = 0; const int x = 0x12345678; little_endian = (*((const char *)&x) == 0x78); my_program_invocation_name = argv[0]; if (KEY_MIN == 256) my_error("unexpected value for KEY_MIN: 256"); if (argc == 3) { fp = fopen(argv[2], "wb"); } else if (argc == 2) { fp = stdout; } else { my_error("Only one or two arguments expected (DFT_ARG_SUFFIX)"); } if ((strlen(argv[0]) + strlen(__FILE__)) > 25) { fprintf(fp, "-- Generated by the C program %.40s.\n", my_program_invocation_name); } else { fprintf(fp, "-- Generated by the C program %s (source %s).\n", my_program_invocation_name, __FILE__); } fprintf(fp, "-- Do not edit this file directly.\n"); fprintf(fp, "-- The values provided here may vary on your system.\n"); fprintf(fp, "\n"); fprintf(fp, "with System;\n"); fprintf(fp, "package Terminal_Interface.Curses_Constants is\n"); fprintf(fp, " pragma Pure;\n"); fprintf(fp, "\n"); fprintf(fp, " DFT_ARG_SUFFIX : constant String := \"%s\";\n", argv[1]); fprintf(fp, " Bit_Order : constant System.Bit_Order := System.%s_Order_First;\n", little_endian ? "Low" : "High"); print_size_of(fp, "Sizeof_Bool", 8 * sizeof(bool)); PRINT_NAMED_CONSTANT(OK); PRINT_NAMED_CONSTANT(ERR); fprintf(fp, " pragma Warnings (Off); -- redefinition of Standard.True and False\n"); PRINT_NAMED_CONSTANT(TRUE); PRINT_NAMED_CONSTANT(FALSE); fprintf(fp, " pragma Warnings (On);\n"); print_comment(fp, "Version of the ncurses library from extensions(3NCURSES)"); PRINT_NAMED_CONSTANT(NCURSES_VERSION_MAJOR); PRINT_NAMED_CONSTANT(NCURSES_VERSION_MINOR); fprintf(fp, " Version : constant String := \"%d.%d\";\n", NCURSES_VERSION_MAJOR, NCURSES_VERSION_MINOR); print_comment(fp, "Character non-color attributes from attr(3NCURSES)"); fprintf(fp, " -- attr_t and chtype may be signed in C.\n"); fprintf(fp, " type attr_t is mod 2 ** %lu;\n", (long unsigned)(8 * sizeof(attr_t))); PRINT_NAMED_BITMASK(attr_t, A_CHARTEXT); PRINT_NAMED_BITMASK(attr_t, A_COLOR); PRINT_BITMASK(attr_t, "Attr", A_ATTRIBUTES & ~A_COLOR); PRINT_NAMED_BITMASK(attr_t, A_STANDOUT); PRINT_NAMED_BITMASK(attr_t, A_UNDERLINE); PRINT_NAMED_BITMASK(attr_t, A_REVERSE); PRINT_NAMED_BITMASK(attr_t, A_BLINK); PRINT_NAMED_BITMASK(attr_t, A_DIM); PRINT_NAMED_BITMASK(attr_t, A_BOLD); PRINT_NAMED_BITMASK(attr_t, A_PROTECT); PRINT_NAMED_BITMASK(attr_t, A_INVIS); PRINT_NAMED_BITMASK(attr_t, A_ALTCHARSET); PRINT_NAMED_BITMASK(attr_t, A_HORIZONTAL); PRINT_NAMED_BITMASK(attr_t, A_LEFT); PRINT_NAMED_BITMASK(attr_t, A_LOW); PRINT_NAMED_BITMASK(attr_t, A_RIGHT); PRINT_NAMED_BITMASK(attr_t, A_TOP); PRINT_NAMED_BITMASK(attr_t, A_VERTICAL); print_size_of(fp, "chtype_Size", 8 * sizeof(chtype)); print_comment(fp, "predefined color numbers from color(3NCURSES)"); PRINT_NAMED_CONSTANT(COLOR_BLACK); PRINT_NAMED_CONSTANT(COLOR_RED); PRINT_NAMED_CONSTANT(COLOR_GREEN); PRINT_NAMED_CONSTANT(COLOR_YELLOW); PRINT_NAMED_CONSTANT(COLOR_BLUE); PRINT_NAMED_CONSTANT(COLOR_MAGENTA); PRINT_NAMED_CONSTANT(COLOR_CYAN); PRINT_NAMED_CONSTANT(COLOR_WHITE); print_comment(fp, "ETI return codes from ncurses.h"); PRINT_NAMED_CONSTANT(E_OK); PRINT_NAMED_CONSTANT(E_SYSTEM_ERROR); PRINT_NAMED_CONSTANT(E_BAD_ARGUMENT); PRINT_NAMED_CONSTANT(E_POSTED); PRINT_NAMED_CONSTANT(E_CONNECTED); PRINT_NAMED_CONSTANT(E_BAD_STATE); PRINT_NAMED_CONSTANT(E_NO_ROOM); PRINT_NAMED_CONSTANT(E_NOT_POSTED); PRINT_NAMED_CONSTANT(E_UNKNOWN_COMMAND); PRINT_NAMED_CONSTANT(E_NO_MATCH); PRINT_NAMED_CONSTANT(E_NOT_SELECTABLE); PRINT_NAMED_CONSTANT(E_NOT_CONNECTED); PRINT_NAMED_CONSTANT(E_REQUEST_DENIED); PRINT_NAMED_CONSTANT(E_INVALID_FIELD); PRINT_NAMED_CONSTANT(E_CURRENT); print_comment(fp, "Input key codes not defined in any ncurses manpage"); PRINT_NAMED_CONSTANT(KEY_MIN); PRINT_NAMED_CONSTANT(KEY_MAX); #ifdef KEY_CODE_YES PRINT_NAMED_CONSTANT(KEY_CODE_YES); #endif print_comment(fp, "Input key codes from getch(3NCURSES)"); PRINT_NAMED_CONSTANT(KEY_BREAK); PRINT_NAMED_CONSTANT(KEY_DOWN); PRINT_NAMED_CONSTANT(KEY_UP); PRINT_NAMED_CONSTANT(KEY_LEFT); PRINT_NAMED_CONSTANT(KEY_RIGHT); PRINT_NAMED_CONSTANT(KEY_HOME); PRINT_NAMED_CONSTANT(KEY_BACKSPACE); PRINT_NAMED_CONSTANT(KEY_F0); #define PRINT_NAMED_FUNC_KEY(name) print_constant(fp, "KEY_F"#name, KEY_F(name)) PRINT_NAMED_FUNC_KEY(1); PRINT_NAMED_FUNC_KEY(2); PRINT_NAMED_FUNC_KEY(3); PRINT_NAMED_FUNC_KEY(4); PRINT_NAMED_FUNC_KEY(5); PRINT_NAMED_FUNC_KEY(6); PRINT_NAMED_FUNC_KEY(7); PRINT_NAMED_FUNC_KEY(8); PRINT_NAMED_FUNC_KEY(9); PRINT_NAMED_FUNC_KEY(10); PRINT_NAMED_FUNC_KEY(11); PRINT_NAMED_FUNC_KEY(12); PRINT_NAMED_FUNC_KEY(13); PRINT_NAMED_FUNC_KEY(14); PRINT_NAMED_FUNC_KEY(15); PRINT_NAMED_FUNC_KEY(16); PRINT_NAMED_FUNC_KEY(17); PRINT_NAMED_FUNC_KEY(18); PRINT_NAMED_FUNC_KEY(19); PRINT_NAMED_FUNC_KEY(20); PRINT_NAMED_FUNC_KEY(21); PRINT_NAMED_FUNC_KEY(22); PRINT_NAMED_FUNC_KEY(23); PRINT_NAMED_FUNC_KEY(24); PRINT_NAMED_CONSTANT(KEY_DL); PRINT_NAMED_CONSTANT(KEY_IL); PRINT_NAMED_CONSTANT(KEY_DC); PRINT_NAMED_CONSTANT(KEY_IC); PRINT_NAMED_CONSTANT(KEY_EIC); PRINT_NAMED_CONSTANT(KEY_CLEAR); PRINT_NAMED_CONSTANT(KEY_EOS); PRINT_NAMED_CONSTANT(KEY_EOL); PRINT_NAMED_CONSTANT(KEY_SF); PRINT_NAMED_CONSTANT(KEY_SR); PRINT_NAMED_CONSTANT(KEY_NPAGE); PRINT_NAMED_CONSTANT(KEY_PPAGE); PRINT_NAMED_CONSTANT(KEY_STAB); PRINT_NAMED_CONSTANT(KEY_CTAB); PRINT_NAMED_CONSTANT(KEY_CATAB); PRINT_NAMED_CONSTANT(KEY_ENTER); PRINT_NAMED_CONSTANT(KEY_SRESET); PRINT_NAMED_CONSTANT(KEY_RESET); PRINT_NAMED_CONSTANT(KEY_PRINT); PRINT_NAMED_CONSTANT(KEY_LL); PRINT_NAMED_CONSTANT(KEY_A1); PRINT_NAMED_CONSTANT(KEY_A3); PRINT_NAMED_CONSTANT(KEY_B2); PRINT_NAMED_CONSTANT(KEY_C1); PRINT_NAMED_CONSTANT(KEY_C3); PRINT_NAMED_CONSTANT(KEY_BTAB); PRINT_NAMED_CONSTANT(KEY_BEG); PRINT_NAMED_CONSTANT(KEY_CANCEL); PRINT_NAMED_CONSTANT(KEY_CLOSE); PRINT_NAMED_CONSTANT(KEY_COMMAND); PRINT_NAMED_CONSTANT(KEY_COPY); PRINT_NAMED_CONSTANT(KEY_CREATE); PRINT_NAMED_CONSTANT(KEY_END); PRINT_NAMED_CONSTANT(KEY_EXIT); PRINT_NAMED_CONSTANT(KEY_FIND); PRINT_NAMED_CONSTANT(KEY_HELP); PRINT_NAMED_CONSTANT(KEY_MARK); PRINT_NAMED_CONSTANT(KEY_MESSAGE); PRINT_NAMED_CONSTANT(KEY_MOVE); PRINT_NAMED_CONSTANT(KEY_NEXT); PRINT_NAMED_CONSTANT(KEY_OPEN); PRINT_NAMED_CONSTANT(KEY_OPTIONS); PRINT_NAMED_CONSTANT(KEY_PREVIOUS); PRINT_NAMED_CONSTANT(KEY_REDO); PRINT_NAMED_CONSTANT(KEY_REFERENCE); PRINT_NAMED_CONSTANT(KEY_REFRESH); PRINT_NAMED_CONSTANT(KEY_REPLACE); PRINT_NAMED_CONSTANT(KEY_RESTART); PRINT_NAMED_CONSTANT(KEY_RESUME); PRINT_NAMED_CONSTANT(KEY_SAVE); PRINT_NAMED_CONSTANT(KEY_SBEG); PRINT_NAMED_CONSTANT(KEY_SCANCEL); PRINT_NAMED_CONSTANT(KEY_SCOMMAND); PRINT_NAMED_CONSTANT(KEY_SCOPY); PRINT_NAMED_CONSTANT(KEY_SCREATE); PRINT_NAMED_CONSTANT(KEY_SDC); PRINT_NAMED_CONSTANT(KEY_SDL); PRINT_NAMED_CONSTANT(KEY_SELECT); PRINT_NAMED_CONSTANT(KEY_SEND); PRINT_NAMED_CONSTANT(KEY_SEOL); PRINT_NAMED_CONSTANT(KEY_SEXIT); PRINT_NAMED_CONSTANT(KEY_SFIND); PRINT_NAMED_CONSTANT(KEY_SHELP); PRINT_NAMED_CONSTANT(KEY_SHOME); PRINT_NAMED_CONSTANT(KEY_SIC); PRINT_NAMED_CONSTANT(KEY_SLEFT); PRINT_NAMED_CONSTANT(KEY_SMESSAGE); PRINT_NAMED_CONSTANT(KEY_SMOVE); PRINT_NAMED_CONSTANT(KEY_SNEXT); PRINT_NAMED_CONSTANT(KEY_SOPTIONS); PRINT_NAMED_CONSTANT(KEY_SPREVIOUS); PRINT_NAMED_CONSTANT(KEY_SPRINT); PRINT_NAMED_CONSTANT(KEY_SREDO); PRINT_NAMED_CONSTANT(KEY_SREPLACE); PRINT_NAMED_CONSTANT(KEY_SRIGHT); PRINT_NAMED_CONSTANT(KEY_SRSUME); PRINT_NAMED_CONSTANT(KEY_SSAVE); PRINT_NAMED_CONSTANT(KEY_SSUSPEND); PRINT_NAMED_CONSTANT(KEY_SUNDO); PRINT_NAMED_CONSTANT(KEY_SUSPEND); PRINT_NAMED_CONSTANT(KEY_UNDO); PRINT_NAMED_CONSTANT(KEY_MOUSE); PRINT_NAMED_CONSTANT(KEY_RESIZE); print_comment(fp, "alternate character codes (ACS) from addch(3NCURSES)"); #define PRINT_ACS(name) print_size_of (fp, #name, (size_t)(&name - &acs_map[0])) PRINT_ACS(ACS_ULCORNER); PRINT_ACS(ACS_LLCORNER); PRINT_ACS(ACS_URCORNER); PRINT_ACS(ACS_LRCORNER); PRINT_ACS(ACS_LTEE); PRINT_ACS(ACS_RTEE); PRINT_ACS(ACS_BTEE); PRINT_ACS(ACS_TTEE); PRINT_ACS(ACS_HLINE); PRINT_ACS(ACS_VLINE); PRINT_ACS(ACS_PLUS); PRINT_ACS(ACS_S1); PRINT_ACS(ACS_S9); PRINT_ACS(ACS_DIAMOND); PRINT_ACS(ACS_CKBOARD); PRINT_ACS(ACS_DEGREE); PRINT_ACS(ACS_PLMINUS); PRINT_ACS(ACS_BULLET); PRINT_ACS(ACS_LARROW); PRINT_ACS(ACS_RARROW); PRINT_ACS(ACS_DARROW); PRINT_ACS(ACS_UARROW); PRINT_ACS(ACS_BOARD); PRINT_ACS(ACS_LANTERN); PRINT_ACS(ACS_BLOCK); PRINT_ACS(ACS_S3); PRINT_ACS(ACS_S7); PRINT_ACS(ACS_LEQUAL); PRINT_ACS(ACS_GEQUAL); PRINT_ACS(ACS_PI); PRINT_ACS(ACS_NEQUAL); PRINT_ACS(ACS_STERLING); print_comment(fp, "Menu_Options from opts(3MENU)"); PRINT_NAMED_BITMASK(Menu_Options, O_ONEVALUE); PRINT_NAMED_BITMASK(Menu_Options, O_SHOWDESC); PRINT_NAMED_BITMASK(Menu_Options, O_ROWMAJOR); PRINT_NAMED_BITMASK(Menu_Options, O_IGNORECASE); PRINT_NAMED_BITMASK(Menu_Options, O_SHOWMATCH); PRINT_NAMED_BITMASK(Menu_Options, O_NONCYCLIC); print_size_of(fp, "Menu_Options_Size", 8 * sizeof(Menu_Options)); print_comment(fp, "Item_Options from menu_opts(3MENU)"); PRINT_NAMED_BITMASK(Item_Options, O_SELECTABLE); print_size_of(fp, "Item_Options_Size", 8 * sizeof(Item_Options)); print_comment(fp, "Field_Options from field_opts(3FORM)"); PRINT_NAMED_BITMASK(Field_Options, O_VISIBLE); PRINT_NAMED_BITMASK(Field_Options, O_ACTIVE); PRINT_NAMED_BITMASK(Field_Options, O_PUBLIC); PRINT_NAMED_BITMASK(Field_Options, O_EDIT); PRINT_NAMED_BITMASK(Field_Options, O_WRAP); PRINT_NAMED_BITMASK(Field_Options, O_BLANK); PRINT_NAMED_BITMASK(Field_Options, O_AUTOSKIP); PRINT_NAMED_BITMASK(Field_Options, O_NULLOK); PRINT_NAMED_BITMASK(Field_Options, O_PASSOK); PRINT_NAMED_BITMASK(Field_Options, O_STATIC); print_size_of(fp, "Field_Options_Size", 8 * sizeof(Field_Options)); print_comment(fp, "Field_Options from opts(3FORM)"); PRINT_NAMED_BITMASK(Field_Options, O_NL_OVERLOAD); PRINT_NAMED_BITMASK(Field_Options, O_BS_OVERLOAD); /* Field_Options_Size is defined below */ print_comment(fp, "MEVENT structure from mouse(3NCURSES)"); STRUCT_OFFSET(MEVENT, id); STRUCT_OFFSET(MEVENT, x); STRUCT_OFFSET(MEVENT, y); STRUCT_OFFSET(MEVENT, z); STRUCT_OFFSET(MEVENT, bstate); print_size_of(fp, "MEVENT_Size", 8 * sizeof(MEVENT)); print_comment(fp, "mouse events from mouse(3NCURSES)"); { mmask_t all_events; #define PRINT_MOUSE_EVENT(event) \ print_constant (fp, #event, event); \ all_events |= event all_events = 0; PRINT_MOUSE_EVENT(BUTTON1_RELEASED); PRINT_MOUSE_EVENT(BUTTON1_PRESSED); PRINT_MOUSE_EVENT(BUTTON1_CLICKED); PRINT_MOUSE_EVENT(BUTTON1_DOUBLE_CLICKED); PRINT_MOUSE_EVENT(BUTTON1_TRIPLE_CLICKED); #ifdef BUTTON1_RESERVED_EVENT PRINT_MOUSE_EVENT(BUTTON1_RESERVED_EVENT); #endif print_constant(fp, "all_events_button_1", (UINT) all_events); all_events = 0; PRINT_MOUSE_EVENT(BUTTON2_RELEASED); PRINT_MOUSE_EVENT(BUTTON2_PRESSED); PRINT_MOUSE_EVENT(BUTTON2_CLICKED); PRINT_MOUSE_EVENT(BUTTON2_DOUBLE_CLICKED); PRINT_MOUSE_EVENT(BUTTON2_TRIPLE_CLICKED); #ifdef BUTTON2_RESERVED_EVENT PRINT_MOUSE_EVENT(BUTTON2_RESERVED_EVENT); #endif print_constant(fp, "all_events_button_2", (UINT) all_events); all_events = 0; PRINT_MOUSE_EVENT(BUTTON3_RELEASED); PRINT_MOUSE_EVENT(BUTTON3_PRESSED); PRINT_MOUSE_EVENT(BUTTON3_CLICKED); PRINT_MOUSE_EVENT(BUTTON3_DOUBLE_CLICKED); PRINT_MOUSE_EVENT(BUTTON3_TRIPLE_CLICKED); #ifdef BUTTON3_RESERVED_EVENT PRINT_MOUSE_EVENT(BUTTON3_RESERVED_EVENT); #endif print_constant(fp, "all_events_button_3", (UINT) all_events); all_events = 0; PRINT_MOUSE_EVENT(BUTTON4_RELEASED); PRINT_MOUSE_EVENT(BUTTON4_PRESSED); PRINT_MOUSE_EVENT(BUTTON4_CLICKED); PRINT_MOUSE_EVENT(BUTTON4_DOUBLE_CLICKED); PRINT_MOUSE_EVENT(BUTTON4_TRIPLE_CLICKED); #ifdef BUTTON4_RESERVED_EVENT PRINT_MOUSE_EVENT(BUTTON4_RESERVED_EVENT); #endif print_constant(fp, "all_events_button_4", (UINT) all_events); } PRINT_NAMED_CONSTANT(BUTTON_CTRL); PRINT_NAMED_CONSTANT(BUTTON_SHIFT); PRINT_NAMED_CONSTANT(BUTTON_ALT); PRINT_NAMED_CONSTANT(REPORT_MOUSE_POSITION); PRINT_NAMED_CONSTANT(ALL_MOUSE_EVENTS); print_comment(fp, "trace selection from trace(3NCURSES)"); PRINT_NAMED_BITMASK(UINT, TRACE_TIMES); PRINT_NAMED_BITMASK(UINT, TRACE_TPUTS); PRINT_NAMED_BITMASK(UINT, TRACE_UPDATE); PRINT_NAMED_BITMASK(UINT, TRACE_MOVE); PRINT_NAMED_BITMASK(UINT, TRACE_CHARPUT); PRINT_NAMED_BITMASK(UINT, TRACE_CALLS); PRINT_NAMED_BITMASK(UINT, TRACE_VIRTPUT); PRINT_NAMED_BITMASK(UINT, TRACE_IEVENT); PRINT_NAMED_BITMASK(UINT, TRACE_BITS); PRINT_NAMED_BITMASK(UINT, TRACE_ICALLS); PRINT_NAMED_BITMASK(UINT, TRACE_CCALLS); PRINT_NAMED_BITMASK(UINT, TRACE_DATABASE); PRINT_NAMED_BITMASK(UINT, TRACE_ATTRS); print_size_of(fp, "Trace_Size", 8 * sizeof(UINT)); fprintf(fp, "end Terminal_Interface.Curses_Constants;\n"); exit(EXIT_SUCCESS); }