Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696/* -*-C-*- * IDL Compiler * * Copyright 2002 Ove Kaaven * * 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 bison-bridge%option bison-locations%option stack%option noinput nounput noyy_top_state%option noyywrap%option 8bit never-interactive prefix="parser_"ws [ \f\t\r]hd [0-9a-fA-F]uuid {hd}{8}-{hd}{4}-{hd}{4}-{hd}{4}-{hd}{12}%x ATTR%x PP_LINE%x PP_FILE%x PP_PRAGMA%{#include "config.h"#include <stdio.h>#include <stdlib.h>#include <string.h>#include <ctype.h>#include <assert.h>#include <errno.h>#include <limits.h>#define YY_NO_UNISTD_H#include "widl.h"#include "utils.h"#include "parser.h"#include "wpp_private.h"#define YYerror PARSER_error#define YYSTYPE PARSER_STYPE#define YYLTYPE PARSER_LTYPE#define YYUNDEF PARSER_UNDEF#define yyerror parser_error#include "parser.tab.h"static void reset_location( struct location *where, const char *input_name );static void update_location( struct location *where, const char *yytext );static void end_of_line( struct location *where );#define YY_USER_INIT reset_location( yylloc, input_name )#define YY_USER_ACTION update_location( yylloc, yytext );static void switch_to_acf(void);static warning_list_t *disabled_warnings = NULL;struct import_state{ YY_BUFFER_STATE buffer; char *input_name; struct location where; struct list entry;};static struct list import_stack = LIST_INIT( import_stack );int parse_only = 0;struct import{ const char *name; struct list entry;};static struct list imports = LIST_INIT( imports );static struct location previous_location;/* converts an integer in string form to an unsigned long and prints an error * on overflow */static unsigned int xstrtoul(const char *nptr, char **endptr, int base){ unsigned long val; errno = 0; val = strtoul(nptr, endptr, base); if ((val == ULONG_MAX && errno == ERANGE) || ((unsigned int)val != val)) error_loc("integer constant %s is too large\n", nptr); return val;}static int token_uuid( const char *str, YYSTYPE *yylval ){ 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 ){ char *tmp = xstrdup( str ); if (token == aWSTRING || token == aSTRING || token == aSQSTRING) { char *src, *dst; src = dst = ++tmp; /* skip first quote */ while (*src) { if (*src == '\\') src++; *dst++ = *src++; } dst[-1] = 0; /* strip last quote */ } yylval->str = tmp; return token;}static int token_num( const char *yytext, YYSTYPE *yylval, int is_hex ){ yylval->integer.value = xstrtoul( yytext, NULL, 0 ); yylval->integer.is_hex = is_hex; yylval->integer.is_long = !!strchr(yytext, 'l'); yylval->integer.is_unsigned = !!strchr(yytext, 'u'); return is_hex ? aHEXNUM : aNUM;}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.\n" ); use_abi_namespace = ns_prefix; winrt_mode = TRUE;}%}/* ************************************************************************** * The flexer starts here ************************************************************************** */%%<PP_PRAGMA>{ midl_echo/"(" { yy_pop_state(); yylloc->first_line -= 1; return tCPPQUOTE; } winrt{ws}+ns_prefix[^\n]* { yy_pop_state(); yylloc->first_line -= 1; winrt_enable( TRUE ); } winrt[^\n]* { yy_pop_state(); yylloc->first_line -= 1; winrt_enable( FALSE ); } [^\n]* { yy_pop_state(); yylloc->first_line -= 1; return token_str( aPRAGMA, yytext, yylval ); }}<PP_LINE>[0-9]+{ws}* { yylloc->first_line = strtoul( yytext, NULL, 10 ) - 1; yylloc->last_line = yylloc->first_line; yy_pop_state(); yy_push_state(PP_FILE); }<PP_FILE>\"(\\[^n]|[^"\\\n])*\"{ws}* { input_name = xstrdup( yytext + 1 ); *strchr( input_name, '"' ) = 0; yylloc->input_name = input_name; }<PP_FILE>[^"][^\n]* { yy_pop_state(); }<ATTR>{ \] { yy_pop_state(); return ']'; } ({uuid}|\"{uuid}\") { return token_uuid( 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; } composable { return token_winrt( tCOMPOSABLE, yytext, yylval ); } 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; } default_overload { return tDEFAULT_OVERLOAD; } defaultbind { return tDEFAULTBIND; } defaultcollelem { return tDEFAULTCOLLELEM; } defaultvalue { return tDEFAULTVALUE; } defaultvtable { return tDEFAULTVTABLE; } deprecated { return token_winrt( tDEPRECATED, yytext, yylval ); } 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; } protected { return tPROTECTED; } 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>{ ^{ws}*\#{ws}*pragma{ws}+ { yy_push_state( PP_PRAGMA ); } ^{ws}*midl_pragma{ws}+warning { return tPRAGMA_WARNING; } [0-9]+\.[0-9]+([eE][+-]?[0-9]+)* { yylval->dbl = strtod( yytext, NULL ); return aDOUBLE; }}SAFEARRAY{ws}*/\( return tSAFEARRAY;<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 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; } apicontract { return token_winrt( tAPICONTRACT, yytext, yylval ); } boolean { return tBOOLEAN; } byte { return tBYTE; } case { return tCASE; } 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 ); } 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; } 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}+[uU]?[lL]? { return token_num( yytext, yylval, TRUE ); } [0-9]+[uU]?[lL]? { return token_num( yytext, yylval, FALSE ); } L\"(\\.|[^"\\])*\" { return token_str( aWSTRING, yytext + 1, yylval ); } \"(\\.|[^"\\])*\" { return token_str( aSTRING, yytext, yylval ); } \'(\\.|[^'\\])*\' { return token_str( aSQSTRING, yytext, yylval ); } \n { end_of_line( yylloc ); } {ws} {} \<\< { return SHL; } \>\> { return SHR; } \-\> { return MEMBERPTR; } == { return EQUALITY; } != { return INEQUALITY; } \>= { return GREATEREQUAL; } \<= { return LESSEQUAL; } \|\| { return LOGICALOR; } && { return LOGICALAND; } \.\.\. { return ELLIPSIS; } . { return yytext[0]; }}<<EOF>> { if (!list_empty( &import_stack )) return aEOF; if (acf_name) { switch_to_acf(); return aACF; } yyterminate(); }%%static void print_imports(void){ struct import_state *state, *next; if (list_empty( &import_stack )) return; fprintf( stderr, "In file included from " ); LIST_FOR_EACH_ENTRY_SAFE_REV( state, next, &import_stack, struct import_state, entry ) { if (&next->entry == &import_stack) break; fprintf( stderr, "%s:%d,\n", state->input_name, state->where.first_line ); fprintf( stderr, " from "); } fprintf( stderr, "%s:%d:\n", state->input_name, state->where.first_line );}struct location pop_import(void){ struct list *entry = list_head( &import_stack ); struct import_state *state; struct location where; assert( entry ); state = LIST_ENTRY( entry, struct import_state, entry ); list_remove( &state->entry ); parse_only = !list_empty( &import_stack ); if (yyin) fclose( yyin ); yy_delete_buffer( YY_CURRENT_BUFFER ); yy_switch_to_buffer( state->buffer ); input_name = state->input_name; where = state->where; free( state ); return where;}void push_import( const char *import_name, struct location *where ){ struct import_state *state; struct import *import; FILE *file; state = xmalloc( sizeof(struct import_state )); list_add_head( &import_stack, &state->entry ); parse_only = !list_empty( &import_stack ); state->buffer = YY_CURRENT_BUFFER; state->input_name = input_name; state->where = *where; input_name = NULL; /* reset buffer for <<EOF>>, in case import fails or already imported */ yy_scan_string( "" ); LIST_FOR_EACH_ENTRY( import, &imports, struct import, entry ) if (!strcmp( import->name, import_name )) return; /* already imported */ if (!strcmp( idl_name, import_name )) return; /* already imported */ import = xmalloc( sizeof(struct import) ); import->name = xstrdup( import_name ); list_add_tail( &imports, &import->entry ); input_name = find_input_file( import_name, state->input_name ); file = open_input_file( input_name ); reset_location( where, input_name ); yy_switch_to_buffer( yy_create_buffer( file, YY_BUF_SIZE ) );}static void switch_to_acf(void){ FILE *file; if (yyin) fclose( yyin ); yy_delete_buffer( YY_CURRENT_BUFFER ); input_name = xstrdup( acf_name ); file = open_input_file( input_name ); acf_name = NULL; yy_switch_to_buffer( yy_create_buffer( file, YY_BUF_SIZE ) );}void close_all_inputs(void){ while (!list_empty( &import_stack )) pop_import(); if (yyin) fclose( yyin );}static void reset_location( struct location *where, const char *input_name ){ where->first_line = 1; where->last_line = 1; where->first_column = 1; where->last_column = 1; where->input_name = xstrdup( input_name );}static void update_location( struct location *where, const char *yytext ){ int len = strlen( yytext ); previous_location = *where; where->first_column = where->last_column; where->last_column += len;}static void end_of_line( struct location *where ){ where->first_line++; where->last_line++; where->first_column = 1; where->last_column = 1;}void init_location( struct location *where, const struct location *begin, const struct location *end ){ if (!begin) begin = &previous_location; *where = *begin; if (end) { where->last_line = end->last_line; where->last_column = end->last_column; } else { where->first_line = begin->last_line; where->first_column = begin->last_column; }}static void diagnostic( const struct location *where, const char *type, const char *message ){ char buffer[1024], *line = NULL; FILE *file; int i; if (!where) where = &previous_location; print_imports(); fprintf( stderr, "%s:%d:%d: %s: %s\n", where->input_name, where->first_line, where->first_column, type, message ); if (!where->input_name || !(file = fopen( where->input_name, "r" ))) return; for (i = 0; i < where->first_line; i++) if (!(line = fgets( buffer, sizeof(buffer), file ))) break; fclose( file ); if (!line) return; fprintf( stderr, "%s", line ); line = buffer; for (i = 0; i < where->first_column - 1; i++) *line++ = ' '; *line++ = '^'; for (i = where->first_column + 1; i < where->last_column; i++) *line++ = '~'; *line = '\0'; fprintf( stderr, "%s\n", buffer );}void parser_error( const struct location *where, const char *message ){ diagnostic( where, "error", message );}void parser_warning( const struct location *where, const char *message ){ diagnostic( where, "warning", message );}static void warning_disable(int warning){ warning_t *warning_entry; LIST_FOR_EACH_ENTRY(warning_entry, disabled_warnings, warning_t, entry) if(warning_entry->num == warning) return; warning_entry = xmalloc( sizeof(*warning_entry) ); warning_entry->num = warning; list_add_tail(disabled_warnings, &warning_entry->entry);}static void warning_enable(int warning){ warning_t *warning_entry; LIST_FOR_EACH_ENTRY(warning_entry, disabled_warnings, warning_t, entry) if(warning_entry->num == warning) { list_remove(&warning_entry->entry); free(warning_entry); break; }}int do_warning(const char *toggle, warning_list_t *wnum){ warning_t *warning, *next; int ret = 1; if(!disabled_warnings) { disabled_warnings = xmalloc( sizeof(*disabled_warnings) ); list_init( disabled_warnings ); } if(!strcmp(toggle, "disable")) LIST_FOR_EACH_ENTRY(warning, wnum, warning_t, entry) warning_disable(warning->num); else if(!strcmp(toggle, "enable") || !strcmp(toggle, "default")) LIST_FOR_EACH_ENTRY(warning, wnum, warning_t, entry) warning_enable(warning->num); else ret = 0; LIST_FOR_EACH_ENTRY_SAFE(warning, next, wnum, warning_t, entry) free(warning); return ret;}int is_warning_enabled(int warning){ warning_t *warning_entry; if(!disabled_warnings) return 1; LIST_FOR_EACH_ENTRY(warning_entry, disabled_warnings, warning_t, entry) if(warning_entry->num == warning) return 0; return 1;}