using System;
using System.Text.RegularExpressions;

class RegexSubtract {
  public static void Main()
  {
    var regex1 = new Regex("[a-z]+");
    var regex2 = new Regex("[a-z-[d-w]]+");
    var regex3 = new Regex("[a-z-[d-w-[m-o]]]+");
    var text = "abcdefghijklmnopqrstuvwxyz";

    Console.WriteLine(Environment.OSVersion);
    Console.WriteLine(Environment.Version);

    Console.WriteLine("regex1");
    foreach (Match m in regex1.Matches(text)) {
      Console.WriteLine(m.Value);
    }

    Console.WriteLine("regex2");
    foreach (Match m in regex2.Matches(text)) {
      Console.WriteLine(m.Value);
    }

    Console.WriteLine("regex3");
    foreach (Match m in regex3.Matches(text)) {
      Console.WriteLine(m.Value);
    }
  }
}

Microsoft Windows NT 5.1.2600 Service Pack 3
2.0.50727.3082
regex1
abcdefghijklmnopqrstuvwxyz
regex2
abc
xyz
regex3
abc
mno
xyz

Unix 2.6.28.11
2.0.50727.1433
regex1
abcdefghijklmnopqrstuvwxyz
regex2
regex3

Index: mcs/class/System/System.Text.RegularExpressions/syntax.cs
===================================================================
--- mcs/class/System/System.Text.RegularExpressions/syntax.cs	(revision 133993)
+++ mcs/class/System/System.Text.RegularExpressions/syntax.cs	(working copy)
@@ -871,6 +871,12 @@
 			intervals.Add (new_interval);
 		}
 
+		public void Exclude(CharacterClass excluded)
+		{
+			throw new NotImplementedException ("Character class subtraction is not implemented");
+			// TODO: exclude categories and characters
+		}
+
 		public override void Compile (ICompiler cmp, bool reverse) {
 			// create the meta-collection
 			IntervalCollection meta =
Index: mcs/class/System/System.Text.RegularExpressions/parser.cs
===================================================================
--- mcs/class/System/System.Text.RegularExpressions/parser.cs	(revision 133993)
+++ mcs/class/System/System.Text.RegularExpressions/parser.cs	(working copy)
@@ -651,7 +651,9 @@
 			int c = -1;
 			int last = -1;
 			bool range = false;
+			bool exclude = false;
 			bool closed = false;
+			CharacterClass clsExcluded = null;
 			while (ptr < pattern.Length) {
 				c = pattern[ptr ++];
 
@@ -660,8 +662,17 @@
 					break;
 				}
 
-				if (c == '-' && last >= 0 && !range) {
-					range = true;
+				if (c == '-') {
+					if (last >= 0 && !range) {
+						range = true;
+					}
+					else if (!exclude) {
+						if (pattern[ptr ++] != '[')
+							throw NewParseException ("Malformed character class subtraction.");
+						range = false;
+						exclude = true;
+						clsExcluded = (CharacterClass)ParseCharacterClass (options);
+					}
 					continue;
 				}
 
@@ -723,7 +734,9 @@
 			if (!closed)
 				throw NewParseException ("Unterminated [] set.");
 
-			if (range)
+			if (exclude)
+				cls.Exclude(clsExcluded);
+			else if (range)
 				cls.AddCharacter ('-');
 
 			return cls;

using System;

static class PpElifTest {
  public static void Main()
  {
#if DEBUG
    Console.WriteLine("if");
#elif
    Console.WriteLine("elif");
#else
    Console.WriteLine("else");
#endif

#if DEBUG
    Console.WriteLine("if");
#elif *invalid-symbol*
    Console.WriteLine("elif");
#else
    Console.WriteLine("else");
#endif
  }
}

D:\test\pp-elif>csc pp-elif.cs /define:DEBUG
Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.

pp-elif.cs(8,6): error CS1517: 無効なプリプロセッサの式です。
pp-elif.cs(16,7): error CS1517: 無効なプリプロセッサの式です。

D:\test\pp-elif>csc pp-elif.cs
Microsoft (R) Visual C# 2008 Compiler version 3.5.30729.1
for Microsoft (R) .NET Framework version 3.5
Copyright (C) Microsoft Corporation. All rights reserved.

pp-elif.cs(8,6): error CS1517: 無効なプリプロセッサの式です。
pp-elif.cs(16,7): error CS1517: 無効なプリプロセッサの式です。

$ gmcs pp-elif.cs -define:DEBUG && mono pp-elif.exe 
if
if

$ gmcs pp-elif.cs && mono pp-elif.exe 
pp-elif.cs(9,0): error CS1517: Invalid preprocessor directive
pp-elif.cs(17,0): error CS1517: Invalid preprocessor directive
pp-elif.cs(17,0): error CS1025: Single-line comment or end-of-line expected
Compilation failed: 3 error(s), 0 warnings

using System;
using System.IO;
using System.Security.Cryptography;

class ExpandTransform : ICryptoTransform {
  public bool CanReuseTransform {
    get { return true; }
  }

  public bool CanTransformMultipleBlocks {
    get; private set;
  }

  public int InputBlockSize {
    get { return 1; }
  }

  public int OutputBlockSize {
    get; private set;
  }

  public ExpandTransform(bool canTranformMultipleBlocks, int outputBlockSize)
  {
    this.CanTransformMultipleBlocks = canTranformMultipleBlocks;
    this.OutputBlockSize = outputBlockSize;
  }

  public void Dispose()
  {
  }

  public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
  {
    var ret = 0;

    for (var i = 0; i < inputCount; i++, inputOffset++) {
      for (var j = 0; j < OutputBlockSize; j++, outputOffset++, ret++) {
        outputBuffer[outputOffset] = inputBuffer[inputOffset];
      }
    }

    return ret;
  }

  public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
  {
    var outputBuffer = new byte[inputCount * OutputBlockSize];

    TransformBlock(inputBuffer, inputOffset, inputCount, outputBuffer, 0);

    return outputBuffer;
  }
}

class CryptoStreamTest
{
  public static void Main(string[] args)
  {
    Console.WriteLine(Environment.OSVersion);
    Console.WriteLine(Environment.Version);

    foreach (var transformMultiple in new[] {false, true}) {
      foreach (var outputBlockSize in new[] {1, 2, 3, 4}) {
        Console.WriteLine("TransformMultiple: {0}, OutputBlockSize: {1}", transformMultiple, outputBlockSize);

        var expantedStream = new MemoryStream();
        var inputData = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07};

        try {
          using (var stream = new CryptoStream(expantedStream, new ExpandTransform(transformMultiple, outputBlockSize), CryptoStreamMode.Write)) {
            stream.Write(inputData, 0, inputData.Length);
          }

          expantedStream.Close();

          Console.WriteLine(BitConverter.ToString(expantedStream.ToArray()));
        }
        catch (Exception ex) {
          Console.WriteLine(ex);
        }

        Console.WriteLine();
      }
    }
  }
}

Microsoft Windows NT 5.1.2600 Service Pack 3
2.0.50727.3082
TransformMultiple: False, OutputBlockSize: 1
00-01-02-03-04-05-06-07

TransformMultiple: False, OutputBlockSize: 2
00-00-01-01-02-02-03-03-04-04-05-05-06-06-07-07

TransformMultiple: False, OutputBlockSize: 3
00-00-00-01-01-01-02-02-02-03-03-03-04-04-04-05-05-05-06-06-06-07-07-07

TransformMultiple: False, OutputBlockSize: 4
00-00-00-00-01-01-01-01-02-02-02-02-03-03-03-03-04-04-04-04-05-05-05-05-06-06-06-06-07-07-07-07

TransformMultiple: True, OutputBlockSize: 1
00-01-02-03-04-05-06-07

TransformMultiple: True, OutputBlockSize: 2
00-00-01-01-02-02-03-03-04-04-05-05-06-06-07-07

TransformMultiple: True, OutputBlockSize: 3
00-00-00-01-01-01-02-02-02-03-03-03-04-04-04-05-05-05-06-06-06-07-07-07

TransformMultiple: True, OutputBlockSize: 4
00-00-00-00-01-01-01-01-02-02-02-02-03-03-03-03-04-04-04-04-05-05-05-05-06-06-06-06-07-07-07-07

Unix 2.6.28.15
2.0.50727.1433
TransformMultiple: False, OutputBlockSize: 1
00-01-02-03-04-05-06-07

TransformMultiple: False, OutputBlockSize: 2
00-00-01-01-02-02-03-03-04-04-05-05-06-06-07-07

TransformMultiple: False, OutputBlockSize: 3
00-00-00-01-01-01-02-02-02-03-03-03-04-04-04-05-05-05-06-06-06-07-07-07

TransformMultiple: False, OutputBlockSize: 4
00-00-00-00-01-01-01-01-02-02-02-02-03-03-03-03-04-04-04-04-05-05-05-05-06-06-06-06-07-07-07-07

TransformMultiple: True, OutputBlockSize: 1
00-01-02-03-04-05-06-07

TransformMultiple: True, OutputBlockSize: 2
System.IndexOutOfRangeException: Array index is out of range.
  at ExpandTransform.TransformBlock (System.Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount, System.Byte[] outputBuffer, Int32 outputOffset) [0x00010] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:38 
  at System.Security.Cryptography.CryptoStream.Write (System.Byte[] buffer, Int32 offset, Int32 count) [0x001be] in /srv/shared/build/mono-classes/corlib/System.Security.Cryptography/CryptoStream.cs:297 
  at CryptoStreamTest.Main (System.String[] args) [0x0008c] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:71 

TransformMultiple: True, OutputBlockSize: 3
System.IndexOutOfRangeException: Array index is out of range.
  at ExpandTransform.TransformBlock (System.Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount, System.Byte[] outputBuffer, Int32 outputOffset) [0x00010] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:38 
  at System.Security.Cryptography.CryptoStream.Write (System.Byte[] buffer, Int32 offset, Int32 count) [0x001be] in /srv/shared/build/mono-classes/corlib/System.Security.Cryptography/CryptoStream.cs:297 
  at CryptoStreamTest.Main (System.String[] args) [0x0008c] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:71 

TransformMultiple: True, OutputBlockSize: 4
System.IndexOutOfRangeException: Array index is out of range.
  at ExpandTransform.TransformBlock (System.Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount, System.Byte[] outputBuffer, Int32 outputOffset) [0x00010] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:38 
  at System.Security.Cryptography.CryptoStream.Write (System.Byte[] buffer, Int32 offset, Int32 count) [0x001be] in /srv/shared/build/mono-classes/corlib/System.Security.Cryptography/CryptoStream.cs:297 
  at CryptoStreamTest.Main (System.String[] args) [0x0008c] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:71 

Index: System.Security.Cryptography/CryptoStream.cs
===================================================================
--- System.Security.Cryptography/CryptoStream.cs	(revision 139809)
+++ System.Security.Cryptography/CryptoStream.cs	(working copy)
@@ -72,11 +72,14 @@
 			_mode = mode;
 			_disposed = false;
 			if (transform != null) {
-				_workingBlock = new byte [transform.InputBlockSize];
-				if (mode == CryptoStreamMode.Read)
+				if (mode == CryptoStreamMode.Read) {
 					_currentBlock = new byte [transform.InputBlockSize];
-				else if (mode == CryptoStreamMode.Write)
+					_workingBlock = new byte [transform.InputBlockSize];
+				}
+				else if (mode == CryptoStreamMode.Write) {
 					_currentBlock = new byte [transform.OutputBlockSize];
+					_workingBlock = new byte [transform.OutputBlockSize];
+				}
 			}
 		}
 
