| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| %{ | |
| /* | |
| * scanner.ll - Lexical scanner for IDLC 1.0 | |
| */ | |
| #include <ctype.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #ifndef _IDLC_IDLC_HXX_ | |
| #include <idlc/idlc.hxx> | |
| #endif | |
| #ifndef _IDLC_ERRORHANDLER_HXX_ | |
| #include <idlc/errorhandler.hxx> | |
| #endif | |
| #ifndef _IDLC_FEHELPER_HXX_ | |
| #include <idlc/fehelper.hxx> | |
| #endif | |
| #include "attributeexceptions.hxx" | |
| class AstExpression; | |
| class AstArray; | |
| class AstMember; | |
| #include <parser.hxx> | |
| sal_Int32 beginLine = 0; | |
| ::rtl::OString docu; | |
| static int asciiToInteger(char const * s, sal_Int64 * sval, sal_uInt64 * uval) { | |
| bool neg = false; | |
| if (*s == '-') { | |
| neg = true; | |
| ++s; | |
| } | |
| unsigned int base = 10; | |
| if (*s == '0') { | |
| base = 8; | |
| ++s; | |
| if (*s == 'X' || *s == 'x') { | |
| base = 16; | |
| ++s; | |
| } | |
| } | |
| sal_uInt64 val = 0; | |
| for (; *s != 0; ++s) { | |
| unsigned int n; | |
| if (*s >= '0' && *s <= '9') { | |
| n = *s - '0'; | |
| } else { | |
| switch (*s) { | |
| case 'A': | |
| case 'a': | |
| n = 10; | |
| break; | |
| case 'B': | |
| case 'b': | |
| n = 11; | |
| break; | |
| case 'C': | |
| case 'c': | |
| n = 12; | |
| break; | |
| case 'D': | |
| case 'd': | |
| n = 13; | |
| break; | |
| case 'E': | |
| case 'e': | |
| n = 14; | |
| break; | |
| case 'F': | |
| case 'f': | |
| n = 15; | |
| break; | |
| default: | |
| goto done; | |
| } | |
| } | |
| // The following guarantees the invariant val <= SAL_MAX_UINT64 (because | |
| // base and n are sufficiently small), *if* | |
| // std::numeric_limits<sal_uInt64>::max() == SAL_MAX_UINT64: | |
| sal_uInt64 nval = val * base + n; | |
| if (nval < val) { | |
| idlc()->error()->syntaxError( | |
| PS_NoState, idlc()->getLineNumber(), | |
| "integral constant too large"); | |
| val = 0; | |
| break; | |
| } | |
| val = nval; | |
| } | |
| done: | |
| if (neg) { | |
| if (val < SAL_CONST_UINT64(0x8000000000000000)) { | |
| *sval = -static_cast< sal_Int64 >(val); | |
| } else if (val == SAL_CONST_UINT64(0x8000000000000000)) { | |
| *sval = SAL_MIN_INT64; | |
| } else { | |
| idlc()->error()->syntaxError( | |
| PS_NoState, idlc()->getLineNumber(), | |
| "negative integral constant too large"); | |
| *sval = 0; | |
| } | |
| return IDL_INTEGER_LITERAL; | |
| } else if (val <= static_cast< sal_uInt64 >(SAL_MAX_INT64)) { | |
| *sval = static_cast< sal_Int64 >(val); | |
| return IDL_INTEGER_LITERAL; | |
| } else { | |
| *uval = val; | |
| return IDL_INTEGER_ULITERAL; | |
| } | |
| } | |
| static double asciiToFloat(const sal_Char *s) | |
| { | |
| double d = 0.0; | |
| double e, k; | |
| sal_Int32 neg = 0, negexp = 0; | |
| if (*s == '-') | |
| { | |
| neg = 1; | |
| s++; | |
| } | |
| while (*s >= '0' && *s <= '9') | |
| { | |
| d = (d * 10) + *s - '0'; | |
| s++; | |
| } | |
| if (*s == '.') | |
| { | |
| s++; | |
| e = 10; | |
| while (*s >= '0' && *s <= '9') | |
| { | |
| d += (*s - '0') / (e * 1.0); | |
| e *= 10; | |
| s++; | |
| } | |
| } | |
| if (*s == 'e' || *s == 'E') | |
| { | |
| s++; | |
| if (*s == '-') | |
| { | |
| negexp = 1; | |
| s++; | |
| } else | |
| { | |
| if (*s == '+') | |
| s++; | |
| e = 0; | |
| while (*s >= '0' && *s <= '9') | |
| { | |
| e = (e * 10) + *s - '0'; | |
| s++; | |
| } | |
| if (e > 0) | |
| { | |
| for (k = 1; e > 0; k *= 10, e--) ; | |
| if (negexp) | |
| d /= k; | |
| else | |
| d *= k; | |
| } | |
| } | |
| } | |
| if (neg) d *= -1.0; | |
| return d; | |
| } | |
| static void idlParsePragma(sal_Char* pPragma) | |
| { | |
| ::rtl::OString pragma(pPragma); | |
| sal_Int32 index = pragma.indexOf("include"); | |
| sal_Char* begin = pPragma + index + 8; | |
| sal_Char* offset = begin; | |
| while (*offset != ',') offset++; | |
| //::rtl::OString include = pragma.copy(index + 8, offset - begin); | |
| idlc()->insertInclude(pragma.copy(index + 8, (sal_Int32)(offset - begin))); | |
| } | |
| static void parseLineAndFile(sal_Char* pBuf) | |
| { | |
| sal_Char *r = pBuf; | |
| sal_Char *h; | |
| sal_Bool bIsInMain = sal_False; | |
| /* Skip initial '#' */ | |
| if (*r != '#') | |
| return; | |
| /* Find line number */ | |
| for (r++; *r == ' ' || *r == '\t' || isalpha(*r); r++) ; | |
| h = r; | |
| for (; *r != '\0' && *r != ' ' && *r != '\t'; r++) ; | |
| *r++ = 0; | |
| idlc()->setLineNumber((sal_uInt32)atol(h)); | |
| /* Find file name, if present */ | |
| for (; *r != '"'; r++) | |
| { | |
| if (*r == '\n' || *r == '\0') | |
| return; | |
| } | |
| h = ++r; | |
| for (; *r != '"'; r++) ; | |
| *r = 0; | |
| if (*h == '\0') | |
| idlc()->setFileName(::rtl::OString("standard input")); | |
| else | |
| idlc()->setFileName(::rtl::OString(h)); | |
| bIsInMain = (idlc()->getFileName() == idlc()->getRealFileName()) ? sal_True : sal_False; | |
| idlc()->setInMainfile(bIsInMain); | |
| } | |
| // Suppress any warnings from generated code: | |
| #if defined __GNUC__ | |
| #pragma GCC system_header | |
| #elif defined __SUNPRO_CC | |
| #pragma disable_warn | |
| #elif defined _MSC_VER | |
| #pragma warning(push, 1) | |
| /**/ | |
| #ifdef yywrap | |
| #undef yywrap | |
| #define yywrap() 1 | |
| #endif | |
| /**/ | |
| #endif | |
| %} | |
| %option noyywrap | |
| %option never-interactive | |
| %x DOCU | |
| %x COMMENT | |
| DIGIT [0-9] | |
| OCT_DIGIT [0-7] | |
| HEX_DIGIT [a-fA-F0-9] | |
| CAPITAL [A-Z] | |
| ALPHA [a-zA-Z] | |
| INT_LITERAL [1-9][0-9]* | |
| OCT_LITERAL 0{OCT_DIGIT}* | |
| HEX_LITERAL (0x|0X){HEX_DIGIT}* | |
| IDENTIFIER_NEW ({ALPHA}({ALPHA}|{DIGIT})*)|({CAPITAL}("_"?({ALPHA}|{DIGIT})+)*) | |
| IDENTIFIER ("_"?({ALPHA}|{DIGIT})+)* | |
| %% | |
| [ \t\r]+ ; /* eat up whitespace */ | |
| [\n] { | |
| idlc()->incLineNumber(); | |
| } | |
| attribute return IDL_ATTRIBUTE; | |
| bound return IDL_BOUND; | |
| case return IDL_CASE; | |
| const return IDL_CONST; | |
| constants return IDL_CONSTANTS; | |
| constrained return IDL_CONSTRAINED; | |
| default return IDL_DEFAULT; | |
| enum return IDL_ENUM; | |
| exception return IDL_EXCEPTION; | |
| interface return IDL_INTERFACE; | |
| maybeambiguous return IDL_MAYBEAMBIGUOUS; | |
| maybedefault return IDL_MAYBEDEFAULT; | |
| maybevoid return IDL_MAYBEVOID; | |
| module return IDL_MODULE; | |
| needs return IDL_NEEDS; | |
| observes return IDL_OBSERVES; | |
| optional return IDL_OPTIONAL; | |
| property return IDL_PROPERTY; | |
| raises return IDL_RAISES; | |
| readonly return IDL_READONLY; | |
| removable return IDL_REMOVEABLE; | |
| service return IDL_SERVICE; | |
| sequence return IDL_SEQUENCE; | |
| singleton return IDL_SINGLETON; | |
| struct return IDL_STRUCT; | |
| switch return IDL_SWITCH; | |
| transient return IDL_TRANSIENT; | |
| typedef return IDL_TYPEDEF; | |
| union return IDL_UNION; | |
| any return IDL_ANY; | |
| boolean return IDL_BOOLEAN; | |
| byte return IDL_BYTE; | |
| char return IDL_CHAR; | |
| double return IDL_DOUBLE; | |
| float return IDL_FLOAT; | |
| hyper return IDL_HYPER; | |
| long return IDL_LONG; | |
| short return IDL_SHORT; | |
| string return IDL_STRING; | |
| type return IDL_TYPE; | |
| unsigned return IDL_UNSIGNED; | |
| void return IDL_VOID; | |
| TRUE return IDL_TRUE; | |
| True return IDL_TRUE; | |
| FALSE return IDL_FALSE; | |
| False return IDL_FALSE; | |
| in return IDL_IN; | |
| out return IDL_OUT; | |
| inout return IDL_INOUT; | |
| oneway return IDL_ONEWAY; | |
| get return IDL_GET; | |
| set return IDL_SET; | |
| published return IDL_PUBLISHED; | |
| "..." return IDL_ELLIPSIS; | |
| ("-")?{INT_LITERAL}+(l|L|u|U)? { | |
| return asciiToInteger(yytext, &yylval.ival, &yylval.uval); | |
| } | |
| ("-")?{OCT_LITERAL}+(l|L|u|U)? { | |
| return asciiToInteger(yytext, &yylval.ival, &yylval.uval); | |
| } | |
| ("-")?{HEX_LITERAL}+(l|L|u|U)? { | |
| return asciiToInteger(yytext, &yylval.ival, &yylval.uval); | |
| } | |
| ("-")?{DIGIT}+(e|E){1}(("+"|"-")?{DIGIT}+)+(f|F)? | | |
| ("-")?"."{DIGIT}+((e|E)("+"|"-")?{DIGIT}+)?(f|F)? | | |
| ("-")?{DIGIT}*"."{DIGIT}+((e|E)("+"|"-")?{DIGIT}+)?(f|F)? { | |
| yylval.dval = asciiToFloat( yytext ); | |
| return IDL_FLOATING_PT_LITERAL; | |
| } | |
| {IDENTIFIER} { | |
| yylval.sval = new ::rtl::OString(yytext); | |
| return IDL_IDENTIFIER; | |
| } | |
| \<\< { | |
| yylval.strval = yytext; | |
| return IDL_LEFTSHIFT; | |
| } | |
| \>\> { | |
| yylval.strval = yytext; | |
| return IDL_RIGHTSHIFT; | |
| } | |
| \:\: { | |
| yylval.strval = yytext; | |
| return IDL_SCOPESEPARATOR; | |
| } | |
| "/*" { | |
| BEGIN( COMMENT ); | |
| docu = ::rtl::OString(); | |
| beginLine = idlc()->getLineNumber(); | |
| } | |
| "/***" { | |
| BEGIN( COMMENT ); | |
| docu = ::rtl::OString(); | |
| beginLine = idlc()->getLineNumber(); | |
| } | |
| <COMMENT>[^*]+ { | |
| docu += ::rtl::OString(yytext); | |
| } | |
| <COMMENT>"*"[^*/]+ { | |
| docu += ::rtl::OString(yytext); | |
| } | |
| <COMMENT>"**" { | |
| docu += ::rtl::OString(yytext); | |
| } | |
| <COMMENT>[*]+"/" { | |
| docu = docu.trim(); | |
| sal_Int32 nIndex = 0; | |
| int count = 0; | |
| do { docu.getToken( 0, '\n', nIndex ); count++; } while( nIndex != -1 ); | |
| idlc()->setLineNumber( beginLine + count - 1); | |
| BEGIN( INITIAL ); | |
| } | |
| "/**" { | |
| BEGIN( DOCU ); | |
| docu = ::rtl::OString(); | |
| beginLine = idlc()->getLineNumber(); | |
| } | |
| <DOCU>[^*\n]+ { | |
| docu += ::rtl::OString(yytext); | |
| } | |
| <DOCU>"\n"[ \t]*"*"{1} { | |
| idlc()->setLineNumber( idlc()->getLineNumber() + 1); | |
| docu += ::rtl::OString("\n"); | |
| } | |
| <DOCU>"\n" { | |
| idlc()->setLineNumber( idlc()->getLineNumber() + 1); | |
| docu += ::rtl::OString(yytext); | |
| } | |
| <DOCU>"*"[^*^/\n]* { | |
| docu += ::rtl::OString(yytext); | |
| } | |
| <DOCU>"\n"[ \t]*"*/" { | |
| docu = docu.trim(); | |
| sal_Int32 nIndex = 0; | |
| int count = 0; | |
| do { docu.getToken( 0, '\n', nIndex ); count++; } while( nIndex != -1 ); | |
| idlc()->setLineNumber( beginLine + count - 1); | |
| if ( (nIndex = docu.indexOf("/*")) >= 0 || (nIndex = docu.indexOf("///")) >= 0 ) | |
| { | |
| if ( 0 != nIndex && | |
| (docu.getStr()[nIndex - 1] != '"' && docu.getStr()[nIndex - 1] != ':') ) | |
| idlc()->error()->syntaxError(PS_NoState, idlc()->getLineNumber(), | |
| "nested documentation strings are not allowed!"); | |
| } | |
| idlc()->setDocumentation(docu); | |
| BEGIN( INITIAL ); | |
| } | |
| <DOCU>"*/" { | |
| docu = docu.trim(); | |
| sal_Int32 nIndex = 0; | |
| int count = 0; | |
| do { docu.getToken( 0, '\n', nIndex ); count++; } while( nIndex != -1 ); | |
| idlc()->setLineNumber( beginLine + count - 1); | |
| if ( docu.indexOf("/*") >= 0 || docu.indexOf("//") >= 0 ) | |
| { | |
| if ( 0 != nIndex && | |
| (docu.getStr()[nIndex - 1] != '"' && docu.getStr()[nIndex - 1] != ':') ) | |
| idlc()->error()->syntaxError(PS_NoState, idlc()->getLineNumber(), | |
| "nested documentation strings are not allowed!"); | |
| } | |
| idlc()->setDocumentation(docu); | |
| BEGIN( INITIAL ); | |
| } | |
| "//"[^/]{1}.*"\n" { | |
| /* only a comment */ | |
| ::rtl::OString docStr(yytext); | |
| docStr = docStr.copy( 0, docStr.lastIndexOf('\n') ); | |
| docStr = docStr.copy( docStr.lastIndexOf('/')+1 ); | |
| docStr = docStr.trim(); | |
| idlc()->incLineNumber(); | |
| } | |
| "///".*"\n" { | |
| ::rtl::OString docStr(yytext); | |
| docStr = docStr.copy( 0, docStr.lastIndexOf('\n') ); | |
| docStr = docStr.copy( docStr.lastIndexOf('/')+1 ); | |
| docStr = docStr.trim(); | |
| idlc()->incLineNumber(); | |
| idlc()->setDocumentation(docStr); | |
| } | |
| . return yytext[0]; | |
| ^#[ \t]*line[ \t]*[0-9]*" ""\""[^\"]*"\""\n { | |
| parseLineAndFile(yytext); | |
| } | |
| ^#[ \t]*[0-9]*" ""\""[^\"]*"\""" "[0-9]*\n { | |
| parseLineAndFile(yytext); | |
| } | |
| ^#[ \t]*[0-9]*" ""\""[^\"]*"\""\n { | |
| parseLineAndFile(yytext); | |
| } | |
| ^#[ \t]*[0-9]*\n { | |
| parseLineAndFile(yytext); | |
| } | |
| ^#[ \t]*ident.*\n { | |
| /* ignore cpp ident */ | |
| idlc()->incLineNumber(); | |
| } | |
| ^#[ \t]*pragma[ \t].*\n { /* remember pragma */ | |
| idlParsePragma(yytext); | |
| idlc()->incLineNumber(); | |
| } | |
| %% |