lexer.cs

来自「全功能c#编译器」· CS 代码 · 共 681 行 · 第 1/2 页

					} else {
						if (number > int.MaxValue || number < int.MinValue) {
							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (long)number);
						} else {
							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (int)number);
						}
					}
				}
				if (ch == 'S') {
					reader.Read();
					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int16.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number));
				} else if (ch == '%' || ch == 'I') {
					reader.Read();
					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int32.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number));
				} else if (ch == '&' || ch == 'L') {
					reader.Read();
					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int64.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number));
				} else if (ishex) {
					--col;
					long number = Int64.Parse(digit, NumberStyles.HexNumber);
					if (number > int.MaxValue || number < int.MinValue) {
						return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), number);
					} else {
						return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (int)number);
					}
				}
			}
			if (!isdouble && reader.Peek() != -1 && reader.Peek() == '.') { // read floating point number
				reader.Read();
				if (Char.IsDigit((char)reader.Peek())) {
					isdouble = true; // double is default
					if (ishex || isokt) {
						errors.Error(line, col, String.Format("No hexadecimal or oktadecimal floating point values allowed"));
					}
					digit += '.';
					++col;
					while (reader.Peek() != -1 && Char.IsDigit((char)reader.Peek())){ // read decimal digits beyond the dot
						digit += (char)reader.Read();
						++col;
					}
				}
			}
			
			if (reader.Peek() != -1 && Char.ToUpper((char)reader.Peek()) == 'E') { // read exponent
				isdouble = true;
				digit +=  (char)reader.Read();
				++col;
				if (reader.Peek() != -1 && (reader.Peek() == '-' || reader.Peek() == '+')) {
					digit += (char)reader.Read();
					++col;
				}
				while (reader.Peek() != -1 && Char.IsDigit((char)reader.Peek())) { // read exponent value
					digit += (char)reader.Read();
					++col;
				}
			}
			
			if (reader.Peek() != -1) {
				if (Char.ToUpper((char)reader.Peek()) == 'R' || Char.ToUpper((char)reader.Peek()) == '#') { // double type suffix (obsolete, double is default)
					reader.Read();
					++col;
					isdouble = true;
				} else if (Char.ToUpper((char)reader.Peek()) == 'D' || Char.ToUpper((char)reader.Peek()) == '@') { // decimal value
					reader.Read();
					++col;
					isdecimal = true;
				} else if (Char.ToUpper((char)reader.Peek()) == 'F' || Char.ToUpper((char)reader.Peek()) == '!') { // decimal value
					reader.Read();
					++col;
					issingle = true;
				}
			}
			
			if (issingle) {
				NumberFormatInfo mi = new NumberFormatInfo();
				mi.CurrencyDecimalSeparator = ".";
				return new Token(Tokens.LiteralSingle, x, y, sb.ToString(), Single.Parse(digit, mi));
			}
			if (isdecimal) {
				NumberFormatInfo mi = new NumberFormatInfo();
				mi.CurrencyDecimalSeparator = ".";
				return new Token(Tokens.LiteralDecimal, x, y, sb.ToString(), Decimal.Parse(digit, mi));
			}
			if (isdouble) {
				NumberFormatInfo mi = new NumberFormatInfo();
				mi.CurrencyDecimalSeparator = ".";
				return new Token(Tokens.LiteralDouble, x, y, sb.ToString(), Double.Parse(digit, mi));
			}
			try {
				return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int32.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number));
			} catch (Exception) {
				try {
					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int64.Parse(digit, ishex ? NumberStyles.HexNumber : NumberStyles.Number));
				} catch (Exception) {
					errors.Error(line, col, String.Format("{0} is not a parseable number (too long?)", sb.ToString()));
					// fallback, when nothing helps :)
					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0);
				}
			}
		}
		
		void ReadPreprocessorDirective()
		{
			Point start = new Point(col - 1, line);
			string directive = ReadIdent('#');
			string argument  = ReadToEOL();
			PreProcessingDirectives.Add(new PreProcessingDirective(directive, argument.Trim(), start, new Point(start.X + directive.Length + argument.Length, start.Y)));
		}
		
		string ReadDate()
		{
			char ch = '\0';
			sb.Length = 0;
			int nextChar;
			while ((nextChar = reader.Read()) != -1) {
				ch = (char)nextChar;
				++col;
				if (ch == '#') {
					break;
				} else if (ch == '\n') {
					errors.Error(line, col, String.Format("No return allowed inside Date literal"));
				} else {
					sb.Append(ch);
				}
			}
			if (ch != '#') {
				errors.Error(line, col, String.Format("End of File reached before Date literal terminated"));
			}
			return sb.ToString();
		}
		
		string ReadString()
		{
			char ch = '\0';
			sb.Length = 0;
			int nextChar;
			while ((nextChar = reader.Read()) != -1) {
				ch = (char)nextChar;
				++col;
				if (ch == '"') {
					if (reader.Peek() != -1 && reader.Peek() == '"') {
						sb.Append('"');
						reader.Read();
						++col;
					} else {
						break;
					}
				} else if (ch == '\n') {
					errors.Error(line, col, String.Format("No return allowed inside String literal"));
				} else {
					sb.Append(ch);
				}
			}
			if (ch != '"') {
				errors.Error(line, col, String.Format("End of File reached before String terminated "));
			}
			return sb.ToString();
		}
		
		void ReadComment()
		{
			sb.Length = 0;
			StringBuilder curWord = new StringBuilder();
			int x = col;
			int y = line;
			int nextChar;
			while ((nextChar = reader.Read()) != -1) {
				char ch = (char)nextChar;
				++col;
				
				if (HandleLineEnd(ch)) {
					return;
				}
				
				if (Char.IsLetter(ch)) {
					curWord.Append(ch);
				} else {
					string tag = curWord.ToString();
					curWord = new StringBuilder();
					if (specialCommentHash != null && specialCommentHash[tag] != null) {
						Point p = new Point(col, line);
						string commentStr = ReadToEOL();
						tagComments.Add(new TagComment(tag, commentStr, p));
						return;
					}
				}
			}
		}
		
		Token ReadOperator(char ch)
		{
			int x = col;
			int y = line;
			switch(ch) {
				case '+':
					switch (reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.PlusAssign, x, y);
						default:
							break;
					}
					return new Token(Tokens.Plus, x, y);
				case '-':
					switch (reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.MinusAssign, x, y);
						default:
							break;
					}
					return new Token(Tokens.Minus, x, y);
				case '*':
					switch (reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.TimesAssign, x, y);
						default:
							break;
					}
					return new Token(Tokens.Times, x, y, "*");
				case '/':
					switch (reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.DivAssign, x, y);
						default:
							break;
					}
					return new Token(Tokens.Div, x, y);
				case '\\':
					switch (reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.DivIntegerAssign, x, y);
						default:
							break;
					}
					return new Token(Tokens.DivInteger, x, y);
				case '&':
					switch ((char)reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.ConcatStringAssign, x, y);
						default:
							break;
					}
					return new Token(Tokens.ConcatString, x, y);
				case '^':
					switch (reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.PowerAssign, x, y);
						default:
							break;
					}
					return new Token(Tokens.Power, x, y);
				case ':':
					return new Token(Tokens.Colon, x, y);
				case '=':
					return new Token(Tokens.Assign, x, y);
				case '<':
					switch (reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.LessEqual, x, y);
						case '>':
							reader.Read();
							++col;
							return new Token(Tokens.NotEqual, x, y);
						case '<':
							reader.Read();
							switch (reader.Peek()) {
								case '=':
									reader.Read();
									col += 2;
									return new Token(Tokens.ShiftLeftAssign, x, y);
								default:
									++col;
									break;
							}
							return new Token(Tokens.ShiftLeft, x, y);
					}
					return new Token(Tokens.LessThan, x, y);
				case '>':
					switch (reader.Peek()) {
						case '=':
							reader.Read();
							++col;
							return new Token(Tokens.GreaterEqual, x, y);
						case '>':
							reader.Read();
							if (reader.Peek() != -1) {
								switch ((char)reader.Peek()) {
									case '=':
										reader.Read();
										col += 2;
										return new Token(Tokens.ShiftRightAssign, x, y);
									default:
										++col;
										break;
								}
							}
							return new Token(Tokens.ShiftRight, x, y);
					}
					return new Token(Tokens.GreaterThan, x, y);
				case ',':
					return new Token(Tokens.Comma, x, y);
				case '.':
					if (Char.IsDigit((char)reader.Peek())) {
						 --col;
						 return ReadDigit('.', col);
					}
					return new Token(Tokens.Dot, x, y);
				case '(':
					return new Token(Tokens.OpenParenthesis, x, y);
				case ')':
					return new Token(Tokens.CloseParenthesis, x, y);
				case '{':
					return new Token(Tokens.OpenCurlyBrace, x, y);
				case '}':
					return new Token(Tokens.CloseCurlyBrace, x, y);
				case '[':
					return new Token(Tokens.OpenSquareBracket, x, y);
				case ']':
					return new Token(Tokens.CloseSquareBracket, x, y);
			}
			return null;
		}
	}
}