@@ -285,14 +288,14 @@
 
 				if (_transform.CanTransformMultipleBlocks) {
 					// get the biggest multiple of InputBlockSize in count (without mul or div)
-					int size = (count & ~(_transform.OutputBlockSize - 1));
-					int rem = (count & (_transform.OutputBlockSize - 1));
+					int size = (count & ~(_transform.InputBlockSize - 1));
+					int rem = (count & (_transform.InputBlockSize - 1));
 					// avoid reallocating memory at each call (reuse same buffer whenever possible)
-					if (_workingBlock.Length < size) {
+					int sizeWorkingBlock = (1 + size / _transform.InputBlockSize) * _transform.OutputBlockSize;
+					if (_workingBlock.Length < sizeWorkingBlock) {
 						Array.Clear (_workingBlock, 0, _workingBlock.Length);
-						_workingBlock = new byte [size];
+						_workingBlock = new byte [sizeWorkingBlock];
 					}
-
 					if (size > 0) {
 						int len = _transform.TransformBlock (buffer, offset, size, _workingBlock, 0);
 						_stream.Write (_workingBlock, 0, len);

using System;
using System.IO;
using System.Security.Cryptography;

class CompressTransform : ICryptoTransform {
  public bool CanReuseTransform {
    get { return true; }
  }

  public bool CanTransformMultipleBlocks {
    get { return true; }
  }

  public int InputBlockSize {
    get; private set;
  }

  public int OutputBlockSize {
    get { return 1; }
  }

  public CompressTransform(int inputBlockSize)
  {
    this.InputBlockSize = inputBlockSize;
  }

  public void Dispose()
  {
  }

  private int bufferedCount = 0;

  public int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset)
  {
    var ret = 0;

    for (var i = 0; i < inputCount; i++, inputOffset++) {
      if (++bufferedCount == InputBlockSize) {
        outputBuffer[outputOffset++] = inputBuffer[inputOffset];
        ret++;
        bufferedCount = 0;
      }
    }

    return ret;
  }

  public byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount)
  {
    var outputBuffer = new byte[inputCount * OutputBlockSize];
    var ret = TransformBlock(inputBuffer, inputOffset, inputCount, outputBuffer, 0);

    Array.Resize(ref outputBuffer, ret);

    return outputBuffer;
  }
}

class CryptoStreamTest
{
  public static void Main(string[] args)
  {
    Console.WriteLine(Environment.OSVersion);
    Console.WriteLine(Environment.Version);

    foreach (var inputBlockSize in new[] {1, 2, 3, 4}) {
      Console.WriteLine("InputBlockSize: {0}", inputBlockSize);

      var inputData = new byte[] {
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
      };

      try {
        using (var stream = new CryptoStream(new MemoryStream(inputData), new CompressTransform(inputBlockSize), CryptoStreamMode.Read)) {
          var buffer = new byte[inputData.Length];

          var ret = stream.Read(buffer, 0, buffer.Length);

          Console.WriteLine(BitConverter.ToString(buffer, 0, ret));
        }
      }
      catch (Exception ex) {
        Console.WriteLine(ex);
      }

      Console.WriteLine();
    }
  }
}

Microsoft Windows NT 5.1.2600 Service Pack 3
2.0.50727.3082
InputBlockSize: 1
00-01-02-03-04-05-06-07-08-09-0A-0B-0C-0D-0E-0F-10-11-12-13-14-15-16-17-18-19-1A-1B-1C-1D-1E-1F

InputBlockSize: 2
01-03-05-07-09-0B-0D-0F-11-13-15-17-19-1B-1D-1F

InputBlockSize: 3
02-05-08-0B-0E-11-14-17-1A-1D

InputBlockSize: 4
03-07-0B-0F-13-17-1B-1F

Unix 2.6.28.15
2.0.50727.1433
InputBlockSize: 1
00-01-02-03-04-05-06-07-08-09-0A-0B-0C-0D-0E-0F-10-11-12-13-14-15-16-17-18-19-1A-1B-1C-1D-1E-1F

InputBlockSize: 2
01-03-05-07-09-0B-0D-0F-11-13-15-17-19-1B-1D-1F

InputBlockSize: 3
System.IndexOutOfRangeException: Array index is out of range.
  at CompressTransform.TransformBlock (System.Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount, System.Byte[] outputBuffer, Int32 outputOffset) [0x00025] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:39 
  at System.Security.Cryptography.CryptoStream.Read (System.Byte[] buffer, Int32 offset, Int32 count) [0x0017a] in /srv/shared/build/mono-classes/corlib/System.Security.Cryptography/CryptoStream.cs:183 
  at CryptoStreamTest.Main (System.String[] args) [0x00072] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:80 

InputBlockSize: 4
System.IndexOutOfRangeException: Array index is out of range.
  at CompressTransform.TransformBlock (System.Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount, System.Byte[] outputBuffer, Int32 outputOffset) [0x00025] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:39 
  at System.Security.Cryptography.CryptoStream.Read (System.Byte[] buffer, Int32 offset, Int32 count) [0x0017a] in /srv/shared/build/mono-classes/corlib/System.Security.Cryptography/CryptoStream.cs:183 
  at CryptoStreamTest.Main (System.String[] args) [0x00072] in /srv/shared/work/CryptoStreamTest/CryptoStreamTest/CryptoStreamTest.cs:80 

Index: System.Security.Cryptography/CryptoStream.cs
===================================================================
--- System.Security.Cryptography/CryptoStream.cs	(revision 139809)
+++ System.Security.Cryptography/CryptoStream.cs	(working copy)
@@ -212,7 +215,7 @@
 					_transformedCount += transformed;
 				}
 				// compaction
