mirrors/cdt
1
0
Fork 0
mirror of https://github.com/eclipse-cdt/cdt synced 2025-04-29 19:45:01 +02:00
Code Issues Wiki Activity

Fixed https://bugs.eclipse.org/bugs/show_bug.cgi?id=65555

Browse source
This commit is contained in:
John Camelon 2004-06-08 17:57:37 +00:00
parent 1a728b8a2a
commit 8b2e0e8b4d
6 changed files with 249 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/Directives.java
View file

@ -28,5 +28,6 @@ public class Directives {
public static final String POUND_PRAGMA = "#pragma"; //$NON-NLS-1$ public static final String POUND_PRAGMA = "#pragma"; //$NON-NLS-1$
public static final String POUND_ELIF = "#elif"; //$NON-NLS-1$ public static final String POUND_ELIF = "#elif"; //$NON-NLS-1$
public static final String POUND_BLANK = "#"; //$NON-NLS-1$ public static final String POUND_BLANK = "#"; //$NON-NLS-1$
public static final String _PRAGMA = "_Pragma"; //$NON-NLS-1$
} }

2
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/KeywordSetKey.java
View file

@ -27,6 +27,8 @@ public class KeywordSetKey extends Enum
public static final KeywordSetKey EXPRESSION = new KeywordSetKey( 9 ); public static final KeywordSetKey EXPRESSION = new KeywordSetKey( 9 );
public static final KeywordSetKey MEMBER = new KeywordSetKey(10); public static final KeywordSetKey MEMBER = new KeywordSetKey(10);
public static final KeywordSetKey ALL = new KeywordSetKey( 11 ); public static final KeywordSetKey ALL = new KeywordSetKey( 11 );
public static final KeywordSetKey KEYWORDS = new KeywordSetKey( 12 );
public static final KeywordSetKey TYPES = new KeywordSetKey( 13 );
/** /**
* @param enumValue * @param enumValue
*/ */

4
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/scanner/Scanner.java
View file

