// retrieve a quoted sugar token (' ` , ,@) and advance our position private Token QuoteSugar() { TokenType type; builder.Clear(); switch (Character) { case '\'': type = TokenType.Quote; break; case '`': type = TokenType.QuasiQuote; break; case ',': type = TokenType.Unquote; break; default: throw TokenizerError.SyntaxError("tokenizer", "unexpected character", lastToken); } builder.Append((char)Character); NextChar(); if (Character == '@') { type = TokenType.UnquoteSplicing; NextChar(); builder.Append((char)Character); } return(DefineToken(type, builder.ToString( ))); }
public static double GetDouble(string value) { double val = 0; if (double.TryParse(value, out val)) { return(val); } throw TokenizerError.ErrorWithName("get-double", "improperly formed float value", value); }
public static float GetFloat(string value) { float val = 0; if (float.TryParse(value, out val)) { return(val); } throw TokenizerError.ErrorWithName("get-float", "improperly formed float value", value); }
public static int GetInteger(string value) { try { var val = int.Parse(value, NumberStyles.AllowLeadingSign); return(val); } catch (System.Exception) { throw TokenizerError.ErrorWithName("get-integer", "improperly formed int value", value); } }
public static int GetHexadecimal(string value) { try { UnityEngine.Debug.Assert(value.Length > 2, "Error in hex literal"); var hval = int.Parse(value.Substring(2), NumberStyles.AllowHexSpecifier); return(hval); } catch (System.Exception ex) { throw TokenizerError.ErrorWithName("get-hexadecimal", "improperly formed int value", value); } }
public char GetCharacter( ) { Debug.Assert(type == TokenType.Character); if (value.Length == 3) { return(System.Convert.ToChar(value[2])); } else { var c = (char)0; if (NamedCharacter.NameToCharacter(value, out c)) { return(c); } throw TokenizerError.SyntaxError("get-character", "improperly formed char value", this); } }
// -- Parse value -------------------------------------------------------------------------------- public bool GetBool() { Debug.Assert(type == TokenType.Boolean); if (value == "#t") { return(true); } else if (value == "#f") { return(false); } else { throw TokenizerError.SyntaxError("get-bool", "improperly formed bool value", this); } }
/// <summary> /// Return double value from any type of string /// </summary> /// <param name="value"></param> /// <returns></returns> public static double GetNumerical(string value) { if (string.IsNullOrEmpty(value)) { throw TokenizerError.ErrorWithName("get-double", "unexpected empty string", value); } if (char.IsDigit(value[0])) { return(GetDouble(value)); } if (value[0] == '#') { return(GetHexadecimal(value)); } throw TokenizerError.ErrorWithName("get-numerical", "improperly formed numerical value", value); }
public int GetInteger() { try { switch (type) { case TokenType.Integer: return(StringParser.GetInteger(value)); case TokenType.Heximal: return(StringParser.GetHexadecimal(value)); default: throw TokenizerError.SyntaxError("get-integer", "wrong token type", this); } } catch (System.Exception) { throw TokenizerError.SyntaxError("get-integer", "improperly formed int value", this); } }
// retrieve a string literal token and advance our position private Token StringLiteral() { builder.Clear(); NextChar(); var type = TokenType.String; var matchingQuotes = false; while (Character >= 0) { // if we get an escape, increment the position some more and map the escaped character to what it should be if (Character == '\\') { NextChar(); builder.Append(MapEscaped(Character)); NextChar(); continue; } // unescaped quote? We're done with this string. if (Character == '"') { NextChar(); matchingQuotes = true; break; } builder.Append((char)Character); NextChar(); } // we didn't get opening and closing quotes :( if (!matchingQuotes) { throw TokenizerError.SyntaxError("tokenizer", "unmatched quotes in string literal", lastToken); } return(DefineToken(type, builder.ToString())); }
// retrieve a number literal token (int or decimal) and advance our position private Token NumberLiteral() { var type = TokenType.Integer; builder.Clear(); while (Character >= 0 && IsNumericalPart(Character)) { // if we get a decimal we're no longer working with an integer if (Character == '.') { if (type == TokenType.Floating) { throw TokenizerError.SyntaxError("tokenizer", "error in numerical literal", lastToken); } type = TokenType.Floating; } builder.Append((char)Character); NextChar(); } return(DefineToken(type, builder.ToString( ))); }
// retrieve a vector literal marker, boolean token, or character literal token and advance our position private Token VectorOrBooleanOrChar() { builder.Clear(); var boolLiterals = new List <char> { 'F', 'f', 't', 'T' }; var nextc = reader.Peek(); if (boolLiterals.Contains((char)nextc)) { // boolean literal! builder.Append((char)Character); NextChar(); // skip # if (Character >= 0) { builder.Append((char)Character); NextChar(); // skip F,f,t,T } return(DefineToken(TokenType.Boolean, builder.ToString( ))); } else if (nextc == '(') { // vector literal! NextChar(); // skip # NextChar(); // skip ( return(DefineToken(TokenType.OpenVector, "(")); } else if (nextc == '\\') { // char literal! while (Character >= 0 && !IsWhitespace(Character)) { if (builder.Size < 3) { builder.Append((char)Character); NextChar(); } else { if (!IsEOF(Character) && IsSymbolPart(Character)) { builder.Append((char)Character); NextChar(); } else { break; } } } return(DefineToken(TokenType.Character, builder.ToString( ))); } else if (nextc == 'x') { builder.Append((char)Character); NextChar(); // skip # builder.Append((char)Character); NextChar(); // skip x // char literal! while (Character >= 0 && IsHeximalPart(Character)) { builder.Append((char)Character); NextChar(); } return(DefineToken(TokenType.Heximal, builder.ToString( ))); } //else if (nextc == '!') //{ // builder.Append((char)Character); // NextChar(); // skip # // builder.Append((char)Character); // NextChar(); // skip ! // // char literal! // while (Character >= 0 && IsSymbolPart(Character)) // { // builder.Append((char)Character); // NextChar(); // } // return DefineToken(TokenType.Symbol, builder.ToString()); //} else { throw TokenizerError.SyntaxError("tokenizer", "inside '#' but no matching characters to construct a token", lastToken); } }