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 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(); }
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); }
/// <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"); }