~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

WriteEmbeddedStatement(doLoopStatement.EmbeddedStatement, prettyPrintOptions.WhileBraceForcement, prettyPrintOptions.StatementBraceStyle, prettyPrintOptions.PlaceWhileOnNewLine);

1719

1720

if (doLoopStatement.ConditionPosition == ConditionPosition.End) {

1721

if (prettyPrintOptions.PlaceWhileOnNewLine) {

1722

outputFormatter.Indent();

1723

} else {

1724

outputFormatter.Space();

1725

}

1726

PrintLoopCheck(doLoopStatement);

1727

outputFormatter.PrintToken(Tokens.Semicolon);

1728

outputFormatter.NewLine();

1729

}

1730

1731

return null;

1732

}

1733

1734

public override object TrackedVisitForeachStatement(ForeachStatement foreachStatement, object data)

1735

{

1736

outputFormatter.PrintToken(Tokens.Foreach);

1737

if (this.prettyPrintOptions.ForeachParentheses) {

1738

outputFormatter.Space();

1739

}

1740

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1741

if (this.prettyPrintOptions.WithinForEachParentheses) {

1742

outputFormatter.Space();

1743

}

1744

TrackVisit(foreachStatement.TypeReference, data);

1745

outputFormatter.Space();

1746

outputFormatter.PrintIdentifier(foreachStatement.VariableName);

1747

outputFormatter.Space();

1748

outputFormatter.PrintToken(Tokens.In);

1749

outputFormatter.Space();

1750

TrackVisit(foreachStatement.Expression, data);

1751

if (this.prettyPrintOptions.WithinForEachParentheses) {

1752

outputFormatter.Space();

1753

}

1754

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1755

1756

WriteEmbeddedStatement(foreachStatement.EmbeddedStatement, prettyPrintOptions.ForEachBraceForcement, prettyPrintOptions.StatementBraceStyle, true);

1757

1758

return null;

1759

}

1760

1761

public override object TrackedVisitLockStatement(LockStatement lockStatement, object data)

1762

{

1763

outputFormatter.PrintToken(Tokens.Lock);

1764

if (this.prettyPrintOptions.LockParentheses) {

1765

outputFormatter.Space();

1766

}

1767

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1768

if (this.prettyPrintOptions.WithinLockParentheses) {

1769

outputFormatter.Space();

1770

}

1771

TrackVisit(lockStatement.LockExpression, data);

1772

if (this.prettyPrintOptions.WithinLockParentheses) {

1773

outputFormatter.Space();

1774

}

1775

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1776

1777

WriteEmbeddedStatement(lockStatement.EmbeddedStatement);

1778

1779

return null;

1780

}

1781

1782

public override object TrackedVisitUsingStatement(UsingStatement usingStatement, object data)

1783

{

1784

outputFormatter.PrintToken(Tokens.Using);

1785

if (this.prettyPrintOptions.UsingParentheses) {

1786

outputFormatter.Space();

1787

}

1788

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1789

if (prettyPrintOptions.WithinUsingParentheses) {

1790

outputFormatter.Space();

1791

}

1792

PrintStatementInline(usingStatement.ResourceAcquisition, data);

1793

if (prettyPrintOptions.WithinUsingParentheses) {

1794

outputFormatter.Space();

1795

}

1796

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1797

1798

WriteEmbeddedStatement(usingStatement.EmbeddedStatement, prettyPrintOptions.UsingBraceForcement, prettyPrintOptions.StatementBraceStyle, true);

1799

1800

return null;

1801

}

1802

1803

void PrintStatementInline(Statement statement, object data)

1804

{

1805

outputFormatter.DoIndent = false;

1806

outputFormatter.DoNewLine = false;

1807

outputFormatter.EmitSemicolon = false;

1808

TrackVisit(statement, data);

1809

outputFormatter.DoIndent = true;

1810

outputFormatter.DoNewLine = true;

1811

outputFormatter.EmitSemicolon = true;

1812

}

1813

1814

public override object TrackedVisitWithStatement(WithStatement withStatement, object data)

1815

{

1816

NotSupported(withStatement);

1817

return null;

1818

}

1819

1820

public override object TrackedVisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)

1821

{

1822

outputFormatter.PrintToken(Tokens.Try);

1823

1824

WriteEmbeddedStatement (tryCatchStatement.StatementBlock, prettyPrintOptions.PlaceCatchOnNewLine);

1825

for (int i = 0 ; i < tryCatchStatement.CatchClauses.Count; i++) {

1826

TrackVisit(tryCatchStatement.CatchClauses[i], i == tryCatchStatement.CatchClauses.Count - 1);

1827

}

1828

1829

if (!tryCatchStatement.FinallyBlock.IsNull) {

1830

if (prettyPrintOptions.PlaceFinallyOnNewLine) {

1831

// if (!prettyPrintOptions.PlaceCatchOnNewLine)

1832

// outputFormatter.NewLine ();

1833

outputFormatter.Indent();

1834

} else {

1835

outputFormatter.Space();

1836

}

1837

outputFormatter.PrintToken(Tokens.Finally);

1838

WriteEmbeddedStatement(tryCatchStatement.FinallyBlock);

1839

}

1840

1841

return null;

1842

}

1843

1844

public override object TrackedVisitCatchClause(CatchClause catchClause, object data)

1845

{

1846

if (prettyPrintOptions.PlaceCatchOnNewLine) {

1847

outputFormatter.Indent();

1848

} else {

1849

outputFormatter.Space();

1850

}

1851

outputFormatter.PrintToken(Tokens.Catch);

1852

1853

if (!catchClause.TypeReference.IsNull) {

1854

if (this.prettyPrintOptions.CatchParentheses) {

1855

outputFormatter.Space();

1856

}

1857

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1858

if (this.prettyPrintOptions.WithinCatchParentheses) {

1859

outputFormatter.Space();

1860

}

1861

outputFormatter.PrintIdentifier(catchClause.TypeReference.Type);

1862

if (catchClause.VariableName.Length > 0) {

1863

outputFormatter.Space();

1864

outputFormatter.PrintIdentifier(catchClause.VariableName);

1865

}

1866

if (this.prettyPrintOptions.WithinCatchParentheses) {

1867

outputFormatter.Space();

1868

}

1869

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1870

}

1871

WriteEmbeddedStatement(catchClause.StatementBlock, ((bool)data) ? prettyPrintOptions.PlaceFinallyOnNewLine : prettyPrintOptions.PlaceCatchOnNewLine);

1872

return null;

1873

}

1874

1875

public override object TrackedVisitThrowStatement(ThrowStatement throwStatement, object data)

1876

{

1877

outputFormatter.PrintToken(Tokens.Throw);

1878

if (!throwStatement.Expression.IsNull) {

1879

outputFormatter.Space();

1880

TrackVisit(throwStatement.Expression, data);

1881

}

1882

outputFormatter.PrintToken(Tokens.Semicolon);

1883

return null;

1884

}

1885

1886

public override object TrackedVisitFixedStatement(FixedStatement fixedStatement, object data)

1887

{

1888

outputFormatter.PrintToken(Tokens.Fixed);

1889

if (this.prettyPrintOptions.FixedParentheses) {

1890

outputFormatter.Space();

1891

}

1892

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1893

if (this.prettyPrintOptions.WithinCheckedExpressionParantheses) {

1894

outputFormatter.Space();

1895

}

1896

PrintStatementInline(fixedStatement.PointerDeclaration, data);

1897

if (this.prettyPrintOptions.WithinCheckedExpressionParantheses) {

1898

outputFormatter.Space();

1899

}

1900

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1901

1902

WriteEmbeddedStatement(fixedStatement.EmbeddedStatement, prettyPrintOptions.FixedBraceForcement, prettyPrintOptions.StatementBraceStyle, true);

1903

return null;

1904

}

