Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Enumerations | Functions | Variables
resrc.c File Reference
#include "bfd.h"
#include "bucomm.h"
#include "libiberty.h"
#include "safe-ctype.h"
#include "windres.h"
#include <assert.h>
#include <errno.h>
#include <sys/stat.h>

Go to the source code of this file.

Classes

struct  icondir
struct  control_info
union  icondir.u
struct  icondir.u.icon
struct  icondir.u.cursor

Defines

#define WIFEXITED(w)   (((w)&0377) == 0)
#define WIFSIGNALED(w)   (((w)&0377) != 0177 && ((w)&~0377) == 0)
#define WTERMSIG(w)   ((w) & 0177)
#define WEXITSTATUS(w)   (((w) >> 8) & 0377)
#define STDOUT_FILENO   1
#define DEFAULT_PREPROCESSOR   "gcc -E -xc -DRC_INVOKED"
#define BITMAP_SKIP   (14)

Enumerations

enum  { ISTREAM_PIPE, ISTREAM_FILE }

Functions

static int run_cmd (char *, const char *)
static FILE * open_input_stream (char *)
static FILE * look_for_default (char *, const char *, int, const char *, const char *)
static void close_input_stream (void)
static void unexpected_eof (const char *)
static int get_word (FILE *, const char *)
static unsigned long get_long (FILE *, const char *)
static void get_data (FILE *, unsigned char *, unsigned long, const char *)
static void define_fontdirs (void)
struct res_directoryread_rc_file (const char *filename, const char *preprocessor, const char *preprocargs, int language, int use_temp_file)
void yyerror (const char *msg)
void rcparse_warning (const char *msg)
void define_accelerator (struct res_id id, const struct res_res_info *resinfo, struct accelerator *data)
void define_bitmap (struct res_id id, const struct res_res_info *resinfo, const char *filename)
void define_cursor (struct res_id id, const struct res_res_info *resinfo, const char *filename)
void define_dialog (struct res_id id, const struct res_res_info *resinfo, const struct dialog *dialog)
struct dialog_controldefine_control (const struct res_id iid, unsigned long id, unsigned long x, unsigned long y, unsigned long width, unsigned long height, unsigned long class, unsigned long style, unsigned long exstyle)
struct dialog_controldefine_icon_control (struct res_id iid, unsigned long id, unsigned long x, unsigned long y, unsigned long style, unsigned long exstyle, unsigned long help, struct rcdata_item *data, struct dialog_ex *ex)
void define_font (struct res_id id, const struct res_res_info *resinfo, const char *filename)
void define_icon (struct res_id id, const struct res_res_info *resinfo, const char *filename)
void define_menu (struct res_id id, const struct res_res_info *resinfo, struct menuitem *menuitems)
struct menuitemdefine_menuitem (const char *text, int menuid, unsigned long type, unsigned long state, unsigned long help, struct menuitem *menuitems)
void define_messagetable (struct res_id id, const struct res_res_info *resinfo, const char *filename)
void define_rcdata (struct res_id id, const struct res_res_info *resinfo, struct rcdata_item *data)
struct rcdata_itemdefine_rcdata_string (const char *string, unsigned long len)
struct rcdata_itemdefine_rcdata_number (unsigned long val, int dword)
void define_stringtable (const struct res_res_info *resinfo, unsigned long stringid, const char *string)
void define_user_data (struct res_id id, struct res_id type, const struct res_res_info *resinfo, struct rcdata_item *data)
void define_rcdata_file (struct res_id id, const struct res_res_info *resinfo, const char *filename)
void define_user_file (struct res_id id, struct res_id type, const struct res_res_info *resinfo, const char *filename)
void define_versioninfo (struct res_id id, int language, struct fixed_versioninfo *fixedverinfo, struct ver_info *verinfo)
struct ver_infoappend_ver_stringfileinfo (struct ver_info *verinfo, const char *language, struct ver_stringinfo *strings)
struct ver_infoappend_ver_varfileinfo (struct ver_info *verinfo, const char *key, struct ver_varinfo *var)
struct ver_stringinfoappend_verval (struct ver_stringinfo *strings, const char *key, const char *value)
struct ver_varinfoappend_vertrans (struct ver_varinfo *var, unsigned long language, unsigned long charset)
static void indent (FILE *, int)
static void write_rc_directory (FILE *, const struct res_directory *, const struct res_id *, const struct res_id *, int *, int)
static void write_rc_subdir (FILE *, const struct res_entry *, const struct res_id *, const struct res_id *, int *, int)
static void write_rc_resource (FILE *, const struct res_id *, const struct res_id *, const struct res_resource *, int *)
static void write_rc_accelerators (FILE *, const struct accelerator *)
static void write_rc_cursor (FILE *, const struct cursor *)
static void write_rc_group_cursor (FILE *, const struct group_cursor *)
static void write_rc_dialog (FILE *, const struct dialog *)
static void write_rc_dialog_control (FILE *, const struct dialog_control *)
static void write_rc_fontdir (FILE *, const struct fontdir *)
static void write_rc_group_icon (FILE *, const struct group_icon *)
static void write_rc_menu (FILE *, const struct menu *, int)
static void write_rc_menuitems (FILE *, const struct menuitem *, int, int)
static void write_rc_rcdata (FILE *, const struct rcdata_item *, int)
static void write_rc_stringtable (FILE *, const struct res_id *, const struct stringtable *)
static void write_rc_versioninfo (FILE *, const struct versioninfo *)
static void write_rc_filedata (FILE *, unsigned long, const unsigned char *)
void write_rc_file (const char *filename, const struct res_directory *resources)

Variables

char * rc_filename
int rc_lineno
static FILE * cpp_pipe
static char * cpp_temp_file
static enum { ... }  istream_type
static struct res_directoryresources
static int cursors
static int fonts
struct fontdirfontdirs
static int icons
static struct control_info []

Class Documentation

struct icondir

Definition at line 87 of file resrc.c.

Class Members
unsigned long bytes
unsigned char colorcount
unsigned char height
unsigned long offset
union icondir u
unsigned char width
struct control_info

Definition at line 2049 of file resrc.c.

Class Members
unsigned short class
const char * name
unsigned long style
union icondir.u

Definition at line 95 of file resrc.c.

Class Members
u cursor
u icon
struct icondir.u.icon

Definition at line 97 of file resrc.c.

Class Members
unsigned short bits
unsigned short planes
struct icondir.u.cursor

Definition at line 104 of file resrc.c.

Class Members
unsigned short xhotspot
unsigned short yhotspot

Define Documentation

#define BITMAP_SKIP   (14)

Definition at line 608 of file resrc.c.

#define DEFAULT_PREPROCESSOR   "gcc -E -xc -DRC_INVOKED"

Definition at line 82 of file resrc.c.

#define STDOUT_FILENO   1

Definition at line 72 of file resrc.c.

#define WEXITSTATUS (   w)    (((w) >> 8) & 0377)

Definition at line 53 of file resrc.c.

#define WIFEXITED (   w)    (((w)&0377) == 0)

Definition at line 44 of file resrc.c.

#define WIFSIGNALED (   w)    (((w)&0377) != 0177 && ((w)&~0377) == 0)

Definition at line 47 of file resrc.c.

#define WTERMSIG (   w)    ((w) & 0177)

Definition at line 50 of file resrc.c.


Enumeration Type Documentation

anonymous enum
Enumerator:
ISTREAM_PIPE 
ISTREAM_FILE 

Definition at line 137 of file resrc.c.


Function Documentation

struct ver_info* append_ver_stringfileinfo ( struct ver_info verinfo,
const char *  language,
struct ver_stringinfo strings 
) [read]

Definition at line 1355 of file resrc.c.

{
  struct ver_info *vi, **pp;

  vi = (struct ver_info *) res_alloc (sizeof *vi);
  vi->next = NULL;
  vi->type = VERINFO_STRING;
  unicode_from_ascii ((int *) NULL, &vi->u.string.language, language);
  vi->u.string.strings = strings;

  for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next)
    ;
  *pp = vi;

  return verinfo;
}

Here is the call graph for this function:

struct ver_info* append_ver_varfileinfo ( struct ver_info verinfo,
const char *  key,
struct ver_varinfo var 
) [read]

Definition at line 1376 of file resrc.c.

{
  struct ver_info *vi, **pp;

  vi = (struct ver_info *) res_alloc (sizeof *vi);
  vi->next = NULL;
  vi->type = VERINFO_VAR;
  unicode_from_ascii ((int *) NULL, &vi->u.var.key, key);
  vi->u.var.var = var;

  for (pp = &verinfo; *pp != NULL; pp = &(*pp)->next)
    ;
  *pp = vi;

  return verinfo;
}

Here is the call graph for this function:

struct ver_varinfo* append_vertrans ( struct ver_varinfo var,
unsigned long  language,
unsigned long  charset 
) [read]

Definition at line 1417 of file resrc.c.

{
  struct ver_varinfo *vv, **pp;

  vv = (struct ver_varinfo *) res_alloc (sizeof *vv);
  vv->next = NULL;
  vv->language = language;
  vv->charset = charset;

  for (pp = &var; *pp != NULL; pp = &(*pp)->next)
    ;
  *pp = vv;

  return var;
}

Here is the call graph for this function:

struct ver_stringinfo* append_verval ( struct ver_stringinfo strings,
const char *  key,
const char *  value 
) [read]

