| /**************************************************************************** |
| * Copyright (c) 1998,2007,2008 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 * |
| ****************************************************************************/ |
| |
| /* |
| Version Control |
| $Id: gen.c,v 1.49 2008/10/04 21:59:37 tom Exp $ |
| --------------------------------------------------------------------------*/ |
| /* |
| This program generates various record structures and constants from the |
| ncurses header file for the Ada95 packages. Essentially it produces |
| Ada95 source on stdout, which is then merged using m4 into a template |
| to produce the real source. |
| */ |
| |
| #include <ncurses_cfg.h> |
| |
| #include <stdlib.h> |
| #include <stddef.h> |
| #include <string.h> |
| #include <assert.h> |
| #include <ctype.h> |
| |
| #include <menu.h> |
| #include <form.h> |
| |
| #define RES_NAME "Reserved" |
| |
| static const char *model = ""; |
| static int little_endian = 0; |
| |
| typedef struct |
| { |
| const char *name; |
| unsigned long attr; |
| } |
| name_attribute_pair; |
| |
| static int |
| find_pos(char *s, unsigned len, int *low, int *high) |
| { |
| unsigned int i, j; |
| int l = 0; |
| |
| *high = -1; |
| *low = 8 * len; |
| |
| for (i = 0; i < len; i++, s++) |
| { |
| if (*s) |
| { |
| for (j = 0; j < 8 * sizeof(char); j++) |
| |
| { |
| if (((little_endian && ((*s) & 0x01)) || |
| (!little_endian && ((*s) & 0x80)))) |
| { |
| if (l > *high) |
| *high = l; |
| if (l < *low) |
| *low = l; |
| } |
| l++; |
| if (little_endian) |
| *s >>= 1; |
| else |
| *s <<= 1; |
| } |
| } |
| else |
| l += 8; |
| } |
| return (*high >= 0 && (*low <= *high)) ? *low : -1; |
| } |
| |
| /* |
| * This helper routine generates a representation clause for a |
| * record type defined in the binding. |
| * We are only dealing with record types which are of 32 or 16 |
| * bit size, i.e. they fit into an (u)int or a (u)short. |
| */ |
| static void |
| gen_reps |
| (const name_attribute_pair * nap, /* array of name_attribute_pair records */ |
| const char *name, /* name of the represented record type */ |
| int len, /* size of the record in bytes */ |
| int bias) |
| { |
| int i, n, l, cnt = 0, low, high; |
| int width = strlen(RES_NAME) + 3; |
| unsigned long a; |
| unsigned long mask = 0; |
| |
| assert(nap != NULL); |
| |
| for (i = 0; nap[i].name != (char *)0; i++) |
| { |
| cnt++; |
| l = strlen(nap[i].name); |
| if (l > width) |
| width = l; |
| } |
| assert(width > 0); |
| |
| printf(" type %s is\n", name); |
| printf(" record\n"); |
| for (i = 0; nap[i].name != (char *)0; i++) |
| { |
| printf(" %-*s : Boolean;\n", width, nap[i].name); |
| } |
| printf(" end record;\n"); |
| printf(" pragma Convention (C, %s);\n\n", name); |
| |
| printf(" for %s use\n", name); |
| printf(" record\n"); |
| |
| for (i = 0; nap[i].name != (char *)0; i++) |
| { |
| a = nap[i].attr; |
| mask |= a; |
| l = find_pos((char *)&a, sizeof(a), &low, &high); |
| if (l >= 0) |
| printf(" %-*s at 0 range %2d .. %2d;\n", width, nap[i].name, |
| low - bias, high - bias); |
| } |
| i = 1; |
| n = cnt; |
| printf(" end record;\n"); |
| printf(" for %s'Size use %d;\n", name, 8 * len); |
| printf(" -- Please note: this rep. clause is generated and may be\n"); |
| printf(" -- different on your system."); |
| } |
| |
| static void |
| chtype_rep(const char *name, attr_t mask) |
| { |
| attr_t x = -1; |
| attr_t t = x & mask; |
| int low, high; |
| int l = find_pos((char *)&t, sizeof(t), &low, &high); |
| |
| if (l >= 0) |
| printf(" %-5s at 0 range %2d .. %2d;\n", name, low, high); |
| } |
| |
| static void |
| gen_chtype_rep(const char *name) |
| { |
| printf(" for %s use\n record\n", name); |
| chtype_rep("Ch", A_CHARTEXT); |
| chtype_rep("Color", A_COLOR); |
| chtype_rep("Attr", (A_ATTRIBUTES & ~A_COLOR)); |
| printf(" end record;\n for %s'Size use %ld;\n", |
| name, (long)(8 * sizeof(chtype))); |
| |
| printf(" -- Please note: this rep. clause is generated and may be\n"); |
| printf(" -- different on your system.\n"); |
| } |
| |
| static void |
| mrep_rep(const char *name, void *rec) |
| { |
| int low, high; |
| int l = find_pos((char *)rec, sizeof(MEVENT), &low, &high); |
| |
| if (l >= 0) |
| printf(" %-7s at 0 range %3d .. %3d;\n", name, low, high); |
| } |
| |
| static void |
| gen_mrep_rep(const char *name) |
| { |
| MEVENT x; |
| |
| printf(" for %s use\n record\n", name); |
| |
| memset(&x, 0, sizeof(x)); |
| x.id = -1; |
| mrep_rep("Id", &x); |
| |
| memset(&x, 0, sizeof(x)); |
| x.x = -1; |
| mrep_rep("X", &x); |
| |
| memset(&x, 0, sizeof(x)); |
| x.y = -1; |
| mrep_rep("Y", &x); |
| |
| memset(&x, 0, sizeof(x)); |
| x.z = -1; |
| mrep_rep("Z", &x); |
| |
| memset(&x, 0, sizeof(x)); |
| x.bstate = -1; |
| mrep_rep("Bstate", &x); |
| |
| printf(" end record;\n"); |
| printf(" -- Please note: this rep. clause is generated and may be\n"); |
| printf(" -- different on your system.\n"); |
| } |
| |
| static void |
| gen_attr_set(const char *name) |
| { |
| /* All of the A_xxx symbols are defined in ncurses, but not all are nonzero |
| * if "configure --enable-widec" is specified. |
| */ |
| static const name_attribute_pair nap[] = |
| { |
| #if A_STANDOUT |
| {"Stand_Out", A_STANDOUT}, |
| #endif |
| #if A_UNDERLINE |
| {"Under_Line", A_UNDERLINE}, |
| #endif |
| #if A_REVERSE |
| {"Reverse_Video", A_REVERSE}, |
| #endif |
| #if A_BLINK |
| {"Blink", A_BLINK}, |
| #endif |
| #if A_DIM |
| {"Dim_Character", A_DIM}, |
| #endif |
| #if A_BOLD |
| {"Bold_Character", A_BOLD}, |
| #endif |
| #if A_ALTCHARSET |
| {"Alternate_Character_Set", A_ALTCHARSET}, |
| #endif |
| #if A_INVIS |
| {"Invisible_Character", A_INVIS}, |
| #endif |
| #if A_PROTECT |
| {"Protected_Character", A_PROTECT}, |
| #endif |
| #if A_HORIZONTAL |
| {"Horizontal", A_HORIZONTAL}, |
| #endif |
| #if A_LEFT |
| {"Left", A_LEFT}, |
| #endif |
| #if A_LOW |
| {"Low", A_LOW}, |
| #endif |
| #if A_RIGHT |
| {"Right", A_RIGHT}, |
| #endif |
| #if A_TOP |
| {"Top", A_TOP}, |
| #endif |
| #if A_VERTICAL |
| {"Vertical", A_VERTICAL}, |
| #endif |
| {(char *)0, 0} |
| }; |
| chtype attr = A_ATTRIBUTES & ~A_COLOR; |
| int start = -1; |
| int len = 0; |
| int i, set; |
| for (i = 0; i < (int)(8 * sizeof(chtype)); i++) |
| |
| { |
| set = attr & 1; |
| if (set) |
| { |
| if (start < 0) |
| start = i; |
| if (start >= 0) |
| { |
| len++; |
| } |
| } |
| attr = attr >> 1; |
| } |
| gen_reps(nap, name, (len + 7) / 8, little_endian ? start : 0); |
| } |
| |
| static void |
| gen_trace(const char *name) |
| { |
| static const name_attribute_pair nap[] = |
| { |
| {"Times", TRACE_TIMES}, |
| {"Tputs", TRACE_TPUTS}, |
| {"Update", TRACE_UPDATE}, |
| {"Cursor_Move", TRACE_MOVE}, |
| {"Character_Output", TRACE_CHARPUT}, |
| {"Calls", TRACE_CALLS}, |
| {"Virtual_Puts", TRACE_VIRTPUT}, |
| {"Input_Events", TRACE_IEVENT}, |
| {"TTY_State", TRACE_BITS}, |
| {"Internal_Calls", TRACE_ICALLS}, |
| {"Character_Calls", TRACE_CCALLS}, |
| {"Termcap_TermInfo", TRACE_DATABASE}, |
| {(char *)0, 0} |
| }; |
| gen_reps(nap, name, sizeof(int), 0); |
| } |
| |
| static void |
| gen_menu_opt_rep(const char *name) |
| { |
| static const name_attribute_pair nap[] = |
| { |
| #ifdef O_ONEVALUE |
| {"One_Valued", O_ONEVALUE}, |
| #endif |
| #ifdef O_SHOWDESC |
| {"Show_Descriptions", O_SHOWDESC}, |
| #endif |
| #ifdef O_ROWMAJOR |
| {"Row_Major_Order", O_ROWMAJOR}, |
| #endif |
| #ifdef O_IGNORECASE |
| {"Ignore_Case", O_IGNORECASE}, |
| #endif |
| #ifdef O_SHOWMATCH |
| {"Show_Matches", O_SHOWMATCH}, |
| #endif |
| #ifdef O_NONCYCLIC |
| {"Non_Cyclic", O_NONCYCLIC}, |
| #endif |
| {(char *)0, 0} |
| }; |
| gen_reps(nap, name, sizeof(int), 0); |
| } |
| |
| static void |
| gen_item_opt_rep(const char *name) |
| { |
| static const name_attribute_pair nap[] = |
| { |
| #ifdef O_SELECTABLE |
| {"Selectable", O_SELECTABLE}, |
| #endif |
| {(char *)0, 0} |
| }; |
| gen_reps(nap, name, sizeof(int), 0); |
| } |
| |
| static void |
| gen_form_opt_rep(const char *name) |
| { |
| static const name_attribute_pair nap[] = |
| { |
| #ifdef O_NL_OVERLOAD |
| {"NL_Overload", O_NL_OVERLOAD}, |
| #endif |
| #ifdef O_BS_OVERLOAD |
| {"BS_Overload", O_BS_OVERLOAD}, |
| #endif |
| {(char *)0, 0} |
| }; |
| gen_reps(nap, name, sizeof(int), 0); |
| } |
| |
| /* |
| * Generate the representation clause for the Field_Option_Set record |
| */ |
| static void |
| gen_field_opt_rep(const char *name) |
| { |
| static const name_attribute_pair nap[] = |
| { |
| #ifdef O_VISIBLE |
| {"Visible", O_VISIBLE}, |
| #endif |
| #ifdef O_ACTIVE |
| {"Active", O_ACTIVE}, |
| #endif |
| #ifdef O_PUBLIC |
| {"Public", O_PUBLIC}, |
| #endif |
| #ifdef O_EDIT |
| {"Edit", O_EDIT}, |
| #endif |
| #ifdef O_WRAP |
| {"Wrap", O_WRAP}, |
| #endif |
| #ifdef O_BLANK |
| {"Blank", O_BLANK}, |
| #endif |
| #ifdef O_AUTOSKIP |
| {"Auto_Skip", O_AUTOSKIP}, |
| #endif |
| #ifdef O_NULLOK |
| {"Null_Ok", O_NULLOK}, |
| #endif |
| #ifdef O_PASSOK |
| {"Pass_Ok", O_PASSOK}, |
| #endif |
| #ifdef O_STATIC |
| {"Static", O_STATIC}, |
| #endif |
| {(char *)0, 0} |
| }; |
| gen_reps(nap, name, sizeof(int), 0); |
| } |
| |
| /* |
| * Generate a single key code constant definition. |
| */ |
| static void |
| keydef(const char *name, const char *old_name, int value, int mode) |
| { |
| if (mode == 0) /* Generate the new name */ |
| printf(" %-30s : constant Special_Key_Code := 8#%3o#;\n", name, value); |
| else |
| { /* generate the old name, but only if it doesn't conflict with the old |
| * name (Ada95 isn't case sensitive!) |
| */ |
| const char *s = old_name; |
| const char *t = name; |
| |
| while (*s && *t && (toupper(*s++) == toupper(*t++))); |
| if (*s || *t) |
| printf(" %-16s : Special_Key_Code renames %s;\n", old_name, name); |
| } |
| } |
| |
| /* |
| * Generate constants for the key codes. When called with mode==0, a |
| * complete list with nice constant names in proper casing style will |
| * be generated. Otherwise a list of old (i.e. C-style) names will be |
| * generated, given that the name wasn't already defined in the "nice" |
| * list. |
| */ |
| static void |
| gen_keydefs(int mode) |
| { |
| char buf[16]; |
| char obuf[16]; |
| int i; |
| |
| #ifdef KEY_CODE_YES |
| keydef("Key_Code_Yes", "KEY_CODE_YES", KEY_CODE_YES, mode); |
| #endif |
| #ifdef KEY_MIN |
| keydef("Key_Min", "KEY_MIN", KEY_MIN, mode); |
| #endif |
| #ifdef KEY_BREAK |
| keydef("Key_Break", "KEY_BREAK", KEY_BREAK, mode); |
| #endif |
| #ifdef KEY_DOWN |
| keydef("Key_Cursor_Down", "KEY_DOWN", KEY_DOWN, mode); |
| #endif |
| #ifdef KEY_UP |
| keydef("Key_Cursor_Up", "KEY_UP", KEY_UP, mode); |
| #endif |
| #ifdef KEY_LEFT |
| keydef("Key_Cursor_Left", "KEY_LEFT", KEY_LEFT, mode); |
| #endif |
| #ifdef KEY_RIGHT |
| keydef("Key_Cursor_Right", "KEY_RIGHT", KEY_RIGHT, mode); |
| #endif |
| #ifdef KEY_HOME |
| keydef("Key_Home", "KEY_HOME", KEY_HOME, mode); |
| #endif |
| #ifdef KEY_BACKSPACE |
| keydef("Key_Backspace", "KEY_BACKSPACE", KEY_BACKSPACE, mode); |
| #endif |
| #ifdef KEY_F0 |
| keydef("Key_F0", "KEY_F0", KEY_F0, mode); |
| #endif |
| #ifdef KEY_F |
| for (i = 1; i <= 24; i++) |
| { |
| sprintf(buf, "Key_F%d", i); |
| sprintf(obuf, "KEY_F%d", i); |
| keydef(buf, obuf, KEY_F(i), mode); |
| } |
| #endif |
| #ifdef KEY_DL |
| keydef("Key_Delete_Line", "KEY_DL", KEY_DL, mode); |
| #endif |
| #ifdef KEY_IL |
| keydef("Key_Insert_Line", "KEY_IL", KEY_IL, mode); |
| #endif |
| #ifdef KEY_DC |
| keydef("Key_Delete_Char", "KEY_DC", KEY_DC, mode); |
| #endif |
| #ifdef KEY_IC |
| keydef("Key_Insert_Char", "KEY_IC", KEY_IC, mode); |
| #endif |
| #ifdef KEY_EIC |
| keydef("Key_Exit_Insert_Mode", "KEY_EIC", KEY_EIC, mode); |
| #endif |
| #ifdef KEY_CLEAR |
| keydef("Key_Clear_Screen", "KEY_CLEAR", KEY_CLEAR, mode); |
| #endif |
| #ifdef KEY_EOS |
| keydef("Key_Clear_End_Of_Screen", "KEY_EOS", KEY_EOS, mode); |
| #endif |
| #ifdef KEY_EOL |
| keydef("Key_Clear_End_Of_Line", "KEY_EOL", KEY_EOL, mode); |
| #endif |
| #ifdef KEY_SF |
| keydef("Key_Scroll_1_Forward", "KEY_SF", KEY_SF, mode); |
| #endif |
| #ifdef KEY_SR |
| keydef("Key_Scroll_1_Backward", "KEY_SR", KEY_SR, mode); |
| #endif |
| #ifdef KEY_NPAGE |
| keydef("Key_Next_Page", "KEY_NPAGE", KEY_NPAGE, mode); |
| #endif |
| #ifdef KEY_PPAGE |
| keydef("Key_Previous_Page", "KEY_PPAGE", KEY_PPAGE, mode); |
| #endif |
| #ifdef KEY_STAB |
| keydef("Key_Set_Tab", "KEY_STAB", KEY_STAB, mode); |
| #endif |
| #ifdef KEY_CTAB |
| keydef("Key_Clear_Tab", "KEY_CTAB", KEY_CTAB, mode); |
| #endif |
| #ifdef KEY_CATAB |
| keydef("Key_Clear_All_Tabs", "KEY_CATAB", KEY_CATAB, mode); |
| #endif |
| #ifdef KEY_ENTER |
| keydef("Key_Enter_Or_Send", "KEY_ENTER", KEY_ENTER, mode); |
| #endif |
| #ifdef KEY_SRESET |
| keydef("Key_Soft_Reset", "KEY_SRESET", KEY_SRESET, mode); |
| #endif |
| #ifdef KEY_RESET |
| keydef("Key_Reset", "KEY_RESET", KEY_RESET, mode); |
| #endif |
| #ifdef KEY_PRINT |
| keydef("Key_Print", "KEY_PRINT", KEY_PRINT, mode); |
| #endif |
| #ifdef KEY_LL |
| keydef("Key_Bottom", "KEY_LL", KEY_LL, mode); |
| #endif |
| #ifdef KEY_A1 |
| keydef("Key_Upper_Left_Of_Keypad", "KEY_A1", KEY_A1, mode); |
| #endif |
| #ifdef KEY_A3 |
| keydef("Key_Upper_Right_Of_Keypad", "KEY_A3", KEY_A3, mode); |
| #endif |
| #ifdef KEY_B2 |
| keydef("Key_Center_Of_Keypad", "KEY_B2", KEY_B2, mode); |
| #endif |
| #ifdef KEY_C1 |
| keydef("Key_Lower_Left_Of_Keypad", "KEY_C1", KEY_C1, mode); |
| #endif |
| #ifdef KEY_C3 |
| keydef("Key_Lower_Right_Of_Keypad", "KEY_C3", KEY_C3, mode); |
| #endif |
| #ifdef KEY_BTAB |
| keydef("Key_Back_Tab", "KEY_BTAB", KEY_BTAB, mode); |
| #endif |
| #ifdef KEY_BEG |
| keydef("Key_Beginning", "KEY_BEG", KEY_BEG, mode); |
| #endif |
| #ifdef KEY_CANCEL |
| keydef("Key_Cancel", "KEY_CANCEL", KEY_CANCEL, mode); |
| #endif |
| #ifdef KEY_CLOSE |
| keydef("Key_Close", "KEY_CLOSE", KEY_CLOSE, mode); |
| #endif |
| #ifdef KEY_COMMAND |
| keydef("Key_Command", "KEY_COMMAND", KEY_COMMAND, mode); |
| #endif |
| #ifdef KEY_COPY |
| keydef("Key_Copy", "KEY_COPY", KEY_COPY, mode); |
| #endif |
| #ifdef KEY_CREATE |
| keydef("Key_Create", "KEY_CREATE", KEY_CREATE, mode); |
| #endif |
| #ifdef KEY_END |
| keydef("Key_End", "KEY_END", KEY_END, mode); |
| #endif |
| #ifdef KEY_EXIT |
| keydef("Key_Exit", "KEY_EXIT", KEY_EXIT, mode); |
| #endif |
| #ifdef KEY_FIND |
| keydef("Key_Find", "KEY_FIND", KEY_FIND, mode); |
| #endif |
| #ifdef KEY_HELP |
| keydef("Key_Help", "KEY_HELP", KEY_HELP, mode); |
| #endif |
| #ifdef KEY_MARK |
| keydef("Key_Mark", "KEY_MARK", KEY_MARK, mode); |
| #endif |
| #ifdef KEY_MESSAGE |
| keydef("Key_Message", "KEY_MESSAGE", KEY_MESSAGE, mode); |
| #endif |
| #ifdef KEY_MOVE |
| keydef("Key_Move", "KEY_MOVE", KEY_MOVE, mode); |
| #endif |
| #ifdef KEY_NEXT |
| keydef("Key_Next", "KEY_NEXT", KEY_NEXT, mode); |
| #endif |
| #ifdef KEY_OPEN |
| keydef("Key_Open", "KEY_OPEN", KEY_OPEN, mode); |
| #endif |
| #ifdef KEY_OPTIONS |
| keydef("Key_Options", "KEY_OPTIONS", KEY_OPTIONS, mode); |
| #endif |
| #ifdef KEY_PREVIOUS |
| keydef("Key_Previous", "KEY_PREVIOUS", KEY_PREVIOUS, mode); |
| #endif |
| #ifdef KEY_REDO |
| keydef("Key_Redo", "KEY_REDO", KEY_REDO, mode); |
| #endif |
| #ifdef KEY_REFERENCE |
| keydef("Key_Reference", "KEY_REFERENCE", KEY_REFERENCE, mode); |
| #endif |
| #ifdef KEY_REFRESH |
| keydef("Key_Refresh", "KEY_REFRESH", KEY_REFRESH, mode); |
| #endif |
| #ifdef KEY_REPLACE |
| keydef("Key_Replace", "KEY_REPLACE", KEY_REPLACE, mode); |
| #endif |
| #ifdef KEY_RESTART |
| keydef("Key_Restart", "KEY_RESTART", KEY_RESTART, mode); |
| #endif |
| #ifdef KEY_RESUME |
| keydef("Key_Resume", "KEY_RESUME", KEY_RESUME, mode); |
| #endif |
| #ifdef KEY_SAVE |
| keydef("Key_Save", "KEY_SAVE", KEY_SAVE, mode); |
| #endif |
| #ifdef KEY_SBEG |
| keydef("Key_Shift_Begin", "KEY_SBEG", KEY_SBEG, mode); |
| #endif |
| #ifdef KEY_SCANCEL |
| keydef("Key_Shift_Cancel", "KEY_SCANCEL", KEY_SCANCEL, mode); |
| #endif |
| #ifdef KEY_SCOMMAND |
| keydef("Key_Shift_Command", "KEY_SCOMMAND", KEY_SCOMMAND, mode); |
| #endif |
| #ifdef KEY_SCOPY |
| keydef("Key_Shift_Copy", "KEY_SCOPY", KEY_SCOPY, mode); |
| #endif |
| #ifdef KEY_SCREATE |
| keydef("Key_Shift_Create", "KEY_SCREATE", KEY_SCREATE, mode); |
| #endif |
| #ifdef KEY_SDC |
| keydef("Key_Shift_Delete_Char", "KEY_SDC", KEY_SDC, mode); |
| #endif |
| #ifdef KEY_SDL |
| keydef("Key_Shift_Delete_Line", "KEY_SDL", KEY_SDL, mode); |
| #endif |
| #ifdef KEY_SELECT |
| keydef("Key_Select", "KEY_SELECT", KEY_SELECT, mode); |
| #endif |
| #ifdef KEY_SEND |
| keydef("Key_Shift_End", "KEY_SEND", KEY_SEND, mode); |
| #endif |
| #ifdef KEY_SEOL |
| keydef("Key_Shift_Clear_End_Of_Line", "KEY_SEOL", KEY_SEOL, mode); |
| #endif |
| #ifdef KEY_SEXIT |
| keydef("Key_Shift_Exit", "KEY_SEXIT", KEY_SEXIT, mode); |
| #endif |
| #ifdef KEY_SFIND |
| keydef("Key_Shift_Find", "KEY_SFIND", KEY_SFIND, mode); |
| #endif |
| #ifdef KEY_SHELP |
| keydef("Key_Shift_Help", "KEY_SHELP", KEY_SHELP, mode); |
| #endif |
| #ifdef KEY_SHOME |
| keydef("Key_Shift_Home", "KEY_SHOME", KEY_SHOME, mode); |
| #endif |
| #ifdef KEY_SIC |
| keydef("Key_Shift_Insert_Char", "KEY_SIC", KEY_SIC, mode); |
| #endif |
| #ifdef KEY_SLEFT |
| keydef("Key_Shift_Cursor_Left", "KEY_SLEFT", KEY_SLEFT, mode); |
| #endif |
| #ifdef KEY_SMESSAGE |
| keydef("Key_Shift_Message", "KEY_SMESSAGE", KEY_SMESSAGE, mode); |
| #endif |
| #ifdef KEY_SMOVE |
| keydef("Key_Shift_Move", "KEY_SMOVE", KEY_SMOVE, mode); |
| #endif |
| #ifdef KEY_SNEXT |
| keydef("Key_Shift_Next_Page", "KEY_SNEXT", KEY_SNEXT, mode); |
| #endif |
| #ifdef KEY_SOPTIONS |
| keydef("Key_Shift_Options", "KEY_SOPTIONS", KEY_SOPTIONS, mode); |
| #endif |
| #ifdef KEY_SPREVIOUS |
| keydef("Key_Shift_Previous_Page", "KEY_SPREVIOUS", KEY_SPREVIOUS, mode); |
| #endif |
| #ifdef KEY_SPRINT |
| keydef("Key_Shift_Print", "KEY_SPRINT", KEY_SPRINT, mode); |
| #endif |
| #ifdef KEY_SREDO |
| keydef("Key_Shift_Redo", "KEY_SREDO", KEY_SREDO, mode); |
| #endif |
| #ifdef KEY_SREPLACE |
| keydef("Key_Shift_Replace", "KEY_SREPLACE", KEY_SREPLACE, mode); |
| #endif |
| #ifdef KEY_SRIGHT |
| keydef("Key_Shift_Cursor_Right", "KEY_SRIGHT", KEY_SRIGHT, mode); |
| #endif |
| #ifdef KEY_SRSUME |
| keydef("Key_Shift_Resume", "KEY_SRSUME", KEY_SRSUME, mode); |
| #endif |
| #ifdef KEY_SSAVE |
| keydef("Key_Shift_Save", "KEY_SSAVE", KEY_SSAVE, mode); |
| #endif |
| #ifdef KEY_SSUSPEND |
| keydef("Key_Shift_Suspend", "KEY_SSUSPEND", KEY_SSUSPEND, mode); |
| #endif |
| #ifdef KEY_SUNDO |
| keydef("Key_Shift_Undo", "KEY_SUNDO", KEY_SUNDO, mode); |
| #endif |
| #ifdef KEY_SUSPEND |
| keydef("Key_Suspend", "KEY_SUSPEND", KEY_SUSPEND, mode); |
| #endif |
| #ifdef KEY_UNDO |
| keydef("Key_Undo", "KEY_UNDO", KEY_UNDO, mode); |
| #endif |
| #ifdef KEY_MOUSE |
| keydef("Key_Mouse", "KEY_MOUSE", KEY_MOUSE, mode); |
| #endif |
| #ifdef KEY_RESIZE |
| keydef("Key_Resize", "KEY_RESIZE", KEY_RESIZE, mode); |
| #endif |
| } |
| |
| /* |
| * Generate a constant with the given name. The second parameter |
| * is a reference to the ACS character in the acs_map[] array and |
| * will be translated into an index. |
| */ |
| static void |
| acs_def(const char *name, chtype *a) |
| { |
| int c = a - &acs_map[0]; |
| |
| printf(" %-24s : constant Character := ", name); |
| if (isprint(c) && (c != '`')) |
| printf("'%c';\n", c); |
| else |
| printf("Character'Val (%d);\n", c); |
| } |
| |
| /* |
| * Generate the constants for the ACS characters |
| */ |
| static void |
| gen_acs(void) |
| { |
| printf(" type C_ACS_Map is array (Character'Val (0) .. Character'Val (127))\n"); |
| printf(" of Attributed_Character;\n"); |
| #if USE_REENTRANT || BROKEN_LINKER |
| printf(" type C_ACS_Ptr is access C_ACS_Map;\n"); |
| printf(" function ACS_Map return C_ACS_Ptr;\n"); |
| printf(" pragma Import (C, ACS_Map, \"_nc_acs_map\");\n"); |
| #else |
| printf(" ACS_Map : C_ACS_Map;\n"); |
| printf(" pragma Import (C, ACS_Map, \"acs_map\");\n"); |
| #endif |
| printf(" --\n"); |
| printf(" --\n"); |
| printf(" -- Constants for several characters from the Alternate Character Set\n"); |
| printf(" -- You must use these constants as indices into the ACS_Map array\n"); |
| printf(" -- to get the corresponding attributed character at runtime.\n"); |
| printf(" --\n"); |
| |
| #ifdef ACS_ULCORNER |
| acs_def("ACS_Upper_Left_Corner", &ACS_ULCORNER); |
| #endif |
| #ifdef ACS_LLCORNER |
| acs_def("ACS_Lower_Left_Corner", &ACS_LLCORNER); |
| #endif |
| #ifdef ACS_URCORNER |
| acs_def("ACS_Upper_Right_Corner", &ACS_URCORNER); |
| #endif |
| #ifdef ACS_LRCORNER |
| acs_def("ACS_Lower_Right_Corner", &ACS_LRCORNER); |
| #endif |
| #ifdef ACS_LTEE |
| acs_def("ACS_Left_Tee", &ACS_LTEE); |
| #endif |
| #ifdef ACS_RTEE |
| acs_def("ACS_Right_Tee", &ACS_RTEE); |
| #endif |
| #ifdef ACS_BTEE |
| acs_def("ACS_Bottom_Tee", &ACS_BTEE); |
| #endif |
| #ifdef ACS_TTEE |
| acs_def("ACS_Top_Tee", &ACS_TTEE); |
| #endif |
| #ifdef ACS_HLINE |
| acs_def("ACS_Horizontal_Line", &ACS_HLINE); |
| #endif |
| #ifdef ACS_VLINE |
| acs_def("ACS_Vertical_Line", &ACS_VLINE); |
| #endif |
| #ifdef ACS_PLUS |
| acs_def("ACS_Plus_Symbol", &ACS_PLUS); |
| #endif |
| #ifdef ACS_S1 |
| acs_def("ACS_Scan_Line_1", &ACS_S1); |
| #endif |
| #ifdef ACS_S9 |
| acs_def("ACS_Scan_Line_9", &ACS_S9); |
| #endif |
| #ifdef ACS_DIAMOND |
| acs_def("ACS_Diamond", &ACS_DIAMOND); |
| #endif |
| #ifdef ACS_CKBOARD |
| acs_def("ACS_Checker_Board", &ACS_CKBOARD); |
| #endif |
| #ifdef ACS_DEGREE |
| acs_def("ACS_Degree", &ACS_DEGREE); |
| #endif |
| #ifdef ACS_PLMINUS |
| acs_def("ACS_Plus_Minus", &ACS_PLMINUS); |
| #endif |
| #ifdef ACS_BULLET |
| acs_def("ACS_Bullet", &ACS_BULLET); |
| #endif |
| #ifdef ACS_LARROW |
| acs_def("ACS_Left_Arrow", &ACS_LARROW); |
| #endif |
| #ifdef ACS_RARROW |
| acs_def("ACS_Right_Arrow", &ACS_RARROW); |
| #endif |
| #ifdef ACS_DARROW |
| acs_def("ACS_Down_Arrow", &ACS_DARROW); |
| #endif |
| #ifdef ACS_UARROW |
| acs_def("ACS_Up_Arrow", &ACS_UARROW); |
| #endif |
| #ifdef ACS_BOARD |
| acs_def("ACS_Board_Of_Squares", &ACS_BOARD); |
| #endif |
| #ifdef ACS_LANTERN |
| acs_def("ACS_Lantern", &ACS_LANTERN); |
| #endif |
| #ifdef ACS_BLOCK |
| acs_def("ACS_Solid_Block", &ACS_BLOCK); |
| #endif |
| #ifdef ACS_S3 |
| acs_def("ACS_Scan_Line_3", &ACS_S3); |
| #endif |
| #ifdef ACS_S7 |
| acs_def("ACS_Scan_Line_7", &ACS_S7); |
| #endif |
| #ifdef ACS_LEQUAL |
| acs_def("ACS_Less_Or_Equal", &ACS_LEQUAL); |
| #endif |
| #ifdef ACS_GEQUAL |
| acs_def("ACS_Greater_Or_Equal", &ACS_GEQUAL); |
| #endif |
| #ifdef ACS_PI |
| acs_def("ACS_PI", &ACS_PI); |
| #endif |
| #ifdef ACS_NEQUAL |
| acs_def("ACS_Not_Equal", &ACS_NEQUAL); |
| #endif |
| #ifdef ACS_STERLING |
| acs_def("ACS_Sterling", &ACS_STERLING); |
| #endif |
| } |
| |
| #define GEN_EVENT(name,value) \ |
| printf(" %-25s : constant Event_Mask := 8#%011lo#;\n", \ |
| #name, value) |
| |
| #define GEN_MEVENT(name) \ |
| printf(" %-25s : constant Event_Mask := 8#%011lo#;\n", \ |
| #name, name) |
| |
| static void |
| gen_mouse_events(void) |
| { |
| mmask_t all1 = 0; |
| mmask_t all2 = 0; |
| mmask_t all3 = 0; |
| mmask_t all4 = 0; |
| |
| #ifdef BUTTON1_RELEASED |
| GEN_MEVENT(BUTTON1_RELEASED); |
| all1 |= BUTTON1_RELEASED; |
| #endif |
| #ifdef BUTTON1_PRESSED |
| GEN_MEVENT(BUTTON1_PRESSED); |
| all1 |= BUTTON1_PRESSED; |
| #endif |
| #ifdef BUTTON1_CLICKED |
| GEN_MEVENT(BUTTON1_CLICKED); |
| all1 |= BUTTON1_CLICKED; |
| #endif |
| #ifdef BUTTON1_DOUBLE_CLICKED |
| GEN_MEVENT(BUTTON1_DOUBLE_CLICKED); |
| all1 |= BUTTON1_DOUBLE_CLICKED; |
| #endif |
| #ifdef BUTTON1_TRIPLE_CLICKED |
| GEN_MEVENT(BUTTON1_TRIPLE_CLICKED); |
| all1 |= BUTTON1_TRIPLE_CLICKED; |
| #endif |
| #ifdef BUTTON1_RESERVED_EVENT |
| GEN_MEVENT(BUTTON1_RESERVED_EVENT); |
| all1 |= BUTTON1_RESERVED_EVENT; |
| #endif |
| #ifdef BUTTON2_RELEASED |
| GEN_MEVENT(BUTTON2_RELEASED); |
| all2 |= BUTTON2_RELEASED; |
| #endif |
| #ifdef BUTTON2_PRESSED |
| GEN_MEVENT(BUTTON2_PRESSED); |
| all2 |= BUTTON2_PRESSED; |
| #endif |
| #ifdef BUTTON2_CLICKED |
| GEN_MEVENT(BUTTON2_CLICKED); |
| all2 |= BUTTON2_CLICKED; |
| #endif |
| #ifdef BUTTON2_DOUBLE_CLICKED |
| GEN_MEVENT(BUTTON2_DOUBLE_CLICKED); |
| all2 |= BUTTON2_DOUBLE_CLICKED; |
| #endif |
| #ifdef BUTTON2_TRIPLE_CLICKED |
| GEN_MEVENT(BUTTON2_TRIPLE_CLICKED); |
| all2 |= BUTTON2_TRIPLE_CLICKED; |
| #endif |
| #ifdef BUTTON2_RESERVED_EVENT |
| GEN_MEVENT(BUTTON2_RESERVED_EVENT); |
| all2 |= BUTTON2_RESERVED_EVENT; |
| #endif |
| #ifdef BUTTON3_RELEASED |
| GEN_MEVENT(BUTTON3_RELEASED); |
| all3 |= BUTTON3_RELEASED; |
| #endif |
| #ifdef BUTTON3_PRESSED |
| GEN_MEVENT(BUTTON3_PRESSED); |
| all3 |= BUTTON3_PRESSED; |
| #endif |
| #ifdef BUTTON3_CLICKED |
| GEN_MEVENT(BUTTON3_CLICKED); |
| all3 |= BUTTON3_CLICKED; |
| #endif |
| #ifdef BUTTON3_DOUBLE_CLICKED |
| GEN_MEVENT(BUTTON3_DOUBLE_CLICKED); |
| all3 |= BUTTON3_DOUBLE_CLICKED; |
| #endif |
| #ifdef BUTTON3_TRIPLE_CLICKED |
| GEN_MEVENT(BUTTON3_TRIPLE_CLICKED); |
| all3 |= BUTTON3_TRIPLE_CLICKED; |
| #endif |
| #ifdef BUTTON3_RESERVED_EVENT |
| GEN_MEVENT(BUTTON3_RESERVED_EVENT); |
| all3 |= BUTTON3_RESERVED_EVENT; |
| #endif |
| #ifdef BUTTON4_RELEASED |
| GEN_MEVENT(BUTTON4_RELEASED); |
| all4 |= BUTTON4_RELEASED; |
| #endif |
| #ifdef BUTTON4_PRESSED |
| GEN_MEVENT(BUTTON4_PRESSED); |
| all4 |= BUTTON4_PRESSED; |
| #endif |
| #ifdef BUTTON4_CLICKED |
| GEN_MEVENT(BUTTON4_CLICKED); |
| all4 |= BUTTON4_CLICKED; |
| #endif |
| #ifdef BUTTON4_DOUBLE_CLICKED |
| GEN_MEVENT(BUTTON4_DOUBLE_CLICKED); |
| all4 |= BUTTON4_DOUBLE_CLICKED; |
| #endif |
| #ifdef BUTTON4_TRIPLE_CLICKED |
| GEN_MEVENT(BUTTON4_TRIPLE_CLICKED); |
| all4 |= BUTTON4_TRIPLE_CLICKED; |
| #endif |
| #ifdef BUTTON4_RESERVED_EVENT |
| GEN_MEVENT(BUTTON4_RESERVED_EVENT); |
| all4 |= BUTTON4_RESERVED_EVENT; |
| #endif |
| #ifdef BUTTON_CTRL |
| GEN_MEVENT(BUTTON_CTRL); |
| #endif |
| #ifdef BUTTON_SHIFT |
| GEN_MEVENT(BUTTON_SHIFT); |
| #endif |
| #ifdef BUTTON_ALT |
| GEN_MEVENT(BUTTON_ALT); |
| #endif |
| #ifdef REPORT_MOUSE_POSITION |
| GEN_MEVENT(REPORT_MOUSE_POSITION); |
| #endif |
| #ifdef ALL_MOUSE_EVENTS |
| GEN_MEVENT(ALL_MOUSE_EVENTS); |
| #endif |
| |
| GEN_EVENT(BUTTON1_EVENTS, all1); |
| GEN_EVENT(BUTTON2_EVENTS, all2); |
| GEN_EVENT(BUTTON3_EVENTS, all3); |
| GEN_EVENT(BUTTON4_EVENTS, all4); |
| } |
| |
| static void |
| wrap_one_var(const char *c_var, |
| const char *c_type, |
| const char *ada_func, |
| const char *ada_type) |
| { |
| #if USE_REENTRANT |
| /* must wrap variables */ |
| printf("\n"); |
| printf(" function %s return %s\n", ada_func, ada_type); |
| printf(" is\n"); |
| printf(" function Result return %s;\n", c_type); |
| printf(" pragma Import (C, Result, \"_nc_%s\");\n", c_var); |
| printf(" begin\n"); |
| if (strcmp(c_type, ada_type)) |
| printf(" return %s (Result);\n", ada_type); |
| else |
| printf(" return Result;\n"); |
| printf(" end %s;\n", ada_func); |
| #else |
| /* global variables are really global */ |
| printf("\n"); |
| printf(" function %s return %s\n", ada_func, ada_type); |
| printf(" is\n"); |
| printf(" Result : %s;\n", c_type); |
| printf(" pragma Import (C, Result, \"%s\");\n", c_var); |
| printf(" begin\n"); |
| if (strcmp(c_type, ada_type)) |
| printf(" return %s (Result);\n", ada_type); |
| else |
| printf(" return Result;\n"); |
| printf(" end %s;\n", ada_func); |
| #endif |
| } |
| |
| #define GEN_PUBLIC_VAR(c_var, c_type, ada_func, ada_type) \ |
| wrap_one_var(#c_var, #c_type, #ada_func, #ada_type) |
| |
| static void |
| gen_public_vars(void) |
| { |
| GEN_PUBLIC_VAR(stdscr, Window, Standard_Window, Window); |
| GEN_PUBLIC_VAR(curscr, Window, Current_Window, Window); |
| GEN_PUBLIC_VAR(LINES, C_Int, Lines, Line_Count); |
| GEN_PUBLIC_VAR(COLS, C_Int, Columns, Column_Count); |
| GEN_PUBLIC_VAR(TABSIZE, C_Int, Tab_Size, Natural); |
| GEN_PUBLIC_VAR(COLORS, C_Int, Number_Of_Colors, Natural); |
| GEN_PUBLIC_VAR(COLOR_PAIRS, C_Int, Number_Of_Color_Pairs, Natural); |
| } |
| |
| /* |
| * Output some comment lines indicating that the file is generated. |
| * The name parameter is the name of the facility to be used in |
| * the comment. |
| */ |
| static void |
| prologue(const char *name) |
| { |
| printf("-- %s binding.\n", name); |
| printf("-- This module is generated. Please don't change it manually!\n"); |
| printf("-- Run the generator instead.\n-- |"); |
| |
| printf("define(`M4_BIT_ORDER',`%s_Order_First')", |
| little_endian ? "Low" : "High"); |
| } |
| |
| /* |
| * Write the prologue for the curses facility and make sure that |
| * KEY_MIN and KEY_MAX are defined for the rest of this source. |
| */ |
| static void |
| basedefs(void) |
| { |
| prologue("curses"); |
| #ifndef KEY_MAX |
| # define KEY_MAX 0777 |
| #endif |
| printf("define(`M4_KEY_MAX',`8#%o#')", KEY_MAX); |
| #ifndef KEY_MIN |
| # define KEY_MIN 0401 |
| #endif |
| if (KEY_MIN == 256) |
| { |
| fprintf(stderr, "Unexpected value for KEY_MIN: %d\n", KEY_MIN); |
| exit(1); |
| } |
| printf("define(`M4_SPECIAL_FIRST',`8#%o#')", KEY_MIN - 1); |
| } |
| |
| /* |
| * Write out the comment lines for the menu facility |
| */ |
| static void |
| menu_basedefs(void) |
| { |
| prologue("menu"); |
| } |
| |
| /* |
| * Write out the comment lines for the form facility |
| */ |
| static void |
| form_basedefs(void) |
| { |
| prologue("form"); |
| } |
| |
| /* |
| * Write out the comment lines for the mouse facility |
| */ |
| static void |
| mouse_basedefs(void) |
| { |
| prologue("mouse"); |
| } |
| |
| /* |
| * Write the definition of a single color |
| */ |
| static void |
| color_def(const char *name, int value) |
| { |
| printf(" %-16s : constant Color_Number := %d;\n", name, value); |
| } |
| |
| /* |
| * Generate all color definitions |
| */ |
| static void |
| gen_color(void) |
| { |
| #if HAVE_USE_DEFAULT_COLORS |
| color_def("Default_Color", -1); |
| #endif |
| #ifdef COLOR_BLACK |
| color_def("Black", COLOR_BLACK); |
| #endif |
| #ifdef COLOR_RED |
| color_def("Red", COLOR_RED); |
| #endif |
| #ifdef COLOR_GREEN |
| color_def("Green", COLOR_GREEN); |
| #endif |
| #ifdef COLOR_YELLOW |
| color_def("Yellow", COLOR_YELLOW); |
| #endif |
| #ifdef COLOR_BLUE |
| color_def("Blue", COLOR_BLUE); |
| #endif |
| #ifdef COLOR_MAGENTA |
| color_def("Magenta", COLOR_MAGENTA); |
| #endif |
| #ifdef COLOR_CYAN |
| color_def("Cyan", COLOR_CYAN); |
| #endif |
| #ifdef COLOR_WHITE |
| color_def("White", COLOR_WHITE); |
| #endif |
| } |
| |
| /* |
| * Generate the linker options for the base facility |
| */ |
| static void |
| gen_linkopts(void) |
| { |
| printf(" pragma Linker_Options (\"-lncurses%s\");\n", model); |
| } |
| |
| /* |
| * Generate the linker options for the menu facility |
| */ |
| static void |
| gen_menu_linkopts(void) |
| { |
| printf(" pragma Linker_Options (\"-lmenu%s\");\n", model); |
| } |
| |
| /* |
| * Generate the linker options for the form facility |
| */ |
| static void |
| gen_form_linkopts(void) |
| { |
| printf(" pragma Linker_Options (\"-lform%s\");\n", model); |
| } |
| |
| /* |
| * Generate the linker options for the panel facility |
| */ |
| static void |
| gen_panel_linkopts(void) |
| { |
| printf(" pragma Linker_Options (\"-lpanel%s\");\n", model); |
| } |
| |
| static void |
| gen_version_info(void) |
| { |
| static const char *v1 = |
| " NC_Major_Version : constant := %d; -- Major version of the library\n"; |
| static const char *v2 = |
| " NC_Minor_Version : constant := %d; -- Minor version of the library\n"; |
| static const char *v3 = |
| " NC_Version : constant String := %c%d.%d%c; -- Version of library\n"; |
| |
| printf(v1, NCURSES_VERSION_MAJOR); |
| printf(v2, NCURSES_VERSION_MINOR); |
| printf(v3, '"', NCURSES_VERSION_MAJOR, NCURSES_VERSION_MINOR, '"'); |
| } |
| |
| static int |
| eti_gen(char *buf, int code, const char *name, int *etimin, int *etimax) |
| { |
| sprintf(buf, " E_%-16s : constant Eti_Error := %d;\n", name, code); |
| if (code < *etimin) |
| *etimin = code; |
| if (code > *etimax) |
| *etimax = code; |
| return strlen(buf); |
| } |
| |
| static void |
| gen_offsets(void) |
| { |
| const char *s_bool = ""; |
| |
| if (sizeof(bool) == sizeof(char)) |
| { |
| s_bool = "char"; |
| } |
| else if (sizeof(bool) == sizeof(short)) |
| { |
| s_bool = "short"; |
| } |
| else if (sizeof(bool) == sizeof(int)) |
| { |
| s_bool = "int"; |
| } |
| printf(" Sizeof%-*s : constant Natural := %2ld; -- %s\n", |
| 12, "_bool", (long)sizeof(bool), "bool"); |
| |
| /* In ncurses _maxy and _maxx needs an offset for the "public" |
| * value |
| */ |
| printf(" Offset%-*s : constant Natural := %2d; -- %s\n", |
| 12, "_XY", 1, "int"); |
| printf("\n"); |
| printf(" type Curses_Bool is mod 2 ** Interfaces.C.%s'Size;\n", s_bool); |
| } |
| |
| /* |
| * main() expects two arguments on the commandline, both single characters. |
| * The first character denotes the facility for which we generate output. |
| * Possible values are |
| * B - Base |
| * M - Menus |
| * F - Forms |
| * P - Pointer Device (Mouse) |
| * E - ETI base definitions |
| * |
| * The second character then denotes the specific output that should be |
| * generated for the selected facility. |
| */ |
| int |
| main(int argc, char *argv[]) |
| { |
| int x = 0x12345678; |
| char *s = (char *)&x; |
| |
| if (*s == 0x78) |
| little_endian = 1; |
| |
| if (argc != 4) |
| exit(1); |
| model = *++argv; |
| |
| switch (argv[1][0]) |
| { |
| /* --------------------------------------------------------------- */ |
| case 'B': /* The Base facility */ |
| switch (argv[2][0]) |
| { |
| case 'A': /* chtype translation into Ada95 record type */ |
| gen_attr_set("Character_Attribute_Set"); |
| break; |
| case 'B': /* write some initial comment lines */ |
| basedefs(); |
| break; |
| case 'C': /* generate color constants */ |
| gen_color(); |
| break; |
| case 'D': /* generate displacements of fields in WINDOW struct. */ |
| gen_offsets(); |
| break; |
| case 'E': /* generate Mouse Event codes */ |
| gen_mouse_events(); |
| break; |
| case 'K': /* translation of keycodes */ |
| gen_keydefs(0); |
| break; |
| case 'L': /* generate the Linker_Options pragma */ |
| gen_linkopts(); |
| break; |
| case 'M': /* generate constants for the ACS characters */ |
| gen_acs(); |
| break; |
| case 'O': /* generate definitions of the old key code names */ |
| gen_keydefs(1); |
| break; |
| case 'P': /* generate definitions of the public variables */ |
| gen_public_vars(); |
| break; |
| case 'R': /* generate representation clause for Attributed character */ |
| gen_chtype_rep("Attributed_Character"); |
| break; |
| case 'T': /* generate the Trace info */ |
| gen_trace("Trace_Attribute_Set"); |
| break; |
| case 'V': /* generate version info */ |
| gen_version_info(); |
| break; |
| default: |
| break; |
| } |
| break; |
| /* --------------------------------------------------------------- */ |
| case 'M': /* The Menu facility */ |
| switch (argv[2][0]) |
| { |
| case 'R': /* generate representation clause for Menu_Option_Set */ |
| gen_menu_opt_rep("Menu_Option_Set"); |
| break; |
| case 'B': /* write some initial comment lines */ |
| menu_basedefs(); |
| break; |
| case 'L': /* generate the Linker_Options pragma */ |
| gen_menu_linkopts(); |
| break; |
| case 'I': /* generate representation clause for Item_Option_Set */ |
| gen_item_opt_rep("Item_Option_Set"); |
| break; |
| default: |
| break; |
| } |
| break; |
| /* --------------------------------------------------------------- */ |
| case 'F': /* The Form facility */ |
| switch (argv[2][0]) |
| { |
| case 'R': /* generate representation clause for Form_Option_Set */ |
| gen_form_opt_rep("Form_Option_Set"); |
| break; |
| case 'B': /* write some initial comment lines */ |
| form_basedefs(); |
| break; |
| case 'L': /* generate the Linker_Options pragma */ |
| gen_form_linkopts(); |
| break; |
| case 'I': /* generate representation clause for Field_Option_Set */ |
| gen_field_opt_rep("Field_Option_Set"); |
| break; |
| default: |
| break; |
| } |
| break; |
| /* --------------------------------------------------------------- */ |
| case 'P': /* The Pointer(=Mouse) facility */ |
| switch (argv[2][0]) |
| { |
| case 'B': /* write some initial comment lines */ |
| mouse_basedefs(); |
| break; |
| case 'M': /* generate representation clause for Mouse_Event */ |
| gen_mrep_rep("Mouse_Event"); |
| break; |
| case 'L': /* generate the Linker_Options pragma */ |
| gen_panel_linkopts(); |
| break; |
| default: |
| break; |
| } |
| break; |
| /* --------------------------------------------------------------- */ |
| case 'E': /* chtype size detection */ |
| switch (argv[2][0]) |
| { |
| case 'C': |
| { |
| const char *fmt = " type C_Chtype is new %s;\n"; |
| const char *afmt = " type C_AttrType is new %s;\n"; |
| |
| if (sizeof(chtype) == sizeof(int)) |
| { |
| if (sizeof(int) == sizeof(long)) |
| printf(fmt, "C_ULong"); |
| |
| else |
| printf(fmt, "C_UInt"); |
| } |
| else if (sizeof(chtype) == sizeof(long)) |
| { |
| printf(fmt, "C_ULong"); |
| } |
| else |
| printf("Error\n"); |
| |
| if (sizeof(attr_t) == sizeof(int)) |
| { |
| if (sizeof(int) == sizeof(long)) |
| printf(afmt, "C_ULong"); |
| |
| else |
| printf(afmt, "C_UInt"); |
| } |
| else if (sizeof(attr_t) == sizeof(long)) |
| { |
| printf(afmt, "C_ULong"); |
| } |
| else |
| printf("Error\n"); |
| |
| printf("define(`CF_CURSES_OK',`%d')", OK); |
| printf("define(`CF_CURSES_ERR',`%d')", ERR); |
| printf("define(`CF_CURSES_TRUE',`%d')", TRUE); |
| printf("define(`CF_CURSES_FALSE',`%d')", FALSE); |
| } |
| break; |
| case 'E': |
| { |
| char *buf = (char *)malloc(2048); |
| char *p = buf; |
| int etimin = E_OK; |
| int etimax = E_OK; |
| |
| if (p) |
| { |
| p += eti_gen(p, E_OK, "Ok", &etimin, &etimax); |
| p += eti_gen(p, E_SYSTEM_ERROR, "System_Error", &etimin, &etimax); |
| p += eti_gen(p, E_BAD_ARGUMENT, "Bad_Argument", &etimin, &etimax); |
| p += eti_gen(p, E_POSTED, "Posted", &etimin, &etimax); |
| p += eti_gen(p, E_CONNECTED, "Connected", &etimin, &etimax); |
| p += eti_gen(p, E_BAD_STATE, "Bad_State", &etimin, &etimax); |
| p += eti_gen(p, E_NO_ROOM, "No_Room", &etimin, &etimax); |
| p += eti_gen(p, E_NOT_POSTED, "Not_Posted", &etimin, &etimax); |
| p += eti_gen(p, E_UNKNOWN_COMMAND, |
| "Unknown_Command", &etimin, &etimax); |
| p += eti_gen(p, E_NO_MATCH, "No_Match", &etimin, &etimax); |
| p += eti_gen(p, E_NOT_SELECTABLE, |
| "Not_Selectable", &etimin, &etimax); |
| p += eti_gen(p, E_NOT_CONNECTED, |
| "Not_Connected", &etimin, &etimax); |
| p += eti_gen(p, E_REQUEST_DENIED, |
| "Request_Denied", &etimin, &etimax); |
| p += eti_gen(p, E_INVALID_FIELD, |
| "Invalid_Field", &etimin, &etimax); |
| p += eti_gen(p, E_CURRENT, |
| "Current", &etimin, &etimax); |
| } |
| printf(" subtype Eti_Error is C_Int range %d .. %d;\n\n", |
| etimin, etimax); |
| printf(buf); |
| } |
| break; |
| default: |
| break; |
| } |
| break; |
| /* --------------------------------------------------------------- */ |
| case 'V': /* plain version dump */ |
| { |
| switch (argv[2][0]) |
| { |
| case '1': /* major version */ |
| #ifdef NCURSES_VERSION_MAJOR |
| printf("%d", NCURSES_VERSION_MAJOR); |
| #endif |
| break; |
| case '2': /* minor version */ |
| #ifdef NCURSES_VERSION_MINOR |
| printf("%d", NCURSES_VERSION_MINOR); |
| #endif |
| break; |
| case '3': /* patch level */ |
| #ifdef NCURSES_VERSION_PATCH |
| printf("%d", NCURSES_VERSION_PATCH); |
| #endif |
| break; |
| default: |
| break; |
| } |
| } |
| break; |
| /* --------------------------------------------------------------- */ |
| default: |
| break; |
| } |
| return 0; |
| } |