1905

1906

public override object TrackedVisitUnsafeStatement(UnsafeStatement unsafeStatement, object data)

1907

{

1908

outputFormatter.PrintToken(Tokens.Unsafe);

1909

WriteEmbeddedStatement(unsafeStatement.Block);

1910

return null;

1911

}

1912

1913

public override object TrackedVisitCheckedStatement(CheckedStatement checkedStatement, object data)

1914

{

1915

outputFormatter.PrintToken(Tokens.Checked);

1916

WriteEmbeddedStatement(checkedStatement.Block);

1917

return null;

1918

}

1919

1920

public override object TrackedVisitUncheckedStatement(UncheckedStatement uncheckedStatement, object data)

1921

{

1922

outputFormatter.PrintToken(Tokens.Unchecked);

1923

WriteEmbeddedStatement(uncheckedStatement.Block);

1924

return null;

1925

}

1926

1927

public override object TrackedVisitExitStatement(ExitStatement exitStatement, object data)

1928

{

1929

if (exitStatement.ExitType == ExitType.Function || exitStatement.ExitType == ExitType.Sub || exitStatement.ExitType == ExitType.Property) {

1930

outputFormatter.PrintToken(Tokens.Return);

1931

outputFormatter.PrintToken(Tokens.Semicolon);

1932

} else {

1933

outputFormatter.PrintToken(Tokens.Break);

1934

outputFormatter.PrintToken(Tokens.Semicolon);

1935

outputFormatter.PrintText(" // TODO: might not be correct. Was : Exit " + exitStatement.ExitType);

1936

}

1937

outputFormatter.NewLine();

1938

return null;

1939

}

1940

1941

public override object TrackedVisitForNextStatement(ForNextStatement forNextStatement, object data)

1942

{

1943

outputFormatter.PrintToken(Tokens.For);

1944

outputFormatter.Space();

1945

outputFormatter.PrintToken(Tokens.OpenParenthesis);

1946

if (this.prettyPrintOptions.WithinForParentheses) {

1947

outputFormatter.Space();

1948

}

1949

if (forNextStatement.LoopVariableExpression.IsNull) {

1950

if (!forNextStatement.TypeReference.IsNull) {

1951

TrackVisit(forNextStatement.TypeReference, data);

1952

outputFormatter.Space();

1953

}

1954

outputFormatter.PrintIdentifier(forNextStatement.VariableName);

1955

} else {

1956

TrackVisit(forNextStatement.LoopVariableExpression, data);

1957

}

1958

if (this.prettyPrintOptions.AroundAssignmentParentheses) {

1959

outputFormatter.Space();

1960

}

1961

outputFormatter.PrintToken(Tokens.Assign);

1962

if (this.prettyPrintOptions.AroundAssignmentParentheses) {

1963

outputFormatter.Space();

1964

}

1965

TrackVisit(forNextStatement.Start, data);

1966

outputFormatter.PrintToken(Tokens.Semicolon);

1967

outputFormatter.Space();

1968

if (forNextStatement.LoopVariableExpression.IsNull)

1969

outputFormatter.PrintIdentifier(forNextStatement.VariableName);

1970

else

1971

TrackVisit(forNextStatement.LoopVariableExpression, data);

1972

outputFormatter.Space();

1973

PrimitiveExpression pe = forNextStatement.Step as PrimitiveExpression;

1974

if ((pe == null || !(pe.Value is int) || ((int)pe.Value) >= 0)

1975

&& !(forNextStatement.Step is UnaryOperatorExpression))

1976

outputFormatter.PrintToken(Tokens.LessEqual);

1977

else

1978

outputFormatter.PrintToken(Tokens.GreaterEqual);

1979

outputFormatter.Space();

1980

TrackVisit(forNextStatement.End, data);

1981

outputFormatter.PrintToken(Tokens.Semicolon);

1982

outputFormatter.Space();

1983

if (forNextStatement.LoopVariableExpression.IsNull)

1984

outputFormatter.PrintIdentifier(forNextStatement.VariableName);

1985

else

1986

TrackVisit(forNextStatement.LoopVariableExpression, data);

1987

if (forNextStatement.Step.IsNull) {

1988

outputFormatter.PrintToken(Tokens.Increment);

1989

} else {

1990

outputFormatter.Space();

1991

outputFormatter.PrintToken(Tokens.PlusAssign);

1992

outputFormatter.Space();

1993

TrackVisit(forNextStatement.Step, data);

1994

}

1995

if (this.prettyPrintOptions.WithinForParentheses) {

1996

outputFormatter.Space();

1997

}

1998

outputFormatter.PrintToken(Tokens.CloseParenthesis);

1999

2000

WriteEmbeddedStatement(forNextStatement.EmbeddedStatement, prettyPrintOptions.ForBraceForcement, prettyPrintOptions.StatementBraceStyle, true);

2001

return null;

2002

}

2003

#endregion

2004

2005

#region Expressions

2006

public override object TrackedVisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data)

2007

{

2008

NotSupported(classReferenceExpression);

2009

return null;

2010

}

2011

2012

static string ConvertCharLiteral(char ch)

2013

{

2014

if (ch == '\'') return "\\'";

2015

return ConvertChar(ch);

2016

}

2017

2018

static string ConvertChar(char ch)

2019

{

2020

switch (ch) {

2021

case '\\':

2022

return "\\\\";

2023

case '\0':

2024

return "\\0";

2025

case '\a':

2026

return "\\a";

2027

case '\b':

2028

return "\\b";

2029

case '\f':

2030

return "\\f";

2031

case '\n':

2032

return "\\n";

2033

case '\r':

2034

return "\\r";

2035

case '\t':

2036

return "\\t";

2037

case '\v':

2038

return "\\v";

2039

default:

2040

if (char.IsControl(ch)) {

2041

return "\\u" + ((int)ch).ToString("x4");

2042

} else {

2043

return ch.ToString();

2044

}

2045

}

2046

}

2047

2048

static string ConvertString(string str)

2049

{

2050

StringBuilder sb = new StringBuilder();

2051

foreach (char ch in str) {

2052

if (ch == '"')

2053

sb.Append("\\\"");

2054

else

2055

sb.Append(ConvertChar(ch));

2056

}

2057

return sb.ToString();

2058

}

2059

2060

public override object TrackedVisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)

2061

{

2062

outputFormatter.PrintText(ToCSharpString(primitiveExpression));

2063

return null;

2064

}

2065

2066

internal static string ToCSharpString(PrimitiveExpression primitiveExpression)

2067

