<s> package org . eclipse . jdt . internal . core ; import java . util . Map ; import org . eclipse . jdt . core . IJavaProject ; import org . eclipse . jdt . core . JavaCore ; import org . eclipse . jdt . core . compiler . CharOperation ; import org . eclipse . jdt . core . compiler . InvalidInputException ; import org . eclipse . jdt . internal . codeassist . impl . AssistOptions ; import org . eclipse . jdt . internal . compiler . impl . CompilerOptions ; import org . eclipse . jdt . internal . compiler . parser . Scanner ; import org . eclipse . jdt . internal . compiler . parser . ScannerHelper ; import org . eclipse . jdt . internal . compiler . parser . TerminalTokens ; import org . eclipse . jdt . internal . compiler . util . SimpleSetOfCharArray ; public class InternalNamingConventions { private static final char [ ] DEFAULT_NAME = "name" . toCharArray ( ) ; private static Scanner getNameScanner ( CompilerOptions compilerOptions ) { return new Scanner ( false , false , false , compilerOptions . sourceLevel , null , null , true ) ; } private static void acceptName ( char [ ] name , char [ ] prefix , char [ ] suffix , boolean isFirstPrefix , boolean isFirstSuffix , int reusedCharacters , INamingRequestor requestor ) { if ( prefix . length > 0 && suffix . length > 0 ) { requestor . acceptNameWithPrefixAndSuffix ( name , isFirstPrefix , isFirstSuffix , reusedCharacters ) ; } else if ( prefix . length > 0 ) { requestor . acceptNameWithPrefix ( name , isFirstPrefix , reusedCharacters ) ; } else if ( suffix . length > 0 ) { requestor . acceptNameWithSuffix ( name , isFirstSuffix , reusedCharacters ) ; } else { requestor . acceptNameWithoutPrefixAndSuffix ( name , reusedCharacters ) ; } } private static char [ ] [ ] computeBaseTypeNames ( char [ ] typeName , boolean isConstantField , char [ ] [ ] excludedNames ) { if ( isConstantField ) { return computeNonBaseTypeNames ( typeName , isConstantField , false ) ; } else { char [ ] name = computeBaseTypeNames ( typeName [ 0 ] , excludedNames ) ; if ( name != null ) { return new char [ ] [ ] { name } ; } else { return computeNonBaseTypeNames ( typeName , isConstantField , false ) ; } } } private static char [ ] computeBaseTypeNames ( char firstName , char [ ] [ ] excludedNames ) { char [ ] name = new char [ ] { firstName } ; for ( int i = 0 ; i < excludedNames . length ; i ++ ) { if ( CharOperation . equals ( name , excludedNames [ i ] , false ) ) { name [ 0 ] ++ ; if ( name [ 0 ] > 'z' ) name [ 0 ] = 'a' ; if ( name [ 0 ] == firstName ) return null ; i = 0 ; } } return name ; } private static char [ ] [ ] computeNonBaseTypeNames ( char [ ] sourceName , boolean isConstantField , boolean onlyLongest ) { int length = sourceName . length ; if ( length == 0 ) { return CharOperation . NO_CHAR_CHAR ; } if ( length == 1 ) { if ( isConstantField ) { return generateConstantName ( new char [ ] [ ] { CharOperation . toLowerCase ( sourceName ) } , 0 , onlyLongest ) ; } else { return generateNonConstantName ( new char [ ] [ ] { CharOperation . toLowerCase ( sourceName ) } , 0 , onlyLongest ) ; } } char [ ] [ ] nameParts = new char [ length ] [ ] ; int namePartsPtr = - 1 ; int endIndex = length ; char c = sourceName [ length - 1 ] ; final int IS_LOWER_CASE = 1 ; final int IS_UPPER_CASE = 2 ; final int IS_UNDERSCORE = 3 ; final int IS_OTHER = 4 ; int previousCharKind = ScannerHelper . isLowerCase ( c ) ? IS_LOWER_CASE : ScannerHelper . isUpperCase ( c ) ? IS_UPPER_CASE : c == '_' ? IS_UNDERSCORE : IS_OTHER ; for ( int i = length - 1 ; i >= 0 ; i -- ) { c = sourceName [ i ] ; int charKind = ScannerHelper . isLowerCase ( c ) ? IS_LOWER_CASE : ScannerHelper . isUpperCase ( c ) ? IS_UPPER_CASE : c == '_' ? IS_UNDERSCORE : IS_OTHER ; switch ( charKind ) { case IS_LOWER_CASE : if ( previousCharKind == IS_UPPER_CASE ) { nameParts [ ++ namePartsPtr ] = CharOperation . subarray ( sourceName , i + 1 , endIndex ) ; endIndex = i + 1 ; } previousCharKind = IS_LOWER_CASE ; break ; case IS_UPPER_CASE : if ( previousCharKind == IS_LOWER_CASE ) { nameParts [ ++ namePartsPtr ] = CharOperation . subarray ( sourceName , i , endIndex ) ; if ( i > 0 ) { char pc = sourceName [ i - 1 ] ; previousCharKind = ScannerHelper . isLowerCase ( pc ) ? IS_LOWER_CASE : ScannerHelper . isUpperCase ( pc ) ? IS_UPPER_CASE : pc == '_' ? IS_UNDERSCORE : IS_OTHER ; } endIndex = i ; } else { previousCharKind = IS_UPPER_CASE ; } break ; case IS_UNDERSCORE : switch ( previousCharKind ) { case IS_UNDERSCORE : if ( isConstantField ) { if ( i > 0 ) { char pc = sourceName [ i - 1 ] ; previousCharKind = ScannerHelper . isLowerCase ( pc ) ? IS_LOWER_CASE : ScannerHelper . isUpperCase ( pc ) ? IS_UPPER_CASE : pc == '_' ? IS_UNDERSCORE : IS_OTHER ; } endIndex = i ; } break ; case IS_LOWER_CASE : case IS_UPPER_CASE : nameParts [ ++ namePartsPtr ] = CharOperation . subarray ( sourceName , i + 1 , endIndex ) ; if ( i > 0 ) { char pc = sourceName [ i - 1 ] ; previousCharKind = ScannerHelper . isLowerCase ( pc ) ? IS_LOWER_CASE : ScannerHelper . isUpperCase ( pc ) ? IS_UPPER_CASE : pc == '_' ? IS_UNDERSCORE : IS_OTHER ; } endIndex = i + 1 ; break ; default : previousCharKind = IS_UNDERSCORE ; break ; } break ; default : previousCharKind = IS_OTHER ; break ; } } if ( endIndex > 0 ) { nameParts [ ++ namePartsPtr ] = CharOperation . subarray ( sourceName , 0 , endIndex ) ; } if ( namePartsPtr == - 1 ) { return new char [ ] [ ] { sourceName } ; } if ( isConstantField ) { return generateConstantName ( nameParts , namePartsPtr , onlyLongest ) ; } else { return generateNonConstantName ( nameParts , namePartsPtr , onlyLongest ) ; } } private static char [ ] excludeNames ( char [ ] suffixName , char [ ] prefixName , char [ ] suffix , char [ ] [ ] excludedNames ) { int count = 2 ; int m = 0 ; while ( m < excludedNames . length ) { if ( CharOperation . equals ( suffixName , excludedNames [ m ] , false ) ) { suffixName = CharOperation . concat ( prefixName , String . valueOf ( count ++ ) . toCharArray ( ) , suffix ) ; m = 0 ; } else { m ++ ; } } return suffixName ; } private static char [ ] [ ] generateNonConstantName ( char [ ] [ ] nameParts , int namePartsPtr , boolean onlyLongest ) { char [ ] [ ] names ; if ( onlyLongest ) { names = new char [ 1 ] [ ] ; } else { names = new char [ namePartsPtr + 1 ] [ ] ; } char [ ] namePart = nameParts [ 0 ] ; char [ ] name = CharOperation . toLowerCase ( namePart ) ; if ( ! onlyLongest ) { names [ namePartsPtr ] = name ; } char [ ] nameSuffix = namePart ; for ( int i = 1 ; i <= namePartsPtr ; i ++ ) { namePart = nameParts [ i ] ; name = CharOperation . concat ( CharOperation . toLowerCase ( namePart ) , nameSuffix ) ; if ( ! onlyLongest ) { names [ namePartsPtr - i ] = name ; } nameSuffix = CharOperation . concat ( namePart , nameSuffix ) ; } if ( onlyLongest ) { names [ 0 ] = name ; } return names ; } private static char [ ] [ ] generateConstantName ( char [ ] [ ] nameParts , int namePartsPtr , boolean onlyLongest ) { char [ ] [ ] names ; if ( onlyLongest ) { names = new char [ 1 ] [ ] ; } else { names = new char [ namePartsPtr + 1 ] [ ] ; } char [ ] namePart = CharOperation . toUpperCase ( nameParts [ 0 ] ) ; int namePartLength = namePart . length ; System . arraycopy ( namePart , 0 , namePart , 0 , namePartLength ) ; char [ ] name = namePart ; if ( ! onlyLongest ) { names [ namePartsPtr ] = name ; } for ( int i = 1 ; i <= namePartsPtr ; i ++ ) { namePart = CharOperation . toUpperCase ( nameParts [ i ] ) ; namePartLength = namePart . length ; if ( namePart [ namePartLength - 1 ] != '_' ) { name = CharOperation . concat ( namePart , name , '_' ) ; } else { name = CharOperation . concat ( namePart , name ) ; } if ( ! onlyLongest ) { names [ namePartsPtr - i ] = name ; } } if ( onlyLongest ) { names [ 0 ] = name ; } return names ; } public static char [ ] getBaseName ( int variableKind , IJavaProject javaProject , char [ ] name , boolean updateFirstCharacter ) { AssistOptions assistOptions ; if ( javaProject != null ) { assistOptions = new AssistOptions ( javaProject . getOptions ( true ) ) ; } else { assistOptions = new AssistOptions ( JavaCore . getOptions ( ) ) ; } char [ ] [ ] prefixes = null ; char [ ] [ ] suffixes = null ; switch ( variableKind ) { case VK_INSTANCE_FIELD : prefixes = assistOptions . fieldPrefixes ; suffixes = assistOptions . fieldSuffixes ; break ; case VK_STATIC_FIELD : prefixes = assistOptions . staticFieldPrefixes ; suffixes = assistOptions . staticFieldSuffixes ; break ; case VK_STATIC_FINAL_FIELD : prefixes = assistOptions . staticFinalFieldPrefixes ; suffixes = assistOptions . staticFinalFieldSuffixes ; break ; case VK_LOCAL : prefixes = assistOptions . localPrefixes ; suffixes = assistOptions . localSuffixes ; break ; case VK_PARAMETER : prefixes = assistOptions . argumentPrefixes ; suffixes = assistOptions . argumentSuffixes ; break ; } return getBaseName ( name , prefixes , suffixes , variableKind == VK_STATIC_FINAL_FIELD , updateFirstCharacter ) ; } private static char [ ] getBaseName ( char [ ] name , char [ ] [ ] prefixes , char [ ] [ ] suffixes , boolean isConstant , boolean updateFirstCharacter ) { char [ ] nameWithoutPrefixAndSiffix = removeVariablePrefixAndSuffix ( name , prefixes , suffixes , updateFirstCharacter ) ; char [ ] baseName ; if ( isConstant ) { int length = nameWithoutPrefixAndSiffix . length ; baseName = new char [ length ] ; int baseNamePtr = - 1 ; boolean previousIsUnderscore = false ; for ( int i = 0 ; i < length ; i ++ ) { char c = nameWithoutPrefixAndSiffix [ i ] ; if ( c != '_' ) { if ( previousIsUnderscore ) { baseName [ ++ baseNamePtr ] = ScannerHelper . toUpperCase ( c ) ; previousIsUnderscore = false ; } else { baseName [ ++ baseNamePtr ] = ScannerHelper . toLowerCase ( c ) ; } } else { previousIsUnderscore = true ; } } System . arraycopy ( baseName , 0 , baseName = new char [ baseNamePtr + 1 ] , 0 , baseNamePtr + 1 ) ; } else { baseName = nameWithoutPrefixAndSiffix ; } return baseName ; } public static char [ ] removeVariablePrefixAndSuffix ( int variableKind , IJavaProject javaProject , char [ ] name ) { AssistOptions assistOptions ; if ( javaProject != null ) { assistOptions = new AssistOptions ( javaProject . getOptions ( true ) ) ; } else { assistOptions = new AssistOptions ( JavaCore . getOptions ( ) ) ; } char [ ] [ ] prefixes = null ; char [ ] [ ] suffixes = null ; switch ( variableKind ) { case VK_INSTANCE_FIELD : prefixes = assistOptions . fieldPrefixes ; suffixes = assistOptions . fieldSuffixes ; break ; case VK_STATIC_FIELD : prefixes = assistOptions . staticFieldPrefixes ; suffixes = assistOptions . staticFieldSuffixes ; break ; case VK_STATIC_FINAL_FIELD : prefixes = assistOptions . staticFinalFieldPrefixes ; suffixes = assistOptions . staticFinalFieldSuffixes ; break ; case VK_LOCAL : prefixes = assistOptions . localPrefixes ; suffixes = assistOptions . localSuffixes ; break ; case VK_PARAMETER : prefixes = assistOptions . argumentPrefixes ; suffixes = assistOptions . argumentSuffixes ; break ; } return InternalNamingConventions . removeVariablePrefixAndSuffix ( name , prefixes , suffixes , true ) ; } private static char [ ] removeVariablePrefixAndSuffix ( char [ ] name , char [ ] [ ] prefixes , char [ ] [ ] suffixes , boolean updateFirstCharacter ) { char [ ] withoutPrefixName = name ; if ( prefixes != null ) { int bestLength = 0 ; for ( int i = 0 ; i < prefixes . length ; i ++ ) { char [ ] prefix = prefixes [ i ] ; if ( CharOperation . prefixEquals ( prefix , name ) ) { int currLen = prefix . length ; boolean lastCharIsLetter = ScannerHelper . isLetter ( prefix [ currLen - 1 ] ) ; if ( ! lastCharIsLetter || ( lastCharIsLetter && name . length > currLen && ScannerHelper . isUpperCase ( name [ currLen ] ) ) ) { if ( bestLength < currLen && name . length != currLen ) { withoutPrefixName = CharOperation . subarray ( name , currLen , name . length ) ; bestLength = currLen ; } } } } } char [ ] withoutSuffixName = withoutPrefixName ; if ( suffixes != null ) { int bestLength = 0 ; for ( int i = 0 ; i < suffixes . length ; i ++ ) { char [ ] suffix = suffixes [ i ] ; if ( CharOperation . endsWith ( withoutPrefixName , suffix ) ) { int currLen = suffix . length ; if ( bestLength < currLen && withoutPrefixName . length != currLen ) { withoutSuffixName = CharOperation . subarray ( withoutPrefixName , 0 , withoutPrefixName . length - currLen ) ; bestLength = currLen ; } } } } if ( updateFirstCharacter ) withoutSuffixName [ 0 ] = ScannerHelper . toLowerCase ( withoutSuffixName [ 0 ] ) ; return withoutSuffixName ; } private static char [ ] removePrefix ( char [ ] name , char [ ] [ ] prefixes ) { char [ ] withoutPrefixName = name ; if ( prefixes != null ) { int bestLength = 0 ; int nameLength = name . length ; for ( int i = 0 ; i < prefixes . length ; i ++ ) { char [ ] prefix = prefixes [ i ] ; int prefixLength = prefix . length ; if ( prefixLength <= nameLength ) { if ( CharOperation . prefixEquals ( prefix , name , false ) ) { if ( prefixLength > bestLength ) { bestLength = prefixLength ; } } } else { int currLen = 0 ; for ( ; currLen < nameLength ; currLen ++ ) { if ( ScannerHelper . toLowerCase ( prefix [ currLen ] ) != ScannerHelper . toLowerCase ( name [ currLen ] ) ) { if ( currLen > bestLength ) { bestLength = currLen ; } break ; } } if ( currLen == nameLength && currLen > bestLength ) { bestLength = currLen ; } } } if ( bestLength > 0 ) { if ( bestLength == nameLength ) { withoutPrefixName = CharOperation . NO_CHAR ; } else { withoutPrefixName = CharOperation . subarray ( name , bestLength , nameLength ) ; } } } return withoutPrefixName ; } public static final int VK_STATIC_FIELD = 1 ; public static final int VK_INSTANCE_FIELD = 2 ; public static final int VK_STATIC_FINAL_FIELD = 3 ; public static final int VK_PARAMETER = 4 ; public static final int VK_LOCAL = 5 ; public static final int BK_SIMPLE_NAME = 1 ; public static final int BK_SIMPLE_TYPE_NAME = 2 ; public static void suggestVariableNames ( int variableKind , int baseNameKind , char [ ] baseName , IJavaProject javaProject , int dim , char [ ] internalPrefix , char [ ] [ ] excluded , boolean evaluateDefault , INamingRequestor requestor ) { if ( baseName == null || baseName . length == 0 ) return ; Map options ; if ( javaProject != null ) { options = javaProject . getOptions ( true ) ; } else { options = JavaCore . getOptions ( ) ; } CompilerOptions compilerOptions = new CompilerOptions ( options ) ; AssistOptions assistOptions = new AssistOptions ( options ) ; boolean isConstantField = false ; char [ ] [ ] prefixes = null ; char [ ] [ ] suffixes = null ; switch ( variableKind ) { case VK_INSTANCE_FIELD : prefixes = assistOptions . fieldPrefixes ; suffixes = assistOptions . fieldSuffixes ; break ; case VK_STATIC_FIELD : prefixes = assistOptions . staticFieldPrefixes ; suffixes = assistOptions . staticFieldSuffixes ; break ; case VK_STATIC_FINAL_FIELD : isConstantField = true ; prefixes = assistOptions . staticFinalFieldPrefixes ; suffixes = assistOptions . staticFinalFieldSuffixes ; break ; case VK_LOCAL : prefixes = assistOptions . localPrefixes ; suffixes = assistOptions . localSuffixes ; break ; case VK_PARAMETER : prefixes = assistOptions . argumentPrefixes ; suffixes = assistOptions . argumentSuffixes ; break ; } if ( prefixes == null || prefixes . length == 0 ) { prefixes = new char [ 1 ] [ 0 ] ; } else { int length = prefixes . length ; System . arraycopy ( prefixes , 0 , prefixes = new char [ length + 1 ] [ ] , 0 , length ) ; prefixes [ length ] = CharOperation . NO_CHAR ; } if ( suffixes == null || suffixes . length == 0 ) { suffixes = new char [ 1 ] [ 0 ] ; } else { int length = suffixes . length ; System . arraycopy ( suffixes , 0 , suffixes = new char [ length + 1 ] [ ] , 0 , length ) ; suffixes [ length ] = CharOperation . NO_CHAR ; } if ( internalPrefix == null ) { internalPrefix = CharOperation . NO_CHAR ; } else { internalPrefix = removePrefix ( internalPrefix , prefixes ) ; } char [ ] [ ] tempNames = null ; Scanner nameScanner = getNameScanner ( compilerOptions ) ; if ( baseNameKind == BK_SIMPLE_TYPE_NAME ) { boolean isBaseType = false ; try { nameScanner . setSource ( baseName ) ; switch ( nameScanner . getNextToken ( ) ) { case TerminalTokens . TokenNameint : case TerminalTokens . TokenNamebyte : case TerminalTokens . TokenNameshort : case TerminalTokens . TokenNamechar : case TerminalTokens . TokenNamelong : case TerminalTokens . TokenNamefloat : case TerminalTokens . TokenNamedouble : case TerminalTokens . TokenNameboolean : isBaseType = true ; break ; } } catch ( InvalidInputException e ) { } if ( isBaseType ) { if ( internalPrefix . length > 0 ) return ; tempNames = computeBaseTypeNames ( baseName , isConstantField , excluded ) ; } else { tempNames = computeNonBaseTypeNames ( baseName , isConstantField , false ) ; } } else { tempNames = computeNonBaseTypeNames ( baseName , isConstantField , true ) ; } boolean acceptDefaultName = true ; SimpleSetOfCharArray foundNames = new SimpleSetOfCharArray ( ) ; for ( int i = 0 ; i < tempNames . length ; i ++ ) { char [ ] tempName = tempNames [ i ] ; if ( dim > 0 ) { int length = tempName . length ; if ( isConstantField ) { if ( tempName [ length - 1 ] == 'S' ) { if ( tempName . length > 1 && tempName [ length - 2 ] == 'S' ) { System . arraycopy ( tempName , 0 , tempName = new char [ length + 2 ] , 0 , length ) ; tempName [ length ] = 'E' ; tempName [ length + 1 ] = 'S' ; } } else if ( tempName [ length - 1 ] == 'Y' ) { boolean precededByAVowel = false ; if ( tempName . length > 1 ) { switch ( tempName [ length - 2 ] ) { case 'A' : case 'E' : case 'I' : case 'O' : case 'U' : precededByAVowel = true ; break ; } } if ( precededByAVowel ) { System . arraycopy ( tempName , 0 , tempName = new char [ length + 1 ] , 0 , length ) ; tempName [ length ] = 'S' ; } else { System . arraycopy ( tempName , 0 , tempName = new char [ length + 2 ] , 0 , length ) ; tempName [ length - 1 ] = 'I' ; tempName [ length ] = 'E' ; tempName [ length + 1 ] = 'S' ; } } else { System . arraycopy ( tempName , 0 , tempName = new char [ length + 1 ] , 0 , length ) ; tempName [ length ] = 'S' ; } } else { if ( tempName [ length - 1 ] == 's' ) { if ( tempName . length > 1 && tempName [ length - 2 ] == 's' ) { System . arraycopy ( tempName , 0 , tempName = new char [ length + 2 ] , 0 , length ) ; tempName [ length ] = 'e' ; tempName [ length + 1 ] = 's' ; } } else if ( tempName [ length - 1 ] == 'y' ) { boolean precededByAVowel = false ; if ( tempName . length > 1 ) { switch ( tempName [ length - 2 ] ) { case 'a' : case 'e' : case 'i' : case 'o' : case 'u' : precededByAVowel = true ; break ; } } if ( precededByAVowel ) { System . arraycopy ( tempName , 0 , tempName = new char [ length + 1 ] , 0 , length ) ; tempName [ length ] = 's' ; } else { System . arraycopy ( tempName , 0 , tempName = new char [ length + 2 ] , 0 , length ) ; tempName [ length - 1 ] = 'i' ; tempName [ length ] = 'e' ; tempName [ length + 1 ] = 's' ; } } else { System . arraycopy ( tempName , 0 , tempName = new char [ length + 1 ] , 0 , length ) ; tempName [ length ] = 's' ; } } } char [ ] unprefixedName = tempName ; int matchingIndex = - 1 ; if ( ! isConstantField ) { unprefixedName [ 0 ] = ScannerHelper . toUpperCase ( unprefixedName [ 0 ] ) ; done : for ( int j = 0 ; j <= internalPrefix . length ; j ++ ) { if ( j == internalPrefix . length || CharOperation . prefixEquals ( CharOperation . subarray ( internalPrefix , j , - 1 ) , unprefixedName , j != 0 ) ) { matchingIndex = j ; break done ; } } } else { done : for ( int j = 0 ; j <= internalPrefix . length ; j ++ ) { if ( j == internalPrefix . length ) { matchingIndex = j ; break done ; } else if ( CharOperation . prefixEquals ( CharOperation . subarray ( internalPrefix , j , - 1 ) , unprefixedName , j != 0 ) ) { if ( j == 0 || internalPrefix [ j - 1 ] == '_' ) { matchingIndex = j ; break done ; } } } } if ( matchingIndex > - 1 ) { if ( ! isConstantField ) { tempName = CharOperation . concat ( CharOperation . subarray ( internalPrefix , 0 , matchingIndex ) , unprefixedName ) ; if ( matchingIndex == 0 ) tempName [ 0 ] = ScannerHelper . toLowerCase ( tempName [ 0 ] ) ; } else { if ( matchingIndex != 0 && tempName [ 0 ] != '_' && internalPrefix [ matchingIndex - 1 ] != '_' ) { tempName = CharOperation . concat ( CharOperation . subarray ( CharOperation . toUpperCase ( internalPrefix ) , 0 , matchingIndex ) , unprefixedName , '_' ) ; } else { tempName = CharOperation . concat ( CharOperation . subarray ( CharOperation . toUpperCase ( internalPrefix ) , 0 , matchingIndex ) , unprefixedName ) ; } } for ( int k = 0 ; k < prefixes . length ; k ++ ) { if ( ! isConstantField ) { if ( prefixes [ k ] . length > 0 && ScannerHelper . isLetterOrDigit ( prefixes [ k ] [ prefixes [ k ] . length - 1 ] ) ) { tempName [ 0 ] = ScannerHelper . toUpperCase ( tempName [ 0 ] ) ; } else { tempName [ 0 ] = ScannerHelper . toLowerCase ( tempName [ 0 ] ) ; } } char [ ] prefixName = CharOperation . concat ( prefixes [ k ] , tempName ) ; for ( int l = 0 ; l < suffixes . length ; l ++ ) { char [ ] suffixName = CharOperation . concat ( prefixName , suffixes [ l ] ) ; suffixName = excludeNames ( suffixName , prefixName , suffixes [ l ] , excluded ) ; try { nameScanner . setSource ( suffixName ) ; switch ( nameScanner . getNextToken ( ) ) { case TerminalTokens . TokenNameIdentifier : int token = nameScanner . getNextToken ( ) ; if ( token == TerminalTokens . TokenNameEOF && nameScanner . startPosition == suffixName . length ) { if ( ! foundNames . includes ( suffixName ) ) { acceptName ( suffixName , prefixes [ k ] , suffixes [ l ] , k == 0 , l == 0 , internalPrefix . length - matchingIndex , requestor ) ; foundNames . add ( suffixName ) ; acceptDefaultName = false ; } } break ; default : suffixName = CharOperation . concat ( prefixName , String . valueOf ( 1 ) . toCharArray ( ) , suffixes [ l ] ) ; suffixName = excludeNames ( suffixName , prefixName , suffixes [ l ] , excluded ) ; nameScanner . setSource ( suffixName ) ; switch ( nameScanner . getNextToken ( ) ) { case TerminalTokens . TokenNameIdentifier : token = nameScanner . getNextToken ( ) ; if ( token == TerminalTokens . TokenNameEOF && nameScanner . startPosition == suffixName . length ) { if ( ! foundNames . includes ( suffixName ) ) { acceptName ( suffixName , prefixes [ k ] , suffixes [ l ] , k == 0 , l == 0 , internalPrefix . length - matchingIndex , requestor ) ; foundNames . add ( suffixName ) ; acceptDefaultName = false ; } } } } } catch ( InvalidInputException e ) { } } } } } if ( evaluateDefault && acceptDefaultName ) { char [ ] name = excludeNames ( DEFAULT_NAME , DEFAULT_NAME , CharOperation . NO_CHAR , excluded ) ; requestor . acceptNameWithoutPrefixAndSuffix ( name , 0 ) ; } } } </s>