-				if (_transformedPos > _transform.InputBlockSize) {
+				if (_transformedPos > _transform.OutputBlockSize) {
 					Buffer.BlockCopy (_transformedBlock, _transformedPos, _transformedBlock, 0, length);
 					_transformedCount -= _transformedPos;
 					_transformedPos = 0;

using System;

namespace DateTimeOffsetTest {
  class MainClass
  {
    public static void Main(string[] args)
    {
      Console.WriteLine(Environment.OSVersion);
      Console.WriteLine(Environment.Version);
      Console.WriteLine();

      foreach (var dtm in new[] {
        "13/Oct/2009:22:35:35 +09:00",
        "13/Oct/2009:22:35:35 +0900",
        "13/Oct/2009:22:35:35 +09:30",
        "13/Oct/2009:22:35:35 +0930",
      }) {
        try {
          Console.Write("{0} => ", dtm);
          Console.WriteLine(DateTimeOffset.ParseExact(dtm, "d/MMM/yyyy:HH:mm:ss zzz", System.Globalization.CultureInfo.InvariantCulture));
        }
        catch (FormatException ex) {
          Console.WriteLine(ex);
        }
      }
    }
  }
}

Microsoft Windows NT 5.1.2600 Service Pack 3
2.0.50727.3082

13/Oct/2009:22:35:35 +09:00 => 2009/10/13 22:35:35 +09:00
13/Oct/2009:22:35:35 +0900 => 2009/10/13 22:35:35 +09:00
13/Oct/2009:22:35:35 +09:30 => 2009/10/13 22:35:35 +09:30
13/Oct/2009:22:35:35 +0930 => 2009/10/13 22:35:35 +09:30

Unix 2.6.28.15
2.0.50727.1433

13/Oct/2009:22:35:35 +09:00 => 2009/10/13 22:35:35 +09:00
13/Oct/2009:22:35:35 +0900 => System.FormatException: Invalid format string
  at System.DateTimeOffset.ParseExact (System.String input, System.String[] formats, IFormatProvider formatProvider, DateTimeStyles styles) [0x00000] 
  at System.DateTimeOffset.ParseExact (System.String input, System.String format, IFormatProvider formatProvider, DateTimeStyles styles) [0x00000] 
  at System.DateTimeOffset.ParseExact (System.String input, System.String format, IFormatProvider formatProvider) [0x00000] 
  at DateTimeOffsetTest.MainClass.Main (System.String[] args) [0x00000] 
13/Oct/2009:22:35:35 +09:30 => 2009/10/13 22:35:35 +09:30
13/Oct/2009:22:35:35 +0930 => System.FormatException: Invalid format string
  at System.DateTimeOffset.ParseExact (System.String input, System.String[] formats, IFormatProvider formatProvider, DateTimeStyles styles) [0x00000] 
  at System.DateTimeOffset.ParseExact (System.String input, System.String format, IFormatProvider formatProvider, DateTimeStyles styles) [0x00000] 
  at System.DateTimeOffset.ParseExact (System.String input, System.String format, IFormatProvider formatProvider) [0x00000] 
  at DateTimeOffsetTest.MainClass.Main (System.String[] args) [0x00000] 

Index: System/DateTimeOffset.cs
===================================================================
--- System/DateTimeOffset.cs	(revision 144011)
+++ System/DateTimeOffset.cs	(working copy)
@@ -525,7 +525,7 @@
 						ii += ParseEnum (input, ii, new string [] {dfi.TimeSeparator}, false, out temp_int);
 						ii += ParseNumber (input, ii, 2, true, false, out off_m);
 					}
-					if (off_h == -1 || off_m == -1 || sign == -1 || temp_int == -1)
+					if (off_h == -1 || off_m == -1 || sign == -1)
 						return false;
 
 					if (sign == 0)

Index: Test/System/DateTimeOffsetTest.cs
===================================================================
--- Test/System/DateTimeOffsetTest.cs	(revision 144011)
+++ Test/System/DateTimeOffsetTest.cs	(working copy)
@@ -273,6 +273,27 @@
 		}
 
 		[Test]
