public DoLoopStatement(Expression condition, Statement embeddedStatement, ConditionType conditionType, ConditionPosition conditionPosition)
 {
     this.condition = condition;
     this.embeddedStatement = embeddedStatement;
     this.conditionType = conditionType;
     this.conditionPosition = conditionPosition;
 }

 public IntBooleanCondition(string field, int condition, ConditionType conditionType = ConditionType.OR, bool negate = false)
 {
     Field = field;
     Condition = condition.ToString();
     ConditionType = conditionType;
     Negate = negate;
 }

 public Result(ConditionType Type, string Variable, string Op, int Value)
 {
     this.Type = Type;
     this.Variable = Variable;
     this.Op = Op;
     this.Value = Value;
 }

 public ConditionTreeLeaf(ConditionType type, string name, ConditionComparison comparison, PropertyUnion compareTo)
 {
     Type = type;
     VariableName = name;
     Comparison = comparison;
     CompareTo = compareTo;
 }

        public GroupedCondition(IBooleanCondition conditionA, ConditionType conditionType, IBooleanCondition conditionB)
        {
            condition = conditionType;

            this.conditionA = conditionA;
            this.conditionB = conditionB;
        }

        public ConditionModel Build(string expression, Type dataContextType, ConditionType conditionType)
        {
            if (String.IsNullOrWhiteSpace(expression))
            {
                return new ConditionModel();
            }

            _stack = new Stack<object>();
            _parameters = RuleParameterProviders.Providers.SelectMany(x => x.GetParameters(dataContextType).ToList())
                                                      .DistinctBy(x => x.Name)
                                                      .ToList();

            var exp = Expression.Parse(expression);
            Visit(exp);

            var top = _stack.Peek();
            if (top is ComparisonModel)
            {
                BuildComparisonGroup();
            }

            BuildConditionModel(conditionType);

            var model = (ConditionModel)_stack.Pop();
            model.Expression = expression;

            return model;
        }

        public Filters Or(string name, ConditionType conditionType, object value)
        {
            this.filters.Add(
                new Filter { Name = name, Value = value, FilterType = FilterType.Or, ConditionType = conditionType });

            return this;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Condition"/> class.
 /// </summary>
 /// <param name="label">The label.</param>
 public Condition(string label)
 {
     _label = label;
     _subconditions = new List<LeftHandSideCondition>();
     _conditionType = ConditionType.Positive;
     _fields = new Term[3];
     _evaluator = new Equals();
 }

 /// <summary>
 /// Creates a new Jump or Call instruction
 /// </summary>
 /// <param name="isCall">true if this is a call instruction</param>
 /// <param name="dest">destination address</param>
 /// <param name="condition">the condition to execute this instruction on</param>
 public JumpCall(bool isCall,
                 short dest,
                 ConditionType condition = ConditionType.Unconditional)
     : base(condition)
 {
     this.IsCall = isCall;
     this.Destination = dest;
 }

 public IcmpConstInstruction(ConditionType cond, VirtualRegister rd, VirtualRegister r1, int immed)
     : base("icmp")
 {
     this.cond = cond;
     this.r1 = r1;
     this.immed = immed;
     this.rd = rd;
 }

 // <summary>
 /// 添加一个筛选条件
 /// </summary>
 public void AddCondition(Conditionner condition, ConditionType AndOr) {
     if (gszConditionner != "") {
         gszConditionner += " " + (AndOr == ConditionType.And ? "and" : "or");
         gszConditionner += " (" + condition.ToString() + ")";
     } else {
         gszConditionner = "(" + condition.ToString() + ")";
     }
 }

        public CastCondition(int conditionGroup, ConditionType type, double[] values, ConditionValueName[] valuenames)
        {
            this.ConditionGroup = conditionGroup;
            this.Type = type;
            this.Values = values;
            this.ValueNames = valuenames;

        }

 public IcmpInstruction(ConditionType cond, VirtualRegister rd, VirtualRegister r1, VirtualRegister r2, string type)
     : base("icmp")
 {
     this.cond = cond;
     this.r1 = r1;
     this.r2 = r2;
     this.rd = rd;
     this.type = type;
 }

 public NetObject(string ip, string dns, string name, BaseType type, int position, ConditionType state, int threadId)
 {
     _ip = ip;
         _dns = dns;
         _name = name;
         _type = type;
         _position = position;
         _state = state;
         _threadId = threadId;
 }

		public ArgumentExcludeCondition(List<Token> toks)
		{
			Token tok = toks[0];
			if (tok.Type != TokenType.Identifier)
				throw new Exception("Unknown token for argument to exclude condition!");
			ArgToExclude = Utils.SingleDigitParse(tok.Value[3]) - 1;
			if (ArgToExclude != 0)
				throw new Exception("Cannot exclude anything but the first argument!");
			tok = toks[1];
			int nextTokIdx = 2;
			switch (tok.Type)
			{
				case TokenType.LThan:
					if (toks[2].Type == TokenType.Equal)
					{
						nextTokIdx++;
						Condition = ConditionType.LessOrEqual;
					}
					else
					{
						Condition = ConditionType.Less;
					}
					break;
				case TokenType.GThan:
					if (toks[2].Type == TokenType.Equal)
					{
						nextTokIdx++;
						Condition = ConditionType.GreaterOrEqual;
					}
					else
					{
						Condition = ConditionType.Greater;
					}
					break;
				case TokenType.Equal:
					if (toks[2].Type != TokenType.Equal)
						throw new Exception("Unknown condition for an argument exclude!");
					nextTokIdx++;
					Condition = ConditionType.Equal;
					break;
				case TokenType.Exclaim:
					if (toks[2].Type != TokenType.Equal)
						throw new Exception("Unknown condition for an argument exclude!");
					nextTokIdx++;
					Condition = ConditionType.NotEqual;
					break;

				default:
					throw new Exception("Unknown condition for an argument exclude!");
			}
			tok = toks[nextTokIdx];
			if (tok.Type != TokenType.Number)
				throw new Exception("The value being compared to in an argument exclude condition must be a decimal number!");
			ConditionArg = tok.NumberValue.Value;
		}

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="Type"></param>
        public ConditionListForm(ConditionType Type)
        {
            InitializeComponent();

            // Set internal vars
            this.List = new ConditionList(Type);
            this.OrigList = new ConditionList(Type);
            this.Node = new TreeNode();

            Initialize();
        }

        public void OnArea(ConditionType eventType, Collider other)
        {
            if (Once == true && Result != ConditionResult.NEVER)
            {
                return;
            }

            if (Type == eventType)
            {
                Result = ConditionResult.CONDITION_ON;
            }
        }

        public Filters AndSql(string name, ConditionType conditionType, string value)
        {
            this.filters.Add(
                new Filter
                    {
                        Name = name,
                        Value = value,
                        FilterType = FilterType.And,
                        ValueType = ValueType.Sql,
                        ConditionType = conditionType
                    });

            return this;
        }

 // Needs to change this
 public ConditionTriggered( GameWorld world, Texture2D texture,
     Vector2 pos, float rotation, SharedResourceList triglist, String name = "ConditionTrigger",
     String texture_name = TNames.ground_switch_inactive, float cooldown = -1,
     SharedResourceList<TriggerableObject> t_objects = null,
     ConditionType c_type = ConditionType.DEATH )
     : base(world, texture, texture, pos, null, TriggerType.NO_COLLISION, cooldown,
          rotation, texture_name: texture_name, t_obj_list: t_objects)
 {
     m_condition_type = c_type;
     if ( trigger_list != null ) {
         trigger_list = triglist;
     }
     else {
         trigger_list = new SharedResourceList( m_world );
     }
 }

 /// <summary>
 /// 获取条件
 /// </summary>
 /// <param name="ConditionType">条件类型</param>
 /// <returns></returns>
 public static string GetConditionType(ConditionType conditionType)
 {
     switch (conditionType)
     {
         case ConditionType.等于:
             return "==";
         case ConditionType.不等于:
             return "!=";
         case ConditionType.大于:
             return ">";
         case ConditionType.大于等于:
             return ">=";
         case ConditionType.小于:
             return "<";
         case ConditionType.小于等于:
             return "<=";
         default:
             return string.Empty;
     }
 }