From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/parser.l | 57 ++++++++++++++++++++++++++------------------- tools/widl/parser.y | 31 +++--------------------- tools/widl/utils.h | 3 --- 3 files changed, 36 insertions(+), 55 deletions(-)
diff --git a/tools/widl/parser.l b/tools/widl/parser.l index a1be68d8bd9..ce4335b5985 100644 --- a/tools/widl/parser.l +++ b/tools/widl/parser.l @@ -26,13 +26,13 @@
nl \r?\n ws [ \f\t\r] +hd [0-9a-fA-F] cident [a-zA-Z_][0-9a-zA-Z_]* u_suffix (u|U) l_suffix (l|L) int [0-9]+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)? -hexd [0-9a-fA-F] -hex 0(x|X){hexd}+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)? -uuid {hexd}{8}-{hexd}{4}-{hexd}{4}-{hexd}{4}-{hexd}{12} +hex 0(x|X){hd}+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)? +uuid {hd}{8}-{hd}{4}-{hd}{4}-{hd}{4}-{hd}{12} double [0-9]+.[0-9]+([eE][+-]?[0-9]+)*
%x ATTR @@ -101,24 +101,36 @@ static unsigned int xstrtoul(const char *nptr, char **endptr, int base) return val; }
-struct uuid *parse_uuid(const char *u) +static int token_uuid( const char *str, YYSTYPE *yylval ) { - struct uuid* uuid = xmalloc(sizeof(*uuid)); - char b[3]; - /* it would be nice to use UuidFromStringA */ - uuid->Data1 = strtoul(u, NULL, 16); - uuid->Data2 = strtoul(u+9, NULL, 16); - uuid->Data3 = strtoul(u+14, NULL, 16); - b[2] = 0; - memcpy(b, u+19, 2); uuid->Data4[0] = strtoul(b, NULL, 16); - memcpy(b, u+21, 2); uuid->Data4[1] = strtoul(b, NULL, 16); - memcpy(b, u+24, 2); uuid->Data4[2] = strtoul(b, NULL, 16); - memcpy(b, u+26, 2); uuid->Data4[3] = strtoul(b, NULL, 16); - memcpy(b, u+28, 2); uuid->Data4[4] = strtoul(b, NULL, 16); - memcpy(b, u+30, 2); uuid->Data4[5] = strtoul(b, NULL, 16); - memcpy(b, u+32, 2); uuid->Data4[6] = strtoul(b, NULL, 16); - memcpy(b, u+34, 2); uuid->Data4[7] = strtoul(b, NULL, 16); - return uuid; + struct uuid *uuid; + char tmp[3] = {0}; + + if (*str == '"') str++; + + uuid = xmalloc( sizeof(*uuid) ); + uuid->Data1 = strtoul( str , NULL, 16 ); + uuid->Data2 = strtoul( str + 9, NULL, 16 ); + uuid->Data3 = strtoul( str + 14, NULL, 16 ); + memcpy( tmp, str + 19, 2 ); + uuid->Data4[0] = strtoul( tmp, NULL, 16 ); + memcpy( tmp, str + 21, 2 ); + uuid->Data4[1] = strtoul( tmp, NULL, 16 ); + memcpy( tmp, str + 24, 2 ); + uuid->Data4[2] = strtoul( tmp, NULL, 16 ); + memcpy( tmp, str + 26, 2 ); + uuid->Data4[3] = strtoul( tmp, NULL, 16 ); + memcpy( tmp, str + 28, 2 ); + uuid->Data4[4] = strtoul( tmp, NULL, 16 ); + memcpy( tmp, str + 30, 2 ); + uuid->Data4[5] = strtoul( tmp, NULL, 16 ); + memcpy( tmp, str + 32, 2 ); + uuid->Data4[6] = strtoul( tmp, NULL, 16 ); + memcpy( tmp, str + 34, 2 ); + uuid->Data4[7] = strtoul( tmp, NULL, 16 ); + + yylval->uuid = uuid; + return aUUID; }
static int token_str( int token, const char *str, YYSTYPE *yylval ) @@ -196,11 +208,8 @@ static int token_num( int token, const char *yytext, YYSTYPE *yylval ) <ATTR>{ ] { yy_pop_state(); return ']'; }
+ ({uuid}|"{uuid}") { return token_uuid( yytext, yylval ); } {cident} { return attr_token( yytext, yylval ); } - {uuid} { - yylval->uuid = parse_uuid( yytext ); - return aUUID; - } }
<INITIAL>{ diff --git a/tools/widl/parser.y b/tools/widl/parser.y index 031e5482792..a48a8ca54f3 100644 --- a/tools/widl/parser.y +++ b/tools/widl/parser.y @@ -330,7 +330,6 @@ int parser_lex( PARSER_STYPE *yylval ); %type <num> pointer_type threading_type marshaling_behavior version %type <str> libraryhdr callconv cppquote importlib import %type <str> typename m_typename -%type <uuid> uuid_string %type <str> import_start %type <typelib> library_start librarydef %type <statement> statement typedef pragma_warning @@ -630,7 +629,7 @@ attribute | tCONTRACT '(' contract_req ')' { $$ = make_attrp(ATTR_CONTRACT, $3); } | tCONTRACTVERSION '(' contract_ver ')' { $$ = make_attrv(ATTR_CONTRACTVERSION, $3); } | tCONTROL { $$ = make_attr(ATTR_CONTROL); } - | tCUSTOM '(' uuid_string ',' expr_const ')' { $$ = make_custom_attr($3, $5); } + | tCUSTOM '(' aUUID ',' expr_const ')' { $$ = make_custom_attr($3, $5); } | tDECODE { $$ = make_attr(ATTR_DECODE); } | tDEFAULT { $$ = make_attr(ATTR_DEFAULT); } | tDEFAULTBIND { $$ = make_attr(ATTR_DEFAULTBIND); } @@ -720,8 +719,8 @@ attribute | tUIDEFAULT { $$ = make_attr(ATTR_UIDEFAULT); } | tUSESGETLASTERROR { $$ = make_attr(ATTR_USESGETLASTERROR); } | tUSERMARSHAL '(' type ')' { $$ = make_attrp(ATTR_USERMARSHAL, $3); } - | tUUID '(' uuid_string ')' { $$ = make_attrp(ATTR_UUID, $3); } - | tASYNCUUID '(' uuid_string ')' { $$ = make_attrp(ATTR_ASYNCUUID, $3); } + | tUUID '(' aUUID ')' { $$ = make_attrp(ATTR_UUID, $3); } + | tASYNCUUID '(' aUUID ')' { $$ = make_attrp(ATTR_ASYNCUUID, $3); } | tV1ENUM { $$ = make_attr(ATTR_V1ENUM); } | tVARARG { $$ = make_attr(ATTR_VARARG); } | tVERSION '(' version ')' { $$ = make_attrv(ATTR_VERSION, $3); } @@ -730,13 +729,6 @@ attribute | pointer_type { $$ = make_attrv(ATTR_POINTERTYPE, $1); } ;
-uuid_string: - aUUID - | aSTRING { if (!is_valid_uuid($1)) - error_loc("invalid UUID: %s\n", $1); - $$ = parse_uuid($1); } - ; - callconv: tCDECL { $$ = xstrdup("__cdecl"); } | tFASTCALL { $$ = xstrdup("__fastcall"); } | tPASCAL { $$ = xstrdup("__pascal"); } @@ -3258,23 +3250,6 @@ static void check_all_user_types(const statement_list_t *stmts) } }
-int is_valid_uuid(const char *s) -{ - int i; - - for (i = 0; i < 36; ++i) - if (i == 8 || i == 13 || i == 18 || i == 23) - { - if (s[i] != '-') - return FALSE; - } - else - if (!isxdigit(s[i])) - return FALSE; - - return s[i] == '\0'; -} - static statement_t *make_statement(enum statement_type type) { statement_t *stmt = xmalloc(sizeof(*stmt)); diff --git a/tools/widl/utils.h b/tools/widl/utils.h index f042f0e064c..2a994e9697d 100644 --- a/tools/widl/utils.h +++ b/tools/widl/utils.h @@ -35,9 +35,6 @@ size_t strappend(char **buf, size_t *len, size_t pos, const char* fmt, ...) __at
size_t widl_getline(char **linep, size_t *lenp, FILE *fp);
-struct uuid *parse_uuid(const char *u); -int is_valid_uuid(const char *s); - /* buffer management */
extern void add_output_to_resources( const char *type, const char *name );
From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/parser.l | 20 +++++++------------- 1 file changed, 7 insertions(+), 13 deletions(-)
diff --git a/tools/widl/parser.l b/tools/widl/parser.l index ce4335b5985..f85315c8e93 100644 --- a/tools/widl/parser.l +++ b/tools/widl/parser.l @@ -24,16 +24,10 @@ %option noyywrap %option 8bit never-interactive prefix="parser_"
-nl \r?\n -ws [ \f\t\r] -hd [0-9a-fA-F] -cident [a-zA-Z_][0-9a-zA-Z_]* -u_suffix (u|U) -l_suffix (l|L) -int [0-9]+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)? -hex 0(x|X){hd}+({l_suffix}?{u_suffix}?|{u_suffix}?{l_suffix}?)? -uuid {hd}{8}-{hd}{4}-{hd}{4}-{hd}{4}-{hd}{12} -double [0-9]+.[0-9]+([eE][+-]?[0-9]+)* +ws [ \f\t\r] +hd [0-9a-fA-F] +uuid {hd}{8}-{hd}{4}-{hd}{4}-{hd}{4}-{hd}{12} +cident [a-zA-Z_][0-9a-zA-Z_]*
%x ATTR %x PP_LINE @@ -216,7 +210,7 @@ static int token_num( int token, const char *yytext, YYSTYPE *yylval ) ^{ws}*#{ws}*pragma{ws}+ { yy_push_state( PP_PRAGMA ); } ^{ws}*midl_pragma{ws}+warning { return tPRAGMA_WARNING; }
- {double} { + [0-9]+.[0-9]+([eE][+-]?[0-9]+)* { yylval->dbl = strtod( yytext, NULL ); return aDOUBLE; } @@ -229,8 +223,8 @@ SAFEARRAY{ws}*/( return tSAFEARRAY; ^{ws}*#{ws}* { yy_push_state(PP_LINE); } [ { yy_push_state(ATTR); return '['; }
- {hex} { return token_num( aHEXNUM, yytext, yylval ); } - {int} { return token_num( aNUM, yytext, yylval ); } + 0[xX]{hd}+([lL][uU]?|[uU][lL]?)? { return token_num( aHEXNUM, yytext, yylval ); } + [0-9]+([lL][uU]?|[uU][lL]?)? { return token_num( aNUM, yytext, yylval ); }
L"(\.|[^"\])*" { return token_str( aWSTRING, yytext + 1, yylval ); } "(\.|[^"\])*" { return token_str( aSTRING, yytext, yylval ); }
From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/parser.l | 74 ++++++++++++++++++++++----------------------- 1 file changed, 37 insertions(+), 37 deletions(-)
diff --git a/tools/widl/parser.l b/tools/widl/parser.l index f85315c8e93..536253aeca2 100644 --- a/tools/widl/parser.l +++ b/tools/widl/parser.l @@ -31,6 +31,7 @@ cident [a-zA-Z_][0-9a-zA-Z_]*
%x ATTR %x PP_LINE +%x PP_FILE %x PP_PRAGMA
%{ @@ -153,6 +154,14 @@ static int token_num( int token, const char *yytext, YYSTYPE *yylval ) return token; }
+static void winrt_enable( int ns_prefix ) +{ + if (!list_empty( &import_stack ) && !winrt_mode) error_loc( "WinRT IDL file imported in non-winrt mode." ); + + use_abi_namespace = ns_prefix; + winrt_mode = TRUE; +} + %}
/* @@ -161,43 +170,34 @@ static int token_num( int token, const char *yytext, YYSTYPE *yylval ) ************************************************************************** */ %% -<PP_LINE>[^\n]* { - int lineno; - char *cptr, *fname; - yy_pop_state(); - lineno = (int)strtol(yytext, &cptr, 10); - if(!lineno) - error_loc("Malformed '#...' line-directive; invalid linenumber\n"); - fname = strchr(cptr, '"'); - if(!fname) - error_loc("Malformed '#...' line-directive; missing filename\n"); - fname++; - cptr = strchr(fname, '"'); - if(!cptr) - error_loc("Malformed '#...' line-directive; missing terminating "\n"); - *cptr = '\0'; - line_number = lineno - 1; /* We didn't read the newline */ - input_name = xstrdup(fname); - } -<PP_PRAGMA>midl_echo[^\n]* yyless(9); yy_pop_state(); return tCPPQUOTE; -<PP_PRAGMA>winrt[^\n]* { - if (!list_empty( &import_stack )) - { - if(!winrt_mode) - error_loc("winrt IDL file imported in non-winrt mode\n"); - }else { - const char *ptr = yytext+5; - - winrt_mode = TRUE; - - while(isspace(*ptr)) - ptr++; - if(!strncmp(ptr, "ns_prefix", 9) && (!*(ptr += 9) || isspace(*ptr))) - use_abi_namespace = TRUE; - } - yy_pop_state(); - } -<PP_PRAGMA>[^\n]* yylval->str = xstrdup(yytext); yy_pop_state(); return aPRAGMA; +<PP_PRAGMA>{ + midl_echo/"(" { + yy_pop_state(); + return tCPPQUOTE; + } + winrt{ws}+ns_prefix[^\n]* { + yy_pop_state(); + winrt_enable( TRUE ); + } + winrt[^\n]* { + yy_pop_state(); + winrt_enable( FALSE ); + } + [^\n]* { + yy_pop_state(); + return token_str( aPRAGMA, yytext, yylval ); + } +} +<PP_LINE>[0-9]+{ws}* { + line_number = strtoul( yytext, NULL, 10 ) - 1; /* We didn't read the newline */ + yy_pop_state(); + yy_push_state(PP_FILE); + } +<PP_FILE>"(\.|[^"\])*"{ws}* { + input_name = xstrdup( yytext + 1 ); + *strchr( input_name, '"' ) = 0; + } +<PP_FILE>[^"][^\n]* { yy_pop_state(); }
<ATTR>{ ] { yy_pop_state(); return ']'; }
From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/parser.l | 452 ++++++++++++++++++++------------------------ tools/widl/parser.y | 14 +- 2 files changed, 208 insertions(+), 258 deletions(-)
diff --git a/tools/widl/parser.l b/tools/widl/parser.l index 536253aeca2..1307e3eff53 100644 --- a/tools/widl/parser.l +++ b/tools/widl/parser.l @@ -27,7 +27,6 @@ ws [ \f\t\r] hd [0-9a-fA-F] uuid {hd}{8}-{hd}{4}-{hd}{4}-{hd}{4}-{hd}{12} -cident [a-zA-Z_][0-9a-zA-Z_]*
%x ATTR %x PP_LINE @@ -59,9 +58,6 @@ cident [a-zA-Z_][0-9a-zA-Z_]*
#include "parser.tab.h"
-static int kw_token(const char *kw, YYSTYPE *yylval); -static int attr_token(const char *kw, YYSTYPE *yylval); - static void switch_to_acf(void);
static warning_list_t *disabled_warnings = NULL; @@ -154,6 +150,17 @@ static int token_num( int token, const char *yytext, YYSTYPE *yylval ) return token; }
+static int token_ident( const char *str, YYSTYPE *yylval ) +{ + return token_str( is_type( str ) ? aKNOWNTYPE : aIDENTIFIER, str, yylval ); +} + +static int token_winrt( int token, const char *str, YYSTYPE *yylval ) +{ + if (winrt_mode) return token; + return token_ident( str, yylval ); +} + static void winrt_enable( int ns_prefix ) { if (!list_empty( &import_stack ) && !winrt_mode) error_loc( "WinRT IDL file imported in non-winrt mode." ); @@ -203,7 +210,131 @@ static void winrt_enable( int ns_prefix ) ] { yy_pop_state(); return ']'; }
({uuid}|"{uuid}") { return token_uuid( yytext, yylval ); } - {cident} { return attr_token( yytext, yylval ); } + activatable { return token_winrt( tACTIVATABLE, yytext, yylval ); } + aggregatable { return tAGGREGATABLE; } + agile { return token_winrt( tAGILE, yytext, yylval ); } + all_nodes { return tALLNODES; } + allocate { return tALLOCATE; } + annotation { return tANNOTATION; } + apartment { return tAPARTMENT; } + appobject { return tAPPOBJECT; } + async { return tASYNC; } + async_uuid { return tASYNCUUID; } + auto_handle { return tAUTOHANDLE; } + bindable { return tBINDABLE; } + both { return tBOTH; } + broadcast { return tBROADCAST; } + byte_count { return tBYTECOUNT; } + call_as { return tCALLAS; } + callback { return tCALLBACK; } + code { return tCODE; } + comm_status { return tCOMMSTATUS; } + context_handle { return tCONTEXTHANDLE; } + context_handle_noserialize { return tCONTEXTHANDLENOSERIALIZE; } + context_handle_serialize { return tCONTEXTHANDLENOSERIALIZE; } + contract { return token_winrt( tCONTRACT, yytext, yylval ); } + contractversion { return token_winrt( tCONTRACTVERSION, yytext, yylval ); } + control { return tCONTROL; } + custom { return tCUSTOM; } + decode { return tDECODE; } + defaultbind { return tDEFAULTBIND; } + defaultcollelem { return tDEFAULTCOLLELEM; } + defaultvalue { return tDEFAULTVALUE; } + defaultvtable { return tDEFAULTVTABLE; } + disable_consistency_check { return tDISABLECONSISTENCYCHECK; } + displaybind { return tDISPLAYBIND; } + dllname { return tDLLNAME; } + dont_free { return tDONTFREE; } + dual { return tDUAL; } + enable_allocate { return tENABLEALLOCATE; } + encode { return tENCODE; } + endpoint { return tENDPOINT; } + entry { return tENTRY; } + eventadd { return token_winrt( tEVENTADD, yytext, yylval ); } + eventremove { return token_winrt( tEVENTREMOVE, yytext, yylval ); } + exclusiveto { return token_winrt( tEXCLUSIVETO, yytext, yylval ); } + explicit_handle { return tEXPLICITHANDLE; } + fault_status { return tFAULTSTATUS; } + flags { return token_winrt( tFLAGS, yytext, yylval ); } + force_allocate { return tFORCEALLOCATE; } + free { return tFREE; } + handle { return tHANDLE; } + helpcontext { return tHELPCONTEXT; } + helpfile { return tHELPFILE; } + helpstring { return tHELPSTRING; } + helpstringcontext { return tHELPSTRINGCONTEXT; } + helpstringdll { return tHELPSTRINGDLL; } + hidden { return tHIDDEN; } + id { return tID; } + idempotent { return tIDEMPOTENT; } + ignore { return tIGNORE; } + iid_is { return tIIDIS; } + immediatebind { return tIMMEDIATEBIND; } + implicit_handle { return tIMPLICITHANDLE; } + in { return tIN; } + in_line { return tIN_LINE; } + input_sync { return tINPUTSYNC; } + lcid { return tLCID; } + length_is { return tLENGTHIS; } + licensed { return tLICENSED; } + local { return tLOCAL; } + marshaling_behavior { return token_winrt( tMARSHALINGBEHAVIOR, yytext, yylval ); } + maybe { return tMAYBE; } + message { return tMESSAGE; } + mta { return tMTA; } + neutral { return tNEUTRAL; } + nocode { return tNOCODE; } + nonbrowsable { return tNONBROWSABLE; } + noncreatable { return tNONCREATABLE; } + none { return token_winrt( tNONE, yytext, yylval ); } + nonextensible { return tNONEXTENSIBLE; } + notify { return tNOTIFY; } + notify_flag { return tNOTIFYFLAG; } + object { return tOBJECT; } + odl { return tODL; } + oleautomation { return tOLEAUTOMATION; } + optimize { return tOPTIMIZE; } + optional { return tOPTIONAL; } + out { return tOUT; } + overload { return tOVERLOAD; } + partial_ignore { return tPARTIALIGNORE; } + pointer_default { return tPOINTERDEFAULT; } + progid { return tPROGID; } + propget { return tPROPGET; } + propput { return tPROPPUT; } + propputref { return tPROPPUTREF; } + proxy { return tPROXY; } + ptr { return tPTR; } + public { return tPUBLIC; } + range { return tRANGE; } + readonly { return tREADONLY; } + ref { return tREF; } + represent_as { return tREPRESENTAS; } + requestedit { return tREQUESTEDIT; } + restricted { return tRESTRICTED; } + retval { return tRETVAL; } + single { return tSINGLE; } + single_node { return tSINGLENODE; } + size_is { return tSIZEIS; } + source { return tSOURCE; } + standard { return token_winrt( tSTANDARD, yytext, yylval ); } + static { return token_winrt( tSTATIC, yytext, yylval ); } + strict_context_handle { return tSTRICTCONTEXTHANDLE; } + string { return tSTRING; } + switch_is { return tSWITCHIS; } + switch_type { return tSWITCHTYPE; } + threading { return tTHREADING; } + transmit_as { return tTRANSMITAS; } + uidefault { return tUIDEFAULT; } + unique { return tUNIQUE; } + user_marshal { return tUSERMARSHAL; } + usesgetlasterror { return tUSESGETLASTERROR; } + uuid { return tUUID; } + v1_enum { return tV1ENUM; } + vararg { return tVARARG; } + version { return tVERSION; } + vi_progid { return tVIPROGID; } + wire_marshal { return tWIREMARSHAL; } }
<INITIAL>{ @@ -217,12 +348,76 @@ static void winrt_enable( int ns_prefix ) }
SAFEARRAY{ws}*/( return tSAFEARRAY; -{cident} return kw_token(yytext, yylval);
<INITIAL,ATTR>{ ^{ws}*#{ws}* { yy_push_state(PP_LINE); } [ { yy_push_state(ATTR); return '['; }
+ FALSE { return tFALSE; } + NULL { return tNULL; } + TRUE { return tTRUE; } + __cdecl { return tCDECL; } + __fastcall { return tFASTCALL; } + __int32 { return tINT32; } + __int3264 { return tINT3264; } + __int64 { return tINT64; } + __pascal { return tPASCAL; } + __stdcall { return tSTDCALL; } + _cdecl { return tCDECL; } + _fastcall { return tFASTCALL; } + _pascal { return tPASCAL; } + _stdcall { return tSTDCALL; } + apicontract { return token_winrt( tAPICONTRACT, yytext, yylval ); } + boolean { return tBOOLEAN; } + byte { return tBYTE; } + case { return tCASE; } + cdecl { return tCDECL; } + char { return tCHAR; } + coclass { return tCOCLASS; } + const { return tCONST; } + cpp_quote { return tCPPQUOTE; } + declare { return token_winrt( tDECLARE, yytext, yylval ); } + default { return tDEFAULT; } + delegate { return token_winrt( tDELEGATE, yytext, yylval ); } + dispinterface { return tDISPINTERFACE; } + double { return tDOUBLE; } + enum { return tENUM; } + error_status_t { return tERRORSTATUST; } + extern { return tEXTERN; } + float { return tFLOAT; } + handle_t { return tHANDLET; } + hyper { return tHYPER; } + import { return tIMPORT; } + importlib { return tIMPORTLIB; } + inline { return tINLINE; } + int { return tINT; } + interface { return tINTERFACE; } + library { return tLIBRARY; } + long { return tLONG; } + methods { return tMETHODS; } + module { return tMODULE; } + namespace { return token_winrt( tNAMESPACE, yytext, yylval ); } + pascal { return tPASCAL; } + properties { return tPROPERTIES; } + register { return tREGISTER; } + requires { return token_winrt( tREQUIRES, yytext, yylval ); } + runtimeclass { return token_winrt( tRUNTIMECLASS, yytext, yylval ); } + short { return tSHORT; } + signed { return tSIGNED; } + sizeof { return tSIZEOF; } + small { return tSMALL; } + static { return tSTATIC; } + stdcall { return tSTDCALL; } + struct { return tSTRUCT; } + switch { return tSWITCH; } + typedef { return tTYPEDEF; } + union { return tUNION; } + unsigned { return tUNSIGNED; } + void { return tVOID; } + wchar_t { return tWCHAR; } + + [a-zA-Z_][0-9a-zA-Z_]* { return token_ident( yytext, yylval ); } + 0[xX]{hd}+([lL][uU]?|[uU][lL]?)? { return token_num( aHEXNUM, yytext, yylval ); } [0-9]+([lL][uU]?|[uU][lL]?)? { return token_num( aNUM, yytext, yylval ); }
@@ -257,251 +452,6 @@ SAFEARRAY{ws}*/( return tSAFEARRAY; } %%
-struct keyword { - const char *kw; - int token; - int winrt_only : 1; -}; - -/* This table MUST be alphabetically sorted on the kw field */ -static const struct keyword keywords[] = { - {"FALSE", tFALSE, 0}, - {"NULL", tNULL, 0}, - {"TRUE", tTRUE, 0}, - {"__cdecl", tCDECL, 0}, - {"__fastcall", tFASTCALL, 0}, - {"__int32", tINT32, 0}, - {"__int3264", tINT3264, 0}, - {"__int64", tINT64, 0}, - {"__pascal", tPASCAL, 0}, - {"__stdcall", tSTDCALL, 0}, - {"_cdecl", tCDECL, 0}, - {"_fastcall", tFASTCALL, 0}, - {"_pascal", tPASCAL, 0}, - {"_stdcall", tSTDCALL, 0}, - {"apicontract", tAPICONTRACT, 1}, - {"boolean", tBOOLEAN, 0}, - {"byte", tBYTE, 0}, - {"case", tCASE, 0}, - {"cdecl", tCDECL, 0}, - {"char", tCHAR, 0}, - {"coclass", tCOCLASS, 0}, - {"const", tCONST, 0}, - {"cpp_quote", tCPPQUOTE, 0}, - {"declare", tDECLARE, 1}, - {"default", tDEFAULT, 0}, - {"delegate", tDELEGATE, 1}, - {"dispinterface", tDISPINTERFACE, 0}, - {"double", tDOUBLE, 0}, - {"enum", tENUM, 0}, - {"error_status_t", tERRORSTATUST, 0}, - {"extern", tEXTERN, 0}, - {"float", tFLOAT, 0}, - {"handle_t", tHANDLET, 0}, - {"hyper", tHYPER, 0}, - {"import", tIMPORT, 0}, - {"importlib", tIMPORTLIB, 0}, - {"inline", tINLINE, 0}, - {"int", tINT, 0}, - {"interface", tINTERFACE, 0}, - {"library", tLIBRARY, 0}, - {"long", tLONG, 0}, - {"methods", tMETHODS, 0}, - {"module", tMODULE, 0}, - {"namespace", tNAMESPACE, 1}, - {"pascal", tPASCAL, 0}, - {"properties", tPROPERTIES, 0}, - {"register", tREGISTER, 0}, - {"requires", tREQUIRES, 1}, - {"runtimeclass", tRUNTIMECLASS, 1}, - {"short", tSHORT, 0}, - {"signed", tSIGNED, 0}, - {"sizeof", tSIZEOF, 0}, - {"small", tSMALL, 0}, - {"static", tSTATIC, 0}, - {"stdcall", tSTDCALL, 0}, - {"struct", tSTRUCT, 0}, - {"switch", tSWITCH, 0}, - {"typedef", tTYPEDEF, 0}, - {"union", tUNION, 0}, - {"unsigned", tUNSIGNED, 0}, - {"void", tVOID, 0}, - {"wchar_t", tWCHAR, 0}, -}; -#define NKEYWORDS (sizeof(keywords)/sizeof(keywords[0])) - -/* keywords only recognized in attribute lists - * This table MUST be alphabetically sorted on the kw field - */ -static const struct keyword attr_keywords[] = -{ - {"activatable", tACTIVATABLE, 1}, - {"aggregatable", tAGGREGATABLE, 0}, - {"agile", tAGILE, 1}, - {"all_nodes", tALLNODES, 0}, - {"allocate", tALLOCATE, 0}, - {"annotation", tANNOTATION, 0}, - {"apartment", tAPARTMENT, 0}, - {"appobject", tAPPOBJECT, 0}, - {"async", tASYNC, 0}, - {"async_uuid", tASYNCUUID, 0}, - {"auto_handle", tAUTOHANDLE, 0}, - {"bindable", tBINDABLE, 0}, - {"both", tBOTH, 0}, - {"broadcast", tBROADCAST, 0}, - {"byte_count", tBYTECOUNT, 0}, - {"call_as", tCALLAS, 0}, - {"callback", tCALLBACK, 0}, - {"code", tCODE, 0}, - {"comm_status", tCOMMSTATUS, 0}, - {"context_handle", tCONTEXTHANDLE, 0}, - {"context_handle_noserialize", tCONTEXTHANDLENOSERIALIZE, 0}, - {"context_handle_serialize", tCONTEXTHANDLENOSERIALIZE, 0}, - {"contract", tCONTRACT, 1}, - {"contractversion", tCONTRACTVERSION, 1}, - {"control", tCONTROL, 0}, - {"custom", tCUSTOM, 0}, - {"decode", tDECODE, 0}, - {"defaultbind", tDEFAULTBIND, 0}, - {"defaultcollelem", tDEFAULTCOLLELEM, 0}, - {"defaultvalue", tDEFAULTVALUE, 0}, - {"defaultvtable", tDEFAULTVTABLE, 0}, - {"disable_consistency_check", tDISABLECONSISTENCYCHECK, 0}, - {"displaybind", tDISPLAYBIND, 0}, - {"dllname", tDLLNAME, 0}, - {"dont_free", tDONTFREE, 0}, - {"dual", tDUAL, 0}, - {"enable_allocate", tENABLEALLOCATE, 0}, - {"encode", tENCODE, 0}, - {"endpoint", tENDPOINT, 0}, - {"entry", tENTRY, 0}, - {"eventadd", tEVENTADD, 1}, - {"eventremove", tEVENTREMOVE, 1}, - {"exclusiveto", tEXCLUSIVETO, 1}, - {"explicit_handle", tEXPLICITHANDLE, 0}, - {"fault_status", tFAULTSTATUS, 0}, - {"flags", tFLAGS, 1}, - {"force_allocate", tFORCEALLOCATE, 0}, - {"free", tFREE, 0}, - {"handle", tHANDLE, 0}, - {"helpcontext", tHELPCONTEXT, 0}, - {"helpfile", tHELPFILE, 0}, - {"helpstring", tHELPSTRING, 0}, - {"helpstringcontext", tHELPSTRINGCONTEXT, 0}, - {"helpstringdll", tHELPSTRINGDLL, 0}, - {"hidden", tHIDDEN, 0}, - {"id", tID, 0}, - {"idempotent", tIDEMPOTENT, 0}, - {"ignore", tIGNORE, 0}, - {"iid_is", tIIDIS, 0}, - {"immediatebind", tIMMEDIATEBIND, 0}, - {"implicit_handle", tIMPLICITHANDLE, 0}, - {"in", tIN, 0}, - {"in_line", tIN_LINE, 0}, - {"input_sync", tINPUTSYNC, 0}, - {"lcid", tLCID, 0}, - {"length_is", tLENGTHIS, 0}, - {"licensed", tLICENSED, 0}, - {"local", tLOCAL, 0}, - {"marshaling_behavior", tMARSHALINGBEHAVIOR, 1}, - {"maybe", tMAYBE, 0}, - {"message", tMESSAGE, 0}, - {"mta" , tMTA, 0}, - {"neutral", tNEUTRAL, 0}, - {"nocode", tNOCODE, 0}, - {"nonbrowsable", tNONBROWSABLE, 0}, - {"noncreatable", tNONCREATABLE, 0}, - {"none", tNONE, 1}, - {"nonextensible", tNONEXTENSIBLE, 0}, - {"notify", tNOTIFY, 0}, - {"notify_flag", tNOTIFYFLAG, 0}, - {"object", tOBJECT, 0}, - {"odl", tODL, 0}, - {"oleautomation", tOLEAUTOMATION, 0}, - {"optimize", tOPTIMIZE, 0}, - {"optional", tOPTIONAL, 0}, - {"out", tOUT, 0}, - {"overload", tOVERLOAD, 0}, - {"partial_ignore", tPARTIALIGNORE, 0}, - {"pointer_default", tPOINTERDEFAULT, 0}, - {"progid", tPROGID, 0}, - {"propget", tPROPGET, 0}, - {"propput", tPROPPUT, 0}, - {"propputref", tPROPPUTREF, 0}, - {"proxy", tPROXY, 0}, - {"ptr", tPTR, 0}, - {"public", tPUBLIC, 0}, - {"range", tRANGE, 0}, - {"readonly", tREADONLY, 0}, - {"ref", tREF, 0}, - {"represent_as", tREPRESENTAS, 0}, - {"requestedit", tREQUESTEDIT, 0}, - {"restricted", tRESTRICTED, 0}, - {"retval", tRETVAL, 0}, - {"single", tSINGLE, 0}, - {"single_node", tSINGLENODE, 0}, - {"size_is", tSIZEIS, 0}, - {"source", tSOURCE, 0}, - {"standard", tSTANDARD, 1}, - {"static", tSTATIC, 1}, - {"strict_context_handle", tSTRICTCONTEXTHANDLE, 0}, - {"string", tSTRING, 0}, - {"switch_is", tSWITCHIS, 0}, - {"switch_type", tSWITCHTYPE, 0}, - {"threading", tTHREADING, 0}, - {"transmit_as", tTRANSMITAS, 0}, - {"uidefault", tUIDEFAULT, 0}, - {"unique", tUNIQUE, 0}, - {"user_marshal", tUSERMARSHAL, 0}, - {"usesgetlasterror", tUSESGETLASTERROR, 0}, - {"uuid", tUUID, 0}, - {"v1_enum", tV1ENUM, 0}, - {"vararg", tVARARG, 0}, - {"version", tVERSION, 0}, - {"vi_progid", tVIPROGID, 0}, - {"wire_marshal", tWIREMARSHAL, 0}, -}; - -/* attributes TODO: - first_is - last_is - max_is - min_is -*/ - -#define KWP(p) ((const struct keyword *)(p)) - -static int kw_cmp_func(const void *s1, const void *s2) -{ - return strcmp(KWP(s1)->kw, KWP(s2)->kw); -} - -static int kw_token(const char *kw, YYSTYPE *yylval) -{ - struct keyword key, *kwp; - key.kw = kw; - kwp = bsearch(&key, keywords, NKEYWORDS, sizeof(keywords[0]), kw_cmp_func); - if (kwp && (!kwp->winrt_only || winrt_mode)) { - yylval->str = xstrdup(kwp->kw); - return kwp->token; - } - yylval->str = xstrdup(kw); - return is_type(kw) ? aKNOWNTYPE : aIDENTIFIER; -} - -static int attr_token(const char *kw, YYSTYPE *yylval) -{ - struct keyword key, *kwp; - key.kw = kw; - kwp = bsearch(&key, attr_keywords, sizeof(attr_keywords)/sizeof(attr_keywords[0]), - sizeof(attr_keywords[0]), kw_cmp_func); - if (kwp && (!kwp->winrt_only || winrt_mode)) { - yylval->str = xstrdup(kwp->kw); - return kwp->token; - } - return kw_token(kw, yylval); -} - void pop_import(void) { struct list *entry = list_head( &import_stack ); diff --git a/tools/widl/parser.y b/tools/widl/parser.y index a48a8ca54f3..8954033206a 100644 --- a/tools/widl/parser.y +++ b/tools/widl/parser.y @@ -934,17 +934,17 @@ typename: aIDENTIFIER ident: typename { $$ = make_var($1); } ;
-base_type: tBYTE { $$ = find_type_or_error(NULL, $<str>1); } - | tWCHAR { $$ = find_type_or_error(NULL, $<str>1); } +base_type: tBYTE { $$ = find_type_or_error( NULL, "byte" ); } + | tWCHAR { $$ = find_type_or_error( NULL, "wchar_t" ); } | int_std | tSIGNED int_std { $$ = type_new_int(type_basic_get_type($2), -1); } | tUNSIGNED int_std { $$ = type_new_int(type_basic_get_type($2), 1); } | tUNSIGNED { $$ = type_new_int(TYPE_BASIC_INT, 1); } - | tFLOAT { $$ = find_type_or_error(NULL, $<str>1); } - | tDOUBLE { $$ = find_type_or_error(NULL, $<str>1); } - | tBOOLEAN { $$ = find_type_or_error(NULL, $<str>1); } - | tERRORSTATUST { $$ = find_type_or_error(NULL, $<str>1); } - | tHANDLET { $$ = find_type_or_error(NULL, $<str>1); } + | tFLOAT { $$ = find_type_or_error( NULL, "float" ); } + | tDOUBLE { $$ = find_type_or_error( NULL, "double" ); } + | tBOOLEAN { $$ = find_type_or_error( NULL, "boolean" ); } + | tERRORSTATUST { $$ = find_type_or_error( NULL, "error_status_t" ); } + | tHANDLET { $$ = find_type_or_error( NULL, "handle_t" ); } ;
m_int
From: Rémi Bernon rbernon@codeweavers.com
--- tools/widl/parser.l | 15 ++++----------- tools/widl/parser.y | 19 +++++++++++-------- 2 files changed, 15 insertions(+), 19 deletions(-)
diff --git a/tools/widl/parser.l b/tools/widl/parser.l index 1307e3eff53..96e99d77337 100644 --- a/tools/widl/parser.l +++ b/tools/widl/parser.l @@ -356,22 +356,17 @@ SAFEARRAY{ws}*/( return tSAFEARRAY; FALSE { return tFALSE; } NULL { return tNULL; } TRUE { return tTRUE; } - __cdecl { return tCDECL; } - __fastcall { return tFASTCALL; } + _?_?cdecl { return token_str( tCDECL, "__cdecl", yylval ); } + _?_?pascal { return token_str( tPASCAL, "__pascal", yylval ); } + _?_?stdcall { return token_str( tSTDCALL, "__stdcall", yylval ); } + __?fastcall { return token_str( tFASTCALL, "__fastcall", yylval ); } __int32 { return tINT32; } __int3264 { return tINT3264; } __int64 { return tINT64; } - __pascal { return tPASCAL; } - __stdcall { return tSTDCALL; } - _cdecl { return tCDECL; } - _fastcall { return tFASTCALL; } - _pascal { return tPASCAL; } - _stdcall { return tSTDCALL; } apicontract { return token_winrt( tAPICONTRACT, yytext, yylval ); } boolean { return tBOOLEAN; } byte { return tBYTE; } case { return tCASE; } - cdecl { return tCDECL; } char { return tCHAR; } coclass { return tCOCLASS; } const { return tCONST; } @@ -397,7 +392,6 @@ SAFEARRAY{ws}*/( return tSAFEARRAY; methods { return tMETHODS; } module { return tMODULE; } namespace { return token_winrt( tNAMESPACE, yytext, yylval ); } - pascal { return tPASCAL; } properties { return tPROPERTIES; } register { return tREGISTER; } requires { return token_winrt( tREQUIRES, yytext, yylval ); } @@ -407,7 +401,6 @@ SAFEARRAY{ws}*/( return tSAFEARRAY; sizeof { return tSIZEOF; } small { return tSMALL; } static { return tSTATIC; } - stdcall { return tSTDCALL; } struct { return tSTRUCT; } switch { return tSWITCH; } typedef { return tTYPEDEF; } diff --git a/tools/widl/parser.y b/tools/widl/parser.y index 8954033206a..1176c2427a1 100644 --- a/tools/widl/parser.y +++ b/tools/widl/parser.y @@ -167,6 +167,10 @@ int parser_lex( PARSER_STYPE *yylval ); %token <num> aNUM aHEXNUM %token <dbl> aDOUBLE %token <str> aSTRING aWSTRING aSQSTRING +%token <str> tCDECL +%token <str> tFASTCALL +%token <str> tPASCAL +%token <str> tSTDCALL %token <uuid> aUUID %token aEOF aACF %token SHL SHR @@ -182,7 +186,7 @@ int parser_lex( PARSER_STYPE *yylval ); %token tAPICONTRACT %token tAPPOBJECT tASYNC tASYNCUUID %token tAUTOHANDLE tBINDABLE tBOOLEAN tBROADCAST tBYTE tBYTECOUNT -%token tCALLAS tCALLBACK tCASE tCDECL tCHAR tCOCLASS tCODE tCOMMSTATUS +%token tCALLAS tCALLBACK tCASE tCHAR tCOCLASS tCODE tCOMMSTATUS %token tCONST tCONTEXTHANDLE tCONTEXTHANDLENOSERIALIZE %token tCONTEXTHANDLESERIALIZE %token tCONTRACT @@ -204,7 +208,7 @@ int parser_lex( PARSER_STYPE *yylval ); %token tEXCLUSIVETO %token tEXPLICITHANDLE tEXTERN %token tFALSE -%token tFASTCALL tFAULTSTATUS +%token tFAULTSTATUS %token tFLAGS %token tFLOAT tFORCEALLOCATE %token tHANDLE @@ -241,7 +245,7 @@ int parser_lex( PARSER_STYPE *yylval ); %token tOPTIMIZE tOPTIONAL %token tOUT %token tOVERLOAD -%token tPARTIALIGNORE tPASCAL +%token tPARTIALIGNORE %token tPOINTERDEFAULT %token tPRAGMA_WARNING %token tPROGID tPROPERTIES @@ -264,7 +268,6 @@ int parser_lex( PARSER_STYPE *yylval ); %token tSOURCE %token tSTANDARD %token tSTATIC -%token tSTDCALL %token tSTRICTCONTEXTHANDLE %token tSTRING tSTRUCT %token tSWITCH tSWITCHIS tSWITCHTYPE @@ -729,10 +732,10 @@ attribute | pointer_type { $$ = make_attrv(ATTR_POINTERTYPE, $1); } ;
-callconv: tCDECL { $$ = xstrdup("__cdecl"); } - | tFASTCALL { $$ = xstrdup("__fastcall"); } - | tPASCAL { $$ = xstrdup("__pascal"); } - | tSTDCALL { $$ = xstrdup("__stdcall"); } +callconv: tCDECL + | tFASTCALL + | tPASCAL + | tSTDCALL ;
cases
Jacek Caban (@jacek) commented about tools/widl/parser.l:
}- winrt[^\n]* {
yy_pop_state();winrt_enable( FALSE );}- [^\n]* {
yy_pop_state();return token_str( aPRAGMA, yytext, yylval );}+} +<PP_LINE>[0-9]+{ws}* {
line_number = strtoul( yytext, NULL, 10 ) - 1; /* We didn't read the newline */yy_pop_state();yy_push_state(PP_FILE);}+<PP_FILE>"(\.|[^"\])*"{ws}* {
I think that \n should not be allowed in the quoted file name.
-
Jacek Caban (＠jacek) -
Rémi Bernon
-
Rémi Bernon (＠rbernon)