@ -736,7 +736,7 @@ public final class Scanner implements IScanner, IScannerData {
private static final String PASTING = "<pasting>"; //$NON-NLS-1$ private static final String PASTING = "<pasting>"; //$NON-NLS-1$
private static final String DEFINED = "defined"; //$NON-NLS-1$ private static final String DEFINED = "defined"; //$NON-NLS-1$
private static final String _PRAGMA = "_Pragma"; //$NON-NLS-1$
private static final String POUND_DEFINE = "#define "; //$NON-NLS-1$ private static final String POUND_DEFINE = "#define "; //$NON-NLS-1$
private IScannerContext lastContext = null; private IScannerContext lastContext = null;
@ -1584,7 +1584,7 @@ public final class Scanner implements IScanner, IScannerData {
if (ident.equals(DEFINED)) if (ident.equals(DEFINED))
return newToken(IToken.tINTEGER, handleDefinedMacro()); return newToken(IToken.tINTEGER, handleDefinedMacro());
if( ident.equals(_PRAGMA) && language == ParserLanguage.C ) if( ident.equals(Directives._PRAGMA) && language == ParserLanguage.C )
{ {
handlePragmaOperator(); handlePragmaOperator();
return null; return null;

232
core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/token/KeywordSets.java
View file

@ -25,7 +25,6 @@ import org.eclipse.cdt.core.parser.ParserLanguage;
*/ */
public class KeywordSets { public class KeywordSets {
public static Set getKeywords( KeywordSetKey kind, ParserLanguage language ) public static Set getKeywords( KeywordSetKey kind, ParserLanguage language )
{ {
if( kind == KeywordSetKey.EMPTY ) if( kind == KeywordSetKey.EMPTY )
@ -53,28 +52,32 @@ public class KeywordSets {
if( kind == KeywordSetKey.MACRO ) if( kind == KeywordSetKey.MACRO )
return MACRO_ONLY; return MACRO_ONLY;
if( kind == KeywordSetKey.PP_DIRECTIVE ) if( kind == KeywordSetKey.PP_DIRECTIVE )
return PP_DIRECTIVES; return (Set) PP_DIRECTIVES_TABLE.get( language );
if( kind == KeywordSetKey.EXPRESSION ) if( kind == KeywordSetKey.EXPRESSION )
return (Set) EXPRESSION_TABLE.get( language ); return (Set) EXPRESSION_TABLE.get( language );
if( kind == KeywordSetKey.ALL ) if( kind == KeywordSetKey.ALL )
return (Set) ALL_TABLE.get( language ); return (Set) ALL_TABLE.get( language );
if( kind == KeywordSetKey.KEYWORDS )
return (Set) KEYWORDS_TABLE.get( language );
if( kind == KeywordSetKey.TYPES )
return (Set) TYPES_TABLE.get( language );
//TODO finish this //TODO finish this
return null; return null;
} }
private static final Set EMPTY_TABLE = new HashSet(); private static final Set EMPTY_TABLE = new HashSet(0);
private static final Set NAMESPACE_ONLY_SET; private static final Set NAMESPACE_ONLY_SET;
static static
{ {
NAMESPACE_ONLY_SET = new HashSet(); NAMESPACE_ONLY_SET = new HashSet(1);
NAMESPACE_ONLY_SET.add(Keywords.NAMESPACE ); NAMESPACE_ONLY_SET.add(Keywords.NAMESPACE );
} }
private static final Set MACRO_ONLY; private static final Set MACRO_ONLY;
static static
{ {
MACRO_ONLY = new HashSet(); MACRO_ONLY = new HashSet(1);
MACRO_ONLY.add("defined()" ); //$NON-NLS-1$ MACRO_ONLY.add("defined()" ); //$NON-NLS-1$
} }
@ -305,30 +308,51 @@ public class KeywordSets {
FUNCTION_MODIFIER_TABLE.put( ParserLanguage.CPP, FUNCTION_MODIFIER_CPP ); FUNCTION_MODIFIER_TABLE.put( ParserLanguage.CPP, FUNCTION_MODIFIER_CPP );
FUNCTION_MODIFIER_TABLE.put( ParserLanguage.C, FUNCTION_MODIFIER_C ); FUNCTION_MODIFIER_TABLE.put( ParserLanguage.C, FUNCTION_MODIFIER_C );
} }
private static final Set PP_DIRECTIVES; private static final Set PP_DIRECTIVES_C;
static static
{ {
PP_DIRECTIVES = new TreeSet(); PP_DIRECTIVES_C = new TreeSet();
PP_DIRECTIVES.add(Directives.POUND_BLANK); PP_DIRECTIVES_C.add(Directives.POUND_BLANK);
PP_DIRECTIVES.add(Directives.POUND_DEFINE); PP_DIRECTIVES_C.add(Directives.POUND_DEFINE);
PP_DIRECTIVES.add(Directives.POUND_UNDEF); PP_DIRECTIVES_C.add(Directives.POUND_UNDEF);
PP_DIRECTIVES.add(Directives.POUND_IF); PP_DIRECTIVES_C.add(Directives.POUND_IF);
PP_DIRECTIVES.add(Directives.POUND_IFDEF); PP_DIRECTIVES_C.add(Directives.POUND_IFDEF);
PP_DIRECTIVES.add(Directives.POUND_IFNDEF); PP_DIRECTIVES_C.add(Directives.POUND_IFNDEF);
PP_DIRECTIVES.add(Directives.POUND_ELSE); PP_DIRECTIVES_C.add(Directives.POUND_ELSE);
PP_DIRECTIVES.add(Directives.POUND_ENDIF); PP_DIRECTIVES_C.add(Directives.POUND_ENDIF);
PP_DIRECTIVES.add(Directives.POUND_INCLUDE); PP_DIRECTIVES_C.add(Directives.POUND_INCLUDE);
PP_DIRECTIVES.add(Directives.POUND_LINE); PP_DIRECTIVES_C.add(Directives.POUND_LINE);
PP_DIRECTIVES.add(Directives.POUND_ERROR); PP_DIRECTIVES_C.add(Directives.POUND_ERROR);
PP_DIRECTIVES.add(Directives.POUND_PRAGMA); PP_DIRECTIVES_C.add(Directives.POUND_PRAGMA);
PP_DIRECTIVES.add(Directives.POUND_ELIF); PP_DIRECTIVES_C.add(Directives.POUND_ELIF);
PP_DIRECTIVES_C.add(Directives._PRAGMA );
}
private static final Set PP_DIRECTIVES_CPP;
static
{
PP_DIRECTIVES_CPP = new TreeSet();
PP_DIRECTIVES_CPP.add(Directives.POUND_BLANK);
PP_DIRECTIVES_CPP.add(Directives.POUND_DEFINE);
PP_DIRECTIVES_CPP.add(Directives.POUND_UNDEF);
PP_DIRECTIVES_CPP.add(Directives.POUND_IF);
PP_DIRECTIVES_CPP.add(Directives.POUND_IFDEF);
PP_DIRECTIVES_CPP.add(Directives.POUND_IFNDEF);
PP_DIRECTIVES_CPP.add(Directives.POUND_ELSE);
PP_DIRECTIVES_CPP.add(Directives.POUND_ENDIF);
PP_DIRECTIVES_CPP.add(Directives.POUND_INCLUDE);
PP_DIRECTIVES_CPP.add(Directives.POUND_LINE);
PP_DIRECTIVES_CPP.add(Directives.POUND_ERROR);
PP_DIRECTIVES_CPP.add(Directives.POUND_PRAGMA);
PP_DIRECTIVES_CPP.add(Directives.POUND_ELIF);
} }
private static final Set ALL_C; private static final Set ALL_C;
static static
{ {
ALL_C = new TreeSet(PP_DIRECTIVES); ALL_C = new TreeSet(PP_DIRECTIVES_CPP);
ALL_C.add( Keywords.AUTO); ALL_C.add( Keywords.AUTO);
ALL_C.add( Keywords.BREAK); ALL_C.add( Keywords.BREAK);
ALL_C.add( Keywords.CASE); ALL_C.add( Keywords.CASE);
@ -372,7 +396,7 @@ public class KeywordSets {
private static final Set ALL_CPP; private static final Set ALL_CPP;
static static
{ {
ALL_CPP = new TreeSet(PP_DIRECTIVES); ALL_CPP = new TreeSet(PP_DIRECTIVES_CPP);
ALL_CPP.add( Keywords.AND ); ALL_CPP.add( Keywords.AND );
ALL_CPP.add( Keywords.AND_EQ); ALL_CPP.add( Keywords.AND_EQ);
ALL_CPP.add( Keywords.ASM); ALL_CPP.add( Keywords.ASM);
@ -456,5 +480,167 @@ public class KeywordSets {
ALL_TABLE.put( ParserLanguage.C, ALL_C ); ALL_TABLE.put( ParserLanguage.C, ALL_C );
ALL_TABLE.put( ParserLanguage.CPP, ALL_CPP ); ALL_TABLE.put( ParserLanguage.CPP, ALL_CPP );
} }
private static final Set KEYWORDS_CPP;
static
{
KEYWORDS_CPP = new TreeSet();
KEYWORDS_CPP.add( Keywords.AND );
KEYWORDS_CPP.add( Keywords.AND_EQ );
KEYWORDS_CPP.add( Keywords.ASM );
KEYWORDS_CPP.add( Keywords.AUTO );
KEYWORDS_CPP.add( Keywords.BITAND );
KEYWORDS_CPP.add( Keywords.BITOR );
KEYWORDS_CPP.add( Keywords.BREAK );
KEYWORDS_CPP.add( Keywords.CASE );
KEYWORDS_CPP.add( Keywords.CATCH );
KEYWORDS_CPP.add( Keywords.CLASS );
KEYWORDS_CPP.add( Keywords.COMPL );
KEYWORDS_CPP.add( Keywords.CONST );
KEYWORDS_CPP.add( Keywords.CONST_CAST );
KEYWORDS_CPP.add( Keywords.CONTINUE );
KEYWORDS_CPP.add( Keywords.DEFAULT );
KEYWORDS_CPP.add( Keywords.DELETE );
KEYWORDS_CPP.add( Keywords.DO );
KEYWORDS_CPP.add( Keywords.DYNAMIC_CAST );
KEYWORDS_CPP.add( Keywords.ELSE );
KEYWORDS_CPP.add( Keywords.ENUM );
KEYWORDS_CPP.add( Keywords.EXPLICIT );
KEYWORDS_CPP.add( Keywords.EXPORT );
KEYWORDS_CPP.add( Keywords.EXTERN );
KEYWORDS_CPP.add( Keywords.FALSE );
KEYWORDS_CPP.add( Keywords.FOR );
KEYWORDS_CPP.add( Keywords.FRIEND );
KEYWORDS_CPP.add( Keywords.GOTO );
KEYWORDS_CPP.add( Keywords.IF );
KEYWORDS_CPP.add( Keywords.INLINE );
KEYWORDS_CPP.add( Keywords.MUTABLE );
KEYWORDS_CPP.add( Keywords.NAMESPACE );
KEYWORDS_CPP.add( Keywords.NEW );
KEYWORDS_CPP.add( Keywords.NOT );
KEYWORDS_CPP.add( Keywords.NOT_EQ );
KEYWORDS_CPP.add( Keywords.OPERATOR );
KEYWORDS_CPP.add( Keywords.OR );
KEYWORDS_CPP.add( Keywords.OR_EQ );
KEYWORDS_CPP.add( Keywords.PRIVATE );
KEYWORDS_CPP.add( Keywords.PROTECTED );
KEYWORDS_CPP.add( Keywords.PUBLIC );
KEYWORDS_CPP.add( Keywords.REGISTER );
KEYWORDS_CPP.add( Keywords.REINTERPRET_CAST );
KEYWORDS_CPP.add( Keywords.RESTRICT );
KEYWORDS_CPP.add( Keywords.RETURN );
KEYWORDS_CPP.add( Keywords.SIZEOF );
KEYWORDS_CPP.add( Keywords.STATIC );
KEYWORDS_CPP.add( Keywords.STATIC_CAST );
KEYWORDS_CPP.add( Keywords.STRUCT );
KEYWORDS_CPP.add( Keywords.SWITCH );
KEYWORDS_CPP.add( Keywords.TEMPLATE );
KEYWORDS_CPP.add( Keywords.THIS );
KEYWORDS_CPP.add( Keywords.THROW );
KEYWORDS_CPP.add( Keywords.TRUE );
KEYWORDS_CPP.add( Keywords.TRY );
KEYWORDS_CPP.add( Keywords.TYPEDEF );
KEYWORDS_CPP.add( Keywords.TYPEID );
KEYWORDS_CPP.add( Keywords.TYPENAME );
KEYWORDS_CPP.add( Keywords.UNION );
KEYWORDS_CPP.add( Keywords.USING );
KEYWORDS_CPP.add( Keywords.VIRTUAL );
KEYWORDS_CPP.add( Keywords.VOLATILE );
KEYWORDS_CPP.add( Keywords.WHILE );
KEYWORDS_CPP.add( Keywords.XOR );
KEYWORDS_CPP.add( Keywords.XOR_EQ );
}
private static Set KEYWORDS_C;
static
{
KEYWORDS_C = new TreeSet();
KEYWORDS_C.add( Keywords.ASM );
KEYWORDS_C.add( Keywords.AUTO );
KEYWORDS_C.add( Keywords.BREAK );
KEYWORDS_C.add( Keywords.CASE );
KEYWORDS_C.add( Keywords.CONST );
KEYWORDS_C.add( Keywords.CONTINUE );
KEYWORDS_C.add( Keywords.DEFAULT );
KEYWORDS_C.add( Keywords.DO );
KEYWORDS_C.add( Keywords.ELSE );
KEYWORDS_C.add( Keywords.ENUM );
KEYWORDS_C.add( Keywords.EXTERN );
KEYWORDS_C.add( Keywords.FOR );
KEYWORDS_C.add( Keywords.GOTO );
KEYWORDS_C.add( Keywords.IF );
KEYWORDS_C.add( Keywords.INLINE );
KEYWORDS_C.add( Keywords.REGISTER );
KEYWORDS_C.add( Keywords.RETURN );
KEYWORDS_C.add( Keywords.RESTRICT );
KEYWORDS_C.add( Keywords.SIZEOF );
KEYWORDS_C.add( Keywords.STATIC );
KEYWORDS_C.add( Keywords.STRUCT );
KEYWORDS_C.add( Keywords.SWITCH );
KEYWORDS_C.add( Keywords.TYPEDEF );
KEYWORDS_C.add( Keywords.UNION );
KEYWORDS_C.add( Keywords.VOLATILE );
KEYWORDS_C.add( Keywords.WHILE );
}
private static final Hashtable KEYWORDS_TABLE;
static
{
KEYWORDS_TABLE = new Hashtable(2);
KEYWORDS_TABLE.put( ParserLanguage.C, KEYWORDS_C );
KEYWORDS_TABLE.put( ParserLanguage.CPP, KEYWORDS_CPP );
}
private static final Set TYPES_C;
static
{
TYPES_C = new TreeSet();
TYPES_C.add( Keywords.CHAR );
TYPES_C.add( Keywords.DOUBLE );
TYPES_C.add( Keywords.FLOAT );
TYPES_C.add( Keywords.INT );
TYPES_C.add( Keywords.LONG );
TYPES_C.add( Keywords.SHORT );
TYPES_C.add( Keywords.SIGNED );
TYPES_C.add( Keywords.UNSIGNED );
TYPES_C.add( Keywords.VOID );
TYPES_C.add( Keywords._BOOL );
TYPES_C.add( Keywords._COMPLEX );
TYPES_C.add( Keywords._IMAGINARY );
}
private static final Set TYPES_CPP;
static
{
TYPES_CPP = new TreeSet();
TYPES_CPP.add( Keywords.BOOL );
TYPES_CPP.add( Keywords.CHAR );
TYPES_CPP.add( Keywords.DOUBLE );
TYPES_CPP.add( Keywords.FLOAT );
TYPES_CPP.add( Keywords.INT );
TYPES_CPP.add( Keywords.LONG );
TYPES_CPP.add( Keywords.SHORT );
TYPES_CPP.add( Keywords.SIGNED );
TYPES_CPP.add( Keywords.UNSIGNED );
TYPES_CPP.add( Keywords.VOID );
TYPES_CPP.add( Keywords.WCHAR_T );
}
private static Hashtable TYPES_TABLE;
static
{
TYPES_TABLE = new Hashtable( 2 );
TYPES_TABLE.put( ParserLanguage.C, TYPES_C );
TYPES_TABLE.put( ParserLanguage.CPP, TYPES_CPP );
}
private static Hashtable PP_DIRECTIVES_TABLE;
static
{
PP_DIRECTIVES_TABLE = new Hashtable( 2 );
PP_DIRECTIVES_TABLE.put( ParserLanguage.C, PP_DIRECTIVES_C );
PP_DIRECTIVES_TABLE.put( ParserLanguage.CPP, PP_DIRECTIVES_CPP );
}
} }

57
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/text/CCodeScanner.java
View file

@ -7,8 +7,12 @@ package org.eclipse.cdt.internal.ui.text;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; import java.util.List;
import org.eclipse.cdt.core.parser.KeywordSetKey;
import org.eclipse.cdt.core.parser.ParserFactory;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.internal.ui.text.util.CWordDetector; import org.eclipse.cdt.internal.ui.text.util.CWordDetector;
import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.rules.IRule; import org.eclipse.jface.text.rules.IRule;
@ -23,37 +27,8 @@ import org.eclipse.jface.util.PropertyChangeEvent;
*/ */
public final class CCodeScanner extends AbstractCScanner { public final class CCodeScanner extends AbstractCScanner {
private static String[] fgKeywords= {
"asm", "auto", //$NON-NLS-1$ //$NON-NLS-2$
"break", //$NON-NLS-1$
"case", //$NON-NLS-1$
"const", "continue", //$NON-NLS-1$ //$NON-NLS-2$
"default", "do", //$NON-NLS-1$ //$NON-NLS-2$
"else", "enum", "extern", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"for", //$NON-NLS-1$
"goto", //$NON-NLS-1$
"if", "inline", //$NON-NLS-1$ //$NON-NLS-2$
"register", "return", "restrict", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"sizeof", "static", "struct", "switch", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
"typedef", //$NON-NLS-1$
"union", //$NON-NLS-1$
"volatile", //$NON-NLS-1$
"while", "_Pragma" //$NON-NLS-1$ //$NON-NLS-2$
};
private static String[] fgTypes= { "char", "double", "float", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"int", "long", "short", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"signed", "unsigned", "void", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"_Bool", "_Complex", "_Imaginary"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
private static String[] fgConstants= { "NULL", "__DATE__", "__LINE__", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ private static String[] fgConstants= { "NULL", "__DATE__", "__LINE__", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"__TIME__", "__FILE__", "__STDC__"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ "__TIME__", "__FILE__", "__STDC__"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
private static String[] fgPreprocessor= { "#define", "#undef", "#include", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"#error", "#warning", "#pragma", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"#ifdef", "#ifndef", "#if", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"#else", "#elif", "#endif", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"#line"}; //$NON-NLS-1$
private static String[] fgTokenProperties= { private static String[] fgTokenProperties= {
@ -101,21 +76,25 @@ public final class CCodeScanner extends AbstractCScanner {
WordRule wordRule= new WordRule(new CWordDetector(), token); WordRule wordRule= new WordRule(new CWordDetector(), token);
token= getToken(ICColorConstants.C_KEYWORD); token= getToken(ICColorConstants.C_KEYWORD);
for (int i=0; i<fgKeywords.length; i++) Iterator i = ParserFactory.getKeywordSet( KeywordSetKey.KEYWORDS, ParserLanguage.C ).iterator();
wordRule.addWord(fgKeywords[i], token); while( i.hasNext() )
wordRule.addWord((String) i.next(), token);
token= getToken(ICColorConstants.C_TYPE); token= getToken(ICColorConstants.C_TYPE);
for (int i=0; i<fgTypes.length; i++) i = ParserFactory.getKeywordSet( KeywordSetKey.TYPES, ParserLanguage.C ).iterator();
wordRule.addWord(fgTypes[i], token); while( i.hasNext() )
for (int i=0; i<fgConstants.length; i++) wordRule.addWord((String) i.next(), token);
wordRule.addWord(fgConstants[i], token);
for (int j=0; j<fgConstants.length; j++)
wordRule.addWord(fgConstants[j], token);
rules.add(wordRule); rules.add(wordRule);
token = getToken(ICColorConstants.C_TYPE); token = getToken(ICColorConstants.C_TYPE);
PreprocessorRule preprocessorRule = new PreprocessorRule(new CWordDetector(), token); PreprocessorRule preprocessorRule = new PreprocessorRule(new CWordDetector(), token);
for (int i=0; i<fgPreprocessor.length; i++) { i = ParserFactory.getKeywordSet( KeywordSetKey.PP_DIRECTIVE, ParserLanguage.C ).iterator();
preprocessorRule.addWord(fgPreprocessor[i], token); while( i.hasNext() )
} preprocessorRule.addWord((String) i.next(), token);
rules.add(preprocessorRule); rules.add(preprocessorRule);
setDefaultReturnToken(getToken(ICColorConstants.C_DEFAULT)); setDefaultReturnToken(getToken(ICColorConstants.C_DEFAULT));

82
core/org.eclipse.cdt.ui/src/org/eclipse/cdt/internal/ui/text/CppCodeScanner.java
View file

@ -5,10 +5,14 @@ package org.eclipse.cdt.internal.ui.text;
* All Rights Reserved. * All Rights Reserved.
*/ */
import org.eclipse.cdt.internal.ui.text.util.CWordDetector;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Iterator;
import java.util.List; import java.util.List;
import org.eclipse.cdt.core.parser.KeywordSetKey;
import org.eclipse.cdt.core.parser.ParserFactory;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.internal.ui.text.util.CWordDetector;
import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.text.rules.IRule; import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.SingleLineRule; import org.eclipse.jface.text.rules.SingleLineRule;
@ -22,47 +26,10 @@ import org.eclipse.jface.util.PropertyChangeEvent;
*/ */
public final class CppCodeScanner extends AbstractCScanner { public final class CppCodeScanner extends AbstractCScanner {
private static String[] fgKeywords= { private static String[] fgConstants= { "NULL", //$NON-NLS-1$
"and", "and_eq", "asm", "auto", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
"bitand", "bitor", "break", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"case", "catch", "class", "compl", "const", "const_cast", "continue", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$
"default", "delete", "do", "dynamic_cast", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
"else", "enum", "explicit", "export", "extern", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
"false", "final", "finally", "for", "friend", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
"goto", //$NON-NLS-1$
"if", "inline", //$NON-NLS-1$ //$NON-NLS-2$
"mutable", //$NON-NLS-1$
"namespace", "new", "not", "not_eq", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
"operator", "or", "or_eq", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"private", "protected", "public", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"redeclared", "register", "reinterpret_cast", "return", "restrict", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
"sizeof", "static", "static_cast", "struct", "switch", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$
"template", "this", "throw", "true", "try", "typedef", "typeid", "typename", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$ //$NON-NLS-5$ //$NON-NLS-6$ //$NON-NLS-7$ //$NON-NLS-8$
"union", "using", //$NON-NLS-1$ //$NON-NLS-2$
"virtual", "volatile", //$NON-NLS-1$ //$NON-NLS-2$
"while", //$NON-NLS-1$
"xor", "xor_eq" //$NON-NLS-1$ //$NON-NLS-2$
};
private static String[] fgTypes= { "bool", "char", "double", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"float", "int", "long", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"short", "signed", "unsigned", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"void", "wchar_t", "_Bool", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"_Complex", "_Imaginary"}; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
private static String[] fgConstants= { "false", "NULL", "true", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"__DATE__", "__LINE__", "__TIME__", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ "__DATE__", "__LINE__", "__TIME__", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"__FILE__", "__STDC__"}; //$NON-NLS-1$ //$NON-NLS-2$ "__FILE__", "__STDC__"}; //$NON-NLS-1$ //$NON-NLS-2$
private static String[] fgPreprocessor= { "#define", "#undef", "#include", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"#error", "#warning", "#pragma", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"#ifdef", "#ifndef", "#line", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"#undef", "#if", "#else", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
"#elif", "#endif"}; //$NON-NLS-1$ //$NON-NLS-2$
private static String[] fgTokenProperties= { private static String[] fgTokenProperties= {
ICColorConstants.C_KEYWORD, ICColorConstants.C_KEYWORD,
ICColorConstants.C_TYPE, ICColorConstants.C_TYPE,
@ -109,21 +76,24 @@ public final class CppCodeScanner extends AbstractCScanner {
WordRule wordRule= new WordRule(new CWordDetector(), token); WordRule wordRule= new WordRule(new CWordDetector(), token);
token= getToken(ICColorConstants.C_KEYWORD); token= getToken(ICColorConstants.C_KEYWORD);
for (int i=0; i<fgKeywords.length; i++) Iterator iter = ParserFactory.getKeywordSet( KeywordSetKey.KEYWORDS, ParserLanguage.CPP ).iterator();
wordRule.addWord(fgKeywords[i], token); while( iter.hasNext() )
wordRule.addWord((String)iter.next(), token);
token= getToken(ICColorConstants.C_TYPE); token= getToken(ICColorConstants.C_TYPE);
for (int i=0; i<fgTypes.length; i++) iter = ParserFactory.getKeywordSet( KeywordSetKey.TYPES, ParserLanguage.CPP ).iterator();
wordRule.addWord(fgTypes[i], token); while( iter.hasNext() )
wordRule.addWord((String) iter.next(), token);
for (int i=0; i<fgConstants.length; i++) for (int i=0; i<fgConstants.length; i++)
wordRule.addWord(fgConstants[i], token); wordRule.addWord(fgConstants[i], token);
rules.add(wordRule); rules.add(wordRule);
token = getToken(ICColorConstants.C_TYPE); token = getToken(ICColorConstants.C_TYPE);
PreprocessorRule preprocessorRule = new PreprocessorRule(new CWordDetector(), token); PreprocessorRule preprocessorRule = new PreprocessorRule(new CWordDetector(), token);
iter = ParserFactory.getKeywordSet( KeywordSetKey.PP_DIRECTIVE, ParserLanguage.CPP ).iterator();
for (int i=0; i<fgPreprocessor.length; i++) {
preprocessorRule.addWord(fgPreprocessor[i], token); while( iter.hasNext() )
} preprocessorRule.addWord((String) iter.next(), token);
rules.add(preprocessorRule); rules.add(preprocessorRule);
setDefaultReturnToken(getToken(ICColorConstants.C_DEFAULT)); setDefaultReturnToken(getToken(ICColorConstants.C_DEFAULT));
@ -154,22 +124,4 @@ public final class CppCodeScanner extends AbstractCScanner {
} }
} }
public static String[] getKeywords(){
int keysLength = fgKeywords.length;
int typesLength = fgTypes.length;
int preprocessorLength = fgPreprocessor.length;
int constsLength = fgConstants.length;
String[] keywords = new String[keysLength + typesLength + preprocessorLength + constsLength];
System.arraycopy(fgKeywords,0,keywords,0,keysLength);
System.arraycopy(fgTypes,0,keywords,keysLength,typesLength);
System.arraycopy(fgPreprocessor,0,keywords,(keysLength + typesLength),preprocessorLength);
System.arraycopy(fgConstants,0,keywords,(keysLength + typesLength + preprocessorLength),constsLength);
return keywords;
}
} }