public static IPyValue FindIncrement(PyVariableExpression controlVariable, IPyStatement statement)
{
if (statement is PyExpressionStatement expressionStatement)
{
return(FindIncrement(controlVariable, expressionStatement.Expression));
}
return(null);
}
/// <summary>
/// Tworzy instancję obiektu
/// <param name="initVariables"></param>
/// <param name="condition"></param>
/// <param name="statement"></param>
/// <param name="incrementors"></param>
/// </summary>
public PyForStatement(PyAssignExpression[] initVariables, IPyValue condition, IPyStatement statement,
IPyStatement[] incrementors)
{
InitVariables = initVariables;
Condition = condition;
Statement = statement;
Incrementors = incrementors;
}
/// <summary>
/// Tworzy instancję obiektu
/// <param name="keyVarname"></param>
/// <param name="valueVarname"></param>
/// <param name="collection"></param>
/// <param name="statement"></param>
/// </summary>
public PyForEachStatement(string keyVarname, string valueVarname, IPyValue collection,
IPyStatement statement)
{
KeyVarname = keyVarname;
ValueVarname = valueVarname;
Collection = collection;
Statement = statement;
}
public static PyCodeBlock Bound(IPyStatement s)
{
if (s is PyCodeBlock)
{
return(s as PyCodeBlock);
}
var g = new PyCodeBlock();
g.Statements.Add(s);
return(g);
}
public static IPyStatement Reduce(IPyStatement x)
{
if (x == null)
{
return(x);
}
if (x is PyCodeBlock)
{
var src = x as PyCodeBlock;
if (src.Statements.Count == 0)
{
return(null);
}
if (src.Statements.Count > 1)
{
return(x);
}
return(Reduce(src.Statements[0]));
}
return(x);
}
// Public Methods
public static bool HasAny(IPyStatement x)
{
if (x == null)
{
return(false);
}
if (x is PyCodeBlock)
{
var src = x as PyCodeBlock;
if (src.Statements.Count == 0)
{
return(false);
}
if (src.Statements.Count > 1)
{
return(true);
}
return(HasAny(src.Statements[0]));
}
return(true);
}
public PyCodeBlock(IPyStatement other)
{
Statements.Add(other);
}
/// <summary>
/// try to resolve simple case like for(int i=0; i<10; i++)
/// </summary>
private static IPyStatement[] TrySimpleForLoop(
PyAssignExpression[] pyDeclarations,
IPyStatement[] incrementors,
IPyValue condition,
IPyStatement statement)
{
if (pyDeclarations.Length != 1 || incrementors.Length != 1)
{
return(null);
}
var dec = pyDeclarations[0];
if (!(dec.Left is PyVariableExpression controlVariable))
{
return(null);
}
if (!(condition is PyBinaryOperatorExpression binCondition))
{
return(null);
}
binCondition = VariableOnLeft(binCondition, controlVariable.VariableName);
var loopIncrement = FindIncrement(controlVariable, incrementors[0]);
if (loopIncrement == null)
{
return(null);
}
var loopStart = pyDeclarations[0].Right;
IPyStatement[] Q(object incrementValue)
{
var range = new PyMethodCallExpression("range");
var isOneIncrement = ValueHelper.EqualsNumericOne(incrementValue) ?? false;
if (!IsConstZero(loopStart) || !isOneIncrement)
{
range.Arguments.Add(new PyMethodInvokeValue(loopStart));
}
range.Arguments.Add(new PyMethodInvokeValue(binCondition.Right));
if (!isOneIncrement)
{
range.Arguments.Add(
new PyMethodInvokeValue(new PyConstValue(incrementValue)));
}
var foreachStatement =
new PyForEachStatement(controlVariable.VariableName, range, statement);
return(new IPyStatement[] { foreachStatement });
}
if (loopIncrement is PyConstValue constLoopIncrement)
{
switch (binCondition.Operator)
{
case "<":
{
if (ValueHelper.IsGreaterThanZero(constLoopIncrement.Value) ?? false)
{
return(Q(constLoopIncrement.Value));
}
}
break;
case ">":
{
if (ValueHelper.IsLowerThanZero(constLoopIncrement.Value) ?? false)
{
return(Q(constLoopIncrement.Value));
}
}
break;
}
}
var result = new PyForStatement(pyDeclarations.ToArray(), condition, statement, incrementors);
return(new IPyStatement[] { result });
}
/// <summary>
/// Tworzy instancję obiektu
/// <param name="condition"></param>
/// <param name="statement"></param>
/// </summary>
public PyWhileStatement(IPyValue condition, IPyStatement statement)
{
Condition = condition;
Statement = statement;
}
// Protected Methods
protected void EmitHeaderStatement(PySourceCodeEmiter emiter, PySourceCodeWriter writer, PyEmitStyle style, string header, IPyStatement statement)
{
style = style ?? new PyEmitStyle();
var iStyle = PyEmitStyle.xClone(style, ShowBracketsEnum.IfManyItems);
if (style.UseBracketsEvenIfNotNecessary)
{
iStyle.Brackets = ShowBracketsEnum.Always;
}
var statementToEmit = PyCodeBlock.Reduce(statement);
var emptyStatement = !PyCodeBlock.HasAny(statementToEmit);
if (emptyStatement)
{
header += "{}";
}
if (style.Compression == EmitStyleCompression.NearCrypto)
{
writer.Write(header);
}
else
{
writer.WriteLn(header);
}
if (emptyStatement)
{
return;
}
var myBracket = style.UseBracketsEvenIfNotNecessary;
if (!myBracket)
{
var gf = statementToEmit.GetStatementEmitInfo(iStyle);
if (gf != StatementEmitInfo.NormalSingleStatement)
{
myBracket = true;
}
}
writer.IncIndent();
if (myBracket)
{
iStyle.Brackets = ShowBracketsEnum.Never;
writer.OpenLn("{");
}
statementToEmit.Emit(emiter, writer, iStyle);
if (myBracket)
{
writer.CloseLn("}");
}
writer.DecIndent();
}
private static IPyStatement[] MkArray(IPyStatement x)
{
return(new[] { x });
}
/// <summary>
/// Tworzy instancję obiektu
/// <param name="condition"></param>
/// <param name="ifTrue"></param>
/// <param name="ifFalse"></param>
/// </summary>
public PyIfStatement(IPyValue condition, IPyStatement ifTrue, IPyStatement ifFalse)
{
Condition = condition;
IfTrue = ifTrue;
IfFalse = ifFalse;
}
