| /************************************************************** | |
| * | |
| * 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_basic.hxx" | |
| #include "sbcomp.hxx" | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <ctype.h> | |
| #if defined UNX | |
| #include <stdlib.h> | |
| #else | |
| #include <math.h> // atof() | |
| #endif | |
| #include <rtl/math.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <unotools/charclass.hxx> | |
| #include <runtime.hxx> | |
| SbiScanner::SbiScanner( const ::rtl::OUString& rBuf, StarBASIC* p ) : aBuf( rBuf ) | |
| { | |
| pBasic = p; | |
| pLine = NULL; | |
| nVal = 0; | |
| eScanType = SbxVARIANT; | |
| nErrors = 0; | |
| nBufPos = 0; | |
| nCurCol1 = 0; | |
| nSavedCol1 = 0; | |
| nColLock = 0; | |
| nLine = 0; | |
| nCol1 = 0; | |
| nCol2 = 0; | |
| nCol = 0; | |
| bError = | |
| bAbort = | |
| bSpaces = | |
| bNumber = | |
| bSymbol = | |
| bUsedForHilite = | |
| bCompatible = | |
| bVBASupportOn = | |
| bPrevLineExtentsComment = sal_False; | |
| bHash = | |
| bErrors = sal_True; | |
| } | |
| SbiScanner::~SbiScanner() | |
| {} | |
| void SbiScanner::LockColumn() | |
| { | |
| if( !nColLock++ ) | |
| nSavedCol1 = nCol1; | |
| } | |
| void SbiScanner::UnlockColumn() | |
| { | |
| if( nColLock ) | |
| nColLock--; | |
| } | |
| void SbiScanner::GenError( SbError code ) | |
| { | |
| if( GetSbData()->bBlockCompilerError ) | |
| { | |
| bAbort = sal_True; | |
| return; | |
| } | |
| if( !bError && bErrors ) | |
| { | |
| sal_Bool bRes = sal_True; | |
| // Nur einen Fehler pro Statement reporten | |
| bError = sal_True; | |
| if( pBasic ) | |
| { | |
| // Falls EXPECTED oder UNEXPECTED kommen sollte, bezieht es sich | |
| // immer auf das letzte Token, also die Col1 übernehmen | |
| sal_uInt16 nc = nColLock ? nSavedCol1 : nCol1; | |
| switch( code ) | |
| { | |
| case SbERR_EXPECTED: | |
| case SbERR_UNEXPECTED: | |
| case SbERR_SYMBOL_EXPECTED: | |
| case SbERR_LABEL_EXPECTED: | |
| nc = nCol1; | |
| if( nc > nCol2 ) nCol2 = nc; | |
| break; | |
| } | |
| bRes = pBasic->CError( code, aError, nLine, nc, nCol2 ); | |
| } | |
| bAbort |= !bRes | | |
| ( code == SbERR_NO_MEMORY || code == SbERR_PROG_TOO_LARGE ); | |
| } | |
| if( bErrors ) | |
| nErrors++; | |
| } | |
| // Falls sofort ein Doppelpunkt folgt, wird sal_True zurückgeliefert. | |
| // Wird von SbiTokenizer::MayBeLabel() verwendet, um einen Label zu erkennen | |
| sal_Bool SbiScanner::DoesColonFollow() | |
| { | |
| if( pLine && *pLine == ':' ) | |
| { | |
| pLine++; nCol++; return sal_True; | |
| } | |
| else return sal_False; | |
| } | |
| // Testen auf ein legales Suffix | |
| static SbxDataType GetSuffixType( sal_Unicode c ) | |
| { | |
| static String aSuffixesStr = String::CreateFromAscii( "%&!#@ $" ); | |
| if( c ) | |
| { | |
| sal_uInt32 n = aSuffixesStr.Search( c ); | |
| if( STRING_NOTFOUND != n && c != ' ' ) | |
| return SbxDataType( (sal_uInt16) n + SbxINTEGER ); | |
| } | |
| return SbxVARIANT; | |
| } | |
| // Einlesen des nächsten Symbols in die Variablen aSym, nVal und eType | |
| // Returnwert ist sal_False bei EOF oder Fehlern | |
| #define BUF_SIZE 80 | |
| namespace { | |
| /** Returns true, if the passed character is a white space character. */ | |
| inline bool lclIsWhitespace( sal_Unicode cChar ) | |
| { | |
| return (cChar == ' ') || (cChar == '\t') || (cChar == '\f'); | |
| } | |
| } // namespace | |
| sal_Bool SbiScanner::NextSym() | |
| { | |
| // Für den EOLN-Fall merken | |
| sal_uInt16 nOldLine = nLine; | |
| sal_uInt16 nOldCol1 = nCol1; | |
| sal_uInt16 nOldCol2 = nCol2; | |
| sal_Unicode buf[ BUF_SIZE ], *p = buf; | |
| bHash = sal_False; | |
| eScanType = SbxVARIANT; | |
| aSym.Erase(); | |
| bSymbol = | |
| bNumber = bSpaces = sal_False; | |
| // Zeile einlesen? | |
| if( !pLine ) | |
| { | |
| sal_Int32 n = nBufPos; | |
| sal_Int32 nLen = aBuf.getLength(); | |
| if( nBufPos >= nLen ) | |
| return sal_False; | |
| const sal_Unicode* p2 = aBuf.getStr(); | |
| p2 += n; | |
| while( ( n < nLen ) && ( *p2 != '\n' ) && ( *p2 != '\r' ) ) | |
| p2++, n++; | |
| // #163944# ignore trailing whitespace | |
| sal_Int32 nCopyEndPos = n; | |
| while( (nBufPos < nCopyEndPos) && lclIsWhitespace( aBuf[ nCopyEndPos - 1 ] ) ) | |
| --nCopyEndPos; | |
| aLine = aBuf.copy( nBufPos, nCopyEndPos - nBufPos ); | |
| if( n < nLen ) | |
| { | |
| if( *p2 == '\r' && *( p2+1 ) == '\n' ) | |
| n += 2; | |
| else | |
| n++; | |
| } | |
| nBufPos = n; | |
| pLine = aLine.getStr(); | |
| nOldLine = ++nLine; | |
| nCol = nCol1 = nCol2 = nOldCol1 = nOldCol2 = 0; | |
| nColLock = 0; | |
| } | |
| // Leerstellen weg: | |
| while( lclIsWhitespace( *pLine ) ) | |
| pLine++, nCol++, bSpaces = sal_True; | |
| nCol1 = nCol; | |
| // nur Leerzeile? | |
| if( !*pLine ) | |
| goto eoln; | |
| if( bPrevLineExtentsComment ) | |
| goto PrevLineCommentLbl; | |
| if( *pLine == '#' ) | |
| { | |
| pLine++; | |
| nCol++; | |
| bHash = sal_True; | |
| } | |
| // Symbol? Dann Zeichen kopieren. | |
| if( BasicSimpleCharClass::isAlpha( *pLine, bCompatible ) || *pLine == '_' ) | |
| { | |
| // Wenn nach '_' nichts kommt, ist es ein Zeilenabschluss! | |
| if( *pLine == '_' && !*(pLine+1) ) | |
| { pLine++; | |
| goto eoln; } | |
| bSymbol = sal_True; | |
| short n = nCol; | |
| for ( ; (BasicSimpleCharClass::isAlphaNumeric( *pLine, bCompatible ) || ( *pLine == '_' ) ); pLine++ ) | |
| nCol++; | |
| aSym = aLine.copy( n, nCol - n ); | |
| // Special handling for "go to" | |
| if( bCompatible && *pLine && aSym.EqualsIgnoreCaseAscii( "go" ) ) | |
| { | |
| const sal_Unicode* pTestLine = pLine; | |
| short nTestCol = nCol; | |
| while( lclIsWhitespace( *pTestLine ) ) | |
| { | |
| pTestLine++; | |
| nTestCol++; | |
| } | |
| if( *pTestLine && *(pTestLine + 1) ) | |
| { | |
| String aTestSym = aLine.copy( nTestCol, 2 ); | |
| if( aTestSym.EqualsIgnoreCaseAscii( "to" ) ) | |
| { | |
| aSym = String::CreateFromAscii( "goto" ); | |
| pLine = pTestLine + 2; | |
| nCol = nTestCol + 2; | |
| } | |
| } | |
| } | |
| // Abschließendes '_' durch Space ersetzen, wenn Zeilenende folgt | |
| // (sonst falsche Zeilenfortsetzung) | |
| if( !bUsedForHilite && !*pLine && *(pLine-1) == '_' ) | |
| { | |
| aSym.GetBufferAccess(); // #109693 force copy if necessary | |
| *((sal_Unicode*)(pLine-1)) = ' '; // cast wegen const | |
| } | |
| // Typkennung? | |
| // Das Ausrufezeichen bitte nicht testen, wenn | |
| // danach noch ein Symbol anschließt | |
| else if( *pLine != '!' || !BasicSimpleCharClass::isAlpha( pLine[ 1 ], bCompatible ) ) | |
| { | |
| SbxDataType t = GetSuffixType( *pLine ); | |
| if( t != SbxVARIANT ) | |
| { | |
| eScanType = t; | |
| pLine++; | |
| nCol++; | |
| } | |
| } | |
| } | |
| // Zahl? Dann einlesen und konvertieren. | |
| else if( BasicSimpleCharClass::isDigit( *pLine & 0xFF ) | |
| || ( *pLine == '.' && BasicSimpleCharClass::isDigit( *(pLine+1) & 0xFF ) ) ) | |
| { | |
| short exp = 0; | |
| short comma = 0; | |
| short ndig = 0; | |
| short ncdig = 0; | |
| eScanType = SbxDOUBLE; | |
| sal_Bool bBufOverflow = sal_False; | |
| while( strchr( "0123456789.DEde", *pLine ) && *pLine ) | |
| { | |
| // AB 4.1.1996: Buffer voll? -> leer weiter scannen | |
| if( (p-buf) == (BUF_SIZE-1) ) | |
| { | |
| bBufOverflow = sal_True; | |
| pLine++, nCol++; | |
| continue; | |
| } | |
| // Komma oder Exponent? | |
| if( *pLine == '.' ) | |
| { | |
| if( ++comma > 1 ) | |
| { | |
| pLine++; nCol++; continue; | |
| } | |
| else *p++ = *pLine++, nCol++; | |
| } | |
| else if( strchr( "DdEe", *pLine ) ) | |
| { | |
| if (++exp > 1) | |
| { | |
| pLine++; nCol++; continue; | |
| } | |
| // if( toupper( *pLine ) == 'D' ) | |
| // eScanType = SbxDOUBLE; | |
| *p++ = 'E'; pLine++; nCol++; | |
| // Vorzeichen hinter Exponent? | |
| if( *pLine == '+' ) | |
| pLine++, nCol++; | |
| else | |
| if( *pLine == '-' ) | |
| *p++ = *pLine++, nCol++; | |
| } | |
| else | |
| { | |
| *p++ = *pLine++, nCol++; | |
| if( comma && !exp ) ncdig++; | |
| } | |
| if (!exp) ndig++; | |
| } | |
| *p = 0; | |
| aSym = p; bNumber = sal_True; | |
| // Komma, Exponent mehrfach vorhanden? | |
| if( comma > 1 || exp > 1 ) | |
| { aError = '.'; | |
| GenError( SbERR_BAD_CHAR_IN_NUMBER ); } | |
| // #57844 Lokalisierte Funktion benutzen | |
| nVal = rtl_math_uStringToDouble( buf, buf+(p-buf), '.', ',', NULL, NULL ); | |
| // ALT: nVal = atof( buf ); | |
| ndig = ndig - comma; | |
| if( !comma && !exp ) | |
| { | |
| if( nVal >= SbxMININT && nVal <= SbxMAXINT ) | |
| eScanType = SbxINTEGER; | |
| else | |
| if( nVal >= SbxMINLNG && nVal <= SbxMAXLNG ) | |
| eScanType = SbxLONG; | |
| } | |
| if( bBufOverflow ) | |
| GenError( SbERR_MATH_OVERFLOW ); | |
| // zu viele Zahlen für SINGLE? | |
| // if (ndig > 15 || ncdig > 6) | |
| // eScanType = SbxDOUBLE; | |
| // else | |
| // if( nVal > SbxMAXSNG || nVal < SbxMINSNG ) | |
| // eScanType = SbxDOUBLE; | |
| // Typkennung? | |
| SbxDataType t = GetSuffixType( *pLine ); | |
| if( t != SbxVARIANT ) | |
| { | |
| eScanType = t; | |
| pLine++; | |
| nCol++; | |
| } | |
| } | |
| // Hex/Oktalzahl? Einlesen und konvertieren: | |
| else if( *pLine == '&' ) | |
| { | |
| pLine++; nCol++; | |
| sal_Unicode cmp1[] = { '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F', 0 }; | |
| sal_Unicode cmp2[] = { '0', '1', '2', '3', '4', '5', '6', '7', 0 }; | |
| sal_Unicode *cmp = cmp1; | |
| //char *cmp = "0123456789ABCDEF"; | |
| sal_Unicode base = 16; | |
| sal_Unicode ndig = 8; | |
| sal_Unicode xch = *pLine++ & 0xFF; nCol++; | |
| switch( toupper( xch ) ) | |
| { | |
| case 'O': | |
| cmp = cmp2; base = 8; ndig = 11; break; | |
| //cmp = "01234567"; base = 8; ndig = 11; break; | |
| case 'H': | |
| break; | |
| default : | |
| // Wird als Operator angesehen | |
| pLine--; nCol--; nCol1 = nCol-1; aSym = '&'; return SYMBOL; | |
| } | |
| bNumber = sal_True; | |
| long l = 0; | |
| int i; | |
| sal_Bool bBufOverflow = sal_False; | |
| while( BasicSimpleCharClass::isAlphaNumeric( *pLine & 0xFF, bCompatible ) ) | |
| { | |
| sal_Unicode ch = sal::static_int_cast< sal_Unicode >( | |
| toupper( *pLine & 0xFF ) ); | |
| pLine++; nCol++; | |
| // AB 4.1.1996: Buffer voll, leer weiter scannen | |
| if( (p-buf) == (BUF_SIZE-1) ) | |
| bBufOverflow = sal_True; | |
| else if( String( cmp ).Search( ch ) != STRING_NOTFOUND ) | |
| //else if( strchr( cmp, ch ) ) | |
| *p++ = ch; | |
| else | |
| { | |
| aError = ch; | |
| GenError( SbERR_BAD_CHAR_IN_NUMBER ); | |
| } | |
| } | |
| *p = 0; | |
| for( p = buf; *p; p++ ) | |
| { | |
| i = (*p & 0xFF) - '0'; | |
| if( i > 9 ) i -= 7; | |
| l = ( l * base ) + i; | |
| if( !ndig-- ) | |
| { | |
| GenError( SbERR_MATH_OVERFLOW ); break; | |
| } | |
| } | |
| if( *pLine == '&' ) pLine++, nCol++; | |
| nVal = (double) l; | |
| eScanType = ( l >= SbxMININT && l <= SbxMAXINT ) ? SbxINTEGER : SbxLONG; | |
| if( bBufOverflow ) | |
| GenError( SbERR_MATH_OVERFLOW ); | |
| } | |
| // Strings: | |
| else if( *pLine == '"' || *pLine == '[' ) | |
| { | |
| sal_Unicode cSep = *pLine; | |
| if( cSep == '[' ) | |
| bSymbol = sal_True, cSep = ']'; | |
| short n = nCol+1; | |
| while( *pLine ) | |
| { | |
| do pLine++, nCol++; | |
| while( *pLine && ( *pLine != cSep ) ); | |
| if( *pLine == cSep ) | |
| { | |
| pLine++; nCol++; | |
| if( *pLine != cSep || cSep == ']' ) break; | |
| } else aError = cSep, GenError( SbERR_EXPECTED ); | |
| } | |
| // If VBA Interop then don't eat the [] chars | |
| if ( cSep == ']' && bVBASupportOn ) | |
| aSym = aLine.copy( n - 1, nCol - n + 1); | |
| else | |
| aSym = aLine.copy( n, nCol - n - 1 ); | |
| // Doppelte Stringbegrenzer raus | |
| String s( cSep ); | |
| s += cSep; | |
| sal_uInt16 nIdx = 0; | |
| do | |
| { | |
| nIdx = aSym.Search( s, nIdx ); | |
| if( nIdx == STRING_NOTFOUND ) | |
| break; | |
| aSym.Erase( nIdx, 1 ); | |
| nIdx++; | |
| } | |
| while( true ); | |
| if( cSep != ']' ) | |
| eScanType = ( cSep == '#' ) ? SbxDATE : SbxSTRING; | |
| } | |
| // ungültige Zeichen: | |
| else if( ( *pLine & 0xFF ) >= 0x7F ) | |
| { | |
| GenError( SbERR_SYNTAX ); pLine++; nCol++; | |
| } | |
| // andere Gruppen: | |
| else | |
| { | |
| short n = 1; | |
| switch( *pLine++ ) | |
| { | |
| case '<': if( *pLine == '>' || *pLine == '=' ) n = 2; break; | |
| case '>': if( *pLine == '=' ) n = 2; break; | |
| case ':': if( *pLine == '=' ) n = 2; break; | |
| } | |
| aSym = aLine.copy( nCol, n ); | |
| pLine += n-1; nCol = nCol + n; | |
| } | |
| nCol2 = nCol-1; | |
| PrevLineCommentLbl: | |
| // Comment? | |
| if( bPrevLineExtentsComment || (eScanType != SbxSTRING && | |
| ( aSym.GetBuffer()[0] == '\'' || aSym.EqualsIgnoreCaseAscii( "REM" ) ) ) ) | |
| { | |
| bPrevLineExtentsComment = sal_False; | |
| aSym = String::CreateFromAscii( "REM" ); | |
| sal_uInt16 nLen = String( pLine ).Len(); | |
| if( bCompatible && pLine[ nLen - 1 ] == '_' && pLine[ nLen - 2 ] == ' ' ) | |
| bPrevLineExtentsComment = sal_True; | |
| nCol2 = nCol2 + nLen; | |
| pLine = NULL; | |
| } | |
| return sal_True; | |
| // Sonst Zeilen-Ende: aber bitte auf '_' testen, ob die | |
| // Zeile nicht weitergeht! | |
| eoln: | |
| if( nCol && *--pLine == '_' ) | |
| { | |
| pLine = NULL; | |
| bool bRes = NextSym(); | |
| if( bVBASupportOn && aSym.GetBuffer()[0] == '.' ) | |
| { | |
| // object _ | |
| // .Method | |
| // ^^^ <- spaces is legal in MSO VBA | |
| OSL_TRACE("*** resetting bSpaces***"); | |
| bSpaces = sal_False; | |
| } | |
| return bRes; | |
| } | |
| else | |
| { | |
| pLine = NULL; | |
| nLine = nOldLine; | |
| nCol1 = nOldCol1; | |
| nCol2 = nOldCol2; | |
| aSym = '\n'; | |
| nColLock = 0; | |
| return sal_True; | |
| } | |
| } | |
| 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; | |
| } | |
| /* vim: set noet sw=4 ts=4: */ |