public static object __Translate(IExternalTranslationContext ctx, object src)
{
CallConstructor x = src as CallConstructor;
if (x == null)
{
return(null);
}
if (x.Arguments.Length != 0)
{
throw new NotSupportedException();
}
var g = new PhpArrayCreateExpression();
var a = x.Initializers.Cast <IValueTable_PseudoValue>().ToArray();
List <IPhpValue> o = new List <IPhpValue>();
foreach (var i in a)
{
var a1 = i as IValueTable_PseudoValue;
var a2 = a1.Items[0];
var a3 = a1.Items[1];
var key = ctx.TranslateValue(a2);
var value = ctx.TranslateValue(a3);
var t = new PhpAssignExpression(key, value);
o.Add(t);
}
g.Initializers = o.ToArray();
return(g);
}
protected override IPhpStatement[] VisitLocalDeclarationStatement(LocalDeclarationStatement src)
{
var s = new List <IPhpStatement>();
foreach (var i in src.Declaration.Declarators)
{
/// to jest przypadek z c# 'int x;', dla php można to pominąć
if (i.Value == null)
{
continue;
}
if (i.Value is UnknownIdentifierValue)
{
throw new NotImplementedException();
}
var l = new PhpVariableExpression(PhpVariableExpression.AddDollar(i.Name), PhpVariableKind.Local);
var r = TransValue(i.Value);
var tt = new PhpAssignExpression(l, r);
s.Add(new PhpExpressionStatement(tt));
//var r = new PhpAssignVariable( PhpVariableExpression.AddDollar(i.Name), false );
//// r.Name = "$" + i.Name;
//r.Value = TV(i.Value);
//s.Add(r);
}
return(s.ToArray());
}
protected virtual T VisitPhpAssignExpression(PhpAssignExpression node)
{
if (ThrowNotImplementedException)
{
throw new NotImplementedException(string.Format("Method {0} is not supported in class {1}", "VisitPhpAssignExpression", this.GetType().FullName));
}
return(default(T));
}
protected override IPhpValue VisitAssignExpression(CsharpAssignExpression src)
{
var l = TransValue(src.Left);
var r = TransValue(src.Right);
var op = src.OptionalOperator;
if (op == "+")
{
var vt = (src as IValue).ValueType;
if (vt == typeof(string))
{
op = ".";
}
}
var a = new PhpAssignExpression(l, r, op);
return(SimplifyPhpExpression(a));
}
protected override IPhpStatement[] VisitVariableDeclaration(VariableDeclaration src)
{
//throw new Exception("DELETE THIS ??????");
var s = new List <IPhpStatement>();
foreach (var i in src.Declarators)
{
var l = new PhpVariableExpression(PhpVariableExpression.AddDollar(i.Name), PhpVariableKind.Local);
var r = TransValue(i.Value);
var tt = new PhpAssignExpression(l, r);
s.Add(new PhpExpressionStatement(tt));
//var r = new PhpAssignVariable(PhpVariableExpression.AddDollar(i.Name), false);
//r.Value = TV(i.Value);
//s.Add(r);
}
return(s.ToArray());
}
public IPhpValue TranslateToPhp(IExternalTranslationContext ctx, CsharpMethodCallExpression src)
{
if (src.MethodInfo.DeclaringType != typeof(StringExtension))
{
return(null);
}
if (src.MethodInfo.Name != "PhpExplodeList")
{
return(null);
}
var a = src.Arguments
.Select(ctx.TranslateValue)
.Cast <PhpMethodInvokeValue>()
.ToArray();
var list = new PhpMethodCallExpression("list");
list.Arguments.AddRange(a.Skip(2));
foreach (var i in list.Arguments)
{
i.ByRef = false;
}
var explode = new PhpMethodCallExpression("explode");
explode.Arguments.Add(a[1]);
explode.Arguments.Add(a[0]);
var aa = new PhpAssignExpression(list, explode);
return(aa);
// throw new NotSupportedException();
// throw new NotSupportedException();
}
public IPhpValue TranslateToPhp(IExternalTranslationContext ctx, CsharpMethodCallExpression src)
{
if (src.MethodInfo.DeclaringType == typeof(MySQLiResult))
{
var fn = src.MethodInfo.ToString();
if (src.MethodInfo.IsGenericMethod)
{
fn = src.MethodInfo.GetGenericMethodDefinition().ToString();
}
if (fn == "Boolean Fetch[T](T ByRef)")
{
// was "T Fetch[T]()"
var typeArgs = src.MethodInfo.GetGenericArguments();
var genTypeInfo = ctx.GetTranslationInfo().GetOrMakeTranslationInfo(typeArgs[0]);
if (genTypeInfo.IsArray)
{
var arg = ctx.TranslateValue(src.Arguments[0].MyValue);
var fetchMethod = new PhpMethodCallExpression("fetch_assoc");
fetchMethod.TargetObject = ctx.TranslateValue(src.TargetObject);
var assoc = new PhpAssignExpression(arg, fetchMethod);
return(assoc);
}
else
{
throw new NotSupportedException(fn);
}
// Console.WriteLine(c);
}
// throw new NotSupportedException(fn);
}
if (src.MethodInfo.DeclaringType == typeof(MySQLiStatement))
{
if (src.MethodInfo.Name == "BindParams") // all BindParams methods
{
#region BindParams
var a = src.MethodInfo.GetParameters();
var phptypes = new StringBuilder(a.Length);
foreach (var i in a)
{
var j = i.ParameterType;
var t = j.GetGenericArguments()[0];
if (t == typeof(string))
{
phptypes.Append("s");
}
else if (t == typeof(Double) ||
t == typeof(Single) ||
t == typeof(Decimal))
{
phptypes.Append("d");
}
else if (t == typeof(Int64) ||
t == typeof(Int32) ||
t == typeof(Byte) ||
t == typeof(UInt64) ||
t == typeof(UInt32) ||
t == typeof(UInt16))
{
phptypes.Append("i");
}
else if (t == typeof(byte[]))
{
phptypes.Append("b");
}
else
{
throw new NotSupportedException(string.Format("Type {0} is not supported by MySQLiStatement.BindParams", t));
}
}
var values = new List <IPhpValue>();
values.Add(new PhpConstValue(phptypes.ToString()));
foreach (var i in src.Arguments)
{
values.Add(ctx.TranslateValue(i.MyValue));
}
var result = new PhpMethodCallExpression("bind_param", values.ToArray());
result.TargetObject = ctx.TranslateValue(src.TargetObject);
return(result);
#endregion
}
if (src.MethodInfo.Name == "BindResult") // all BindResult methods
{
#region BindResult
var a = src.MethodInfo.GetParameters();
var values = new List <IPhpValue>();
foreach (var i in src.Arguments)
{
values.Add(ctx.TranslateValue(i.MyValue));
}
var result = new PhpMethodCallExpression("bind_result", values.ToArray());
result.TargetObject = ctx.TranslateValue(src.TargetObject);
return(result);
#endregion
}
}
return(null);
}
private void TranslateField(PhpCodeModule module, PhpClassDefinition phpClass, FieldDeclaration field)
{
PhpValueTranslator phpValueTranslator = null;
foreach (var item in field.Items)
{
if (item.OptionalFieldInfo == null)
{
continue;
}
var fti = Info.GetOrMakeTranslationInfo(item.OptionalFieldInfo);
switch (fti.Destination)
{
case FieldTranslationDestionations.DefinedConst:
if (item.Value == null)
{
throw new NotSupportedException();
}
if (phpValueTranslator == null)
{
phpValueTranslator = new PhpValueTranslator(_state);
}
var definedValue = phpValueTranslator.TransValue(item.Value);
{
if (fti.IncludeModule != module.Name)
{
module = GetOrMakeModuleByName(fti.IncludeModule);
}
}
module.DefinedConsts.Add(new KeyValuePair <string, IPhpValue>(fti.ScriptName, definedValue));
break;
case FieldTranslationDestionations.GlobalVariable:
if (item.Value != null)
{
IPhpValue value;
// muszę na chwilę wyłączyć current type, bo to jes poza klasą generowane
{
var saveCurrentType = _state.Principles.CurrentType;
_state.Principles.CurrentType = null;
try
{
if (phpValueTranslator == null)
{
phpValueTranslator = new PhpValueTranslator(_state);
}
value = phpValueTranslator.TransValue(item.Value);
}
finally
{
_state.Principles.CurrentType = saveCurrentType;
}
}
var assign = new PhpAssignExpression(PhpVariableExpression.MakeGlobal(fti.ScriptName),
value);
module.TopCode.Statements.Add(new PhpExpressionStatement(assign));
}
break;
case FieldTranslationDestionations.JustValue:
continue; // don't define
case FieldTranslationDestionations.NormalField:
case FieldTranslationDestionations.ClassConst:
{
var def = new PhpClassFieldDefinition();
var cti = _state.Principles.GetTi(_state.Principles.CurrentType, true);
if (cti.IsArray)
{
continue;
}
if (field.Modifiers.Has("const") ^
(fti.Destination == FieldTranslationDestionations.ClassConst))
{
throw new Exception("beige lion");
}
def.IsConst =
fti.Destination ==
FieldTranslationDestionations.ClassConst; // field.Modifiers.Has("const");
def.Name = fti.ScriptName;
def.IsStatic = def.IsConst || field.Modifiers.Has("static");
if (field.Modifiers.Has("public"))
{
def.Visibility = Visibility.Public;
}
else if (field.Modifiers.Has("protected"))
{
def.Visibility = Visibility.Protected;
}
else
{
def.Visibility = Visibility.Private;
}
if (item.Value != null)
{
if (phpValueTranslator == null)
{
phpValueTranslator = new PhpValueTranslator(_state);
}
def.ConstValue = phpValueTranslator.TransValue(item.Value);
}
phpClass.Fields.Add(def);
break;
}
default:
throw new NotSupportedException();
}
}
}
/// <summary>
/// Creates expression based on DirectCallAttribute
/// </summary>
/// <param name="ctx"></param>
/// <param name="directCallAttribute"></param>
/// <param name="targetObject"></param>
/// <param name="arguments"></param>
/// <returns></returns>
public static IPhpValue CreateExpressionFromDirectCallAttribute(IExternalTranslationContext ctx, DirectCallAttribute directCallAttribute, IValue targetObject, FunctionArgument[] arguments, MethodBase methodInfo)
{
if (directCallAttribute.CallType == MethodCallStyles.Static)
{
throw new NotSupportedException();
}
if (directCallAttribute.MemberToCall != ClassMembers.Method)
{
throw new NotSupportedException();
}
if (string.IsNullOrEmpty(directCallAttribute.Name))
{
var ma = directCallAttribute.MapArray;
if (ma.Length != 1)
{
throw new NotSupportedException("gray horse 1");
}
if (ma[0] == DirectCallAttribute.This)
{
if (targetObject == null)
{
throw new NotSupportedException("gray horse 2");
}
return(ctx.TranslateValue(targetObject));
}
// return phpMethod.Arguments[ma[0]].Expression
return(ctx.TranslateValue(arguments[ma[0]].MyValue));
}
var name = directCallAttribute.Name;
var phpMethod = new PhpMethodCallExpression(name);
if (directCallAttribute.CallType == MethodCallStyles.Instance)
{
if (targetObject == null)
{
throw new NotSupportedException("gray horse 3");
}
phpMethod.TargetObject = ctx.TranslateValue(targetObject);
}
{
List <int> skipRefIndexList = null;
if (methodInfo != null)
{
var skipRefOrOutArray = directCallAttribute.SkipRefOrOutArray;
if (skipRefOrOutArray.Any())
{
var parameters = methodInfo.GetParameters();
for (var index = 0; index < parameters.Length; index++)
{
if (!skipRefOrOutArray.Contains(parameters[index].Name))
{
continue;
}
if (skipRefIndexList == null)
{
skipRefIndexList = new List <int>();
}
skipRefIndexList.Add(index);
}
}
}
CopyArguments(ctx, arguments, phpMethod, skipRefIndexList);
}
#region Mapping
if (directCallAttribute.HasMapping)
{
var phpArguments = phpMethod.Arguments.ToArray();
phpMethod.Arguments.Clear();
foreach (var argNr in directCallAttribute.MapArray)
{
if (argNr == DirectCallAttribute.This)
{
if (targetObject == null)
{
throw new NotSupportedException();
}
var v = ctx.TranslateValue(targetObject);
phpMethod.Arguments.Add(new PhpMethodInvokeValue(v));
}
else
{
if (argNr < phpArguments.Length)
{
phpMethod.Arguments.Add(phpArguments[argNr]);
}
}
}
}
#endregion
#region Out
if (directCallAttribute.OutNr >= 0)
{
var nr = directCallAttribute.OutNr;
var movedExpression = phpMethod.Arguments[nr].Expression;
phpMethod.Arguments.RemoveAt(nr);
var a = new PhpAssignExpression(movedExpression, phpMethod);
return(a);
}
#endregion
return(phpMethod);
}
protected override IPhpValue VisitPhpAssignExpression(PhpAssignExpression node)
{
return(node.Simplify(this));
}
