private string GetCommandName(CommandElementAst commandNameAst)
{
string name;
ExpressionAst exprAst = commandNameAst as ExpressionAst;
if (exprAst != null)
{
object expressionValue = this.GetExpressionValue(exprAst);
if (expressionValue == null)
{
ScriptBlockToPowerShellChecker.ThrowError(new ScriptBlockToPowerShellNotSupportedException("CantConvertWithScriptBlockInvocation", null, AutomationExceptions.CantConvertWithScriptBlockInvocation, new object[0]), exprAst);
}
if (expressionValue is CommandInfo)
{
name = ((CommandInfo)expressionValue).Name;
}
else
{
name = expressionValue as string;
}
}
else
{
name = commandNameAst.Extent.Text;
}
if (string.IsNullOrWhiteSpace(name))
{
throw new ScriptBlockToPowerShellNotSupportedException("CantConvertWithScriptBlockInvocation", null, AutomationExceptions.CantConvertWithScriptBlockInvocation, new object[0]);
}
return(name);
}
public override void GenerateCode(ILCode code, ExpressionAst rightExpr)
{
//--->
bool pushOnStack = code.PushOnStack;
//cargo primero el array.
code.PushOnStack = true;
_arrayAccess.Array.Accept(CodeGenerator);
//cargo el indice al cual voy a acceder
code.PushOnStack = true;
_arrayAccess.Indexer.Accept(CodeGenerator);
//cargo el valor que le voy a asignar
code.PushOnStack = true;
//generar el codigo de la expresion que quiero asignar.
rightExpr.Accept(CodeGenerator);
ILGenerator il = code.Method.GetILGenerator();
//aca tengo que pedir el tipo del array , y luego el type asociado a el.
string typeCodeName = _arrayAccess.CurrentScope.GetTypeInfo(_arrayAccess.Array.ReturnType.TypeID).CodeName;
Type t = code.DefinedType[typeCodeName];
il.Emit(OpCodes.Stelem, t.IsArray ? t.GetElementType() : t);
//<----
code.PushOnStack = pushOnStack;
}
public virtual DataType ProcessExpression(ExpressionAst expression)
{
Guard.Against.Null(expression, nameof(expression));
if (expression is OperatorExpressionAst operatorExpression)
{
return(ProcessOperatorExpression(operatorExpression));
}
if (expression is AssignExpressionAst assignExpression)
{
return(ProcessAssignExpression(assignExpression));
}
if (expression is CallExpressionAst callExpression)
{
return(ProcessCallExpression(callExpression));
}
if (expression is LiteralExpressionAst literalExpression)
{
return(ProcessLiteralExpression(literalExpression));
}
if (expression is IdentExpressionAst identExpression)
{
return(ProcessIdentExpression(identExpression));
}
if (expression is GroupExpressionAst groupExpression)
{
return(ProcessGroupExpression(groupExpression));
}
throw new ArgumentException("Unknown expression type" + expression.GetType(), nameof(expression));
}
/// <summary>
/// Return the boolean value of a named attribute argument.
/// </summary>
/// <param name="argumentAst">The ast of the argument's value</param>
public static bool GetValue(this NamedAttributeArgumentAst attrAst, out ExpressionAst argumentAst)
{
argumentAst = null;
if (attrAst.ExpressionOmitted)
{
return(true);
}
var varExpAst = attrAst.Argument as VariableExpressionAst;
argumentAst = attrAst.Argument;
if (varExpAst == null)
{
var constExpAst = attrAst.Argument as ConstantExpressionAst;
if (constExpAst == null)
{
return(false);
}
bool constExpVal;
if (LanguagePrimitives.TryConvertTo(constExpAst.Value, out constExpVal))
{
return(constExpVal);
}
}
else
{
return(varExpAst.VariablePath.UserPath.Equals(
bool.TrueString,
StringComparison.OrdinalIgnoreCase));
}
return(false);
}
private StatementAst CreateProcessedMessage(IScriptPosition position, ConsoleColor dashColor, Type astType)
{
ExpressionAst traceInvocation = InvokeMember(
isStatic: true,
Type(typeof(SequencePointTracer)),
nameof(SequencePointTracer.TraceExpression),
Variable("Host"),
Member(Type(typeof(ConsoleColor)), dashColor.ToString(), isStatic: true),
Type(astType),
Variable(StackVariable),
Constant(position.LineNumber),
Constant(position.ColumnNumber),
Index(
Array(
Pipeline(
CommandExpression(
ArrayLiteral(Variable(TempVariable))))),
Constant(0)),
Variable("false"));
return(Pipeline(CommandExpression(traceInvocation)));
// var prefix = Add(CreateDashString(), String("< {0}"));
// var message = Format(prefix, Variable(TempVariable));
// return Pipeline(
// Command(
// WriteHost,
// message,
// CommandParameter("ForegroundColor"),
// String(dashColor.ToString())));
}
public InvokeMemberExpressionAst InvokeMember(
ExpressionAst expression,
string methodName,
params ExpressionAst[] arguments)
{
return(InvokeMember(isStatic: false, expression, String(methodName), arguments));
}
public IndexExpressionAst Index(ExpressionAst target, ExpressionAst index)
{
return(new IndexExpressionAst(
_currentExtent,
target,
index));
}
internal static bool TrySafeEval(ExpressionAst ast, ExecutionContext executionContext, out object value)
{
bool flag;
if (!((bool)ast.Accept(new SafeExprEvaluator())))
{
value = null;
return(false);
}
PSLanguageMode?nullable = null;
try
{
if (ExecutionContext.HasEverUsedConstrainedLanguage)
{
nullable = new PSLanguageMode?(executionContext.LanguageMode);
executionContext.LanguageMode = PSLanguageMode.ConstrainedLanguage;
}
value = Compiler.GetExpressionValue(ast, executionContext, (IList)null);
flag = true;
}
catch
{
value = null;
flag = false;
}
finally
{
if (nullable.HasValue)
{
executionContext.LanguageMode = nullable.Value;
}
}
return(flag);
}
public MemberExpressionAst Member(
ExpressionAst expression,
string memberName,
bool isStatic = false)
{
return(Member(expression, String(memberName), isStatic));
}
public InvokeMemberExpressionAst InvokeMember(
ExpressionAst expression,
CommandElementAst method,
params ExpressionAst[] arguments)
{
return(InvokeMember(isStatic: false, expression, method, arguments));
}
/// <summary>
/// Get assignment targets from expressionast
/// </summary>
/// <param name="expressionAst"></param>
/// <returns></returns>
internal static IEnumerable <ExpressionAst> GetAssignmentTargets(ExpressionAst expressionAst)
{
var parenExpr = expressionAst as ParenExpressionAst;
if (parenExpr != null)
{
foreach (var e in GetAssignmentTargets(parenExpr.Pipeline.GetPureExpression()))
{
yield return(e);
}
}
else
{
var arrayLiteral = expressionAst as ArrayLiteralAst;
if (arrayLiteral != null)
{
foreach (var e in arrayLiteral.Elements.SelectMany(GetAssignmentTargets))
{
yield return(e);
}
}
else
{
yield return(expressionAst);
}
}
}
private List <string> GetArrayFromAst(ExpressionAst exprAst)
{
ArrayLiteralAst arrayLitAst = exprAst as ArrayLiteralAst;
var result = new List <string>();
if (arrayLitAst == null && exprAst is ArrayExpressionAst)
{
ArrayExpressionAst arrayExp = (ArrayExpressionAst)exprAst;
return(arrayExp == null ? null : GetArrayFromArrayExpressionAst(arrayExp));
}
if (arrayLitAst == null)
{
ThrowInvalidDataException(arrayLitAst);
}
foreach (var element in arrayLitAst.Elements)
{
var elementValue = element as StringConstantExpressionAst;
if (elementValue == null)
{
ThrowInvalidDataException(element);
}
result.Add(elementValue.Value);
}
return(result);
}
private static CorrectionExtent CreateNewObjectCorrection(
string filePath,
IScriptExtent offendingExtent,
string typeName,
IReadOnlyList <ExpressionAst> argumentAsts)
{
var sb = new StringBuilder("New-Object ")
.Append('\'')
.Append(typeName)
.Append('\'');
if (argumentAsts != null && argumentAsts.Count > 0)
{
sb.Append(" @(");
int i = 0;
for (; i < argumentAsts.Count - 1; i++)
{
ExpressionAst argAst = argumentAsts[i];
sb.Append(argAst.Extent.Text).Append(", ");
}
sb.Append(argumentAsts[i].Extent.Text).Append(")");
}
return(new CorrectionExtent(
offendingExtent,
sb.ToString(),
filePath,
string.Format(
CultureInfo.CurrentCulture,
Strings.UseCompatibleSyntaxCorrection,
"New-Object @($arg1, $arg2, ...)",
"3,4")));
}
public override bool VisitSequence(SequenceExpressionAST sequenceExpression)
{
//Se asume q no se retorna nada
sequenceExpression.ReturnType = TigerType.GetType <NoType>();
foreach (var exp in sequenceExpression.ExpressionList)
{
if (!exp.Accept(this))
{
//hubo error
sequenceExpression.ReturnType = TigerType.GetType <ErrorType>();
}
}
ExpressionAst last = sequenceExpression.ExpressionList.LastOrDefault();
if (last != null)
{
//si existe una ultima expresion, esta define el retorno del let
sequenceExpression.AlwaysReturn = last.AlwaysReturn;
sequenceExpression.ReturnType = last.ReturnType;
}
//true si no hubo ningun error
return(sequenceExpression.ReturnType != TigerType.GetType <ErrorType>());
}
public CommandExpressionAst CommandExpression(ExpressionAst expression)
{
return(new CommandExpressionAst(
_currentExtent,
expression,
Enumerable.Empty <RedirectionAst>()));
}
public System.Object VisitUnaryExpression(System.Management.Automation.Language.UnaryExpressionAst unaryExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(unaryExpressionAst.Extent);
ExpressionAst mappedChild = _VisitExpression(unaryExpressionAst.Child);
return(new UnaryExpressionAst(mappedExtent, unaryExpressionAst.TokenKind, mappedChild));
}
public System.Object VisitNamedAttributeArgument(System.Management.Automation.Language.NamedAttributeArgumentAst namedAttributeArgumentAst)
{
IScriptExtent mappedExtent = MapExtent(namedAttributeArgumentAst.Extent);
ExpressionAst mappedArgument = _VisitExpression(namedAttributeArgumentAst.Argument);
return(new NamedAttributeArgumentAst(mappedExtent, namedAttributeArgumentAst.ArgumentName, mappedArgument, namedAttributeArgumentAst.ExpressionOmitted));
}
public System.Object VisitContinueStatement(System.Management.Automation.Language.ContinueStatementAst continueStatementAst)
{
IScriptExtent mappedExtent = MapExtent(continueStatementAst.Extent);
ExpressionAst mappedLabel = _VisitExpression(continueStatementAst.Label);
return(new ContinueStatementAst(mappedExtent, mappedLabel));
}
public System.Object VisitBreakStatement(System.Management.Automation.Language.BreakStatementAst breakStatementAst)
{
IScriptExtent mappedExtent = MapExtent(breakStatementAst.Extent);
ExpressionAst mappedLabel = breakStatementAst.Label;
return(new BreakStatementAst(mappedExtent, mappedLabel));
}
public System.Object VisitUsingExpression(System.Management.Automation.Language.UsingExpressionAst usingExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(usingExpressionAst.Extent);
ExpressionAst mappedExpressionAst = _VisitExpression(usingExpressionAst.SubExpression);
return(new UsingExpressionAst(mappedExtent, mappedExpressionAst));
}
public System.Object VisitFileRedirection(System.Management.Automation.Language.FileRedirectionAst fileRedirectionAst)
{
IScriptExtent mappedExtent = MapExtent(fileRedirectionAst.Extent);
ExpressionAst mappedFile = _VisitExpression(fileRedirectionAst.Location);
return(new FileRedirectionAst(mappedExtent, fileRedirectionAst.FromStream, mappedFile, fileRedirectionAst.Append));
}
public CommandParameterAst CommandParameter(string parameterName, ExpressionAst argument = null)
{
return(new CommandParameterAst(
_currentExtent,
parameterName,
argument,
Empty.Extent(_currentExtent)));
}
public override ExpressionAst VisitExpression(ExpressionAst expressionAst)
{
if (CurrentExpectedKind == SyntaxKind.Any || CurrentExpectedKind == SyntaxKind.Expression)
{
return(CreateLoggingExpression(expressionAst));
}
return(expressionAst);
}
public System.Object VisitAttributedExpression(System.Management.Automation.Language.AttributedExpressionAst attributedExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(attributedExpressionAst.Extent);
AttributeBaseAst mappedAttribute = _VisitAttributeBase(attributedExpressionAst.Attribute);
ExpressionAst mappedChild = _VisitExpression(attributedExpressionAst.Child);
return(new AttributedExpressionAst(mappedExtent, mappedAttribute, mappedChild));
}
public System.Object VisitIndexExpression(System.Management.Automation.Language.IndexExpressionAst indexExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(indexExpressionAst.Extent);
ExpressionAst mappedTarget = _VisitExpression(indexExpressionAst.Target);
ExpressionAst mappedIndex = _VisitExpression(indexExpressionAst.Index);
return(new IndexExpressionAst(mappedExtent, mappedTarget, mappedIndex));
}
public static void AddVariables(
ExpressionAst expression,
List <Tuple <ITypeName, VariableExpressionAst> > variables)
{
var visitor = new DelegateParameterVisitor();
visitor._variables = variables;
expression.Visit(visitor);
}
public System.Object VisitMemberExpression(System.Management.Automation.Language.MemberExpressionAst memberExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(memberExpressionAst.Extent);
ExpressionAst mappedExpression = _VisitExpression(memberExpressionAst.Expression);
CommandElementAst mappedMember = _VisitCommandElement(memberExpressionAst.Member);
return(new MemberExpressionAst(mappedExtent, mappedExpression, mappedMember, memberExpressionAst.Static));
}
public override void GenerateCode(ILCode code, ExpressionAst rightExpr)
{
ILGenerator il = code.Method.GetILGenerator();
//buscar la variable
VarInfo varInfo = _varAst.CurrentScope.GetVarInfo(_varAst.VarId);
//--->
bool pushOnStack = code.PushOnStack;
code.PushOnStack = true;
if (_varAst.IsForeignVar)
//aqui se entra cuando se usa una variable se usa en una funcion que no fue quien la declaro
{
string currentParentFunctionCodeName = _varAst.CurrentScope.CurrentFunction.FunctionParent.CodeName;
//carga el respectivo campo de la clase contenedora.
//como mis metodos son de instancia y las varibles tambien tengo que cargar el parametro 0
il.Emit(OpCodes.Ldarg_0);
//ahora viene cargar la variable de verdad.
TypeCodeInfo typeCodeInfo = code.GetWrapperAsociatteTo(currentParentFunctionCodeName);
while (!typeCodeInfo.ContainFieldInLevel1(varInfo.CodeName))
{
//cargo el campo que representa al padre del tipo actual
string parentInstanceName = typeCodeInfo.FieldNameOfParent;
il.Emit(OpCodes.Ldfld, typeCodeInfo.GetField(parentInstanceName));
typeCodeInfo = typeCodeInfo.Parent;
}
//pongo el valor que quiero asignar en la pila
rightExpr.Accept(CodeGenerator);
//lo asigno.
il.Emit(OpCodes.Stfld, typeCodeInfo.GetField(varInfo.CodeName));
}
else
{
if (varInfo.IsLocalVariable)
{
rightExpr.Accept(CodeGenerator);
il.Emit(OpCodes.Stloc, code.DefinedLocal[varInfo.CodeName].LocalIndex);
}
else if (varInfo.IsParameterFunction)
{
rightExpr.Accept(CodeGenerator);
il.Emit(OpCodes.Starg, varInfo.ParameterNumber + 1);
}
else // tengo que acceder a la variable a travez de la instancia que tengo como varible local.
{
//se asume que el wrapper siempre esta como primera variable del metodo.
il.Emit(OpCodes.Ldloc_0);
rightExpr.Accept(CodeGenerator);
il.Emit(OpCodes.Stfld, code.DefinedField[varInfo.CodeName]);
}
}
code.PushOnStack = pushOnStack;
}
public System.Object VisitBinaryExpression(System.Management.Automation.Language.BinaryExpressionAst binaryExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(binaryExpressionAst.Extent);
IScriptExtent mappedErrorExtent = MapExtent(binaryExpressionAst.ErrorPosition);
ExpressionAst mappedLeft = _VisitExpression(binaryExpressionAst.Left);
ExpressionAst mappedRight = _VisitExpression(binaryExpressionAst.Right);
return(new BinaryExpressionAst(mappedExtent, mappedLeft, binaryExpressionAst.Operator, mappedRight, mappedErrorExtent));
}
public System.Object VisitConvertExpression(System.Management.Automation.Language.ConvertExpressionAst convertExpressionAst)
{
IScriptExtent mappedExtent = MapExtent(convertExpressionAst.Extent);
TypeConstraintAst mappedTypeConstraint = (TypeConstraintAst)VisitTypeConstraint(convertExpressionAst.Attribute as TypeConstraintAst);
ExpressionAst mappedChild = _VisitExpression(convertExpressionAst.Child);
return(new ConvertExpressionAst(mappedExtent, mappedTypeConstraint, mappedChild));
}
