public static string DOUBLE_MARKS = "dD"; //double的结尾标志
public Element Read(ExpressionReader sr)
{
int index = sr.GetCurrentIndex();
string s = string.Empty;
int b = -1;
while ((b = sr.Read()) != -1)
{
char c = (char)b;
if (NUMBER_CHARS.IndexOf(c) == -1)
{
if (LONG_MARKS.IndexOf(c) >= 0)
{
if (s.IndexOf(".") >= 0)
{//有小数点
throw new FormatException("long类型不能有小数点");
}
return(new Element(s.ToString(), index, ElementType.LONG));
}
else if (FLOAT_MARKS.IndexOf(c) >= 0)
{
CheckDecimal(s);
return(new Element(s.ToString(), index, ElementType.FLOAT));
}
else if (DOUBLE_MARKS.IndexOf(c) >= 0)
{
CheckDecimal(s);
return(new Element(s.ToString(), index, ElementType.DOUBLE));
}
else
{
sr.Reset();
if (s.IndexOf(".") >= 0)
{//没有结束标志，有小数点，为double
CheckDecimal(s);
return(new Element(s.ToString(), index, ElementType.DOUBLE));
}
else
{//没有结束标志，无小数点，为int
return(new Element(s.ToString(), index, ElementType.INT));
}
}
}
s += c;
sr.Mark(0);
}
//读到结未
if (s.IndexOf(".") >= 0)
{//没有结束标志，有小数点，为double
CheckDecimal(s);
return(new Element(s.ToString(), index, ElementType.DOUBLE));
}
else
{//没有结束标志，无小数点，为int
return(new Element(s.ToString(), index, ElementType.INT));
}
}
/// <summary>
/// 根据流开头构造不同的词元读取 流应该非空格开头
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static IElementReader CreateElementReader(ExpressionReader reader)
{
//读一个char
reader.Mark(0);
int b = reader.Read();
reader.Reset();
if (b != -1)
{
char c = (char)b;
try
{
if (c == StringTypeReader.START_MARK)
{//"开头，构造字符串读取器
return(new StringTypeReader());
}
else if (c == DateTypeReader.START_MARK)
{//[开头，构造日期读取器
return(new DateTypeReader());
}
else if (c == FunctionTypeReader.START_MARK)
{//$开头，构造函数读取器
return(new FunctionTypeReader());
}
else if (SplitorTypeReader.SPLITOR_CHAR.IndexOf(c) >= 0)
{//如果是分隔符，构造分隔符读取器
return(new SplitorTypeReader());
}
else if (NumberTypeReader.NUMBER_CHARS.IndexOf(c) >= 0)
{//以数字开头，构造数字类型读取器
return(new NumberTypeReader());
}
else if (OperatorTypeReader.IsOperatorStart(reader))
{//如果前缀是运算符，构造运算符读取器
return(new OperatorTypeReader());
}
else
{
return(new VariableTypeReader());//否则构造一个变量读取器
}
}
catch (Exception e)
{
throw new FormatException("", e);
}
}
else
{
throw new FormatException("流已结束");
}
}
public Element Read(ExpressionReader sr)
{
int index = sr.GetCurrentIndex();
var sb = new StringBuilder();
int b = sr.Read();
if (b == -1)
{
throw new FormatException("表达式已结束");
}
char c = (char)b;
sb.Append(c);
if (IsOperatorWord(sb.ToString()))
{
if (sb.Length == 1)
{//两个符号的运算符优先，如<=，不应该认为是<运算符
sr.Mark(0);
b = sr.Read();
if (b != -1)
{
if (IsOperatorWord(sb.ToString() + (char)b))
{
return(new Element(sb.ToString() + (char)b, index,
ElementType.OPERATOR));
}
}
sr.Reset();
}
return(new Element(sb.ToString(), index,
ElementType.OPERATOR));
}
while ((b = sr.Read()) != -1)
{
c = (char)b;
sb.Append(c);
if (IsOperatorWord(sb.ToString()))
{
return(new Element(sb.ToString(), index,
ElementType.OPERATOR));
}
if (VariableTypeReader.STOP_CHAR.IndexOf(c) >= 0)
{//单词停止符
throw new FormatException("不是有效的运算符：" + sb.ToString());
}
}
throw new FormatException("不是有效的运算符结束");
}
public static char END_MARK = '('; //函数结束
/**
* 从流中读取函数类型的ExpressionToken
* @param sr
* @return
* @throws FormatException
* @throws IOException
*/
public Element Read(ExpressionReader sr)
{
int index = sr.GetCurrentIndex();
var sb = new StringBuilder();
int b = sr.Read();
if (b == -1 || b != START_MARK)
{
throw new FormatException("不是有效的函数开始");
}
bool readStart = true;
while ((b = sr.Read()) != -1)
{
char c = (char)b;
if (c == END_MARK)
{
if (sb.Length == 0)
{
throw new FormatException("函数名称不能为空");
}
sr.Reset();
return(new Element(sb.ToString(), index, ElementType.FUNCTION));
}
//if (!Character.isJavaIdentifierPart(c)) {
// throw new FormatException("名称不能为非法字符：" + c);
//}
if (readStart)
{
//if (!Character.isJavaIdentifierStart(c)) {
// throw new FormatException("名称开头不能为字符：" + c);
//}
readStart = false;
}
sb.Append(c);
sr.Mark(0);
}
throw new FormatException("不是有效的函数结束");
}
private string ReadWord(ExpressionReader sr)
{
var sb = new StringBuilder();
bool readStart = true;
int b = -1;
while ((b = sr.Read()) != -1)
{
char c = (char)b;
if (STOP_CHAR.IndexOf(c) >= 0 && !readStart)
{//单词停止符,并且忽略第一个字符
sr.Reset();
return(sb.ToString());
}
if (readStart)
{
readStart = false;
}
sb.Append(c);
sr.Mark(0);
}
return(sb.ToString());
}
/// <summary>
/// 测试是否为运算符
/// </summary>
/// <param name="sr"></param>
/// <returns></returns>
public static bool IsOperatorStart(ExpressionReader sr)
{
sr.Mark(0);
try
{
var sb = new StringBuilder();
int b = sr.Read();
if (b == -1)
{
return(false);
}
char c = (char)b;
sb.Append(c);
if (IsOperatorWord(sb.ToString()))
{
return(true);
}
while ((b = sr.Read()) != -1)
{
c = (char)b;
sb.Append(c);
if (IsOperatorWord(sb.ToString()))
{
return(true);
}
if (VariableTypeReader.STOP_CHAR.IndexOf(c) >= 0)
{//单词停止符
return(false);
}
}
return(false);
}
finally
{
sr.Reset();
}
}
