text: /****************************************************************************
   * Copyright (c) 1998,2004,2005 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.40 2005/01/22 17:03:48 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 <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)
  {
  #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);
  }
  
  /*
   * 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);
  }
  
  #define HAVE_USE_DEFAULT_COLORS 1
  
  /*
   * Generate all color definitions
   */
  static void
  gen_color(void)
  {
  #ifdef 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);
  }
  
  #define GEN_OFFSET(member,itype)                                    \
    if (sizeof(((WINDOW*)0)->member)==sizeof(itype)) {                \
      o = offsetof(WINDOW, member);                                   \
      if ((o%sizeof(itype) == 0)) {                                   \
         printf("   Offset%-*s : constant Natural := %2ld; --  %s\n", \
                12, #member, (long)(o/sizeof(itype)),#itype);         \
      }                                                               \
    }
  
  static void
  gen_offsets(void)
  {
    long o;
    const char *s_bool = "";
  
    GEN_OFFSET(_maxy, short);
    GEN_OFFSET(_maxx, short);
    GEN_OFFSET(_begy, short);
    GEN_OFFSET(_begx, short);
    GEN_OFFSET(_cury, short);
    GEN_OFFSET(_curx, short);
    GEN_OFFSET(_yoffset, short);
    GEN_OFFSET(_pary, int);
    GEN_OFFSET(_parx, int);
    if (sizeof(bool) == sizeof(char))
      {
        GEN_OFFSET(_notimeout, char);
        GEN_OFFSET(_clear, char);
        GEN_OFFSET(_leaveok, char);
        GEN_OFFSET(_scroll, char);
        GEN_OFFSET(_idlok, char);
        GEN_OFFSET(_idcok, char);
        GEN_OFFSET(_immed, char);
        GEN_OFFSET(_sync, char);
        GEN_OFFSET(_use_keypad, char);
  
        s_bool = "char";
      }
    else if (sizeof(bool) == sizeof(short))
      {
        GEN_OFFSET(_notimeout, short);
        GEN_OFFSET(_clear, short);
        GEN_OFFSET(_leaveok, short);
        GEN_OFFSET(_scroll, short);
        GEN_OFFSET(_idlok, short);
        GEN_OFFSET(_idcok, short);
        GEN_OFFSET(_immed, short);
        GEN_OFFSET(_sync, short);
        GEN_OFFSET(_use_keypad, short);
  
        s_bool = "short";
      }
    else if (sizeof(bool) == sizeof(int))
      {
        GEN_OFFSET(_notimeout, int);
        GEN_OFFSET(_clear, int);
        GEN_OFFSET(_leaveok, int);
        GEN_OFFSET(_scroll, int);
        GEN_OFFSET(_idlok, int);
        GEN_OFFSET(_idcok, int);
        GEN_OFFSET(_immed, int);
        GEN_OFFSET(_sync, int);
        GEN_OFFSET(_use_keypad, 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 'K':		/* translation of keycodes */
  	  gen_keydefs(0);
  	  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 'M':		/* generate constants for the ACS characters */
  	  gen_acs();
  	  break;
  	case 'L':		/* generate the Linker_Options pragma */
  	  gen_linkopts();
  	  break;
  	case 'O':		/* generate definitions of the old key code names */
  	  gen_keydefs(1);
  	  break;
  	case 'R':		/* generate representation clause for Attributed character */
  	  gen_chtype_rep("Attributed_Character");
  	  break;
  	case 'V':		/* generate version info */
  	  gen_version_info();
  	  break;
  	case 'T':		/* generate the Trace info */
  	  gen_trace("Trace_Attribute_Set");
  	  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;
  }
  