Definition at line 1397 of file resrc.c.

{
  struct ver_stringinfo *vs, **pp;

  vs = (struct ver_stringinfo *) res_alloc (sizeof *vs);
  vs->next = NULL;
  unicode_from_ascii ((int *) NULL, &vs->key, key);
  unicode_from_ascii ((int *) NULL, &vs->value, value);

  for (pp = &strings; *pp != NULL; pp = &(*pp)->next)
    ;
  *pp = vs;

  return strings;
}

Here is the call graph for this function:

static void close_input_stream ( void  ) [static]

Definition at line 489 of file resrc.c.

{
  if (istream_type == ISTREAM_FILE)
    {
      if (cpp_pipe != NULL)
       fclose (cpp_pipe);

      if (cpp_temp_file != NULL)
       {
         int errno_save = errno;

         unlink (cpp_temp_file);
         errno = errno_save;
         free (cpp_temp_file);
       }
    }
  else
    {
      if (cpp_pipe != NULL)
       pclose (cpp_pipe);
    }

  /* Since this is also run via xatexit, safeguard.  */
  cpp_pipe = NULL;
  cpp_temp_file = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void define_accelerator ( struct res_id  id,
const struct res_res_info resinfo,
struct accelerator data 
)

Definition at line 592 of file resrc.c.

{
  struct res_resource *r;

  r = define_standard_resource (&resources, RT_ACCELERATOR, id,
                            resinfo->language, 0);
  r->type = RES_TYPE_ACCELERATOR;
  r->u.acc = data;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

void define_bitmap ( struct res_id  id,
const struct res_res_info resinfo,
const char *  filename 
)

Definition at line 611 of file resrc.c.

{
  FILE *e;
  char *real_filename;
  struct stat s;
  unsigned char *data;
  int i;
  struct res_resource *r;

  e = open_file_search (filename, FOPEN_RB, "bitmap file", &real_filename);

  if (stat (real_filename, &s) < 0)
    fatal (_("stat failed on bitmap file `%s': %s"), real_filename,
          strerror (errno));

  data = (unsigned char *) res_alloc (s.st_size - BITMAP_SKIP);

  for (i = 0; i < BITMAP_SKIP; i++)
    getc (e);

  get_data (e, data, s.st_size - BITMAP_SKIP, real_filename);

  fclose (e);
  free (real_filename);

  r = define_standard_resource (&resources, RT_BITMAP, id,
                            resinfo->language, 0);

  r->type = RES_TYPE_BITMAP;
  r->u.data.length = s.st_size - BITMAP_SKIP;
  r->u.data.data = data;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

struct dialog_control* define_control ( const struct res_id  iid,
unsigned long  id,
unsigned long  x,
unsigned long  y,
unsigned long  width,
unsigned long  height,
unsigned long  class,
unsigned long  style,
unsigned long  exstyle 
) [read]

Definition at line 791 of file resrc.c.

{
  struct dialog_control *n;

  n = (struct dialog_control *) res_alloc (sizeof *n);
  n->next = NULL;
  n->id = id;
  n->style = style;
  n->exstyle = exstyle;
  n->x = x;
  n->y = y;
  n->width = width;
  n->height = height;
  n->class.named = 0;
  n->class.u.id = class;
  n->text = iid;
  n->data = NULL;
  n->help = 0;

  return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void define_cursor ( struct res_id  id,
const struct res_res_info resinfo,
const char *  filename 
)

Definition at line 653 of file resrc.c.

{
  FILE *e;
  char *real_filename;
  int type, count, i;
  struct icondir *icondirs;
  int first_cursor;
  struct res_resource *r;
  struct group_cursor *first, **pp;

  e = open_file_search (filename, FOPEN_RB, "cursor file", &real_filename);

  /* A cursor file is basically an icon file.  The start of the file
     is a three word structure.  The first word is ignored.  The
     second word is the type of data.  The third word is the number of
     entries.  */

  get_word (e, real_filename);
  type = get_word (e, real_filename);
  count = get_word (e, real_filename);
  if (type != 2)
    fatal (_("cursor file `%s' does not contain cursor data"), real_filename);

  /* Read in the icon directory entries.  */

  icondirs = (struct icondir *) xmalloc (count * sizeof *icondirs);

  for (i = 0; i < count; i++)
    {
      icondirs[i].width = getc (e);
      icondirs[i].height = getc (e);
      icondirs[i].colorcount = getc (e);
      getc (e);
      icondirs[i].u.cursor.xhotspot = get_word (e, real_filename);
      icondirs[i].u.cursor.yhotspot = get_word (e, real_filename);
      icondirs[i].bytes = get_long (e, real_filename);
      icondirs[i].offset = get_long (e, real_filename);

      if (feof (e))
       unexpected_eof (real_filename);
    }

  /* Define each cursor as a unique resource.  */

  first_cursor = cursors;

  for (i = 0; i < count; i++)
    {
      unsigned char *data;
      struct res_id name;
      struct cursor *c;

      if (fseek (e, icondirs[i].offset, SEEK_SET) != 0)
       fatal (_("%s: fseek to %lu failed: %s"), real_filename,
              icondirs[i].offset, strerror (errno));

      data = (unsigned char *) res_alloc (icondirs[i].bytes);

      get_data (e, data, icondirs[i].bytes, real_filename);

      c = (struct cursor *) res_alloc (sizeof *c);
      c->xhotspot = icondirs[i].u.cursor.xhotspot;
      c->yhotspot = icondirs[i].u.cursor.yhotspot;
      c->length = icondirs[i].bytes;
      c->data = data;

      ++cursors;

      name.named = 0;
      name.u.id = cursors;

      r = define_standard_resource (&resources, RT_CURSOR, name,
                                resinfo->language, 0);
      r->type = RES_TYPE_CURSOR;
      r->u.cursor = c;
      r->res_info = *resinfo;
    }

  fclose (e);
  free (real_filename);

  /* Define a cursor group resource.  */

  first = NULL;
  pp = &first;
  for (i = 0; i < count; i++)
    {
      struct group_cursor *cg;

      cg = (struct group_cursor *) res_alloc (sizeof *cg);
      cg->next = NULL;
      cg->width = icondirs[i].width;
      cg->height = 2 * icondirs[i].height;

      /* FIXME: What should these be set to?  */
      cg->planes = 1;
      cg->bits = 1;

      cg->bytes = icondirs[i].bytes + 4;
      cg->index = first_cursor + i + 1;

      *pp = cg;
      pp = &(*pp)->next;
    }

  free (icondirs);

  r = define_standard_resource (&resources, RT_GROUP_CURSOR, id,
                            resinfo->language, 0);
  r->type = RES_TYPE_GROUP_CURSOR;
  r->u.group_cursor = first;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

void define_dialog ( struct res_id  id,
const struct res_res_info resinfo,
const struct dialog dialog 
)

Definition at line 771 of file resrc.c.

{
  struct dialog *copy;
  struct res_resource *r;

  copy = (struct dialog *) res_alloc (sizeof *copy);
  *copy = *dialog;

  r = define_standard_resource (&resources, RT_DIALOG, id,
                            resinfo->language, 0);
  r->type = RES_TYPE_DIALOG;
  r->u.dialog = copy;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

void define_font ( struct res_id  id,
const struct res_res_info resinfo,
const char *  filename 
)

Definition at line 843 of file resrc.c.

{
  FILE *e;
  char *real_filename;
  struct stat s;
  unsigned char *data;
  struct res_resource *r;
  long offset;
  long fontdatalength;
  unsigned char *fontdata;
  struct fontdir *fd;
  const char *device, *face;
  struct fontdir **pp;

  e = open_file_search (filename, FOPEN_RB, "font file", &real_filename);

  if (stat (real_filename, &s) < 0)
    fatal (_("stat failed on font file `%s': %s"), real_filename,
          strerror (errno));

  data = (unsigned char *) res_alloc (s.st_size);

  get_data (e, data, s.st_size, real_filename);

  fclose (e);
  free (real_filename);

  r = define_standard_resource (&resources, RT_FONT, id,
                            resinfo->language, 0);

  r->type = RES_TYPE_FONT;
  r->u.data.length = s.st_size;
  r->u.data.data = data;
  r->res_info = *resinfo;

  /* For each font resource, we must add an entry in the FONTDIR
     resource.  The FONTDIR resource includes some strings in the font
     file.  To find them, we have to do some magic on the data we have
     read.  */

  offset = ((((((data[47] << 8)
              | data[46]) << 8)
             | data[45]) << 8)
           | data[44]);
  if (offset > 0 && offset < s.st_size)
    device = (char *) data + offset;
  else
    device = "";

  offset = ((((((data[51] << 8)
              | data[50]) << 8)
             | data[49]) << 8)
           | data[48]);
  if (offset > 0 && offset < s.st_size)
    face = (char *) data + offset;
  else
    face = "";

  ++fonts;

  fontdatalength = 58 + strlen (device) + strlen (face);
  fontdata = (unsigned char *) res_alloc (fontdatalength);
  memcpy (fontdata, data, 56);
  strcpy ((char *) fontdata + 56, device);
  strcpy ((char *) fontdata + 57 + strlen (device), face);

  fd = (struct fontdir *) res_alloc (sizeof *fd);
  fd->next = NULL;
  fd->index = fonts;
  fd->length = fontdatalength;
  fd->data = fontdata;

  for (pp = &fontdirs; *pp != NULL; pp = &(*pp)->next)
    ;
  *pp = fd;

  /* For the single fontdirs resource, we always use the resource
     information of the last font.  I don't know what else to do.  */
  fontdirs_resinfo = *resinfo;
}

Here is the call graph for this function:

static void define_fontdirs ( void  ) [static]

Definition at line 929 of file resrc.c.

{
  struct res_resource *r;
  struct res_id id;

  id.named = 0;
  id.u.id = 1;

  r = define_standard_resource (&resources, RT_FONTDIR, id, 0x409, 0);

  r->type = RES_TYPE_FONTDIR;
  r->u.fontdir = fontdirs;
  r->res_info = fontdirs_resinfo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void define_icon ( struct res_id  id,
const struct res_res_info resinfo,
const char *  filename 
)

Definition at line 951 of file resrc.c.

{
  FILE *e;
  char *real_filename;
  int type, count, i;
  struct icondir *icondirs;
  int first_icon;
  struct res_resource *r;
  struct group_icon *first, **pp;

  e = open_file_search (filename, FOPEN_RB, "icon file", &real_filename);

  /* The start of an icon file is a three word structure.  The first
     word is ignored.  The second word is the type of data.  The third
     word is the number of entries.  */

  get_word (e, real_filename);
  type = get_word (e, real_filename);
  count = get_word (e, real_filename);
  if (type != 1)
    fatal (_("icon file `%s' does not contain icon data"), real_filename);

  /* Read in the icon directory entries.  */

  icondirs = (struct icondir *) xmalloc (count * sizeof *icondirs);

  for (i = 0; i < count; i++)
    {
      icondirs[i].width = getc (e);
      icondirs[i].height = getc (e);
      icondirs[i].colorcount = getc (e);
      getc (e);
      icondirs[i].u.icon.planes = get_word (e, real_filename);
      icondirs[i].u.icon.bits = get_word (e, real_filename);
      icondirs[i].bytes = get_long (e, real_filename);
      icondirs[i].offset = get_long (e, real_filename);

      if (feof (e))
       unexpected_eof (real_filename);
    }

  /* Define each icon as a unique resource.  */

  first_icon = icons;

  for (i = 0; i < count; i++)
    {
      unsigned char *data;
      struct res_id name;

      if (fseek (e, icondirs[i].offset, SEEK_SET) != 0)
       fatal (_("%s: fseek to %lu failed: %s"), real_filename,
              icondirs[i].offset, strerror (errno));

      data = (unsigned char *) res_alloc (icondirs[i].bytes);

      get_data (e, data, icondirs[i].bytes, real_filename);

      ++icons;

      name.named = 0;
      name.u.id = icons;

      r = define_standard_resource (&resources, RT_ICON, name,
                                resinfo->language, 0);
      r->type = RES_TYPE_ICON;
      r->u.data.length = icondirs[i].bytes;
      r->u.data.data = data;
      r->res_info = *resinfo;
    }

  fclose (e);
  free (real_filename);

  /* Define an icon group resource.  */

  first = NULL;
  pp = &first;
  for (i = 0; i < count; i++)
    {
      struct group_icon *cg;

      /* For some reason, at least in some files the planes and bits
         are zero.  We instead set them from the color.  This is
         copied from rcl.  */

      cg = (struct group_icon *) res_alloc (sizeof *cg);
      cg->next = NULL;
      cg->width = icondirs[i].width;
      cg->height = icondirs[i].height;
      cg->colors = icondirs[i].colorcount;

      if (icondirs[i].u.icon.planes)
       cg->planes = icondirs[i].u.icon.planes;
      else
       cg->planes = 1;

      if (icondirs[i].u.icon.bits)
       cg->bits = icondirs[i].u.icon.bits;
      else
       {
         cg->bits = 0;

         while ((1L << cg->bits) < cg->colors)
           ++cg->bits;
       }

      cg->bytes = icondirs[i].bytes;
      cg->index = first_icon + i + 1;

      *pp = cg;
      pp = &(*pp)->next;
    }

  free (icondirs);

  r = define_standard_resource (&resources, RT_GROUP_ICON, id,
                            resinfo->language, 0);
  r->type = RES_TYPE_GROUP_ICON;
  r->u.group_icon = first;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

struct dialog_control* define_icon_control ( struct res_id  iid,
unsigned long  id,
unsigned long  x,
unsigned long  y,
unsigned long  style,
unsigned long  exstyle,
unsigned long  help,
struct rcdata_item data,
struct dialog_ex ex 
) [read]

Definition at line 817 of file resrc.c.

{
  struct dialog_control *n;
  struct res_id tid;

  if (style == 0)
    style = SS_ICON | WS_CHILD | WS_VISIBLE;
  res_string_to_id (&tid, "");
  n = define_control (tid, id, x, y, 0, 0, CTL_STATIC, style, exstyle);
  n->text = iid;
  if (help && !ex)
    rcparse_warning (_("help ID requires DIALOGEX"));
  if (data && !ex)
    rcparse_warning (_("control data requires DIALOGEX"));
  n->help = help;
  n->data = data;

  return n;
}

Here is the call graph for this function:

void define_menu ( struct res_id  id,
const struct res_res_info resinfo,
struct menuitem menuitems 
)

Definition at line 1078 of file resrc.c.

{
  struct menu *m;
  struct res_resource *r;

  m = (struct menu *) res_alloc (sizeof *m);
  m->items = menuitems;
  m->help = 0;

  r = define_standard_resource (&resources, RT_MENU, id, resinfo->language, 0);
  r->type = RES_TYPE_MENU;
  r->u.menu = m;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

struct menuitem* define_menuitem ( const char *  text,
int  menuid,
unsigned long  type,
unsigned long  state,
unsigned long  help,
struct menuitem menuitems 
) [read]

Definition at line 1098 of file resrc.c.

{
  struct menuitem *mi;

  mi = (struct menuitem *) res_alloc (sizeof *mi);
  mi->next = NULL;
  mi->type = type;
  mi->state = state;
  mi->id = menuid;
  if (text == NULL)
    mi->text = NULL;
  else
    unicode_from_ascii ((int *) NULL, &mi->text, text);
  mi->help = help;
  mi->popup = menuitems;
  return mi;
}

Here is the call graph for this function:

void define_messagetable ( struct res_id  id,
const struct res_res_info resinfo,
const char *  filename 
)

Definition at line 1121 of file resrc.c.

{
  FILE *e;
  char *real_filename;
  struct stat s;
  unsigned char *data;
  struct res_resource *r;

  e = open_file_search (filename, FOPEN_RB, "messagetable file",
                     &real_filename);

  if (stat (real_filename, &s) < 0)
    fatal (_("stat failed on bitmap file `%s': %s"), real_filename,
          strerror (errno));

  data = (unsigned char *) res_alloc (s.st_size);

  get_data (e, data, s.st_size, real_filename);

  fclose (e);
  free (real_filename);

  r = define_standard_resource (&resources, RT_MESSAGETABLE, id,
                            resinfo->language, 0);

  r->type = RES_TYPE_MESSAGETABLE;
  r->u.data.length = s.st_size;
  r->u.data.data = data;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

void define_rcdata ( struct res_id  id,
const struct res_res_info resinfo,
struct rcdata_item data 
)

Definition at line 1156 of file resrc.c.

{
  struct res_resource *r;

  r = define_standard_resource (&resources, RT_RCDATA, id,
                            resinfo->language, 0);
  r->type = RES_TYPE_RCDATA;
  r->u.rcdata = data;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void define_rcdata_file ( struct res_id  id,
const struct res_res_info resinfo,
const char *  filename 
)

Definition at line 1260 of file resrc.c.

{
  struct rcdata_item *ri;
  FILE *e;
  char *real_filename;
  struct stat s;
  unsigned char *data;

  e = open_file_search (filename, FOPEN_RB, "file", &real_filename);


  if (stat (real_filename, &s) < 0)
    fatal (_("stat failed on file `%s': %s"), real_filename,
          strerror (errno));

  data = (unsigned char *) res_alloc (s.st_size);

  get_data (e, data, s.st_size, real_filename);

  fclose (e);
  free (real_filename);

  ri = (struct rcdata_item *) res_alloc (sizeof *ri);
  ri->next = NULL;
  ri->type = RCDATA_BUFFER;
  ri->u.buffer.length = s.st_size;
  ri->u.buffer.data = data;

  define_rcdata (id, resinfo, ri);
}

Here is the call graph for this function:

struct rcdata_item* define_rcdata_number ( unsigned long  val,
int  dword 
) [read]

Definition at line 1190 of file resrc.c.

{
  struct rcdata_item *ri;

  ri = (struct rcdata_item *) res_alloc (sizeof *ri);
  ri->next = NULL;
  ri->type = dword ? RCDATA_DWORD : RCDATA_WORD;
  ri->u.word = val;

  return ri;
}

Here is the call graph for this function:

struct rcdata_item* define_rcdata_string ( const char *  string,
unsigned long  len 
) [read]

Definition at line 1171 of file resrc.c.

{
  struct rcdata_item *ri;
  char *s;

  ri = (struct rcdata_item *) res_alloc (sizeof *ri);
  ri->next = NULL;
  ri->type = RCDATA_STRING;
  ri->u.string.length = len;
  s = (char *) res_alloc (len);
  memcpy (s, string, len);
  ri->u.string.s = s;

  return ri;
}

Here is the call graph for this function:

void define_stringtable ( const struct res_res_info resinfo,
unsigned long  stringid,
const char *  string 
)

Definition at line 1206 of file resrc.c.

{
  struct res_id id;
  struct res_resource *r;

  id.named = 0;
  id.u.id = (stringid >> 4) + 1;
  r = define_standard_resource (&resources, RT_STRING, id,
                            resinfo->language, 1);

  if (r->type == RES_TYPE_UNINITIALIZED)
    {
      int i;

      r->type = RES_TYPE_STRINGTABLE;
      r->u.stringtable = ((struct stringtable *)
                       res_alloc (sizeof (struct stringtable)));
      for (i = 0; i < 16; i++)
       {
         r->u.stringtable->strings[i].length = 0;
         r->u.stringtable->strings[i].string = NULL;
       }

      r->res_info = *resinfo;
    }

  unicode_from_ascii (&r->u.stringtable->strings[stringid & 0xf].length,
                    &r->u.stringtable->strings[stringid & 0xf].string,
                    string);
}

Here is the call graph for this function:

void define_user_data ( struct res_id  id,
struct res_id  type,
const struct res_res_info resinfo,
struct rcdata_item data 
)

Definition at line 1241 of file resrc.c.

{
  struct res_id ids[3];
  struct res_resource *r;

  ids[0] = type;
  ids[1] = id;
  ids[2].named = 0;
  ids[2].u.id = resinfo->language;

  r = define_resource (& resources, 3, ids, 0);
  r->type = RES_TYPE_USERDATA;
  r->u.userdata = data;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

void define_user_file ( struct res_id  id,
struct res_id  type,
const struct res_res_info resinfo,
const char *  filename 
)

Definition at line 1295 of file resrc.c.

{
  FILE *e;
  char *real_filename;
  struct stat s;
  unsigned char *data;
  struct res_id ids[3];
  struct res_resource *r;

  e = open_file_search (filename, FOPEN_RB, "file", &real_filename);

  if (stat (real_filename, &s) < 0)
    fatal (_("stat failed on file `%s': %s"), real_filename,
          strerror (errno));

  data = (unsigned char *) res_alloc (s.st_size);

  get_data (e, data, s.st_size, real_filename);

  fclose (e);
  free (real_filename);

  ids[0] = type;
  ids[1] = id;
  ids[2].named = 0;
  ids[2].u.id = resinfo->language;

  r = define_resource (&resources, 3, ids, 0);
  r->type = RES_TYPE_USERDATA;
  r->u.userdata = ((struct rcdata_item *)
                 res_alloc (sizeof (struct rcdata_item)));
  r->u.userdata->next = NULL;
  r->u.userdata->type = RCDATA_BUFFER;
  r->u.userdata->u.buffer.length = s.st_size;
  r->u.userdata->u.buffer.data = data;
  r->res_info = *resinfo;
}

Here is the call graph for this function:

void define_versioninfo ( struct res_id  id,
int  language,
struct fixed_versioninfo fixedverinfo,
struct ver_info verinfo 
)

Definition at line 1337 of file resrc.c.

{
  struct res_resource *r;

  r = define_standard_resource (&resources, RT_VERSION, id, language, 0);
  r->type = RES_TYPE_VERSIONINFO;
  r->u.versioninfo = ((struct versioninfo *)
                    res_alloc (sizeof (struct versioninfo)));
  r->u.versioninfo->fixed = fixedverinfo;
  r->u.versioninfo->var = verinfo;
  r->res_info.language = language;
}

Here is the call graph for this function:

static void get_data ( FILE *  e,
unsigned char *  p,
unsigned long  c,
const char *  msg 
) [static]

Definition at line 578 of file resrc.c.

{
  unsigned long got;

  got = fread (p, 1, c, e);
  if (got == c)
    return;

  fatal (_("%s: read of %lu returned %lu"), msg, c, got);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned long get_long ( FILE *  e,
const char *  msg 
) [static]

Definition at line 559 of file resrc.c.

{
  int b1, b2, b3, b4;

  b1 = getc (e);
  b2 = getc (e);
  b3 = getc (e);
  b4 = getc (e);
  if (feof (e))
    unexpected_eof (msg);
  return (((((((b4 & 0xff) << 8)
             | (b3 & 0xff)) << 8)
           | (b2 & 0xff)) << 8)
         | (b1 & 0xff));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int get_word ( FILE *  e,
const char *  msg 
) [static]

Definition at line 544 of file resrc.c.

{
  int b1, b2;

  b1 = getc (e);
  b2 = getc (e);
  if (feof (e))
    unexpected_eof (msg);
  return ((b2 & 0xff) << 8) | (b1 & 0xff);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void indent ( FILE *  e,
int  c 
) [static]

Definition at line 1464 of file resrc.c.

{
  int i;

  for (i = 0; i < c; i++)
    putc (' ', e);
}

Here is the caller graph for this function:

static FILE * look_for_default ( char *  cmd,
const char *  prefix,
int  end_prefix,
const char *  preprocargs,
const char *  filename 
) [static]

Definition at line 333 of file resrc.c.

{
  char *space;
  int found;
  struct stat s;

  strcpy (cmd, prefix);

  sprintf (cmd + end_prefix, "%s", DEFAULT_PREPROCESSOR);
  space = strchr (cmd + end_prefix, ' ');
  if (space)
    *space = 0;

  if (
#if defined (__DJGPP__) || defined (__CYGWIN__) || defined (_WIN32)
      strchr (cmd, '\\') ||
#endif
      strchr (cmd, '/'))
    {
      found = (stat (cmd, &s) == 0
#ifdef HAVE_EXECUTABLE_SUFFIX
              || stat (strcat (cmd, EXECUTABLE_SUFFIX), &s) == 0
#endif
              );

      if (! found)
       {
         if (verbose)
           fprintf (stderr, _("Tried `%s'\n"), cmd);
         return NULL;
       }
    }

  strcpy (cmd, prefix);

  sprintf (cmd + end_prefix, "%s %s %s",
          DEFAULT_PREPROCESSOR, preprocargs, filename);

  if (verbose)
    fprintf (stderr, _("Using `%s'\n"), cmd);

  cpp_pipe = open_input_stream (cmd);
  return cpp_pipe;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FILE * open_input_stream ( char *  cmd) [static]

Definition at line 293 of file resrc.c.

{
  if (istream_type == ISTREAM_FILE)
    {
      char *fileprefix;

      fileprefix = choose_temp_base ();
      cpp_temp_file = (char *) xmalloc (strlen (fileprefix) + 5);
      sprintf (cpp_temp_file, "%s.irc", fileprefix);
      free (fileprefix);

      if (run_cmd (cmd, cpp_temp_file))
       fatal (_("can't execute `%s': %s"), cmd, strerror (errno));

      cpp_pipe = fopen (cpp_temp_file, FOPEN_RT);;
      if (cpp_pipe == NULL)
       fatal (_("can't open temporary file `%s': %s"),
              cpp_temp_file, strerror (errno));

      if (verbose)
       fprintf (stderr,
                _("Using temporary file `%s' to read preprocessor output\n"),
               cpp_temp_file);
    }
  else
    {
      cpp_pipe = popen (cmd, FOPEN_RT);
      if (cpp_pipe == NULL)
       fatal (_("can't popen `%s': %s"), cmd, strerror (errno));
      if (verbose)
       fprintf (stderr, _("Using popen to read preprocessor output\n"));
    }

  xatexit (close_input_stream);
  return cpp_pipe;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void rcparse_warning ( const char *  msg)

Definition at line 527 of file resrc.c.

{
  fprintf (stderr, _("%s:%d: %s\n"), rc_filename, rc_lineno, msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct res_directory* read_rc_file ( const char *  filename,
const char *  preprocessor,
const char *  preprocargs,
int  language,
int  use_temp_file 
) [read]

Definition at line 382 of file resrc.c.

{
  char *cmd;

  istream_type = (use_temp_file) ? ISTREAM_FILE : ISTREAM_PIPE;

  if (preprocargs == NULL)
    preprocargs = "";
  if (filename == NULL)
    filename = "-";

  if (preprocessor)
    {
      cmd = xmalloc (strlen (preprocessor)
                   + strlen (preprocargs)
                   + strlen (filename)
                   + 10);
      sprintf (cmd, "%s %s %s", preprocessor, preprocargs, filename);

      cpp_pipe = open_input_stream (cmd);
    }
  else
    {
      char *dash, *slash, *cp;

      preprocessor = DEFAULT_PREPROCESSOR;

      cmd = xmalloc (strlen (program_name)
                   + strlen (preprocessor)
                   + strlen (preprocargs)
                   + strlen (filename)
#ifdef HAVE_EXECUTABLE_SUFFIX
                   + strlen (EXECUTABLE_SUFFIX)
#endif
                   + 10);


      dash = slash = 0;
      for (cp = program_name; *cp; cp++)
       {
         if (*cp == '-')
           dash = cp;
         if (
#if defined (__DJGPP__) || defined (__CYGWIN__) || defined(_WIN32)
             *cp == ':' || *cp == '\\' ||
#endif
             *cp == '/')
           {
             slash = cp;
             dash = 0;
           }
       }

      cpp_pipe = 0;

      if (dash)
       {
         /* First, try looking for a prefixed gcc in the windres
            directory, with the same prefix as windres */

         cpp_pipe = look_for_default (cmd, program_name, dash-program_name+1,
                                   preprocargs, filename);
       }

      if (slash && !cpp_pipe)
       {
         /* Next, try looking for a gcc in the same directory as
             that windres */

         cpp_pipe = look_for_default (cmd, program_name, slash-program_name+1,
                                   preprocargs, filename);
       }

      if (!cpp_pipe)
       {
         /* Sigh, try the default */

         cpp_pipe = look_for_default (cmd, "", 0, preprocargs, filename);
       }

    }

  free (cmd);

  rc_filename = xstrdup (filename);
  rc_lineno = 1;
  if (language != -1)
    rcparse_set_language (language);
  yyin = cpp_pipe;
  yyparse ();
  rcparse_discard_strings ();

  close_input_stream ();

  if (fontdirs != NULL)
    define_fontdirs ();

  free (rc_filename);
  rc_filename = NULL;

  return resources;
}

Here is the call graph for this function:

static int run_cmd ( char *  cmd,
const char *  redir 
) [static]

Definition at line 179 of file resrc.c.

{
  char *s;
  int pid, wait_status, retcode;
  int i;
  const char **argv;
  char *errmsg_fmt, *errmsg_arg;
  char *temp_base = choose_temp_base ();
  int in_quote;
  char sep;
  int redir_handle = -1;
  int stdout_save = -1;

  /* Count the args.  */
  i = 0;

  for (s = cmd; *s; s++)
    if (*s == ' ')
      i++;

  i++;
  argv = alloca (sizeof (char *) * (i + 3));
  i = 0;
  s = cmd;

  while (1)
    {
      while (*s == ' ' && *s != 0)
       s++;

      if (*s == 0)
       break;

      in_quote = (*s == '\'' || *s == '"');
      sep = (in_quote) ? *s++ : ' ';
      argv[i++] = s;

      while (*s != sep && *s != 0)
       s++;

      if (*s == 0)
       break;

      *s++ = 0;

      if (in_quote)
       s++;
    }
  argv[i++] = NULL;

  /* Setup the redirection.  We can't use the usual fork/exec and redirect
     since we may be running on non-POSIX Windows host.  */

  fflush (stdout);
  fflush (stderr);

  /* Open temporary output file.  */
  redir_handle = open (redir, O_WRONLY | O_TRUNC | O_CREAT, 0666);
  if (redir_handle == -1)
    fatal (_("can't open temporary file `%s': %s"), redir,
          strerror (errno));

  /* Duplicate the stdout file handle so it can be restored later.  */
  stdout_save = dup (STDOUT_FILENO);
  if (stdout_save == -1)
    fatal (_("can't redirect stdout: `%s': %s"), redir, strerror (errno));

  /* Redirect stdout to our output file.  */
  dup2 (redir_handle, STDOUT_FILENO);

  pid = pexecute (argv[0], (char * const *) argv, program_name, temp_base,
                &errmsg_fmt, &errmsg_arg, PEXECUTE_ONE | PEXECUTE_SEARCH);

  /* Restore stdout to its previous setting.  */
  dup2 (stdout_save, STDOUT_FILENO);

  /* Close response file.  */
  close (redir_handle);

  if (pid == -1)
    {
      fatal (_("%s %s: %s"), errmsg_fmt, errmsg_arg, strerror (errno));
      return 1;
    }

  retcode = 0;
  pid = pwait (pid, &wait_status, 0);

  if (pid == -1)
    {
      fatal (_("wait: %s"), strerror (errno));
      retcode = 1;
    }
  else if (WIFSIGNALED (wait_status))
    {
      fatal (_("subprocess got fatal signal %d"), WTERMSIG (wait_status));
      retcode = 1;
    }
  else if (WIFEXITED (wait_status))
    {
      if (WEXITSTATUS (wait_status) != 0)
       {
         fatal (_("%s exited with status %d"), cmd,
                WEXITSTATUS (wait_status));
         retcode = 1;
       }
    }
  else
    retcode = 1;

  return retcode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void unexpected_eof ( const char *  msg) [static]

Definition at line 535 of file resrc.c.

{
  fatal (_("%s: unexpected EOF"), msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_accelerators ( FILE *  e,
const struct accelerator accelerators 
) [static]

Definition at line 1914 of file resrc.c.

{
  const struct accelerator *acc;

  fprintf (e, "BEGIN\n");
  for (acc = accelerators; acc != NULL; acc = acc->next)
    {
      int printable;

      fprintf (e, "  ");

      if ((acc->key & 0x7f) == acc->key
         && ISPRINT (acc->key)
         && (acc->flags & ACC_VIRTKEY) == 0)
       {
         fprintf (e, "\"%c\"", acc->key);
         printable = 1;
       }
      else
       {
         fprintf (e, "%d", acc->key);
         printable = 0;
       }

      fprintf (e, ", %d", acc->id);

      if (! printable)
       {
         if ((acc->flags & ACC_VIRTKEY) != 0)
           fprintf (e, ", VIRTKEY");
         else
           fprintf (e, ", ASCII");
       }

      if ((acc->flags & ACC_SHIFT) != 0)
       fprintf (e, ", SHIFT");
      if ((acc->flags & ACC_CONTROL) != 0)
       fprintf (e, ", CONTROL");
      if ((acc->flags & ACC_ALT) != 0)
       fprintf (e, ", ALT");

      fprintf (e, "\n");
    }

  fprintf (e, "END\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_cursor ( FILE *  e,
const struct cursor cursor 
) [static]

Definition at line 1965 of file resrc.c.

{
  fprintf (e, "// Hotspot: x: %d; y: %d\n", cursor->xhotspot,
          cursor->yhotspot);
  write_rc_filedata (e, cursor->length, cursor->data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_dialog ( FILE *  e,
const struct dialog dialog 
) [static]

Definition at line 1992 of file resrc.c.

{
  const struct dialog_control *control;

  fprintf (e, "STYLE 0x%lx\n", dialog->style);

  if (dialog->exstyle != 0)
    fprintf (e, "EXSTYLE 0x%lx\n", dialog->exstyle);

  if ((dialog->class.named && dialog->class.u.n.length > 0)
      || dialog->class.u.id != 0)
    {
      fprintf (e, "CLASS ");
      res_id_print (e, dialog->class, 1);
      fprintf (e, "\n");
    }

  if (dialog->caption != NULL)
    {
      fprintf (e, "CAPTION \"");
      unicode_print (e, dialog->caption, -1);
      fprintf (e, "\"\n");
    }

  if ((dialog->menu.named && dialog->menu.u.n.length > 0)
      || dialog->menu.u.id != 0)
    {
      fprintf (e, "MENU ");
      res_id_print (e, dialog->menu, 0);
      fprintf (e, "\n");
    }

  if (dialog->font != NULL)
    {
      fprintf (e, "FONT %d, \"", dialog->pointsize);
      unicode_print (e, dialog->font, -1);
      fprintf (e, "\"");
      if (dialog->ex != NULL
         && (dialog->ex->weight != 0
             || dialog->ex->italic != 0
             || dialog->ex->charset != 1))
       fprintf (e, ", %d, %d, %d",
               dialog->ex->weight, dialog->ex->italic, dialog->ex->charset);
      fprintf (e, "\n");
    }

  fprintf (e, "BEGIN\n");

  for (control = dialog->controls; control != NULL; control = control->next)
    write_rc_dialog_control (e, control);

  fprintf (e, "END\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_dialog_control ( FILE *  e,
const struct dialog_control control 
) [static]

Definition at line 2085 of file resrc.c.

{
  const struct control_info *ci;

  fprintf (e, "  ");

  if (control->class.named)
    ci = NULL;
  else
    {
      for (ci = control_info; ci->name != NULL; ++ci)
       if (ci->class == control->class.u.id
           && (ci->style == (unsigned long) -1
              || ci->style == (control->style & 0xff)))
         break;
    }
  if (ci == NULL)
    fprintf (e, "CONTROL");
  else if (ci->name != NULL)
    fprintf (e, "%s", ci->name);
  else
    fprintf (e, "CONTROL");

  if (control->text.named || control->text.u.id != 0)
    {
      fprintf (e, " ");
      res_id_print (e, control->text, 1);
      fprintf (e, ",");
    }

  fprintf (e, " %d, ", control->id);

  if (ci == NULL)
    {
      if (control->class.named)
       fprintf (e, "\"");
      res_id_print (e, control->class, 0);
      if (control->class.named)
       fprintf (e, "\"");
      fprintf (e, ", 0x%lx, ", control->style);
    }

  fprintf (e, "%d, %d", control->x, control->y);

  if (control->style != SS_ICON
      || control->exstyle != 0
      || control->width != 0
      || control->height != 0
      || control->help != 0)
    {
      fprintf (e, ", %d, %d", control->width, control->height);

      /* FIXME: We don't need to print the style if it is the default.
        More importantly, in certain cases we actually need to turn
        off parts of the forced style, by using NOT.  */
      fprintf (e, ", 0x%lx", control->style);

      if (control->exstyle != 0 || control->help != 0)
       fprintf (e, ", 0x%lx, %lu", control->exstyle, control->help);
    }

  fprintf (e, "\n");

  if (control->data != NULL)
    write_rc_rcdata (e, control->data, 2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_directory ( FILE *  e,
const struct res_directory rd,
const struct res_id type,
const struct res_id name,
int language,
int  level 
) [static]

Definition at line 1509 of file resrc.c.

{
  const struct res_entry *re;

  /* Print out some COFF information that rc files can't represent.  */

  if (rd->time != 0)
    fprintf (e, "// Time stamp: %lu\n", rd->time);
  if (rd->characteristics != 0)
    fprintf (e, "// Characteristics: %lu\n", rd->characteristics);
  if (rd->major != 0 || rd->minor != 0)
    fprintf (e, "// Version: %d %d\n", rd->major, rd->minor);

  for (re = rd->entries;  re != NULL; re = re->next)
    {
      switch (level)
       {
       case 1:
         /* If we're at level 1, the key of this resource is the
             type.  This normally duplicates the information we have
             stored with the resource itself, but we need to remember
             the type if this is a user define resource type.  */
         type = &re->id;
         break;

       case 2:
         /* If we're at level 2, the key of this resource is the name
            we are going to use in the rc printout.  */
         name = &re->id;
         break;

       case 3:
         /* If we're at level 3, then this key represents a language.
            Use it to update the current language.  */
         if (! re->id.named
             && re->id.u.id != (unsigned long) (unsigned int) *language
             && (re->id.u.id & 0xffff) == re->id.u.id)
           {
             fprintf (e, "LANGUAGE %lu, %lu\n",
                     re->id.u.id & ((1 << SUBLANG_SHIFT) - 1),
                     (re->id.u.id >> SUBLANG_SHIFT) & 0xff);
             *language = re->id.u.id;
           }
         break;

       default:
         break;
       }

      if (re->subdir)
       write_rc_subdir (e, re, type, name, language, level);
      else
       {
         if (level == 3)
           {
             /* This is the normal case: the three levels are
                 TYPE/NAME/LANGUAGE.  NAME will have been set at level
                 2, and represents the name to use.  We probably just
                 set LANGUAGE, and it will probably match what the
                 resource itself records if anything.  */
             write_rc_resource (e, type, name, re->u.res, language);
           }
         else
           {
             fprintf (e, "// Resource at unexpected level %d\n", level);
             write_rc_resource (e, type, (struct res_id *) NULL, re->u.res,
                             language);
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void write_rc_file ( const char *  filename,
const struct res_directory resources 
)

Definition at line 1483 of file resrc.c.

{
  FILE *e;
  int language;

  if (filename == NULL)
    e = stdout;
  else
    {
      e = fopen (filename, FOPEN_WT);
      if (e == NULL)
       fatal (_("can't open `%s' for output: %s"), filename, strerror (errno));
    }

  language = -1;
  write_rc_directory (e, resources, (const struct res_id *) NULL,
                    (const struct res_id *) NULL, &language, 1);
}

Here is the call graph for this function:

static void write_rc_filedata ( FILE *  e,
unsigned long  length,
const unsigned char *  data 
) [static]

Definition at line 2571 of file resrc.c.

{
  unsigned long i;

  for (i = 0; i + 15 < length; i += 16)
    {
      fprintf (e, "// %4lx: ", i);
      fprintf (e, "%02x %02x %02x %02x %02x %02x %02x %02x ",
              data[i + 0], data[i + 1], data[i + 2], data[i + 3],
              data[i + 4], data[i + 5], data[i + 6], data[i + 7]);
      fprintf (e, "%02x %02x %02x %02x %02x %02x %02x %02x\n",
              data[i +  8], data[i +  9], data[i + 10], data[i + 11],
              data[i + 12], data[i + 13], data[i + 14], data[i + 15]);
    }

  if (i < length)
    {
      fprintf (e, "// %4lx:", i);
      while (i < length)
       {
         fprintf (e, " %02x", data[i]);
         ++i;
       }
      fprintf (e, "\n");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_fontdir ( FILE *  e,
const struct fontdir fontdir 
) [static]

Definition at line 2156 of file resrc.c.

{
  const struct fontdir *fc;

  for (fc = fontdir; fc != NULL; fc = fc->next)
    {
      fprintf (e, "// Font index: %d\n", fc->index);
      write_rc_filedata (e, fc->length, fc->data);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_group_cursor ( FILE *  e,
const struct group_cursor group_cursor 
) [static]

Definition at line 1976 of file resrc.c.

{
  const struct group_cursor *gc;

  for (gc = group_cursor; gc != NULL; gc = gc->next)
    {
      fprintf (e, "// width: %d; height %d; planes %d; bits %d\n",
            gc->width, gc->height, gc->planes, gc->bits);
      fprintf (e, "// data bytes: %lu; index: %d\n",
              gc->bytes, gc->index);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_group_icon ( FILE *  e,
const struct group_icon group_icon 
) [static]

Definition at line 2171 of file resrc.c.

{
  const struct group_icon *gi;

  for (gi = group_icon; gi != NULL; gi = gi->next)
    {
      fprintf (e, "// width: %d; height %d; colors: %d; planes %d; bits %d\n",
              gi->width, gi->height, gi->colors, gi->planes, gi->bits);
      fprintf (e, "// data bytes: %lu; index: %d\n",
              gi->bytes, gi->index);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_menu ( FILE *  e,
const struct menu menu,
int  menuex 
) [static]

Definition at line 2187 of file resrc.c.

{
  if (menu->help != 0)
    fprintf (e, "// Help ID: %lu\n", menu->help);
  write_rc_menuitems (e, menu->items, menuex, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_menuitems ( FILE *  e,
const struct menuitem menuitems,
int  menuex,
int  ind 
) [static]

Definition at line 2197 of file resrc.c.

{
  const struct menuitem *mi;

  indent (e, ind);
  fprintf (e, "BEGIN\n");

  for (mi = menuitems; mi != NULL; mi = mi->next)
    {
      indent (e, ind + 2);

      if (mi->popup == NULL)
       fprintf (e, "MENUITEM");
      else
       fprintf (e, "POPUP");

      if (! menuex
         && mi->popup == NULL
         && mi->text == NULL
         && mi->type == 0
         && mi->id == 0)
       {
         fprintf (e, " SEPARATOR\n");
         continue;
       }

      if (mi->text == NULL)
       fprintf (e, " \"\"");
      else
       {
         fprintf (e, " \"");
         unicode_print (e, mi->text, -1);
         fprintf (e, "\"");
       }

      if (! menuex)
       {
         if (mi->popup == NULL)
           fprintf (e, ", %d", mi->id);

         if ((mi->type & MENUITEM_CHECKED) != 0)
           fprintf (e, ", CHECKED");
         if ((mi->type & MENUITEM_GRAYED) != 0)
           fprintf (e, ", GRAYED");
         if ((mi->type & MENUITEM_HELP) != 0)
           fprintf (e, ", HELP");
         if ((mi->type & MENUITEM_INACTIVE) != 0)
           fprintf (e, ", INACTIVE");
         if ((mi->type & MENUITEM_MENUBARBREAK) != 0)
           fprintf (e, ", MENUBARBREAK");
         if ((mi->type & MENUITEM_MENUBREAK) != 0)
           fprintf (e, ", MENUBREAK");
       }
      else
       {
         if (mi->id != 0 || mi->type != 0 || mi->state != 0 || mi->help != 0)
           {
             fprintf (e, ", %d", mi->id);
             if (mi->type != 0 || mi->state != 0 || mi->help != 0)
              {
                fprintf (e, ", %lu", mi->type);
                if (mi->state != 0 || mi->help != 0)
                  {
                    fprintf (e, ", %lu", mi->state);
                    if (mi->help != 0)
                     fprintf (e, ", %lu", mi->help);
                  }
              }
           }
       }

      fprintf (e, "\n");

      if (mi->popup != NULL)
       write_rc_menuitems (e, mi->popup, menuex, ind + 2);
    }

  indent (e, ind);
  fprintf (e, "END\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_rcdata ( FILE *  e,
const struct rcdata_item rcdata,
int  ind 
) [static]

Definition at line 2283 of file resrc.c.

{
  const struct rcdata_item *ri;

  indent (e, ind);
  fprintf (e, "BEGIN\n");

  for (ri = rcdata; ri != NULL; ri = ri->next)
    {
      if (ri->type == RCDATA_BUFFER && ri->u.buffer.length == 0)
       continue;

      indent (e, ind + 2);

      switch (ri->type)
       {
       default:
         abort ();

       case RCDATA_WORD:
         fprintf (e, "%d", ri->u.word);
         break;

       case RCDATA_DWORD:
         fprintf (e, "%luL", ri->u.dword);
         break;

       case RCDATA_STRING:
         {
           const char *s;
           unsigned long i;

           fprintf (e, "\"");
           s = ri->u.string.s;
           for (i = 0; i < ri->u.string.length; i++)
             {
              if (ISPRINT (*s))
                putc (*s, e);
              else
                fprintf (e, "\\%03o", *s);
             }
           fprintf (e, "\"");
           break;
         }

       case RCDATA_WSTRING:
         fprintf (e, "L\"");
         unicode_print (e, ri->u.wstring.w, ri->u.wstring.length);
         fprintf (e, "\"");
         break;

       case RCDATA_BUFFER:
         {
           unsigned long i;
           int first;

           /* Assume little endian data.  */

           first = 1;
           for (i = 0; i + 3 < ri->u.buffer.length; i += 4)
             {
              unsigned long l;
              int j;

              if (! first)
                indent (e, ind + 2);
              l = ((((((ri->u.buffer.data[i + 3] << 8)
                      | ri->u.buffer.data[i + 2]) << 8)
                     | ri->u.buffer.data[i + 1]) << 8)
                   | ri->u.buffer.data[i]);
              fprintf (e, "%luL", l);
              if (i + 4 < ri->u.buffer.length || ri->next != NULL)
                fprintf (e, ",");
              for (j = 0; j < 4; ++j)
                if (! ISPRINT (ri->u.buffer.data[i + j])
                    && ri->u.buffer.data[i + j] != 0)
                  break;
              if (j >= 4)
                {
                  fprintf (e, "\t// ");
                  for (j = 0; j < 4; ++j)
                    {
                     if (! ISPRINT (ri->u.buffer.data[i + j]))
                       fprintf (e, "\\%03o", ri->u.buffer.data[i + j]);
                     else
                       {
                         if (ri->u.buffer.data[i + j] == '\\')
                           fprintf (e, "\\");
                         fprintf (e, "%c", ri->u.buffer.data[i + j]);
                       }
                    }
                }
              fprintf (e, "\n");
              first = 0;
             }

           if (i + 1 < ri->u.buffer.length)
             {
              int s;
              int j;

              if (! first)
                indent (e, ind + 2);
              s = (ri->u.buffer.data[i + 1] << 8) | ri->u.buffer.data[i];
              fprintf (e, "%d", s);
              if (i + 2 < ri->u.buffer.length || ri->next != NULL)
                fprintf (e, ",");
              for (j = 0; j < 2; ++j)
                if (! ISPRINT (ri->u.buffer.data[i + j])
                    && ri->u.buffer.data[i + j] != 0)
                  break;
              if (j >= 2)
                {
                  fprintf (e, "\t// ");
                  for (j = 0; j < 2; ++j)
                    {
                     if (! ISPRINT (ri->u.buffer.data[i + j]))
                       fprintf (e, "\\%03o", ri->u.buffer.data[i + j]);
                     else
                       {
                         if (ri->u.buffer.data[i + j] == '\\')
                           fprintf (e, "\\");
                         fprintf (e, "%c", ri->u.buffer.data[i + j]);
                       }
                    }
                }
              fprintf (e, "\n");
              i += 2;
              first = 0;
             }

           if (i < ri->u.buffer.length)
             {
              if (! first)
                indent (e, ind + 2);
              if ((ri->u.buffer.data[i] & 0x7f) == ri->u.buffer.data[i]
                  && ISPRINT (ri->u.buffer.data[i]))
                fprintf (e, "\"%c\"", ri->u.buffer.data[i]);
              else
                fprintf (e, "\"\\%03o\"", ri->u.buffer.data[i]);
              if (ri->next != NULL)
                fprintf (e, ",");
              fprintf (e, "\n");
              first = 0;
             }

           break;
         }
       }

      if (ri->type != RCDATA_BUFFER)
       {
         if (ri->next != NULL)
           fprintf (e, ",");
         fprintf (e, "\n");
       }
    }

  indent (e, ind);
  fprintf (e, "END\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_resource ( FILE *  e,
const struct res_id type,
const struct res_id name,
const struct res_resource res,
int language 
) [static]

Definition at line 1664 of file resrc.c.

{
  const char *s;
  int rt;
  int menuex = 0;

  fprintf (e, "\n");

  switch (res->type)
    {
    default:
      abort ();

    case RES_TYPE_ACCELERATOR:
      s = "ACCELERATOR";
      rt = RT_ACCELERATOR;
      break;

    case RES_TYPE_BITMAP:
      s = "BITMAP";
      rt = RT_BITMAP;
      break;

    case RES_TYPE_CURSOR:
      s = "CURSOR";
      rt = RT_CURSOR;
      break;

    case RES_TYPE_GROUP_CURSOR:
      s = "GROUP_CURSOR";
      rt = RT_GROUP_CURSOR;
      break;

    case RES_TYPE_DIALOG:
      if (extended_dialog (res->u.dialog))
       s = "DIALOGEX";
      else
       s = "DIALOG";
      rt = RT_DIALOG;
      break;

    case RES_TYPE_FONT:
      s = "FONT";
      rt = RT_FONT;
      break;

    case RES_TYPE_FONTDIR:
      s = "FONTDIR";
      rt = RT_FONTDIR;
      break;

    case RES_TYPE_ICON:
      s = "ICON";
      rt = RT_ICON;
      break;

    case RES_TYPE_GROUP_ICON:
      s = "GROUP_ICON";
      rt = RT_GROUP_ICON;
      break;

    case RES_TYPE_MENU:
      if (extended_menu (res->u.menu))
       {
         s = "MENUEX";
         menuex = 1;
       }
      else
       {
         s = "MENU";
         menuex = 0;
       }
      rt = RT_MENU;
      break;

    case RES_TYPE_MESSAGETABLE:
      s = "MESSAGETABLE";
      rt = RT_MESSAGETABLE;
      break;

    case RES_TYPE_RCDATA:
      s = "RCDATA";
      rt = RT_RCDATA;
      break;

    case RES_TYPE_STRINGTABLE:
      s = "STRINGTABLE";
      rt = RT_STRING;
      break;

    case RES_TYPE_USERDATA:
      s = NULL;
      rt = 0;
      break;

    case RES_TYPE_VERSIONINFO:
      s = "VERSIONINFO";
      rt = RT_VERSION;
      break;
    }

  if (rt != 0
      && type != NULL
      && (type->named || type->u.id != (unsigned long) rt))
    {
      fprintf (e, "// Unexpected resource type mismatch: ");
      res_id_print (e, *type, 1);
      fprintf (e, " != %d", rt);
    }

  if (res->coff_info.codepage != 0)
    fprintf (e, "// Code page: %lu\n", res->coff_info.codepage);
  if (res->coff_info.reserved != 0)
    fprintf (e, "// COFF reserved value: %lu\n", res->coff_info.reserved);

  if (name != NULL)
    res_id_print (e, *name, 0);
  else
    fprintf (e, "??Unknown-Name??");

  fprintf (e, " ");
  if (s != NULL)
    fprintf (e, "%s", s);
  else if (type != NULL)
    res_id_print (e, *type, 0);
  else
    fprintf (e, "??Unknown-Type??");

  if (res->res_info.memflags != 0)
    {
      if ((res->res_info.memflags & MEMFLAG_MOVEABLE) != 0)
       fprintf (e, " MOVEABLE");
      if ((res->res_info.memflags & MEMFLAG_PURE) != 0)
       fprintf (e, " PURE");
      if ((res->res_info.memflags & MEMFLAG_PRELOAD) != 0)
       fprintf (e, " PRELOAD");
      if ((res->res_info.memflags & MEMFLAG_DISCARDABLE) != 0)
       fprintf (e, " DISCARDABLE");
    }

  if (res->type == RES_TYPE_DIALOG)
    {
      fprintf (e, " %d, %d, %d, %d", res->u.dialog->x, res->u.dialog->y,
              res->u.dialog->width, res->u.dialog->height);
      if (res->u.dialog->ex != NULL
         && res->u.dialog->ex->help != 0)
       fprintf (e, ", %lu", res->u.dialog->ex->help);
    }

  fprintf (e, "\n");

  if ((res->res_info.language != 0 && res->res_info.language != *language)
      || res->res_info.characteristics != 0
      || res->res_info.version != 0)
    {
      int modifiers;

      switch (res->type)
       {
       case RES_TYPE_ACCELERATOR:
       case RES_TYPE_DIALOG:
       case RES_TYPE_MENU:
       case RES_TYPE_RCDATA:
       case RES_TYPE_STRINGTABLE:
         modifiers = 1;
         break;

       default:
         modifiers = 0;
         break;
       }

      if (res->res_info.language != 0 && res->res_info.language != *language)
       fprintf (e, "%sLANGUAGE %d, %d\n",
               modifiers ? "// " : "",
               res->res_info.language & ((1<<SUBLANG_SHIFT)-1),
               (res->res_info.language >> SUBLANG_SHIFT) & 0xff);
      if (res->res_info.characteristics != 0)
       fprintf (e, "%sCHARACTERISTICS %lu\n",
               modifiers ? "// " : "",
               res->res_info.characteristics);
      if (res->res_info.version != 0)
       fprintf (e, "%sVERSION %lu\n",
               modifiers ? "// " : "",
               res->res_info.version);
    }

  switch (res->type)
    {
    default:
      abort ();

    case RES_TYPE_ACCELERATOR:
      write_rc_accelerators (e, res->u.acc);
      break;

    case RES_TYPE_CURSOR:
      write_rc_cursor (e, res->u.cursor);
      break;

    case RES_TYPE_GROUP_CURSOR:
      write_rc_group_cursor (e, res->u.group_cursor);
      break;

    case RES_TYPE_DIALOG:
      write_rc_dialog (e, res->u.dialog);
      break;

    case RES_TYPE_FONTDIR:
      write_rc_fontdir (e, res->u.fontdir);
      break;

    case RES_TYPE_GROUP_ICON:
      write_rc_group_icon (e, res->u.group_icon);
      break;

    case RES_TYPE_MENU:
      write_rc_menu (e, res->u.menu, menuex);
      break;

    case RES_TYPE_RCDATA:
      write_rc_rcdata (e, res->u.rcdata, 0);
      break;

    case RES_TYPE_STRINGTABLE:
      write_rc_stringtable (e, name, res->u.stringtable);
      break;

    case RES_TYPE_USERDATA:
      write_rc_rcdata (e, res->u.userdata, 0);
      break;

    case RES_TYPE_VERSIONINFO:
      write_rc_versioninfo (e, res->u.versioninfo);
      break;

    case RES_TYPE_BITMAP:
    case RES_TYPE_FONT:
    case RES_TYPE_ICON:
    case RES_TYPE_MESSAGETABLE:
      write_rc_filedata (e, res->u.data.length, res->u.data.data);
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_stringtable ( FILE *  e,
const struct res_id name,
const struct stringtable stringtable 
) [static]

Definition at line 2448 of file resrc.c.

{
  unsigned long offset;
  int i;

  if (name != NULL && ! name->named)
    offset = (name->u.id - 1) << 4;
  else
    {
      fprintf (e, "// %s string table name\n",
              name == NULL ? "Missing" : "Invalid");
      offset = 0;
    }

  fprintf (e, "BEGIN\n");

  for (i = 0; i < 16; i++)
    {
      if (stringtable->strings[i].length != 0)
       {
         fprintf (e, "  %lu, \"", offset + i);
         unicode_print (e, stringtable->strings[i].string,
                      stringtable->strings[i].length);
         fprintf (e, "\"\n");
       }
    }

  fprintf (e, "END\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_subdir ( FILE *  e,
const struct res_entry re,
const struct res_id type,
const struct res_id name,
int language,
int  level 
) [static]

Definition at line 1589 of file resrc.c.

{
  fprintf (e, "\n");
  switch (level)
    {
    case 1:
      fprintf (e, "// Type: ");
      if (re->id.named)
       res_id_print (e, re->id, 1);
      else
       {
         const char *s;

         switch (re->id.u.id)
           {
           case RT_CURSOR: s = "cursor"; break;
           case RT_BITMAP: s = "bitmap"; break;
           case RT_ICON: s = "icon"; break;
           case RT_MENU: s = "menu"; break;
           case RT_DIALOG: s = "dialog"; break;
           case RT_STRING: s = "stringtable"; break;
           case RT_FONTDIR: s = "fontdir"; break;
           case RT_FONT: s = "font"; break;
           case RT_ACCELERATOR: s = "accelerators"; break;
           case RT_RCDATA: s = "rcdata"; break;
           case RT_MESSAGETABLE: s = "messagetable"; break;
           case RT_GROUP_CURSOR: s = "group cursor"; break;
           case RT_GROUP_ICON: s = "group icon"; break;
           case RT_VERSION: s = "version"; break;
           case RT_DLGINCLUDE: s = "dlginclude"; break;
           case RT_PLUGPLAY: s = "plugplay"; break;
           case RT_VXD: s = "vxd"; break;
           case RT_ANICURSOR: s = "anicursor"; break;
           case RT_ANIICON: s = "aniicon"; break;
           default: s = NULL; break;
           }

         if (s != NULL)
           fprintf (e, "%s", s);
         else
           res_id_print (e, re->id, 1);
       }
      fprintf (e, "\n");
      break;

    case 2:
      fprintf (e, "// Name: ");
      res_id_print (e, re->id, 1);
      fprintf (e, "\n");
      break;

    case 3:
      fprintf (e, "// Language: ");
      res_id_print (e, re->id, 1);
      fprintf (e, "\n");
      break;

    default:
      fprintf (e, "// Level %d: ", level);
      res_id_print (e, re->id, 1);
      fprintf (e, "\n");
    }

  write_rc_directory (e, re->u.dir, type, name, language, level + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void write_rc_versioninfo ( FILE *  e,
const struct versioninfo versioninfo 
) [static]

Definition at line 2482 of file resrc.c.

{
  const struct fixed_versioninfo *f;
  const struct ver_info *vi;

  f = versioninfo->fixed;
  if (f->file_version_ms != 0 || f->file_version_ls != 0)
    fprintf (e, " FILEVERSION %lu, %lu, %lu, %lu\n",
            (f->file_version_ms >> 16) & 0xffff,
            f->file_version_ms & 0xffff,
            (f->file_version_ls >> 16) & 0xffff,
            f->file_version_ls & 0xffff);
  if (f->product_version_ms != 0 || f->product_version_ls != 0)
    fprintf (e, " PRODUCTVERSION %lu, %lu, %lu, %lu\n",
            (f->product_version_ms >> 16) & 0xffff,
            f->product_version_ms & 0xffff,
            (f->product_version_ls >> 16) & 0xffff,
            f->product_version_ls & 0xffff);
  if (f->file_flags_mask != 0)
    fprintf (e, " FILEFLAGSMASK 0x%lx\n", f->file_flags_mask);
  if (f->file_flags != 0)
    fprintf (e, " FILEFLAGS 0x%lx\n", f->file_flags);
  if (f->file_os != 0)
    fprintf (e, " FILEOS 0x%lx\n", f->file_os);
  if (f->file_type != 0)
    fprintf (e, " FILETYPE 0x%lx\n", f->file_type);
  if (f->file_subtype != 0)
    fprintf (e, " FILESUBTYPE 0x%lx\n", f->file_subtype);
  if (f->file_date_ms != 0 || f->file_date_ls != 0)
    fprintf (e, "// Date: %lu, %lu\n", f->file_date_ms, f->file_date_ls);

  fprintf (e, "BEGIN\n");

  for (vi = versioninfo->var; vi != NULL; vi = vi->next)
    {
      switch (vi->type)
       {
       case VERINFO_STRING:
         {
           const struct ver_stringinfo *vs;

           fprintf (e, "  BLOCK \"StringFileInfo\"\n");
           fprintf (e, "  BEGIN\n");
           fprintf (e, "    BLOCK \"");
           unicode_print (e, vi->u.string.language, -1);
           fprintf (e, "\"\n");
           fprintf (e, "    BEGIN\n");

           for (vs = vi->u.string.strings; vs != NULL; vs = vs->next)
             {
              fprintf (e, "      VALUE \"");
              unicode_print (e, vs->key, -1);
              fprintf (e, "\", \"");
              unicode_print (e, vs->value, -1);
              fprintf (e, "\"\n");
             }

           fprintf (e, "    END\n");
           fprintf (e, "  END\n");
           break;
         }

       case VERINFO_VAR:
         {
           const struct ver_varinfo *vv;

           fprintf (e, "  BLOCK \"VarFileInfo\"\n");
           fprintf (e, "  BEGIN\n");
           fprintf (e, "    VALUE \"");
           unicode_print (e, vi->u.var.key, -1);
           fprintf (e, "\"");

           for (vv = vi->u.var.var; vv != NULL; vv = vv->next)
             fprintf (e, ", 0x%x, %d", (unsigned int) vv->language,
                     vv->charset);

           fprintf (e, "\n  END\n");

           break;
         }
       }
    }

  fprintf (e, "END\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

void yyerror ( const char *  msg)

Definition at line 519 of file resrc.c.

{
  fatal ("%s:%d: %s", rc_filename, rc_lineno, msg);
}

Here is the call graph for this function:


Variable Documentation

struct control_info[] [static]
Initial value:
{
  { "AUTO3STATE", CTL_BUTTON, BS_AUTO3STATE },
  { "AUTOCHECKBOX", CTL_BUTTON, BS_AUTOCHECKBOX },
  { "AUTORADIOBUTTON", CTL_BUTTON, BS_AUTORADIOBUTTON },
  { "CHECKBOX", CTL_BUTTON, BS_CHECKBOX },
  { "COMBOBOX", CTL_COMBOBOX, (unsigned long) -1 },
  { "CTEXT", CTL_STATIC, SS_CENTER },
  { "DEFPUSHBUTTON", CTL_BUTTON, BS_DEFPUSHBUTTON },
  { "EDITTEXT", CTL_EDIT, (unsigned long) -1 },
  { "GROUPBOX", CTL_BUTTON, BS_GROUPBOX },
  { "ICON", CTL_STATIC, SS_ICON },
  { "LISTBOX", CTL_LISTBOX, (unsigned long) -1 },
  { "LTEXT", CTL_STATIC, SS_LEFT },
  { "PUSHBOX", CTL_BUTTON, BS_PUSHBOX },
  { "PUSHBUTTON", CTL_BUTTON, BS_PUSHBUTTON },
  { "RADIOBUTTON", CTL_BUTTON, BS_RADIOBUTTON },
  { "RTEXT", CTL_STATIC, SS_RIGHT },
  { "SCROLLBAR", CTL_SCROLLBAR, (unsigned long) -1 },
  { "STATE3", CTL_BUTTON, BS_3STATE },
  
  { "USERBUTTON", CTL_BUTTON, (unsigned long) -1 },
  { NULL, 0, 0 }
}

Definition at line 2056 of file resrc.c.

FILE* cpp_pipe [static]

Definition at line 128 of file resrc.c.

char* cpp_temp_file [static]

Definition at line 133 of file resrc.c.

int cursors [static]

Definition at line 145 of file resrc.c.

Definition at line 153 of file resrc.c.

int fonts [static]

Definition at line 149 of file resrc.c.

int icons [static]

Definition at line 161 of file resrc.c.

enum { ... } istream_type [static]
char* rc_filename

Definition at line 120 of file resrc.c.

Definition at line 124 of file resrc.c.

Definition at line 141 of file resrc.c.