/* expr  : expr1 {('+' | '-') expr1}; */
int expr(ParserData *pd)
{
	double right, left;
	int currToken;

	if ( !expr1(pd) )
		return 0;

	while ( pd->m_Token.Type == T_PLUS || pd->m_Token.Type == T_MINUS )
	{
		currToken = pd->m_Token.Type;
		GetNextToken(pd->m_strExpr, &(pd->m_Token));

		if ( !expr1(pd) )
			return 0;

		right = pd->m_stack[pd->m_top--];
		left  = pd->m_stack[pd->m_top--];

		if ( currToken == T_PLUS )
		{
			pd->m_stack[++pd->m_top] = left + right;
		}
		else if ( currToken == T_MINUS )
		{
			pd->m_stack[++pd->m_top] = left - right;
		}
	}

	return 1;
}
Пример #2
0
Файл: eval.c Проект: AxFab/nasm
static expr *expr0(int critical)
{
    expr *e, *f;

    e = expr1(critical);
    if (!e)
        return NULL;

    while (i == '|') {
        i = scan(scpriv, tokval);
        f = expr1(critical);
        if (!f)
            return NULL;
        if (!(is_simple(e) || is_just_unknown(e)) ||
            !(is_simple(f) || is_just_unknown(f))) {
            nasm_error(ERR_NONFATAL, "`|' operator may only be applied to"
                  " scalar values");
        }
        if (is_just_unknown(e) || is_just_unknown(f))
            e = unknown_expr();
        else
            e = scalarvect(reloc_value(e) | reloc_value(f));
    }
    return e;
}
Пример #3
0
static ksp_tree_t* expr(ksp_parser_t* parser)
{
	ksp_lexer_t* lexer = parser->lexer;
	ksp_tree_t* left = expr1(parser);
	if (left == K_NULL)
		return left;
	ksp_tree_t* right = K_NULL;

	while (K_TRUE) {
		ksp_word_t* w = ksp_word_look(lexer);
		ksp_tag_t tag = w->tag;

		if (tag == TAG_GE || tag == TAG_GT || tag == TAG_EQ
			|| tag == TAG_LE || tag == TAG_LT || tag == TAG_NE) {
			ksp_tree_t* t = tree_new3(parser, EXPR1, w);
			ksp_word_next(lexer);
			right = expr1(parser);
			tree_set_left(t, left);
			tree_set_right(t, right);
			left = t;
		}
		else {
			return left;
		}
	}
}
Пример #4
0
Tree expr(int tok) {
	static char stop[] = { IF, ID, '}', 0 };
	Tree p = expr1(0);

	while (t == ',') {
		Tree q;
		t = gettok();
		q = pointer(expr1(0));
		p = tree(RIGHT, q->type, root(value(p)), q);
	}
	if (tok)	
		test(tok, stop);
	return p;
}
Пример #5
0
void test_expressions()
{
	RPN::Context cxt;
	cxt.insert("a", new RPN::ArgumentNode(1, 3));
	cxt.insert("b", new RPN::ArgumentNode(2, 3));
	cxt.insert("c", new RPN::ArgumentNode(3, 3));
	
	RPN::Expression fixed("13 + sin(0)", cxt);
	insist_equal(fixed.evaluate(), 13.0);
	
	RPN::Expression functor("a + b * c", cxt, 3);
	insist_equal(functor.evaluate(1, 2, 3), 7.0);
	
	cxt.insert("e", new RPN::ExpressionNode(&fixed));
	cxt.insert("f", new RPN::ExpressionNode(&functor));
	
	const RPN::Node* node = cxt.lookup("e");
	insist_equal(node->isValue(), 1);
	insist_zero(node->arguments());
	
	node = cxt.lookup("f");
	insist_equal(node->isFunction(), 1);
	insist_equal(node->arguments(), 3);
	
	RPN::Expression expr1("2 * e + 5", cxt);
	insist_equal(expr1.evaluate(), 31.0);
	
	RPN::Expression expr2("f(1, 2, 3)", cxt);
	insist_equal(expr2.evaluate(), 7.0);
	
	RPN::Expression expr3("2 * f(3, e, 2) + 5", cxt);
	insist_equal(expr3.evaluate(), 63.0);
}
void test_expression_comparison::test_fraction_to_a_power()
{
  std::string expr1("(A/B+C/D)^E");
  std::string expr2("(C/D+A/B)^E");
  bool result = are_expressions_equal(expr1, expr2, "are_expressions_equal.xhtml", false);
  CPPUNIT_ASSERT(result == true);
}
Пример #7
0
Tree expr1(int tok) {
	static char stop[] = {IF, ID, 0};
	Tree p = expr2();

	if (t == '=' || (prec[t] >= 6 && prec[t] <= 8) || (prec[t] >= 11 && prec[t] <= 13)) {
		int op = t;
		t = gettok();

		if (oper[op] == ASGN)
			p = asgntree(ASGN, p, value(expr1(0)));
		else {
				expect('=');
				p = incr(op, p, expr1(0));
			}
	}

	if (tok)	
		test(tok, stop);
	return p;
}
Пример #8
0
int expr(big_int *a)
{
    big_int *b = NULL;
    int result = 0;

    b = big_int_create(1);
    if (b == NULL) {
        printf("error when creating [b]\n");
        result = 1;
        goto done;
    }

    if (expr1(a)) {
        result = 2;
        goto done;
    }

    while (1) {
        switch ((int) curr_lex.token) {
            case OR1 : case '|' :
                match(curr_lex.token);
                if (expr1(b)) {
                    result = 3;
                    goto done;
                }
                if (big_int_or(a, b, 0, a)) {
                    printf("error in big_int_or()\n");
                    result = 4;
                    goto done;
                }
                continue;
            default :
                goto done;
        }
    }

done:
    big_int_destroy(b);
    return result;
}
Пример #9
0
static bool expr3 (int * pn)
{
    if (* cur == '-' && (cur == text_start || strchr ("+-*/(", cur [-1])))
    {
        cur ++;

        if (! expr3 (pn))
            return false;

        * pn = - *pn;
    }
    else if (* cur == '(')
    {
        cur ++;

        if (! expr1 (pn))
            return false;

        if (* cur != ')')
            return false;

        cur ++;
    }
    else if (isdigit (* cur))
    {
        int n = 0;

        do
        {
            int d  = * cur - '0';
            int nn = n * 10 + d;

            // checking overflow

            if ((nn - d) / 10 != n)
                return false;

            n = nn;
        }
        while (isdigit (* ++ cur));

        * pn = n;
    }
    else
    {
        return false;
    }

    return true;
}
Пример #10
0
void CCFCreater::CreateMutantsRun(std::vector<std::string> &expressions)
{
    int varnumber=m_varlist.size();
    int literalnum=m_literal_var_map.size();

    //for each literal x
    for(int i=0;i<literalnum;i++)
    {
        //for each variable y
        for(int k=0;k<varnumber;k++)
        {
            std::string expr1(m_expression);
            std::string expr2(m_expression);

            //replace x by (x+y) and (x+!y)
            if(m_literal_var_map[i].first==0 || m_expression[m_literal_var_map[i].first-1]!='!')
            {
                expr1.insert(expr1.begin()+m_literal_var_map[i].first,'(');
                expr1.insert(m_literal_var_map[i].first+m_varlength[m_literal_var_map[i].second]+1,
                    std::string("*)"));
                expr1.insert(m_literal_var_map[i].first+m_varlength[m_literal_var_map[i].second]+2,
                    m_varlist[k]);

                expr2.insert(expr2.begin()+m_literal_var_map[i].first,'(');
                expr2.insert(m_literal_var_map[i].first+m_varlength[m_literal_var_map[i].second]+1,
                    std::string("*!)"));
                expr2.insert(m_literal_var_map[i].first+m_varlength[m_literal_var_map[i].second]+3,
                    m_varlist[k]);
            }
            //replace !x by (!x+y) and (!x+!y)
            else//if(m_varappear[i][j]-1>=0 && m_expression[m_varappear[i][j]-1]=='!')
            {
                expr1.insert(expr1.begin()+m_literal_var_map[i].first-1,'(');
                expr1.insert(m_literal_var_map[i].first+m_varlength[m_literal_var_map[i].second]+1,
                    std::string("*)"));
                expr1.insert(m_literal_var_map[i].first+m_varlength[m_literal_var_map[i].second]+2,
                    m_varlist[k]);

                expr2.insert(expr2.begin()+m_literal_var_map[i].first-1,'(');
                expr2.insert(m_literal_var_map[i].first+m_varlength[m_literal_var_map[i].second]+1,
                    std::string("*!)"));
                expr2.insert(m_literal_var_map[i].first+m_varlength[m_literal_var_map[i].second]+3,
                    m_varlist[k]);
            }

            expressions.push_back(expr1);
            expressions.push_back(expr2);
        }
    }
}
Пример #11
0
Object* Parser::parseSubExpression3()
{
	std::auto_ptr<Object> expr1(parseSubExpression2());

	while(hasTokens() && peekToken().getType() == T_EXPONENT)
	{
		Token tok = getToken();
		std::auto_ptr<Object> expr2(parseSubExpression2());
		expr1.reset(new Exponent(expr1.release(), expr2.release()));
		expr1->setLineNumber(tok.getLineNumber());
		expr1->setColumnNumber(tok.getColumnNumber());
	}

	return expr1.release();
}
Пример #12
0
Object* Parser::parseSubExpression7()
{
	std::auto_ptr<Object> expr1(parseSubExpression6());

	while(hasTokens() && (peekToken().getType() == T_SLASHEQ || peekToken().getType() == T_EQUAL))
	{
		Token tok = getToken();
		std::auto_ptr<Object> expr2(parseSubExpression6());
		if(tok.getType() == T_SLASHEQ)
			expr1.reset(new Unequal(expr1.release(), expr2.release()));
		else
			expr1.reset(new Equal(expr1.release(), expr2.release()));
		expr1->setLineNumber(tok.getLineNumber());
		expr1->setColumnNumber(tok.getColumnNumber());
	}

	return expr1.release();
}
Пример #13
0
Object* Parser::parseSubExpression5()
{
	std::auto_ptr<Object> expr1(parseSubExpression4());

	while(hasTokens() && (peekToken().getType() == T_PLUS || peekToken().getType() == T_MINUS))
	{
		Token tok = getToken();
		unsigned char operation = tok.getType();
		std::auto_ptr<Object> expr2(parseSubExpression4());
		if(operation == T_PLUS)
			expr1.reset(new Add(expr1.release(), expr2.release()));
		else
			expr1.reset(new Subtract(expr1.release(), expr2.release()));
		expr1->setLineNumber(tok.getLineNumber());
		expr1->setColumnNumber(tok.getColumnNumber());
	}

	return expr1.release();
}
Пример #14
0
Object* Parser::parseSubExpression6()
{
	std::auto_ptr<Object> expr1(parseSubExpression5());

	while(hasTokens() && (peekToken().getType() == T_LESS || peekToken().getType() == T_GREAT || peekToken().getType() == T_LESSEQ || peekToken().getType() == T_GREATEQ))
	{
		Token tok = getToken();
		unsigned char operation = tok.getType();
		std::auto_ptr<Object> expr2(parseSubExpression5());
		if(operation == T_LESS)
			expr1.reset(new Less(expr1.release(), expr2.release()));
		else if(operation == T_GREAT)
			expr1.reset(new Greater(expr1.release(), expr2.release()));
		else if(operation == T_LESSEQ)
			expr1.reset(new LessEq(expr1.release(), expr2.release()));
		else
			expr1.reset(new GreatEq(expr1.release(), expr2.release()));
		expr1->setLineNumber(tok.getLineNumber());
		expr1->setColumnNumber(tok.getColumnNumber());
	}

	return expr1.release();
}
Пример #15
0
Object* Parser::parseSubExpression4()
{
	std::auto_ptr<Object> expr1(parseSubExpression3());

	while(hasTokens() && (peekToken().getType() == T_MULTIPLY || peekToken().getType() == T_DIVIDE || peekToken().getType() == T_INTDIVIDE || peekToken().getType() == T_REMAINDER))
	{
		Token tok = getToken();
		unsigned char operation = tok.getType();
		std::auto_ptr<Object> expr2(parseSubExpression3());
		if(operation == T_MULTIPLY)
			expr1.reset(new Multiply(expr1.release(), expr2.release()));
		else if(operation == T_DIVIDE)
			expr1.reset(new Divide(expr1.release(), expr2.release()));
		else if(operation == T_INTDIVIDE)
			expr1.reset(new IntDivide(expr1.release(), expr2.release()));
		else
			expr1.reset(new Remainder(expr1.release(), expr2.release()));
		expr1->setLineNumber(tok.getLineNumber());
		expr1->setColumnNumber(tok.getColumnNumber());
	}

	return expr1.release();
}
Пример #16
0
static bool expr1 (int * pn)
{
    int op, n1, n2, n;

    if (! expr2 (& n1))
        return false;

    op = * cur;

    if (op != '+' && op != '-')
    {
        * pn = n1;
        return true;
    }

    cur ++;

    if (! expr1 (& n2))
        return false;

    if (op == '-')
        n2 = - n2;

    n = n1 + n2;

    // checking overflow

    if (    n1 > 0 && n2 > 0 && n < 0
         || n1 < 0 && n2 < 0 && n > 0)
    {
        return false;
    }

    * pn = n;
    return true;
}
Пример #17
0
/**************************************************程序入口****************************************************/
int main()
{
	clock_t start,finish;
	double totaltime;
	start=clock();
	time_t nowTime=time(0);
	struct tm* nowTimeStruct=localtime(&nowTime);//打印系统时间
	// output<<"系统当前时间:"<<1900+nowTimeStruct->tm_year<<"."<<nowTimeStruct->tm_mon+1<<"."<<
		// nowTimeStruct->tm_mday<<"  "<<nowTimeStruct->tm_hour<<":"<<nowTimeStruct->tm_min<<":"<<nowTimeStruct->tm_sec<<endl;
	
	try
	{
		// output<<">>>>>>>>>>>>>>>>>>>>>>>>>数据区<<<<<<<<<<<<<<<<<<<<"<<endl;
		define_data(env);//首先初始化全局变量
		// output<<">>>>>>>>>>>>>>>>>>>>>>>>>/数据区<<<<<<<<<<<<<<<<<<<"<<endl<<endl;
		
		IloInvert(env,B0,B0l,Node-1);//求逆矩阵
		
		//在此创建两种形式的目标函数
		IloNumExpr Cost(env);//目标函数			
		for(IloInt w=0;w<NW;++w)
		{
			Cost+=detaPw[w];
		}
		IloObjective min(env,Cost,IloObjective::Sense::Minimize,"min");
		IloObjective max(env,Cost,IloObjective::Sense::Maximize,"max");	
		Master_Model.add(min);
		// Master_Model.add(IloMaximize(env,Cost));//目标函数二选一
		Cost.end();

		IloNumExpr expr1(env),expr2(env);//功率平衡约束
		for(IloInt i=0;i<NG;++i)
		{
			expr1+=detaP[i];
		}
		for(IloInt w=0;w<NW;++w)
		{
			expr2+=detaPw[w];
		}
		Master_Model.add(expr1+expr2==0);
		expr1.end();
		expr2.end();
		
		for(IloInt i=0;i<NG;++i)//机组可调节范围
		{
			Master_Model.add(detaP[i]>=Unit[i][1]*u[i]-P1[i]);
			Master_Model.add(detaP[i]<=Unit[i][2]*u[i]-P1[i]);
			
			Master_Model.add(detaP[i]>=-detaa[i]);
			Master_Model.add(detaP[i]<=detaa[i]);
		}
		
		IloNumExprArray detaP_node(env,Node-1),detaPw_node(env,Node-1);//安全约束,实际上安全约束影响不大
		IloNumExprArray Theta(env,Node);
		
		for(IloInt b=0;b<Node-1;++b)
		{
			detaP_node[b]=IloNumExpr(env);
			detaPw_node[b]=IloNumExpr(env);
			IloInt i=0;
			for(;i<NG;++i)
			{
				if(Unit[i][0]==b-1)break;
			}
			
			if(i<NG)
			{
				detaP_node[b]+=detaP[i];
			}	
			
			if(Sw[b]>=0)
			{
				detaPw_node[b]+=detaPw[ Sw[b] ];
			}
		}
		
		for(IloInt b=0;b<Node-1;++b)
		{
			Theta[b]=IloNumExpr(env);
			for(IloInt k=0;k<Node-1;++k)
			{			
				Theta[b]+=B0l[b][k]*(detaP_node[k]+detaPw_node[k]);	
			}
		}
		Theta[Node-1]=IloNumExpr(env);
		
		for(IloInt h=0;h<Branch;++h)
		{
			IloNumExpr exprTheta(env);//莫明其妙的错误
			exprTheta+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1]);
			
			Master_Model.add(exprTheta<=Info_Branch[h][3]*(Info_Branch[h][4]-PL[h]));			
			Master_Model.add(exprTheta>=Info_Branch[h][3]*(-Info_Branch[h][4]-PL[h]));
			exprTheta.end();
			//两个相减的节点顺序没有影响么?
		}
		Theta.end();
		detaP_node.end();
		detaPw_node.end();
		
		Master_Cplex.extract(Master_Model);
		Master_Cplex.solve();
		if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
		{
			output<<"Master Problem Have No Solution"<<endl;
			goto lable2;
		}
		