{

2068

if (primitiveExpression.Value == null)

2069

return "null";

2070

if (primitiveExpression.HasStringValue)

2071

return primitiveExpression.StringValue;

2072

object val = primitiveExpression.Value;

2073

2074

if (val is bool) {

2075

if ((bool)val) {

2076

return "true";

2077

} else {

2078

return "false";

2079

}

2080

}

2081

2082

if (val is string) {

2083

if (primitiveExpression.LiteralFormat == LiteralFormat.VerbatimStringLiteral)

2084

return "@\"" + val.ToString() + "\"";

2085

return "\"" + ConvertString(val.ToString()) + "\"";

2086

}

2087

2088

if (val is char) {

2089

return "'" + ConvertCharLiteral((char)val) + "'";

2090

}

2091

2092

if (val is decimal) {

2093

return ((decimal)val).ToString(NumberFormatInfo.InvariantInfo) + "m";

2094

}

2095

2096

if (val is float) {

2097

return ((float)val).ToString(NumberFormatInfo.InvariantInfo) + "f";

2098

}

2099

2100

if (val is double) {

2101

string text = ((double)val).ToString(NumberFormatInfo.InvariantInfo);

2102

if (text.IndexOf('.') < 0 && text.IndexOf('E') < 0)

2103

return text + ".0";

2104

else

2105

return text;

2106

}

2107

2108

if (val is IFormattable) {

2109

StringBuilder b = new StringBuilder();

2110

if (primitiveExpression.LiteralFormat == LiteralFormat.HexadecimalNumber) {

2111

b.Append("0x");

2112

b.Append(((IFormattable)val).ToString("x", NumberFormatInfo.InvariantInfo));

2113

} else {

2114

b.Append(((IFormattable)val).ToString(null, NumberFormatInfo.InvariantInfo));

2115

}

2116

if (val is uint || val is ulong) {

2117

b.Append("u");

2118

}

2119

if (val is long || val is ulong) {

2120

b.Append("L");

2121

}

2122

return b.ToString();

2123

} else {

2124

return val.ToString();

2125

}

2126

}

2127

2128

static bool IsNullLiteralExpression(Expression expr)

2129

{

2130

PrimitiveExpression pe = expr as PrimitiveExpression;

2131

if (pe == null) return false;

2132

return pe.Value == null;

2133

}

2134

2135

public override object TrackedVisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)

2136

{

2137

// VB-operators that require special representation:

2138

switch (binaryOperatorExpression.Op) {

2139

case BinaryOperatorType.ReferenceEquality:

2140

case BinaryOperatorType.ReferenceInequality:

2141

if (IsNullLiteralExpression(binaryOperatorExpression.Left) || IsNullLiteralExpression(binaryOperatorExpression.Right)) {

2142

// prefer a == null to object.ReferenceEquals(a, null)

2143

break;

2144

}

2145

2146

if (binaryOperatorExpression.Op == BinaryOperatorType.ReferenceInequality)

2147

outputFormatter.PrintToken(Tokens.Not);

2148

outputFormatter.PrintText("object.ReferenceEquals");

2149

if (prettyPrintOptions.BeforeMethodCallParentheses) {

2150

outputFormatter.Space();

2151

}

2152

2153

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2154

TrackVisit(binaryOperatorExpression.Left, data);

2155

PrintFormattedComma();

2156

TrackVisit(binaryOperatorExpression.Right, data);

2157

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2158

return null;

2159

case BinaryOperatorType.Power:

2160

outputFormatter.PrintText("Math.Pow");

2161

if (prettyPrintOptions.BeforeMethodCallParentheses) {

2162

outputFormatter.Space();

2163

}

2164

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2165

if (this.prettyPrintOptions.WithinMethodCallParentheses) {

2166

outputFormatter.Space();

2167

}

2168

TrackVisit(binaryOperatorExpression.Left, data);

2169

PrintFormattedComma();

2170

TrackVisit(binaryOperatorExpression.Right, data);

2171

if (this.prettyPrintOptions.WithinMethodCallParentheses) {

2172

outputFormatter.Space();

2173

}

2174

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2175

return null;

2176

case BinaryOperatorType.DictionaryAccess:

2177

TrackVisit(binaryOperatorExpression.Left, data);

2178

outputFormatter.PrintToken(Tokens.OpenSquareBracket);

2179

TrackVisit(binaryOperatorExpression.Right, data);

2180

outputFormatter.PrintToken(Tokens.CloseSquareBracket);

2181

return null;

2182

}

2183

TrackVisit(binaryOperatorExpression.Left, data);

2184

switch (binaryOperatorExpression.Op) {

2185

case BinaryOperatorType.Add:

2186

case BinaryOperatorType.Concat: // translate Concatenation to +

2187

if (prettyPrintOptions.AroundAdditiveOperatorParentheses) {

2188

outputFormatter.Space();

2189

}

2190

outputFormatter.PrintToken(Tokens.Plus);

2191

if (prettyPrintOptions.AroundAdditiveOperatorParentheses) {

2192

outputFormatter.Space();

2193

}

2194

break;

2195

2196

case BinaryOperatorType.Subtract:

2197

if (prettyPrintOptions.AroundAdditiveOperatorParentheses) {

2198

outputFormatter.Space();

2199

}

2200

outputFormatter.PrintToken(Tokens.Minus);

2201

if (prettyPrintOptions.AroundAdditiveOperatorParentheses) {

2202

outputFormatter.Space();

2203

}

2204

break;

2205

2206

case BinaryOperatorType.Multiply:

2207

if (prettyPrintOptions.AroundMultiplicativeOperatorParentheses) {

2208

outputFormatter.Space();

2209

}

2210

outputFormatter.PrintToken(Tokens.Times);

2211

if (prettyPrintOptions.AroundMultiplicativeOperatorParentheses) {

2212

outputFormatter.Space();

2213

}

2214

break;

2215

2216

case BinaryOperatorType.Divide:

2217

case BinaryOperatorType.DivideInteger:

2218

if (prettyPrintOptions.AroundMultiplicativeOperatorParentheses) {

2219

outputFormatter.Space();

2220

}

2221

outputFormatter.PrintToken(Tokens.Div);

2222

if (prettyPrintOptions.AroundMultiplicativeOperatorParentheses) {

2223

outputFormatter.Space();

2224

}

2225

break;

2226

2227

case BinaryOperatorType.Modulus:

2228

if (prettyPrintOptions.AroundMultiplicativeOperatorParentheses) {

2229

outputFormatter.Space();

2230

}

2231

outputFormatter.PrintToken(Tokens.Mod);

2232

if (prettyPrintOptions.AroundMultiplicativeOperatorParentheses) {

2233

outputFormatter.Space();

2234

}

2235

break;

2236

2237

case BinaryOperatorType.ShiftLeft:

2238

if (prettyPrintOptions.AroundShiftOperatorParentheses) {

2239

outputFormatter.Space();

2240

}

2241

outputFormatter.PrintToken(Tokens.ShiftLeft);

2242

if (prettyPrintOptions.AroundShiftOperatorParentheses) {

2243

outputFormatter.Space();

2244

}

2245

break;

2246

2247

case BinaryOperatorType.ShiftRight:

2248

if (prettyPrintOptions.AroundShiftOperatorParentheses) {

2249

outputFormatter.Space();

2250

}

2251

outputFormatter.PrintToken(Tokens.GreaterThan);

2252

outputFormatter.PrintToken(Tokens.GreaterThan);

2253

if (prettyPrintOptions.AroundShiftOperatorParentheses) {

2254

outputFormatter.Space();

2255

}

2256

break;

2257

2258

case BinaryOperatorType.BitwiseAnd:

2259

if (prettyPrintOptions.AroundBitwiseOperatorParentheses) {

2260

outputFormatter.Space();

2261

}

2262

outputFormatter.PrintToken(Tokens.BitwiseAnd);

2263

if (prettyPrintOptions.AroundBitwiseOperatorParentheses) {

2264

outputFormatter.Space();

2265

}

2266

break;

2267

case BinaryOperatorType.BitwiseOr:

2268

if (prettyPrintOptions.AroundBitwiseOperatorParentheses) {

2269

outputFormatter.Space();

2270

}

2271

outputFormatter.PrintToken(Tokens.BitwiseOr);

2272

if (prettyPrintOptions.AroundBitwiseOperatorParentheses) {

2273

outputFormatter.Space();

2274

}

2275

break;

2276

case BinaryOperatorType.ExclusiveOr:

2277

if (prettyPrintOptions.AroundBitwiseOperatorParentheses) {

2278

outputFormatter.Space();

2279

}

2280

outputFormatter.PrintToken(Tokens.Xor);

2281

if (prettyPrintOptions.AroundBitwiseOperatorParentheses) {

2282

outputFormatter.Space();

2283

}

2284

break;

2285

2286

case BinaryOperatorType.LogicalAnd:

2287

if (prettyPrintOptions.AroundLogicalOperatorParentheses) {

2288

outputFormatter.Space();

2289

}

2290

outputFormatter.PrintToken(Tokens.LogicalAnd);

2291

if (prettyPrintOptions.AroundLogicalOperatorParentheses) {

2292

outputFormatter.Space();

2293

}

2294

break;

2295

case BinaryOperatorType.LogicalOr:

2296

if (prettyPrintOptions.AroundLogicalOperatorParentheses) {

2297

outputFormatter.Space();

2298

}

2299

outputFormatter.PrintToken(Tokens.LogicalOr);

2300

if (prettyPrintOptions.AroundLogicalOperatorParentheses) {

2301

outputFormatter.Space();

2302

}

2303

break;

2304

2305

case BinaryOperatorType.Equality:

2306

case BinaryOperatorType.ReferenceEquality:

2307

if (prettyPrintOptions.AroundEqualityOperatorParentheses) {

2308

outputFormatter.Space();

2309

}

2310

outputFormatter.PrintToken(Tokens.Equal);

2311

if (prettyPrintOptions.AroundEqualityOperatorParentheses) {

2312

outputFormatter.Space();

2313

}

2314

break;

2315

case BinaryOperatorType.GreaterThan:

2316

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2317

outputFormatter.Space();

2318

}

2319

outputFormatter.PrintToken(Tokens.GreaterThan);

2320

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2321

outputFormatter.Space();

2322

}

