reactos/wine
1
0
Fork 0
mirror of https://github.com/reactos/wine.git synced 2024-12-12 13:56:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
0f418a698c
wine/programs/winhlp32/macro.lex.l
Jean-Christophe Cardot 1dba777e69 winhlp32: Use debugstr_a() to trace. 
Signed-off-by: Jean-Christophe Cardot <wine@cardot.net>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
2016-04-22 21:04:34 +09:00

374 lines
9.7 KiB
C
Raw Blame History

%{ /* -*-C-*- */
/*
* Help Viewer
*
* Copyright 1996 Ulrich Schmid
* Copyright 2002,2008 Eric Pouech
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
%}
%option noinput nounput never-interactive 8bit
%x quote
%{
#include "config.h"
#include <assert.h>
#include <stdarg.h>
#define YY_NO_UNISTD_H
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winhelp.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(winhelp);
struct lex_data {
LPCSTR macroptr;
LPSTR strptr;
int quote_stack[32];
unsigned quote_stk_idx;
LPSTR cache_string[32];
int cache_used;
WINHELP_WINDOW* window;
};
static struct lex_data* lex_data = NULL;
struct lexret yylval;
#define YY_INPUT(buf,result,max_size)\
if ((result = *lex_data->macroptr ? 1 : 0)) buf[0] = *lex_data->macroptr++;
%}
%%
[-+]?[0-9]+ yylval.integer = strtol(yytext, NULL, 10); return INTEGER;
[-+]?0[xX][0-9a-f]+ yylval.integer = strtol(yytext, NULL, 16); return INTEGER;
[a-zA-Z][_0-9a-zA-Z]* return MACRO_Lookup(yytext, &yylval);
\` |
\" |
\' |
<quote>\` |
<quote>\" |
<quote>\' {
if (lex_data->quote_stk_idx == 0 ||
(yytext[0] == '\"' && lex_data->quote_stack[lex_data->quote_stk_idx - 1] != '\"') ||
(yytext[0] == '`'))
{
/* opening a new one */
if (lex_data->quote_stk_idx == 0)
{
assert(lex_data->cache_used < sizeof(lex_data->cache_string) / sizeof(lex_data->cache_string[0]));
lex_data->strptr = lex_data->cache_string[lex_data->cache_used] = HeapAlloc(GetProcessHeap(), 0, strlen(lex_data->macroptr) + 1);
yylval.string = lex_data->strptr;
lex_data->cache_used++;
BEGIN(quote);
}
else *lex_data->strptr++ = yytext[0];
lex_data->quote_stack[lex_data->quote_stk_idx++] = yytext[0];
assert(lex_data->quote_stk_idx < sizeof(lex_data->quote_stack) / sizeof(lex_data->quote_stack[0]));
}
else
{
if (yytext[0] == '`') assert(0);
/* close the current quote */
if (--lex_data->quote_stk_idx == 0)
{
BEGIN INITIAL;
*lex_data->strptr++ = '\0';
return STRING;
}
else *lex_data->strptr++ = yytext[0];
}
}
<quote>. *lex_data->strptr++ = yytext[0];
<quote>\\. *lex_data->strptr++ = yytext[1];
<quote><<EOF>> return 0;
" "
. return yytext[0];
%%
#if 0
/* all code for testing macros */
#include "winhelp.h"
static CHAR szTestMacro[256];
static LRESULT CALLBACK MACRO_TestDialogProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (msg == WM_COMMAND && wParam == IDOK)
{
GetDlgItemText(hDlg, 99, szTestMacro, sizeof(szTestMacro));
EndDialog(hDlg, IDOK);
return TRUE;
}
return FALSE;
}
void macro_test(void)
{
WNDPROC lpfnDlg = MakeProcInstance(MACRO_TestDialogProc, Globals.hInstance);
DialogBox(Globals.hInstance, STRING_DIALOG_TEST, Globals.active_win->hMainWnd, (DLGPROC)lpfnDlg);
FreeProcInstance(lpfnDlg);
macro = szTestMacro;
}
#endif
/* small helper function for debug messages */
static const char* ts(int t)
{
static char c[2] = {0,0};
switch (t)
{
case EMPTY: return "EMPTY";
case VOID_FUNCTION: return "VOID_FUNCTION";
case BOOL_FUNCTION: return "BOOL_FUNCTION";
case INTEGER: return "INTEGER";
case STRING: return "STRING";
case IDENTIFIER: return "IDENTIFIER";
default: c[0] = (char)t; return c;
}
}
static int MACRO_CallBoolFunc(void *fn, const char* args, void** ret);
/******************************************************************
* MACRO_CheckArgs
*
* checks number of arguments against prototype, and stores arguments on
* stack pa for later call
* returns -1 on error, otherwise the number of pushed parameters
*/
static int MACRO_CheckArgs(void* pa[], unsigned max, const char* args)
{
int t;
unsigned int len = 0, idx = 0;
WINE_TRACE("Checking %s\n", debugstr_a(args));
if (yylex() != '(') {WINE_WARN("missing (\n");return -1;}
if (*args)
{
len = strlen(args);
for (;;)
{
t = yylex();
WINE_TRACE("Got %s <=> %c\n", debugstr_a(ts(t)), *args);
switch (*args)
{
case 'S':
if (t != STRING)
{WINE_WARN("missing S\n");return -1;}
pa[idx] = (void*)yylval.string;
break;
case 'U':
case 'I':
if (t != INTEGER)
{WINE_WARN("missing U\n");return -1;}
pa[idx] = LongToPtr(yylval.integer);
break;
case 'B':
if (t != BOOL_FUNCTION)
{WINE_WARN("missing B\n");return -1;}
if (MACRO_CallBoolFunc(yylval.function, yylval.proto, &pa[idx]) == 0)
return -1;
break;
default:
WINE_WARN("unexpected %s while args is %c\n", debugstr_a(ts(t)), *args);
return -1;
}
idx++;
if (*++args == '\0') break;
t = yylex();
if (t == ')') goto CheckArgs_end;
if (t != ',') {WINE_WARN("missing ,\n");return -1;}
if (idx >= max) {WINE_FIXME("stack overflow (%d)\n", max);return -1;}
}
}
if (yylex() != ')') {WINE_WARN("missing )\n");return -1;}
CheckArgs_end:
while (len > idx) pa[--len] = NULL;
return idx;
}
/******************************************************************
* MACRO_CallBoolFunc
*
* Invokes boolean function fn, which arguments are defined by args
* stores bool result into ret
*/
static int MACRO_CallBoolFunc(void *fn, const char* args, void** ret)
{
void* pa[2];
int idx = MACRO_CheckArgs(pa, sizeof(pa)/sizeof(pa[0]), args);
if (idx < 0) return 0;
if (!fn) return 1;
WINE_TRACE("calling with %u pmts\n", idx);
switch (strlen(args))
{
case 0:
{
BOOL (WINAPI *func)(void) = fn;
*ret = (void *)(ULONG_PTR)func();
break;
}
case 1:
{
BOOL (WINAPI *func)(void *) = fn;
*ret = (void *)(ULONG_PTR)func( pa[0]);
break;
}
default: WINE_FIXME("NIY\n");
}
return 1;
}
/******************************************************************
* MACRO_CallVoidFunc
*
*
*/
static int MACRO_CallVoidFunc(void *fn, const char* args)
{
void* pa[6];
int idx = MACRO_CheckArgs(pa, sizeof(pa)/sizeof(pa[0]), args);
if (idx < 0) return 0;
if (!fn) return 1;
WINE_TRACE("calling %p with %u pmts\n", fn, idx);
switch (strlen(args))
{
case 0:
{
void (WINAPI *func)(void) = fn;
func();
break;
}
case 1:
{
void (WINAPI *func)(void*) = fn;
func( pa[0] );
break;
}
case 2:
{
void (WINAPI *func)(void*,void*) = fn;
func( pa[0], pa[1] );
break;
}
case 3:
{
void (WINAPI *func)(void*,void*,void*) = fn;
func( pa[0], pa[1], pa[2] );
break;
}
case 4:
{
void (WINAPI *func)(void*,void*,void*,void*) = fn;
func( pa[0], pa[1], pa[2], pa[3] );
break;
}
case 5:
{
void (WINAPI *func)(void*,void*,void*,void*,void*) = fn;
func( pa[0], pa[1], pa[2], pa[3], pa[4] );
break;
}
case 6:
{
void (WINAPI *func)(void*,void*,void*,void*,void*,void*) = fn;
func( pa[0], pa[1], pa[2], pa[3], pa[4], pa[5] );
break;
}
default: WINE_FIXME("NIY\n");
}
return 1;
}
BOOL MACRO_ExecuteMacro(WINHELP_WINDOW* window, LPCSTR macro)
{
struct lex_data curr_lex_data, *prev_lex_data;
BOOL ret = TRUE;
int t;
WINE_TRACE("%s\n", debugstr_a(macro));
prev_lex_data = lex_data;
lex_data = &curr_lex_data;
memset(lex_data, 0, sizeof(*lex_data));
lex_data->macroptr = macro;
lex_data->window = WINHELP_GrabWindow(window);
while ((t = yylex()) != EMPTY)
{
switch (t)
{
case VOID_FUNCTION:
WINE_TRACE("got type void func(%s)\n", debugstr_a(yylval.proto));
MACRO_CallVoidFunc(yylval.function, yylval.proto);
break;
case BOOL_FUNCTION:
WINE_WARN("got type bool func(%s)\n", debugstr_a(yylval.proto));
break;
default:
WINE_WARN("got unexpected type %s\n", debugstr_a(ts(t)));
YY_FLUSH_BUFFER;
ret = FALSE;
goto done;
}
switch (t = yylex())
{
case EMPTY: goto done;
case ';': break;
default: ret = FALSE; YY_FLUSH_BUFFER; goto done;
}
}
done:
for (t = 0; t < lex_data->cache_used; t++)
HeapFree(GetProcessHeap(), 0, lex_data->cache_string[t]);
lex_data = prev_lex_data;
WINHELP_ReleaseWindow(window);
return ret;
}
WINHELP_WINDOW* MACRO_CurrentWindow(void)
{
return lex_data ? lex_data->window : Globals.active_win;
}
#ifndef yywrap
int yywrap(void) { return 1; }
#endif
Reference in New Issue View Git Blame Copy Permalink