/************************************************************输出显示过程**************************************************/
		
		// output/*<<endl<<"Min:"*/<<Master_Cplex.getObjValue()<<endl;
		
		Master_Model.remove(min);
		Master_Model.add(max);
		Master_Cplex.extract(Master_Model);
		Master_Cplex.solve();
		if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
		{
			output<<"Master Problem Have No Solution"<<endl;
			goto lable2;
		}
		output/*<<endl<<"Max:"*/<<Master_Cplex.getObjValue()<<endl<<endl;;
		
		// output<<endl<<"常规机组出力调整量:"<<endl;
		// for(IloInt i=0;i<NG;++i)
		// {
			// output<<Master_Cplex.getValue(detaP[i])<<"  ";
		// }
		// output<<endl<<"风电机组出力调整量:"<<endl;
		// for(IloInt i=0;i<NW;++i)
		// {
			// output<<Master_Cplex.getValue(detaPw[i])<<"  ";
		// }
		// output<<endl;
		
		lable2:
		Master_Model.end();
		Master_Cplex.end();
		env.end();
	}
	catch(IloException& ex)//异常捕获
	{
		output<<"Error: "<<ex<<endl;
	}
	catch(...)
	{
		output<<"Error: Unknown exception caught!" << endl;
	}
	
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	output<<"totaltime: "<<totaltime<<"s"<<endl<<endl;
	output.close();	
	return 0;
}
Пример #18
0
Tree call(Tree f, Type fty, Coordinate src) {
	int n = 0;
	Tree args = NULL, r = NULL, e;
	Type *proto, rty = unqual(freturn(fty));
	Symbol t3 = NULL;

	if (fty->u.f.oldstyle)
		proto = NULL;
	else
		proto = fty->u.f.proto;
	if (hascall(f))
		r = f;
	if (isstruct(rty))
		{
			t3 = temporary(AUTO, unqual(rty));
			if (rty->size == 0)
				error("illegal use of incomplete type `%t'\n", rty);
		}
	if (t != ')')
		for (;;) {
			Tree q = pointer(expr1(0));
			if (proto && *proto && *proto != voidtype)
				{
					Type aty;
					q = value(q);
					aty = assign(*proto, q);
					if (aty)
						q = cast(q, aty);
					else
						error("type error in argument %d to %s; found `%t' expected `%t'\n", n + 1, funcname(f),

							q->type, *proto);
					if ((isint(q->type) || isenum(q->type))
					&& q->type->size != inttype->size)
						q = cast(q, promote(q->type));
					++proto;
				}
			else
				{
					if (!fty->u.f.oldstyle && *proto == NULL)
						error("too many arguments to %s\n", funcname(f));
					q = value(q);
					if (isarray(q->type) || q->type->size == 0)
						error("type error in argument %d to %s; `%t' is illegal\n", n + 1, funcname(f), q->type);

					else
						q = cast(q, promote(q->type));
				}
			if (!IR->wants_argb && isstruct(q->type))
				if (iscallb(q))
					q = addrof(q);
				else {
					Symbol t1 = temporary(AUTO, unqual(q->type));
					q = asgn(t1, q);
					q = tree(RIGHT, ptr(t1->type),
						root(q), lvalue(idtree(t1)));
				}
			if (q->type->size == 0)
				q->type = inttype;
			if (hascall(q))
				r = r ? tree(RIGHT, voidtype, r, q) : q;
			args = tree(mkop(ARG, q->type), q->type, q, args);
			n++;
			if (Aflag >= 2 && n == 32)
				warning("more than 31 arguments in a call to %s\n",
					funcname(f));
			if (t != ',')
				break;
			t = gettok();
		}
	expect(')');
	if (proto && *proto && *proto != voidtype)
		error("insufficient number of arguments to %s\n",
			funcname(f));
	if (r)
		args = tree(RIGHT, voidtype, r, args);
	e = calltree(f, rty, args, t3);
	if (events.calls)
		apply(events.calls, &src, &e);
	return e;
}
Пример #19
0
Файл: simp.c Проект: DevenLu/lcc

}
/* sub[id] - return 1 if min <= x-y <= max, 0 otherwise */
static int subi(long x, long y, long min, long max, int needconst) {
	return addi(x, -y, min, max, needconst);
}