2323

break;

2324

case BinaryOperatorType.GreaterThanOrEqual:

2325

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2326

outputFormatter.Space();

2327

}

2328

outputFormatter.PrintToken(Tokens.GreaterEqual);

2329

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2330

outputFormatter.Space();

2331

}

2332

break;

2333

case BinaryOperatorType.InEquality:

2334

case BinaryOperatorType.ReferenceInequality:

2335

if (prettyPrintOptions.AroundEqualityOperatorParentheses) {

2336

outputFormatter.Space();

2337

}

2338

outputFormatter.PrintToken(Tokens.NotEqual);

2339

if (prettyPrintOptions.AroundEqualityOperatorParentheses) {

2340

outputFormatter.Space();

2341

}

2342

break;

2343

case BinaryOperatorType.LessThan:

2344

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2345

outputFormatter.Space();

2346

}

2347

outputFormatter.PrintToken(Tokens.LessThan);

2348

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2349

outputFormatter.Space();

2350

}

2351

break;

2352

case BinaryOperatorType.LessThanOrEqual:

2353

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2354

outputFormatter.Space();

2355

}

2356

outputFormatter.PrintToken(Tokens.LessEqual);

2357

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2358

outputFormatter.Space();

2359

}

2360

break;

2361

case BinaryOperatorType.NullCoalescing:

2362

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2363

outputFormatter.Space();

2364

}

2365

outputFormatter.PrintToken(Tokens.DoubleQuestion);

2366

if (prettyPrintOptions.AroundRelationalOperatorParentheses) {

2367

outputFormatter.Space();

2368

}

2369

break;

2370

2371

default:

2372

Error(binaryOperatorExpression, String.Format("Unknown binary operator {0}", binaryOperatorExpression.Op));

2373

return null;

2374

}

2375

TrackVisit(binaryOperatorExpression.Right, data);

2376

return null;

2377

}

2378

2379

public override object TrackedVisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)

2380

{

2381

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2382

if (this.prettyPrintOptions.WithinParentheses) {

2383

outputFormatter.Space();

2384

}

2385

TrackVisit(parenthesizedExpression.Expression, data);

2386

if (this.prettyPrintOptions.WithinParentheses) {

2387

outputFormatter.Space();

2388

}

2389

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2390

return null;

2391

}

2392

2393

public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)

2394

{

2395

TrackVisit(invocationExpression.TargetObject, data);

2396

2397

if (prettyPrintOptions.BeforeMethodCallParentheses) {

2398

outputFormatter.Space();

2399

}

2400

2401

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2402

if (this.prettyPrintOptions.WithinMethodCallParentheses) {

2403

outputFormatter.Space();

2404

}

2405

AppendCommaSeparatedList(invocationExpression.Arguments);

2406

if (this.prettyPrintOptions.WithinMethodCallParentheses) {

2407

outputFormatter.Space();

2408

}

2409

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2410

return null;

2411

}

2412

2413

public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)

2414

{

2415

outputFormatter.PrintIdentifier(identifierExpression.Identifier);

2416

PrintTypeArgumentList(identifierExpression.TypeArguments);

2417

return null;

2418

}

2419

2420

void PrintTypeArgumentList(List<TypeReference> typeArguments)

2421

{

2422

if (typeArguments != null && typeArguments.Count > 0) {

2423

outputFormatter.PrintToken(Tokens.LessThan);

2424

AppendCommaSeparatedList(typeArguments);

2425

outputFormatter.PrintToken(Tokens.GreaterThan);

2426

}

2427

}

2428

2429

public override object TrackedVisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data)

2430

{

2431

TrackVisit(typeReferenceExpression.TypeReference, data);

2432

return null;

2433

}

2434

2435

public override object TrackedVisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)

2436

{

2437

switch (unaryOperatorExpression.Op) {

2438

case UnaryOperatorType.BitNot:

2439

outputFormatter.PrintToken(Tokens.BitwiseComplement);

2440

break;

2441

case UnaryOperatorType.Decrement:

2442

outputFormatter.PrintToken(Tokens.Decrement);

2443

break;

2444

case UnaryOperatorType.Increment:

2445

outputFormatter.PrintToken(Tokens.Increment);

2446

break;

2447

case UnaryOperatorType.Minus:

2448

outputFormatter.PrintToken(Tokens.Minus);

2449

break;

2450

case UnaryOperatorType.Not:

2451

outputFormatter.PrintToken(Tokens.Not);

2452

break;

2453

case UnaryOperatorType.Plus:

2454

outputFormatter.PrintToken(Tokens.Plus);

2455

break;

2456

case UnaryOperatorType.PostDecrement:

2457

TrackVisit(unaryOperatorExpression.Expression, data);

2458

outputFormatter.PrintToken(Tokens.Decrement);

2459

return null;

2460

case UnaryOperatorType.PostIncrement:

2461

TrackVisit(unaryOperatorExpression.Expression, data);

2462

outputFormatter.PrintToken(Tokens.Increment);

2463

return null;

2464

case UnaryOperatorType.Dereference:

2465

outputFormatter.PrintToken(Tokens.Times);

2466

break;

2467

case UnaryOperatorType.AddressOf:

2468

outputFormatter.PrintToken(Tokens.BitwiseAnd);

2469

break;

2470

default:

2471

Error(unaryOperatorExpression, String.Format("Unknown unary operator {0}", unaryOperatorExpression.Op));

2472

return null;

2473

}

2474

TrackVisit(unaryOperatorExpression.Expression, data);

2475

return null;

2476

}

