protected static void CreateFunction(LinqParser parser, MemberInfo member, LambdaExpression expr)
{
parser.Function(ConstructFunctionName(member), expr);
parser._program.Functions.Add(Macro.InstantiateAllMacros(parser._function));
Compiler.Function.Add(member, new Function(parser._program, parser._function,
parser._typesDefined));
}
public override string Output(LinqParser parser)
{
var arrayDecl = ArrayLength > 0 ?
string.Format("[{0}]", ArrayLength) : "";
return(string.Format("{0} {1}{2}", parser.MapType(Type), Name, arrayDecl));
}
public override string Output(LinqParser parser)
{
var def = Definition.Output(parser);
return(Value != null?
string.Format("{0}{1} = {2};\n", Tabs(), def, Value.Output(parser)) :
string.Format("{0}{1};\n", Tabs(), def));
}
public override string Output(LinqParser parser)
{
var result = new StringBuilder();
EmitLine(result, "while ({0})", Condition.Output(parser));
EmitIntended(result, Body, parser);
return(result.ToString());
}
public override string Output(LinqParser parser)
{
var retType = ReturnType == null ? "void" : parser.MapType(ReturnType);
return(string.Format("{0} {1} ({2})\n{3}", retType, Name,
Arguments.Select(v => v.Output(parser)).SeparateWith(", "),
Body.Output(parser)));
}
public override string Output(LinqParser parser)
{
var result = new StringBuilder();
EmitLine(result, "for ({0} = {1}; {2}; {3})", LoopVar.Output(parser),
InitialValue.Output(parser), Condition.Output(parser), Increment.Output(parser));
EmitIntended(result, Body, parser);
return(result.ToString());
}
public override string Output(LinqParser parser)
{
var result = new StringBuilder();
BeginScope(result);
foreach (var statement in Statements)
{
result.Append(statement.Output(parser));
}
EndScope(result);
return(result.ToString());
}
protected void EmitIntended(StringBuilder sb, Statement statement, LinqParser parser)
{
if (statement is Block)
{
sb.Append(statement.Output(parser));
}
else
{
_tabLevel++;
sb.Append(statement.Output(parser));
_tabLevel--;
}
}
public override string Output(LinqParser parser)
{
var result = new StringBuilder();
EmitLine(result, "if ({0})\n", Condition.Output(parser));
EmitIntended(result, IfTrue, parser);
if (IfFalse != null)
{
EmitLine(result, "else");
EmitIntended(result, IfFalse, parser);
}
return(result.ToString());
}
public override string Output(LinqParser parser)
{
var functions = new StringBuilder();
foreach (var func in Functions)
{
functions.Append(func.Output(parser));
functions.AppendLine();
}
var globals = new StringBuilder();
foreach (var glob in Globals)
{
globals.Append(glob.Output(parser));
globals.AppendLine();
}
return(globals.ToString() + "\n" + functions.ToString());
}
public override string Output(LinqParser parser)
{
return(string.Format("{0} = {1} ({2})",
ResultVar.Output(parser), Target.Result.Name,
Parameters.Select(p => p.Output(parser)).SeparateWith(", ")));
}
public override string Output(LinqParser parser)
{
return(string.Format("{0}return {1};\n", Tabs(), Value.Output(parser)));
}
public override string Output(LinqParser parser)
{
return(string.Format("{0}{1};\n", Tabs(), ExternalCall.Output(parser)));
}
public override string Output(LinqParser parser)
{
return(Definition.Output(parser));
}
public override string Output(LinqParser parser)
{
return(Target.Output(parser));
}
public override string Output(LinqParser parser)
{
return(string.Format(Operator, Operand.Output(parser)));
}
public override string Output(LinqParser parser)
{
return(base.Output(parser) + "\n" + Implementation.Output(parser));
}
public abstract string Output(LinqParser parser);
public override string Output(LinqParser parser)
{
return(Value);
}
public override string Output(LinqParser parser)
{
return(string.Format("({0} ? {1} : {2})", Condition.Output(parser),
IfTrue.Output(parser), IfFalse.Output(parser)));
}
public override string Output(LinqParser parser)
{
return(string.Format(FormatStr,
Arguments.Select(e => e.Output(parser)).SeparateWith(", ")));
}
public override string Output(LinqParser parser)
{
return(string.Format("{0} ({1})", FuncRef.Name,
Arguments.Select(e => e.Output(parser)).SeparateWith(", ")));
}
public override string Output(LinqParser parser)
{
return(string.Format("(" + Operator + ")",
LeftOperand.Output(parser), RightOperand.Output(parser)));
}
public override string Output(LinqParser parser)
{
return(Text);
}
public override string Output(LinqParser parser)
{
return(parser.MapType(Type));
}
public override string Output(LinqParser parser)
{
return(string.Format("{0} ({1})", Result,
Parameters.Select(v => v.Output(parser)).SeparateWith(", ")));
}
public override string Output(LinqParser parser)
{
var decl = base.Output(parser);
return(string.Format("{0} = {1}", decl, Value.Output(parser)));
}
public override string Output(LinqParser parser)
{
return(string.Format("{0}.{1}", TargetExpr.Output(parser), TargetField.Name));
}
protected static void CreateMacro(LinqParser parser, MemberInfo member, LambdaExpression expr)
{
var macro = parser.ParseMacro(expr);
Macro.Add(member, new Macro(macro, parser._program, parser._typesDefined));
}
public override string Output(LinqParser parser)
{
return(string.Format("{0}[{1}]", Target.Name, Index.Output(parser)));
}
