programs/winhelp/macro.lex.l

   1 %{
   2 /*
   3  * Help Viewer
   4  *
   5  * Copyright 1996 Ulrich Schmid
   6  * Copyright 2002 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22 %}
  23 %x quote
  24 %{
  25 #include <assert.h>
  26 #include "macro.h"
  27
  28 #include "wine/debug.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
  31
  32 static LPCSTR  macroptr;
  33 static LPSTR   strptr;
  34 static int     quote_stack[32];
  35 static int     quote_stk_idx = 0;
  36 struct lexret  yylval;
  37
  38 #define YY_INPUT(buf,result,max_size)\
  39   if ((result = *macroptr ? 1 : 0)) buf[0] = *macroptr++;
  40
  41 #define YY_NO_UNPUT
  42 %}
  43 %%
  44
  45 [-+]?[0-9]+             yylval.integer = strtol(yytext, NULL, 10);      return INTEGER;
  46 [-+]?0[xX][0-9a-f]+     yylval.integer = strtol(yytext, NULL, 16);      return INTEGER;
  47
  48 [a-zA-Z][_0-9a-zA-Z]*   return MACRO_Lookup(yytext, &yylval);
  49
  50 \`          |
  51 \"          |
  52 \'          |
  53 <quote>\`   |
  54 <quote>\"   |
  55 <quote>\'   {
  56     if (quote_stk_idx == 0 ||
  57         (yytext[0] == '\"' && quote_stack[quote_stk_idx - 1] != '\"') ||
  58         (yytext[0] == '`'))
  59     {
  60         /* opening a new one */
  61         if (quote_stk_idx == 0)
  62         {
  63             strptr = HeapAlloc(GetProcessHeap(), 0, strlen(macroptr) + 1);
  64             yylval.string = strptr;
  65             BEGIN(quote);
  66         }
  67         else *strptr++ = yytext[0];
  68         quote_stack[quote_stk_idx++] = yytext[0];
  69         assert(quote_stk_idx < sizeof(quote_stack) / sizeof(quote_stack[0]));
  70     }
  71     else
  72     {
  73         if (yytext[0] == '`') assert(0);
  74         /* close the current quote */
  75         if (--quote_stk_idx == 0)
  76         {
  77             BEGIN INITIAL;
  78             *strptr++ = '\0';
  79             return STRING;
  80         }
  81         else *strptr++ = yytext[0];
  82     }
  83 }
  84
  85 <quote>.                *strptr++ = yytext[0];
  86 <quote>\\.              *strptr++ = yytext[1];
  87 <quote><<EOF>>          return 0;
  88
  89 " "
  90 .                       return yytext[0];
  91 %%
  92
  93 #if 0
  94 /* all code for testing macros */
  95 #include "winhelp.h"
  96 static CHAR szTestMacro[256];
  97
  98 static LRESULT CALLBACK MACRO_TestDialogProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
  99 {
 100     if (msg == WM_COMMAND && wParam == IDOK)
 101     {
 102         GetDlgItemText(hDlg, 99, szTestMacro, sizeof(szTestMacro));
 103         EndDialog(hDlg, IDOK);
 104         return TRUE;
 105     }
 106     return FALSE;
 107 }
 108
 109 void macro_test(void)
 110 {
 111     WNDPROC lpfnDlg = MakeProcInstance(MACRO_TestDialogProc, Globals.hInstance);
 112     DialogBox(Globals.hInstance, STRING_DIALOG_TEST, Globals.active_win->hMainWnd, (DLGPROC)lpfnDlg);
 113     FreeProcInstance(lpfnDlg);
 114     macro = szTestMacro;
 115 }
 116 #endif
 117
 118 /* small helper function for debug messages */
 119 static const char* ts(int t)
 120 {
 121     static char c[2] = {0,0};
 122
 123     switch (t)
 124     {
 125     case EMPTY: return "EMPTY";
 126     case VOID_FUNCTION: return "VOID_FUNCTION";
 127     case BOOL_FUNCTION: return "BOOL_FUNCTION";
 128     case INTEGER: return "INTEGER";
 129     case STRING: return "STRING";
 130     case IDENTIFIER: return "IDENTIFIER";
 131     default: c[0] = (char)t; return c;
 132     }
 133 }
 134
 135 static int MACRO_CallBoolFunc(BOOL (*fn)(), const char* args, void** ret);
 136
 137 /******************************************************************
 138  *              MACRO_CheckArgs
 139  *
 140  * checks number of arguments against prototype, and stores arguments on
 141  * stack pa for later call
 142  * returns -1 on error, otherwise the number of pushed parameters
 143  */
 144 static int MACRO_CheckArgs(void* pa[], unsigned max, const char* args)
 145 {
 146     int         t;
 147     int         idx = 0;
 148
 149     WINE_TRACE("Checking %s\n", args);
 150
 151     if (yylex() != '(') {WINE_WARN("missing (\n");return -1;}
 152
 153     if (*args)
 154     {
 155         for (;;)
 156         {
 157             t = yylex();
 158             WINE_TRACE("Got %s <=> %c\n", ts(t), *args);
 159
 160             switch (*args)
 161             {
 162             case 'S':
 163                 if (t != STRING)
 164                 {WINE_WARN("missing S\n");return -1;}
 165                 pa[idx] = (void*)yylval.string;
 166                 break;
 167             case 'U':
 168             case 'I':
 169                 if (t != INTEGER)
 170                 {WINE_WARN("missing U\n");return -1;}
 171                 pa[idx] = (void*)yylval.integer;
 172                 break;
 173             case 'B':
 174                 if (t != BOOL_FUNCTION)
 175                 {WINE_WARN("missing B\n");return -1;}
 176                 if (MACRO_CallBoolFunc(yylval.bool_function, yylval.proto, &pa[idx]) == 0)
 177                     return -1;
 178                 break;
 179             default:
 180                 WINE_WARN("unexpected %s while args is %c\n", ts(t), *args);
 181                 return -1;
 182             }
 183             idx++;
 184             if (*++args == '\0') break;
 185             if (yylex() != ',') {WINE_WARN("missing ,\n");return -1;}
 186             if (idx == max) {WINE_FIXME("stack overflow (%d)\n", max);return -1;}
 187         }
 188     }
 189     if (yylex() != ')') {WINE_WARN("missing )\n");return -1;}
 190     return idx;
 191 }
 192
 193 /******************************************************************
 194  *              MACRO_CallBoolFunc
 195  *
 196  * Invokes boolean function fn, which arguments are defined by args
 197  * stores bool result into ret
 198  */
 199 static int MACRO_CallBoolFunc(BOOL (*fn)(), const char* args, void** ret)
 200 {
 201     void*       pa[2];
 202     int         idx = MACRO_CheckArgs(pa, sizeof(pa)/sizeof(pa[0]), args);
 203
 204     if (idx == -1) return 0;
 205     if (!fn)       return 1;
 206
 207     WINE_TRACE("calling with %u pmts\n", idx);
 208
 209     switch (idx)
 210     {
 211     case 0: *ret = (void*)(fn)();          break;
 212     case 1: *ret = (void*)(fn)(pa[0]);     break;
 213     default: WINE_FIXME("NIY\n");
 214     }
 215
 216     return 1;
 217 }
 218
 219 /******************************************************************
 220  *              MACRO_CallVoidFunc
 221  *
 222  *
 223  */
 224 static int MACRO_CallVoidFunc(void (*fn)(), const char* args)
 225 {
 226     void*       pa[6];
 227     int         idx = MACRO_CheckArgs(pa, sizeof(pa)/sizeof(pa[0]), args);
 228
 229     if (idx == -1) return 0;
 230     if (!fn)       return 1;
 231
 232     WINE_TRACE("calling with %u pmts\n", idx);
 233
 234     switch (idx)
 235     {
 236     case 0: (fn)();                                     break;
 237     case 1: (fn)(pa[0]);                                break;
 238     case 2: (fn)(pa[0],pa[1]);                          break;
 239     case 3: (fn)(pa[0],pa[1],pa[2]);                    break;
 240     case 4: (fn)(pa[0],pa[1],pa[2],pa[3]);              break;
 241     case 5: (fn)(pa[0],pa[1],pa[2],pa[3],pa[4]);        break;
 242     case 6: (fn)(pa[0],pa[1],pa[2],pa[3],pa[4],pa[5]);  break;
 243     default: WINE_FIXME("NIY\n");
 244     }
 245
 246     return 1;
 247 }
 248
 249 BOOL MACRO_ExecuteMacro(LPCSTR macro)
 250 {
 251     int t;
 252
 253     WINE_TRACE("%s\n", wine_dbgstr_a(macro));
 254
 255     macroptr = macro;
 256
 257     while ((t = yylex()) != EMPTY)
 258     {
 259         switch (t)
 260         {
 261         case VOID_FUNCTION:
 262             WINE_TRACE("got type void func(%s)\n", yylval.proto);
 263             MACRO_CallVoidFunc(yylval.void_function, yylval.proto);
 264             break;
 265         case BOOL_FUNCTION:
 266             WINE_WARN("got type bool func(%s)\n", yylval.proto);
 267             break;
 268         default:
 269             WINE_WARN("got unexpected type %s\n", ts(t));
 270             return 0;
 271         }
 272         switch (t = yylex())
 273         {
 274         case EMPTY:     return 1;
 275         case ';':       break;
 276         default:        return 0;
 277         }
 278     }
 279
 280     if (strptr)
 281     {
 282         HeapFree(GetProcessHeap(), 0, strptr);
 283         strptr = NULL;
 284     }
 285     quote_stk_idx = 0;
 286
 287     return 1;
 288 }
 289
 290 #ifndef yywrap
 291 int yywrap(void) { return 1; }
 292 #endif