2477

2478

public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)

2479

{

2480

TrackVisit(assignmentExpression.Left, data);

2481

if (this.prettyPrintOptions.AroundAssignmentParentheses) {

2482

outputFormatter.Space();

2483

}

2484

switch (assignmentExpression.Op) {

2485

case AssignmentOperatorType.Assign:

2486

outputFormatter.PrintToken(Tokens.Assign);

2487

break;

2488

case AssignmentOperatorType.Add:

2489

case AssignmentOperatorType.ConcatString:

2490

outputFormatter.PrintToken(Tokens.PlusAssign);

2491

break;

2492

case AssignmentOperatorType.Subtract:

2493

outputFormatter.PrintToken(Tokens.MinusAssign);

2494

break;

2495

case AssignmentOperatorType.Multiply:

2496

outputFormatter.PrintToken(Tokens.TimesAssign);

2497

break;

2498

case AssignmentOperatorType.Divide:

2499

case AssignmentOperatorType.DivideInteger:

2500

outputFormatter.PrintToken(Tokens.DivAssign);

2501

break;

2502

case AssignmentOperatorType.ShiftLeft:

2503

outputFormatter.PrintToken(Tokens.ShiftLeftAssign);

2504

break;

2505

case AssignmentOperatorType.ShiftRight:

2506

outputFormatter.PrintToken(Tokens.GreaterThan);

2507

outputFormatter.PrintToken(Tokens.GreaterEqual);

2508

break;

2509

case AssignmentOperatorType.ExclusiveOr:

2510

outputFormatter.PrintToken(Tokens.XorAssign);

2511

break;

2512

case AssignmentOperatorType.Modulus:

2513

outputFormatter.PrintToken(Tokens.ModAssign);

2514

break;

2515

case AssignmentOperatorType.BitwiseAnd:

2516

outputFormatter.PrintToken(Tokens.BitwiseAndAssign);

2517

break;

2518

case AssignmentOperatorType.BitwiseOr:

2519

outputFormatter.PrintToken(Tokens.BitwiseOrAssign);

2520

break;

2521

case AssignmentOperatorType.Power:

2522

outputFormatter.PrintToken(Tokens.Assign);

2523

if (this.prettyPrintOptions.AroundAssignmentParentheses) {

2524

outputFormatter.Space();

2525

}

2526

VisitBinaryOperatorExpression(new BinaryOperatorExpression(assignmentExpression.Left,

2527

BinaryOperatorType.Power,

2528

assignmentExpression.Right), data);

2529

return null;

2530

default:

2531

Error(assignmentExpression, String.Format("Unknown assignment operator {0}", assignmentExpression.Op));

2532

return null;

2533

}

2534

if (this.prettyPrintOptions.AroundAssignmentParentheses) {

2535

outputFormatter.Space();

2536

}

2537

TrackVisit(assignmentExpression.Right, data);

2538

return null;

2539

}

2540

2541

public override object TrackedVisitSizeOfExpression(SizeOfExpression sizeOfExpression, object data)

2542

{

2543

outputFormatter.PrintToken(Tokens.Sizeof);

2544

if (prettyPrintOptions.SizeOfParentheses) {

2545

outputFormatter.Space();

2546

}

2547

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2548

if (this.prettyPrintOptions.WithinSizeOfParentheses) {

2549

outputFormatter.Space();

2550

}

2551

TrackVisit(sizeOfExpression.TypeReference, data);

2552

if (this.prettyPrintOptions.WithinSizeOfParentheses) {

2553

outputFormatter.Space();

2554

}

2555

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2556

return null;

2557

}

2558

2559

public override object TrackedVisitTypeOfExpression(TypeOfExpression typeOfExpression, object data)

2560

{

2561

outputFormatter.PrintToken(Tokens.Typeof);

2562

if (prettyPrintOptions.TypeOfParentheses) {

2563

outputFormatter.Space();

2564

}

2565

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2566

if (this.prettyPrintOptions.WithinTypeOfParentheses) {

2567

outputFormatter.Space();

2568

}

2569

TrackVisit(typeOfExpression.TypeReference, data);

2570

if (this.prettyPrintOptions.WithinTypeOfParentheses) {

2571

outputFormatter.Space();

2572

}

2573

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2574

return null;

2575

}

2576

2577

public override object TrackedVisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)

2578

{

2579

outputFormatter.PrintToken(Tokens.Default);

2580

if (prettyPrintOptions.TypeOfParentheses) {

2581

outputFormatter.Space();

2582

}

2583

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2584

if (this.prettyPrintOptions.WithinTypeOfParentheses) {

2585

outputFormatter.Space();

2586

}

2587

TrackVisit(defaultValueExpression.TypeReference, data);

2588

if (this.prettyPrintOptions.WithinTypeOfParentheses) {

2589

outputFormatter.Space();

2590

}

2591

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2592

return null;

2593

}

2594

2595

public override object TrackedVisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data)

2596

{

2597

TrackVisit(typeOfIsExpression.Expression, data);

2598

outputFormatter.Space();

2599

outputFormatter.PrintToken(Tokens.Is);

2600

outputFormatter.Space();

2601

TrackVisit(typeOfIsExpression.TypeReference, data);

2602

return null;

2603

}

2604

2605

public override object TrackedVisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)

2606

{

2607

// C# 2.0 can reference methods directly

2608

return TrackVisit(addressOfExpression.Expression, data);

2609

}

2610

2611

public override object TrackedVisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data)

2612

{

2613

outputFormatter.PrintToken(Tokens.Delegate);

2614

2615

if (anonymousMethodExpression.Parameters.Count > 0 || anonymousMethodExpression.HasParameterList) {

2616

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2617

bool withinParentheses = this.prettyPrintOptions.WithinMethodDeclarationParentheses && anonymousMethodExpression.Parameters.Any ();

2618

if (withinParentheses) {

2619

outputFormatter.Space();

2620

}

2621

AppendCommaSeparatedList(anonymousMethodExpression.Parameters);

2622

if (withinParentheses) {

2623

outputFormatter.Space();

2624

}

2625

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2626

}

2627

OutputBlockAllowInline(anonymousMethodExpression.Body, this.prettyPrintOptions.AnonymousMethodBraceStyle, false);

2628

return null;

2629

}

2630

2631

public override object TrackedVisitLambdaExpression(LambdaExpression lambdaExpression, object data)

2632

{

2633

if (lambdaExpression.Parameters.Count == 1 && lambdaExpression.Parameters[0].TypeReference.IsNull) {

2634

// short syntax

2635

outputFormatter.PrintIdentifier(lambdaExpression.Parameters[0].ParameterName);

2636

} else {

2637

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2638

if (this.prettyPrintOptions.WithinParentheses) {

2639

outputFormatter.Space();

2640

}

2641

AppendCommaSeparatedList(lambdaExpression.Parameters);

2642

if (this.prettyPrintOptions.WithinParentheses) {

2643

outputFormatter.Space();

2644

}

2645

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2646

}

2647

outputFormatter.Space();

2648

outputFormatter.PrintToken(Tokens.LambdaArrow);

2649

if (!lambdaExpression.ExpressionBody.IsNull) {

2650

outputFormatter.Space();

2651

TrackVisit(lambdaExpression.ExpressionBody, null);

2652

}

2653

if (!lambdaExpression.StatementBody.IsNull) {

2654

OutputBlockAllowInline(lambdaExpression.StatementBody, this.prettyPrintOptions.MethodBraceStyle, false);

2655

}

2656

return null;

2657

}

