public Unit Unary(ExternalExpression <Label, SymbolicValue> pc, UnaryOperator op, bool overflow, bool unsigned, SymbolicValue dest, ExternalExpression <Label, SymbolicValue> source, StringBuilder data)
{
data.AppendFormat("{0}(", op.ToString());
Recurse(data, source);
data.AppendFormat(")");
return(Unit.Value);
}
// public AstPrinterNode Visit(Forward node)
// {
// var printer = new AstPrinterNode(node.ToString());
// return printer;
// }
public AstPrinterNode Visit(UnaryOperator node)
{
var printer = new AstPrinterNode(node.ToString());
printer.AddChild(node.Expr.Accept(this));
return(printer);
}
public static string ToPrettyString(this UnaryOperator @operator)
{
if (UnaryOperatorToStringMap.ContainsKey(@operator))
{
return(UnaryOperatorToStringMap[@operator]);
}
return(@operator.ToString());
}
public virtual MyError UnaryError(UnaryOperator op, PyObj obj0)
{
return(new MyError(string.Format("No se puede realizar la operacion unaria: {0} ({1}). Con tipo: <{2}> y valor: <{3}>"
, op.ToString()
, op.ToStringSymbol()
, TypeConstants.GetMyTypeName(obj0.GetMyType())
, obj0.MyToString()
)));
}
static string ToString(UnaryOperator op)
{
switch (op)
{
case UnaryOperator.BitwiseComplement: return("~");
case UnaryOperator.Not: return("!");
}
throw new ArgumentException(op.ToString(), "op");
}
public void RemoveRootOperator()
{
CriteriaOperator unaryOperator = new UnaryOperator(UnaryOperatorType.IsNull, "prop2");
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
binaryOperatorExtractor.Remove(ref unaryOperator, unaryOperator.ToString());
Assert.IsNull(unaryOperator);
}
public override void WriteXml(XmlWriter xmlw)
{
xmlw.WriteStartElement(this.GetType().Name);
xmlw.WriteAttributeString("Operator", _op.ToString());
xmlw.WriteStartElement("Operand");
_operand.WriteXml(xmlw);
xmlw.WriteEndElement();
xmlw.WriteEndElement();
}
public void RemoveNestedOperator()
{
var unaryOperator = new UnaryOperator(UnaryOperatorType.IsNull, "prop2");
CriteriaOperator groupOperator = new GroupOperator(new BinaryOperator("pro1", 1), unaryOperator);
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
binaryOperatorExtractor.Remove(ref groupOperator, unaryOperator.ToString());
Assert.AreEqual(new BinaryOperator("pro1", 1).ToString(), groupOperator.ToString());
}
public void ReplaceRootOperator()
{
CriteriaOperator unaryOperator = new UnaryOperator(UnaryOperatorType.IsNull, "prop2");
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
var replaceOperator = new BinaryOperator("pr", 1);
binaryOperatorExtractor.Replace(ref unaryOperator, unaryOperator.ToString(), replaceOperator);
Assert.AreEqual(unaryOperator, replaceOperator);
}
public void ReplaceNestedOperator()
{
var unaryOperator = new UnaryOperator(UnaryOperatorType.BitwiseNot, "pro");
CriteriaOperator criteriaOperator = new GroupOperator(new BinaryOperator(), unaryOperator);
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
var notOperator = new NotOperator();
binaryOperatorExtractor.Replace(ref criteriaOperator, unaryOperator.ToString(), notOperator);
Assert.AreEqual(((GroupOperator)criteriaOperator).Operands[1], notOperator);
}
public static string ToPrettyString(this UnaryOperator op)
{
switch (op)
{
case UnaryOperator.Complement:
return(TILDE);
case UnaryOperator.Negation:
return(DASH);
}
return(op.ToString().ToLowerInvariant());
}
private string CheckDefine(UnaryOperator unaryOperator)
{
switch (unaryOperator)
{
case UnaryOperator.UnaryInversion:
return("Not");
case UnaryOperator.UnaryMinus:
return("Minus");
default:
return(unaryOperator.ToString());
}
}
public static string ToStringSymbol(this UnaryOperator op)
{
switch (op)
{
case UnaryOperator.Minus:
return("-");
case UnaryOperator.Not:
return("!");
default:
throw new Exception("Operador: " + op.ToString() + " no se puede pasar a symbolString");
}
}
public virtual Word UnaryOperation(UnaryOperator op)
{
switch (op)
{
case UnaryOperator.Minus:
return(Calculator.Minus(this));
case UnaryOperator.Not:
return(Calculator.Not(this));
default:
throw new Exception("Operador Unario no valido: " + op.ToString());
}
}
public static string JsName(this UnaryOperator op)
{
switch (op)
{
case UnaryOperator.Negate:
return("$neg");
case UnaryOperator.BooleanNot:
return("$bnot");
case UnaryOperator.BitwiseNot:
return("$not");
default:
return(op.ToString());
}
}
public override string DotLabel()
{
return(Graphviz.DotUtilities.BuildDotLabel(this.GetType().Name, UnaryOperator.ToString()));
}
private static Activity <TResult> HandleUnaryExpression <TOperand, TResult>(UnaryOperator op, TestExpression operand)
{
Activity <TResult> we = null;
switch (op)
{
case UnaryOperator.Cast:
we = new Cast <TOperand, TResult>()
{
Checked = false,
Operand = TestExpression.GetInArgumentFromExpectedNode <TOperand>(operand),
};
break;
case UnaryOperator.CheckedCast:
we = new Cast <TOperand, TResult>()
{
Checked = true,
Operand = TestExpression.GetInArgumentFromExpectedNode <TOperand>(operand),
};
break;
case UnaryOperator.Not:
we = new Not <TOperand, TResult>()
{
Operand = TestExpression.GetInArgumentFromExpectedNode <TOperand>(operand),
};
break;
case UnaryOperator.TypeAs:
we = new As <TOperand, TResult>()
{
Operand = TestExpression.GetInArgumentFromExpectedNode <TOperand>(operand),
};
break;
default:
throw new NotSupportedException(string.Format("Operator: {0} is unsupported", op.ToString()));
}
return(we);
}
public bool Visit(UnaryOperator node)
{
if (node.SymType != null)
{
return(true);
}
node.Expr.Accept(this);
switch (node.Token.Type)
{
case TokenType.SumOperator:
case TokenType.DifOperator:
{
if (!(node.Expr.SymType.Equals(SymbolStack.SymInt) ||
node.Expr.SymType.Equals(SymbolStack.SymFloat)))
{
throw new Exception(string.Format(
"({0}, {1}) semantic error: 'integer' or 'float' expected, but '{2}' found",
node.Expr.Token.Line, node.Expr.Token.Column, node.Expr.Token.Lexeme));
}
node.SymType = node.Expr.SymType;
break;
}
case TokenType.AtSign:
{
if (!node.Expr.IsLValue)
{
throw new Exception(string.Format(
"({0}, {1}) semantic error: expression '{2}' is not lvalue",
node.Expr.Token.Line, node.Expr.Token.Column, node.Expr.ToString()));
}
node.SymType = _symStack.SymTypeToSymPointerType(node.Expr.SymType);
break;
}
case TokenType.Not:
{
if (!node.Expr.SymType.Equals(SymbolStack.SymBool))
{
throw new Exception(string.Format(
"({0}, {1}) semantic error: boolean expected, but '{2}' found",
node.Expr.Token.Line, node.Expr.Token.Column, node.Expr.ToString()));
}
node.SymType = node.Expr.SymType;
break;
}
default:
{
throw new Exception(string.Format(
"({0}, {1}) semantic error: unrecognized unary operator '{2}'",
node.Token.Line, node.Token.Column, node.ToString()));
}
}
node.IsLValue = false;
return(true);
}
/// <summary>
/// Returns the internal function name for unary operator
/// </summary>
/// <param name="op"></param>
/// <returns></returns>
public static string GetUnaryOpFunction(UnaryOperator op)
{
return(Constants.kInternalNamePrefix + op.ToString());
}
public Unit Unary(Label pc, UnaryOperator op, bool ovf, bool unsigned, Dest dest, Source source, TextWriter data)
{
data.WriteLine("{0}{4} = {3}{1}{2} {5}", prefix, ovf ? "_ovf" : null, unsigned ? "_un" : null, op.ToString(), DestName(dest), SourceName(source));
return(Unit.Value);
}
public Dummy Unary(LabeledSymbol <APC, SymbolicValue> pc, UnaryOperator op, bool unsigned, SymbolicValue dest, LabeledSymbol <APC, SymbolicValue> source, StringBuilder data)
{
data.AppendFormat("{0} ", op.ToString());
Recurse(data, source);
return(Dummy.Value);
}
// The following methods are used to insert methods to the bottom of the AST and convert operator to these method calls
// to support replication on operators
private static void InsertUnaryOperationMethod(Core core, ProtoCore.AST.Node root, UnaryOperator op, PrimitiveType r, PrimitiveType operand)
{
ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode();
funcDefNode.access = ProtoCore.DSASM.AccessSpecifier.kPublic;
funcDefNode.IsAssocOperator = true;
funcDefNode.IsBuiltIn = true;
funcDefNode.Name = ProtoCore.DSASM.Constants.kInternalNamePrefix + op.ToString();
funcDefNode.ReturnType = new ProtoCore.Type() { Name = core.TypeSystem.GetType((int)r), UID = (int)r };
ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode();
args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode()
{
memregion = ProtoCore.DSASM.MemoryRegion.kMemStack,
access = ProtoCore.DSASM.AccessSpecifier.kPublic,
NameNode = BuildAssocIdentifier(core, "%param"),
ArgumentType = new ProtoCore.Type { Name = core.TypeSystem.GetType((int)operand), UID = (int)operand }
});
funcDefNode.Singnature = args;
ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode();
ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Kw.kw_return, ProtoCore.PrimitiveType.kTypeReturn);
ProtoCore.AST.AssociativeAST.IdentifierNode param = BuildAssocIdentifier(core, "%param");
body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode() { LeftNode = _return, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.UnaryExpressionNode() { Expression = param, Operator = op } });
funcDefNode.FunctionBody = body;
(root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode);
}
private ProtoCore.AST.AssociativeAST.AssociativeNode GenerateUnaryOperatorMethodCallNode(UnaryOperator op, ProtoCore.AST.AssociativeAST.AssociativeNode operand)
{
ProtoCore.AST.AssociativeAST.FunctionCallNode funCallNode = new ProtoCore.AST.AssociativeAST.FunctionCallNode();
ProtoCore.AST.AssociativeAST.IdentifierNode funcName = new ProtoCore.AST.AssociativeAST.IdentifierNode { Value = ProtoCore.DSASM.Constants.kInternalNamePrefix + op.ToString(), Name = ProtoCore.DSASM.Constants.kInternalNamePrefix + op.ToString() };
funCallNode.Function = funcName;
funCallNode.Name = ProtoCore.DSASM.Constants.kInternalNamePrefix + op.ToString();
funCallNode.FormalArguments.Add(operand);
NodeUtils.CopyNodeLocation(funCallNode, operand);
return funCallNode;
}
public void ReplaceRootOperator()
{
CriteriaOperator unaryOperator = new UnaryOperator(UnaryOperatorType.IsNull, "prop2");
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
var replaceOperator = new BinaryOperator("pr", 1);
binaryOperatorExtractor.Replace(ref unaryOperator, unaryOperator.ToString(), replaceOperator);
Assert.AreEqual(unaryOperator, replaceOperator);
}
public void RemoveRootOperator()
{
CriteriaOperator unaryOperator = new UnaryOperator(UnaryOperatorType.IsNull, "prop2");
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
binaryOperatorExtractor.Remove(ref unaryOperator, unaryOperator.ToString());
Assert.IsNull(unaryOperator);
}
public override object Exec(UnionType operand, object arg)
{
// * If all the types in typeset generate a constraint, we simply generate one constraint using the whole union type
if (operand.IsFreshVariable() && methodAnalyzed != null)
{
// * A constraint is added to the method analyzed
ArithmeticConstraint constraint = new ArithmeticConstraint(operand, unaryOperator, location);
methodAnalyzed.AddConstraint(constraint);
return(constraint.ReturnType);
}
TypeExpression returnType = null;
foreach (TypeExpression type in operand.TypeSet)
{
TypeExpression ret = (TypeExpression)type.AcceptOperation(ArithmeticalOperation.Create(unaryOperator, methodAnalyzed, !operand.IsDynamic && showErrorMessage, location), arg);
if (ret == null && !operand.IsDynamic)
{
return(null);
}
if (ret != null)
{
returnType = UnionType.collect(returnType, ret);
}
}
// * If there has been some errors, they have not been shown because the type is dynamic, we show it
if (showErrorMessage && operand.IsDynamic && returnType == null)
{
ErrorManager.Instance.NotifyError(new NoTypeAcceptsOperation(operand.FullName, unaryOperator.ToString(), location));
}
return(returnType);
}
public void Visit(UnaryOperator op)
{
EmitGraphvizNodeBegin(op.ToString());
op.Operand.Accept(this);
EmitGraphvizNodeEnd();
}
// The following methods are used to insert methods to the bottom of the AST and convert operator to these method calls
// to support replication on operators
private static void InsertUnaryOperationMethod(Core core, ProtoCore.AST.Node root, UnaryOperator op, PrimitiveType r, PrimitiveType operand)
{
ProtoCore.AST.AssociativeAST.FunctionDefinitionNode funcDefNode = new ProtoCore.AST.AssociativeAST.FunctionDefinitionNode();
funcDefNode.access = ProtoCore.DSASM.AccessSpecifier.kPublic;
funcDefNode.IsAssocOperator = true;
funcDefNode.IsBuiltIn = true;
funcDefNode.Name = ProtoCore.DSASM.Constants.kInternalNamePrefix + op.ToString();
funcDefNode.ReturnType = new ProtoCore.Type()
{
Name = core.TypeSystem.GetType((int)r), UID = (int)r
};
ProtoCore.AST.AssociativeAST.ArgumentSignatureNode args = new ProtoCore.AST.AssociativeAST.ArgumentSignatureNode();
args.AddArgument(new ProtoCore.AST.AssociativeAST.VarDeclNode()
{
memregion = ProtoCore.DSASM.MemoryRegion.kMemStack,
access = ProtoCore.DSASM.AccessSpecifier.kPublic,
NameNode = BuildAssocIdentifier(core, "%param"),
ArgumentType = new ProtoCore.Type {
Name = core.TypeSystem.GetType((int)operand), UID = (int)operand
}
});
funcDefNode.Singnature = args;
ProtoCore.AST.AssociativeAST.CodeBlockNode body = new ProtoCore.AST.AssociativeAST.CodeBlockNode();
ProtoCore.AST.AssociativeAST.IdentifierNode _return = BuildAssocIdentifier(core, ProtoCore.DSDefinitions.Kw.kw_return, ProtoCore.PrimitiveType.kTypeReturn);
ProtoCore.AST.AssociativeAST.IdentifierNode param = BuildAssocIdentifier(core, "%param");
body.Body.Add(new ProtoCore.AST.AssociativeAST.BinaryExpressionNode()
{
LeftNode = _return, Optr = ProtoCore.DSASM.Operator.assign, RightNode = new ProtoCore.AST.AssociativeAST.UnaryExpressionNode()
{
Expression = param, Operator = op
}
});
funcDefNode.FunctionBody = body;
(root as ProtoCore.AST.AssociativeAST.CodeBlockNode).Body.Add(funcDefNode);
}
public Unit Unary(APC pc, UnaryOperator op, bool overflow, bool unsigned, Dest dest, Source source, Unit data)
{
this.tw.WriteLine(" {3} = {2}{0}{1} {4}", overflow ? "_ovf" : null, unsigned ? "_un" : null, op.ToString(), this.dest2String(dest), this.source2String(source));
return(Unit.Value);
}
public void RemoveNestedOperator()
{
var unaryOperator = new UnaryOperator(UnaryOperatorType.IsNull, "prop2");
CriteriaOperator groupOperator = new GroupOperator(new BinaryOperator("pro1", 1), unaryOperator);
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
binaryOperatorExtractor.Remove(ref groupOperator, unaryOperator.ToString());
Assert.AreEqual(new BinaryOperator("pro1", 1).ToString(), groupOperator.ToString());
}
/// <summary>
/// Return the internal function name for unary operator
/// </summary>
/// <param name="op"></param>
/// <returns></returns>
public static string GetUnaryOpFunction(UnaryOperator op)
{
return Constants.kInternalNamePrefix + op.ToString();
}
public void ReplaceNestedOperator()
{
var unaryOperator = new UnaryOperator(UnaryOperatorType.BitwiseNot, "pro");
CriteriaOperator criteriaOperator = new GroupOperator(new BinaryOperator(), unaryOperator);
var binaryOperatorExtractor = new CriteriaOperatorExtractor();
var notOperator = new NotOperator();
binaryOperatorExtractor.Replace(ref criteriaOperator, unaryOperator.ToString(), notOperator);
Assert.AreEqual(((GroupOperator) criteriaOperator).Operands[1], notOperator);
}
static string ToString (UnaryOperator op)
{
switch (op) {
case UnaryOperator.BitwiseComplement: return "~";
case UnaryOperator.Not: return "!";
}
throw new ArgumentException (op.ToString (), "op");
}
