public RealPrimitive(string value, Token relatedToken)
            : base(relatedToken)
		{
			originalString = value;
			char c = value[value.Length - 1];
			switch(c)
			{
				case 'f':
				case 'F':
					isFloat = true;
					value = value.Substring(0, value.Length - 1);
					val = float.Parse(value, CultureInfo.InvariantCulture);
					break;
				case 'd':
				case 'D':
					isDouble = true;
					value = value.Substring(0, value.Length - 1);
					val = double.Parse(value, CultureInfo.InvariantCulture);
					break;
				case 'm':
				case 'M':
					isDecimal = true;
					value = value.Substring(0, value.Length - 1);
					val = (double)decimal.Parse(value, CultureInfo.InvariantCulture);
					break;
				default:
					val = double.Parse(value, CultureInfo.InvariantCulture);
					break;
			}
		}

 public Error(string message, Token token, int line, int column, string fileName)
 {
     Message = message;
     Token = token;
     Line = line;
     Column = column;
     FileName = fileName;
 }

		public IntegralPrimitive(string value, IntegralType integralType, Token relatedToken) : base(relatedToken)
		{
			this.originalString = value;
			this.integralType = integralType;

			switch (integralType)
			{
				case IntegralType.SByte:
				case IntegralType.Byte:
				case IntegralType.Short:
				case IntegralType.Int:
					break;

				case IntegralType.UShort:
					value = value.TrimEnd('U', 'u');
					break;

				case IntegralType.UInt:
					value = value.TrimEnd('U', 'u');
					break;

				case IntegralType.Long:
					value = value.TrimEnd('L', 'l');
					break;

				case IntegralType.ULong:
					value = value.TrimEnd('L', 'l', 'U', 'u');
					value = value.TrimEnd('L', 'l', 'U', 'u');
					break;

				default:
					throw new FormatException("Illegal Integral type");
			}

			int radix = 10;
			NumberStyles style = NumberStyles.Integer;
			if (value.StartsWith("0x", true, CultureInfo.InvariantCulture))
			{
				radix = 16;
				style = NumberStyles.HexNumber;
				value = value.Substring(2, value.Length - 2);
			}
			// negation is wrapped in a unaryNegationNode so no need to account for negative values
			//try
			//{
			this.value = UInt64.Parse(value, style);
			//this.value = Convert.ToUInt64(value, radix);

			//}
			//catch (OverflowException)
			//{
			//    ConsoleWr
			//}
			//catch (FormatException)
			//{
			//}

		}

        public CharPrimitive(string value, Token relatedToken)
            : base(relatedToken)
		{
			if (value.Length == 1
                || value.Length == 2 && value.StartsWith("\\") )
			{
				this.value = value;
			}
			else
			{
				throw new FormatException("char primitive value is not a char");
			}
		}

        public Token GetLastTokenIDExceptBlanks()
        {
            LinkedListNode<Token> node = tokens.Last;
            Token ret = new Token(TokenID.Invalid);

            while (node != null
                   && (node.Value.ID == TokenID.Whitespace || node.Value.ID == TokenID.Newline))
            {
                node = node.Previous;
            }

            if (node != null)
            {
                ret = node.Value;
            }

            return ret;
        }

		public ThisAccessExpression(Token relatedToken): base(relatedToken)
		{
            identifier = "this";
		}

	  public LabeledStatement(Token relatedtoken)
	    : base(relatedtoken)
	  {
	  }

		//private NodeCollection<FieldNode> members;
		//public NodeCollection<FieldNode> Members
		//{
		//    get { return members; }
		//    set { members = value; }
        //}

        public ClassNode(Token relatedToken) : base(relatedToken)
        {
            kind = ConstructedTypeNode.KindEnum.Class;
        }

 public EventNode(Token relatedtoken)
     : base(relatedtoken)
 {
 }

 public StackallocExpression(Token relatedToken)
     : base(relatedToken)
 {
 }

        public ObjectCreationExpression(IType type, Token relatedToken)
            : base(relatedToken)
		{
			this.type = type;
		}

	  public SizeOfExpression(Token relatedToken)
            : base(relatedToken)
        {
        }

	  public AnonymousMethodNode(Token relatedtoken)
	    : base(relatedtoken)
	  {
	    statementBlock = new BlockStatement(relatedtoken);
	  }

 public BreakStatement(Token relatedtoken)
     : base(relatedtoken)
 {
 }

 public BlockStatement(bool isUnsafe, Token relatedtoken) : base(relatedtoken)
 {
     this.IsUnsafe = isUnsafe;
 }

	    public PredefinedTypeNode(TokenID type, Token relatedToken) 
            : base( new IdentifierExpression(type.ToString().ToLower(), relatedToken) )
		{
	        this.type = type;
		}

	  public OutNode(Token relatedToken)
            : base(relatedToken)
        {
        }

	  public SwitchStatement(Token relatedtoken)
	    : base(relatedtoken)
	  {
	  }

 public InterfaceMethodNode(Token relatedtoken)
   : base(relatedtoken)
 {
 }

 public DoStatement(Token relatedToken)
     : base(relatedToken)
 {
     statements = new BlockStatement(relatedToken);
 }