2658

2659

public override object TrackedVisitCheckedExpression(CheckedExpression checkedExpression, object data)

2660

{

2661

outputFormatter.PrintToken(Tokens.Checked);

2662

if (prettyPrintOptions.CheckedParentheses) {

2663

outputFormatter.Space();

2664

}

2665

2666

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2667

if (this.prettyPrintOptions.WithinCheckedExpressionParantheses) {

2668

outputFormatter.Space();

2669

}

2670

TrackVisit(checkedExpression.Expression, data);

2671

if (this.prettyPrintOptions.WithinCheckedExpressionParantheses) {

2672

outputFormatter.Space();

2673

}

2674

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2675

return null;

2676

}

2677

2678

public override object TrackedVisitUncheckedExpression(UncheckedExpression uncheckedExpression, object data)

2679

{

2680

outputFormatter.PrintToken(Tokens.Unchecked);

2681

if (prettyPrintOptions.UncheckedParentheses) {

2682

outputFormatter.Space();

2683

}

2684

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2685

if (this.prettyPrintOptions.WithinCheckedExpressionParantheses) {

2686

outputFormatter.Space();

2687

}

2688

TrackVisit(uncheckedExpression.Expression, data);

2689

if (this.prettyPrintOptions.WithinCheckedExpressionParantheses) {

2690

outputFormatter.Space();

2691

}

2692

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2693

return null;

2694

}

2695

2696

public override object TrackedVisitPointerReferenceExpression(PointerReferenceExpression pointerReferenceExpression, object data)

2697

{

2698

Expression target = pointerReferenceExpression.TargetObject;

2699

2700

if (target is BinaryOperatorExpression || target is CastExpression) {

2701

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2702

}

2703

TrackVisit(target, data);

2704

if (target is BinaryOperatorExpression || target is CastExpression) {

2705

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2706

}

2707

outputFormatter.PrintToken(Tokens.Pointer);

2708

outputFormatter.PrintIdentifier(pointerReferenceExpression.MemberName);

2709

PrintTypeArgumentList(pointerReferenceExpression.TypeArguments);

2710

2711

return null;

2712

}

2713

2714

public override object TrackedVisitCastExpression(CastExpression castExpression, object data)

2715

{

2716

if (castExpression.CastType == CastType.TryCast) {

2717

TrackVisit(castExpression.Expression, data);

2718

outputFormatter.Space();

2719

outputFormatter.PrintToken(Tokens.As);

2720

outputFormatter.Space();

2721

TrackVisit(castExpression.CastTo, data);

2722

} else {

2723

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2724

if (prettyPrintOptions.WithinCastParentheses) {

2725

outputFormatter.Space();

2726

}

2727

TrackVisit(castExpression.CastTo, data);

2728

if (prettyPrintOptions.WithinCastParentheses) {

2729

outputFormatter.Space();

2730

}

2731

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2732

if (this.prettyPrintOptions.SpacesAfterTypecast) {

2733

outputFormatter.Space();

2734

}

2735

TrackVisit(castExpression.Expression, data);

2736

}

2737

return null;

2738

}

2739

2740

public override object TrackedVisitStackAllocExpression(StackAllocExpression stackAllocExpression, object data)

2741

{

2742

outputFormatter.PrintToken(Tokens.Stackalloc);

2743

outputFormatter.Space();

2744

TrackVisit(stackAllocExpression.TypeReference, data);

2745

outputFormatter.PrintToken(Tokens.OpenSquareBracket);

2746

if (this.prettyPrintOptions.SpacesWithinBrackets) {

2747

outputFormatter.Space();

2748

}

2749

TrackVisit(stackAllocExpression.Expression, data);

2750

if (this.prettyPrintOptions.SpacesWithinBrackets) {

2751

outputFormatter.Space();

2752

}

2753

outputFormatter.PrintToken(Tokens.CloseSquareBracket);

2754

return null;

2755

}

2756

2757

public override object TrackedVisitIndexerExpression(IndexerExpression indexerExpression, object data)

2758

{

2759

TrackVisit(indexerExpression.TargetObject, data);

2760

outputFormatter.PrintToken(Tokens.OpenSquareBracket);

2761

if (this.prettyPrintOptions.SpacesWithinBrackets) {

2762

outputFormatter.Space();

2763

}

2764

AppendCommaSeparatedList(indexerExpression.Indexes);

2765

if (this.prettyPrintOptions.SpacesWithinBrackets) {

2766

outputFormatter.Space();

2767

}

2768

outputFormatter.PrintToken(Tokens.CloseSquareBracket);

2769

return null;

2770

}

2771

2772

public override object TrackedVisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)

2773

{

2774

outputFormatter.PrintToken(Tokens.This);

2775

return null;

2776

}

2777

2778

public override object TrackedVisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {

2779

outputFormatter.PrintToken(Tokens.Base);

2780

return null;

2781

}

2782

2783

public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)

2784

{

2785

outputFormatter.PrintToken(Tokens.New);

2786

if (!objectCreateExpression.CreateType.IsNull) {

2787

outputFormatter.Space();

2788

TrackVisit(objectCreateExpression.CreateType, data);

2789

}

2790

if (objectCreateExpression.Parameters.Count > 0 || objectCreateExpression.ObjectInitializer.IsNull) {

2791

if (prettyPrintOptions.NewParentheses) {

2792

outputFormatter.Space();

2793

}

2794

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2795

if (this.prettyPrintOptions.WithinMethodCallParentheses) {

2796

outputFormatter.Space();

2797

}

2798

AppendCommaSeparatedList(objectCreateExpression.Parameters);

2799

if (this.prettyPrintOptions.WithinMethodCallParentheses) {

2800

outputFormatter.Space();

2801

}

2802

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2803

}

2804

if (!objectCreateExpression.ObjectInitializer.IsNull) {

2805

outputFormatter.Space();

2806

TrackVisit(objectCreateExpression.ObjectInitializer, data);

2807

}

2808

return null;

2809

}

2810

2811

public override object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)

2812

{

2813

outputFormatter.PrintToken(Tokens.New);

2814

if (arrayCreateExpression.IsImplicitlyTyped) {

2815

outputFormatter.PrintToken(Tokens.OpenSquareBracket);

2816

outputFormatter.PrintToken(Tokens.CloseSquareBracket);

2817

} else {

2818

outputFormatter.Space();

2819

PrintTypeReferenceWithoutArray(arrayCreateExpression.CreateType);

2820

2821

if (arrayCreateExpression.Arguments.Count > 0) {

2822

outputFormatter.PrintToken(Tokens.OpenSquareBracket);

2823

bool outputSpace = this.prettyPrintOptions.SpacesWithinBrackets && arrayCreateExpression.Arguments.Count > 0;

2824

if (outputSpace) {

2825

outputFormatter.Space();

2826

}

2827

for (int i = 0; i < arrayCreateExpression.Arguments.Count; ++i) {

2828

if (i > 0) PrintFormattedComma();

2829

TrackVisit(arrayCreateExpression.Arguments[i], data);

2830

}

2831

if (outputSpace) {

2832

outputFormatter.Space();

2833

}

2834

outputFormatter.PrintToken(Tokens.CloseSquareBracket);

2835

PrintArrayRank(arrayCreateExpression.CreateType.RankSpecifier, 1);

2836

} else {

2837

PrintArrayRank(arrayCreateExpression.CreateType.RankSpecifier, 0);

2838

}

2839

}

2840

2841

if (!arrayCreateExpression.ArrayInitializer.IsNull) {

2842

outputFormatter.Space();

2843

TrackVisit(arrayCreateExpression.ArrayInitializer, data);

2844

}

2845

return null;

2846

}

