private Expression ParseKeyword_WHILE(string Keyword)
{
var Element = ParseBoolean(false).ConvertTo(typeof(bool));
var snap = ExpressionTypeBeam.TakeSnapshot();
ConsumeWS();
if (!EOL)
{
var @break = Expression.Label();
var @continue = Expression.Label();
return(Expression.Block(
Expression.Label(@continue),
Expression.IfThen(Expression.Not(Element), Expression.Goto(@break)),
ParseBoolean(),
Expression.Goto(@continue),
Expression.Label(@break)));
}
else if (!INTERCATIVE)
{
var @break = Expression.Label("break");
var @continue = Expression.Label("continue");
Contextual.Push(Expression.Goto(@break));
Contextual.Push(Expression.Goto(@continue));
List <Expression> Instruction = new List <Expression>();
Instruction.Add(Expression.Label(@continue));
Instruction.Add(Expression.IfThen(Expression.Not(Element), Expression.Goto(@break)));
Instruction.AddRange(ParseBlock(true));
Instruction.Add(Expression.Goto(@continue));
Instruction.Add(Expression.Label(@break));
Instruction.Add(ExpressionTypeBeam.RestoreSnapshot(snap));
Contextual.Pop();
Contextual.Pop();
return(Expression.Block(Instruction.ToArray()));
}
else
{
throw new AutoitException(AutoitExceptionType.MULTILINEININTERACTIVE, LineNumber, Cursor, Keyword);
}
}
private Expression ParseBlock()
{
ExpressionTypeBeam.PushBlockScope();
ConsumeWS();
Expression C1 = null;
List <Expression> BlockCT = new List <Expression>();
bool ct = true;
do
{
BlockCT.Add(C1);
C1 = ParseBoolean();
ct = !EOF && (!(C1 is AutExpression) || (C1 as AutExpression).ExpressionType != AutExpressionType.EndOfBlock);
if (ct)
{
NextLine();
}
} while (ct);
return(Expression.Block(ExpressionTypeBeam.PopScope(), BlockCT.Where(x => x != null)));
}
private Expression ParseKeyword_IF(string Keyword)
{
var Element = ParseBoolean(false).ConvertTo(typeof(bool));
ConsumeWS();
if (Peek(4).ToUpper() == "THEN")
{
Consume(4);
ConsumeWS();
if (!EOL)
{
ExpressionTypeBeam.PushBlockScope();
var Exp = ParseBoolean();
Exp = Expression.Block(ExpressionTypeBeam.PopScope(), Exp);
NextLine(); ConsumeWS();
if (Peek(6).ToUpper() == "ELSEIF")
{
Consume(6); return(Expression.IfThenElse(Element, Exp, ParseKeyword_IF(Keyword)));
}
else if (Peek(4).ToUpper() == "ELSE")
{
Consume(4);
ExpressionTypeBeam.PushBlockScope();
var e2 = ParseBoolean();
return(Expression.IfThenElse(Element, Exp, Expression.Block(ExpressionTypeBeam.PopScope(), e2)));
}
else
{
NextLine(-1); return(Expression.IfThen(Element, Exp));
}
}
else if (!INTERCATIVE)
{
Expression Condition = Element;
Expression Instruction = ParseBlock();
Seek();
ConsumeWS();
var s = Getstr(Reg_AlphaNum).ToUpper();
switch (s)
{
case "ELSE":
Expression Otherwise = ParseBlock();
Seek();
ConsumeWS();
return(Expression.IfThenElse(Condition, Instruction, Otherwise));
case "ELSEIF":
return(Expression.IfThenElse(Condition, Instruction, ParseKeywordOrFunc("IF")));
default:
return(Expression.IfThen(Condition, Instruction));
}
}
else
{
throw new AutoitException(AutoitExceptionType.MULTILINEININTERACTIVE, LineNumber, Cursor, Keyword);
}
}
else
{
throw new AutoitException(AutoitExceptionType.MISSINGTHEN, LineNumber, Cursor, ScriptLine);
}
}
private Expression ParseRelationnal(bool ExpectAssign = true, Type Desired = null)
{
ConsumeWS();
Expression C1, C2;
char ch;
C1 = ParseConcat();
do
{
ConsumeWS();
ch = Read()[0];
switch (ch)
{
case '<':
if (Peek() == ">")
{
Consume();
C2 = ParseConcat().ConvertTo(C1.Type);
C1 = Expression.NotEqual(C1, C2);
}
else if (Peek() == "=")
{
Consume();
C2 = ParseConcat();
C1 = Expression.LessThanOrEqual(
C1.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)));
}
else
{
C2 = ParseConcat();
C1 = Expression.LessThan(
C1.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)));
}
continue;
case '>':
if (Peek() == "=")
{
Consume();
C2 = ParseConcat();
C1 = Expression.GreaterThanOrEqual(
C1.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)));
}
else
{
C2 = ParseConcat();
C1 = Expression.GreaterThan(
C1.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)));
}
continue;
case '=':
if (Peek() == "=")
{
throw new NotSupportedException("Sorry, No support for ==");
C2 = ParseConcat();
C1 = Expression.AndAlso(Expression.TypeEqual(C1, C2.Type), Expression.Equal(C1, C2));
}
else if (ExpectAssign)
{
if (C1 is VarAutExpression)
{
Consume();
var value = ParseBoolean(false);
C1 = (C1 as VarAutExpression).Setter(value);
}
else
{
throw new AutoitException(AutoitExceptionType.ASSIGNTONOTVARIABLE, LineNumber, Cursor, C1.ToString());
}
}
else
{
C2 = ParseConcat();
C1 = Expression.Equal(
C1.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type)));
}
continue;
case '+':
if (Peek() != "=" || !ExpectAssign)
{
break;
}
Consume();
if (C1 is VarAutExpression)
{
ConsumeWS();
C2 = ParseBoolean(false);
C1 = (C1 as VarAutExpression).Setter(
Expression.Add(
(C1 as VarAutExpression).Getter(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type))
)
);
}
else
{
throw new AutoitException(AutoitExceptionType.ASSIGNTONOTVARIABLE, LineNumber, Cursor, C1.ToString());
}
continue;
case '-':
if (Peek() != "=" || !ExpectAssign)
{
break;
}
Consume();
if (C1 is VarAutExpression)
{
ConsumeWS();
C2 = ParseBoolean(false);
C1 = (C1 as VarAutExpression).Setter(
Expression.Subtract(
(C1 as VarAutExpression).Getter(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type))
)
);
}
else
{
throw new AutoitException(AutoitExceptionType.ASSIGNTONOTVARIABLE, LineNumber, Cursor, C1.ToString());
}
continue;
case '*':
if (Peek() != "=" || !ExpectAssign)
{
break;
}
Consume();
if (C1 is VarAutExpression)
{
ConsumeWS();
C2 = ParseBoolean(false);
C1 = (C1 as VarAutExpression).Setter(
Expression.Multiply(
(C1 as VarAutExpression).Getter(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type))
)
);
}
else
{
throw new AutoitException(AutoitExceptionType.ASSIGNTONOTVARIABLE, LineNumber, Cursor, C1.ToString());
}
continue;
case '/':
if (Peek() != "=" || !ExpectAssign)
{
break;
}
ConsumeWS();
if (C1 is VarAutExpression)
{
ConsumeWS();
C2 = ParseBoolean(false);
C1 = (C1 as VarAutExpression).Setter(
Expression.Divide(
(C1 as VarAutExpression).Getter(ExpressionTypeBeam.Largest(C1.Type, C2.Type)),
C2.ConvertTo(ExpressionTypeBeam.Largest(C1.Type, C2.Type))
)
);
}
else
{
throw new AutoitException(AutoitExceptionType.ASSIGNTONOTVARIABLE, LineNumber, Cursor, C1.ToString());
}
continue;
}
SeekRelative(-1);
break;
} while (!EOL);
return(C1);
}
//protected CompileFuncDelegate CompileFunc;
public void LiCompileFunction()
{
foreach (var ID in FunctionIdentifiers)
{
GotoLine(ID.Key);
var FMeta = GetFunctionMeta();
NextLine();
var Ret = Expression.Label();
Contextual.Push(Expression.Goto(Ret, FMeta.ReturnType));
ExpressionTypeBeam.PushScope();
foreach (var arg in FMeta.Parameters)
{
ExpressionTypeBeam.CurrentScope.SetVarCached(arg.Name, Expression.Constant(arg.ArgType.DefaultValue(), arg.ArgType), false);
}
ExpressionTypeBeam.CurrentScope.DefineFunc(ID.Value, Expression.Lambda(ParseBlock(), ExpressionTypeBeam.PopScope()));
}
/*
* return;
* var Matches = Script.Where(x => Regex.IsMatch(x, "^(?:\t| )*func(.*?)$", RegexOptions.IgnoreCase)).ToList();
* var Lines = Matches.Select(x => Array.IndexOf(Script, x));
* List<ParameterExpression> Params = new List<ParameterExpression>();
* foreach (var L in Lines)
* {
* GotoLine(L);
* var FMeta = GetFunctionMeta();
* ExpressionTypeBeam.PushScope();
* List<Expression> PreFunction = new List<Expression>();
*
* var MyFunc = ExpressionTypeBeam.CurrentScope.Parent.ScopeFunctions.First(x => x.Name == FMeta.Name && x.Parameters.SequenceEqual(FMeta.Parameters) && x.ReturnType == FMeta.ReturnType);
*
* PreFunction.Add(VarAutExpression.VariableAccess("Return-store", false)
* .Setter(Expression.Constant(FMeta.ReturnType.DefaultValue(), FMeta.ReturnType)));
* PreFunction.AddRange(
* MyFunc.Parameters.Select(x =>
* {
* var PType = x.GetTypeInfo().IsValueType ? typeof(Nullable<>).MakeGenericType(x) : x;
* Params.Add(Expression.Parameter(PType));
* return VarAutExpression.VariableAccess(x.ArgName).Setter(
* Expression.Coalesce(Params.Last(), x.DefaultValue().ConvertTo(x))
* );
* })
* );
* var Ret = Expression.Label();
* Contextual.Push(Expression.Goto(Ret, FMeta.ReturnType));
*
* var Block = ParseBlock();
*
* Block.Add(Expression.Label(Ret));
* Block.Add(VarAutExpression.VariableAccess("Return-store", false).Getter(L.FDef.ReturnType));
* ExpressionTypeBeam.CurrentScope.DefineFunc(, Expression.Lambda(Expression.Block(ExpressionTypeBeam.PopScope(), Block), Params));
* Block.Clear();
* Params.Clear();
* }*/
}
public static LambdaExpression Parse(
string s,
IScope GlobalScope,
IEnumerable <Assembly> RequireASM = null,
IEnumerable <Type> RequireType = null)
{
var l = new LiParser(
Regex.Replace(s, ";(.*)((\r\n)|(\r)|(\n))", "\r\n")
.Replace("\r\n", "\r")
);
l.Included = RequireASM != null?RequireASM.ToList() : new List <Assembly>();
l.IncludedType = RequireType != null?RequireType.ToList() : new List <Type>();
/*l.DefineFunc = D;
* l.CompileFunc = C;
* l.GetVar = G;
* l.SetVar = S;
* l.CreateVar = CR;*/
GlobalScope.Parent = new ClrScope((RequireType ?? new List <Type>()).Concat((RequireASM ?? new List <Assembly>()).SelectMany(x => x.ExportedTypes)));
ExpressionTypeBeam.InitializeParameterEngine(GlobalScope);
List <Expression> Output = new List <Expression>();
l.DefineGlobal();
l.DeclareAllFunctions();
l.LiCompileFunction();
ExpressionTypeBeam.PushScope();
l.Script = Regex.Replace(string.Join("\r", l.Script), "func(.*?)endfunc", "", RegexOptions.IgnoreCase | RegexOptions.Singleline).Split('\r');
if (l.Script.Length > 0)
{
l.GotoLine(0);
}
Expression ex;
var cmd = AutExpression.VariableAccess("CmdLine", false, Expression.Constant(1, typeof(int)), typeof(string)).Generator();
l.ConsumeWS();
if (l.ScriptLine != "" && !l.ScriptLine.StartsWith(";") && !l.EOF && !l.EOL)
{
ex = l.ParseBoolean();
if (ex is VarAutExpression)
{
ex = (ex as VarAutExpression).Generator();
}
Output.Add(ex);
}
while (!l.EOF)
{
try
{
l.NextLine();
}
catch { break; }
l.ConsumeWS();
if (l.ScriptLine == "" || l.ScriptLine.StartsWith(";") || l.EOF || l.EOL)
{
continue;
}
ex = l.ParseBoolean();
if (ex is VarAutExpression)
{
ex = (ex as VarAutExpression).Generator();
}
Output.Add(ex);
}
if (Output.Count(x => x != null) <= 0)
{
return(null);
}
var SC = ExpressionTypeBeam.PopScope();
BlockExpression e = Expression.Block(SC.Where(x => x.Name != "CmdLine" || x.Type != typeof(string[])), Output.ToArray().Where(x => x != null));
return(Expression.Lambda <Action <string[]> >(e, SC.First(x => x.Name == "CmdLine" && x.Type == typeof(string[]))));
}
