public static string test(string s1, string s2)
{
SB sb = new SB(s1);
sb.append(s2);
return(sb.toString());
}
public String toString()
{
StringBuilder outputString = new StringBuilder();
outputString.append("Country Code: ").append(countryCode_);
outputString.append(" National Number: ").append(nationalNumber_);
if (hasItalianLeadingZero() && isItalianLeadingZero())
{
outputString.append(" Leading Zero: true");
}
if (hasExtension())
{
outputString.append(" Extension: ").append(extension_);
}
if (hasCountryCodeSource())
{
outputString.append(" Country Code Source: ").append(Enum.GetName(typeof(CountryCodeSource), countryCodeSource_));
}
if (hasPreferredDomesticCarrierCode())
{
outputString.append(" Preferred Domestic Carrier Code: ").
append(preferredDomesticCarrierCode_);
}
return(outputString.toString());
}
/**
* Gets the name of the file that contains the mapping data for the {@code countryCallingCode} in
* the language specified.
*
* @param countryCallingCode the country calling code of phone numbers which the data file
* contains
* @param language two-letter lowercase ISO language codes as defined by ISO 639-1
* @param script four-letter titlecase (the first letter is uppercase and the rest of the letters
* are lowercase) ISO script codes as defined in ISO 15924
* @param region two-letter uppercase ISO country codes as defined by ISO 3166-1
* @return the name of the file, or empty string if no such file can be found
*/
internal String getFileName(int countryCallingCode, String language, String script, String region)
{
if (language.length() == 0)
{
return("");
}
int index = Arrays.binarySearch(countryCallingCodes, countryCallingCode);
if (index < 0)
{
return("");
}
Set <String> setOfLangs = availableLanguages.get(index);
if (setOfLangs.size() > 0)
{
String languageCode = findBestMatchingLanguageCode(setOfLangs, language, script, region);
if (languageCode.length() > 0)
{
StringBuilder fileName = new StringBuilder();
fileName.append(countryCallingCode).append('_').append(languageCode);
return(fileName.toString());
}
}
return("");
}
public static string method(params string[] values) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < sizeof(values); i++) {
sb.append(values[i]);
}
return sb.toString();
}
public override string format(LogRecord logrecord)
{
var stringbuilder = new StringBuilder();
stringbuilder.append(dateFormat.format(Long.valueOf(logrecord.getMillis())));
Level level = logrecord.getLevel();
if (level == Level.FINEST)
{
stringbuilder.append(" [FINEST] ");
}
else if (level == Level.FINER)
{
stringbuilder.append(" [FINER] ");
}
else if (level == Level.FINE)
{
stringbuilder.append(" [FINE] ");
}
else if (level == Level.INFO)
{
stringbuilder.append(" [INFO] ");
}
else if (level == Level.WARNING)
{
stringbuilder.append(" [WARNING] ");
}
else if (level == Level.SEVERE)
{
stringbuilder.append(" [SEVERE] ");
}
else if (level == Level.SEVERE)
{
stringbuilder.append(
(new StringBuilder()).append(" [").append(level.getLocalizedName()).append("] ").toString());
}
stringbuilder.append(logrecord.getMessage());
stringbuilder.append('\n');
var throwable = logrecord.getThrown() as Throwable;
if (throwable != null)
{
var stringwriter = new StringWriter();
throwable.printStackTrace(new PrintWriter(stringwriter));
stringbuilder.append(stringwriter.toString());
}
Debug.WriteLine(stringbuilder.toString());
return stringbuilder.toString();
}
public string method() {
var sb = new StringBuilder();
var it = strings().iterator();
while (it.hasNext()) {
sb.append(it.next());
}
return sb.toString();
}
public static string test() {
var obj1 = new SelectManyAux(1);
var obj2 = new SelectManyAux(2);
var lst = new ArrayList<SelectManyAux> { obj1, obj2 };
var sb = new StringBuilder();
foreach (var s in lst.selectMany(p => p.getStrings())) {
sb.append(s);
}
return sb.toString();
}
private string join(Iterable<String> items, int limit) {
StringBuilder sb = new StringBuilder();
int count = 0;
foreach (string item in items) {
if (count > 0)
sb.append(", ");
sb.append(item);
if (limit > 0 && count == limit)
break;
count++;
}
return sb.toString();
}
public static string test() {
var sb = new StringBuilder();
var first = true;
foreach (var i in range(0, 5)) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(i);
}
return sb.toString();
}
public static string test() {
var list = new ArrayList<string>();
list.add("a");
list.add("b");
list.add("c");
var sb = new StringBuilder();
foreach (var s in list) {
sb.append(s);
}
return sb.toString();
}
public static String quoteReplacement(String s)
{
if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
return s;
StringBuilder sb = new StringBuilder();
for (int i=0; i<s.length(); i++) {
char c = s.charAt(i);
if (c == '\\' || c == '$') {
sb.append('\\');
}
sb.append(c);
}
return sb.toString();
}
public string method() {
var sb = new StringBuilder();
var it = power(2, 8).iterator();
var first = true;
while (it.hasNext()) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append("" + it.nextInt());
}
return sb.toString();
}
private String findBestMatchingLanguageCode(
Set <String> setOfLangs, String language, String script, String region)
{
StringBuilder fullLocale = constructFullLocale(language, script, region);
String fullLocaleStr = fullLocale.toString();
String normalizedLocale = LOCALE_NORMALIZATION_MAP.get(fullLocaleStr);
if (normalizedLocale != null)
{
if (setOfLangs.contains(normalizedLocale))
{
return(normalizedLocale);
}
}
if (setOfLangs.contains(fullLocaleStr))
{
return(fullLocaleStr);
}
if (onlyOneOfScriptOrRegionIsEmpty(script, region))
{
if (setOfLangs.contains(language))
{
return(language);
}
}
else if (script.length() > 0 && region.length() > 0)
{
StringBuilder langWithScript = new StringBuilder(language).append('_').append(script);
String langWithScriptStr = langWithScript.toString();
if (setOfLangs.contains(langWithScriptStr))
{
return(langWithScriptStr);
}
StringBuilder langWithRegion = new StringBuilder(language).append('_').append(region);
String langWithRegionStr = langWithRegion.toString();
if (setOfLangs.contains(langWithRegionStr))
{
return(langWithRegionStr);
}
if (setOfLangs.contains(language))
{
return(language);
}
}
return("");
}
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("java.util.regex.Matcher");
sb.append("[pattern=" + pattern());
sb.append(" region=");
sb.append(regionStart() + "," + regionEnd());
sb.append(" lastmatch=");
if ((first >= 0) && (group() != null))
{
sb.append(group());
}
sb.append("]");
return(sb.toString());
}
/**
* Returns a string representing the data in this class. The string contains one line for each
* country calling code. The country calling code is followed by a '|' and then a list of
* comma-separated languages sorted in ascending order.
*/
public String toString()
{
StringBuilder output = new StringBuilder();
for (int i = 0; i < numOfEntries; i++)
{
output.append(countryCallingCodes[i]);
output.append('|');
SortedSet <String> sortedSetOfLangs = new TreeSet <String>(availableLanguages.get(i));
foreach (String lang in sortedSetOfLangs)
{
output.append(lang);
output.append(',');
}
output.append('\n');
}
return(output.toString());
}
/**
* Invokes inputDigitHelper on each digit of the national number accrued, and returns a formatted
* string in the end.
*/
private String inputAccruedNationalNumber()
{
int lengthOfNationalNumber = nationalNumber.length();
if (lengthOfNationalNumber > 0)
{
String tempNationalNumber = "";
for (int i = 0; i < lengthOfNationalNumber; i++)
{
tempNationalNumber = inputDigitHelper(nationalNumber.charAt(i));
}
return(ableToFormat ? appendNationalNumber(tempNationalNumber) : accruedInput.toString());
}
else
{
return(prefixBeforeNationalNumber.toString());
}
}
public virtual string getMessage()
{
StringBuilder stringBuilder = new StringBuilder();
if (this.fMessage != null)
stringBuilder.append(this.fMessage);
stringBuilder.append("arrays first differed at element ");
Iterator iterator = this.fIndices.iterator();
while (iterator.hasNext())
{
int num = ((Integer) iterator.next()).intValue();
stringBuilder.append("[");
stringBuilder.append(num);
stringBuilder.append("]");
}
stringBuilder.append("; ");
stringBuilder.append(Throwable.instancehelper_getMessage((Exception) this.fCause));
return stringBuilder.toString();
}
public static String quoteReplacement(String s)
{
if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
{
return(s);
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++)
{
char c = s.charAt(i);
if (c == '\\' || c == '$')
{
sb.append('\\');
}
sb.append(c);
}
return(sb.toString());
}
internal static boolean allNumberGroupsAreExactlyPresent(PhoneNumberUtil util,
PhoneNumber number,
StringBuilder normalizedCandidate,
String[] formattedNumberGroups)
{
String[] candidateGroups =
PhoneNumberUtil.NON_DIGITS_PATTERN.split(normalizedCandidate.toString());
// Set this to the last group, skipping it if the number has an extension.
int candidateNumberGroupIndex =
number.hasExtension() ? candidateGroups.length() - 2 : candidateGroups.length() - 1;
// First we check if the national significant number is formatted as a block.
// We use contains and not equals, since the national significant number may be present with
// a prefix such as a national number prefix, or the country code itself.
if (candidateGroups.length() == 1 ||
candidateGroups[candidateNumberGroupIndex].contains(
util.getNationalSignificantNumber(number)))
{
return(true);
}
// Starting from the end, go through in reverse, excluding the first group, and check the
// candidate and number groups are the same.
for (int formattedNumberGroupIndex = (formattedNumberGroups.length() - 1);
formattedNumberGroupIndex > 0 && candidateNumberGroupIndex >= 0;
formattedNumberGroupIndex--, candidateNumberGroupIndex--)
{
if (!candidateGroups[candidateNumberGroupIndex].equals(
formattedNumberGroups[formattedNumberGroupIndex]))
{
return(false);
}
}
// Now check the first group. There may be a national prefix at the start, so we only check
// that the candidate group ends with the formatted number group.
return(candidateNumberGroupIndex >= 0 &&
candidateGroups[candidateNumberGroupIndex].endsWith(formattedNumberGroups[0]));
}
private String getTypeName(String packageName, int offset, int length) {
var sb = new StringBuilder();
if (!Helper.isNullOrEmpty(packageName)) {
sb.append(packageName).append('/');
}
context.appendIdentifier(sb, offset, length);
return sb.toString();
}
private String getPackageName(String outerPackage, PackageDeclarationNode packageDeclaration, char separator) {
var sb = new StringBuilder();
var first = true;
if (!Helper.isNullOrEmpty(outerPackage)) {
sb.append(outerPackage);
first = false;
}
foreach (var identifier in packageDeclaration.Identifiers) {
if (first) {
first = false;
} else {
sb.append(separator);
}
var id = context.getIdentifier(identifier.Offset, identifier.Length);
sb.append(id);
identifier.addUserData(id);
}
return sb.toString();
}
public Matcher appendReplacement(StringBuffer sb, String replacement)
{
// If no match, return error
if (first < 0)
{
throw new InvalidOperationException("No match available");
}
// Process substitution string to replace group references with groups
int cursor = 0;
StringBuilder result = new StringBuilder();
while (cursor < replacement.length())
{
char nextChar = replacement.charAt(cursor);
if (nextChar == '\\')
{
cursor++;
nextChar = replacement.charAt(cursor);
result.append(nextChar);
cursor++;
}
else if (nextChar == '$')
{
// Skip past $
cursor++;
// A StringIndexOutOfBoundsException is thrown if
// this "$" is the last character in replacement
// string in current implementation, a IAE might be
// more appropriate.
nextChar = replacement.charAt(cursor);
int refNum = -1;
if (nextChar == '{')
{
cursor++;
StringBuilder gsb = new StringBuilder();
while (cursor < replacement.length())
{
nextChar = replacement.charAt(cursor);
if (ASCII.isLower(nextChar) ||
ASCII.isUpper(nextChar) ||
ASCII.isDigit(nextChar))
{
gsb.append(nextChar);
cursor++;
}
else
{
break;
}
}
if (gsb.length() == 0)
{
throw new IllegalArgumentException(
"named capturing group has 0 length name");
}
if (nextChar != '}')
{
throw new IllegalArgumentException(
"named capturing group is missing trailing '}'");
}
String gname = gsb.toString();
if (ASCII.isDigit(gname.charAt(0)))
{
throw new IllegalArgumentException(
"capturing group name {" + gname +
"} starts with digit character");
}
if (!parentPattern.namedGroups().containsKey(gname))
{
throw new IllegalArgumentException(
"No group with name {" + gname + "}");
}
refNum = parentPattern.namedGroups().get(gname);
cursor++;
}
else
{
// The first number is always a group
refNum = (int)nextChar - '0';
if ((refNum < 0) || (refNum > 9))
{
throw new IllegalArgumentException(
"Illegal group reference");
}
cursor++;
// Capture the largest legal group string
boolean done = false;
while (!done)
{
if (cursor >= replacement.length())
{
break;
}
int nextDigit = replacement.charAt(cursor) - '0';
if ((nextDigit < 0) || (nextDigit > 9)) // not a number
{
break;
}
int newRefNum = (refNum * 10) + nextDigit;
if (groupCount() < newRefNum)
{
done = true;
}
else
{
refNum = newRefNum;
cursor++;
}
}
}
// Append group
if (start(refNum) != -1 && end(refNum) != -1)
{
result.append(text, start(refNum), end(refNum));
}
}
else
{
result.append(nextChar);
cursor++;
}
}
// Append the intervening text
sb.append(text, lastAppendPosition, first);
// Append the match substitution
sb.append(result);
lastAppendPosition = last;
return(this);
}
public static String decodeDocumentation(char[] text, int offset, int length) {
var end = offset + length;
offset++;
var sb = new StringBuilder();
if (text[offset] == '*') {
offset += 2;
for (var i = offset; i < end; i++) {
var c = text[i];
switch (c) {
case '\r':
sb.append(c);
if (text[i + 1] == '\n') {
i++;
}
goto case '\n';
case '\u2028':
case '\u2029':
case '\n':
sb.append(c);
var done = false;
while (i + 1 < end && !done) {
switch (text[i + 1]) {
case ' ':
case '\t':
case '\v':
case '\f':
i++;
break;
case '*':
if (text[i + 2] != '/') {
i++;
if (text[i + 1] == ' ') {
i++;
}
}
goto default;
default:
done = true;
break;
}
}
break;
case '*':
if (text[i + 1] != '/') {
sb.append(c);
} else {
i++;
}
break;
default:
sb.append(c);
break;
}
}
} else {
offset += 2;
if (offset < end && text[offset] == ' ') {
offset++;
}
for (var i = offset; i < end; i++) {
var c = text[i];
switch (c) {
case '\r':
sb.append(c);
if (text[i + 1] == '\n') {
c = '\n';
i++;
}
goto case '\n';
case '\u2028':
case '\u2029':
case '\n':
sb.append(c);
do {
i++;
} while (i < end && text[i] != '/');
i += 2;
if (i + 1 < end && text[i + 1] == ' ') {
i++;
}
break;
default:
sb.append(c);
break;
}
}
}
return sb.toString();
}
public static String unescapeVerbatimString(char[] text, int offset, int length) {
var sb = new StringBuilder();
var end = offset + length;
for (var i = offset; i < end; i++) {
var c = text[i];
if (c == '"') {
i++;
}
sb.append(c);
}
return sb.toString();
}
public static String unescapeString(char[] text, int offset, int length) {
var sb = new StringBuilder();
var end = offset + length;
for (var i = offset; i < end; i++) {
var c = text[i];
if (c == '\\') {
switch (c = text[++i]) {
case '"':
case '\\':
case '\'':
sb.append(c);
break;
case '0':
sb.append((char)0);
break;
case 'a':
sb.append((char)7);
break;
case 'b':
sb.append((char)8);
break;
case 'f':
sb.append((char)12);
break;
case 'n':
sb.append((char)10);
break;
case 'r':
sb.append((char)13);
break;
case 't':
sb.append((char)9);
break;
case 'v':
sb.append((char)11);
break;
case 'u': {
var value = 0;
for (var j = 0; j < 4; j++) {
value = value * 16 + ParserHelper.scanHexDigit(text[++i]);
}
sb.append((char)value);
break;
}
case 'U': {
var value = 0;
for (var j = 0; j < 4; j++) {
value = value * 16 + ParserHelper.scanHexDigit(text[++i]);
}
sb.append((char)value);
value = 0;
for (int j = 0; j < 4; j++) {
value = value * 16 + ParserHelper.scanHexDigit(text[++i]);
}
sb.append((char)value);
break;
}
case 'x': {
var value = ParserHelper.scanHexDigit(text[++i]);
var d = ParserHelper.scanHexDigit(text[i + 1]);
if (d > -1) {
value = value * 16 + d;
if ((d = ParserHelper.scanHexDigit(text[++i + 1])) > -1) {
value = value * 16 + d;
if ((d = ParserHelper.scanHexDigit(text[++i + 1])) > -1) {
value = value * 16 + d;
i++;
}
}
}
sb.append((char)value);
break;
}
}
} else {
sb.append(c);
}
}
return sb.toString();
}
private String inputDigitWithOptionToRememberPosition(char nextChar, boolean rememberPosition)
{
accruedInput.append(nextChar);
if (rememberPosition)
{
originalPosition = accruedInput.length();
}
// We do formatting on-the-fly only when each character entered is either a digit, or a plus
// sign (accepted at the start of the number only).
if (!isDigitOrLeadingPlusSign(nextChar))
{
ableToFormat = false;
inputHasFormatting = true;
}
else
{
nextChar = normalizeAndAccrueDigitsAndPlusSign(nextChar, rememberPosition);
}
if (!ableToFormat)
{
// When we are unable to format because of reasons other than that formatting chars have been
// entered, it can be due to really long IDDs or NDDs. If that is the case, we might be able
// to do formatting again after extracting them.
if (inputHasFormatting)
{
return(accruedInput.toString());
}
else if (attemptToExtractIdd())
{
if (attemptToExtractCountryCallingCode())
{
return(attemptToChoosePatternWithPrefixExtracted());
}
}
else if (ableToExtractLongerNdd())
{
// Add an additional space to separate long NDD and national significant number for
// readability. We don't set shouldAddSpaceAfterNationalPrefix to true, since we don't want
// this to change later when we choose formatting templates.
prefixBeforeNationalNumber.append(SEPARATOR_BEFORE_NATIONAL_NUMBER);
return(attemptToChoosePatternWithPrefixExtracted());
}
return(accruedInput.toString());
}
// We start to attempt to format only when at least MIN_LEADING_DIGITS_LENGTH digits (the plus
// sign is counted as a digit as well for this purpose) have been entered.
switch (accruedInputWithoutFormatting.length())
{
case 0:
case 1:
case 2:
return(accruedInput.toString());
default:
if (accruedInputWithoutFormatting.length() == 3)
{
if (attemptToExtractIdd())
{
isExpectingCountryCallingCode = true;
}
else // No IDD or plus sign is found, might be entering in national format.
{
nationalPrefixExtracted = removeNationalPrefixFromNationalNumber();
return(attemptToChooseFormattingPattern());
}
}
if (isExpectingCountryCallingCode)
{
if (attemptToExtractCountryCallingCode())
{
isExpectingCountryCallingCode = false;
}
return(prefixBeforeNationalNumber + nationalNumber.toString());
}
if (possibleFormats.size() > 0) // The formatting pattern is already chosen.
{
String tempNationalNumber = inputDigitHelper(nextChar);
// See if the accrued digits can be formatted properly already. If not, use the results
// from inputDigitHelper, which does formatting based on the formatting pattern chosen.
String formattedNumber = attemptToFormatAccruedDigits();
if (formattedNumber.length() > 0)
{
return(formattedNumber);
}
narrowDownPossibleFormats(nationalNumber.toString());
if (maybeCreateNewTemplate())
{
return(inputAccruedNationalNumber());
}
return(ableToFormat
? appendNationalNumber(tempNationalNumber)
: accruedInput.toString());
}
else
{
return(attemptToChooseFormattingPattern());
}
}
}
public /*synchronized*/ StringBuffer append(StringBuilder sb)
{
base.append(sb.toString());
return(this);
}
public StringBuilder(StringBuilder str)
: base(str.length() + 16)
{
append(str.toString());
}
public void save(IFile file) {
try {
var document = XmlHelper.load(new StringReader(EMPTY_DOC));
var libs = (Element)document.getElementsByTagName("libraries").item(0);
foreach (var lib in this.Libraries) {
var e = document.createElement("library");
libs.appendChild(e);
e.setAttribute("name", lib.Path);
if (!lib.Enabled) {
e.setAttribute("enabled", "false");
}
}
if (this.PreprocessorSymbols.any()) {
var sb = new StringBuilder();
var first = true;
foreach (String s in this.PreprocessorSymbols) {
if (first) {
first = false;
} else {
sb.append(';');
}
sb.append(s);
}
var e = document.createElement("preprocessorSymbols");
document.getDocumentElement().appendChild(e);
e.setTextContent(sb.toString());
}
var outputElt = document.createElement("outputPath");
document.getDocumentElement().appendChild(outputElt);
outputElt.setTextContent(this.OutputPath);
var writer = new StringWriter();
XmlHelper.save(document, writer);
var bytes = writer.toString().getBytes("UTF-8");
var stream = new ByteArrayInputStream(bytes);
if (file.exists()) {
file.setContents(stream, IResource.FORCE, null);
} else {
file.create(stream, true, null);
}
} catch (Exception e) {
Environment.logException(e);
}
}
private static String getIdString(MethodInfo method) {
var p = method.getUserData(typeof(PropertyMemberInfo));
var sb = new StringBuilder();
if (p != null) {
sb.append("P:");
sb.append(getIdName(method.DeclaringType)).append('.');
sb.append(p.Name);
return sb.toString();
}
var i = method.getUserData(typeof(IndexerMemberInfo));
int nparams = method.Parameters.count();
if (i != null) {
sb.append("P:");
if (method.ReturnType == method.ReturnType.Library.VoidType) {
nparams--;
}
} else {
sb.append("M:");
}
sb.append(getIdName(method.DeclaringType)).append('.');
sb.append((method.Name.equals("<init>")) ? "#init" : method.Name);
if (method.Parameters.any()) {
sb.append('(');
var first = true;
foreach (var t in method.Parameters.take(nparams).select(p => p.Type)) {
if (first) {
first = false;
} else {
sb.append(",");
}
sb.append(getIdName(t));
}
sb.append(')');
}
return sb.toString();
}
private void formatInputSectionPart(char[] source, InputSectionPart part, StringBuilder sb, int indent) {
var indentSb = new StringBuilder();
for (int i = 0; i < indent; i++) {
indentSb.append('.');
}
var indentStr = indentSb.toString();
switch (part.InputSectionPartKind) {
case Definition:
sb.append(indentStr);
if (part.Define) {
sb.append("#define ");
} else {
sb.append("#undef ");
}
sb.append(part.Symbol).append("\r\n");
break;
case Line:
sb.append(indentStr).append("#line ");
if (part.Default) {
sb.append("default");
} else if (part.Hidden) {
sb.append("hidden");
} else {
sb.append(part.Line).append(" ");
if (!Helper.isNullOrEmpty(part.Filename)) {
sb.append('"').append(part.Filename).append('"');
}
}
break;
case Region:
sb.append(indentStr).append("#region");
if (!Helper.isNullOrEmpty(part.StartMessage)) {
sb.append(" ").append(part.StartMessage);
}
sb.append("\r\n");
foreach (var p in part.InputSectionParts) {
formatInputSectionPart(source, p, sb, indent + 4);
}
sb.append(indentStr).append("#endregion");
if (!Helper.isNullOrEmpty(part.EndMessage)) {
sb.append(" ").append(part.EndMessage);
}
sb.append("\r\n");
break;
case If:
sb.append(indentStr).append("#if expression: ").append(part.ExpressionValue).append(", skipped: ")
.append(part.SkippedSection).append("\r\n");
foreach (var p in part.InputSectionParts) {
formatInputSectionPart(source, p, sb, indent + 4);
}
sb.append(indentStr).append("#end\r\n");
break;
case Elif:
sb.append(indentStr).append("#elif expression: ").append(part.ExpressionValue).append(", skipped: ")
.append(part.SkippedSection).append("\r\n");
foreach (var p in part.InputSectionParts) {
formatInputSectionPart(source, p, sb, indent + 4);
}
sb.append(indentStr).append("#end\r\n");
break;
case Else:
sb.append(indentStr).append("#else skipped: ").append(part.SkippedSection).append("\r\n");
foreach (var p in part.InputSectionParts) {
formatInputSectionPart(source, p, sb, indent + 4);
}
sb.append(indentStr).append("#end\r\n");
break;
case Diagnostic:
sb.append(indentStr).append((part.Error) ? "#error" : "#warning");
if (!Helper.isNullOrEmpty(part.Message)) {
sb.append(" ").append(part.Message);
}
sb.append("\r\n");
break;
case Pragma:
sb.append(indentStr).append("#pragma warning ").append((part.Restore) ? "restore" : "disable");
if (part.Warnings.any()) {
sb.append(" ");
var first = true;
foreach (var w in part.Warnings) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(w);
}
}
sb.append("\r\n");
break;
case SourceCode:
sb.append(indentStr).append("----\r\n");
var s = new BufferedReader(new StringReader(new String(source, part.Position, part.Length)));
var line = "";
while ((line = s.readLine()) != null) {
sb.append(indentStr).append(line).append("\r\n");
}
sb.append(indentStr).append("----\r\n");
break;
}
}
private static String getIdName(TypeInfo type) {
switch (type.TypeKind) {
case Boolean:
return "boolean";
case Byte:
return "byte";
case Char:
return "char";
case Double:
return "double";
case Float:
return "float";
case Int:
return "int";
case Long:
return "long";
case Short:
return "short";
case Void:
return "void";
case Array:
return getIdName(type.ElementType) + "[]";
default:
var result = type.FullName.replace('/', '.').replace('$', '.');
if (type.OriginalTypeDefinition != type && type.GenericArguments.any()) {
var sb = new StringBuilder();
sb.append(result).append('{');
var first = true;
foreach (var t in type.GenericArguments) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(getIdName(t));
}
sb.append('}');
result = sb.toString();
}
return result;
}
}
public String toString()
{
StringBuilder outputString = new StringBuilder();
outputString.append("Country Code: ").append(countryCode_);
outputString.append(" National Number: ").append(nationalNumber_);
if (hasItalianLeadingZero() && isItalianLeadingZero()) {
outputString.append(" Leading Zero: true");
}
if (hasExtension()) {
outputString.append(" Extension: ").append(extension_);
}
if (hasCountryCodeSource()) {
outputString.append(" Country Code Source: ").append(Enum.GetName(typeof(CountryCodeSource), countryCodeSource_));
}
if (hasPreferredDomesticCarrierCode()) {
outputString.append(" Preferred Domestic Carrier Code: ").
append(preferredDomesticCarrierCode_);
}
return outputString.toString();
}
public static string test() {
var sb = new StringBuilder();
sb.append("ABC");
sb.setLength(2);
return sb.toString();
}
private String preprocessedTextToString(PreprocessedText source) {
var sb = new StringBuilder();
foreach (var part in source.InputSectionParts) {
formatInputSectionPart(source.Text, part, sb, 0);
}
return sb.toString();
}
private String typeReferenceToString(TypeReferenceNode typeRef) {
var sb = new StringBuilder();
switch (typeRef.TypeReferenceKind) {
case Int:
case Long:
case Short:
case Float:
case Double:
case Boolean:
case Byte:
case Void:
case String:
sb.append(typeRef.TypeReferenceKind.toString().toLowerCase());
break;
case SimpleName:
var simpleName = (SimpleNameTypeReferenceNode)typeRef;
sb.append(new String(text, simpleName.NameOffset, simpleName.NameLength));
if (simpleName.TypeArguments.size() > 0) {
formatTypeArguments(simpleName.TypeArguments, sb);
}
break;
case Qualified:
var qtype = (QualifiedTypeReferenceNode)typeRef;
sb.append(typeReferenceToString(qtype.EnclosingType));
sb.append(".");
sb.append(typeReferenceToString(qtype.SimpleName));
break;
case Array:
var array = (ArrayTypeReferenceNode)typeRef;
sb.append(typeReferenceToString(array.ElementType));
sb.append("[]");
break;
default:
throw new RuntimeException("Unhandled type kind: " + typeRef.TypeReferenceKind);
}
return sb.toString();
}
private String readToEnd(Reader reader) {
var sb = new StringBuilder();
var buff = new char[1024];
int read;
while ((read = reader.read(buff)) != -1) {
sb.append(buff, 0, read);
}
return sb.toString();
}
//void readFloats(float[] v, int off, int len) {
// int span, endoff = off + len;
// while (off < endoff) {
// if (!blkmode) {
// span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 2);
// @in.readFully(buf, 0, span << 2);
// pos = 0;
// } else if (end - pos < 4) {
// v[off++] = din.readFloat();
// continue;
// } else {
// span = Math.min(endoff - off, ((end - pos) >> 2));
// }
// bytesToFloats(buf, pos, v, off, span);
// off += span;
// pos += span << 2;
// }
//}
//void readLongs(long[] v, int off, int len) {
// int stop, endoff = off + len;
// while (off < endoff) {
// if (!blkmode) {
// int span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3);
// @in.readFully(buf, 0, span << 3);
// stop = off + span;
// pos = 0;
// } else if (end - pos < 8) {
// v[off++] = din.readLong();
// continue;
// } else {
// stop = Math.min(endoff, off + ((end - pos) >> 3));
// }
// while (off < stop) {
// v[off++] = Bits.getLong(buf, pos);
// pos += 8;
// }
// }
//}
//void readDoubles(double[] v, int off, int len) {
// int span, endoff = off + len;
// while (off < endoff) {
// if (!blkmode) {
// span = Math.min(endoff - off, MAX_BLOCK_SIZE >> 3);
// @in.readFully(buf, 0, span << 3);
// pos = 0;
// } else if (end - pos < 8) {
// v[off++] = din.readDouble();
// continue;
// } else {
// span = Math.min(endoff - off, ((end - pos) >> 3));
// }
// bytesToDoubles(buf, pos, v, off, span);
// off += span;
// pos += span << 3;
// }
//}
//String readLongUTF() {
// return readUTFBody(readLong());
//}
private String readUTFBody(long utflen)
{
StringBuilder sbuf = new StringBuilder();
if (!blkmode) {
end = pos = 0;
}
while (utflen > 0) {
int avail = end - pos;
if (avail >= 3 || (long) avail == utflen) {
utflen -= readUTFSpan(sbuf, utflen);
} else {
if (blkmode) {
// near block boundary, read one byte at a time
utflen -= readUTFChar(sbuf, utflen);
} else {
// shift and refill buffer manually
if (avail > 0) {
System.Array.Copy(buf, pos, buf, 0, avail);
}
pos = 0;
end = (int) Math.min(MAX_BLOCK_SIZE, (int)utflen);
@in.readFully(buf, avail, end - avail);
}
}
}
return sbuf.toString();
}
private String expressionToString(ExpressionNode expression) {
var sb = new StringBuilder();
var first = false;
switch (expression.ExpressionKind) {
case Literal:
var literal = (LiteralExpressionNode)expression;
sb.append("Literal(");
sb.append(literal.LiteralKind);
sb.append(", [");
sb.append(new String(text, literal.ValueOffset, literal.ValueLength));
sb.append("])");
break;
case MemberAccess:
var member = (MemberAccessExpressionNode)expression;
sb.append("(");
sb.append(expressionToString(member.TargetObject));
sb.append(").");
sb.append(new String(text, member.Member.NameOffset, member.Member.NameLength));
break;
case NullSafeMemberAccess:
var nsmember = (NullSafeMemberAccessExpressionNode)expression;
sb.append("(");
sb.append(expressionToString(nsmember.TargetObject));
sb.append(")?.");
sb.append(new String(text, nsmember.Member.NameOffset, nsmember.Member.NameLength));
break;
case Type:
var type = (TypeExpressionNode)expression;
sb.append("Type(");
sb.append(typeReferenceToString(type.TypeReference));
sb.append(")");
break;
case SimpleName:
var name = (SimpleNameExpressionNode)expression;
sb.append("Name(");
sb.append(new String(text, name.NameOffset, name.NameLength));
formatTypeArguments(name.TypeArguments, sb);
sb.append(")");
break;
case ThisAccess:
sb.append("this");
break;
case SuperAccess:
sb.append("base");
break;
case ObjectCreation:
var objectCreation = (ObjectCreationExpressionNode)expression;
sb.append("new ");
sb.append(typeReferenceToString(objectCreation.Type));
if (objectCreation.Arguments.size() > 0 || objectCreation.Initializer == null) {
sb.append("(");
first = true;
foreach (var arg in objectCreation.Arguments) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(expressionToString(arg));
}
sb.append(")");
}
if (objectCreation.Initializer != null) {
sb.append(expressionToString(objectCreation.Initializer));
}
break;
case ObjectInitializer:
var objectInit = (ObjectInitializerExpressionNode)expression;
sb.append("{");
first = true;
foreach (var mi in objectInit.MemberInitializers) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(new String(text, mi.NameOffset, mi.NameLength));
sb.append("=");
sb.append(expressionToString(mi.Value));
}
sb.append("}");
break;
case CollectionInitializer:
var collectionInit = (CollectionInitializerExpressionNode)expression;
sb.append("{");
first = true;
foreach (var v in collectionInit.Values) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append("{");
var f = true;
foreach (var exp in v) {
if (f) {
f = false;
} else {
sb.append(", ");
}
sb.append(expressionToString(exp));
}
sb.append("}");
}
sb.append("}");
break;
case AnonymousObjectCreation:
var anonymousCreation = (AnonymousObjectCreationExpressionNode)expression;
sb.append("new{");
first = true;
foreach (var decl in anonymousCreation.MemberDeclarators) {
if (first) {
first = false;
} else {
sb.append(", ");
}
if (decl.NameLength > 0) {
sb.append(new String(text, decl.NameOffset, decl.NameLength));
sb.append("=");
}
sb.append(expressionToString(decl.Value));
}
sb.append("}");
break;
case ArrayCreation:
var arrayCreation = (ArrayCreationExpressionNode)expression;
sb.append("new");
if (arrayCreation.Type != null) {
sb.append(" ");
sb.append(typeReferenceToString(arrayCreation.Type));
}
if (arrayCreation.DimensionExpressions.size() > 0) {
sb.append("[");
first = true;
foreach (var exp in arrayCreation.DimensionExpressions) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(expressionToString(exp));
}
sb.append("]");
}
if (arrayCreation.Dimensions > 0) {
sb.append("[");
for (int i = 1; i < arrayCreation.Dimensions; i++) {
sb.append(",");
}
sb.append("]");
}
if (arrayCreation.Initializer != null) {
sb.append(expressionToString(arrayCreation.Initializer));
}
break;
case ArrayInitializer:
var arrayInit = (ArrayInitializerExpressionNode)expression;
sb.append("{");
first = true;
foreach (var v in arrayInit.Values) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(expressionToString(v));
}
sb.append("}");
break;
case ElementAccess:
var elementAccess = (ElementAccessExpressionNode)expression;
sb.append("(");
sb.append(expressionToString(elementAccess.TargetObject));
sb.append(")[");
first = true;
foreach (var index in elementAccess.Indexes) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(expressionToString(index));
}
sb.append("]");
break;
case Invocation:
var invocation = (InvocationExpressionNode)expression;
sb.append(expressionToString(invocation.TargetObject));
sb.append("(");
first = true;
foreach (var arg in invocation.Arguments) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(expressionToString(arg));
}
sb.append(")");
break;
case Unary:
var unary = (UnaryExpressionNode)expression;
sb.append("(");
sb.append(unary.Operator.toString());
sb.append(" ");
sb.append(expressionToString(unary.Operand));
sb.append(")");
break;
case Binary:
var binary = (BinaryExpressionNode)expression;
sb.append("(");
sb.append(expressionToString(binary.LeftOperand));
sb.append(" ");
sb.append(binary.Operator.toString());
sb.append(" ");
sb.append(expressionToString(binary.RightOperand));
sb.append(")");
break;
case Cast:
var cast = (CastExpressionNode)expression;
sb.append("Cast<");
sb.append(typeReferenceToString(cast.TargetType));
sb.append(">(");
sb.append(expressionToString(cast.Expression));
sb.append(")");
break;
case Assign:
var assign = (AssignExpressionNode)expression;
sb.append("Assign(");
sb.append(expressionToString(assign.Left));
sb.append(" ");
sb.append(assign.Operator.toString());
sb.append(" ");
sb.append(expressionToString(assign.Right));
sb.append(")");
break;
case Lambda:
var lambda = (LambdaExpressionNode)expression;
sb.append("Lambda(");
first = true;
foreach (var par in lambda.Parameters) {
if (first) {
first = false;
} else {
sb.append(", ");
}
if (par.Modifier != ParameterModifier.None) {
sb.append(par.Modifier.toString().toLowerCase());
sb.append(" ");
}
if (par.Type != null) {
sb.append(typeReferenceToString(par.Type));
sb.append(" ");
}
sb.append(new String(text, par.NameOffset, par.NameLength));
}
sb.append(" => ");
sb.append(statementToString(lambda.Body));
sb.append(")");
break;
case Conditional:
var conditional = (ConditionalExpressionNode)expression;
sb.append(expressionToString(conditional.Condition));
sb.append("?");
sb.append(expressionToString(conditional.IfTrue));
sb.append(":");
sb.append(expressionToString(conditional.IfFalse));
break;
case Typeof:
var tpof = (TypeofExpressionNode)expression;
sb.append("typeof(");
sb.append(typeReferenceToString(tpof.Type));
sb.append(")");
break;
case Query:
var query = (QueryExpressionNode)expression;
sb.append("from ");
if (query.From.Type != null) {
sb.append(typeReferenceToString(query.From.Type));
sb.append(" ");
}
sb.append(new String(text, query.From.NameOffset, query.From.NameLength));
sb.append(" in ");
sb.append(expressionToString(query.From.Origin));
sb.append("\r\n");
formatQueryBody(query.Body, sb);
break;
default:
throw new RuntimeException("Unhandled expression type: " + expression.ExpressionKind);
}
return sb.toString();
}
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("java.util.regex.Matcher");
sb.append("[pattern=" + pattern());
sb.append(" region=");
sb.append(regionStart() + "," + regionEnd());
sb.append(" lastmatch=");
if ((first >= 0) && (group() != null)) {
sb.append(group());
}
sb.append("]");
return sb.toString();
}
private String statementToString(StatementNode statement) {
var sb = new StringBuilder();
switch (statement.StatementKind) {
case Empty:
sb.append("#empty;\r\n");
break;
case Expression:
var expression = (ExpressionStatementNode)statement;
sb.append(expressionToString(expression.Expression));
sb.append(";\r\n");
break;
case Block:
var block = (BlockStatementNode)statement;
sb.append("{\r\n");
foreach (var s in block.Statements) {
sb.append(statementToString(s));
}
sb.append("}\r\n");
break;
case LocalDeclaration:
var locals = (LocalDeclarationStatementNode)statement;
if (locals.Type == null) {
sb.append("var ");
} else {
sb.append(typeReferenceToString(locals.Type));
sb.append(" ");
}
var first = true;
foreach (var d in locals.Declarators) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(new String(text, d.NameOffset, d.NameLength));
if (d.Value != null) {
sb.append(" = ");
sb.append(expressionToString(d.Value));
}
}
sb.append(";\r\n");
break;
case Return:
var rt = (ReturnStatementNode)statement;
sb.append("return");
if (rt.Value != null) {
sb.append("(");
sb.append(expressionToString(rt.Value));
sb.append(")");
}
sb.append(";\r\n");
break;
case If:
var ifStatement = (IfStatementNode)statement;
sb.append("if (");
sb.append(expressionToString(ifStatement.Condition));
sb.append(")\r\n");
sb.append(statementToString(ifStatement.IfTrue));
if (ifStatement.IfFalse != null) {
sb.append("else\r\n");
sb.append(statementToString(ifStatement.IfFalse));
}
break;
case While:
var whileStatement = (WhileStatementNode)statement;
sb.append("while (");
sb.append(expressionToString(whileStatement.Condition));
sb.append(")\r\n");
sb.append(statementToString(whileStatement.Statement));
break;
case Do:
var doStatement = (DoStatementNode)statement;
sb.append("do ");
sb.append(statementToString(doStatement.Statement));
sb.append("while (");
sb.append(expressionToString(doStatement.Condition));
sb.append(");\r\n");
break;
case For:
var forStatement = (ForStatementNode)statement;
sb.append("for (");
foreach (var init in forStatement.Initializer) {
sb.append(statementToString(init));
}
sb.append("Condition(");
if (forStatement.Condition != null) {
sb.append(expressionToString(forStatement.Condition));
}
sb.append(");\r\n");
foreach (var iter in forStatement.Iterator) {
sb.append(statementToString(iter));
}
sb.append(")\r\n");
sb.append(statementToString(forStatement.Statement));
break;
case Try:
var tryStatement = (TryStatementNode)statement;
sb.append("try ");
sb.append(statementToString(tryStatement.Block));
foreach (var cc in tryStatement.CatchClauses) {
sb.append("catch ");
if (cc.ExceptionType != null) {
sb.append("(");
sb.append(typeReferenceToString(cc.ExceptionType));
if (cc.NameLength > 0) {
sb.append(" ");
sb.append(new String(text, cc.NameOffset, cc.NameLength));
}
sb.append(") ");
}
sb.append(statementToString(cc.Block));
}
if (tryStatement.Finally != null) {
sb.append("finally ");
sb.append(statementToString(tryStatement.Finally));
}
break;
case Switch:
var switchStatement = (SwitchStatementNode)statement;
sb.append("switch (");
sb.append(expressionToString(switchStatement.Selector));
sb.append(") {\r\n");
foreach (var ss in switchStatement.Sections) {
if (ss.CaseExpression != null) {
sb.append("case ");
sb.append(expressionToString(ss.CaseExpression));
sb.append(":\r\n");
} else {
sb.append("default:\r\n");
}
foreach (var s in ss.Statements) {
sb.append(statementToString(s));
}
}
sb.append("}\r\n");
break;
case Foreach:
var foreachStatement = (ForeachStatementNode)statement;
sb.append("foreach (");
if (foreachStatement.Type != null) {
sb.append(typeReferenceToString(foreachStatement.Type));
sb.append(" ");
} else {
sb.append("var ");
}
sb.append(new String(text, foreachStatement.NameOffset, foreachStatement.NameLength));
sb.append(" in ");
sb.append(expressionToString(foreachStatement.Source));
sb.append(") ");
sb.append(statementToString(foreachStatement.Statement));
break;
case Break:
sb.append("break;\r\n");
break;
case Continue:
sb.append("continue;\r\n");
break;
case GotoCase:
var gotoCaseStatememt = (GotoCaseStatementNode)statement;
sb.append("goto ");
if (gotoCaseStatememt.Expression != null) {
sb.append("case ");
sb.append(expressionToString(gotoCaseStatememt.Expression));
} else {
sb.append("default");
}
sb.append(";\r\n");
break;
case Using:
var usingStatement = (UsingStatementNode)statement;
sb.append("using (");
sb.append(statementToString(usingStatement.ResourceAcquisition));
sb.append(") ");
sb.append(statementToString(usingStatement.Statement));
break;
case Synchronized:
var lockStatement = (SynchronizedStatementNode)statement;
sb.append("synchronized (");
sb.append(expressionToString(lockStatement.Lock));
sb.append(") ");
sb.append(statementToString(lockStatement.Statement));
break;
case Goto:
var gotoStatememt = (GotoStatementNode)statement;
sb.append("goto ");
sb.append(new String(text, gotoStatememt.LabelOffset, gotoStatememt.LabelLength));
sb.append(";\r\n");
break;
case Labeled:
var label = (LabeledStatementNode)statement;
sb.append(new String(text, label.NameOffset, label.NameLength));
sb.append(": ");
sb.append(statementToString(label.Statement));
sb.append(";\r\n");
break;
default:
throw new RuntimeException("Unhandled statement: " + statement.StatementKind);
}
return sb.toString();
}
public Matcher appendReplacement(StringBuffer sb, String replacement)
{
// If no match, return error
if (first < 0)
throw new InvalidOperationException("No match available");
// Process substitution string to replace group references with groups
int cursor = 0;
StringBuilder result = new StringBuilder();
while (cursor < replacement.length()) {
char nextChar = replacement.charAt(cursor);
if (nextChar == '\\') {
cursor++;
nextChar = replacement.charAt(cursor);
result.append(nextChar);
cursor++;
} else if (nextChar == '$') {
// Skip past $
cursor++;
// A StringIndexOutOfBoundsException is thrown if
// this "$" is the last character in replacement
// string in current implementation, a IAE might be
// more appropriate.
nextChar = replacement.charAt(cursor);
int refNum = -1;
if (nextChar == '{') {
cursor++;
StringBuilder gsb = new StringBuilder();
while (cursor < replacement.length()) {
nextChar = replacement.charAt(cursor);
if (ASCII.isLower(nextChar) ||
ASCII.isUpper(nextChar) ||
ASCII.isDigit(nextChar)) {
gsb.append(nextChar);
cursor++;
} else {
break;
}
}
if (gsb.length() == 0)
throw new IllegalArgumentException(
"named capturing group has 0 length name");
if (nextChar != '}')
throw new IllegalArgumentException(
"named capturing group is missing trailing '}'");
String gname = gsb.toString();
if (ASCII.isDigit(gname.charAt(0)))
throw new IllegalArgumentException(
"capturing group name {" + gname +
"} starts with digit character");
if (!parentPattern.namedGroups().containsKey(gname))
throw new IllegalArgumentException(
"No group with name {" + gname + "}");
refNum = parentPattern.namedGroups().get(gname);
cursor++;
} else {
// The first number is always a group
refNum = (int)nextChar - '0';
if ((refNum < 0)||(refNum > 9))
throw new IllegalArgumentException(
"Illegal group reference");
cursor++;
// Capture the largest legal group string
boolean done = false;
while (!done) {
if (cursor >= replacement.length()) {
break;
}
int nextDigit = replacement.charAt(cursor) - '0';
if ((nextDigit < 0)||(nextDigit > 9)) { // not a number
break;
}
int newRefNum = (refNum * 10) + nextDigit;
if (groupCount() < newRefNum) {
done = true;
} else {
refNum = newRefNum;
cursor++;
}
}
}
// Append group
if (start(refNum) != -1 && end(refNum) != -1)
result.append(text, start(refNum), end(refNum));
} else {
result.append(nextChar);
cursor++;
}
}
// Append the intervening text
sb.append(text, lastAppendPosition, first);
// Append the match substitution
sb.append(result);
lastAppendPosition = last;
return this;
}
public StringBuilder(StringBuilder str) : base(str.length() + 16)
{
append(str.toString());
}