2847

2848

public override object TrackedVisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)

2849

{

2850

Expression target = memberReferenceExpression.TargetObject;

2851

2852

if (target is BinaryOperatorExpression || target is CastExpression) {

2853

outputFormatter.PrintToken(Tokens.OpenParenthesis);

2854

if (this.prettyPrintOptions.WithinMethodCallParentheses) {

2855

outputFormatter.Space();

2856

}

2857

}

2858

TrackVisit(target, data);

2859

if (target is BinaryOperatorExpression || target is CastExpression) {

2860

if (this.prettyPrintOptions.WithinMethodCallParentheses) {

2861

outputFormatter.Space();

2862

}

2863

outputFormatter.PrintToken(Tokens.CloseParenthesis);

2864

}

2865

outputFormatter.PrintToken(Tokens.Dot);

2866

outputFormatter.PrintIdentifier(memberReferenceExpression.MemberName);

2867

PrintTypeArgumentList(memberReferenceExpression.TypeArguments);

2868

return null;

2869

}

2870

2871

public override object TrackedVisitDirectionExpression(DirectionExpression directionExpression, object data)

2872

{

2873

switch (directionExpression.FieldDirection) {

2874

case FieldDirection.Out:

2875

outputFormatter.PrintToken(Tokens.Out);

2876

outputFormatter.Space();

2877

break;

2878

case FieldDirection.Ref:

2879

outputFormatter.PrintToken(Tokens.Ref);

2880

outputFormatter.Space();

2881

break;

2882

}

2883

TrackVisit(directionExpression.Expression, data);

2884

return null;

2885

}

2886

2887

public override object TrackedVisitCollectionInitializerExpression(CollectionInitializerExpression arrayInitializerExpression, object data)

2888

{

2889

outputFormatter.PrintToken (Tokens.OpenCurlyBrace);

2890

if (arrayInitializerExpression.CreateExpressions.Count == 1) {

2891

outputFormatter.Space ();

2892

} else {

2893

if (this.prettyPrintOptions.PlaceArrayInitializersOnNewLine == ArrayInitializerPlacement.AlwaysNewLine) {

2894

outputFormatter.IndentationLevel++;

2895

outputFormatter.NewLine ();

2896

outputFormatter.Indent ();

2897

} else {

2898

outputFormatter.Space ();

2899

}

2900

}

2901

this.AppendCommaSeparatedList (arrayInitializerExpression.CreateExpressions, this.prettyPrintOptions.PlaceArrayInitializersOnNewLine == ArrayInitializerPlacement.AlwaysNewLine);

2902

if (arrayInitializerExpression.CreateExpressions.Count == 1) {

2903

outputFormatter.Space ();

2904

} else {

2905

if (this.prettyPrintOptions.PlaceArrayInitializersOnNewLine == ArrayInitializerPlacement.AlwaysNewLine) {

2906

outputFormatter.IndentationLevel--;

2907

outputFormatter.NewLine();

2908

outputFormatter.Indent();

2909

} else {

2910

outputFormatter.Space();

2911

}

2912

}

2913

outputFormatter.PrintToken(Tokens.CloseCurlyBrace);

2914

return null;

2915

}

2916

2917

public override object TrackedVisitConditionalExpression(ConditionalExpression conditionalExpression, object data)

2918

{

2919

TrackVisit(conditionalExpression.Condition, data);

2920

if (this.prettyPrintOptions.ConditionalOperatorBeforeConditionSpace) {

2921

outputFormatter.Space();

2922

}

2923

outputFormatter.PrintToken(Tokens.Question);

2924

if (this.prettyPrintOptions.ConditionalOperatorAfterConditionSpace) {

2925

outputFormatter.Space();

2926

}

2927

TrackVisit(conditionalExpression.TrueExpression, data);

2928

if (this.prettyPrintOptions.ConditionalOperatorBeforeSeparatorSpace) {

2929

outputFormatter.Space();

2930

}

2931

outputFormatter.PrintToken(Tokens.Colon);

2932

if (this.prettyPrintOptions.ConditionalOperatorAfterSeparatorSpace) {

2933

outputFormatter.Space();

2934

}

2935

TrackVisit(conditionalExpression.FalseExpression, data);

2936

return null;

2937

}

2938

2939

#endregion

2940

#endregion

2941

2942

void OutputModifier(ParameterModifiers modifier, INode node)

2943

{

2944

if ((modifier & ParameterModifiers.Ref) == ParameterModifiers.Ref) {

2945

outputFormatter.PrintToken(Tokens.Ref);

2946

outputFormatter.Space();

2947

} else if ((modifier & ParameterModifiers.Out) == ParameterModifiers.Out) {

2948

outputFormatter.PrintToken(Tokens.Out);

2949

outputFormatter.Space();

2950

}

2951

if ((modifier & ParameterModifiers.Params) == ParameterModifiers.Params) {

2952

outputFormatter.PrintToken(Tokens.Params);

2953

outputFormatter.Space();

2954

}

2955

if ((modifier & ParameterModifiers.Optional) == ParameterModifiers.Optional) {

2956

Error(node, String.Format("Optional parameters aren't supported in C#"));

2957

}

2958

}

2959

2960

void OutputModifier(Modifiers modifier)

2961

{

2962

ArrayList tokenList = new ArrayList();

2963

if ((modifier & Modifiers.Unsafe) != 0) {

2964

tokenList.Add(Tokens.Unsafe);

2965

}

2966

if ((modifier & Modifiers.Public) != 0) {

2967

tokenList.Add(Tokens.Public);

2968

}

2969

if ((modifier & Modifiers.Private) != 0) {

2970

tokenList.Add(Tokens.Private);

2971

}

2972

if ((modifier & Modifiers.Protected) != 0) {

2973

tokenList.Add(Tokens.Protected);

2974

}

2975

if ((modifier & Modifiers.Static) != 0) {

2976

tokenList.Add(Tokens.Static);

2977

}

2978

if ((modifier & Modifiers.Internal) != 0) {

2979

tokenList.Add(Tokens.Internal);

2980

}

2981

if ((modifier & Modifiers.Override) != 0) {

2982

tokenList.Add(Tokens.Override);

2983

}

2984

if ((modifier & Modifiers.Abstract) != 0) {

2985

tokenList.Add(Tokens.Abstract);

2986

}

2987

if ((modifier & Modifiers.Virtual) != 0) {

2988

tokenList.Add(Tokens.Virtual);

2989

}

2990

if ((modifier & Modifiers.New) != 0) {

2991

tokenList.Add(Tokens.New);

2992

}

2993

if ((modifier & Modifiers.Sealed) != 0) {

2994

tokenList.Add(Tokens.Sealed);

2995

}

2996

if ((modifier & Modifiers.Extern) != 0) {

2997

tokenList.Add(Tokens.Extern);

2998

}

2999

if ((modifier & Modifiers.Const) != 0) {

3000

tokenList.Add(Tokens.Const);

3001

}

3002

if ((modifier & Modifiers.ReadOnly) != 0) {

3003

tokenList.Add(Tokens.Readonly);

3004

}

3005

if ((modifier & Modifiers.Volatile) != 0) {

3006

tokenList.Add(Tokens.Volatile);

3007

}

3008

if ((modifier & Modifiers.Fixed) != 0) {

3009

tokenList.Add(Tokens.Fixed);

3010

}

3011

outputFormatter.PrintTokenList(tokenList);

3012

3013

if ((modifier & Modifiers.Partial) != 0) {

3014

outputFormatter.PrintText("partial ");

3015

}

3016

}

