private void ParseIdentifier()
{
while (_CurrentChar >= '0' && _CurrentChar <= '9' ||
_CurrentChar >= 'a' && _CurrentChar <= 'z' ||
_CurrentChar >= 'A' && _CurrentChar <= 'Z' ||
_CurrentChar == '_')
{
Value.Append(_CurrentChar);
NextChar();
}
switch (Value.ToString().ToLower())
{
case "and":
TokenType = eTokenType.operator_and;
break;
case "or":
TokenType = eTokenType.operator_or;
break;
case "true":
case "yes":
TokenType = eTokenType.value_true;
break;
case "false":
case "no":
TokenType = eTokenType.value_false;
break;
default:
TokenType = eTokenType.value_identifier;
break;
}
}
public static JsonScannerToken New(eTokenType type)
{
JsonScannerToken ret = new JsonScannerToken();
ret.Type = type;
return(ret);
}
/// <summary>
/// Add a keyword to the default type dictionary.
/// </summary>
public void AddKeyword(string keyword, eTokenType type, bool caseSensative)
{
/// NOTE: The keyword is interned, and the lexer will use
/// the interned string when possible. In other cases,
/// common strings are pooled by the lexer (see MinTern)
keyword = string.Intern(keyword);
if (caseSensative)
{
// Add to case sensative
if (!mKeywordsSensative.ContainsKey(keyword))
{
mKeywordsSensative[string.Intern(keyword)]
= new TokenTypeLu(keyword, type);
}
}
else
{
// Add to case insensative
string lower = string.Intern(keyword.ToLower());
if (!mKeywordsInsensative.ContainsKey(keyword))
{
mKeywordsInsensative[string.Intern(lower)]
= new TokenTypeLu(keyword, type);
}
}
}
public Token(string tokenName, int lineIndex, int charIndex, eTokenType tokenType)
{
Name = tokenName;
Line = lineIndex;
Char = charIndex;
Type = tokenType;
}
public opCodeUnary(eTokenType tt, opCode param1)
{
mParam1 = param1;
mParam1.ValueChanged += mParam1_ValueChanged;
EvalType v1Type = mParam1.EvalType;
switch (tt)
{
case eTokenType.operator_not:
{
if (v1Type == EvalType.Boolean)
{
mValueDelegate = BOOLEAN_NOT;
mEvalType = EvalType.Boolean;
}
break;
}
case eTokenType.operator_minus:
{
if (v1Type == EvalType.Number)
{
mValueDelegate = NUM_CHGSIGN;
mEvalType = EvalType.Number;
}
break;
}
}
}
private IList <iEvalTypedValue> ParseParameters(ref bool brackets)
{
IList <iEvalTypedValue> parameters = new List <iEvalTypedValue>();
opCode valueleft;
eTokenType lClosing = eTokenType.none;
if (mTokenizer.type == eTokenType.open_parenthesis || (mTokenizer.type == eTokenType.open_bracket & mEvaluator.Syntax == eParserSyntax.cSharp))
{
switch (mTokenizer.type)
{
case eTokenType.open_bracket:
{
lClosing = eTokenType.close_bracket;
brackets = true;
break;
}
case eTokenType.open_parenthesis:
{
lClosing = eTokenType.close_parenthesis;
break;
}
}
mTokenizer.NextToken(); // eat the parenthesis
do
{
if (mTokenizer.type == lClosing)
{
// good we eat the end parenthesis and continue ...
mTokenizer.NextToken();
break;
}
valueleft = ParseExpr(null /* TODO Change to default(_) if this is not a reference type */, ePriority.none);
parameters.Add(valueleft);
if (mTokenizer.type == lClosing)
{
// good we eat the end parenthesis and continue ...
mTokenizer.NextToken();
break;
}
else if (mTokenizer.type == eTokenType.comma)
{
mTokenizer.NextToken();
}
else
{
mTokenizer.RaiseUnexpectedToken(lClosing.ToString() + " not found");
}
}while (true);
}
return(parameters);
}
private void ParseIdentifier()
{
while ((mCurChar >= '0' & mCurChar <= '9') | (mCurChar >= 'a' & mCurChar <= 'z') | (mCurChar >= 'A' & mCurChar <= 'Z') | (mCurChar >= 'A' & mCurChar <= 'Z') | (mCurChar >= (char)(128)) | (mCurChar == '_'))
{
value.Append(mCurChar);
NextChar();
}
switch (value.ToString())
{
case "and":
{
type = eTokenType.operator_and;
break;
}
case "or":
{
type = eTokenType.operator_or;
break;
}
case "not":
{
type = eTokenType.operator_not;
break;
}
case "true":
case "yes":
{
type = eTokenType.value_true;
break;
}
case "if":
{
type = eTokenType.operator_if;
break;
}
case "false":
case "no":
{
type = eTokenType.value_false;
break;
}
default:
{
type = eTokenType.value_identifier;
break;
}
}
}
protected JsonScannerToken ReturnToken(eTokenType tipo, object conteudo)
{
CurrentToken.Type = tipo;
if (conteudo != null)
{
CurrentTokenAppend(conteudo);
}
JsonScannerToken ret = CurrentToken;
NewCurrentToken();
return(ret);
}
private void ParseDate()
{
NextChar();
while (_CurrentChar >= '0' && _CurrentChar <= '9' ||
_CurrentChar == ':' || _CurrentChar == ' ' ||
_CurrentChar == '/' || _CurrentChar == 'A' || _CurrentChar == 'P' ||
_CurrentChar == 'M')
{
Value.Append(_CurrentChar);
NextChar();
}
if (_CurrentChar != '#')
{
throw new ApplicationException("Error Tipe Data Date !");
}
NextChar();
TokenType = eTokenType.value_date;
}
private void ParseText()
{
NextChar();
while (_CurrentChar != '\x0')
{
if (_CurrentChar == '"')
{
NextChar();
if (_CurrentChar != '"')
{
break;
}
}
Value.Append(_CurrentChar);
NextChar();
}
TokenType = eTokenType.value_string;
}
private void ParseNumber()
{
while (_CurrentChar >= '0' && _CurrentChar <= '9')
{
Value.Append(_CurrentChar);
NextChar();
}
if (_CurrentChar == '.')
{
Value.Append('.');
NextChar();
while (_CurrentChar >= '0' && _CurrentChar <= '9')
{
Value.Append(_CurrentChar);
NextChar();
}
}
TokenType = eTokenType.value_number;
}
private void ParseNumber()
{
type = eTokenType.value_number;
while (mCurChar >= '0' & mCurChar <= '9')
{
value.Append(mCurChar);
NextChar();
}
if (mCurChar == '.')
{
value.Append(mCurChar);
NextChar();
while (mCurChar >= '0' & mCurChar <= '9')
{
value.Append(mCurChar);
NextChar();
}
}
}
private void ParseDate()
{
NextChar(); // eat the #
int zone = 0;
while ((mCurChar >= '0' & mCurChar <= '9') | (mCurChar == '/') | (mCurChar == ':') | (mCurChar == ' '))
{
value.Append(mCurChar);
NextChar();
}
if (mCurChar != '#')
{
RaiseError("Invalid date should be #dd/mm/yyyy#");
}
else
{
NextChar();
}
type = eTokenType.value_date;
}
internal void RaiseWrongOperator(eTokenType tt, object ValueLeft, object valueRight, string msg = null)
{
if (msg.Length > 0)
{
msg.Replace("[op]", tt.GetType().ToString());
msg += ". ";
}
msg = "Cannot apply the operator " + tt.ToString();
if (ValueLeft == null)
{
msg += " on nothing";
}
else
{
msg += " on a " + ValueLeft.GetType().ToString();
}
if (valueRight != null)
{
msg += " and a " + valueRight.GetType().ToString();
}
RaiseError(msg);
}
public void NextToken()
{
value.Length = 0;
type = eTokenType.none;
do
{
startpos = mPos;
switch (mCurChar)
{
case 0:
type = eTokenType.end_of_formula;
break;
case '0': // TODO: to '9'
ParseNumber();
break;
case '-':
case '–':
NextChar();
type = eTokenType.operator_minus;
break;
case '+':
NextChar();
type = eTokenType.operator_plus;
break;
case '*':
NextChar();
type = eTokenType.operator_mul;
break;
case '/':
NextChar();
type = eTokenType.operator_div;
break;
case '%':
NextChar();
type = eTokenType.operator_percent;
break;
case '(':
NextChar();
type = eTokenType.open_parenthesis;
break;
case ')':
NextChar();
type = eTokenType.close_parenthesis;
break;
case '<':
NextChar();
if (mCurChar == '=')
{
NextChar();
type = eTokenType.operator_le;
}
else if (mCurChar == '>')
{
NextChar();
type = eTokenType.operator_ne;
}
else
{
type = eTokenType.operator_lt;
}
break;
case '>':
NextChar();
if (mCurChar == '=')
{
NextChar();
type = eTokenType.operator_ge;
}
else
{
type = eTokenType.operator_gt;
}
break;
case ',':
NextChar();
type = eTokenType.comma;
break;
case '=':
NextChar();
type = eTokenType.operator_eq;
break;
case '.':
NextChar();
type = eTokenType.dot;
break;
case '\'':
case '"':
ParseString(true);
type = eTokenType.value_string;
break;
case '#':
ParseDate();
break;
case '&':
NextChar();
type = eTokenType.operator_concat;
break;
case '[':
NextChar();
type = eTokenType.open_bracket;
break;
case ']':
NextChar();
type = eTokenType.close_bracket;
break;
case '\0': // TODO: to ' '
break;
// do nothing
default:
ParseIdentifier();
break;
}
if (type != eTokenType.none)
break;
NextChar();
}
while (true);
}
internal void RaiseWrongOperator(eTokenType tt, object ValueLeft, object valueRight, string msg)
{
if (Strings.Len(msg) > 0) {
msg.Replace("[op]", tt.GetType().ToString());
msg // ERROR: Unknown assignment operator ConcatString ;
}
msg = "Cannot apply the operator " + tt.ToString();
if (ValueLeft == null) {
msg // ERROR: Unknown assignment operator ConcatString ;
}
else {
msg // ERROR: Unknown assignment operator ConcatString ;
}
if ((valueRight != null)) {
msg // ERROR: Unknown assignment operator ConcatString ;
}
RaiseError(msg);
}
public Token(eTokenType type)
{
mType = type;
}
internal void NextToken()
{
Value.Length = 0;
TokenType = eTokenType.none;
do
{
switch (_CurrentChar)
{
case '\x0':
TokenType = eTokenType.end_of_expr;
break;
case '-':
NextChar();
TokenType = eTokenType.operator_minus;
break;
case '+':
NextChar();
TokenType = eTokenType.operator_plus;
break;
case '*':
NextChar();
TokenType = eTokenType.operator_mul;
break;
case '/':
NextChar();
TokenType = eTokenType.operator_div;
break;
case '(':
NextChar();
TokenType = eTokenType.open_parenthesis;
break;
case ')':
NextChar();
TokenType = eTokenType.close_parenthesis;
break;
case '<':
NextChar();
switch (_CurrentChar)
{
case '=':
NextChar();
TokenType = eTokenType.operator_le;
break;
case '>':
NextChar();
TokenType = eTokenType.operator_ne;
break;
default:
TokenType = eTokenType.operator_lt;
break;
}
break;
case '>':
NextChar();
if (_CurrentChar == '=')
{
NextChar();
TokenType = eTokenType.operator_ge;
}
else
{
TokenType = eTokenType.operator_gt;
}
break;
case ',':
NextChar();
TokenType = eTokenType.comma;
break;
case '=':
NextChar();
TokenType = eTokenType.operator_eq;
break;
case '.':
NextChar();
TokenType = eTokenType.dot;
break;
case '"':
ParseText();
break;
case '#':
ParseDate();
break;
case ' ':
break;
default:
if (_CurrentChar >= '0' && _CurrentChar <= '9')
{
ParseNumber();
}
else
{
ParseIdentifier();
}
break;
}
if (TokenType != eTokenType.none)
{
break;
}
NextChar();
} while (true);
}
public Token(eTokenType type, string value)
{
this.Type = type;
this.Value = value;
}
public opCodeBinary(tokenizer tokenizer, opCode param1, eTokenType tt, opCode param2)
{
mParam1 = param1;
mParam2 = param2;
EvalType v1Type = mParam1.EvalType;
EvalType v2Type = mParam2.EvalType;
switch (tt)
{
case eTokenType.operator_plus:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_PLUS_NUM;
mEvalType = EvalType.Number;
}
else if (v1Type == EvalType.Number & v2Type == EvalType.Date)
{
SwapParams(ref mParam1, mParam2);
mValueDelegate = DATE_PLUS_NUM;
mEvalType = EvalType.Date;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Number)
{
mValueDelegate = DATE_PLUS_NUM;
mEvalType = EvalType.Date;
}
else if (mParam1.CanReturn(EvalType.String) & mParam2.CanReturn(EvalType.String))
{
Convert(tokenizer, param1, ref EvalType.String);
mValueDelegate = STR_CONCAT_STR;
mEvalType = EvalType.String;
}
break;
case eTokenType.operator_minus:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_MINUS_NUM;
mEvalType = EvalType.Number;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Number)
{
mValueDelegate = DATE_MINUS_NUM;
mEvalType = EvalType.Date;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Date)
{
mValueDelegate = DATE_MINUS_DATE;
mEvalType = EvalType.Number;
}
break;
case eTokenType.operator_mul:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_MUL_NUM;
mEvalType = EvalType.Number;
}
break;
case eTokenType.operator_div:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_DIV_NUM;
mEvalType = EvalType.Number;
}
break;
case eTokenType.operator_percent:
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_PERCENT_NUM;
mEvalType = EvalType.Number;
}
break;
case eTokenType.operator_and:
case eTokenType.operator_or:
Convert(tokenizer, mParam1, ref EvalType.Boolean);
Convert(tokenizer, mParam2, ref EvalType.Boolean);
switch (tt)
{
case eTokenType.operator_or:
mValueDelegate = BOOL_OR_BOOL;
mEvalType = EvalType.Boolean;
break;
case eTokenType.operator_and:
mValueDelegate = BOOL_AND_BOOL;
mEvalType = EvalType.Boolean;
break;
}
break;
}
if (mValueDelegate == null)
{
tokenizer.RaiseError("Cannot apply the operator " + tt.ToString().Replace("operator_", "") + " on " + v1Type.ToString() + " and " + v2Type.ToString());
}
}
private void ParseDate()
{
NextChar();
// eat the #
int zone = 0;
while ((mCurChar >= '0' & mCurChar <= '9') | (mCurChar == '/') | (mCurChar == ':') | (mCurChar == ' '))
{
value.Append(mCurChar);
NextChar();
}
if (mCurChar != "#")
{
RaiseError("Invalid date should be #dd/mm/yyyy#");
}
else
{
NextChar();
}
type = eTokenType.value_date;
}
protected JsonScannerToken ReturnToken(eTokenType tipo)
{
return(ReturnToken(tipo, null));
}
private object ParseExpr(ePriority ePriority)
{
object ValueLeft = null, ValueRight;
LeftParse:
#region LeftParse
switch (_Tokenizer.TokenType)
{
case eTokenType.operator_minus:
_Tokenizer.NextToken();
ValueLeft = ParseExpr(ePriority.UnaryMinus);
if (ValueLeft.GetType() == typeof(decimal))
{
ValueLeft = -(decimal)ValueLeft;
}
else
{
throw new ApplicationException("Operator Unary Minus pada nilai non numerik");
}
break;
case eTokenType.operator_plus:
_Tokenizer.NextToken();
goto LeftParse;
case eTokenType.operator_not:
_Tokenizer.NextToken();
ValueLeft = ParseExpr(ePriority.Not);
if (ValueLeft.GetType() == typeof(bool))
{
ValueLeft = !(bool)ValueLeft;
}
else
{
throw new ApplicationException("Operator NOT pada nilai non boolean");
}
break;
case eTokenType.value_identifier:
ValueLeft = ParseIdentifier();
break;
case eTokenType.value_true:
ValueLeft = true;
_Tokenizer.NextToken();
break;
case eTokenType.value_false:
ValueLeft = false;
_Tokenizer.NextToken();
break;
case eTokenType.value_string:
ValueLeft = _Tokenizer.Value.ToString();
_Tokenizer.NextToken();
break;
case eTokenType.value_number:
decimal TmpNum;
if (!decimal.TryParse(_Tokenizer.Value.ToString(),
NumberStyles.Number, BaseUtility.DefaultCultureInfo,
out TmpNum))
{
ValueLeft = decimal.Zero;
}
else
{
ValueLeft = TmpNum;
}
_Tokenizer.NextToken();
break;
case eTokenType.value_date:
DateTime TmpDate;
if (!DateTime.TryParse(_Tokenizer.Value.ToString(),
BaseUtility.DefaultCultureInfo, DateTimeStyles.None,
out TmpDate))
{
ValueLeft = DateTime.Today;
}
else
{
ValueLeft = TmpDate;
}
_Tokenizer.NextToken();
break;
case eTokenType.open_parenthesis:
_Tokenizer.NextToken();
ValueLeft = ParseExpr(ePriority.None);
if (_Tokenizer.TokenType == eTokenType.close_parenthesis)
{
_Tokenizer.NextToken();
}
else
{
throw new ApplicationException("Kurung Tutup tidak ditemukan !");
}
break;
}
#endregion
if (ValueLeft == null)
{
return(null);
}
RightParse:
#region RightParse
eTokenType tt = _Tokenizer.TokenType;
switch (tt)
{
case eTokenType.end_of_expr:
return(ValueLeft);
case eTokenType.value_number:
throw new ApplicationException("Bilangan diikuti Bilangan tanpa Operator");
case eTokenType.operator_plus:
case eTokenType.operator_minus:
if (ePriority < ePriority.PlusMinus)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.PlusMinus);
Type tp = ValueLeft.GetType();
if (tp == typeof(decimal))
{
Type tp2 = ValueRight.GetType();
if (tp2 == typeof(decimal))
{
if (tt == eTokenType.operator_plus)
{
ValueLeft = (decimal)ValueLeft + (decimal)ValueRight;
}
else
{
ValueLeft = (decimal)ValueLeft - (decimal)ValueRight;
}
goto RightParse;
}
else if (tp2 == typeof(DateTime))
{
if (tt == eTokenType.operator_plus)
{
ValueLeft = ((DateTime)ValueRight).AddDays(
Convert.ToDouble(ValueLeft));
}
goto RightParse;
}
else
{
throw new ApplicationException(
"Operator Tambah/ Kurang pada Data bukan Bilangan/ DateTime");
}
}
else if (tp == typeof(DateTime))
{
Type tp2 = ValueRight.GetType();
if (tp2 == typeof(decimal))
{
if (tt == eTokenType.operator_plus)
{
ValueLeft = ((DateTime)ValueLeft).AddDays(
Convert.ToDouble(ValueRight));
}
else
{
ValueLeft = ((DateTime)ValueLeft).AddDays(
-Convert.ToDouble(ValueRight));
}
goto RightParse;
}
else
{
throw new ApplicationException(
"Operator Tambah/ Kurang pada Data bukan Bilangan/ DateTime");
}
}
else if (tp == typeof(string))
{
ValueLeft = ValueLeft + ValueRight.ToString();
goto RightParse;
}
else
{
throw new ApplicationException(
"Operator Tambah/ Kurang pada Data bukan Bilangan/ DateTime");
}
}
break;
case eTokenType.operator_mul:
case eTokenType.operator_div:
if (ePriority < ePriority.MulDiv)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.MulDiv);
if (ValueLeft.GetType() == typeof(decimal) &&
ValueRight.GetType() == typeof(decimal))
{
if (tt == eTokenType.operator_mul)
{
ValueLeft = (decimal)ValueLeft * (decimal)ValueRight;
}
else
{
ValueLeft = (decimal)ValueLeft / (decimal)ValueRight;
}
goto RightParse;
}
else
{
throw new ApplicationException("Operator Kali/ Bagi pada Data bukan Bilangan");
}
}
break;
case eTokenType.operator_or:
if (ePriority < ePriority.Or)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.Or);
if (ValueLeft.GetType() == typeof(bool) &&
ValueRight.GetType() == typeof(bool))
{
ValueLeft = (bool)ValueLeft || (bool)ValueRight;
goto RightParse;
}
else
{
throw new ApplicationException("Operator OR pada Data bukan Boolean");
}
}
break;
case eTokenType.operator_and:
if (ePriority < ePriority.And)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.And);
if (ValueLeft.GetType() == typeof(bool) &&
ValueRight.GetType() == typeof(bool))
{
ValueLeft = (bool)ValueLeft && (bool)ValueRight;
goto RightParse;
}
else
{
throw new ApplicationException("Operator AND pada Data bukan Boolean");
}
}
break;
case eTokenType.operator_eq:
if (ePriority < ePriority.Equality)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.Equality);
Type tp = ValueLeft.GetType();
if (!object.ReferenceEquals(tp, ValueRight.GetType()))
{
throw new ApplicationException("Membandingkan dua jenis data yang berbeda");
}
if (tp == typeof(decimal))
{
ValueLeft = (decimal)ValueLeft == (decimal)ValueRight;
}
else if (tp == typeof(string))
{
ValueLeft = (string)ValueLeft == (string)ValueRight;
}
else if (tp == typeof(DateTime))
{
ValueLeft = (DateTime)ValueLeft == (DateTime)ValueRight;
}
else if (tp == typeof(bool))
{
ValueLeft = (bool)ValueLeft == (bool)ValueRight;
}
goto RightParse;
}
break;
case eTokenType.operator_ne:
if (ePriority < ePriority.Equality)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.Equality);
Type tp = ValueLeft.GetType();
if (!object.ReferenceEquals(tp, ValueRight.GetType()))
{
throw new ApplicationException("Membandingkan dua jenis data yang berbeda");
}
if (tp == typeof(decimal))
{
ValueLeft = (decimal)ValueLeft != (decimal)ValueRight;
}
else if (tp == typeof(string))
{
ValueLeft = (string)ValueLeft != (string)ValueRight;
}
else if (tp == typeof(DateTime))
{
ValueLeft = (DateTime)ValueLeft != (DateTime)ValueRight;
}
else if (tp == typeof(bool))
{
ValueLeft = (bool)ValueLeft != (bool)ValueRight;
}
goto RightParse;
}
break;
case eTokenType.operator_lt:
if (ePriority < ePriority.Equality)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.Equality);
Type tp = ValueLeft.GetType();
if (!object.ReferenceEquals(tp, ValueRight.GetType()))
{
throw new ApplicationException("Membandingkan dua jenis data yang berbeda");
}
if (tp == typeof(decimal))
{
ValueLeft = (decimal)ValueLeft < (decimal)ValueRight;
}
else if (tp == typeof(string))
{
ValueLeft = string.Compare((string)ValueLeft, (string)ValueRight);
}
else if (tp == typeof(DateTime))
{
ValueLeft = (DateTime)ValueLeft < (DateTime)ValueRight;
}
else if (tp == typeof(bool))
{
ValueLeft = !(bool)ValueLeft && (bool)ValueRight;
}
goto RightParse;
}
break;
case eTokenType.operator_le:
if (ePriority < ePriority.Equality)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.Equality);
Type tp = ValueLeft.GetType();
if (!object.ReferenceEquals(tp, ValueRight.GetType()))
{
throw new ApplicationException("Membandingkan dua jenis data yang berbeda");
}
if (tp == typeof(decimal))
{
ValueLeft = (decimal)ValueLeft <= (decimal)ValueRight;
}
else if (tp == typeof(string))
{
ValueLeft = string.Compare((string)ValueLeft, (string)ValueRight);
}
else if (tp == typeof(DateTime))
{
ValueLeft = (DateTime)ValueLeft <= (DateTime)ValueRight;
}
else if (tp == typeof(bool))
{
ValueLeft = !(bool)ValueLeft && (bool)ValueRight ||
(bool)ValueLeft == (bool)ValueRight;
}
goto RightParse;
}
break;
case eTokenType.operator_gt:
if (ePriority < ePriority.Equality)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.Equality);
Type tp = ValueLeft.GetType();
if (!object.ReferenceEquals(tp, ValueRight.GetType()))
{
throw new ApplicationException("Membandingkan dua jenis data yang berbeda");
}
if (tp == typeof(decimal))
{
ValueLeft = (decimal)ValueLeft > (decimal)ValueRight;
}
else if (tp == typeof(string))
{
ValueLeft = string.Compare((string)ValueLeft, (string)ValueRight);
}
else if (tp == typeof(DateTime))
{
ValueLeft = (DateTime)ValueLeft > (DateTime)ValueRight;
}
else if (tp == typeof(bool))
{
ValueLeft = (bool)ValueLeft && !(bool)ValueRight;
}
goto RightParse;
}
break;
case eTokenType.operator_ge:
if (ePriority < ePriority.Equality)
{
_Tokenizer.NextToken();
ValueRight = ParseExpr(ePriority.Equality);
Type tp = ValueLeft.GetType();
if (!object.ReferenceEquals(tp, ValueRight.GetType()))
{
throw new ApplicationException("Membandingkan dua jenis data yang berbeda");
}
if (tp == typeof(decimal))
{
ValueLeft = (decimal)ValueLeft >= (decimal)ValueRight;
}
else if (tp == typeof(string))
{
ValueLeft = string.Compare((string)ValueLeft, (string)ValueRight);
}
else if (tp == typeof(DateTime))
{
ValueLeft = (DateTime)ValueLeft >= (DateTime)ValueRight;
}
else if (tp == typeof(bool))
{
ValueLeft = (bool)ValueLeft && !(bool)ValueRight ||
(bool)ValueLeft == (bool)ValueRight;
}
goto RightParse;
}
break;
}
#endregion
return(ValueLeft);
}
private void ParseNumber()
{
type = eTokenType.value_number;
while (mCurChar >= '0' & mCurChar <= '9')
{
value.Append(mCurChar);
NextChar();
}
if (mCurChar == '.')
{
value.Append(mCurChar);
NextChar();
while (mCurChar >= '0' & mCurChar <= '9')
{
value.Append(mCurChar);
NextChar();
}
}
}
private void ParseIdentifier()
{
while ((mCurChar >= '0' & mCurChar <= '9') | (mCurChar >= 'a' & mCurChar <= 'z') | (mCurChar >= 'A' & mCurChar <= 'Z') | (mCurChar >= 'A' & mCurChar <= 'Z') | (mCurChar >= (128)) | (mCurChar == '_'))
{
value.Append(mCurChar);
NextChar();
}
switch (value.ToString())
{
case "and":
type = eTokenType.operator_and;
break;
case "or":
type = eTokenType.operator_or;
break;
case "not":
type = eTokenType.operator_not;
break;
case "true":
case "yes":
type = eTokenType.value_true;
break;
case "if":
type = eTokenType.operator_if;
break;
case "false":
case "no":
type = eTokenType.value_false;
break;
default:
type = eTokenType.value_identifier;
break;
}
}
public void NextToken()
{
value.Length = 0;
type = eTokenType.none;
do
{
startpos = mPos;
switch (mCurChar)
{
case default(Char):
{
type = eTokenType.end_of_formula;
break;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
ParseNumber();
break;
}
case '-':
case '–':
{
NextChar();
type = eTokenType.operator_minus;
break;
}
case '+':
{
NextChar();
type = eTokenType.operator_plus;
break;
}
case '*':
{
NextChar();
type = eTokenType.operator_mul;
break;
}
case '/':
{
NextChar();
type = eTokenType.operator_div;
break;
}
case '%':
{
NextChar();
type = eTokenType.operator_percent;
break;
}
case '(':
{
NextChar();
type = eTokenType.open_parenthesis;
break;
}
case ')':
{
NextChar();
type = eTokenType.close_parenthesis;
break;
}
case '<':
{
NextChar();
if (mCurChar == '=')
{
NextChar();
type = eTokenType.operator_le;
}
else if (mCurChar == '>')
{
NextChar();
type = eTokenType.operator_ne;
}
else
{
type = eTokenType.operator_lt;
}
break;
}
case '>':
{
NextChar();
if (mCurChar == '=')
{
NextChar();
type = eTokenType.operator_ge;
}
else
{
type = eTokenType.operator_gt;
}
break;
}
case ',':
{
NextChar();
type = eTokenType.comma;
break;
}
case '=':
{
NextChar();
type = eTokenType.operator_eq;
break;
}
case '.':
{
NextChar();
type = eTokenType.dot;
break;
}
case '\'':
case '"':
{
ParseString(true);
type = eTokenType.value_string;
break;
}
case '#':
{
ParseDate();
break;
}
case '&':
{
NextChar();
type = eTokenType.operator_concat;
break;
}
case '[':
{
NextChar();
type = eTokenType.open_bracket;
break;
}
case ']':
{
NextChar();
type = eTokenType.close_bracket;
break;
}
//case (char)0 <= mCurChar && mCurChar <= ' ':
// {
// break;
// }
default:
{
ParseIdentifier();
break;
}
}
if (type != eTokenType.none)
{
break;
}
NextChar();
}while (true);
}
public opCodeUnary(eTokenType tt, opCode param1)
{
mParam1 = param1;
EvalType v1Type = mParam1.EvalType;
switch (tt)
{
case eTokenType.operator_not:
if (v1Type == EvalType.Boolean)
{
mValueDelegate = BOOLEAN_NOT;
mEvalType = EvalType.Boolean;
}
break;
case eTokenType.operator_minus:
if (v1Type == EvalType.Number)
{
mValueDelegate = NUM_CHGSIGN;
mEvalType = EvalType.Number;
}
break;
}
}
public opCodeBinary(tokenizer tokenizer, opCode param1, eTokenType tt, opCode param2)
{
mParam1 = param1;
mParam2 = param2;
mParam1.ValueChanged += mParam1_ValueChanged;
mParam2.ValueChanged += mParam2_ValueChanged;
EvalType v1Type = mParam1.EvalType;
EvalType v2Type = mParam2.EvalType;
switch (tt)
{
case eTokenType.operator_plus:
{
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_PLUS_NUM;
mEvalType = EvalType.Number;
}
else if (v1Type == EvalType.Number & v2Type == EvalType.Date)
{
SwapParams(ref mParam1, ref mParam2);
mValueDelegate = DATE_PLUS_NUM;
mEvalType = EvalType.Date;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Number)
{
mValueDelegate = DATE_PLUS_NUM;
mEvalType = EvalType.Date;
}
else if (mParam1.CanReturn(EvalType.String) & mParam2.CanReturn(EvalType.String))
{
Convert(tokenizer, ref param1, EvalType.String);
mValueDelegate = STR_CONCAT_STR;
mEvalType = EvalType.String;
}
break;
}
case eTokenType.operator_minus:
{
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_MINUS_NUM;
mEvalType = EvalType.Number;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Number)
{
mValueDelegate = DATE_MINUS_NUM;
mEvalType = EvalType.Date;
}
else if (v1Type == EvalType.Date & v2Type == EvalType.Date)
{
mValueDelegate = DATE_MINUS_DATE;
mEvalType = EvalType.Number;
}
break;
}
case eTokenType.operator_mul:
{
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_MUL_NUM;
mEvalType = EvalType.Number;
}
break;
}
case eTokenType.operator_div:
{
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_DIV_NUM;
mEvalType = EvalType.Number;
}
break;
}
case eTokenType.operator_percent:
{
if (v1Type == EvalType.Number & v2Type == EvalType.Number)
{
mValueDelegate = NUM_PERCENT_NUM;
mEvalType = EvalType.Number;
}
break;
}
case eTokenType.operator_and:
case eTokenType.operator_or:
{
Convert(tokenizer, ref mParam1, EvalType.Boolean);
Convert(tokenizer, ref mParam2, EvalType.Boolean);
switch (tt)
{
case eTokenType.operator_or:
{
mValueDelegate = BOOL_OR_BOOL;
mEvalType = EvalType.Boolean;
break;
}
case eTokenType.operator_and:
{
mValueDelegate = BOOL_AND_BOOL;
mEvalType = EvalType.Boolean;
break;
}
}
break;
}
}
if (mValueDelegate == null)
{
tokenizer.RaiseError("Cannot apply the operator " + tt.ToString().Replace("operator_", "") + " on " + v1Type.ToString() + " and " + v2Type.ToString());
}
}
public cToken(eTokenType a_type, object a_value)
{
cf_Type = a_type;
cf_Value = a_value;
}
public Token(eTokenType type, string value)
{
Type = type;
Value = value;
}
public Token(eTokenType type)
{
mType = type;
}
public TokenTypeLu(string tokenInterned, eTokenType tokenType)
{
TokenInterned = tokenInterned;
TokenType = tokenType;
}
public Token(eTokenType type, char value)
{
Type = type;
Value = value.ToString();
}
public cToken(eTokenType a_type, object a_value)
{
cf_Type = a_type;
cf_Value = a_value;
}