static int subd(double x, double y, double min, double max, int needconst) {
	return addd(x, -y, min, max, needconst);
}
Tree constexpr(int tok) {
	Tree p;

	needconst++;
	p = expr1(tok);
	needconst--;
	return p;
}

int intexpr(int tok, int n) {
	Tree p = constexpr(tok);

	needconst++;
	if (p->op == CNST+I || p->op == CNST+U)
		n = cast(p, inttype)->u.v.i;
	else
		error("integer expression must be constant\n");
	needconst--;
	return n;
}
Пример #20
0
/**************************************************程序入口****************************************************/
int main()
{
	clock_t start,finish;
	double totaltime;
	start=clock();
	
	try
	{
		define_data(env);//首先初始化全局变量		
		IloInvert(env,B0,B0l,Node-1);//求逆矩阵
/*************************************************************主问题目标函数*******************************************************/
		IloNumExpr Cost(env);
		for(IloInt w=0;w<NW;++w)
		{
			Cost+=detaPw[w];
		}		
		 Master_Model.add(IloMinimize(env,Cost));
		//Master_Model.add(IloMaximize(env,Cost));//目标函数二先一
		Cost.end();
/********************************************************机组出力上下限约束**************************************************/
		IloNumExpr expr1(env),expr2(env);
		for(IloInt i=0;i<NG;++i)
		{
			expr1+=detaP[i];
		}
		for(IloInt w=0;w<NW;++w)
		{
			expr2+=detaPw[w];
		}
		Master_Model.add(expr1==expr2);
		expr1.end();
		expr2.end();
		
		for(IloInt i=0;i<NG;++i)
		{
			Master_Model.add(detaP[i]>=Unit[i][1]*u[i]-P1[i]);
			Master_Model.add(detaP[i]<=Unit[i][2]*u[i]-P1[i]);
			
			Master_Model.add(detaP[i]>=-detaa[i]);
			Master_Model.add(detaP[i]<=detaa[i]);
		}
		
		IloNumExprArray detaP_node(env,Node-1),detaPw_node(env,Node-1);
		IloNumExprArray Theta(env,Node);
		
		for(IloInt b=0;b<Node-1;++b)
		{
			detaP_node[b]=IloNumExpr(env);
			detaPw_node[b]=IloNumExpr(env);
			IloInt i=0;
			for(;i<NG;++i)
			{
				if(Unit[i][0]==b-1)break;
			}
			if(i<NG)
			{
				detaP_node[b]+=detaP[i];
			}
			else
			{
				detaP_node[b]+=0;
			}
			
			
			if(Sw[b]>=0)
			{
				detaPw_node[b]+=detaPw[ Sw[b] ];
			}
			else
			{
				detaPw_node[b]+=0;
			}
		}
		
		for(IloInt b=0;b<Node-1;++b)
		{
			Theta[b]=IloNumExpr(env);
			for(IloInt k=0;k<Node-1;++k)
			{			
				Theta[b]+=B0l[b][k]*(detaP_node[k]+detaPw_node[k]);	
			}
		}
		Theta[Node-1]=IloNumExpr(env);
		
		for(IloInt h=0;h<Branch;++h)
		{
			IloNumExpr exprTheta(env);//莫明其妙的错误
			exprTheta+=(Theta[(IloInt)Info_Branch[h][0]-1]-Theta[(IloInt)Info_Branch[h][1]-1]);
			
			Master_Model.add(exprTheta<=Info_Branch[h][3]*(Info_Branch[h][4]-PL[h]));			
			Master_Model.add(exprTheta>=Info_Branch[h][3]*(-Info_Branch[h][4]-PL[h]));
			exprTheta.end();
			//两个相减的节点顺序没有影响么?
		}
		Theta.end();
		detaP_node.end();
		detaPw_node.end();
		
		Master_Cplex.extract(Master_Model);
		Master_Cplex.solve();
		if (Master_Cplex.getStatus() == IloAlgorithm::Infeasible)//输出结果
		{
			output<<"Master Problem Have No Solution"<<endl;
			goto lable2;
		}
		
/************************************************************输出显示过程**************************************************/
		output<<endl<<"Min/Max:"<<Master_Cplex.getObjValue()<<endl;
		
		lable2:		
		Master_Model.end();
		Master_Cplex.end();
		env.end();
	}
	catch(IloException& ex)//异常捕获
	{
		output<<"Error: "<<ex<<endl;
	}
	catch(...)
	{
		output<<"Error: Unknown exception caught!" << endl;
	}
	
	finish=clock();
	totaltime=(double)(finish-start)/CLOCKS_PER_SEC;
	output<<"totaltime: "<<totaltime<<"s"<<endl<<endl;
	output.close();	
	return 0;
}
Пример #21
0
typename Evaluator<iDim, Iterator, Pset, ExprT>::eval_element_type
Evaluator<iDim, Iterator, Pset, ExprT>::operator()( mpl::size_t<MESH_FACES> ) const
{

    boost::timer __timer;

    VLOG(2) << "evaluator(MESH_FACES) " << "\n";
    //
    // a few typedefs
    //

    // mesh element
    typedef typename mesh_element_type::entity_type geoelement_type;
    //typedef typename geoelement_type::face_type face_type;
    typedef mesh_element_type face_type;

    // geometric mapping context
    typedef typename geoelement_type::gm_type gm_type;
    typedef boost::shared_ptr<gm_type> gm_ptrtype;
    typedef typename geoelement_type::gm1_type gm1_type;
    typedef boost::shared_ptr<gm1_type> gm1_ptrtype;

    typedef typename gm_type::template Context<context, geoelement_type> gmc_type;
    typedef boost::shared_ptr<gmc_type> gmc_ptrtype;
    typedef fusion::map<fusion::pair<vf::detail::gmc<0>, gmc_ptrtype> > map_gmc_type;
    typedef typename gm1_type::template Context<context, geoelement_type> gmc1_type;
    typedef boost::shared_ptr<gmc1_type> gmc1_ptrtype;
    typedef fusion::map<fusion::pair<vf::detail::gmc<0>, gmc1_ptrtype> > map_gmc1_type;

    // expression
    //typedef typename expression_type::template tensor<map_gmc_type,fecontext_type> t_expr_type;
    //typedef decltype( basis_type::isomorphism( M_expr ) ) the_expression_type;
    typedef expression_type the_expression_type;
    typedef typename boost::remove_reference<typename boost::remove_const<the_expression_type>::type >::type iso_expression_type;
    typedef typename iso_expression_type::template tensor<map_gmc_type> t_expr_type;
    typedef typename iso_expression_type::template tensor<map_gmc1_type> t_expr1_type;
    typedef typename t_expr_type::shape shape;

    //
    // start
    //

    iterator_type __face_it, __face_en;
    boost::tie( boost::tuples::ignore, __face_it, __face_en ) = M_range;

    int npoints = M_pset.fpoints(0,1).size2();
    element_type __v( M_pset.fpoints(0,1).size2()*std::distance( __face_it, __face_en )*shape::M );
    node_type __p( mesh_element_type::nRealDim, M_pset.fpoints(0,1).size2()*std::distance( __face_it, __face_en ) );
    __v.setZero();
    __p.setZero();
    VLOG(2) << "pset: " << M_pset.fpoints(0,1);
    VLOG(2) << "Checking trivial result...";

    if ( __face_it == __face_en )
        return boost::make_tuple( __v, __p );

    gm_ptrtype __gm( new gm_type );
    gm1_ptrtype __gm1( new gm1_type );



    //
    // Precompute some data in the reference element for
    // geometric mapping and reference finite element
    //
    typedef typename geoelement_type::permutation_type permutation_type;
    typedef typename gm_type::precompute_ptrtype geopc_ptrtype;
    typedef typename gm_type::precompute_type geopc_type;
    typedef typename gm1_type::precompute_ptrtype geopc1_ptrtype;
    typedef typename gm1_type::precompute_type geopc1_type;

    std::vector<std::map<permutation_type, geopc_ptrtype> > __geopc( M_pset.nFaces() );
    std::vector<std::map<permutation_type, geopc1_ptrtype> > __geopc1( M_pset.nFaces() );

    VLOG(2) << "computing geopc...";
    for ( uint16_type __f = 0; __f < M_pset.nFaces(); ++__f )
    {
        for ( permutation_type __p( permutation_type::IDENTITY );
                __p < permutation_type( permutation_type::N_PERMUTATIONS ); ++__p )
        {
            __geopc[__f][__p] = geopc_ptrtype(  new geopc_type( __gm, M_pset.fpoints(__f, __p.value() ) ) );
            __geopc1[__f][__p] = geopc1_ptrtype(  new geopc1_type( __gm1, M_pset.fpoints(__f, __p.value() ) ) );
            DVLOG(2) << "pset " << __f << " : " << M_pset.fpoints(__f, __p.value() );
            CHECK( __geopc[__f][__p]->nPoints()  ) << "invalid number of points for geopc";
            CHECK( __geopc1[__f][__p]->nPoints() ) << "invalid number of points for geopc1";
        }
    }

    uint16_type __face_id = __face_it->pos_first();
    gmc_ptrtype __c( new gmc_type( __gm, __face_it->element( 0 ), __geopc, __face_id ) );
    gmc1_ptrtype __c1( new gmc1_type( __gm1, __face_it->element( 0 ), __geopc1, __face_id ) );

    map_gmc_type mapgmc( fusion::make_pair<vf::detail::gmc<0> >( __c ) );
    t_expr_type expr( M_expr, mapgmc );
    map_gmc1_type mapgmc1( fusion::make_pair<vf::detail::gmc<0> >( __c1 ) );
    t_expr1_type expr1( M_expr, mapgmc1 );




    size_type nbFaceDof = invalid_size_type_value;

    for ( int e = 0; __face_it != __face_en; ++__face_it, ++e )
    {
        FEELPP_ASSERT( __face_it->isOnBoundary() && !__face_it->isConnectedTo1() )
        ( __face_it->marker() )
        ( __face_it->isOnBoundary() )
        ( __face_it->ad_first() )
        ( __face_it->pos_first() )
        ( __face_it->ad_second() )
        ( __face_it->pos_second() )
        ( __face_it->id() ).warn( "inconsistent data face" );
        DVLOG(2) << "[evaluator] FACE_ID = " << __face_it->id()
                      << " element id= " << __face_it->ad_first()
                      << " pos in elt= " << __face_it->pos_first()
                      << " marker: " << __face_it->marker() << "\n";
        DVLOG(2) << "[evaluator] FACE_ID = " << __face_it->id() << " real pts=" << __face_it->G() << "\n";

        uint16_type __face_id = __face_it->pos_first();


        switch ( M_geomap_strategy )
        {
        default:
        case GeomapStrategyType::GEOMAP_OPT:
        case GeomapStrategyType::GEOMAP_HO:
        {
            __c->update( __face_it->element( 0 ), __face_id );
            DVLOG(2) << "[evaluator::GEOMAP_HO|GEOMAP_OPT] FACE_ID = " << __face_it->id() << "  ref pts=" << __c->xRefs() << "\n";
            DVLOG(2) << "[evaluator::GEOMAP_HO|GEOMAP_OPT] FACE_ID = " << __face_it->id() << " real pts=" << __c->xReal() << "\n";

            map_gmc_type mapgmc( fusion::make_pair<vf::detail::gmc<0> >( __c ) );

            expr.update( mapgmc );

            for ( uint16_type p = 0; p < npoints; ++p )
            {
                for ( uint16_type c1 = 0; c1 < mesh_element_type::nRealDim; ++c1 )
                {
                    __p(c1, e*npoints+p) = __c->xReal(p)[c1];
                }

                for ( uint16_type c1 = 0; c1 < shape::M; ++c1 )
                {
                    __v( e*npoints*shape::M+shape::M*p+c1) = expr.evalq( c1, 0, p );
                }
            }
        }
        break;

        case GeomapStrategyType::GEOMAP_O1:
        {
            __c1->update( __face_it->element( 0 ), __face_id );
            DVLOG(2) << "[evaluator::GEOMAP_O1] FACE_ID = " << __face_it->id() << "  ref pts=" << __c1->xRefs() << "\n";
            DVLOG(2) << "[evaluator::GEOMAP_O1] FACE_ID = " << __face_it->id() << " real pts=" << __c1->xReal() << "\n";

            map_gmc1_type mapgmc1( fusion::make_pair<vf::detail::gmc<0> >( __c1 ) );

            expr1.update( mapgmc1 );

            for ( uint16_type p = 0; p < npoints; ++p )
            {
                for ( uint16_type c1 = 0; c1 < mesh_element_type::nRealDim; ++c1 )
                {
                    __p(c1, e*npoints+p) = __c1->xReal(p)[c1];
                }

                for ( uint16_type c1 = 0; c1 < shape::M; ++c1 )
                {
                    __v( e*npoints*shape::M+shape::M*p+c1) = expr1.evalq( c1, 0, p );
                }

            }
        }
        break;
        }

    } // face_it


    return boost::make_tuple( __v, __p );
}
Пример #22
0
void CheckCondition::checkIncorrectLogicOperator()
{
    const bool printStyle = _settings->isEnabled("style");
    const bool printWarning = _settings->isEnabled("warning");
    if (!printWarning && !printStyle)
        return;

    const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
    const std::size_t functions = symbolDatabase->functionScopes.size();
    for (std::size_t ii = 0; ii < functions; ++ii) {
        const Scope * scope = symbolDatabase->functionScopes[ii];

        for (const Token* tok = scope->classStart->next(); tok != scope->classEnd; tok = tok->next()) {
            if (!Token::Match(tok, "%oror%|&&") || !tok->astOperand1() || !tok->astOperand2())
                continue;

            // Opposite comparisons around || or && => always true or always false
            if ((tok->astOperand1()->isName() || tok->astOperand2()->isName()) &&
                isOppositeCond(true, _tokenizer->isCPP(), tok->astOperand1(), tok->astOperand2(), _settings->library.functionpure)) {

                const bool alwaysTrue(tok->str() == "||");
                incorrectLogicOperatorError(tok, tok->expressionString(), alwaysTrue, false);
                continue;
            }


            // 'A && (!A || B)' is equivalent with 'A && B'
            // 'A || (!A && B)' is equivalent with 'A || B'
            if (printStyle &&
                ((tok->str() == "||" && tok->astOperand2()->str() == "&&") ||
                 (tok->str() == "&&" && tok->astOperand2()->str() == "||"))) {
                const Token* tok2 = tok->astOperand2()->astOperand1();
                if (isOppositeCond(true, _tokenizer->isCPP(), tok->astOperand1(), tok2, _settings->library.functionpure)) {
                    std::string expr1(tok->astOperand1()->expressionString());
                    std::string expr2(tok->astOperand2()->astOperand1()->expressionString());
                    std::string expr3(tok->astOperand2()->astOperand2()->expressionString());

                    if (expr1.length() + expr2.length() + expr3.length() > 50U) {
                        if (expr1[0] == '!' && expr2[0] != '!') {
                            expr1 = "!A";
                            expr2 = "A";
                        } else {
                            expr1 = "A";
                            expr2 = "!A";
                        }

                        expr3 = "B";
                    }

                    const std::string cond1 = expr1 + " " + tok->str() + " (" + expr2 + " " + tok->astOperand2()->str() + " " + expr3 + ")";
                    const std::string cond2 = expr1 + " " + tok->str() + " " + expr3;

                    redundantConditionError(tok, tok2->expressionString() + ". '" + cond1 + "' is equivalent to '" + cond2 + "'", false);
                    continue;
                }
            }

            // Comparison #1 (LHS)
            const Token *comp1 = tok->astOperand1();
            if (comp1 && comp1->str() == tok->str())
                comp1 = comp1->astOperand2();

            // Comparison #2 (RHS)
            const Token *comp2 = tok->astOperand2();

            bool inconclusive = false;

            // Parse LHS
            bool not1;
            std::string op1, value1;
            const Token *expr1;
            if (!parseComparison(comp1, &not1, &op1, &value1, &expr1, &inconclusive))
                continue;

            // Parse RHS
            bool not2;
            std::string op2, value2;
            const Token *expr2;
            if (!parseComparison(comp2, &not2, &op2, &value2, &expr2, &inconclusive))
                continue;

            if (inconclusive && !_settings->inconclusive)
                continue;

            if (isSameExpression(_tokenizer->isCPP(), true, comp1, comp2, _settings->library.functionpure))
                continue; // same expressions => only report that there are same expressions
            if (!isSameExpression(_tokenizer->isCPP(), true, expr1, expr2, _settings->library.functionpure))
                continue;

            const bool isfloat = astIsFloat(expr1, true) || MathLib::isFloat(value1) || astIsFloat(expr2, true) || MathLib::isFloat(value2);

            // don't check floating point equality comparisons. that is bad
            // and deserves different warnings.
            if (isfloat && (op1 == "==" || op1 == "!=" || op2 == "==" || op2 == "!="))
                continue;

            const double d1 = (isfloat) ? MathLib::toDoubleNumber(value1) : 0;
            const double d2 = (isfloat) ? MathLib::toDoubleNumber(value2) : 0;
            const MathLib::bigint i1 = (isfloat) ? 0 : MathLib::toLongNumber(value1);
            const MathLib::bigint i2 = (isfloat) ? 0 : MathLib::toLongNumber(value2);
            const bool useUnsignedInt = (std::numeric_limits<MathLib::bigint>::max()==i1)||(std::numeric_limits<MathLib::bigint>::max()==i2);
            const MathLib::biguint u1 = (useUnsignedInt) ? MathLib::toLongNumber(value1) : 0;
            const MathLib::biguint u2 = (useUnsignedInt) ? MathLib::toLongNumber(value2) : 0;
            // evaluate if expression is always true/false
            bool alwaysTrue = true, alwaysFalse = true;
            bool firstTrue = true, secondTrue = true;
            for (int test = 1; test <= 5; ++test) {
                // test:
                // 1 => testvalue is less than both value1 and value2
                // 2 => testvalue is value1
                // 3 => testvalue is between value1 and value2
                // 4 => testvalue value2
                // 5 => testvalue is larger than both value1 and value2
                bool result1, result2;
                if (isfloat) {
                    const double testvalue = getvalue<double>(test, d1, d2);
                    result1 = checkFloatRelation(op1, testvalue, d1);
                    result2 = checkFloatRelation(op2, testvalue, d2);
                } else if (useUnsignedInt) {
                    const MathLib::biguint testvalue = getvalue<MathLib::biguint>(test, u1, u2);
                    result1 = checkIntRelation(op1, testvalue, u1);
                    result2 = checkIntRelation(op2, testvalue, u2);
                } else {
                    const MathLib::bigint testvalue = getvalue<MathLib::bigint>(test, i1, i2);
                    result1 = checkIntRelation(op1, testvalue, i1);
                    result2 = checkIntRelation(op2, testvalue, i2);
                }
                if (not1)
                    result1 = !result1;
                if (not2)
                    result2 = !result2;
                if (tok->str() == "&&") {
                    alwaysTrue &= (result1 && result2);
                    alwaysFalse &= !(result1 && result2);
                } else {
                    alwaysTrue &= (result1 || result2);
                    alwaysFalse &= !(result1 || result2);
                }
                firstTrue &= !(!result1 && result2);
                secondTrue &= !(result1 && !result2);
            }

            const std::string cond1str = conditionString(not1, expr1, op1, value1);
            const std::string cond2str = conditionString(not2, expr2, op2, value2);
            if (printWarning && (alwaysTrue || alwaysFalse)) {
                const std::string text = cond1str + " " + tok->str() + " " + cond2str;
                incorrectLogicOperatorError(tok, text, alwaysTrue, inconclusive);
            } else if (printStyle && secondTrue) {
                const std::string text = "If '" + cond1str + "', the comparison '" + cond2str +
                                         "' is always " + (secondTrue ? "true" : "false") + ".";
                redundantConditionError(tok, text, inconclusive);
            } else if (printStyle && firstTrue) {
                //const std::string text = "The comparison " + cond1str + " is always " +
                //                         (firstTrue ? "true" : "false") + " when " +
                //                         cond2str + ".";
                const std::string text = "If '" + cond2str + "', the comparison '" + cond1str +
                                         "' is always " + (firstTrue ? "true" : "false") + ".";
                redundantConditionError(tok, text, inconclusive);
            }
        }
    }
}
Пример #23
0
//on the reduced problem
void solveIP(double time_limit, int ite, double gap){
	IloEnv env;
	IloModel model(env);
	IloIntVarArray x(env, n_var, 0, 1);
	IloRangeArray con(env);

	IloExpr obj(env);
	int i,j,k;
	for(i=0;i<n;i++){
		for(j=0;j<group[i].nItem;j++){
			obj+=group[i].profit[j]*x[sum_n_item[i]+j];
		}
	}
	model.add(IloMaximize(env, obj));
	obj.end();
	
	for(k=0;k<m;k++){
		IloExpr expr(env);
		for(i=0;i<n;i++){
			for(j=0;j<group[i].nItem;j++){
				expr+=group[i].consume[j][k]*x[sum_n_item[i]+j];
			}
		}
		con.add(expr<=Gb[k]);
		expr.end();
	}

	for(i=0;i<n;i++){
		IloExpr expr(env);
		for(j=0;j<group[i].nItem;j++){
			expr+=x[sum_n_item[i]+j];
		}
		con.add(expr==1);
		expr.end();
	}

	/*
	int *tempFix=new int[n_var];
	memset(tempFix, 0, n_var*sizeof(int));
	for(i=0;i<rp.len;i++){
		tempFix[rp.posi[i]]=1;
	}
	//force those not appeared in rp to 0
	for(i=0;i<n;i++){
		IloExpr expr(env);
		for(j=0;j<group[i].nItem;j++){
			if(tempFix[sum_n_item[i]+j]==0){
				expr+=x[sum_n_item[i]+j];
			}
		}
		con.add(expr==0);
		expr.end();
	}
	delete []tempFix;
	*/
	//add constrains from the last iteration
	if(ite>0){
		for(k=0;k<ite;k++){
			IloExpr expr(env);
			for(i=0;i<len_v1[k];i++){
				expr+=x[pre_v1[k][i]];
			}
			for(i=0;i<len_v0[k];i++){
				expr-=x[pre_v0[k][i]];
			}
			con.add(expr<=sum_pre_v1[k]-1);
			expr.end();
		}
	}
	if(0&&len_rdCost0>0&&len_rdCost1>0){
		IloExpr expr(env);
		for(i=0;i<len_rdCost1;i++){
			expr+=(1-x[rdCost_sort1[i].posi])*rdCost_sort1[i].value;
		}

		for(i=0;i<len_rdCost0;i++){
			expr+=x[rdCost_sort[i].posi]*rdCost_sort[i].value;
		}
		con.add(expr<=gap);
		expr.end();
	}
	if(len_rdCost0>0){
		printf("0 rdCostSort_len:%d. \n",len_rdCost0);
		k=1;
		int start=0, end;
		int cnt=0;
		//for(i=0;i<len_rdCost0;i++) printf("%lf, ", rdCost_sort[i].value);
		while(start<len_rdCost0){
			double sum=0;
			for(i=start;i<len_rdCost0-k;i++){
				sum=0;
				for(int ii=i;ii<i+k;ii++){
					sum+=rdCost_sort[ii].value;
				}
				if(sum<gap) break;
			}
			if(i>=len_rdCost0-k && sum<gap) break;
			//printf("cut %d, start=%d, end=%d\n",k-1, start, i+k);
			end=i+k;
			IloExpr expr1(env);
			for(i=start;i<end;i++){
				expr1+=x[rdCost_sort[i].posi];
			}
			con.add(expr1<=k-1);
			expr1.end();
			for(i=start;i<end;i++){
				pre_v0[ite][cnt++]=rdCost_sort[i].posi;
			}
			start=end;
			k++;
		}
		len_v0[ite]=cnt;
	}
	if(len_rdCost1>0){
		printf("1 rdCost_sort length:%d. \n",len_rdCost1);
		k=1;
		int start=0, end;
		int cnt=0;
		sum_pre_v1[ite]=0;
		//for(i=0;i<len_rdCost1;i++) printf("%lf, ", rdCost_sort1[i].value);
		while(start<len_rdCost1){
			double sum=0;
			for(i=start;i<len_rdCost1-k;i++){
				sum=0;
				for(int ii=i;ii<i+k;ii++){
					sum+=rdCost_sort1[ii].value;
				}
				if(sum<gap) break;
			}
			if(i>=len_rdCost1-k && sum<gap) break;
			//printf("cut %d, start=%d, end=%d\n",k-1, start, i+k);
			end=i+k;
			IloExpr expr1(env);
			for(i=start;i<end;i++){
				expr1+=x[rdCost_sort1[i].posi];
			}
			int cnt1=(end-start)-(k-1);
			con.add(expr1>=cnt1);
			expr1.end();
			for(i=start;i<end;i++){
				pre_v1[ite][cnt++]=rdCost_sort1[i].posi;
			}
			sum_pre_v1[ite]=sum_pre_v1[ite]+(end-start);
			start=end;
			k++;
		}
		len_v1[ite]=cnt;
	}
	model.add(con);
	IloCplex cplex(model);
	cplex.setParam(IloCplex::TiLim, time_limit);
	cplex.setParam(IloCplex::Threads, 1);
	cplex.setParam(IloCplex::NodeFileInd,2);
	//cplex.setOut(env.getNullStream());
	if(LB>0){
		printf("\t add start point\n");
		IloNumVarArray start_var(env);
		IloNumArray start_val(env);
		int k=0;
		for(i=0;i<n;i++){
			for(j=0;j<group[i].nItem;j++){
				if(bestSolVec[i]==j){
					start_val.add(1);
				} else start_val.add(0);
				start_var.add(x[k]);
				k++;
			}
		}
		cplex.addMIPStart(start_var, start_val);
		start_var.end();
		start_val.end();
	}
	if(!cplex.solve()){
		std::cout<<"not solved IP."<<std::endl;
	} else {
		std::cout<<"solution status "<<cplex.getStatus()<<std::endl;
		std::cout<<"solution value "<<cplex.getObjValue()<<std::endl;
		
		if((double)cplex.getObjValue()>LB){
			LB=(double)cplex.getObjValue();	
			IloNumArray vals(env);
			cplex.getValues(vals, x);
			printf("new best solution vector is: ");
			for(i=0;i<n;i++){
				for(j=0;j<group[i].nItem;j++){
					if(cplex.getValue(x[sum_n_item[i]+j])>1-EPSILON){
					printf("%d ", j);
					bestSolVec[i]=j;
					}
				}
			}
			printf("\n\n");
		}
	}
	env.end();
}
Пример #24
0
inline
void Not::jumping(const std::uint32_t &to, const std::uint32_t &from) {
    expr1()->jumping(from, to);
}
Пример #25
0
inline
std::string Not::to_string() const {
    return oper()->to_string() + " " + expr1()->to_string();
}
Пример #26
0
char * calculator (char in)
{
    static char prev_in = equal;

    switch (in)
    {
    case add       :
    case substract :
    case multiply  :
    case divide    :

        break;

    default:

        if (prev_in == equal)
            cur = text_start;

        break;
    }

    prev_in = in;

    if (in == equal)
    {
        int n;

        cur = text_start;

        if (expr1 (& n) && * cur == '\0')
        {
            int_to_string (n, text_start);
            cur = text_start + strlen (text_start);
        }
        else
        {
            strcpy (text_start, "error @ ");

            int_to_string
            (
                cur - text_start + 1,
                text_start + strlen (text_start)
            );

            cur = text_start;
        }

        return newline_before_text;
    }

    switch (in)
    {
    case add        : in = '+'; break;
    case substract  : in = '-'; break;
    case multiply   : in = '*'; break;
    case divide     : in = '/'; break;

    case parentheses:

        if (cur == text_start || strchr ("+-*/(", cur [-1]))
            in = '(';
        else
            in = ')';

        break;

    default:
        
        in = '0' + in;
        break;
    }

    if (cur == buf + sizeof (buf) - 2)
    {
        strcpy (text_start, "buffer overflow @ ");

        int_to_string
        (
            cur - text_start + 1,
            text_start + strlen (text_start)
        );

        return newline_before_text;
    }

    * cur ++ = in;
    * cur    = '\0';

    return cur == text_start + 1 ? newline_before_text : cur - 1;
}