3017

3018

object TrackVisit(INode node, object data)

3019

{

3020

return node.AcceptVisitor(this, data);

3021

}

3022

3023

/// <summary>

3024

/// Resets the output formatter, sets Text to string.Empty.

3025

/// </summary>

3026

public void Reset ()

3027

{

3028

outputFormatter.Reset ();

3029

}

3030

3031

public void AppendCommaSeparatedList<T>(ICollection<T> list) where T : class, INode

3032

{

3033

AppendCommaSeparatedList(list, false);

3034

}

3035

3036

public void AppendCommaSeparatedList<T>(ICollection<T> list, bool alwaysBreakLine) where T : class, INode

3037

{

3038

if (list != null) {

3039

int i = 0;

3040

foreach (T node in list) {

3041

node.AcceptVisitor(this, null);

3042

if (i + 1 < list.Count) {

3043

if (alwaysBreakLine || (i + 1) % 10 == 0) {

3044

PrintFormattedCommaAndNewLine();

3045

} else {

3046

PrintFormattedComma();

3047

}

3048

}

3049

i++;

3050

}

3051

}

3052

}

3053

3054

public override object TrackedVisitQueryExpression(QueryExpression queryExpression, object data)

3055

{

3056

if (queryExpression.IsQueryContinuation) {

3057

queryExpression.FromClause.InExpression.AcceptVisitor(this, data);

3058

}

3059

outputFormatter.IndentationLevel++;

3060

if (queryExpression.IsQueryContinuation) {

3061

outputFormatter.Space();

3062

outputFormatter.PrintToken(Tokens.Into);

3063

outputFormatter.Space();

3064

outputFormatter.PrintIdentifier(queryExpression.FromClause.Identifier);

3065

} else {

3066

queryExpression.FromClause.AcceptVisitor(this, data);

3067

}

3068

queryExpression.MiddleClauses.ForEach(PrintClause);

3069

PrintClause(queryExpression.SelectOrGroupClause);

3070

outputFormatter.IndentationLevel--;

3071

return null;

3072

}

3073

3074

void PrintClause(QueryExpressionClause clause)

3075

{

3076

if (!clause.IsNull) {

3077

outputFormatter.NewLine();

3078

outputFormatter.Indent();

3079

clause.AcceptVisitor(this, null);

3080

}

3081

}

3082

3083

public override object TrackedVisitQueryExpressionFromClause(QueryExpressionFromClause fromClause, object data)

3084

{

3085

outputFormatter.PrintToken(Tokens.From);

3086

outputFormatter.Space();

3087

VisitQueryExpressionFromOrJoinClause(fromClause, data);

3088

return null;

3089

}

3090

3091

public override object TrackedVisitQueryExpressionJoinClause(QueryExpressionJoinClause joinClause, object data)

3092

{

3093

outputFormatter.PrintToken(Tokens.Join);

3094

outputFormatter.Space();

3095

VisitQueryExpressionFromOrJoinClause(joinClause, data);

3096

outputFormatter.Space();

3097

outputFormatter.PrintToken(Tokens.On);

3098

outputFormatter.Space();

3099

joinClause.OnExpression.AcceptVisitor(this, data);

3100

outputFormatter.Space();

3101

outputFormatter.PrintToken(Tokens.Equals);

3102

outputFormatter.Space();

3103

joinClause.EqualsExpression.AcceptVisitor(this, data);

3104

if (!string.IsNullOrEmpty(joinClause.IntoIdentifier)) {

3105

outputFormatter.Space();

3106

outputFormatter.PrintToken(Tokens.Into);

3107

outputFormatter.Space();

3108

outputFormatter.PrintIdentifier(joinClause.IntoIdentifier);

3109

}

3110

return null;

3111

}

3112

3113

void VisitQueryExpressionFromOrJoinClause(QueryExpressionFromOrJoinClause clause, object data)

3114

{

3115

outputFormatter.PrintIdentifier(clause.Identifier);

3116

outputFormatter.Space();

3117

outputFormatter.PrintToken(Tokens.In);

3118

outputFormatter.Space();

3119

clause.InExpression.AcceptVisitor(this, data);

3120

}

3121

3122

public override object TrackedVisitQueryExpressionLetClause(QueryExpressionLetClause letClause, object data)

3123

{

3124

outputFormatter.PrintToken(Tokens.Let);

3125

outputFormatter.Space();

3126

outputFormatter.PrintIdentifier(letClause.Identifier);

3127

if (this.prettyPrintOptions.AroundAssignmentParentheses) {

3128

outputFormatter.Space();

3129

}

3130

outputFormatter.PrintToken(Tokens.Assign);

3131

if (this.prettyPrintOptions.AroundAssignmentParentheses) {

3132

outputFormatter.Space();

3133

}

3134

var result = letClause.Expression.AcceptVisitor(this, data);

3135

outputFormatter.Space();

3136

return result;

3137

}

3138

3139

public override object TrackedVisitQueryExpressionGroupClause(QueryExpressionGroupClause groupClause, object data)

3140

{

3141

outputFormatter.PrintToken(Tokens.Group);

3142

outputFormatter.Space();

3143

groupClause.Projection.AcceptVisitor(this, data);

3144

outputFormatter.Space();

3145

outputFormatter.PrintToken(Tokens.By);

3146

outputFormatter.Space();

3147

return groupClause.GroupBy.AcceptVisitor(this, data);

3148

}

3149

3150

public override object TrackedVisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data)

3151

{

3152

outputFormatter.PrintToken(Tokens.Orderby);

3153

outputFormatter.Space();

3154

AppendCommaSeparatedList(queryExpressionOrderClause.Orderings);

3155

return null;

3156

}

3157

3158

public override object TrackedVisitQueryExpressionOrdering(QueryExpressionOrdering ordering, object data)

3159

{

3160

ordering.Criteria.AcceptVisitor(this, data);

3161

if (ordering.Direction == QueryExpressionOrderingDirection.Ascending) {

3162

outputFormatter.Space();

3163

outputFormatter.PrintToken(Tokens.Ascending);

3164

} else if (ordering.Direction == QueryExpressionOrderingDirection.Descending) {

3165

outputFormatter.Space();

3166

outputFormatter.PrintToken(Tokens.Descending);

3167

}

3168

return null;

3169

}

3170

3171

public override object TrackedVisitQueryExpressionSelectClause(QueryExpressionSelectClause selectClause, object data)

3172

{

3173

outputFormatter.PrintToken(Tokens.Select);

3174

outputFormatter.Space();

3175

return selectClause.Projection.AcceptVisitor(this, data);

3176

}

3177

3178

public override object TrackedVisitQueryExpressionWhereClause(QueryExpressionWhereClause whereClause, object data)

3179

{

3180

outputFormatter.PrintToken(Tokens.Where);

3181

outputFormatter.Space();

3182

return whereClause.Condition.AcceptVisitor(this, data);

3183

}

3184

}

3185

}

Older »