| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svtools.hxx" |
| |
| #include <svtools/syntaxhighlight.hxx> |
| |
| #include <unotools/charclass.hxx> |
| #include <tools/debug.hxx> |
| |
| |
| // ########################################################################## |
| // ATTENTION: all these words needs to be in small caps |
| // ########################################################################## |
| static const char* strListBasicKeyWords[] = { |
| "access", |
| "alias", |
| "and", |
| "any", |
| "append", |
| "as", |
| "base", |
| "binary", |
| "boolean", |
| "byref", |
| "byte", |
| "byval", |
| "call", |
| "case", |
| "cdecl", |
| "classmodule", |
| "close", |
| "compare", |
| "compatible", |
| "const", |
| "currency", |
| "date", |
| "declare", |
| "defbool", |
| "defcur", |
| "defdate", |
| "defdbl", |
| "deferr", |
| "defint", |
| "deflng", |
| "defobj", |
| "defsng", |
| "defstr", |
| "defvar", |
| "dim", |
| "do", |
| "double", |
| "each", |
| "else", |
| "elseif", |
| "end", |
| "end enum", |
| "end function", |
| "end if", |
| "end select", |
| "end sub", |
| "end type", |
| "endif", |
| "enum", |
| "eqv", |
| "erase", |
| "error", |
| "exit", |
| "explicit", |
| "for", |
| "function", |
| "get", |
| "global", |
| "gosub", |
| "goto", |
| "if", |
| "imp", |
| "implements", |
| "in", |
| "input", |
| "integer", |
| "is", |
| "let", |
| "lib", |
| "like", |
| "line", |
| "line input", |
| "local", |
| "lock", |
| "long", |
| "loop", |
| "lprint", |
| "lset", |
| "mod", |
| "name", |
| "new", |
| "next", |
| "not", |
| "object", |
| "on", |
| "open", |
| "option", |
| "optional", |
| "or", |
| "output", |
| "preserve", |
| "print", |
| "private", |
| "property", |
| "public", |
| "random", |
| "read", |
| "redim", |
| "rem", |
| "resume", |
| "return", |
| "rset", |
| "select", |
| "set", |
| "shared", |
| "single", |
| "static", |
| "step", |
| "stop", |
| "string", |
| "sub", |
| "system", |
| "text", |
| "then", |
| "to", |
| "type", |
| "typeof", |
| "until", |
| "variant", |
| "wend", |
| "while", |
| "with", |
| "write", |
| "xor" |
| }; |
| |
| |
| static const char* strListSqlKeyWords[] = { |
| "all", |
| "and", |
| "any", |
| "as", |
| "asc", |
| "avg", |
| "between", |
| "by", |
| "cast", |
| "corresponding", |
| "count", |
| "create", |
| "cross", |
| "delete", |
| "desc", |
| "distinct", |
| "drop", |
| "escape", |
| "except", |
| "exists", |
| "false", |
| "from", |
| "full", |
| "global", |
| "group", |
| "having", |
| "in", |
| "inner", |
| "insert", |
| "intersect", |
| "into", |
| "is", |
| "join", |
| "left", |
| "like", |
| "local", |
| "match", |
| "max", |
| "min", |
| "natural", |
| "not", |
| "null", |
| "on", |
| "or", |
| "order", |
| "outer", |
| "right", |
| "select", |
| "set", |
| "some", |
| "sum", |
| "table", |
| "temporary", |
| "true", |
| "union", |
| "unique", |
| "unknown", |
| "update", |
| "using", |
| "values", |
| "where" |
| }; |
| |
| |
| extern "C" int CDECL compare_strings( const void *arg1, const void *arg2 ) |
| { |
| return strcmp( (char *)arg1, *(char **)arg2 ); |
| } |
| |
| |
| class LetterTable |
| { |
| bool IsLetterTab[256]; |
| |
| public: |
| LetterTable( void ); |
| |
| inline bool isLetter( sal_Unicode c ) |
| { |
| bool bRet = (c < 256) ? IsLetterTab[c] : isLetterUnicode( c ); |
| return bRet; |
| } |
| bool isLetterUnicode( sal_Unicode c ); |
| }; |
| |
| class BasicSimpleCharClass |
| { |
| static LetterTable aLetterTable; |
| |
| public: |
| static sal_Bool isAlpha( sal_Unicode c, bool bCompatible ) |
| { |
| sal_Bool bRet = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') |
| || (bCompatible && aLetterTable.isLetter( c )); |
| return bRet; |
| } |
| |
| static sal_Bool isDigit( sal_Unicode c ) |
| { |
| sal_Bool bRet = (c >= '0' && c <= '9'); |
| return bRet; |
| } |
| |
| static sal_Bool isAlphaNumeric( sal_Unicode c, bool bCompatible ) |
| { |
| sal_Bool bRet = isDigit( c ) || isAlpha( c, bCompatible ); |
| return bRet; |
| } |
| }; |
| |
| LetterTable BasicSimpleCharClass::aLetterTable; |
| |
| LetterTable::LetterTable( void ) |
| { |
| for( int i = 0 ; i < 256 ; ++i ) |
| IsLetterTab[i] = false; |
| |
| IsLetterTab[0xC0] = true; // ?, CAPITAL LETTER A WITH GRAVE ACCENT |
| IsLetterTab[0xC1] = true; // ?, CAPITAL LETTER A WITH ACUTE ACCENT |
| IsLetterTab[0xC2] = true; // ?, CAPITAL LETTER A WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xC3] = true; // ?, CAPITAL LETTER A WITH TILDE |
| IsLetterTab[0xC4] = true; // ?, CAPITAL LETTER A WITH DIAERESIS |
| IsLetterTab[0xC5] = true; // ?, CAPITAL LETTER A WITH RING ABOVE |
| IsLetterTab[0xC6] = true; // ?, CAPITAL LIGATURE AE |
| IsLetterTab[0xC7] = true; // ?, CAPITAL LETTER C WITH CEDILLA |
| IsLetterTab[0xC8] = true; // ?, CAPITAL LETTER E WITH GRAVE ACCENT |
| IsLetterTab[0xC9] = true; // ?, CAPITAL LETTER E WITH ACUTE ACCENT |
| IsLetterTab[0xCA] = true; // ?, CAPITAL LETTER E WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xCB] = true; // ?, CAPITAL LETTER E WITH DIAERESIS |
| IsLetterTab[0xCC] = true; // ?, CAPITAL LETTER I WITH GRAVE ACCENT |
| IsLetterTab[0xCD] = true; // ?, CAPITAL LETTER I WITH ACUTE ACCENT |
| IsLetterTab[0xCE] = true; // ?, CAPITAL LETTER I WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xCF] = true; // ?, CAPITAL LETTER I WITH DIAERESIS |
| IsLetterTab[0xD0] = true; // ?, CAPITAL LETTER ETH |
| IsLetterTab[0xD1] = true; // ?, CAPITAL LETTER N WITH TILDE |
| IsLetterTab[0xD2] = true; // ?, CAPITAL LETTER O WITH GRAVE ACCENT |
| IsLetterTab[0xD3] = true; // ?, CAPITAL LETTER O WITH ACUTE ACCENT |
| IsLetterTab[0xD4] = true; // ?, CAPITAL LETTER O WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xD5] = true; // ?, CAPITAL LETTER O WITH TILDE |
| IsLetterTab[0xD6] = true; // ?, CAPITAL LETTER O WITH DIAERESIS |
| IsLetterTab[0xD8] = true; // ?, CAPITAL LETTER O WITH STROKE |
| IsLetterTab[0xD9] = true; // ?, CAPITAL LETTER U WITH GRAVE ACCENT |
| IsLetterTab[0xDA] = true; // ?, CAPITAL LETTER U WITH ACUTE ACCENT |
| IsLetterTab[0xDB] = true; // ?, CAPITAL LETTER U WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xDC] = true; // ?, CAPITAL LETTER U WITH DIAERESIS |
| IsLetterTab[0xDD] = true; // ?, CAPITAL LETTER Y WITH ACUTE ACCENT |
| IsLetterTab[0xDE] = true; // ?, CAPITAL LETTER THORN |
| IsLetterTab[0xDF] = true; // ?, SMALL LETTER SHARP S |
| IsLetterTab[0xE0] = true; // ?, SMALL LETTER A WITH GRAVE ACCENT |
| IsLetterTab[0xE1] = true; // ?, SMALL LETTER A WITH ACUTE ACCENT |
| IsLetterTab[0xE2] = true; // ?, SMALL LETTER A WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xE3] = true; // ?, SMALL LETTER A WITH TILDE |
| IsLetterTab[0xE4] = true; // ?, SMALL LETTER A WITH DIAERESIS |
| IsLetterTab[0xE5] = true; // ?, SMALL LETTER A WITH RING ABOVE |
| IsLetterTab[0xE6] = true; // ?, SMALL LIGATURE AE |
| IsLetterTab[0xE7] = true; // ?, SMALL LETTER C WITH CEDILLA |
| IsLetterTab[0xE8] = true; // ?, SMALL LETTER E WITH GRAVE ACCENT |
| IsLetterTab[0xE9] = true; // ?, SMALL LETTER E WITH ACUTE ACCENT |
| IsLetterTab[0xEA] = true; // ?, SMALL LETTER E WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xEB] = true; // ?, SMALL LETTER E WITH DIAERESIS |
| IsLetterTab[0xEC] = true; // ?, SMALL LETTER I WITH GRAVE ACCENT |
| IsLetterTab[0xED] = true; // ?, SMALL LETTER I WITH ACUTE ACCENT |
| IsLetterTab[0xEE] = true; // ?, SMALL LETTER I WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xEF] = true; // ?, SMALL LETTER I WITH DIAERESIS |
| IsLetterTab[0xF0] = true; // ?, SMALL LETTER ETH |
| IsLetterTab[0xF1] = true; // ?, SMALL LETTER N WITH TILDE |
| IsLetterTab[0xF2] = true; // ?, SMALL LETTER O WITH GRAVE ACCENT |
| IsLetterTab[0xF3] = true; // ?, SMALL LETTER O WITH ACUTE ACCENT |
| IsLetterTab[0xF4] = true; // ?, SMALL LETTER O WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xF5] = true; // ?, SMALL LETTER O WITH TILDE |
| IsLetterTab[0xF6] = true; // ?, SMALL LETTER O WITH DIAERESIS |
| IsLetterTab[0xF8] = true; // ?, SMALL LETTER O WITH OBLIQUE BAR |
| IsLetterTab[0xF9] = true; // ?, SMALL LETTER U WITH GRAVE ACCENT |
| IsLetterTab[0xFA] = true; // ?, SMALL LETTER U WITH ACUTE ACCENT |
| IsLetterTab[0xFB] = true; // ?, SMALL LETTER U WITH CIRCUMFLEX ACCENT |
| IsLetterTab[0xFC] = true; // ?, SMALL LETTER U WITH DIAERESIS |
| IsLetterTab[0xFD] = true; // ?, SMALL LETTER Y WITH ACUTE ACCENT |
| IsLetterTab[0xFE] = true; // ?, SMALL LETTER THORN |
| IsLetterTab[0xFF] = true; // � , SMALL LETTER Y WITH DIAERESIS |
| } |
| |
| bool LetterTable::isLetterUnicode( sal_Unicode c ) |
| { |
| static CharClass* pCharClass = NULL; |
| if( pCharClass == NULL ) |
| pCharClass = new CharClass( Application::GetSettings().GetLocale() ); |
| String aStr( c ); |
| bool bRet = pCharClass->isLetter( aStr, 0 ); |
| return bRet; |
| } |
| |
| // Hilfsfunktion: Zeichen-Flag Testen |
| sal_Bool SimpleTokenizer_Impl::testCharFlags( sal_Unicode c, sal_uInt16 nTestFlags ) |
| { |
| bool bRet = false; |
| if( c != 0 && c <= 255 ) |
| { |
| bRet = ( (aCharTypeTab[c] & nTestFlags) != 0 ); |
| } |
| else if( c > 255 ) |
| { |
| bRet = (( CHAR_START_IDENTIFIER | CHAR_IN_IDENTIFIER ) & nTestFlags) != 0 |
| ? BasicSimpleCharClass::isAlpha( c, true ) : false; |
| } |
| return bRet; |
| } |
| |
| void SimpleTokenizer_Impl::setKeyWords( const char** ppKeyWords, sal_uInt16 nCount ) |
| { |
| ppListKeyWords = ppKeyWords; |
| nKeyWordCount = nCount; |
| } |
| |
| // Neues Token holen |
| sal_Bool SimpleTokenizer_Impl::getNextToken( /*out*/TokenTypes& reType, |
| /*out*/const sal_Unicode*& rpStartPos, /*out*/const sal_Unicode*& rpEndPos ) |
| { |
| reType = TT_UNKNOWN; |
| |
| // Position merken |
| rpStartPos = mpActualPos; |
| |
| // Zeichen untersuchen |
| sal_Unicode c = peekChar(); |
| if( c == CHAR_EOF ) |
| return sal_False; |
| |
| // Zeichen lesen |
| getChar(); |
| |
| //*** Alle Moeglichkeiten durchgehen *** |
| // Space? |
| if ( (testCharFlags( c, CHAR_SPACE ) == sal_True) ) |
| { |
| while( testCharFlags( peekChar(), CHAR_SPACE ) == sal_True ) |
| getChar(); |
| |
| reType = TT_WHITESPACE; |
| } |
| |
| // Identifier? |
| else if ( (testCharFlags( c, CHAR_START_IDENTIFIER ) == sal_True) ) |
| { |
| sal_Bool bIdentifierChar; |
| do |
| { |
| // Naechstes Zeichen holen |
| c = peekChar(); |
| bIdentifierChar = testCharFlags( c, CHAR_IN_IDENTIFIER ); |
| if( bIdentifierChar ) |
| getChar(); |
| } |
| while( bIdentifierChar ); |
| |
| reType = TT_IDENTIFIER; |
| |
| // Schluesselwort-Tabelle |
| if (ppListKeyWords != NULL) |
| { |
| int nCount = mpActualPos - rpStartPos; |
| |
| // No keyword if string contains char > 255 |
| bool bCanBeKeyword = true; |
| for( int i = 0 ; i < nCount ; i++ ) |
| { |
| if( rpStartPos[i] > 255 ) |
| { |
| bCanBeKeyword = false; |
| break; |
| } |
| } |
| |
| if( bCanBeKeyword ) |
| { |
| String aKWString(rpStartPos, sal::static_int_cast< xub_StrLen >(nCount) ); |
| ByteString aByteStr( aKWString, RTL_TEXTENCODING_ASCII_US ); |
| aByteStr.ToLowerAscii(); |
| if ( bsearch( aByteStr.GetBuffer(), ppListKeyWords, nKeyWordCount, sizeof( char* ), |
| compare_strings ) ) |
| { |
| reType = TT_KEYWORDS; |
| |
| if ( aByteStr.Equals( "rem" ) ) |
| { |
| // Alle Zeichen bis Zeilen-Ende oder EOF entfernen |
| sal_Unicode cPeek = peekChar(); |
| while( cPeek != CHAR_EOF && testCharFlags( cPeek, CHAR_EOL ) == sal_False ) |
| { |
| c = getChar(); |
| cPeek = peekChar(); |
| } |
| |
| reType = TT_COMMENT; |
| } |
| } |
| } |
| } |
| } |
| |
| // Operator? |
| // only for BASIC '\'' should be a comment, otherwise it is a normal string and handled there |
| else if ( ( testCharFlags( c, CHAR_OPERATOR ) == sal_True ) || ( (c == '\'') && (aLanguage==HIGHLIGHT_BASIC)) ) |
| { |
| // paramters for SQL view |
| if ( (c==':') || (c=='?')) |
| { |
| if (c!='?') |
| { |
| sal_Bool bIdentifierChar; |
| do |
| { |
| // Naechstes Zeichen holen |
| c = peekChar(); |
| bIdentifierChar = BasicSimpleCharClass::isAlpha( c, true ); |
| if( bIdentifierChar ) |
| getChar(); |
| } |
| while( bIdentifierChar ); |
| } |
| reType = TT_PARAMETER; |
| } |
| else if( c=='-' ) |
| { |
| sal_Unicode cPeekNext = peekChar(); |
| if (cPeekNext=='-') |
| { |
| // Alle Zeichen bis Zeilen-Ende oder EOF entfernen |
| while( cPeekNext != CHAR_EOF && testCharFlags( cPeekNext, CHAR_EOL ) == sal_False ) |
| { |
| getChar(); |
| cPeekNext = peekChar(); |
| } |
| reType = TT_COMMENT; |
| } |
| } |
| else if (c=='/') |
| { |
| sal_Unicode cPeekNext = peekChar(); |
| if (cPeekNext=='/') |
| { |
| // Alle Zeichen bis Zeilen-Ende oder EOF entfernen |
| while( cPeekNext != CHAR_EOF && testCharFlags( cPeekNext, CHAR_EOL ) == sal_False ) |
| { |
| getChar(); |
| cPeekNext = peekChar(); |
| } |
| reType = TT_COMMENT; |
| } |
| } |
| else |
| { |
| // Kommentar ? |
| if ( c == '\'' ) |
| { |
| c = getChar(); // '/' entfernen |
| |
| // Alle Zeichen bis Zeilen-Ende oder EOF entfernen |
| sal_Unicode cPeek = c; |
| while( cPeek != CHAR_EOF && testCharFlags( cPeek, CHAR_EOL ) == sal_False ) |
| { |
| getChar(); |
| cPeek = peekChar(); |
| } |
| |
| reType = TT_COMMENT; |
| } |
| |
| // Echter Operator, kann hier einfach behandelt werden, |
| // da nicht der wirkliche Operator, wie z.B. += interessiert, |
| // sondern nur die Tatsache, dass es sich um einen handelt. |
| if( reType != TT_COMMENT ) |
| { |
| reType = TT_OPERATOR; |
| } |
| |
| } |
| } |
| |
| // Objekt-Trenner? Muss vor Number abgehandelt werden |
| else if( c == '.' && ( peekChar() < '0' || peekChar() > '9' ) ) |
| { |
| reType = TT_OPERATOR; |
| } |
| |
| // Zahl? |
| else if( testCharFlags( c, CHAR_START_NUMBER ) == sal_True ) |
| { |
| reType = TT_NUMBER; |
| |
| // Zahlensystem, 10 = normal, wird bei Oct/Hex geaendert |
| int nRadix = 10; |
| |
| // Ist es eine Hex- oder Oct-Zahl? |
| if( c == '&' ) |
| { |
| // Octal? |
| if( peekChar() == 'o' || peekChar() == 'O' ) |
| { |
| // o entfernen |
| getChar(); |
| nRadix = 8; // Octal-Basis |
| |
| // Alle Ziffern einlesen |
| while( testCharFlags( peekChar(), CHAR_IN_OCT_NUMBER ) ) |
| c = getChar(); |
| } |
| // Hex? |
| else if( peekChar() == 'h' || peekChar() == 'H' ) |
| { |
| // x entfernen |
| getChar(); |
| nRadix = 16; // Hex-Basis |
| |
| // Alle Ziffern einlesen und puffern |
| while( testCharFlags( peekChar(), CHAR_IN_HEX_NUMBER ) ) |
| c = getChar(); |
| } |
| else |
| { |
| reType = TT_OPERATOR; |
| } |
| } |
| |
| // Wenn nicht Oct oder Hex als double ansehen |
| if( reType == TT_NUMBER && nRadix == 10 ) |
| { |
| // Flag, ob das letzte Zeichen ein Exponent war |
| sal_Bool bAfterExpChar = sal_False; |
| |
| // Alle Ziffern einlesen |
| while( testCharFlags( peekChar(), CHAR_IN_NUMBER ) || |
| (bAfterExpChar && peekChar() == '+' ) || |
| (bAfterExpChar && peekChar() == '-' ) ) |
| // Nach Exponent auch +/- OK |
| { |
| c = getChar(); // Zeichen lesen |
| bAfterExpChar = ( c == 'e' || c == 'E' ); |
| } |
| } |
| |
| // reType = TT_NUMBER; |
| } |
| |
| // String? |
| else if( testCharFlags( c, CHAR_START_STRING ) == sal_True ) |
| { |
| // Merken, welches Zeichen den String eroeffnet hat |
| sal_Unicode cEndString = c; |
| if( c == '[' ) |
| cEndString = ']'; |
| |
| // Alle Ziffern einlesen und puffern |
| while( peekChar() != cEndString ) |
| { |
| // #58846 EOF vor getChar() abfangen, damit EOF micht verloren geht |
| if( peekChar() == CHAR_EOF ) |
| { |
| // ERROR: unterminated string literal |
| reType = TT_ERROR; |
| break; |
| } |
| c = getChar(); |
| if( testCharFlags( c, CHAR_EOL ) == sal_True ) |
| { |
| // ERROR: unterminated string literal |
| reType = TT_ERROR; |
| break; |
| } |
| } |
| |
| // Zeichen lesen |
| if( reType != TT_ERROR ) |
| { |
| getChar(); |
| if( cEndString == ']' ) |
| reType = TT_IDENTIFIER; |
| else |
| reType = TT_STRING; |
| } |
| } |
| |
| // Zeilenende? |
| else if( testCharFlags( c, CHAR_EOL ) == sal_True ) |
| { |
| // Falls ein weiteres anderes EOL-Char folgt, weg damit |
| sal_Unicode cNext = peekChar(); |
| if( cNext != c && testCharFlags( cNext, CHAR_EOL ) == sal_True ) |
| getChar(); |
| |
| // Positions-Daten auf Zeilen-Beginn setzen |
| nCol = 0; |
| nLine++; |
| |
| reType = TT_EOL; |
| } |
| |
| // Alles andere bleibt TT_UNKNOWN |
| |
| |
| // End-Position eintragen |
| rpEndPos = mpActualPos; |
| return sal_True; |
| } |
| |
| String SimpleTokenizer_Impl::getTokStr |
| ( /*out*/const sal_Unicode* pStartPos, /*out*/const sal_Unicode* pEndPos ) |
| { |
| return String( pStartPos, (sal_uInt16)( pEndPos - pStartPos ) ); |
| } |
| |
| #ifdef DBG_UTIL |
| // TEST: Token ausgeben |
| String SimpleTokenizer_Impl::getFullTokenStr( /*out*/TokenTypes eType, |
| /*out*/const sal_Unicode* pStartPos, /*out*/const sal_Unicode* pEndPos ) |
| { |
| String aOut; |
| switch( eType ) |
| { |
| case TT_UNKNOWN: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_UNKNOWN:") ); break; |
| case TT_IDENTIFIER: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_IDENTIFIER:") ); break; |
| case TT_WHITESPACE: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_WHITESPACE:") ); break; |
| case TT_NUMBER: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_NUMBER:") ); break; |
| case TT_STRING: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_STRING:") ); break; |
| case TT_EOL: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_EOL:") ); break; |
| case TT_COMMENT: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_COMMENT:") ); break; |
| case TT_ERROR: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_ERROR:") ); break; |
| case TT_OPERATOR: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_OPERATOR:") ); break; |
| case TT_KEYWORDS: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_KEYWORD:") ); break; |
| case TT_PARAMETER: aOut = String( RTL_CONSTASCII_USTRINGPARAM("TT_PARAMETER:") ); break; |
| } |
| if( eType != TT_EOL ) |
| { |
| aOut += String( pStartPos, (sal_uInt16)( pEndPos - pStartPos ) ); |
| } |
| aOut += String( RTL_CONSTASCII_USTRINGPARAM("\n") ); |
| return aOut; |
| } |
| #endif |
| |
| SimpleTokenizer_Impl::SimpleTokenizer_Impl( HighlighterLanguage aLang ): aLanguage(aLang) |
| { |
| memset( aCharTypeTab, 0, sizeof( aCharTypeTab ) ); |
| |
| // Zeichen-Tabelle fuellen |
| sal_uInt16 i; |
| |
| // Zulaessige Zeichen fuer Identifier |
| sal_uInt16 nHelpMask = (sal_uInt16)( CHAR_START_IDENTIFIER | CHAR_IN_IDENTIFIER ); |
| for( i = 'a' ; i <= 'z' ; i++ ) |
| aCharTypeTab[i] |= nHelpMask; |
| for( i = 'A' ; i <= 'Z' ; i++ ) |
| aCharTypeTab[i] |= nHelpMask; |
| // '_' extra eintragen |
| aCharTypeTab[(int)'_'] |= nHelpMask; |
| // AB 23.6.97: '$' ist auch erlaubt |
| aCharTypeTab[(int)'$'] |= nHelpMask; |
| |
| // Ziffern (Identifier und Number ist moeglich) |
| nHelpMask = (sal_uInt16)( CHAR_IN_IDENTIFIER | CHAR_START_NUMBER | |
| CHAR_IN_NUMBER | CHAR_IN_HEX_NUMBER ); |
| for( i = '0' ; i <= '9' ; i++ ) |
| aCharTypeTab[i] |= nHelpMask; |
| |
| // e und E sowie . von Hand ergaenzen |
| aCharTypeTab[(int)'e'] |= CHAR_IN_NUMBER; |
| aCharTypeTab[(int)'E'] |= CHAR_IN_NUMBER; |
| aCharTypeTab[(int)'.'] |= (sal_uInt16)( CHAR_IN_NUMBER | CHAR_START_NUMBER ); |
| aCharTypeTab[(int)'&'] |= CHAR_START_NUMBER; |
| |
| // Hex-Ziffern |
| for( i = 'a' ; i <= 'f' ; i++ ) |
| aCharTypeTab[i] |= CHAR_IN_HEX_NUMBER; |
| for( i = 'A' ; i <= 'F' ; i++ ) |
| aCharTypeTab[i] |= CHAR_IN_HEX_NUMBER; |
| |
| // Oct-Ziffern |
| for( i = '0' ; i <= '7' ; i++ ) |
| aCharTypeTab[i] |= CHAR_IN_OCT_NUMBER; |
| |
| // String-Beginn/End-Zeichen |
| aCharTypeTab[(int)'\''] |= CHAR_START_STRING; |
| aCharTypeTab[(int)'\"'] |= CHAR_START_STRING; |
| aCharTypeTab[(int)'['] |= CHAR_START_STRING; |
| aCharTypeTab[(int)'`'] |= CHAR_START_STRING; |
| |
| // Operator-Zeichen |
| aCharTypeTab[(int)'!'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'%'] |= CHAR_OPERATOR; |
| // aCharTypeTab[(int)'&'] |= CHAR_OPERATOR; Removed because of #i14140 |
| aCharTypeTab[(int)'('] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)')'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'*'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'+'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)','] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'-'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'/'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)':'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'<'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'='] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'>'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'?'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'^'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'|'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'~'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'{'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)'}'] |= CHAR_OPERATOR; |
| // aCharTypeTab[(int)'['] |= CHAR_OPERATOR; Removed because of #i17826 |
| aCharTypeTab[(int)']'] |= CHAR_OPERATOR; |
| aCharTypeTab[(int)';'] |= CHAR_OPERATOR; |
| |
| // Space |
| aCharTypeTab[(int)' ' ] |= CHAR_SPACE; |
| aCharTypeTab[(int)'\t'] |= CHAR_SPACE; |
| |
| // Zeilen-Ende-Zeichen |
| aCharTypeTab[(int)'\r'] |= CHAR_EOL; |
| aCharTypeTab[(int)'\n'] |= CHAR_EOL; |
| |
| ppListKeyWords = NULL; |
| } |
| |
| SimpleTokenizer_Impl::~SimpleTokenizer_Impl( void ) |
| { |
| } |
| |
| SimpleTokenizer_Impl* getSimpleTokenizer( void ) |
| { |
| static SimpleTokenizer_Impl* pSimpleTokenizer = NULL; |
| if( !pSimpleTokenizer ) |
| pSimpleTokenizer = new SimpleTokenizer_Impl(); |
| return pSimpleTokenizer; |
| } |
| |
| // Heraussuchen der jeweils naechsten Funktion aus einem JavaScript-Modul |
| sal_uInt16 SimpleTokenizer_Impl::parseLine( sal_uInt32 nParseLine, const String* aSource ) |
| { |
| // Position auf den Anfang des Source-Strings setzen |
| mpStringBegin = mpActualPos = aSource->GetBuffer(); |
| |
| // Zeile und Spalte initialisieren |
| nLine = nParseLine; |
| nCol = 0L; |
| |
| // Variablen fuer die Out-Parameter |
| TokenTypes eType; |
| const sal_Unicode* pStartPos; |
| const sal_Unicode* pEndPos; |
| |
| // Schleife ueber alle Tokens |
| sal_uInt16 nTokenCount = 0; |
| while( getNextToken( eType, pStartPos, pEndPos ) ) |
| nTokenCount++; |
| |
| return nTokenCount; |
| } |
| |
| void SimpleTokenizer_Impl::getHighlightPortions( sal_uInt32 nParseLine, const String& rLine, |
| /*out*/HighlightPortions& portions ) |
| { |
| // Position auf den Anfang des Source-Strings setzen |
| mpStringBegin = mpActualPos = rLine.GetBuffer(); |
| |
| // Zeile und Spalte initialisieren |
| nLine = nParseLine; |
| nCol = 0L; |
| |
| // Variablen fuer die Out-Parameter |
| TokenTypes eType; |
| const sal_Unicode* pStartPos; |
| const sal_Unicode* pEndPos; |
| |
| // Schleife ueber alle Tokens |
| while( getNextToken( eType, pStartPos, pEndPos ) ) |
| { |
| HighlightPortion portion; |
| |
| portion.nBegin = (sal_uInt16)(pStartPos - mpStringBegin); |
| portion.nEnd = (sal_uInt16)(pEndPos - mpStringBegin); |
| portion.tokenType = eType; |
| |
| portions.push_back(portion); |
| } |
| } |
| |
| |
| ////////////////////////////////////////////////////////////////////////// |
| // Implementierung des SyntaxHighlighter |
| |
| SyntaxHighlighter::SyntaxHighlighter() |
| { |
| m_pSimpleTokenizer = 0; |
| m_pKeyWords = NULL; |
| m_nKeyWordCount = 0; |
| } |
| |
| SyntaxHighlighter::~SyntaxHighlighter() |
| { |
| delete m_pSimpleTokenizer; |
| delete m_pKeyWords; |
| } |
| |
| void SyntaxHighlighter::initialize( HighlighterLanguage eLanguage_ ) |
| { |
| eLanguage = eLanguage_; |
| delete m_pSimpleTokenizer; |
| m_pSimpleTokenizer = new SimpleTokenizer_Impl(eLanguage); |
| |
| switch (eLanguage) |
| { |
| case HIGHLIGHT_BASIC: |
| m_pSimpleTokenizer->setKeyWords( strListBasicKeyWords, |
| sizeof( strListBasicKeyWords ) / sizeof( char* )); |
| break; |
| case HIGHLIGHT_SQL: |
| m_pSimpleTokenizer->setKeyWords( strListSqlKeyWords, |
| sizeof( strListSqlKeyWords ) / sizeof( char* )); |
| break; |
| default: |
| m_pSimpleTokenizer->setKeyWords( NULL, 0 ); |
| } |
| } |
| |
| const Range SyntaxHighlighter::notifyChange( sal_uInt32 nLine, sal_Int32 nLineCountDifference, |
| const String* pChangedLines, sal_uInt32 nArrayLength) |
| { |
| (void)nLineCountDifference; |
| |
| for( sal_uInt32 i=0 ; i < nArrayLength ; i++ ) |
| m_pSimpleTokenizer->parseLine(nLine+i, &pChangedLines[i]); |
| |
| return Range( nLine, nLine + nArrayLength-1 ); |
| } |
| |
| void SyntaxHighlighter::getHighlightPortions( sal_uInt32 nLine, const String& rLine, |
| /*out*/HighlightPortions& portions ) |
| { |
| m_pSimpleTokenizer->getHighlightPortions( nLine, rLine, portions ); |
| } |
