/// <summary> /// Creates a SIGNED(width - 1 DOWNTO 0) subtype indication. /// </summary> /// <param name="width">the width</param> /// <returns>the subtype indication</returns> public static SubtypeIndication Create_SIGNED(Expression width) { Expression from = new Subtract(width, new DecimalLiteral(1)); Expression to = new DecimalLiteral(0); return(Create_SIGNED(new Range(from, Range.RangeDirection.DOWNTO, to))); }
private void appendExpression(Expression expression, int precedence) { if (expression == null) { writer.Append("null"); return; } bool writeParenthesis = expression.Precedence < precedence; if (writeParenthesis) { writer.Append("("); } visit(expression); if (writeParenthesis) { writer.Append(")"); } }
/// <summary> /// Creates a case statement. /// </summary> /// <param name="expression">the expression</param> public CaseStatement(Expression expression) { this.expression = expression; }
/// <summary> /// Creates a reject inertial delay mechanism. /// </summary> /// <param name="time">the puls rejection limit</param> public RejectInertialImpl(Expression time) { this.time = time; }
/// <summary> /// Creates a reject inertial delay mechanism. /// </summary> /// <param name="time">the pulse rejection limit</param> /// <returns>the created delay mechanism.</returns> public static DelayMechanism REJECT_INERTIAL(Expression time) { return(new RejectInertialImpl(time)); }
/// <summary> /// Creates a waveform element with a delay. /// </summary> /// <param name="value">value the value</param> /// <param name="after">after the delay</param> public WaveformElement(Expression @value, Expression after) { this.value = @value; this.after = after; }
/// <summary> /// Creates a waveform element. /// </summary> /// <param name="value">the value</param> public WaveformElement(Expression @value) { this.value = @value; }
/// <summary> /// Creates a range. /// </summary> /// <param name="from">the from expression</param> /// <param name="direction">the direction</param> /// <param name="to">the to expression</param> public Range(Expression from, RangeDirection direction, Expression to) { this.from = from; this.direction = direction; this.to = to; }
public override void visit(Expression expression) { VhdlOutputHelper.handleAnnotationsBefore(expression, writer); base.visit(expression); VhdlOutputHelper.handleAnnotationsAfter(expression, writer); }
/// <summary> /// Sets the to expression. /// </summary> /// <param name="to">the value of the to expression</param> public virtual void setTo(int to) { this.to = new DecimalLiteral(to); }
/// <summary> /// Sets the from expression. /// </summary> /// <param name="from">the value of the from expression</param> public virtual void setFrom(int from) { this.from = new DecimalLiteral(from); }
/// <summary> /// Creates an association element with a formal and actual part. /// </summary> /// <param name="formal">the formal part</param> /// <param name="actual">the actual part</param> public AssociationElement(string formal, Expression actual) { this.formal = formal; this.actual = actual; }
/// <summary> /// Creates an association element without a formal part. /// </summary> /// <param name="actual">actual the actual part</param> public AssociationElement(Expression actual) { this.actual = actual; }
public static Expression create(ExpressionType type, Expression l, Expression r) { switch (type) { case ExpressionType.AND: return(new And(l, r)); case ExpressionType.OR: return(new Or(l, r)); case ExpressionType.NAND: return(new Nand(l, r)); case ExpressionType.NOR: return(new Nor(l, r)); case ExpressionType.XOR: return(new Xor(l, r)); case ExpressionType.XNOR: return(new Xnor(l, r)); case ExpressionType.EQ: return(new Equals(l, r)); case ExpressionType.NEQ: return(new NotEquals(l, r)); case ExpressionType.LT: return(new LessThan(l, r)); case ExpressionType.LE: return(new LessEquals(l, r)); case ExpressionType.GT: return(new GreaterThan(l, r)); case ExpressionType.GE: return(new GreaterEquals(l, r)); case ExpressionType.SLL: return(new Sll(l, r)); case ExpressionType.SRL: return(new Srl(l, r)); case ExpressionType.SLA: return(new Sla(l, r)); case ExpressionType.SRA: return(new Sra(l, r)); case ExpressionType.ROL: return(new Rol(l, r)); case ExpressionType.ROR: return(new Ror(l, r)); case ExpressionType.ADD: return(new Add(l, r)); case ExpressionType.SUB: return(new Subtract(l, r)); case ExpressionType.CONCAT: return(new Concatenate(l, r)); case ExpressionType.MUL: return(new Multiply(l, r)); case ExpressionType.DIV: return(new Divide(l, r)); case ExpressionType.MOD: return(new Mod(l, r)); case ExpressionType.REM: return(new Rem(l, r)); default: return(null); } }