diff options
Diffstat (limited to 'dcop/dcopidl/yacc.yy')
| -rw-r--r-- | dcop/dcopidl/yacc.yy | 857 |
1 files changed, 857 insertions, 0 deletions
diff --git a/dcop/dcopidl/yacc.yy b/dcop/dcopidl/yacc.yy new file mode 100644 index 000000000..ca22c65e1 --- /dev/null +++ b/dcop/dcopidl/yacc.yy @@ -0,0 +1,857 @@ +%{ +/***************************************************************** +Copyright (c) 1999 Torben Weis <weis@kde.org> +Copyright (c) 2000 Matthias Ettrich <ettrich@kde.org> + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +******************************************************************/ + +#include <config.h> + +// Workaround for a bison issue: +// bison.simple concludes from _GNU_SOURCE that stpcpy is available, +// while GNU string.h only exposes it if __USE_GNU is set. +#ifdef _GNU_SOURCE +#define __USE_GNU 1 +#endif + +#include <stdlib.h> +#include <stdio.h> +#include <assert.h> + +#include <qstring.h> + +#define AMP_ENTITY "&" +#define YYERROR_VERBOSE + +extern int yylex(); + +// extern QString idl_lexFile; +extern int idl_line_no; +extern int function_mode; + +static int dcop_area = 0; +static int dcop_signal_area = 0; + +static QString in_namespace( "" ); + +void dcopidlInitFlex( const char *_code ); + +void yyerror( const char *s ) +{ + qDebug( "In line %i : %s", idl_line_no, s ); + exit(1); + // theParser->parse_error( idl_lexFile, s, idl_line_no ); +} + +%} + + +%union +{ + long _int; + QString *_str; + unsigned short _char; + double _float; +} + +%nonassoc T_UNIMPORTANT +%token <_char> T_CHARACTER_LITERAL +%token <_float> T_DOUBLE_LITERAL +%right <_str> T_IDENTIFIER +%token <_int> T_INTEGER_LITERAL +%token <_str> T_STRING_LITERAL +%token <_str> T_INCLUDE +%token T_CLASS +%token T_STRUCT +%token T_LEFT_CURLY_BRACKET +%token T_LEFT_PARANTHESIS +%token T_RIGHT_CURLY_BRACKET +%token T_RIGHT_PARANTHESIS +%token T_COLON +%token T_SEMICOLON +%token T_PUBLIC +%token T_PROTECTED +%token T_TRIPE_DOT +%token T_PRIVATE +%token T_VIRTUAL +%token T_CONST +%token T_INLINE +%token T_FRIEND +%token T_RETURN +%token T_SIGNAL +%token T_SLOT +%token T_TYPEDEF +%token T_PLUS +%token T_MINUS +%token T_COMMA +%right T_ASTERISK +%token T_TILDE +%token T_LESS +%token T_GREATER +%token T_AMPERSAND +%token T_EXTERN +%token T_EXTERN_C +%token T_ACCESS +%token T_ENUM +%token T_NAMESPACE +%token T_USING +%token T_UNKNOWN +%token T_TRIPLE_DOT +%token T_TRUE +%token T_FALSE +%token T_STATIC +%token T_MUTABLE +%token T_EQUAL +%token T_SCOPE +%token T_NULL +%token T_INT +%token T_ARRAY_OPEN +%token T_ARRAY_CLOSE +%token T_CHAR +%token T_DCOP +%token T_DCOP_AREA +%token T_DCOP_SIGNAL_AREA +%token T_SIGNED +%token T_UNSIGNED +%token T_LONG +%token T_SHORT +%token T_FUNOPERATOR +%token T_MISCOPERATOR +%token T_SHIFT + +%type <_str> body +%type <_str> class_header +%type <_str> super_classes +%type <_str> super_class +%type <_str> super_class_name +%type <_str> typedef +%type <_str> function +%type <_str> function_header +%type <_str> param +%type <_str> type +%type <_str> type_name +%type <_str> templ_type +%type <_str> templ_type_list +%type <_str> type_list +%type <_str> params +%type <_str> int_type +%type <_int> const_qualifier +%type <_int> virtual_qualifier +%type <_str> Identifier +%type <_int> dcoptag + +%% + +/*1*/ +main + : includes declaration main + { + } + | /* empty */ + ; + +includes + : includes T_INCLUDE + { + printf("<INCLUDE>%s</INCLUDE>\n", $2->latin1() ); + } + | T_EXTERN_C T_LEFT_CURLY_BRACKET main T_RIGHT_CURLY_BRACKET + { + } + | /* empty */ + { + } + ; + +dcoptag + : T_DCOP { $$ = 1; } + | /* empty */ { $$ = 0; } + ; + +declaration + : T_CLASS Identifier class_header dcoptag body T_SEMICOLON + { + if ($4) + printf("<CLASS>\n <NAME>%s</NAME>\n%s%s</CLASS>\n", ( in_namespace + *$2 ).latin1(), $3->latin1(), $5->latin1() ); + // default C++ visibility specifier is 'private' + dcop_area = 0; + dcop_signal_area = 0; + + } + | T_CLASS T_IDENTIFIER Identifier class_header dcoptag body T_SEMICOLON + { + if ($5) + printf("<CLASS>\n <NAME>%s</NAME>\n <LINK_SCOPE>%s</LINK_SCOPE>\n%s%s</CLASS>\n", ( in_namespace + *$3 ).latin1(),$2->latin1(), $4->latin1(), $6->latin1() ); + // default C++ visibility specifier is 'private' + dcop_area = 0; + dcop_signal_area = 0; + + } + | T_CLASS Identifier T_SEMICOLON + { + } + | T_STRUCT Identifier T_SEMICOLON + { + } + | T_STRUCT Identifier class_header body T_SEMICOLON + { + } + | T_NAMESPACE T_IDENTIFIER T_LEFT_CURLY_BRACKET + { + in_namespace += *$2; in_namespace += "::"; + } + main T_RIGHT_CURLY_BRACKET opt_semicolon + { + int pos = in_namespace.findRev( "::", -3 ); + if( pos >= 0 ) + in_namespace = in_namespace.left( pos + 2 ); + else + in_namespace = ""; + } + | T_USING T_NAMESPACE T_IDENTIFIER T_SEMICOLON + { + } + | T_USING T_IDENTIFIER T_SCOPE T_IDENTIFIER T_SEMICOLON + { + } + | T_EXTERN T_SEMICOLON + { + } + | T_TYPEDEF type Identifier T_SEMICOLON + { + } + | T_TYPEDEF T_STRUCT T_LEFT_CURLY_BRACKET member_list T_RIGHT_CURLY_BRACKET Identifier T_SEMICOLON + { + } + | T_TYPEDEF T_STRUCT Identifier T_LEFT_CURLY_BRACKET member_list T_RIGHT_CURLY_BRACKET Identifier T_SEMICOLON + { + } + | T_INLINE function + { + } + | function + { + } + | member + { + } + | enum + { + } + ; + +member_list + : member member_list + | /* empty */ + ; + +bool_value: T_TRUE | T_FALSE; + +nodcop_area: T_PRIVATE | T_PROTECTED | T_PUBLIC ; + +sigslot: T_SIGNAL | T_SLOT | ; + +nodcop_area_begin + : nodcop_area sigslot T_COLON + { + dcop_area = 0; + dcop_signal_area = 0; + } + | sigslot T_COLON + { + dcop_area = 0; + dcop_signal_area = 0; + } + ; + +dcop_area_begin + : T_DCOP_AREA T_COLON + { + dcop_area = 1; + dcop_signal_area = 0; + } + ; + +dcop_signal_area_begin + : T_DCOP_SIGNAL_AREA T_COLON + { + /* + A dcop signals area needs all dcop area capabilities, + e.g. parsing of function parameters. + */ + dcop_area = 1; + dcop_signal_area = 1; + } + ; + +Identifier + : T_IDENTIFIER %prec T_UNIMPORTANT { + $$ = $1; + } + | T_IDENTIFIER T_SCOPE Identifier { + QString* tmp = new QString( "%1::%2" ); + *tmp = tmp->arg(*($1)).arg(*($3)); + $$ = tmp; + } + ; + +super_class_name + : Identifier + { + QString* tmp = new QString( " <SUPER>%1</SUPER>\n" ); + *tmp = tmp->arg( *($1) ); + $$ = tmp; + } + | Identifier T_LESS type_list T_GREATER + { + QString* tmp = new QString( " <SUPER>%1</SUPER>\n" ); + *tmp = tmp->arg( *($1) + "<" + *($3) + ">" ); + $$ = tmp; + } + ; + +super_class + : virtual_qualifier T_PUBLIC super_class_name + { + $$ = $3; + } + | super_class_name + { + $$ = $1; + } + ; + +super_classes + : super_class T_LEFT_CURLY_BRACKET + { + $$ = $1; + } + | super_class T_COMMA super_classes + { + /* $$ = $1; */ + $$ = new QString( *($1) + *($3) ); + } + ; + +class_header + : T_COLON super_classes + { + $$ = $2; + } + | T_LEFT_CURLY_BRACKET + { + $$ = new QString( "" ); + } + ; + +opt_semicolon + : /* empty */ + { + } + | T_SEMICOLON + ; + +body + : T_RIGHT_CURLY_BRACKET + { + $$ = new QString( "" ); + } + | typedef body + { + $$ = new QString( *($1) + *($2) ); + } + | T_INLINE function body + { + $$ = new QString( *($2) + *($3) ); + } + | function body + { + $$ = new QString( *($1) + *($2) ); + } + | dcop_signal_area_begin body + { + $$ = $2; + } + | enum body + { + $$ = $2; + } + | dcop_area_begin body + { + $$ = $2; + } + | nodcop_area_begin body + { + $$ = $2; + } + | member body + { + $$ = $2; + } + | T_FRIEND T_CLASS Identifier T_SEMICOLON body + { + $$ = $5; + } + | T_FRIEND Identifier T_SEMICOLON body + { + $$ = $4; + } + | T_FRIEND function_header T_SEMICOLON body + { + $$ = $4; + } + | T_CLASS Identifier T_SEMICOLON body + { + $$ = $4; + } + | T_CLASS Identifier class_header body T_SEMICOLON body + { + $$ = $6; + } + | T_STRUCT Identifier T_SEMICOLON body + { + $$ = $4; + } + | T_STRUCT Identifier class_header body T_SEMICOLON body + { + $$ = $6; + } + | T_USING T_IDENTIFIER T_SCOPE T_IDENTIFIER T_SEMICOLON body + { + $$ = $6; + } + ; + +enum + : T_ENUM T_IDENTIFIER T_LEFT_CURLY_BRACKET enum_list T_RIGHT_CURLY_BRACKET T_IDENTIFIER T_SEMICOLON + | T_ENUM T_IDENTIFIER T_LEFT_CURLY_BRACKET enum_list T_RIGHT_CURLY_BRACKET T_SEMICOLON + | T_ENUM T_LEFT_CURLY_BRACKET enum_list T_RIGHT_CURLY_BRACKET T_IDENTIFIER T_SEMICOLON + | T_ENUM T_LEFT_CURLY_BRACKET enum_list T_RIGHT_CURLY_BRACKET T_SEMICOLON + ; + +enum_list + : enum_item T_COMMA enum_list + | enum_item + ; + +enum_item + : T_IDENTIFIER T_EQUAL int_expression {} + | T_IDENTIFIER {} + ; + +number + : T_CHARACTER_LITERAL {} + | T_INTEGER_LITERAL {} + | T_MINUS T_INTEGER_LITERAL {} + | T_NULL {} + | Identifier {} + ; + +int_expression + : number {} + | number T_PLUS number {} + | number T_SHIFT number {} + ; + +typedef + : T_TYPEDEF Identifier T_LESS type_list T_GREATER Identifier T_SEMICOLON + { + if (dcop_area) { + QString* tmp = new QString("<TYPEDEF name=\"%1\" template=\"%2\"><PARAM %3</TYPEDEF>\n"); + *tmp = tmp->arg( *($6) ).arg( *($2) ).arg( *($4) ); + $$ = tmp; + } else { + $$ = new QString(""); + } + } + | T_TYPEDEF Identifier T_LESS type_list T_GREATER T_SCOPE T_IDENTIFIER Identifier T_SEMICOLON + { + if (dcop_area) + yyerror("scoped template typedefs are not supported in dcop areas!"); + } + ; + +const_qualifier + : /* empty */ + { + $$ = 0; + } + | T_CONST + { + $$ = 1; + } + ; + +int_type + : T_SIGNED { $$ = new QString("signed int"); } + | T_SIGNED T_INT { $$ = new QString("signed int"); } + | T_UNSIGNED { $$ = new QString("unsigned int"); } + | T_UNSIGNED T_INT { $$ = new QString("unsigned int"); } + | T_SIGNED T_SHORT { $$ = new QString("signed short int"); } + | T_SIGNED T_SHORT T_INT { $$ = new QString("signed short int"); } + | T_SIGNED T_LONG { $$ = new QString("signed long int"); } + | T_SIGNED T_LONG T_INT { $$ = new QString("signed long int"); } + | T_UNSIGNED T_SHORT { $$ = new QString("unsigned short int"); } + | T_UNSIGNED T_SHORT T_INT { $$ = new QString("unsigned short int"); } + | T_UNSIGNED T_LONG { $$ = new QString("unsigned long int"); } + | T_UNSIGNED T_LONG T_INT { $$ = new QString("unsigned long int"); } + | T_INT { $$ = new QString("int"); } + | T_LONG { $$ = new QString("long int"); } + | T_LONG T_INT { $$ = new QString("long int"); } + | T_SHORT { $$ = new QString("short int"); } + | T_SHORT T_INT { $$ = new QString("short int"); } + | T_CHAR { $$ = new QString("char"); } + | T_SIGNED T_CHAR { $$ = new QString("signed char"); } + | T_UNSIGNED T_CHAR { $$ = new QString("unsigned char"); } + ; + +asterisks + : T_ASTERISK asterisks + | T_ASTERISK + ; + +params + : /* empty */ + { + $$ = new QString( "" ); + } + | param + | params T_COMMA param + { + $$ = new QString( *($1) + *($3) ); + } + ; + +/* Lowlevel definition of a type - doesn't include const, * nor & */ +type_name + : int_type + | Identifier { $$ = $1; } + | T_STRUCT Identifier { $$ = $2; } + | T_CLASS Identifier { $$ = $2; } + | Identifier T_LESS templ_type_list T_GREATER { + QString *tmp = new QString("%1<%2>"); + *tmp = tmp->arg(*($1)); + *tmp = tmp->arg(*($3)); + $$ = tmp; + } + | Identifier T_LESS templ_type_list T_GREATER T_SCOPE Identifier{ + QString *tmp = new QString("%1<%2>::%3"); + *tmp = tmp->arg(*($1)); + *tmp = tmp->arg(*($3)); + *tmp = tmp->arg(*($6)); + $$ = tmp; + } + ; + +/* List of types inside a template def like QMap< blah, blah > */ +templ_type_list + : templ_type T_COMMA templ_type_list + { + $$ = new QString(*($1) + "," + *($3)); + } + | templ_type + { + $$ = $1; + } + ; + +/* One type inside a template. No '&' or const here. */ +templ_type + : type_name asterisks + { + if (dcop_area) + yyerror("in dcop areas are no pointers allowed"); + } + | type_name + { + $$ = $1; + } + ; + +/* The hi-level, complete definition of a type, which also generates + the <TYPE> tag for it */ +type + : T_CONST type_name asterisks + { + if (dcop_area) + yyerror("in dcop areas are no pointers allowed"); + } + | T_CONST type_name T_AMPERSAND { + if (dcop_area) { + QString* tmp = new QString("<TYPE qleft=\"const\" qright=\"" AMP_ENTITY "\">%1</TYPE>"); + *tmp = tmp->arg( *($2) ); + $$ = tmp; + } + } + | T_CONST type_name %prec T_UNIMPORTANT { + QString* tmp = new QString("<TYPE>%1</TYPE>"); + *tmp = tmp->arg( *($2) ); + $$ = tmp; + } + | type_name T_CONST %prec T_UNIMPORTANT { + QString* tmp = new QString("<TYPE>%1</TYPE>"); + *tmp = tmp->arg( *($1) ); + $$ = tmp; + } + | type_name T_CONST T_AMPERSAND { + if (dcop_area) { + QString* tmp = new QString("<TYPE qleft=\"const\" qright=\"" AMP_ENTITY "\">%1</TYPE>"); + *tmp = tmp->arg( *($1) ); + $$ = tmp; + } + } + | type_name T_AMPERSAND { + if (dcop_area) + yyerror("in dcop areas are only const references allowed!"); + } + + | type_name %prec T_UNIMPORTANT { + QString* tmp = new QString("<TYPE>%1</TYPE>"); + *tmp = tmp->arg( *($1) ); + $$ = tmp; + } + | type_name asterisks + { + if (dcop_area) + yyerror("in dcop areas are no pointers allowed"); + } + ; + +type_list + : type T_COMMA type_list + { + $$ = new QString(*($1) + "," + *($3)); + } + | type + { + $$ = $1; + } + ; + +param + : type Identifier default + { + if (dcop_area) { + QString* tmp = new QString("\n <ARG>%1<NAME>%2</NAME></ARG>"); + *tmp = tmp->arg( *($1) ); + *tmp = tmp->arg( *($2) ); + $$ = tmp; + } else $$ = new QString(); + } + | type default + { + if (dcop_area) { + QString* tmp = new QString("\n <ARG>%1</ARG>"); + *tmp = tmp->arg( *($1) ); + $$ = tmp; + } else $$ = new QString(); + } + | T_TRIPLE_DOT + { + if (dcop_area) + yyerror("variable arguments not supported in dcop area."); + $$ = new QString(""); + } + ; + +default + : /* empty */ + { + } + | T_EQUAL value + { + } + | T_EQUAL T_LEFT_PARANTHESIS type T_RIGHT_PARANTHESIS value /* cast */ + { + } + ; + +/* Literal or calculated value, used for an initialization */ +value + : T_STRING_LITERAL + { + } + | int_expression + { + } + | T_DOUBLE_LITERAL + { + } + | bool_value + { + } + | Identifier T_LEFT_PARANTHESIS params T_RIGHT_PARANTHESIS + { + } + ; + +virtual_qualifier + : /* empty */ { $$ = 0; } + | T_VIRTUAL { $$ = 1; } + ; + +operator + : T_MISCOPERATOR | T_SHIFT | T_GREATER | T_LESS | T_EQUAL + ; + +function_header + : type Identifier T_LEFT_PARANTHESIS params T_RIGHT_PARANTHESIS const_qualifier + { + if (dcop_area || dcop_signal_area) { + QString* tmp = 0; + tmp = new QString( + " <%4>\n" + " %2\n" + " <NAME>%1</NAME>" + "%3\n" + " </%5>\n"); + *tmp = tmp->arg( *($2) ); + *tmp = tmp->arg( *($1) ); + *tmp = tmp->arg( *($4) ); + + QString tagname = (dcop_signal_area) ? "SIGNAL" : "FUNC"; + QString attr = ($6) ? " qual=\"const\"" : ""; + *tmp = tmp->arg( QString("%1%2").arg(tagname).arg(attr) ); + *tmp = tmp->arg( QString("%1").arg(tagname) ); + $$ = tmp; + } else + $$ = new QString(""); + } + | type T_FUNOPERATOR operator T_LEFT_PARANTHESIS params T_RIGHT_PARANTHESIS const_qualifier + { + if (dcop_area) + yyerror("operators aren't allowed in dcop areas!"); + $$ = new QString(""); + } + ; + +/* In an inline constructor: + List of values used as initialization for member var, or as params to parent constructor */ +values + : value {} + | value T_COMMA values {} + | /* empty */ {} + ; + +/* One initialization done by an inline constructor */ +init_item + : T_IDENTIFIER T_LEFT_PARANTHESIS values T_RIGHT_PARANTHESIS {} + ; + +/* List of initializations done by an inline constructor */ +init_list + : init_item {} + | init_item T_COMMA init_list {} + ; + +function + : function_header function_body + { + $$ = $1; + } + | T_VIRTUAL function_header T_EQUAL T_NULL function_body + { + $$ = $2; + } + | T_VIRTUAL function_header function_body + { + $$ = $2; + } + | Identifier T_LEFT_PARANTHESIS params T_RIGHT_PARANTHESIS function_body + { + /* The constructor */ + assert(!dcop_area); + $$ = new QString(""); + } + | Identifier T_LEFT_PARANTHESIS params T_RIGHT_PARANTHESIS T_COLON init_list function_body + { + /* The constructor */ + assert(!dcop_area); + $$ = new QString(""); + } + | virtual_qualifier T_TILDE Identifier T_LEFT_PARANTHESIS T_RIGHT_PARANTHESIS function_body + { + /* The destructor */ + assert(!dcop_area); + $$ = new QString(""); + } + | T_STATIC function_header function_body + { + if (dcop_area) { + if (dcop_signal_area) + yyerror("DCOP signals cannot be static"); + else + yyerror("DCOP functions cannot be static"); + } else { + $$ = new QString(); + } + } + ; + +function_begin : T_LEFT_CURLY_BRACKET + { + function_mode = 1; + } + ; + +function_body + : T_SEMICOLON + | function_begin function_lines T_RIGHT_CURLY_BRACKET + | function_begin function_lines T_RIGHT_CURLY_BRACKET T_SEMICOLON + ; + +function_lines + : function_line function_lines {} + | /* empty */ {} + ; + +function_line + : T_SEMICOLON /* dummy */ + ; + +Identifier_list_rest + : T_COMMA Identifier_list + | /* empty */ + ; + +Identifier_list_entry : T_IDENTIFIER {} + | T_IDENTIFIER T_EQUAL value {} + | asterisks T_IDENTIFIER {} + ; + +Identifier_list : Identifier_list_entry Identifier_list_rest {} + ; + +member + : type Identifier_list T_SEMICOLON {} + | type Identifier T_COLON T_INTEGER_LITERAL T_SEMICOLON {} + | T_STATIC type T_IDENTIFIER default T_SEMICOLON {} + | T_MUTABLE type T_IDENTIFIER default T_SEMICOLON {} + | type T_IDENTIFIER T_ARRAY_OPEN int_expression T_ARRAY_CLOSE T_SEMICOLON {} + | T_STATIC type T_IDENTIFIER T_ARRAY_OPEN int_expression T_ARRAY_CLOSE T_SEMICOLON {} + ; + +%% + +void dcopidlParse( const char *_code ) +{ + dcopidlInitFlex( _code ); + yyparse(); +} |