/// <summary>
/// Parse the time (hours, minutes, seconds)
/// </summary>
private void ParseTime(ParseStream stream,
out int hour, out int minutes, out int seconds)
{
if (stream.Char == 't' || stream.Char == 'T')
{
stream.Next(true);
}
else
{
SkipWhitespace(stream);
}
// Parse hour
// Note: A hour can be represented by one or two digits.
string hulp = "";
while (stream.Char >= '0' && stream.Char <= '9' &&
!stream.EOF && hulp.Length <= 2)
{
hulp += stream.Char;
stream.Next(true);
}
hour = Int32.Parse(hulp);
SkipChar(stream, ':');
// Parse minutes
minutes = ParseNumber(stream, 2);
SkipChar(stream, ':');
// Parse seconds
seconds = ParseNumber(stream, 2);
}
/// <summary> Hexadecimal string </summary>
private static long Parse16(ParseStream stream, short sign)
{
uint output = 0;
while (!stream.EOF)
{
// 0 .. 9
if (stream.Char >= '0' && stream.Char <= '9')
{
output = (output * 16) + (uint)(stream.Char - '0');
OverflowTest(output, sign);
}
// a .. f
else if (stream.Char >= 'a' && stream.Char <= 'f')
{
output = (output * 16) + (uint)(stream.Char - 'a') + 10;
OverflowTest(output, sign);
}
// A .. F
else if (stream.Char >= 'A' && stream.Char <= 'F')
{
output = (output * 16) + (uint)(stream.Char - 'A') + 10;
OverflowTest(output, sign);
}
// Ignore underscores, other chars are not allowed
else if (stream.Char != '_')
{
throw new Exception("Unknown char in base 16");
}
stream.Next();
}
return((long)(sign * output));
}
/// <summary>
/// Skips the spaces * and tabs * in the current stream
/// </summary>
private void SkipWhitespace(ParseStream stream)
{
while ((stream.Char == ' ' || stream.Char == '\t') && !stream.EOF)
{
stream.Next(true);
}
}
/// <summary> Parses a string with a given base (maximum 10) </summary>
/// <remarks>
/// This is not completly correct. For base10 the first char may not be a '_'
/// The other bases allow this...
/// </remarks>
private static long ParseBase(ParseStream stream, uint basis, short sign)
{
// Base must be <= 10
if (basis > 10)
{
throw new Exception("Base to large. Maximum 10");
}
ulong output = 0;
char max = (char)((basis - 1) + (int)'0');
// Parse
while (!stream.EOF)
{
// Decimal
if (stream.Char >= '0' && stream.Char <= max)
{
output = (output * basis) + (uint)(stream.Char - '0');
OverflowTest(output, sign);
}
// Ignore underscores, but other chars are not allowed
// see remarks
else if (stream.Char != '_')
{
throw new Exception("Unknown char in base " + basis);
}
stream.Next();
}
return(sign * (long)output);
}
/// <summary>
/// Test for the value's nan, NaN and NAN in the stream. If
/// found then it is placed inside the content.
/// There is no more data excepted behind it
/// </summary>
private void ParseNaN(ParseStream stream)
{
// Read the first 8 chars
char [] chars = new char [8];
int length = 0;
for (int i = 0; i < chars.Length && !stream.EOF; i++)
{
chars [i] = stream.Char;
length++;
stream.Next(true);
}
// Compare
if (length == 3)
{
string s = "" + chars [0] + chars [1] + chars [2];
if (s == "NAN" || s == "NaN" || s == "nan")
{
content = double.NaN;
return;
}
}
throw new ParseException(stream, "No valid NaN");
}
/// <summary> Parse a DateTime </summary>
public Timestamp(ParseStream stream) :
base("tag:yaml.org,2002:timestamp", NodeType.Timestamp)
{
int year = 0;
int month = 0;
int day = 0;
int hour = 0;
int minutes = 0;
int seconds = 0;
int ms = 0;
try
{
// Parse year
year = ParseNumber(stream, 4);
SkipChar(stream, '-');
// Parse month
month = ParseNumber(stream, 2);
SkipChar(stream, '-');
// Parse day
day = ParseNumber(stream, 2);
// Additional, the time
if (!stream.EOF)
{
ParseTime(stream, out hour, out minutes, out seconds);
}
// Additional, milliseconds
if (!stream.EOF)
{
ms = ParseMilliSeconds(stream);
}
// Additional, the timezone
if (!stream.EOF)
{
timezone = ParseTimezone(stream);
}
// If there is more, then a format exception
if (!stream.EOF)
{
throw new Exception("More data then excepted");
}
content = new DateTime(year, month, day, hour, minutes, seconds, ms);
}
catch (Exception ex)
{
throw new ParseException(stream, ex.ToString());
}
}
/// <summary>
/// Skips a specified char, and throws an exception when
/// another char was found.
/// </summary>
private void SkipChar(ParseStream stream, char toSkip)
{
if (stream.Char == toSkip)
{
stream.Next(true);
}
else
{
throw new Exception("Unexpected character");
}
}
/// <summary> Parse a binary node </summary>
public Binary(ParseStream stream) :
base("tag:yaml.org,2002:binary", NodeType.Binary)
{
try
{
content = Parse(stream);
}
catch (FormatException e)
{
throw new ParseException(stream, e);
}
}
/// <summary> Parse a binary node </summary>
public Binary(ParseStream stream)
: base("tag:yaml.org,2002:binary", NodeType.Binary)
{
try
{
content = Parse (stream);
}
catch (FormatException e)
{
throw new ParseException (stream, e);
}
}
/// <summary>
/// Parse a Yaml string from a textfile and return a Yaml tree
/// </summary>
public static Node FromFile(string filename)
{
// Open YAML file
StreamReader reader = File.OpenText(filename);
ParseStream parsestream = new ParseStream(reader);
// Parse
Node node = Parse(parsestream);
// Close YAML file
reader.Close();
return(node);
}
/// <summary>
/// Parses a String surrounded with single quotes
/// </summary>
private string ParseSingleQuoted(ParseStream stream)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
// Start literal parsing
stream.StartLiteral();
// Skip '''
stream.Next(true);
while (!stream.EOF)
{
if (stream.Char == '\'')
{
stream.Next();
// Escaped single quote
if (stream.Char == '\'')
{
builder.Append(stream.Char);
}
// End of string
else
{
break;
}
}
else
{
builder.Append(stream.Char);
}
stream.Next();
// Skip \'
if (stream.EOF)
{
stream.StopLiteral();
throw new ParseException(stream,
"Single quoted string not closed");
}
}
// Stop literal parsing
stream.StopLiteral();
return(builder.ToString());
}
/// <summary> Parses a binairy node. </summary>
/// <remarks>
/// This is not an efficient method. First the stream is placed
/// in a string. And after that the string is converted in a byte[].
/// If there is a fault in the binairy string then that will only be detected
/// after reading the whole stream and after coneverting.
/// </remarks>
public static new byte [] Parse(ParseStream stream)
{
bool quoted = false;
bool block = false;
System.Text.StringBuilder input = new System.Text.StringBuilder();
if (stream.EOF)
{
throw new ParseException(stream, "Empty node");
}
// Detect block scalar
stream.SkipSpaces();
if (stream.Char == '|')
{
block = true;
stream.Next();
stream.SkipSpaces();
}
while (!stream.EOF)
{
// Detect quotes
if (stream.Char == '\"')
{
if (quoted)
{
break; //End of stream
}
else
{
quoted = true; //Start of quoted stream
}
}
// Detect and ignore newline char's
else if (!(stream.Char == '\n' && block))
{
input.Append(stream.Char);
}
stream.Next();
}
//Console.WriteLine("convert [" + input.ToString() + "]");
return(System.Convert.FromBase64String(input.ToString()));
}
/// <summary> Parse a DateTime </summary>
public Timestamp(ParseStream stream)
: base("tag:yaml.org,2002:timestamp", NodeType.Timestamp)
{
int year = 0;
int month = 0;
int day = 0;
int hour = 0;
int minutes = 0;
int seconds = 0;
int ms = 0;
try
{
// Parse year
year = ParseNumber (stream, 4);
SkipChar (stream, '-');
// Parse month
month = ParseNumber (stream, 2);
SkipChar (stream, '-');
// Parse day
day = ParseNumber (stream, 2);
// Additional, the time
if ( ! stream.EOF)
ParseTime (stream, out hour, out minutes, out seconds);
// Additional, milliseconds
if ( ! stream.EOF)
ms = ParseMilliSeconds (stream);
// Additional, the timezone
if ( ! stream.EOF)
timezone = ParseTimezone (stream);
// If there is more, then a format exception
if ( ! stream.EOF)
throw new Exception ("More data then excepted");
content = new DateTime (year, month, day, hour, minutes, seconds, ms);
}
catch (Exception ex)
{
throw new ParseException (stream, ex.ToString ());
}
}
/// <summary> Parse a null node </summary>
public Null(ParseStream stream) :
base("tag:yaml.org,2002:null", NodeType.Null)
{
// An empty string is a valid null node
if (stream.EOF)
{
return;
}
else
{
// Read the first 4 chars
char [] chars = new char [8];
int length = 0;
for (int i = 0; i < chars.Length && !stream.EOF; i++)
{
chars [i] = stream.Char;
length++;
stream.Next();
}
// Compare
if (length == 1)
{
string s = "" + chars [0];
// Canonical notation
if (s == "~")
{
return;
}
}
if (length == 4)
{
string s = "" + chars [0] + chars [1] + chars [2] + chars [3];
// null, Null, NULL
if (s == "NULL" || s == "Null" || s == "null")
{
return;
}
}
throw new ParseException(stream, "Not NULL");
}
}
/// <summary>
/// Parse the milliseconds
/// </summary>
private int ParseMilliSeconds(ParseStream stream)
{
int ms = 0;
// Look for fraction
if (stream.Char == '.')
{
stream.Next(true);
// Parse fraction, can consists of an
// unlimited sequence of numbers, we only
// look to the first three (max 1000)
int count = 0;
while (stream.Char >= '0' && stream.Char <= '9' &&
count < 3 && !stream.EOF)
{
ms *= 10;
ms += stream.Char - '0';
stream.Next(true);
count++;
}
if (count == 1)
{
ms *= 100;
}
if (count == 2)
{
ms *= 10;
}
if (count == 3)
{
ms *= 1;
}
// Ignore the rest
while (stream.Char >= '0' && stream.Char <= '9' &&
!stream.EOF)
{
stream.Next(true);
}
}
return(ms);
}
/// <summary> Parse float </summary>
public Float(ParseStream stream) :
base("tag:yaml.org,2002:float", NodeType.Float)
{
// NaN
if (stream.Char == '.')
{
stream.Next(true);
ParseNaN(stream);
}
else
{
// By default positief
int sign = 1;
// Negative sign
if (stream.Char == '-')
{
sign = -1;
stream.Next(true);
}
// Positive sign
else if (stream.Char == '+')
{
stream.Next(true);
}
// Test for inf, Inf and INF
if (!stream.EOF && stream.Char == '.')
{
stream.Next(true);
ParseInf(stream, sign);
}
// Parse the numbers
else if (!stream.EOF)
{
ParseNumber(stream, sign);
}
else
{
throw new ParseException(stream,
"No valid float, no data behind the sign");
}
}
}
/// <summary>
/// Parse an integer
/// </summary>
/// <param name="length">
/// The number of characters that the integer is expected to be.
/// </param>
/// <param name="stream"> The stream that will be parsed </param>
private int ParseNumber(ParseStream stream, int length)
{
System.Text.StringBuilder hulp = new System.Text.StringBuilder();
int i;
for (i = 0; i < length && !stream.EOF; i++)
{
hulp.Append(stream.Char);
stream.Next(true);
}
if (i == length)
{
return(Int32.Parse(hulp.ToString()));
}
else
{
throw new Exception("Can't parse number");
}
}
/// <summary> Parse a null node </summary>
public Null(ParseStream stream)
: base("tag:yaml.org,2002:null", NodeType.Null)
{
// An empty string is a valid null node
if (stream.EOF)
return;
else
{
// Read the first 4 chars
char [] chars = new char [8];
int length = 0;
for (int i = 0; i < chars.Length && ! stream.EOF; i ++)
{
chars [i] = stream.Char;
length ++;
stream.Next ();
}
// Compare
if (length == 1)
{
string s = "" + chars [0];
// Canonical notation
if (s == "~")
return;
}
if (length == 4)
{
string s = "" + chars [0] + chars [1] + chars [2] + chars [3];
// null, Null, NULL
if (s == "NULL" || s == "Null" || s == "null")
return;
}
throw new ParseException (stream, "Not NULL");
}
}
/// <summary>
/// Parses a String surrounded with double quotes
/// </summary>
private string ParseDoubleQuoted(ParseStream stream)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
// Skip '"'
stream.Next();
// Stop at "
stream.StopAt(new char [] { '\"' });
while (!stream.EOF)
{
if (stream.Char == '\n')
{
builder.Append(' ');
stream.Next();
}
else
{
builder.Append(NextUnescapedChar(stream));
}
}
// Don't stop at "
stream.DontStop();
// Skip '"'
if (stream.Char != '\"')
{
throw new ParseException(stream,
"Double quoted string not closed");
}
else
{
stream.Next(true);
}
return(builder.ToString());
}
/// <summary>
/// Parses a String surrounded without nothing
/// </summary>
private string ParseUnQuoted(ParseStream stream)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
while (!stream.EOF)
{
builder.Append(NextUnescapedChar(stream));
}
// Trimming left
int count = 0;
while (count < builder.Length &&
(builder [count] == ' ' || builder [count] == '\t'))
{
count++;
}
if (count >= 0)
{
builder.Remove(0, count);
}
// Trimming right
count = 0;
while (count < builder.Length &&
(builder [builder.Length - count - 1] == ' ' ||
builder [builder.Length - count - 1] == '\t'))
{
count++;
}
if (count >= 0)
{
builder.Remove(builder.Length - count, count);
}
return(builder.ToString());
}
/// <summary> Parses the exponential part of the float </summary>
private static long ParseScient(ParseStream stream)
{
ulong output = 0;
short sign;
if (stream.Char == '-')
{
sign = -1;
}
else if (stream.Char == '+')
{
sign = 1;
}
else
{
throw new ParseException(stream,
"Excepted + or - for the exponential part");
}
stream.Next(true);
while (!stream.EOF)
{
if (stream.Char >= '0' && stream.Char <= '9')
{
output = (10 * output) + (uint)stream.Char - '0';
}
else
{
throw new ParseException(stream,
"Unexepted char in exponential part: >" +
stream.Char + "<");
}
stream.Next(true);
}
return(sign * (long)output);
}
/// <summary>
/// Test for the value's inf, Inf and INF in the stream. If
/// found then it 'merged' with the sign and placed in the content.
/// There is no more data excepted behind it.
/// </summary>
private void ParseInf(ParseStream stream, int sign)
{
// Read the first 8 chars
char [] chars = new char [8];
int length = 0;
for (int i = 0; i < chars.Length && !stream.EOF; i++)
{
chars [i] = stream.Char;
length++;
stream.Next(true);
}
// Compare
if (length == 3)
{
string s = "" + chars [0] + chars [1] + chars [2];
if (s == "INF" || s == "Inf" || s == "inf")
{
if (sign < 0)
{
content = double.NegativeInfinity;
}
else
{
content = double.PositiveInfinity;
}
return;
}
}
throw new ParseException(stream, "No valid infinity");
}
/// <summary> Internal parse method </summary>
/// <param name="parseImplicitMappings">
/// Avoids ethernal loops while parsing implicit mappings. Implicit mappings are
/// not rocognized by a leading character. So while trying to parse the key of
/// something we think that could be a mapping, we're sure that if it is a mapping,
/// the key of this implicit mapping is not a mapping itself.
///
/// NOTE: Implicit mapping still belong to unstable code and require the UNSTABLE and
/// IMPLICIT_MAPPINGS preprocessor flags.
/// </param>
/// <param name="stream"></param>
protected static Node Parse (ParseStream stream, bool parseImplicitMappings)
{
// ----------------
// Skip Whitespace
// ----------------
if (! stream.EOF)
{
// Move the firstindentation pointer after the whitespaces of this line
stream.SkipSpaces ();
while (stream.Char == '\n' && ! stream.EOF)
{
// Skip newline and next whitespaces
stream.Next ();
stream.SkipSpaces ();
}
}
// -----------------
// No remaining chars (Null/empty stream)
// -----------------
if (stream.EOF)
return new Null ();
// -----------------
// Explicit type
// -----------------
#if SUPPORT_EXPLICIT_TYPES
stream.BuildLookaheadBuffer ();
char a = '\0', b = '\0';
a = stream.Char; stream.Next ();
b = stream.Char; stream.Next ();
// Starting with !!
if (a == '!' && b == '!' && ! stream.EOF)
{
stream.DestroyLookaheadBuffer ();
// Read the tagname
string tag = "";
while (stream.Char != ' ' && stream.Char != '\n' && ! stream.EOF)
{
tag += stream.Char;
stream.Next ();
}
// Skip Whitespace
if (! stream.EOF)
{
stream.SkipSpaces ();
while (stream.Char == '\n' && ! stream.EOF)
{
stream.Next ();
stream.SkipSpaces ();
}
}
// Parse
Node n;
switch (tag)
{
// Mappings and sequences
// NOTE:
// - sets are mappings without values
// - Ordered maps are ordered sequence of key: value
// pairs without duplicates.
// - Pairs are ordered sequence of key: value pairs
// allowing duplicates.
// TODO: Create new datatypes for omap and pairs
// derived from sequence with a extra duplicate
// checking.
case "seq": n = new Sequence (stream); break;
case "map": n = new Mapping (stream); break;
case "set": n = new Mapping (stream); break;
case "omap": n = new Sequence (stream); break;
case "pairs": n = new Sequence (stream); break;
// Scalars
//
// TODO: do we have to move this to Scalar.cs
// in order to get the following working:
//
// !!str "...": "..."
// !!str "...": "..."
case "timestamp": n = new Timestamp (stream); break;
case "binary": n = new Binary (stream); break;
case "null": n = new Null (stream); break;
case "float": n = new Float (stream); break;
case "int": n = new Integer (stream); break;
case "bool": n = new Boolean (stream); break;
case "str": n = new String (stream); break;
// Unknown data type
default:
throw new Exception ("Incorrect tag '!!" + tag + "'");
}
return n;
}
else
{
stream.RewindLookaheadBuffer ();
stream.DestroyLookaheadBuffer ();
}
#endif
// -----------------
// Sequence
// -----------------
if (stream.Char == '-' || stream.Char == '[')
return new Sequence (stream);
// -----------------
// Mapping
// -----------------
if (stream.Char == '?' || stream.Char == '{')
return new Mapping (stream);
// -----------------
// Try implicit mapping
// -----------------
// This are mappings which are not preceded by a question
// mark. The keys have to be scalars.
#if (UNSTABLE && SUPPORT_IMPLICIT_MAPPINGS)
// NOTE: This code can't be included in Mapping.cs
// because of the way we are using to rewind the buffer.
Node key, val;
if (parseImplicitMappings)
{
// First Key/value pair
stream.BuildLookaheadBuffer ();
stream.StopAt (new char [] {':'});
// Keys of implicit mappings can't be sequences, or other mappings
// just look for scalars
key = Scalar.Parse (stream, false);
stream.DontStop ();
Console.WriteLine ("key: " + key);
// Followed by a colon, so this is a real mapping
if (stream.Char == ':')
{
stream.DestroyLookaheadBuffer ();
Mapping mapping = new Mapping ();
// Skip colon and spaces
stream.Next ();
stream.SkipSpaces ();
// Parse the value
Console.Write ("using buffer: " + stream.UsingBuffer ());
stream.Indent ();
Console.Write ("using buffer: " + stream.UsingBuffer ());
// val = Parse (stream, false);
Console.Write ("<<");
while (!stream.EOF) {Console.Write (stream.Char);stream.Next (true);}
Console.Write (">>");
val = new String (stream);
Console.Write ("using buffer: " + stream.UsingBuffer ());
stream.UnIndent ();
Console.Write ("using buffer: " + stream.UsingBuffer ());
Console.Write ("<<");
while (!stream.EOF) {Console.Write (stream.Char);stream.Next (true);}
Console.Write (">>");
Console.WriteLine ("val: " + val);
mapping.AddMappingNode (key, val);
// Skip possible newline
// NOTE: this can't be done by the drop-newline
// method since this is not the end of a block
while (stream.Char == '\n')
stream.Next (true);
// Other key/value pairs
while (! stream.EOF)
{
stream.StopAt (new char [] {':'} );
stream.Indent ();
key = Scalar.Parse (stream);
stream.UnIndent ();
stream.DontStop ();
Console.WriteLine ("key 2: " + key);
if (stream.Char == ':')
{
// Skip colon and spaces
stream.Next ();
stream.SkipSpaces ();
// Parse the value
stream.Indent ();
val = Parse (stream);
stream.UnIndent ();
Console.WriteLine ("val 2: " + val);
mapping.AddMappingNode (key, val);
}
else // TODO: Is this an error?
{
// NOTE: We can't recover from this error,
// the last buffer has been destroyed, so
// rewinding is impossible.
throw new ParseException (stream,
"Implicit mapping without value node");
}
// Skip possible newline
while (stream.Char == '\n')
stream.Next ();
}
return mapping;
}
stream.RewindLookaheadBuffer ();
stream.DestroyLookaheadBuffer ();
}
#endif
// -----------------
// No known data structure, assume this is a scalar
// -----------------
Scalar scalar = Scalar.Parse (stream);
// Skip trash
while (! stream.EOF)
stream.Next ();
return scalar;
}
/// <summary> Constructor </summary>
/// <param name="stream"> The parse stream (contains the line number where it went wrong) </param>
/// <param name="message"> Info about the exception </param>
public ParseException(ParseStream stream, string message) :
base("Parse error near line " + stream.CurrentLine + ": " + message)
{
this.linenr = stream.CurrentLine;
}
/// <summary> Constructor </summary>
/// <param name="stream"> The parse stream (contains the line number where it went wrong) </param>
/// <param name="child"> The exception that is for example throwed again </param>
public ParseException(ParseStream stream, Exception child)
: base("Parse error near line " + stream.CurrentLine, child)
{
this.linenr = stream.CurrentLine;
}
/// <summary> Parses a string with base 60, without sign </summary>
private static long Parse60(ParseStream stream, short sign)
{
ulong output = 0;
// Parse
ulong part = 0;
bool firstPart = true; // Only the first part can be larger then 59
while (!stream.EOF)
{
// Decimal
if (stream.Char >= '0' && stream.Char <= '9')
{
part = (part * 10) + (uint)(stream.Char - '0');
}
// New part
else if (stream.Char == ':')
{
// Only the first part can be largen then 60
if (!firstPart)
{
if (part >= 60)
{
throw new
Exception("Part of base 60 scalar is too large (max. 59)");
}
else
{
firstPart = false;
}
}
output = (output * 60) + part;
OverflowTest(output, sign);
part = 0;
}
// Ignore underscores, other chars are not allowed
else if (stream.Char != '_')
{
throw new Exception("Unknown char in base 16");
}
stream.Next();
}
// Add last part to the output
if (!firstPart)
{
if (part >= 60)
{
throw new Exception(
"Part of base 60 scalar is too large (max. 59)");
}
else
{
firstPart = false;
}
}
output = (output * 60) + part;
OverflowTest(output, sign);
return(sign * (long)output);
}
/// <summary>
/// Parse the milliseconds
/// </summary>
private int ParseMilliSeconds(ParseStream stream)
{
int ms = 0;
// Look for fraction
if (stream.Char == '.')
{
stream.Next (true);
// Parse fraction, can consists of an
// unlimited sequence of numbers, we only
// look to the first three (max 1000)
int count = 0;
while (stream.Char >= '0' && stream.Char <= '9' &&
count < 3 && ! stream.EOF)
{
ms *= 10;
ms += stream.Char - '0';
stream.Next (true);
count ++;
}
if (count == 1) ms *= 100;
if (count == 2) ms *= 10;
if (count == 3) ms *= 1;
// Ignore the rest
while (stream.Char >= '0' && stream.Char <= '9' &&
! stream.EOF)
stream.Next (true);
}
return ms;
}
/// <summary>
/// Reads a character from the stream, unescapes it,
/// and moves to the next character.
/// </summary>
private char NextUnescapedChar(ParseStream stream)
{
char c = stream.Char;
// If escaped
if (c == '\\')
{
// Never stop, every special character
// looses its meaning behind a backslash.
stream.StopAt(new Char [] { });
stream.Next(true);
c = stream.Char;
// ASCII null
if (c == '0')
{
c = '\0';
}
// ASCII bell
else if (c == 'a')
{
c = (char)0x7;
}
// ASCII backspace
else if (c == 'b')
{
c = (char)0x8;
}
// ASCII horizontal tab
else if (c == 't')
{
c = (char)0x9;
}
// ASCII newline
else if (c == 'n')
{
c = (char)0xA;
}
// ASCII vertical tab
else if (c == 'v')
{
c = (char)0xB;
}
// ASCII form feed
else if (c == 'f')
{
c = (char)0xC;
}
// ASCII carriage return
else if (c == 'r')
{
c = (char)0xD;
}
// ASCII escape
else if (c == 'e')
{
c = (char)0x1D;
}
// Unicode next line
else if (c == 'N')
{
c = (char)0x85;
}
// Unicode non breaking space
else if (c == '_')
{
c = (char)0xA0;
}
// TODO larger unicode characters
// Unicode line separator
// else if (c == 'L') c = (char) 0x20282028;
// 8 bit hexadecimal
else if (c == 'x')
{
int c_int = (char)0;
for (int i = 0; i < 2; i++)
{
c_int *= 16;
stream.Next();
char d = stream.Char;
if (d >= '0' && d <= '9')
{
c_int += d - '0';
}
else if (d >= 'a' && d <= 'f')
{
c_int += d - 'a';
}
else if (d >= 'A' && d <= 'F')
{
c_int += d - 'A';
}
else
{
stream.DontStop();
throw new ParseException(stream,
"Invalid escape sequence");
}
}
c = (char)c_int;
}
stream.Next(true);
// Restore last stop settings
stream.DontStop();
}
else
{
stream.Next(true);
}
return(c);
}
/// <summary> Parse function </summary>
protected static Node Parse (ParseStream stream) { return Parse (stream, true); }
/// <summary> Parses a binairy node. </summary>
/// <remarks>
/// This is not an efficient method. First the stream is placed
/// in a string. And after that the string is converted in a byte[].
/// If there is a fault in the binairy string then that will only be detected
/// after reading the whole stream and after coneverting.
/// </remarks>
public static new byte[] Parse(ParseStream stream)
{
bool quoted = false;
bool block = false;
System.Text.StringBuilder input = new System.Text.StringBuilder();
if (stream.EOF)
throw new ParseException (stream, "Empty node");
// Detect block scalar
stream.SkipSpaces ();
if (stream.Char == '|')
{
block = true;
stream.Next ();
stream.SkipSpaces ();
}
while ( ! stream.EOF)
{
// Detect quotes
if (stream.Char == '\"')
if (quoted)
break; //End of stream
else
quoted = true; //Start of quoted stream
// Detect and ignore newline char's
else if (!(stream.Char == '\n' && block))
input.Append( stream.Char );
stream.Next ();
}
//Console.WriteLine("convert [" + input.ToString() + "]");
return System.Convert.FromBase64String (input.ToString ());
}
/// <summary>
/// Reads a character from the stream, unescapes it,
/// and moves to the next character.
/// </summary>
private char NextUnescapedChar(ParseStream stream)
{
char c = stream.Char;
// If escaped
if (c == '\\')
{
// Never stop, every special character
// looses its meaning behind a backslash.
stream.StopAt (new Char [] { });
stream.Next (true);
c = stream.Char;
// ASCII null
if (c == '0') c = '\0';
// ASCII bell
else if (c == 'a') c = (char) 0x7;
// ASCII backspace
else if (c == 'b') c = (char) 0x8;
// ASCII horizontal tab
else if (c == 't') c = (char) 0x9;
// ASCII newline
else if (c == 'n') c = (char) 0xA;
// ASCII vertical tab
else if (c == 'v') c = (char) 0xB;
// ASCII form feed
else if (c == 'f') c = (char) 0xC;
// ASCII carriage return
else if (c == 'r') c = (char) 0xD;
// ASCII escape
else if (c == 'e') c = (char) 0x1D;
// Unicode next line
else if (c == 'N') c = (char) 0x85;
// Unicode non breaking space
else if (c == '_') c = (char) 0xA0;
// TODO larger unicode characters
// Unicode line separator
// else if (c == 'L') c = (char) 0x20282028;
// 8 bit hexadecimal
else if (c == 'x')
{
int c_int = (char) 0;
for (int i = 0; i < 2; i ++)
{
c_int *= 16;
stream.Next ();
char d = stream.Char;
if (d >= '0' && d <= '9')
c_int += d - '0';
else if (d >= 'a' && d <= 'f')
c_int += d - 'a';
else if (d >= 'A' && d <= 'F')
c_int += d - 'A';
else
{
stream.DontStop ();
throw new ParseException (stream,
"Invalid escape sequence");
}
}
c = (char) c_int;
}
stream.Next (true);
// Restore last stop settings
stream.DontStop ();
}
else
stream.Next (true);
return c;
}
/// <summary>
/// Skips a specified char, and throws an exception when
/// another char was found.
/// </summary>
private void SkipChar(ParseStream stream, char toSkip)
{
if (stream.Char == toSkip)
stream.Next (true);
else
throw new Exception ("Unexpected character");
}
/// <summary>
/// Skips the spaces * and tabs * in the current stream
/// </summary>
private void SkipWhitespace(ParseStream stream)
{
while ((stream.Char == ' ' || stream.Char == '\t') && ! stream.EOF)
stream.Next (true);
}
/// <summary>
/// Parse the time zone
/// </summary>
private double ParseTimezone(ParseStream stream)
{
double timezone = 0;
SkipWhitespace (stream);
// Timezone = UTC, use by default 0
if (stream.Char == 'Z')
stream.Next (true);
else
{
// Find the sign of the offset
int sign = 0;
if (stream.Char == '-')
sign = -1;
else if (stream.Char == '+')
sign = +1;
else
throw new Exception ("Invalid time zone: " +
"unexpected character");
// Read next char and test for more chars
stream.Next (true);
if (stream.EOF)
throw new Exception ("Invalid time zone");
// Parse hour offset
// Note: A hour can be represented by one or two digits.
string hulp = "";
while (stream.Char >= '0' &&
stream.Char <= '9' &&
!stream.EOF && hulp.Length <= 2)
{
hulp += (stream.Char);
stream.Next (true);
}
timezone = sign * Double.Parse (hulp);
// Parse the minutes of the timezone
// when there is still more to parse
if ( ! stream.EOF)
{
SkipChar (stream, ':');
int temp = ParseNumber (stream, 2);
timezone += (temp / 60.0);
}
}
return timezone;
}
/// <summary>
/// Parse the time (hours, minutes, seconds)
/// </summary>
private void ParseTime(ParseStream stream,
out int hour, out int minutes, out int seconds)
{
if (stream.Char == 't' || stream.Char == 'T')
stream.Next (true);
else
SkipWhitespace (stream);
// Parse hour
// Note: A hour can be represented by one or two digits.
string hulp = "";
while (stream.Char >= '0' && stream.Char <= '9' &&
! stream.EOF && hulp.Length <= 2)
{
hulp += stream.Char;
stream.Next (true);
}
hour = Int32.Parse (hulp);
SkipChar (stream, ':');
// Parse minutes
minutes = ParseNumber (stream, 2);
SkipChar (stream, ':');
// Parse seconds
seconds = ParseNumber (stream, 2);
}
/// <summary>
/// Parse an integer
/// </summary>
/// <param name="length">
/// The number of characters that the integer is expected to be.
/// </param>
/// <param name="stream"> The stream that will be parsed </param>
private int ParseNumber(ParseStream stream, int length)
{
System.Text.StringBuilder hulp = new System.Text.StringBuilder ();
int i;
for (i = 0; i < length && !stream.EOF; i++)
{
hulp.Append (stream.Char);
stream.Next (true);
}
if (i == length)
return Int32.Parse (hulp.ToString ());
else
throw new Exception ("Can't parse number");
}
/// <summary> Parses a string with base 60, without sign </summary>
private static long Parse60(ParseStream stream, short sign)
{
ulong output = 0;
// Parse
ulong part = 0;
bool firstPart = true; // Only the first part can be larger then 59
while (! stream.EOF)
{
// Decimal
if (stream.Char >= '0' && stream.Char <= '9')
part = (part * 10) + (uint) (stream.Char - '0');
// New part
else if (stream.Char == ':')
{
// Only the first part can be largen then 60
if ( ! firstPart)
if (part >= 60)
throw new
Exception ("Part of base 60 scalar is too large (max. 59)");
else
firstPart = false;
output = (output * 60) + part;
OverflowTest(output, sign);
part = 0;
}
// Ignore underscores, other chars are not allowed
else if (stream.Char != '_')
throw new Exception ("Unknown char in base 16");
stream.Next ();
}
// Add last part to the output
if (!firstPart)
if (part >= 60)
throw new Exception (
"Part of base 60 scalar is too large (max. 59)");
else
firstPart = false;
output = (output * 60) + part;
OverflowTest (output, sign);
return sign * (long) output;
}
/// <summary>
/// Parses a String surrounded with double quotes
/// </summary>
private string ParseDoubleQuoted(ParseStream stream)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder ();
// Skip '"'
stream.Next ();
// Stop at "
stream.StopAt (new char [] {'\"'} );
while (! stream.EOF)
{
if (stream.Char == '\n')
{
builder.Append (' ');
stream.Next ();
}
else
builder.Append (NextUnescapedChar (stream));
}
// Don't stop at "
stream.DontStop ();
// Skip '"'
if (stream.Char != '\"')
throw new ParseException (stream,
"Double quoted string not closed");
else
stream.Next (true);
return builder.ToString();
}
/// <summary> Constructor </summary>
/// <param name="stream"> The parse stream (contains the line number where it went wrong) </param>
/// <param name="child"> The exception that is for example throwed again </param>
public ParseException(ParseStream stream, Exception child) :
base("Parse error near line " + stream.CurrentLine, child)
{
this.linenr = stream.CurrentLine;
}
/// <summary> Parse a mapping </summary>
public Mapping(ParseStream stream) :
base("tag:yaml.org,2002:map", NodeType.Mapping)
{
// Mapping with eplicit key, (implicit mappings are threaded
// in Node.cs)
if (stream.Char == '?')
{
// Parse recursively
do
{
Node key, val;
// Skip over '?'
stream.Next();
stream.SkipSpaces();
// Parse recursively. The false param avoids
// looking recursively for implicit mappings.
stream.StopAt(new char [] { ':' });
stream.Indent();
key = Parse(stream, false);
stream.UnIndent();
stream.DontStop();
// Parse recursively. The false param avoids
// looking for implit nodes
if (stream.Char == ':')
{
// Skip over ':'
stream.Next();
stream.SkipSpaces();
// Parse recursively
stream.Indent();
val = Parse(stream);
stream.UnIndent();
}
else
{
val = new Null();
}
AddMappingNode(key, val);
// Skip possible newline
// NOTE: this can't be done by the drop-newline
// method since this is not the end of a block
if (stream.Char == '\n')
{
stream.Next();
}
}while (!stream.EOF && stream.Char == '?');
}
// Inline mapping
else if (stream.Char == '{')
{
// Override the parent's stop chars, never stop
stream.StopAt(new char [] { });
// Skip '{'
stream.Next();
do
{
Node key, val;
// Skip '?'
// (NOTE: it's not obligated to use this '?',
// especially because this is an inline mapping)
if (stream.Char == '?')
{
stream.Next();
stream.SkipSpaces();
}
// Parse recursively the key
stream.StopAt(new char [] { ':', ',', '}' });
stream.Indent();
key = Parse(stream, false);
stream.UnIndent();
stream.DontStop();
// Value
if (stream.Char == ':')
{
// Skip colon
stream.Next();
stream.SkipSpaces();
// Parse recursively the value
stream.StopAt(new char [] { '}', ',' });
stream.Indent();
val = Parse(stream, false);
stream.UnIndent();
stream.DontStop();
}
else
{
val = new Null();
}
AddMappingNode(key, val);
// Skip comma (key sepatator)
if (stream.Char != '}' && stream.Char != ',')
{
stream.DontStop();
throw new ParseException(stream, "Comma expected in inline sequence");
}
if (stream.Char == ',')
{
stream.Next();
stream.SkipSpaces();
}
}while (!stream.EOF && stream.Char != '}');
// Re-accept the parent's stop chars
stream.DontStop();
// Skip '}'
if (stream.Char == '}')
{
stream.Next();
}
else
{
throw new ParseException(stream, "Inline mapping not closed");
}
}
}
/// <summary> Parse a string </summary>
public String(ParseStream stream) :
base("tag:yaml.org,2002:str", NodeType.String)
{
// set flags for folded or block scalar
if (stream.Char == '>') // TODO: '+' and '-' chomp chars
{
folded = true;
}
else if (stream.Char == '|')
{
block = true;
}
if (block || folded)
{
stream.Next();
stream.SkipSpaces();
}
// -----------------
// Folded Scalar
// -----------------
if (folded)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
// First line (the \n after the first line is always ignored,
// not replaced with a whitespace)
while (!stream.EOF && stream.Char != '\n')
{
builder.Append(stream.Char);
stream.Next();
}
// Skip the first newline
stream.Next();
// Next lines (newlines will be replaced by spaces in folded scalars)
while (!stream.EOF)
{
if (stream.Char == '\n')
{
builder.Append(' ');
}
else
{
builder.Append(stream.Char);
}
stream.Next(true);
}
content = builder.ToString();
}
// -----------------
// Block Scalar (verbatim block without folding)
// -----------------
else if (block)
{
/*
* Console.Write(">>");
* while (! stream.EOF)
* {
* Console.Write (stream.Char);
* stream.Next();
* }
* Console.Write("<<");
* // */
System.Text.StringBuilder builder = new System.Text.StringBuilder();
while (!stream.EOF)
{
builder.Append(stream.Char);
stream.Next(true);
}
content = builder.ToString();
}
// String between double quotes
if (stream.Char == '\"')
{
content = ParseDoubleQuoted(stream);
}
// Single quoted string
else if (stream.Char == '\'')
{
content = ParseSingleQuoted(stream);
}
// String without quotes
else
{
content = ParseUnQuoted(stream);
}
}
/// <summary> Parse a mapping </summary>
public Mapping(ParseStream stream)
: base("tag:yaml.org,2002:map", NodeType.Mapping)
{
// Mapping with eplicit key, (implicit mappings are threaded
// in Node.cs)
if (stream.Char == '?')
{
// Parse recursively
do {
Node key, val;
// Skip over '?'
stream.Next ();
stream.SkipSpaces ();
// Parse recursively. The false param avoids
// looking recursively for implicit mappings.
stream.StopAt (new char [] {':'});
stream.Indent ();
key = Parse (stream, false);
stream.UnIndent ();
stream.DontStop ();
// Parse recursively. The false param avoids
// looking for implit nodes
if (stream.Char == ':')
{
// Skip over ':'
stream.Next ();
stream.SkipSpaces ();
// Parse recursively
stream.Indent ();
val = Parse (stream);
stream.UnIndent ();
}
else
val = new Null ();
AddMappingNode (key, val);
// Skip possible newline
// NOTE: this can't be done by the drop-newline
// method since this is not the end of a block
if (stream.Char == '\n')
stream.Next ();
}
while ( ! stream.EOF && stream.Char == '?');
}
// Inline mapping
else if (stream.Char == '{')
{
// Override the parent's stop chars, never stop
stream.StopAt (new char [] { });
// Skip '{'
stream.Next ();
do {
Node key, val;
// Skip '?'
// (NOTE: it's not obligated to use this '?',
// especially because this is an inline mapping)
if (stream.Char == '?')
{
stream.Next ();
stream.SkipSpaces ();
}
// Parse recursively the key
stream.StopAt (new char [] {':', ',', '}'});
stream.Indent ();
key = Parse (stream, false);
stream.UnIndent ();
stream.DontStop ();
// Value
if (stream.Char == ':')
{
// Skip colon
stream.Next ();
stream.SkipSpaces ();
// Parse recursively the value
stream.StopAt (new char [] {'}', ','});
stream.Indent ();
val = Parse (stream, false);
stream.UnIndent ();
stream.DontStop ();
}
else
val = new Null ();
AddMappingNode (key, val);
// Skip comma (key sepatator)
if (stream.Char != '}' && stream.Char != ',')
{
stream.DontStop ();
throw new ParseException (stream, "Comma expected in inline sequence");
}
if (stream.Char == ',')
{
stream.Next ();
stream.SkipSpaces ();
}
}
while ( ! stream.EOF && stream.Char != '}' );
// Re-accept the parent's stop chars
stream.DontStop ();
// Skip '}'
if (stream.Char == '}')
stream.Next ();
else
throw new ParseException (stream, "Inline mapping not closed");
}
}
/// <summary>
/// Parse a Yaml string from a textfile and return a Yaml tree
/// </summary>
public static Node FromFile (string filename)
{
// Open YAML file
StreamReader reader = File.OpenText (filename);
ParseStream parsestream = new ParseStream (reader);
// Parse
Node node = Parse (parsestream);
// Close YAML file
reader.Close ();
return node;
}
/// <summary> Parse boolean </summary>
public Boolean(ParseStream stream) :
base("tag:yaml.org,2002:bool", NodeType.Boolean)
{
// Read the first 8 chars
char [] chars = new char [8];
int length = 0;
for (int i = 0; i < chars.Length && !stream.EOF; i++)
{
chars [i] = stream.Char;
length++;
stream.Next(true);
}
// Compare
if (length == 1)
{
if (chars[0] == 'Y' || chars[0] == 'y')
{
content = true; return;
}
if (chars[0] == 'N' || chars[0] == 'n')
{
content = false; return;
}
}
if (length == 2)
{
string s = "" + chars [0] + chars [1];
if (s == "ON" || s == "On" || s == "on")
{
content = true; return;
}
if (s == "NO" || s == "No" || s == "no")
{
content = false; return;
}
}
if (length == 3)
{
string s = "" + chars [0] + chars [1] + chars [2];
if (s == "YES" || s == "Yes" || s == "yes")
{
content = true; return;
}
if (s == "OFF" || s == "Off" || s == "off")
{
content = false; return;
}
}
if (length == 4)
{
string s = "" + chars [0] + chars [1] + chars [2] + chars [3];
if (s == "TRUE" || s == "True" || s == "true")
{
content = true; return;
}
}
if (length == 5)
{
string s = "" + chars [0] + chars [1] + chars [2] + chars [3] + chars[4];
if (s == "FALSE" || s == "False" || s == "false")
{
content = false; return;
}
}
// No boolean
throw new Exception("No valid boolean");
}
/// <summary> Parse an integer </summary>
public Integer(ParseStream stream) :
base("tag:yaml.org,2002:int", NodeType.Integer)
{
short sign = 1; // Positive sign by default
// Negative sign
if (stream.Char == '-')
{
sign = -1;
stream.Next();
}
// Positive sign
else if (stream.Char == '+')
{
stream.Next();
}
try
{
// Determine base
if (stream.Char == '0')
{
stream.Next();
// Base 2
if (stream.Char == 'b')
{
stream.Next();
content = ParseBase(stream, 2, sign);
return;
}
// Base 16
else if (stream.Char == 'x')
{
stream.Next();
content = Parse16(stream, sign);
return;
}
// Base 8
else
{
content = ParseBase(stream, 8, sign);
return;
}
}
// Other base
stream.BuildLookaheadBuffer();
// First, try to parse with base 10
try
{
content = ParseBase(stream, 10, sign);
stream.DestroyLookaheadBuffer();
return;
}
catch { }
// If not parseable with base 10, then try base 60
stream.RewindLookaheadBuffer();
stream.DestroyLookaheadBuffer();
content = Parse60(stream, sign);
}
catch (Exception ex)
{
throw new ParseException(stream, ex.ToString());
}
}
/// <summary> Hexadecimal string </summary>
private static long Parse16(ParseStream stream, short sign)
{
uint output = 0;
while (! stream.EOF)
{
// 0 .. 9
if (stream.Char >= '0' && stream.Char <= '9')
{
output = (output * 16) + (uint) (stream.Char - '0');
OverflowTest (output, sign);
}
// a .. f
else if (stream.Char >= 'a' && stream.Char <= 'f')
{
output = (output * 16) + (uint) (stream.Char - 'a') + 10;
OverflowTest (output, sign);
}
// A .. F
else if (stream.Char >= 'A' && stream.Char <= 'F')
{
output = (output * 16) + (uint) (stream.Char - 'A') + 10;
OverflowTest(output, sign);
}
// Ignore underscores, other chars are not allowed
else if (stream.Char != '_')
throw new Exception ("Unknown char in base 16");
stream.Next ();
}
return (long) (sign * output);
}
/// <summary> Parse boolean </summary>
public Boolean(ParseStream stream)
: base("tag:yaml.org,2002:bool", NodeType.Boolean)
{
// Read the first 8 chars
char [] chars = new char [8];
int length = 0;
for (int i = 0; i < chars.Length && ! stream.EOF; i ++)
{
chars [i] = stream.Char;
length ++;
stream.Next (true);
}
// Compare
if (length == 1)
{
if (chars[0] == 'Y' || chars[0] == 'y')
{ content = true; return; }
if (chars[0] == 'N' || chars[0] == 'n')
{ content = false; return; }
}
if (length == 2)
{
string s = "" + chars [0] + chars [1];
if (s == "ON" || s == "On" || s == "on")
{ content = true; return; }
if (s == "NO" || s == "No" || s == "no")
{ content = false; return; }
}
if (length == 3)
{
string s = "" + chars [0] + chars [1] + chars [2];
if (s == "YES" || s == "Yes" || s == "yes")
{ content = true; return; }
if (s == "OFF" || s == "Off" || s == "off")
{ content = false; return; }
}
if (length == 4)
{
string s = "" + chars [0] + chars [1] + chars [2] + chars [3];
if (s == "TRUE" || s == "True" || s == "true")
{ content = true; return; }
}
if (length == 5)
{
string s = "" + chars [0] + chars [1] + chars [2] + chars [3] + chars[4];
if (s == "FALSE" || s == "False" || s == "false")
{ content = false; return; }
}
// No boolean
throw new Exception ("No valid boolean");
}
/// <summary> Parses a string with a given base (maximum 10) </summary>
/// <remarks>
/// This is not completly correct. For base10 the first char may not be a '_'
/// The other bases allow this...
/// </remarks>
private static long ParseBase(ParseStream stream, uint basis, short sign)
{
// Base must be <= 10
if (basis > 10)
throw new Exception ("Base to large. Maximum 10");
ulong output = 0;
char max = (char) ((basis - 1) + (int) '0');
// Parse
while (! stream.EOF)
{
// Decimal
if (stream.Char >= '0' && stream.Char <= max)
{
output = (output * basis) + (uint) (stream.Char - '0');
OverflowTest (output, sign);
}
// Ignore underscores, but other chars are not allowed
// see remarks
else if (stream.Char != '_')
throw new Exception ("Unknown char in base " + basis);
stream.Next ();
}
return sign * (long) output;
}
/// <summary>
/// Parses a scalar
/// <list type="bullet">
/// <item>Integer</item>
/// <item>String</item>
/// <item>Boolean</item>
/// <item>Null</item>
/// <item>Timestamp</item>
/// <item>Float</item>
/// <item>Binary</item>
/// </list>
/// </summary>
/// <remarks>
/// Binary is only parsed behind an explicit !!binary tag (in Node.cs)
/// </remarks>
public static new Scalar Parse(ParseStream stream)
{
// -----------------
// Parse scalars
// -----------------
stream.BuildLookaheadBuffer();
// Try Null
#if SUPPORT_NULL_NODES
try
{
Scalar s = new Null(stream);
stream.DestroyLookaheadBuffer();
return(s);
} catch { }
#endif
// Try boolean
#if SUPPORT_BOOLEAN_NODES
stream.RewindLookaheadBuffer();
try
{
Scalar scalar = new Boolean(stream);
stream.DestroyLookaheadBuffer();
return(scalar);
}
catch { }
#endif
// Try integer
#if SUPPORT_INTEGER_NODES
stream.RewindLookaheadBuffer();
try
{
Scalar scalar = new Integer(stream);
stream.DestroyLookaheadBuffer();
return(scalar);
} catch { }
#endif
// Try Float
#if SUPPORT_FLOAT_NODES
stream.RewindLookaheadBuffer();
try
{
Scalar scalar = new Float(stream);
stream.DestroyLookaheadBuffer();
return(scalar);
}
catch { }
#endif
// Try timestamp
#if SUPPORT_TIMESTAMP_NODES
stream.RewindLookaheadBuffer();
try {
Scalar scalar = new Timestamp(stream);
stream.DestroyLookaheadBuffer();
return(scalar);
} catch { }
#endif
// Other scalars are strings
stream.RewindLookaheadBuffer();
stream.DestroyLookaheadBuffer();
return(new String(stream));
}
/// <summary> Parse an integer </summary>
public Integer(ParseStream stream)
: base("tag:yaml.org,2002:int", NodeType.Integer)
{
short sign = 1; // Positive sign by default
// Negative sign
if (stream.Char == '-')
{
sign = -1;
stream.Next ();
}
// Positive sign
else if (stream.Char == '+')
stream.Next ();
try
{
// Determine base
if (stream.Char == '0')
{
stream.Next ();
// Base 2
if (stream.Char == 'b')
{
stream.Next ();
content = ParseBase (stream, 2, sign);
return;
}
// Base 16
else if (stream.Char == 'x')
{
stream.Next ();
content = Parse16 (stream, sign);
return;
}
// Base 8
else
{
content = ParseBase (stream, 8, sign);
return;
}
}
// Other base
stream.BuildLookaheadBuffer ();
// First, try to parse with base 10
try
{
content = ParseBase (stream, 10, sign);
stream.DestroyLookaheadBuffer ();
return;
}
catch { }
// If not parseable with base 10, then try base 60
stream.RewindLookaheadBuffer ();
stream.DestroyLookaheadBuffer ();
content = Parse60 (stream, sign);
}
catch (Exception ex)
{
throw new ParseException (stream, ex.ToString ());
}
}
/// <summary>
/// Parses a String surrounded with single quotes
/// </summary>
private string ParseSingleQuoted(ParseStream stream)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder ();
// Start literal parsing
stream.StartLiteral ();
// Skip '''
stream.Next (true);
while (! stream.EOF)
{
if (stream.Char == '\'')
{
stream.Next ();
// Escaped single quote
if (stream.Char == '\'')
builder.Append (stream.Char);
// End of string
else
break;
}
else
builder.Append (stream.Char);
stream.Next ();
// Skip \'
if (stream.EOF)
{
stream.StopLiteral ();
throw new ParseException (stream,
"Single quoted string not closed");
}
}
// Stop literal parsing
stream.StopLiteral ();
return builder.ToString();
}
/// <summary>
/// Parses a scalar
/// <list type="bullet">
/// <item>Integer</item>
/// <item>String</item>
/// <item>Boolean</item>
/// <item>Null</item>
/// <item>Timestamp</item>
/// <item>Float</item>
/// <item>Binary</item>
/// </list>
/// </summary>
/// <remarks>
/// Binary is only parsed behind an explicit !!binary tag (in Node.cs)
/// </remarks>
public static new Scalar Parse (ParseStream stream)
{
// -----------------
// Parse scalars
// -----------------
stream.BuildLookaheadBuffer ();
// Try Null
#if SUPPORT_NULL_NODES
try
{
Scalar s = new Null (stream);
stream.DestroyLookaheadBuffer ();
return s;
} catch { }
#endif
// Try boolean
#if SUPPORT_BOOLEAN_NODES
stream.RewindLookaheadBuffer ();
try
{
Scalar scalar = new Boolean (stream);
stream.DestroyLookaheadBuffer ();
return scalar;
}
catch { }
#endif
// Try integer
#if SUPPORT_INTEGER_NODES
stream.RewindLookaheadBuffer ();
try
{
Scalar scalar = new Integer (stream);
stream.DestroyLookaheadBuffer ();
return scalar;
} catch { }
#endif
// Try Float
#if SUPPORT_FLOAT_NODES
stream.RewindLookaheadBuffer ();
try
{
Scalar scalar = new Float (stream);
stream.DestroyLookaheadBuffer ();
return scalar;
}
catch { }
#endif
// Try timestamp
#if SUPPORT_TIMESTAMP_NODES
stream.RewindLookaheadBuffer ();
try {
Scalar scalar = new Timestamp (stream);
stream.DestroyLookaheadBuffer ();
return scalar;
} catch { }
#endif
// Other scalars are strings
stream.RewindLookaheadBuffer ();
stream.DestroyLookaheadBuffer ();
return new String (stream);
}
/// <summary>
/// If it is not Infinity or NaN, then parse as a number
/// </summary>
private void ParseNumber(ParseStream stream, int sign)
{
bool base60 = false; // Base 60 with ':'
bool afterDecimal = false; // Before or after the decimal point
double factor = 0.1;
double part; // If base60 different parts, else output value
// Set sign
content = sign >= 0 ? 1 : -1;
// First char must 0-9
if (stream.Char >= '0' && stream.Char <= '9')
{
part = (uint)(stream.Char - '0');
stream.Next(true);
}
else
{
throw new ParseException(stream,
"No valid float: Invalid first character of float: " + stream.Char);
}
while (!stream.EOF)
{
// Decimal
if (stream.Char >= '0' && stream.Char <= '9')
{
if (afterDecimal)
{
part += (uint)(stream.Char - '0') * factor;
factor *= 0.1;
}
else
{
part = (part * 10) + (uint)(stream.Char - '0');
}
}
// Base60 detected
else if (stream.Char == ':')
{
if (!base60) // First time
{
content *= part; // Multiply to get sign
part = 0;
base60 = true; // We are now sure base 60
}
else
{
if (part > 59)
{
throw new ParseException(stream,
"Part of base 60 can't be larger then 59");
}
content = (60 * content) + part;
part = 0;
}
}
// If first '.', then after decimal, else it is ignored if not in Base60
else if ((!base60 || (base60 && !afterDecimal)) && stream.Char == '.')
{
afterDecimal = true;
}
// Determine scientific notation
else if ((stream.Char == 'E' || stream.Char == 'e') && !base60)
{
stream.Next(true);
content *= Math.Pow(10, ParseScient(stream));
}
// Ignore underscores if before the decimal point, special case if base 60
else if ((!afterDecimal || (afterDecimal && base60)) && stream.Char != '_')
{
throw new ParseException(stream, "Unknown char");
}
stream.Next(true);
}
// Add last part of base to content
if (base60)
{
content = (60 * content) + part;
}
else
{
content *= part; // Multiply to get sign
}
}
/// <summary>
/// Parses a String surrounded without nothing
/// </summary>
private string ParseUnQuoted(ParseStream stream)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder ();
while (! stream.EOF)
builder.Append (NextUnescapedChar (stream));
// Trimming left
int count = 0;
while (count < builder.Length &&
(builder [count] == ' ' || builder [count] == '\t'))
count ++;
if (count >= 0)
builder.Remove (0, count);
// Trimming right
count = 0;
while (count < builder.Length &&
(builder [builder.Length - count - 1] == ' ' ||
builder [builder.Length - count - 1] == '\t'))
count ++;
if (count >= 0)
builder.Remove (builder.Length - count, count);
return builder.ToString();
}
/// <summary> Parse a string </summary>
public String(ParseStream stream)
: base("tag:yaml.org,2002:str", NodeType.String)
{
// set flags for folded or block scalar
if (stream.Char == '>') // TODO: '+' and '-' chomp chars
folded = true;
else if (stream.Char == '|')
block = true;
if (block || folded)
{
stream.Next ();
stream.SkipSpaces ();
}
// -----------------
// Folded Scalar
// -----------------
if (folded)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder ();
// First line (the \n after the first line is always ignored,
// not replaced with a whitespace)
while (! stream.EOF && stream.Char != '\n')
{
builder.Append (stream.Char);
stream.Next ();
}
// Skip the first newline
stream.Next ();
// Next lines (newlines will be replaced by spaces in folded scalars)
while (! stream.EOF)
{
if (stream.Char == '\n')
builder.Append (' ');
else
builder.Append (stream.Char);
stream.Next (true);
}
content = builder.ToString ();
}
// -----------------
// Block Scalar (verbatim block without folding)
// -----------------
else if (block)
{
/*
Console.Write(">>");
while (! stream.EOF)
{
Console.Write (stream.Char);
stream.Next();
}
Console.Write("<<");
// */
System.Text.StringBuilder builder = new System.Text.StringBuilder ();
while (! stream.EOF)
{
builder.Append (stream.Char);
stream.Next (true);
}
content = builder.ToString ();
}
// String between double quotes
if (stream.Char == '\"')
content = ParseDoubleQuoted (stream);
// Single quoted string
else if (stream.Char == '\'')
content = ParseSingleQuoted (stream);
// String without quotes
else
content = ParseUnQuoted (stream);
}
/// <summary> Constructor </summary>
/// <param name="stream"> The parse stream (contains the line number where it went wrong) </param>
/// <param name="message"> Info about the exception </param>
public ParseException(ParseStream stream, string message)
: base("Parse error near line " + stream.CurrentLine + ": " + message)
{
this.linenr = stream.CurrentLine;
}
/// <summary> Parse a sequence </summary>
public Sequence(ParseStream stream)
: base("tag:yaml.org,2002:seq", NodeType.Sequence)
{
// Is this really a sequence?
if (stream.Char == '-')
{
// Parse recursively
do {
// Override the parent's stop chars, never stop
stream.StopAt (new char [] { } );
// Skip over '-'
stream.Next ();
// Parse recursively
stream.Indent ();
AddNode (Parse (stream));
stream.UnIndent ();
// Re-accept the parent's stop chars
stream.DontStop ();
}
while ( ! stream.EOF && stream.Char == '-' );
}
// Or inline Sequence
else if (stream.Char == '[')
{
// Override the parent's stop chars, never stop
stream.StopAt (new char [] { });
// Skip '['
stream.Next ();
do {
stream.StopAt (new char [] {']', ','});
stream.Indent ();
AddNode (Parse (stream, false));
stream.UnIndent ();
stream.DontStop ();
// Skip ','
if (stream.Char != ']' && stream.Char != ',')
{
stream.DontStop ();
throw new ParseException (stream, "Comma expected in inline sequence");
}
if (stream.Char == ',')
{
stream.Next ();
stream.SkipSpaces ();
}
}
while ( ! stream.EOF && stream.Char != ']');
// Re-accept the parent's stop chars
stream.DontStop ();
// Skip ']'
if (stream.Char == ']')
stream.Next (true);
else
throw new ParseException (stream, "Inline sequence not closed");
}
// Throw an exception when not
else
throw new Exception ("This is not a sequence");
}
/// <summary>
/// Parse the time zone
/// </summary>
private double ParseTimezone(ParseStream stream)
{
double timezone = 0;
SkipWhitespace(stream);
// Timezone = UTC, use by default 0
if (stream.Char == 'Z')
{
stream.Next(true);
}
else
{
// Find the sign of the offset
int sign = 0;
if (stream.Char == '-')
{
sign = -1;
}
else if (stream.Char == '+')
{
sign = +1;
}
else
{
throw new Exception("Invalid time zone: " +
"unexpected character");
}
// Read next char and test for more chars
stream.Next(true);
if (stream.EOF)
{
throw new Exception("Invalid time zone");
}
// Parse hour offset
// Note: A hour can be represented by one or two digits.
string hulp = "";
while (stream.Char >= '0' &&
stream.Char <= '9' &&
!stream.EOF && hulp.Length <= 2)
{
hulp += (stream.Char);
stream.Next(true);
}
timezone = sign * Double.Parse(hulp);
// Parse the minutes of the timezone
// when there is still more to parse
if (!stream.EOF)
{
SkipChar(stream, ':');
int temp = ParseNumber(stream, 2);
timezone += (temp / 60.0);
}
}
return(timezone);
}