Changeset 5522 for trunk/tools

Timestamp:

Apr 16, 2001, 7:11:03 PM (24 years ago)

Author:

sandervl

Message:

updates

Location:

trunk/tools/wrc

Files:

• Makefile.in (modified) (3 diffs)
• README.wrc (modified) (11 diffs)
• dumpres.c (modified) (32 diffs)
• dumpres.h (modified) (1 diff)
• genres.c (modified) (54 diffs)
• lexyy.c (modified) (40 diffs)
• makefile.os2 (modified) (5 diffs)
• newstruc.c (modified) (10 diffs)
• newstruc.h (modified) (2 diffs)
• parser.h (modified) (1 diff)
• parser.l (modified) (29 diffs)
• parser.y (modified) (104 diffs)
• ppl.l (added)
• ppy.tab.c (added)
• ppy.tab.h (added)
• ppy.y (added)
• preproc.c (modified) (11 diffs)
• preproc.h (modified) (1 diff)
• readres.c (modified) (6 diffs)

trunk/tools/wrc/Makefile.in

@@ -4 +4 @@
 SRCDIR    = @srcdir@
 VPATH     = @srcdir@
+LEXOPT    = -Cf #-w -b
+YACCOPT   = #-v
 
-PROGRAMS = wrc@PROGEXT@
+PROGRAMS = wrc
 MODULE   = none
 
@@ -18 +20 @@
         writeres.c
 
+GEN_C_SRCS = ppy.tab.c lex.ppl.c
 EXTRA_SRCS = parser.y parser.l
 EXTRA_OBJS = y.tab.o lex.yy.o
@@ -23 +26 @@
 all: $(PROGRAMS)
 
-depend:: y.tab.h
-
 @MAKE_RULES@
 
-wrc@PROGEXT@: $(OBJS)
-        $(CC) $(CFLAGS) -o wrc@PROGEXT@ $(OBJS) $(LEXLIB)
+wrc: $(OBJS) $(TOPOBJDIR)/unicode/libwine_unicode.$(LIBEXT)
+        $(CC) $(CFLAGS) -o wrc $(OBJS) $(LIBUNICODE) $(LEXLIB) $(LDFLAGS)
+
+$(TOPOBJDIR)/unicode/libwine_unicode.$(LIBEXT):
+        cd `dirname $@` && $(MAKE) `basename $@`
 
 y.tab.c y.tab.h: parser.y
-        $(YACC) -d -t $(SRCDIR)/parser.y
+        $(YACC) $(YACCOPT) -d -t $(SRCDIR)/parser.y
+
+ppy.tab.c ppy.tab.h: ppy.y
+        $(YACC) $(YACCOPT) -bppy -ppp -d -t $(SRCDIR)/ppy.y
 
 lex.yy.c: parser.l
-        $(LEX) -8 $(SRCDIR)/parser.l
+        $(LEX) $(LEXOPT) -d -8 $(SRCDIR)/parser.l
+
+lex.ppl.c: ppl.l
+        $(LEX) $(LEXOPT) -d -Ppp -8 -olex.ppl.c $(SRCDIR)/ppl.l
 
 clean::
-        $(RM) y.tab.c y.tab.h lex.yy.c
+        $(RM) ppy.tab.h ppy.output parser.output parser.tab.h lex.backup y.output
+
+install:: $(PROGRAMS)
+        [ -d $(bindir) ] || $(MKDIR) $(bindir)
+        [ -d $(mandir)/man$(prog_manext) ] || $(MKDIR) $(mandir)/man$(prog_manext)
+        $(INSTALL_DATA) $(SRCDIR)/wrc.man $(mandir)/man$(prog_manext)/wrc.$(prog_manext)
+        $(INSTALL_PROGRAM) wrc $(bindir)/wrc
+
+uninstall::
+        $(RM) $(bindir)/wrc $(mandir)/man$(prog_manext)/wrc.$(prog_manext)
 
 ### Dependencies:

trunk/tools/wrc/README.wrc

@@ -1 @@
-Release 1.0.2 of wrc (20-Jun-1998), the wine resource compiler.
+Release 1.1.8 of wrc (24-Aug-2000), the wine resource compiler.
 
 See the file CHANGES for differences between the version and what has been
@@ -6 +6 @@
 Wrc features:
 
-- source preprocessing
+- full source preprocessing
 - 16 and 32 bit support
 - LANGUAGE support (32 bit only)
-- almost all resource types are supported
+- most resource types are supported
 - enhanced expression capabilities and resource naming
 - indirect loadable resources
 - NE/PE resource directory generation
 - binary .res file generation/reading
+- byte-order conversions
 
 Wrc generates an assembly file that can be assembled with GNU's gas, or
@@ -35 +36 @@
    -D id[=val] Define preprocessor identifier id=val
    -e          Disable recognition of win32 keywords in 16bit compile
+   -E          Preprocess only
    -g          Add symbols to the global c namespace
    -h          Also generate a .h file
    -H file     Same as -h but written to file
    -I path     Set include search dir to path (multiple -I allowed)
-   -l lan      Set default language to lan (default is neutral {0})
+   -l lan      Set default language to lan (default is neutral {0, 0})
    -L          Leave case of embedded filenames as is
+   -m          Do not remap numerical resource IDs
    -n          Do not generate .s file
+   -N          Do not preprocess input
    -o file     Output to file (default is infile.[res|s|h]
    -p prefix   Give a prefix for the generated names
@@ -58 +62 @@
     * 0x02 Dump internal structures
     * 0x04 Create a parser trace (yydebug=1)
+    * 0x08 Preprocessor messages
+    * 0x10 Preprocessor lex messages
+    * 0x20 Preprocessor yacc trace
 
 The -o option only applies to the final destination file, which is
@@ -65 +72 @@
 with -o and/or -H, then the output is written to "wrc.tab.[sh]"
 
+For more info see the wrc manpage.
+
 
 Preprocessing
 -------------
-The build-in preprocessor is not a full implementation of the C counterpart.
-Wrc does not understand function-type macros. These are discarded as they
-are scanned. This will be a future project. Wrc does understand these:
-#define
+The preprocessor is a fully operational C preprocessor. It handles all
+directives supported by ANSI-C. It also includes some additions from
+gcc/egcs.
+Wrc understands these directives:
+#define         (both simple and macro)
+#undef
 #if
 #ifdef
@@ -79 +90 @@
 #endif
 #error
-
-Also 'defined' is supported as operator (both with and without parenthesis).
-'#if' expressions can be anything valid that evaluates to an integer
-expression (where 0 is false and anything else is true). Others (#pragma,
-#line) are ignored. A special case '#' generates an error. This is due to
-the implementation to enable generation of errors on preprocessing and will
-be improved in the future.
+#warning
+#line
+#
+#pragma         (ignored)
+#ident          (ignored)
+
+The extensions include '#'-line directives.
+Not handled at the moment are variable argument macros. They are parsed,
+but not expanded properly. This will be corrected in the future.
+
+The preprocessor handles the special defines and aditionally defines an
+extra set of defines:
+  Define       | Value         | Comment
+---------------+---------------+---------------
+RC_INVOKED     | 1             | Always defined
+__FLAT__       | 1             | Only defined if win32 compile
+__WIN32__      | 1             | Only defined if win32 compile
+__FILE__       | "..."         | Current filename as string
+__LINE__       | nnn           | Current linenumber as integer
+__TIME__       | "23:59:59"    | Timestring of compilation
+__DATE__       | "May  1 2000" | Datestring of compilation
+__WRC__        | 1             | Wrc's major version
+__WRC_MINOR__  | 1             | Wrc's minor version
+__WRC_MICRO__  | 7             | Wrc's minor version
+__WRC_PATCH__  | 8             | Alias of __WRC_MICRO__
+
+Include-files are not read twice if they are protected with this scheme:
+#ifndef SOME_DEFINE
+#define SOME_DEFINE
+...
+#endif
+This strategy has been borrowed from gcc/egcs and results in significantly
+reduced preprocessing times (20..30%). There must not be any junk before
+the first #ifndef and not after the last #endif; comments and whitespace
+excepted. Wrc will check the existance of the define prior to inclusion to
+detect "#undef SOME_DEFINE" (notably poppack.h) and act accordingly.
 
 
@@ -106 +146 @@
 compiler runs on.
 
-Not all resource-types can have local language keywords attached yet
-(notably: BITMAP, CURSOR, ICON and usertype). This is due to implementation
-of filename-scanning and the complexity that it poses. This will be changed
-in the next release. You can work arround this problem by putting a LANGUAGE
-statement before (and evt. after) the code in the resource file.
+Language, version and characteristics can be bound to all resource types that
+have inline data, such as RCDATA. This is an extension to MS' resource
+compiler, which lacks this support completely. Only VERSIONINFO cannot have
+version and characteristics attached, but languages are propagated properly if
+you declare it correctly before the VERSIONINFO resource starts.
+
+Example:
+
+1 RCDATA DISCARDABLE
+LANGUAGE 1, 0
+VERSION 312
+CHARACTERISTICS 876
+{
+        1, 2, 3, 4, 5, "and whatever more data you want"
+        '00 01 02 03 04 05 06 07 08'
+}
 
 
@@ -116 +167 @@
 ------------------------
 All types are supported except for:
-- FONT
-- MESSAGETABLE
-- extensions like TOOLBAR and the like (is this a user-type?)
+- RT_VXD
+- RT_PLUGPLAY
+- RT_HTML
+- RT_DLGINCLUDE
 
 These types will be implemented as soon as I get a proper specification of
 the layout.
 
-Note: Usertype resources with character strings as types have a different
-layout and do not accept expressions when a numerical type is specified. The
-must be enclosed in double quotes. These are examples of valid usertype
-resources:
-
-MyName "MyType" mydata.bin
-MyName 12345    mydata.bin
-MyName "MyType" "mydata.bin"
-MyName 12345    "mydata.bin"
-
-MyName "MyType"
-{
-  ..., data, ...
-}
-
-or
-
-MyName 12345
-{
- ..., data, ...
-}
+Font type resources (RT_FONT, RT_FONTDIR) are partially supported and will
+be enhanced when I have the complete spec. The font resources work only if
+you supply the FONTDIR resource yourself.
 
 
@@ -153 +187 @@
 *       multiply
 /       divide
-+       add
++       plus/add
 -       minus/substract
 |       binary or
@@ -160 +194 @@
 NOT     ... (sigh)
 
-Minus (-) can both be unary and binary. The NOT operator is (primarily)
-used to disable window styles but I strongly suggest to refrain from using
-this operator.
-There is a shift/reduce conflict on the unary minus, but this is not
-problematic. I was too lazy to make a new expression parser (next version or
-so). Unary plus (+) would cause another confilct, so I let it out for now.
+Plus (+) and minus (-) can both be unary and binary. The NOT operator is
+(primarily) used to disable window styles but I strongly suggest to refrain
+from using this operator.
 
 Resource names can be both numerical (expressions) and character typed. Wrc
-does supports this insane (deep sigh) construct:
+does support this insane (deep sigh) construct:
 
 MENU MENU
@@ -248 +279 @@
 - No codepage translation
 - UNICODE translations are not/not correct implemented
-- No documentation ('wrc -?' gives command-line options though)
+- No documentation ('wrc -?' gives command-line options and a manpage)
 - grep for FIXME in the source
 - Memory options are wrong under some conditions. There seems to be a
-  different action for win32 and win16.
-- User-type resources have slightly different layout.
-- Filename scanning is still hopeless.
+  different action for win32 and win16
+- PUSHBOX control is unsupported. The MS docs use it plenty, but neither
+  MS' nor Borland's compiler supports it.
 
 Reporting bugs and patches

trunk/tools/wrc/dumpres.c

@@ -47 +47 @@
         case res_dlginit: return "DLGINIT";
         case res_toolbar: return "TOOLBAR";
+        case res_anicur:  return "CURSOR (animated)";
+        case res_aniico:  return "ICON (animated)";
         default:        return "Unknown";
         }
@@ -153 +155 @@
  *****************************************************************************
 */
-void dump_memopt(DWORD memopt)
+static void dump_memopt(DWORD memopt)
 {
         printf("Memory/load options: ");
@@ -184 +186 @@
  *****************************************************************************
 */
-void dump_lvc(lvc_t *l)
+static void dump_lvc(lvc_t *l)
 {
         if(l->language)
@@ -213 +215 @@
  *****************************************************************************
 */
-void dump_raw_data(raw_data_t *d)
-{
-        int n;
+static void dump_raw_data(raw_data_t *d)
+{
+        unsigned int n;
         int i;
         int j;
@@ -236 +238 @@
                                 printf("- ");
                                 for(i = 0; i < 16; i++)
-                                        printf("%c", isprint(d->data[n-16+i]) ? d->data[n-16+i] : '.');
+                                        printf("%c", isprint(d->data[n-16+i] & 0xff) ? d->data[n-16+i] : '.');
                                 printf("\n%08x: ", n);
                         }
@@ -249 +251 @@
                 j = 16;
         for(i = 0; i < j; i++)
-                printf("%c", isprint(d->data[n-j+i]) ? d->data[n-j+i] : '.');
+                printf("%c", isprint(d->data[n-j+i] & 0xff) ? d->data[n-j+i] : '.');
         printf("\n");
 }
@@ -264 +266 @@
  *****************************************************************************
 */
-void dump_accelerator(accelerator_t *acc)
+static void dump_accelerator(accelerator_t *acc)
 {
         event_t *ev = acc->events;
@@ -298 +300 @@
  *****************************************************************************
 */
-void dump_cursor(cursor_t *cur)
+static void dump_cursor(cursor_t *cur)
 {
         printf("Id: %d\n", cur->id);
@@ -319 +321 @@
  *****************************************************************************
 */
-void dump_cursor_group(cursor_group_t *curg)
+static void dump_cursor_group(cursor_group_t *curg)
 {
         dump_memopt(curg->memopt);
@@ -336 +338 @@
  *****************************************************************************
 */
-void dump_icon(icon_t *ico)
+static void dump_icon(icon_t *ico)
 {
         printf("Id: %d\n", ico->id);
@@ -358 +360 @@
  *****************************************************************************
 */
-void dump_icon_group(icon_group_t *icog)
+static void dump_icon_group(icon_group_t *icog)
 {
         dump_memopt(icog->memopt);
@@ -366 +368 @@
 /*
  *****************************************************************************
+ * Function     : dump_ani_curico
+ * Syntax       : void dump_ani_curico(ani_curico_t *ani)
+ * Input        :
+ *      ani     - Animated object resource descriptor
+ * Output       : nop
+ * Description  :
+ * Remarks      :
+ *****************************************************************************
+*/
+static void dump_ani_curico(ani_curico_t *ani)
+{
+        dump_memopt(ani->memopt);
+        dump_lvc(&ani->data->lvc);
+        dump_raw_data(ani->data);
+}
+
+/*
+ *****************************************************************************
  * Function     : dump_font
  * Syntax       : void dump_font(font_t *fnt)
@@ -375 +395 @@
  *****************************************************************************
 */
-void dump_font(font_t *fnt)
+static void dump_font(font_t *fnt)
 {
         dump_memopt(fnt->memopt);
+        dump_lvc(&(fnt->data->lvc));
         dump_raw_data(fnt->data);
 }
@@ -392 +413 @@
  *****************************************************************************
 */
-void dump_bitmap(bitmap_t *bmp)
+static void dump_bitmap(bitmap_t *bmp)
 {
         dump_memopt(bmp->memopt);
+        dump_lvc(&(bmp->data->lvc));
         dump_raw_data(bmp->data);
 }
@@ -409 +431 @@
  *****************************************************************************
 */
-void dump_rcdata(rcdata_t *rdt)
+static void dump_rcdata(rcdata_t *rdt)
 {
         dump_memopt(rdt->memopt);
+        dump_lvc(&(rdt->data->lvc));
         dump_raw_data(rdt->data);
 }
@@ -426 +449 @@
  *****************************************************************************
 */
-void dump_user(user_t *usr)
+static void dump_user(user_t *usr)
 {
         dump_memopt(usr->memopt);
+        dump_lvc(&(usr->data->lvc));
         printf("Class %s\n", get_nameid_str(usr->type));
         dump_raw_data(usr->data);
@@ -444 +468 @@
  *****************************************************************************
 */
-void dump_messagetable(messagetable_t *msg)
-{
+static void dump_messagetable(messagetable_t *msg)
+{
+        dump_memopt(msg->memopt);
+        dump_lvc(&(msg->data->lvc));
         dump_raw_data(msg->data);
 }
@@ -460 +486 @@
  *****************************************************************************
 */
-void dump_stringtable(stringtable_t *stt)
+static void dump_stringtable(stringtable_t *stt)
 {
         int i;
@@ -492 +518 @@
  *****************************************************************************
 */
-void dump_control(control_t *ctrl)
+static void dump_control(control_t *ctrl)
 {
         printf("Control {\n\tClass: %s\n", get_nameid_str(ctrl->ctlclass));
@@ -531 +557 @@
  *****************************************************************************
 */
-void dump_dialog(dialog_t *dlg)
+static void dump_dialog(dialog_t *dlg)
 {
         control_t *c = dlg->controls;
@@ -581 +607 @@
  *****************************************************************************
 */
-void dump_dialogex(dialogex_t *dlgex)
+static void dump_dialogex(dialogex_t *dlgex)
 {
         control_t *c = dlgex->controls;
@@ -631 +657 @@
  *****************************************************************************
 */
-void dump_menu_item(menu_item_t *item)
+static void dump_menu_item(menu_item_t *item)
 {
         while(item)
@@ -669 +695 @@
  *****************************************************************************
 */
-void dump_menu(menu_t *men)
+static void dump_menu(menu_t *men)
 {
         dump_memopt(men->memopt);
@@ -686 +712 @@
  *****************************************************************************
 */
-void dump_menuex_item(menuex_item_t *item)
+static void dump_menuex_item(menuex_item_t *item)
 {
         while(item)
@@ -739 +765 @@
  *****************************************************************************
 */
-void dump_menuex(menuex_t *menex)
+static void dump_menuex(menuex_t *menex)
 {
         dump_memopt(menex->memopt);
@@ -756 +782 @@
  *****************************************************************************
 */
-void dump_ver_value(ver_value_t *val)
-{
-        extern void dump_ver_block(ver_block_t *);
+static void dump_ver_block(ver_block_t *);      /* Forward ref */
+
+static void dump_ver_value(ver_value_t *val)
+{
         if(val->type == val_str)
         {
@@ -792 +819 @@
  *****************************************************************************
 */
-void dump_ver_block(ver_block_t *blk)
+static void dump_ver_block(ver_block_t *blk)
 {
         ver_value_t *val = blk->values;
@@ -817 +844 @@
  *****************************************************************************
 */
-void dump_versioninfo(versioninfo_t *ver)
+static void dump_versioninfo(versioninfo_t *ver)
 {
         ver_block_t *blk = ver->blocks;
+
+        dump_lvc(&(ver->lvc));
 
         if(ver->gotit.fv)
@@ -860 +889 @@
  *****************************************************************************
 */
-void dump_toolbar_items(toolbar_item_t *items)
+static void dump_toolbar_items(toolbar_item_t *items)
 {
         while(items)
@@ -886 +915 @@
  *****************************************************************************
 */
-void dump_toolbar(toolbar_t *toolbar)
+static void dump_toolbar(toolbar_t *toolbar)
 {
         dump_memopt(toolbar->memopt);
@@ -904 +933 @@
  *****************************************************************************
 */
-void dump_dlginit(dlginit_t *dit)
+static void dump_dlginit(dlginit_t *dit)
 {
         dump_memopt(dit->memopt);
-        dump_lvc(&(dit->lvc));
+        dump_lvc(&(dit->data->lvc));
         dump_raw_data(dit->data);
 }
@@ -997 +1026 @@
                         dump_toolbar(top->res.tbt);
                         break;
+                case res_anicur:
+                case res_aniico:
+                        dump_ani_curico(top->res.ani);
+                        break;
                 default:
                         printf("Report this: Unknown resource type parsed %08x\n", top->type);

trunk/tools/wrc/dumpres.h

@@ -15 +15 @@
 char *get_typename(resource_t* r);
 void dump_resources(resource_t *top);
+char *get_nameid_str(name_id_t *n);
 
 #endif

trunk/tools/wrc/genres.c

@@ -4 +4 @@
  * Copyright 1998 Bertho A. Stultiens
  *
+ * 05-May-2000 BS       - Added code to support endian conversions. The
+ *                        extra functions also aid unaligned access, but
+ *                        this is not yet implemented.
  * 25-May-1998 BS       - Added simple unicode -> char conversion for resource
  *                        names in .s and .h files.  
@@ -20 +23 @@
 #include "utils.h"
 #include "windef.h"
+#include "winbase.h"
 #include "wingdi.h"
 #include "winuser.h"
 
-#define SetResSize(res, tag)    *(DWORD *)&((res)->data[(tag)]) = \
-                                (res)->size - *(DWORD *)&((res)->data[(tag)])
+#define SetResSize(res, tag)    set_dword((res), (tag), (res)->size - get_dword((res), (tag)))
 
 res_t *new_res(void)
@@ -64 +67 @@
         if(res->allocsize - res->size < sizeof(char))
                 grow_res(res, RES_BLOCKSIZE);
-        *(char *)&(res->data[res->size]) = (char)c;
+        res->data[res->size] = (char)c;
         res->size += sizeof(char);
 }
@@ -72 +75 @@
         if(res->allocsize - res->size < sizeof(WORD))
                 grow_res(res, RES_BLOCKSIZE);
-        *(WORD *)&(res->data[res->size]) = (WORD)w;
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                res->data[res->size+0] = HIBYTE(w);
+                res->data[res->size+1] = LOBYTE(w);
+                break;
+
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                res->data[res->size+1] = HIBYTE(w);
+                res->data[res->size+0] = LOBYTE(w);
+                break;
+        }
         res->size += sizeof(WORD);
 }
@@ -80 +100 @@
         if(res->allocsize - res->size < sizeof(DWORD))
                 grow_res(res, RES_BLOCKSIZE);
-        *(DWORD *)&(res->data[res->size]) = (DWORD)d;
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                res->data[res->size+0] = HIBYTE(HIWORD(d));
+                res->data[res->size+1] = LOBYTE(HIWORD(d));
+                res->data[res->size+2] = HIBYTE(LOWORD(d));
+                res->data[res->size+3] = LOBYTE(LOWORD(d));
+                break;
+
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                res->data[res->size+3] = HIBYTE(HIWORD(d));
+                res->data[res->size+2] = LOBYTE(HIWORD(d));
+                res->data[res->size+1] = HIBYTE(LOWORD(d));
+                res->data[res->size+0] = LOBYTE(LOWORD(d));
+                break;
+        }
         res->size += sizeof(DWORD);
 }
@@ -88 +129 @@
         while(res->size & 0x3)
                 put_byte(res, 0);
+}
+
+/*
+ *****************************************************************************
+ * Function     : set_word
+ *                set_dword
+ * Syntax       : void set_word(res_t *res, int ofs, unsigned w)
+ *                void set_dword(res_t *res, int ofs, unsigned d)
+ * Input        :
+ *      res     - Binary resource to put the data in
+ *      ofs     - Byte offset in data-array
+ *      w, d    - Data to put
+ * Output       : nop
+ * Description  : Set the value of a binary resource data array to a
+ *                specific value.
+ * Remarks      :
+ *****************************************************************************
+*/
+void set_word(res_t *res, int ofs, unsigned w)
+{
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                res->data[ofs+0] = HIBYTE(w);
+                res->data[ofs+1] = LOBYTE(w);
+                break;
+
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                res->data[ofs+1] = HIBYTE(w);
+                res->data[ofs+0] = LOBYTE(w);
+                break;
+        }
+}
+
+void set_dword(res_t *res, int ofs, unsigned d)
+{
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                res->data[ofs+0] = HIBYTE(HIWORD(d));
+                res->data[ofs+1] = LOBYTE(HIWORD(d));
+                res->data[ofs+2] = HIBYTE(LOWORD(d));
+                res->data[ofs+3] = LOBYTE(LOWORD(d));
+                break;
+
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                res->data[ofs+3] = HIBYTE(HIWORD(d));
+                res->data[ofs+2] = LOBYTE(HIWORD(d));
+                res->data[ofs+1] = HIBYTE(LOWORD(d));
+                res->data[ofs+0] = LOBYTE(LOWORD(d));
+                break;
+        }
+}
+
+/*
+ *****************************************************************************
+ * Function     : get_word
+ *                get_dword
+ * Syntax       : WORD get_word(res_t *res, int ofs)
+ *                DWORD get_dword(res_t *res, int ofs)
+ * Input        :
+ *      res     - Binary resource to put the data in
+ *      ofs     - Byte offset in data-array
+ * Output       : The data in native endian
+ * Description  : Get the value of a binary resource data array in native
+ *                endian.
+ * Remarks      :
+ *****************************************************************************
+*/
+WORD get_word(res_t *res, int ofs)
+{
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                return   (res->data[ofs+0] << 8)
+                       |  res->data[ofs+1];
+
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                return   (res->data[ofs+1] << 8)
+                       |  res->data[ofs+0];
+        }
+}
+
+DWORD get_dword(res_t *res, int ofs)
+{
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                return   (res->data[ofs+0] << 24)
+                       | (res->data[ofs+1] << 16)
+                       | (res->data[ofs+2] <<  8)
+                       |  res->data[ofs+3];
+
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                return   (res->data[ofs+3] << 24)
+                       | (res->data[ofs+2] << 16)
+                       | (res->data[ofs+1] <<  8)
+                       |  res->data[ofs+0];
+        }
 }
 
@@ -137 +301 @@
  *****************************************************************************
 */
-void put_string(res_t *res, string_t *str, enum str_e type, int isterm)
+static void put_string(res_t *res, string_t *str, enum str_e type, int isterm)
 {
         int cnt;
@@ -149 +313 @@
         }
 
+        str = convert_string(str, type);
         if(str->type == str_unicode && type == str_unicode)
         {
@@ -197 +362 @@
                         put_word(res, 0);
         }
+        free(str);
 }
 
@@ -255 +421 @@
         else
                 put_dword(res, 0);
+        if(lvc && lvc->language)
+            set_language( lvc->language->id, lvc->language->sub );
+        else if (currentlanguage)
+            set_language( currentlanguage->id, currentlanguage->sub );
+        else
+            set_language( LANG_NEUTRAL, SUBLANG_NEUTRAL );
 }
 
@@ -314 +486 @@
                 put_word(res, memopt);          /* Memory options */
                 put_lvc(res, lvc);              /* Language, version and characts */
-                ((DWORD *)res->data)[0] = res->size;    /* Set preliminary resource */
-                ((DWORD *)res->data)[1] = res->size;    /* Set HeaderSize */
+                set_dword(res, 0*sizeof(DWORD), res->size);     /* Set preliminary resource */
+                set_dword(res, 1*sizeof(DWORD), res->size);     /* Set HeaderSize */
                 res->dataidx = res->size;
                 return 0;
@@ -333 +505 @@
                 tag = res->size;
                 put_dword(res, 0);              /* ResSize overwritten later*/
-                *(DWORD *)&(res->data[tag]) = res->size;
+                set_dword(res, tag, res->size);
                 res->dataidx = res->size;
                 return tag;
@@ -351 +523 @@
  *****************************************************************************
 */
-res_t *accelerator2res(name_id_t *name, accelerator_t *acc)
+static res_t *accelerator2res(name_id_t *name, accelerator_t *acc)
 {
         int restag;
@@ -402 +574 @@
  *****************************************************************************
 */
-res_t *dialog2res(name_id_t *name, dialog_t *dlg)
+static res_t *dialog2res(name_id_t *name, dialog_t *dlg)
 {
         int restag;
@@ -478 +650 @@
                 }
                 /* Set number of controls */
-                *(WORD *)&((char *)res->data)[tag_nctrl] = (WORD)nctrl;
+                set_word(res, tag_nctrl, (WORD)nctrl);
         }
         else /* win16 */
@@ -561 +733 @@
  *****************************************************************************
 */
-res_t *dialogex2res(name_id_t *name, dialogex_t *dlgex)
+static res_t *dialogex2res(name_id_t *name, dialogex_t *dlgex)
 {
         int restag;
@@ -654 +826 @@
                 }
                 /* Set number of controls */
-                *(WORD *)&((char *)res->data)[tag_nctrl] = (WORD)nctrl;
+                set_word(res, tag_nctrl, (WORD)nctrl);
                 /* Set ResourceSize */
                 SetResSize(res, restag);
@@ -679 +851 @@
  *****************************************************************************
 */
-void menuitem2res(res_t *res, menu_item_t *menitem)
+static void menuitem2res(res_t *res, menu_item_t *menitem)
 {
         menu_item_t *itm = menitem;
@@ -729 +901 @@
  *****************************************************************************
 */
-res_t *menu2res(name_id_t *name, menu_t *men)
+static res_t *menu2res(name_id_t *name, menu_t *men)
 {
         int restag;
@@ -758 +930 @@
  *****************************************************************************
 */
-void menuexitem2res(res_t *res, menuex_item_t *menitem)
+static void menuexitem2res(res_t *res, menuex_item_t *menitem)
 {
         menuex_item_t *itm = menitem;
@@ -795 +967 @@
  *****************************************************************************
 */
-res_t *menuex2res(name_id_t *name, menuex_t *menex)
+static res_t *menuex2res(name_id_t *name, menuex_t *menex)
 {
         int restag;
@@ -838 +1010 @@
  *****************************************************************************
 */
-res_t *cursorgroup2res(name_id_t *name, cursor_group_t *curg)
+static res_t *cursorgroup2res(name_id_t *name, cursor_group_t *curg)
 {
         int restag;
@@ -946 +1118 @@
  *****************************************************************************
 */
-res_t *cursor2res(cursor_t *cur)
+static res_t *cursor2res(cursor_t *cur)
 {
         int restag;
@@ -981 +1153 @@
  *****************************************************************************
 */
-res_t *icongroup2res(name_id_t *name, icon_group_t *icog)
+static res_t *icongroup2res(name_id_t *name, icon_group_t *icog)
 {
         int restag;
@@ -1049 +1221 @@
  *****************************************************************************
 */
-res_t *icon2res(icon_t *ico)
+static res_t *icon2res(icon_t *ico)
 {
         int restag;
@@ -1072 +1244 @@
 /*
  *****************************************************************************
+ * Function     : anicurico2res
+ * Syntax       : res_t *anicurico2res(name_id_t *name, ani_curico_t *ani)
+ * Input        :
+ *      name    - Name/ordinal of the resource
+ *      ani     - The animated object descriptor
+ * Output       : New .res format structure
+ * Description  :
+ * Remarks      : The endian of the object's structures have been converted
+ *                by the loader.
+ *                There are rumors that win311 could handle animated stuff.
+ *                That is why they are generated for both win16 and win32
+ *                compile.
+ *****************************************************************************
+*/
+static res_t *anicurico2res(name_id_t *name, ani_curico_t *ani, enum res_e type)
+{
+        int restag;
+        res_t *res;
+        assert(name != NULL);
+        assert(ani != NULL);
+
+        res = new_res();
+        restag = put_res_header(res, type == res_anicur ? WRC_RT_ANICURSOR : WRC_RT_ANIICON,
+                                NULL, name, ani->memopt, NULL);
+        put_raw_data(res, ani->data, 0);
+        /* Set ResourceSize */
+        SetResSize(res, restag);
+        if(win32)
+                put_pad(res);
+        return res;
+}
+
+/*
+ *****************************************************************************
  * Function     : bitmap2res
  * Syntax       : res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
@@ -1079 +1285 @@
  * Output       : New .res format structure
  * Description  :
- * Remarks      :
- *****************************************************************************
-*/
-res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
+ * Remarks      : The endian of the bitmap structures have been converted
+ *                by the loader.
+ *****************************************************************************
+*/
+static res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
 {
         int restag;
@@ -1089 +1296 @@
         assert(bmp != NULL);
 
-        HEAPCHECK();
         res = new_res();
-        HEAPCHECK();
-        restag = put_res_header(res, WRC_RT_BITMAP, NULL, name, bmp->memopt, NULL);
-        HEAPCHECK();
+        restag = put_res_header(res, WRC_RT_BITMAP, NULL, name, bmp->memopt, &(bmp->data->lvc));
         if(bmp->data->data[0] == 'B'
         && bmp->data->data[1] == 'M'
@@ -1106 +1310 @@
                 put_raw_data(res, bmp->data, 0);
         }
-        HEAPCHECK();
         /* Set ResourceSize */
         SetResSize(res, restag);
-        HEAPCHECK();
-        if(win32)
-                put_pad(res);
-        HEAPCHECK();
+        if(win32)
+                put_pad(res);
         return res;
 }
@@ -1125 +1326 @@
  * Output       : New .res format structure
  * Description  :
- * Remarks      :
- *****************************************************************************
-*/
-res_t *font2res(name_id_t *name, font_t *fnt)
-{
+ * Remarks      : The data has been prepared just after parsing.
+ *****************************************************************************
+*/
+static res_t *font2res(name_id_t *name, font_t *fnt)
+{
+        int restag;
+        res_t *res;
         assert(name != NULL);
         assert(fnt != NULL);
-        warning("Fonts not yet implemented");
-        return NULL;
+
+        res = new_res();
+        restag = put_res_header(res, WRC_RT_FONT, NULL, name, fnt->memopt, &(fnt->data->lvc));
+        put_raw_data(res, fnt->data, 0);
+        /* Set ResourceSize */
+        SetResSize(res, restag);
+        if(win32)
+                put_pad(res);
+        return res;
+}
+
+/*
+ *****************************************************************************
+ * Function     : fontdir2res
+ * Syntax       : res_t *fontdir2res(name_id_t *name, fontdir_t *fnd)
+ * Input        :
+ *      name    - Name/ordinal of the resource
+ *      fntdir  - The fontdir descriptor
+ * Output       : New .res format structure
+ * Description  :
+ * Remarks      : The data has been prepared just after parsing.
+ *****************************************************************************
+*/
+static res_t *fontdir2res(name_id_t *name, fontdir_t *fnd)
+{
+        int restag;
+        res_t *res;
+        assert(name != NULL);
+        assert(fnd != NULL);
+
+        res = new_res();
+        restag = put_res_header(res, WRC_RT_FONTDIR, NULL, name, fnd->memopt, &(fnd->data->lvc));
+        put_raw_data(res, fnd->data, 0);
+        /* Set ResourceSize */
+        SetResSize(res, restag);
+        if(win32)
+                put_pad(res);
+        return res;
 }
 
@@ -1148 +1387 @@
  *****************************************************************************
 */
-res_t *rcdata2res(name_id_t *name, rcdata_t *rdt)
+static res_t *rcdata2res(name_id_t *name, rcdata_t *rdt)
 {
         int restag;
@@ -1156 +1395 @@
 
         res = new_res();
-        restag = put_res_header(res, WRC_RT_RCDATA, NULL, name, rdt->memopt, NULL);
+        restag = put_res_header(res, WRC_RT_RCDATA, NULL, name, rdt->memopt, &(rdt->data->lvc));
         put_raw_data(res, rdt->data, 0);
         /* Set ResourceSize */
@@ -1174 +1413 @@
  * Output       : New .res format structure
  * Description  :
- * Remarks      :
- *****************************************************************************
-*/
-res_t *messagetable2res(name_id_t *name, messagetable_t *msg)
-{
+ * Remarks      : The data has been converted to the appropriate endian
+ *                after is was parsed.
+ *****************************************************************************
+*/
+static res_t *messagetable2res(name_id_t *name, messagetable_t *msg)
+{
+        int restag;
+        res_t *res;
         assert(name != NULL);
         assert(msg != NULL);
-        warning("Messagetable not yet implemented");
-        return NULL;
+
+        res = new_res();
+        restag = put_res_header(res, WRC_RT_MESSAGETABLE, NULL, name, msg->memopt, &(msg->data->lvc));
+        put_raw_data(res, msg->data, 0);
+        /* Set ResourceSize */
+        SetResSize(res, restag);
+        if(win32)
+                put_pad(res);
+        return res;
 }
 
@@ -1196 +1445 @@
  *****************************************************************************
 */
-res_t *stringtable2res(stringtable_t *stt)
+static res_t *stringtable2res(stringtable_t *stt)
 {
         res_t *res;
@@ -1219 +1468 @@
                 for(i = 0; i < stt->nentries; i++)
                 {
-                        if(stt->entries[i].str)
+                        if(stt->entries[i].str && stt->entries[i].str->size)
                         {
-                                if(win32)
-                                        put_word(res, stt->entries[i].str->size);
+                                string_t *str = convert_string(stt->entries[i].str, win32 ? str_unicode : str_char);
+                                if(win32)
+                                        put_word(res, str->size);
                                 else
-                                        put_byte(res, stt->entries[i].str->size);
-                                put_string(res, stt->entries[i].str, win32 ? str_unicode : str_char, FALSE);
+                                        put_byte(res, str->size);
+                                put_string(res, str, win32 ? str_unicode : str_char, FALSE);
+                                free(str);
                         }
                         else
@@ -1256 +1507 @@
  *****************************************************************************
 */
-res_t *user2res(name_id_t *name, user_t *usr)
+static res_t *user2res(name_id_t *name, user_t *usr)
 {
         int restag;
@@ -1264 +1515 @@
 
         res = new_res();
-        restag = put_res_header(res, 0, usr->type, name, usr->memopt, NULL);
+        restag = put_res_header(res, 0, usr->type, name, usr->memopt, &(usr->data->lvc));
         put_raw_data(res, usr->data, 0);
         /* Set ResourceSize */
@@ -1285 +1536 @@
  *****************************************************************************
 */
-void versionblock2res(res_t *res, ver_block_t *blk, int level)
+static void versionblock2res(res_t *res, ver_block_t *blk, int level)
 {
         ver_value_t *val;
@@ -1318 +1569 @@
                         put_string(res, val->value.str, win32 ? str_unicode : str_char, TRUE);
                         if(win32)
-                                *(WORD *)&(res->data[valvalsizetag]) = (WORD)((res->size - tag) >> 1);
+                                set_word(res, valvalsizetag, (WORD)((res->size - tag) >> 1));
                         else
-                                *(WORD *)&(res->data[valvalsizetag]) = (WORD)(res->size - tag);
-                        *(WORD *)&(res->data[valblksizetag]) = (WORD)(res->size - valblksizetag);
+                                set_word(res, valvalsizetag, (WORD)(res->size - tag));
+                        set_word(res, valblksizetag, (WORD)(res->size - valblksizetag));
                         put_pad(res);
                 }
@@ -1341 +1592 @@
                                 put_word(res, val->value.words->words[i]);
                         }
-                        *(WORD *)&(res->data[valvalsizetag]) = (WORD)(res->size - tag);
-                        *(WORD *)&(res->data[valblksizetag]) = (WORD)(res->size - valblksizetag);
+                        set_word(res, valvalsizetag, (WORD)(res->size - tag));
+                        set_word(res, valblksizetag, (WORD)(res->size - valblksizetag));
                         put_pad(res);
                 }
@@ -1356 +1607 @@
 
         /* Set blocksize */
-        *(WORD *)&(res->data[blksizetag]) = (WORD)(res->size - blksizetag);
+        set_word(res, blksizetag, (WORD)(res->size - blksizetag));
 }
 
@@ -1371 +1622 @@
  *****************************************************************************
 */
-res_t *versioninfo2res(name_id_t *name, versioninfo_t *ver)
+static res_t *versioninfo2res(name_id_t *name, versioninfo_t *ver)
 {
         int restag;
@@ -1389 +1640 @@
 
         res = new_res();
-        restag = put_res_header(res, WRC_RT_VERSION, NULL, name, WRC_MO_MOVEABLE | WRC_MO_PURE, NULL);
+        restag = put_res_header(res, WRC_RT_VERSION, NULL, name, ver->memopt, &(ver->lvc));
         rootblocksizetag = res->size;
         put_word(res, 0);       /* BlockSize filled in later */
@@ -1414 +1665 @@
         put_dword(res, 0);              /* FileDateLS */
         /* Set ValueSize */
-        *(WORD *)&(res->data[valsizetag]) = (WORD)(res->size - tag);
+        set_word(res, valsizetag, (WORD)(res->size - tag));
         /* Descend into the blocks */
         for(blk = ver->blocks; blk; blk = blk->next)
                 versionblock2res(res, blk, 0);
         /* Set root block's size */
-        *(WORD *)&(res->data[rootblocksizetag]) = (WORD)(res->size - rootblocksizetag);
+        set_word(res, rootblocksizetag, (WORD)(res->size - rootblocksizetag));
 
         SetResSize(res, restag);
@@ -1438 +1689 @@
  *****************************************************************************
 */
-void toolbaritem2res(res_t *res, toolbar_item_t *tbitem)
+static void toolbaritem2res(res_t *res, toolbar_item_t *tbitem)
 {
         toolbar_item_t *itm = tbitem;
@@ -1462 +1713 @@
  *****************************************************************************
 */
-res_t *toolbar2res(name_id_t *name, toolbar_t *toolbar)
+static res_t *toolbar2res(name_id_t *name, toolbar_t *toolbar)
 {
         int restag;
@@ -1506 +1757 @@
  *****************************************************************************
 */
-res_t *dlginit2res(name_id_t *name, dlginit_t *dit)
+static res_t *dlginit2res(name_id_t *name, dlginit_t *dit)
 {
         int restag;
@@ -1514 +1765 @@
 
         res = new_res();
-        restag = put_res_header(res, WRC_RT_DLGINIT, NULL, name, dit->memopt, &(dit->lvc));
+        restag = put_res_header(res, WRC_RT_DLGINIT, NULL, name, dit->memopt, &(dit->data->lvc));
         put_raw_data(res, dit->data, 0);
         /* Set ResourceSize */
@@ -1549 +1800 @@
                 for(i = 0; *sptr && i < MAXNAMELEN; i++)
                 {
-                        if((unsigned)*sptr < 0x80 && isprint((char)*sptr))
+                        if((unsigned)*sptr < 0x80 && isprint(*sptr & 0xff))
                                 buf[i] = *sptr++;
                         else
@@ -1564 +1815 @@
                 for(i = 0; *cptr && i < MAXNAMELEN; i++)
                 {
-                        if((unsigned)*cptr < 0x80 && isprint(*cptr))
+                        if((unsigned)*cptr < 0x80 && isprint(*cptr & 0xff))
                                 buf[i] = *cptr++;
                         else
@@ -1631 +1882 @@
         {
         case res_acc:   return "Acc";
+        case res_anicur:return "AniCur";
+        case res_aniico:return "AniIco";
         case res_bmp:   return "Bmp";
         case res_cur:   return "Cur";
@@ -1637 +1890 @@
         case res_dlgex: return "Dlg";
         case res_fnt:   return "Fnt";
+        case res_fntdir:return "FntDir";
         case res_ico:   return "Ico";
         case res_icog:  return "IcoGrp";
@@ -1696 +1950 @@
                         if(!top->binres)
                                 top->binres = font2res(top->name, top->res.fnt);
+                        break;
+                case res_fntdir:
+                        if(!top->binres)
+                                top->binres = fontdir2res(top->name, top->res.fnd);
                         break;
                 case res_ico:
@@ -1741 +1999 @@
                             top->binres = dlginit2res(top->name, top->res.dlgi);
                         break;
-
+                case res_anicur:
+                case res_aniico:
+                        if(!top->binres)
+                            top->binres = anicurico2res(top->name, top->res.ani, top->type);
+                        break;
                 default:
                         internal_error(__FILE__, __LINE__, "Unknown resource type encountered %d in binary res generation", top->type);

trunk/tools/wrc/lexyy.c

@@ -2 +2 @@
 
 /* Scanner skeleton version:
- * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/tools/wrc/lexyy.c,v 1.2 2000-04-19 14:44:58 sandervl Exp $
+ * $Header: /home/ktk/tmp/odin/2007/netlabs.cvs/odin32/tools/wrc/lexyy.c,v 1.3 2001-04-16 17:10:49 sandervl Exp $
  */
 
@@ -261 +261 @@
 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 
+
+#define FLEX_DEBUG
 typedef unsigned char YY_CHAR;
 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 typedef int yy_state_type;
+
+#define FLEX_DEBUG
 extern char *yytext;
 #define yytext_ptr yytext
@@ -282 +286 @@
         yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 124
-#define YY_END_OF_BUFFER 125
-static yyconst short int yy_accept[369] =
+#define YY_NUM_RULES 84
+#define YY_END_OF_BUFFER 85
+static yyconst short int yy_accept[162] =
     {   0,
-        0,    0,   66,   66,    0,    0,    0,    0,    0,    0,
-        0,    0,  114,  114,    0,    0,    0,    0,    0,    0,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   22,   22,    9,    9,    9,    9,   46,   46,
-        0,    0,   36,   36,   31,   31,   40,   40,   41,   41,
-      125,  122,  121,  120,  122,   88,  122,  107,  122,   56,
-       56,  118,  122,  122,  122,   59,   59,   54,  122,   55,
-      121,  122,   66,  121,   67,   66,   66,   66,   66,   66,
-       66,  123,   69,   68,  102,   90,   89,  106,   87,   72,
-       71,  123,  112,  110,  111,  108,  112,  114,  116,  115,
-
-        4,  123,    4,    4,    8,    6,   14,   22,    9,   12,
-      123,  123,   46,   45,   45,   45,   36,  123,   34,   32,
-       33,   36,  123,   31,  123,   29,   27,   28,   31,   40,
-       37,   38,  123,   40,   44,   41,   43,   42,  121,   63,
-       61,  113,  119,   56,   59,   56,   59,   59,  118,   64,
-       62,   65,   70,   60,  121,    0,    0,    0,    0,    0,
-        0,    0,    0,   66,   66,   66,   66,   66,   66,   66,
-       66,    0,   68,  102,    0,  103,  101,  101,   91,   93,
-       94,   95,   96,   97,   98,   99,  100,  101,   87,    0,
-       84,   83,   83,   73,   75,   76,   77,   78,   79,   80,
-
-       81,   82,   83,  110,  109,  114,  115,  115,  117,    0,
-        0,    7,    6,   14,   22,    9,   10,    0,   11,   46,
-        0,    0,    0,    0,    0,   36,   35,   36,    0,    0,
-       31,   30,   31,   40,   39,   40,   41,  119,   58,   57,
-        0,    0,    0,    0,    0,   15,    0,    0,    0,    0,
-       66,   66,   66,   66,   66,   66,   66,  105,  104,   91,
-       93,    0,   86,   85,   73,   75,    0,    3,    2,   10,
-        0,   58,   57,    0,    0,    0,    0,    0,    0,   15,
-        0,    0,    0,    0,    0,    0,   66,   66,   66,   66,
-       66,   66,   53,   91,   92,   73,    0,    0,    0,   18,
-
-       19,    0,    0,    0,    0,    0,    0,   26,    0,    0,
-       66,   48,   66,   66,   66,   66,   73,    0,    0,    0,
-       18,   19,   20,   21,   25,   16,    0,    0,   26,    0,
-       13,   66,   49,   66,   66,   66,   73,   74,   23,    5,
-       20,   21,   25,   16,   17,    0,   24,   13,   66,   66,
-       66,   52,   73,   23,    5,   17,    1,   24,   66,   66,
-       50,    1,   66,   66,   66,   51,   47,    0
+        0,    0,    0,    0,    0,    0,    0,    0,   74,   74,
+        0,    0,    7,    7,   12,   12,   14,   14,    2,    2,
+       85,   82,   81,   80,   46,   67,   24,   24,   20,   20,
+       78,   23,   23,   18,   19,   81,    1,   62,   66,   48,
+       83,   44,   45,   27,   83,   72,   70,   71,   68,   72,
+       74,   76,   75,   83,    7,    8,   83,    5,    3,    4,
+        7,    1,   12,   13,    9,   10,   83,   12,   17,   14,
+       16,   15,    2,   81,   24,   73,   24,   20,   23,   20,
+       23,   23,   78,   25,   81,    1,    1,   62,   47,   63,
+       60,   60,   60,   49,   52,   53,   54,   55,   56,   57,
+
+       58,   59,   60,   44,   26,   41,   39,   39,   39,   28,
+       31,   32,   33,   34,   35,   36,   37,   38,   39,   70,
+       69,   74,   75,   75,   77,    7,    6,    7,   12,   11,
+       12,   14,    2,   79,   24,   22,   21,   65,   61,   64,
+       49,   52,   51,   43,   40,   42,   28,   31,   30,   22,
+       21,   49,   50,   28,   30,   28,   30,   28,   29,   28,
+        0
     } ;
 
@@ -331 +313 @@
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
-        1,    2,    2,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    4,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    2,    4,    5,    6,    1,    1,    7,    8,    9,
-       10,   11,    1,    1,    1,    1,   12,   13,   14,   14,
-       14,   14,   14,   14,   14,   15,   15,    1,   16,   17,
-       18,   19,    1,    1,   20,   21,   22,   23,   24,   25,
-       26,   26,   27,   26,   26,   28,   29,   30,   31,   32,
-       26,   33,   34,   26,   35,   36,   26,   37,   26,   26,
-        1,   38,    1,    1,   26,    1,   39,   40,   41,   42,
-
-       43,   44,   45,   26,   46,   26,   26,   47,   48,   49,
-       50,   51,   26,   52,   53,   54,   55,   56,   26,   57,
-       26,   26,   58,   59,   60,    1,    1,    1,    1,    1,
+        1,    2,    1,    5,    6,    1,    1,    1,    7,    8,
+        9,   10,    1,    1,    1,   11,   12,   13,   14,   14,
+       14,   14,   14,   14,   14,   15,   15,    1,   16,    1,
+        1,    1,    1,    1,   17,   17,   17,   17,   17,   17,
+       18,   18,   18,   18,   18,   19,   18,   18,   20,   18,
+       18,   18,   18,   18,   18,   18,   18,   21,   18,   18,
+        1,   22,    1,    1,   18,    1,   23,   24,   17,   17,
+
+       17,   25,   18,   18,   18,   18,   18,   26,   18,   27,
+       20,   18,   18,   28,   18,   29,   18,   30,   18,   31,
+       18,   18,   32,    1,   33,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -360 +342 @@
     } ;
 
-static yyconst int yy_meta[61] =
+static yyconst int yy_meta[34] =
     {   0,
-        1,    2,    3,    1,    4,    5,    1,    1,    6,    7,
-        8,    9,   10,   10,   10,    5,    1,    1,   11,   10,
-       10,   10,   10,   10,   10,   12,   12,   12,   12,   12,
-       12,   12,   12,   12,   12,   12,   12,   13,   10,   10,
-       10,   10,   10,   10,   12,   12,   12,   12,   12,   12,
-       12,   12,   12,   12,   12,   12,   12,   14,    1,   14
+        1,    1,    2,    1,    3,    4,    1,    5,    5,    6,
+        7,    8,    9,    9,    9,    4,    9,    7,    7,    7,
+        7,   10,    9,    9,    9,    7,    7,    7,    7,    7,
+        7,   11,   11
     } ;
 
-static yyconst short int yy_base[425] =
+static yyconst short int yy_base[191] =
     {   0,
-        0,   60,  119,  169,   17,   18,   42,   43,   46,   47,
-      219,  262,   21,   22,   24,   37,  306,  366,  426,  486,
-        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0, 1053, 1048,   79,   87,   89,   90, 1030, 1021,
-     1020,   28,   94,  127,  120,  187,  323,  339,   41,   92,
-     1005, 1334,  994, 1334,  977, 1334,  974, 1334,   24,  241,
-      191,    0,  950,  949,  948,    0,  948, 1334,  619, 1334,
-       81,  113,    0,  675, 1334,   10,   59,   83,   85,  103,
-      174,  671, 1334, 1334,    0, 1334,  102,  542,    0, 1334,
-      109,  595, 1334,  673, 1334, 1334,    0,    0, 1334,  126,
-
-     1334, 1334,    0,    0, 1334,  665,    0,    0,    0, 1334,
-      129,  147,    0, 1334,  107,  206,    0,  662, 1334, 1334,
-     1334,  156,  246,    0,  661, 1334, 1334, 1334,  167,    0,
-     1334, 1334,  660,  173, 1334,  668, 1334, 1334,  667, 1334,
-     1334, 1334,    0,  253,    0,    0,  163,  640,    0, 1334,
-     1334, 1334, 1334, 1334,  180,  344,  350,  625,  176,  139,
-      621,  614,  610,    0,  157,  193,  163,  192,  215,  194,
-      247,  653, 1334,    0,  325, 1334, 1334,  652,  281,  323,
-     1334, 1334, 1334, 1334, 1334, 1334, 1334,    0,    0,  326,
-     1334, 1334,  651,  343,  346, 1334, 1334, 1334, 1334, 1334,
-
-     1334, 1334,    0,  648, 1334,    0,  224,  262, 1334,  643,
-      627, 1334,  636,    0,    0,    0,    0,  351, 1334,    0,
-      341,  360,  406,  363,   11,    0, 1334,  392,  412,  419,
-        0, 1334,  407,    0, 1334,  414,  641,    0,  433,  372,
-      598,   43,  599,  588,  595,  465,  596,  587,  594,  590,
-      428,  430,  367,  433,  436,  478,  484, 1334, 1334,  463,
-      468,    0, 1334, 1334,  496,  502,    0,  626, 1334,    0,
-      578,    0,    0,  583,  584,  584,  580,  575,  575,  621,
-      579,  579,  573,  576,  573,  574,  492,  490,  485,  488,
-      500,  490,    0,  515, 1334,  520,    0,  566,  566,  612,
-
-      611,  568,  559,  553,  561,  561,  546,    0,  549,  548,
-      489,    0,  499,  513,  527,  529,  537,    0,  538,  546,
-      586,  573,  534,  524,    0,  469,  424,  409,    0,  409,
-      421,  530,    0,  532,  530,  536,  550, 1334,    0,  416,
-      415,  387,    0,  386,  361,  307,    0,  338,  540,  541,
-      542,    0,  556,    0,  332,  288,  277,    0,  553,  548,
-        0,  244,  555,  556,  563,    0,    0, 1334,  684,  698,
-      712,  726,  740,  754,  768,  782,  796,  810,  824,  838,
-      852,  866,  880,  894,  908,  922,  936,  190,  950,  964,
-      978,  992, 1006, 1020, 1034,  214, 1048, 1062, 1076, 1090,
-
-     1099,  462, 1111, 1125, 1139, 1153, 1167, 1180, 1194, 1207,
-     1221, 1235, 1249,  174,  147, 1263,  135,   93,   29, 1277,
-       16, 1291, 1305, 1319
+        0,   32,   32,   36,   37,   40,   61,   85,   41,   43,
+        0,    0,  108,  140,  171,  186,   45,   53,  183,  182,
+      181,  622,   48,  622,  622,  622,    0,   60,  192,   46,
+        0,  211,  170,  622,  622,   77,   69,    0,  622,   89,
+      242,    0,  622,   99,  275,  622,   78,  622,  622,    0,
+        0,  622,   85,  622,    0,  622,  161,  622,  622,  622,
+      111,  103,    0,  622,  622,  622,  160,  117,  622,  114,
+      622,  622,    0,  123,    0,  622,  308,  108,    0,    0,
+      117,  329,    0,  622,  130,  131,  143,    0,  146,  622,
+      622,  158,  144,  140,  144,  622,  622,  622,  622,  622,
+
+      622,  622,    0,    0,  158,  622,  622,  135,  132,  151,
+      154,  622,  622,  622,  622,  622,  622,  622,    0,  174,
+      622,    0,  172,  181,  622,    0,  622,  195,    0,  622,
+      232,  225,    0,    0,  354,  306,  209,  622,  622,  622,
+      226,  308,    0,  622,  622,  622,  313,  316,    0,    0,
+        0,  320,  622,  323,    0,  334,    0,  352,  622,  358,
+      622,  387,  398,  409,  420,  431,  442,  453,  464,  475,
+      480,  490,  501,  512,  117,  523,  534,  545,  555,  566,
+      577,  588,  599,  113,  103,  610,   97,   87,   81,   51
     } ;
 
-static yyconst short int yy_def[425] =
+static yyconst short int yy_def[191] =
     {   0,
-      369,  369,  370,  370,  371,  371,  372,  372,  373,  373,
-      374,  374,  375,  375,  376,  376,  377,  377,  378,  378,
-      379,  379,  379,  379,  379,  379,  379,  379,  379,  379,
-      379,  379,  380,  380,  381,  381,  381,  381,  382,  382,
-      383,  383,  384,  384,  385,  385,  386,  386,  387,  387,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  388,
-      388,  389,  368,  368,  368,  388,  388,  368,  368,  368,
-      368,  368,  390,  368,  368,  390,  390,  390,  390,  390,
-      390,  391,  368,  368,  392,  368,  368,  393,  394,  368,
-      368,  395,  368,  368,  368,  368,  396,  397,  368,  398,
-
-      368,  368,  399,  400,  368,  401,  402,  403,  404,  368,
-      405,  368,  406,  368,  368,  368,  407,  408,  368,  368,
-      368,  407,  368,  409,  410,  368,  368,  368,  409,  411,
-      368,  368,  412,  411,  368,  368,  368,  368,  368,  368,
-      368,  368,  413,  388,  388,  388,  388,  388,  389,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  390,  390,  390,  390,  390,  390,  390,
-      390,  391,  368,  392,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  414,  394,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-
-      368,  368,  415,  368,  368,  397,  398,  398,  368,  399,
-      400,  368,  401,  402,  403,  404,  416,  368,  368,  406,
-      368,  368,  368,  368,  368,  407,  368,  407,  368,  368,
-      409,  368,  409,  411,  368,  411,  368,  413,  388,  148,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      390,  390,  390,  390,  390,  390,  390,  368,  368,  368,
-      368,  417,  368,  368,  368,  368,  418,  399,  368,  416,
-      368,  388,  388,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  390,  390,  390,  390,
-      390,  390,  390,  368,  368,  368,  419,  368,  368,  368,
-
-      368,  368,  368,  368,  368,  368,  368,  420,  368,  368,
-      390,  390,  390,  390,  390,  390,  368,  421,  368,  368,
-      368,  368,  368,  368,  422,  368,  368,  368,  420,  368,
-      368,  390,  390,  390,  390,  390,  368,  368,  423,  368,
-      368,  368,  422,  368,  368,  368,  424,  368,  390,  390,
-      390,  390,  368,  423,  368,  368,  368,  424,  390,  390,
-      390,  368,  390,  390,  390,  390,  390,    0,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368
+      161,    1,  162,  162,  163,  163,  164,  164,  165,  165,
+      166,  166,  167,  167,  168,  168,  169,  169,  170,  170,
+      161,  161,  161,  161,  161,  161,  171,  171,  161,   29,
+      172,   29,   32,  161,  161,  161,  161,  173,  161,  161,
+      161,  174,  161,  161,  161,  161,  161,  161,  161,  175,
+      176,  161,  177,  161,  178,  161,  179,  161,  161,  161,
+      178,  161,  180,  161,  161,  161,  181,  180,  161,  161,
+      161,  161,  182,  161,  171,  161,  183,   29,   32,   32,
+       32,   32,  172,  161,  161,  161,  161,  173,  161,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+
+      161,  161,  184,  174,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  185,  161,
+      161,  176,  177,  177,  161,  178,  161,  178,  180,  161,
+      180,  161,  182,  186,  183,   32,   82,  161,  161,  161,
+      161,  161,  187,  161,  161,  161,  161,  161,  188,   32,
+       32,  161,  161,  161,  189,  161,  190,  161,  161,  161,
+        0,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  161,  161
     } ;
 
-static yyconst short int yy_nxt[1395] =
+static yyconst short int yy_nxt[656] =
     {   0,
-       52,   53,   54,   55,   56,   52,   57,   58,   52,   52,
-       52,   59,   60,   61,   61,   62,   63,   64,   65,   83,
-       83,   84,   84,   99,   99,  338,  102,   67,  103,  115,
-       54,  100,  100,  116,  142,  143,  165,   52,  318,  102,
-      104,  103,  136,  137,   86,   86,   87,   87,   90,   90,
-       91,   91,  245,  104,  246,  165,  138,   68,   69,   70,
-       52,   71,   54,   55,   56,   72,   57,   58,   52,   52,
-       52,   59,   60,   61,   61,   62,   63,   64,   65,   88,
-       88,  110,  155,   92,   92,  166,  156,   67,  275,  110,
-      111,  110,  110,  136,  137,  276,   54,   52,  111,  102,
-
-      111,  111,  297,  175,  166,  118,  176,  138,  221,  119,
-      190,  167,  222,  191,  157,  168,  112,   68,   69,   70,
-       74,   54,   54,   75,  112,  102,  112,  112,  122,   54,
-      167,  125,  123,  169,  168,  126,  208,  209,  118,  142,
-      143,   76,  119,   77,  295,   78,   79,   80,  218,  219,
-       81,  120,  169,  121,  158,  159,  267,  228,  160,  161,
-       76,  229,   77,  162,   78,   79,   80,  163,  233,   81,
-       74,   54,  229,   75,  236,  239,  239,  127,  229,  128,
-      245,  155,  246,  262,  120,  156,  121,  247,  129,   54,
-      251,   76,  123,   77,  253,   78,   79,   80,  125,  145,
-
-       81,  145,  126,  144,  144,  144,  170,  223,  171,  251,
-       76,  254,   77,  253,   78,   79,   80,  256,  146,   81,
-       94,   95,  242,  205,  243,  170,   96,  244,  171,  252,
-      254,   97,   97,   97,  368,  368,  256,  146,   97,   97,
-       97,   97,   97,   97,  127,  362,  128,  230,  224,  252,
-      255,  225,  161,  144,  144,  144,  162,   97,   97,   97,
-       97,   97,   97,   94,   95,  144,  144,  144,  146,   96,
-      255,  147,  208,  209,   97,   97,   97,  148,  362,  257,
-      146,   97,   97,   97,   97,   97,   97,  146,  159,  356,
-      147,  225,  161,  260,  260,  261,  162,  148,  257,  146,
-
-       97,   97,   97,   97,   97,   97,  105,  105,  102,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,   54,  175,  190,  102,  258,
-      263,  131,  132,  355,  133,  261,  261,  261,  102,  348,
-      134,   54,  221,  105,  123,  157,  222,  131,  132,  357,
-      133,  157,  218,  219,  102,  265,  265,  266,  266,  266,
-      266,  223,  356,  105,  105,  105,  105,  105,  102,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  158,  159,  344,  342,  160,
-      161,  158,  159,  228,  162,  160,  161,  229,  163,  273,
-
-      162,  289,  224,  105,  163,  225,  161,  223,  233,  242,
-      162,  243,  229,  230,  271,  236,  341,  355,  273,  229,
-      230,  289,  348,  105,  105,  105,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  239,  239,  347,  224,  287,
-      346,  225,  161,  288,  159,  290,  162,  225,  161,  291,
-      272,  159,  162,  102,  225,  161,  280,  345,  287,  162,
-      344,  214,  288,  214,  290,  294,  294,  261,  291,  272,
-      261,  261,  261,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-
-      102,  102,  102,  102,  102,  292,  281,  293,  296,  296,
-      266,  311,  312,  282,  266,  266,  266,  313,  314,  315,
-      316,  332,  333,  102,  292,  342,  293,  261,  261,  261,
-      311,  312,  317,  317,  266,  341,  313,  314,  315,  316,
-      332,  333,  334,  102,  102,  102,  178,  335,  336,  337,
-      337,  266,  349,  350,  179,  179,  180,  351,  352,  359,
-      360,  334,  353,  353,  266,  361,  335,  336,  266,  266,
-      266,  349,  350,  363,  322,  364,  351,  352,  359,  360,
-      181,  182,  365,  366,  361,  183,  367,  321,  340,  339,
-      184,  331,  363,  185,  364,  186,  330,  187,  188,  193,
-
-      328,  365,  366,  327,  326,  367,  325,  194,  194,  195,
-      324,  323,  322,  321,  320,  319,  310,  309,  308,  307,
-      306,  305,  280,  304,  303,  302,  301,  300,  299,  298,
-      268,  286,  285,  196,  197,  284,  283,  279,  198,  278,
-      277,  274,  237,  199,  212,  269,  200,  268,  201,  204,
-      202,  203,  240,  240,  240,  264,  259,  173,  250,  240,
-      240,  240,  240,  240,  240,  249,  248,  241,  139,  237,
-      142,  142,  142,  212,  204,  173,  139,  154,  240,  240,
-      240,  240,  240,  240,   66,   66,   66,   66,   66,   66,
-       66,   66,   66,   66,   66,   66,   66,   66,   73,   73,
-
-       73,   73,   73,   73,   73,   73,   73,   73,   73,   73,
-       73,   73,   82,   82,   82,   82,   82,   82,   82,   82,
-       82,   82,   82,   82,   82,   82,   85,   85,   85,   85,
-       85,   85,   85,   85,   85,   85,   85,   85,   85,   85,
-       89,   89,   89,   89,   89,   89,   89,   89,   89,   89,
-       89,   89,   89,   89,   93,   93,   93,   93,   93,   93,
-       93,   93,   93,   93,   93,   93,   93,   93,   98,   98,
-       98,   98,   98,   98,   98,   98,   98,   98,   98,   98,
-       98,   98,  101,  101,  101,  101,  101,  101,  101,  101,
-      101,  101,  101,  101,  101,  101,  106,  106,  106,  106,
-
-      106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
-      107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
-      107,  107,  107,  107,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  108,  108,
-      108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
-      108,  108,  109,  109,  109,  109,  109,  109,  109,  109,
-      109,  109,  109,  109,  109,  109,  113,  113,  113,  113,
-      113,  113,  113,  113,  113,  113,  113,  113,  113,  113,
-      114,  114,  114,  114,  114,  114,  114,  114,  114,  114,
-      114,  114,  114,  114,  117,  117,  117,  117,  117,  117,
-
-      117,  117,  117,  117,  117,  117,  117,  117,  124,  124,
-      124,  124,  124,  124,  124,  124,  124,  124,  124,  124,
-      124,  124,  130,  130,  130,  130,  130,  130,  130,  130,
-      130,  130,  130,  130,  130,  130,  135,  135,  135,  135,
-      135,  135,  135,  135,  135,  135,  135,  135,  135,  135,
-      149,  149,  153,  149,  149,  149,  149,  149,  149,  149,
-      149,  149,  149,  149,  164,  152,  151,  150,  164,  164,
-      164,  164,  164,  164,  164,  164,  164,  164,  172,  172,
-      141,  172,  172,  172,  172,  172,  172,  172,  172,  172,
-      172,  172,  174,  174,  140,  139,  174,  174,  174,  174,
-
-      174,  174,  174,  174,  368,  174,  177,  177,  177,  177,
-      177,  177,  177,  177,  177,  177,  177,  177,  177,  177,
-      189,  189,   54,  102,  189,  189,  189,  189,  189,  189,
-      189,  189,  102,  189,  192,  192,  192,  192,  192,  192,
-      192,  192,  192,  192,  192,  192,  192,  192,  206,  206,
-      102,  206,  206,  206,  206,  102,  206,  206,  206,  206,
-      206,  206,  207,  207,  368,  207,  207,  207,  207,  207,
-      207,  207,  207,  207,  207,  207,  210,  210,  368,  210,
-      210,  210,  210,  210,  210,  210,  368,  210,  210,  210,
-      211,  211,  368,  211,  211,  211,  211,  211,  211,  211,
-
-      368,  211,  211,  211,  213,  368,  368,  368,  213,  368,
-      213,  215,  215,  368,  215,  215,  215,  215,  215,  215,
-      215,  215,  215,  215,  215,  216,  216,  368,  216,  216,
-      216,  216,  216,  368,  216,  216,  216,  368,  216,  217,
-      217,  217,  217,  217,  217,  217,  217,  217,  217,  217,
-      217,  217,  217,  220,  220,  368,  220,  220,  220,  220,
-      220,  220,  220,  220,  220,  220,  220,  226,  226,  368,
-      226,  368,  226,  226,  226,  368,  226,  226,  226,  226,
-      227,  227,  368,  227,  227,  227,  227,  227,  227,  227,
-      227,  227,  227,  227,  231,  231,  368,  231,  368,  231,
-
-      231,  231,  368,  231,  231,  231,  231,  232,  232,  368,
-      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
-      232,  234,  234,  368,  234,  368,  368,  368,  234,  368,
-      234,  234,  234,  234,  234,  235,  235,  368,  235,  235,
-      235,  235,  235,  235,  235,  235,  235,  235,  235,  238,
-      238,  368,  238,  238,  238,  238,  238,  238,  238,  238,
-      238,  238,  238,  270,  270,  368,  270,  270,  270,  270,
-      270,  368,  270,  270,  270,  368,  270,  329,  329,  368,
-      329,  329,  329,  329,  329,  329,  329,  329,  329,  329,
-      329,  343,  343,  368,  343,  343,  343,  343,  343,  343,
-
-      343,  343,  343,  343,  343,  354,  354,  368,  354,  354,
-      354,  354,  354,  354,  354,  354,  354,  354,  354,  358,
-      358,  368,  358,  358,  358,  358,  358,  358,  358,  358,
-      358,  358,  358,   51,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368
-
+       22,   23,   24,   23,   25,   22,   26,   22,   22,   22,
+       27,   28,   29,   30,   30,   31,   32,   32,   33,   32,
+       32,   27,   32,   32,   32,   32,   32,   32,   32,   32,
+       32,   34,   35,   36,   39,   36,   40,   37,   39,   43,
+       40,   44,   43,   52,   44,   52,   70,   71,   70,   74,
+       53,   74,   53,   41,   70,   71,   70,   41,   45,  159,
+       72,   45,   47,   48,   47,   79,   79,   49,   72,   76,
+       87,   77,   87,   50,   50,   50,   79,   50,   85,  120,
+       85,  120,   86,   50,   50,   50,   47,   48,   47,  157,
+       89,   49,   89,   90,  124,  155,  125,   50,   50,   50,
+
+      105,   50,  105,  106,   87,  153,   87,   50,   50,   50,
+       56,  149,  128,   54,  128,  132,   86,  132,  131,   57,
+      131,  143,   86,   58,   74,  121,   74,   79,   79,  136,
+      136,   85,   87,   85,   87,   86,  146,  145,   79,   59,
+       60,   61,   56,   61,   87,   62,   87,   89,  140,   89,
+      138,   57,  141,  141,  142,   58,  142,  142,  142,  105,
+      139,  105,  144,  147,  147,  148,  148,  148,  148,   76,
+       76,   59,   60,   64,   84,  120,   54,  120,   65,   66,
+      161,  161,   67,  161,   54,   54,   54,   68,   64,   68,
+      124,   62,  125,   65,   66,  161,  128,   67,  128,  161,
+
+       86,   54,   75,   75,   78,   78,   78,  161,   79,   79,
+       80,   81,   82,   75,   79,   79,   79,   80,   79,   79,
+       79,   79,   82,   79,   79,   79,  132,  151,  132,   79,
+       79,   79,  161,  131,  151,  131,   79,   86,  152,  152,
+      142,   79,   91,   91,   91,   92,   93,   91,   91,   91,
+       91,   91,   91,   91,   94,   94,   95,   91,   91,   91,
+       91,   91,   91,   91,   96,   97,   98,   91,   99,  100,
+      101,  102,  103,   91,   91,  107,  107,  107,  108,  109,
+      107,  107,  107,  107,  107,  107,  107,  110,  110,  111,
+      107,  107,  107,  107,  107,  107,  107,  112,  113,  114,
+
+      107,  115,  116,  117,  118,  119,  107,  107,  134,  134,
+      161,  134,  134,  134,  134,  134,  134,  134,  136,  136,
+      142,  142,  142,  134,  150,  154,  154,  148,  148,  148,
+      148,  150,  142,  142,  142,  156,  156,  148,  161,  134,
+      134,  137,  137,  137,  161,  137,  158,  158,  148,  161,
+      161,  137,  137,  137,  134,  134,  161,  134,  134,  134,
+      134,  134,  134,  134,  160,  160,  148,  161,  161,  134,
+      148,  148,  148,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  134,  134,   38,   38,   38,
+       38,   38,   38,   38,   38,   38,   38,   38,   42,   42,
+
+       42,   42,   42,   42,   42,   42,   42,   42,   42,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
+       51,   51,   51,   51,   51,   51,   51,   51,   51,   51,
+       51,   54,   54,   54,   54,   54,   54,   54,   54,   54,
+       54,   54,   55,   55,   55,   55,   55,   55,   55,   55,
+       55,   55,   55,   63,   63,   63,   63,   63,   63,   63,
+       63,   63,   63,   63,   69,   69,   69,   69,   69,   69,
+       69,   69,   69,   69,   69,   73,   73,   73,   73,   73,
+       73,   73,   73,   73,   73,   73,   75,   75,   75,   75,
+       83,  161,   83,   83,   83,   83,   83,   83,   83,   83,
+
+       83,   88,  161,  161,   88,   88,   88,   88,   88,   88,
+      161,   88,  104,  161,  161,  104,  104,  104,  104,  104,
+      104,  161,  104,  122,  161,  122,  122,  122,  161,  122,
+      122,  122,  122,  122,  123,  161,  123,  123,  123,  123,
+      123,  123,  123,  123,  123,  126,  161,  126,  161,  126,
+      126,  126,  161,  126,  126,  127,  161,  127,  127,  127,
+      127,  127,  127,  127,  127,  127,  129,  161,  129,  161,
+      161,  129,  129,  161,  129,  129,  129,  130,  161,  130,
+      130,  130,  130,  130,  130,  130,  130,  130,  133,  161,
+      133,  133,  133,  133,  133,  133,  133,  133,  133,  135,
+
+      161,  135,  135,  135,  135,  135,  135,  135,  135,  135,
+      134,  161,  134,  134,  134,  134,  134,  134,  134,  134,
+      134,   21,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161
     } ;
 
-static yyconst short int yy_chk[1395] =
+static yyconst short int yy_chk[656] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    5,
-        6,    5,    6,   13,   14,  421,   15,    1,   15,   42,
-       42,   13,   14,   42,   59,   59,   76,    1,  419,   16,
-       15,   16,   49,   49,    7,    8,    7,    8,    9,   10,
-        9,   10,  225,   16,  225,   76,   49,    1,    1,    1,
-        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
-        2,    2,    2,    2,    2,    2,    2,    2,    2,    7,
-        8,   35,   71,    9,   10,   77,   71,    2,  242,   36,
-       35,   37,   38,   50,   50,  242,   43,    2,   36,   43,
-
-       37,   38,  418,   87,   77,   43,   87,   50,  115,   43,
-       91,   78,  115,   91,   72,   79,   35,    2,    2,    2,
-        3,    3,   45,    3,   36,   45,   37,   38,   44,   44,
-       78,   45,   44,   80,   79,   45,  100,  100,   44,  111,
-      111,    3,   44,    3,  417,    3,    3,    3,  112,  112,
-        3,   43,   80,   43,   72,   72,  415,  122,   72,   72,
-        3,  122,    3,   72,    3,    3,    3,   72,  129,    3,
-        4,    4,  129,    4,  134,  147,  147,   45,  134,   45,
-      160,  155,  160,  414,   44,  155,   44,  160,   46,   46,
-      165,    4,   46,    4,  167,    4,    4,    4,   46,  388,
-
-        4,  388,   46,   61,   61,   61,   81,  116,   81,  165,
-        4,  168,    4,  167,    4,    4,    4,  170,   61,    4,
-       11,   11,  159,  396,  159,   81,   11,  159,   81,  166,
-      168,   11,   11,   11,  207,  207,  170,   61,   11,   11,
-       11,   11,   11,   11,   46,  362,   46,  123,  116,  166,
-      169,  116,  116,   60,   60,   60,  116,   11,   11,   11,
-       11,   11,   11,   12,   12,  144,  144,  144,   60,   12,
-      169,   60,  208,  208,   12,   12,   12,   60,  357,  171,
-      144,   12,   12,   12,   12,   12,   12,   60,  123,  356,
-       60,  123,  123,  179,  179,  179,  123,   60,  171,  144,
-
-       12,   12,   12,   12,   12,   12,   17,   17,   17,   17,
-       17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
-       17,   17,   17,   17,   17,   47,  175,  190,   47,  175,
-      190,   47,   47,  355,   47,  180,  180,  180,   47,  348,
-       48,   48,  221,   17,   48,  156,  221,   48,   48,  346,
-       48,  157,  218,  218,   48,  194,  194,  194,  195,  195,
-      195,  222,  345,   17,   17,   17,   18,   18,   18,   18,
-       18,   18,   18,   18,   18,   18,   18,   18,   18,   18,
-       18,   18,   18,   18,   18,  156,  156,  344,  342,  156,
-      156,  157,  157,  228,  156,  157,  157,  228,  156,  240,
-
-      157,  253,  222,   18,  157,  222,  222,  223,  233,  224,
-      222,  224,  233,  229,  224,  236,  341,  340,  240,  236,
-      230,  253,  331,   18,   18,   18,   19,   19,   19,   19,
-       19,   19,   19,   19,   19,   19,   19,   19,   19,   19,
-       19,   19,   19,   19,   19,  239,  239,  330,  223,  251,
-      328,  223,  223,  252,  229,  254,  223,  229,  229,  255,
-      239,  230,  229,   19,  230,  230,  246,  327,  251,  230,
-      326,  402,  252,  402,  254,  260,  260,  260,  255,  239,
-      261,  261,  261,   19,   19,   19,   20,   20,   20,   20,
-       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
-
-       20,   20,   20,   20,   20,  256,  246,  257,  265,  265,
-      265,  287,  288,  246,  266,  266,  266,  289,  290,  291,
-      292,  311,  313,   20,  256,  324,  257,  294,  294,  294,
-      287,  288,  296,  296,  296,  323,  289,  290,  291,  292,
-      311,  313,  314,   20,   20,   20,   88,  315,  316,  317,
-      317,  317,  332,  334,   88,   88,   88,  335,  336,  349,
-      350,  314,  337,  337,  337,  351,  315,  316,  353,  353,
-      353,  332,  334,  359,  322,  360,  335,  336,  349,  350,
-       88,   88,  363,  364,  351,   88,  365,  321,  320,  319,
-       88,  310,  359,   88,  360,   88,  309,   88,   88,   92,
-
-      307,  363,  364,  306,  305,  365,  304,   92,   92,   92,
-      303,  302,  301,  300,  299,  298,  286,  285,  284,  283,
-      282,  281,  280,  279,  278,  277,  276,  275,  274,  271,
-      268,  250,  249,   92,   92,  248,  247,  245,   92,  244,
-      243,  241,  237,   92,  213,  211,   92,  210,   92,  204,
-       92,   92,  148,  148,  148,  193,  178,  172,  163,  148,
-      148,  148,  148,  148,  148,  162,  161,  158,  139,  136,
-      133,  125,  118,  106,   94,   82,   74,   69,  148,  148,
-      148,  148,  148,  148,  369,  369,  369,  369,  369,  369,
-      369,  369,  369,  369,  369,  369,  369,  369,  370,  370,
-
-      370,  370,  370,  370,  370,  370,  370,  370,  370,  370,
-      370,  370,  371,  371,  371,  371,  371,  371,  371,  371,
-      371,  371,  371,  371,  371,  371,  372,  372,  372,  372,
-      372,  372,  372,  372,  372,  372,  372,  372,  372,  372,
-      373,  373,  373,  373,  373,  373,  373,  373,  373,  373,
-      373,  373,  373,  373,  374,  374,  374,  374,  374,  374,
-      374,  374,  374,  374,  374,  374,  374,  374,  375,  375,
-      375,  375,  375,  375,  375,  375,  375,  375,  375,  375,
-      375,  375,  376,  376,  376,  376,  376,  376,  376,  376,
-      376,  376,  376,  376,  376,  376,  377,  377,  377,  377,
-
-      377,  377,  377,  377,  377,  377,  377,  377,  377,  377,
-      378,  378,  378,  378,  378,  378,  378,  378,  378,  378,
-      378,  378,  378,  378,  379,  379,  379,  379,  379,  379,
-      379,  379,  379,  379,  379,  379,  379,  379,  380,  380,
-      380,  380,  380,  380,  380,  380,  380,  380,  380,  380,
-      380,  380,  381,  381,  381,  381,  381,  381,  381,  381,
-      381,  381,  381,  381,  381,  381,  382,  382,  382,  382,
-      382,  382,  382,  382,  382,  382,  382,  382,  382,  382,
-      383,  383,  383,  383,  383,  383,  383,  383,  383,  383,
-      383,  383,  383,  383,  384,  384,  384,  384,  384,  384,
-
-      384,  384,  384,  384,  384,  384,  384,  384,  385,  385,
-      385,  385,  385,  385,  385,  385,  385,  385,  385,  385,
-      385,  385,  386,  386,  386,  386,  386,  386,  386,  386,
-      386,  386,  386,  386,  386,  386,  387,  387,  387,  387,
-      387,  387,  387,  387,  387,  387,  387,  387,  387,  387,
-      389,  389,   67,  389,  389,  389,  389,  389,  389,  389,
-      389,  389,  389,  389,  390,   65,   64,   63,  390,  390,
-      390,  390,  390,  390,  390,  390,  390,  390,  391,  391,
-       57,  391,  391,  391,  391,  391,  391,  391,  391,  391,
-      391,  391,  392,  392,   55,   53,  392,  392,  392,  392,
-
-      392,  392,  392,  392,   51,  392,  393,  393,  393,  393,
-      393,  393,  393,  393,  393,  393,  393,  393,  393,  393,
-      394,  394,   41,   40,  394,  394,  394,  394,  394,  394,
-      394,  394,   39,  394,  395,  395,  395,  395,  395,  395,
-      395,  395,  395,  395,  395,  395,  395,  395,  397,  397,
-       34,  397,  397,  397,  397,   33,  397,  397,  397,  397,
-      397,  397,  398,  398,    0,  398,  398,  398,  398,  398,
-      398,  398,  398,  398,  398,  398,  399,  399,    0,  399,
-      399,  399,  399,  399,  399,  399,    0,  399,  399,  399,
-      400,  400,    0,  400,  400,  400,  400,  400,  400,  400,
-
-        0,  400,  400,  400,  401,    0,    0,    0,  401,    0,
-      401,  403,  403,    0,  403,  403,  403,  403,  403,  403,
-      403,  403,  403,  403,  403,  404,  404,    0,  404,  404,
-      404,  404,  404,    0,  404,  404,  404,    0,  404,  405,
-      405,  405,  405,  405,  405,  405,  405,  405,  405,  405,
-      405,  405,  405,  406,  406,    0,  406,  406,  406,  406,
-      406,  406,  406,  406,  406,  406,  406,  407,  407,    0,
-      407,    0,  407,  407,  407,    0,  407,  407,  407,  407,
-      408,  408,    0,  408,  408,  408,  408,  408,  408,  408,
-      408,  408,  408,  408,  409,  409,    0,  409,    0,  409,
-
-      409,  409,    0,  409,  409,  409,  409,  410,  410,    0,
-      410,  410,  410,  410,  410,  410,  410,  410,  410,  410,
-      410,  411,  411,    0,  411,    0,    0,    0,  411,    0,
-      411,  411,  411,  411,  411,  412,  412,    0,  412,  412,
-      412,  412,  412,  412,  412,  412,  412,  412,  412,  413,
-      413,    0,  413,  413,  413,  413,  413,  413,  413,  413,
-      413,  413,  413,  416,  416,    0,  416,  416,  416,  416,
-      416,    0,  416,  416,  416,    0,  416,  420,  420,    0,
-      420,  420,  420,  420,  420,  420,  420,  420,  420,  420,
-      420,  422,  422,    0,  422,  422,  422,  422,  422,  422,
-
-      422,  422,  422,  422,  422,  423,  423,    0,  423,  423,
-      423,  423,  423,  423,  423,  423,  423,  423,  423,  424,
-      424,    0,  424,  424,  424,  424,  424,  424,  424,  424,
-      424,  424,  424,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368,  368,  368,  368,  368,  368,  368,
-      368,  368,  368,  368
-
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    2,    3,    2,    3,    2,    4,    5,
+        4,    5,    6,    9,    6,   10,   17,   17,   17,   23,
+        9,   23,   10,    3,   18,   18,   18,    4,    5,  190,
+       17,    6,    7,    7,    7,   30,   30,    7,   18,   28,
+       37,   28,   37,    7,    7,    7,   30,    7,   36,   47,
+       36,   47,   36,    7,    7,    7,    8,    8,    8,  189,
+       40,    8,   40,   40,   53,  188,   53,    8,    8,    8,
+
+       44,    8,   44,   44,   62,  187,   62,    8,    8,    8,
+       13,  185,   61,   13,   61,   70,   61,   70,   68,   13,
+       68,  184,   68,   13,   74,  175,   74,   78,   78,   81,
+       81,   85,   86,   85,   86,   85,  109,  108,   78,   13,
+       13,   14,   14,   14,   87,   14,   87,   89,   93,   89,
+       89,   14,   94,   94,   94,   14,   95,   95,   95,  105,
+       92,  105,  105,  110,  110,  110,  111,  111,  111,   67,
+       57,   14,   14,   15,   33,  120,   15,  120,   15,   15,
+       21,  123,   15,  123,   20,   19,   15,   16,   16,   16,
+      124,   16,  124,   16,   16,    0,  128,   16,  128,    0,
+
+      128,   16,   29,   29,   29,   29,   29,    0,   29,   29,
+       29,   29,   29,   29,   29,   29,   29,   29,   29,   29,
+       29,   29,   29,   32,   32,   32,  132,  137,  132,   32,
+       32,   32,    0,  131,  137,  131,   32,  131,  141,  141,
+      141,   32,   41,   41,   41,   41,   41,   41,   41,   41,
+       41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
+       41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
+       41,   41,   41,   41,   41,   45,   45,   45,   45,   45,
+       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
+       45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
+
+       45,   45,   45,   45,   45,   45,   45,   45,   77,   77,
+        0,   77,   77,   77,   77,   77,   77,   77,  136,  136,
+      142,  142,  142,   77,  136,  147,  147,  147,  148,  148,
+      148,  136,  152,  152,  152,  154,  154,  154,    0,   77,
+       77,   82,   82,   82,    0,   82,  156,  156,  156,    0,
+        0,   82,   82,   82,  135,  135,    0,  135,  135,  135,
+      135,  135,  135,  135,  158,  158,  158,    0,    0,  135,
+      160,  160,  160,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,  135,  135,  162,  162,  162,
+      162,  162,  162,  162,  162,  162,  162,  162,  163,  163,
+
+      163,  163,  163,  163,  163,  163,  163,  163,  163,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      165,  165,  165,  165,  165,  165,  165,  165,  165,  165,
+      165,  166,  166,  166,  166,  166,  166,  166,  166,  166,
+      166,  166,  167,  167,  167,  167,  167,  167,  167,  167,
+      167,  167,  167,  168,  168,  168,  168,  168,  168,  168,
+      168,  168,  168,  168,  169,  169,  169,  169,  169,  169,
+      169,  169,  169,  169,  169,  170,  170,  170,  170,  170,
+      170,  170,  170,  170,  170,  170,  171,  171,  171,  171,
+      172,    0,  172,  172,  172,  172,  172,  172,  172,  172,
+
+      172,  173,    0,    0,  173,  173,  173,  173,  173,  173,
+        0,  173,  174,    0,    0,  174,  174,  174,  174,  174,
+      174,    0,  174,  176,    0,  176,  176,  176,    0,  176,
+      176,  176,  176,  176,  177,    0,  177,  177,  177,  177,
+      177,  177,  177,  177,  177,  178,    0,  178,    0,  178,
+      178,  178,    0,  178,  178,  179,    0,  179,  179,  179,
+      179,  179,  179,  179,  179,  179,  180,    0,  180,    0,
+        0,  180,  180,    0,  180,  180,  180,  181,    0,  181,
+      181,  181,  181,  181,  181,  181,  181,  181,  182,    0,
+      182,  182,  182,  182,  182,  182,  182,  182,  182,  183,
+
+        0,  183,  183,  183,  183,  183,  183,  183,  183,  183,
+      186,    0,  186,  186,  186,  186,  186,  186,  186,  186,
+      186,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161,  161,  161,  161,  161,  161,
+      161,  161,  161,  161,  161
     } ;
 
 static yy_state_type yy_last_accepting_state;
 static char *yy_last_accepting_cpos;
+
+extern int yy_flex_debug;
+int yy_flex_debug = 1;
+
+static yyconst short int yy_rule_linenum[84] =
+    {   0,
+      313,  314,  339,  340,  341,  342,  343,  344,  346,  347,
+      355,  356,  357,  359,  360,  361,  362,  364,  365,  367,
+      368,  369,  378,  399,  404,  410,  411,  416,  423,  428,
+      430,  431,  432,  433,  434,  435,  436,  437,  438,  439,
+      440,  441,  442,  443,  448,  453,  454,  455,  460,  467,
+      472,  474,  475,  476,  477,  478,  479,  480,  481,  482,
+      483,  484,  489,  490,  491,  492,  497,  498,  506,  511,
+      512,  513,  519,  525,  526,  527,  528,  530,  531,  533,
+      543,  545,  554
+    } ;
 
 /* The intent behind this definition is that it'll catch
@@ -802 +580 @@
 /* -*-C-*-
  *
- * Copyright 1994 Martin von Loewis
- * Copyright 1998 Bertho A. Stultiens (BS)
+ * Copyright 1998-2000  Bertho A. Stultiens (BS)
  *
+ * 21-May-2000 BS       - Fixed the ident requirement of resource names
+ *                        which can be keywords.
+ * 30-Apr-2000 BS       - Reintegration into the wine-tree
+ * 11-Jan-2000 BS       - Very drastic cleanup because we don't have a
+ *                        preprocessor in here anymore.
+ * 02-Jan-2000 BS       - Removed the preprocessor code
+ * 23-Dec-1999 BS       - Removed the copyright for Martin von Loewis.
+ *                        There is really nothing left of his code in 
+ *                        this parser.
  * 20-Jun-1998 BS       - Changed the filename conversion. Filenames are
  *                        case-sensitive inder *nix, but not under dos.
@@ -845 +631 @@
  *                        escaped '\0'.
  */
-/* Exclusive rules when looking for a filename */
-#define yywf 1
-
-#define yywf_s 2
-
 /* Exclusive string handling */
-#define yystr 3
+#define yystr 1
 
 /* Exclusive unicode string handling */
-#define yylstr 4
+#define yylstr 2
 
 /* Exclusive rcdata single quoted data handling */
-#define yyrcd 5
+#define yyrcd 3
 
 /* Exclusive comment eating... */
-#define comment 6
-
-/* Preprocessor exclusives */
-#define pp_incl 7
-
-#define pp_def 8
-
-#define pp_undef 9
-
-#define pp_if 10
-
-#define pp_ifdef 11
-
-#define pp_ifndef 12
-
-#define pp_elif 13
-
-#define pp_else 14
-
-#define pp_endif 15
-
-#define pp_error 16
-
-/* Set when accumulating #define's expansion text */
-#define pp_def_s 17
-
-/* Set when processing function type defines */
-#define pp_ignore 18
-
-/* Set when need to strip to eol */
-#define pp_ignore_eol 19
-
-/* Set when handling a false #if case */
-#define pp_false 20
+#define comment 4
 
 /* Set when stripping c-junk */
-#define pp_stripe 21
-
-#define pp_strips 22
-
-#define pp_stripp 23
-
-#define pp_stripp_final 24
-
-/*%option stack*/
+#define pp_stripe 5
+
+#define pp_strips 6
+
+#define pp_stripp 7
+
+#define pp_stripp_final 8
+
+/* Set when scanning #line style directives */
+#define pp_line 9
+
+#define YY_STACK_USED 1
 #define YY_NEVER_INTERACTIVE 1
-/*%option noyywrap */
 /* Some shortcut definitions */
-#line 91 "parser.l"
-
-#if !defined(YY_FLEX_MAJOR_VERSION) || (1000 * YY_FLEX_MAJOR_VERSION + YY_FLEX_MINOR_VERSION < 2005)
-#error Must use flex version 2.5.1 or higher (yy_scan_* routines are required).
-#endif
+#line 79 "parser.l"
 
 /*#define LEX_DEBUG*/
@@ -922 +668 @@
 #include <string.h>
 #include <ctype.h>
+#include <assert.h>
 
 #include "wrc.h"
@@ -933 +680 @@
 #define YY_USE_PROTOS
 #define YY_NO_UNPUT
+#define YY_NO_TOP_STATE
 
 /* Always update the current character position within a line */
-#define YY_USER_ACTION  char_number+=yyleng;
-
-raw_data_t *new_raw_data(void);
-
-void addcchar(char c);
-void addwchar(short s);
-string_t *get_buffered_cstring(void);
-string_t *get_buffered_wstring(void);
-string_t *make_string(char *s);
-string_t *make_filename(char *s, int len);
-
-int line_number = 1;            /* The current line */
-int char_number = 1;            /* The current char pos within the line */
+#define YY_USER_ACTION  char_number+=yyleng; wanted_id = want_id; want_id = 0;
+
+static void addcchar(char c);
+static void addwchar(short s);
+static string_t *get_buffered_cstring(void);
+static string_t *get_buffered_wstring(void);
+static string_t *make_string(char *s);
+
 static char *cbuffer;           /* Buffers for string collection */
 static int cbufidx;
@@ -954 +697 @@
 static int wbufidx;
 static int wbufalloc = 0;
-static int want_nl = 0;         /* Set when newline needs to go to parser */
-static int want_ident = 0;      /* Set is #ifdef, #ifndef or defined is seen */
 static int stripslevel = 0;     /* Count {} during pp_strips/pp_stripe mode */
 static int stripplevel = 0;     /* Count () during pp_strips mode */
-static char *substtext = NULL;  /* Holds the substition text while getting a define */
 static int cjunk_tagline;       /* Where did we start stripping (helps error tracking) */
 
-#ifdef YY_USE_STACK
-void push_to(int start) { yy_push_state(start); }
-void pop_start(void)    { yy_pop_state(start); }
-#else
-#define MAXSTARTSTACK   32
-static int startstack[MAXSTARTSTACK];
-static int startstackidx = 0;
-
-void push_to(int start)
-{
-        if(yydebug)
-                printf("push_to(%d): %d -> %d\n", line_number, YY_START, start);
-        if(startstackidx >= MAXSTARTSTACK-1)
-                internal_error(__FILE__, __LINE__, "Start condition stack overflow");
-        startstack[startstackidx++] = YY_START;
-        BEGIN(start);
-}
-
-void pop_start(void)
-{
-        if(yydebug)
-                printf("pop_start(%d): %d <- %d\n", line_number, startstack[startstackidx-1], YY_START);
-        if(startstackidx <= 0)
-                internal_error(__FILE__, __LINE__, "Start condition stack underflow");
-        --startstackidx;
-        BEGIN(startstack[startstackidx]);
-}
-#endif
-
-
-struct bufferstackentry {
-        YY_BUFFER_STATE bufferstate;    /* Buffer to switch back to */
-        struct pp_entry *define;        /* Points to expanding define
-                                           or NULL if handling includes
-                                         */
-        int line_number;                /* Line that we were handling */
-        int char_number;                /* The current position */
-        char *filename;                 /* Filename that we were handling */
-};
-
-#define MAXBUFFERSTACK 128
-static struct bufferstackentry bufferstack[MAXBUFFERSTACK];
-static int bufferstackidx = 0;
-
-void push_buffer(YY_BUFFER_STATE buf, struct pp_entry *ppp, char *filename)
-{
-        if(yydebug)
-                printf("push_buffer: %p %p %p\n", buf, ppp, filename);
-        if(bufferstackidx >= MAXBUFFERSTACK-1)
-                internal_error(__FILE__, __LINE__, "Buffer stack overflow");
-        memset(&bufferstack[bufferstackidx], 0, sizeof(bufferstack[0]));
-        bufferstack[bufferstackidx].bufferstate = buf;
-        bufferstack[bufferstackidx].define = ppp;
-        if(ppp)
-                ppp->expanding = 1;
-        else if(filename)
-        {
-                /* These will track the yyerror to the correct file and line */
-                bufferstack[bufferstackidx].line_number = line_number;
-                bufferstack[bufferstackidx].char_number = char_number;
-                line_number = 1;
-                char_number = 1;
-                bufferstack[bufferstackidx].filename = input_name;
-                input_name = filename;
-        }
-        else
-                internal_error(__FILE__, __LINE__, "Pushing buffer without knowing where to go to");
-        bufferstackidx++;
-}
-
-YY_BUFFER_STATE pop_buffer(void)
-{
-        if(bufferstackidx <= 0)
-                return (YY_BUFFER_STATE)0;
-        bufferstackidx--;
-        if(bufferstack[bufferstackidx].define)
-                bufferstack[bufferstackidx].define->expanding = 0;
-        else
-        {
-                line_number = bufferstack[bufferstackidx].line_number;
-                char_number = bufferstack[bufferstackidx].char_number;
-                input_name = bufferstack[bufferstackidx].filename;
-                fclose(yyin);
-        }
-        if(yydebug)
-                printf("pop_buffer: %p %p (%d, %d) %p\n",
-                        bufferstack[bufferstackidx].bufferstate,
-                        bufferstack[bufferstackidx].define,
-                        bufferstack[bufferstackidx].line_number,
-                        bufferstack[bufferstackidx].char_number,
-                        bufferstack[bufferstackidx].filename);
-        yy_switch_to_buffer(bufferstack[bufferstackidx].bufferstate);
-        return bufferstack[bufferstackidx].bufferstate;
-}
-
-void do_include(char *name, int namelen)
-{
-        char *cpy = (char *)xmalloc(namelen);
-        strcpy(cpy, name+1);    /* strip leading " or < */
-        cpy[namelen-2] = '\0';  /* strip trailing " or > */
-        if((yyin = open_include(cpy, name[0] == '"')) == NULL)
-                yyerror("Unable to open include file %s", cpy);
-        push_buffer(YY_CURRENT_BUFFER, NULL, cpy);
-        yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
-}
-
+/*
+ * This one is a bit tricky.
+ * We set 'want_id' in the parser to get the first
+ * identifier we get across in the scanner, but we
+ * also want it to be reset at nearly any token we
+ * see. Exceptions are:
+ * - newlines
+ * - comments
+ * - whitespace
+ *
+ * The scanner will automatically reset 'want_id'
+ * after *each* scanner reduction and puts is value
+ * into the var below. In this way we can see the
+ * state after the YY_RULE_SETUP (i.e. the user action;
+ * see above) and don't have to worry too much when
+ * it needs to be reset.
+ */
+static int wanted_id = 0;
+static int save_wanted_id;      /* To save across comment reductions */
 
 struct keyword {
@@ -1073 +726 @@
         int     isextension;
         int     needcase;
-        int     alwayskeyword;
+        int     alwayskw;
 };
 
 static struct keyword keywords[] = {
-        { "ACCELERATORS", ACCELERATORS, 0, 0, 0},
-        { "ALT", ALT, 0, 0, 0},
-        { "ASCII", ASCII, 0, 0, 0},
-        { "AUTO3STATE", AUTO3STATE, 1, 0, 0},
-        { "AUTOCHECKBOX", AUTOCHECKBOX, 1, 0, 0},
-        { "AUTORADIOBUTTON", AUTORADIOBUTTON, 1, 0, 0},
-        { "BEGIN", tBEGIN, 0, 0, 1},
-        { "BITMAP", tBITMAP, 0, 0, 0},
-        { "BLOCK", BLOCK, 0, 0, 1},
-        { "BUTTON", BUTTON, 1, 0, 0},
-        { "CAPTION", CAPTION, 0, 0, 0},
-        { "CHARACTERISTICS", CHARACTERISTICS, 1, 0, 0},
-        { "CHECKBOX", CHECKBOX, 0, 0, 0},
-        { "CHECKED", CHECKED, 0, 0, 0},
-        { "CLASS", CLASS, 0, 0, 0},
-        { "COMBOBOX", COMBOBOX, 0, 0, 0},
-        { "CONTROL", CONTROL, 0, 0, 0},
-        { "CTEXT", CTEXT, 0, 0, 0},
-        { "CURSOR", CURSOR, 0, 0, 0},
-        { "defined", tDEFINED, 0, 1, 1},
-        { "DEFPUSHBUTTON", DEFPUSHBUTTON, 0, 0, 1},
-        { "DIALOG", DIALOG, 0, 0, 0},
-        { "DIALOGEX", DIALOGEX, 1, 0, 0},
-        { "DISCARDABLE", DISCARDABLE, 0, 0, 0},
-        { "DLGINIT", DLGINIT, 0, 0, 0},
-        { "EDITTEXT", EDITTEXT, 0, 0, 0},
-        { "END", tEND, 0, 0, 1},
-        { "EXSTYLE", EXSTYLE, 0, 0, 0},
-        { "extern", tEXTERN, 0, 1, 1},
-        { "FILEFLAGS", FILEFLAGS, 0, 0, 0},
-        { "FILEFLAGSMASK", FILEFLAGSMASK, 0, 0, 0},
-        { "FILEOS", FILEOS, 0, 0, 0},
-        { "FILESUBTYPE", FILESUBTYPE, 0, 0, 0},
-        { "FILETYPE", FILETYPE, 0, 0, 0},
-        { "FILEVERSION", FILEVERSION, 0, 0, 0},
-        { "FIXED", tFIXED, 0, 0, 0},
-        { "FONT", FONT, 0, 0, 0},
-        { "GRAYED", GRAYED, 0, 0, 0},
-        { "GROUPBOX", GROUPBOX, 0, 0, 0},
-        { "HELP", HELP, 0, 0, 0},
-        { "ICON", ICON, 0, 0, 0},
-        { "IMPURE", IMPURE, 0, 0, 0},
-        { "INACTIVE", INACTIVE, 0, 0, 0},
-        { "LANGUAGE", LANGUAGE, 1, 0, 1},
-        { "LISTBOX", LISTBOX, 0, 0, 0},
-        { "LOADONCALL", LOADONCALL, 0, 0, 0},
-        { "LTEXT", LTEXT, 0, 0, 0},
-        { "MENU", MENU, 0, 0, 0},
-        { "MENUBARBREAK", MENUBARBREAK, 0, 0, 0},
-        { "MENUBREAK", MENUBREAK, 0, 0, 0},
-        { "MENUEX", MENUEX, 1, 0, 0},
-        { "MENUITEM", MENUITEM, 0, 0, 0},
-        { "MESSAGETABLE", MESSAGETABLE, 1, 0, 0},
-        { "MOVEABLE", MOVEABLE, 0, 0, 0},
-        { "NOINVERT", NOINVERT, 0, 0, 0},
-        { "NOT", NOT, 0, 0, 0},
-        { "POPUP", POPUP, 0, 0, 0},
-        { "PRELOAD", PRELOAD, 0, 0, 0},
-        { "PRODUCTVERSION", PRODUCTVERSION, 0, 0, 0},
-        { "PURE", tPURE, 0, 0, 0},
-        { "PUSHBUTTON", PUSHBUTTON, 0, 0, 0},
-        { "RADIOBUTTON", RADIOBUTTON, 0, 0, 0},
-        { "RCDATA", RCDATA, 0, 0, 0},
-        { "RTEXT", RTEXT, 0, 0, 0},
-        { "SCROLLBAR", SCROLLBAR, 0, 0, 0},
-        { "SEPARATOR", SEPARATOR, 0, 0, 0},
-        { "SHIFT", SHIFT, 0, 0, 0},
-        { "STATE3", STATE3, 1, 0, 0},
-        { "STRING", tSTRING, 0, 0, 0},
-        { "STRINGTABLE", STRINGTABLE, 0, 0, 1},
-        { "STYLE", STYLE, 0, 0, 0},
-        { "TOOLBAR", TOOLBAR, 1, 0, 0},
-        { "typedef", tTYPEDEF, 0, 1, 1},
-        { "VALUE", VALUE, 0, 0, 0},
-        { "VERSION", VERSION, 1, 0, 0},
-        { "VERSIONINFO", VERSIONINFO, 0, 0, 0},
-        { "VIRTKEY", VIRTKEY, 0, 0, 0}
+        { "ACCELERATORS",       tACCELERATORS,          0, 0, 0},
+        { "ALT",                tALT,                   0, 0, 0},
+        { "ASCII",              tASCII,                 0, 0, 0},
+        { "AUTO3STATE",         tAUTO3STATE,            1, 0, 0},
+        { "AUTOCHECKBOX",       tAUTOCHECKBOX,          1, 0, 0},
+        { "AUTORADIOBUTTON",    tAUTORADIOBUTTON,       1, 0, 0},
+        { "BEGIN",              tBEGIN,                 0, 0, 0},
+        { "BITMAP",             tBITMAP,                0, 0, 0},
+        { "BLOCK",              tBLOCK,                 0, 0, 0},
+        { "BUTTON",             tBUTTON,                1, 0, 0},
+        { "CAPTION",            tCAPTION,               0, 0, 0},
+        { "CHARACTERISTICS",    tCHARACTERISTICS,       1, 0, 0},
+        { "CHECKBOX",           tCHECKBOX,              0, 0, 0},
+        { "CHECKED",            tCHECKED,               0, 0, 0},
+        { "CLASS",              tCLASS,                 0, 0, 0},
+        { "COMBOBOX",           tCOMBOBOX,              0, 0, 0},
+        { "CONTROL",            tCONTROL,               0, 0, 0},
+        { "CTEXT",              tCTEXT,                 0, 0, 0},
+        { "CURSOR",             tCURSOR,                0, 0, 0},
+        { "DEFPUSHBUTTON",      tDEFPUSHBUTTON,         0, 0, 0},
+        { "DIALOG",             tDIALOG,                0, 0, 0},
+        { "DIALOGEX",           tDIALOGEX,              1, 0, 0},
+        { "DISCARDABLE",        tDISCARDABLE,           0, 0, 0},
+        { "DLGINIT",            tDLGINIT,               0, 0, 0},
+        { "EDITTEXT",           tEDITTEXT,              0, 0, 0},
+        { "END",                tEND,                   0, 0, 0},
+        { "enum",               tENUM,                  0, 1, 1},
+        { "EXSTYLE",            tEXSTYLE,               0, 0, 0},
+        { "extern",             tEXTERN,                0, 1, 1},
+        { "FILEFLAGS",          tFILEFLAGS,             0, 0, 0},
+        { "FILEFLAGSMASK",      tFILEFLAGSMASK,         0, 0, 0},
+        { "FILEOS",             tFILEOS,                0, 0, 0},
+        { "FILESUBTYPE",        tFILESUBTYPE,           0, 0, 0},
+        { "FILETYPE",           tFILETYPE,              0, 0, 0},
+        { "FILEVERSION",        tFILEVERSION,           0, 0, 0},
+        { "FIXED",              tFIXED,                 0, 0, 0},
+        { "FONT",               tFONT,                  0, 0, 0},
+        { "FONTDIR",            tFONTDIR,               0, 0, 0},       /* This is a Borland BRC extension */
+        { "GRAYED",             tGRAYED,                0, 0, 0},
+        { "GROUPBOX",           tGROUPBOX,              0, 0, 0},
+        { "HELP",               tHELP,                  0, 0, 0},
+        { "ICON",               tICON,                  0, 0, 0},
+        { "IMPURE",             tIMPURE,                0, 0, 0},
+        { "INACTIVE",           tINACTIVE,              0, 0, 0},
+        { "inline",             tINLINE,                0, 1, 1},
+        { "LANGUAGE",           tLANGUAGE,              1, 0, 1},
+        { "LISTBOX",            tLISTBOX,               0, 0, 0},
+        { "LOADONCALL",         tLOADONCALL,            0, 0, 0},
+        { "LTEXT",              tLTEXT,                 0, 0, 0},
+        { "MENU",               tMENU,                  0, 0, 0},
+        { "MENUBARBREAK",       tMENUBARBREAK,          0, 0, 0},
+        { "MENUBREAK",          tMENUBREAK,             0, 0, 0},
+        { "MENUEX",             tMENUEX,                1, 0, 0},
+        { "MENUITEM",           tMENUITEM,              0, 0, 0},
+        { "MESSAGETABLE",       tMESSAGETABLE,          1, 0, 0},
+        { "MOVEABLE",           tMOVEABLE,              0, 0, 0},
+        { "NOINVERT",           tNOINVERT,              0, 0, 0},
+        { "NOT",                tNOT,                   0, 0, 0},
+        { "POPUP",              tPOPUP,                 0, 0, 0},
+        { "PRELOAD",            tPRELOAD,               0, 0, 0},
+        { "PRODUCTVERSION",     tPRODUCTVERSION,        0, 0, 0},
+        { "PURE",               tPURE,                  0, 0, 0},
+        { "PUSHBUTTON",         tPUSHBUTTON,            0, 0, 0},
+        { "RADIOBUTTON",        tRADIOBUTTON,           0, 0, 0},
+        { "RCDATA",             tRCDATA,                0, 0, 0},
+        { "RTEXT",              tRTEXT,                 0, 0, 0},
+        { "SCROLLBAR",          tSCROLLBAR,             0, 0, 0},
+        { "SEPARATOR",          tSEPARATOR,             0, 0, 0},
+        { "SHIFT",              tSHIFT,                 0, 0, 0},
+        { "STATE3",             tSTATE3,                1, 0, 0},
+        { "static",             tSTATIC,                0, 1, 1},
+        { "STRING",             tSTRING,                0, 0, 0},
+        { "STRINGTABLE",        tSTRINGTABLE,           0, 0, 1},
+        { "struct",             tSTRUCT,                0, 1, 1},
+        { "STYLE",              tSTYLE,                 0, 0, 0},
+        { "TOOLBAR",            tTOOLBAR,               1, 0, 0},
+        { "typedef",            tTYPEDEF,               0, 1, 1},
+        { "VALUE",              tVALUE,                 0, 0, 0},
+        { "VERSION",            tVERSION,               1, 0, 0},
+        { "VERSIONINFO",        tVERSIONINFO,           0, 0, 0},
+        { "VIRTKEY",            tVIRTKEY,               0, 0, 0}
 };
 
 #define NKEYWORDS       (sizeof(keywords)/sizeof(keywords[0]))
 #define KWP(p)          ((struct keyword *)(p))
-int kw_cmp_func(const void *s1, const void *s2)
+static int kw_cmp_func(const void *s1, const void *s2)
 {
         int ret;
@@ -1170 +827 @@
 #define KW_BSEARCH
 #define DO_SORT
-struct keyword *iskeyword(char *kw)
+static struct keyword *iskeyword(char *kw)
 {
         struct keyword *kwp;
@@ -1204 +861 @@
 #endif
 
-#ifdef LEX_DEBUG
-        if(kwp && !strcmp(kwp->keyword, "LANGUAGE"))
-                printf("Got Language\n");
-#endif
         if(kwp == NULL || (kwp->isextension && !extensions))
                 return NULL;
@@ -1214 +867 @@
 }
 
-void add_to_substtext(char *text, int len)
-{
-        if(!substtext)
-        {
-                substtext = xstrdup(text);
-        }
-        else
-        {
-                substtext = (char *)xrealloc(substtext, strlen(substtext)+len+1);
-                strcat(substtext, text);
-        }
-}
-
-#line 1230 "lexyy.c"
+/*
+ **************************************************************************
+ * The flexer starts here
+ **************************************************************************
+ */
+#line 875 "lexyy.c"
 
 /* Macros after this point can all be overridden by user definitions in
@@ -1377 +1022 @@
         register int yy_act;
 
-#line 411 "parser.l"
-
-        /* #include handling */
-#line 1383 "lexyy.c"
+#line 294 "parser.l"
+
+        /*
+         * Catch the GCC-style line statements here and parse them.
+         * This has the advantage that you can #include at any
+         * stage in the resource file.
+         * The preprocessor generates line directives in the format:
+         * # <linenum> "filename" <codes>
+         *
+         * Codes can be a sequence of:
+         * - 1 start of new file
+         * - 2 returning to previous
+         * - 3 system header
+         * - 4 interpret as C-code
+         *
+         * 4 is not used and 1 mutually excludes 2
+         * Anyhow, we are not really interested in these at all
+         * because we only want to know the linenumber and
+         * filename.
+         */
+#line 1045 "lexyy.c"
 
         if ( yy_init )
@@ -1432 +1094 @@
                                 {
                                 yy_current_state = (int) yy_def[yy_current_state];
-                                if ( yy_current_state >= 369 )
+                                if ( yy_current_state >= 162 )
                                         yy_c = yy_meta[(unsigned int) yy_c];
                                 }
@@ -1438 +1100 @@
                         ++yy_cp;
                         }
-                while ( yy_base[yy_current_state] != 1334 );
+                while ( yy_base[yy_current_state] != 622 );
 
 yy_find_action:
@@ -1454 +1116 @@
 do_action:      /* This label is used only to access EOF actions. */
 
+                if ( yy_flex_debug )
+                        {
+                        if ( yy_act == 0 )
+                                fprintf( stderr, "--scanner backing up\n" );
+                        else if ( yy_act < 84 )
+                                fprintf( stderr, "--accepting rule at line %d (\"%s\")\n",
+                                         yy_rule_linenum[yy_act], yytext );
+                        else if ( yy_act == 84 )
+                                fprintf( stderr, "--accepting default rule (\"%s\")\n",
+                                         yytext );
+                        else if ( yy_act == 85 )
+                                fprintf( stderr, "--(end of buffer or a NUL)\n" );
+                        else
+                                fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
+                        }
 
                 switch ( yy_act )
@@ -1466 +1143 @@
 case 1:
 YY_RULE_SETUP
-#line 413 "parser.l"
-push_to(pp_incl);
+#line 313 "parser.l"
+yy_push_state(pp_line);
         YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 414 "parser.l"
-do_include(yytext, yyleng); pop_start();
-        YY_BREAK
+#line 314 "parser.l"
+{
+                int lineno;
+                char *cptr;
+                char *fname;
+                yy_pop_state();
+                lineno = (int)strtol(yytext, &cptr, 10);
+                if(!lineno)
+                        yyerror("Malformed '#...' line-directive; invalid linenumber");
+                fname = strchr(cptr, '"');
+                if(!fname)
+                        yyerror("Malformed '#...' line-directive; missing filename");
+                fname++;
+                cptr = strchr(fname, '"');
+                if(!cptr)
+                        yyerror("Malformed '#...' line-directive; missing terminating \"");
+                *cptr = '\0';
+                line_number = lineno - 1;       /* We didn't read the newline */
+                input_name = xstrdup(fname);
+        }
+        YY_BREAK
+/*
+         * Strip everything until a ';' taking
+         * into account braces {} for structures,
+         * classes and enums.
+         */
 case 3:
 YY_RULE_SETUP
-#line 415 "parser.l"
-do_include(yytext, yyleng); pop_start();
+#line 339 "parser.l"
+stripslevel++;
         YY_BREAK
 case 4:
 YY_RULE_SETUP
-#line 416 "parser.l"
-yyerror("Malformed #include");
-        YY_BREAK
-/* #define handling */
+#line 340 "parser.l"
+stripslevel--;
+        YY_BREAK
 case 5:
 YY_RULE_SETUP
-#line 419 "parser.l"
-push_to(pp_def);
+#line 341 "parser.l"
+if(!stripslevel) yy_pop_state();
         YY_BREAK
 case 6:
 YY_RULE_SETUP
-#line 420 "parser.l"
+#line 342 "parser.l"
+; /* To catch comments */
+        YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 343 "parser.l"
+; /* Ignore rest */
+        YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 344 "parser.l"
+line_number++; char_number = 1;
+        YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 346 "parser.l"
+stripplevel++;
+        YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 347 "parser.l"
 {
-                                set_define(yytext);
-                                push_to(pp_def_s);
-                        }
-        YY_BREAK
-case 7:
-YY_RULE_SETUP
-#line 424 "parser.l"
-push_to(pp_ignore); /* Ignore function-like defines for now*/
-        YY_BREAK
-case 8:
-YY_RULE_SETUP
-#line 425 "parser.l"
-yyerror("Malformed #define");
-        YY_BREAK
-case 9:
-YY_RULE_SETUP
-#line 427 "parser.l"
-{
-                        if(YY_START == pp_def_s)
-                                add_to_substtext(yytext, yyleng);
-                }
-        YY_BREAK
-case 10:
-YY_RULE_SETUP
-#line 431 "parser.l"
-{ /* Comment is handled in normal handling */
-                        if(YY_START == pp_def_s)
-                                add_to_substtext(yytext, yyleng);
-                }
-        YY_BREAK
-case 11:
-YY_RULE_SETUP
-#line 435 "parser.l"
-line_number++;  char_number = 1; /* Line continuation */
-        YY_BREAK
-case 12:
-YY_RULE_SETUP
-#line 436 "parser.l"
-{
-                        if(YY_START == pp_def_s)
-                        {
-                                add_define(substtext ? substtext : "");
-                                free(substtext);
-                                substtext = NULL;
-                        }
-                        line_number++;
-                        char_number = 1;
-                        pop_start();
-                        pop_start();
-                }
-        YY_BREAK
-/* #undef handling */
-case 13:
-YY_RULE_SETUP
-#line 450 "parser.l"
-push_to(pp_undef);
-        YY_BREAK
-case 14:
-YY_RULE_SETUP
-#line 451 "parser.l"
-{
-                                del_define(yytext);
-                                pop_start();
-                                /*push_to(pp_ignore);*/
-                        }
-        YY_BREAK
-/* Conditional handling */
-case 15:
-YY_RULE_SETUP
-#line 458 "parser.l"
-{
-                        if(YY_START == pp_false)
-                        {
-                                if(yydebug)
-                                        printf("(%d)#if ignored\n", line_number);
-                                push_if(0, 0, 1);
-                                push_to(pp_ignore_eol);
-                        }
-                        else
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                return tIF;
-                        }
-                }
-        YY_BREAK
-case 16:
-YY_RULE_SETUP
-#line 473 "parser.l"
-{
-                        if(YY_START == pp_false)
-                        {
-                                if(yydebug)
-                                        printf("(%d)#ifdef ignored\n", line_number);
-                                push_if(0, 0, 1);
-                                push_to(pp_ignore_eol);
-                        }
-                        else
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                want_ident = 1;
-                                return tIFDEF;
-                        }
-                }
-        YY_BREAK
-case 17:
-YY_RULE_SETUP
-#line 489 "parser.l"
-{
-                        if(YY_START == pp_false)
-                        {
-                                if(yydebug)
-                                        printf("(%d)#ifndef ignored\n", line_number);
-                                push_if(0, 0, 1);
-                                push_to(pp_ignore_eol);
-                        }
-                        else
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                want_ident = 1;
-                                return tIFNDEF;
-                        }
-                }
-        YY_BREAK
-case 18:
-YY_RULE_SETUP
-#line 505 "parser.l"
-{
-                        if(!isnevertrue_if())
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                return tELIF;
-                        }
-                        else if(YY_START == pp_false)
-                                push_to(pp_ignore_eol);
-                        if(yydebug)
-                                printf("(%d)#elif ignored\n", line_number);
-                }
-        YY_BREAK
-case 19:
-YY_RULE_SETUP
-#line 517 "parser.l"
-{
-                        if(!isnevertrue_if())
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                return tELSE;
-                        }
-                        if(yydebug)
-                                printf("(%d)#else ignored\n", line_number);
-                }
-        YY_BREAK
-case 20:
-YY_RULE_SETUP
-#line 527 "parser.l"
-{
-                        if(!isnevertrue_if())
-                        {
-                                want_nl = 1;
-                                return tENDIF;
-                        }
-                        else
-                        {
-                                if(yydebug)
-                                        printf("(%d)#endif ignored\n", line_number);
-                                pop_if();
-                        }
-                }
-        YY_BREAK
-/* The error directive */
-case 21:
-YY_RULE_SETUP
-#line 542 "parser.l"
-push_to(pp_error);
-        YY_BREAK
-case 22:
-YY_RULE_SETUP
-#line 543 "parser.l"
-yyerror("Error directive: %s", yytext);
-        YY_BREAK
-case 23:
-YY_RULE_SETUP
-#line 544 "parser.l"
-{
-                        if(yydebug)
-                                printf("(%d)#error ignored\n", line_number);
-                }
-        YY_BREAK
-/* preprocessor junk */
-case 24:
-YY_RULE_SETUP
-#line 550 "parser.l"
-;       /* Ignore #pragma */
-        YY_BREAK
-case 25:
-YY_RULE_SETUP
-#line 551 "parser.l"
-;       /* Ignore #ident */
-        YY_BREAK
-case 26:
-YY_RULE_SETUP
-#line 552 "parser.l"
-;       /* Ignore #line */
-        YY_BREAK
-/* We'll get an error on malformed #xxx statements
-  * by not recognising '#' at all. This helps tracking
-  * preprocessor errors.
-  */
-/*^{ws}*#{ws}*                  ;        Ignore # */
-case 27:
-YY_RULE_SETUP
-#line 559 "parser.l"
-stripslevel++;
-        YY_BREAK
-case 28:
-YY_RULE_SETUP
-#line 560 "parser.l"
-stripslevel--;
-        YY_BREAK
-case 29:
-YY_RULE_SETUP
-#line 561 "parser.l"
-if(!stripslevel) pop_start();
-        YY_BREAK
-case 30:
-YY_RULE_SETUP
-#line 562 "parser.l"
-; /* To catch comments */
-        YY_BREAK
-case 31:
-YY_RULE_SETUP
-#line 563 "parser.l"
-; /* Ignore rest */
-        YY_BREAK
-case 32:
-YY_RULE_SETUP
-#line 565 "parser.l"
-stripslevel++;
-        YY_BREAK
-case 33:
-YY_RULE_SETUP
-#line 566 "parser.l"
-{
-                        stripslevel--;
-                        if(!stripslevel) pop_start();
-                }
-        YY_BREAK
-case 34:
-YY_RULE_SETUP
-#line 570 "parser.l"
-if(!stripslevel) pop_start();
-        YY_BREAK
-case 35:
-YY_RULE_SETUP
-#line 571 "parser.l"
-; /* To catch comments */
-        YY_BREAK
-case 36:
-YY_RULE_SETUP
-#line 572 "parser.l"
-; /* Ignore rest */
-        YY_BREAK
-case 37:
-YY_RULE_SETUP
-#line 574 "parser.l"
-stripplevel++;
-        YY_BREAK
-case 38:
-YY_RULE_SETUP
-#line 575 "parser.l"
-{
-                                stripplevel--;
-                                if(!stripplevel)
-                                {
-                                        pop_start();
-                                        push_to(pp_stripp_final);
-                                }
-                        }
-        YY_BREAK
-case 39:
-YY_RULE_SETUP
-#line 583 "parser.l"
-; /* To catch comments */
-        YY_BREAK
-case 40:
-YY_RULE_SETUP
-#line 584 "parser.l"
-; /* Ignore rest */
-        YY_BREAK
-case 41:
-YY_RULE_SETUP
-#line 586 "parser.l"
-; /* Ignore */
-        YY_BREAK
-case 42:
-YY_RULE_SETUP
-#line 587 "parser.l"
-pop_start(); /* Kill the semicolon */
-        YY_BREAK
-case 43:
-YY_RULE_SETUP
-#line 588 "parser.l"
-line_number++; char_number = 1; pop_start();
-        YY_BREAK
-case 44:
-YY_RULE_SETUP
-#line 589 "parser.l"
-yyless(0); pop_start();
-        YY_BREAK
-case 45:
-YY_RULE_SETUP
-#line 591 "parser.l"
-;       /* Ignore everything except #xxx during false #if state */
-        YY_BREAK
-case 46:
-YY_RULE_SETUP
-#line 593 "parser.l"
-pop_start();
-        YY_BREAK
-/* These are special cases due to filename scanning */
-case 47:
-YY_RULE_SETUP
-#line 596 "parser.l"
-return DISCARDABLE;
-        YY_BREAK
-case 48:
-YY_RULE_SETUP
-#line 597 "parser.l"
-return tFIXED;
-        YY_BREAK
-case 49:
-YY_RULE_SETUP
-#line 598 "parser.l"
-return IMPURE;
-        YY_BREAK
-case 50:
-YY_RULE_SETUP
-#line 599 "parser.l"
-return MOVEABLE;
-        YY_BREAK
-case 51:
-YY_RULE_SETUP
-#line 600 "parser.l"
-return LOADONCALL;
-        YY_BREAK
-case 52:
-YY_RULE_SETUP
-#line 601 "parser.l"
-return PRELOAD;
-        YY_BREAK
-case 53:
-YY_RULE_SETUP
-#line 602 "parser.l"
-return tPURE;
-        YY_BREAK
-case 54:
-YY_RULE_SETUP
-#line 604 "parser.l"
-return tBEGIN;
-        YY_BREAK
-case 55:
-YY_RULE_SETUP
-#line 605 "parser.l"
-return tEND;
-        YY_BREAK
-case 56:
-YY_RULE_SETUP
-#line 607 "parser.l"
-{ yylval.num = strtoul(yytext,  0, 10); return toupper(yytext[yyleng-1]) == 'L' ? LNUMBER : NUMBER; }
-        YY_BREAK
-case 57:
-YY_RULE_SETUP
-#line 608 "parser.l"
-{ yylval.num = strtoul(yytext,  0, 16); return toupper(yytext[yyleng-1]) == 'L' ? LNUMBER : NUMBER; }
-        YY_BREAK
-case 58:
-YY_RULE_SETUP
-#line 609 "parser.l"
-{ yylval.num = strtoul(yytext+2, 0, 8); return toupper(yytext[yyleng-1]) == 'L' ? LNUMBER : NUMBER; }
-        YY_BREAK
-case 59:
-YY_RULE_SETUP
-#line 610 "parser.l"
-{
-                                struct keyword *token;
-                                struct pp_entry *ppp;
-
-                                want_rscname = 0;
-                                
-                                if(want_ident)
-                                {
-                                        /* Prevent preprocessor subst */
-                                        want_ident = 0;
-                                        yylval.str = make_string(yytext);
-                                #ifdef LEX_DEBUG
-                                        printf("want IDENT (%s, %d, %d): <%s>\n", input_name, line_number, char_number, yytext);
-                                #endif
-                                        return IDENT;
-                                }
-                                else if((ppp = pp_lookup(yytext)) != NULL)
-                                {
-                                        /* Do preprocessor substitution,
-                                         * but expand only if macro is not
-                                         * already expanding.
-                                         */
-                                        if(!ppp->expanding)
+                                        stripplevel--;
+                                        if(!stripplevel)
                                         {
-                                #ifdef LEX_DEBUG
-                                                printf("expand IDENT (%s, %d, %d): <%s>\n", input_name, line_number, char_number, yytext);
-                                #endif
-                                                push_buffer(YY_CURRENT_BUFFER, ppp, NULL);
-                                                yy_scan_string(ppp->subst);
+                                                yy_pop_state();
+                                                yy_push_state(pp_stripp_final);
                                         }
                                 }
-                                else if((token = iskeyword(yytext)) != NULL
-                                  && !(!token->alwayskeyword && want_rscname))
+        YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 355 "parser.l"
+; /* To catch comments */
+        YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 356 "parser.l"
+; /* Ignore rest */
+        YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 357 "parser.l"
+line_number++; char_number = 1;
+        YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 359 "parser.l"
+; /* Ignore */
+        YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 360 "parser.l"
+yy_pop_state(); /* Kill the semicolon */
+        YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 361 "parser.l"
+line_number++; char_number = 1; yy_pop_state();
+        YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 362 "parser.l"
+yyless(0); yy_pop_state();
+        YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 364 "parser.l"
+return tBEGIN;
+        YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 365 "parser.l"
+return tEND;
+        YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 367 "parser.l"
+{ yylval.num = strtoul(yytext,  0, 10); return toupper(yytext[yyleng-1]) == 'L' ? tLNUMBER : tNUMBER; }
+        YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 368 "parser.l"
+{ yylval.num = strtoul(yytext,  0, 16); return toupper(yytext[yyleng-1]) == 'L' ? tLNUMBER : tNUMBER; }
+        YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 369 "parser.l"
+{ yylval.num = strtoul(yytext+2, 0, 8); return toupper(yytext[yyleng-1]) == 'L' ? tLNUMBER : tNUMBER; }
+        YY_BREAK
+/*
+         * The next two rules scan identifiers and filenames.
+         * This is achieved by using the priority ruling
+         * of the scanner where a '.' is valid in a filename
+         * and *only* in a filename. In this case, the second
+         * rule will be reduced because it is longer.
+         */
+case 23:
+YY_RULE_SETUP
+#line 378 "parser.l"
+{
+                                struct keyword *tok = iskeyword(yytext);
+
+                                if(tok)
                                 {
-                                        switch(token->token)
+                                        if(tok->token == tCLASS && !strcmp(yytext, "class"))
+                                                return tCPPCLASS;
+                                        else if(wanted_id && !tok->alwayskw)
                                         {
-                                        case tDEFINED:
-                                                want_ident = 1;
-                                                break;
-                                        /*case RCDATA:*/
-                                        case CURSOR:
-                                        case tBITMAP:
-                                        case MESSAGETABLE:
-                                        case DLGINIT:
-                                                push_to(yywf);
-                                                break;
-                                        case FONT:
-                                        case ICON:
-                                                if(!indialog)
-                                                        push_to(yywf);
-                                                break;
-                                        case DIALOG:
-                                        case DIALOGEX:
-                                                indialog = 1;
-                                                break;
+                                                yylval.str = make_string(yytext);
+                                                return tIDENT;
                                         }
-                                        return token->token;
+                                        else
+                                                return tok->token;
                                 }
                                 else
                                 {
                                         yylval.str = make_string(yytext);
-                                #ifdef LEX_DEBUG
-                                        printf("%s IDENT (%s, %d, %d): <%s>\n",
-                                                want_rscname ? "rscname" : "just",
-                                                input_name,
-                                                line_number,
-                                                char_number,
-                                                yytext);
-                                #endif
-                                        return IDENT;
+                                        return tIDENT;
                                 }
                         }
         YY_BREAK
-case 60:
-YY_RULE_SETUP
-#line 682 "parser.l"
-return LOGOR;
-        YY_BREAK
-case 61:
-YY_RULE_SETUP
-#line 683 "parser.l"
-return LOGAND;
-        YY_BREAK
-case 62:
-YY_RULE_SETUP
-#line 684 "parser.l"
-return EQ;
-        YY_BREAK
-case 63:
-YY_RULE_SETUP
-#line 685 "parser.l"
-return NE;
-        YY_BREAK
-case 64:
-YY_RULE_SETUP
-#line 686 "parser.l"
-return LTE;
-        YY_BREAK
-case 65:
-YY_RULE_SETUP
-#line 687 "parser.l"
-return GTE;
-        YY_BREAK
-case 66:
-YY_RULE_SETUP
-#line 689 "parser.l"
-{ pop_start(); yylval.str = make_filename(yytext, yyleng); return FILENAME; }
-        YY_BREAK
-case 67:
-YY_RULE_SETUP
-#line 690 "parser.l"
-push_to(yywf_s);
-        YY_BREAK
-case 68:
-YY_RULE_SETUP
-#line 691 "parser.l"
-{ pop_start(); pop_start(); yylval.str = make_filename(yytext, yyleng-1); return FILENAME; }
-        YY_BREAK
-case 69:
-YY_RULE_SETUP
-#line 692 "parser.l"
-yyerror("Newline in filename");
-        YY_BREAK
-case 70:
-YY_RULE_SETUP
-#line 694 "parser.l"
+case 24:
+YY_RULE_SETUP
+#line 399 "parser.l"
+yylval.str = make_string(yytext); return tFILENAME;
+        YY_BREAK
+/*
+         * Wide string scanning
+         */
+case 25:
+YY_RULE_SETUP
+#line 404 "parser.l"
 {
-                                push_to(yylstr);
+                                yy_push_state(yylstr);
                                 wbufidx = 0;
                                 if(!win32)
@@ -2014 +1331 @@
                         }
         YY_BREAK
-case 71:
-YY_RULE_SETUP
-#line 700 "parser.l"
+case 26:
+#line 411 "parser.l"
+case 27:
+YY_RULE_SETUP
+#line 411 "parser.l"
 {
-                                pop_start();
+                                yy_pop_state();
                                 yylval.str = get_buffered_wstring();
                                 return tSTRING;
                         }
         YY_BREAK
-case 72:
-YY_RULE_SETUP
-#line 705 "parser.l"
-yyerror("Unterminated string");
-        YY_BREAK
-case 73:
-YY_RULE_SETUP
-#line 706 "parser.l"
+case 28:
+YY_RULE_SETUP
+#line 416 "parser.l"
 { /* octal escape sequence */
                                 int result;
@@ -2039 +1353 @@
                         }
         YY_BREAK
-case 74:
-YY_RULE_SETUP
-#line 713 "parser.l"
+case 29:
+YY_RULE_SETUP
+#line 423 "parser.l"
 {  /* hex escape sequence */
                                 int result;
@@ -2048 +1362 @@
                         }
         YY_BREAK
-case 75:
-YY_RULE_SETUP
-#line 718 "parser.l"
+case 30:
+YY_RULE_SETUP
+#line 428 "parser.l"
+{  yyerror("Invalid hex escape sequence '%s'", yytext); }
+        YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 430 "parser.l"
 yyerror("Bad escape secuence");
         YY_BREAK
-case 76:
-YY_RULE_SETUP
-#line 719 "parser.l"
+case 32:
+YY_RULE_SETUP
+#line 431 "parser.l"
 addwchar('\a');
         YY_BREAK
-case 77:
-YY_RULE_SETUP
-#line 720 "parser.l"
+case 33:
+YY_RULE_SETUP
+#line 432 "parser.l"
 addwchar('\b');
         YY_BREAK
-case 78:
-YY_RULE_SETUP
-#line 721 "parser.l"
+case 34:
+YY_RULE_SETUP
+#line 433 "parser.l"
 addwchar('\f');
         YY_BREAK
-case 79:
-YY_RULE_SETUP
-#line 722 "parser.l"
+case 35:
+YY_RULE_SETUP
+#line 434 "parser.l"
 addwchar('\n');
         YY_BREAK
-case 80:
-YY_RULE_SETUP
-#line 723 "parser.l"
+case 36:
+YY_RULE_SETUP
+#line 435 "parser.l"
 addwchar('\r');
         YY_BREAK
-case 81:
-YY_RULE_SETUP
-#line 724 "parser.l"
+case 37:
+YY_RULE_SETUP
+#line 436 "parser.l"
 addwchar('\t');
         YY_BREAK
-case 82:
-YY_RULE_SETUP
-#line 725 "parser.l"
+case 38:
+YY_RULE_SETUP
+#line 437 "parser.l"
 addwchar('\v');
         YY_BREAK
-case 83:
-YY_RULE_SETUP
-#line 726 "parser.l"
+case 39:
+YY_RULE_SETUP
+#line 438 "parser.l"
 addwchar(yytext[1]);
         YY_BREAK
-case 84:
-YY_RULE_SETUP
-#line 727 "parser.l"
+case 40:
+YY_RULE_SETUP
+#line 439 "parser.l"
+addwchar(yytext[2]);
+        YY_BREAK
+case 41:
+YY_RULE_SETUP
+#line 440 "parser.l"
 addcchar('\"');         /* "bla""bla"  -> "bla\"bla" */
         YY_BREAK
-case 85:
-YY_RULE_SETUP
-#line 728 "parser.l"
+case 42:
+YY_RULE_SETUP
+#line 441 "parser.l"
 addcchar('\"');         /* "bla\""bla" -> "bla\"bla" */
         YY_BREAK
-case 86:
-YY_RULE_SETUP
-#line 729 "parser.l"
+case 43:
+YY_RULE_SETUP
+#line 442 "parser.l"
 ;                       /* "bla" "bla" -> "blabla" */
         YY_BREAK
-case 87:
-YY_RULE_SETUP
-#line 730 "parser.l"
+case 44:
+YY_RULE_SETUP
+#line 443 "parser.l"
 {
                                 char *yptr = yytext;
@@ -2117 +1441 @@
                         }
         YY_BREAK
-case 88:
-YY_RULE_SETUP
-#line 736 "parser.l"
+case 45:
+YY_RULE_SETUP
+#line 448 "parser.l"
+yyerror("Unterminated string");
+        YY_BREAK
+/*
+         * Normal string scanning
+         */
+case 46:
+YY_RULE_SETUP
+#line 453 "parser.l"
+yy_push_state(yystr); cbufidx = 0;
+        YY_BREAK
+case 47:
+#line 455 "parser.l"
+case 48:
+YY_RULE_SETUP
+#line 455 "parser.l"
 {
-                                push_to(yystr);
-                                cbufidx = 0;
-                        }
-        YY_BREAK
-case 89:
-YY_RULE_SETUP
-#line 740 "parser.l"
-{
-                                pop_start();
+                                yy_pop_state();
                                 yylval.str = get_buffered_cstring();
                                 return tSTRING;
                         }
         YY_BREAK
-case 90:
-YY_RULE_SETUP
-#line 745 "parser.l"
-yyerror("Unterminated string");
-        YY_BREAK
-case 91:
-YY_RULE_SETUP
-#line 746 "parser.l"
+case 49:
+YY_RULE_SETUP
+#line 460 "parser.l"
 { /* octal escape sequence */
                                 int result;
@@ -2150 +1476 @@
                         }
         YY_BREAK
-case 92:
-YY_RULE_SETUP
-#line 753 "parser.l"
+case 50:
+YY_RULE_SETUP
+#line 467 "parser.l"
 {  /* hex escape sequence */
                                 int result;
@@ -2159 +1485 @@
                         }
         YY_BREAK
-case 93:
-YY_RULE_SETUP
-#line 758 "parser.l"
+case 51:
+YY_RULE_SETUP
+#line 472 "parser.l"
+{  yyerror("Invalid hex escape sequence '%s'", yytext); }
+        YY_BREAK
+case 52:
+YY_RULE_SETUP
+#line 474 "parser.l"
 yyerror("Bad escape secuence");
         YY_BREAK
-case 94:
-YY_RULE_SETUP
-#line 759 "parser.l"
+case 53:
+YY_RULE_SETUP
+#line 475 "parser.l"
 addcchar('\a');
         YY_BREAK
-case 95:
-YY_RULE_SETUP
-#line 760 "parser.l"
+case 54:
+YY_RULE_SETUP
+#line 476 "parser.l"
 addcchar('\b');
         YY_BREAK
-case 96:
-YY_RULE_SETUP
-#line 761 "parser.l"
+case 55:
+YY_RULE_SETUP
+#line 477 "parser.l"
 addcchar('\f');
         YY_BREAK
-case 97:
-YY_RULE_SETUP
-#line 762 "parser.l"
+case 56:
+YY_RULE_SETUP
+#line 478 "parser.l"
 addcchar('\n');
         YY_BREAK
-case 98:
-YY_RULE_SETUP
-#line 763 "parser.l"
+case 57:
+YY_RULE_SETUP
+#line 479 "parser.l"
 addcchar('\r');
         YY_BREAK
-case 99:
-YY_RULE_SETUP
-#line 764 "parser.l"
+case 58:
+YY_RULE_SETUP
+#line 480 "parser.l"
 addcchar('\t');
         YY_BREAK
-case 100:
-YY_RULE_SETUP
-#line 765 "parser.l"
+case 59:
+YY_RULE_SETUP
+#line 481 "parser.l"
 addcchar('\v');
         YY_BREAK
-case 101:
-YY_RULE_SETUP
-#line 766 "parser.l"
+case 60:
+YY_RULE_SETUP
+#line 482 "parser.l"
 addcchar(yytext[1]);
         YY_BREAK
-case 102:
-YY_RULE_SETUP
-#line 767 "parser.l"
+case 61:
+YY_RULE_SETUP
+#line 483 "parser.l"
+addcchar(yytext[2]);
+        YY_BREAK
+case 62:
+YY_RULE_SETUP
+#line 484 "parser.l"
 {
                                 char *yptr = yytext;
@@ -2213 +1549 @@
                         }
         YY_BREAK
-case 103:
-YY_RULE_SETUP
-#line 772 "parser.l"
+case 63:
+YY_RULE_SETUP
+#line 489 "parser.l"
 addcchar('\"');         /* "bla""bla"   -> "bla\"bla" */
         YY_BREAK
-case 104:
-YY_RULE_SETUP
-#line 773 "parser.l"
+case 64:
+YY_RULE_SETUP
+#line 490 "parser.l"
 addcchar('\"');         /* "bla\""bla"  -> "bla\"bla" */
         YY_BREAK
-case 105:
-YY_RULE_SETUP
-#line 774 "parser.l"
+case 65:
+YY_RULE_SETUP
+#line 491 "parser.l"
 ;                       /* "bla" "bla"  -> "blabla" */
         YY_BREAK
-case 106:
-YY_RULE_SETUP
-#line 775 "parser.l"
-yywarning("Matched %c", *yytext);
-        YY_BREAK
-case 107:
-YY_RULE_SETUP
-#line 778 "parser.l"
+case 66:
+YY_RULE_SETUP
+#line 492 "parser.l"
+yyerror("Unterminated string");
+        YY_BREAK
+/*
+         * Raw data scanning
+         */
+case 67:
+YY_RULE_SETUP
+#line 497 "parser.l"
+yy_push_state(yyrcd); cbufidx = 0;
+        YY_BREAK
+case 68:
+YY_RULE_SETUP
+#line 498 "parser.l"
 {
-                                push_to(yyrcd);
-                                cbufidx = 0;
-                        }
-        YY_BREAK
-case 108:
-YY_RULE_SETUP
-#line 782 "parser.l"
-{
-                                pop_start();
+                                yy_pop_state();
                                 yylval.raw = new_raw_data();
                                 yylval.raw->size = cbufidx;
                                 yylval.raw->data = xmalloc(yylval.raw->size);
                                 memcpy(yylval.raw->data, cbuffer, yylval.raw->size);
-                                return RAWDATA;
-                        }
-        YY_BREAK
-case 109:
-YY_RULE_SETUP
-#line 790 "parser.l"
+                                return tRAWDATA;
+                        }
+        YY_BREAK
+case 69:
+YY_RULE_SETUP
+#line 506 "parser.l"
 {
                                 int result;
@@ -2262 +1598 @@
                         }
         YY_BREAK
-case 110:
-YY_RULE_SETUP
-#line 795 "parser.l"
+case 70:
+YY_RULE_SETUP
+#line 511 "parser.l"
 ;       /* Ignore space */
         YY_BREAK
-case 111:
-YY_RULE_SETUP
-#line 796 "parser.l"
+case 71:
+YY_RULE_SETUP
+#line 512 "parser.l"
 line_number++; char_number = 1;
         YY_BREAK
-case 112:
-YY_RULE_SETUP
-#line 797 "parser.l"
+case 72:
+YY_RULE_SETUP
+#line 513 "parser.l"
 yyerror("Malformed data-line");
         YY_BREAK
-case 113:
-YY_RULE_SETUP
-#line 799 "parser.l"
-push_to(comment);       /* Eat comment */
-        YY_BREAK
-case 114:
-YY_RULE_SETUP
-#line 800 "parser.l"
+/*
+         * Comment stripping
+         * Should never occur after preprocessing
+         */
+case 73:
+YY_RULE_SETUP
+#line 519 "parser.l"
+{
+                                yy_push_state(comment);
+                                save_wanted_id = wanted_id;
+                                if(!no_preprocess)
+                                        yywarning("Found comments after preprocessing, please report");
+                        }
+        YY_BREAK
+case 74:
+YY_RULE_SETUP
+#line 525 "parser.l"
 ;
         YY_BREAK
-case 115:
-YY_RULE_SETUP
-#line 801 "parser.l"
+case 75:
+YY_RULE_SETUP
+#line 526 "parser.l"
 ;
         YY_BREAK
-case 116:
-YY_RULE_SETUP
-#line 802 "parser.l"
+case 76:
+YY_RULE_SETUP
+#line 527 "parser.l"
 line_number++; char_number = 1;
         YY_BREAK
-case 117:
-YY_RULE_SETUP
-#line 803 "parser.l"
-pop_start();
-        YY_BREAK
-case 118:
-YY_RULE_SETUP
-#line 805 "parser.l"
-; /* Eat comment */
-        YY_BREAK
-case 119:
-YY_RULE_SETUP
-#line 806 "parser.l"
-; /* Eat comment */
-        YY_BREAK
-case 120:
-YY_RULE_SETUP
-#line 808 "parser.l"
+case 77:
+YY_RULE_SETUP
+#line 528 "parser.l"
+yy_pop_state(); want_id = save_wanted_id;
+        YY_BREAK
+case 78:
+YY_RULE_SETUP
+#line 530 "parser.l"
+want_id = wanted_id; /* not really comment, but left-over c-junk */
+        YY_BREAK
+case 79:
+YY_RULE_SETUP
+#line 531 "parser.l"
+want_id = wanted_id; if(!no_preprocess) yywarning("Found comments after preprocessing, please report");
+        YY_BREAK
+case 80:
+YY_RULE_SETUP
+#line 533 "parser.l"
 {
-                                if(YY_START == yywf)
-                                        pop_start();
+                                want_id = wanted_id;
                                 line_number++;
                                 char_number = 1;
@@ -2327 +1671 @@
                         }
         YY_BREAK
-case 121:
-YY_RULE_SETUP
-#line 819 "parser.l"
-;       /* Eat whitespace */
-        YY_BREAK
-case 122:
-YY_RULE_SETUP
-#line 821 "parser.l"
+case 81:
+YY_RULE_SETUP
+#line 543 "parser.l"
+want_id = wanted_id;    /* Eat whitespace */
+        YY_BREAK
+case 82:
+YY_RULE_SETUP
+#line 545 "parser.l"
 return yytext[0];
         YY_BREAK
 case YY_STATE_EOF(INITIAL):
-case YY_STATE_EOF(yywf):
-case YY_STATE_EOF(yywf_s):
 case YY_STATE_EOF(yystr):
 case YY_STATE_EOF(yylstr):
 case YY_STATE_EOF(yyrcd):
 case YY_STATE_EOF(comment):
-case YY_STATE_EOF(pp_incl):
-case YY_STATE_EOF(pp_def):
-case YY_STATE_EOF(pp_undef):
-case YY_STATE_EOF(pp_if):
-case YY_STATE_EOF(pp_ifdef):
-case YY_STATE_EOF(pp_ifndef):
-case YY_STATE_EOF(pp_elif):
-case YY_STATE_EOF(pp_else):
-case YY_STATE_EOF(pp_endif):
-case YY_STATE_EOF(pp_error):
-case YY_STATE_EOF(pp_def_s):
-case YY_STATE_EOF(pp_ignore):
-case YY_STATE_EOF(pp_ignore_eol):
-case YY_STATE_EOF(pp_false):
 case YY_STATE_EOF(pp_stripe):
 case YY_STATE_EOF(pp_strips):
 case YY_STATE_EOF(pp_stripp):
 case YY_STATE_EOF(pp_stripp_final):
-#line 822 "parser.l"
+case YY_STATE_EOF(pp_line):
+#line 547 "parser.l"
 {
-                                YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
-                                if(!pop_buffer())
-                                {
-                                        if(YY_START == pp_strips || YY_START == pp_stripe || YY_START == pp_stripp || YY_START == pp_stripp_final)
-                                                yyerror("Unexpected end of file during c-junk scanning (started at %d)", cjunk_tagline);
-                                        else
-                                                yyterminate();
-                                }
-                                yy_delete_buffer(b);
-                        }
-        YY_BREAK
-case 123:
-YY_RULE_SETUP
-#line 834 "parser.l"
+                                if(YY_START == pp_strips || YY_START == pp_stripe || YY_START == pp_stripp || YY_START == pp_stripp_final)
+                                        yyerror("Unexpected end of file during c-junk scanning (started at %d)", cjunk_tagline);
+                                else
+                                        yyterminate();
+                        }
+        YY_BREAK
+case 83:
+YY_RULE_SETUP
+#line 554 "parser.l"
 {
                                 /* Catch all rule to find any unmatched text */
@@ -2386 +1710 @@
                                 }
                                 yywarning("Unmatched text '%c' (0x%02x) YY_START=%d stripslevel=%d",
-                                        isprint(*yytext) ? *yytext : '.', *yytext, YY_START,stripslevel);
-                        }
-        YY_BREAK
-case 124:
-YY_RULE_SETUP
-#line 845 "parser.l"
+                                        isprint(*yytext & 0xff) ? *yytext : '.', *yytext, YY_START,stripslevel);
+                        }
+        YY_BREAK
+case 84:
+YY_RULE_SETUP
+#line 565 "parser.l"
 ECHO;
         YY_BREAK
-#line 2397 "lexyy.c"
+#line 1721 "lexyy.c"
 
         case YY_END_OF_BUFFER:
@@ -2682 +2006 @@
                         {
                         yy_current_state = (int) yy_def[yy_current_state];
-                        if ( yy_current_state >= 369 )
+                        if ( yy_current_state >= 162 )
                                 yy_c = yy_meta[(unsigned int) yy_c];
                         }
@@ -2717 +2041 @@
                 {
                 yy_current_state = (int) yy_def[yy_current_state];
-                if ( yy_current_state >= 369 )
+                if ( yy_current_state >= 162 )
                         yy_c = yy_meta[(unsigned int) yy_c];
                 }
         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-        yy_is_jam = (yy_current_state == 368);
+        yy_is_jam = (yy_current_state == 161);
 
         return yy_is_jam ? 0 : yy_current_state;
@@ -3254 +2578 @@
         }
 #endif
-#line 845 "parser.l"
+#line 565 "parser.l"
 
 
@@ -3273 +2597 @@
  * the resource string.
  */
-void addcchar(char c)
+static void addcchar(char c)
 {
         if(cbufidx >= cbufalloc)
@@ -3285 +2609 @@
 }
 
-void addwchar(short s)
+static void addwchar(short s)
 {
         if(wbufidx >= wbufalloc)
@@ -3306 +2630 @@
 }
 
-string_t *get_buffered_cstring(void)
+static string_t *get_buffered_cstring(void)
 {
         string_t *str = new_string();
@@ -3314 +2638 @@
         memcpy(str->str.cstr, cbuffer, cbufidx);
         str->str.cstr[cbufidx] = '\0';
-/*      printf("got cstring \"%s\"\n", str->str.cstr); */
         return str;
 }
 
-string_t *get_buffered_wstring(void)
+static string_t *get_buffered_wstring(void)
 {
         string_t *str = new_string();
@@ -3329 +2652 @@
 }
 
-string_t *make_string(char *s)
+static string_t *make_string(char *s)
 {
         string_t *str = new_string();
@@ -3339 +2662 @@
 }
 
-string_t *make_filename(char *s, int len)
-{
-        char *cptr;
-        string_t *str = new_string();
-
-        str->size = len;
-        str->type = str_char;
-        str->str.cstr = (char *)xmalloc(str->size+1);
-        memcpy(str->str.cstr, s, str->size);
-        str->str.cstr[str->size] = '\0';
-
-        /* Remove escaped backslash and convert to forward */
-        cptr = str->str.cstr;
-        for(cptr = str->str.cstr; (cptr = strchr(cptr, '\\')) != NULL; cptr++)
-        {
-                if(cptr[1] == '\\')
-                {
-                        memmove(cptr, cptr+1, strlen(cptr));
-                        str->size--;
-                }
-                *cptr = '/';
-        }
-
-        /* Convert to lower case. Seems to be reasonable to do */
-        for(cptr = str->str.cstr; !leave_case && *cptr; cptr++)
-        {
-                *cptr = tolower(*cptr);
-        }
-        return str;
-}
-
-/* Called from the parser to signal filename request */
-void set_yywf(void)
-{
-        push_to(yywf);
-}
-
-/* Called from the parser to signal preprocessor if case */
-void set_pp_ignore(int state)
-{
-        if(state)
-                push_to(pp_false);
-        else
-                pop_start();
-}
-
 /* Called from the parser to kill c-junk */
 void strip_extern(void)
 {
         cjunk_tagline = line_number;
-        push_to(pp_stripe);
+        yy_push_state(pp_stripe);
 }
 
@@ -3395 +2672 @@
 {
         cjunk_tagline = line_number;
-        push_to(pp_strips);
+        yy_push_state(pp_strips);
 }
 
@@ -3402 +2679 @@
         cjunk_tagline = line_number;
         stripplevel = 1;        /* One scanned already */
-        push_to(pp_stripp);
+        yy_push_state(pp_stripp);
 }
 

trunk/tools/wrc/makefile.os2

@@ -1 @@
-# $Id: makefile.os2,v 1.12 2000-12-02 23:27:03 bird Exp $
+# $Id: makefile.os2,v 1.13 2001-04-16 17:10:52 sandervl Exp $
 
 
@@ -8 +8 @@
 
 #DEFS      = -D__WINE__ -D__WIN32OS2__ -idirafter ../../include/win -idirafter ../../include
-DEFS      = -D__WINE__ -D__SEMICOLON__  -I. -I../../include/win -I../../include
+DEFS      = -D__WINE__ -D__EMX__ -DMASM -D__SEMICOLON__  -I. -I../../include/win -I../../include -g -DDEBUG
 
 PROGRAMS = wrc.exe
 MODULE   = none
+
+YACCOPT   = #-v
 
 OBJS = \
@@ -23 +25 @@
         y.tab.o \
         lexyy.o \
-        writeres.o
+        ppy.tab.o \
+        lex.ppl.o \
+        writeres.o \
+        u/string.o \
+        u/cptable.o \
+        u/utf8.o \
+        u/mbtowc.o \
+        u/wctomb.o \
+        u/c_869.o \
+        u/c_775.o \
+        u/c_865.o \
+        u/c_857.o \
+        u/c_10000.o \
+        u/c_10006.o \
+        u/c_861.o \
+        u/c_737.o \
+        u/c_860.o \
+        u/c_1253.o \
+        u/c_28597.o \
+        u/c_10029.o \
+        u/c_10081.o \
+        u/c_1257.o \
+        u/c_1252.o \
+        u/c_1254.o \
+        u/c_28591.o \
+        u/c_437.o \
+        u/c_10079.o \
+        u/c_852.o \
+        u/c_875.o \
+        u/c_863.o \
+        u/c_037.o \
+        u/c_1258.o \
+        u/c_1250.o \
+        u/c_850.o \
+        u/c_28605.o \
+        u/c_500.o \
+        u/c_28599.o \
+        u/c_28600.o \
+        u/c_28603.o \
+        u/c_28604.o \
+        u/c_28594.o \
+        u/c_1026.o \
+        u/c_28592.o \
+        u/c_28593.o \
+        u/c_856.o \
+        u/c_1006.o \
+        u/c_862.o \
+        u/c_864.o \
+        u/c_878.o \
+        u/c_866.o \
+        u/c_855.o \
+        u/c_20866.o \
+        u/c_874.o \
+        u/c_424.o \
+        u/c_1255.o \
+        u/c_1256.o \
+        u/c_28596.o \
+        u/c_28598.o \
+        u/c_10007.o \
+        u/c_1251.o \
+        u/c_28595.o \
+        u/c_042.o \
+        u/compose.o \
+        u/c_932.o \
+        u/c_950.o \
+        u/c_936.o \
+        u/c_949.o \
+        u/casemap.o \
+        u/wctype.o
 
 EXTRA_SRCS = parser.y parser.l
@@ -43 +113 @@
 
 wrc.exe: lexyy.c y.tab.c $(OBJS)
-    $(CC) $(CFLAGS) -o $@ $(OBJS)
+    $(CC) $(CFLAGS) -o $@ $(OBJS)  -L. -lm
     copy $@ ..\bin
 
@@ -50 +120 @@
 
 lexyy.c: parser.l
-    $(LEX) -8 parser.l
+    $(LEX) -8 -d parser.l
 
+ppy.tab.c ppy.tab.h: ppy.y
+    $(YACC) $(YACCOPT) -bppy -ppp -d -t ppy.y -o ppy.tab.c
+
+lex.ppl.c: ppl.l
+    $(LEX) $(LEXOPT) -d -Ppp -8 -olex.ppl.c ppl.l
 
 dep:

trunk/tools/wrc/newstruc.c

@@ -13 +13 @@
 #include <string.h>
 #include <assert.h>
+#include <ctype.h>
 
 #include "wrc.h"
@@ -18 +19 @@
 #include "utils.h"
 #include "parser.h"
+
+#include "wingdi.h"     /* for BITMAPINFOHEADER */
 
 /* Generate new_* functions that have no parameters (NOTE: no ';') */
@@ -41 +44 @@
 __NEW_STRUCT_FUNC(string)
 __NEW_STRUCT_FUNC(toolbar_item)
+__NEW_STRUCT_FUNC(ani_any)
 
 /* New instances for all types of structures */
@@ -145 +149 @@
         }
         else
-                fnt->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
+                fnt->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
         return fnt;
 }
+
+fontdir_t *new_fontdir(raw_data_t *rd, int *memopt)
+{
+        fontdir_t *fnd = (fontdir_t *)xmalloc(sizeof(fontdir_t));
+        fnd->data = rd;
+        if(memopt)
+        {
+                fnd->memopt = *memopt;
+                free(memopt);
+        }
+        else
+                fnd->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
+        return fnd;
+}
+
+
+/*
+ * Convert bitmaps to proper endian
+ */
+static void convert_bitmap_swap_v3(BITMAPINFOHEADER *bih)
+{
+        bih->biSize             = BYTESWAP_DWORD(bih->biSize);
+        bih->biWidth            = BYTESWAP_DWORD(bih->biWidth);
+        bih->biHeight           = BYTESWAP_DWORD(bih->biHeight);
+        bih->biPlanes           = BYTESWAP_WORD(bih->biPlanes);
+        bih->biBitCount         = BYTESWAP_WORD(bih->biBitCount);
+        bih->biCompression      = BYTESWAP_DWORD(bih->biCompression);
+        bih->biSizeImage        = BYTESWAP_DWORD(bih->biSizeImage);
+        bih->biXPelsPerMeter    = BYTESWAP_DWORD(bih->biXPelsPerMeter);
+        bih->biYPelsPerMeter    = BYTESWAP_DWORD(bih->biYPelsPerMeter);
+        bih->biClrUsed          = BYTESWAP_DWORD(bih->biClrUsed);
+        bih->biClrImportant     = BYTESWAP_DWORD(bih->biClrImportant);
+}
+
+static void convert_bitmap_swap_v4(BITMAPV4HEADER *b4h)
+{
+        convert_bitmap_swap_v3((BITMAPINFOHEADER *)b4h);
+        b4h->bV4RedMask         = BYTESWAP_DWORD(b4h->bV4RedMask);
+        b4h->bV4GreenMask       = BYTESWAP_DWORD(b4h->bV4GreenMask);
+        b4h->bV4BlueMask        = BYTESWAP_DWORD(b4h->bV4BlueMask);
+        b4h->bV4AlphaMask       = BYTESWAP_DWORD(b4h->bV4AlphaMask);
+        b4h->bV4CSType          = BYTESWAP_DWORD(b4h->bV4CSType);
+        b4h->bV4Endpoints.ciexyzRed.ciexyzX     = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzX);
+        b4h->bV4Endpoints.ciexyzRed.ciexyzY     = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzY);
+        b4h->bV4Endpoints.ciexyzRed.ciexyzZ     = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzRed.ciexyzZ);
+        b4h->bV4Endpoints.ciexyzGreen.ciexyzX   = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzX);
+        b4h->bV4Endpoints.ciexyzGreen.ciexyzY   = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzY);
+        b4h->bV4Endpoints.ciexyzGreen.ciexyzZ   = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzGreen.ciexyzZ);
+        b4h->bV4Endpoints.ciexyzBlue.ciexyzX    = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzX);
+        b4h->bV4Endpoints.ciexyzBlue.ciexyzY    = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzY);
+        b4h->bV4Endpoints.ciexyzBlue.ciexyzZ    = BYTESWAP_DWORD(b4h->bV4Endpoints.ciexyzBlue.ciexyzZ);
+        b4h->bV4GammaRed        = BYTESWAP_DWORD(b4h->bV4GammaRed);
+        b4h->bV4GammaGreen      = BYTESWAP_DWORD(b4h->bV4GammaGreen);
+        b4h->bV4GammaBlue       = BYTESWAP_DWORD(b4h->bV4GammaBlue);
+}
+
+#define FL_SIGBE        0x01
+#define FL_SIZEBE       0x02
+#define FL_V4           0x04
+static int convert_bitmap(char *data, int size)
+{
+        BITMAPINFOHEADER *bih = (BITMAPINFOHEADER *)data;
+        BITMAPV4HEADER *b4h = (BITMAPV4HEADER *)data;
+        int type = 0;
+#ifdef WORDS_BIGENDIAN
+        DWORD bisizel = BYTESWAP_DWORD(sizeof(BITMAPINFOHEADER));
+        DWORD b4sizel = BYTESWAP_DWORD(sizeof(BITMAPV4HEADER));
+        DWORD bisizeb = sizeof(BITMAPINFOHEADER);
+        DWORD b4sizeb = sizeof(BITMAPV4HEADER);
+#else
+        DWORD bisizel = sizeof(BITMAPINFOHEADER);
+        DWORD b4sizel = sizeof(BITMAPV4HEADER);
+        DWORD bisizeb = BYTESWAP_DWORD(sizeof(BITMAPINFOHEADER));
+        DWORD b4sizeb = BYTESWAP_DWORD(sizeof(BITMAPV4HEADER));
+#endif
+
+        if(data[0] == 'B' && data[1] == 'M')
+        {
+                /* Little endian signature */
+                bih = (BITMAPINFOHEADER *)(data + sizeof(BITMAPFILEHEADER));
+                b4h = (BITMAPV4HEADER *)(data + sizeof(BITMAPFILEHEADER));
+        }
+        else if(data[0] == 'M' && data[1] == 'B')
+        {
+                type |= FL_SIGBE;       /* Big endian signature */
+                bih = (BITMAPINFOHEADER *)(data + sizeof(BITMAPFILEHEADER));
+                b4h = (BITMAPV4HEADER *)(data + sizeof(BITMAPFILEHEADER));
+        }
+
+        if(bih->biSize == bisizel)
+        {
+                /* Little endian */
+        }
+        else if(bih->biSize == b4sizel)
+        {
+                type |= FL_V4;
+        }
+        else if(bih->biSize == bisizeb)
+        {
+                type |= FL_SIZEBE;
+        }
+        else if(bih->biSize == b4sizeb)
+        {
+                type |= FL_SIZEBE | FL_V4;
+        }
+#ifdef __EMX__
+        else if(bih->biSize == sizeof(BITMAPCOREHEADER)) 
+        {
+                /* Little endian */
+        }
+#endif
+        else 
+                type = -1;
+
+        switch(type)
+        {
+        default:
+                break;
+        case FL_SIZEBE:
+        case FL_SIZEBE | FL_V4:
+                yywarning("Bitmap v%c signature little-endian, but size big-endian", type & FL_V4 ? '4' : '3');
+                break;
+        case FL_SIGBE:
+        case FL_SIGBE | FL_V4:
+                yywarning("Bitmap v%c signature big-endian, but size little-endian", type & FL_V4 ? '4' : '3');
+                break;
+        case -1:
+                yyerror("Invalid bitmap format");
+                break;
+        }
+
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                if(!(type & FL_SIZEBE))
+                {
+                        if(type & FL_V4)
+                                convert_bitmap_swap_v4(b4h);
+                        else
+                                convert_bitmap_swap_v3(bih);
+                }
+                break;
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                if(type & FL_SIZEBE)
+                {
+                        if(type & FL_V4)
+                                convert_bitmap_swap_v4(b4h);
+                        else
+                                convert_bitmap_swap_v3(bih);
+                }
+                break;
+        }
+
+        if(size && (void *)data != (void *)bih)
+        {
+                /* We have the fileheader still attached, remove it */
+                memmove(data, data+sizeof(BITMAPFILEHEADER), size - sizeof(BITMAPFILEHEADER));
+                return sizeof(BITMAPFILEHEADER);
+        }
+        return 0;
+}
+#undef FL_SIGBE
+#undef FL_SIZEBE
+#undef FL_V4
+
+/*
+ * Cursor and icon splitter functions used when allocating
+ * cursor- and icon-groups.
+ */
+typedef struct {
+        language_t      lan;
+        int             id;
+} id_alloc_t;
+
+static int get_new_id(id_alloc_t **list, int *n, language_t *lan)
+{
+        int i;
+        assert(lan != NULL);
+        assert(list != NULL);
+        assert(n != NULL);
+
+        if(!*list)
+        {
+                *list = (id_alloc_t *)xmalloc(sizeof(id_alloc_t));
+                *n = 1;
+                (*list)[0].lan = *lan;
+                (*list)[0].id = 1;
+                return 1;
+        }
+
+        for(i = 0; i < *n; i++)
+        {
+                if((*list)[i].lan.id == lan->id && (*list)[i].lan.sub == lan->sub)
+                        return ++((*list)[i].id);
+        }
+
+        *list = (id_alloc_t *)xrealloc(*list, sizeof(id_alloc_t) * (*n+1));
+        (*list)[*n].lan = *lan;
+        (*list)[*n].id = 1;
+        *n += 1;
+        return 1;
+}
+
+static int alloc_icon_id(language_t *lan)
+{
+        static id_alloc_t *idlist = NULL;
+        static int nid = 0;
+
+        return get_new_id(&idlist, &nid, lan);
+}
+
+static int alloc_cursor_id(language_t *lan)
+{
+        static id_alloc_t *idlist = NULL;
+        static int nid = 0;
+
+        return get_new_id(&idlist, &nid, lan);
+}
+
+static void split_icons(raw_data_t *rd, icon_group_t *icog, int *nico)
+{
+        int cnt;
+        int i;
+        icon_t *ico;
+        icon_t *list = NULL;
+        icon_header_t *ih = (icon_header_t *)rd->data;
+        int swap = 0;
+
+        if(ih->type == 1)
+                swap = 0;
+        else if(BYTESWAP_WORD(ih->type) == 1)
+                swap = 1;
+        else
+                yyerror("Icon resource data has invalid type id %d", ih->type);
+
+        cnt = swap ? BYTESWAP_WORD(ih->count) : ih->count;
+        for(i = 0; i < cnt; i++)
+        {
+                icon_dir_entry_t ide;
+                BITMAPINFOHEADER info;
+                memcpy(&ide, rd->data + sizeof(icon_header_t)
+                                      + i*sizeof(icon_dir_entry_t), sizeof(ide));
+
+                ico = new_icon();
+                ico->id = alloc_icon_id(icog->lvc.language);
+                ico->lvc = icog->lvc;
+                if(swap)
+                {
+                        ide.offset = BYTESWAP_DWORD(ide.offset);
+                        ide.ressize= BYTESWAP_DWORD(ide.ressize);
+                }
+                if(ide.offset > rd->size
+                || ide.offset + ide.ressize > rd->size)
+                        yyerror("Icon resource data corrupt");
+                ico->width = ide.width;
+                ico->height = ide.height;
+                ico->nclr = ide.nclr;
+                ico->planes = swap ? BYTESWAP_WORD(ide.planes) : ide.planes;
+                ico->bits = swap ? BYTESWAP_WORD(ide.bits) : ide.bits;
+                convert_bitmap((char *)rd->data + ide.offset, 0);
+                memcpy(&info, rd->data + ide.offset, sizeof(info));
+                if(!ico->planes)
+                {
+                        /* Argh! They did not fill out the resdir structure */
+                        /* The bitmap is in destination byteorder. We want native for our structures */
+                        switch(byteorder)
+                        {
+#ifdef WORDS_BIGENDIAN
+                        case WRC_BO_LITTLE:
+#else
+                        case WRC_BO_BIG:
+#endif
+                                ico->planes = BYTESWAP_WORD(info.biPlanes);
+                                break;
+                        default:
+                                ico->planes = info.biPlanes;
+                        }
+                }
+                if(!ico->bits)
+                {
+                        /* Argh! They did not fill out the resdir structure */
+                        /* The bitmap is in destination byteorder. We want native for our structures */
+                        switch(byteorder)
+                        {
+#ifdef WORDS_BIGENDIAN
+                        case WRC_BO_LITTLE:
+#else
+                        case WRC_BO_BIG:
+#endif
+                                ico->bits = BYTESWAP_WORD(info.biBitCount);
+                                break;
+                        default:
+                                ico->bits = info.biBitCount;
+                        }
+                }
+                ico->data = new_raw_data();
+                copy_raw_data(ico->data, rd, ide.offset, ide.ressize);
+                if(!list)
+                {
+                        list = ico;
+                }
+                else
+                {
+                        ico->next = list;
+                        list->prev = ico;
+                        list = ico;
+                }
+        }
+        icog->iconlist = list;
+        *nico = cnt;
+}
+
+static void split_cursors(raw_data_t *rd, cursor_group_t *curg, int *ncur)
+{
+        int cnt;
+        int i;
+        cursor_t *cur;
+        cursor_t *list = NULL;
+        cursor_header_t *ch = (cursor_header_t *)rd->data;
+        int swap = 0;
+
+        if(ch->type == 2)
+                swap = 0;
+        else if(BYTESWAP_WORD(ch->type) == 2)
+                swap = 1;
+        else
+                yyerror("Cursor resource data has invalid type id %d", ch->type);
+        cnt = swap ? BYTESWAP_WORD(ch->count) : ch->count;
+        for(i = 0; i < cnt; i++)
+        {
+                cursor_dir_entry_t cde;
+                BITMAPINFOHEADER info;
+                memcpy(&cde, rd->data + sizeof(cursor_header_t)
+                                      + i*sizeof(cursor_dir_entry_t), sizeof(cde));
+
+                cur = new_cursor();
+                cur->id = alloc_cursor_id(curg->lvc.language);
+                cur->lvc = curg->lvc;
+                if(swap)
+                {
+                        cde.offset = BYTESWAP_DWORD(cde.offset);
+                        cde.ressize= BYTESWAP_DWORD(cde.ressize);
+                }
+                if(cde.offset > rd->size
+                || cde.offset + cde.ressize > rd->size)
+                        yyerror("Cursor resource data corrupt");
+                cur->width = cde.width;
+                cur->height = cde.height;
+                cur->nclr = cde.nclr;
+                convert_bitmap((char *)rd->data + cde.offset, 0);
+                memcpy(&info, rd->data + cde.offset, sizeof(info));
+                /* The bitmap is in destination byteorder. We want native for our structures */
+                switch(byteorder)
+                {
+#ifdef WORDS_BIGENDIAN
+                case WRC_BO_LITTLE:
+#else
+                case WRC_BO_BIG:
+#endif
+                        cur->planes = BYTESWAP_WORD(info.biPlanes);
+                        cur->bits = BYTESWAP_WORD(info.biBitCount);
+                        break;
+                default:
+                        cur->planes = info.biPlanes;
+                        cur->bits = info.biBitCount;
+                }
+                if(!win32 && (cur->planes != 1 || cur->bits != 1))
+                        yywarning("Win16 cursor contains colors");
+                cur->xhot = swap ? BYTESWAP_WORD(cde.xhot) : cde.xhot;
+                cur->yhot = swap ? BYTESWAP_WORD(cde.yhot) : cde.yhot;
+                cur->data = new_raw_data();
+                copy_raw_data(cur->data, rd, cde.offset, cde.ressize);
+                if(!list)
+                {
+                        list = cur;
+                }
+                else
+                {
+                        cur->next = list;
+                        list->prev = cur;
+                        list = cur;
+                }
+        }
+        curg->cursorlist = list;
+        *ncur = cnt;
+}
+
 
 icon_group_t *new_icon_group(raw_data_t *rd, int *memopt)
@@ -159 +556 @@
         else
                 icog->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
-        icog->lvc.language = dup_language(currentlanguage);
+        icog->lvc = rd->lvc;
         split_icons(rd, icog, &(icog->nicon));
         free(rd->data);
@@ -176 +573 @@
         else
                 curg->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
-        curg->lvc.language = dup_language(currentlanguage);
+        curg->lvc = rd->lvc;
         split_cursors(rd, curg, &(curg->ncursor));
         free(rd->data);
@@ -183 +580 @@
 }
 
+/*
+ * Animated cursors and icons
+ *
+ * The format of animated cursors and icons is yet another example
+ * of bad design by "The Company". The entire RIFF structure is
+ * flawed by design because it is inconsistent and single minded:
+ * - some tags have lengths attached, others don't. The use of these
+ *   non-length tags is absolutely unclear;
+ * - the content of "icon" tags can be both icons and cursors;
+ * - tags lack proper alignment constraints. It seems that everything
+ *   is 16bit aligned, but I could not find that in any docu. Just be
+ *   prepared to eat anything;
+ * - there are no strict constraints on tag-nesting and the organization
+ *   is highly illogical;
+ *
+ * Anyhow, here is the basic structure:
+ * "RIFF" { dword taglength }
+ *      "ACON"                                  // What does it do?
+ *      "LIST" { dword taglength }
+ *              "INFO"                          // And what does this do?
+ *              "INAM" { dword taglength }      // Icon/cursor name
+ *                      {inam data}
+ *              "IART" { dword taglength }      // The artist
+ *                      {iart data}
+ *              "fram"                          // Is followed by "icon"s
+ *              "icon" { dword taglength }      // First frame
+ *                      { icon/cursor data }
+ *              "icon" { dword taglength }      // Second frame
+ *                      { icon/cursor data }
+ *                      ...                     // ...
+ *      "anih" { dword taglength }              // Header structure
+ *              { aniheader_t structure }
+ *      "rate" { dword taglength }              // The rate for each frame
+ *              { `steps' dwords }
+ *      "seq " { dword taglength }              // The frame blit-order
+ *              { `steps' dwords }
+ *
+ * Tag length are bytelength without the header and length field (i.e. -8).
+ * The "LIST" tag may occur several times and may encapsulate different
+ * tags. The `steps' is the number of "icon" tags found (actually the
+ * number of steps specified in the aniheader_t structure). The "seq "uence
+ * tag can be ommitted, in which case the sequence is equal to the sequence
+ * of "icon"s found in the file. Also "rate" may be ommitted, in which case
+ * the default from the aniheader_t structure is used.
+ *
+ * An animated cursor puts `.cur' formatted files into each "icon" tag,
+ * whereas animated icons contain `.ico' formatted files.
+ *
+ * Note about the code: Yes, it can be shorter/compressed. Some tags can be
+ * dealt with in the same code. However, this version shows what is going on
+ * and is better debug-able.
+ */
+static const char riff[4] = "RIFF";
+static const char acon[4] = "ACON";
+static const char list[4] = "LIST";
+static const char info[4] = "INFO";
+static const char inam[4] = "INAM";
+static const char iart[4] = "IART";
+static const char fram[4] = "fram";
+static const char icon[4] = "icon";
+static const char anih[4] = "anih";
+static const char rate[4] = "rate";
+static const char seq[4]  = "seq ";
+
+#define NEXT_TAG(p)     ((riff_tag_t *)(((char *)p) + (isswapped ? BYTESWAP_DWORD(p->size) : p->size) + sizeof(*p)))
+
+static void handle_ani_icon(riff_tag_t *rtp, enum res_e type, int isswapped)
+{
+        cursor_dir_entry_t *cdp;
+        cursor_header_t *chp;
+        int count;
+        int ctype;
+        int i;
+        static int once = 0;    /* This will trigger only once per file! */
+        const char *anistr = type == res_aniico ? "icon" : "cursor";
+        /* Notes:
+         * Both cursor and icon directories are similar
+         * Both cursor and icon headers are similar
+         */
+
+        chp = (cursor_header_t *)(rtp+1);
+        cdp = (cursor_dir_entry_t *)(chp+1);
+        count = isswapped ? BYTESWAP_WORD(chp->count) : chp->count;
+        ctype = isswapped ? BYTESWAP_WORD(chp->type) : chp->type;
+        chp->reserved   = BYTESWAP_WORD(chp->reserved);
+        chp->type       = BYTESWAP_WORD(chp->type);
+        chp->count      = BYTESWAP_WORD(chp->count);
+
+        if(type == res_anicur && ctype != 2 && !once)
+        {
+                yywarning("Animated cursor contains invalid \"icon\" tag cursor-file (%d->%s)",
+                                ctype,
+                                ctype == 1 ? "icontype" : "?");
+                once++;
+        }
+        else if(type == res_aniico && ctype != 1 && !once)
+        {
+                yywarning("Animated icon contains invalid \"icon\" tag icon-file (%d->%s)",
+                                ctype,
+                                ctype == 2 ? "cursortype" : "?");
+                once++;
+        }
+        else if(ctype != 1 && ctype != 2 && !once)
+        {
+                yywarning("Animated %s contains invalid \"icon\" tag file-type (%d; neither icon nor cursor)", anistr, ctype);
+                once++;
+        }
+
+        for(i = 0; i < count; i++)
+        {
+                DWORD ofs = isswapped ? BYTESWAP_DWORD(cdp[i].offset) : cdp[i].offset;
+                DWORD sze = isswapped ? BYTESWAP_DWORD(cdp[i].ressize) : cdp[i].ressize;
+                if(ofs > rtp->size || ofs+sze > rtp->size)
+                        yyerror("Animated %s's data corrupt", anistr);
+                convert_bitmap((char *)chp + ofs, 0);
+                cdp[i].xhot     = BYTESWAP_WORD(cdp->xhot);
+                cdp[i].yhot     = BYTESWAP_WORD(cdp->yhot);
+                cdp[i].ressize  = BYTESWAP_DWORD(cdp->ressize);
+                cdp[i].offset   = BYTESWAP_DWORD(cdp->offset);
+        }
+}
+
+static void handle_ani_list(riff_tag_t *lst, enum res_e type, int isswapped)
+{
+        riff_tag_t *rtp = lst+1;        /* Skip the "LIST" tag */
+        
+        while((char *)rtp < (char *)lst + lst->size + sizeof(*lst))
+        {
+                if(!memcmp(rtp->tag, info, sizeof(info)))
+                {
+                        rtp = (riff_tag_t *)(((char *)rtp) + 4);
+                }
+                else if(!memcmp(rtp->tag, inam, sizeof(inam)))
+                {
+                        /* Ignore the icon/cursor name; its a string */
+                        rtp = NEXT_TAG(rtp);
+                }
+                else if(!memcmp(rtp->tag, iart, sizeof(iart)))
+                {
+                        /* Ignore the author's name; its a string */
+                        rtp = NEXT_TAG(rtp);
+                }
+                else if(!memcmp(rtp->tag, fram, sizeof(fram)))
+                {
+                        /* This should be followed by "icon"s, but we
+                         * simply ignore this because it is pure
+                         * non-information.
+                         */
+                        rtp = (riff_tag_t *)(((char *)rtp) + 4);
+                }
+                else if(!memcmp(rtp->tag, icon, sizeof(icon)))
+                {
+                        handle_ani_icon(rtp, type, isswapped);
+                        rtp = NEXT_TAG(rtp);
+                }
+                else
+                        internal_error(__FILE__, __LINE__, "Unknown tag \"%c%c%c%c\" in RIFF file",
+                                       isprint(rtp->tag[0]) ? rtp->tag[0] : '.',
+                                       isprint(rtp->tag[1]) ? rtp->tag[1] : '.',
+                                       isprint(rtp->tag[2]) ? rtp->tag[2] : '.',
+                                       isprint(rtp->tag[3]) ? rtp->tag[3] : '.');
+
+                /* FIXME: This relies in sizeof(DWORD) == sizeof(pointer_type) */
+                if((DWORD)rtp & 1)
+                        ((char *)rtp)++;
+        }
+}
+
+ani_curico_t *new_ani_curico(enum res_e type, raw_data_t *rd, int *memopt)
+{
+        ani_curico_t *ani = (ani_curico_t *)xmalloc(sizeof(ani_curico_t));
+        riff_tag_t *rtp;
+        int isswapped = 0;
+        int doswap;
+        const char *anistr = type == res_aniico ? "icon" : "cursor";
+
+        assert(!memcmp(rd->data, riff, sizeof(riff)));
+        assert(type == res_anicur || type == res_aniico);
+
+        rtp = (riff_tag_t *)rd->data;
+
+        if(BYTESWAP_DWORD(rtp->size) + 2*sizeof(DWORD) == rd->size)
+                isswapped = 1;
+        else if(rtp->size + 2*sizeof(DWORD) == rd->size)
+                isswapped = 0;
+        else
+                yyerror("Animated %s has an invalid RIFF length", anistr);
+
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        case WRC_BO_LITTLE:
+#else
+        case WRC_BO_BIG:
+#endif
+                doswap = !isswapped;
+                break;
+        default:
+                doswap = isswapped;
+        }
+
+        /*
+         * When to swap what:
+         * isswapped | doswap |
+         * ----------+--------+---------------------------------
+         *     0     |    0   | read native; don't convert
+         *     1     |    0   | read swapped size; don't convert
+         *     0     |    1   | read native; convert
+         *     1     |    1   | read swapped size; convert
+         * Reading swapped size if necessary to calculate in native
+         * format. E.g. a little-endian source on a big-endian
+         * processor.
+         */
+        if(doswap)
+        {
+                /* We only go through the RIFF file if we need to swap
+                 * bytes in words/dwords. Else we couldn't care less
+                 * what the file contains. This is consistent with
+                 * MS' rc.exe, which doesn't complain at all, eventhough
+                 * the fileformat might not be entirely correct.
+                 */
+                rtp++;  /* Skip the "RIFF" tag */
+
+                while((char *)rtp < (char *)rd->data + rd->size)
+                {
+                        if(!memcmp(rtp->tag, acon, sizeof(acon)))
+                        {
+                                rtp = (riff_tag_t *)(((char *)rtp) + 4);
+                        }
+                        else if(!memcmp(rtp->tag, list, sizeof(list)))
+                        {
+                                handle_ani_list(rtp, type, isswapped);
+                                rtp = NEXT_TAG(rtp);
+                        }
+                        else if(!memcmp(rtp->tag, anih, sizeof(anih)))
+                        {
+                                aniheader_t *ahp = (aniheader_t *)((char *)(rtp+1));
+                                ahp->structsize = BYTESWAP_DWORD(ahp->structsize);
+                                ahp->frames     = BYTESWAP_DWORD(ahp->frames);
+                                ahp->steps      = BYTESWAP_DWORD(ahp->steps);
+                                ahp->cx         = BYTESWAP_DWORD(ahp->cx);
+                                ahp->cy         = BYTESWAP_DWORD(ahp->cy);
+                                ahp->bitcount   = BYTESWAP_DWORD(ahp->bitcount);
+                                ahp->planes     = BYTESWAP_DWORD(ahp->planes);
+                                ahp->rate       = BYTESWAP_DWORD(ahp->rate);
+                                ahp->flags      = BYTESWAP_DWORD(ahp->flags);
+                                rtp = NEXT_TAG(rtp);
+                        }
+                        else if(!memcmp(rtp->tag, rate, sizeof(rate)))
+                        {
+                                int cnt = rtp->size / sizeof(DWORD);
+                                DWORD *dwp = (DWORD *)(rtp+1);
+                                int i;
+                                for(i = 0; i < cnt; i++)
+                                        dwp[i] = BYTESWAP_DWORD(dwp[i]);
+                                rtp = NEXT_TAG(rtp);
+                        }
+                        else if(!memcmp(rtp->tag, seq, sizeof(seq)))
+                        {
+                                int cnt = rtp->size / sizeof(DWORD);
+                                DWORD *dwp = (DWORD *)(rtp+1);
+                                int i;
+                                for(i = 0; i < cnt; i++)
+                                        dwp[i] = BYTESWAP_DWORD(dwp[i]);
+                                rtp = NEXT_TAG(rtp);
+                        }
+                        else
+                                internal_error(__FILE__, __LINE__, "Unknown tag \"%c%c%c%c\" in RIFF file",
+                                       isprint(rtp->tag[0]) ? rtp->tag[0] : '.',
+                                       isprint(rtp->tag[1]) ? rtp->tag[1] : '.',
+                                       isprint(rtp->tag[2]) ? rtp->tag[2] : '.',
+                                       isprint(rtp->tag[3]) ? rtp->tag[3] : '.');
+
+                        /* FIXME: This relies in sizeof(DWORD) == sizeof(pointer_type) */
+                        if((DWORD)rtp & 1)
+                                ((char *)rtp)++;
+                }
+
+                /* We must end correctly here */
+                if((char *)rtp != (char *)rd->data + rd->size)
+                        yyerror("Animated %s contains invalid field size(s)", anistr);
+        }
+
+        ani->data = rd;
+        if(memopt)
+        {
+                ani->memopt = *memopt;
+                free(memopt);
+        }
+        else
+                ani->memopt = WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE;
+        return ani;
+}
+#undef NEXT_TAG
+
+/* Bitmaps */
 bitmap_t *new_bitmap(raw_data_t *rd, int *memopt)
 {
         bitmap_t *bmp = (bitmap_t *)xmalloc(sizeof(bitmap_t));
+
         bmp->data = rd;
         if(memopt)
@@ -194 +888 @@
         else
                 bmp->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
+        rd->size -= convert_bitmap(rd->data, rd->size);
         return bmp;
 }
@@ -214 +909 @@
 }
 
-messagetable_t *new_messagetable(raw_data_t *rd)
+#define MSGTAB_BAD_PTR(p, b, l, r)      (((l) - ((char *)(p) - (char *)(b))) > (r))
+messagetable_t *new_messagetable(raw_data_t *rd, int *memopt)
 {
         messagetable_t *msg = (messagetable_t *)xmalloc(sizeof(messagetable_t));
+        msgtab_block_t *mbp;
+        DWORD nblk;
+        DWORD i;
+        WORD lo;
+        WORD hi;
+
         msg->data = rd;
+        if(memopt)
+        {
+                msg->memopt = *memopt;
+                free(memopt);
+        }
+        else
+                msg->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
+
+        if(rd->size < sizeof(DWORD))
+                yyerror("Invalid messagetable, size too small");
+
+        nblk = *(DWORD *)rd->data;
+        lo = WRC_LOWORD(nblk);
+        hi = WRC_HIWORD(nblk);
+
+        /* FIXME:
+         * This test will fail for all n*2^16 blocks in the messagetable.
+         * However, no sane person would want to have so many blocks
+         * and have a table of megabytes attached.
+         * So, I will assume that we have less than 2^16 blocks in the table
+         * and all will just work out fine. Otherwise, we would need to test
+         * the ID, offset and length (and flag) fields to be very sure.
+         */
+        if(hi && lo)
+                internal_error(__FILE__, __LINE__, "Messagetable contains more than 65535 blocks; cannot determine endian");
+        if(!hi && !lo)
+                yyerror("Invalid messagetable block count 0");
+
+        if(!hi && lo)  /* Messagetable byteorder == native byteorder */
+        {
+#ifdef WORDS_BIGENDIAN
+                if(byteorder != WRC_BO_LITTLE) goto out;
+#else
+                if(byteorder != WRC_BO_BIG) goto out;
+#endif
+                /* Resource byteorder != native byteorder */
+
+                mbp = (msgtab_block_t *)&(((DWORD *)rd->data)[1]);
+                if(MSGTAB_BAD_PTR(mbp, rd->data, rd->size, nblk * sizeof(*mbp)))
+                        yyerror("Messagetable's blocks are outside of defined data");
+                for(i = 0; i < nblk; i++)
+                {
+                        msgtab_entry_t *mep, *next_mep;
+                        DWORD id;
+
+                        mep = (msgtab_entry_t *)(((char *)rd->data) + mbp[i].offset);
+
+                        for(id = mbp[i].idlo; id <= mbp[i].idhi; id++)
+                        {
+                                if(MSGTAB_BAD_PTR(mep, rd->data, rd->size, mep->length))
+                                        yyerror("Messagetable's data for block %d, ID 0x%08lx is outside of defined data", (int)i, id);
+                                if(mep->flags == 1)     /* Docu says 'flags == 0x0001' for unicode */
+                                {
+                                        WORD *wp = (WORD *)&mep[1];
+                                        int l = mep->length/2 - 2; /* Length included header */
+                                        int n;
+
+                                        if(mep->length & 1)
+                                                yyerror("Message 0x%08lx is unicode (block %d), but has odd length (%d)", id, (int)i, mep->length);
+                                        for(n = 0; n < l; n++)
+                                                wp[n] = BYTESWAP_WORD(wp[n]);
+                                                
+                                }
+                                next_mep = (msgtab_entry_t *)(((char *)mep) + mep->length);
+                                mep->length = BYTESWAP_WORD(mep->length);
+                                mep->flags  = BYTESWAP_WORD(mep->flags);
+                                mep = next_mep;
+                        }
+
+                        mbp[i].idlo   = BYTESWAP_DWORD(mbp[i].idlo);
+                        mbp[i].idhi   = BYTESWAP_DWORD(mbp[i].idhi);
+                        mbp[i].offset = BYTESWAP_DWORD(mbp[i].offset);
+                }
+        }
+        if(hi && !lo)  /* Messagetable byteorder != native byteorder */
+        {
+#ifdef WORDS_BIGENDIAN
+                if(byteorder == WRC_BO_LITTLE) goto out;
+#else
+                if(byteorder == WRC_BO_BIG) goto out;
+#endif
+                /* Resource byteorder == native byteorder */
+
+                mbp = (msgtab_block_t *)&(((DWORD *)rd->data)[1]);
+                nblk = BYTESWAP_DWORD(nblk);
+                if(MSGTAB_BAD_PTR(mbp, rd->data, rd->size, nblk * sizeof(*mbp)))
+                        yyerror("Messagetable's blocks are outside of defined data");
+                for(i = 0; i < nblk; i++)
+                {
+                        msgtab_entry_t *mep;
+                        DWORD id;
+
+                        mbp[i].idlo   = BYTESWAP_DWORD(mbp[i].idlo);
+                        mbp[i].idhi   = BYTESWAP_DWORD(mbp[i].idhi);
+                        mbp[i].offset = BYTESWAP_DWORD(mbp[i].offset);
+                        mep = (msgtab_entry_t *)(((char *)rd->data) + mbp[i].offset);
+
+                        for(id = mbp[i].idlo; id <= mbp[i].idhi; id++)
+                        {
+                                mep->length = BYTESWAP_WORD(mep->length);
+                                mep->flags  = BYTESWAP_WORD(mep->flags);
+
+                                if(MSGTAB_BAD_PTR(mep, rd->data, rd->size, mep->length))
+                                        yyerror("Messagetable's data for block %d, ID 0x%08lx is outside of defined data", (int)i, id);
+                                if(mep->flags == 1)     /* Docu says 'flags == 0x0001' for unicode */
+                                {
+                                        WORD *wp = (WORD *)&mep[1];
+                                        int l = mep->length/2 - 2; /* Length included header */
+                                        int n;
+
+                                        if(mep->length & 1)
+                                                yyerror("Message 0x%08lx is unicode (block %d), but has odd length (%d)", id, (int)i, mep->length);
+                                        for(n = 0; n < l; n++)
+                                                wp[n] = BYTESWAP_WORD(wp[n]);
+                                                
+                                }
+                                mep = (msgtab_entry_t *)(((char *)mep) + mep->length);
+                        }
+                }
+        }
+
+ out:
         return msg;
 }
-
-void copy_raw_data(raw_data_t *dst, raw_data_t *src, int offs, int len)
+#undef MSGTAB_BAD_PTR
+
+void copy_raw_data(raw_data_t *dst, raw_data_t *src, unsigned int offs, int len)
 {
         assert(offs <= src->size);
@@ -294 +1119 @@
         return st;
 }
+

trunk/tools/wrc/newstruc.h

@@ -42 +42 @@
 __NEW_STRUCT_PROTO(string);
 __NEW_STRUCT_PROTO(toolbar_item);
+__NEW_STRUCT_PROTO(ani_any);
 
 resource_t *new_resource(enum res_e t, void *res, int memopt, language_t *lan);
@@ -54 +55 @@
 user_t *new_user(name_id_t *type, raw_data_t *rd, int *memopt);
 font_t *new_font(raw_data_t *rd, int *memopt);
+fontdir_t *new_fontdir(raw_data_t *rd, int *memopt);
 icon_group_t *new_icon_group(raw_data_t *rd, int *memopt);
 cursor_group_t *new_cursor_group(raw_data_t *rd, int *memopt);
+ani_curico_t *new_ani_curico(enum res_e type, raw_data_t *rd, int *memopt);
 bitmap_t *new_bitmap(raw_data_t *rd, int *memopt);
 ver_words_t *new_ver_words(int i);
 ver_words_t *add_ver_words(ver_words_t *w, int i);
-messagetable_t *new_messagetable(raw_data_t *rd);
+messagetable_t *new_messagetable(raw_data_t *rd, int *memopt);
 dlginit_t *new_dlginit(raw_data_t *rd, int *memopt);
-void copy_raw_data(raw_data_t *dst, raw_data_t *src, int offs, int len);
+void copy_raw_data(raw_data_t *dst, raw_data_t *src, unsigned int offs, int len);
 int *new_int(int i);
 stringtable_t *new_stringtable(lvc_t *lvc);

trunk/tools/wrc/parser.h

@@ -10 +10 @@
 /* From parser.y */
 extern int yydebug;
-extern int indialog;            /* Set when parsing dialogs */
-extern int want_rscname;        /* Set when a resource's name is required */
+extern int want_nl;             /* Set when getting line-numers */
+extern int want_id;             /* Set when getting the resource name */
 
 int yyparse(void);
-void split_icons(raw_data_t *rd, icon_group_t *icog, int *nico);
-void split_cursors(raw_data_t *rd, cursor_group_t *curg, int *ncur);
 
 /* From parser.l */
 extern FILE *yyin;
 extern char *yytext;
-extern int line_number;
-extern int char_number;
+extern int yy_flex_debug;
 
 int yylex(void);
-void set_yywf(void);
 void set_pp_ignore(int state);
-void push_to(int start);
-void pop_start(void);
-void strip_extern(void);
 void strip_til_semicolon(void);
 void strip_til_parenthesis(void);

trunk/tools/wrc/parser.l

@@ -1 +1 @@
 /* -*-C-*-
  *
- * Copyright 1994 Martin von Loewis
- * Copyright 1998 Bertho A. Stultiens (BS)
+ * Copyright 1998-2000  Bertho A. Stultiens (BS)
  *
+ * 21-May-2000 BS       - Fixed the ident requirement of resource names
+ *                        which can be keywords.
+ * 30-Apr-2000 BS       - Reintegration into the wine-tree
+ * 11-Jan-2000 BS       - Very drastic cleanup because we don't have a
+ *                        preprocessor in here anymore.
+ * 02-Jan-2000 BS       - Removed the preprocessor code
+ * 23-Dec-1999 BS       - Removed the copyright for Martin von Loewis.
+ *                        There is really nothing left of his code in 
+ *                        this parser.
  * 20-Jun-1998 BS       - Changed the filename conversion. Filenames are
  *                        case-sensitive inder *nix, but not under dos.
@@ -45 +53 @@
  */
 
-/* Exclusive rules when looking for a filename */
-%x yywf
-%x yywf_s
 /* Exclusive string handling */
 %x yystr
@@ -56 +61 @@
 /* Exclusive comment eating... */
 %x comment
-/* Preprocessor exclusives */
-%x pp_incl
-%x pp_def
-%x pp_undef
-%x pp_if
-%x pp_ifdef
-%x pp_ifndef
-%x pp_elif
-%x pp_else
-%x pp_endif
-%x pp_error
-/* Set when accumulating #define's expansion text */
-%x pp_def_s
-/* Set when processing function type defines */
-%x pp_ignore
-/* Set when need to strip to eol */
-%x pp_ignore_eol
-/* Set when handling a false #if case */
-%x pp_false
 /* Set when stripping c-junk */
 %x pp_stripe
@@ -80 +66 @@
 %x pp_stripp
 %x pp_stripp_final
-
-/*%option stack*/
+/* Set when scanning #line style directives */
+%x pp_line
+
+%option stack
 %option never-interactive
-/*%option noyywrap */
+
 /* Some shortcut definitions */
 ws      [ \f\t\r]
@@ -89 +77 @@
 
 %{
-
-#if !defined(YY_FLEX_MAJOR_VERSION) || (1000 * YY_FLEX_MAJOR_VERSION + YY_FLEX_MINOR_VERSION < 2005)
-#error Must use flex version 2.5.1 or higher (yy_scan_* routines are required).
-#endif
 
 /*#define LEX_DEBUG*/
@@ -102 +86 @@
 #include <string.h>
 #include <ctype.h>
+#include <assert.h>
 
 #include "wrc.h"
@@ -113 +98 @@
 #define YY_USE_PROTOS
 #define YY_NO_UNPUT
+#define YY_NO_TOP_STATE
 
 /* Always update the current character position within a line */
-#define YY_USER_ACTION  char_number+=yyleng;
-
-raw_data_t *new_raw_data(void);
-
-void addcchar(char c);
-void addwchar(short s);
-string_t *get_buffered_cstring(void);
-string_t *get_buffered_wstring(void);
-string_t *make_string(char *s);
-string_t *make_filename(char *s, int len);
-
-int line_number = 1;            /* The current line */
-int char_number = 1;            /* The current char pos within the line */
+#define YY_USER_ACTION  char_number+=yyleng; wanted_id = want_id; want_id = 0;
+
+static void addcchar(char c);
+static void addwchar(short s);
+static string_t *get_buffered_cstring(void);
+static string_t *get_buffered_wstring(void);
+static string_t *make_string(char *s);
+
 static char *cbuffer;           /* Buffers for string collection */
 static int cbufidx;
@@ -134 +115 @@
 static int wbufidx;
 static int wbufalloc = 0;
-static int want_nl = 0;         /* Set when newline needs to go to parser */
-static int want_ident = 0;      /* Set is #ifdef, #ifndef or defined is seen */
 static int stripslevel = 0;     /* Count {} during pp_strips/pp_stripe mode */
 static int stripplevel = 0;     /* Count () during pp_strips mode */
-static char *substtext = NULL;  /* Holds the substition text while getting a define */
 static int cjunk_tagline;       /* Where did we start stripping (helps error tracking) */
 
-#ifdef YY_USE_STACK
-void push_to(int start) { yy_push_state(start); }
-void pop_start(void)    { yy_pop_state(start); }
-#else
-#define MAXSTARTSTACK   32
-static int startstack[MAXSTARTSTACK];
-static int startstackidx = 0;
-
-void push_to(int start)
-{
-        if(yydebug)
-                printf("push_to(%d): %d -> %d\n", line_number, YY_START, start);
-        if(startstackidx >= MAXSTARTSTACK-1)
-                internal_error(__FILE__, __LINE__, "Start condition stack overflow");
-        startstack[startstackidx++] = YY_START;
-        BEGIN(start);
-}
-
-void pop_start(void)
-{
-        if(yydebug)
-                printf("pop_start(%d): %d <- %d\n", line_number, startstack[startstackidx-1], YY_START);
-        if(startstackidx <= 0)
-                internal_error(__FILE__, __LINE__, "Start condition stack underflow");
-        --startstackidx;
-        BEGIN(startstack[startstackidx]);
-}
-#endif
-
-
-struct bufferstackentry {
-        YY_BUFFER_STATE bufferstate;    /* Buffer to switch back to */
-        struct pp_entry *define;        /* Points to expanding define
-                                           or NULL if handling includes
-                                         */
-        int line_number;                /* Line that we were handling */
-        int char_number;                /* The current position */
-        char *filename;                 /* Filename that we were handling */
-};
-
-#define MAXBUFFERSTACK 128
-static struct bufferstackentry bufferstack[MAXBUFFERSTACK];
-static int bufferstackidx = 0;
-
-void push_buffer(YY_BUFFER_STATE buf, struct pp_entry *ppp, char *filename)
-{
-        if(yydebug)
-                printf("push_buffer: %p %p %p\n", buf, ppp, filename);
-        if(bufferstackidx >= MAXBUFFERSTACK-1)
-                internal_error(__FILE__, __LINE__, "Buffer stack overflow");
-        memset(&bufferstack[bufferstackidx], 0, sizeof(bufferstack[0]));
-        bufferstack[bufferstackidx].bufferstate = buf;
-        bufferstack[bufferstackidx].define = ppp;
-        if(ppp)
-                ppp->expanding = 1;
-        else if(filename)
-        {
-                /* These will track the yyerror to the correct file and line */
-                bufferstack[bufferstackidx].line_number = line_number;
-                bufferstack[bufferstackidx].char_number = char_number;
-                line_number = 1;
-                char_number = 1;
-                bufferstack[bufferstackidx].filename = input_name;
-                input_name = filename;
-        }
-        else
-                internal_error(__FILE__, __LINE__, "Pushing buffer without knowing where to go to");
-        bufferstackidx++;
-}
-
-YY_BUFFER_STATE pop_buffer(void)
-{
-        if(bufferstackidx <= 0)
-                return (YY_BUFFER_STATE)0;
-        bufferstackidx--;
-        if(bufferstack[bufferstackidx].define)
-                bufferstack[bufferstackidx].define->expanding = 0;
-        else
-        {
-                line_number = bufferstack[bufferstackidx].line_number;
-                char_number = bufferstack[bufferstackidx].char_number;
-                input_name = bufferstack[bufferstackidx].filename;
-                fclose(yyin);
-        }
-        if(yydebug)
-                printf("pop_buffer: %p %p (%d, %d) %p\n",
-                        bufferstack[bufferstackidx].bufferstate,
-                        bufferstack[bufferstackidx].define,
-                        bufferstack[bufferstackidx].line_number,
-                        bufferstack[bufferstackidx].char_number,
-                        bufferstack[bufferstackidx].filename);
-        yy_switch_to_buffer(bufferstack[bufferstackidx].bufferstate);
-        return bufferstack[bufferstackidx].bufferstate;
-}
-
-void do_include(char *name, int namelen)
-{
-        char *cpy = (char *)xmalloc(namelen);
-        strcpy(cpy, name+1);    /* strip leading " or < */
-        cpy[namelen-2] = '\0';  /* strip trailing " or > */
-        if((yyin = open_include(cpy, name[0] == '"')) == NULL)
-                yyerror("Unable to open include file %s", cpy);
-        push_buffer(YY_CURRENT_BUFFER, NULL, cpy);
-        yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
-}
-
+/*
+ * This one is a bit tricky.
+ * We set 'want_id' in the parser to get the first
+ * identifier we get across in the scanner, but we
+ * also want it to be reset at nearly any token we
+ * see. Exceptions are:
+ * - newlines
+ * - comments
+ * - whitespace
+ *
+ * The scanner will automatically reset 'want_id'
+ * after *each* scanner reduction and puts is value
+ * into the var below. In this way we can see the
+ * state after the YY_RULE_SETUP (i.e. the user action;
+ * see above) and don't have to worry too much when
+ * it needs to be reset.
+ */
+static int wanted_id = 0;
+static int save_wanted_id;      /* To save across comment reductions */
 
 struct keyword {
@@ -253 +144 @@
         int     isextension;
         int     needcase;
-        int     alwayskeyword;
+        int     alwayskw;
 };
 
 static struct keyword keywords[] = {
-        { "ACCELERATORS", ACCELERATORS, 0, 0, 0},
-        { "ALT", ALT, 0, 0, 0},
-        { "ASCII", ASCII, 0, 0, 0},
-        { "AUTO3STATE", AUTO3STATE, 1, 0, 0},
-        { "AUTOCHECKBOX", AUTOCHECKBOX, 1, 0, 0},
-        { "AUTORADIOBUTTON", AUTORADIOBUTTON, 1, 0, 0},
-        { "BEGIN", tBEGIN, 0, 0, 1},
-        { "BITMAP", tBITMAP, 0, 0, 0},
-        { "BLOCK", BLOCK, 0, 0, 1},
-        { "BUTTON", BUTTON, 1, 0, 0},
-        { "CAPTION", CAPTION, 0, 0, 0},
-        { "CHARACTERISTICS", CHARACTERISTICS, 1, 0, 0},
-        { "CHECKBOX", CHECKBOX, 0, 0, 0},
-        { "CHECKED", CHECKED, 0, 0, 0},
-        { "CLASS", CLASS, 0, 0, 0},
-        { "COMBOBOX", COMBOBOX, 0, 0, 0},
-        { "CONTROL", CONTROL, 0, 0, 0},
-        { "CTEXT", CTEXT, 0, 0, 0},
-        { "CURSOR", CURSOR, 0, 0, 0},
-        { "defined", tDEFINED, 0, 1, 1},
-        { "DEFPUSHBUTTON", DEFPUSHBUTTON, 0, 0, 1},
-        { "DIALOG", DIALOG, 0, 0, 0},
-        { "DIALOGEX", DIALOGEX, 1, 0, 0},
-        { "DISCARDABLE", DISCARDABLE, 0, 0, 0},
-        { "DLGINIT", DLGINIT, 0, 0, 0},
-        { "EDITTEXT", EDITTEXT, 0, 0, 0},
-        { "END", tEND, 0, 0, 1},
-        { "EXSTYLE", EXSTYLE, 0, 0, 0},
-        { "extern", tEXTERN, 0, 1, 1},
-        { "FILEFLAGS", FILEFLAGS, 0, 0, 0},
-        { "FILEFLAGSMASK", FILEFLAGSMASK, 0, 0, 0},
-        { "FILEOS", FILEOS, 0, 0, 0},
-        { "FILESUBTYPE", FILESUBTYPE, 0, 0, 0},
-        { "FILETYPE", FILETYPE, 0, 0, 0},
-        { "FILEVERSION", FILEVERSION, 0, 0, 0},
-        { "FIXED", tFIXED, 0, 0, 0},
-        { "FONT", FONT, 0, 0, 0},
-        { "GRAYED", GRAYED, 0, 0, 0},
-        { "GROUPBOX", GROUPBOX, 0, 0, 0},
-        { "HELP", HELP, 0, 0, 0},
-        { "ICON", ICON, 0, 0, 0},
-        { "IMPURE", IMPURE, 0, 0, 0},
-        { "INACTIVE", INACTIVE, 0, 0, 0},
-        { "LANGUAGE", LANGUAGE, 1, 0, 1},
-        { "LISTBOX", LISTBOX, 0, 0, 0},
-        { "LOADONCALL", LOADONCALL, 0, 0, 0},
-        { "LTEXT", LTEXT, 0, 0, 0},
-        { "MENU", MENU, 0, 0, 0},
-        { "MENUBARBREAK", MENUBARBREAK, 0, 0, 0},
-        { "MENUBREAK", MENUBREAK, 0, 0, 0},
-        { "MENUEX", MENUEX, 1, 0, 0},
-        { "MENUITEM", MENUITEM, 0, 0, 0},
-        { "MESSAGETABLE", MESSAGETABLE, 1, 0, 0},
-        { "MOVEABLE", MOVEABLE, 0, 0, 0},
-        { "NOINVERT", NOINVERT, 0, 0, 0},
-        { "NOT", NOT, 0, 0, 0},
-        { "POPUP", POPUP, 0, 0, 0},
-        { "PRELOAD", PRELOAD, 0, 0, 0},
-        { "PRODUCTVERSION", PRODUCTVERSION, 0, 0, 0},
-        { "PURE", tPURE, 0, 0, 0},
-        { "PUSHBUTTON", PUSHBUTTON, 0, 0, 0},
-        { "RADIOBUTTON", RADIOBUTTON, 0, 0, 0},
-        { "RCDATA", RCDATA, 0, 0, 0},
-        { "RTEXT", RTEXT, 0, 0, 0},
-        { "SCROLLBAR", SCROLLBAR, 0, 0, 0},
-        { "SEPARATOR", SEPARATOR, 0, 0, 0},
-        { "SHIFT", SHIFT, 0, 0, 0},
-        { "STATE3", STATE3, 1, 0, 0},
-        { "STRING", tSTRING, 0, 0, 0},
-        { "STRINGTABLE", STRINGTABLE, 0, 0, 1},
-        { "STYLE", STYLE, 0, 0, 0},
-        { "TOOLBAR", TOOLBAR, 1, 0, 0},
-        { "typedef", tTYPEDEF, 0, 1, 1},
-        { "VALUE", VALUE, 0, 0, 0},
-        { "VERSION", VERSION, 1, 0, 0},
-        { "VERSIONINFO", VERSIONINFO, 0, 0, 0},
-        { "VIRTKEY", VIRTKEY, 0, 0, 0}
+        { "ACCELERATORS",       tACCELERATORS,          0, 0, 0},
+        { "ALT",                tALT,                   0, 0, 0},
+        { "ASCII",              tASCII,                 0, 0, 0},
+        { "AUTO3STATE",         tAUTO3STATE,            1, 0, 0},
+        { "AUTOCHECKBOX",       tAUTOCHECKBOX,          1, 0, 0},
+        { "AUTORADIOBUTTON",    tAUTORADIOBUTTON,       1, 0, 0},
+        { "BEGIN",              tBEGIN,                 0, 0, 0},
+        { "BITMAP",             tBITMAP,                0, 0, 0},
+        { "BLOCK",              tBLOCK,                 0, 0, 0},
+        { "BUTTON",             tBUTTON,                1, 0, 0},
+        { "CAPTION",            tCAPTION,               0, 0, 0},
+        { "CHARACTERISTICS",    tCHARACTERISTICS,       1, 0, 0},
+        { "CHECKBOX",           tCHECKBOX,              0, 0, 0},
+        { "CHECKED",            tCHECKED,               0, 0, 0},
+        { "CLASS",              tCLASS,                 0, 0, 0},
+        { "COMBOBOX",           tCOMBOBOX,              0, 0, 0},
+        { "CONTROL",            tCONTROL,               0, 0, 0},
+        { "CTEXT",              tCTEXT,                 0, 0, 0},
+        { "CURSOR",             tCURSOR,                0, 0, 0},
+        { "DEFPUSHBUTTON",      tDEFPUSHBUTTON,         0, 0, 0},
+        { "DIALOG",             tDIALOG,                0, 0, 0},
+        { "DIALOGEX",           tDIALOGEX,              1, 0, 0},
+        { "DISCARDABLE",        tDISCARDABLE,           0, 0, 0},
+        { "DLGINIT",            tDLGINIT,               0, 0, 0},
+        { "EDITTEXT",           tEDITTEXT,              0, 0, 0},
+        { "END",                tEND,                   0, 0, 0},
+        { "enum",               tENUM,                  0, 1, 1},
+        { "EXSTYLE",            tEXSTYLE,               0, 0, 0},
+        { "extern",             tEXTERN,                0, 1, 1},
+        { "FILEFLAGS",          tFILEFLAGS,             0, 0, 0},
+        { "FILEFLAGSMASK",      tFILEFLAGSMASK,         0, 0, 0},
+        { "FILEOS",             tFILEOS,                0, 0, 0},
+        { "FILESUBTYPE",        tFILESUBTYPE,           0, 0, 0},
+        { "FILETYPE",           tFILETYPE,              0, 0, 0},
+        { "FILEVERSION",        tFILEVERSION,           0, 0, 0},
+        { "FIXED",              tFIXED,                 0, 0, 0},
+        { "FONT",               tFONT,                  0, 0, 0},
+        { "FONTDIR",            tFONTDIR,               0, 0, 0},       /* This is a Borland BRC extension */
+        { "GRAYED",             tGRAYED,                0, 0, 0},
+        { "GROUPBOX",           tGROUPBOX,              0, 0, 0},
+        { "HELP",               tHELP,                  0, 0, 0},
+        { "ICON",               tICON,                  0, 0, 0},
+        { "IMPURE",             tIMPURE,                0, 0, 0},
+        { "INACTIVE",           tINACTIVE,              0, 0, 0},
+        { "inline",             tINLINE,                0, 1, 1},
+        { "LANGUAGE",           tLANGUAGE,              1, 0, 1},
+        { "LISTBOX",            tLISTBOX,               0, 0, 0},
+        { "LOADONCALL",         tLOADONCALL,            0, 0, 0},
+        { "LTEXT",              tLTEXT,                 0, 0, 0},
+        { "MENU",               tMENU,                  0, 0, 0},
+        { "MENUBARBREAK",       tMENUBARBREAK,          0, 0, 0},
+        { "MENUBREAK",          tMENUBREAK,             0, 0, 0},
+        { "MENUEX",             tMENUEX,                1, 0, 0},
+        { "MENUITEM",           tMENUITEM,              0, 0, 0},
+        { "MESSAGETABLE",       tMESSAGETABLE,          1, 0, 0},
+        { "MOVEABLE",           tMOVEABLE,              0, 0, 0},
+        { "NOINVERT",           tNOINVERT,              0, 0, 0},
+        { "NOT",                tNOT,                   0, 0, 0},
+        { "POPUP",              tPOPUP,                 0, 0, 0},
+        { "PRELOAD",            tPRELOAD,               0, 0, 0},
+        { "PRODUCTVERSION",     tPRODUCTVERSION,        0, 0, 0},
+        { "PURE",               tPURE,                  0, 0, 0},
+        { "PUSHBUTTON",         tPUSHBUTTON,            0, 0, 0},
+        { "RADIOBUTTON",        tRADIOBUTTON,           0, 0, 0},
+        { "RCDATA",             tRCDATA,                0, 0, 0},
+        { "RTEXT",              tRTEXT,                 0, 0, 0},
+        { "SCROLLBAR",          tSCROLLBAR,             0, 0, 0},
+        { "SEPARATOR",          tSEPARATOR,             0, 0, 0},
+        { "SHIFT",              tSHIFT,                 0, 0, 0},
+        { "STATE3",             tSTATE3,                1, 0, 0},
+        { "static",             tSTATIC,                0, 1, 1},
+        { "STRING",             tSTRING,                0, 0, 0},
+        { "STRINGTABLE",        tSTRINGTABLE,           0, 0, 1},
+        { "struct",             tSTRUCT,                0, 1, 1},
+        { "STYLE",              tSTYLE,                 0, 0, 0},
+        { "TOOLBAR",            tTOOLBAR,               1, 0, 0},
+        { "typedef",            tTYPEDEF,               0, 1, 1},
+        { "VALUE",              tVALUE,                 0, 0, 0},
+        { "VERSION",            tVERSION,               1, 0, 0},
+        { "VERSIONINFO",        tVERSIONINFO,           0, 0, 0},
+        { "VIRTKEY",            tVIRTKEY,               0, 0, 0}
 };
 
 #define NKEYWORDS       (sizeof(keywords)/sizeof(keywords[0]))
 #define KWP(p)          ((struct keyword *)(p))
-int kw_cmp_func(const void *s1, const void *s2)
+static int kw_cmp_func(const void *s1, const void *s2)
 {
         int ret;
@@ -350 +245 @@
 #define KW_BSEARCH
 #define DO_SORT
-struct keyword *iskeyword(char *kw)
+static struct keyword *iskeyword(char *kw)
 {
         struct keyword *kwp;
@@ -384 +279 @@
 #endif
 
-#ifdef LEX_DEBUG
-        if(kwp && !strcmp(kwp->keyword, "LANGUAGE"))
-                printf("Got Language\n");
-#endif
         if(kwp == NULL || (kwp->isextension && !extensions))
                 return NULL;
@@ -394 +285 @@
 }
 
-void add_to_substtext(char *text, int len)
-{
-        if(!substtext)
-        {
-                substtext = xstrdup(text);
+%}
+
+/*
+ **************************************************************************
+ * The flexer starts here
+ **************************************************************************
+ */
+%%
+        /*
+         * Catch the GCC-style line statements here and parse them.
+         * This has the advantage that you can #include at any
+         * stage in the resource file.
+         * The preprocessor generates line directives in the format:
+         * # <linenum> "filename" <codes>
+         *
+         * Codes can be a sequence of:
+         * - 1 start of new file
+         * - 2 returning to previous
+         * - 3 system header
+         * - 4 interpret as C-code
+         *
+         * 4 is not used and 1 mutually excludes 2
+         * Anyhow, we are not really interested in these at all
+         * because we only want to know the linenumber and
+         * filename.
+         */
+<INITIAL,pp_strips,pp_stripp>^{ws}*\#{ws}*      yy_push_state(pp_line);
+<pp_line>[^\n]* {
+                int lineno;
+                char *cptr;
+                char *fname;
+                yy_pop_state();
+                lineno = (int)strtol(yytext, &cptr, 10);
+                if(!lineno)
+                        yyerror("Malformed '#...' line-directive; invalid linenumber");
+                fname = strchr(cptr, '"');
+                if(!fname)
+                        yyerror("Malformed '#...' line-directive; missing filename");
+                fname++;
+                cptr = strchr(fname, '"');
+                if(!cptr)
+                        yyerror("Malformed '#...' line-directive; missing terminating \"");
+                *cptr = '\0';
+                line_number = lineno - 1;       /* We didn't read the newline */
+                input_name = xstrdup(fname);
         }
-        else
-        {
-                substtext = (char *)xrealloc(substtext, strlen(substtext)+len+1);
-                strcat(substtext, text);
-        }
-}
-
-%}
-
-%%
-        /* #include handling */
-^{ws}*#{ws}*include{ws}*        push_to(pp_incl);
-<pp_incl>\<[^\n\>]+\>           do_include(yytext, yyleng); pop_start();
-<pp_incl>\"[^\n\>]+\"           do_include(yytext, yyleng); pop_start();
-<pp_incl>.              yyerror("Malformed #include");
-
-        /* #define handling */
-^{ws}*#{ws}*define{ws}* push_to(pp_def);
-<pp_def>{cident}        {
-                                set_define(yytext);
-                                push_to(pp_def_s);
-                        }
-<pp_def>{cident}\(      push_to(pp_ignore); /* Ignore function-like defines for now*/
-<pp_def>.               yyerror("Malformed #define");
-
-<pp_ignore,pp_def_s>[^\/\\\n]*  {
-                        if(YY_START == pp_def_s)
-                                add_to_substtext(yytext, yyleng);
-                }
-<pp_ignore,pp_def_s>\/[^\/\*][^\/\\\n]* { /* Comment is handled in normal handling */
-                        if(YY_START == pp_def_s)
-                                add_to_substtext(yytext, yyleng);
-                }
-<pp_ignore,pp_def_s>\\{ws}*\n   line_number++;  char_number = 1; /* Line continuation */
-<pp_ignore,pp_def_s>\n          {
-                        if(YY_START == pp_def_s)
-                        {
-                                add_define(substtext ? substtext : "");
-                                free(substtext);
-                                substtext = NULL;
-                        }
-                        line_number++;
-                        char_number = 1;
-                        pop_start();
-                        pop_start();
-                }
-
-        /* #undef handling */
-^{ws}*#{ws}*undef{ws}*  push_to(pp_undef);
-<pp_undef>{cident}      {
-                                del_define(yytext);
-                                pop_start();
-                                /*push_to(pp_ignore);*/
-                        }
-
-        /* Conditional handling */
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*if{ws}*     {
-                        if(YY_START == pp_false)
-                        {
-                                if(yydebug)
-                                        printf("(%d)#if ignored\n", line_number);
-                                push_if(0, 0, 1);
-                                push_to(pp_ignore_eol);
-                        }
-                        else
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                return tIF;
-                        }
-                }
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*ifdef{ws}*  {
-                        if(YY_START == pp_false)
-                        {
-                                if(yydebug)
-                                        printf("(%d)#ifdef ignored\n", line_number);
-                                push_if(0, 0, 1);
-                                push_to(pp_ignore_eol);
-                        }
-                        else
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                want_ident = 1;
-                                return tIFDEF;
-                        }
-                }
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*ifndef{ws}* {
-                        if(YY_START == pp_false)
-                        {
-                                if(yydebug)
-                                        printf("(%d)#ifndef ignored\n", line_number);
-                                push_if(0, 0, 1);
-                                push_to(pp_ignore_eol);
-                        }
-                        else
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                want_ident = 1;
-                                return tIFNDEF;
-                        }
-                }
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*elif{ws}*   {
-                        if(!isnevertrue_if())
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                return tELIF;
-                        }
-                        else if(YY_START == pp_false)
-                                push_to(pp_ignore_eol);
-                        if(yydebug)
-                                printf("(%d)#elif ignored\n", line_number);
-                }
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*else{ws}*   {
-                        if(!isnevertrue_if())
-                        {
-                                push_to(INITIAL);
-                                want_nl = 1;
-                                return tELSE;
-                        }
-                        if(yydebug)
-                                printf("(%d)#else ignored\n", line_number);
-                }
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*endif{ws}*  {
-                        if(!isnevertrue_if())
-                        {
-                                want_nl = 1;
-                                return tENDIF;
-                        }
-                        else
-                        {
-                                if(yydebug)
-                                        printf("(%d)#endif ignored\n", line_number);
-                                pop_if();
-                        }
-                }
-
-        /* The error directive */
-<INITIAL,pp_strips,pp_stripe,pp_stripp>^{ws}*#{ws}*error{ws}*   push_to(pp_error);
-<pp_error>[^\n]*        yyerror("Error directive: %s", yytext);
-<pp_false>^{ws}*#{ws}*error[^\n]* {
-                        if(yydebug)
-                                printf("(%d)#error ignored\n", line_number);
-                }
-
-        /* preprocessor junk */
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*pragma[^\n]*        ;       /* Ignore #pragma */
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*ident[^\n]*         ;       /* Ignore #ident */
-<INITIAL,pp_strips,pp_stripe,pp_stripp,pp_false>^{ws}*#{ws}*line[^\n]*          ;       /* Ignore #line */
- /* We'll get an error on malformed #xxx statements
-  * by not recognising '#' at all. This helps tracking
-  * preprocessor errors.
-  */
- /*^{ws}*#{ws}*                 ;        Ignore # */
-
-<pp_strips>\{           stripslevel++;
-<pp_strips>\}           stripslevel--;
-<pp_strips>;            if(!stripslevel) pop_start();
+
+        /*
+         * Strip everything until a ';' taking
+         * into account braces {} for structures,
+         * classes and enums.
+         */
+<pp_strips>\{                   stripslevel++;
+<pp_strips>\}                   stripslevel--;
+<pp_strips>;                    if(!stripslevel) yy_pop_state();
 <pp_strips>\/[^*\n]             ; /* To catch comments */
 <pp_strips>[^\{\};\n#/]*        ; /* Ignore rest */
-
-<pp_stripe>\{           stripslevel++;
-<pp_stripe>\}   {
-                        stripslevel--;
-                        if(!stripslevel) pop_start();
-                }
-<pp_stripe>;            if(!stripslevel) pop_start();
-<pp_stripe>\/[^*\n]             ; /* To catch comments */
-<pp_stripe>[^\{\};\n#/]*        ; /* Ignore rest */
-
-<pp_stripp>\(           stripplevel++;
-<pp_stripp>\)           {
-                                stripplevel--;
-                                if(!stripplevel)
-                                {
-                                        pop_start();
-                                        push_to(pp_stripp_final);
+<pp_strips>\n                   line_number++; char_number = 1;
+
+<pp_stripp>\(                   stripplevel++;
+<pp_stripp>\)                   {
+                                        stripplevel--;
+                                        if(!stripplevel)
+                                        {
+                                                yy_pop_state();
+                                                yy_push_state(pp_stripp_final);
+                                        }
                                 }
-                        }
 <pp_stripp>\/[^*\n]             ; /* To catch comments */
 <pp_stripp>[^\(\);\n#/]*        ; /* Ignore rest */
-
-<pp_stripp_final>{ws}*  ; /* Ignore */
-<pp_stripp_final>;      pop_start(); /* Kill the semicolon */
-<pp_stripp_final>\n     line_number++; char_number = 1; pop_start();
-<pp_stripp_final>.      yyless(0); pop_start();
-
-<pp_false>.             ;       /* Ignore everything except #xxx during false #if state */
-
-<pp_ignore_eol>[^\n]*   pop_start();
-
- /* These are special cases due to filename scanning */
-<yywf>[Dd][Ii][Ss][Cc][Aa][Rr][Dd][Aa][Bb][Ll][Ee]      return DISCARDABLE;
-<yywf>[Ff][Ii][Xx][Ee][Dd]                              return tFIXED;
-<yywf>[Ii][Mm][Pp][Uu][Rr][Ee]                          return IMPURE;
-<yywf>[Mm][Oo][Vv][Ee][Aa][Bb][Ll][Ee]                  return MOVEABLE;
-<yywf>[Ll][Oo][Aa][Dd][Oo][Nn][Cc][Aa][Ll][Ll]          return LOADONCALL;
-<yywf>[Pp][Rr][Ee][Ll][Oo][Aa][Dd]                      return PRELOAD;
-<yywf>[Pp][Uu][Rr][Ee]                                  return tPURE;
+<pp_stripp>\n                   line_number++; char_number = 1;
+
+<pp_stripp_final>{ws}*          ; /* Ignore */
+<pp_stripp_final>;              yy_pop_state(); /* Kill the semicolon */
+<pp_stripp_final>\n             line_number++; char_number = 1; yy_pop_state();
+<pp_stripp_final>.              yyless(0); yy_pop_state();
 
 \{                      return tBEGIN;
 \}                      return tEND;
 
-[0-9]+[lL]?             { yylval.num = strtoul(yytext,  0, 10); return toupper(yytext[yyleng-1]) == 'L' ? LNUMBER : NUMBER; }
-0[xX][0-9A-Fa-f]+[lL]?  { yylval.num = strtoul(yytext,  0, 16); return toupper(yytext[yyleng-1]) == 'L' ? LNUMBER : NUMBER; }
-0[oO][0-7]+[lL]?        { yylval.num = strtoul(yytext+2, 0, 8); return toupper(yytext[yyleng-1]) == 'L' ? LNUMBER : NUMBER; }
+[0-9]+[lL]?             { yylval.num = strtoul(yytext,  0, 10); return toupper(yytext[yyleng-1]) == 'L' ? tLNUMBER : tNUMBER; }
+0[xX][0-9A-Fa-f]+[lL]?  { yylval.num = strtoul(yytext,  0, 16); return toupper(yytext[yyleng-1]) == 'L' ? tLNUMBER : tNUMBER; }
+0[oO][0-7]+[lL]?        { yylval.num = strtoul(yytext+2, 0, 8); return toupper(yytext[yyleng-1]) == 'L' ? tLNUMBER : tNUMBER; }
+
+        /*
+         * The next two rules scan identifiers and filenames.
+         * This is achieved by using the priority ruling
+         * of the scanner where a '.' is valid in a filename
+         * and *only* in a filename. In this case, the second
+         * rule will be reduced because it is longer.
+         */
 [A-Za-z_0-9]+           {
-                                struct keyword *token;
-                                struct pp_entry *ppp;
-
-                                want_rscname = 0;
-                                
-                                if(want_ident)
+                                struct keyword *tok = iskeyword(yytext);
+
+                                if(tok)
                                 {
-                                        /* Prevent preprocessor subst */
-                                        want_ident = 0;
-                                        yylval.str = make_string(yytext);
-                                #ifdef LEX_DEBUG
-                                        printf("want IDENT (%s, %d, %d): <%s>\n", input_name, line_number, char_number, yytext);
-                                #endif
-                                        return IDENT;
-                                }
-                                else if((ppp = pp_lookup(yytext)) != NULL)
-                                {
-                                        /* Do preprocessor substitution,
-                                         * but expand only if macro is not
-                                         * already expanding.
-                                         */
-                                        if(!ppp->expanding)
+                                        if(tok->token == tCLASS && !strcmp(yytext, "class"))
+                                                return tCPPCLASS;
+                                        else if(wanted_id && !tok->alwayskw)
                                         {
-                                #ifdef LEX_DEBUG
-                                                printf("expand IDENT (%s, %d, %d): <%s>\n", input_name, line_number, char_number, yytext);
-                                #endif
-                                                push_buffer(YY_CURRENT_BUFFER, ppp, NULL);
-                                                yy_scan_string(ppp->subst);
+                                                yylval.str = make_string(yytext);
+                                                return tIDENT;
                                         }
-                                }
-                                else if((token = iskeyword(yytext)) != NULL
-                                  && !(!token->alwayskeyword && want_rscname))
-                                {
-                                        switch(token->token)
-                                        {
-                                        case tDEFINED:
-                                                want_ident = 1;
-                                                break;
-                                        /*case RCDATA:*/
-                                        case CURSOR:
-                                        case tBITMAP:
-                                        case MESSAGETABLE:
-                                        case DLGINIT:
-                                                push_to(yywf);
-                                                break;
-                                        case FONT:
-                                        case ICON:
-                                                if(!indialog)
-                                                        push_to(yywf);
-                                                break;
-                                        case DIALOG:
-                                        case DIALOGEX:
-                                                indialog = 1;
-                                                break;
-                                        }
-                                        return token->token;
+                                        else
+                                                return tok->token;
                                 }
                                 else
                                 {
                                         yylval.str = make_string(yytext);
-                                #ifdef LEX_DEBUG
-                                        printf("%s IDENT (%s, %d, %d): <%s>\n",
-                                                want_rscname ? "rscname" : "just",
-                                                input_name,
-                                                line_number,
-                                                char_number,
-                                                yytext);
-                                #endif
-                                        return IDENT;
+                                        return tIDENT;
                                 }
                         }
-\|\|                    return LOGOR;
-\&\&                    return LOGAND;
-\=\=                    return EQ;
-\!\=                    return NE;
-\<\=                    return LTE;
-\>\=                    return GTE;
-
-<yywf>[^ \f\t\r\n\"]*   { pop_start(); yylval.str = make_filename(yytext, yyleng); return FILENAME; }
-<yywf>\"                push_to(yywf_s);
-<yywf_s>[^\"\n]*\"      { pop_start(); pop_start(); yylval.str = make_filename(yytext, yyleng-1); return FILENAME; }
-<yywf_s>\n              yyerror("Newline in filename");
-
+[A-Za-z_0-9./\\]+               yylval.str = make_string(yytext); return tFILENAME;
+
+        /*
+         * Wide string scanning
+         */
 L\"                     {
-                                push_to(yylstr);
+                                yy_push_state(yylstr);
                                 wbufidx = 0;
                                 if(!win32)
                                         yywarning("16bit resource contains unicode strings\n");
                         }
+<yylstr>\"{ws}+ |
 <yylstr>\"              {
-                                pop_start();
+                                yy_pop_state();
                                 yylval.str = get_buffered_wstring();
                                 return tSTRING;
                         }
-<yylstr>\n              yyerror("Unterminated string");
 <yylstr>\\[0-7]{1,6}    { /* octal escape sequence */
                                 int result;
@@ -716 +426 @@
                                 addwchar((short)result);
                         }
+<yylstr>\\x[0-9a-fA-F]{1,3} {  yyerror("Invalid hex escape sequence '%s'", yytext); }
+
 <yylstr>\\[0-9]+        yyerror("Bad escape secuence");
 <yylstr>\\a             addwchar('\a');
@@ -724 +436 @@
 <yylstr>\\t             addwchar('\t');
 <yylstr>\\v             addwchar('\v');
-<yylstr>\\(.|\n)        addwchar(yytext[1]);
+<yylstr>\\(\n|.)        addwchar(yytext[1]);
+<yylstr>\\\r\n          addwchar(yytext[2]);
 <yylstr>\"\"            addcchar('\"');         /* "bla""bla"  -> "bla\"bla" */
 <yylstr>\\\"\"          addcchar('\"');         /* "bla\""bla" -> "bla\"bla" */
@@ -733 +446 @@
                                         addwchar(*yptr++ & 0xff);
                         }
-
-\"                      {
-                                push_to(yystr);
-                                cbufidx = 0;
-                        }
+<yylstr>\n              yyerror("Unterminated string");
+
+        /*
+         * Normal string scanning
+         */
+\"                      yy_push_state(yystr); cbufidx = 0;
+<yystr>\"{ws}+  |
 <yystr>\"               {
-                                pop_start();
+                                yy_pop_state();
                                 yylval.str = get_buffered_cstring();
                                 return tSTRING;
                         }
-<yystr>\n               yyerror("Unterminated string");
 <yystr>\\[0-7]{1,3}     { /* octal escape sequence */
                                 int result;
@@ -756 +470 @@
                                 addcchar((char)result);
                         }
+<yystr>\\x[0-9a-fA-F]   {  yyerror("Invalid hex escape sequence '%s'", yytext); }
+
 <yystr>\\[0-9]+         yyerror("Bad escape secuence");
 <yystr>\\a              addcchar('\a');
@@ -764 +480 @@
 <yystr>\\t              addcchar('\t');
 <yystr>\\v              addcchar('\v');
-<yystr>\\(.|\n)         addcchar(yytext[1]);
+<yystr>\\(\n|.)         addcchar(yytext[1]);
+<yystr>\\\r\n           addcchar(yytext[2]);
 <yystr>[^\\\n\"]+       {
                                 char *yptr = yytext;
@@ -773 +490 @@
 <yystr>\\\"\"           addcchar('\"');         /* "bla\""bla"  -> "bla\"bla" */
 <yystr>\"{ws}+\"        ;                       /* "bla" "bla"  -> "blabla" */
-<yystr>.                yywarning("Matched %c", *yytext);
-
-
-\'                      {
-                                push_to(yyrcd);
-                                cbufidx = 0;
-                        }
+<yystr>\n               yyerror("Unterminated string");
+
+        /*
+         * Raw data scanning
+         */
+\'                      yy_push_state(yyrcd); cbufidx = 0;
 <yyrcd>\'               {
-                                pop_start();
+                                yy_pop_state();
                                 yylval.raw = new_raw_data();
                                 yylval.raw->size = cbufidx;
                                 yylval.raw->data = xmalloc(yylval.raw->size);
                                 memcpy(yylval.raw->data, cbuffer, yylval.raw->size);
-                                return RAWDATA;
+                                return tRAWDATA;
                         }
 <yyrcd>[0-9a-fA-F]{2}   {
@@ -797 +513 @@
 <yyrcd>.                yyerror("Malformed data-line");
 
-<INITIAL,pp_ignore,pp_def_s,pp_strips,pp_stripe,pp_stripp>"/*"  push_to(comment);       /* Eat comment */
+        /*
+         * Comment stripping
+         * Should never occur after preprocessing
+         */
+<INITIAL,pp_stripp,pp_strips>"/*"       {
+                                yy_push_state(comment);
+                                save_wanted_id = wanted_id;
+                                if(!no_preprocess)
+                                        yywarning("Found comments after preprocessing, please report");
+                        }
 <comment>[^*\n]*        ;
 <comment>"*"+[^*/\n]*   ;
 <comment>\n             line_number++; char_number = 1;
-<comment>"*"+"/"        pop_start();
-
-;[^\n]*                 ; /* Eat comment */
-<INITIAL,pp_ignore,pp_def_s>"//"[^\n]*          ; /* Eat comment */
-
-<INITIAL,yywf,pp_false,pp_strips,pp_stripe,pp_stripp>\n {
-                                if(YY_START == yywf)
-                                        pop_start();
+<comment>"*"+"/"        yy_pop_state(); want_id = save_wanted_id;
+
+;[^\n]*                 want_id = wanted_id; /* not really comment, but left-over c-junk */
+"//"[^\n]*              want_id = wanted_id; if(!no_preprocess) yywarning("Found comments after preprocessing, please report");
+
+\n                      {
+                                want_id = wanted_id;
                                 line_number++;
                                 char_number = 1;
@@ -817 +541 @@
                                 }
                         }
-<INITIAL,yywf>{ws}+     ;       /* Eat whitespace */
+{ws}+                   want_id = wanted_id;    /* Eat whitespace */
 
 <INITIAL>.              return yytext[0];
+
 <<EOF>>                 {
-                                YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
-                                if(!pop_buffer())
-                                {
-                                        if(YY_START == pp_strips || YY_START == pp_stripe || YY_START == pp_stripp || YY_START == pp_stripp_final)
-                                                yyerror("Unexpected end of file during c-junk scanning (started at %d)", cjunk_tagline);
-                                        else
-                                                yyterminate();
-                                }
-                                yy_delete_buffer(b);
+                                if(YY_START == pp_strips || YY_START == pp_stripe || YY_START == pp_stripp || YY_START == pp_stripp_final)
+                                        yyerror("Unexpected end of file during c-junk scanning (started at %d)", cjunk_tagline);
+                                else
+                                        yyterminate();
                         }
 
@@ -840 +560 @@
                                 }
                                 yywarning("Unmatched text '%c' (0x%02x) YY_START=%d stripslevel=%d",
-                                        isprint(*yytext) ? *yytext : '.', *yytext, YY_START,stripslevel);
+                                        isprint(*yytext & 0xff) ? *yytext : '.', *yytext, YY_START,stripslevel);
                         }
 
@@ -861 +581 @@
  * the resource string.
  */
-void addcchar(char c)
+static void addcchar(char c)
 {
         if(cbufidx >= cbufalloc)
@@ -873 +593 @@
 }
 
-void addwchar(short s)
+static void addwchar(short s)
 {
         if(wbufidx >= wbufalloc)
@@ -894 +614 @@
 }
 
-string_t *get_buffered_cstring(void)
+static string_t *get_buffered_cstring(void)
 {
         string_t *str = new_string();
@@ -902 +622 @@
         memcpy(str->str.cstr, cbuffer, cbufidx);
         str->str.cstr[cbufidx] = '\0';
-/*      printf("got cstring \"%s\"\n", str->str.cstr); */
         return str;
 }
 
-string_t *get_buffered_wstring(void)
+static string_t *get_buffered_wstring(void)
 {
         string_t *str = new_string();
@@ -917 +636 @@
 }
 
-string_t *make_string(char *s)
+static string_t *make_string(char *s)
 {
         string_t *str = new_string();
@@ -927 +646 @@
 }
 
-string_t *make_filename(char *s, int len)
-{
-        char *cptr;
-        string_t *str = new_string();
-
-        str->size = len;
-        str->type = str_char;
-        str->str.cstr = (char *)xmalloc(str->size+1);
-        memcpy(str->str.cstr, s, str->size);
-        str->str.cstr[str->size] = '\0';
-
-        /* Remove escaped backslash and convert to forward */
-        cptr = str->str.cstr;
-        for(cptr = str->str.cstr; (cptr = strchr(cptr, '\\')) != NULL; cptr++)
-        {
-                if(cptr[1] == '\\')
-                {
-                        memmove(cptr, cptr+1, strlen(cptr));
-                        str->size--;
-                }
-                *cptr = '/';
-        }
-
-        /* Convert to lower case. Seems to be reasonable to do */
-        for(cptr = str->str.cstr; !leave_case && *cptr; cptr++)
-        {
-                *cptr = tolower(*cptr);
-        }
-        return str;
-}
-
-/* Called from the parser to signal filename request */
-void set_yywf(void)
-{
-        push_to(yywf);
-}
-
-/* Called from the parser to signal preprocessor if case */
-void set_pp_ignore(int state)
-{
-        if(state)
-                push_to(pp_false);
-        else
-                pop_start();
-}
-
 /* Called from the parser to kill c-junk */
 void strip_extern(void)
 {
         cjunk_tagline = line_number;
-        push_to(pp_stripe);
+        yy_push_state(pp_stripe);
 }
 
@@ -983 +656 @@
 {
         cjunk_tagline = line_number;
-        push_to(pp_strips);
+        yy_push_state(pp_strips);
 }
 
@@ -990 +663 @@
         cjunk_tagline = line_number;
         stripplevel = 1;        /* One scanned already */
-        push_to(pp_stripp);
-}
-
+        yy_push_state(pp_stripp);
+}
+

trunk/tools/wrc/parser.y

@@ -1 +1 @@
 %{
 /*
- * Copyright  Martin von Loewis, 1994
- * Copyright 1998 Bertho A. Stultiens (BS)
- *           1999 Juergen Schmied (JS)
+ * Copyright 1994       Martin von Loewis
+ * Copyright 1998-2000  Bertho A. Stultiens (BS)
+ *           1999       Juergen Schmied (JS)
  *
- * 6-Nov-1999 JS        - see CHANGES
+ * 24-Jul-2000 BS       - Made a fix for broken Berkeley yacc on
+ *                        non-terminals (see cjunk rule).
+ * 21-May-2000 BS       - Partial implementation of font resources.
+ *                      - Corrected language propagation for binary
+ *                        resources such as bitmaps, isons, cursors,
+ *                        userres and rcdata. The language is now
+ *                        correct in .res files.
+ *                      - Fixed reading the resource name as ident,
+ *                        so that it may overlap keywords.
+ * 20-May-2000 BS       - Implemented animated cursors and icons
+ *                        resource types.
+ * 30-Apr-2000 BS       - Reintegration into the wine-tree
+ * 14-Jan-2000 BS       - Redid the usertype resources so that they
+ *                        are compatible.
+ * 02-Jan-2000 BS       - Removed the preprocessor from the grammar
+ *                        expect for the # command (line numbers).
+ *
+ * 06-Nov-1999 JS       - see CHANGES
  * 
  * 29-Dec-1998 AdH      - Grammar and function extensions.
@@ -108 +125 @@
 #include "parser.h"
 #include "windef.h"
+#include "winbase.h"
 #include "wingdi.h"
 #include "winuser.h"
 
-#ifdef __BORLANDC__
-#pragma warn -sig
+#if defined(YYBYACC)
+        /* Berkeley yacc (byacc) doesn't seem to know about these */
+        /* Some *BSD supplied versions do define these though */
+# ifndef YYEMPTY
+#  define YYEMPTY       (-1)    /* Empty lookahead value of yychar */
+# endif
+# ifndef YYLEX
+#  define YYLEX         yylex()
+# endif
+
+#elif defined(YYBISON)
+        /* Bison was used for original development */
+        /* #define YYEMPTY -2 */
+        /* #define YYLEX   yylex() */
+
+#else   
+        /* No yacc we know yet */
+# if !defined(YYEMPTY) || !defined(YYLEX)
+#  error Yacc version/type unknown. This version needs to be verified for settings of YYEMPTY and YYLEX.
+# elif defined(__GNUC__)        /* gcc defines the #warning directive */
+#  warning Yacc version/type unknown. It defines YYEMPTY and YYLEX, but is not tested
+  /* #else we just take a chance that it works... */
+# endif
 #endif
 
-int indialog = 0;       /* Signal flex that we're parsing a dialog */
-int want_rscname = 0;   /* Set when a resource's name is required */
+int want_nl = 0;        /* Signal flex that we need the next newline */
+int want_id = 0;        /* Signal flex that we need the next identifier */
 stringtable_t *tagstt;  /* Stringtable tag.
                          * It is set while parsing a stringtable to one of
@@ -125 +164 @@
                          * stringtables with different lanuages
                          */
+static int dont_want_id = 0;    /* See language parsing for details */
+
 /* Set to the current options of the currently scanning stringtable */
 static int *tagstt_memopt;
@@ -130 +171 @@
 static version_t *tagstt_version;
 
+static const char riff[4] = "RIFF";     /* RIFF file magic for animated cursor/icon */
+
 /* Prototypes of here defined functions */
-void split_cursors(raw_data_t *rd, cursor_group_t *curg, int *ncur);
-void split_icons(raw_data_t *rd, icon_group_t *icog, int *nico);
-int alloc_cursor_id(language_t *);
-int alloc_icon_id(language_t *);
-void ins_stt_entry(stt_entry_t *ste);
-int check_stt_entry(stringtable_t *tabs, stt_entry_t *ste);
-event_t *get_event_head(event_t *p);
-control_t *get_control_head(control_t *p);
-ver_value_t *get_ver_value_head(ver_value_t *p);
-ver_block_t *get_ver_block_head(ver_block_t *p);
-resource_t *get_resource_head(resource_t *p);
-menuex_item_t *get_itemex_head(menuex_item_t *p);
-menu_item_t *get_item_head(menu_item_t *p);
-raw_data_t *merge_raw_data_str(raw_data_t *r1, string_t *str);
-raw_data_t *merge_raw_data_int(raw_data_t *r1, int i);
-raw_data_t *merge_raw_data_long(raw_data_t *r1, int i);
-raw_data_t *merge_raw_data(raw_data_t *r1, raw_data_t *r2);
-raw_data_t *str2raw_data(string_t *str);
-raw_data_t *int2raw_data(int i);
-raw_data_t *long2raw_data(int i);
-raw_data_t *load_file(string_t *name);
-itemex_opt_t *new_itemex_opt(int id, int type, int state, int helpid);
-event_t *add_string_event(string_t *key, int id, int flags, event_t *prev);
-event_t *add_event(int key, int id, int flags, event_t *prev);
-dialogex_t *dialogex_version(version_t *v, dialogex_t *dlg);
-dialogex_t *dialogex_characteristics(characts_t *c, dialogex_t *dlg);
-dialogex_t *dialogex_language(language_t *l, dialogex_t *dlg);
-dialogex_t *dialogex_menu(name_id_t *m, dialogex_t *dlg);
-dialogex_t *dialogex_class(name_id_t *n, dialogex_t *dlg);
-dialogex_t *dialogex_font(font_id_t *f, dialogex_t *dlg);
-dialogex_t *dialogex_caption(string_t *s, dialogex_t *dlg);
-dialogex_t *dialogex_exstyle(style_t *st, dialogex_t *dlg);
-dialogex_t *dialogex_style(style_t *st, dialogex_t *dlg);
-name_id_t *convert_ctlclass(name_id_t *cls);
-control_t *ins_ctrl(int type, int special_style, control_t *ctrl, control_t *prev);
-dialog_t *dialog_version(version_t *v, dialog_t *dlg);
-dialog_t *dialog_characteristics(characts_t *c, dialog_t *dlg);
-dialog_t *dialog_language(language_t *l, dialog_t *dlg);
-dialog_t *dialog_menu(name_id_t *m, dialog_t *dlg);
-dialog_t *dialog_class(name_id_t *n, dialog_t *dlg);
-dialog_t *dialog_font(font_id_t *f, dialog_t *dlg);
-dialog_t *dialog_caption(string_t *s, dialog_t *dlg);
-dialog_t *dialog_exstyle(style_t * st, dialog_t *dlg);
-dialog_t *dialog_style(style_t * st, dialog_t *dlg);
-resource_t *build_stt_resources(stringtable_t *stthead);
-stringtable_t *find_stringtable(lvc_t *lvc);
-toolbar_item_t *ins_tlbr_button(toolbar_item_t *prev, toolbar_item_t *idrec);
-toolbar_item_t *get_tlbr_buttons_head(toolbar_item_t *p, int *nitems);
+static event_t *get_event_head(event_t *p);
+static control_t *get_control_head(control_t *p);
+static ver_value_t *get_ver_value_head(ver_value_t *p);
+static ver_block_t *get_ver_block_head(ver_block_t *p);
+static resource_t *get_resource_head(resource_t *p);
+static menuex_item_t *get_itemex_head(menuex_item_t *p);
+static menu_item_t *get_item_head(menu_item_t *p);
+static raw_data_t *merge_raw_data_str(raw_data_t *r1, string_t *str);
+static raw_data_t *merge_raw_data_int(raw_data_t *r1, int i);
+static raw_data_t *merge_raw_data_long(raw_data_t *r1, int i);
+static raw_data_t *merge_raw_data(raw_data_t *r1, raw_data_t *r2);
+static raw_data_t *str2raw_data(string_t *str);
+static raw_data_t *int2raw_data(int i);
+static raw_data_t *long2raw_data(int i);
+static raw_data_t *load_file(string_t *name);
+static itemex_opt_t *new_itemex_opt(int id, int type, int state, int helpid);
+static event_t *add_string_event(string_t *key, int id, int flags, event_t *prev);
+static event_t *add_event(int key, int id, int flags, event_t *prev);
+static dialogex_t *dialogex_version(version_t *v, dialogex_t *dlg);
+static dialogex_t *dialogex_characteristics(characts_t *c, dialogex_t *dlg);
+static dialogex_t *dialogex_language(language_t *l, dialogex_t *dlg);
+static dialogex_t *dialogex_menu(name_id_t *m, dialogex_t *dlg);
+static dialogex_t *dialogex_class(name_id_t *n, dialogex_t *dlg);
+static dialogex_t *dialogex_font(font_id_t *f, dialogex_t *dlg);
+static dialogex_t *dialogex_caption(string_t *s, dialogex_t *dlg);
+static dialogex_t *dialogex_exstyle(style_t *st, dialogex_t *dlg);
+static dialogex_t *dialogex_style(style_t *st, dialogex_t *dlg);
+static name_id_t *convert_ctlclass(name_id_t *cls);
+static control_t *ins_ctrl(int type, int special_style, control_t *ctrl, control_t *prev);
+static dialog_t *dialog_version(version_t *v, dialog_t *dlg);
+static dialog_t *dialog_characteristics(characts_t *c, dialog_t *dlg);
+static dialog_t *dialog_language(language_t *l, dialog_t *dlg);
+static dialog_t *dialog_menu(name_id_t *m, dialog_t *dlg);
+static dialog_t *dialog_class(name_id_t *n, dialog_t *dlg);
+static dialog_t *dialog_font(font_id_t *f, dialog_t *dlg);
+static dialog_t *dialog_caption(string_t *s, dialog_t *dlg);
+static dialog_t *dialog_exstyle(style_t * st, dialog_t *dlg);
+static dialog_t *dialog_style(style_t * st, dialog_t *dlg);
+static resource_t *build_stt_resources(stringtable_t *stthead);
+static stringtable_t *find_stringtable(lvc_t *lvc);
+static toolbar_item_t *ins_tlbr_button(toolbar_item_t *prev, toolbar_item_t *idrec);
+static toolbar_item_t *get_tlbr_buttons_head(toolbar_item_t *p, int *nitems);
+static string_t *make_filename(string_t *s);
+static resource_t *build_fontdirs(resource_t *tail);
+static resource_t *build_fontdir(resource_t **fnt, int nfnt);
+static int rsrcid_to_token(int lookahead);
 
 %}
@@ -185 +226 @@
         int             num;
         int             *iptr;
+        char            *cptr;
         resource_t      *res;
         accelerator_t   *acc;
         bitmap_t        *bmp;
-        cursor_t        *cur;
-        cursor_group_t  *curg;
         dialog_t        *dlg;
         dialogex_t      *dlgex;
         font_t          *fnt;
-        icon_t          *ico;
-        icon_group_t    *icog;
+        fontdir_t       *fnd;
         menu_t          *men;
         menuex_t        *menex;
@@ -223 +262 @@
         style_pair_t    *styles;
         style_t         *style;
-}
-
-%token tIF tIFDEF tIFNDEF tELSE tELIF tENDIF tDEFINED tNL
-%token tTYPEDEF tEXTERN
-%token <num> NUMBER LNUMBER
-%token <str> tSTRING IDENT FILENAME
-%token <raw> RAWDATA
-%token ACCELERATORS tBITMAP CURSOR DIALOG DIALOGEX MENU MENUEX MESSAGETABLE
-%token RCDATA VERSIONINFO STRINGTABLE FONT ICON
-%token AUTO3STATE AUTOCHECKBOX AUTORADIOBUTTON CHECKBOX DEFPUSHBUTTON
-%token PUSHBUTTON RADIOBUTTON STATE3 /* PUSHBOX */
-%token GROUPBOX COMBOBOX LISTBOX SCROLLBAR
-%token CONTROL EDITTEXT
-%token RTEXT CTEXT LTEXT
-%token BLOCK VALUE
-%token SHIFT ALT ASCII VIRTKEY GRAYED CHECKED INACTIVE NOINVERT
-%token tPURE IMPURE DISCARDABLE LOADONCALL PRELOAD tFIXED MOVEABLE
-%token CLASS CAPTION CHARACTERISTICS EXSTYLE STYLE VERSION LANGUAGE
-%token FILEVERSION PRODUCTVERSION FILEFLAGSMASK FILEOS FILETYPE FILEFLAGS FILESUBTYPE
-%token MENUBARBREAK MENUBREAK MENUITEM POPUP SEPARATOR
-%token HELP
-%token tSTRING IDENT RAWDATA
-%token TOOLBAR BUTTON
+        ani_any_t       *ani;
+}
+
+%token tTYPEDEF tEXTERN tSTRUCT tENUM tCPPCLASS tINLINE tSTATIC tNL
+%token <num> tNUMBER tLNUMBER
+%token <str> tSTRING tIDENT tFILENAME
+%token <raw> tRAWDATA
+%token tACCELERATORS tBITMAP tCURSOR tDIALOG tDIALOGEX tMENU tMENUEX tMESSAGETABLE
+%token tRCDATA tVERSIONINFO tSTRINGTABLE tFONT tFONTDIR tICON
+%token tAUTO3STATE tAUTOCHECKBOX tAUTORADIOBUTTON tCHECKBOX tDEFPUSHBUTTON
+%token tPUSHBUTTON tRADIOBUTTON tSTATE3 /* PUSHBOX */
+%token tGROUPBOX tCOMBOBOX tLISTBOX tSCROLLBAR
+%token tCONTROL tEDITTEXT
+%token tRTEXT tCTEXT tLTEXT
+%token tBLOCK tVALUE
+%token tSHIFT tALT tASCII tVIRTKEY tGRAYED tCHECKED tINACTIVE tNOINVERT
+%token tPURE tIMPURE tDISCARDABLE tLOADONCALL tPRELOAD tFIXED tMOVEABLE
+%token tCLASS tCAPTION tCHARACTERISTICS tEXSTYLE tSTYLE tVERSION tLANGUAGE
+%token tFILEVERSION tPRODUCTVERSION tFILEFLAGSMASK tFILEOS tFILETYPE tFILEFLAGS tFILESUBTYPE
+%token tMENUBARBREAK tMENUBREAK tMENUITEM tPOPUP tSEPARATOR
+%token tHELP
+%token tSTRING tIDENT tRAWDATA
+%token tTOOLBAR tBUTTON
 %token tBEGIN tEND
-%token DLGINIT
-%left LOGOR
-%left LOGAND
+%token tDLGINIT
 %left '|'
 %left '^'
 %left '&'
-%left EQ NE
-%left '<' LTE '>' GTE
 %left '+' '-'
 %left '*' '/'
-%right '~' '!' NOT
+%right '~' tNOT
+%left pUPM
 
 %type <res>     resource_file resource resources resource_definition
 %type <stt>     stringtable strings
 %type <fnt>     font
-%type <icog>    icon
+%type <fnd>     fontdir
 %type <acc>     accelerators
 %type <event>   events
 %type <bmp>     bitmap
-%type <curg>    cursor
+%type <ani>     cursor icon
 %type <dlg>     dialog dlg_attributes
 %type <ctl>     ctrls gen_ctrl lab_ctrl ctrl_desc iconinfo
@@ -273 +309 @@
 %type <ctl>     exctrls gen_exctrl lab_exctrl exctrl_desc
 %type <rdt>     rcdata
-%type <raw>     raw_data raw_elements opt_data
+%type <raw>     raw_data raw_elements opt_data file_raw
 %type <veri>    versioninfo fix_version
 %type <verw>    ver_words
@@ -287 +323 @@
 %type <num>     item_options
 %type <nid>     nameid nameid_s ctlclass usertype
-%type <num>     acc_opt
+%type <num>     acc_opt acc accs
 %type <iptr>    loadmemopts lamo lama
 %type <fntid>   opt_font opt_exfont opt_expr
@@ -296 +332 @@
 %type <num>     expr xpr
 %type <iptr>    e_expr
-%type <iptr>    pp_expr pp_constant
 %type <tlbar>   toolbar
 %type <tlbarItems>      toolbar_items
@@ -304 +339 @@
 %type <style>   optional_style
 %type <style>   style
+%type <str>     filename
 
 %%
@@ -321 +357 @@
                 else
                         $1 = rsc;
+                /* Find the tail again */
+                while($1 && $1->next)
+                        $1 = $1->next;
+                /* Now add any fontdirecory */
+                rsc = build_fontdirs($1);
+                /* 'build_fontdir' returns a head and $1 is a tail */
+                if($1)
+                {
+                        $1->next = rsc;
+                        if(rsc)
+                                rsc->prev = $1;
+                }
+                else
+                        $1 = rsc;
                 /* Final statement before were done */
                 resource_top = get_resource_head($1);
@@ -328 +378 @@
 /* Resources are put into a linked list */
 resources
-        : /* Empty */           { $$ = NULL; want_rscname = 1; }
+        : /* Empty */           { $$ = NULL; want_id = 1; }
         | resources resource    {
                 if($2)
@@ -342 +392 @@
                                 $1->next = head;
                         $$ = tail;
+                        /* Check for duplicate identifiers */
+                        while($1 && head)
+                        {
+                                resource_t *rsc = $1;
+                                while(rsc)
+                                {
+                                        if(rsc->type == head->type
+                                        && rsc->lan->id == head->lan->id
+                                        && rsc->lan->sub == head->lan->sub
+                                        && !compare_name_id(rsc->name, head->name))
+                                        {
+                                                yyerror("Duplicate resource name '%s'", get_nameid_str(rsc->name));
+                                        }
+                                        rsc = rsc->prev;
+                                }
+                                head = head->next;
+                        }
                 }
                 else if($1)
@@ -352 +419 @@
                 else
                         $$ = NULL;
-                want_rscname = 1;
-                }
-        | resources preprocessor                { $$ = $1; want_rscname = 1; }
-        | resources cjunk                       { $$ = $1; want_rscname = 1; }
-        ;
-
-/* The buildin preprocessor */
-preprocessor
-        : tIF pp_expr tNL       { pop_start(); push_if($2 ? *($2) : 0, 0, 0); if($2) free($2);}
-        | tIFDEF IDENT tNL      { pop_start(); push_if(pp_lookup($2->str.cstr) != NULL, 0, 0); }
-        | tIFNDEF IDENT tNL     { pop_start(); push_if(pp_lookup($2->str.cstr) == NULL, 0, 0); }
-        | tELIF pp_expr tNL     { pop_start(); push_if($2 ? *($2) : 0, pop_if(), 0); if($2) free($2); }
-        | tELSE tNL             { pop_start(); push_if(1, pop_if(), 0); }
-        | tENDIF tNL            { pop_if(); }
-        ;
-
-pp_expr : pp_constant                   { $$ = $1; }
-        | pp_expr LOGOR pp_expr         { $$ = new_int($1 && $3 ? (*$1 || *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr LOGAND pp_expr        { $$ = new_int($1 && $3 ? (*$1 && *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr '+' pp_expr           { $$ = new_int($1 && $3 ? (*$1  + *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr '-' pp_expr           { $$ = new_int($1 && $3 ? (*$1  - *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr '^' pp_expr           { $$ = new_int($1 && $3 ? (*$1  ^ *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr EQ pp_expr            { $$ = new_int($1 && $3 ? (*$1 == *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr NE pp_expr            { $$ = new_int($1 && $3 ? (*$1 != *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr '<' pp_expr           { $$ = new_int($1 && $3 ? (*$1  < *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr '>' pp_expr           { $$ = new_int($1 && $3 ? (*$1  > *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr LTE pp_expr           { $$ = new_int($1 && $3 ? (*$1 <= *$3) : 0); if($1) free($1); if($3) free($3); }
-        | pp_expr GTE pp_expr           { $$ = new_int($1 && $3 ? (*$1 >= *$3) : 0); if($1) free($1); if($3) free($3); }
-        | '~' pp_expr                   { $$ = $2; if($2) *$2 = ~(*$2); }
-        | '+' pp_expr                   { $$ = $2; }
-        | '-' pp_expr                   { $$ = $2; if($2) *$2 = -(*$2); }
-        | '!' pp_expr                   { $$ = $2; if($2) *$2 = !(*$2); }
-        | '(' pp_expr ')'               { $$ = $2; }
-        ;
-
-pp_constant
-        : any_num                       { $$ = new_int($1); }
-        | IDENT                         { $$ = NULL; }
-        | tDEFINED IDENT                { $$ = new_int(pp_lookup($2->str.cstr) != NULL); }
-        | tDEFINED '(' IDENT ')'        { $$ = new_int(pp_lookup($3->str.cstr) != NULL); }
-        ;
+
+                if(!dont_want_id)       /* See comments in language parsing below */
+                        want_id = 1;
+                dont_want_id = 0;
+                }
+        | resources cjunk                       { $$ = $1; want_id = 1; }
+        ;
+
 
 /* C ignore stuff */
 cjunk   : tTYPEDEF                      { strip_til_semicolon(); }
-        | tEXTERN                       { strip_extern(); }
-        | IDENT IDENT                   { strip_til_semicolon(); }
-        | IDENT '('                     { strip_til_parenthesis(); }
-        | IDENT '*'                     { strip_til_semicolon(); }
+        | tSTRUCT                       { strip_til_semicolon(); }
+        | tEXTERN                       { strip_til_semicolon(); }
+        | tENUM                         { strip_til_semicolon(); }
+        | tCPPCLASS                     { strip_til_semicolon(); }
+        | tSTATIC                       { strip_til_semicolon(); }
+        | tINLINE                       { internal_error(__FILE__, __LINE__, "Don't yet know how to strip inline functions\n"); }
+/*      | tIDENT tIDENT                 { strip_til_semicolon(); } */
+/*      | tIDENT tIDENT '('             { strip_til_parenthesis(); } See comments in 'resource' below */
+/*      | tIDENT '('                    { strip_til_parenthesis(); } */
+        | tIDENT '*'                    { strip_til_semicolon(); }
+        | tNL   /*
+                 * This newline rule will never get reduced because we never
+                 * get the tNL token, unless we explicitely set the 'want_nl'
+                 * flag, which we don't.
+                 * The *ONLY* reason for this to be here is because Berkeley
+                 * yacc (byacc), at least version 1.9, has a bug.
+                 * (identified in the generated parser on the second
+                 *  line with:
+                 *  static char yysccsid[] = "@(#)yaccpar   1.9 (Berkeley) 02/21/93";
+                 * )
+                 * This extra rule fixes it.
+                 * The problem is that the expression handling rule "expr: xpr"
+                 * is not reduced on non-terminal tokens, defined above in the
+                 * %token declarations. Token tNL is the only non-terminal that
+                 * can occur. The error becomes visible in the language parsing
+                 * rule below, which looks at the look-ahead token and tests it
+                 * for tNL. However, byacc already generates an error upon reading
+                 * the token instead of keeping it as a lookahead. The reason
+                 * lies in the lack of a $default transition in the "expr : xpr . "
+                 * state (currently state 25). It is probably ommitted because tNL
+                 * is a non-terminal and the state contains 2 s/r conflicts. The
+                 * state enumerates all possible transitions instead of using a
+                 * $default transition.
+                 * All in all, it is a bug in byacc. (period)
+                 */
         ;
 
 /* Parse top level resource definitions etc. */
 resource
-        : nameid resource_definition {
-                $$ = $2;
+        : expr usrcvt resource_definition {
+                $$ = $3;
                 if($$)
                 {
-                        $$->name = $1;
-                        if($1->type == name_ord)
-                        {
-                                chat("Got %s (%d)",get_typename($2),$1->name.i_name);
+                        if($1 > 65535 || $1 < -32768)
+                                yyerror("Resource's ID out of range (%d)", $1);
+                        $$->name = new_name_id();
+                        $$->name->type = name_ord;
+                        $$->name->name.i_name = $1;
+                        chat("Got %s (%d)", get_typename($3), $$->name->name.i_name);
                         }
-                        else if($1->type == name_str)
-                        {
-                                chat("Got %s (%s)",get_typename($2),$1->name.s_name->str.cstr);
                         }
-                }
-                }
+        | tIDENT usrcvt resource_definition {
+                $$ = $3;
+                if($$)
+                {
+                        $$->name = new_name_id();
+                        $$->name->type = name_str;
+                        $$->name->name.s_name = $1;
+                        chat("Got %s (%s)", get_typename($3), $$->name->name.s_name->str.cstr);
+                }
+                }
+        | tIDENT usrcvt tIDENT '('      { /* cjunk */ strip_til_parenthesis(); $$ = NULL; }
+                /* The above rule is inserted here with explicit tIDENT
+                 * references to avoid a nasty LALR(2) problem when
+                 * considering the 'cjunk' rules with respect to the usertype
+                 * resources.
+                 * A usertype resource can have two leading identifiers before
+                 * it qualifies as shift into usertype rules. However, the
+                 * cjunk scanner also has a rule of two leading identifiers.
+                 * The problem occurs because the second identifier is at the
+                 * second lookahead (hence LALR(2)) seen from the recursion
+                 * rule 'resources'.
+                 * Thus, the scanner will pick *one* of the rules in preference
+                 * of the other (in this case it was 'cjunk') and generates a
+                 * syntax error if the trailing context wasn't seen. The
+                 * correct action would have been to rollback the stack and
+                 * decent into the 'userres' rule, but this cannot be done
+                 * because yacc only parses LALR(1).
+                 * The problem is prevented from happening by making the decent
+                 * into the cjunk-scanning obsolete and explicitly force the
+                 * scanner to require no more than 1 lookahead.
+                 */
         | stringtable {
                 /* Don't do anything, stringtables are converted to
@@ -427 +520 @@
                 chat("Got STRINGTABLE");
                 }
-        | opt_language {
+        | tLANGUAGE {want_nl = 1; } expr ',' expr {
+                /* We *NEED* the newline to delimit the expression.
+                 * Otherwise, we would not be able to set the next
+                 * want_id anymore because of the token-lookahead.
+                 *
+                 * However, we can test the lookahead-token for
+                 * being "non-expression" type, in which case we
+                 * continue. Fortunately, tNL is the only token that
+                 * will break expression parsing and is implicitely
+                 * void, so we just remove it. This scheme makes it
+                 * possible to do some (not all) fancy preprocessor
+                 * stuff.
+                 * BTW, we also need to make sure that the next
+                 * reduction of 'resources' above will *not* set
+                 * want_id because we already have a lookahead that
+                 * cannot be undone.
+                 */
+                if(yychar != YYEMPTY && yychar != tNL)
+                        dont_want_id = 1;
+
+                if(yychar == tNL)
+                        yychar = YYEMPTY;       /* Could use 'yyclearin', but we already need the*/
+                                                /* direct access to yychar in rule 'usrcvt' below. */
+                else if(yychar == tIDENT)
+                        yywarning("LANGUAGE statement not delimited with newline; next identifier might be wrong");
+
+                want_nl = 0;    /* We don't want it anymore if we didn't get it */
+
                 if(!win32)
                         yywarning("LANGUAGE not supported in 16-bit mode");
                 if(currentlanguage)
                         free(currentlanguage);
-                currentlanguage = $1;
+                currentlanguage = new_language($3, $5);
                 $$ = NULL;
-                }
+                chat("Got LANGUAGE %d,%d (0x%04x)", $3, $5, ($5<<10) + $3);
+                }
+        ;
+
+/*
+ * Remapping of numerical resource types
+ * (see also comment of called function below)
+ */
+usrcvt  : /* Empty */   { yychar = rsrcid_to_token(yychar); }
         ;
 
@@ -446 +574 @@
                 $$->type = name_ord;
                 $$->name.i_name = $1;
-                want_rscname = 0;
-                }
-        | IDENT {
+                }
+        | tIDENT {
                 $$ = new_name_id();
                 $$->type = name_str;
                 $$->name.s_name = $1;
-                want_rscname = 0;
                 }
         ;
@@ -464 +590 @@
                 $$->type = name_str;
                 $$->name.s_name = $1;
-                want_rscname = 0;
                 }
         ;
@@ -471 +596 @@
 resource_definition
         : accelerators  { $$ = new_resource(res_acc, $1, $1->memopt, $1->lvc.language); }
-        | bitmap        { $$ = new_resource(res_bmp, $1, $1->memopt, dup_language(currentlanguage)); }
+        | bitmap        { $$ = new_resource(res_bmp, $1, $1->memopt, $1->data->lvc.language); }
         | cursor {
                 resource_t *rsc;
-                cursor_t *cur;
-                $$ = rsc = new_resource(res_curg, $1, $1->memopt, dup_language(currentlanguage));
-                for(cur = $1->cursorlist; cur; cur = cur->next)
-                {
-                        rsc->prev = new_resource(res_cur, cur, $1->memopt, dup_language(currentlanguage));
-                        rsc->prev->next = rsc;
-                        rsc = rsc->prev;
-                        rsc->name = new_name_id();
-                        rsc->name->type = name_ord;
-                        rsc->name->name.i_name = cur->id;
-                }
+                if($1->type == res_anicur)
+                {
+                        $$ = rsc = new_resource(res_anicur, $1->u.ani, $1->u.ani->memopt, $1->u.ani->data->lvc.language);
+                }
+                else if($1->type == res_curg)
+                {
+                        cursor_t *cur;
+                        $$ = rsc = new_resource(res_curg, $1->u.curg, $1->u.curg->memopt, $1->u.curg->lvc.language);
+                        for(cur = $1->u.curg->cursorlist; cur; cur = cur->next)
+                        {
+                                rsc->prev = new_resource(res_cur, cur, $1->u.curg->memopt, $1->u.curg->lvc.language);
+                                rsc->prev->next = rsc;
+                                rsc = rsc->prev;
+                                rsc->name = new_name_id();
+                                rsc->name->type = name_ord;
+                                rsc->name->name.i_name = cur->id;
+                        }
+                }
+                else
+                        internal_error(__FILE__, __LINE__, "Invalid top-level type %d in cursor resource", $1->type);
+                free($1);
                 }
         | dialog        { $$ = new_resource(res_dlg, $1, $1->memopt, $1->lvc.language); }
@@ -493 +628 @@
                         $$ = NULL;
                 }
-        | dlginit       { $$ = new_resource(res_dlginit, $1, $1->memopt, $1->lvc.language); }
-        | font          { $$ = new_resource(res_fnt, $1, $1->memopt, dup_language(currentlanguage)); }
+        | dlginit       { $$ = new_resource(res_dlginit, $1, $1->memopt, $1->data->lvc.language); }
+        | font          { $$ = new_resource(res_fnt, $1, $1->memopt, $1->data->lvc.language); }
+        | fontdir       { $$ = new_resource(res_fntdir, $1, $1->memopt, $1->data->lvc.language); }
         | icon {
                 resource_t *rsc;
-                icon_t *ico;
-                $$ = rsc = new_resource(res_icog, $1, $1->memopt, dup_language(currentlanguage));
-                for(ico = $1->iconlist; ico; ico = ico->next)
-                {
-                        rsc->prev = new_resource(res_ico, ico, $1->memopt, dup_language(currentlanguage));
-                        rsc->prev->next = rsc;
-                        rsc = rsc->prev;
-                        rsc->name = new_name_id();
-                        rsc->name->type = name_ord;
-                        rsc->name->name.i_name = ico->id;
-                }
+                if($1->type == res_aniico)
+                {
+                        $$ = rsc = new_resource(res_aniico, $1->u.ani, $1->u.ani->memopt, $1->u.ani->data->lvc.language);
+                }
+                else if($1->type == res_icog)
+                {
+                        icon_t *ico;
+                        $$ = rsc = new_resource(res_icog, $1->u.icog, $1->u.icog->memopt, $1->u.icog->lvc.language);
+                        for(ico = $1->u.icog->iconlist; ico; ico = ico->next)
+                        {
+                                rsc->prev = new_resource(res_ico, ico, $1->u.icog->memopt, $1->u.icog->lvc.language);
+                                rsc->prev->next = rsc;
+                                rsc = rsc->prev;
+                                rsc->name = new_name_id();
+                                rsc->name->type = name_ord;
+                                rsc->name->name.i_name = ico->id;
+                        }
+                }
+                else
+                        internal_error(__FILE__, __LINE__, "Invalid top-level type %d in icon resource", $1->type);
+                free($1);
                 }
         | menu          { $$ = new_resource(res_men, $1, $1->memopt, $1->lvc.language); }
@@ -517 +663 @@
                 }
         | messagetable  { $$ = new_resource(res_msg, $1, WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE, dup_language(currentlanguage)); }
-        | rcdata        { $$ = new_resource(res_rdt, $1, $1->memopt, $1->lvc.language); }
+        | rcdata        { $$ = new_resource(res_rdt, $1, $1->memopt, $1->data->lvc.language); }
         | toolbar       { $$ = new_resource(res_toolbar, $1, $1->memopt, $1->lvc.language); }
-        | userres       { $$ = new_resource(res_usr, $1, $1->memopt, dup_language(currentlanguage)); }
-        | versioninfo   { $$ = new_resource(res_ver, $1, WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE, dup_language(currentlanguage)); }
+        | userres       { $$ = new_resource(res_usr, $1, $1->memopt, $1->data->lvc.language); }
+        | versioninfo   { $$ = new_resource(res_ver, $1, WRC_MO_MOVEABLE | WRC_MO_DISCARDABLE, $1->lvc.language); }
+        ;
+
+
+filename: tFILENAME     { $$ = make_filename($1); }
+        | tIDENT        { $$ = make_filename($1); }
+        | tSTRING       { $$ = make_filename($1); }
         ;
 
 /* ------------------------------ Bitmap ------------------------------ */
-bitmap  : tBITMAP loadmemopts FILENAME  { $$ = new_bitmap(load_file($3), $2); }
-        | tBITMAP loadmemopts raw_data  { $$ = new_bitmap($3, $2); }
+bitmap  : tBITMAP loadmemopts file_raw  { $$ = new_bitmap($3, $2); }
         ;
 
 /* ------------------------------ Cursor ------------------------------ */
-cursor  : CURSOR loadmemopts FILENAME   { $$ = new_cursor_group(load_file($3), $2); }
-        | CURSOR loadmemopts raw_data   { $$ = new_cursor_group($3, $2); }
+cursor  : tCURSOR loadmemopts file_raw  {
+                $$ = new_ani_any();
+                if($3->size > 4 && !memcmp($3->data, riff, sizeof(riff)))
+                {
+                        $$->type = res_anicur;
+                        $$->u.ani = new_ani_curico(res_anicur, $3, $2);
+                }
+                else
+                {
+                        $$->type = res_curg;
+                        $$->u.curg = new_cursor_group($3, $2);
+                }
+        }
+        ;
+
+/* ------------------------------ Icon ------------------------------ */
+icon    : tICON loadmemopts file_raw    {
+                $$ = new_ani_any();
+                if($3->size > 4 && !memcmp($3->data, riff, sizeof(riff)))
+                {
+                        $$->type = res_aniico;
+                        $$->u.ani = new_ani_curico(res_aniico, $3, $2);
+                }
+                else
+                {
+                        $$->type = res_icog;
+                        $$->u.icog = new_icon_group($3, $2);
+                }
+        }
         ;
 
 /* ------------------------------ Font ------------------------------ */
-/* FIXME: Should we allow raw_data here? */
-font    : FONT loadmemopts FILENAME     { $$ = new_font(load_file($3), $2); }
-        ;
-
-/* ------------------------------ Icon ------------------------------ */
-icon    : ICON loadmemopts FILENAME     { $$ = new_icon_group(load_file($3), $2); }
-        | ICON loadmemopts raw_data     { $$ = new_icon_group($3, $2); }
+        /*
+         * The reading of raw_data for fonts is a Borland BRC
+         * extension. MS generates an error. However, it is
+         * most logical to support this, considering how wine
+         * enters things in CVS (ascii).
+         */
+font    : tFONT loadmemopts file_raw    { $$ = new_font($3, $2); }
+        ;
+
+        /*
+         * The fontdir is a Borland BRC extension which only
+         * reads the data as 'raw_data' from the file.
+         * I don't know whether it is interpreted.
+         * The fontdir is generated if it was not present and
+         * fonts are defined in the source.
+         */
+fontdir : tFONTDIR loadmemopts file_raw { $$ = new_fontdir($3, $2); }
         ;
 
@@ -548 +736 @@
  */
 messagetable
-        : MESSAGETABLE FILENAME {
+        : tMESSAGETABLE loadmemopts file_raw    {
                 if(!win32)
                         yywarning("MESSAGETABLE not supported in 16-bit mode");
-                $$ = new_messagetable(load_file($2));
+                $$ = new_messagetable($3, $2);
                 }
         ;
 
 /* ------------------------------ RCData ------------------------------ */
-rcdata  : RCDATA loadmemopts opt_lvc raw_data {
-                $$ = new_rcdata($4, $2);
-                if($3)
-                {
-                        $$->lvc = *($3);
-                        free($3);
-                }
-                if(!$$->lvc.language)
-                        $$->lvc.language = dup_language(currentlanguage);
-                }
+rcdata  : tRCDATA loadmemopts file_raw  { $$ = new_rcdata($3, $2); }
         ;
 
 /* ------------------------------ DLGINIT ------------------------------ */
-dlginit : DLGINIT loadmemopts opt_lvc raw_data {
-                $$ = new_dlginit($4, $2);
-                if($3)
-                {
-                        $$->lvc = *($3);
-                        free($3);
-                }
-                if(!$$->lvc.language)
-                        $$->lvc.language = dup_language(currentlanguage);
-                }
+dlginit : tDLGINIT loadmemopts file_raw { $$ = new_dlginit($3, $2); }
         ;         
 
 /* ------------------------------ UserType ------------------------------ */
-userres : usertype loadmemopts FILENAME { $$ = new_user($1, load_file($3), $2); }
-        | usertype loadmemopts raw_data { $$ = new_user($1, $3, $2); }
-        ;
-
-/* NOTE: This here is an exception where I do not allow an expression.
- * Reason for this is that it is not possible to set the 'yywf' condition
- * for flex if loadmemopts is empty. Reading an expression requires a
- * lookahead to determine its end. In this case here, that would mean that
- * the filename has been read as IDENT or tSTRING, which is incorrect.
- * Note also that IDENT cannot be used as a file-name because it is lacking
- * the '.'.
- */
-
-/* I also allow string identifiers as classtypes. Not MS implemented, but
- * seems to be reasonable to implement.
- */
-/* Allowing anything else than NUMBER makes it very hard to get rid of
- * prototypes. So, I remove IDENT to be able to get prototypes out of the
- * world.
- */
-usertype: NUMBER {
+userres : usertype loadmemopts file_raw         {
+                #ifdef WORDS_BIGENDIAN
+                        if(pedantic && byteorder != WRC_BO_LITTLE)
+                #else
+                        if(pedantic && byteorder == WRC_BO_BIG)
+                #endif
+                                yywarning("Byteordering is not little-endian and type cannot be interpreted");
+                        $$ = new_user($1, $3, $2);
+                }
+        ;
+
+usertype: tNUMBER {
                 $$ = new_name_id();
                 $$->type = name_ord;
                 $$->name.i_name = $1;
-                set_yywf();
-                }
-/*      | IDENT {
+                }
+        | tIDENT {
                 $$ = new_name_id();
                 $$->type = name_str;
                 $$->name.s_name = $1;
-                set_yywf();
-                }
-*/      | tSTRING {
-                $$ = new_name_id();
-                $$->type = name_str;
-                $$->name.s_name = $1;
-                set_yywf();
                 }
         ;
@@ -624 +777 @@
 /* ------------------------------ Accelerator ------------------------------ */
 accelerators
-        : ACCELERATORS loadmemopts opt_lvc tBEGIN events tEND {
+        : tACCELERATORS loadmemopts opt_lvc tBEGIN events tEND {
                 $$ = new_accelerator();
                 if($2)
@@ -653 +806 @@
         ;
 
-acc_opt : /* Empty */           { $$=0; }
-        | acc_opt ',' NOINVERT  { $$=$1 | WRC_AF_NOINVERT; }
-        | acc_opt ',' SHIFT     { $$=$1 | WRC_AF_SHIFT; }
-        | acc_opt ',' CONTROL   { $$=$1 | WRC_AF_CONTROL; }
-        | acc_opt ',' ALT       { $$=$1 | WRC_AF_ALT; }
-        | acc_opt ',' ASCII     { $$=$1 | WRC_AF_ASCII; }
-        | acc_opt ',' VIRTKEY   { $$=$1 | WRC_AF_VIRTKEY; }
+/*
+ * The empty rule generates a s/r conflict because of {bi,u}nary expr
+ * on - and +. It cannot be solved in any way because it is the same as
+ * the if/then/else problem (LALR(1) problem). The conflict is moved
+ * away by forcing it to be in the expression handling below.
+ */
+acc_opt : /* Empty */   { $$ = 0; }
+        | ',' accs      { $$ = $2; }
+        ;
+
+accs    : acc           { $$ = $1; }
+        | accs ',' acc  { $$ = $1 | $3; }
+        ;
+
+acc     : tNOINVERT     { $$ = WRC_AF_NOINVERT; }
+        | tSHIFT        { $$ = WRC_AF_SHIFT; }
+        | tCONTROL      { $$ = WRC_AF_CONTROL; }
+        | tALT          { $$ = WRC_AF_ALT; }
+        | tASCII        { $$ = WRC_AF_ASCII; }
+        | tVIRTKEY      { $$ = WRC_AF_VIRTKEY; }
         ;
 
 /* ------------------------------ Dialog ------------------------------ */
 /* FIXME: Support EXSTYLE in the dialog line itself */
-dialog  : DIALOG loadmemopts expr ',' expr ',' expr ',' expr dlg_attributes
+dialog  : tDIALOG loadmemopts expr ',' expr ',' expr ',' expr dlg_attributes
           tBEGIN  ctrls tEND {
                 if($2)
@@ -692 +858 @@
                 $$->style->and_mask = 0;
 
-                indialog = FALSE;
                 if(!$$->lvc.language)
                         $$->lvc.language = dup_language(currentlanguage);
@@ -699 +864 @@
 
 dlg_attributes
-        : /* Empty */                   { $$=new_dialog(); }
-        | dlg_attributes STYLE style    { $$=dialog_style($3,$1); }
-        | dlg_attributes EXSTYLE style  { $$=dialog_exstyle($3,$1); }
-        | dlg_attributes CAPTION tSTRING { $$=dialog_caption($3,$1); }
-        | dlg_attributes opt_font       { $$=dialog_font($2,$1); }
-        | dlg_attributes CLASS nameid_s { $$=dialog_class($3,$1); }
-        | dlg_attributes MENU nameid    { $$=dialog_menu($3,$1); }
-        | dlg_attributes opt_language   { $$=dialog_language($2,$1); }
-        | dlg_attributes opt_characts   { $$=dialog_characteristics($2,$1); }
-        | dlg_attributes opt_version    { $$=dialog_version($2,$1); }
+        : /* Empty */                           { $$=new_dialog(); }
+        | dlg_attributes tSTYLE style           { $$=dialog_style($3,$1); }
+        | dlg_attributes tEXSTYLE style         { $$=dialog_exstyle($3,$1); }
+        | dlg_attributes tCAPTION tSTRING       { $$=dialog_caption($3,$1); }
+        | dlg_attributes opt_font               { $$=dialog_font($2,$1); }
+        | dlg_attributes tCLASS nameid_s        { $$=dialog_class($3,$1); }
+        | dlg_attributes tCPPCLASS nameid_s     { $$=dialog_class($3,$1); }
+        | dlg_attributes tMENU nameid           { $$=dialog_menu($3,$1); }
+        | dlg_attributes opt_language           { $$=dialog_language($2,$1); }
+        | dlg_attributes opt_characts           { $$=dialog_characteristics($2,$1); }
+        | dlg_attributes opt_version            { $$=dialog_version($2,$1); }
         ;
 
 ctrls   : /* Empty */                           { $$ = NULL; }
-        | ctrls CONTROL         gen_ctrl        { $$=ins_ctrl(-1, 0, $3, $1); }
-        | ctrls EDITTEXT        ctrl_desc       { $$=ins_ctrl(CT_EDIT, 0, $3, $1); }
-        | ctrls LISTBOX         ctrl_desc       { $$=ins_ctrl(CT_LISTBOX, 0, $3, $1); }
-        | ctrls COMBOBOX        ctrl_desc       { $$=ins_ctrl(CT_COMBOBOX, 0, $3, $1); }
-        | ctrls SCROLLBAR       ctrl_desc       { $$=ins_ctrl(CT_SCROLLBAR, 0, $3, $1); }
-        | ctrls CHECKBOX        lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_CHECKBOX, $3, $1); }
-        | ctrls DEFPUSHBUTTON   lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_DEFPUSHBUTTON, $3, $1); }
-        | ctrls GROUPBOX        lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_GROUPBOX, $3, $1);}
-        | ctrls PUSHBUTTON      lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_PUSHBUTTON, $3, $1); }
-/*      | ctrls PUSHBOX         lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_PUSHBOX, $3, $1); } */
-        | ctrls RADIOBUTTON     lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_RADIOBUTTON, $3, $1); }
-        | ctrls AUTO3STATE      lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_AUTO3STATE, $3, $1); }
-        | ctrls STATE3          lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_3STATE, $3, $1); }
-        | ctrls AUTOCHECKBOX    lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_AUTOCHECKBOX, $3, $1); }
-        | ctrls AUTORADIOBUTTON lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_AUTORADIOBUTTON, $3, $1); }
-        | ctrls LTEXT           lab_ctrl        { $$=ins_ctrl(CT_STATIC, SS_LEFT, $3, $1); }
-        | ctrls CTEXT           lab_ctrl        { $$=ins_ctrl(CT_STATIC, SS_CENTER, $3, $1); }
-        | ctrls RTEXT           lab_ctrl        { $$=ins_ctrl(CT_STATIC, SS_RIGHT, $3, $1); }
+        | ctrls tCONTROL        gen_ctrl        { $$=ins_ctrl(-1, 0, $3, $1); }
+        | ctrls tEDITTEXT       ctrl_desc       { $$=ins_ctrl(CT_EDIT, 0, $3, $1); }
+        | ctrls tLISTBOX        ctrl_desc       { $$=ins_ctrl(CT_LISTBOX, 0, $3, $1); }
+        | ctrls tCOMBOBOX       ctrl_desc       { $$=ins_ctrl(CT_COMBOBOX, 0, $3, $1); }
+        | ctrls tSCROLLBAR      ctrl_desc       { $$=ins_ctrl(CT_SCROLLBAR, 0, $3, $1); }
+        | ctrls tCHECKBOX       lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_CHECKBOX, $3, $1); }
+        | ctrls tDEFPUSHBUTTON  lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_DEFPUSHBUTTON, $3, $1); }
+        | ctrls tGROUPBOX       lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_GROUPBOX, $3, $1);}
+        | ctrls tPUSHBUTTON     lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_PUSHBUTTON, $3, $1); }
+/*      | ctrls tPUSHBOX        lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_PUSHBOX, $3, $1); } */
+        | ctrls tRADIOBUTTON    lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_RADIOBUTTON, $3, $1); }
+        | ctrls tAUTO3STATE     lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_AUTO3STATE, $3, $1); }
+        | ctrls tSTATE3         lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_3STATE, $3, $1); }
+        | ctrls tAUTOCHECKBOX   lab_ctrl        { $$=ins_ctrl(CT_BUTTON, BS_AUTOCHECKBOX, $3, $1); }
+        | ctrls tAUTORADIOBUTTON lab_ctrl       { $$=ins_ctrl(CT_BUTTON, BS_AUTORADIOBUTTON, $3, $1); }
+        | ctrls tLTEXT          lab_ctrl        { $$=ins_ctrl(CT_STATIC, SS_LEFT, $3, $1); }
+        | ctrls tCTEXT          lab_ctrl        { $$=ins_ctrl(CT_STATIC, SS_CENTER, $3, $1); }
+        | ctrls tRTEXT          lab_ctrl        { $$=ins_ctrl(CT_STATIC, SS_RIGHT, $3, $1); }
         /* special treatment for icons, as the extent is optional */
-        | ctrls ICON nameid_s opt_comma expr ',' expr ',' expr iconinfo {
+        | ctrls tICON nameid_s opt_comma expr ',' expr ',' expr iconinfo {
                 $10->title = $3;
                 $10->id = $5;
@@ -830 +996 @@
 
 opt_font
-        : FONT expr ',' tSTRING { $$ = new_font_id($2, $4, 0, 0); }
+        : tFONT expr ',' tSTRING        { $$ = new_font_id($2, $4, 0, 0); }
         ;
 
@@ -849 +1015 @@
         | '(' style ')'         { $$ = $2; }
         | any_num               { $$ = new_style($1, 0); }
-        | NOT any_num           { $$ = new_style(0, $2); }
+        | tNOT any_num          { $$ = new_style(0, $2); }
         ;   
 
@@ -866 +1032 @@
 
 /* ------------------------------ DialogEx ------------------------------ */
-dialogex: DIALOGEX loadmemopts expr ',' expr ',' expr ',' expr helpid dlgex_attribs
+dialogex: tDIALOGEX loadmemopts expr ',' expr ',' expr ',' expr helpid dlgex_attribs
           tBEGIN  exctrls tEND {
                 if(!win32)
@@ -904 +1070 @@
                 $$->style->and_mask = 0;
 
-                indialog = FALSE;
                 if(!$$->lvc.language)
                         $$->lvc.language = dup_language(currentlanguage);
@@ -911 +1076 @@
 
 dlgex_attribs
-        : /* Empty */                   { $$=new_dialogex(); }
-        | dlgex_attribs STYLE style     { $$=dialogex_style($3,$1); }
-        | dlgex_attribs EXSTYLE style   { $$=dialogex_exstyle($3,$1); }
-        | dlgex_attribs CAPTION tSTRING { $$=dialogex_caption($3,$1); }
-        | dlgex_attribs opt_font        { $$=dialogex_font($2,$1); }
-        | dlgex_attribs opt_exfont      { $$=dialogex_font($2,$1); }
-        | dlgex_attribs CLASS nameid_s  { $$=dialogex_class($3,$1); }
-        | dlgex_attribs MENU nameid     { $$=dialogex_menu($3,$1); }
-        | dlgex_attribs opt_language    { $$=dialogex_language($2,$1); }
-        | dlgex_attribs opt_characts    { $$=dialogex_characteristics($2,$1); }
-        | dlgex_attribs opt_version     { $$=dialogex_version($2,$1); }
+        : /* Empty */                           { $$=new_dialogex(); }
+        | dlgex_attribs tSTYLE style            { $$=dialogex_style($3,$1); }
+        | dlgex_attribs tEXSTYLE style          { $$=dialogex_exstyle($3,$1); }
+        | dlgex_attribs tCAPTION tSTRING        { $$=dialogex_caption($3,$1); }
+        | dlgex_attribs opt_font                { $$=dialogex_font($2,$1); }
+        | dlgex_attribs opt_exfont              { $$=dialogex_font($2,$1); }
+        | dlgex_attribs tCLASS nameid_s         { $$=dialogex_class($3,$1); }
+        | dlgex_attribs tCPPCLASS nameid_s      { $$=dialogex_class($3,$1); }
+        | dlgex_attribs tMENU nameid            { $$=dialogex_menu($3,$1); }
+        | dlgex_attribs opt_language            { $$=dialogex_language($2,$1); }
+        | dlgex_attribs opt_characts            { $$=dialogex_characteristics($2,$1); }
+        | dlgex_attribs opt_version             { $$=dialogex_version($2,$1); }
         ;
 
 exctrls : /* Empty */                           { $$ = NULL; }
-        | exctrls CONTROL       gen_exctrl      { $$=ins_ctrl(-1, 0, $3, $1); }
-        | exctrls EDITTEXT      exctrl_desc     { $$=ins_ctrl(CT_EDIT, 0, $3, $1); }
-        | exctrls LISTBOX       exctrl_desc     { $$=ins_ctrl(CT_LISTBOX, 0, $3, $1); }
-        | exctrls COMBOBOX      exctrl_desc     { $$=ins_ctrl(CT_COMBOBOX, 0, $3, $1); }
-        | exctrls SCROLLBAR     exctrl_desc     { $$=ins_ctrl(CT_SCROLLBAR, 0, $3, $1); }
-        | exctrls CHECKBOX      lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_CHECKBOX, $3, $1); }
-        | exctrls DEFPUSHBUTTON lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_DEFPUSHBUTTON, $3, $1); }
-        | exctrls GROUPBOX      lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_GROUPBOX, $3, $1);}
-        | exctrls PUSHBUTTON    lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_PUSHBUTTON, $3, $1); }
-/*      | exctrls PUSHBOX       lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_PUSHBOX, $3, $1); } */
-        | exctrls RADIOBUTTON   lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_RADIOBUTTON, $3, $1); }
-        | exctrls AUTO3STATE    lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_AUTO3STATE, $3, $1); }
-        | exctrls STATE3        lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_3STATE, $3, $1); }
-        | exctrls AUTOCHECKBOX  lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_AUTOCHECKBOX, $3, $1); }
-        | exctrls AUTORADIOBUTTON lab_exctrl    { $$=ins_ctrl(CT_BUTTON, BS_AUTORADIOBUTTON, $3, $1); }
-        | exctrls LTEXT         lab_exctrl      { $$=ins_ctrl(CT_STATIC, SS_LEFT, $3, $1); }
-        | exctrls CTEXT         lab_exctrl      { $$=ins_ctrl(CT_STATIC, SS_CENTER, $3, $1); }
-        | exctrls RTEXT         lab_exctrl      { $$=ins_ctrl(CT_STATIC, SS_RIGHT, $3, $1); }
+        | exctrls tCONTROL      gen_exctrl      { $$=ins_ctrl(-1, 0, $3, $1); }
+        | exctrls tEDITTEXT     exctrl_desc     { $$=ins_ctrl(CT_EDIT, 0, $3, $1); }
+        | exctrls tLISTBOX      exctrl_desc     { $$=ins_ctrl(CT_LISTBOX, 0, $3, $1); }
+        | exctrls tCOMBOBOX     exctrl_desc     { $$=ins_ctrl(CT_COMBOBOX, 0, $3, $1); }
+        | exctrls tSCROLLBAR    exctrl_desc     { $$=ins_ctrl(CT_SCROLLBAR, 0, $3, $1); }
+        | exctrls tCHECKBOX     lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_CHECKBOX, $3, $1); }
+        | exctrls tDEFPUSHBUTTON lab_exctrl     { $$=ins_ctrl(CT_BUTTON, BS_DEFPUSHBUTTON, $3, $1); }
+        | exctrls tGROUPBOX     lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_GROUPBOX, $3, $1);}
+        | exctrls tPUSHBUTTON   lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_PUSHBUTTON, $3, $1); }
+/*      | exctrls tPUSHBOX      lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_PUSHBOX, $3, $1); } */
+        | exctrls tRADIOBUTTON  lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_RADIOBUTTON, $3, $1); }
+        | exctrls tAUTO3STATE   lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_AUTO3STATE, $3, $1); }
+        | exctrls tSTATE3       lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_3STATE, $3, $1); }
+        | exctrls tAUTOCHECKBOX lab_exctrl      { $$=ins_ctrl(CT_BUTTON, BS_AUTOCHECKBOX, $3, $1); }
+        | exctrls tAUTORADIOBUTTON lab_exctrl   { $$=ins_ctrl(CT_BUTTON, BS_AUTORADIOBUTTON, $3, $1); }
+        | exctrls tLTEXT        lab_exctrl      { $$=ins_ctrl(CT_STATIC, SS_LEFT, $3, $1); }
+        | exctrls tCTEXT        lab_exctrl      { $$=ins_ctrl(CT_STATIC, SS_CENTER, $3, $1); }
+        | exctrls tRTEXT        lab_exctrl      { $$=ins_ctrl(CT_STATIC, SS_RIGHT, $3, $1); }
         /* special treatment for icons, as the extent is optional */
-        | exctrls ICON nameid_s opt_comma expr ',' expr ',' expr iconinfo {
+        | exctrls tICON nameid_s opt_comma expr ',' expr ',' expr iconinfo {
                 $10->title = $3;
                 $10->id = $5;
@@ -1055 +1221 @@
 
 opt_exfont
-        : FONT expr ',' tSTRING ',' expr ',' expr  opt_expr { $$ = new_font_id($2, $4, $6, $8); }
+        : tFONT expr ',' tSTRING ',' expr ',' expr  opt_expr { $$ = new_font_id($2, $4, $6, $8); }
         ;
 
@@ -1067 +1233 @@
 
 /* ------------------------------ Menu ------------------------------ */
-menu    : MENU loadmemopts opt_lvc menu_body {
+menu    : tMENU loadmemopts opt_lvc menu_body {
                 if(!$4)
                         yyerror("Menu must contain items");
@@ -1095 +1261 @@
 item_definitions
         : /* Empty */   {$$ = NULL;}
-        | item_definitions MENUITEM tSTRING opt_comma expr item_options {
+        | item_definitions tMENUITEM tSTRING opt_comma expr item_options {
                 $$=new_menu_item();
                 $$->prev = $1;
@@ -1104 +1270 @@
                 $$->name = $3;
                 }
-        | item_definitions MENUITEM SEPARATOR {
+        | item_definitions tMENUITEM tSEPARATOR {
                 $$=new_menu_item();
                 $$->prev = $1;
@@ -1110 +1276 @@
                         $1->next = $$;
                 }
-        | item_definitions POPUP tSTRING item_options menu_body {
+        | item_definitions tPOPUP tSTRING item_options menu_body {
                 $$ = new_menu_item();
                 $$->prev = $1;
@@ -1129 +1295 @@
  */
 item_options
-        : /* Empty */                   { $$ = 0; }
-        | ',' CHECKED   item_options    { $$ = $3 | MF_CHECKED; }
-        | ',' GRAYED    item_options    { $$ = $3 | MF_GRAYED; }
-        | ',' HELP      item_options    { $$ = $3 | MF_HELP; }
-        | ',' INACTIVE  item_options    { $$ = $3 | MF_DISABLED; }
-        | ',' MENUBARBREAK item_options { $$ = $3 | MF_MENUBARBREAK; }
-        | ',' MENUBREAK item_options    { $$ = $3 | MF_MENUBREAK; }
+        : /* Empty */                           { $$ = 0; }
+        | ',' tCHECKED          item_options    { $$ = $3 | MF_CHECKED; }
+        | ',' tGRAYED           item_options    { $$ = $3 | MF_GRAYED; }
+        | ',' tHELP             item_options    { $$ = $3 | MF_HELP; }
+        | ',' tINACTIVE         item_options    { $$ = $3 | MF_DISABLED; }
+        | ',' tMENUBARBREAK     item_options    { $$ = $3 | MF_MENUBARBREAK; }
+        | ',' tMENUBREAK        item_options    { $$ = $3 | MF_MENUBREAK; }
         ;
 
 /* ------------------------------ MenuEx ------------------------------ */
-menuex  : MENUEX loadmemopts opt_lvc menuex_body        {
+menuex  : tMENUEX loadmemopts opt_lvc menuex_body       {
                 if(!win32)
                         yywarning("MENUEX not supported in 16-bit mode");
@@ -1169 +1335 @@
 itemex_definitions
         : /* Empty */   {$$ = NULL; }
-        | itemex_definitions MENUITEM tSTRING itemex_options {
+        | itemex_definitions tMENUITEM tSTRING itemex_options {
                 $$ = new_menuex_item();
                 $$->prev = $1;
@@ -1185 +1351 @@
                 free($4);
                 }
-        | itemex_definitions MENUITEM SEPARATOR {
+        | itemex_definitions tMENUITEM tSEPARATOR {
                 $$ = new_menuex_item();
                 $$->prev = $1;
@@ -1191 +1357 @@
                         $1->next = $$;
                 }
-        | itemex_definitions POPUP tSTRING itemex_p_options menuex_body {
+        | itemex_definitions tPOPUP tSTRING itemex_p_options menuex_body {
                 $$ = new_menuex_item();
                 $$->prev = $1;
@@ -1315 +1481 @@
 
 /* This is to get the language of the currently parsed stringtable */
-stt_head: STRINGTABLE loadmemopts opt_lvc {
+stt_head: tSTRINGTABLE loadmemopts opt_lvc {
                 if((tagstt = find_stringtable($3)) == NULL)
                         tagstt = new_stringtable($3);
@@ -1350 +1516 @@
                 tagstt->entries[tagstt->nentries-1].characts = tagstt_characts;
 
+                if(pedantic && !$4->size)
+                        yywarning("Zero length strings make no sense");
                 if(!win32 && $4->size > 254)
                         yyerror("Stringtable entry more than 254 characters");
@@ -1365 +1533 @@
 /* ------------------------------ VersionInfo ------------------------------ */
 versioninfo
-        : VERSIONINFO fix_version tBEGIN ver_blocks tEND {
-                $$ = $2;
-                $2->blocks = get_ver_block_head($4);
+        : tVERSIONINFO loadmemopts fix_version tBEGIN ver_blocks tEND {
+                $$ = $3;
+                if($2)
+                {
+                        $$->memopt = *($2);
+                        free($2);
+                }
+                else
+                        $$->memopt = WRC_MO_MOVEABLE | (win32 ? WRC_MO_PURE : 0);
+                $$->blocks = get_ver_block_head($5);
+                /* Set language; there is no version or characteristics */
+                $$->lvc.language = dup_language(currentlanguage);
                 }
         ;
@@ -1373 +1550 @@
 fix_version
         : /* Empty */                   { $$ = new_versioninfo(); }
-        | fix_version FILEVERSION expr ',' expr ',' expr ',' expr {
+        | fix_version tFILEVERSION expr ',' expr ',' expr ',' expr {
                 if($1->gotit.fv)
                         yyerror("FILEVERSION already defined");
@@ -1383 +1560 @@
                 $$->gotit.fv = 1;
                 }
-        | fix_version PRODUCTVERSION expr ',' expr ',' expr ',' expr {
+        | fix_version tPRODUCTVERSION expr ',' expr ',' expr ',' expr {
                 if($1->gotit.pv)
                         yyerror("PRODUCTVERSION already defined");
@@ -1393 +1570 @@
                 $$->gotit.pv = 1;
                 }
-        | fix_version FILEFLAGS expr {
+        | fix_version tFILEFLAGS expr {
                 if($1->gotit.ff)
                         yyerror("FILEFLAGS already defined");
@@ -1400 +1577 @@
                 $$->gotit.ff = 1;
                 }
-        | fix_version FILEFLAGSMASK expr {
+        | fix_version tFILEFLAGSMASK expr {
                 if($1->gotit.ffm)
                         yyerror("FILEFLAGSMASK already defined");
@@ -1407 +1584 @@
                 $$->gotit.ffm = 1;
                 }
-        | fix_version FILEOS expr {
+        | fix_version tFILEOS expr {
                 if($1->gotit.fo)
                         yyerror("FILEOS already defined");
@@ -1414 +1591 @@
                 $$->gotit.fo = 1;
                 }
-        | fix_version FILETYPE expr {
+        | fix_version tFILETYPE expr {
                 if($1->gotit.ft)
                         yyerror("FILETYPE already defined");
@@ -1421 +1598 @@
                 $$->gotit.ft = 1;
                 }
-        | fix_version FILESUBTYPE expr {
+        | fix_version tFILESUBTYPE expr {
                 if($1->gotit.fst)
                         yyerror("FILESUBTYPE already defined");
@@ -1441 +1618 @@
 
 ver_block
-        : BLOCK tSTRING tBEGIN ver_values tEND {
+        : tBLOCK tSTRING tBEGIN ver_values tEND {
                 $$ = new_ver_block();
                 $$->name = $2;
@@ -1464 +1641 @@
                 $$->value.block = $1;
                 }
-        | VALUE tSTRING ',' tSTRING {
+        | tVALUE tSTRING ',' tSTRING {
                 $$ = new_ver_value();
                 $$->type = val_str;
@@ -1470 +1647 @@
                 $$->value.str = $4;
                 }
-        | VALUE tSTRING ',' ver_words {
+        | tVALUE tSTRING ',' ver_words {
                 $$ = new_ver_value();
                 $$->type = val_words;
@@ -1484 +1661 @@
 
 /* ------------------------------ Toolbar ------------------------------ */
-toolbar: TOOLBAR loadmemopts expr ',' expr opt_lvc tBEGIN toolbar_items tEND {
+toolbar: tTOOLBAR loadmemopts expr ',' expr opt_lvc tBEGIN toolbar_items tEND {
                 int nitems;
                 toolbar_item_t *items = get_tlbr_buttons_head($8, &nitems);
@@ -1511 +1688 @@
 toolbar_items
         :  /* Empty */                  { $$ = NULL; }
-        | toolbar_items BUTTON expr     {         
+        | toolbar_items tBUTTON expr    {         
                 toolbar_item_t *idrec = new_toolbar_item();
                 idrec->id = $3;
                 $$ = ins_tlbr_button($1, idrec); 
                 }
-        | toolbar_items SEPARATOR       {         
+        | toolbar_items tSEPARATOR      {         
                 toolbar_item_t *idrec = new_toolbar_item();
                 idrec->id = 0;
@@ -1551 +1728 @@
         ;
 
-lamo    : PRELOAD       { $$ = new_int(WRC_MO_PRELOAD); }
-        | MOVEABLE      { $$ = new_int(WRC_MO_MOVEABLE); }
-        | DISCARDABLE   { $$ = new_int(WRC_MO_DISCARDABLE); }
+lamo    : tPRELOAD      { $$ = new_int(WRC_MO_PRELOAD); }
+        | tMOVEABLE     { $$ = new_int(WRC_MO_MOVEABLE); }
+        | tDISCARDABLE  { $$ = new_int(WRC_MO_DISCARDABLE); }
         | tPURE         { $$ = new_int(WRC_MO_PURE); }
         ;
 
-lama    : LOADONCALL    { $$ = new_int(~WRC_MO_PRELOAD); }
+lama    : tLOADONCALL   { $$ = new_int(~WRC_MO_PRELOAD); }
         | tFIXED        { $$ = new_int(~WRC_MO_MOVEABLE); }
-        | IMPURE        { $$ = new_int(~WRC_MO_PURE); }
+        | tIMPURE       { $$ = new_int(~WRC_MO_PURE); }
         ;
 
@@ -1590 +1767 @@
         ;
 
+        /*
+         * This here is another s/r conflict on {bi,u}nary + and -.
+         * It is due to the look-ahead which must determine when the
+         * rule opt_language ends. It could be solved with adding a
+         * tNL at the end, but that seems unreasonable to do.
+         * The conflict is now moved to the expression handling below.
+         */
 opt_language
-        : LANGUAGE expr ',' expr        { $$ = new_language($2, $4); }
+        : tLANGUAGE expr ',' expr       { $$ = new_language($2, $4); }
         ;
 
 opt_characts
-        : CHARACTERISTICS expr          { $$ = new_characts($2); }
+        : tCHARACTERISTICS expr         { $$ = new_characts($2); }
         ;
 
 opt_version
-        : VERSION expr                  { $$ = new_version($2); }
-        ;
-
-/* ------------------------------ Raw data handking ------------------------------ */
-raw_data: tBEGIN raw_elements tEND      { $$ = $2; }
+        : tVERSION expr                 { $$ = new_version($2); }
+        ;
+
+/* ------------------------------ Raw data handling ------------------------------ */
+raw_data: opt_lvc tBEGIN raw_elements tEND {
+                if($1)
+                {
+                        $3->lvc = *($1);
+                        free($1);
+                }
+
+                if(!$3->lvc.language)
+                        $3->lvc.language = dup_language(currentlanguage);
+
+                $$ = $3;
+                }
         ;
 
 raw_elements
-        : RAWDATA                       { $$ = $1; }
-        | NUMBER                        { $$ = int2raw_data($1); }
-        | LNUMBER                       { $$ = long2raw_data($1); }
+        : tRAWDATA                      { $$ = $1; }
+        | tNUMBER                       { $$ = int2raw_data($1); }
+        | tLNUMBER                      { $$ = long2raw_data($1); }
         | tSTRING                       { $$ = str2raw_data($1); }
-        | raw_elements opt_comma RAWDATA   { $$ = merge_raw_data($1, $3); free($3->data); free($3); }
-        | raw_elements opt_comma NUMBER    { $$ = merge_raw_data_int($1, $3); }
-        | raw_elements opt_comma LNUMBER   { $$ = merge_raw_data_long($1, $3); }
-        | raw_elements opt_comma tSTRING   { $$ = merge_raw_data_str($1, $3); }
+        | raw_elements opt_comma tRAWDATA { $$ = merge_raw_data($1, $3); free($3->data); free($3); }
+        | raw_elements opt_comma tNUMBER  { $$ = merge_raw_data_int($1, $3); }
+        | raw_elements opt_comma tLNUMBER { $$ = merge_raw_data_long($1, $3); }
+        | raw_elements opt_comma tSTRING  { $$ = merge_raw_data_str($1, $3); }
+        ;
+
+/* File data or raw data */
+file_raw: filename      {
+                $$ = load_file($1);
+                $$->lvc.language = dup_language(currentlanguage);
+                }
+        | raw_data      { $$ = $1; }
         ;
 
@@ -1624 +1827 @@
         | expr          { $$ = new_int($1); }
         ;
+
+/* This rule moves ALL s/r conflicts on {bi,u}nary - and + to here */
 expr    : xpr   { $$ = ($1); }
         ;
@@ -1633 +1838 @@
         | xpr '*' xpr   { $$ = ($1) * ($3); }
         | xpr '/' xpr   { $$ = ($1) / ($3); }
+        | xpr '^' xpr   { $$ = ($1) ^ ($3); }
         | '~' xpr       { $$ = ~($2); }
-        | '-' xpr       { $$ = -($2); }         /* FIXME: shift/reduce conflict */
-/*      | '+' xpr       { $$ = $2; } */
+        | '-' xpr %prec pUPM    { $$ = -($2); }
+        | '+' xpr %prec pUPM    { $$ = $2; }
         | '(' xpr ')'   { $$ = $2; }
-        | any_num       { $$ = $1; want_rscname = 0; }
-        | NOT any_num   { $$ = ~($2); }
-        ;
-
-any_num : NUMBER        { $$ = $1; }
-        | LNUMBER       { $$ = $1; }
+        | any_num       { $$ = $1; }
+        | tNOT any_num  { $$ = ~($2); }
+        ;
+
+any_num : tNUMBER       { $$ = $1; }
+        | tLNUMBER      { $$ = $1; }
         ;
 
 %%
 /* Dialog specific functions */
-dialog_t *dialog_style(style_t * st, dialog_t *dlg)
+static dialog_t *dialog_style(style_t * st, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1671 +1877 @@
 }
 
-dialog_t *dialog_exstyle(style_t *st, dialog_t *dlg)
+static dialog_t *dialog_exstyle(style_t *st, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1695 +1901 @@
 }
 
-dialog_t *dialog_caption(string_t *s, dialog_t *dlg)
+static dialog_t *dialog_caption(string_t *s, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1704 +1910 @@
 }
 
-dialog_t *dialog_font(font_id_t *f, dialog_t *dlg)
+static dialog_t *dialog_font(font_id_t *f, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1713 +1919 @@
 }
 
-dialog_t *dialog_class(name_id_t *n, dialog_t *dlg)
+static dialog_t *dialog_class(name_id_t *n, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1722 +1928 @@
 }
 
-dialog_t *dialog_menu(name_id_t *m, dialog_t *dlg)
+static dialog_t *dialog_menu(name_id_t *m, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1731 +1937 @@
 }
 
-dialog_t *dialog_language(language_t *l, dialog_t *dlg)
+static dialog_t *dialog_language(language_t *l, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1740 +1946 @@
 }
 
-dialog_t *dialog_characteristics(characts_t *c, dialog_t *dlg)
+static dialog_t *dialog_characteristics(characts_t *c, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1749 +1955 @@
 }
 
-dialog_t *dialog_version(version_t *v, dialog_t *dlg)
+static dialog_t *dialog_version(version_t *v, dialog_t *dlg)
 {
         assert(dlg != NULL);
@@ -1759 +1965 @@
 
 /* Controls specific functions */
-control_t *ins_ctrl(int type, int special_style, control_t *ctrl, control_t *prev)
+static control_t *ins_ctrl(int type, int special_style, control_t *ctrl, control_t *prev)
 {
         /* Hm... this seems to be jammed in at all time... */
@@ -1883 +2089 @@
 }
 
-name_id_t *convert_ctlclass(name_id_t *cls)
-{
-        char *cc;
+static name_id_t *convert_ctlclass(name_id_t *cls)
+{
+        char *cc = NULL;
         int iclass;
 
@@ -1921 +2127 @@
 
 /* DialogEx specific functions */
-dialogex_t *dialogex_style(style_t * st, dialogex_t *dlg)
+static dialogex_t *dialogex_style(style_t * st, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -1945 +2151 @@
 }
 
-dialogex_t *dialogex_exstyle(style_t * st, dialogex_t *dlg)
+static dialogex_t *dialogex_exstyle(style_t * st, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -1969 +2175 @@
 }
 
-dialogex_t *dialogex_caption(string_t *s, dialogex_t *dlg)
+static dialogex_t *dialogex_caption(string_t *s, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -1978 +2184 @@
 }
 
-dialogex_t *dialogex_font(font_id_t *f, dialogex_t *dlg)
+static dialogex_t *dialogex_font(font_id_t *f, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -1987 +2193 @@
 }
 
-dialogex_t *dialogex_class(name_id_t *n, dialogex_t *dlg)
+static dialogex_t *dialogex_class(name_id_t *n, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -1996 +2202 @@
 }
 
-dialogex_t *dialogex_menu(name_id_t *m, dialogex_t *dlg)
+static dialogex_t *dialogex_menu(name_id_t *m, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -2005 +2211 @@
 }
 
-dialogex_t *dialogex_language(language_t *l, dialogex_t *dlg)
+static dialogex_t *dialogex_language(language_t *l, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -2014 +2220 @@
 }
 
-dialogex_t *dialogex_characteristics(characts_t *c, dialogex_t *dlg)
+static dialogex_t *dialogex_characteristics(characts_t *c, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -2023 +2229 @@
 }
 
-dialogex_t *dialogex_version(version_t *v, dialogex_t *dlg)
+static dialogex_t *dialogex_version(version_t *v, dialogex_t *dlg)
 {
         assert(dlg != NULL);
@@ -2033 +2239 @@
 
 /* Accelerator specific functions */
-event_t *add_event(int key, int id, int flags, event_t *prev)
+static event_t *add_event(int key, int id, int flags, event_t *prev)
 {
         event_t *ev = new_event();
@@ -2049 +2255 @@
 }
 
-event_t *add_string_event(string_t *key, int id, int flags, event_t *prev)
+static event_t *add_string_event(string_t *key, int id, int flags, event_t *prev)
 {
         int keycode = 0;
@@ -2057 +2263 @@
                 yyerror("Key code must be an ascii string");
 
-        if((flags & WRC_AF_VIRTKEY) && (!isupper(key->str.cstr[0]) && !isdigit(key->str.cstr[0])))
+        if((flags & WRC_AF_VIRTKEY) && (!isupper(key->str.cstr[0] & 0xff) && !isdigit(key->str.cstr[0] & 0xff)))
                 yyerror("VIRTKEY code is not equal to ascii value");
 
@@ -2082 +2288 @@
 
 /* MenuEx specific functions */
-itemex_opt_t *new_itemex_opt(int id, int type, int state, int helpid)
+static itemex_opt_t *new_itemex_opt(int id, int type, int state, int helpid)
 {
         itemex_opt_t *opt = (itemex_opt_t *)xmalloc(sizeof(itemex_opt_t));
@@ -2093 +2299 @@
 
 /* Raw data functions */
-raw_data_t *load_file(string_t *name)
+static raw_data_t *load_file(string_t *name)
 {
         FILE *fp;
@@ -2100 +2306 @@
                 yyerror("Filename must be ASCII string");
                 
-        fp = open_include(name->str.cstr, 1);
+        fp = open_include(name->str.cstr, 1, NULL);
         if(!fp)
                 yyerror("Cannot open file %s", name->str.cstr);
@@ -2110 +2316 @@
         fread(rd->data, rd->size, 1, fp);
         fclose(fp);
-        HEAPCHECK();
         return rd;
 }
 
-raw_data_t *int2raw_data(int i)
+static raw_data_t *int2raw_data(int i)
 {
         raw_data_t *rd;
@@ -2124 +2329 @@
         rd->size = sizeof(short);
         rd->data = (char *)xmalloc(rd->size);
-        *(short *)(rd->data) = (short)i;
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                rd->data[0] = HIBYTE(i);
+                rd->data[1] = LOBYTE(i);
+                break;
+
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                rd->data[1] = HIBYTE(i);
+                rd->data[0] = LOBYTE(i);
+                break;
+        }
         return rd;
 }
 
-raw_data_t *long2raw_data(int i)
+static raw_data_t *long2raw_data(int i)
 {
         raw_data_t *rd;
@@ -2134 +2356 @@
         rd->size = sizeof(int);
         rd->data = (char *)xmalloc(rd->size);
-        *(int *)(rd->data) = i;
+        switch(byteorder)
+        {
+#ifdef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_BIG:
+                rd->data[0] = HIBYTE(HIWORD(i));
+                rd->data[1] = LOBYTE(HIWORD(i));
+                rd->data[2] = HIBYTE(LOWORD(i));
+                rd->data[3] = LOBYTE(LOWORD(i));
+                break;
+
+#ifndef WORDS_BIGENDIAN
+        default:
+#endif
+        case WRC_BO_LITTLE:
+                rd->data[3] = HIBYTE(HIWORD(i));
+                rd->data[2] = LOBYTE(HIWORD(i));
+                rd->data[1] = HIBYTE(LOWORD(i));
+                rd->data[0] = LOBYTE(LOWORD(i));
+                break;
+        }
         return rd;
 }
 
-raw_data_t *str2raw_data(string_t *str)
+static raw_data_t *str2raw_data(string_t *str)
 {
         raw_data_t *rd;
@@ -2144 +2387 @@
         rd->size = str->size * (str->type == str_char ? 1 : 2);
         rd->data = (char *)xmalloc(rd->size);
-        memcpy(rd->data, str->str.cstr, rd->size);
+        if(str->type == str_char)
+                memcpy(rd->data, str->str.cstr, rd->size);
+        else if(str->type == str_unicode)
+        {
+                int i;
+                switch(byteorder)
+                {
+#ifdef WORDS_BIGENDIAN
+                default:
+#endif
+                case WRC_BO_BIG:
+                        for(i = 0; i < str->size; i++)
+                        {
+                                rd->data[2*i + 0] = HIBYTE((WORD)str->str.wstr[i]);
+                                rd->data[2*i + 1] = LOBYTE((WORD)str->str.wstr[i]);
+                        }
+                        break;
+#ifndef WORDS_BIGENDIAN
+                default:
+#endif
+                case WRC_BO_LITTLE:
+                        for(i = 0; i < str->size; i++)
+                        {
+                                rd->data[2*i + 1] = HIBYTE((WORD)str->str.wstr[i]);
+                                rd->data[2*i + 0] = LOBYTE((WORD)str->str.wstr[i]);
+                        }
+                        break;
+                }
+        }
+        else
+                internal_error(__FILE__, __LINE__, "Invalid stringtype");
         return rd;
 }
 
-raw_data_t *merge_raw_data(raw_data_t *r1, raw_data_t *r2)
+static raw_data_t *merge_raw_data(raw_data_t *r1, raw_data_t *r2)
 {
         r1->data = xrealloc(r1->data, r1->size + r2->size);
@@ -2156 +2429 @@
 }
 
-raw_data_t *merge_raw_data_int(raw_data_t *r1, int i)
+static raw_data_t *merge_raw_data_int(raw_data_t *r1, int i)
 {
         raw_data_t *t = int2raw_data(i);
@@ -2165 +2438 @@
 }
 
-raw_data_t *merge_raw_data_long(raw_data_t *r1, int i)
+static raw_data_t *merge_raw_data_long(raw_data_t *r1, int i)
 {
         raw_data_t *t = long2raw_data(i);
@@ -2174 +2447 @@
 }
 
-raw_data_t *merge_raw_data_str(raw_data_t *r1, string_t *str)
+static raw_data_t *merge_raw_data_str(raw_data_t *r1, string_t *str)
 {
         raw_data_t *t = str2raw_data(str);
@@ -2184 +2457 @@
 
 /* Function the go back in a list to get the head */
-menu_item_t *get_item_head(menu_item_t *p)
+static menu_item_t *get_item_head(menu_item_t *p)
 {
         if(!p)
@@ -2193 +2466 @@
 }
 
-menuex_item_t *get_itemex_head(menuex_item_t *p)
+static menuex_item_t *get_itemex_head(menuex_item_t *p)
 {
         if(!p)
@@ -2202 +2475 @@
 }
 
-resource_t *get_resource_head(resource_t *p)
+static resource_t *get_resource_head(resource_t *p)
 {
         if(!p)
@@ -2211 +2484 @@
 }
 
-ver_block_t *get_ver_block_head(ver_block_t *p)
+static ver_block_t *get_ver_block_head(ver_block_t *p)
 {
         if(!p)
@@ -2220 +2493 @@
 }
 
-ver_value_t *get_ver_value_head(ver_value_t *p)
+static ver_value_t *get_ver_value_head(ver_value_t *p)
 {
         if(!p)
@@ -2229 +2502 @@
 }
 
-control_t *get_control_head(control_t *p)
+static control_t *get_control_head(control_t *p)
 {
         if(!p)
@@ -2238 +2511 @@
 }
 
-event_t *get_event_head(event_t *p)
+static event_t *get_event_head(event_t *p)
 {
         if(!p)
@@ -2248 +2521 @@
 
 /* Find a stringtable with given language */
-stringtable_t *find_stringtable(lvc_t *lvc)
+static stringtable_t *find_stringtable(lvc_t *lvc)
 {
         stringtable_t *stt;
@@ -2260 +2533 @@
         {
                 if(stt->lvc.language->id == lvc->language->id
-                && stt->lvc.language->id == lvc->language->id)
+                && stt->lvc.language->sub == lvc->language->sub)
                 {
                         /* Found a table with the same language */
@@ -2284 +2557 @@
 /* qsort sorting function for string table entries */
 #define STE(p)  ((stt_entry_t *)(p))
-int sort_stt_entry(const void *e1, const void *e2)
+static int sort_stt_entry(const void *e1, const void *e2)
 {
         return STE(e1)->id - STE(e2)->id;
@@ -2290 +2563 @@
 #undef STE
 
-resource_t *build_stt_resources(stringtable_t *stthead)
+static resource_t *build_stt_resources(stringtable_t *stthead)
 {
         stringtable_t *stt;
@@ -2388 +2661 @@
 }
 
-/* Cursor and icon splitter functions */
-typedef struct {
-        language_t      lan;
-        int             id;
-} id_alloc_t;
-
-static int get_new_id(id_alloc_t **list, int *n, language_t *lan)
-{
-        int i;
-        assert(lan != NULL);
-        assert(list != NULL);
-        assert(n != NULL);
-
-        if(!*list)
-        {
-                *list = (id_alloc_t *)xmalloc(sizeof(id_alloc_t));
-                *n = 1;
-                (*list)[0].lan = *lan;
-                (*list)[0].id = 1;
-                return 1;
-        }
-
-        for(i = 0; i < *n; i++)
-        {
-                if((*list)[i].lan.id == lan->id && (*list)[i].lan.sub == lan->sub)
-                        return ++((*list)[i].id);
-        }
-
-        *list = (id_alloc_t *)xrealloc(*list, sizeof(id_alloc_t) * (*n+1));
-        (*list)[*n].lan = *lan;
-        (*list)[*n].id = 1;
-        *n += 1;
-        return 1;
-}
-
-int alloc_icon_id(language_t *lan)
-{
-        static id_alloc_t *idlist = NULL;
-        static int nid = 0;
-
-        return get_new_id(&idlist, &nid, lan);
-}
-
-int alloc_cursor_id(language_t *lan)
-{
-        static id_alloc_t *idlist = NULL;
-        static int nid = 0;
-
-        return get_new_id(&idlist, &nid, lan);
-}
-
-#define BPTR(base)      ((char *)(rd->data + (base)))
-#define WPTR(base)      ((WORD *)(rd->data + (base)))
-#define DPTR(base)      ((DWORD *)(rd->data + (base)))
-void split_icons(raw_data_t *rd, icon_group_t *icog, int *nico)
-{
-        int cnt;
-        int i;
-        icon_dir_entry_t *ide;
-        icon_t *ico;
-        icon_t *list = NULL;
-
-        /* FIXME: Distinguish between normal and animated icons (RIFF format) */
-        if(WPTR(0)[1] != 1)
-                yyerror("Icon resource data has invalid type id %d", WPTR(0)[1]);
-        cnt = WPTR(0)[2];
-        ide = (icon_dir_entry_t *)&(WPTR(0)[3]);
-        for(i = 0; i < cnt; i++)
-        {
-                ico = new_icon();
-                ico->id = alloc_icon_id(icog->lvc.language);
-                ico->lvc.language = dup_language(icog->lvc.language);
-                if(ide[i].offset > rd->size
-                || ide[i].offset + ide[i].ressize > rd->size)
-                        yyerror("Icon resource data corrupt");
-                ico->width = ide[i].width;
-                ico->height = ide[i].height;
-                ico->nclr = ide[i].nclr;
-                ico->planes = ide[i].planes;
-                ico->bits = ide[i].bits;
-                if(!ico->planes)
-                {
-                        /* Argh! They did not fill out the resdir structure */
-                        ico->planes = ((BITMAPINFOHEADER *)BPTR(ide[i].offset))->biPlanes;
-                }
-                if(!ico->bits)
-                {
-                        /* Argh! They did not fill out the resdir structure */
-                        ico->bits = ((BITMAPINFOHEADER *)BPTR(ide[i].offset))->biBitCount;
-                }
-                ico->data = new_raw_data();
-                copy_raw_data(ico->data, rd, ide[i].offset, ide[i].ressize);
-                if(!list)
-                {
-                        list = ico;
-                }
-                else
-                {
-                        ico->next = list;
-                        list->prev = ico;
-                        list = ico;
-                }
-        }
-        icog->iconlist = list;
-        *nico = cnt;
-}
-
-void split_cursors(raw_data_t *rd, cursor_group_t *curg, int *ncur)
-{
-        int cnt;
-        int i;
-        cursor_dir_entry_t *cde;
-        cursor_t *cur;
-        cursor_t *list = NULL;
-
-        /* FIXME: Distinguish between normal and animated cursors (RIFF format)*/
-        if(WPTR(0)[1] != 2)
-                yyerror("Cursor resource data has invalid type id %d", WPTR(0)[1]);
-        cnt = WPTR(0)[2];
-        cde = (cursor_dir_entry_t *)&(WPTR(0)[3]);
-        for(i = 0; i < cnt; i++)
-        {
-                cur = new_cursor();
-                cur->id = alloc_cursor_id(curg->lvc.language);
-                cur->lvc.language = dup_language(curg->lvc.language);
-                if(cde[i].offset > rd->size
-                || cde[i].offset + cde[i].ressize > rd->size)
-                        yyerror("Cursor resource data corrupt");
-                cur->width = cde[i].width;
-                cur->height = cde[i].height;
-                cur->nclr = cde[i].nclr;
-                /* The next two are to support color cursors */
-                cur->planes = ((BITMAPINFOHEADER *)BPTR(cde[i].offset))->biPlanes;
-                cur->bits = ((BITMAPINFOHEADER *)BPTR(cde[i].offset))->biBitCount;
-                if(!win32 && (cur->planes != 1 || cur->bits != 1))
-                        yywarning("Win16 cursor contains colors");
-                cur->xhot = cde[i].xhot;
-                cur->yhot = cde[i].yhot;
-                cur->data = new_raw_data();
-                copy_raw_data(cur->data, rd, cde[i].offset, cde[i].ressize);
-                if(!list)
-                {
-                        list = cur;
-                }
-                else
-                {
-                        cur->next = list;
-                        list->prev = cur;
-                        list = cur;
-                }
-        }
-        curg->cursorlist = list;
-        *ncur = cnt;
-}
-
-#undef  BPTR
-#undef  WPTR
-#undef  DPTR
-
-
-toolbar_item_t *ins_tlbr_button(toolbar_item_t *prev, toolbar_item_t *idrec)
+
+static toolbar_item_t *ins_tlbr_button(toolbar_item_t *prev, toolbar_item_t *idrec)
 {
         idrec->prev = prev;
@@ -2557 +2671 @@
 }
 
-toolbar_item_t *get_tlbr_buttons_head(toolbar_item_t *p, int *nitems)
+static toolbar_item_t *get_tlbr_buttons_head(toolbar_item_t *p, int *nitems)
 {
         if(!p)
@@ -2576 +2690 @@
 }
 
+static string_t *make_filename(string_t *str)
+{
+        char *cptr;
+
+        if(str->type != str_char)
+                yyerror("Cannot handle UNICODE filenames");
+
+        /* Remove escaped backslash and convert to forward */
+        cptr = str->str.cstr;
+        for(cptr = str->str.cstr; (cptr = strchr(cptr, '\\')) != NULL; cptr++)
+        {
+                if(cptr[1] == '\\')
+                {
+                        memmove(cptr, cptr+1, strlen(cptr));
+                        str->size--;
+                }
+                *cptr = '/';
+        }
+
+        /* Convert to lower case. Seems to be reasonable to do */
+        for(cptr = str->str.cstr; !leave_case && *cptr; cptr++)
+        {
+                *cptr = tolower(*cptr);
+        }
+        return str;
+}
+
+/*
+ * Process all resources to extract fonts and build
+ * a fontdir resource.
+ *
+ * Note: MS' resource compiler (build 1472) does not
+ * handle font resources with different languages.
+ * The fontdir is generated in the last active language
+ * and font identifiers must be unique across the entire
+ * source.
+ * This is not logical considering the localization
+ * constraints of all other resource types. MS has,
+ * most probably, never testet localized fonts. However,
+ * using fontresources is rare, so it might not occur
+ * in normal applications.
+ * Wine does require better localization because a lot
+ * of languages are coded into the same executable.
+ * Therefore, I will generate fontdirs for *each*
+ * localized set of fonts.
+ */
+static resource_t *build_fontdir(resource_t **fnt, int nfnt)
+{
+        static int once = 0;
+        if(!once)
+        {
+                warning("Need to parse fonts, not yet implemented (fnt: %p, nfnt: %d)", fnt, nfnt);
+                once++;
+        }
+        return NULL;
+}
+
+static resource_t *build_fontdirs(resource_t *tail)
+{
+        resource_t *rsc;
+        resource_t *lst = NULL;
+        resource_t **fnt = NULL;        /* List of all fonts */
+        int nfnt = 0;
+        resource_t **fnd = NULL;        /* List of all fontdirs */
+        int nfnd = 0;
+        resource_t **lanfnt = NULL;
+        int nlanfnt = 0;
+        int i;
+        name_id_t nid;
+        string_t str;
+        int fntleft;
+
+        nid.type = name_str;
+        nid.name.s_name = &str;
+        str.type = str_char;
+        str.str.cstr = "FONTDIR";
+        str.size = 7;
+
+        /* Extract all fonts and fontdirs */
+        for(rsc = tail; rsc; rsc = rsc->prev)
+        {
+                if(rsc->type == res_fnt)
+                {
+                        nfnt++;
+                        fnt = xrealloc(fnt, nfnt * sizeof(*fnt));
+                        fnt[nfnt-1] = rsc;
+                }
+                else if(rsc->type == res_fntdir)
+                {
+                        nfnd++;
+                        fnd = xrealloc(fnd, nfnd * sizeof(*fnd));
+                        fnd[nfnd-1] = rsc;
+                }
+        }
+
+        /* Verify the name of the present fontdirs */
+        for(i = 0; i < nfnd; i++)
+        {
+                if(compare_name_id(&nid, fnd[i]->name))
+                {
+                        warning("User supplied FONTDIR entry has an invalid name '%s', ignored",
+                                get_nameid_str(fnd[i]->name));
+                        fnd[i] = NULL;
+                }
+        }
+
+        /* Sanity check */
+        if(nfnt == 0)
+        {
+                if(nfnd != 0)
+                        warning("Found %d FONTDIR entries without any fonts present", nfnd);
+                goto clean;
+        }
+
+        /* Copy space */
+        lanfnt = xmalloc(nfnt * sizeof(*lanfnt));
+
+        /* Get all fonts covered by fontdirs */
+        for(i = 0; i < nfnd; i++)
+        {
+                int j;
+                WORD cnt;
+                int isswapped = 0;
+
+                if(!fnd[i])
+                        continue;
+                for(j = 0; j < nfnt; j++)
+                {
+                        if(!fnt[j])
+                                continue;
+                        if(fnt[j]->lan->id == fnd[i]->lan->id && fnt[j]->lan->sub == fnd[i]->lan->sub)
+                        {
+                                lanfnt[nlanfnt] = fnt[j];
+                                nlanfnt++;
+                                fnt[j] = NULL;
+                        }
+                }
+
+                cnt = *(WORD *)fnd[i]->res.fnd->data->data;
+                if(nlanfnt == cnt)
+                        isswapped = 0;
+                else if(nlanfnt == BYTESWAP_WORD(cnt))
+                        isswapped = 1;
+                else
+                        error("FONTDIR for language %d,%d has wrong count (%d, expected %d)",
+                                fnd[i]->lan->id, fnd[i]->lan->sub, cnt, nlanfnt);
+#ifdef WORDS_BIGENDIAN
+                if((byteorder == WRC_BO_LITTLE && !isswapped) || (byteorder != WRC_BO_LITTLE && isswapped))
+#else
+                if((byteorder == WRC_BO_BIG && !isswapped) || (byteorder != WRC_BO_BIG && isswapped))
+#endif
+                {
+                        internal_error(__FILE__, __LINE__, "User supplied FONTDIR needs byteswapping");
+                }
+        }
+
+        /* We now have fonts left where we need to make a fontdir resource */
+        for(i = fntleft = 0; i < nfnt; i++)
+        {
+                if(fnt[i])
+                        fntleft++;
+        }
+        while(fntleft)
+        {
+                /* Get fonts of same language in lanfnt[] */
+                for(i = nlanfnt = 0; i < nfnt; i++)
+                {
+                        if(fnt[i])
+                        {
+                                if(!nlanfnt)
+                                {
+                        addlanfnt:
+                                        lanfnt[nlanfnt] = fnt[i];
+                                        nlanfnt++;
+                                        fnt[i] = NULL;
+                                        fntleft--;
+                                }
+                                else if(fnt[i]->lan->id == lanfnt[0]->lan->id && fnt[i]->lan->sub == lanfnt[0]->lan->sub)
+                                        goto addlanfnt;
+                        }
+                }
+                /* and build a fontdir */
+                rsc = build_fontdir(lanfnt, nlanfnt);
+                if(rsc)
+                {
+                        if(lst)
+                        {
+                                lst->next = rsc;
+                                rsc->prev = lst;
+                        }
+                        lst = rsc;
+                }
+        }
+
+        free(lanfnt);
+clean:
+        if(fnt)
+                free(fnt);
+        if(fnd)
+                free(fnd);
+        return lst;
+}
+
+/*
+ * This gets invoked to determine whether the next resource
+ * is to be of a standard-type (e.g. bitmaps etc.), or should
+ * be a user-type resource. This function is required because
+ * there is the _possibility_ of a lookahead token in the
+ * parser, which is generated from the "expr" state in the
+ * "nameid" parsing.
+ *
+ * The general resource format is:
+ * <identifier> <type> <flags> <resourcebody>
+ *
+ * The <identifier> can either be tIDENT or "expr". The latter
+ * will always generate a lookahead, which is the <type> of the
+ * resource to parse. Otherwise, we need to get a new token from
+ * the scanner to determine the next step.
+ *
+ * The problem arrises when <type> is numerical. This case should
+ * map onto default resource-types and be parsed as such instead
+ * of being mapped onto user-type resources.
+ *
+ * The trick lies in the fact that yacc (bison) doesn't care about
+ * intermediate changes of the lookahead while reducing a rule. We
+ * simply replace the lookahead with a token that will result in
+ * a shift to the appropriate rule for the specific resource-type.
+ */
+static int rsrcid_to_token(int lookahead)
+{
+        int token;
+        char *type = "?";
+
+        /* Get a token if we don't have one yet */
+        if(lookahead == YYEMPTY)
+                lookahead = YYLEX;
+
+        /* Only numbers are possibly interesting */
+        switch(lookahead)
+        {
+        case tNUMBER:
+        case tLNUMBER:
+                break;
+        default:
+                return lookahead;
+        }
+
+        token = lookahead;
+
+        switch(yylval.num)
+        {
+        case WRC_RT_CURSOR:
+                type = "CURSOR";
+                token = tCURSOR;
+                break;
+        case WRC_RT_ICON:
+                type = "ICON";
+                token = tICON;
+                break;
+        case WRC_RT_BITMAP:
+                type = "BITMAP";
+                token = tBITMAP;
+                break;
+        case WRC_RT_FONT:
+                type = "FONT";
+                token = tFONT;
+                break;
+        case WRC_RT_FONTDIR:
+                type = "FONTDIR";
+                token = tFONTDIR;
+                break;
+        case WRC_RT_RCDATA:
+                type = "RCDATA";
+                token = tRCDATA;
+                break;
+        case WRC_RT_MESSAGETABLE:
+                type = "MESSAGETABLE";
+                token = tMESSAGETABLE;
+                break;
+        case WRC_RT_DLGINIT:
+                type = "DLGINIT";
+                token = tDLGINIT;
+                break;
+        case WRC_RT_ACCELERATOR:
+                type = "ACCELERATOR";
+                token = tACCELERATORS;
+                break;
+        case WRC_RT_MENU:
+                type = "MENU";
+                token = tMENU;
+                break;
+        case WRC_RT_DIALOG:
+                type = "DIALOG";
+                token = tDIALOG;
+                break;
+        case WRC_RT_VERSION:
+                type = "VERSION";
+                token = tVERSIONINFO;
+                break;
+        case WRC_RT_TOOLBAR:
+                type = "TOOLBAR";
+                token = tTOOLBAR;
+                break;
+
+        case WRC_RT_STRING:
+                type = "STRINGTABLE";
+                break;
+
+        case WRC_RT_ANICURSOR:
+        case WRC_RT_ANIICON:
+        case WRC_RT_GROUP_CURSOR:
+        case WRC_RT_GROUP_ICON:
+                yywarning("Usertype uses reserved type-ID %d, which is auto-generated", yylval.num);
+                return lookahead;
+
+        case WRC_RT_DLGINCLUDE:
+        case WRC_RT_PLUGPLAY:
+        case WRC_RT_VXD:
+        case WRC_RT_HTML:
+                yywarning("Usertype uses reserved type-ID %d, which is not supported by wrc", yylval.num);
+        default:
+                return lookahead;
+        }
+
+        if(remap)
+                return token;
+        else
+                yywarning("Usertype uses reserved type-ID %d, which is used by %s", yylval.num, type);
+        return lookahead;
+}
+

trunk/tools/wrc/preproc.c

@@ -9 +9 @@
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 
 #include "wrc.h"
 #include "utils.h"
 #include "preproc.h"
-#include "parser.h"
 
 
 extern void set_pp_ignore(int); /* From parser.l */
 
-static char *current_define;
-
 #define HASHKEY         2039
-static struct pp_entry *pp_defines[HASHKEY];
+static pp_entry_t *pp_defines[HASHKEY];
 
 #define MAXIFSTACK      64
-static struct if_state ifstack[MAXIFSTACK];
-static int ifstackidx = 0;
+static if_state_t if_stack[MAXIFSTACK];
+static int if_stack_idx = 0;
 
 #if 0
+void pp_status(void) __attribute__((destructor));
 void pp_status(void)
 {
@@ -33 +32 @@
         int sum;
         int total = 0;
-        struct pp_entry *ppp;
-
-        printf("Defines statistics:\n");
+        pp_entry_t *ppp;
+
+        fprintf(stderr, "Defines statistics:\n");
         for(i = 0; i < HASHKEY; i++)
         {
@@ -42 +41 @@
                         sum++;
                 total += sum;
-                printf("%4d, %3d\n", i, sum);
-        }
-        printf("Total defines: %d\n", total);
-}
-#pragma exit pp_status
+                fprintf(stderr, "%4d, %3d\n", i, sum);
+        }
+        fprintf(stderr, "Total defines: %d\n", total);
+}
 #endif
 
 /* Don't comment on the hash, its primitive but functional... */
-int pp_hash(char *str)
+int pphash(char *str)
 {
         int sum = 0;
@@ -58 +56 @@
 }
 
-struct pp_entry *pp_lookup(char *ident)
-{
-        int index = pp_hash(ident);
-        struct pp_entry *ppp;
-        for(ppp = pp_defines[index]; ppp; ppp = ppp->next)
+pp_entry_t *pplookup(char *ident)
+{
+        int idx = pphash(ident);
+        pp_entry_t *ppp;
+
+        for(ppp = pp_defines[idx]; ppp; ppp = ppp->next)
         {
                 if(!strcmp(ident, ppp->ident))
@@ -70 +69 @@
 }
 
-void set_define(char *name)
-{
-        current_define = xstrdup(name);
-}
-
 void del_define(char *name)
 {
-        int index;
-        struct pp_entry *ppp;
-
-        if((ppp = pp_lookup(name)) == NULL)
+        int idx;
+        pp_entry_t *ppp;
+
+        if((ppp = pplookup(name)) == NULL)
         {
                 if(pedantic)
@@ -87 +81 @@
         }
 
-        index = pp_hash(name);
-        if(pp_defines[index] == ppp)
-        {
-                pp_defines[index] = ppp->next;
-                if(pp_defines[index])
-                        pp_defines[index]->prev = NULL;
+        if(ppp->iep)
+        {
+                if(debuglevel & DEBUGLEVEL_PPMSG)
+                        fprintf(stderr, "del_define: %s:%d: includelogic removed, include_ppp='%s', file=%s\n", input_name, line_number, name, ppp->iep->filename);
+                if(ppp->iep == includelogiclist)
+                {
+                        includelogiclist = ppp->iep->next;
+                        if(includelogiclist)
+                                includelogiclist->prev = NULL;
+                }
+                else
+                {
+                        ppp->iep->prev->next = ppp->iep->next;
+                        if(ppp->iep->next)
+                                ppp->iep->next->prev = ppp->iep->prev;
+                }
+                free(ppp->iep->filename);
+                free(ppp->iep);
+        }
+
+        idx = pphash(name);
+        if(pp_defines[idx] == ppp)
+        {
+                pp_defines[idx] = ppp->next;
+                if(pp_defines[idx])
+                        pp_defines[idx]->prev = NULL;
         }
         else
@@ -100 +114 @@
                         ppp->next->prev = ppp->prev;
         }
+
         free(ppp);
-}
-
-void add_define(char *text)
+
+        if(debuglevel & DEBUGLEVEL_PPMSG)
+                printf("Deleted (%s, %d) <%s>\n", input_name, line_number, name);
+}
+
+pp_entry_t *add_define(char *def, char *text)
 {
         int len;
         char *cptr;
-        int index = pp_hash(current_define);
-        struct pp_entry *ppp;
-        if(pp_lookup(current_define) != NULL)
+        int idx = pphash(def);
+        pp_entry_t *ppp;
+
+        if((ppp = pplookup(def)) != NULL)
         {
                 if(pedantic)
-                        yywarning("Redefinition of %s", current_define);
-                del_define(current_define);
-        }
-        ppp = (struct pp_entry *)xmalloc(sizeof(struct pp_entry));
-        ppp->ident = current_define;
-        ppp->subst = xstrdup(text);
-        ppp->next = pp_defines[index];
-        pp_defines[index] = ppp;
+                        yywarning("Redefinition of %s\n\tPrevious definition: %s:%d", def, ppp->filename, ppp->linenumber);
+                del_define(def);
+        }
+        ppp = (pp_entry_t *)xmalloc(sizeof(pp_entry_t));
+        ppp->ident = def;
+        ppp->type = def_define;
+        ppp->subst.text = text;
+        ppp->filename = input_name ? xstrdup(input_name) : "<internal or cmdline>";
+        ppp->linenumber = input_name ? line_number : 0;
+        ppp->next = pp_defines[idx];
+        pp_defines[idx] = ppp;
         if(ppp->next)
                 ppp->next->prev = ppp;
-        /* Strip trailing white space from subst text */
-        len = strlen(ppp->subst);
-        while(len && strchr(" \t\r\n", ppp->subst[len-1]))
-        {
-                ppp->subst[--len] = '\0';
-        }
-        /* Strip leading white space from subst text */
-        for(cptr = ppp->subst; *cptr && strchr(" \t\r", *cptr); cptr++)
+        if(text)
+        {
+                /* Strip trailing white space from subst text */
+                len = strlen(text);
+                while(len && strchr(" \t\r\n", text[len-1]))
+                {
+                        text[--len] = '\0';
+                }
+                /* Strip leading white space from subst text */
+                for(cptr = text; *cptr && strchr(" \t\r", *cptr); cptr++)
                 ;
-        if(ppp->subst != cptr)
-                memmove(ppp->subst, cptr, strlen(cptr)+1);
-        if(yydebug)
-                printf("Added (%s, %d) <%s> to <%s>\n", input_name, line_number, ppp->ident, ppp->subst);
-}
-
-void add_cmdline_define(char *set)
+                if(text != cptr)
+                        memmove(text, cptr, strlen(cptr)+1);
+        }
+        if(debuglevel & DEBUGLEVEL_PPMSG)
+                printf("Added define (%s, %d) <%s> to <%s>\n", input_name, line_number, ppp->ident, text ? text : "(null)");
+
+        return ppp;
+}
+
+pp_entry_t *add_cmdline_define(char *set)
 {
         char *cpy = xstrdup(set);       /* Because gcc passes a R/O string */
@@ -143 +170 @@
         if(cptr)
                 *cptr = '\0';
-        set_define(cpy);
-        add_define(cptr ? cptr+1 : "");
-        free(cpy);
-}
-
-/*kso added test for __SEMICOLON__ since __WIN32OS2__ isn't defined! */
-#if defined(__SEMICOLON__) || defined(_Windows) || defined(__MSDOS__) || defined(__WIN32OS2__)
+        return add_define(cpy, xstrdup(cptr ? cptr+1 : ""));
+}
+
+pp_entry_t *add_special_define(char *id)
+{
+        pp_entry_t *ppp = add_define(xstrdup(id), xstrdup(""));
+        ppp->type = def_special;
+        return ppp;
+}
+
+pp_entry_t *add_macro(char *id, marg_t *args[], int nargs, mtext_t *exp)
+{
+        int idx = pphash(id);
+        pp_entry_t *ppp;
+
+        if((ppp = pplookup(id)) != NULL)
+        {
+                if(pedantic)
+                        yywarning("Redefinition of %s\n\tPrevious definition: %s:%d", id, ppp->filename, ppp->linenumber);
+                del_define(id);
+        }
+        ppp = (pp_entry_t *)xmalloc(sizeof(pp_entry_t));
+        ppp->ident      = id;
+        ppp->type       = def_macro;
+        ppp->margs      = args;
+        ppp->nargs      = nargs;
+        ppp->subst.mtext= exp;
+        ppp->filename = input_name ? xstrdup(input_name) : "<internal or cmdline>";
+        ppp->linenumber = input_name ? line_number : 0;
+        ppp->next       = pp_defines[idx];
+        pp_defines[idx] = ppp;
+        if(ppp->next)
+                ppp->next->prev = ppp;
+
+        if(debuglevel & DEBUGLEVEL_PPMSG)
+        {
+                fprintf(stderr, "Added macro (%s, %d) <%s(%d)> to <", input_name, line_number, ppp->ident, nargs);
+                for(; exp; exp = exp->next)
+                {
+                        switch(exp->type)
+                        {
+                        case exp_text:
+                                fprintf(stderr, " \"%s\" ", exp->subst.text);
+                                break;
+                        case exp_stringize:
+                                fprintf(stderr, " #(%d) ", exp->subst.argidx);
+                                break;
+                        case exp_concat:
+                                fprintf(stderr, "##");
+                                break;
+                        case exp_subst:
+                                fprintf(stderr, " <%d> ", exp->subst.argidx);
+                                break;
+                        }
+                }
+                fprintf(stderr, ">\n");
+        }
+        return ppp;
+}
+
+
+/*
+ *-------------------------------------------------------------------------
+ * Include management
+ *-------------------------------------------------------------------------
+ */
+#if defined(_Windows) || defined(__MSDOS__)
 #define INCLUDESEPARATOR        ";"
-#warning "Using ; as include separator"
 #else
-#warning "Using : as include separator"
 #define INCLUDESEPARATOR        ":"
 #endif
@@ -192 +277 @@
 }
 
-FILE *open_include(const char *name, int search)
+FILE *open_include(const char *name, int search, char **newpath)
 {
         char *cpy = xstrdup(name);
@@ -212 +297 @@
         {
                 /* Search current dir and then -I path */
-                fp = fopen(name, "rt");
+                fp = fopen(cpy, "rb");
                 if(fp)
                 {
-                        if(yydebug)
+                        if(debuglevel & DEBUGLEVEL_PPMSG)
                                 printf("Going to include <%s>\n", name);
-                        free(cpy);
+                        if(newpath)
+                                *newpath = cpy;
+                        else
+                                free(cpy);
                         return fp;
                 }
@@ -229 +317 @@
                 strcat(path, "/");
                 strcat(path, cpy);
-                fp = fopen(path, "rt");
-                if(fp && yydebug)
+                fp = fopen(path, "rb");
+                if(fp && (debuglevel & DEBUGLEVEL_PPMSG))
                         printf("Going to include <%s>\n", path);
-                free(path);
                 if(fp)
                 {
+                        if(newpath)
+                                *newpath = path;
+                        else
+                                free(path);
                         free(cpy);
                         return fp;
                 }
-
+                free(path);
         }
         free(cpy);
+        if(newpath)
+                *newpath = NULL;
         return NULL;
 }
 
-void push_if(int truecase, int wastrue, int nevertrue)
-{
-        if(ifstackidx >= MAXIFSTACK-1)
-                internal_error(__FILE__, __LINE__, "#if stack overflow");
-        ifstack[ifstackidx].current = truecase && !wastrue;
-        ifstack[ifstackidx].hasbeentrue = wastrue;
-        ifstack[ifstackidx].nevertrue = nevertrue;
-        if(nevertrue || !(truecase && !wastrue))
-                set_pp_ignore(1);
-        if(yydebug)
-                printf("push_if: %d %d %d (%d %d %d)\n",
-                        truecase,
-                        wastrue,
-                        nevertrue,
-                        ifstack[ifstackidx].current,
-                        ifstack[ifstackidx].hasbeentrue,
-                        ifstack[ifstackidx].nevertrue);
-        ifstackidx++;
-}
-
-int pop_if(void)
-{
-        if(ifstackidx <= 0)
-                yyerror("#endif without #if|#ifdef|#ifndef (#if stack underflow)");
-        ifstackidx--;
-        if(yydebug)
-                printf("pop_if: %d %d %d\n",
-                        ifstack[ifstackidx].current,
-                        ifstack[ifstackidx].hasbeentrue,
-                        ifstack[ifstackidx].nevertrue);
-        if(ifstack[ifstackidx].nevertrue || !ifstack[ifstackidx].current)
-                set_pp_ignore(0);
-        return ifstack[ifstackidx].hasbeentrue || ifstack[ifstackidx].current;
-}
-
-int isnevertrue_if(void)
-{
-        return ifstackidx > 0 && ifstack[ifstackidx-1].nevertrue;
-}
-
+/*
+ *-------------------------------------------------------------------------
+ * #if, #ifdef, #ifndef, #else, #elif and #endif state management
+ *
+ * #if state transitions are made on basis of the current TOS and the next
+ * required state. The state transitions are required to housekeep because
+ * #if:s can be nested. The ignore case is activated to prevent output from
+ * within a false clause.
+ * Some special cases come from the fact that the #elif cases are not
+ * binary, but three-state. The problem is that all other elif-cases must
+ * be false when one true one has been found. A second problem is that the
+ * #else clause is a final clause. No extra #else:s may follow.
+ *
+ * The states mean:
+ * if_true      Process input to output
+ * if_false     Process input but no output
+ * if_ignore    Process input but no output
+ * if_elif      Process input but no output
+ * if_elsefalse Process input but no output
+ * if_elsettrue Process input to output
+ *
+ * The possible state-sequences are [state(stack depth)] (rest can be deduced):
+ *      TOS             #if 1           #else                   #endif
+ *      if_true(n)      if_true(n+1)    if_elsefalse(n+1)
+ *      if_false(n)     if_ignore(n+1)  if_ignore(n+1)
+ *      if_elsetrue(n)  if_true(n+1)    if_elsefalse(n+1)
+ *      if_elsefalse(n) if_ignore(n+1)  if_ignore(n+1)
+ *      if_elif(n)      if_ignore(n+1)  if_ignore(n+1)
+ *      if_ignore(n)    if_ignore(n+1)  if_ignore(n+1)
+ *
+ *      TOS             #if 1           #elif 0         #else           #endif
+ *      if_true(n)      if_true(n+1)    if_elif(n+1)    if_elif(n+1)
+ *      if_false(n)     if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_elsetrue(n)  if_true(n+1)    if_elif(n+1)    if_elif(n+1)
+ *      if_elsefalse(n) if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_elif(n)      if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_ignore(n)    if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *
+ *      TOS             #if 0           #elif 1         #else           #endif
+ *      if_true(n)      if_false(n+1)   if_true(n+1)    if_elsefalse(n+1)
+ *      if_false(n)     if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_elsetrue(n)  if_false(n+1)   if_true(n+1)    if_elsefalse(n+1)
+ *      if_elsefalse(n) if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_elif(n)      if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *      if_ignore(n)    if_ignore(n+1)  if_ignore(n+1)  if_ignore(n+1)
+ *
+ *-------------------------------------------------------------------------
+ */
+static char *if_state_str[] = {
+        "if_false",
+        "if_true",
+        "if_elif",
+        "if_elsefalse",
+        "if_elsetrue",
+        "if_ignore"
+};
+
+void push_if(if_state_t s)
+{
+        if(if_stack_idx >= MAXIFSTACK)
+                internal_error(__FILE__, __LINE__, "#if-stack overflow; #{if,ifdef,ifndef} nested too deeply (> %d)", MAXIFSTACK);
+
+        if(debuglevel & DEBUGLEVEL_PPLEX)
+                fprintf(stderr, "Push if %s:%d: %s(%d) -> %s(%d)\n", input_name, line_number, if_state_str[if_state()], if_stack_idx, if_state_str[s], if_stack_idx+1);
+
+        if_stack[if_stack_idx++] = s;
+
+        switch(s)
+        {
+        case if_true:
+        case if_elsetrue:
+                break;
+        case if_false:
+        case if_elsefalse:
+        case if_elif:
+        case if_ignore:
+                push_ignore_state();
+                break;
+        }
+}
+
+if_state_t pop_if(void)
+{
+        if(if_stack_idx <= 0)
+                yyerror("#{endif,else,elif} without #{if,ifdef,ifndef} (#if-stack underflow)");
+
+        switch(if_state())
+        {
+        case if_true:
+        case if_elsetrue:
+                break;
+        case if_false:
+        case if_elsefalse:
+        case if_elif:
+        case if_ignore:
+                pop_ignore_state();
+                break;
+        }
+
+        if(debuglevel & DEBUGLEVEL_PPLEX)
+                fprintf(stderr, "Pop if %s:%d: %s(%d) -> %s(%d)\n",
+                                input_name,
+                                line_number,
+                                if_state_str[if_state()],
+                                if_stack_idx,
+                                if_state_str[if_stack[if_stack_idx <= 1 ? if_true : if_stack_idx-2]],
+                                if_stack_idx-1);
+
+        return if_stack[--if_stack_idx];
+}
+
+if_state_t if_state(void)
+{
+        if(!if_stack_idx)
+                return if_true;
+        else
+                return if_stack[if_stack_idx-1];
+}
+
+
+void next_if_state(int i)
+{
+        switch(if_state())
+        {
+        case if_true:
+        case if_elsetrue:
+                push_if(i ? if_true : if_false);
+                break;
+        case if_false:
+        case if_elsefalse:
+        case if_elif:
+        case if_ignore:
+                push_if(if_ignore);
+                break;
+        default:
+                internal_error(__FILE__, __LINE__, "Invalid if_state (%d) in #{if,ifdef,ifndef} directive", (int)if_state());
+        }
+}
+
+int get_if_depth(void)
+{
+        return if_stack_idx;
+}
+

trunk/tools/wrc/preproc.h

@@ -7 +7 @@
 #define __WRC_PREPROC_H
 
-struct pp_entry {
+struct pp_entry;        /* forward */
+/*
+ * Include logic
+ * A stack of files which are already included and
+ * are protected in the #ifndef/#endif way.
+ */
+typedef struct includelogicentry {
+        struct includelogicentry *next;
+        struct includelogicentry *prev;
+        struct pp_entry *ppp;           /* The define which protects the file */
+        char            *filename;      /* The filename of the include */
+} includelogicentry_t;
+
+/*
+ * The arguments of a macrodefinition
+ */
+typedef enum {
+        arg_single,
+        arg_list
+} def_arg_t;
+
+typedef struct marg {
+        def_arg_t       type;   /* Normal or ... argument */
+        char            *arg;   /* The textual argument */
+        int             nnl;    /* Number of newlines in the text to subst */
+} marg_t;
+
+/*
+ * The expansiontext of a macro
+ */
+typedef enum {
+        exp_text,       /* Simple text substitution */
+        exp_concat,     /* Concat (##) operator requested */
+        exp_stringize,  /* Stringize (#) operator requested */
+        exp_subst       /* Substitute argument */
+} def_exp_t;
+
+typedef struct mtext {
+        struct mtext    *next;
+        struct mtext    *prev;
+        def_exp_t       type;
+        union {
+                char    *text;
+                int     argidx;         /* For exp_subst and exp_stringize reference */
+        } subst;
+} mtext_t;
+
+/*
+ * The define descriptor
+ */
+typedef enum {
+        def_none,       /* Not-a-define; used as return value */
+        def_define,     /* Simple defines */
+        def_macro,      /* Macro defines */
+        def_special     /* Special expansions like __LINE__ and __FILE__ */
+} def_type_t;
+
+typedef struct pp_entry {
         struct pp_entry *next;
         struct pp_entry *prev;
-        char    *ident;
-        char    *subst;
-        int     expanding;
-};
+        def_type_t      type;           /* Define or macro */
+        char            *ident;         /* The key */
+        marg_t          **margs;        /* Macro arguments array or NULL if none */
+        int             nargs;
+        union {
+                mtext_t *mtext;         /* The substitution sequence or NULL if none */
+                char    *text;
+        } subst;
+        int             expanding;      /* Set when feeding substitution into the input */
+        char            *filename;      /* Filename where it was defined */
+        int             linenumber;     /* Linenumber where it was defined */
+        includelogicentry_t *iep;       /* Points to the include it protects */
+} pp_entry_t;
 
-struct if_state {
-        int     current;
-        int     hasbeentrue;
-        int     nevertrue;
-};
 
-struct pp_entry *pp_lookup(char *ident);
-void set_define(char *name);
+/*
+ * If logic
+ */
+#define MAXIFSTACK      64      /* If this isn't enough you should alter the source... */
+
+typedef enum {
+        if_false,
+        if_true,
+        if_elif,
+        if_elsefalse,
+        if_elsetrue,
+        if_ignore
+} if_state_t;
+
+/*
+ * I assume that 'long long' exists in the compiler when it has a size
+ * of 8 or bigger. If not, then we revert to a simple 'long' for now.
+ * This should prevent most unexpected things with other compilers than
+ * gcc and egcs for now.
+ * In the future it should be possible to use another way, like a
+ * structure, so that we can emulate the MS compiler.
+ */
+#if defined(SIZEOF_LONGLONG) && SIZEOF_LONGLONG >= 8
+typedef long long wrc_sll_t;
+typedef unsigned long long wrc_ull_t;
+#else
+typedef long wrc_sll_t;
+typedef unsigned long wrc_ull_t;
+#endif
+
+#define SIZE_CHAR       1
+#define SIZE_SHORT      2
+#define SIZE_INT        3
+#define SIZE_LONG       4
+#define SIZE_LONGLONG   5
+#define SIZE_MASK       0x00ff
+#define FLAG_SIGNED     0x0100
+
+typedef enum {
+#if 0
+        cv_schar  = SIZE_CHAR + FLAG_SIGNED,
+        cv_uchar  = SIZE_CHAR,
+        cv_sshort = SIZE_SHORT + FLAG_SIGNED,
+        cv_ushort = SIZE_SHORT,
+#endif
+        cv_sint   = SIZE_INT + FLAG_SIGNED,
+        cv_uint   = SIZE_INT,
+        cv_slong  = SIZE_LONG + FLAG_SIGNED,
+        cv_ulong  = SIZE_LONG,
+        cv_sll    = SIZE_LONGLONG + FLAG_SIGNED,
+        cv_ull    = SIZE_LONGLONG
+} ctype_t;
+
+typedef struct cval {
+        ctype_t type;
+        union {
+#if 0
+                signed char     sc;     /* Explicitely signed because compilers are stupid */
+                unsigned char   uc;
+                short           ss;
+                unsigned short  us;
+#endif
+                int             si;
+                unsigned int    ui;
+                long            sl;
+                unsigned long   ul;
+                wrc_sll_t       sll;
+                wrc_ull_t       ull;
+        } val;
+} cval_t;
+
+
+
+pp_entry_t *pplookup(char *ident);
+pp_entry_t *add_define(char *def, char *text);
+pp_entry_t *add_cmdline_define(char *set);
+pp_entry_t *add_special_define(char *id);
+pp_entry_t *add_macro(char *ident, marg_t *args[], int nargs, mtext_t *exp);
 void del_define(char *name);
-void add_define(char *text);
-void add_cmdline_define(char *set);
-FILE *open_include(const char *name, int search);
+FILE *open_include(const char *name, int search, char **newpath);
 void add_include_path(char *path);
-void push_if(int truecase, int wastrue, int nevertrue);
-int pop_if(void);
-int isnevertrue_if(void);
+void push_if(if_state_t s);
+void next_if_state(int);
+if_state_t pop_if(void);
+if_state_t if_state(void);
+int get_if_depth(void);
+
+/*
+ * From ppl.l
+ */
+extern FILE *ppin;
+extern FILE *ppout;
+extern char *pptext;
+extern int pp_flex_debug;
+int pplex(void);
+
+void do_include(char *fname, int type);
+void push_ignore_state(void);
+void pop_ignore_state(void);
+
+extern int include_state;
+extern char *include_ppp;
+extern char *include_filename;
+extern int include_ifdepth;
+extern int seen_junk;
+extern includelogicentry_t *includelogiclist;
+
+/*
+ * From ppy.y
+ */
+int ppparse(void);
+extern int ppdebug;
 
 #endif

trunk/tools/wrc/readres.c

@@ -31 +31 @@
         DWORD   version;        /* 0 */
         DWORD   characts;       /* 0 */
-} emptyheader = {0, 0x20, 0xffff, 0, 0xffff, 0, 0, 0, 0, 0, 0};
+} emptyheader           = {0, 0x20, 0xffff, 0, 0xffff, 0, 0, 0, 0, 0, 0},
+  emptyheaderSWAPPED    = {0, BYTESWAP_DWORD(0x20), 0xffff, 0, 0xffff, 0, 0, 0, 0, 0, 0};
 
 /*
@@ -65 +66 @@
 int read_data(FILE *fp, size_t size, void *buf)
 {
-        int r;
+        unsigned int r;
         int pos = ftell(fp);
         r = fread(buf, 1, size, fp);
@@ -136 +137 @@
 #define get_dword(idx)  (*((DWORD *)(&res->data[idx])))
 
-resource_t *read_res32(FILE *fp)
+static resource_t *read_res32(FILE *fp)
 {
         static char wrong_format[] = "Wrong resfile format (32bit)";
@@ -312 +313 @@
  *****************************************************************************
 */
-resource_t *read_res16(FILE *fp)
+static resource_t *read_res16(FILE *fp)
 {
         internal_error(__FILE__, __LINE__, "Can't yet read 16 bit .res files");
@@ -332 +333 @@
         FILE *fp;
         struct resheader32 rh;
-        int is32bit;
+        int is32bit = 1;
         resource_t *top;
 
@@ -346 +347 @@
                 if(!memcmp(&emptyheader, &rh, sizeof(rh)))
                         is32bit = 1;
+                else if(!memcmp(&emptyheaderSWAPPED, &rh, sizeof(rh)))
+                        error("Binary .res-file has its byteorder swapped");
                 else
                         is32bit = 0;