public ExprRecResult Recognize(CodeString Code, PluginRoot Plugin, ref ExpressionNode Out)
{
var Result = Code.StartsWith(Operators, Skip, new IdCharCheck(true));
if (Result.Position != -1)
{
var State = Plugin.State;
var Right = Code.Substring(Result.String.Length).Trim();
Right = Right.TrimOneBracket(SkippingHandlers);
if (Right.Length == 0)
{
State.Messages.Add(MessageId.DeficientExpr, Code);
return(ExprRecResult.Failed);
}
var TypeMngrPlugin = Plugin.GetPlugin <TypeMngrPlugin>();
if (TypeMngrPlugin == null)
{
return(ExprRecResult.Unknown);
}
var OldCheckingMode = TypeMngrPlugin.CheckingMode;
if (Result.Index == 0)
{
TypeMngrPlugin.CheckingMode = CheckingMode.Checked;
}
else if (Result.Index == 1)
{
TypeMngrPlugin.CheckingMode = CheckingMode.Unchecked;
}
else
{
throw new ApplicationException();
}
Out = Expressions.Recognize(Right, Plugin);
TypeMngrPlugin.CheckingMode = OldCheckingMode;
if (Out == null)
{
return(ExprRecResult.Failed);
}
else
{
return(ExprRecResult.Ready);
}
}
return(ExprRecResult.Unknown);
}
private bool AllocateObject(CodeScopeNode Scope, ref int Index, SelfVariable Self, ExpressionNode Size, PluginRoot Plugin, CodeString Code)
{
var TypeMngrPlugin = Plugin.GetPlugin <TypeMngrPlugin>();
TypeMngrPlugin.Flags |= TypeMngrPluginFlags.NoWarningOnCastingToSameType;
TypeMngrPlugin.Flags |= TypeMngrPluginFlags.EnableReadonlyWriting;
var Func = Identifiers.GetByFullNameFast <Function>(Scope.State, "Internals.ObjectHelper.Allocate");
if (Func == null)
{
return(false);
}
var FuncNode = Plugin.NewNode(new IdExpressionNode(Func, Code));
if (Func == null)
{
return(false);
}
var FuncType = Func.Children[0] as TypeOfFunction;
var SizeParam = FuncType.Children[1] as FunctionParameter;
if (Size.Type == null || !Size.Type.IsEquivalent(SizeParam.TypeOfSelf))
{
Size = Expressions.Convert(Size, SizeParam.TypeOfSelf, Plugin, Code);
if (Size == null)
{
return(false);
}
}
var CallCh = new ExpressionNode[] { FuncNode, Size };
var Call = Plugin.NewNode(new OpExpressionNode(Operator.Call, CallCh, Code));
if (Call == null)
{
return(false);
}
var Node = Expressions.Reinterpret(Call, Self.TypeOfSelf, Plugin, Code);
if (Node == null)
{
return(false);
}
var FS = Scope.FunctionScope;
var Assignment = Expressions.SetValue(FS.SelfVariable, Node, Plugin, Code, true);
if (Assignment == null)
{
return(false);
}
var Command = new Command(Scope, Code, CommandType.Expression);
Command.Expressions = new List <ExpressionNode>()
{
Assignment
};
Scope.Children.Insert(Index, Command);
Index++;
return(ProcessContainer(Command));
}
public static ExpressionNode FlattenIndices(PluginRoot Plugin, ExpressionNode[] Indices,
ExpressionNode[] Dimensions, CodeString Code, Identifier TempVarType = null)
{
if (Dimensions.Length == 1)
{
return(Indices[0]);
}
var Ret = (ExpressionNode)null;
var MulVar = (Identifier)null;
var Container = Plugin.Container;
var State = Plugin.State;
if (Dimensions.Length >= 2)
{
var NCPlugin = Plugin.GetPlugin <NCPlugin>();
var DeclContainer = NCPlugin.DeclContainer;
MulVar = DeclContainer.CreateAndDeclareVariable(State.AutoVarName, TempVarType);
if (MulVar == null)
{
return(null);
}
}
for (var i = Dimensions.Length - 1; i >= 0; i--)
{
var Chi = Indices[i];
var LinkedNode = (LinkedExprNode)null;
if (MulVar != null && i != 1)
{
ExpressionNode[] AssignmentCh;
if (i == Dimensions.Length - 1)
{
var Dst = Plugin.NewNode(new IdExpressionNode(MulVar, Code));
if (Dst == null)
{
return(null);
}
AssignmentCh = new ExpressionNode[] { Dst, Dimensions[i] };
}
else
{
var Dst = Plugin.NewNode(new IdExpressionNode(MulVar, Code));
var MulSrc = Plugin.NewNode(new IdExpressionNode(MulVar, Code));
if (Dst == null || MulSrc == null)
{
return(null);
}
var MulCh = new ExpressionNode[] { MulSrc, Dimensions[i] };
var MulNode = Plugin.NewNode(new OpExpressionNode(Operator.Multiply, MulCh, Code));
if (MulNode == null)
{
return(null);
}
AssignmentCh = new ExpressionNode[] { Dst, MulNode };
}
var Assignment = Plugin.NewNode(new OpExpressionNode(Operator.Assignment, AssignmentCh, Code));
if (Assignment == null)
{
return(null);
}
LinkedNode = new LinkedExprNode(Assignment, LinkedNodeFlags.NotRemovable);
}
if (MulVar != null && i != Dimensions.Length - 1)
{
var MulNode = Plugin.NewNode(new IdExpressionNode(MulVar, Code));
if (MulNode == null)
{
return(null);
}
var MulCh = new ExpressionNode[] { Chi, MulNode };
Chi = Plugin.NewNode(new OpExpressionNode(Operator.Multiply, MulCh, Code));
if (Chi == null)
{
return(null);
}
}
if (Ret != null)
{
var AddCh = new ExpressionNode[] { Ret, Chi };
var AddNode = new OpExpressionNode(Operator.Add, AddCh, Code);
if (LinkedNode != null)
{
AddNode.LinkedNodes.Add(LinkedNode);
}
Ret = Plugin.NewNode(AddNode);
if (Ret == null)
{
return(null);
}
}
else
{
Ret = Chi;
if (LinkedNode != null)
{
Ret.LinkedNodes.Add(LinkedNode);
}
}
}
return(Ret);
}
