git.oblomov.eu Git - wine/blob - programs/winhlp32/macro.lex.l

   1 %{ /* -*-C-*- */
   2 /*
   3  * Help Viewer
   4  *
   5  * Copyright 1996 Ulrich Schmid
   6  * Copyright 2002,2008 Eric Pouech
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22 %}
  23 %option noinput nounput interactive 8bit
  24 %x quote
  25 %{
  26 #include "config.h"
  27 #include <assert.h>
  28 #include <stdarg.h>
  29
  30 #ifndef HAVE_UNISTD_H
  31 #define YY_NO_UNISTD_H
  32 #endif
  33
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "wingdi.h"
  37 #include "winuser.h"
  38 #include "winhelp.h"
  39
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
  43
  44 struct lex_data {
  45     LPCSTR   macroptr;
  46     LPSTR    strptr;
  47     int      quote_stack[32];
  48     unsigned quote_stk_idx;
  49     LPSTR    cache_string[32];
  50     int      cache_used;
  51     WINHELP_WINDOW* window;
  52 };
  53 static struct lex_data* lex_data = NULL;
  54
  55 struct lexret  yylval;
  56
  57 #define YY_INPUT(buf,result,max_size)\
  58   if ((result = *lex_data->macroptr ? 1 : 0)) buf[0] = *lex_data->macroptr++;
  59
  60 %}
  61 %%
  62
  63 [-+]?[0-9]+             yylval.integer = strtol(yytext, NULL, 10);      return INTEGER;
  64 [-+]?0[xX][0-9a-f]+     yylval.integer = strtol(yytext, NULL, 16);      return INTEGER;
  65
  66 [a-zA-Z][_0-9a-zA-Z]*   return MACRO_Lookup(yytext, &yylval);
  67
  68 \`          |
  69 \"          |
  70 \'          |
  71 <quote>\`   |
  72 <quote>\"   |
  73 <quote>\'   {
  74     if (lex_data->quote_stk_idx == 0 ||
  75         (yytext[0] == '\"' && lex_data->quote_stack[lex_data->quote_stk_idx - 1] != '\"') ||
  76         (yytext[0] == '`'))
  77     {
  78         /* opening a new one */
  79         if (lex_data->quote_stk_idx == 0)
  80         {
  81             assert(lex_data->cache_used < sizeof(lex_data->cache_string) / sizeof(lex_data->cache_string[0]));
  82             lex_data->strptr = lex_data->cache_string[lex_data->cache_used] = HeapAlloc(GetProcessHeap(), 0, strlen(lex_data->macroptr) + 1);
  83             yylval.string = lex_data->strptr;
  84             lex_data->cache_used++;
  85             BEGIN(quote);
  86         }
  87         else *lex_data->strptr++ = yytext[0];
  88         lex_data->quote_stack[lex_data->quote_stk_idx++] = yytext[0];
  89         assert(lex_data->quote_stk_idx < sizeof(lex_data->quote_stack) / sizeof(lex_data->quote_stack[0]));
  90     }
  91     else
  92     {
  93         if (yytext[0] == '`') assert(0);
  94         /* close the current quote */
  95         if (--lex_data->quote_stk_idx == 0)
  96         {
  97             BEGIN INITIAL;
  98             *lex_data->strptr++ = '\0';
  99             return STRING;
 100         }
 101         else *lex_data->strptr++ = yytext[0];
 102     }
 103 }
 104
 105 <quote>.                *lex_data->strptr++ = yytext[0];
 106 <quote>\\.              *lex_data->strptr++ = yytext[1];
 107 <quote><<EOF>>          return 0;
 108
 109 " "
 110 .                       return yytext[0];
 111 %%
 112
 113 #if 0
 114 /* all code for testing macros */
 115 #include "winhelp.h"
 116 static CHAR szTestMacro[256];
 117
 118 static LRESULT CALLBACK MACRO_TestDialogProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
 119 {
 120     if (msg == WM_COMMAND && wParam == IDOK)
 121     {
 122         GetDlgItemText(hDlg, 99, szTestMacro, sizeof(szTestMacro));
 123         EndDialog(hDlg, IDOK);
 124         return TRUE;
 125     }
 126     return FALSE;
 127 }
 128
 129 void macro_test(void)
 130 {
 131     WNDPROC lpfnDlg = MakeProcInstance(MACRO_TestDialogProc, Globals.hInstance);
 132     DialogBox(Globals.hInstance, STRING_DIALOG_TEST, Globals.active_win->hMainWnd, (DLGPROC)lpfnDlg);
 133     FreeProcInstance(lpfnDlg);
 134     macro = szTestMacro;
 135 }
 136 #endif
 137
 138 /* small helper function for debug messages */
 139 static const char* ts(int t)
 140 {
 141     static char c[2] = {0,0};
 142
 143     switch (t)
 144     {
 145     case EMPTY: return "EMPTY";
 146     case VOID_FUNCTION: return "VOID_FUNCTION";
 147     case BOOL_FUNCTION: return "BOOL_FUNCTION";
 148     case INTEGER: return "INTEGER";
 149     case STRING: return "STRING";
 150     case IDENTIFIER: return "IDENTIFIER";
 151     default: c[0] = (char)t; return c;
 152     }
 153 }
 154
 155 static int MACRO_CallBoolFunc(FARPROC fn, const char* args, void** ret);
 156
 157 /******************************************************************
 158  *              MACRO_CheckArgs
 159  *
 160  * checks number of arguments against prototype, and stores arguments on
 161  * stack pa for later call
 162  * returns -1 on error, otherwise the number of pushed parameters
 163  */
 164 static int MACRO_CheckArgs(void* pa[], unsigned max, const char* args)
 165 {
 166     int t;
 167     unsigned int len = 0, idx = 0;
 168
 169     WINE_TRACE("Checking %s\n", args);
 170
 171     if (yylex() != '(') {WINE_WARN("missing (\n");return -1;}
 172
 173     if (*args)
 174     {
 175         len = strlen(args);
 176         for (;;)
 177         {
 178             t = yylex();
 179             WINE_TRACE("Got %s <=> %c\n", ts(t), *args);
 180
 181             switch (*args)
 182             {
 183             case 'S':
 184                 if (t != STRING)
 185                 {WINE_WARN("missing S\n");return -1;}
 186                 pa[idx] = (void*)yylval.string;
 187                 break;
 188             case 'U':
 189             case 'I':
 190                 if (t != INTEGER)
 191                 {WINE_WARN("missing U\n");return -1;}
 192                 pa[idx] = LongToPtr(yylval.integer);
 193                 break;
 194             case 'B':
 195                 if (t != BOOL_FUNCTION)
 196                 {WINE_WARN("missing B\n");return -1;}
 197                 if (MACRO_CallBoolFunc(yylval.function, yylval.proto, &pa[idx]) == 0)
 198                     return -1;
 199                 break;
 200             default:
 201                 WINE_WARN("unexpected %s while args is %c\n", ts(t), *args);
 202                 return -1;
 203             }
 204             idx++;
 205             if (*++args == '\0') break;
 206             t = yylex();
 207             if (t == ')') goto CheckArgs_end;
 208             if (t != ',') {WINE_WARN("missing ,\n");return -1;}
 209             if (idx >= max) {WINE_FIXME("stack overflow (%d)\n", max);return -1;}
 210         }
 211     }
 212     if (yylex() != ')') {WINE_WARN("missing )\n");return -1;}
 213
 214 CheckArgs_end:
 215     while (len > idx) pa[--len] = NULL;
 216     return idx;
 217 }
 218
 219 /******************************************************************
 220  *              MACRO_CallBoolFunc
 221  *
 222  * Invokes boolean function fn, which arguments are defined by args
 223  * stores bool result into ret
 224  */
 225 static int MACRO_CallBoolFunc(FARPROC fn, const char* args, void** ret)
 226 {
 227     void*       pa[2];
 228     int         idx = MACRO_CheckArgs(pa, sizeof(pa)/sizeof(pa[0]), args);
 229
 230     if (idx < 0) return 0;
 231     if (!fn)     return 1;
 232
 233     WINE_TRACE("calling with %u pmts\n", idx);
 234
 235     switch (strlen(args))
 236     {
 237     case 0: *ret = (void*)(fn)();          break;
 238     case 1: *ret = (void*)(fn)(pa[0]);     break;
 239     default: WINE_FIXME("NIY\n");
 240     }
 241
 242     return 1;
 243 }
 244
 245 /******************************************************************
 246  *              MACRO_CallVoidFunc
 247  *
 248  *
 249  */
 250 static int MACRO_CallVoidFunc(FARPROC fn, const char* args)
 251 {
 252     void*       pa[6];
 253     int         idx = MACRO_CheckArgs(pa, sizeof(pa)/sizeof(pa[0]), args);
 254
 255     if (idx < 0) return 0;
 256     if (!fn)     return 1;
 257
 258     WINE_TRACE("calling %p with %u pmts\n", fn, idx);
 259
 260     switch (strlen(args))
 261     {
 262     case 0: (fn)();                                     break;
 263     case 1: (fn)(pa[0]);                                break;
 264     case 2: (fn)(pa[0],pa[1]);                          break;
 265     case 3: (fn)(pa[0],pa[1],pa[2]);                    break;
 266     case 4: (fn)(pa[0],pa[1],pa[2],pa[3]);              break;
 267     case 5: (fn)(pa[0],pa[1],pa[2],pa[3],pa[4]);        break;
 268     case 6: (fn)(pa[0],pa[1],pa[2],pa[3],pa[4],pa[5]);  break;
 269     default: WINE_FIXME("NIY\n");
 270     }
 271
 272     return 1;
 273 }
 274
 275 BOOL MACRO_ExecuteMacro(WINHELP_WINDOW* window, LPCSTR macro)
 276 {
 277     struct lex_data     curr_lex_data, *prev_lex_data;
 278     BOOL ret = TRUE;
 279     int t;
 280
 281     WINE_TRACE("%s\n", wine_dbgstr_a(macro));
 282
 283     prev_lex_data = lex_data;
 284     lex_data = &curr_lex_data;
 285
 286     memset(lex_data, 0, sizeof(*lex_data));
 287     lex_data->macroptr = macro;
 288     lex_data->window = window;
 289
 290     while ((t = yylex()) != EMPTY)
 291     {
 292         switch (t)
 293         {
 294         case VOID_FUNCTION:
 295             WINE_TRACE("got type void func(%s)\n", yylval.proto);
 296             MACRO_CallVoidFunc(yylval.function, yylval.proto);
 297             break;
 298         case BOOL_FUNCTION:
 299             WINE_WARN("got type bool func(%s)\n", yylval.proto);
 300             break;
 301         default:
 302             WINE_WARN("got unexpected type %s\n", ts(t));
 303             YY_FLUSH_BUFFER;
 304             ret = FALSE;
 305             goto done;
 306         }
 307         switch (t = yylex())
 308         {
 309         case EMPTY:     goto done;
 310         case ';':       break;
 311         default:        ret = FALSE; YY_FLUSH_BUFFER; goto done;
 312         }
 313     }
 314
 315 done:
 316     for (t = 0; t < lex_data->cache_used; t++)
 317         HeapFree(GetProcessHeap(), 0, lex_data->cache_string[t]);
 318     lex_data = prev_lex_data;
 319
 320     return ret;
 321 }
 322
 323 WINHELP_WINDOW* MACRO_CurrentWindow(void)
 324 {
 325     return lex_data ? lex_data->window : Globals.active_win;
 326 }
 327
 328 #ifndef yywrap
 329 int yywrap(void) { return 1; }
 330 #endif