+		public void ParseExactOffsetFormat ()
+		{
+			CultureInfo fp = CultureInfo.InvariantCulture;
+			string[] dates = {
+				"13/Oct/2009:22:35:35 +09:00",
+				"13/Oct/2009:22:35:35 +0900",
+				"13/Oct/2009:22:35:35 +09:30",
+				"13/Oct/2009:22:35:35 +0930",
+			};
+			TimeSpan[] offsets = {
+				new TimeSpan (9,0,0),
+				new TimeSpan (9,0,0),
+				new TimeSpan (9,30,0),
+				new TimeSpan (9,30,0),
+			};
+
+			for (int i = 0; i < dates.Length; i++)
+				Assert.AreEqual(offsets[i], DateTimeOffset.ParseExact (dates[i], "d/MMM/yyyy:HH:mm:ss zzz", fp).Offset, dates[i]);
+		}
+
+		[Test]
 		[ExpectedException (typeof (FormatException))]
 		public void ParseExactYearException ()
 		{

using System;
using System.Xml;

class XmlConvertToDateTimeOffsetTest {
  public static void Main()
  {
    var dtm = "2009-11-05T20:16:22+09:00";

    Console.WriteLine("{0} => {1}", dtm, XmlConvert.ToDateTimeOffset(dtm));
  }
}

2009-11-05T20:16:22+09:00 => 2009/11/05 20:16:22 +09:00

2009-11-05T20:16:22+09:00 => 2009/11/05 20:16:22 +00:00

Index: System.Xml/XmlConvert.cs
===================================================================
--- System.Xml/XmlConvert.cs	(revision 145470)
+++ System.Xml/XmlConvert.cs	(working copy)
@@ -48,14 +48,6 @@
 		
 		static readonly string [] datetimeFormats = {
 		  // dateTime
-		  "yyyy-MM-ddTHH:mm:ss",
-		  "yyyy-MM-ddTHH:mm:ss.f",
-		  "yyyy-MM-ddTHH:mm:ss.ff",
-		  "yyyy-MM-ddTHH:mm:ss.fff",
-		  "yyyy-MM-ddTHH:mm:ss.ffff",
-		  "yyyy-MM-ddTHH:mm:ss.fffff",
-		  "yyyy-MM-ddTHH:mm:ss.ffffff",
-		  "yyyy-MM-ddTHH:mm:ss.fffffff",
 		  "yyyy-MM-ddTHH:mm:sszzz",
 		  "yyyy-MM-ddTHH:mm:ss.fzzz",
 		  "yyyy-MM-ddTHH:mm:ss.ffzzz",
@@ -72,6 +64,14 @@
 		  "yyyy-MM-ddTHH:mm:ss.fffffZ",
 		  "yyyy-MM-ddTHH:mm:ss.ffffffZ",
 		  "yyyy-MM-ddTHH:mm:ss.fffffffZ",
+		  "yyyy-MM-ddTHH:mm:ss",
+		  "yyyy-MM-ddTHH:mm:ss.f",
+		  "yyyy-MM-ddTHH:mm:ss.ff",
+		  "yyyy-MM-ddTHH:mm:ss.fff",
+		  "yyyy-MM-ddTHH:mm:ss.ffff",
+		  "yyyy-MM-ddTHH:mm:ss.fffff",
+		  "yyyy-MM-ddTHH:mm:ss.ffffff",
+		  "yyyy-MM-ddTHH:mm:ss.fffffff",
 		  // time
 		  "HH:mm:ss",
 		  "HH:mm:ss.f",

using System;
using System.Xml;

class XmlConvertToDateTimeOffsetTest {
  public static void Main()
  {
    var dtm = "2009-11-05T20:16:22+09:00";

    Console.WriteLine("{0} => {1}", dtm, XmlConvert.ToDateTimeOffset(dtm));
  }
}

2009-11-05T20:16:22+09:00 => 2009/11/05 20:16:22 +09:00

2009-11-05T20:16:22+09:00 => 2009/11/05 20:16:22 +00:00

Index: System.Xml/XmlConvert.cs
===================================================================
--- System.Xml/XmlConvert.cs	(revision 145470)
+++ System.Xml/XmlConvert.cs	(working copy)
@@ -48,14 +48,6 @@
 		
 		static readonly string [] datetimeFormats = {
 		  // dateTime
-		  "yyyy-MM-ddTHH:mm:ss",
-		  "yyyy-MM-ddTHH:mm:ss.f",
-		  "yyyy-MM-ddTHH:mm:ss.ff",
-		  "yyyy-MM-ddTHH:mm:ss.fff",
-		  "yyyy-MM-ddTHH:mm:ss.ffff",
-		  "yyyy-MM-ddTHH:mm:ss.fffff",
-		  "yyyy-MM-ddTHH:mm:ss.ffffff",
-		  "yyyy-MM-ddTHH:mm:ss.fffffff",
 		  "yyyy-MM-ddTHH:mm:sszzz",
 		  "yyyy-MM-ddTHH:mm:ss.fzzz",
 		  "yyyy-MM-ddTHH:mm:ss.ffzzz",
@@ -72,6 +64,14 @@
 		  "yyyy-MM-ddTHH:mm:ss.fffffZ",
 		  "yyyy-MM-ddTHH:mm:ss.ffffffZ",
 		  "yyyy-MM-ddTHH:mm:ss.fffffffZ",
+		  "yyyy-MM-ddTHH:mm:ss",
+		  "yyyy-MM-ddTHH:mm:ss.f",
+		  "yyyy-MM-ddTHH:mm:ss.ff",
+		  "yyyy-MM-ddTHH:mm:ss.fff",
+		  "yyyy-MM-ddTHH:mm:ss.ffff",
+		  "yyyy-MM-ddTHH:mm:ss.fffff",
+		  "yyyy-MM-ddTHH:mm:ss.ffffff",
+		  "yyyy-MM-ddTHH:mm:ss.fffffff",
 		  // time
 		  "HH:mm:ss",
 		  "HH:mm:ss.f",

using System;
using System.Net;

class MainClass {
  public static void Main(string[] args)
  {
    using (var client = new WebClient()) {
      client.UploadStringCompleted += delegate(object sender, UploadStringCompletedEventArgs e) {
        if (e.Error != null)
          Console.WriteLine(e.Error);
      };

      client.UploadStringAsync(new Uri("http://localhost/"), "hoge");

      System.Threading.Thread.Sleep(500);
    }
  }
}

System.Net.WebException: An error occurred performing a WebClient request. ---> System.NotSupportedException: WebClient does not support conccurent I/O operations.
  at System.Net.WebClient.CheckBusy () [0x00016] in /srv/files/build/mono/trunk/mcs/class/System/System.Net/WebClient.cs:226 
  at System.Net.WebClient.SetBusy () [0x00008] in /srv/files/build/mono/trunk/mcs/class/System/System.Net/WebClient.cs:231 
  at System.Net.WebClient.UploadData (System.Uri address, System.String method, System.Byte[] data) [0x00028] in /srv/files/build/mono/trunk/mcs/class/System/System.Net/WebClient.cs:520 
  --- End of inner exception stack trace ---
  at System.Net.WebClient.UploadData (System.Uri address, System.String method, System.Byte[] data) [0x00053] in /srv/files/build/mono/trunk/mcs/class/System/System.Net/WebClient.cs:528 
  at System.Net.WebClient.UploadString (System.Uri address, System.String method, System.String data) [0x00028] in /srv/files/build/mono/trunk/mcs/class/System/System.Net/WebClient.cs:840 
  at System.Net.WebClient.<UploadStringAsync>m__13 (System.Object state) [0x00007] in /srv/files/build/mono/trunk/mcs/class/System/System.Net/WebClient.cs:1412 

Index: System/System.Net/WebClient.cs
===================================================================
--- System/System.Net/WebClient.cs	(revision 150935)
+++ System/System.Net/WebClient.cs	(working copy)
@@ -1402,7 +1402,7 @@
 				throw new ArgumentNullException ("data");
 			
 			lock (this) {
-				SetBusy ();
+				CheckBusy ();
 				async = true;
 				
 				async_thread = new Thread (delegate (object state) {

using System;

[assembly: CLSCompliant(true)]

public partial class PartialClass {
  public void Method1(int arg)
  {
  }

  [CLSCompliant(false)]
  public void Method2(uint arg)
  {
  }
}

/*public*/ partial class PartialClass {
  [CLSCompliant(false)]
  public void Method3(uint arg)
  {
  }
}

$ gmcs --version
Mono C# compiler version 2.7.0.0

$ gmcs PartialClass.cs /clscheck+ /t:library /o:test.dll
PartialClass.cs(17,4): warning CS3019: CLS compliance checking will not be performed on `PartialClass.Method3(uint)' because it is not visible from outside this assembly
Compilation succeeded - 1 warning(s)

using System;

class EnumTest {
  public static void Main()
  {
    Console.WriteLine("{0} {1}", Environment.Version, Environment.OSVersion);

    try {
      Guid parsed;

      var ret = Enum.TryParse("val", out parsed);
      Console.WriteLine("ArgumentException not thrown");
      Console.WriteLine("{0} {1}", ret, parsed);
    }
    catch (ArgumentException ex) {
      Console.WriteLine(ex);
    }
  }
}

4.0.30319.1 Microsoft Windows NT 6.0.6002 Service Pack 2
System.ArgumentException: 指定された型は Enum でなければなりません。
パラメーター名: enumType
   場所 System.Enum.TryParseEnum(Type enumType, String value, Boolean ignoreCase, EnumResult& parseResult)
   場所 System.Enum.TryParse[TEnum](String value, Boolean ignoreCase, TEnum& result)
   場所 EnumTest.Main()

4.0.21006.1 Unix 2.6.31.20
ArgumentException not thrown
False 00000000-0000-0000-0000-000000000000

Index: System/Enum.cs
===================================================================
--- System/Enum.cs	(revision 155838)
+++ System/Enum.cs	(working copy)
@@ -628,9 +628,13 @@
 		public static bool TryParse<TEnum> (string value, bool ignoreCase, out TEnum result) where TEnum : struct
 		{
 			Type tenum_type = typeof (TEnum);
+
+			if (!tenum_type.IsEnum)
+				throw new ArgumentException("TEnum is not an Enum type.", "enumType");
+
 			result = default (TEnum);
 
-			if (value == null || value.Trim ().Length == 0 || !tenum_type.IsEnum)
+			if (value == null || value.Trim ().Length == 0)
 				return false;
 
 			return Parse (tenum_type, value, ignoreCase, out result);

Index: Test/System/EnumTest.cs
===================================================================
--- Test/System/EnumTest.cs	(revision 155838)
+++ Test/System/EnumTest.cs	(working copy)
@@ -705,11 +705,18 @@
 			Assert.AreEqual (false, success, "#D1");
 			Assert.AreEqual (TestingEnum.This, result, "#D2");
 
-			// TryParse can accept any struct derived type
-			int n;
-			success = Enum.TryParse<int> ("31416", out n);
-			Assert.AreEqual (false, success, "#E1");
-			Assert.AreEqual (0, n, "#E2");
+			// TryParse throws ArgumentException if TEnum is not an enumeration type
+			try {
+				int n;
+				Enum.TryParse<int> ("31416", out n);
+				Assert.Fail ("#E1");
+			} catch (ArgumentException ex) {
+				Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
+				Assert.IsNull (ex.InnerException, "#E3");
+				Assert.IsNotNull (ex.Message, "#E4");
+				Assert.IsNotNull (ex.ParamName, "#E5");
+				Assert.AreEqual ("enumType", ex.ParamName, "#E6");
+			}
 		}
 
 		[Test]

delegate(int i){ return i; }

public override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)
{
	for (int i = 0; i < localVariableDeclaration.Variables.Count; ++i) {
		VariableDeclaration varDecl = (VariableDeclaration)localVariableDeclaration.Variables[i];
				
		AddVariable(localVariableDeclaration.GetTypeForVariable(i),
				            varDecl.Name,
				            localVariableDeclaration.StartLocation,
				            CurrentEndLocation,
				            (localVariableDeclaration.Modifier & Modifiers.Const) == Modifiers.Const,
				            false, varDecl.Initializer, null, false, localVariableDeclaration.SemicolonPosition);
	}
	return base.VisitLocalVariableDeclaration(localVariableDeclaration, data)
}

public override object VisitLambdaExpression(LambdaExpression lambdaExpression, object data)
{
	foreach (ParameterDeclarationExpression p in lambdaExpression.Parameters) {
		AddVariable(p.TypeReference, p.ParameterName,
			lambdaExpression.StartLocation, lambdaExpression.ExtendedEndLocation,
				false, false, null, lambdaExpression, false, lambdaExpression.StartLocation);
	}
	return base.VisitLambdaExpression(lambdaExpression, data);
}

public override object VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data)
{
	foreach (ParameterDeclarationExpression p in anonymousMethodExpression.Parameters) {
		AddVariable(p.TypeReference, p.ParameterName,
			anonymousMethodExpression.StartLocation, anonymousMethodExpression.EndLocation,
				            false, false, null, null, false, anonymousMethodExpression.EndLocation);
		}
		return base.VisitAnonymousMethodExpression(anonymousMethodExpression, data);
	}
}

public override object VisitAnonymousMethodExpression(AnonymousMethodExpression anonymousMethodExpression, object data)
{
	foreach (ParameterDeclarationExpression p in anonymousMethodExpression.Parameters) {
		AddVariable(p.TypeReference, p.ParameterName,
			anonymousMethodExpression.StartLocation, anonymousMethodExpression.EndLocation,
				            false, false, null, null, false, anonymousMethodExpression.StartLocation);
		}
		return base.VisitAnonymousMethodExpression(anonymousMethodExpression, data);
	}

}

if (type != null) {
	if (type.ClassType == MonoDevelop.Projects.Dom.ClassType.Delegate) {
		if (type is InstantiatedType) {
			this.delegateName = ((InstantiatedType)type).UninstantiatedType.Name;
		} else {
			this.delegateName = type.Name;
		}
		foreach (IMethod method in type.Methods) {
			if (method.Name == ".ctor"){
				methods.Add (method);
			}
		}
		return;
	}
}

DomMethod delegateMethodconstructor = new DomMethod (".ctor", Modifiers.None, MethodModifier.None, location, DomRegion.Empty, new DomReturnType(name));
delegateMethodconstructor.Add (new List<DomParameter>());
result.Add(delegateMethodconstructor);

using System;

namespace Like{
	public class Like{
		public static void Main (){
			System.Console.WriteLine(Microsoft.VisualBasic.CompilerServices.StringType.StrLike("\\5","\\#",Microsoft.VisualBasic.CompareMethod.Binary));
		}
	}
}

Private Function GetSystemDir() As String
    Dim assemblies() As Reflection.Assembly
    Dim result As String
    Dim sw As System.IO.StreamWriter = New System.IO.StreamWriter("D:\compilerdebugging\hoge2.log",True,System.Text.Encoding.UTF8) 

    If Not String.IsNullOrEmpty(CommandLine.SDKPath) Then
        If CommandLine.Verbose Then Report.WriteLine(string.Format ("Using alternate system path: {0}", CommandLine.SDKPath))
        Return CommandLine.SDKPath
    End If

	sw.WriteLine("pass")

    assemblies = AppDomain.CurrentDomain.GetAssemblies

    For Each a As Reflection.Assembly In assemblies
        Dim codebase As String = a.Location
		sw.WriteLine(codebase)

        If codebase.EndsWith("corlib.dll") Then
            result = codebase.Substring(0, codebase.LastIndexOf(System.IO.Path.DirectorySeparatorChar))
            If CommandLine.Verbose Then Report.WriteLine(String.Format("Using system path: {0}", result))
            sw.Flush()
            sw.Close()
            
            Return result
        End If
    Next
    Throw New InternalException("Cannot compute the system directory.")
    Return ""
End Function

   Doubleの型指定子: http://msdn.microsoft.com/en-us/library/office/gg264155%28v=office.15%29.aspx
   ファイルIO: http://msdn.microsoft.com/en-us/library/office/gg264163%28v=office.15%29.aspx
   日付リテラル: http://msdn.microsoft.com/en-us/library/office/gg278460%28v=office.15%29.aspx

   // カレントディレクトリにあるfile2.txtをディレクトリE:\dir\に移動する
   File.Move("file2.txt", @"E:\dir\");　//★★エラー

   if (exp[0] == '(')
       remove_bracket(exp);
   return 0;

   size_t i;                      // ★ size_tは必要？ INT_MAX超の長大な式を扱う？                   ★
   size_t pos_operator = -1;      // ★ size_t型に-1？                                               ★
   int priority_current = 4;      // ★ <limits.h>で定義されるINT_MAX等の充分大きな値で初期化したい  ★
                                  // ★ 対応する演算子を増やした場合に、ここを変更し忘れてもＯＫ     ★

        :
   // 左右の子ノードの値からノードの値が求まったため、
   // このノードは左右に子ノードを持たない値のみのノードとする
   node->left  = NULL;  // ★ 不要 ★
   node->right = NULL;  // ★ 不要 ★

   ・int has_outer_most_bracket = ( '(' == exp[0] );  //  boolean
   ・for (i = 0; i < len; i++) {  //  i=1ではなく、i=0から開始

   size_t i;
   // ★ expが長大な場合、strlenは遅い                                                           ★
   // ★ この関数は再帰的に何度も呼び出されるので、できるだけ先頭の処理を軽くしたい              ★
   // ★ 括弧の対応をチェックする際にexpを最後までスキャンすれば、strlen無しでも文字列長は分かる ★
   size_t len = strlen(exp);
   int has_outer_most_bracket = 0; // 最も外側に括弧を持つかどうか(0=持たない、1=持つ)
   // ★ int has_outer_most_bracket = ( '(' == exp[0] );  で初期化した方がよい？                 ★
   int nest = 0;

   // ★ この後のfor文を工夫すれば、次の１０行は不要？ ★
   if ('(' == exp[0]) {
       // 0文字目が開き丸括弧の場合、最も外側に丸括弧があると仮定する
       nest = 1;
       has_outer_most_bracket = 1;
   }
   else if (')' == exp[0]) {
       // 0文字目が閉じ丸括弧の場合、エラーとする
       fprintf(stderr, "unbalanced bracket: %s\n", exp);
       return -1;
   }

   // 1文字目以降を1文字ずつ検証
   // ★ この前のifとelse ifの両ブロックを削除した場合は、i=1ではなく、i=0からスキャン開始 ★
   for (i = 1; i < len; i++) {
       if ('(' == exp[i]) {
           // 開き丸括弧なので深度を1増やす
           nest++;
       }
       else if (')' == exp[i]) {
           // 閉じ丸括弧なので深度を1減らす
           nest--;
           // ★ ここに nest<0 の場合のエラー処理を入れる？ ★

           // 最後の文字以外で閉じ丸括弧が現れた場合、最も外側には丸括弧がないと判断する
           if (i < len - 1 && 0 == nest)
             has_outer_most_bracket = 0;  // ★ false ★
       }
   }

                   :
       // 最初と最後の文字を取り除く
       for (i = 0; i < len - 2; i++) {
           exp[i] = exp[i + 1];
       }
       exp[i] = '\0';

       // 再帰的に呼び出す
       // "((1+2))"など、多重になっている括弧を取り除くため再帰的に呼び出す

       return remove_outer_most_bracket(exp);
     }

             :
       // 演算子の左側を左の部分式としてノードを構成
       // ★ expが長大になるとmemsetは遅くなる                               ★
       // ★ strncpy後にnode->left->exp[pos_operator]='\0'で終端した方が速い ★
       memset(node->left->exp, 0, MAX_EXP_LEN);
       strncpy(node->left->exp, node->exp, pos_operator);

       // 左側のノード(部分式)について、再帰的に二分木へと分割する
       if (parse_expression(node->left) < 0)
           return -1;

       // 演算子の右側を右の部分式としてノードを構成
       // ★ node->expはnull文字で終端されているのでstrncpyではなく、strcpyでＯＫ ★
       // ★     strcpy(node->right->exp, node->exp + pos_operator + 1);          ★
       memset(node->right->exp, 0, MAX_EXP_LEN);
       strncpy(node->right->exp, node->exp + pos_operator + 1, len_exp - pos_operator);

            :
   // 巡回を終えた後でノードの演算子または項を表示する
   printf("%s", node->exp);  // ★ 空白を追加して"%s "とすると見易くなる ★

          :
   if ((size_t)0 == pos_operator || (size_t)(len_exp - 1) == pos_operator) {
     // 演算子の位置が式の先頭または末尾の場合は不正な式とする
       fprintf(stderr, "invalid expression: %s\n", node->exp);
       return -1;
   }
   else if ((size_t)-1 == pos_operator) { //  ★ else if ではなく、if の方が読みやすい ★
       // 式Expressionに演算子が含まれない場合、Expressionは項であるとみなす
       // (左右に子ノードを持たないノードとする)
       node->left  = NULL;
       node->right = NULL;

       return 0;
   }
   else {  //  ★ else ブロックを止めた方が読みやすい ★
       // 左側・右側のノードを作成
       node->left   = create_node();
       node->right  = create_node();

 ・コメント文が充実しているのは理解の助けになり大変ありがたいのですが、
   体言止めを使うなどして、できるだけ文章を簡潔に表現した方が読みやすくなると思います。

        for (i = 0, len = 0; exp[i]; i++, len++) {
            if ('(' == exp[i]) {
                // 開き丸括弧なので深度を1増やす
                nest++;

                // 0文字目が開き丸括弧の場合、最も外側に丸括弧があると仮定する
                if (0 == i)
                    has_outer_most_bracket = 1;
            }

diff --git a/contents/programming/tips/polish/_source/polish.c b/contents/programming/tips/polish/_source/polish.c
index abd4b22..ef61b7a 100644
--- a/contents/programming/tips/polish/_source/polish.c
+++ b/contents/programming/tips/polish/_source/polish.c
@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <limits.h>
 
 typedef struct Node Node;
 
@@ -32,24 +33,19 @@ Node* create_node()
 // (成功した場合は0、エラーの場合は-1を返す)
 int remove_outer_most_bracket(char *exp)
 {
-    size_t i;
-    size_t len = strlen(exp);
+    int i;
+    size_t len;
     int has_outer_most_bracket = 0; // 最も外側に括弧を持つかどうか(0=持たない、1=持つ)
-    int nest = 0;
+    int nest = 0; // 丸括弧の深度(式中で開かれた括弧が閉じられたかどうか調べるために用いる)
 
     if ('(' == exp[0]) {
         // 0文字目が開き丸括弧の場合、最も外側に丸括弧があると仮定する
-        nest = 1;
         has_outer_most_bracket = 1;
-    }
-    else if (')' == exp[0]) {
-        // 0文字目が閉じ丸括弧の場合、エラーとする
-        fprintf(stderr, "unbalanced bracket: %s\n", exp);
-        return -1;
+        nest = 1;
     }
 
     // 1文字目以降を1文字ずつ検証
-    for (i = 1; i < len; i++) {
+    for (i = 1, len = 1; exp[i]; i++, len++) {
         if ('(' == exp[i]) {
             // 開き丸括弧なので深度を1増やす
             nest++;
@@ -58,51 +54,48 @@ int remove_outer_most_bracket(char *exp)
             // 閉じ丸括弧なので深度を1減らす
             nest--;
 
-            // 最後の文字以外で閉じ丸括弧が現れた場合、最も外側には丸括弧がないと判断する
-            if (i < len - 1 && 0 == nest)
+            // 最後の文字以外で開き丸括弧がすべて閉じられた場合、最も外側には丸括弧がないと判断する
+            // 例:"(1+2)+(3+4)"などの場合
+            if (0 == nest && exp[i + 1]) {
                 has_outer_most_bracket = 0;
+                break;
             }
         }
-
-    // 括弧の深度が0以外の場合
-    if (0 != nest) {
-        // 開かれていない/閉じられていない括弧があるので、エラーとする
-        fprintf(stderr, "unbalanced bracket: %s\n", exp);
-        return -1;
     }
-    // 最も外側に丸括弧がある場合
-    else if (0 != has_outer_most_bracket) {
-      if (len <= 2) {
+
+    // 最も外側に丸括弧がない場合は、何もしない
+    if (0 == has_outer_most_bracket)
+        return 0;
+
     // 文字列の長さが2未満の場合は、つまり空の丸括弧"()"なのでエラーとする
+    if (len <= 2) {
         fprintf(stderr, "empty bracket: %s\n", exp);
         return -1;
     }
-      else {
-        // 最初と最後の文字を取り除く
+
+    // 最初と最後の文字を取り除く(最も外側の丸括弧を取り除く)
     for (i = 0; i < len - 2; i++) {
         exp[i] = exp[i + 1];
     }
     exp[i] = '\0';
 
-        // 再帰的に呼び出す
-        // "((1+2))"など、多重になっている括弧を取り除くため再帰的に呼び出す
+    // 取り除いた後の文字列の最も外側に括弧が残っている場合
+    // 例:"((1+2))"などの場合
+    if ('(' == exp[0] && ')' == exp[i - 1])
+        // 再帰的に呼び出して取り除く
         return remove_outer_most_bracket(exp);
-      }
-    }
-    // 最も外側に丸括弧がない場合
-    else {
-        // 何もしない
+    else
+        // そうでない場合は処理を終える
         return 0;
-    }
 }
 
-// 式expから最も優先順位が低い演算子を探して位置を返す関数
+// 式expから最も右側にあり、かつ優先順位が低い演算子を探して位置を返す関数
 // (演算子がない場合は-1を返す)
-size_t get_pos_operator(char *exp)
+int get_pos_operator(char *exp)
 {
-    size_t i;
-    size_t pos_operator = -1; // 現在見つかっている演算子の位置(初期値として-1=演算子なしを設定)
-    int priority_current = 4; // 現在見つかっている演算子の優先順位(初期値として4=最高(3)+1を設定)
+    int i;
+    int pos_operator = -1; // 現在見つかっている演算子の位置(初期値として-1=演算子なしを設定)
+    int priority_current = INT_MAX; // 現在見つかっている演算子の優先順位(初期値としてINT_MAXを設定)
     int nest = 0; // 丸括弧の深度(括弧でくくられていない部分の演算子を「最も優先順位が低い」と判断するために用いる)
     int priority;
 
@@ -127,6 +120,7 @@ size_t get_pos_operator(char *exp)
 
         // 括弧の深度が0(丸括弧でくくられていない部分)かつ、
         // 現在見つかっている演算子よりも優先順位が同じか低い場合
+        // (優先順位が同じ場合は、より右側に同じ優先順位の演算子があることになる)
         if (0 == nest && priority <= priority_current) {
           // 最も優先順位が低い演算子とみなし、その位置を保存する
           priority_current = priority;
@@ -142,8 +136,8 @@ size_t get_pos_operator(char *exp)
 // (成功した場合は0、エラーの場合は-1を返す)
 int parse_expression(Node* node)
 {
-    size_t pos_operator;
-    size_t len_exp;
+    int pos_operator;
+    size_t len;
 
     if (!node)
         return -1;
@@ -152,26 +146,28 @@ int parse_expression(Node* node)
     if (remove_outer_most_bracket(node->exp) < 0)
         return -1;
 
-    len_exp = strlen(node->exp);
-
     // 式expから演算子を探して位置を取得する
     pos_operator = get_pos_operator(node->exp);
 
-    if ((size_t)0 == pos_operator || (size_t)(len_exp - 1) == pos_operator) {
-      // 演算子の位置が式の先頭または末尾の場合は不正な式とする
-        fprintf(stderr, "invalid expression: %s\n", node->exp);
-        return -1;
-    }
-    else if ((size_t)-1 == pos_operator) {
-        // 式Expressionに演算子が含まれない場合、Expressionは項であるとみなす
+    if (-1 == pos_operator) {
+        // 式expに演算子が含まれない場合、expは項であるとみなす
         // (左右に子ノードを持たないノードとする)
         node->left  = NULL;
         node->right = NULL;
-
         return 0;
     }
-    else {
-        // 左側・右側のノードを作成
+
+    len = strlen(node->exp);
+
+    if (0 == pos_operator || (len - 1) == pos_operator) {
+      // 演算子の位置が式の先頭または末尾の場合は不正な式とする
+        fprintf(stderr, "invalid expression: %s\n", node->exp);
+        return -1;
+    }
+
+    // 以下、演算子の位置をもとに左右の部分式に分割する
+
+    // 左側・右側のノードを作成する
     node->left   = create_node();
     node->right  = create_node();
 
@@ -181,7 +177,7 @@ int parse_expression(Node* node)
         return -1;
     }
 
-        // 演算子の左側を左の部分式としてノードを構成
+    // 演算子の左側を左の部分式としてノードを構成する
     memset(node->left->exp, 0, MAX_EXP_LEN);
     strncpy(node->left->exp, node->exp, pos_operator);
 
@@ -189,9 +185,9 @@ int parse_expression(Node* node)
     if (parse_expression(node->left) < 0)
         return -1;
 
-        // 演算子の右側を右の部分式としてノードを構成
+    // 演算子の右側を右の部分式としてノードを構成する
     memset(node->right->exp, 0, MAX_EXP_LEN);
-        strncpy(node->right->exp, node->exp + pos_operator + 1, len_exp - pos_operator);
+    strncpy(node->right->exp, node->exp + pos_operator + 1, len - pos_operator);
 
     // 右側のノード(部分式)について、再帰的に二分木へと分割する
     if (parse_expression(node->right) < 0)
@@ -202,7 +198,6 @@ int parse_expression(Node* node)
     node->exp[1] = '\0';
 
     return 0;
-    }
 }
 
 // 後行順序訪問(帰りがけ順)で二分木を巡回して
@@ -216,7 +211,8 @@ void traverse_postorder(Node* node)
         traverse_postorder(node->right);
 
     // 巡回を終えた後でノードの演算子または項を表示する
-    printf("%s", node->exp);
+    // (読みやすさのために項の後に空白を補って表示する)
+    printf("%s ", node->exp);
 }
 
 // 中間順序訪問(通りがけ順)で二分木を巡回して
@@ -228,27 +224,36 @@ void traverse_inorder(Node* node)
         printf("(");
 
     // 表示する前に左の子ノードを再帰的に巡回する
-    if (node->left)
+    if (node->left) {
         traverse_inorder(node->left);
 
+        // 読みやすさのために空白を補う
+        printf(" ");
+    }
+
     // 左の子ノードの巡回を終えた後でノードの演算子または項を表示する
     printf("%s", node->exp);
 
     // 表示した後に右の子ノードを再帰的に巡回する
-    if (node->right)
+    if (node->right) {
+        // 読みやすさのために空白を補う
+        printf(" ");
+
         traverse_inorder(node->right);
+    }
 
     // 左右に項を持つ場合、読みやすさのために項の後に閉じ括弧を補う
     if (node->left && node->right)
         printf(")");
 }
 
-  // 先行順序訪問(行きがけ順)で二分木を巡回して
-  // すべてのノードの演算子または項を表示する関数
+// 先行順序訪問(行きがけ順)で二分木を巡回して
+// すべてのノードの演算子または項を表示する関数
 void traverse_preorder(Node* node)
 {
     // 巡回を始める前にノードの演算子または項を表示する
-    printf("%s", node->exp);
+    // (読みやすさのために項の後に空白を補って表示する)
+    printf("%s ", node->exp);
 
     // 左右に子ノードをもつ場合、表示した後にノードを再帰的に巡回する
     if (node->left)
@@ -317,6 +322,40 @@ void remove_space(char *exp)
     *dst = '\0';
 }
 
+// 式exp内の括弧の対応を検証する関数
+// 開き括弧と閉じ括弧が同数でない場合はエラーとして0以外、同数の場合は0を返す
+int validate_bracket_balance(char *exp)
+{
+    int i;
+    int nest = 0; // 丸括弧の深度(くくられる括弧の数を計上するために用いる)
+
+    // 1文字ずつ検証する
+    for (i = 0; exp[i]; i++) {
+        if ('(' == exp[i]) {
+            // 開き丸括弧なので深度を1増やす
+            nest++;
+        }
+        else if (')' == exp[i]) {
+            // 閉じ丸括弧なので深度を1減らす
+            nest--;
+
+            // 深度が負になった場合
+            if (nest < 0)
+                // 式中で開かれた括弧よりも閉じ括弧が多いため、その時点でエラーとする
+                // 例:"(1+2))"などの場合
+                break;
+        }
+    }
+
+    // 深度が0でない場合
+    if (0 != nest)
+        // 式中に開かれていない/閉じられていない括弧があるので、エラーとする
+        // 例:"((1+2)"などの場合
+        fprintf(stderr, "unbalanced bracket: %s\n", exp);
+
+    return nest;
+}
+
 int main()
 {
     // 二分木の根(root)ノードを作成する
@@ -329,23 +368,27 @@ int main()
     // 入力された式から空白を除去する
     remove_space(root->exp);
 
+    // 入力された式における括弧の対応数をチェックする
+    if (0 != validate_bracket_balance(root->exp))
+        return -1;
+
     printf("expression: %s\n", root->exp);
 
     // 根ノードに格納した式を二分木へと分割する
     if (parse_expression(root) < 0)
         return -1;
 
-    // 分割した二分木を帰りがけ順で巡回して表示(前置記法/逆ポーランド記法で表示される)
+    // 分割した二分木を帰りがけ順で巡回して表示する(前置記法/逆ポーランド記法で表示される)
     printf("reverse polish notation: ");
     traverse_postorder(root);
     printf("\n");
 
-    // 分割した二分木を通りがけ順で巡回して表示(中置記法で表示される)
+    // 分割した二分木を通りがけ順で巡回して表示する(中置記法で表示される)
     printf("infix notation: ");
     traverse_inorder(root);
     printf("\n");
 
-    // 分割した二分木を行きがけ順で巡回して表示(後置記法/ポーランド記法で表示される)
+    // 分割した二分木を行きがけ順で巡回して表示する(後置記法/ポーランド記法で表示される)
     printf("polish notation: ");
     traverse_preorder(root);
     printf("\n");